drivers/net/ethernet/freescale/dpaa2/dpni.c

   1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2 /* Copyright 2013-2016 Freescale Semiconductor Inc.
   3  * Copyright 2016 NXP
   4  * Copyright 2020 NXP
   5  */
   6 #include <linux/kernel.h>
   7 #include <linux/errno.h>
   8 #include <linux/fsl/mc.h>
   9 #include "dpni.h"
  10 #include "dpni-cmd.h"
  11
  12 /**
  13  * dpni_prepare_key_cfg() - function prepare extract parameters
  14  * @cfg: defining a full Key Generation profile (rule)
  15  * @key_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
  16  *
  17  * This function has to be called before the following functions:
  18  *      - dpni_set_rx_tc_dist()
  19  *      - dpni_set_qos_table()
  20  *
  21  * Return:      '0' on Success; Error code otherwise.
  22  */
  23 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg *cfg, u8 *key_cfg_buf)
  24 {
  25         int i, j;
  26         struct dpni_ext_set_rx_tc_dist *dpni_ext;
  27         struct dpni_dist_extract *extr;
  28
  29         if (cfg->num_extracts > DPKG_MAX_NUM_OF_EXTRACTS)
  30                 return -EINVAL;
  31
  32         dpni_ext = (struct dpni_ext_set_rx_tc_dist *)key_cfg_buf;
  33         dpni_ext->num_extracts = cfg->num_extracts;
  34
  35         for (i = 0; i < cfg->num_extracts; i++) {
  36                 extr = &dpni_ext->extracts[i];
  37
  38                 switch (cfg->extracts[i].type) {
  39                 case DPKG_EXTRACT_FROM_HDR:
  40                         extr->prot = cfg->extracts[i].extract.from_hdr.prot;
  41                         dpni_set_field(extr->efh_type, EFH_TYPE,
  42                                        cfg->extracts[i].extract.from_hdr.type);
  43                         extr->size = cfg->extracts[i].extract.from_hdr.size;
  44                         extr->offset = cfg->extracts[i].extract.from_hdr.offset;
  45                         extr->field = cpu_to_le32(
  46                                 cfg->extracts[i].extract.from_hdr.field);
  47                         extr->hdr_index =
  48                                 cfg->extracts[i].extract.from_hdr.hdr_index;
  49                         break;
  50                 case DPKG_EXTRACT_FROM_DATA:
  51                         extr->size = cfg->extracts[i].extract.from_data.size;
  52                         extr->offset =
  53                                 cfg->extracts[i].extract.from_data.offset;
  54                         break;
  55                 case DPKG_EXTRACT_FROM_PARSE:
  56                         extr->size = cfg->extracts[i].extract.from_parse.size;
  57                         extr->offset =
  58                                 cfg->extracts[i].extract.from_parse.offset;
  59                         break;
  60                 default:
  61                         return -EINVAL;
  62                 }
  63
  64                 extr->num_of_byte_masks = cfg->extracts[i].num_of_byte_masks;
  65                 dpni_set_field(extr->extract_type, EXTRACT_TYPE,
  66                                cfg->extracts[i].type);
  67
  68                 for (j = 0; j < DPKG_NUM_OF_MASKS; j++) {
  69                         extr->masks[j].mask = cfg->extracts[i].masks[j].mask;
  70                         extr->masks[j].offset =
  71                                 cfg->extracts[i].masks[j].offset;
  72                 }
  73         }
  74
  75         return 0;
  76 }
  77
  78 /**
  79  * dpni_open() - Open a control session for the specified object
  80  * @mc_io:      Pointer to MC portal's I/O object
  81  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  82  * @dpni_id:    DPNI unique ID
  83  * @token:      Returned token; use in subsequent API calls
  84  *
  85  * This function can be used to open a control session for an
  86  * already created object; an object may have been declared in
  87  * the DPL or by calling the dpni_create() function.
  88  * This function returns a unique authentication token,
  89  * associated with the specific object ID and the specific MC
  90  * portal; this token must be used in all subsequent commands for
  91  * this specific object.
  92  *
  93  * Return:      '0' on Success; Error code otherwise.
  94  */
  95 int dpni_open(struct fsl_mc_io *mc_io,
  96               u32 cmd_flags,
  97               int dpni_id,
  98               u16 *token)
  99 {
 100         struct fsl_mc_command cmd = { 0 };
 101         struct dpni_cmd_open *cmd_params;
 102
 103         int err;
 104
 105         /* prepare command */
 106         cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
 107                                           cmd_flags,
 108                                           0);
 109         cmd_params = (struct dpni_cmd_open *)cmd.params;
 110         cmd_params->dpni_id = cpu_to_le32(dpni_id);
 111
 112         /* send command to mc*/
 113         err = mc_send_command(mc_io, &cmd);
 114         if (err)
 115                 return err;
 116
 117         /* retrieve response parameters */
 118         *token = mc_cmd_hdr_read_token(&cmd);
 119
 120         return 0;
 121 }
 122
 123 /**
 124  * dpni_close() - Close the control session of the object
 125  * @mc_io:      Pointer to MC portal's I/O object
 126  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 127  * @token:      Token of DPNI object
 128  *
 129  * After this function is called, no further operations are
 130  * allowed on the object without opening a new control session.
 131  *
 132  * Return:      '0' on Success; Error code otherwise.
 133  */
 134 int dpni_close(struct fsl_mc_io *mc_io,
 135                u32 cmd_flags,
 136                u16 token)
 137 {
 138         struct fsl_mc_command cmd = { 0 };
 139
 140         /* prepare command */
 141         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
 142                                           cmd_flags,
 143                                           token);
 144
 145         /* send command to mc*/
 146         return mc_send_command(mc_io, &cmd);
 147 }
 148
 149 /**
 150  * dpni_set_pools() - Set buffer pools configuration
 151  * @mc_io:      Pointer to MC portal's I/O object
 152  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 153  * @token:      Token of DPNI object
 154  * @cfg:        Buffer pools configuration
 155  *
 156  * mandatory for DPNI operation
 157  * warning:Allowed only when DPNI is disabled
 158  *
 159  * Return:      '0' on Success; Error code otherwise.
 160  */
 161 int dpni_set_pools(struct fsl_mc_io *mc_io,
 162                    u32 cmd_flags,
 163                    u16 token,
 164                    const struct dpni_pools_cfg *cfg)
 165 {
 166         struct fsl_mc_command cmd = { 0 };
 167         struct dpni_cmd_set_pools *cmd_params;
 168         int i;
 169
 170         /* prepare command */
 171         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
 172                                           cmd_flags,
 173                                           token);
 174         cmd_params = (struct dpni_cmd_set_pools *)cmd.params;
 175         cmd_params->num_dpbp = cfg->num_dpbp;
 176         for (i = 0; i < DPNI_MAX_DPBP; i++) {
 177                 cmd_params->dpbp_id[i] = cpu_to_le32(cfg->pools[i].dpbp_id);
 178                 cmd_params->buffer_size[i] =
 179                         cpu_to_le16(cfg->pools[i].buffer_size);
 180                 cmd_params->backup_pool_mask |=
 181                         DPNI_BACKUP_POOL(cfg->pools[i].backup_pool, i);
 182         }
 183
 184         /* send command to mc*/
 185         return mc_send_command(mc_io, &cmd);
 186 }
 187
 188 /**
 189  * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
 190  * @mc_io:      Pointer to MC portal's I/O object
 191  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 192  * @token:              Token of DPNI object
 193  *
 194  * Return:      '0' on Success; Error code otherwise.
 195  */
 196 int dpni_enable(struct fsl_mc_io *mc_io,
 197                 u32 cmd_flags,
 198                 u16 token)
 199 {
 200         struct fsl_mc_command cmd = { 0 };
 201
 202         /* prepare command */
 203         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
 204                                           cmd_flags,
 205                                           token);
 206
 207         /* send command to mc*/
 208         return mc_send_command(mc_io, &cmd);
 209 }
 210
 211 /**
 212  * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
 213  * @mc_io:      Pointer to MC portal's I/O object
 214  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 215  * @token:      Token of DPNI object
 216  *
 217  * Return:      '0' on Success; Error code otherwise.
 218  */
 219 int dpni_disable(struct fsl_mc_io *mc_io,
 220                  u32 cmd_flags,
 221                  u16 token)
 222 {
 223         struct fsl_mc_command cmd = { 0 };
 224
 225         /* prepare command */
 226         cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
 227                                           cmd_flags,
 228                                           token);
 229
 230         /* send command to mc*/
 231         return mc_send_command(mc_io, &cmd);
 232 }
 233
 234 /**
 235  * dpni_is_enabled() - Check if the DPNI is enabled.
 236  * @mc_io:      Pointer to MC portal's I/O object
 237  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 238  * @token:      Token of DPNI object
 239  * @en:         Returns '1' if object is enabled; '0' otherwise
 240  *
 241  * Return:      '0' on Success; Error code otherwise.
 242  */
 243 int dpni_is_enabled(struct fsl_mc_io *mc_io,
 244                     u32 cmd_flags,
 245                     u16 token,
 246                     int *en)
 247 {
 248         struct fsl_mc_command cmd = { 0 };
 249         struct dpni_rsp_is_enabled *rsp_params;
 250         int err;
 251
 252         /* prepare command */
 253         cmd.header = mc_encode_cmd_header(DPNI_CMDID_IS_ENABLED,
 254                                           cmd_flags,
 255                                           token);
 256
 257         /* send command to mc*/
 258         err = mc_send_command(mc_io, &cmd);
 259         if (err)
 260                 return err;
 261
 262         /* retrieve response parameters */
 263         rsp_params = (struct dpni_rsp_is_enabled *)cmd.params;
 264         *en = dpni_get_field(rsp_params->enabled, ENABLE);
 265
 266         return 0;
 267 }
 268
 269 /**
 270  * dpni_reset() - Reset the DPNI, returns the object to initial state.
 271  * @mc_io:      Pointer to MC portal's I/O object
 272  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 273  * @token:      Token of DPNI object
 274  *
 275  * Return:      '0' on Success; Error code otherwise.
 276  */
 277 int dpni_reset(struct fsl_mc_io *mc_io,
 278                u32 cmd_flags,
 279                u16 token)
 280 {
 281         struct fsl_mc_command cmd = { 0 };
 282
 283         /* prepare command */
 284         cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
 285                                           cmd_flags,
 286                                           token);
 287
 288         /* send command to mc*/
 289         return mc_send_command(mc_io, &cmd);
 290 }
 291
 292 /**
 293  * dpni_set_irq_enable() - Set overall interrupt state.
 294  * @mc_io:      Pointer to MC portal's I/O object
 295  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 296  * @token:      Token of DPNI object
 297  * @irq_index:  The interrupt index to configure
 298  * @en:         Interrupt state: - enable = 1, disable = 0
 299  *
 300  * Allows GPP software to control when interrupts are generated.
 301  * Each interrupt can have up to 32 causes.  The enable/disable control's the
 302  * overall interrupt state. if the interrupt is disabled no causes will cause
 303  * an interrupt.
 304  *
 305  * Return:      '0' on Success; Error code otherwise.
 306  */
 307 int dpni_set_irq_enable(struct fsl_mc_io *mc_io,
 308                         u32 cmd_flags,
 309                         u16 token,
 310                         u8 irq_index,
 311                         u8 en)
 312 {
 313         struct fsl_mc_command cmd = { 0 };
 314         struct dpni_cmd_set_irq_enable *cmd_params;
 315
 316         /* prepare command */
 317         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_IRQ_ENABLE,
 318                                           cmd_flags,
 319                                           token);
 320         cmd_params = (struct dpni_cmd_set_irq_enable *)cmd.params;
 321         dpni_set_field(cmd_params->enable, ENABLE, en);
 322         cmd_params->irq_index = irq_index;
 323
 324         /* send command to mc*/
 325         return mc_send_command(mc_io, &cmd);
 326 }
 327
 328 /**
 329  * dpni_get_irq_enable() - Get overall interrupt state
 330  * @mc_io:      Pointer to MC portal's I/O object
 331  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 332  * @token:      Token of DPNI object
 333  * @irq_index:  The interrupt index to configure
 334  * @en:         Returned interrupt state - enable = 1, disable = 0
 335  *
 336  * Return:      '0' on Success; Error code otherwise.
 337  */
 338 int dpni_get_irq_enable(struct fsl_mc_io *mc_io,
 339                         u32 cmd_flags,
 340                         u16 token,
 341                         u8 irq_index,
 342                         u8 *en)
 343 {
 344         struct fsl_mc_command cmd = { 0 };
 345         struct dpni_cmd_get_irq_enable *cmd_params;
 346         struct dpni_rsp_get_irq_enable *rsp_params;
 347
 348         int err;
 349
 350         /* prepare command */
 351         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_ENABLE,
 352                                           cmd_flags,
 353                                           token);
 354         cmd_params = (struct dpni_cmd_get_irq_enable *)cmd.params;
 355         cmd_params->irq_index = irq_index;
 356
 357         /* send command to mc*/
 358         err = mc_send_command(mc_io, &cmd);
 359         if (err)
 360                 return err;
 361
 362         /* retrieve response parameters */
 363         rsp_params = (struct dpni_rsp_get_irq_enable *)cmd.params;
 364         *en = dpni_get_field(rsp_params->enabled, ENABLE);
 365
 366         return 0;
 367 }
 368
 369 /**
 370  * dpni_set_irq_mask() - Set interrupt mask.
 371  * @mc_io:      Pointer to MC portal's I/O object
 372  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 373  * @token:      Token of DPNI object
 374  * @irq_index:  The interrupt index to configure
 375  * @mask:       event mask to trigger interrupt;
 376  *                      each bit:
 377  *                              0 = ignore event
 378  *                              1 = consider event for asserting IRQ
 379  *
 380  * Every interrupt can have up to 32 causes and the interrupt model supports
 381  * masking/unmasking each cause independently
 382  *
 383  * Return:      '0' on Success; Error code otherwise.
 384  */
 385 int dpni_set_irq_mask(struct fsl_mc_io *mc_io,
 386                       u32 cmd_flags,
 387                       u16 token,
 388                       u8 irq_index,
 389                       u32 mask)
 390 {
 391         struct fsl_mc_command cmd = { 0 };
 392         struct dpni_cmd_set_irq_mask *cmd_params;
 393
 394         /* prepare command */
 395         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_IRQ_MASK,
 396                                           cmd_flags,
 397                                           token);
 398         cmd_params = (struct dpni_cmd_set_irq_mask *)cmd.params;
 399         cmd_params->mask = cpu_to_le32(mask);
 400         cmd_params->irq_index = irq_index;
 401
 402         /* send command to mc*/
 403         return mc_send_command(mc_io, &cmd);
 404 }
 405
 406 /**
 407  * dpni_get_irq_mask() - Get interrupt mask.
 408  * @mc_io:      Pointer to MC portal's I/O object
 409  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 410  * @token:      Token of DPNI object
 411  * @irq_index:  The interrupt index to configure
 412  * @mask:       Returned event mask to trigger interrupt
 413  *
 414  * Every interrupt can have up to 32 causes and the interrupt model supports
 415  * masking/unmasking each cause independently
 416  *
 417  * Return:      '0' on Success; Error code otherwise.
 418  */
 419 int dpni_get_irq_mask(struct fsl_mc_io *mc_io,
 420                       u32 cmd_flags,
 421                       u16 token,
 422                       u8 irq_index,
 423                       u32 *mask)
 424 {
 425         struct fsl_mc_command cmd = { 0 };
 426         struct dpni_cmd_get_irq_mask *cmd_params;
 427         struct dpni_rsp_get_irq_mask *rsp_params;
 428         int err;
 429
 430         /* prepare command */
 431         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_MASK,
 432                                           cmd_flags,
 433                                           token);
 434         cmd_params = (struct dpni_cmd_get_irq_mask *)cmd.params;
 435         cmd_params->irq_index = irq_index;
 436
 437         /* send command to mc*/
 438         err = mc_send_command(mc_io, &cmd);
 439         if (err)
 440                 return err;
 441
 442         /* retrieve response parameters */
 443         rsp_params = (struct dpni_rsp_get_irq_mask *)cmd.params;
 444         *mask = le32_to_cpu(rsp_params->mask);
 445
 446         return 0;
 447 }
 448
 449 /**
 450  * dpni_get_irq_status() - Get the current status of any pending interrupts.
 451  * @mc_io:      Pointer to MC portal's I/O object
 452  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 453  * @token:      Token of DPNI object
 454  * @irq_index:  The interrupt index to configure
 455  * @status:     Returned interrupts status - one bit per cause:
 456  *                      0 = no interrupt pending
 457  *                      1 = interrupt pending
 458  *
 459  * Return:      '0' on Success; Error code otherwise.
 460  */
 461 int dpni_get_irq_status(struct fsl_mc_io *mc_io,
 462                         u32 cmd_flags,
 463                         u16 token,
 464                         u8 irq_index,
 465                         u32 *status)
 466 {
 467         struct fsl_mc_command cmd = { 0 };
 468         struct dpni_cmd_get_irq_status *cmd_params;
 469         struct dpni_rsp_get_irq_status *rsp_params;
 470         int err;
 471
 472         /* prepare command */
 473         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_IRQ_STATUS,
 474                                           cmd_flags,
 475                                           token);
 476         cmd_params = (struct dpni_cmd_get_irq_status *)cmd.params;
 477         cmd_params->status = cpu_to_le32(*status);
 478         cmd_params->irq_index = irq_index;
 479
 480         /* send command to mc*/
 481         err = mc_send_command(mc_io, &cmd);
 482         if (err)
 483                 return err;
 484
 485         /* retrieve response parameters */
 486         rsp_params = (struct dpni_rsp_get_irq_status *)cmd.params;
 487         *status = le32_to_cpu(rsp_params->status);
 488
 489         return 0;
 490 }
 491
 492 /**
 493  * dpni_clear_irq_status() - Clear a pending interrupt's status
 494  * @mc_io:      Pointer to MC portal's I/O object
 495  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 496  * @token:      Token of DPNI object
 497  * @irq_index:  The interrupt index to configure
 498  * @status:     bits to clear (W1C) - one bit per cause:
 499  *                      0 = don't change
 500  *                      1 = clear status bit
 501  *
 502  * Return:      '0' on Success; Error code otherwise.
 503  */
 504 int dpni_clear_irq_status(struct fsl_mc_io *mc_io,
 505                           u32 cmd_flags,
 506                           u16 token,
 507                           u8 irq_index,
 508                           u32 status)
 509 {
 510         struct fsl_mc_command cmd = { 0 };
 511         struct dpni_cmd_clear_irq_status *cmd_params;
 512
 513         /* prepare command */
 514         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLEAR_IRQ_STATUS,
 515                                           cmd_flags,
 516                                           token);
 517         cmd_params = (struct dpni_cmd_clear_irq_status *)cmd.params;
 518         cmd_params->irq_index = irq_index;
 519         cmd_params->status = cpu_to_le32(status);
 520
 521         /* send command to mc*/
 522         return mc_send_command(mc_io, &cmd);
 523 }
 524
 525 /**
 526  * dpni_get_attributes() - Retrieve DPNI attributes.
 527  * @mc_io:      Pointer to MC portal's I/O object
 528  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 529  * @token:      Token of DPNI object
 530  * @attr:       Object's attributes
 531  *
 532  * Return:      '0' on Success; Error code otherwise.
 533  */
 534 int dpni_get_attributes(struct fsl_mc_io *mc_io,
 535                         u32 cmd_flags,
 536                         u16 token,
 537                         struct dpni_attr *attr)
 538 {
 539         struct fsl_mc_command cmd = { 0 };
 540         struct dpni_rsp_get_attr *rsp_params;
 541
 542         int err;
 543
 544         /* prepare command */
 545         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
 546                                           cmd_flags,
 547                                           token);
 548
 549         /* send command to mc*/
 550         err = mc_send_command(mc_io, &cmd);
 551         if (err)
 552                 return err;
 553
 554         /* retrieve response parameters */
 555         rsp_params = (struct dpni_rsp_get_attr *)cmd.params;
 556         attr->options = le32_to_cpu(rsp_params->options);
 557         attr->num_queues = rsp_params->num_queues;
 558         attr->num_tcs = rsp_params->num_tcs;
 559         attr->mac_filter_entries = rsp_params->mac_filter_entries;
 560         attr->vlan_filter_entries = rsp_params->vlan_filter_entries;
 561         attr->qos_entries = rsp_params->qos_entries;
 562         attr->fs_entries = le16_to_cpu(rsp_params->fs_entries);
 563         attr->qos_key_size = rsp_params->qos_key_size;
 564         attr->fs_key_size = rsp_params->fs_key_size;
 565         attr->wriop_version = le16_to_cpu(rsp_params->wriop_version);
 566
 567         return 0;
 568 }
 569
 570 /**
 571  * dpni_set_errors_behavior() - Set errors behavior
 572  * @mc_io:      Pointer to MC portal's I/O object
 573  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 574  * @token:      Token of DPNI object
 575  * @cfg:        Errors configuration
 576  *
 577  * this function may be called numerous times with different
 578  * error masks
 579  *
 580  * Return:      '0' on Success; Error code otherwise.
 581  */
 582 int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
 583                              u32 cmd_flags,
 584                              u16 token,
 585                              struct dpni_error_cfg *cfg)
 586 {
 587         struct fsl_mc_command cmd = { 0 };
 588         struct dpni_cmd_set_errors_behavior *cmd_params;
 589
 590         /* prepare command */
 591         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR,
 592                                           cmd_flags,
 593                                           token);
 594         cmd_params = (struct dpni_cmd_set_errors_behavior *)cmd.params;
 595         cmd_params->errors = cpu_to_le32(cfg->errors);
 596         dpni_set_field(cmd_params->flags, ERROR_ACTION, cfg->error_action);
 597         dpni_set_field(cmd_params->flags, FRAME_ANN, cfg->set_frame_annotation);
 598
 599         /* send command to mc*/
 600         return mc_send_command(mc_io, &cmd);
 601 }
 602
 603 /**
 604  * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
 605  * @mc_io:      Pointer to MC portal's I/O object
 606  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 607  * @token:      Token of DPNI object
 608  * @qtype:      Type of queue to retrieve configuration for
 609  * @layout:     Returns buffer layout attributes
 610  *
 611  * Return:      '0' on Success; Error code otherwise.
 612  */
 613 int dpni_get_buffer_layout(struct fsl_mc_io *mc_io,
 614                            u32 cmd_flags,
 615                            u16 token,
 616                            enum dpni_queue_type qtype,
 617                            struct dpni_buffer_layout *layout)
 618 {
 619         struct fsl_mc_command cmd = { 0 };
 620         struct dpni_cmd_get_buffer_layout *cmd_params;
 621         struct dpni_rsp_get_buffer_layout *rsp_params;
 622         int err;
 623
 624         /* prepare command */
 625         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_BUFFER_LAYOUT,
 626                                           cmd_flags,
 627                                           token);
 628         cmd_params = (struct dpni_cmd_get_buffer_layout *)cmd.params;
 629         cmd_params->qtype = qtype;
 630
 631         /* send command to mc*/
 632         err = mc_send_command(mc_io, &cmd);
 633         if (err)
 634                 return err;
 635
 636         /* retrieve response parameters */
 637         rsp_params = (struct dpni_rsp_get_buffer_layout *)cmd.params;
 638         layout->pass_timestamp = dpni_get_field(rsp_params->flags, PASS_TS);
 639         layout->pass_parser_result = dpni_get_field(rsp_params->flags, PASS_PR);
 640         layout->pass_frame_status = dpni_get_field(rsp_params->flags, PASS_FS);
 641         layout->private_data_size = le16_to_cpu(rsp_params->private_data_size);
 642         layout->data_align = le16_to_cpu(rsp_params->data_align);
 643         layout->data_head_room = le16_to_cpu(rsp_params->head_room);
 644         layout->data_tail_room = le16_to_cpu(rsp_params->tail_room);
 645
 646         return 0;
 647 }
 648
 649 /**
 650  * dpni_set_buffer_layout() - Set buffer layout configuration.
 651  * @mc_io:      Pointer to MC portal's I/O object
 652  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 653  * @token:      Token of DPNI object
 654  * @qtype:      Type of queue this configuration applies to
 655  * @layout:     Buffer layout configuration
 656  *
 657  * Return:      '0' on Success; Error code otherwise.
 658  *
 659  * @warning     Allowed only when DPNI is disabled
 660  */
 661 int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
 662                            u32 cmd_flags,
 663                            u16 token,
 664                            enum dpni_queue_type qtype,
 665                            const struct dpni_buffer_layout *layout)
 666 {
 667         struct fsl_mc_command cmd = { 0 };
 668         struct dpni_cmd_set_buffer_layout *cmd_params;
 669
 670         /* prepare command */
 671         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
 672                                           cmd_flags,
 673                                           token);
 674         cmd_params = (struct dpni_cmd_set_buffer_layout *)cmd.params;
 675         cmd_params->qtype = qtype;
 676         cmd_params->options = cpu_to_le16(layout->options);
 677         dpni_set_field(cmd_params->flags, PASS_TS, layout->pass_timestamp);
 678         dpni_set_field(cmd_params->flags, PASS_PR, layout->pass_parser_result);
 679         dpni_set_field(cmd_params->flags, PASS_FS, layout->pass_frame_status);
 680         cmd_params->private_data_size = cpu_to_le16(layout->private_data_size);
 681         cmd_params->data_align = cpu_to_le16(layout->data_align);
 682         cmd_params->head_room = cpu_to_le16(layout->data_head_room);
 683         cmd_params->tail_room = cpu_to_le16(layout->data_tail_room);
 684
 685         /* send command to mc*/
 686         return mc_send_command(mc_io, &cmd);
 687 }
 688
 689 /**
 690  * dpni_set_offload() - Set DPNI offload configuration.
 691  * @mc_io:      Pointer to MC portal's I/O object
 692  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 693  * @token:      Token of DPNI object
 694  * @type:       Type of DPNI offload
 695  * @config:     Offload configuration.
 696  *              For checksum offloads, non-zero value enables the offload
 697  *
 698  * Return:     '0' on Success; Error code otherwise.
 699  *
 700  * @warning    Allowed only when DPNI is disabled
 701  */
 702
 703 int dpni_set_offload(struct fsl_mc_io *mc_io,
 704                      u32 cmd_flags,
 705                      u16 token,
 706                      enum dpni_offload type,
 707                      u32 config)
 708 {
 709         struct fsl_mc_command cmd = { 0 };
 710         struct dpni_cmd_set_offload *cmd_params;
 711
 712         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_OFFLOAD,
 713                                           cmd_flags,
 714                                           token);
 715         cmd_params = (struct dpni_cmd_set_offload *)cmd.params;
 716         cmd_params->dpni_offload = type;
 717         cmd_params->config = cpu_to_le32(config);
 718
 719         return mc_send_command(mc_io, &cmd);
 720 }
 721
 722 int dpni_get_offload(struct fsl_mc_io *mc_io,
 723                      u32 cmd_flags,
 724                      u16 token,
 725                      enum dpni_offload type,
 726                      u32 *config)
 727 {
 728         struct fsl_mc_command cmd = { 0 };
 729         struct dpni_cmd_get_offload *cmd_params;
 730         struct dpni_rsp_get_offload *rsp_params;
 731         int err;
 732
 733         /* prepare command */
 734         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_OFFLOAD,
 735                                           cmd_flags,
 736                                           token);
 737         cmd_params = (struct dpni_cmd_get_offload *)cmd.params;
 738         cmd_params->dpni_offload = type;
 739
 740         /* send command to mc*/
 741         err = mc_send_command(mc_io, &cmd);
 742         if (err)
 743                 return err;
 744
 745         /* retrieve response parameters */
 746         rsp_params = (struct dpni_rsp_get_offload *)cmd.params;
 747         *config = le32_to_cpu(rsp_params->config);
 748
 749         return 0;
 750 }
 751
 752 /**
 753  * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
 754  *                      for enqueue operations
 755  * @mc_io:      Pointer to MC portal's I/O object
 756  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 757  * @token:      Token of DPNI object
 758  * @qtype:      Type of queue to receive QDID for
 759  * @qdid:       Returned virtual QDID value that should be used as an argument
 760  *                      in all enqueue operations
 761  *
 762  * Return:      '0' on Success; Error code otherwise.
 763  */
 764 int dpni_get_qdid(struct fsl_mc_io *mc_io,
 765                   u32 cmd_flags,
 766                   u16 token,
 767                   enum dpni_queue_type qtype,
 768                   u16 *qdid)
 769 {
 770         struct fsl_mc_command cmd = { 0 };
 771         struct dpni_cmd_get_qdid *cmd_params;
 772         struct dpni_rsp_get_qdid *rsp_params;
 773         int err;
 774
 775         /* prepare command */
 776         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
 777                                           cmd_flags,
 778                                           token);
 779         cmd_params = (struct dpni_cmd_get_qdid *)cmd.params;
 780         cmd_params->qtype = qtype;
 781
 782         /* send command to mc*/
 783         err = mc_send_command(mc_io, &cmd);
 784         if (err)
 785                 return err;
 786
 787         /* retrieve response parameters */
 788         rsp_params = (struct dpni_rsp_get_qdid *)cmd.params;
 789         *qdid = le16_to_cpu(rsp_params->qdid);
 790
 791         return 0;
 792 }
 793
 794 /**
 795  * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
 796  * @mc_io:      Pointer to MC portal's I/O object
 797  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 798  * @token:      Token of DPNI object
 799  * @data_offset: Tx data offset (from start of buffer)
 800  *
 801  * Return:      '0' on Success; Error code otherwise.
 802  */
 803 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
 804                             u32 cmd_flags,
 805                             u16 token,
 806                             u16 *data_offset)
 807 {
 808         struct fsl_mc_command cmd = { 0 };
 809         struct dpni_rsp_get_tx_data_offset *rsp_params;
 810         int err;
 811
 812         /* prepare command */
 813         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
 814                                           cmd_flags,
 815                                           token);
 816
 817         /* send command to mc*/
 818         err = mc_send_command(mc_io, &cmd);
 819         if (err)
 820                 return err;
 821
 822         /* retrieve response parameters */
 823         rsp_params = (struct dpni_rsp_get_tx_data_offset *)cmd.params;
 824         *data_offset = le16_to_cpu(rsp_params->data_offset);
 825
 826         return 0;
 827 }
 828
 829 /**
 830  * dpni_set_link_cfg() - set the link configuration.
 831  * @mc_io:      Pointer to MC portal's I/O object
 832  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 833  * @token:      Token of DPNI object
 834  * @cfg:        Link configuration
 835  *
 836  * Return:      '0' on Success; Error code otherwise.
 837  */
 838 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
 839                       u32 cmd_flags,
 840                       u16 token,
 841                       const struct dpni_link_cfg *cfg)
 842 {
 843         struct fsl_mc_command cmd = { 0 };
 844         struct dpni_cmd_link_cfg *cmd_params;
 845
 846         /* prepare command */
 847         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
 848                                           cmd_flags,
 849                                           token);
 850         cmd_params = (struct dpni_cmd_link_cfg *)cmd.params;
 851         cmd_params->rate = cpu_to_le32(cfg->rate);
 852         cmd_params->options = cpu_to_le64(cfg->options);
 853
 854         /* send command to mc*/
 855         return mc_send_command(mc_io, &cmd);
 856 }
 857
 858 /**
 859  * dpni_get_link_cfg() - return the link configuration
 860  * @mc_io:      Pointer to MC portal's I/O object
 861  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 862  * @token:      Token of DPNI object
 863  * @cfg:        Link configuration from dpni object
 864  *
 865  * Return:      '0' on Success; Error code otherwise.
 866  */
 867 int dpni_get_link_cfg(struct fsl_mc_io *mc_io,
 868                       u32 cmd_flags,
 869                       u16 token,
 870                       struct dpni_link_cfg *cfg)
 871 {
 872         struct fsl_mc_command cmd = { 0 };
 873         struct dpni_cmd_link_cfg *rsp_params;
 874         int err;
 875
 876         /* prepare command */
 877         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_CFG,
 878                                           cmd_flags,
 879                                           token);
 880
 881         /* send command to mc*/
 882         err = mc_send_command(mc_io, &cmd);
 883         if (err)
 884                 return err;
 885
 886         /* retrieve response parameters */
 887         rsp_params = (struct dpni_cmd_link_cfg *)cmd.params;
 888         cfg->rate = le32_to_cpu(rsp_params->rate);
 889         cfg->options = le64_to_cpu(rsp_params->options);
 890
 891         return err;
 892 }
 893
 894 /**
 895  * dpni_get_link_state() - Return the link state (either up or down)
 896  * @mc_io:      Pointer to MC portal's I/O object
 897  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 898  * @token:      Token of DPNI object
 899  * @state:      Returned link state;
 900  *
 901  * Return:      '0' on Success; Error code otherwise.
 902  */
 903 int dpni_get_link_state(struct fsl_mc_io *mc_io,
 904                         u32 cmd_flags,
 905                         u16 token,
 906                         struct dpni_link_state *state)
 907 {
 908         struct fsl_mc_command cmd = { 0 };
 909         struct dpni_rsp_get_link_state *rsp_params;
 910         int err;
 911
 912         /* prepare command */
 913         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
 914                                           cmd_flags,
 915                                           token);
 916
 917         /* send command to mc*/
 918         err = mc_send_command(mc_io, &cmd);
 919         if (err)
 920                 return err;
 921
 922         /* retrieve response parameters */
 923         rsp_params = (struct dpni_rsp_get_link_state *)cmd.params;
 924         state->up = dpni_get_field(rsp_params->flags, LINK_STATE);
 925         state->rate = le32_to_cpu(rsp_params->rate);
 926         state->options = le64_to_cpu(rsp_params->options);
 927
 928         return 0;
 929 }
 930
 931 /**
 932  * dpni_set_max_frame_length() - Set the maximum received frame length.
 933  * @mc_io:      Pointer to MC portal's I/O object
 934  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 935  * @token:      Token of DPNI object
 936  * @max_frame_length:   Maximum received frame length (in
 937  *                              bytes); frame is discarded if its
 938  *                              length exceeds this value
 939  *
 940  * Return:      '0' on Success; Error code otherwise.
 941  */
 942 int dpni_set_max_frame_length(struct fsl_mc_io *mc_io,
 943                               u32 cmd_flags,
 944                               u16 token,
 945                               u16 max_frame_length)
 946 {
 947         struct fsl_mc_command cmd = { 0 };
 948         struct dpni_cmd_set_max_frame_length *cmd_params;
 949
 950         /* prepare command */
 951         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MAX_FRAME_LENGTH,
 952                                           cmd_flags,
 953                                           token);
 954         cmd_params = (struct dpni_cmd_set_max_frame_length *)cmd.params;
 955         cmd_params->max_frame_length = cpu_to_le16(max_frame_length);
 956
 957         /* send command to mc*/
 958         return mc_send_command(mc_io, &cmd);
 959 }
 960
 961 /**
 962  * dpni_get_max_frame_length() - Get the maximum received frame length.
 963  * @mc_io:      Pointer to MC portal's I/O object
 964  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 965  * @token:      Token of DPNI object
 966  * @max_frame_length:   Maximum received frame length (in
 967  *                              bytes); frame is discarded if its
 968  *                              length exceeds this value
 969  *
 970  * Return:      '0' on Success; Error code otherwise.
 971  */
 972 int dpni_get_max_frame_length(struct fsl_mc_io *mc_io,
 973                               u32 cmd_flags,
 974                               u16 token,
 975                               u16 *max_frame_length)
 976 {
 977         struct fsl_mc_command cmd = { 0 };
 978         struct dpni_rsp_get_max_frame_length *rsp_params;
 979         int err;
 980
 981         /* prepare command */
 982         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MAX_FRAME_LENGTH,
 983                                           cmd_flags,
 984                                           token);
 985
 986         /* send command to mc*/
 987         err = mc_send_command(mc_io, &cmd);
 988         if (err)
 989                 return err;
 990
 991         /* retrieve response parameters */
 992         rsp_params = (struct dpni_rsp_get_max_frame_length *)cmd.params;
 993         *max_frame_length = le16_to_cpu(rsp_params->max_frame_length);
 994
 995         return 0;
 996 }
 997
 998 /**
 999  * dpni_set_multicast_promisc() - Enable/disable multicast promiscuous mode
1000  * @mc_io:      Pointer to MC portal's I/O object
1001  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1002  * @token:      Token of DPNI object
1003  * @en:         Set to '1' to enable; '0' to disable
1004  *
1005  * Return:      '0' on Success; Error code otherwise.
1006  */
1007 int dpni_set_multicast_promisc(struct fsl_mc_io *mc_io,
1008                                u32 cmd_flags,
1009                                u16 token,
1010                                int en)
1011 {
1012         struct fsl_mc_command cmd = { 0 };
1013         struct dpni_cmd_set_multicast_promisc *cmd_params;
1014
1015         /* prepare command */
1016         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MCAST_PROMISC,
1017                                           cmd_flags,
1018                                           token);
1019         cmd_params = (struct dpni_cmd_set_multicast_promisc *)cmd.params;
1020         dpni_set_field(cmd_params->enable, ENABLE, en);
1021
1022         /* send command to mc*/
1023         return mc_send_command(mc_io, &cmd);
1024 }
1025
1026 /**
1027  * dpni_get_multicast_promisc() - Get multicast promiscuous mode
1028  * @mc_io:      Pointer to MC portal's I/O object
1029  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1030  * @token:      Token of DPNI object
1031  * @en:         Returns '1' if enabled; '0' otherwise
1032  *
1033  * Return:      '0' on Success; Error code otherwise.
1034  */
1035 int dpni_get_multicast_promisc(struct fsl_mc_io *mc_io,
1036                                u32 cmd_flags,
1037                                u16 token,
1038                                int *en)
1039 {
1040         struct fsl_mc_command cmd = { 0 };
1041         struct dpni_rsp_get_multicast_promisc *rsp_params;
1042         int err;
1043
1044         /* prepare command */
1045         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MCAST_PROMISC,
1046                                           cmd_flags,
1047                                           token);
1048
1049         /* send command to mc*/
1050         err = mc_send_command(mc_io, &cmd);
1051         if (err)
1052                 return err;
1053
1054         /* retrieve response parameters */
1055         rsp_params = (struct dpni_rsp_get_multicast_promisc *)cmd.params;
1056         *en = dpni_get_field(rsp_params->enabled, ENABLE);
1057
1058         return 0;
1059 }
1060
1061 /**
1062  * dpni_set_unicast_promisc() - Enable/disable unicast promiscuous mode
1063  * @mc_io:      Pointer to MC portal's I/O object
1064  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1065  * @token:      Token of DPNI object
1066  * @en:         Set to '1' to enable; '0' to disable
1067  *
1068  * Return:      '0' on Success; Error code otherwise.
1069  */
1070 int dpni_set_unicast_promisc(struct fsl_mc_io *mc_io,
1071                              u32 cmd_flags,
1072                              u16 token,
1073                              int en)
1074 {
1075         struct fsl_mc_command cmd = { 0 };
1076         struct dpni_cmd_set_unicast_promisc *cmd_params;
1077
1078         /* prepare command */
1079         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_UNICAST_PROMISC,
1080                                           cmd_flags,
1081                                           token);
1082         cmd_params = (struct dpni_cmd_set_unicast_promisc *)cmd.params;
1083         dpni_set_field(cmd_params->enable, ENABLE, en);
1084
1085         /* send command to mc*/
1086         return mc_send_command(mc_io, &cmd);
1087 }
1088
1089 /**
1090  * dpni_get_unicast_promisc() - Get unicast promiscuous mode
1091  * @mc_io:      Pointer to MC portal's I/O object
1092  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1093  * @token:      Token of DPNI object
1094  * @en:         Returns '1' if enabled; '0' otherwise
1095  *
1096  * Return:      '0' on Success; Error code otherwise.
1097  */
1098 int dpni_get_unicast_promisc(struct fsl_mc_io *mc_io,
1099                              u32 cmd_flags,
1100                              u16 token,
1101                              int *en)
1102 {
1103         struct fsl_mc_command cmd = { 0 };
1104         struct dpni_rsp_get_unicast_promisc *rsp_params;
1105         int err;
1106
1107         /* prepare command */
1108         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_UNICAST_PROMISC,
1109                                           cmd_flags,
1110                                           token);
1111
1112         /* send command to mc*/
1113         err = mc_send_command(mc_io, &cmd);
1114         if (err)
1115                 return err;
1116
1117         /* retrieve response parameters */
1118         rsp_params = (struct dpni_rsp_get_unicast_promisc *)cmd.params;
1119         *en = dpni_get_field(rsp_params->enabled, ENABLE);
1120
1121         return 0;
1122 }
1123
1124 /**
1125  * dpni_set_primary_mac_addr() - Set the primary MAC address
1126  * @mc_io:      Pointer to MC portal's I/O object
1127  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1128  * @token:      Token of DPNI object
1129  * @mac_addr:   MAC address to set as primary address
1130  *
1131  * Return:      '0' on Success; Error code otherwise.
1132  */
1133 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
1134                               u32 cmd_flags,
1135                               u16 token,
1136                               const u8 mac_addr[6])
1137 {
1138         struct fsl_mc_command cmd = { 0 };
1139         struct dpni_cmd_set_primary_mac_addr *cmd_params;
1140         int i;
1141
1142         /* prepare command */
1143         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
1144                                           cmd_flags,
1145                                           token);
1146         cmd_params = (struct dpni_cmd_set_primary_mac_addr *)cmd.params;
1147         for (i = 0; i < 6; i++)
1148                 cmd_params->mac_addr[i] = mac_addr[5 - i];
1149
1150         /* send command to mc*/
1151         return mc_send_command(mc_io, &cmd);
1152 }
1153
1154 /**
1155  * dpni_get_primary_mac_addr() - Get the primary MAC address
1156  * @mc_io:      Pointer to MC portal's I/O object
1157  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1158  * @token:      Token of DPNI object
1159  * @mac_addr:   Returned MAC address
1160  *
1161  * Return:      '0' on Success; Error code otherwise.
1162  */
1163 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
1164                               u32 cmd_flags,
1165                               u16 token,
1166                               u8 mac_addr[6])
1167 {
1168         struct fsl_mc_command cmd = { 0 };
1169         struct dpni_rsp_get_primary_mac_addr *rsp_params;
1170         int i, err;
1171
1172         /* prepare command */
1173         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
1174                                           cmd_flags,
1175                                           token);
1176
1177         /* send command to mc*/
1178         err = mc_send_command(mc_io, &cmd);
1179         if (err)
1180                 return err;
1181
1182         /* retrieve response parameters */
1183         rsp_params = (struct dpni_rsp_get_primary_mac_addr *)cmd.params;
1184         for (i = 0; i < 6; i++)
1185                 mac_addr[5 - i] = rsp_params->mac_addr[i];
1186
1187         return 0;
1188 }
1189
1190 /**
1191  * dpni_get_port_mac_addr() - Retrieve MAC address associated to the physical
1192  *                      port the DPNI is attached to
1193  * @mc_io:      Pointer to MC portal's I/O object
1194  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1195  * @token:      Token of DPNI object
1196  * @mac_addr:   MAC address of the physical port, if any, otherwise 0
1197  *
1198  * The primary MAC address is not cleared by this operation.
1199  *
1200  * Return:      '0' on Success; Error code otherwise.
1201  */
1202 int dpni_get_port_mac_addr(struct fsl_mc_io *mc_io,
1203                            u32 cmd_flags,
1204                            u16 token,
1205                            u8 mac_addr[6])
1206 {
1207         struct fsl_mc_command cmd = { 0 };
1208         struct dpni_rsp_get_port_mac_addr *rsp_params;
1209         int i, err;
1210
1211         /* prepare command */
1212         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PORT_MAC_ADDR,
1213                                           cmd_flags,
1214                                           token);
1215
1216         /* send command to mc*/
1217         err = mc_send_command(mc_io, &cmd);
1218         if (err)
1219                 return err;
1220
1221         /* retrieve response parameters */
1222         rsp_params = (struct dpni_rsp_get_port_mac_addr *)cmd.params;
1223         for (i = 0; i < 6; i++)
1224                 mac_addr[5 - i] = rsp_params->mac_addr[i];
1225
1226         return 0;
1227 }
1228
1229 /**
1230  * dpni_enable_vlan_filter() - Enable/disable VLAN filtering mode
1231  * @mc_io:      Pointer to MC portal's I/O object
1232  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1233  * @token:      Token of DPNI object
1234  * @en:         Set to '1' to enable; '0' to disable
1235  *
1236  * Return:      '0' on Success; Error code otherwise.
1237  */
1238 int dpni_enable_vlan_filter(struct fsl_mc_io *mc_io,
1239                             u32 cmd_flags,
1240                             u16 token,
1241                             u32 en)
1242 {
1243         struct dpni_cmd_enable_vlan_filter *cmd_params;
1244         struct fsl_mc_command cmd = { 0 };
1245
1246         /* prepare command */
1247         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE_VLAN_FILTER,
1248                                           cmd_flags,
1249                                           token);
1250         cmd_params = (struct dpni_cmd_enable_vlan_filter *)cmd.params;
1251         dpni_set_field(cmd_params->en, ENABLE, en);
1252
1253         /* send command to mc*/
1254         return mc_send_command(mc_io, &cmd);
1255 }
1256
1257 /**
1258  * dpni_add_vlan_id() - Add VLAN ID filter
1259  * @mc_io:      Pointer to MC portal's I/O object
1260  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1261  * @token:      Token of DPNI object
1262  * @vlan_id:    VLAN ID to add
1263  * @flags:   0 - tc_id and flow_id will be ignored.
1264  * Pkt with this vlan_id will be passed to the next
1265  * classification stages
1266  * DPNI_VLAN_SET_QUEUE_ACTION
1267  * Pkt with this vlan_id will be forward directly to
1268  * queue defined by the tc_id and flow_id
1269  *
1270  * @tc_id: Traffic class selection (0-7)
1271  * @flow_id: Selects the specific queue out of the set allocated for the
1272  *           same as tc_id. Value must be in range 0 to NUM_QUEUES - 1
1273  *
1274  * Return:      '0' on Success; Error code otherwise.
1275  */
1276 int dpni_add_vlan_id(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
1277                      u16 vlan_id, u8 flags, u8 tc_id, u8 flow_id)
1278 {
1279         struct dpni_cmd_vlan_id *cmd_params;
1280         struct fsl_mc_command cmd = { 0 };
1281
1282         /* prepare command */
1283         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_VLAN_ID,
1284                                           cmd_flags,
1285                                           token);
1286         cmd_params = (struct dpni_cmd_vlan_id *)cmd.params;
1287         cmd_params->flags = flags;
1288         cmd_params->tc_id = tc_id;
1289         cmd_params->flow_id =  flow_id;
1290         cmd_params->vlan_id = cpu_to_le16(vlan_id);
1291
1292         /* send command to mc*/
1293         return mc_send_command(mc_io, &cmd);
1294 }
1295
1296 /**
1297  * dpni_remove_vlan_id() - Remove VLAN ID filter
1298  * @mc_io:      Pointer to MC portal's I/O object
1299  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1300  * @token:      Token of DPNI object
1301  * @vlan_id:    VLAN ID to remove
1302  *
1303  * Return:      '0' on Success; Error code otherwise.
1304  */
1305 int dpni_remove_vlan_id(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
1306                         u16 vlan_id)
1307 {
1308         struct dpni_cmd_vlan_id *cmd_params;
1309         struct fsl_mc_command cmd = { 0 };
1310
1311         /* prepare command */
1312         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_VLAN_ID,
1313                                           cmd_flags,
1314                                           token);
1315         cmd_params = (struct dpni_cmd_vlan_id *)cmd.params;
1316         cmd_params->vlan_id = cpu_to_le16(vlan_id);
1317
1318         /* send command to mc*/
1319         return mc_send_command(mc_io, &cmd);
1320 }
1321
1322 /**
1323  * dpni_add_mac_addr() - Add MAC address filter
1324  * @mc_io:      Pointer to MC portal's I/O object
1325  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1326  * @token:      Token of DPNI object
1327  * @mac_addr:   MAC address to add
1328  *
1329  * Return:      '0' on Success; Error code otherwise.
1330  */
1331 int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
1332                       u32 cmd_flags,
1333                       u16 token,
1334                       const u8 mac_addr[6])
1335 {
1336         struct fsl_mc_command cmd = { 0 };
1337         struct dpni_cmd_add_mac_addr *cmd_params;
1338         int i;
1339
1340         /* prepare command */
1341         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
1342                                           cmd_flags,
1343                                           token);
1344         cmd_params = (struct dpni_cmd_add_mac_addr *)cmd.params;
1345         for (i = 0; i < 6; i++)
1346                 cmd_params->mac_addr[i] = mac_addr[5 - i];
1347
1348         /* send command to mc*/
1349         return mc_send_command(mc_io, &cmd);
1350 }
1351
1352 /**
1353  * dpni_remove_mac_addr() - Remove MAC address filter
1354  * @mc_io:      Pointer to MC portal's I/O object
1355  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1356  * @token:      Token of DPNI object
1357  * @mac_addr:   MAC address to remove
1358  *
1359  * Return:      '0' on Success; Error code otherwise.
1360  */
1361 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
1362                          u32 cmd_flags,
1363                          u16 token,
1364                          const u8 mac_addr[6])
1365 {
1366         struct fsl_mc_command cmd = { 0 };
1367         struct dpni_cmd_remove_mac_addr *cmd_params;
1368         int i;
1369
1370         /* prepare command */
1371         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
1372                                           cmd_flags,
1373                                           token);
1374         cmd_params = (struct dpni_cmd_remove_mac_addr *)cmd.params;
1375         for (i = 0; i < 6; i++)
1376                 cmd_params->mac_addr[i] = mac_addr[5 - i];
1377
1378         /* send command to mc*/
1379         return mc_send_command(mc_io, &cmd);
1380 }
1381
1382 /**
1383  * dpni_clear_mac_filters() - Clear all unicast and/or multicast MAC filters
1384  * @mc_io:      Pointer to MC portal's I/O object
1385  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1386  * @token:      Token of DPNI object
1387  * @unicast:    Set to '1' to clear unicast addresses
1388  * @multicast:  Set to '1' to clear multicast addresses
1389  *
1390  * The primary MAC address is not cleared by this operation.
1391  *
1392  * Return:      '0' on Success; Error code otherwise.
1393  */
1394 int dpni_clear_mac_filters(struct fsl_mc_io *mc_io,
1395                            u32 cmd_flags,
1396                            u16 token,
1397                            int unicast,
1398                            int multicast)
1399 {
1400         struct fsl_mc_command cmd = { 0 };
1401         struct dpni_cmd_clear_mac_filters *cmd_params;
1402
1403         /* prepare command */
1404         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLR_MAC_FILTERS,
1405                                           cmd_flags,
1406                                           token);
1407         cmd_params = (struct dpni_cmd_clear_mac_filters *)cmd.params;
1408         dpni_set_field(cmd_params->flags, UNICAST_FILTERS, unicast);
1409         dpni_set_field(cmd_params->flags, MULTICAST_FILTERS, multicast);
1410
1411         /* send command to mc*/
1412         return mc_send_command(mc_io, &cmd);
1413 }
1414
1415 /**
1416  * dpni_set_rx_tc_dist() - Set Rx traffic class distribution configuration
1417  * @mc_io:      Pointer to MC portal's I/O object
1418  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1419  * @token:      Token of DPNI object
1420  * @tc_id:      Traffic class selection (0-7)
1421  * @cfg:        Traffic class distribution configuration
1422  *
1423  * warning: if 'dist_mode != DPNI_DIST_MODE_NONE', call dpni_prepare_key_cfg()
1424  *                      first to prepare the key_cfg_iova parameter
1425  *
1426  * Return:      '0' on Success; error code otherwise.
1427  */
1428 int dpni_set_rx_tc_dist(struct fsl_mc_io *mc_io,
1429                         u32 cmd_flags,
1430                         u16 token,
1431                         u8 tc_id,
1432                         const struct dpni_rx_tc_dist_cfg *cfg)
1433 {
1434         struct fsl_mc_command cmd = { 0 };
1435         struct dpni_cmd_set_rx_tc_dist *cmd_params;
1436
1437         /* prepare command */
1438         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_TC_DIST,
1439                                           cmd_flags,
1440                                           token);
1441         cmd_params = (struct dpni_cmd_set_rx_tc_dist *)cmd.params;
1442         cmd_params->dist_size = cpu_to_le16(cfg->dist_size);
1443         cmd_params->tc_id = tc_id;
1444         dpni_set_field(cmd_params->flags, DIST_MODE, cfg->dist_mode);
1445         dpni_set_field(cmd_params->flags, MISS_ACTION, cfg->fs_cfg.miss_action);
1446         cmd_params->default_flow_id = cpu_to_le16(cfg->fs_cfg.default_flow_id);
1447         cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1448
1449         /* send command to mc*/
1450         return mc_send_command(mc_io, &cmd);
1451 }
1452
1453 /**
1454  * dpni_set_congestion_notification() - Set traffic class congestion
1455  *                                      notification configuration
1456  * @mc_io:      Pointer to MC portal's I/O object
1457  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1458  * @token:      Token of DPNI object
1459  * @qtype:      Type of queue - Rx, Tx and Tx confirm types are supported
1460  * @tc_id:      Traffic class selection (0-7)
1461  * @cfg:        Congestion notification configuration
1462  *
1463  * Return:      '0' on Success; error code otherwise.
1464  */
1465 int dpni_set_congestion_notification(
1466                         struct fsl_mc_io *mc_io,
1467                         u32 cmd_flags,
1468                         u16 token,
1469                         enum dpni_queue_type qtype,
1470                         u8 tc_id,
1471                         const struct dpni_congestion_notification_cfg *cfg)
1472 {
1473         struct dpni_cmd_set_congestion_notification *cmd_params;
1474         struct fsl_mc_command cmd = { 0 };
1475
1476         /* prepare command */
1477         cmd.header =
1478                 mc_encode_cmd_header(DPNI_CMDID_SET_CONGESTION_NOTIFICATION,
1479                                      cmd_flags,
1480                                      token);
1481         cmd_params = (struct dpni_cmd_set_congestion_notification *)cmd.params;
1482         cmd_params->qtype = qtype;
1483         cmd_params->tc = tc_id;
1484         cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
1485         cmd_params->notification_mode = cpu_to_le16(cfg->notification_mode);
1486         cmd_params->dest_priority = cfg->dest_cfg.priority;
1487         dpni_set_field(cmd_params->type_units, DEST_TYPE,
1488                        cfg->dest_cfg.dest_type);
1489         dpni_set_field(cmd_params->type_units, CONG_UNITS, cfg->units);
1490         cmd_params->message_iova = cpu_to_le64(cfg->message_iova);
1491         cmd_params->message_ctx = cpu_to_le64(cfg->message_ctx);
1492         cmd_params->threshold_entry = cpu_to_le32(cfg->threshold_entry);
1493         cmd_params->threshold_exit = cpu_to_le32(cfg->threshold_exit);
1494
1495         /* send command to mc*/
1496         return mc_send_command(mc_io, &cmd);
1497 }
1498
1499 /**
1500  * dpni_set_queue() - Set queue parameters
1501  * @mc_io:      Pointer to MC portal's I/O object
1502  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1503  * @token:      Token of DPNI object
1504  * @qtype:      Type of queue - all queue types are supported, although
1505  *              the command is ignored for Tx
1506  * @tc:         Traffic class, in range 0 to NUM_TCS - 1
1507  * @index:      Selects the specific queue out of the set allocated for the
1508  *              same TC. Value must be in range 0 to NUM_QUEUES - 1
1509  * @options:    A combination of DPNI_QUEUE_OPT_ values that control what
1510  *              configuration options are set on the queue
1511  * @queue:      Queue structure
1512  *
1513  * Return:      '0' on Success; Error code otherwise.
1514  */
1515 int dpni_set_queue(struct fsl_mc_io *mc_io,
1516                    u32 cmd_flags,
1517                    u16 token,
1518                    enum dpni_queue_type qtype,
1519                    u8 tc,
1520                    u8 index,
1521                    u8 options,
1522                    const struct dpni_queue *queue)
1523 {
1524         struct fsl_mc_command cmd = { 0 };
1525         struct dpni_cmd_set_queue *cmd_params;
1526
1527         /* prepare command */
1528         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
1529                                           cmd_flags,
1530                                           token);
1531         cmd_params = (struct dpni_cmd_set_queue *)cmd.params;
1532         cmd_params->qtype = qtype;
1533         cmd_params->tc = tc;
1534         cmd_params->index = index;
1535         cmd_params->options = options;
1536         cmd_params->dest_id = cpu_to_le32(queue->destination.id);
1537         cmd_params->dest_prio = queue->destination.priority;
1538         dpni_set_field(cmd_params->flags, DEST_TYPE, queue->destination.type);
1539         dpni_set_field(cmd_params->flags, STASH_CTRL, queue->flc.stash_control);
1540         dpni_set_field(cmd_params->flags, HOLD_ACTIVE,
1541                        queue->destination.hold_active);
1542         cmd_params->flc = cpu_to_le64(queue->flc.value);
1543         cmd_params->user_context = cpu_to_le64(queue->user_context);
1544
1545         /* send command to mc */
1546         return mc_send_command(mc_io, &cmd);
1547 }
1548
1549 /**
1550  * dpni_get_queue() - Get queue parameters
1551  * @mc_io:      Pointer to MC portal's I/O object
1552  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1553  * @token:      Token of DPNI object
1554  * @qtype:      Type of queue - all queue types are supported
1555  * @tc:         Traffic class, in range 0 to NUM_TCS - 1
1556  * @index:      Selects the specific queue out of the set allocated for the
1557  *              same TC. Value must be in range 0 to NUM_QUEUES - 1
1558  * @queue:      Queue configuration structure
1559  * @qid:        Queue identification
1560  *
1561  * Return:      '0' on Success; Error code otherwise.
1562  */
1563 int dpni_get_queue(struct fsl_mc_io *mc_io,
1564                    u32 cmd_flags,
1565                    u16 token,
1566                    enum dpni_queue_type qtype,
1567                    u8 tc,
1568                    u8 index,
1569                    struct dpni_queue *queue,
1570                    struct dpni_queue_id *qid)
1571 {
1572         struct fsl_mc_command cmd = { 0 };
1573         struct dpni_cmd_get_queue *cmd_params;
1574         struct dpni_rsp_get_queue *rsp_params;
1575         int err;
1576
1577         /* prepare command */
1578         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
1579                                           cmd_flags,
1580                                           token);
1581         cmd_params = (struct dpni_cmd_get_queue *)cmd.params;
1582         cmd_params->qtype = qtype;
1583         cmd_params->tc = tc;
1584         cmd_params->index = index;
1585
1586         /* send command to mc */
1587         err = mc_send_command(mc_io, &cmd);
1588         if (err)
1589                 return err;
1590
1591         /* retrieve response parameters */
1592         rsp_params = (struct dpni_rsp_get_queue *)cmd.params;
1593         queue->destination.id = le32_to_cpu(rsp_params->dest_id);
1594         queue->destination.priority = rsp_params->dest_prio;
1595         queue->destination.type = dpni_get_field(rsp_params->flags,
1596                                                  DEST_TYPE);
1597         queue->flc.stash_control = dpni_get_field(rsp_params->flags,
1598                                                   STASH_CTRL);
1599         queue->destination.hold_active = dpni_get_field(rsp_params->flags,
1600                                                         HOLD_ACTIVE);
1601         queue->flc.value = le64_to_cpu(rsp_params->flc);
1602         queue->user_context = le64_to_cpu(rsp_params->user_context);
1603         qid->fqid = le32_to_cpu(rsp_params->fqid);
1604         qid->qdbin = le16_to_cpu(rsp_params->qdbin);
1605
1606         return 0;
1607 }
1608
1609 /**
1610  * dpni_get_statistics() - Get DPNI statistics
1611  * @mc_io:      Pointer to MC portal's I/O object
1612  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1613  * @token:      Token of DPNI object
1614  * @page:       Selects the statistics page to retrieve, see
1615  *              DPNI_GET_STATISTICS output. Pages are numbered 0 to 6.
1616  * @stat:       Structure containing the statistics
1617  *
1618  * Return:      '0' on Success; Error code otherwise.
1619  */
1620 int dpni_get_statistics(struct fsl_mc_io *mc_io,
1621                         u32 cmd_flags,
1622                         u16 token,
1623                         u8 page,
1624                         union dpni_statistics *stat)
1625 {
1626         struct fsl_mc_command cmd = { 0 };
1627         struct dpni_cmd_get_statistics *cmd_params;
1628         struct dpni_rsp_get_statistics *rsp_params;
1629         int i, err;
1630
1631         /* prepare command */
1632         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
1633                                           cmd_flags,
1634                                           token);
1635         cmd_params = (struct dpni_cmd_get_statistics *)cmd.params;
1636         cmd_params->page_number = page;
1637
1638         /* send command to mc */
1639         err = mc_send_command(mc_io, &cmd);
1640         if (err)
1641                 return err;
1642
1643         /* retrieve response parameters */
1644         rsp_params = (struct dpni_rsp_get_statistics *)cmd.params;
1645         for (i = 0; i < DPNI_STATISTICS_CNT; i++)
1646                 stat->raw.counter[i] = le64_to_cpu(rsp_params->counter[i]);
1647
1648         return 0;
1649 }
1650
1651 /**
1652  * dpni_set_taildrop() - Set taildrop per queue or TC
1653  * @mc_io:      Pointer to MC portal's I/O object
1654  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1655  * @token:      Token of DPNI object
1656  * @cg_point:   Congestion point
1657  * @qtype:      Queue type on which the taildrop is configured.
1658  *              Only Rx queues are supported for now
1659  * @tc:         Traffic class to apply this taildrop to
1660  * @index:      Index of the queue if the DPNI supports multiple queues for
1661  *              traffic distribution. Ignored if CONGESTION_POINT is not 0.
1662  * @taildrop:   Taildrop structure
1663  *
1664  * Return:      '0' on Success; Error code otherwise.
1665  */
1666 int dpni_set_taildrop(struct fsl_mc_io *mc_io,
1667                       u32 cmd_flags,
1668                       u16 token,
1669                       enum dpni_congestion_point cg_point,
1670                       enum dpni_queue_type qtype,
1671                       u8 tc,
1672                       u8 index,
1673                       struct dpni_taildrop *taildrop)
1674 {
1675         struct fsl_mc_command cmd = { 0 };
1676         struct dpni_cmd_set_taildrop *cmd_params;
1677
1678         /* prepare command */
1679         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TAILDROP,
1680                                           cmd_flags,
1681                                           token);
1682         cmd_params = (struct dpni_cmd_set_taildrop *)cmd.params;
1683         cmd_params->congestion_point = cg_point;
1684         cmd_params->qtype = qtype;
1685         cmd_params->tc = tc;
1686         cmd_params->index = index;
1687         dpni_set_field(cmd_params->enable, ENABLE, taildrop->enable);
1688         cmd_params->units = taildrop->units;
1689         cmd_params->threshold = cpu_to_le32(taildrop->threshold);
1690
1691         /* send command to mc */
1692         return mc_send_command(mc_io, &cmd);
1693 }
1694
1695 /**
1696  * dpni_get_taildrop() - Get taildrop information
1697  * @mc_io:      Pointer to MC portal's I/O object
1698  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1699  * @token:      Token of DPNI object
1700  * @cg_point:   Congestion point
1701  * @qtype:      Queue type on which the taildrop is configured.
1702  *              Only Rx queues are supported for now
1703  * @tc:         Traffic class to apply this taildrop to
1704  * @index:      Index of the queue if the DPNI supports multiple queues for
1705  *              traffic distribution. Ignored if CONGESTION_POINT is not 0.
1706  * @taildrop:   Taildrop structure
1707  *
1708  * Return:      '0' on Success; Error code otherwise.
1709  */
1710 int dpni_get_taildrop(struct fsl_mc_io *mc_io,
1711                       u32 cmd_flags,
1712                       u16 token,
1713                       enum dpni_congestion_point cg_point,
1714                       enum dpni_queue_type qtype,
1715                       u8 tc,
1716                       u8 index,
1717                       struct dpni_taildrop *taildrop)
1718 {
1719         struct fsl_mc_command cmd = { 0 };
1720         struct dpni_cmd_get_taildrop *cmd_params;
1721         struct dpni_rsp_get_taildrop *rsp_params;
1722         int err;
1723
1724         /* prepare command */
1725         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TAILDROP,
1726                                           cmd_flags,
1727                                           token);
1728         cmd_params = (struct dpni_cmd_get_taildrop *)cmd.params;
1729         cmd_params->congestion_point = cg_point;
1730         cmd_params->qtype = qtype;
1731         cmd_params->tc = tc;
1732         cmd_params->index = index;
1733
1734         /* send command to mc */
1735         err = mc_send_command(mc_io, &cmd);
1736         if (err)
1737                 return err;
1738
1739         /* retrieve response parameters */
1740         rsp_params = (struct dpni_rsp_get_taildrop *)cmd.params;
1741         taildrop->enable = dpni_get_field(rsp_params->enable, ENABLE);
1742         taildrop->units = rsp_params->units;
1743         taildrop->threshold = le32_to_cpu(rsp_params->threshold);
1744
1745         return 0;
1746 }
1747
1748 /**
1749  * dpni_get_api_version() - Get Data Path Network Interface API version
1750  * @mc_io:      Pointer to MC portal's I/O object
1751  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1752  * @major_ver:  Major version of data path network interface API
1753  * @minor_ver:  Minor version of data path network interface API
1754  *
1755  * Return:      '0' on Success; Error code otherwise.
1756  */
1757 int dpni_get_api_version(struct fsl_mc_io *mc_io,
1758                          u32 cmd_flags,
1759                          u16 *major_ver,
1760                          u16 *minor_ver)
1761 {
1762         struct dpni_rsp_get_api_version *rsp_params;
1763         struct fsl_mc_command cmd = { 0 };
1764         int err;
1765
1766         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
1767                                           cmd_flags, 0);
1768
1769         err = mc_send_command(mc_io, &cmd);
1770         if (err)
1771                 return err;
1772
1773         rsp_params = (struct dpni_rsp_get_api_version *)cmd.params;
1774         *major_ver = le16_to_cpu(rsp_params->major);
1775         *minor_ver = le16_to_cpu(rsp_params->minor);
1776
1777         return 0;
1778 }
1779
1780 /**
1781  * dpni_set_rx_fs_dist() - Set Rx flow steering distribution
1782  * @mc_io:      Pointer to MC portal's I/O object
1783  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1784  * @token:      Token of DPNI object
1785  * @cfg: Distribution configuration
1786  *
1787  * If the FS is already enabled with a previous call the classification
1788  * key will be changed but all the table rules are kept. If the
1789  * existing rules do not match the key the results will not be
1790  * predictable. It is the user responsibility to keep key integrity.
1791  * If cfg.enable is set to 1 the command will create a flow steering table
1792  * and will classify packets according to this table. The packets that
1793  * miss all the table rules will be classified according to settings
1794  * made in dpni_set_rx_hash_dist()
1795  * If cfg.enable is set to 0 the command will clear flow steering table.
1796  * The packets will be classified according to settings made in
1797  * dpni_set_rx_hash_dist()
1798  *
1799  * Return:      '0' on Success; Error code otherwise.
1800  */
1801 int dpni_set_rx_fs_dist(struct fsl_mc_io *mc_io,
1802                         u32 cmd_flags,
1803                         u16 token,
1804                         const struct dpni_rx_dist_cfg *cfg)
1805 {
1806         struct dpni_cmd_set_rx_fs_dist *cmd_params;
1807         struct fsl_mc_command cmd = { 0 };
1808
1809         /* prepare command */
1810         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FS_DIST,
1811                                           cmd_flags,
1812                                           token);
1813         cmd_params = (struct dpni_cmd_set_rx_fs_dist *)cmd.params;
1814         cmd_params->dist_size = cpu_to_le16(cfg->dist_size);
1815         dpni_set_field(cmd_params->enable, RX_FS_DIST_ENABLE, cfg->enable);
1816         cmd_params->tc = cfg->tc;
1817         cmd_params->miss_flow_id = cpu_to_le16(cfg->fs_miss_flow_id);
1818         cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1819
1820         /* send command to mc*/
1821         return mc_send_command(mc_io, &cmd);
1822 }
1823
1824 /**
1825  * dpni_set_rx_hash_dist() - Set Rx hash distribution
1826  * @mc_io:      Pointer to MC portal's I/O object
1827  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1828  * @token:      Token of DPNI object
1829  * @cfg: Distribution configuration
1830  * If cfg.enable is set to 1 the packets will be classified using a hash
1831  * function based on the key received in cfg.key_cfg_iova parameter.
1832  * If cfg.enable is set to 0 the packets will be sent to the default queue
1833  *
1834  * Return:      '0' on Success; Error code otherwise.
1835  */
1836 int dpni_set_rx_hash_dist(struct fsl_mc_io *mc_io,
1837                           u32 cmd_flags,
1838                           u16 token,
1839                           const struct dpni_rx_dist_cfg *cfg)
1840 {
1841         struct dpni_cmd_set_rx_hash_dist *cmd_params;
1842         struct fsl_mc_command cmd = { 0 };
1843
1844         /* prepare command */
1845         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_HASH_DIST,
1846                                           cmd_flags,
1847                                           token);
1848         cmd_params = (struct dpni_cmd_set_rx_hash_dist *)cmd.params;
1849         cmd_params->dist_size = cpu_to_le16(cfg->dist_size);
1850         dpni_set_field(cmd_params->enable, RX_HASH_DIST_ENABLE, cfg->enable);
1851         cmd_params->tc = cfg->tc;
1852         cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1853
1854         /* send command to mc*/
1855         return mc_send_command(mc_io, &cmd);
1856 }
1857
1858 /**
1859  * dpni_add_fs_entry() - Add Flow Steering entry for a specific traffic class
1860  *                      (to select a flow ID)
1861  * @mc_io:      Pointer to MC portal's I/O object
1862  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1863  * @token:      Token of DPNI object
1864  * @tc_id:      Traffic class selection (0-7)
1865  * @index:      Location in the FS table where to insert the entry.
1866  *              Only relevant if MASKING is enabled for FS
1867  *              classification on this DPNI, it is ignored for exact match.
1868  * @cfg:        Flow steering rule to add
1869  * @action:     Action to be taken as result of a classification hit
1870  *
1871  * Return:      '0' on Success; Error code otherwise.
1872  */
1873 int dpni_add_fs_entry(struct fsl_mc_io *mc_io,
1874                       u32 cmd_flags,
1875                       u16 token,
1876                       u8 tc_id,
1877                       u16 index,
1878                       const struct dpni_rule_cfg *cfg,
1879                       const struct dpni_fs_action_cfg *action)
1880 {
1881         struct dpni_cmd_add_fs_entry *cmd_params;
1882         struct fsl_mc_command cmd = { 0 };
1883
1884         /* prepare command */
1885         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_FS_ENT,
1886                                           cmd_flags,
1887                                           token);
1888         cmd_params = (struct dpni_cmd_add_fs_entry *)cmd.params;
1889         cmd_params->tc_id = tc_id;
1890         cmd_params->key_size = cfg->key_size;
1891         cmd_params->index = cpu_to_le16(index);
1892         cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
1893         cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
1894         cmd_params->options = cpu_to_le16(action->options);
1895         cmd_params->flow_id = cpu_to_le16(action->flow_id);
1896         cmd_params->flc = cpu_to_le64(action->flc);
1897
1898         /* send command to mc*/
1899         return mc_send_command(mc_io, &cmd);
1900 }
1901
1902 /**
1903  * dpni_remove_fs_entry() - Remove Flow Steering entry from a specific
1904  *                          traffic class
1905  * @mc_io:      Pointer to MC portal's I/O object
1906  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1907  * @token:      Token of DPNI object
1908  * @tc_id:      Traffic class selection (0-7)
1909  * @cfg:        Flow steering rule to remove
1910  *
1911  * Return:      '0' on Success; Error code otherwise.
1912  */
1913 int dpni_remove_fs_entry(struct fsl_mc_io *mc_io,
1914                          u32 cmd_flags,
1915                          u16 token,
1916                          u8 tc_id,
1917                          const struct dpni_rule_cfg *cfg)
1918 {
1919         struct dpni_cmd_remove_fs_entry *cmd_params;
1920         struct fsl_mc_command cmd = { 0 };
1921
1922         /* prepare command */
1923         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_FS_ENT,
1924                                           cmd_flags,
1925                                           token);
1926         cmd_params = (struct dpni_cmd_remove_fs_entry *)cmd.params;
1927         cmd_params->tc_id = tc_id;
1928         cmd_params->key_size = cfg->key_size;
1929         cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
1930         cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
1931
1932         /* send command to mc*/
1933         return mc_send_command(mc_io, &cmd);
1934 }
1935
1936 /**
1937  * dpni_set_qos_table() - Set QoS mapping table
1938  * @mc_io:      Pointer to MC portal's I/O object
1939  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1940  * @token:      Token of DPNI object
1941  * @cfg:        QoS table configuration
1942  *
1943  * This function and all QoS-related functions require that
1944  *'max_tcs > 1' was set at DPNI creation.
1945  *
1946  * warning: Before calling this function, call dpkg_prepare_key_cfg() to
1947  *                      prepare the key_cfg_iova parameter
1948  *
1949  * Return:      '0' on Success; Error code otherwise.
1950  */
1951 int dpni_set_qos_table(struct fsl_mc_io *mc_io,
1952                        u32 cmd_flags,
1953                        u16 token,
1954                        const struct dpni_qos_tbl_cfg *cfg)
1955 {
1956         struct dpni_cmd_set_qos_table *cmd_params;
1957         struct fsl_mc_command cmd = { 0 };
1958
1959         /* prepare command */
1960         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QOS_TBL,
1961                                           cmd_flags,
1962                                           token);
1963         cmd_params = (struct dpni_cmd_set_qos_table *)cmd.params;
1964         cmd_params->default_tc = cfg->default_tc;
1965         cmd_params->key_cfg_iova = cpu_to_le64(cfg->key_cfg_iova);
1966         dpni_set_field(cmd_params->discard_on_miss, DISCARD_ON_MISS,
1967                        cfg->discard_on_miss);
1968
1969         /* send command to mc*/
1970         return mc_send_command(mc_io, &cmd);
1971 }
1972
1973 /**
1974  * dpni_add_qos_entry() - Add QoS mapping entry (to select a traffic class)
1975  * @mc_io:      Pointer to MC portal's I/O object
1976  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
1977  * @token:      Token of DPNI object
1978  * @cfg:        QoS rule to add
1979  * @tc_id:      Traffic class selection (0-7)
1980  * @index:      Location in the QoS table where to insert the entry.
1981  *              Only relevant if MASKING is enabled for QoS classification on
1982  *              this DPNI, it is ignored for exact match.
1983  *
1984  * Return:      '0' on Success; Error code otherwise.
1985  */
1986 int dpni_add_qos_entry(struct fsl_mc_io *mc_io,
1987                        u32 cmd_flags,
1988                        u16 token,
1989                        const struct dpni_rule_cfg *cfg,
1990                        u8 tc_id,
1991                        u16 index)
1992 {
1993         struct dpni_cmd_add_qos_entry *cmd_params;
1994         struct fsl_mc_command cmd = { 0 };
1995
1996         /* prepare command */
1997         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_QOS_ENT,
1998                                           cmd_flags,
1999                                           token);
2000         cmd_params = (struct dpni_cmd_add_qos_entry *)cmd.params;
2001         cmd_params->tc_id = tc_id;
2002         cmd_params->key_size = cfg->key_size;
2003         cmd_params->index = cpu_to_le16(index);
2004         cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
2005         cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
2006
2007         /* send command to mc*/
2008         return mc_send_command(mc_io, &cmd);
2009 }
2010
2011 /**
2012  * dpni_remove_qos_entry() - Remove QoS mapping entry
2013  * @mc_io:      Pointer to MC portal's I/O object
2014  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
2015  * @token:      Token of DPNI object
2016  * @cfg:        QoS rule to remove
2017  *
2018  * Return:      '0' on Success; Error code otherwise.
2019  */
2020 int dpni_remove_qos_entry(struct fsl_mc_io *mc_io,
2021                           u32 cmd_flags,
2022                           u16 token,
2023                           const struct dpni_rule_cfg *cfg)
2024 {
2025         struct dpni_cmd_remove_qos_entry *cmd_params;
2026         struct fsl_mc_command cmd = { 0 };
2027
2028         /* prepare command */
2029         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_QOS_ENT,
2030                                           cmd_flags,
2031                                           token);
2032         cmd_params = (struct dpni_cmd_remove_qos_entry *)cmd.params;
2033         cmd_params->key_size = cfg->key_size;
2034         cmd_params->key_iova = cpu_to_le64(cfg->key_iova);
2035         cmd_params->mask_iova = cpu_to_le64(cfg->mask_iova);
2036
2037         /* send command to mc*/
2038         return mc_send_command(mc_io, &cmd);
2039 }
2040
2041 /**
2042  * dpni_clear_qos_table() - Clear all QoS mapping entries
2043  * @mc_io:      Pointer to MC portal's I/O object
2044  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
2045  * @token:      Token of DPNI object
2046  *
2047  * Following this function call, all frames are directed to
2048  * the default traffic class (0)
2049  *
2050  * Return:      '0' on Success; Error code otherwise.
2051  */
2052 int dpni_clear_qos_table(struct fsl_mc_io *mc_io,
2053                          u32 cmd_flags,
2054                          u16 token)
2055 {
2056         struct fsl_mc_command cmd = { 0 };
2057
2058         /* prepare command */
2059         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLR_QOS_TBL,
2060                                           cmd_flags,
2061                                           token);
2062
2063         /* send command to mc*/
2064         return mc_send_command(mc_io, &cmd);
2065 }
2066
2067 /**
2068  * dpni_set_tx_shaping() - Set the transmit shaping
2069  * @mc_io:              Pointer to MC portal's I/O object
2070  * @cmd_flags:          Command flags; one or more of 'MC_CMD_FLAG_'
2071  * @token:              Token of DPNI object
2072  * @tx_cr_shaper:       TX committed rate shaping configuration
2073  * @tx_er_shaper:       TX excess rate shaping configuration
2074  * @coupled:            Committed and excess rate shapers are coupled
2075  *
2076  * Return:      '0' on Success; Error code otherwise.
2077  */
2078 int dpni_set_tx_shaping(struct fsl_mc_io *mc_io,
2079                         u32 cmd_flags,
2080                         u16 token,
2081                         const struct dpni_tx_shaping_cfg *tx_cr_shaper,
2082                         const struct dpni_tx_shaping_cfg *tx_er_shaper,
2083                         int coupled)
2084 {
2085         struct dpni_cmd_set_tx_shaping *cmd_params;
2086         struct fsl_mc_command cmd = { 0 };
2087
2088         /* prepare command */
2089         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_SHAPING,
2090                                           cmd_flags,
2091                                           token);
2092         cmd_params = (struct dpni_cmd_set_tx_shaping *)cmd.params;
2093         cmd_params->tx_cr_max_burst_size = cpu_to_le16(tx_cr_shaper->max_burst_size);
2094         cmd_params->tx_er_max_burst_size = cpu_to_le16(tx_er_shaper->max_burst_size);
2095         cmd_params->tx_cr_rate_limit = cpu_to_le32(tx_cr_shaper->rate_limit);
2096         cmd_params->tx_er_rate_limit = cpu_to_le32(tx_er_shaper->rate_limit);
2097         dpni_set_field(cmd_params->coupled, COUPLED, coupled);
2098
2099         /* send command to mc*/
2100         return mc_send_command(mc_io, &cmd);
2101 }
2102
2103 /**
2104  * dpni_get_single_step_cfg() - return current configuration for
2105  *                              single step PTP
2106  * @mc_io:      Pointer to MC portal's I/O object
2107  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
2108  * @token:      Token of DPNI object
2109  * @ptp_cfg:    ptp single step configuration
2110  *
2111  * Return:      '0' on Success; Error code otherwise.
2112  *
2113  */
2114 int dpni_get_single_step_cfg(struct fsl_mc_io *mc_io,
2115                              u32 cmd_flags,
2116                              u16 token,
2117                              struct dpni_single_step_cfg *ptp_cfg)
2118 {
2119         struct dpni_rsp_single_step_cfg *rsp_params;
2120         struct fsl_mc_command cmd = { 0 };
2121         int err;
2122
2123         /* prepare command */
2124         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_SINGLE_STEP_CFG,
2125                                           cmd_flags, token);
2126         /* send command to mc*/
2127         err =  mc_send_command(mc_io, &cmd);
2128         if (err)
2129                 return err;
2130
2131         /* read command response */
2132         rsp_params = (struct dpni_rsp_single_step_cfg *)cmd.params;
2133         ptp_cfg->offset = le16_to_cpu(rsp_params->offset);
2134         ptp_cfg->en = dpni_get_field(le16_to_cpu(rsp_params->flags),
2135                                      PTP_ENABLE) ? 1 : 0;
2136         ptp_cfg->ch_update = dpni_get_field(le16_to_cpu(rsp_params->flags),
2137                                             PTP_CH_UPDATE) ? 1 : 0;
2138         ptp_cfg->peer_delay = le32_to_cpu(rsp_params->peer_delay);
2139
2140         return err;
2141 }
2142
2143 /**
2144  * dpni_set_single_step_cfg() - enable/disable and configure single step PTP
2145  * @mc_io:      Pointer to MC portal's I/O object
2146  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
2147  * @token:      Token of DPNI object
2148  * @ptp_cfg:    ptp single step configuration
2149  *
2150  * Return:      '0' on Success; Error code otherwise.
2151  *
2152  * The function has effect only when dpni object is connected to a dpmac
2153  * object. If the dpni is not connected to a dpmac the configuration will
2154  * be stored inside and applied when connection is made.
2155  */
2156 int dpni_set_single_step_cfg(struct fsl_mc_io *mc_io,
2157                              u32 cmd_flags,
2158                              u16 token,
2159                              struct dpni_single_step_cfg *ptp_cfg)
2160 {
2161         struct dpni_cmd_single_step_cfg *cmd_params;
2162         struct fsl_mc_command cmd = { 0 };
2163         u16 flags;
2164
2165         /* prepare command */
2166         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_SINGLE_STEP_CFG,
2167                                           cmd_flags, token);
2168         cmd_params = (struct dpni_cmd_single_step_cfg *)cmd.params;
2169         cmd_params->offset = cpu_to_le16(ptp_cfg->offset);
2170         cmd_params->peer_delay = cpu_to_le32(ptp_cfg->peer_delay);
2171
2172         flags = le16_to_cpu(cmd_params->flags);
2173         dpni_set_field(flags, PTP_ENABLE, !!ptp_cfg->en);
2174         dpni_set_field(flags, PTP_CH_UPDATE, !!ptp_cfg->ch_update);
2175         cmd_params->flags = cpu_to_le16(flags);
2176
2177         /* send command to mc*/
2178         return mc_send_command(mc_io, &cmd);
2179 }