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 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 } 1039