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