linux/drivers/net/ethernet/freescale/dpaa2/dpni.c
<<
>>
Prefs
   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 */
  23int 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 */
  95int 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 */
 134int 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 */
 161int 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 */
 196int 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 */
 219int 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 */
 243int 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 */
 277int 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 */
 307int 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 */
 338int 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 */
 385int 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 */
 419int 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 */
 461int 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 */
 504int 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 */
 534int 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 */
 582int 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 */
 613int 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 */
 661int 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
 703int 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
 722int 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 */
 764int 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 */
 803int 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 */
 838int 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 */
 867int 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 */
 903int 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 */
 942int 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 */
 972int 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 */
1007int 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 */
1035int 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 */
1070int 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 */
1098int 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 */
1133int 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 */
1163int 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 */
1202int 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 */
1238int 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 */
1276int 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 */
1305int 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 */
1331int 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 */
1361int 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 */
1394int 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 */
1428int 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 */
1465int 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 */
1515int 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 */
1563int 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 */
1620int 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 */
1666int 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 */
1710int 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 */
1757int 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 */
1801int 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 */
1836int 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 */
1873int 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 */
1913int 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 */
1951int 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 */
1986int 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 */
2020int 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 */
2052int 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 */
2078int 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 */
2114int 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 */
2156int 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}
2180
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.