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 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
 448 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
 449                       uint32_t cmd_flags,
 450                       uint16_t token,
 451                       const struct dpni_link_cfg *cfg)
 452 {
 453         struct mc_command cmd = { 0 };
 454
 455         /* prepare command */
 456         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
 457                                           cmd_flags,
 458                                           token);
 459         DPNI_CMD_SET_LINK_CFG(cmd, cfg);
 460
 461         /* send command to mc*/
 462         return mc_send_command(mc_io, &cmd);
 463 }
 464
 465 int dpni_get_link_state(struct fsl_mc_io *mc_io,
 466                         uint32_t cmd_flags,
 467                         uint16_t token,
 468                         struct dpni_link_state *state)
 469 {
 470         struct mc_command cmd = { 0 };
 471         int err;
 472
 473         /* prepare command */
 474         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
 475                                           cmd_flags,
 476                                           token);
 477
 478         /* send command to mc*/
 479         err = mc_send_command(mc_io, &cmd);
 480         if (err)
 481                 return err;
 482
 483         /* retrieve response parameters */
 484         DPNI_RSP_GET_LINK_STATE(cmd, state);
 485
 486         return 0;
 487 }
 488
 489 int dpni_set_max_frame_length(struct fsl_mc_io *mc_io,
 490                               uint32_t cmd_flags,
 491                               uint16_t token,
 492                               uint16_t max_frame_length)
 493 {
 494         struct mc_command cmd = { 0 };
 495
 496         /* prepare command */
 497         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MAX_FRAME_LENGTH,
 498                                           cmd_flags,
 499                                           token);
 500         DPNI_CMD_SET_MAX_FRAME_LENGTH(cmd, max_frame_length);
 501
 502         /* send command to mc*/
 503         return mc_send_command(mc_io, &cmd);
 504 }
 505
 506 int dpni_get_max_frame_length(struct fsl_mc_io *mc_io,
 507                               uint32_t cmd_flags,
 508                               uint16_t token,
 509                               uint16_t *max_frame_length)
 510 {
 511         struct mc_command cmd = { 0 };
 512         int err;
 513
 514         /* prepare command */
 515         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MAX_FRAME_LENGTH,
 516                                           cmd_flags,
 517                                           token);
 518
 519         /* send command to mc*/
 520         err = mc_send_command(mc_io, &cmd);
 521         if (err)
 522                 return err;
 523
 524         /* retrieve response parameters */
 525         DPNI_RSP_GET_MAX_FRAME_LENGTH(cmd, *max_frame_length);
 526
 527         return 0;
 528 }
 529
 530 int dpni_set_multicast_promisc(struct fsl_mc_io *mc_io,
 531                                uint32_t cmd_flags,
 532                                uint16_t token,
 533                                int en)
 534 {
 535         struct mc_command cmd = { 0 };
 536
 537         /* prepare command */
 538         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_MCAST_PROMISC,
 539                                           cmd_flags,
 540                                           token);
 541         DPNI_CMD_SET_MULTICAST_PROMISC(cmd, en);
 542
 543         /* send command to mc*/
 544         return mc_send_command(mc_io, &cmd);
 545 }
 546
 547 int dpni_get_multicast_promisc(struct fsl_mc_io *mc_io,
 548                                uint32_t cmd_flags,
 549                                uint16_t token,
 550                                int *en)
 551 {
 552         struct mc_command cmd = { 0 };
 553         int err;
 554
 555         /* prepare command */
 556         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_MCAST_PROMISC,
 557                                           cmd_flags,
 558                                           token);
 559
 560         /* send command to mc*/
 561         err = mc_send_command(mc_io, &cmd);
 562         if (err)
 563                 return err;
 564
 565         /* retrieve response parameters */
 566         DPNI_RSP_GET_MULTICAST_PROMISC(cmd, *en);
 567
 568         return 0;
 569 }
 570
 571 int dpni_set_unicast_promisc(struct fsl_mc_io *mc_io,
 572                              uint32_t cmd_flags,
 573                              uint16_t token,
 574                              int en)
 575 {
 576         struct mc_command cmd = { 0 };
 577
 578         /* prepare command */
 579         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_UNICAST_PROMISC,
 580                                           cmd_flags,
 581                                           token);
 582         DPNI_CMD_SET_UNICAST_PROMISC(cmd, en);
 583
 584         /* send command to mc*/
 585         return mc_send_command(mc_io, &cmd);
 586 }
 587
 588 int dpni_get_unicast_promisc(struct fsl_mc_io *mc_io,
 589                              uint32_t cmd_flags,
 590                              uint16_t token,
 591                              int *en)
 592 {
 593         struct mc_command cmd = { 0 };
 594         int err;
 595
 596         /* prepare command */
 597         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_UNICAST_PROMISC,
 598                                           cmd_flags,
 599                                           token);
 600
 601         /* send command to mc*/
 602         err = mc_send_command(mc_io, &cmd);
 603         if (err)
 604                 return err;
 605
 606         /* retrieve response parameters */
 607         DPNI_RSP_GET_UNICAST_PROMISC(cmd, *en);
 608
 609         return 0;
 610 }
 611
 612 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
 613                               uint32_t cmd_flags,
 614                               uint16_t token,
 615                               const uint8_t mac_addr[6])
 616 {
 617         struct mc_command cmd = { 0 };
 618
 619         /* prepare command */
 620         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
 621                                           cmd_flags,
 622                                           token);
 623         DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
 624
 625         /* send command to mc*/
 626         return mc_send_command(mc_io, &cmd);
 627 }
 628
 629 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
 630                               uint32_t cmd_flags,
 631                               uint16_t token,
 632                               uint8_t mac_addr[6])
 633 {
 634         struct mc_command cmd = { 0 };
 635         int err;
 636
 637         /* prepare command */
 638         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
 639                                           cmd_flags,
 640                                           token);
 641
 642         /* send command to mc*/
 643         err = mc_send_command(mc_io, &cmd);
 644         if (err)
 645                 return err;
 646
 647         /* retrieve response parameters */
 648         DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
 649
 650         return 0;
 651 }
 652
 653 int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
 654                       uint32_t cmd_flags,
 655                       uint16_t token,
 656                       const uint8_t mac_addr[6])
 657 {
 658         struct mc_command cmd = { 0 };
 659
 660         /* prepare command */
 661         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
 662                                           cmd_flags,
 663                                           token);
 664         DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr);
 665
 666         /* send command to mc*/
 667         return mc_send_command(mc_io, &cmd);
 668 }
 669
 670 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
 671                          uint32_t cmd_flags,
 672                          uint16_t token,
 673                          const uint8_t mac_addr[6])
 674 {
 675         struct mc_command cmd = { 0 };
 676
 677         /* prepare command */
 678         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
 679                                           cmd_flags,
 680                                           token);
 681         DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr);
 682
 683         /* send command to mc*/
 684         return mc_send_command(mc_io, &cmd);
 685 }
 686
 687 int dpni_clear_mac_filters(struct fsl_mc_io *mc_io,
 688                            uint32_t cmd_flags,
 689                            uint16_t token,
 690                            int unicast,
 691                            int multicast)
 692 {
 693         struct mc_command cmd = { 0 };
 694
 695         /* prepare command */
 696         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLR_MAC_FILTERS,
 697                                           cmd_flags,
 698                                           token);
 699         DPNI_CMD_CLEAR_MAC_FILTERS(cmd, unicast, multicast);
 700
 701         /* send command to mc*/
 702         return mc_send_command(mc_io, &cmd);
 703 }
 704
 705 int dpni_get_port_mac_addr(struct fsl_mc_io *mc_io,
 706                            uint32_t cmd_flags,
 707                            uint16_t token,
 708                            uint8_t mac_addr[6])
 709 {
 710         struct mc_command cmd = { 0 };
 711         int err;
 712
 713         /* prepare command */
 714         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PORT_MAC_ADDR,
 715                                           cmd_flags,
 716                                           token);
 717
 718         /* send command to mc*/
 719         err = mc_send_command(mc_io, &cmd);
 720         if (err)
 721                 return err;
 722
 723         /* retrieve response parameters */
 724         DPNI_RSP_GET_PORT_MAC_ADDR(cmd, mac_addr);
 725
 726         return 0;
 727 }
 728
 729 int dpni_enable_vlan_filter(struct fsl_mc_io *mc_io,
 730                             uint32_t cmd_flags,
 731                           uint16_t token,
 732                           int en)
 733 {
 734         struct mc_command cmd = { 0 };
 735
 736         /* prepare command */
 737         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE_VLAN_FILTER,
 738                                           cmd_flags,
 739                                           token);
 740         DPNI_CMD_ENABLE_VLAN_FILTER(cmd, en);
 741
 742         /* send command to mc*/
 743         return mc_send_command(mc_io, &cmd);
 744 }
 745
 746 int dpni_add_vlan_id(struct fsl_mc_io *mc_io,
 747                      uint32_t cmd_flags,
 748                      uint16_t token,
 749                      uint16_t vlan_id)
 750 {
 751         struct mc_command cmd = { 0 };
 752
 753         /* prepare command */
 754         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_VLAN_ID,
 755                                           cmd_flags,
 756                                           token);
 757         DPNI_CMD_ADD_VLAN_ID(cmd, vlan_id);
 758
 759         /* send command to mc*/
 760         return mc_send_command(mc_io, &cmd);
 761 }
 762
 763 int dpni_remove_vlan_id(struct fsl_mc_io *mc_io,
 764                         uint32_t cmd_flags,
 765                         uint16_t token,
 766                         uint16_t vlan_id)
 767 {
 768         struct mc_command cmd = { 0 };
 769
 770         /* prepare command */
 771         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_VLAN_ID,
 772                                           cmd_flags,
 773                                           token);
 774         DPNI_CMD_REMOVE_VLAN_ID(cmd, vlan_id);
 775
 776         /* send command to mc*/
 777         return mc_send_command(mc_io, &cmd);
 778 }
 779
 780 int dpni_clear_vlan_filters(struct fsl_mc_io *mc_io,
 781                             uint32_t cmd_flags,
 782                             uint16_t token)
 783 {
 784         struct mc_command cmd = { 0 };
 785
 786         /* prepare command */
 787         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLR_VLAN_FILTERS,
 788                                           cmd_flags,
 789                                           token);
 790
 791         /* send command to mc*/
 792         return mc_send_command(mc_io, &cmd);
 793 }
 794
 795 int dpni_set_rx_tc_dist(struct fsl_mc_io *mc_io,
 796                         uint32_t cmd_flags,
 797                         uint16_t token,
 798                         uint8_t tc_id,
 799                         const struct dpni_rx_tc_dist_cfg *cfg)
 800 {
 801         struct mc_command cmd = { 0 };
 802
 803         /* prepare command */
 804         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_TC_DIST,
 805                                           cmd_flags,
 806                                           token);
 807         DPNI_CMD_SET_RX_TC_DIST(cmd, tc_id, cfg);
 808
 809         /* send command to mc*/
 810         return mc_send_command(mc_io, &cmd);
 811 }
 812
 813 int dpni_set_tx_confirmation_mode(struct fsl_mc_io      *mc_io,
 814                                   uint32_t              cmd_flags,
 815                             uint16_t            token,
 816                             enum dpni_confirmation_mode mode)
 817 {
 818         struct mc_command cmd = { 0 };
 819
 820         /* prepare command */
 821         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
 822                                           cmd_flags,
 823                                           token);
 824         DPNI_CMD_SET_TX_CONFIRMATION_MODE(cmd, mode);
 825
 826         /* send command to mc*/
 827         return mc_send_command(mc_io, &cmd);
 828 }
 829
 830 int dpni_set_congestion_notification(
 831                         struct fsl_mc_io        *mc_io,
 832                         uint32_t                cmd_flags,
 833                         uint16_t                token,
 834                         enum dpni_queue_type qtype,
 835                         uint8_t         tc_id,
 836                         const struct dpni_congestion_notification_cfg *cfg)
 837 {
 838         struct mc_command cmd = { 0 };
 839
 840         /* prepare command */
 841         cmd.header = mc_encode_cmd_header(
 842                         DPNI_CMDID_SET_CONGESTION_NOTIFICATION,
 843                         cmd_flags,
 844                         token);
 845         DPNI_CMD_SET_CONGESTION_NOTIFICATION(cmd, qtype, tc_id, cfg);
 846
 847         /* send command to mc*/
 848         return mc_send_command(mc_io, &cmd);
 849 }
 850
 851 int dpni_get_congestion_notification(struct fsl_mc_io   *mc_io,
 852                                      uint32_t           cmd_flags,
 853                                            uint16_t             token,
 854                                      enum dpni_queue_type qtype,
 855                                            uint8_t              tc_id,
 856                                 struct dpni_congestion_notification_cfg *cfg)
 857 {
 858         struct mc_command cmd = { 0 };
 859         int err;
 860
 861         /* prepare command */
 862         cmd.header = mc_encode_cmd_header(
 863                         DPNI_CMDID_GET_CONGESTION_NOTIFICATION,
 864                         cmd_flags,
 865                         token);
 866         DPNI_CMD_GET_CONGESTION_NOTIFICATION(cmd, qtype, tc_id);
 867
 868         /* send command to mc*/
 869         err = mc_send_command(mc_io, &cmd);
 870         if (err)
 871                 return err;
 872
 873         DPNI_RSP_GET_CONGESTION_NOTIFICATION(cmd, cfg);
 874
 875         return 0;
 876 }
 877
 878 int dpni_get_api_version(struct fsl_mc_io *mc_io,
 879                          uint32_t cmd_flags,
 880                            uint16_t *major_ver,
 881                            uint16_t *minor_ver)
 882 {
 883         struct mc_command cmd = { 0 };
 884         int err;
 885
 886         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
 887                                         cmd_flags,
 888                                         0);
 889
 890         err = mc_send_command(mc_io, &cmd);
 891         if (err)
 892                 return err;
 893
 894         DPNI_RSP_GET_API_VERSION(cmd, *major_ver, *minor_ver);
 895
 896         return 0;
 897 }
 898
 899 int dpni_set_queue(struct fsl_mc_io *mc_io,
 900                    uint32_t cmd_flags,
 901                      uint16_t token,
 902                    enum dpni_queue_type qtype,
 903                          uint8_t tc,
 904                          uint8_t index,
 905                    uint8_t options,
 906                      const struct dpni_queue *queue)
 907 {
 908         struct mc_command cmd = { 0 };
 909
 910         /* prepare command */
 911         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
 912                                           cmd_flags,
 913                                           token);
 914         DPNI_CMD_SET_QUEUE(cmd, qtype, tc, index, options, queue);
 915
 916         /* send command to mc*/
 917         return mc_send_command(mc_io, &cmd);
 918 }
 919
 920 int dpni_get_queue(struct fsl_mc_io *mc_io,
 921                    uint32_t cmd_flags,
 922                      uint16_t token,
 923                    enum dpni_queue_type qtype,
 924                          uint8_t tc,
 925                          uint8_t index,
 926                    struct dpni_queue *queue,
 927                    struct dpni_queue_id *qid)
 928 {
 929         struct mc_command cmd = { 0 };
 930         int err;
 931
 932         /* prepare command */
 933         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
 934                                           cmd_flags,
 935                                           token);
 936         DPNI_CMD_GET_QUEUE(cmd, qtype, tc, index);
 937
 938         /* send command to mc*/
 939         err = mc_send_command(mc_io, &cmd);
 940         if (err)
 941                 return err;
 942
 943         /* retrieve response parameters */
 944         DPNI_RSP_GET_QUEUE(cmd, queue, qid);
 945
 946         return 0;
 947 }
 948
 949 int dpni_get_statistics(struct fsl_mc_io *mc_io,
 950                         uint32_t cmd_flags,
 951                         uint16_t token,
 952                         uint8_t page,
 953                         union dpni_statistics *stat)
 954 {
 955         struct mc_command cmd = { 0 };
 956         int err;
 957
 958         /* prepare command */
 959         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
 960                                           cmd_flags,
 961                                           token);
 962         DPNI_CMD_GET_STATISTICS(cmd, page);
 963
 964         /* send command to mc*/
 965         err = mc_send_command(mc_io, &cmd);
 966         if (err)
 967                 return err;
 968
 969         /* retrieve response parameters */
 970         DPNI_RSP_GET_STATISTICS(cmd, stat);
 971
 972         return 0;
 973 }
 974
 975 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
 976                           uint32_t cmd_flags,
 977                      uint16_t token)
 978 {
 979         struct mc_command cmd = { 0 };
 980
 981         /* prepare command */
 982         cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
 983                                           cmd_flags,
 984                                           token);
 985
 986         /* send command to mc*/
 987         return mc_send_command(mc_io, &cmd);
 988 }
 989
 990 int dpni_set_taildrop(struct fsl_mc_io *mc_io,
 991                       uint32_t cmd_flags,
 992                       uint16_t token,
 993                       enum dpni_congestion_point cg_point,
 994                       enum dpni_queue_type q_type,
 995                       uint8_t tc,
 996                       uint8_t q_index,
 997                       struct dpni_taildrop *taildrop)
 998 {
 999         struct mc_command cmd = { 0 };
1000
1001         /* prepare command */
1002         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TAILDROP,
1003                                           cmd_flags,
1004                                           token);
1005         DPNI_CMD_SET_TAILDROP(cmd, cg_point, q_type, tc, q_index, taildrop);
1006
1007         /* send command to mc*/
1008         return mc_send_command(mc_io, &cmd);
1009 }
1010
1011 int dpni_get_taildrop(struct fsl_mc_io *mc_io,
1012                       uint32_t cmd_flags,
1013                      uint16_t token,
1014                          enum dpni_congestion_point cg_point,
1015                          enum dpni_queue_type q_type,
1016                          uint8_t tc,
1017                          uint8_t q_index,
1018                          struct dpni_taildrop *taildrop)
1019 {
1020         struct mc_command cmd = { 0 };
1021         int err;
1022
1023         /* prepare command */
1024         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TAILDROP,
1025                                           cmd_flags,
1026                                           token);
1027         DPNI_CMD_GET_TAILDROP(cmd, cg_point, q_type, tc, q_index);
1028
1029         /* send command to mc*/
1030         err = mc_send_command(mc_io, &cmd);
1031         if (err)
1032                 return err;
1033
1034         /* retrieve response parameters */
1035         DPNI_RSP_GET_TAILDROP(cmd, taildrop);
1036
1037         return 0;
1038 }