1 /* 2 * Copyright (C) 2013-2015 Freescale Semiconductor 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <fsl-mc/fsl_mc_sys.h> 8 #include <fsl-mc/fsl_mc_cmd.h> 9 #include <fsl-mc/fsl_dpni.h> 10 11 int dpni_prepare_extended_cfg(const struct dpni_extended_cfg *cfg, 12 uint8_t *ext_cfg_buf) 13 { 14 uint64_t *ext_params = (uint64_t *)ext_cfg_buf; 15 16 DPNI_PREP_EXTENDED_CFG(ext_params, cfg); 17 18 return 0; 19 } 20 21 int dpni_extract_extended_cfg(struct dpni_extended_cfg *cfg, 22 const uint8_t *ext_cfg_buf) 23 { 24 uint64_t *ext_params = (uint64_t *)ext_cfg_buf; 25 26 DPNI_EXT_EXTENDED_CFG(ext_params, cfg); 27 28 return 0; 29 } 30 31 int dpni_open(struct fsl_mc_io *mc_io, 32 uint32_t cmd_flags, 33 int dpni_id, 34 uint16_t *token) 35 { 36 struct mc_command cmd = { 0 }; 37 int err; 38 39 /* prepare command */ 40 cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN, 41 cmd_flags, 42 0); 43 DPNI_CMD_OPEN(cmd, dpni_id); 44 45 /* send command to mc*/ 46 err = mc_send_command(mc_io, &cmd); 47 if (err) 48 return err; 49 50 /* retrieve response parameters */ 51 *token = MC_CMD_HDR_READ_TOKEN(cmd.header); 52 53 return 0; 54 } 55 56 int dpni_close(struct fsl_mc_io *mc_io, 57 uint32_t cmd_flags, 58 uint16_t token) 59 { 60 struct mc_command cmd = { 0 }; 61 62 /* prepare command */ 63 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE, 64 cmd_flags, 65 token); 66 67 /* send command to mc*/ 68 return mc_send_command(mc_io, &cmd); 69 } 70 71 int dpni_create(struct fsl_mc_io *mc_io, 72 uint32_t cmd_flags, 73 const struct dpni_cfg *cfg, 74 uint16_t *token) 75 { 76 struct mc_command cmd = { 0 }; 77 int err; 78 79 /* prepare command */ 80 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE, 81 cmd_flags, 82 0); 83 DPNI_CMD_CREATE(cmd, cfg); 84 85 /* send command to mc*/ 86 err = mc_send_command(mc_io, &cmd); 87 if (err) 88 return err; 89 90 /* retrieve response parameters */ 91 *token = MC_CMD_HDR_READ_TOKEN(cmd.header); 92 93 return 0; 94 } 95 96 int dpni_destroy(struct fsl_mc_io *mc_io, 97 uint32_t cmd_flags, 98 uint16_t token) 99 { 100 struct mc_command cmd = { 0 }; 101 102 /* prepare command */ 103 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY, 104 cmd_flags, 105 token); 106 107 /* send command to mc*/ 108 return mc_send_command(mc_io, &cmd); 109 } 110 111 int dpni_set_pools(struct fsl_mc_io *mc_io, 112 uint32_t cmd_flags, 113 uint16_t token, 114 const struct dpni_pools_cfg *cfg) 115 { 116 struct mc_command cmd = { 0 }; 117 118 /* prepare command */ 119 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS, 120 cmd_flags, 121 token); 122 DPNI_CMD_SET_POOLS(cmd, cfg); 123 124 /* send command to mc*/ 125 return mc_send_command(mc_io, &cmd); 126 } 127 128 int dpni_enable(struct fsl_mc_io *mc_io, 129 uint32_t cmd_flags, 130 uint16_t token) 131 { 132 struct mc_command cmd = { 0 }; 133 134 /* prepare command */ 135 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE, 136 cmd_flags, 137 token); 138 139 /* send command to mc*/ 140 return mc_send_command(mc_io, &cmd); 141 } 142 143 int dpni_disable(struct fsl_mc_io *mc_io, 144 uint32_t cmd_flags, 145 uint16_t token) 146 { 147 struct mc_command cmd = { 0 }; 148 149 /* prepare command */ 150 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE, 151 cmd_flags, 152 token); 153 154 /* send command to mc*/ 155 return mc_send_command(mc_io, &cmd); 156 } 157 158 int dpni_reset(struct fsl_mc_io *mc_io, 159 uint32_t cmd_flags, 160 uint16_t token) 161 { 162 struct mc_command cmd = { 0 }; 163 164 /* prepare command */ 165 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET, 166 cmd_flags, 167 token); 168 169 /* send command to mc*/ 170 return mc_send_command(mc_io, &cmd); 171 } 172 173 int dpni_get_attributes(struct fsl_mc_io *mc_io, 174 uint32_t cmd_flags, 175 uint16_t token, 176 struct dpni_attr *attr) 177 { 178 struct mc_command cmd = { 0 }; 179 int err; 180 181 /* prepare command */ 182 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR, 183 cmd_flags, 184 token); 185 DPNI_CMD_GET_ATTR(cmd, attr); 186 187 /* send command to mc*/ 188 err = mc_send_command(mc_io, &cmd); 189 if (err) 190 return err; 191 192 /* retrieve response parameters */ 193 DPNI_RSP_GET_ATTR(cmd, attr); 194 195 return 0; 196 } 197 198 int dpni_set_errors_behavior(struct fsl_mc_io *mc_io, 199 uint32_t cmd_flags, 200 uint16_t token, 201 struct dpni_error_cfg *cfg) 202 { 203 struct mc_command cmd = { 0 }; 204 205 /* prepare command */ 206 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR, 207 cmd_flags, 208 token); 209 DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg); 210 211 /* send command to mc*/ 212 return mc_send_command(mc_io, &cmd); 213 } 214 215 int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io, 216 uint32_t cmd_flags, 217 uint16_t token, 218 struct dpni_buffer_layout *layout) 219 { 220 struct mc_command cmd = { 0 }; 221 int err; 222 223 /* prepare command */ 224 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_BUFFER_LAYOUT, 225 cmd_flags, 226 token); 227 228 /* send command to mc*/ 229 err = mc_send_command(mc_io, &cmd); 230 if (err) 231 return err; 232 233 /* retrieve response parameters */ 234 DPNI_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout); 235 236 return 0; 237 } 238 239 int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io, 240 uint32_t cmd_flags, 241 uint16_t token, 242 const struct dpni_buffer_layout *layout) 243 { 244 struct mc_command cmd = { 0 }; 245 246 /* prepare command */ 247 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_BUFFER_LAYOUT, 248 cmd_flags, 249 token); 250 DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout); 251 252 /* send command to mc*/ 253 return mc_send_command(mc_io, &cmd); 254 } 255 256 int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io, 257 uint32_t cmd_flags, 258 uint16_t token, 259 struct dpni_buffer_layout *layout) 260 { 261 struct mc_command cmd = { 0 }; 262 int err; 263 264 /* prepare command */ 265 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_BUFFER_LAYOUT, 266 cmd_flags, 267 token); 268 269 /* send command to mc*/ 270 err = mc_send_command(mc_io, &cmd); 271 if (err) 272 return err; 273 274 /* retrieve response parameters */ 275 DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout); 276 277 return 0; 278 } 279 280 int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io, 281 uint32_t cmd_flags, 282 uint16_t token, 283 const struct dpni_buffer_layout *layout) 284 { 285 struct mc_command cmd = { 0 }; 286 287 /* prepare command */ 288 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_BUFFER_LAYOUT, 289 cmd_flags, 290 token); 291 DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout); 292 293 /* send command to mc*/ 294 return mc_send_command(mc_io, &cmd); 295 } 296 297 int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io, 298 uint32_t cmd_flags, 299 uint16_t token, 300 struct dpni_buffer_layout *layout) 301 { 302 struct mc_command cmd = { 0 }; 303 int err; 304 305 /* prepare command */ 306 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT, 307 cmd_flags, 308 token); 309 310 /* send command to mc*/ 311 err = mc_send_command(mc_io, &cmd); 312 if (err) 313 return err; 314 315 /* retrieve response parameters */ 316 DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout); 317 318 return 0; 319 } 320 321 int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io, 322 uint32_t cmd_flags, 323 uint16_t token, 324 const struct dpni_buffer_layout *layout) 325 { 326 struct mc_command cmd = { 0 }; 327 328 /* prepare command */ 329 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT, 330 cmd_flags, 331 token); 332 DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout); 333 334 /* send command to mc*/ 335 return mc_send_command(mc_io, &cmd); 336 } 337 338 int dpni_get_qdid(struct fsl_mc_io *mc_io, 339 uint32_t cmd_flags, 340 uint16_t token, 341 uint16_t *qdid) 342 { 343 struct mc_command cmd = { 0 }; 344 int err; 345 346 /* prepare command */ 347 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID, 348 cmd_flags, 349 token); 350 351 /* send command to mc*/ 352 err = mc_send_command(mc_io, &cmd); 353 if (err) 354 return err; 355 356 /* retrieve response parameters */ 357 DPNI_RSP_GET_QDID(cmd, *qdid); 358 359 return 0; 360 } 361 362 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io, 363 uint32_t cmd_flags, 364 uint16_t token, 365 uint16_t *data_offset) 366 { 367 struct mc_command cmd = { 0 }; 368 int err; 369 370 /* prepare command */ 371 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET, 372 cmd_flags, 373 token); 374 375 /* send command to mc*/ 376 err = mc_send_command(mc_io, &cmd); 377 if (err) 378 return err; 379 380 /* retrieve response parameters */ 381 DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset); 382 383 return 0; 384 } 385 386 int dpni_get_counter(struct fsl_mc_io *mc_io, 387 uint32_t cmd_flags, 388 uint16_t token, 389 enum dpni_counter counter, 390 uint64_t *value) 391 { 392 struct mc_command cmd = { 0 }; 393 int err; 394 395 /* prepare command */ 396 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_COUNTER, 397 cmd_flags, 398 token); 399 DPNI_CMD_GET_COUNTER(cmd, counter); 400 401 /* send command to mc*/ 402 err = mc_send_command(mc_io, &cmd); 403 if (err) 404 return err; 405 406 /* retrieve response parameters */ 407 DPNI_RSP_GET_COUNTER(cmd, *value); 408 409 return 0; 410 } 411 412 int dpni_set_counter(struct fsl_mc_io *mc_io, 413 uint32_t cmd_flags, 414 uint16_t token, 415 enum dpni_counter counter, 416 uint64_t value) 417 { 418 struct mc_command cmd = { 0 }; 419 420 /* prepare command */ 421 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_COUNTER, 422 cmd_flags, 423 token); 424 DPNI_CMD_SET_COUNTER(cmd, counter, value); 425 426 /* send command to mc*/ 427 return mc_send_command(mc_io, &cmd); 428 } 429 430 int dpni_set_link_cfg(struct fsl_mc_io *mc_io, 431 uint32_t cmd_flags, 432 uint16_t token, 433 const struct dpni_link_cfg *cfg) 434 { 435 struct mc_command cmd = { 0 }; 436 437 /* prepare command */ 438 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG, 439 cmd_flags, 440 token); 441 DPNI_CMD_SET_LINK_CFG(cmd, cfg); 442 443 /* send command to mc*/ 444 return mc_send_command(mc_io, &cmd); 445 } 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 472 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io, 473 uint32_t cmd_flags, 474 uint16_t token, 475 const uint8_t mac_addr[6]) 476 { 477 struct mc_command cmd = { 0 }; 478 479 /* prepare command */ 480 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC, 481 cmd_flags, 482 token); 483 DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr); 484 485 /* send command to mc*/ 486 return mc_send_command(mc_io, &cmd); 487 } 488 489 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io, 490 uint32_t cmd_flags, 491 uint16_t token, 492 uint8_t mac_addr[6]) 493 { 494 struct mc_command cmd = { 0 }; 495 int err; 496 497 /* prepare command */ 498 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC, 499 cmd_flags, 500 token); 501 502 /* send command to mc*/ 503 err = mc_send_command(mc_io, &cmd); 504 if (err) 505 return err; 506 507 /* retrieve response parameters */ 508 DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr); 509 510 return 0; 511 } 512 513 int dpni_add_mac_addr(struct fsl_mc_io *mc_io, 514 uint32_t cmd_flags, 515 uint16_t token, 516 const uint8_t mac_addr[6]) 517 { 518 struct mc_command cmd = { 0 }; 519 520 /* prepare command */ 521 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR, 522 cmd_flags, 523 token); 524 DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr); 525 526 /* send command to mc*/ 527 return mc_send_command(mc_io, &cmd); 528 } 529 530 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io, 531 uint32_t cmd_flags, 532 uint16_t token, 533 const uint8_t mac_addr[6]) 534 { 535 struct mc_command cmd = { 0 }; 536 537 /* prepare command */ 538 cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR, 539 cmd_flags, 540 token); 541 DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr); 542 543 /* send command to mc*/ 544 return mc_send_command(mc_io, &cmd); 545 } 546 547 int dpni_set_tx_flow(struct fsl_mc_io *mc_io, 548 uint32_t cmd_flags, 549 uint16_t token, 550 uint16_t *flow_id, 551 const struct dpni_tx_flow_cfg *cfg) 552 { 553 struct mc_command cmd = { 0 }; 554 int err; 555 556 /* prepare command */ 557 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_FLOW, 558 cmd_flags, 559 token); 560 DPNI_CMD_SET_TX_FLOW(cmd, *flow_id, cfg); 561 562 /* send command to mc*/ 563 err = mc_send_command(mc_io, &cmd); 564 if (err) 565 return err; 566 567 /* retrieve response parameters */ 568 DPNI_RSP_SET_TX_FLOW(cmd, *flow_id); 569 570 return 0; 571 } 572 573 int dpni_get_tx_flow(struct fsl_mc_io *mc_io, 574 uint32_t cmd_flags, 575 uint16_t token, 576 uint16_t flow_id, 577 struct dpni_tx_flow_attr *attr) 578 { 579 struct mc_command cmd = { 0 }; 580 int err; 581 582 /* prepare command */ 583 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_FLOW, 584 cmd_flags, 585 token); 586 DPNI_CMD_GET_TX_FLOW(cmd, flow_id); 587 588 /* send command to mc*/ 589 err = mc_send_command(mc_io, &cmd); 590 if (err) 591 return err; 592 593 /* retrieve response parameters */ 594 DPNI_RSP_GET_TX_FLOW(cmd, attr); 595 596 return 0; 597 } 598 599 int dpni_set_rx_flow(struct fsl_mc_io *mc_io, 600 uint32_t cmd_flags, 601 uint16_t token, 602 uint8_t tc_id, 603 uint16_t flow_id, 604 const struct dpni_queue_cfg *cfg) 605 { 606 struct mc_command cmd = { 0 }; 607 608 /* prepare command */ 609 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FLOW, 610 cmd_flags, 611 token); 612 DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg); 613 614 /* send command to mc*/ 615 return mc_send_command(mc_io, &cmd); 616 } 617 618 int dpni_get_rx_flow(struct fsl_mc_io *mc_io, 619 uint32_t cmd_flags, 620 uint16_t token, 621 uint8_t tc_id, 622 uint16_t flow_id, 623 struct dpni_queue_attr *attr) 624 { 625 struct mc_command cmd = { 0 }; 626 int err; 627 /* prepare command */ 628 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_FLOW, 629 cmd_flags, 630 token); 631 DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id); 632 633 /* send command to mc*/ 634 err = mc_send_command(mc_io, &cmd); 635 if (err) 636 return err; 637 638 /* retrieve response parameters */ 639 DPNI_RSP_GET_RX_FLOW(cmd, attr); 640 641 return 0; 642 } 643 644 int dpni_set_tx_conf(struct fsl_mc_io *mc_io, 645 uint32_t cmd_flags, 646 uint16_t token, 647 uint16_t flow_id, 648 const struct dpni_tx_conf_cfg *cfg) 649 { 650 struct mc_command cmd = { 0 }; 651 652 /* prepare command */ 653 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF, 654 cmd_flags, 655 token); 656 DPNI_CMD_SET_TX_CONF(cmd, flow_id, cfg); 657 658 /* send command to mc*/ 659 return mc_send_command(mc_io, &cmd); 660 } 661 662 int dpni_get_tx_conf(struct fsl_mc_io *mc_io, 663 uint32_t cmd_flags, 664 uint16_t token, 665 uint16_t flow_id, 666 struct dpni_tx_conf_attr *attr) 667 { 668 struct mc_command cmd = { 0 }; 669 int err; 670 671 /* prepare command */ 672 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF, 673 cmd_flags, 674 token); 675 DPNI_CMD_GET_TX_CONF(cmd, flow_id); 676 677 /* send command to mc*/ 678 err = mc_send_command(mc_io, &cmd); 679 if (err) 680 return err; 681 682 DPNI_RSP_GET_TX_CONF(cmd, attr); 683 684 return 0; 685 } 686