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