drivers/net/dpaa2/mc/dpni.c

   1 /*-
   2  * This file is provided under a dual BSD/GPLv2 license. When using or
   3  * redistributing this file, you may do so under either license.
   4  *
   5  *   BSD LICENSE
   6  *
   7  * Copyright 2013-2016 Freescale Semiconductor Inc.
   8  * Copyright (c) 2016 NXP.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  * * Redistributions of source code must retain the above copyright
  13  * notice, this list of conditions and the following disclaimer.
  14  * * Redistributions in binary form must reproduce the above copyright
  15  * notice, this list of conditions and the following disclaimer in the
  16  * documentation and/or other materials provided with the distribution.
  17  * * Neither the name of the above-listed copyright holders nor the
  18  * names of any contributors may be used to endorse or promote products
  19  * derived from this software without specific prior written permission.
  20  *
  21  *   GPL LICENSE SUMMARY
  22  *
  23  * ALTERNATIVELY, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") as published by the Free Software
  25  * Foundation, either version 2 of that License or (at your option) any
  26  * later version.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40 #include <fsl_mc_sys.h>
  41 #include <fsl_mc_cmd.h>
  42 #include <fsl_dpni.h>
  43 #include <fsl_dpni_cmd.h>
  44
  45 int dpni_prepare_key_cfg(const struct dpkg_profile_cfg *cfg,
  46                          uint8_t *key_cfg_buf)
  47 {
  48         int i, j;
  49         int offset = 0;
  50         int param = 1;
  51         uint64_t *params = (uint64_t *)key_cfg_buf;
  52
  53         if (!key_cfg_buf || !cfg)
  54                 return -EINVAL;
  55
  56         params[0] |= mc_enc(0, 8, cfg->num_extracts);
  57         params[0] = cpu_to_le64(params[0]);
  58
  59         if (cfg->num_extracts >= DPKG_MAX_NUM_OF_EXTRACTS)
  60                 return -EINVAL;
  61
  62         for (i = 0; i < cfg->num_extracts; i++) {
  63                 switch (cfg->extracts[i].type) {
  64                 case DPKG_EXTRACT_FROM_HDR:
  65                         params[param] |= mc_enc(0, 8,
  66                                         cfg->extracts[i].extract.from_hdr.prot);
  67                         params[param] |= mc_enc(8, 4,
  68                                         cfg->extracts[i].extract.from_hdr.type);
  69                         params[param] |= mc_enc(16, 8,
  70                                         cfg->extracts[i].extract.from_hdr.size);
  71                         params[param] |= mc_enc(24, 8,
  72                                         cfg->extracts[i].extract.
  73                                         from_hdr.offset);
  74                         params[param] |= mc_enc(32, 32,
  75                                         cfg->extracts[i].extract.
  76                                         from_hdr.field);
  77                         params[param] = cpu_to_le64(params[param]);
  78                         param++;
  79                         params[param] |= mc_enc(0, 8,
  80                                         cfg->extracts[i].extract.
  81                                         from_hdr.hdr_index);
  82                         break;
  83                 case DPKG_EXTRACT_FROM_DATA:
  84                         params[param] |= mc_enc(16, 8,
  85                                         cfg->extracts[i].extract.
  86                                         from_data.size);
  87                         params[param] |= mc_enc(24, 8,
  88                                         cfg->extracts[i].extract.
  89                                         from_data.offset);
  90                         params[param] = cpu_to_le64(params[param]);
  91                         param++;
  92                         break;
  93                 case DPKG_EXTRACT_FROM_PARSE:
  94                         params[param] |= mc_enc(16, 8,
  95                                         cfg->extracts[i].extract.
  96                                         from_parse.size);
  97                         params[param] |= mc_enc(24, 8,
  98                                         cfg->extracts[i].extract.
  99                                         from_parse.offset);
 100                         params[param] = cpu_to_le64(params[param]);
 101                         param++;
 102                         break;
 103                 default:
 104                         return -EINVAL;
 105                 }
 106                 params[param] |= mc_enc(
 107                         24, 8, cfg->extracts[i].num_of_byte_masks);
 108                 params[param] |= mc_enc(32, 4, cfg->extracts[i].type);
 109                 params[param] = cpu_to_le64(params[param]);
 110                 param++;
 111                 for (offset = 0, j = 0;
 112                         j < DPKG_NUM_OF_MASKS;
 113                         offset += 16, j++) {
 114                         params[param] |= mc_enc(
 115                                 (offset), 8, cfg->extracts[i].masks[j].mask);
 116                         params[param] |= mc_enc(
 117                                 (offset + 8), 8,
 118                                 cfg->extracts[i].masks[j].offset);
 119                 }
 120                 params[param] = cpu_to_le64(params[param]);
 121                 param++;
 122         }
 123         return 0;
 124 }
 125
 126 int dpni_open(struct fsl_mc_io *mc_io,
 127               uint32_t cmd_flags,
 128               int dpni_id,
 129               uint16_t *token)
 130 {
 131         struct mc_command cmd = { 0 };
 132         int err;
 133
 134         /* prepare command */
 135         cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
 136                                           cmd_flags,
 137                                           0);
 138         DPNI_CMD_OPEN(cmd, dpni_id);
 139
 140         /* send command to mc*/
 141         err = mc_send_command(mc_io, &cmd);
 142         if (err)
 143                 return err;
 144
 145         /* retrieve response parameters */
 146         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
 147
 148         return 0;
 149 }
 150
 151 int dpni_close(struct fsl_mc_io *mc_io,
 152                uint32_t cmd_flags,
 153                uint16_t token)
 154 {
 155         struct mc_command cmd = { 0 };
 156
 157         /* prepare command */
 158         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
 159                                           cmd_flags,
 160                                           token);
 161
 162         /* send command to mc*/
 163         return mc_send_command(mc_io, &cmd);
 164 }
 165
 166 int dpni_create(struct fsl_mc_io        *mc_io,
 167                 uint16_t        dprc_token,
 168                 uint32_t        cmd_flags,
 169                 const struct dpni_cfg   *cfg,
 170                 uint32_t        *obj_id)
 171 {
 172         struct mc_command cmd = { 0 };
 173         int err;
 174
 175         /* prepare command */
 176         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
 177                                           cmd_flags,
 178                                           dprc_token);
 179         DPNI_CMD_CREATE(cmd, cfg);
 180
 181         /* send command to mc*/
 182         err = mc_send_command(mc_io, &cmd);
 183         if (err)
 184                 return err;
 185
 186         /* retrieve response parameters */
 187         CMD_CREATE_RSP_GET_OBJ_ID_PARAM0(cmd, *obj_id);
 188
 189         return 0;
 190 }
 191
 192 int dpni_destroy(struct fsl_mc_io       *mc_io,
 193                  uint16_t       dprc_token,
 194                 uint32_t        cmd_flags,
 195                 uint32_t        object_id)
 196 {
 197         struct mc_command cmd = { 0 };
 198
 199         /* prepare command */
 200         cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
 201                                           cmd_flags,
 202                                           dprc_token);
 203         /* set object id to destroy */
 204         CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id);
 205         /* send command to mc*/
 206         return mc_send_command(mc_io, &cmd);
 207 }
 208
 209 int dpni_set_pools(struct fsl_mc_io *mc_io,
 210                    uint32_t cmd_flags,
 211                    uint16_t token,
 212                    const struct dpni_pools_cfg *cfg)
 213 {
 214         struct mc_command cmd = { 0 };
 215
 216         /* prepare command */
 217         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
 218                                           cmd_flags,
 219                                           token);
 220         DPNI_CMD_SET_POOLS(cmd, cfg);
 221
 222         /* send command to mc*/
 223         return mc_send_command(mc_io, &cmd);
 224 }
 225
 226 int dpni_enable(struct fsl_mc_io *mc_io,
 227                 uint32_t cmd_flags,
 228                 uint16_t token)
 229 {
 230         struct mc_command cmd = { 0 };
 231
 232         /* prepare command */
 233         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
 234                                           cmd_flags,
 235                                           token);
 236
 237         /* send command to mc*/
 238         return mc_send_command(mc_io, &cmd);
 239 }
 240
 241 int dpni_disable(struct fsl_mc_io *mc_io,
 242                  uint32_t cmd_flags,
 243                  uint16_t token)
 244 {
 245         struct mc_command cmd = { 0 };
 246
 247         /* prepare command */
 248         cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
 249                                           cmd_flags,
 250                                           token);
 251
 252         /* send command to mc*/
 253         return mc_send_command(mc_io, &cmd);
 254 }
 255
 256 int dpni_is_enabled(struct fsl_mc_io *mc_io,
 257                     uint32_t cmd_flags,
 258                     uint16_t token,
 259                     int *en)
 260 {
 261         struct mc_command cmd = { 0 };
 262         int err;
 263         /* prepare command */
 264         cmd.header = mc_encode_cmd_header(DPNI_CMDID_IS_ENABLED, cmd_flags,
 265                                           token);
 266
 267         /* send command to mc*/
 268         err = mc_send_command(mc_io, &cmd);
 269         if (err)
 270                 return err;
 271
 272         /* retrieve response parameters */
 273         DPNI_RSP_IS_ENABLED(cmd, *en);
 274
 275         return 0;
 276 }
 277
 278 int dpni_reset(struct fsl_mc_io *mc_io,
 279                uint32_t cmd_flags,
 280                uint16_t token)
 281 {
 282         struct mc_command cmd = { 0 };
 283
 284         /* prepare command */
 285         cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
 286                                           cmd_flags,
 287                                           token);
 288
 289         /* send command to mc*/
 290         return mc_send_command(mc_io, &cmd);
 291 }
 292
 293 int dpni_get_attributes(struct fsl_mc_io *mc_io,
 294                         uint32_t cmd_flags,
 295                         uint16_t token,
 296                         struct dpni_attr *attr)
 297 {
 298         struct mc_command cmd = { 0 };
 299         int err;
 300
 301         /* prepare command */
 302         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
 303                                           cmd_flags,
 304                                           token);
 305
 306         /* send command to mc*/
 307         err = mc_send_command(mc_io, &cmd);
 308         if (err)
 309                 return err;
 310
 311         /* retrieve response parameters */
 312         DPNI_RSP_GET_ATTR(cmd, attr);
 313
 314         return 0;
 315 }
 316
 317 int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
 318                              uint32_t cmd_flags,
 319                              uint16_t token,
 320                               struct dpni_error_cfg *cfg)
 321 {
 322         struct mc_command cmd = { 0 };
 323
 324         /* prepare command */
 325         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR,
 326                                           cmd_flags,
 327                                           token);
 328         DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg);
 329
 330         /* send command to mc*/
 331         return mc_send_command(mc_io, &cmd);
 332 }
 333
 334 int dpni_get_buffer_layout(struct fsl_mc_io *mc_io,
 335                            uint32_t cmd_flags,
 336                            uint16_t token,
 337                            enum dpni_queue_type qtype,
 338                            struct dpni_buffer_layout *layout)
 339 {
 340         struct mc_command cmd = { 0 };
 341         int err;
 342
 343         /* prepare command */
 344         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_BUFFER_LAYOUT,
 345                                           cmd_flags,
 346                                           token);
 347         DPNI_CMD_GET_BUFFER_LAYOUT(cmd, qtype);
 348
 349         /* send command to mc*/
 350         err = mc_send_command(mc_io, &cmd);
 351         if (err)
 352                 return err;
 353
 354         /* retrieve response parameters */
 355         DPNI_RSP_GET_BUFFER_LAYOUT(cmd, layout);
 356
 357         return 0;
 358 }
 359
 360 int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
 361                            uint32_t cmd_flags,
 362                               uint16_t token,
 363                               enum dpni_queue_type qtype,
 364                               const struct dpni_buffer_layout *layout)
 365 {
 366         struct mc_command cmd = { 0 };
 367
 368         /* prepare command */
 369         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
 370                                           cmd_flags,
 371                                           token);
 372         DPNI_CMD_SET_BUFFER_LAYOUT(cmd, qtype, layout);
 373
 374         /* send command to mc*/
 375         return mc_send_command(mc_io, &cmd);
 376 }
 377
 378 int dpni_set_offload(struct fsl_mc_io *mc_io,
 379                      uint32_t cmd_flags,
 380                      uint16_t token,
 381                      enum dpni_offload type,
 382                      uint32_t config)
 383 {
 384         struct mc_command cmd = { 0 };
 385
 386         /* prepare command */
 387         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_OFFLOAD,
 388                                           cmd_flags,
 389                                           token);
 390         DPNI_CMD_SET_OFFLOAD(cmd, type, config);
 391
 392         /* send command to mc*/
 393         return mc_send_command(mc_io, &cmd);
 394 }
 395
 396 int dpni_get_offload(struct fsl_mc_io *mc_io,
 397                      uint32_t cmd_flags,
 398                      uint16_t token,
 399                      enum dpni_offload type,
 400                      uint32_t *config)
 401 {
 402         struct mc_command cmd = { 0 };
 403         int err;
 404
 405         /* prepare command */
 406         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_OFFLOAD,
 407                                           cmd_flags,
 408                                           token);
 409         DPNI_CMD_GET_OFFLOAD(cmd, type);
 410
 411         /* send command to mc*/
 412         err = mc_send_command(mc_io, &cmd);
 413         if (err)
 414                 return err;
 415
 416         /* retrieve response parameters */
 417         DPNI_RSP_GET_OFFLOAD(cmd, *config);
 418
 419         return 0;
 420 }
 421
 422 int dpni_get_qdid(struct fsl_mc_io *mc_io,
 423                   uint32_t cmd_flags,
 424                   uint16_t token,
 425                   enum dpni_queue_type qtype,
 426                   uint16_t *qdid)
 427 {
 428         struct mc_command cmd = { 0 };
 429         int err;
 430
 431         /* prepare command */
 432         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
 433                                           cmd_flags,
 434                                           token);
 435         DPNI_CMD_GET_QDID(cmd, qtype);
 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         DPNI_RSP_GET_QDID(cmd, *qdid);
 444
 445         return 0;
 446 }
 447 int dpni_get_link_state(struct fsl_mc_io *mc_io,
 448                         uint32_t cmd_flags,
 449                         uint16_t token,
 450                         struct dpni_link_state *state)
 451 {
 452         struct mc_command cmd = { 0 };
 453         int err;
 454
 455         /* prepare command */
 456         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
 457                                           cmd_flags,
 458                                           token);
 459
 460         /* send command to mc*/
 461         err = mc_send_command(mc_io, &cmd);
 462         if (err)
 463                 return err;
 464
 465         /* retrieve response parameters */
 466         DPNI_RSP_GET_LINK_STATE(cmd, state);
 467
 468         return 0;
 469 }
 470
 471 int dpni_set_max_frame_length(struct fsl_mc_io *mc_io,
 472                               uint32_t cmd_flags,
 473                               uint16_t token,
 474                               uint16_t max_frame_length)
 475 {
 476         struct mc_command cmd = { 0 };
 477
 478         /* prepare command */
 479         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MAX_FRAME_LENGTH,
 480                                           cmd_flags,
 481                                           token);
 482         DPNI_CMD_SET_MAX_FRAME_LENGTH(cmd, max_frame_length);
 483
 484         /* send command to mc*/
 485         return mc_send_command(mc_io, &cmd);
 486 }
 487
 488 int dpni_get_max_frame_length(struct fsl_mc_io *mc_io,
 489                               uint32_t cmd_flags,
 490                               uint16_t token,
 491                               uint16_t *max_frame_length)
 492 {
 493         struct mc_command cmd = { 0 };
 494         int err;
 495
 496         /* prepare command */
 497         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MAX_FRAME_LENGTH,
 498                                           cmd_flags,
 499                                           token);
 500
 501         /* send command to mc*/
 502         err = mc_send_command(mc_io, &cmd);
 503         if (err)
 504                 return err;
 505
 506         /* retrieve response parameters */
 507         DPNI_RSP_GET_MAX_FRAME_LENGTH(cmd, *max_frame_length);
 508
 509         return 0;
 510 }
 511
 512 int dpni_set_unicast_promisc(struct fsl_mc_io *mc_io,
 513                              uint32_t cmd_flags,
 514                              uint16_t token,
 515                              int en)
 516 {
 517         struct mc_command cmd = { 0 };
 518
 519         /* prepare command */
 520         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_UNICAST_PROMISC,
 521                                           cmd_flags,
 522                                           token);
 523         DPNI_CMD_SET_UNICAST_PROMISC(cmd, en);
 524
 525         /* send command to mc*/
 526         return mc_send_command(mc_io, &cmd);
 527 }
 528
 529 int dpni_get_unicast_promisc(struct fsl_mc_io *mc_io,
 530                              uint32_t cmd_flags,
 531                              uint16_t token,
 532                              int *en)
 533 {
 534         struct mc_command cmd = { 0 };
 535         int err;
 536
 537         /* prepare command */
 538         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_UNICAST_PROMISC,
 539                                           cmd_flags,
 540                                           token);
 541
 542         /* send command to mc*/
 543         err = mc_send_command(mc_io, &cmd);
 544         if (err)
 545                 return err;
 546
 547         /* retrieve response parameters */
 548         DPNI_RSP_GET_UNICAST_PROMISC(cmd, *en);
 549
 550         return 0;
 551 }
 552
 553 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
 554                               uint32_t cmd_flags,
 555                               uint16_t token,
 556                               const uint8_t mac_addr[6])
 557 {
 558         struct mc_command cmd = { 0 };
 559
 560         /* prepare command */
 561         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
 562                                           cmd_flags,
 563                                           token);
 564         DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
 565
 566         /* send command to mc*/
 567         return mc_send_command(mc_io, &cmd);
 568 }
 569
 570 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
 571                               uint32_t cmd_flags,
 572                               uint16_t token,
 573                               uint8_t mac_addr[6])
 574 {
 575         struct mc_command cmd = { 0 };
 576         int err;
 577
 578         /* prepare command */
 579         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
 580                                           cmd_flags,
 581                                           token);
 582
 583         /* send command to mc*/
 584         err = mc_send_command(mc_io, &cmd);
 585         if (err)
 586                 return err;
 587
 588         /* retrieve response parameters */
 589         DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
 590
 591         return 0;
 592 }
 593
 594 int dpni_set_rx_tc_dist(struct fsl_mc_io *mc_io,
 595                         uint32_t cmd_flags,
 596                         uint16_t token,
 597                         uint8_t tc_id,
 598                         const struct dpni_rx_tc_dist_cfg *cfg)
 599 {
 600         struct mc_command cmd = { 0 };
 601
 602         /* prepare command */
 603         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_TC_DIST,
 604                                           cmd_flags,
 605                                           token);
 606         DPNI_CMD_SET_RX_TC_DIST(cmd, tc_id, cfg);
 607
 608         /* send command to mc*/
 609         return mc_send_command(mc_io, &cmd);
 610 }
 611
 612 int dpni_set_tx_confirmation_mode(struct fsl_mc_io      *mc_io,
 613                                   uint32_t              cmd_flags,
 614                             uint16_t            token,
 615                             enum dpni_confirmation_mode mode)
 616 {
 617         struct mc_command cmd = { 0 };
 618
 619         /* prepare command */
 620         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
 621                                           cmd_flags,
 622                                           token);
 623         DPNI_CMD_SET_TX_CONFIRMATION_MODE(cmd, mode);
 624
 625         /* send command to mc*/
 626         return mc_send_command(mc_io, &cmd);
 627 }
 628
 629 int dpni_get_api_version(struct fsl_mc_io *mc_io,
 630                          uint32_t cmd_flags,
 631                            uint16_t *major_ver,
 632                            uint16_t *minor_ver)
 633 {
 634         struct mc_command cmd = { 0 };
 635         int err;
 636
 637         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
 638                                         cmd_flags,
 639                                         0);
 640
 641         err = mc_send_command(mc_io, &cmd);
 642         if (err)
 643                 return err;
 644
 645         DPNI_RSP_GET_API_VERSION(cmd, *major_ver, *minor_ver);
 646
 647         return 0;
 648 }
 649
 650 int dpni_set_queue(struct fsl_mc_io *mc_io,
 651                    uint32_t cmd_flags,
 652                      uint16_t token,
 653                    enum dpni_queue_type qtype,
 654                          uint8_t tc,
 655                          uint8_t index,
 656                    uint8_t options,
 657                      const struct dpni_queue *queue)
 658 {
 659         struct mc_command cmd = { 0 };
 660
 661         /* prepare command */
 662         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
 663                                           cmd_flags,
 664                                           token);
 665         DPNI_CMD_SET_QUEUE(cmd, qtype, tc, index, options, queue);
 666
 667         /* send command to mc*/
 668         return mc_send_command(mc_io, &cmd);
 669 }
 670
 671 int dpni_get_queue(struct fsl_mc_io *mc_io,
 672                    uint32_t cmd_flags,
 673                      uint16_t token,
 674                    enum dpni_queue_type qtype,
 675                          uint8_t tc,
 676                          uint8_t index,
 677                    struct dpni_queue *queue,
 678                    struct dpni_queue_id *qid)
 679 {
 680         struct mc_command cmd = { 0 };
 681         int err;
 682
 683         /* prepare command */
 684         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
 685                                           cmd_flags,
 686                                           token);
 687         DPNI_CMD_GET_QUEUE(cmd, qtype, tc, index);
 688
 689         /* send command to mc*/
 690         err = mc_send_command(mc_io, &cmd);
 691         if (err)
 692                 return err;
 693
 694         /* retrieve response parameters */
 695         DPNI_RSP_GET_QUEUE(cmd, queue, qid);
 696
 697         return 0;
 698 }
 699
 700 int dpni_get_statistics(struct fsl_mc_io *mc_io,
 701                         uint32_t cmd_flags,
 702                         uint16_t token,
 703                         uint8_t page,
 704                         union dpni_statistics *stat)
 705 {
 706         struct mc_command cmd = { 0 };
 707         int err;
 708
 709         /* prepare command */
 710         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
 711                                           cmd_flags,
 712                                           token);
 713         DPNI_CMD_GET_STATISTICS(cmd, page);
 714
 715         /* send command to mc*/
 716         err = mc_send_command(mc_io, &cmd);
 717         if (err)
 718                 return err;
 719
 720         /* retrieve response parameters */
 721         DPNI_RSP_GET_STATISTICS(cmd, stat);
 722
 723         return 0;
 724 }
 725
 726 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
 727                           uint32_t cmd_flags,
 728                      uint16_t token)
 729 {
 730         struct mc_command cmd = { 0 };
 731
 732         /* prepare command */
 733         cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
 734                                           cmd_flags,
 735                                           token);
 736
 737         /* send command to mc*/
 738         return mc_send_command(mc_io, &cmd);
 739 }