portmod_dispatch.c (590366B)
1 /* 2 * 3 * 4 * 5 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 6 * 7 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 8 * 9 * 10 * DO NOT EDIT THIS FILE! 11 */ 12 13 #include <soc/types.h> 14 #include <soc/error.h> 15 #include <soc/portmod/portmod_internal.h> 16 #include <soc/portmod/portmod.h> 17 #include <soc/portmod/portmod_dispatch.h> 18 19 20 21 #ifdef _ERR_MSG_MODULE_NAME 22 #error "_ERR_MSG_MODULE_NAME redefined" 23 #endif 24 #define _ERR_MSG_MODULE_NAME BSL_LS_SOC_PORT 25 26 #ifdef PORTMOD_PM4X25_SUPPORT 27 extern __portmod__dispatch__t__ portmod_pm4x25_driver; 28 #endif 29 #ifdef PORTMOD_PM4X10_SUPPORT 30 extern __portmod__dispatch__t__ portmod_pm4x10_driver; 31 #endif 32 #ifdef PORTMOD_PM4X10TD_SUPPORT 33 extern __portmod__dispatch__t__ portmod_pm4x10td_driver; 34 #endif 35 #ifdef PORTMOD_PM12X10_SUPPORT 36 extern __portmod__dispatch__t__ portmod_pm12x10_driver; 37 #endif 38 #ifdef PORTMOD_PM4x10Q_SUPPORT 39 extern __portmod__dispatch__t__ portmod_pm4x10Q_driver; 40 #endif 41 #ifdef PORTMOD_PM_QTC_SUPPORT 42 extern __portmod__dispatch__t__ portmod_pm_qtc_driver; 43 #endif 44 #ifdef PORTMOD_PM_OS_ILKN_SUPPORT 45 extern __portmod__dispatch__t__ portmod_pmOsILKN_driver; 46 #endif 47 #ifdef PORTMOD_PM_OS_ILKN_50G_SUPPORT 48 extern __portmod__dispatch__t__ portmod_pmOsILKN_50G_driver; 49 #endif 50 #ifdef PORTMOD_DNX_FABRIC_SUPPORT 51 extern __portmod__dispatch__t__ portmod_dnx_fabric_driver; 52 #endif 53 #ifdef PORTMOD_DNX_FABRIC_O_NIF_SUPPORT 54 extern __portmod__dispatch__t__ portmod_dnx_fabric_o_nif_driver; 55 #endif 56 #ifdef PORTMOD_PM8X50_FABRIC_SUPPORT 57 extern __portmod__dispatch__t__ portmod_pm8x50_fabric_driver; 58 #endif 59 #ifdef PORTMOD_PM4X25TD_SUPPORT 60 extern __portmod__dispatch__t__ portmod_pm4x25td_driver; 61 #endif 62 #ifdef PORTMOD_PM12X10_XGS_SUPPORT 63 extern __portmod__dispatch__t__ portmod_pm12x10_xgs_driver; 64 #endif 65 #ifdef PORTMOD_PM4X2P5_SUPPORT 66 extern __portmod__dispatch__t__ portmod_pm4x2p5_driver; 67 #endif 68 #ifdef PORTMOD_CPM4X25_SUPPORT 69 extern __portmod__dispatch__t__ portmod_cpm4x25_driver; 70 #endif 71 #ifdef PORTMOD_PM8X50_SUPPORT 72 extern __portmod__dispatch__t__ portmod_pm8x50_driver; 73 #endif 74 #ifdef PORTMOD_PM4X10_QTC_SUPPORT 75 extern __portmod__dispatch__t__ portmod_pm4x10_qtc_driver; 76 #endif 77 #ifdef PORTMOD_PMNULL_SUPPORT 78 extern __portmod__dispatch__t__ portmod_pmNull_driver; 79 #endif 80 81 __portmod__dispatch__t__* __portmod__dispatch__[portmodDispatchTypeCount] = { 82 #ifdef PORTMOD_PM4X25_SUPPORT 83 &portmod_pm4x25_driver, 84 #endif 85 #ifdef PORTMOD_PM4X10_SUPPORT 86 &portmod_pm4x10_driver, 87 #endif 88 #ifdef PORTMOD_PM4X10TD_SUPPORT 89 &portmod_pm4x10td_driver, 90 #endif 91 #ifdef PORTMOD_PM12X10_SUPPORT 92 &portmod_pm12x10_driver, 93 #endif 94 #ifdef PORTMOD_PM4x10Q_SUPPORT 95 &portmod_pm4x10Q_driver, 96 #endif 97 #ifdef PORTMOD_PM_QTC_SUPPORT 98 &portmod_pm_qtc_driver, 99 #endif 100 #ifdef PORTMOD_PM_OS_ILKN_SUPPORT 101 &portmod_pmOsILKN_driver, 102 #endif 103 #ifdef PORTMOD_PM_OS_ILKN_50G_SUPPORT 104 &portmod_pmOsILKN_50G_driver, 105 #endif 106 #ifdef PORTMOD_DNX_FABRIC_SUPPORT 107 &portmod_dnx_fabric_driver, 108 #endif 109 #ifdef PORTMOD_DNX_FABRIC_O_NIF_SUPPORT 110 &portmod_dnx_fabric_o_nif_driver, 111 #endif 112 #ifdef PORTMOD_PM8X50_FABRIC_SUPPORT 113 &portmod_pm8x50_fabric_driver, 114 #endif 115 #ifdef PORTMOD_PM4X25TD_SUPPORT 116 &portmod_pm4x25td_driver, 117 #endif 118 #ifdef PORTMOD_PM12X10_XGS_SUPPORT 119 &portmod_pm12x10_xgs_driver, 120 #endif 121 #ifdef PORTMOD_PM4X2P5_SUPPORT 122 &portmod_pm4x2p5_driver, 123 #endif 124 #ifdef PORTMOD_CPM4X25_SUPPORT 125 &portmod_cpm4x25_driver, 126 #endif 127 #ifdef PORTMOD_PM8X50_SUPPORT 128 &portmod_pm8x50_driver, 129 #endif 130 #ifdef PORTMOD_PM4X10_QTC_SUPPORT 131 &portmod_pm4x10_qtc_driver, 132 #endif 133 #ifdef PORTMOD_PMNULL_SUPPORT 134 &portmod_pmNull_driver, 135 #endif 136 137 }; 138 139 int portmod_dispatch_type_t_validate(int unit, portmod_dispatch_type_t portmod_dispatch_type) 140 { 141 SOC_INIT_FUNC_DEFS; 142 if(portmod_dispatch_type >= portmodDispatchTypeCount) { 143 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 144 } 145 146 exit: 147 SOC_FUNC_RETURN; 148 149 } 150 151 int portmod_default_user_access_t_validate(int unit, const portmod_default_user_access_t* portmod_default_user_access) 152 { 153 SOC_INIT_FUNC_DEFS; 154 if(portmod_default_user_access == NULL) { 155 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 156 } 157 158 159 160 exit: 161 SOC_FUNC_RETURN; 162 163 } 164 165 int portmod_default_user_access_t_init(int unit, portmod_default_user_access_t* portmod_default_user_access) 166 { 167 SOC_INIT_FUNC_DEFS; 168 169 if(portmod_default_user_access == NULL){ 170 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_default_user_access NULL parameter")); 171 } 172 sal_memset(portmod_default_user_access, 0, sizeof(portmod_default_user_access_t)); 173 portmod_default_user_access->unit = -1; 174 portmod_default_user_access->blk_id = -1; 175 portmod_default_user_access->mutex = NULL; 176 portmod_default_user_access->flags = 0; 177 178 179 exit: 180 SOC_FUNC_RETURN; 181 182 } 183 184 int portmod_pm4x10q_user_data_t_validate(int unit, const portmod_pm4x10q_user_data_t* portmod_pm4x10q_user_data) 185 { 186 SOC_INIT_FUNC_DEFS; 187 if(portmod_pm4x10q_user_data == NULL) { 188 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 189 } 190 191 if(SOC_E_NONE != portmod_default_user_access_t_validate(unit, &portmod_pm4x10q_user_data->qsgmiie_user_data)) { 192 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("qsgmiie_user_data validation failed")); 193 } 194 195 196 197 exit: 198 SOC_FUNC_RETURN; 199 200 } 201 202 int portmod_pm4x10q_user_data_t_init(int unit, portmod_pm4x10q_user_data_t* portmod_pm4x10q_user_data) 203 { 204 SOC_INIT_FUNC_DEFS; 205 206 if(portmod_pm4x10q_user_data == NULL){ 207 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm4x10q_user_data NULL parameter")); 208 } 209 sal_memset(portmod_pm4x10q_user_data, 0, sizeof(portmod_pm4x10q_user_data_t)); 210 if(SOC_E_NONE != portmod_default_user_access_t_init(unit, &portmod_pm4x10q_user_data->qsgmiie_user_data)) { 211 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("qsgmiie_user_data initialization failed")); 212 } 213 214 215 216 exit: 217 SOC_FUNC_RETURN; 218 219 } 220 221 int portmod_fifo_status_t_validate(int unit, const portmod_fifo_status_t* portmod_fifo_status) 222 { 223 SOC_INIT_FUNC_DEFS; 224 if(portmod_fifo_status == NULL) { 225 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 226 } 227 228 229 230 exit: 231 SOC_FUNC_RETURN; 232 233 } 234 235 int portmod_fifo_status_t_init(int unit, portmod_fifo_status_t* portmod_fifo_status) 236 { 237 SOC_INIT_FUNC_DEFS; 238 239 if(portmod_fifo_status == NULL){ 240 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_fifo_status NULL parameter")); 241 } 242 sal_memset(portmod_fifo_status, 0, sizeof(portmod_fifo_status_t)); 243 portmod_fifo_status->timestamps_in_fifo = 0; 244 portmod_fifo_status->timestamps_in_fifo_hi = 0; 245 portmod_fifo_status->sequence_id = 0; 246 portmod_fifo_status->timestamp_sub_nanosec = 0; 247 248 249 exit: 250 SOC_FUNC_RETURN; 251 252 } 253 254 int portmod_pfc_config_t_validate(int unit, const portmod_pfc_config_t* portmod_pfc_config) 255 { 256 SOC_INIT_FUNC_DEFS; 257 if(portmod_pfc_config == NULL) { 258 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 259 } 260 261 262 263 exit: 264 SOC_FUNC_RETURN; 265 266 } 267 268 int portmod_pfc_config_t_init(int unit, portmod_pfc_config_t* portmod_pfc_config) 269 { 270 SOC_INIT_FUNC_DEFS; 271 272 if(portmod_pfc_config == NULL){ 273 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pfc_config NULL parameter")); 274 } 275 sal_memset(portmod_pfc_config, 0, sizeof(portmod_pfc_config_t)); 276 portmod_pfc_config->type = 0; 277 portmod_pfc_config->opcode = 0; 278 portmod_pfc_config->classes = 0; 279 portmod_pfc_config->da_oui = 0; 280 portmod_pfc_config->da_nonoui = 0; 281 portmod_pfc_config->rxpass = 0; 282 283 284 exit: 285 SOC_FUNC_RETURN; 286 287 } 288 289 int portmod_eee_t_validate(int unit, const portmod_eee_t* portmod_eee) 290 { 291 SOC_INIT_FUNC_DEFS; 292 if(portmod_eee == NULL) { 293 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 294 } 295 296 297 298 exit: 299 SOC_FUNC_RETURN; 300 301 } 302 303 int portmod_eee_t_init(int unit, portmod_eee_t* portmod_eee) 304 { 305 SOC_INIT_FUNC_DEFS; 306 307 if(portmod_eee == NULL){ 308 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_eee NULL parameter")); 309 } 310 sal_memset(portmod_eee, 0, sizeof(portmod_eee_t)); 311 portmod_eee->enable = 0; 312 portmod_eee->tx_idle_time = 0; 313 portmod_eee->tx_wake_time = 0; 314 315 316 exit: 317 SOC_FUNC_RETURN; 318 319 } 320 321 int portmod_eee_clock_t_validate(int unit, const portmod_eee_clock_t* portmod_eee_clock) 322 { 323 SOC_INIT_FUNC_DEFS; 324 if(portmod_eee_clock == NULL) { 325 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 326 } 327 328 329 330 exit: 331 SOC_FUNC_RETURN; 332 333 } 334 335 int portmod_eee_clock_t_init(int unit, portmod_eee_clock_t* portmod_eee_clock) 336 { 337 SOC_INIT_FUNC_DEFS; 338 339 if(portmod_eee_clock == NULL){ 340 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_eee_clock NULL parameter")); 341 } 342 sal_memset(portmod_eee_clock, 0, sizeof(portmod_eee_clock_t)); 343 portmod_eee_clock->clock_gate = 0; 344 portmod_eee_clock->clock_count = 0; 345 portmod_eee_clock->timer_pulse = 0; 346 347 348 exit: 349 SOC_FUNC_RETURN; 350 351 } 352 353 int portmod_vlan_tag_t_validate(int unit, const portmod_vlan_tag_t* portmod_vlan_tag) 354 { 355 SOC_INIT_FUNC_DEFS; 356 if(portmod_vlan_tag == NULL) { 357 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 358 } 359 360 361 362 exit: 363 SOC_FUNC_RETURN; 364 365 } 366 367 int portmod_vlan_tag_t_init(int unit, portmod_vlan_tag_t* portmod_vlan_tag) 368 { 369 SOC_INIT_FUNC_DEFS; 370 371 if(portmod_vlan_tag == NULL){ 372 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_vlan_tag NULL parameter")); 373 } 374 sal_memset(portmod_vlan_tag, 0, sizeof(portmod_vlan_tag_t)); 375 portmod_vlan_tag->inner_vlan_tag = 0; 376 portmod_vlan_tag->outer_vlan_tag = 0; 377 378 379 exit: 380 SOC_FUNC_RETURN; 381 382 } 383 384 int portmod_rx_control_t_validate(int unit, const portmod_rx_control_t* portmod_rx_control) 385 { 386 SOC_INIT_FUNC_DEFS; 387 if(portmod_rx_control == NULL) { 388 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 389 } 390 391 392 393 exit: 394 SOC_FUNC_RETURN; 395 396 } 397 398 int portmod_rx_control_t_init(int unit, portmod_rx_control_t* portmod_rx_control) 399 { 400 SOC_INIT_FUNC_DEFS; 401 402 if(portmod_rx_control == NULL){ 403 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_rx_control NULL parameter")); 404 } 405 sal_memset(portmod_rx_control, 0, sizeof(portmod_rx_control_t)); 406 portmod_rx_control->flags = 0; 407 portmod_rx_control->pass_control_frames = 0; 408 portmod_rx_control->pass_pfc_frames = 0; 409 portmod_rx_control->pass_pause_frames = 0; 410 411 412 exit: 413 SOC_FUNC_RETURN; 414 415 } 416 417 int portmod_multi_get_t_validate(int unit, const portmod_multi_get_t* portmod_multi_get) 418 { 419 SOC_INIT_FUNC_DEFS; 420 if(portmod_multi_get == NULL) { 421 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 422 } 423 424 425 426 exit: 427 SOC_FUNC_RETURN; 428 429 } 430 431 int portmod_multi_get_t_init(int unit, portmod_multi_get_t* portmod_multi_get) 432 { 433 SOC_INIT_FUNC_DEFS; 434 435 if(portmod_multi_get == NULL){ 436 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_multi_get NULL parameter")); 437 } 438 sal_memset(portmod_multi_get, 0, sizeof(portmod_multi_get_t)); 439 portmod_multi_get->flags = 0; 440 portmod_multi_get->dev_addr = 0; 441 portmod_multi_get->offset = 0; 442 portmod_multi_get->max_size = 0; 443 444 445 exit: 446 SOC_FUNC_RETURN; 447 448 } 449 450 int portmod_loopback_mode_t_validate(int unit, portmod_loopback_mode_t portmod_loopback_mode) 451 { 452 SOC_INIT_FUNC_DEFS; 453 if(portmod_loopback_mode >= portmodLoopbackCount) { 454 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 455 } 456 457 exit: 458 SOC_FUNC_RETURN; 459 460 } 461 462 int portmod_core_port_mode_t_validate(int unit, portmod_core_port_mode_t portmod_core_port_mode) 463 { 464 SOC_INIT_FUNC_DEFS; 465 if(portmod_core_port_mode >= portmodPortModeCount) { 466 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 467 } 468 469 exit: 470 SOC_FUNC_RETURN; 471 472 } 473 474 int portmod_port_mode_aux_info_t_validate(int unit, portmod_port_mode_aux_info_t portmod_port_mode_aux_info) 475 { 476 SOC_INIT_FUNC_DEFS; 477 if(portmod_port_mode_aux_info >= portmodModeInfoCount) { 478 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 479 } 480 481 exit: 482 SOC_FUNC_RETURN; 483 484 } 485 486 int portmod_prbs_mode_t_validate(int unit, portmod_prbs_mode_t portmod_prbs_mode) 487 { 488 SOC_INIT_FUNC_DEFS; 489 if(portmod_prbs_mode >= portmodPrbsModeCount) { 490 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 491 } 492 493 exit: 494 SOC_FUNC_RETURN; 495 496 } 497 498 int portmod_ext_to_int_phy_ctrlcode_t_validate(int unit, portmod_ext_to_int_phy_ctrlcode_t portmod_ext_to_int_phy_ctrlcode) 499 { 500 SOC_INIT_FUNC_DEFS; 501 if(portmod_ext_to_int_phy_ctrlcode >= portmodExtToInt_CtrlCode_Count) { 502 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 503 } 504 505 exit: 506 SOC_FUNC_RETURN; 507 508 } 509 510 int portmod_cpm_core_mode_t_validate(int unit, portmod_cpm_core_mode_t portmod_cpm_core_mode) 511 { 512 SOC_INIT_FUNC_DEFS; 513 if(portmod_cpm_core_mode >= portmodCpmCount) { 514 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 515 } 516 517 exit: 518 SOC_FUNC_RETURN; 519 520 } 521 522 int portmod_core_port_enet_cpri_type_t_validate(int unit, portmod_core_port_enet_cpri_type_t portmod_core_port_enet_cpri_type) 523 { 524 SOC_INIT_FUNC_DEFS; 525 if(portmod_core_port_enet_cpri_type >= portmodCpmPrtCount) { 526 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 527 } 528 529 exit: 530 SOC_FUNC_RETURN; 531 532 } 533 534 int portmod_portphy_ability_t_validate(int unit, const portmod_portphy_ability_t* portmod_portphy_ability) 535 { 536 SOC_INIT_FUNC_DEFS; 537 if(portmod_portphy_ability == NULL) { 538 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 539 } 540 541 542 543 exit: 544 SOC_FUNC_RETURN; 545 546 } 547 548 int portmod_portphy_ability_t_init(int unit, portmod_portphy_ability_t* portmod_portphy_ability) 549 { 550 SOC_INIT_FUNC_DEFS; 551 552 if(portmod_portphy_ability == NULL){ 553 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_portphy_ability NULL parameter")); 554 } 555 sal_memset(portmod_portphy_ability, 0, sizeof(portmod_portphy_ability_t)); 556 portmod_portphy_ability->cur_mode = 0; 557 portmod_portphy_ability->speed_half_duplex = 0; 558 portmod_portphy_ability->speed_full_duplex = 0; 559 portmod_portphy_ability->pause = 0; 560 portmod_portphy_ability->interface = 0; 561 portmod_portphy_ability->medium = 0; 562 portmod_portphy_ability->loopback = 0; 563 portmod_portphy_ability->flags = 0; 564 portmod_portphy_ability->eee = 0; 565 portmod_portphy_ability->fcmap = 0; 566 portmod_portphy_ability->encap = 0; 567 568 569 exit: 570 SOC_FUNC_RETURN; 571 572 } 573 574 int portmod_pdata_t_validate(int unit, const portmod_pdata_t* portmod_pdata) 575 { 576 SOC_INIT_FUNC_DEFS; 577 if(portmod_pdata == NULL) { 578 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 579 } 580 581 582 583 exit: 584 SOC_FUNC_RETURN; 585 586 } 587 588 int portmod_pdata_t_init(int unit, portmod_pdata_t* portmod_pdata) 589 { 590 SOC_INIT_FUNC_DEFS; 591 592 if(portmod_pdata == NULL){ 593 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pdata NULL parameter")); 594 } 595 sal_memset(portmod_pdata, 0, sizeof(portmod_pdata_t)); 596 portmod_pdata->data = 0; 597 portmod_pdata->enable = 0; 598 portmod_pdata->pif = 0; 599 portmod_pdata->ability = 0; 600 601 602 exit: 603 SOC_FUNC_RETURN; 604 605 } 606 607 int portmod_port_mode_info_t_validate(int unit, const portmod_port_mode_info_t* portmod_port_mode_info) 608 { 609 SOC_INIT_FUNC_DEFS; 610 if(portmod_port_mode_info == NULL) { 611 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 612 } 613 614 if(SOC_E_NONE != portmod_core_port_mode_t_validate(unit, portmod_port_mode_info->cur_mode)) { 615 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cur_mode validation failed")); 616 } 617 618 619 620 exit: 621 SOC_FUNC_RETURN; 622 623 } 624 625 int portmod_port_mode_info_t_init(int unit, portmod_port_mode_info_t* portmod_port_mode_info) 626 { 627 SOC_INIT_FUNC_DEFS; 628 629 if(portmod_port_mode_info == NULL){ 630 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_mode_info NULL parameter")); 631 } 632 sal_memset(portmod_port_mode_info, 0, sizeof(portmod_port_mode_info_t)); 633 portmod_port_mode_info->cur_mode = 0; 634 portmod_port_mode_info->lanes = 0; 635 portmod_port_mode_info->port_index = 0; 636 637 638 exit: 639 SOC_FUNC_RETURN; 640 641 } 642 643 int portmod_port_diag_info_t_validate(int unit, const portmod_port_diag_info_t* portmod_port_diag_info) 644 { 645 SOC_INIT_FUNC_DEFS; 646 if(portmod_port_diag_info == NULL) { 647 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 648 } 649 650 if(SOC_E_NONE != portmod_port_mode_info_t_validate(unit, &portmod_port_diag_info->core_mode)) { 651 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_mode validation failed")); 652 } 653 654 655 656 exit: 657 SOC_FUNC_RETURN; 658 659 } 660 661 int portmod_port_diag_info_t_init(int unit, portmod_port_diag_info_t* portmod_port_diag_info) 662 { 663 SOC_INIT_FUNC_DEFS; 664 665 if(portmod_port_diag_info == NULL){ 666 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_diag_info NULL parameter")); 667 } 668 sal_memset(portmod_port_diag_info, 0, sizeof(portmod_port_diag_info_t)); 669 portmod_port_diag_info->interface = phymodInterfaceCount; 670 PORTMOD_PBMP_CLEAR(portmod_port_diag_info->phys); 671 portmod_port_diag_info->sub_phy = 0; 672 portmod_port_diag_info->medium = 0; 673 sal_memset(&(portmod_port_diag_info->core_mode), 0, sizeof(portmod_port_mode_info_t)); 674 sal_memset(&(portmod_port_diag_info->polarity), 0, sizeof(phymod_polarity_t)); 675 portmod_port_diag_info->fec = _SHR_PORT_PHY_FEC_COUNT; 676 677 678 exit: 679 SOC_FUNC_RETURN; 680 681 } 682 683 int portmod_pm_core_info_t_validate(int unit, const portmod_pm_core_info_t* portmod_pm_core_info) 684 { 685 SOC_INIT_FUNC_DEFS; 686 if(portmod_pm_core_info == NULL) { 687 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 688 } 689 690 691 692 exit: 693 SOC_FUNC_RETURN; 694 695 } 696 697 int portmod_pm_core_info_t_init(int unit, portmod_pm_core_info_t* portmod_pm_core_info) 698 { 699 SOC_INIT_FUNC_DEFS; 700 701 if(portmod_pm_core_info == NULL){ 702 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_core_info NULL parameter")); 703 } 704 sal_memset(portmod_pm_core_info, 0, sizeof(portmod_pm_core_info_t)); 705 portmod_pm_core_info->ref_clk = -1; 706 sal_memset(&(portmod_pm_core_info->lane_map), 0, sizeof(phymod_lane_map_t)); 707 portmod_pm_core_info->nof_phys = 0; 708 709 710 exit: 711 SOC_FUNC_RETURN; 712 713 } 714 715 int portmod_pm_diag_info_t_validate(int unit, const portmod_pm_diag_info_t* portmod_pm_diag_info) 716 { 717 SOC_INIT_FUNC_DEFS; 718 if(portmod_pm_diag_info == NULL) { 719 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 720 } 721 722 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, portmod_pm_diag_info->type)) { 723 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 724 } 725 726 if(SOC_E_NONE != portmod_pm_core_info_t_validate(unit, &portmod_pm_diag_info->core_info)) { 727 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_info validation failed")); 728 } 729 730 731 732 exit: 733 SOC_FUNC_RETURN; 734 735 } 736 737 int portmod_pm_diag_info_t_init(int unit, portmod_pm_diag_info_t* portmod_pm_diag_info) 738 { 739 SOC_INIT_FUNC_DEFS; 740 741 if(portmod_pm_diag_info == NULL){ 742 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_diag_info NULL parameter")); 743 } 744 sal_memset(portmod_pm_diag_info, 0, sizeof(portmod_pm_diag_info_t)); 745 portmod_pm_diag_info->type = portmodDispatchTypeCount; 746 sal_memset(&(portmod_pm_diag_info->core_info), 0, sizeof(portmod_pm_core_info_t)); 747 PORTMOD_PBMP_CLEAR(portmod_pm_diag_info->phys); 748 SOC_PBMP_CLEAR(portmod_pm_diag_info->ports); 749 portmod_pm_diag_info->serdes_id0 = -1; 750 portmod_pm_diag_info->phy_id0 = -1; 751 portmod_pm_diag_info->phy_id1 = -1; 752 753 754 exit: 755 SOC_FUNC_RETURN; 756 757 } 758 759 int portmod_port_ts_adjust_t_validate(int unit, const portmod_port_ts_adjust_t* portmod_port_ts_adjust) 760 { 761 SOC_INIT_FUNC_DEFS; 762 if(portmod_port_ts_adjust == NULL) { 763 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 764 } 765 766 767 768 exit: 769 SOC_FUNC_RETURN; 770 771 } 772 773 int portmod_port_ts_adjust_t_init(int unit, portmod_port_ts_adjust_t* portmod_port_ts_adjust) 774 { 775 SOC_INIT_FUNC_DEFS; 776 777 if(portmod_port_ts_adjust == NULL){ 778 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_ts_adjust NULL parameter")); 779 } 780 sal_memset(portmod_port_ts_adjust, 0, sizeof(portmod_port_ts_adjust_t)); 781 782 783 exit: 784 SOC_FUNC_RETURN; 785 786 } 787 788 int portmod_qtc_mode_t_validate(int unit, portmod_qtc_mode_t portmod_qtc_mode) 789 { 790 SOC_INIT_FUNC_DEFS; 791 if(portmod_qtc_mode >= portmodQtcModeCount) { 792 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 793 } 794 795 exit: 796 SOC_FUNC_RETURN; 797 798 } 799 800 int portmod_port_init_config_t_validate(int unit, const portmod_port_init_config_t* portmod_port_init_config) 801 { 802 SOC_INIT_FUNC_DEFS; 803 if(portmod_port_init_config == NULL) { 804 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 805 } 806 807 if(SOC_E_NONE != portmod_port_mode_aux_info_t_validate(unit, portmod_port_init_config->port_mode_aux_info)) { 808 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("port_mode_aux_info validation failed")); 809 } 810 811 if(SOC_E_NONE != portmod_cpm_core_mode_t_validate(unit, portmod_port_init_config->cpm_core_mode)) { 812 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cpm_core_mode validation failed")); 813 } 814 815 if(SOC_E_NONE != portmod_qtc_mode_t_validate(unit, portmod_port_init_config->qtc_mode)) { 816 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("qtc_mode validation failed")); 817 } 818 819 820 821 exit: 822 SOC_FUNC_RETURN; 823 824 } 825 826 int portmod_port_init_config_t_init(int unit, portmod_port_init_config_t* portmod_port_init_config) 827 { 828 int _array_iter; 829 830 SOC_INIT_FUNC_DEFS; 831 832 if(portmod_port_init_config == NULL){ 833 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_init_config NULL parameter")); 834 } 835 sal_memset(portmod_port_init_config, 0, sizeof(portmod_port_init_config_t)); 836 portmod_port_init_config->cx4_10g = 0; 837 portmod_port_init_config->pdetect1000x = 0; 838 portmod_port_init_config->an_mode = phymod_AN_MODE_NONE; 839 portmod_port_init_config->an_master_lane = 0; 840 portmod_port_init_config->an_cl72 = 0; 841 portmod_port_init_config->fs_cl72 = 0; 842 portmod_port_init_config->an_fec = 0; 843 portmod_port_init_config->sgmii_mstr = 0; 844 portmod_port_init_config->serdes_driver_current = 0; 845 portmod_port_init_config->serdes_1000x_at_6250_vco = 0; 846 portmod_port_init_config->serdes_1000x_at_12500_vco = 0; 847 portmod_port_init_config->serdes_1000x_at_25g_vco = 0; 848 portmod_port_init_config->serdes_10g_at_25g_vco = 0; 849 portmod_port_init_config->pll_divider_req = 0; 850 portmod_port_init_config->rxaui_mode = 0; 851 portmod_port_init_config->port_fallback_lane = 0; 852 portmod_port_init_config->an_cl37 = 0; 853 portmod_port_init_config->cl37_sgmii_war = 0; 854 portmod_port_init_config->cl37_sgmii_cnt = 0; 855 portmod_port_init_config->cl37_sgmii_RESTART_CNT = 2; 856 portmod_port_init_config->an_cl73 = 0; 857 portmod_port_init_config->is_hg = 0; 858 portmod_port_init_config->polarity_overwrite = 0; 859 portmod_port_init_config->lane_map_overwrite = 0; 860 portmod_port_init_config->fw_load_method_overwrite = 0; 861 portmod_port_init_config->ref_clk = 0; 862 portmod_port_init_config->ref_clk_overwrite = 0; 863 portmod_port_init_config->port_mode_aux_info = 0; 864 for(_array_iter = 0 ; _array_iter < PORTMOD_TS_ADJUST_NUM ; _array_iter++){ 865 if(SOC_E_NONE != portmod_port_ts_adjust_t_init(unit, &portmod_port_init_config->port_ts_adjust[_array_iter])) { 866 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("port_ts_adjust initialization failed")); 867 } 868 } 869 870 871 872 exit: 873 SOC_FUNC_RETURN; 874 875 } 876 877 int portmod_port_interface_config_t_validate(int unit, const portmod_port_interface_config_t* portmod_port_interface_config) 878 { 879 SOC_INIT_FUNC_DEFS; 880 if(portmod_port_interface_config == NULL) { 881 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 882 } 883 884 885 886 exit: 887 SOC_FUNC_RETURN; 888 889 } 890 891 int portmod_port_interface_config_t_init(int unit, portmod_port_interface_config_t* portmod_port_interface_config) 892 { 893 SOC_INIT_FUNC_DEFS; 894 895 if(portmod_port_interface_config == NULL){ 896 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_interface_config NULL parameter")); 897 } 898 sal_memset(portmod_port_interface_config, 0, sizeof(portmod_port_interface_config_t)); 899 portmod_port_interface_config->interface = SOC_PORT_IF_NULL; 900 portmod_port_interface_config->line_interface = SOC_PORT_IF_NULL; 901 portmod_port_interface_config->serdes_interface = SOC_PORT_IF_NULL; 902 portmod_port_interface_config->interface_modes = 0; 903 portmod_port_interface_config->flags = 0; 904 portmod_port_interface_config->port_refclk_int = -1; 905 portmod_port_interface_config->port_num_lanes = 0; 906 portmod_port_interface_config->speed = 0; 907 portmod_port_interface_config->max_speed = 0; 908 portmod_port_interface_config->encap_mode = 0; 909 portmod_port_interface_config->pll_divider_req = 0; 910 portmod_port_interface_config->port_op_mode = 0; 911 912 913 exit: 914 SOC_FUNC_RETURN; 915 916 } 917 918 int portmod_port_speed_ability_t_validate(int unit, const portmod_port_speed_ability_t* portmod_port_speed_ability) 919 { 920 SOC_INIT_FUNC_DEFS; 921 if(portmod_port_speed_ability == NULL) { 922 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 923 } 924 925 926 927 exit: 928 SOC_FUNC_RETURN; 929 930 } 931 932 int portmod_port_speed_ability_t_init(int unit, portmod_port_speed_ability_t* portmod_port_speed_ability) 933 { 934 SOC_INIT_FUNC_DEFS; 935 936 if(portmod_port_speed_ability == NULL){ 937 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_speed_ability NULL parameter")); 938 } 939 sal_memset(portmod_port_speed_ability, 0, sizeof(portmod_port_speed_ability_t)); 940 portmod_port_speed_ability->speed = 0; 941 portmod_port_speed_ability->num_lanes = 0; 942 portmod_port_speed_ability->fec_type = _SHR_PORT_PHY_FEC_COUNT; 943 portmod_port_speed_ability->medium = _SHR_PORT_MEDIUM_COUNT; 944 portmod_port_speed_ability->pause = _SHR_PORT_PHY_PAUSE_COUNT; 945 portmod_port_speed_ability->channel = _SHR_PORT_PHY_CHANNEL_COUNT; 946 portmod_port_speed_ability->an_mode = _SHR_PORT_PHY_CONTROL_AUTONEG_MODE_COUNT; 947 948 949 exit: 950 SOC_FUNC_RETURN; 951 952 } 953 954 int portmod_port_speed_ability_local_get(int unit, int port, int max_num_abilities, portmod_port_speed_ability_t* abilities, int* num_abilities) 955 { 956 957 portmod_dispatch_type_t __type__; 958 int __rv__; 959 SOC_INIT_FUNC_DEFS; 960 961 if(abilities == NULL) { 962 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities NULL parameter")); 963 } 964 if(SOC_E_NONE != portmod_port_speed_ability_t_init(unit, abilities)) { 965 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities initialization failed")); 966 } 967 968 if(num_abilities == NULL) { 969 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("num_abilities NULL parameter")); 970 } 971 /* Dispatch */ 972 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 973 if(__type__ >= portmodDispatchTypeCount) { 974 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 975 } 976 977 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_speed_ability_local_get) { 978 pm_info_t pm_info; 979 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 980 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_speed_ability_local_get(unit, port, pm_info, max_num_abilities, abilities, num_abilities); 981 _SOC_IF_ERR_EXIT(__rv__); 982 } else { 983 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_speed_ability_local_get isn't implemented for driver type")); 984 } 985 986 exit: 987 SOC_FUNC_RETURN; 988 989 } 990 991 992 int portmod_speed_config_t_validate(int unit, const portmod_speed_config_t* portmod_speed_config) 993 { 994 SOC_INIT_FUNC_DEFS; 995 if(portmod_speed_config == NULL) { 996 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 997 } 998 999 1000 1001 exit: 1002 SOC_FUNC_RETURN; 1003 1004 } 1005 1006 int portmod_speed_config_t_init(int unit, portmod_speed_config_t* portmod_speed_config) 1007 { 1008 SOC_INIT_FUNC_DEFS; 1009 1010 if(portmod_speed_config == NULL){ 1011 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_speed_config NULL parameter")); 1012 } 1013 sal_memset(portmod_speed_config, 0, sizeof(portmod_speed_config_t)); 1014 portmod_speed_config->speed = 0; 1015 portmod_speed_config->num_lane = 0; 1016 portmod_speed_config->fec = 0; 1017 portmod_speed_config->link_training = 0; 1018 portmod_speed_config->lane_config = -1; 1019 portmod_speed_config->flags = 0; 1020 1021 1022 exit: 1023 SOC_FUNC_RETURN; 1024 1025 } 1026 1027 int portmod_vco_type_t_validate(int unit, portmod_vco_type_t portmod_vco_type) 1028 { 1029 SOC_INIT_FUNC_DEFS; 1030 if(portmod_vco_type >= portmodVCOCount) { 1031 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 1032 } 1033 1034 exit: 1035 SOC_FUNC_RETURN; 1036 1037 } 1038 1039 int portmod_pm_identifier_t_validate(int unit, const portmod_pm_identifier_t* portmod_pm_identifier) 1040 { 1041 SOC_INIT_FUNC_DEFS; 1042 if(portmod_pm_identifier == NULL) { 1043 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1044 } 1045 1046 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, portmod_pm_identifier->type)) { 1047 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 1048 } 1049 1050 1051 1052 exit: 1053 SOC_FUNC_RETURN; 1054 1055 } 1056 1057 int portmod_pm_identifier_t_init(int unit, portmod_pm_identifier_t* portmod_pm_identifier) 1058 { 1059 SOC_INIT_FUNC_DEFS; 1060 1061 if(portmod_pm_identifier == NULL){ 1062 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_identifier NULL parameter")); 1063 } 1064 sal_memset(portmod_pm_identifier, 0, sizeof(portmod_pm_identifier_t)); 1065 portmod_pm_identifier->type = portmodDispatchTypeCount; 1066 portmod_pm_identifier->phy = 0; 1067 1068 1069 exit: 1070 SOC_FUNC_RETURN; 1071 1072 } 1073 1074 int portmod_port_add_info_t_validate(int unit, const portmod_port_add_info_t* portmod_port_add_info) 1075 { 1076 SOC_INIT_FUNC_DEFS; 1077 if(portmod_port_add_info == NULL) { 1078 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1079 } 1080 1081 if(SOC_E_NONE != portmod_port_interface_config_t_validate(unit, &portmod_port_add_info->interface_config)) { 1082 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("interface_config validation failed")); 1083 } 1084 1085 if(SOC_E_NONE != portmod_port_init_config_t_validate(unit, &portmod_port_add_info->init_config)) { 1086 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("init_config validation failed")); 1087 } 1088 1089 if(SOC_E_NONE != portmod_speed_config_t_validate(unit, &portmod_port_add_info->speed_config)) { 1090 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config validation failed")); 1091 } 1092 1093 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, portmod_port_add_info->tvco)) { 1094 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("tvco validation failed")); 1095 } 1096 1097 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, portmod_port_add_info->ovco)) { 1098 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ovco validation failed")); 1099 } 1100 1101 switch(portmod_port_add_info->sub_phy) { 1102 case 0: 1103 case 1: 1104 case 2: 1105 case 3: 1106 break; 1107 default: 1108 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("sub_phy not allowed value")); 1109 break; 1110 } 1111 1112 1113 1114 exit: 1115 SOC_FUNC_RETURN; 1116 1117 } 1118 1119 int portmod_port_add_info_t_init(int unit, portmod_port_add_info_t* portmod_port_add_info) 1120 { 1121 int _array_iter; 1122 1123 SOC_INIT_FUNC_DEFS; 1124 1125 if(portmod_port_add_info == NULL){ 1126 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_add_info NULL parameter")); 1127 } 1128 sal_memset(portmod_port_add_info, 0, sizeof(portmod_port_add_info_t)); 1129 if(SOC_E_NONE != portmod_port_interface_config_t_init(unit, &portmod_port_add_info->interface_config)) { 1130 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("interface_config initialization failed")); 1131 } 1132 1133 if(SOC_E_NONE != portmod_port_init_config_t_init(unit, &portmod_port_add_info->init_config)) { 1134 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("init_config initialization failed")); 1135 } 1136 1137 if(SOC_E_NONE != portmod_speed_config_t_init(unit, &portmod_port_add_info->speed_config)) { 1138 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config initialization failed")); 1139 } 1140 1141 PORTMOD_PBMP_CLEAR(portmod_port_add_info->phys); 1142 PORTMOD_PBMP_CLEAR(portmod_port_add_info->phy_ports); 1143 portmod_port_add_info->sub_phy = 0; 1144 portmod_port_add_info->autoneg_en = 0; 1145 portmod_port_add_info->link_training_en = 0; 1146 portmod_port_add_info->flags = PORTMOD_PORT_ADD_F_FIRMWARE_LOAD_VERIFY; 1147 portmod_port_add_info->is_fabric_o_nif = 0; 1148 portmod_port_add_info->ilkn_core_id = 0; 1149 portmod_port_add_info->ilkn_port_is_over_fabric = 0; 1150 portmod_port_add_info->ilkn_burst_max = -1; 1151 portmod_port_add_info->ilkn_burst_min = -1; 1152 portmod_port_add_info->ilkn_burst_short = -1; 1153 portmod_port_add_info->ilkn_nof_segments = -1; 1154 portmod_port_add_info->ilkn_metaframe_period = -1; 1155 portmod_port_add_info->rx_retransmit = 0; 1156 portmod_port_add_info->tx_retransmit = 0; 1157 portmod_port_add_info->phy_op_mode = 0; 1158 portmod_port_add_info->phy_op_datapath = 0; 1159 portmod_port_add_info->ilkn_inb_cal_len_rx = -1; 1160 portmod_port_add_info->ilkn_inb_cal_len_tx = -1; 1161 portmod_port_add_info->ilkn_oob_cal_len_rx = -1; 1162 portmod_port_add_info->ilkn_oob_cal_len_tx = -1; 1163 portmod_port_add_info->reserved_channel_rx = 0; 1164 portmod_port_add_info->reserved_channel_tx = 0; 1165 PORTMOD_PBMP_CLEAR(portmod_port_add_info->ilkn_lanes); 1166 portmod_port_add_info->nof_aggregated_pms = 0; 1167 for(_array_iter = 0 ; _array_iter < PORTMOD_MAX_ILKN_AGGREGATED_PMS ; _array_iter++){ 1168 if(SOC_E_NONE != portmod_pm_identifier_t_init(unit, &portmod_port_add_info->controlled_pms[_array_iter])) { 1169 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("controlled_pms initialization failed")); 1170 } 1171 } 1172 1173 1174 1175 exit: 1176 SOC_FUNC_RETURN; 1177 1178 } 1179 1180 int portmod_dnx_fabric_create_info_t_validate(int unit, const portmod_dnx_fabric_create_info_t* portmod_dnx_fabric_create_info) 1181 { 1182 SOC_INIT_FUNC_DEFS; 1183 if(portmod_dnx_fabric_create_info == NULL) { 1184 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1185 } 1186 1187 if(SOC_E_NONE != portmod_pm_identifier_t_validate(unit, &portmod_dnx_fabric_create_info->fabric_o_nif_pm)) { 1188 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("fabric_o_nif_pm validation failed")); 1189 } 1190 1191 1192 1193 exit: 1194 SOC_FUNC_RETURN; 1195 1196 } 1197 1198 int portmod_dnx_fabric_create_info_t_init(int unit, portmod_dnx_fabric_create_info_t* portmod_dnx_fabric_create_info) 1199 { 1200 SOC_INIT_FUNC_DEFS; 1201 1202 if(portmod_dnx_fabric_create_info == NULL){ 1203 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_dnx_fabric_create_info NULL parameter")); 1204 } 1205 sal_memset(portmod_dnx_fabric_create_info, 0, sizeof(portmod_dnx_fabric_create_info_t)); 1206 portmod_dnx_fabric_create_info->ref_clk = phymodRefClkCount; 1207 portmod_dnx_fabric_create_info->com_clk = phymodRefClkCount; 1208 phymod_access_t_init(&portmod_dnx_fabric_create_info->access); 1209 phymod_lane_map_t_init(&portmod_dnx_fabric_create_info->lane_map); 1210 portmod_dnx_fabric_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1211 portmod_dnx_fabric_create_info->external_fw_loader = NULL; 1212 portmod_dnx_fabric_create_info->fmac_schan_id = -1; 1213 portmod_dnx_fabric_create_info->fsrd_schan_id = -1; 1214 portmod_dnx_fabric_create_info->fsrd_internal_quad = -1; 1215 portmod_dnx_fabric_create_info->first_phy_offset = 0; 1216 portmod_dnx_fabric_create_info->core_index = -1; 1217 portmod_dnx_fabric_create_info->is_over_nif = 0; 1218 if(SOC_E_NONE != portmod_pm_identifier_t_init(unit, &portmod_dnx_fabric_create_info->fabric_o_nif_pm)) { 1219 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("fabric_o_nif_pm initialization failed")); 1220 } 1221 1222 1223 1224 exit: 1225 SOC_FUNC_RETURN; 1226 1227 } 1228 1229 int portmod_pm8x50_fabric_create_info_t_validate(int unit, const portmod_pm8x50_fabric_create_info_t* portmod_pm8x50_fabric_create_info) 1230 { 1231 SOC_INIT_FUNC_DEFS; 1232 if(portmod_pm8x50_fabric_create_info == NULL) { 1233 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1234 } 1235 1236 1237 1238 exit: 1239 SOC_FUNC_RETURN; 1240 1241 } 1242 1243 int portmod_pm8x50_fabric_create_info_t_init(int unit, portmod_pm8x50_fabric_create_info_t* portmod_pm8x50_fabric_create_info) 1244 { 1245 int _array_iter; 1246 1247 SOC_INIT_FUNC_DEFS; 1248 1249 if(portmod_pm8x50_fabric_create_info == NULL){ 1250 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm8x50_fabric_create_info NULL parameter")); 1251 } 1252 sal_memset(portmod_pm8x50_fabric_create_info, 0, sizeof(portmod_pm8x50_fabric_create_info_t)); 1253 portmod_pm8x50_fabric_create_info->ref_clk = phymodRefClkCount; 1254 phymod_access_t_init(&portmod_pm8x50_fabric_create_info->access); 1255 portmod_pm8x50_fabric_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1256 portmod_pm8x50_fabric_create_info->external_fw_loader = NULL; 1257 for(_array_iter = 0 ; _array_iter < PORTMOD_NOF_FMACS_PER_PM8X50_FABRIC ; _array_iter++){ portmod_pm8x50_fabric_create_info->fmac_schan_id[_array_iter] = -1; 1258 } portmod_pm8x50_fabric_create_info->fsrd_schan_id = -1; 1259 portmod_pm8x50_fabric_create_info->first_phy_offset = 0; 1260 portmod_pm8x50_fabric_create_info->core_index = -1; 1261 portmod_pm8x50_fabric_create_info->force_single_pll = 0; 1262 for(_array_iter = 0 ; _array_iter < PORTMOD_NOF_WORDS_PER_PM8X50_FABRIC_LANES_BITMAP ; _array_iter++){ portmod_pm8x50_fabric_create_info->bypass_lanes_bitmap[_array_iter] = 0; 1263 } portmod_pm8x50_fabric_create_info->is_rx_ctrl_bypass_supported = 0; 1264 1265 1266 exit: 1267 SOC_FUNC_RETURN; 1268 1269 } 1270 1271 int portmod_call_back_action_type_t_validate(int unit, portmod_call_back_action_type_t portmod_call_back_action_type) 1272 { 1273 SOC_INIT_FUNC_DEFS; 1274 if(portmod_call_back_action_type >= portmodCallBackActionTypeCount) { 1275 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 1276 } 1277 1278 exit: 1279 SOC_FUNC_RETURN; 1280 1281 } 1282 1283 int portmod_intr_type_t_validate(int unit, portmod_intr_type_t portmod_intr_type) 1284 { 1285 SOC_INIT_FUNC_DEFS; 1286 if(portmod_intr_type >= portmodIntrTypeCount) { 1287 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 1288 } 1289 1290 exit: 1291 SOC_FUNC_RETURN; 1292 1293 } 1294 1295 int portmod_pm4x25_create_info_t_validate(int unit, const portmod_pm4x25_create_info_t* portmod_pm4x25_create_info) 1296 { 1297 SOC_INIT_FUNC_DEFS; 1298 if(portmod_pm4x25_create_info == NULL) { 1299 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1300 } 1301 1302 switch(portmod_pm4x25_create_info->in_pm_12x10) { 1303 case 0: 1304 case 1: 1305 break; 1306 default: 1307 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("in_pm_12x10 not allowed value")); 1308 break; 1309 } 1310 1311 if(SOC_E_NONE != portmod_port_mode_aux_info_t_validate(unit, portmod_pm4x25_create_info->port_mode_aux_info)) { 1312 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("port_mode_aux_info validation failed")); 1313 } 1314 1315 1316 1317 exit: 1318 SOC_FUNC_RETURN; 1319 1320 } 1321 1322 int portmod_pm4x25_create_info_t_init(int unit, portmod_pm4x25_create_info_t* portmod_pm4x25_create_info) 1323 { 1324 SOC_INIT_FUNC_DEFS; 1325 1326 if(portmod_pm4x25_create_info == NULL){ 1327 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm4x25_create_info NULL parameter")); 1328 } 1329 sal_memset(portmod_pm4x25_create_info, 0, sizeof(portmod_pm4x25_create_info_t)); 1330 portmod_pm4x25_create_info->ref_clk = phymodRefClkCount; 1331 phymod_access_t_init(&portmod_pm4x25_create_info->access); 1332 phymod_lane_map_t_init(&portmod_pm4x25_create_info->lane_map); 1333 portmod_pm4x25_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1334 portmod_pm4x25_create_info->external_fw_loader = NULL; 1335 portmod_pm4x25_create_info->in_pm_12x10 = 0; 1336 portmod_pm4x25_create_info->core_num = 0; 1337 portmod_pm4x25_create_info->core_num_int = 0; 1338 portmod_pm4x25_create_info->portmod_mac_soft_reset = NULL; 1339 phymod_afe_pll_t_init(&portmod_pm4x25_create_info->afe_pll); 1340 portmod_pm4x25_create_info->rescal = -1; 1341 portmod_pm4x25_create_info->port_mode_aux_info = 0; 1342 1343 1344 exit: 1345 SOC_FUNC_RETURN; 1346 1347 } 1348 1349 int portmod_pm4x10_create_info_t_validate(int unit, const portmod_pm4x10_create_info_t* portmod_pm4x10_create_info) 1350 { 1351 SOC_INIT_FUNC_DEFS; 1352 if(portmod_pm4x10_create_info == NULL) { 1353 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1354 } 1355 1356 switch(portmod_pm4x10_create_info->in_pm_12x10) { 1357 case 0: 1358 case 1: 1359 break; 1360 default: 1361 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("in_pm_12x10 not allowed value")); 1362 break; 1363 } 1364 1365 if(SOC_E_NONE != portmod_port_mode_aux_info_t_validate(unit, portmod_pm4x10_create_info->port_mode_aux_info)) { 1366 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("port_mode_aux_info validation failed")); 1367 } 1368 1369 1370 1371 exit: 1372 SOC_FUNC_RETURN; 1373 1374 } 1375 1376 int portmod_pm4x10_create_info_t_init(int unit, portmod_pm4x10_create_info_t* portmod_pm4x10_create_info) 1377 { 1378 SOC_INIT_FUNC_DEFS; 1379 1380 if(portmod_pm4x10_create_info == NULL){ 1381 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm4x10_create_info NULL parameter")); 1382 } 1383 sal_memset(portmod_pm4x10_create_info, 0, sizeof(portmod_pm4x10_create_info_t)); 1384 PORTMOD_PBMP_CLEAR(portmod_pm4x10_create_info->phy_ports); 1385 portmod_pm4x10_create_info->ref_clk = phymodRefClkCount; 1386 phymod_access_t_init(&portmod_pm4x10_create_info->access); 1387 phymod_lane_map_t_init(&portmod_pm4x10_create_info->lane_map); 1388 portmod_pm4x10_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1389 portmod_pm4x10_create_info->external_fw_loader = NULL; 1390 portmod_pm4x10_create_info->in_pm_12x10 = 0; 1391 portmod_pm4x10_create_info->portmod_phy_external_reset = NULL; 1392 portmod_pm4x10_create_info->portmod_mac_soft_reset = NULL; 1393 portmod_pm4x10_create_info->core_num = 0; 1394 portmod_pm4x10_create_info->core_num_int = 0; 1395 portmod_pm4x10_create_info->port_mode_aux_info = 0; 1396 portmod_pm4x10_create_info->rescal = -1; 1397 portmod_pm4x10_create_info->is_pm4x10q = 0; 1398 1399 1400 exit: 1401 SOC_FUNC_RETURN; 1402 1403 } 1404 1405 int portmod_pm_qtc_create_info_t_validate(int unit, const portmod_pm_qtc_create_info_t* portmod_pm_qtc_create_info) 1406 { 1407 SOC_INIT_FUNC_DEFS; 1408 if(portmod_pm_qtc_create_info == NULL) { 1409 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1410 } 1411 1412 1413 1414 exit: 1415 SOC_FUNC_RETURN; 1416 1417 } 1418 1419 int portmod_pm_qtc_create_info_t_init(int unit, portmod_pm_qtc_create_info_t* portmod_pm_qtc_create_info) 1420 { 1421 SOC_INIT_FUNC_DEFS; 1422 1423 if(portmod_pm_qtc_create_info == NULL){ 1424 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_qtc_create_info NULL parameter")); 1425 } 1426 sal_memset(portmod_pm_qtc_create_info, 0, sizeof(portmod_pm_qtc_create_info_t)); 1427 portmod_pm_qtc_create_info->ref_clk = phymodRefClkCount; 1428 phymod_access_t_init(&portmod_pm_qtc_create_info->access); 1429 phymod_lane_map_t_init(&portmod_pm_qtc_create_info->lane_map); 1430 portmod_pm_qtc_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1431 portmod_pm_qtc_create_info->external_fw_loader = NULL; 1432 portmod_pm_qtc_create_info->portmod_phy_external_reset = NULL; 1433 portmod_pm_qtc_create_info->portmod_mac_soft_reset = NULL; 1434 portmod_pm_qtc_create_info->core_num = 0; 1435 portmod_pm_qtc_create_info->core_clock_khz = 0; 1436 1437 1438 exit: 1439 SOC_FUNC_RETURN; 1440 1441 } 1442 1443 int portmod_pm_gphy_create_info_t_validate(int unit, const portmod_pm_gphy_create_info_t* portmod_pm_gphy_create_info) 1444 { 1445 SOC_INIT_FUNC_DEFS; 1446 if(portmod_pm_gphy_create_info == NULL) { 1447 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1448 } 1449 1450 1451 1452 exit: 1453 SOC_FUNC_RETURN; 1454 1455 } 1456 1457 int portmod_pm_gphy_create_info_t_init(int unit, portmod_pm_gphy_create_info_t* portmod_pm_gphy_create_info) 1458 { 1459 SOC_INIT_FUNC_DEFS; 1460 1461 if(portmod_pm_gphy_create_info == NULL){ 1462 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_gphy_create_info NULL parameter")); 1463 } 1464 sal_memset(portmod_pm_gphy_create_info, 0, sizeof(portmod_pm_gphy_create_info_t)); 1465 portmod_pm_gphy_create_info->ref_clk = phymodRefClkCount; 1466 phymod_access_t_init(&portmod_pm_gphy_create_info->access); 1467 phymod_lane_map_t_init(&portmod_pm_gphy_create_info->lane_map); 1468 portmod_pm_gphy_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1469 portmod_pm_gphy_create_info->external_fw_loader = NULL; 1470 portmod_pm_gphy_create_info->portmod_phy_external_reset = NULL; 1471 portmod_pm_gphy_create_info->portmod_mac_soft_reset = NULL; 1472 portmod_pm_gphy_create_info->core_num = 0; 1473 1474 1475 exit: 1476 SOC_FUNC_RETURN; 1477 1478 } 1479 1480 int portmod_pm12x10_create_info_t_validate(int unit, const portmod_pm12x10_create_info_t* portmod_pm12x10_create_info) 1481 { 1482 SOC_INIT_FUNC_DEFS; 1483 if(portmod_pm12x10_create_info == NULL) { 1484 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1485 } 1486 1487 if(SOC_E_NONE != portmod_pm4x25_create_info_t_validate(unit, &portmod_pm12x10_create_info->pm4x25_info)) { 1488 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x25_info validation failed")); 1489 } 1490 1491 1492 1493 exit: 1494 SOC_FUNC_RETURN; 1495 1496 } 1497 1498 int portmod_pm12x10_create_info_t_init(int unit, portmod_pm12x10_create_info_t* portmod_pm12x10_create_info) 1499 { 1500 int _array_iter; 1501 1502 SOC_INIT_FUNC_DEFS; 1503 1504 if(portmod_pm12x10_create_info == NULL){ 1505 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm12x10_create_info NULL parameter")); 1506 } 1507 sal_memset(portmod_pm12x10_create_info, 0, sizeof(portmod_pm12x10_create_info_t)); 1508 for(_array_iter = 0 ; _array_iter < 3 ; _array_iter++){ 1509 if(SOC_E_NONE != portmod_pm4x10_create_info_t_init(unit, &portmod_pm12x10_create_info->pm4x10_infos[_array_iter])) { 1510 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x10_infos initialization failed")); 1511 } 1512 } 1513 1514 if(SOC_E_NONE != portmod_pm4x25_create_info_t_init(unit, &portmod_pm12x10_create_info->pm4x25_info)) { 1515 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x25_info initialization failed")); 1516 } 1517 1518 portmod_pm12x10_create_info->blk_id = -1; 1519 portmod_pm12x10_create_info->refclk_source = 0; 1520 1521 1522 exit: 1523 SOC_FUNC_RETURN; 1524 1525 } 1526 1527 int portmod_pm4x10q_create_info_t_validate(int unit, const portmod_pm4x10q_create_info_t* portmod_pm4x10q_create_info) 1528 { 1529 SOC_INIT_FUNC_DEFS; 1530 if(portmod_pm4x10q_create_info == NULL) { 1531 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1532 } 1533 1534 if(SOC_E_NONE != portmod_pm4x10_create_info_t_validate(unit, &portmod_pm4x10q_create_info->pm4x10_info)) { 1535 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x10_info validation failed")); 1536 } 1537 1538 1539 1540 exit: 1541 SOC_FUNC_RETURN; 1542 1543 } 1544 1545 int portmod_pm4x10q_create_info_t_init(int unit, portmod_pm4x10q_create_info_t* portmod_pm4x10q_create_info) 1546 { 1547 SOC_INIT_FUNC_DEFS; 1548 1549 if(portmod_pm4x10q_create_info == NULL){ 1550 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm4x10q_create_info NULL parameter")); 1551 } 1552 sal_memset(portmod_pm4x10q_create_info, 0, sizeof(portmod_pm4x10q_create_info_t)); 1553 if(SOC_E_NONE != portmod_pm4x10_create_info_t_init(unit, &portmod_pm4x10q_create_info->pm4x10_info)) { 1554 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x10_info initialization failed")); 1555 } 1556 1557 portmod_pm4x10q_create_info->qsgmii_user_acc = NULL; 1558 portmod_pm4x10q_create_info->core_clock_khz = 0; 1559 1560 1561 exit: 1562 SOC_FUNC_RETURN; 1563 1564 } 1565 1566 int portmod_ilkn_os_create_info_t_validate(int unit, const portmod_ilkn_os_create_info_t* portmod_ilkn_os_create_info) 1567 { 1568 SOC_INIT_FUNC_DEFS; 1569 if(portmod_ilkn_os_create_info == NULL) { 1570 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1571 } 1572 1573 if(SOC_E_NONE != portmod_pm_identifier_t_validate(unit, portmod_ilkn_os_create_info->controlled_pms)) { 1574 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("controlled_pms validation failed")); 1575 } 1576 1577 1578 1579 exit: 1580 SOC_FUNC_RETURN; 1581 1582 } 1583 1584 int portmod_ilkn_os_create_info_t_init(int unit, portmod_ilkn_os_create_info_t* portmod_ilkn_os_create_info) 1585 { 1586 int _array_iter; 1587 1588 SOC_INIT_FUNC_DEFS; 1589 1590 if(portmod_ilkn_os_create_info == NULL){ 1591 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_ilkn_os_create_info NULL parameter")); 1592 } 1593 sal_memset(portmod_ilkn_os_create_info, 0, sizeof(portmod_ilkn_os_create_info_t)); 1594 portmod_ilkn_os_create_info->nof_aggregated_pms = phymodRefClkCount; 1595 for(_array_iter = 0 ; _array_iter < PORTMOD_MAX_ILKN_PORTS_PER_ILKN_PM ; _array_iter++){ portmod_ilkn_os_create_info->wm_high[_array_iter] = 0; 1596 } for(_array_iter = 0 ; _array_iter < PORTMOD_MAX_ILKN_PORTS_PER_ILKN_PM ; _array_iter++){ portmod_ilkn_os_create_info->wm_low[_array_iter] = 0; 1597 } portmod_ilkn_os_create_info->is_over_fabric = 0; 1598 portmod_ilkn_os_create_info->core_clock_khz = 0; 1599 portmod_ilkn_os_create_info->ilkn_core_lane_map_get = NULL; 1600 portmod_ilkn_os_create_info->ilkn_pm_lane_map_get = NULL; 1601 portmod_ilkn_os_create_info->ilkn_block_index = 0; 1602 1603 1604 exit: 1605 SOC_FUNC_RETURN; 1606 1607 } 1608 1609 int portmod_pm4x2p5_create_info_t_validate(int unit, const portmod_pm4x2p5_create_info_t* portmod_pm4x2p5_create_info) 1610 { 1611 SOC_INIT_FUNC_DEFS; 1612 if(portmod_pm4x2p5_create_info == NULL) { 1613 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1614 } 1615 1616 1617 1618 exit: 1619 SOC_FUNC_RETURN; 1620 1621 } 1622 1623 int portmod_pm4x2p5_create_info_t_init(int unit, portmod_pm4x2p5_create_info_t* portmod_pm4x2p5_create_info) 1624 { 1625 SOC_INIT_FUNC_DEFS; 1626 1627 if(portmod_pm4x2p5_create_info == NULL){ 1628 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm4x2p5_create_info NULL parameter")); 1629 } 1630 sal_memset(portmod_pm4x2p5_create_info, 0, sizeof(portmod_pm4x2p5_create_info_t)); 1631 SOC_PBMP_CLEAR(portmod_pm4x2p5_create_info->phy_ports); 1632 portmod_pm4x2p5_create_info->ref_clk = phymodRefClkCount; 1633 phymod_access_t_init(&portmod_pm4x2p5_create_info->access); 1634 phymod_lane_map_t_init(&portmod_pm4x2p5_create_info->lane_map); 1635 portmod_pm4x2p5_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1636 portmod_pm4x2p5_create_info->external_fw_loader = NULL; 1637 portmod_pm4x2p5_create_info->portmod_phy_external_reset = NULL; 1638 portmod_pm4x2p5_create_info->portmod_mac_soft_reset = NULL; 1639 1640 1641 exit: 1642 SOC_FUNC_RETURN; 1643 1644 } 1645 1646 int portmod_pm8x50_create_info_t_validate(int unit, const portmod_pm8x50_create_info_t* portmod_pm8x50_create_info) 1647 { 1648 SOC_INIT_FUNC_DEFS; 1649 if(portmod_pm8x50_create_info == NULL) { 1650 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1651 } 1652 1653 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, portmod_pm8x50_create_info->tvco)) { 1654 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("tvco validation failed")); 1655 } 1656 1657 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, portmod_pm8x50_create_info->ovco)) { 1658 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ovco validation failed")); 1659 } 1660 1661 1662 1663 exit: 1664 SOC_FUNC_RETURN; 1665 1666 } 1667 1668 int portmod_pm8x50_create_info_t_init(int unit, portmod_pm8x50_create_info_t* portmod_pm8x50_create_info) 1669 { 1670 SOC_INIT_FUNC_DEFS; 1671 1672 if(portmod_pm8x50_create_info == NULL){ 1673 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm8x50_create_info NULL parameter")); 1674 } 1675 sal_memset(portmod_pm8x50_create_info, 0, sizeof(portmod_pm8x50_create_info_t)); 1676 SOC_PBMP_CLEAR(portmod_pm8x50_create_info->phy_ports); 1677 portmod_pm8x50_create_info->ref_clk = phymodRefClkCount; 1678 portmod_pm8x50_create_info->tvco = 0; 1679 portmod_pm8x50_create_info->ovco = 0; 1680 phymod_phy_access_t_init(&portmod_pm8x50_create_info->access); 1681 phymod_lane_map_t_init(&portmod_pm8x50_create_info->lane_map); 1682 portmod_pm8x50_create_info->fw_load_method = phymodFirmwareLoadMethodCount; 1683 portmod_pm8x50_create_info->external_fw_loader = NULL; 1684 portmod_pm8x50_create_info->portmod_phy_external_reset = NULL; 1685 portmod_pm8x50_create_info->portmod_mac_soft_reset = NULL; 1686 portmod_pm8x50_create_info->core_num = 0; 1687 phymod_afe_pll_t_init(&portmod_pm8x50_create_info->afe_pll); 1688 portmod_pm8x50_create_info->rescal = -1; 1689 portmod_pm8x50_create_info->is_master_pm = -1; 1690 portmod_pm8x50_create_info->portmod_egress_buffer_reset = NULL; 1691 portmod_pm8x50_create_info->allow_20p625g_tvco = -1; 1692 1693 1694 exit: 1695 SOC_FUNC_RETURN; 1696 1697 } 1698 1699 int portmod_pm4x10_qtc_create_info_t_validate(int unit, const portmod_pm4x10_qtc_create_info_t* portmod_pm4x10_qtc_create_info) 1700 { 1701 SOC_INIT_FUNC_DEFS; 1702 if(portmod_pm4x10_qtc_create_info == NULL) { 1703 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1704 } 1705 1706 if(SOC_E_NONE != portmod_pm4x10_create_info_t_validate(unit, &portmod_pm4x10_qtc_create_info->pm4x10_info)) { 1707 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x10_info validation failed")); 1708 } 1709 1710 if(SOC_E_NONE != portmod_pm_qtc_create_info_t_validate(unit, &portmod_pm4x10_qtc_create_info->pm_qtc_info)) { 1711 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm_qtc_info validation failed")); 1712 } 1713 1714 1715 1716 exit: 1717 SOC_FUNC_RETURN; 1718 1719 } 1720 1721 int portmod_pm4x10_qtc_create_info_t_init(int unit, portmod_pm4x10_qtc_create_info_t* portmod_pm4x10_qtc_create_info) 1722 { 1723 SOC_INIT_FUNC_DEFS; 1724 1725 if(portmod_pm4x10_qtc_create_info == NULL){ 1726 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm4x10_qtc_create_info NULL parameter")); 1727 } 1728 sal_memset(portmod_pm4x10_qtc_create_info, 0, sizeof(portmod_pm4x10_qtc_create_info_t)); 1729 if(SOC_E_NONE != portmod_pm4x10_create_info_t_init(unit, &portmod_pm4x10_qtc_create_info->pm4x10_info)) { 1730 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm4x10_info initialization failed")); 1731 } 1732 1733 if(SOC_E_NONE != portmod_pm_qtc_create_info_t_init(unit, &portmod_pm4x10_qtc_create_info->pm_qtc_info)) { 1734 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm_qtc_info initialization failed")); 1735 } 1736 1737 1738 1739 exit: 1740 SOC_FUNC_RETURN; 1741 1742 } 1743 1744 int portmod_remote_fault_control_t_validate(int unit, const portmod_remote_fault_control_t* portmod_remote_fault_control) 1745 { 1746 SOC_INIT_FUNC_DEFS; 1747 if(portmod_remote_fault_control == NULL) { 1748 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1749 } 1750 1751 1752 1753 exit: 1754 SOC_FUNC_RETURN; 1755 1756 } 1757 1758 int portmod_remote_fault_control_t_init(int unit, portmod_remote_fault_control_t* portmod_remote_fault_control) 1759 { 1760 SOC_INIT_FUNC_DEFS; 1761 1762 if(portmod_remote_fault_control == NULL){ 1763 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_remote_fault_control NULL parameter")); 1764 } 1765 sal_memset(portmod_remote_fault_control, 0, sizeof(portmod_remote_fault_control_t)); 1766 portmod_remote_fault_control->enable = 0; 1767 portmod_remote_fault_control->drop_tx_on_fault = 1; 1768 1769 1770 exit: 1771 SOC_FUNC_RETURN; 1772 1773 } 1774 1775 int portmod_local_fault_control_t_validate(int unit, const portmod_local_fault_control_t* portmod_local_fault_control) 1776 { 1777 SOC_INIT_FUNC_DEFS; 1778 if(portmod_local_fault_control == NULL) { 1779 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1780 } 1781 1782 1783 1784 exit: 1785 SOC_FUNC_RETURN; 1786 1787 } 1788 1789 int portmod_local_fault_control_t_init(int unit, portmod_local_fault_control_t* portmod_local_fault_control) 1790 { 1791 SOC_INIT_FUNC_DEFS; 1792 1793 if(portmod_local_fault_control == NULL){ 1794 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_local_fault_control NULL parameter")); 1795 } 1796 sal_memset(portmod_local_fault_control, 0, sizeof(portmod_local_fault_control_t)); 1797 portmod_local_fault_control->enable = 0; 1798 portmod_local_fault_control->drop_tx_on_fault = 1; 1799 1800 1801 exit: 1802 SOC_FUNC_RETURN; 1803 1804 } 1805 1806 int portmod_llfc_control_t_validate(int unit, const portmod_llfc_control_t* portmod_llfc_control) 1807 { 1808 SOC_INIT_FUNC_DEFS; 1809 if(portmod_llfc_control == NULL) { 1810 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1811 } 1812 1813 1814 1815 exit: 1816 SOC_FUNC_RETURN; 1817 1818 } 1819 1820 int portmod_llfc_control_t_init(int unit, portmod_llfc_control_t* portmod_llfc_control) 1821 { 1822 SOC_INIT_FUNC_DEFS; 1823 1824 if(portmod_llfc_control == NULL){ 1825 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_llfc_control NULL parameter")); 1826 } 1827 sal_memset(portmod_llfc_control, 0, sizeof(portmod_llfc_control_t)); 1828 portmod_llfc_control->rx_enable = 1; 1829 portmod_llfc_control->tx_enable = 1; 1830 portmod_llfc_control->crc_ignore = 0; 1831 portmod_llfc_control->in_ipg_only = 0; 1832 1833 1834 exit: 1835 SOC_FUNC_RETURN; 1836 1837 } 1838 1839 int portmod_pfc_control_t_validate(int unit, const portmod_pfc_control_t* portmod_pfc_control) 1840 { 1841 SOC_INIT_FUNC_DEFS; 1842 if(portmod_pfc_control == NULL) { 1843 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1844 } 1845 1846 1847 1848 exit: 1849 SOC_FUNC_RETURN; 1850 1851 } 1852 1853 int portmod_pfc_control_t_init(int unit, portmod_pfc_control_t* portmod_pfc_control) 1854 { 1855 SOC_INIT_FUNC_DEFS; 1856 1857 if(portmod_pfc_control == NULL){ 1858 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pfc_control NULL parameter")); 1859 } 1860 sal_memset(portmod_pfc_control, 0, sizeof(portmod_pfc_control_t)); 1861 portmod_pfc_control->rx_enable = 0; 1862 portmod_pfc_control->tx_enable = 0; 1863 portmod_pfc_control->stats_en = 1; 1864 portmod_pfc_control->force_xon = 0; 1865 portmod_pfc_control->refresh_timer = -1; 1866 portmod_pfc_control->xoff_timer = 0xFFFF; 1867 1868 1869 exit: 1870 SOC_FUNC_RETURN; 1871 1872 } 1873 1874 int portmod_pause_control_t_validate(int unit, const portmod_pause_control_t* portmod_pause_control) 1875 { 1876 SOC_INIT_FUNC_DEFS; 1877 if(portmod_pause_control == NULL) { 1878 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1879 } 1880 1881 1882 1883 exit: 1884 SOC_FUNC_RETURN; 1885 1886 } 1887 1888 int portmod_pause_control_t_init(int unit, portmod_pause_control_t* portmod_pause_control) 1889 { 1890 SOC_INIT_FUNC_DEFS; 1891 1892 if(portmod_pause_control == NULL){ 1893 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pause_control NULL parameter")); 1894 } 1895 sal_memset(portmod_pause_control, 0, sizeof(portmod_pause_control_t)); 1896 portmod_pause_control->rx_enable = 0; 1897 portmod_pause_control->tx_enable = 0; 1898 portmod_pause_control->refresh_timer = 0xc000; 1899 portmod_pause_control->xoff_timer = 0xFFFF; 1900 1901 1902 exit: 1903 SOC_FUNC_RETURN; 1904 1905 } 1906 1907 int portmod_drain_cells_t_validate(int unit, const portmod_drain_cells_t* portmod_drain_cells) 1908 { 1909 SOC_INIT_FUNC_DEFS; 1910 if(portmod_drain_cells == NULL) { 1911 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1912 } 1913 1914 1915 1916 exit: 1917 SOC_FUNC_RETURN; 1918 1919 } 1920 1921 int portmod_drain_cells_t_init(int unit, portmod_drain_cells_t* portmod_drain_cells) 1922 { 1923 SOC_INIT_FUNC_DEFS; 1924 1925 if(portmod_drain_cells == NULL){ 1926 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_drain_cells NULL parameter")); 1927 } 1928 sal_memset(portmod_drain_cells, 0, sizeof(portmod_drain_cells_t)); 1929 portmod_drain_cells->rx_pfc_en = 0; 1930 portmod_drain_cells->llfc_en = 0; 1931 portmod_drain_cells->rx_pause = 0; 1932 portmod_drain_cells->tx_pause = 0; 1933 1934 1935 exit: 1936 SOC_FUNC_RETURN; 1937 1938 } 1939 1940 int portmod_pm_create_info_t_validate(int unit, const portmod_pm_create_info_t* portmod_pm_create_info) 1941 { 1942 SOC_INIT_FUNC_DEFS; 1943 if(portmod_pm_create_info == NULL) { 1944 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1945 } 1946 1947 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, portmod_pm_create_info->type)) { 1948 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 1949 } 1950 1951 1952 1953 exit: 1954 SOC_FUNC_RETURN; 1955 1956 } 1957 1958 int portmod_pm_create_info_t_init(int unit, portmod_pm_create_info_t* portmod_pm_create_info) 1959 { 1960 SOC_INIT_FUNC_DEFS; 1961 1962 if(portmod_pm_create_info == NULL){ 1963 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_create_info NULL parameter")); 1964 } 1965 sal_memset(portmod_pm_create_info, 0, sizeof(portmod_pm_create_info_t)); 1966 portmod_pm_create_info->type = portmodDispatchTypeCount; 1967 PORTMOD_PBMP_CLEAR(portmod_pm_create_info->phys); 1968 sal_memset(&(portmod_pm_create_info->pm_specific_info), 0, sizeof(portmod_pm_specific_create_info_t)); 1969 1970 1971 exit: 1972 SOC_FUNC_RETURN; 1973 1974 } 1975 1976 int portmod_access_get_params_t_validate(int unit, const portmod_access_get_params_t* portmod_access_get_params) 1977 { 1978 SOC_INIT_FUNC_DEFS; 1979 if(portmod_access_get_params == NULL) { 1980 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 1981 } 1982 1983 switch(portmod_access_get_params->sys_side) { 1984 case PORTMOD_SIDE_LINE: 1985 case PORTMOD_SIDE_SYSTEM: 1986 break; 1987 default: 1988 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("sys_side not allowed value")); 1989 break; 1990 } 1991 1992 1993 1994 exit: 1995 SOC_FUNC_RETURN; 1996 1997 } 1998 1999 int portmod_access_get_params_t_init(int unit, portmod_access_get_params_t* portmod_access_get_params) 2000 { 2001 SOC_INIT_FUNC_DEFS; 2002 2003 if(portmod_access_get_params == NULL){ 2004 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_access_get_params NULL parameter")); 2005 } 2006 sal_memset(portmod_access_get_params, 0, sizeof(portmod_access_get_params_t)); 2007 portmod_access_get_params->phyn = -1; 2008 portmod_access_get_params->sys_side = PORTMOD_SIDE_LINE; 2009 portmod_access_get_params->lane = -1; 2010 portmod_access_get_params->apply_lane_mask = 0; 2011 2012 2013 exit: 2014 SOC_FUNC_RETURN; 2015 2016 } 2017 2018 int portmod_pm_instances_t_validate(int unit, const portmod_pm_instances_t* portmod_pm_instances) 2019 { 2020 SOC_INIT_FUNC_DEFS; 2021 if(portmod_pm_instances == NULL) { 2022 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 2023 } 2024 2025 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, portmod_pm_instances->type)) { 2026 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 2027 } 2028 2029 2030 2031 exit: 2032 SOC_FUNC_RETURN; 2033 2034 } 2035 2036 int portmod_pm_instances_t_init(int unit, portmod_pm_instances_t* portmod_pm_instances) 2037 { 2038 SOC_INIT_FUNC_DEFS; 2039 2040 if(portmod_pm_instances == NULL){ 2041 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_instances NULL parameter")); 2042 } 2043 sal_memset(portmod_pm_instances, 0, sizeof(portmod_pm_instances_t)); 2044 portmod_pm_instances->type = portmodDispatchTypeCount; 2045 portmod_pm_instances->instances = 0; 2046 2047 2048 exit: 2049 SOC_FUNC_RETURN; 2050 2051 } 2052 2053 int portmod_pm_interface_type_is_supported(int unit, pm_info_t pm_info, soc_port_if_t interface, int* is_supported) 2054 { 2055 2056 portmod_dispatch_type_t __type__; 2057 int __rv__; 2058 SOC_INIT_FUNC_DEFS; 2059 2060 if(is_supported == NULL) { 2061 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("is_supported NULL parameter")); 2062 } 2063 /* Dispatch */ 2064 __type__ = (pm_info)->type; 2065 if(__type__ >= portmodDispatchTypeCount) { 2066 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2067 } 2068 2069 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_interface_type_is_supported) { 2070 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_interface_type_is_supported(unit, interface, is_supported); 2071 _SOC_IF_ERR_EXIT(__rv__); 2072 } else { 2073 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_interface_type_is_supported isn't implemented for driver type")); 2074 } 2075 2076 exit: 2077 SOC_FUNC_RETURN; 2078 2079 } 2080 2081 2082 int portmod_pm_init(int unit, const portmod_pm_create_info_internal_t* pm_add_info, int wb_buffer_index, pm_info_t pm_info) 2083 { 2084 2085 portmod_dispatch_type_t __type__; 2086 int __rv__; 2087 SOC_INIT_FUNC_DEFS; 2088 2089 /* Dispatch */ 2090 __type__ = (pm_add_info)->type; 2091 if(__type__ >= portmodDispatchTypeCount) { 2092 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2093 } 2094 2095 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_init) { 2096 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_init(unit, pm_add_info, wb_buffer_index, pm_info); 2097 _SOC_IF_ERR_EXIT(__rv__); 2098 } else { 2099 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_init isn't implemented for driver type")); 2100 } 2101 2102 exit: 2103 SOC_FUNC_RETURN; 2104 2105 } 2106 2107 2108 int portmod_pm_destroy(int unit, pm_info_t pm_info) 2109 { 2110 2111 portmod_dispatch_type_t __type__; 2112 int __rv__; 2113 SOC_INIT_FUNC_DEFS; 2114 2115 /* Dispatch */ 2116 __type__ = (pm_info)->type; 2117 if(__type__ >= portmodDispatchTypeCount) { 2118 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2119 } 2120 2121 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_destroy) { 2122 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_destroy(unit, pm_info); 2123 _SOC_IF_ERR_EXIT(__rv__); 2124 } else { 2125 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_destroy isn't implemented for driver type")); 2126 } 2127 2128 exit: 2129 SOC_FUNC_RETURN; 2130 2131 } 2132 2133 2134 int portmod_port_attach(int unit, int port, const portmod_port_add_info_t* add_info) 2135 { 2136 2137 portmod_dispatch_type_t __type__; 2138 int __rv__; 2139 SOC_INIT_FUNC_DEFS; 2140 2141 if(SOC_E_NONE != portmod_port_add_info_t_validate(unit, add_info)) { 2142 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("add_info validation failed")); 2143 } 2144 2145 /* Dispatch */ 2146 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2147 if(__type__ >= portmodDispatchTypeCount) { 2148 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2149 } 2150 2151 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_attach) { 2152 pm_info_t pm_info; 2153 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2154 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_attach(unit, port, pm_info, add_info); 2155 _SOC_IF_ERR_EXIT(__rv__); 2156 } else { 2157 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_attach isn't implemented for driver type")); 2158 } 2159 2160 exit: 2161 SOC_FUNC_RETURN; 2162 2163 } 2164 2165 2166 int portmod_default_bus_update(int unit, pm_info_t pm_info, const portmod_bus_update_t* update) 2167 { 2168 2169 portmod_dispatch_type_t __type__; 2170 int __rv__; 2171 SOC_INIT_FUNC_DEFS; 2172 2173 /* Dispatch */ 2174 __type__ = (pm_info)->type; 2175 if(__type__ >= portmodDispatchTypeCount) { 2176 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2177 } 2178 2179 if(NULL != __portmod__dispatch__[__type__]->f_portmod_default_bus_update) { 2180 __rv__ = __portmod__dispatch__[__type__]->f_portmod_default_bus_update(unit, pm_info, update); 2181 _SOC_IF_ERR_EXIT(__rv__); 2182 } else { 2183 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_default_bus_update isn't implemented for driver type")); 2184 } 2185 2186 exit: 2187 SOC_FUNC_RETURN; 2188 2189 } 2190 2191 2192 int portmod_pm_bypass_set(int unit, int enable) 2193 { 2194 2195 portmod_dispatch_type_t __type__; 2196 int __rv__; 2197 SOC_INIT_FUNC_DEFS; 2198 2199 /* Dispatch */ 2200 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, enable, &enable, &__type__)); 2201 if(__type__ >= portmodDispatchTypeCount) { 2202 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2203 } 2204 2205 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_bypass_set) { 2206 pm_info_t pm_info; 2207 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, enable, &pm_info)); 2208 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_bypass_set(unit, pm_info, enable); 2209 _SOC_IF_ERR_EXIT(__rv__); 2210 } else { 2211 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_bypass_set isn't implemented for driver type")); 2212 } 2213 2214 exit: 2215 SOC_FUNC_RETURN; 2216 2217 } 2218 2219 2220 int portmod_pm_core_info_get(int unit, pm_info_t pm_info, int phyn, portmod_pm_core_info_t* core_info) 2221 { 2222 2223 portmod_dispatch_type_t __type__; 2224 int __rv__; 2225 SOC_INIT_FUNC_DEFS; 2226 2227 if(core_info == NULL) { 2228 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_info NULL parameter")); 2229 } 2230 if(SOC_E_NONE != portmod_pm_core_info_t_init(unit, core_info)) { 2231 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_info initialization failed")); 2232 } 2233 2234 /* Dispatch */ 2235 __type__ = (pm_info)->type; 2236 if(__type__ >= portmodDispatchTypeCount) { 2237 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2238 } 2239 2240 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_core_info_get) { 2241 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_core_info_get(unit, pm_info, phyn, core_info); 2242 _SOC_IF_ERR_EXIT(__rv__); 2243 } else { 2244 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_core_info_get isn't implemented for driver type")); 2245 } 2246 2247 exit: 2248 SOC_FUNC_RETURN; 2249 2250 } 2251 2252 2253 int portmod_pm_aggregated_update(int unit, pm_info_t pm_info, int core_id, int nof_aggregated_pms, const pm_info_t* pms, const int* pm_ids) 2254 { 2255 2256 portmod_dispatch_type_t __type__; 2257 int __rv__; 2258 SOC_INIT_FUNC_DEFS; 2259 2260 /* Dispatch */ 2261 __type__ = (pm_info)->type; 2262 if(__type__ >= portmodDispatchTypeCount) { 2263 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2264 } 2265 2266 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_aggregated_update) { 2267 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_aggregated_update(unit, pm_info, core_id, nof_aggregated_pms, pms, pm_ids); 2268 _SOC_IF_ERR_EXIT(__rv__); 2269 } else { 2270 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_aggregated_update isn't implemented for driver type")); 2271 } 2272 2273 exit: 2274 SOC_FUNC_RETURN; 2275 2276 } 2277 2278 2279 int portmod_pm_phys_get(int unit, pm_info_t pm_info, portmod_pbmp_t* phys) 2280 { 2281 2282 portmod_dispatch_type_t __type__; 2283 int __rv__; 2284 SOC_INIT_FUNC_DEFS; 2285 2286 if(phys == NULL) { 2287 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("phys NULL parameter")); 2288 } 2289 /* Dispatch */ 2290 __type__ = (pm_info)->type; 2291 if(__type__ >= portmodDispatchTypeCount) { 2292 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2293 } 2294 2295 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_phys_get) { 2296 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_phys_get(unit, pm_info, phys); 2297 _SOC_IF_ERR_EXIT(__rv__); 2298 } else { 2299 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_phys_get isn't implemented for driver type")); 2300 } 2301 2302 exit: 2303 SOC_FUNC_RETURN; 2304 2305 } 2306 2307 2308 int portmod_port_detach(int unit, int port) 2309 { 2310 2311 portmod_dispatch_type_t __type__; 2312 int __rv__; 2313 SOC_INIT_FUNC_DEFS; 2314 2315 /* Dispatch */ 2316 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2317 if(__type__ >= portmodDispatchTypeCount) { 2318 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2319 } 2320 2321 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_detach) { 2322 pm_info_t pm_info; 2323 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2324 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_detach(unit, port, pm_info); 2325 _SOC_IF_ERR_EXIT(__rv__); 2326 } else { 2327 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_detach isn't implemented for driver type")); 2328 } 2329 2330 exit: 2331 SOC_FUNC_RETURN; 2332 2333 } 2334 2335 2336 int portmod_port_replace(int unit, int port, int new_port) 2337 { 2338 2339 portmod_dispatch_type_t __type__; 2340 int __rv__; 2341 SOC_INIT_FUNC_DEFS; 2342 2343 /* Dispatch */ 2344 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2345 if(__type__ >= portmodDispatchTypeCount) { 2346 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2347 } 2348 2349 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_replace) { 2350 pm_info_t pm_info; 2351 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2352 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_replace(unit, port, pm_info, new_port); 2353 _SOC_IF_ERR_EXIT(__rv__); 2354 } else { 2355 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_replace isn't implemented for driver type")); 2356 } 2357 2358 exit: 2359 SOC_FUNC_RETURN; 2360 2361 } 2362 2363 2364 int portmod_port_enable_set(int unit, int port, int flags, int enable) 2365 { 2366 2367 portmod_dispatch_type_t __type__; 2368 int __rv__; 2369 SOC_INIT_FUNC_DEFS; 2370 2371 switch(enable) { 2372 case 0: 2373 case 1: 2374 break; 2375 default: 2376 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable not allowed value")); 2377 break; 2378 } 2379 2380 /* Dispatch */ 2381 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2382 if(__type__ >= portmodDispatchTypeCount) { 2383 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2384 } 2385 2386 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_enable_set) { 2387 pm_info_t pm_info; 2388 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2389 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_enable_set(unit, port, pm_info, flags, enable); 2390 _SOC_IF_ERR_EXIT(__rv__); 2391 } else { 2392 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_enable_set isn't implemented for driver type")); 2393 } 2394 2395 exit: 2396 SOC_FUNC_RETURN; 2397 2398 } 2399 2400 2401 int portmod_port_enable_get(int unit, int port, int flags, int* enable) 2402 { 2403 2404 portmod_dispatch_type_t __type__; 2405 int __rv__; 2406 SOC_INIT_FUNC_DEFS; 2407 2408 if(enable == NULL) { 2409 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 2410 } 2411 /* Dispatch */ 2412 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2413 if(__type__ >= portmodDispatchTypeCount) { 2414 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2415 } 2416 2417 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_enable_get) { 2418 pm_info_t pm_info; 2419 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2420 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_enable_get(unit, port, pm_info, flags, enable); 2421 _SOC_IF_ERR_EXIT(__rv__); 2422 } else { 2423 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_enable_get isn't implemented for driver type")); 2424 } 2425 2426 exit: 2427 SOC_FUNC_RETURN; 2428 2429 } 2430 2431 2432 int portmod_port_cdr_lock_get(int unit, int port, int* is_locked) 2433 { 2434 2435 portmod_dispatch_type_t __type__; 2436 int __rv__; 2437 SOC_INIT_FUNC_DEFS; 2438 2439 if(is_locked == NULL) { 2440 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("is_locked NULL parameter")); 2441 } 2442 /* Dispatch */ 2443 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2444 if(__type__ >= portmodDispatchTypeCount) { 2445 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2446 } 2447 2448 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_cdr_lock_get) { 2449 pm_info_t pm_info; 2450 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2451 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_cdr_lock_get(unit, port, pm_info, is_locked); 2452 _SOC_IF_ERR_EXIT(__rv__); 2453 } else { 2454 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_cdr_lock_get isn't implemented for driver type")); 2455 } 2456 2457 exit: 2458 SOC_FUNC_RETURN; 2459 2460 } 2461 2462 2463 int portmod_port_interface_config_set(int unit, int port, const portmod_port_interface_config_t* config, int phy_init_flags) 2464 { 2465 2466 portmod_dispatch_type_t __type__; 2467 int __rv__; 2468 SOC_INIT_FUNC_DEFS; 2469 2470 if(SOC_E_NONE != portmod_port_interface_config_t_validate(unit, config)) { 2471 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 2472 } 2473 2474 /* Dispatch */ 2475 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2476 if(__type__ >= portmodDispatchTypeCount) { 2477 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2478 } 2479 2480 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interface_config_set) { 2481 pm_info_t pm_info; 2482 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2483 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interface_config_set(unit, port, pm_info, config, phy_init_flags); 2484 _SOC_IF_ERR_EXIT(__rv__); 2485 } else { 2486 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interface_config_set isn't implemented for driver type")); 2487 } 2488 2489 exit: 2490 SOC_FUNC_RETURN; 2491 2492 } 2493 2494 2495 int portmod_port_interface_config_get(int unit, int port, portmod_port_interface_config_t* config, int phy_init_flags) 2496 { 2497 2498 portmod_dispatch_type_t __type__; 2499 int __rv__; 2500 SOC_INIT_FUNC_DEFS; 2501 2502 if(config == NULL) { 2503 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 2504 } 2505 if(SOC_E_NONE != portmod_port_interface_config_t_init(unit, config)) { 2506 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config initialization failed")); 2507 } 2508 2509 /* Dispatch */ 2510 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2511 if(__type__ >= portmodDispatchTypeCount) { 2512 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2513 } 2514 2515 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interface_config_get) { 2516 pm_info_t pm_info; 2517 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2518 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interface_config_get(unit, port, pm_info, config, phy_init_flags); 2519 _SOC_IF_ERR_EXIT(__rv__); 2520 } else { 2521 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interface_config_get isn't implemented for driver type")); 2522 } 2523 2524 exit: 2525 SOC_FUNC_RETURN; 2526 2527 } 2528 2529 2530 int portmod_port_default_interface_get(int unit, int port, const portmod_port_interface_config_t* config, soc_port_if_t* interface) 2531 { 2532 2533 portmod_dispatch_type_t __type__; 2534 int __rv__; 2535 SOC_INIT_FUNC_DEFS; 2536 2537 if(SOC_E_NONE != portmod_port_interface_config_t_validate(unit, config)) { 2538 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 2539 } 2540 2541 if(interface == NULL) { 2542 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("interface NULL parameter")); 2543 } 2544 /* Dispatch */ 2545 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2546 if(__type__ >= portmodDispatchTypeCount) { 2547 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2548 } 2549 2550 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_default_interface_get) { 2551 pm_info_t pm_info; 2552 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2553 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_default_interface_get(unit, port, pm_info, config, interface); 2554 _SOC_IF_ERR_EXIT(__rv__); 2555 } else { 2556 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_default_interface_get isn't implemented for driver type")); 2557 } 2558 2559 exit: 2560 SOC_FUNC_RETURN; 2561 2562 } 2563 2564 2565 int portmod_port_interface_check(int unit, int port, const portmod_port_interface_config_t* config, int is_ext_phy, soc_port_if_t interface, int* is_valid) 2566 { 2567 2568 portmod_dispatch_type_t __type__; 2569 int __rv__; 2570 SOC_INIT_FUNC_DEFS; 2571 2572 if(SOC_E_NONE != portmod_port_interface_config_t_validate(unit, config)) { 2573 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 2574 } 2575 2576 if(is_valid == NULL) { 2577 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("is_valid NULL parameter")); 2578 } 2579 /* Dispatch */ 2580 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2581 if(__type__ >= portmodDispatchTypeCount) { 2582 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2583 } 2584 2585 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interface_check) { 2586 pm_info_t pm_info; 2587 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2588 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interface_check(unit, port, pm_info, config, is_ext_phy, interface, is_valid); 2589 _SOC_IF_ERR_EXIT(__rv__); 2590 } else { 2591 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interface_check isn't implemented for driver type")); 2592 } 2593 2594 exit: 2595 SOC_FUNC_RETURN; 2596 2597 } 2598 2599 2600 int portmod_port_encoding_set(int unit, int port, uint32 properties, portmod_port_pcs_t encoding) 2601 { 2602 2603 portmod_dispatch_type_t __type__; 2604 int __rv__; 2605 SOC_INIT_FUNC_DEFS; 2606 2607 /* Dispatch */ 2608 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2609 if(__type__ >= portmodDispatchTypeCount) { 2610 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2611 } 2612 2613 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_encoding_set) { 2614 pm_info_t pm_info; 2615 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2616 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_encoding_set(unit, port, pm_info, properties, encoding); 2617 _SOC_IF_ERR_EXIT(__rv__); 2618 } else { 2619 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_encoding_set isn't implemented for driver type")); 2620 } 2621 2622 exit: 2623 SOC_FUNC_RETURN; 2624 2625 } 2626 2627 2628 int portmod_port_encoding_get(int unit, int port, uint32* properties, portmod_port_pcs_t* encoding) 2629 { 2630 2631 portmod_dispatch_type_t __type__; 2632 int __rv__; 2633 SOC_INIT_FUNC_DEFS; 2634 2635 if(properties == NULL) { 2636 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("properties NULL parameter")); 2637 } 2638 if(encoding == NULL) { 2639 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("encoding NULL parameter")); 2640 } 2641 /* Dispatch */ 2642 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2643 if(__type__ >= portmodDispatchTypeCount) { 2644 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2645 } 2646 2647 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_encoding_get) { 2648 pm_info_t pm_info; 2649 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2650 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_encoding_get(unit, port, pm_info, properties, encoding); 2651 _SOC_IF_ERR_EXIT(__rv__); 2652 } else { 2653 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_encoding_get isn't implemented for driver type")); 2654 } 2655 2656 exit: 2657 SOC_FUNC_RETURN; 2658 2659 } 2660 2661 2662 int portmod_port_cl72_set(int unit, int port, uint32 enable) 2663 { 2664 2665 portmod_dispatch_type_t __type__; 2666 int __rv__; 2667 SOC_INIT_FUNC_DEFS; 2668 2669 /* Dispatch */ 2670 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2671 if(__type__ >= portmodDispatchTypeCount) { 2672 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2673 } 2674 2675 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_cl72_set) { 2676 pm_info_t pm_info; 2677 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2678 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_cl72_set(unit, port, pm_info, enable); 2679 _SOC_IF_ERR_EXIT(__rv__); 2680 } else { 2681 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_cl72_set isn't implemented for driver type")); 2682 } 2683 2684 exit: 2685 SOC_FUNC_RETURN; 2686 2687 } 2688 2689 2690 int portmod_port_cl72_get(int unit, int port, uint32* enable) 2691 { 2692 2693 portmod_dispatch_type_t __type__; 2694 int __rv__; 2695 SOC_INIT_FUNC_DEFS; 2696 2697 if(enable == NULL) { 2698 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 2699 } 2700 /* Dispatch */ 2701 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2702 if(__type__ >= portmodDispatchTypeCount) { 2703 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2704 } 2705 2706 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_cl72_get) { 2707 pm_info_t pm_info; 2708 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2709 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_cl72_get(unit, port, pm_info, enable); 2710 _SOC_IF_ERR_EXIT(__rv__); 2711 } else { 2712 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_cl72_get isn't implemented for driver type")); 2713 } 2714 2715 exit: 2716 SOC_FUNC_RETURN; 2717 2718 } 2719 2720 2721 int portmod_port_cl72_status_get(int unit, int port, phymod_cl72_status_t* status) 2722 { 2723 2724 portmod_dispatch_type_t __type__; 2725 int __rv__; 2726 SOC_INIT_FUNC_DEFS; 2727 2728 if(status == NULL) { 2729 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("status NULL parameter")); 2730 } 2731 /* Dispatch */ 2732 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2733 if(__type__ >= portmodDispatchTypeCount) { 2734 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2735 } 2736 2737 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_cl72_status_get) { 2738 pm_info_t pm_info; 2739 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2740 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_cl72_status_get(unit, port, pm_info, status); 2741 _SOC_IF_ERR_EXIT(__rv__); 2742 } else { 2743 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_cl72_status_get isn't implemented for driver type")); 2744 } 2745 2746 exit: 2747 SOC_FUNC_RETURN; 2748 2749 } 2750 2751 2752 int portmod_port_loopback_set(int unit, int port, portmod_loopback_mode_t loopback_type, int enable) 2753 { 2754 2755 portmod_dispatch_type_t __type__; 2756 int __rv__; 2757 SOC_INIT_FUNC_DEFS; 2758 2759 if(SOC_E_NONE != portmod_loopback_mode_t_validate(unit, loopback_type)) { 2760 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("loopback_type validation failed")); 2761 } 2762 2763 /* Dispatch */ 2764 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2765 if(__type__ >= portmodDispatchTypeCount) { 2766 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2767 } 2768 2769 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_loopback_set) { 2770 pm_info_t pm_info; 2771 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2772 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_loopback_set(unit, port, pm_info, loopback_type, enable); 2773 _SOC_IF_ERR_EXIT(__rv__); 2774 } else { 2775 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_loopback_set isn't implemented for driver type")); 2776 } 2777 2778 exit: 2779 SOC_FUNC_RETURN; 2780 2781 } 2782 2783 2784 int portmod_port_loopback_get(int unit, int port, portmod_loopback_mode_t loopback_type, int* enable) 2785 { 2786 2787 portmod_dispatch_type_t __type__; 2788 int __rv__; 2789 SOC_INIT_FUNC_DEFS; 2790 2791 if(SOC_E_NONE != portmod_loopback_mode_t_validate(unit, loopback_type)) { 2792 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("loopback_type validation failed")); 2793 } 2794 2795 if(enable == NULL) { 2796 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 2797 } 2798 /* Dispatch */ 2799 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2800 if(__type__ >= portmodDispatchTypeCount) { 2801 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2802 } 2803 2804 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_loopback_get) { 2805 pm_info_t pm_info; 2806 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2807 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_loopback_get(unit, port, pm_info, loopback_type, enable); 2808 _SOC_IF_ERR_EXIT(__rv__); 2809 } else { 2810 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_loopback_get isn't implemented for driver type")); 2811 } 2812 2813 exit: 2814 SOC_FUNC_RETURN; 2815 2816 } 2817 2818 2819 int portmod_port_pass_through_set(int unit, int port, int loopback_en, int enable) 2820 { 2821 2822 portmod_dispatch_type_t __type__; 2823 int __rv__; 2824 SOC_INIT_FUNC_DEFS; 2825 2826 /* Dispatch */ 2827 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2828 if(__type__ >= portmodDispatchTypeCount) { 2829 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2830 } 2831 2832 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pass_through_set) { 2833 pm_info_t pm_info; 2834 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2835 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pass_through_set(unit, port, pm_info, loopback_en, enable); 2836 _SOC_IF_ERR_EXIT(__rv__); 2837 } else { 2838 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pass_through_set isn't implemented for driver type")); 2839 } 2840 2841 exit: 2842 SOC_FUNC_RETURN; 2843 2844 } 2845 2846 2847 int portmod_port_pass_through_get(int unit, int port, int* loopback_en, int* enable) 2848 { 2849 2850 portmod_dispatch_type_t __type__; 2851 int __rv__; 2852 SOC_INIT_FUNC_DEFS; 2853 2854 if(loopback_en == NULL) { 2855 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("loopback_en NULL parameter")); 2856 } 2857 if(enable == NULL) { 2858 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 2859 } 2860 /* Dispatch */ 2861 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2862 if(__type__ >= portmodDispatchTypeCount) { 2863 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2864 } 2865 2866 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pass_through_get) { 2867 pm_info_t pm_info; 2868 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2869 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pass_through_get(unit, port, pm_info, loopback_en, enable); 2870 _SOC_IF_ERR_EXIT(__rv__); 2871 } else { 2872 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pass_through_get isn't implemented for driver type")); 2873 } 2874 2875 exit: 2876 SOC_FUNC_RETURN; 2877 2878 } 2879 2880 2881 int portmod_port_pass_through_calibrate(int unit, int port) 2882 { 2883 2884 portmod_dispatch_type_t __type__; 2885 int __rv__; 2886 SOC_INIT_FUNC_DEFS; 2887 2888 /* Dispatch */ 2889 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2890 if(__type__ >= portmodDispatchTypeCount) { 2891 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2892 } 2893 2894 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pass_through_calibrate) { 2895 pm_info_t pm_info; 2896 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2897 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pass_through_calibrate(unit, port, pm_info); 2898 _SOC_IF_ERR_EXIT(__rv__); 2899 } else { 2900 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pass_through_calibrate isn't implemented for driver type")); 2901 } 2902 2903 exit: 2904 SOC_FUNC_RETURN; 2905 2906 } 2907 2908 2909 int portmod_port_pass_through_fec_enable_set(int unit, int port, int enable) 2910 { 2911 2912 portmod_dispatch_type_t __type__; 2913 int __rv__; 2914 SOC_INIT_FUNC_DEFS; 2915 2916 /* Dispatch */ 2917 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2918 if(__type__ >= portmodDispatchTypeCount) { 2919 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2920 } 2921 2922 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pass_through_fec_enable_set) { 2923 pm_info_t pm_info; 2924 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2925 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pass_through_fec_enable_set(unit, port, pm_info, enable); 2926 _SOC_IF_ERR_EXIT(__rv__); 2927 } else { 2928 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pass_through_fec_enable_set isn't implemented for driver type")); 2929 } 2930 2931 exit: 2932 SOC_FUNC_RETURN; 2933 2934 } 2935 2936 2937 int portmod_port_pass_through_fec_enable_get(int unit, int port, int* enable) 2938 { 2939 2940 portmod_dispatch_type_t __type__; 2941 int __rv__; 2942 SOC_INIT_FUNC_DEFS; 2943 2944 if(enable == NULL) { 2945 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 2946 } 2947 /* Dispatch */ 2948 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2949 if(__type__ >= portmodDispatchTypeCount) { 2950 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2951 } 2952 2953 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pass_through_fec_enable_get) { 2954 pm_info_t pm_info; 2955 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2956 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pass_through_fec_enable_get(unit, port, pm_info, enable); 2957 _SOC_IF_ERR_EXIT(__rv__); 2958 } else { 2959 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pass_through_fec_enable_get isn't implemented for driver type")); 2960 } 2961 2962 exit: 2963 SOC_FUNC_RETURN; 2964 2965 } 2966 2967 2968 int portmod_port_rx_mac_enable_set(int unit, int port, int enable) 2969 { 2970 2971 portmod_dispatch_type_t __type__; 2972 int __rv__; 2973 SOC_INIT_FUNC_DEFS; 2974 2975 /* Dispatch */ 2976 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 2977 if(__type__ >= portmodDispatchTypeCount) { 2978 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 2979 } 2980 2981 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_enable_set) { 2982 pm_info_t pm_info; 2983 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 2984 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_enable_set(unit, port, pm_info, enable); 2985 _SOC_IF_ERR_EXIT(__rv__); 2986 } else { 2987 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rx_mac_enable_set isn't implemented for driver type")); 2988 } 2989 2990 exit: 2991 SOC_FUNC_RETURN; 2992 2993 } 2994 2995 2996 int portmod_port_rx_mac_enable_get(int unit, int port, int* enable) 2997 { 2998 2999 portmod_dispatch_type_t __type__; 3000 int __rv__; 3001 SOC_INIT_FUNC_DEFS; 3002 3003 if(enable == NULL) { 3004 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 3005 } 3006 /* Dispatch */ 3007 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3008 if(__type__ >= portmodDispatchTypeCount) { 3009 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3010 } 3011 3012 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_enable_get) { 3013 pm_info_t pm_info; 3014 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3015 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_enable_get(unit, port, pm_info, enable); 3016 _SOC_IF_ERR_EXIT(__rv__); 3017 } else { 3018 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rx_mac_enable_get isn't implemented for driver type")); 3019 } 3020 3021 exit: 3022 SOC_FUNC_RETURN; 3023 3024 } 3025 3026 3027 int portmod_port_tx_mac_enable_set(int unit, int port, int enable) 3028 { 3029 3030 portmod_dispatch_type_t __type__; 3031 int __rv__; 3032 SOC_INIT_FUNC_DEFS; 3033 3034 /* Dispatch */ 3035 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3036 if(__type__ >= portmodDispatchTypeCount) { 3037 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3038 } 3039 3040 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_enable_set) { 3041 pm_info_t pm_info; 3042 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3043 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_enable_set(unit, port, pm_info, enable); 3044 _SOC_IF_ERR_EXIT(__rv__); 3045 } else { 3046 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_mac_enable_set isn't implemented for driver type")); 3047 } 3048 3049 exit: 3050 SOC_FUNC_RETURN; 3051 3052 } 3053 3054 3055 int portmod_port_tx_mac_enable_get(int unit, int port, int* enable) 3056 { 3057 3058 portmod_dispatch_type_t __type__; 3059 int __rv__; 3060 SOC_INIT_FUNC_DEFS; 3061 3062 if(enable == NULL) { 3063 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 3064 } 3065 /* Dispatch */ 3066 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3067 if(__type__ >= portmodDispatchTypeCount) { 3068 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3069 } 3070 3071 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_enable_get) { 3072 pm_info_t pm_info; 3073 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3074 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_enable_get(unit, port, pm_info, enable); 3075 _SOC_IF_ERR_EXIT(__rv__); 3076 } else { 3077 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_mac_enable_get isn't implemented for driver type")); 3078 } 3079 3080 exit: 3081 SOC_FUNC_RETURN; 3082 3083 } 3084 3085 3086 int portmod_port_ability_local_get(int unit, int port, uint32 phy_flags, portmod_port_ability_t* ability) 3087 { 3088 3089 portmod_dispatch_type_t __type__; 3090 int __rv__; 3091 SOC_INIT_FUNC_DEFS; 3092 3093 if(ability == NULL) { 3094 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ability NULL parameter")); 3095 } 3096 /* Dispatch */ 3097 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3098 if(__type__ >= portmodDispatchTypeCount) { 3099 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3100 } 3101 3102 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ability_local_get) { 3103 pm_info_t pm_info; 3104 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3105 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ability_local_get(unit, port, pm_info, phy_flags, ability); 3106 _SOC_IF_ERR_EXIT(__rv__); 3107 } else { 3108 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ability_local_get isn't implemented for driver type")); 3109 } 3110 3111 exit: 3112 SOC_FUNC_RETURN; 3113 3114 } 3115 3116 3117 int portmod_port_autoneg_set(int unit, int port, uint32 phy_flags, const phymod_autoneg_control_t* an) 3118 { 3119 3120 portmod_dispatch_type_t __type__; 3121 int __rv__; 3122 SOC_INIT_FUNC_DEFS; 3123 3124 /* Dispatch */ 3125 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3126 if(__type__ >= portmodDispatchTypeCount) { 3127 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3128 } 3129 3130 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_autoneg_set) { 3131 pm_info_t pm_info; 3132 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3133 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_autoneg_set(unit, port, pm_info, phy_flags, an); 3134 _SOC_IF_ERR_EXIT(__rv__); 3135 } else { 3136 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_autoneg_set isn't implemented for driver type")); 3137 } 3138 3139 exit: 3140 SOC_FUNC_RETURN; 3141 3142 } 3143 3144 3145 int portmod_port_autoneg_get(int unit, int port, uint32 phy_flags, phymod_autoneg_control_t* an) 3146 { 3147 3148 portmod_dispatch_type_t __type__; 3149 int __rv__; 3150 SOC_INIT_FUNC_DEFS; 3151 3152 if(an == NULL) { 3153 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("an NULL parameter")); 3154 } 3155 /* Dispatch */ 3156 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3157 if(__type__ >= portmodDispatchTypeCount) { 3158 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3159 } 3160 3161 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_autoneg_get) { 3162 pm_info_t pm_info; 3163 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3164 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_autoneg_get(unit, port, pm_info, phy_flags, an); 3165 _SOC_IF_ERR_EXIT(__rv__); 3166 } else { 3167 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_autoneg_get isn't implemented for driver type")); 3168 } 3169 3170 exit: 3171 SOC_FUNC_RETURN; 3172 3173 } 3174 3175 3176 int portmod_port_autoneg_status_get(int unit, int port, phymod_autoneg_status_t* an_status) 3177 { 3178 3179 portmod_dispatch_type_t __type__; 3180 int __rv__; 3181 SOC_INIT_FUNC_DEFS; 3182 3183 if(an_status == NULL) { 3184 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("an_status NULL parameter")); 3185 } 3186 /* Dispatch */ 3187 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3188 if(__type__ >= portmodDispatchTypeCount) { 3189 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3190 } 3191 3192 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_autoneg_status_get) { 3193 pm_info_t pm_info; 3194 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3195 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_autoneg_status_get(unit, port, pm_info, an_status); 3196 _SOC_IF_ERR_EXIT(__rv__); 3197 } else { 3198 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_autoneg_status_get isn't implemented for driver type")); 3199 } 3200 3201 exit: 3202 SOC_FUNC_RETURN; 3203 3204 } 3205 3206 3207 int portmod_port_link_get(int unit, int port, int flags, int* link) 3208 { 3209 3210 portmod_dispatch_type_t __type__; 3211 int __rv__; 3212 SOC_INIT_FUNC_DEFS; 3213 3214 if(link == NULL) { 3215 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("link NULL parameter")); 3216 } 3217 /* Dispatch */ 3218 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3219 if(__type__ >= portmodDispatchTypeCount) { 3220 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3221 } 3222 3223 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_link_get) { 3224 pm_info_t pm_info; 3225 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3226 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_link_get(unit, port, pm_info, flags, link); 3227 _SOC_IF_ERR_EXIT(__rv__); 3228 } else { 3229 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_link_get isn't implemented for driver type")); 3230 } 3231 3232 exit: 3233 SOC_FUNC_RETURN; 3234 3235 } 3236 3237 3238 int portmod_port_link_latch_down_get(int unit, int port, uint32 flags, int* link) 3239 { 3240 3241 portmod_dispatch_type_t __type__; 3242 int __rv__; 3243 SOC_INIT_FUNC_DEFS; 3244 3245 if(link == NULL) { 3246 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("link NULL parameter")); 3247 } 3248 /* Dispatch */ 3249 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3250 if(__type__ >= portmodDispatchTypeCount) { 3251 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3252 } 3253 3254 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_link_latch_down_get) { 3255 pm_info_t pm_info; 3256 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3257 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_link_latch_down_get(unit, port, pm_info, flags, link); 3258 _SOC_IF_ERR_EXIT(__rv__); 3259 } else { 3260 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_link_latch_down_get isn't implemented for driver type")); 3261 } 3262 3263 exit: 3264 SOC_FUNC_RETURN; 3265 3266 } 3267 3268 3269 int portmod_port_phy_link_up_event(int unit, int port) 3270 { 3271 3272 portmod_dispatch_type_t __type__; 3273 int __rv__; 3274 SOC_INIT_FUNC_DEFS; 3275 3276 /* Dispatch */ 3277 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3278 if(__type__ >= portmodDispatchTypeCount) { 3279 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3280 } 3281 3282 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_link_up_event) { 3283 pm_info_t pm_info; 3284 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3285 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_link_up_event(unit, port, pm_info); 3286 _SOC_IF_ERR_EXIT(__rv__); 3287 } else { 3288 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_link_up_event isn't implemented for driver type")); 3289 } 3290 3291 exit: 3292 SOC_FUNC_RETURN; 3293 3294 } 3295 3296 3297 int portmod_port_phy_link_down_event(int unit, int port) 3298 { 3299 3300 portmod_dispatch_type_t __type__; 3301 int __rv__; 3302 SOC_INIT_FUNC_DEFS; 3303 3304 /* Dispatch */ 3305 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3306 if(__type__ >= portmodDispatchTypeCount) { 3307 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3308 } 3309 3310 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_link_down_event) { 3311 pm_info_t pm_info; 3312 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3313 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_link_down_event(unit, port, pm_info); 3314 _SOC_IF_ERR_EXIT(__rv__); 3315 } else { 3316 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_link_down_event isn't implemented for driver type")); 3317 } 3318 3319 exit: 3320 SOC_FUNC_RETURN; 3321 3322 } 3323 3324 3325 int portmod_port_prbs_config_set(int unit, int port, portmod_prbs_mode_t mode, int flags, const phymod_prbs_t* config) 3326 { 3327 3328 portmod_dispatch_type_t __type__; 3329 int __rv__; 3330 SOC_INIT_FUNC_DEFS; 3331 3332 if(SOC_E_NONE != portmod_prbs_mode_t_validate(unit, mode)) { 3333 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode validation failed")); 3334 } 3335 3336 /* Dispatch */ 3337 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3338 if(__type__ >= portmodDispatchTypeCount) { 3339 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3340 } 3341 3342 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_prbs_config_set) { 3343 pm_info_t pm_info; 3344 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3345 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_prbs_config_set(unit, port, pm_info, mode, flags, config); 3346 _SOC_IF_ERR_EXIT(__rv__); 3347 } else { 3348 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_prbs_config_set isn't implemented for driver type")); 3349 } 3350 3351 exit: 3352 SOC_FUNC_RETURN; 3353 3354 } 3355 3356 3357 int portmod_port_prbs_config_get(int unit, int port, portmod_prbs_mode_t mode, int flags, phymod_prbs_t* config) 3358 { 3359 3360 portmod_dispatch_type_t __type__; 3361 int __rv__; 3362 SOC_INIT_FUNC_DEFS; 3363 3364 if(SOC_E_NONE != portmod_prbs_mode_t_validate(unit, mode)) { 3365 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode validation failed")); 3366 } 3367 3368 if(config == NULL) { 3369 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 3370 } 3371 /* Dispatch */ 3372 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3373 if(__type__ >= portmodDispatchTypeCount) { 3374 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3375 } 3376 3377 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_prbs_config_get) { 3378 pm_info_t pm_info; 3379 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3380 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_prbs_config_get(unit, port, pm_info, mode, flags, config); 3381 _SOC_IF_ERR_EXIT(__rv__); 3382 } else { 3383 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_prbs_config_get isn't implemented for driver type")); 3384 } 3385 3386 exit: 3387 SOC_FUNC_RETURN; 3388 3389 } 3390 3391 3392 int portmod_port_prbs_enable_set(int unit, int port, portmod_prbs_mode_t mode, int flags, int enable) 3393 { 3394 3395 portmod_dispatch_type_t __type__; 3396 int __rv__; 3397 SOC_INIT_FUNC_DEFS; 3398 3399 if(SOC_E_NONE != portmod_prbs_mode_t_validate(unit, mode)) { 3400 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode validation failed")); 3401 } 3402 3403 switch(enable) { 3404 case 0: 3405 case 1: 3406 break; 3407 default: 3408 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable not allowed value")); 3409 break; 3410 } 3411 3412 /* Dispatch */ 3413 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3414 if(__type__ >= portmodDispatchTypeCount) { 3415 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3416 } 3417 3418 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_prbs_enable_set) { 3419 pm_info_t pm_info; 3420 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3421 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_prbs_enable_set(unit, port, pm_info, mode, flags, enable); 3422 _SOC_IF_ERR_EXIT(__rv__); 3423 } else { 3424 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_prbs_enable_set isn't implemented for driver type")); 3425 } 3426 3427 exit: 3428 SOC_FUNC_RETURN; 3429 3430 } 3431 3432 3433 int portmod_port_prbs_enable_get(int unit, int port, portmod_prbs_mode_t mode, int flags, int* enable) 3434 { 3435 3436 portmod_dispatch_type_t __type__; 3437 int __rv__; 3438 SOC_INIT_FUNC_DEFS; 3439 3440 if(SOC_E_NONE != portmod_prbs_mode_t_validate(unit, mode)) { 3441 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode validation failed")); 3442 } 3443 3444 if(enable == NULL) { 3445 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 3446 } 3447 /* Dispatch */ 3448 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3449 if(__type__ >= portmodDispatchTypeCount) { 3450 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3451 } 3452 3453 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_prbs_enable_get) { 3454 pm_info_t pm_info; 3455 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3456 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_prbs_enable_get(unit, port, pm_info, mode, flags, enable); 3457 _SOC_IF_ERR_EXIT(__rv__); 3458 } else { 3459 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_prbs_enable_get isn't implemented for driver type")); 3460 } 3461 3462 exit: 3463 SOC_FUNC_RETURN; 3464 3465 } 3466 3467 3468 int portmod_port_prbs_status_get(int unit, int port, portmod_prbs_mode_t mode, int flags, phymod_prbs_status_t* status) 3469 { 3470 3471 portmod_dispatch_type_t __type__; 3472 int __rv__; 3473 SOC_INIT_FUNC_DEFS; 3474 3475 if(SOC_E_NONE != portmod_prbs_mode_t_validate(unit, mode)) { 3476 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode validation failed")); 3477 } 3478 3479 if(status == NULL) { 3480 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("status NULL parameter")); 3481 } 3482 /* Dispatch */ 3483 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3484 if(__type__ >= portmodDispatchTypeCount) { 3485 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3486 } 3487 3488 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_prbs_status_get) { 3489 pm_info_t pm_info; 3490 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3491 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_prbs_status_get(unit, port, pm_info, mode, flags, status); 3492 _SOC_IF_ERR_EXIT(__rv__); 3493 } else { 3494 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_prbs_status_get isn't implemented for driver type")); 3495 } 3496 3497 exit: 3498 SOC_FUNC_RETURN; 3499 3500 } 3501 3502 3503 int portmod_port_nof_lanes_get(int unit, int port, int* nof_lanes) 3504 { 3505 3506 portmod_dispatch_type_t __type__; 3507 int __rv__; 3508 SOC_INIT_FUNC_DEFS; 3509 3510 if(nof_lanes == NULL) { 3511 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("nof_lanes NULL parameter")); 3512 } 3513 /* Dispatch */ 3514 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3515 if(__type__ >= portmodDispatchTypeCount) { 3516 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3517 } 3518 3519 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_nof_lanes_get) { 3520 pm_info_t pm_info; 3521 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3522 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_nof_lanes_get(unit, port, pm_info, nof_lanes); 3523 _SOC_IF_ERR_EXIT(__rv__); 3524 } else { 3525 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_nof_lanes_get isn't implemented for driver type")); 3526 } 3527 3528 exit: 3529 SOC_FUNC_RETURN; 3530 3531 } 3532 3533 3534 int portmod_port_ilkn_nof_segments_set(int unit, int port, uint32 nof_segments) 3535 { 3536 3537 portmod_dispatch_type_t __type__; 3538 int __rv__; 3539 SOC_INIT_FUNC_DEFS; 3540 3541 switch(nof_segments) { 3542 case 2: 3543 case 4: 3544 break; 3545 default: 3546 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("nof_segments not allowed value")); 3547 break; 3548 } 3549 3550 /* Dispatch */ 3551 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3552 if(__type__ >= portmodDispatchTypeCount) { 3553 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3554 } 3555 3556 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ilkn_nof_segments_set) { 3557 pm_info_t pm_info; 3558 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3559 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ilkn_nof_segments_set(unit, port, pm_info, nof_segments); 3560 _SOC_IF_ERR_EXIT(__rv__); 3561 } else { 3562 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ilkn_nof_segments_set isn't implemented for driver type")); 3563 } 3564 3565 exit: 3566 SOC_FUNC_RETURN; 3567 3568 } 3569 3570 3571 int portmod_port_ilkn_nof_segments_get(int unit, int port, uint32* nof_segments) 3572 { 3573 3574 portmod_dispatch_type_t __type__; 3575 int __rv__; 3576 SOC_INIT_FUNC_DEFS; 3577 3578 if(nof_segments == NULL) { 3579 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("nof_segments NULL parameter")); 3580 } 3581 /* Dispatch */ 3582 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3583 if(__type__ >= portmodDispatchTypeCount) { 3584 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3585 } 3586 3587 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ilkn_nof_segments_get) { 3588 pm_info_t pm_info; 3589 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3590 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ilkn_nof_segments_get(unit, port, pm_info, nof_segments); 3591 _SOC_IF_ERR_EXIT(__rv__); 3592 } else { 3593 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ilkn_nof_segments_get isn't implemented for driver type")); 3594 } 3595 3596 exit: 3597 SOC_FUNC_RETURN; 3598 3599 } 3600 3601 3602 int portmod_ilkn_retranstmit_config_set(int unit, int port, const ilkn_retransmit_config_t* retransmit_config) 3603 { 3604 3605 portmod_dispatch_type_t __type__; 3606 int __rv__; 3607 SOC_INIT_FUNC_DEFS; 3608 3609 /* Dispatch */ 3610 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3611 if(__type__ >= portmodDispatchTypeCount) { 3612 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3613 } 3614 3615 if(NULL != __portmod__dispatch__[__type__]->f_portmod_ilkn_retranstmit_config_set) { 3616 pm_info_t pm_info; 3617 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3618 __rv__ = __portmod__dispatch__[__type__]->f_portmod_ilkn_retranstmit_config_set(unit, port, pm_info, retransmit_config); 3619 _SOC_IF_ERR_EXIT(__rv__); 3620 } else { 3621 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_ilkn_retranstmit_config_set isn't implemented for driver type")); 3622 } 3623 3624 exit: 3625 SOC_FUNC_RETURN; 3626 3627 } 3628 3629 3630 int portmod_ilkn_retranstmit_config_get(int unit, int port, ilkn_retransmit_config_t* retransmit_config) 3631 { 3632 3633 portmod_dispatch_type_t __type__; 3634 int __rv__; 3635 SOC_INIT_FUNC_DEFS; 3636 3637 if(retransmit_config == NULL) { 3638 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("retransmit_config NULL parameter")); 3639 } 3640 /* Dispatch */ 3641 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3642 if(__type__ >= portmodDispatchTypeCount) { 3643 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3644 } 3645 3646 if(NULL != __portmod__dispatch__[__type__]->f_portmod_ilkn_retranstmit_config_get) { 3647 pm_info_t pm_info; 3648 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3649 __rv__ = __portmod__dispatch__[__type__]->f_portmod_ilkn_retranstmit_config_get(unit, port, pm_info, retransmit_config); 3650 _SOC_IF_ERR_EXIT(__rv__); 3651 } else { 3652 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_ilkn_retranstmit_config_get isn't implemented for driver type")); 3653 } 3654 3655 exit: 3656 SOC_FUNC_RETURN; 3657 3658 } 3659 3660 3661 int portmod_port_lanes_assign(int unit, int port, const portmod_lanes_assign_info_t* assign_map) 3662 { 3663 3664 portmod_dispatch_type_t __type__; 3665 int __rv__; 3666 SOC_INIT_FUNC_DEFS; 3667 3668 /* Dispatch */ 3669 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3670 if(__type__ >= portmodDispatchTypeCount) { 3671 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3672 } 3673 3674 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lanes_assign) { 3675 pm_info_t pm_info; 3676 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3677 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lanes_assign(unit, port, pm_info, assign_map); 3678 _SOC_IF_ERR_EXIT(__rv__); 3679 } else { 3680 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lanes_assign isn't implemented for driver type")); 3681 } 3682 3683 exit: 3684 SOC_FUNC_RETURN; 3685 3686 } 3687 3688 3689 int portmod_port_lanes_retrieve(int unit, int port, portmod_lanes_assign_info_t* assign_map) 3690 { 3691 3692 portmod_dispatch_type_t __type__; 3693 int __rv__; 3694 SOC_INIT_FUNC_DEFS; 3695 3696 if(assign_map == NULL) { 3697 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("assign_map NULL parameter")); 3698 } 3699 /* Dispatch */ 3700 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3701 if(__type__ >= portmodDispatchTypeCount) { 3702 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3703 } 3704 3705 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lanes_retrieve) { 3706 pm_info_t pm_info; 3707 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3708 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lanes_retrieve(unit, port, pm_info, assign_map); 3709 _SOC_IF_ERR_EXIT(__rv__); 3710 } else { 3711 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lanes_retrieve isn't implemented for driver type")); 3712 } 3713 3714 exit: 3715 SOC_FUNC_RETURN; 3716 3717 } 3718 3719 3720 int portmod_port_firmware_mode_set(int unit, int port, phymod_firmware_mode_t fw_mode) 3721 { 3722 3723 portmod_dispatch_type_t __type__; 3724 int __rv__; 3725 SOC_INIT_FUNC_DEFS; 3726 3727 /* Dispatch */ 3728 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3729 if(__type__ >= portmodDispatchTypeCount) { 3730 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3731 } 3732 3733 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_firmware_mode_set) { 3734 pm_info_t pm_info; 3735 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3736 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_firmware_mode_set(unit, port, pm_info, fw_mode); 3737 _SOC_IF_ERR_EXIT(__rv__); 3738 } else { 3739 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_firmware_mode_set isn't implemented for driver type")); 3740 } 3741 3742 exit: 3743 SOC_FUNC_RETURN; 3744 3745 } 3746 3747 3748 int portmod_port_firmware_mode_get(int unit, int port, phymod_firmware_mode_t* fw_mode) 3749 { 3750 3751 portmod_dispatch_type_t __type__; 3752 int __rv__; 3753 SOC_INIT_FUNC_DEFS; 3754 3755 if(fw_mode == NULL) { 3756 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("fw_mode NULL parameter")); 3757 } 3758 /* Dispatch */ 3759 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3760 if(__type__ >= portmodDispatchTypeCount) { 3761 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3762 } 3763 3764 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_firmware_mode_get) { 3765 pm_info_t pm_info; 3766 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3767 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_firmware_mode_get(unit, port, pm_info, fw_mode); 3768 _SOC_IF_ERR_EXIT(__rv__); 3769 } else { 3770 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_firmware_mode_get isn't implemented for driver type")); 3771 } 3772 3773 exit: 3774 SOC_FUNC_RETURN; 3775 3776 } 3777 3778 3779 int portmod_port_runt_threshold_set(int unit, int port, int value) 3780 { 3781 3782 portmod_dispatch_type_t __type__; 3783 int __rv__; 3784 SOC_INIT_FUNC_DEFS; 3785 3786 /* Dispatch */ 3787 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3788 if(__type__ >= portmodDispatchTypeCount) { 3789 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3790 } 3791 3792 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_runt_threshold_set) { 3793 pm_info_t pm_info; 3794 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3795 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_runt_threshold_set(unit, port, pm_info, value); 3796 _SOC_IF_ERR_EXIT(__rv__); 3797 } else { 3798 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_runt_threshold_set isn't implemented for driver type")); 3799 } 3800 3801 exit: 3802 SOC_FUNC_RETURN; 3803 3804 } 3805 3806 3807 int portmod_port_runt_threshold_get(int unit, int port, int* value) 3808 { 3809 3810 portmod_dispatch_type_t __type__; 3811 int __rv__; 3812 SOC_INIT_FUNC_DEFS; 3813 3814 if(value == NULL) { 3815 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 3816 } 3817 /* Dispatch */ 3818 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3819 if(__type__ >= portmodDispatchTypeCount) { 3820 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3821 } 3822 3823 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_runt_threshold_get) { 3824 pm_info_t pm_info; 3825 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3826 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_runt_threshold_get(unit, port, pm_info, value); 3827 _SOC_IF_ERR_EXIT(__rv__); 3828 } else { 3829 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_runt_threshold_get isn't implemented for driver type")); 3830 } 3831 3832 exit: 3833 SOC_FUNC_RETURN; 3834 3835 } 3836 3837 3838 int portmod_port_max_packet_size_set(int unit, int port, int value) 3839 { 3840 3841 portmod_dispatch_type_t __type__; 3842 int __rv__; 3843 SOC_INIT_FUNC_DEFS; 3844 3845 /* Dispatch */ 3846 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3847 if(__type__ >= portmodDispatchTypeCount) { 3848 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3849 } 3850 3851 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_max_packet_size_set) { 3852 pm_info_t pm_info; 3853 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3854 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_max_packet_size_set(unit, port, pm_info, value); 3855 _SOC_IF_ERR_EXIT(__rv__); 3856 } else { 3857 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_max_packet_size_set isn't implemented for driver type")); 3858 } 3859 3860 exit: 3861 SOC_FUNC_RETURN; 3862 3863 } 3864 3865 3866 int portmod_port_max_packet_size_get(int unit, int port, int* value) 3867 { 3868 3869 portmod_dispatch_type_t __type__; 3870 int __rv__; 3871 SOC_INIT_FUNC_DEFS; 3872 3873 if(value == NULL) { 3874 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 3875 } 3876 /* Dispatch */ 3877 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3878 if(__type__ >= portmodDispatchTypeCount) { 3879 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3880 } 3881 3882 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_max_packet_size_get) { 3883 pm_info_t pm_info; 3884 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3885 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_max_packet_size_get(unit, port, pm_info, value); 3886 _SOC_IF_ERR_EXIT(__rv__); 3887 } else { 3888 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_max_packet_size_get isn't implemented for driver type")); 3889 } 3890 3891 exit: 3892 SOC_FUNC_RETURN; 3893 3894 } 3895 3896 3897 int portmod_port_pad_size_set(int unit, int port, int value) 3898 { 3899 3900 portmod_dispatch_type_t __type__; 3901 int __rv__; 3902 SOC_INIT_FUNC_DEFS; 3903 3904 /* Dispatch */ 3905 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3906 if(__type__ >= portmodDispatchTypeCount) { 3907 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3908 } 3909 3910 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pad_size_set) { 3911 pm_info_t pm_info; 3912 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3913 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pad_size_set(unit, port, pm_info, value); 3914 _SOC_IF_ERR_EXIT(__rv__); 3915 } else { 3916 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pad_size_set isn't implemented for driver type")); 3917 } 3918 3919 exit: 3920 SOC_FUNC_RETURN; 3921 3922 } 3923 3924 3925 int portmod_port_pad_size_get(int unit, int port, int* value) 3926 { 3927 3928 portmod_dispatch_type_t __type__; 3929 int __rv__; 3930 SOC_INIT_FUNC_DEFS; 3931 3932 if(value == NULL) { 3933 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 3934 } 3935 /* Dispatch */ 3936 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3937 if(__type__ >= portmodDispatchTypeCount) { 3938 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3939 } 3940 3941 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pad_size_get) { 3942 pm_info_t pm_info; 3943 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3944 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pad_size_get(unit, port, pm_info, value); 3945 _SOC_IF_ERR_EXIT(__rv__); 3946 } else { 3947 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pad_size_get isn't implemented for driver type")); 3948 } 3949 3950 exit: 3951 SOC_FUNC_RETURN; 3952 3953 } 3954 3955 3956 int portmod_port_tx_mac_sa_set(int unit, int port, sal_mac_addr_t mac_sa) 3957 { 3958 3959 portmod_dispatch_type_t __type__; 3960 int __rv__; 3961 SOC_INIT_FUNC_DEFS; 3962 3963 /* Dispatch */ 3964 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3965 if(__type__ >= portmodDispatchTypeCount) { 3966 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3967 } 3968 3969 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_sa_set) { 3970 pm_info_t pm_info; 3971 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 3972 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_sa_set(unit, port, pm_info, mac_sa); 3973 _SOC_IF_ERR_EXIT(__rv__); 3974 } else { 3975 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_mac_sa_set isn't implemented for driver type")); 3976 } 3977 3978 exit: 3979 SOC_FUNC_RETURN; 3980 3981 } 3982 3983 3984 int portmod_port_tx_mac_sa_get(int unit, int port, sal_mac_addr_t mac_sa) 3985 { 3986 3987 portmod_dispatch_type_t __type__; 3988 int __rv__; 3989 SOC_INIT_FUNC_DEFS; 3990 3991 /* Dispatch */ 3992 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 3993 if(__type__ >= portmodDispatchTypeCount) { 3994 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 3995 } 3996 3997 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_sa_get) { 3998 pm_info_t pm_info; 3999 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4000 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_mac_sa_get(unit, port, pm_info, mac_sa); 4001 _SOC_IF_ERR_EXIT(__rv__); 4002 } else { 4003 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_mac_sa_get isn't implemented for driver type")); 4004 } 4005 4006 exit: 4007 SOC_FUNC_RETURN; 4008 4009 } 4010 4011 4012 int portmod_port_rx_mac_sa_set(int unit, int port, sal_mac_addr_t mac_sa) 4013 { 4014 4015 portmod_dispatch_type_t __type__; 4016 int __rv__; 4017 SOC_INIT_FUNC_DEFS; 4018 4019 /* Dispatch */ 4020 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4021 if(__type__ >= portmodDispatchTypeCount) { 4022 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4023 } 4024 4025 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_sa_set) { 4026 pm_info_t pm_info; 4027 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4028 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_sa_set(unit, port, pm_info, mac_sa); 4029 _SOC_IF_ERR_EXIT(__rv__); 4030 } else { 4031 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rx_mac_sa_set isn't implemented for driver type")); 4032 } 4033 4034 exit: 4035 SOC_FUNC_RETURN; 4036 4037 } 4038 4039 4040 int portmod_port_rx_mac_sa_get(int unit, int port, sal_mac_addr_t mac_sa) 4041 { 4042 4043 portmod_dispatch_type_t __type__; 4044 int __rv__; 4045 SOC_INIT_FUNC_DEFS; 4046 4047 /* Dispatch */ 4048 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4049 if(__type__ >= portmodDispatchTypeCount) { 4050 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4051 } 4052 4053 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_sa_get) { 4054 pm_info_t pm_info; 4055 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4056 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rx_mac_sa_get(unit, port, pm_info, mac_sa); 4057 _SOC_IF_ERR_EXIT(__rv__); 4058 } else { 4059 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rx_mac_sa_get isn't implemented for driver type")); 4060 } 4061 4062 exit: 4063 SOC_FUNC_RETURN; 4064 4065 } 4066 4067 4068 int portmod_port_tx_average_ipg_set(int unit, int port, int value) 4069 { 4070 4071 portmod_dispatch_type_t __type__; 4072 int __rv__; 4073 SOC_INIT_FUNC_DEFS; 4074 4075 /* Dispatch */ 4076 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4077 if(__type__ >= portmodDispatchTypeCount) { 4078 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4079 } 4080 4081 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_average_ipg_set) { 4082 pm_info_t pm_info; 4083 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4084 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_average_ipg_set(unit, port, pm_info, value); 4085 _SOC_IF_ERR_EXIT(__rv__); 4086 } else { 4087 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_average_ipg_set isn't implemented for driver type")); 4088 } 4089 4090 exit: 4091 SOC_FUNC_RETURN; 4092 4093 } 4094 4095 4096 int portmod_port_tx_average_ipg_get(int unit, int port, int* value) 4097 { 4098 4099 portmod_dispatch_type_t __type__; 4100 int __rv__; 4101 SOC_INIT_FUNC_DEFS; 4102 4103 if(value == NULL) { 4104 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4105 } 4106 /* Dispatch */ 4107 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4108 if(__type__ >= portmodDispatchTypeCount) { 4109 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4110 } 4111 4112 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_average_ipg_get) { 4113 pm_info_t pm_info; 4114 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4115 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_average_ipg_get(unit, port, pm_info, value); 4116 _SOC_IF_ERR_EXIT(__rv__); 4117 } else { 4118 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_average_ipg_get isn't implemented for driver type")); 4119 } 4120 4121 exit: 4122 SOC_FUNC_RETURN; 4123 4124 } 4125 4126 4127 int portmod_port_tx_preamble_length_set(int unit, int port, int value) 4128 { 4129 4130 portmod_dispatch_type_t __type__; 4131 int __rv__; 4132 SOC_INIT_FUNC_DEFS; 4133 4134 /* Dispatch */ 4135 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4136 if(__type__ >= portmodDispatchTypeCount) { 4137 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4138 } 4139 4140 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_preamble_length_set) { 4141 pm_info_t pm_info; 4142 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4143 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_preamble_length_set(unit, port, pm_info, value); 4144 _SOC_IF_ERR_EXIT(__rv__); 4145 } else { 4146 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_preamble_length_set isn't implemented for driver type")); 4147 } 4148 4149 exit: 4150 SOC_FUNC_RETURN; 4151 4152 } 4153 4154 4155 int portmod_port_tx_preamble_length_get(int unit, int port, int* value) 4156 { 4157 4158 portmod_dispatch_type_t __type__; 4159 int __rv__; 4160 SOC_INIT_FUNC_DEFS; 4161 4162 if(value == NULL) { 4163 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4164 } 4165 /* Dispatch */ 4166 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4167 if(__type__ >= portmodDispatchTypeCount) { 4168 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4169 } 4170 4171 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_preamble_length_get) { 4172 pm_info_t pm_info; 4173 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4174 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_preamble_length_get(unit, port, pm_info, value); 4175 _SOC_IF_ERR_EXIT(__rv__); 4176 } else { 4177 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_preamble_length_get isn't implemented for driver type")); 4178 } 4179 4180 exit: 4181 SOC_FUNC_RETURN; 4182 4183 } 4184 4185 4186 int portmod_port_local_fault_control_set(int unit, int port, const portmod_local_fault_control_t* control) 4187 { 4188 4189 portmod_dispatch_type_t __type__; 4190 int __rv__; 4191 SOC_INIT_FUNC_DEFS; 4192 4193 if(SOC_E_NONE != portmod_local_fault_control_t_validate(unit, control)) { 4194 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control validation failed")); 4195 } 4196 4197 /* Dispatch */ 4198 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4199 if(__type__ >= portmodDispatchTypeCount) { 4200 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4201 } 4202 4203 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_local_fault_control_set) { 4204 pm_info_t pm_info; 4205 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4206 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_local_fault_control_set(unit, port, pm_info, control); 4207 _SOC_IF_ERR_EXIT(__rv__); 4208 } else { 4209 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_local_fault_control_set isn't implemented for driver type")); 4210 } 4211 4212 exit: 4213 SOC_FUNC_RETURN; 4214 4215 } 4216 4217 4218 int portmod_port_local_fault_control_get(int unit, int port, portmod_local_fault_control_t* control) 4219 { 4220 4221 portmod_dispatch_type_t __type__; 4222 int __rv__; 4223 SOC_INIT_FUNC_DEFS; 4224 4225 if(control == NULL) { 4226 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control NULL parameter")); 4227 } 4228 if(SOC_E_NONE != portmod_local_fault_control_t_init(unit, control)) { 4229 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control initialization failed")); 4230 } 4231 4232 /* Dispatch */ 4233 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4234 if(__type__ >= portmodDispatchTypeCount) { 4235 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4236 } 4237 4238 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_local_fault_control_get) { 4239 pm_info_t pm_info; 4240 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4241 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_local_fault_control_get(unit, port, pm_info, control); 4242 _SOC_IF_ERR_EXIT(__rv__); 4243 } else { 4244 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_local_fault_control_get isn't implemented for driver type")); 4245 } 4246 4247 exit: 4248 SOC_FUNC_RETURN; 4249 4250 } 4251 4252 4253 int portmod_port_remote_fault_control_set(int unit, int port, const portmod_remote_fault_control_t* control) 4254 { 4255 4256 portmod_dispatch_type_t __type__; 4257 int __rv__; 4258 SOC_INIT_FUNC_DEFS; 4259 4260 if(SOC_E_NONE != portmod_remote_fault_control_t_validate(unit, control)) { 4261 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control validation failed")); 4262 } 4263 4264 /* Dispatch */ 4265 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4266 if(__type__ >= portmodDispatchTypeCount) { 4267 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4268 } 4269 4270 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_control_set) { 4271 pm_info_t pm_info; 4272 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4273 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_control_set(unit, port, pm_info, control); 4274 _SOC_IF_ERR_EXIT(__rv__); 4275 } else { 4276 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_remote_fault_control_set isn't implemented for driver type")); 4277 } 4278 4279 exit: 4280 SOC_FUNC_RETURN; 4281 4282 } 4283 4284 4285 int portmod_port_remote_fault_control_get(int unit, int port, portmod_remote_fault_control_t* control) 4286 { 4287 4288 portmod_dispatch_type_t __type__; 4289 int __rv__; 4290 SOC_INIT_FUNC_DEFS; 4291 4292 if(control == NULL) { 4293 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control NULL parameter")); 4294 } 4295 if(SOC_E_NONE != portmod_remote_fault_control_t_init(unit, control)) { 4296 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control initialization failed")); 4297 } 4298 4299 /* Dispatch */ 4300 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4301 if(__type__ >= portmodDispatchTypeCount) { 4302 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4303 } 4304 4305 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_control_get) { 4306 pm_info_t pm_info; 4307 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4308 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_control_get(unit, port, pm_info, control); 4309 _SOC_IF_ERR_EXIT(__rv__); 4310 } else { 4311 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_remote_fault_control_get isn't implemented for driver type")); 4312 } 4313 4314 exit: 4315 SOC_FUNC_RETURN; 4316 4317 } 4318 4319 4320 int portmod_port_local_fault_status_get(int unit, int port, int* value) 4321 { 4322 4323 portmod_dispatch_type_t __type__; 4324 int __rv__; 4325 SOC_INIT_FUNC_DEFS; 4326 4327 if(value == NULL) { 4328 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4329 } 4330 /* Dispatch */ 4331 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4332 if(__type__ >= portmodDispatchTypeCount) { 4333 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4334 } 4335 4336 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_local_fault_status_get) { 4337 pm_info_t pm_info; 4338 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4339 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_local_fault_status_get(unit, port, pm_info, value); 4340 _SOC_IF_ERR_EXIT(__rv__); 4341 } else { 4342 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_local_fault_status_get isn't implemented for driver type")); 4343 } 4344 4345 exit: 4346 SOC_FUNC_RETURN; 4347 4348 } 4349 4350 4351 int portmod_port_remote_fault_status_get(int unit, int port, int* value) 4352 { 4353 4354 portmod_dispatch_type_t __type__; 4355 int __rv__; 4356 SOC_INIT_FUNC_DEFS; 4357 4358 if(value == NULL) { 4359 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4360 } 4361 /* Dispatch */ 4362 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4363 if(__type__ >= portmodDispatchTypeCount) { 4364 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4365 } 4366 4367 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_status_get) { 4368 pm_info_t pm_info; 4369 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4370 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_status_get(unit, port, pm_info, value); 4371 _SOC_IF_ERR_EXIT(__rv__); 4372 } else { 4373 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_remote_fault_status_get isn't implemented for driver type")); 4374 } 4375 4376 exit: 4377 SOC_FUNC_RETURN; 4378 4379 } 4380 4381 4382 int portmod_port_local_fault_status_clear(int unit, int port) 4383 { 4384 4385 portmod_dispatch_type_t __type__; 4386 int __rv__; 4387 SOC_INIT_FUNC_DEFS; 4388 4389 /* Dispatch */ 4390 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4391 if(__type__ >= portmodDispatchTypeCount) { 4392 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4393 } 4394 4395 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_local_fault_status_clear) { 4396 pm_info_t pm_info; 4397 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4398 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_local_fault_status_clear(unit, port, pm_info); 4399 _SOC_IF_ERR_EXIT(__rv__); 4400 } else { 4401 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_local_fault_status_clear isn't implemented for driver type")); 4402 } 4403 4404 exit: 4405 SOC_FUNC_RETURN; 4406 4407 } 4408 4409 4410 int portmod_port_remote_fault_status_clear(int unit, int port) 4411 { 4412 4413 portmod_dispatch_type_t __type__; 4414 int __rv__; 4415 SOC_INIT_FUNC_DEFS; 4416 4417 /* Dispatch */ 4418 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4419 if(__type__ >= portmodDispatchTypeCount) { 4420 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4421 } 4422 4423 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_status_clear) { 4424 pm_info_t pm_info; 4425 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4426 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_remote_fault_status_clear(unit, port, pm_info); 4427 _SOC_IF_ERR_EXIT(__rv__); 4428 } else { 4429 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_remote_fault_status_clear isn't implemented for driver type")); 4430 } 4431 4432 exit: 4433 SOC_FUNC_RETURN; 4434 4435 } 4436 4437 4438 int portmod_port_pause_control_set(int unit, int port, const portmod_pause_control_t* control) 4439 { 4440 4441 portmod_dispatch_type_t __type__; 4442 int __rv__; 4443 SOC_INIT_FUNC_DEFS; 4444 4445 if(SOC_E_NONE != portmod_pause_control_t_validate(unit, control)) { 4446 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control validation failed")); 4447 } 4448 4449 /* Dispatch */ 4450 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4451 if(__type__ >= portmodDispatchTypeCount) { 4452 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4453 } 4454 4455 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pause_control_set) { 4456 pm_info_t pm_info; 4457 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4458 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pause_control_set(unit, port, pm_info, control); 4459 _SOC_IF_ERR_EXIT(__rv__); 4460 } else { 4461 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pause_control_set isn't implemented for driver type")); 4462 } 4463 4464 exit: 4465 SOC_FUNC_RETURN; 4466 4467 } 4468 4469 4470 int portmod_port_pause_control_get(int unit, int port, portmod_pause_control_t* control) 4471 { 4472 4473 portmod_dispatch_type_t __type__; 4474 int __rv__; 4475 SOC_INIT_FUNC_DEFS; 4476 4477 if(control == NULL) { 4478 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control NULL parameter")); 4479 } 4480 if(SOC_E_NONE != portmod_pause_control_t_init(unit, control)) { 4481 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control initialization failed")); 4482 } 4483 4484 /* Dispatch */ 4485 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4486 if(__type__ >= portmodDispatchTypeCount) { 4487 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4488 } 4489 4490 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pause_control_get) { 4491 pm_info_t pm_info; 4492 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4493 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pause_control_get(unit, port, pm_info, control); 4494 _SOC_IF_ERR_EXIT(__rv__); 4495 } else { 4496 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pause_control_get isn't implemented for driver type")); 4497 } 4498 4499 exit: 4500 SOC_FUNC_RETURN; 4501 4502 } 4503 4504 4505 int portmod_port_pfc_control_set(int unit, int port, const portmod_pfc_control_t* control) 4506 { 4507 4508 portmod_dispatch_type_t __type__; 4509 int __rv__; 4510 SOC_INIT_FUNC_DEFS; 4511 4512 if(SOC_E_NONE != portmod_pfc_control_t_validate(unit, control)) { 4513 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control validation failed")); 4514 } 4515 4516 /* Dispatch */ 4517 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4518 if(__type__ >= portmodDispatchTypeCount) { 4519 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4520 } 4521 4522 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pfc_control_set) { 4523 pm_info_t pm_info; 4524 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4525 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pfc_control_set(unit, port, pm_info, control); 4526 _SOC_IF_ERR_EXIT(__rv__); 4527 } else { 4528 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pfc_control_set isn't implemented for driver type")); 4529 } 4530 4531 exit: 4532 SOC_FUNC_RETURN; 4533 4534 } 4535 4536 4537 int portmod_port_pfc_control_get(int unit, int port, portmod_pfc_control_t* control) 4538 { 4539 4540 portmod_dispatch_type_t __type__; 4541 int __rv__; 4542 SOC_INIT_FUNC_DEFS; 4543 4544 if(control == NULL) { 4545 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control NULL parameter")); 4546 } 4547 if(SOC_E_NONE != portmod_pfc_control_t_init(unit, control)) { 4548 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control initialization failed")); 4549 } 4550 4551 /* Dispatch */ 4552 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4553 if(__type__ >= portmodDispatchTypeCount) { 4554 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4555 } 4556 4557 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pfc_control_get) { 4558 pm_info_t pm_info; 4559 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4560 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pfc_control_get(unit, port, pm_info, control); 4561 _SOC_IF_ERR_EXIT(__rv__); 4562 } else { 4563 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pfc_control_get isn't implemented for driver type")); 4564 } 4565 4566 exit: 4567 SOC_FUNC_RETURN; 4568 4569 } 4570 4571 4572 int portmod_port_llfc_control_set(int unit, int port, const portmod_llfc_control_t* control) 4573 { 4574 4575 portmod_dispatch_type_t __type__; 4576 int __rv__; 4577 SOC_INIT_FUNC_DEFS; 4578 4579 if(SOC_E_NONE != portmod_llfc_control_t_validate(unit, control)) { 4580 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control validation failed")); 4581 } 4582 4583 /* Dispatch */ 4584 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4585 if(__type__ >= portmodDispatchTypeCount) { 4586 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4587 } 4588 4589 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_llfc_control_set) { 4590 pm_info_t pm_info; 4591 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4592 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_llfc_control_set(unit, port, pm_info, control); 4593 _SOC_IF_ERR_EXIT(__rv__); 4594 } else { 4595 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_llfc_control_set isn't implemented for driver type")); 4596 } 4597 4598 exit: 4599 SOC_FUNC_RETURN; 4600 4601 } 4602 4603 4604 int portmod_port_llfc_control_get(int unit, int port, portmod_llfc_control_t* control) 4605 { 4606 4607 portmod_dispatch_type_t __type__; 4608 int __rv__; 4609 SOC_INIT_FUNC_DEFS; 4610 4611 if(control == NULL) { 4612 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control NULL parameter")); 4613 } 4614 if(SOC_E_NONE != portmod_llfc_control_t_init(unit, control)) { 4615 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("control initialization failed")); 4616 } 4617 4618 /* Dispatch */ 4619 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4620 if(__type__ >= portmodDispatchTypeCount) { 4621 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4622 } 4623 4624 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_llfc_control_get) { 4625 pm_info_t pm_info; 4626 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4627 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_llfc_control_get(unit, port, pm_info, control); 4628 _SOC_IF_ERR_EXIT(__rv__); 4629 } else { 4630 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_llfc_control_get isn't implemented for driver type")); 4631 } 4632 4633 exit: 4634 SOC_FUNC_RETURN; 4635 4636 } 4637 4638 4639 int portmod_port_update_control_t_validate(int unit, const portmod_port_update_control_t* portmod_port_update_control) 4640 { 4641 SOC_INIT_FUNC_DEFS; 4642 if(portmod_port_update_control == NULL) { 4643 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 4644 } 4645 4646 4647 4648 exit: 4649 SOC_FUNC_RETURN; 4650 4651 } 4652 4653 int portmod_port_update_control_t_init(int unit, portmod_port_update_control_t* portmod_port_update_control) 4654 { 4655 SOC_INIT_FUNC_DEFS; 4656 4657 if(portmod_port_update_control == NULL){ 4658 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_update_control NULL parameter")); 4659 } 4660 sal_memset(portmod_port_update_control, 0, sizeof(portmod_port_update_control_t)); 4661 portmod_port_update_control->link_status = -1; 4662 portmod_port_update_control->flags = 0; 4663 4664 4665 exit: 4666 SOC_FUNC_RETURN; 4667 4668 } 4669 4670 int portmod_port_update(int unit, int port, const portmod_port_update_control_t* update_control) 4671 { 4672 4673 portmod_dispatch_type_t __type__; 4674 int __rv__; 4675 SOC_INIT_FUNC_DEFS; 4676 4677 if(SOC_E_NONE != portmod_port_update_control_t_validate(unit, update_control)) { 4678 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("update_control validation failed")); 4679 } 4680 4681 /* Dispatch */ 4682 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4683 if(__type__ >= portmodDispatchTypeCount) { 4684 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4685 } 4686 4687 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_update) { 4688 pm_info_t pm_info; 4689 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4690 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_update(unit, port, pm_info, update_control); 4691 _SOC_IF_ERR_EXIT(__rv__); 4692 } else { 4693 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_update isn't implemented for driver type")); 4694 } 4695 4696 exit: 4697 SOC_FUNC_RETURN; 4698 4699 } 4700 4701 4702 int portmod_port_core_access_get(int unit, int port, int phyn, int max_cores, phymod_core_access_t* core_access_arr, int* nof_cores, int* is_most_ext) 4703 { 4704 4705 portmod_dispatch_type_t __type__; 4706 int __rv__; 4707 SOC_INIT_FUNC_DEFS; 4708 4709 if(core_access_arr == NULL) { 4710 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_access_arr NULL parameter")); 4711 } 4712 if(nof_cores == NULL) { 4713 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("nof_cores NULL parameter")); 4714 } 4715 /* Dispatch */ 4716 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4717 if(__type__ >= portmodDispatchTypeCount) { 4718 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4719 } 4720 4721 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_core_access_get) { 4722 pm_info_t pm_info; 4723 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4724 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_core_access_get(unit, port, pm_info, phyn, max_cores, core_access_arr, nof_cores, is_most_ext); 4725 _SOC_IF_ERR_EXIT(__rv__); 4726 } else { 4727 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_core_access_get isn't implemented for driver type")); 4728 } 4729 4730 exit: 4731 SOC_FUNC_RETURN; 4732 4733 } 4734 4735 4736 int portmod_port_phy_lane_access_get(int unit, int port, const portmod_access_get_params_t* params, int max_phys, phymod_phy_access_t* access, int* nof_phys, int* is_most_ext) 4737 { 4738 4739 portmod_dispatch_type_t __type__; 4740 int __rv__; 4741 SOC_INIT_FUNC_DEFS; 4742 4743 if(SOC_E_NONE != portmod_access_get_params_t_validate(unit, params)) { 4744 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("params validation failed")); 4745 } 4746 4747 if(access == NULL) { 4748 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("access NULL parameter")); 4749 } 4750 if(nof_phys == NULL) { 4751 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("nof_phys NULL parameter")); 4752 } 4753 /* Dispatch */ 4754 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4755 if(__type__ >= portmodDispatchTypeCount) { 4756 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4757 } 4758 4759 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_lane_access_get) { 4760 pm_info_t pm_info; 4761 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4762 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_lane_access_get(unit, port, pm_info, params, max_phys, access, nof_phys, is_most_ext); 4763 _SOC_IF_ERR_EXIT(__rv__); 4764 } else { 4765 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_lane_access_get isn't implemented for driver type")); 4766 } 4767 4768 exit: 4769 SOC_FUNC_RETURN; 4770 4771 } 4772 4773 4774 int portmod_pm_phy_lane_access_get(int unit, int pm_id, const portmod_access_get_params_t* params, int max_phys, phymod_phy_access_t* access, int* nof_phys, int* is_most_ext) 4775 { 4776 4777 portmod_dispatch_type_t __type__; 4778 int __rv__; 4779 SOC_INIT_FUNC_DEFS; 4780 4781 if(SOC_E_NONE != portmod_access_get_params_t_validate(unit, params)) { 4782 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("params validation failed")); 4783 } 4784 4785 if(access == NULL) { 4786 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("access NULL parameter")); 4787 } 4788 if(nof_phys == NULL) { 4789 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("nof_phys NULL parameter")); 4790 } 4791 /* Dispatch */ 4792 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 4793 if(__type__ >= portmodDispatchTypeCount) { 4794 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4795 } 4796 4797 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_phy_lane_access_get) { 4798 pm_info_t pm_info; 4799 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 4800 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_phy_lane_access_get(unit, pm_id, pm_info, params, max_phys, access, nof_phys, is_most_ext); 4801 _SOC_IF_ERR_EXIT(__rv__); 4802 } else { 4803 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_phy_lane_access_get isn't implemented for driver type")); 4804 } 4805 4806 exit: 4807 SOC_FUNC_RETURN; 4808 4809 } 4810 4811 4812 int portmod_port_duplex_set(int unit, int port, int enable) 4813 { 4814 4815 portmod_dispatch_type_t __type__; 4816 int __rv__; 4817 SOC_INIT_FUNC_DEFS; 4818 4819 /* Dispatch */ 4820 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4821 if(__type__ >= portmodDispatchTypeCount) { 4822 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4823 } 4824 4825 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_duplex_set) { 4826 pm_info_t pm_info; 4827 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4828 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_duplex_set(unit, port, pm_info, enable); 4829 _SOC_IF_ERR_EXIT(__rv__); 4830 } else { 4831 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_duplex_set isn't implemented for driver type")); 4832 } 4833 4834 exit: 4835 SOC_FUNC_RETURN; 4836 4837 } 4838 4839 4840 int portmod_port_duplex_get(int unit, int port, int* enable) 4841 { 4842 4843 portmod_dispatch_type_t __type__; 4844 int __rv__; 4845 SOC_INIT_FUNC_DEFS; 4846 4847 if(enable == NULL) { 4848 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 4849 } 4850 /* Dispatch */ 4851 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4852 if(__type__ >= portmodDispatchTypeCount) { 4853 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4854 } 4855 4856 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_duplex_get) { 4857 pm_info_t pm_info; 4858 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4859 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_duplex_get(unit, port, pm_info, enable); 4860 _SOC_IF_ERR_EXIT(__rv__); 4861 } else { 4862 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_duplex_get isn't implemented for driver type")); 4863 } 4864 4865 exit: 4866 SOC_FUNC_RETURN; 4867 4868 } 4869 4870 4871 int portmod_port_phy_reg_read(int unit, int port, int lane, int flags, int reg_addr, uint32* value) 4872 { 4873 4874 portmod_dispatch_type_t __type__; 4875 int __rv__; 4876 SOC_INIT_FUNC_DEFS; 4877 4878 if(value == NULL) { 4879 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4880 } 4881 /* Dispatch */ 4882 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4883 if(__type__ >= portmodDispatchTypeCount) { 4884 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4885 } 4886 4887 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_reg_read) { 4888 pm_info_t pm_info; 4889 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4890 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_reg_read(unit, port, pm_info, lane, flags, reg_addr, value); 4891 _SOC_IF_ERR_EXIT(__rv__); 4892 } else { 4893 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_reg_read isn't implemented for driver type")); 4894 } 4895 4896 exit: 4897 SOC_FUNC_RETURN; 4898 4899 } 4900 4901 4902 int portmod_port_phy_reg_write(int unit, int port, int lane, int flags, int reg_addr, uint32 value) 4903 { 4904 4905 portmod_dispatch_type_t __type__; 4906 int __rv__; 4907 SOC_INIT_FUNC_DEFS; 4908 4909 /* Dispatch */ 4910 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4911 if(__type__ >= portmodDispatchTypeCount) { 4912 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4913 } 4914 4915 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_reg_write) { 4916 pm_info_t pm_info; 4917 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4918 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_reg_write(unit, port, pm_info, lane, flags, reg_addr, value); 4919 _SOC_IF_ERR_EXIT(__rv__); 4920 } else { 4921 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_reg_write isn't implemented for driver type")); 4922 } 4923 4924 exit: 4925 SOC_FUNC_RETURN; 4926 4927 } 4928 4929 4930 int portmod_port_reset_set(int unit, int port, int mode, int opcode, int value) 4931 { 4932 4933 portmod_dispatch_type_t __type__; 4934 int __rv__; 4935 SOC_INIT_FUNC_DEFS; 4936 4937 /* Dispatch */ 4938 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4939 if(__type__ >= portmodDispatchTypeCount) { 4940 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4941 } 4942 4943 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_reset_set) { 4944 pm_info_t pm_info; 4945 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4946 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_reset_set(unit, port, pm_info, mode, opcode, value); 4947 _SOC_IF_ERR_EXIT(__rv__); 4948 } else { 4949 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_reset_set isn't implemented for driver type")); 4950 } 4951 4952 exit: 4953 SOC_FUNC_RETURN; 4954 4955 } 4956 4957 4958 int portmod_port_reset_get(int unit, int port, int mode, int opcode, int* value) 4959 { 4960 4961 portmod_dispatch_type_t __type__; 4962 int __rv__; 4963 SOC_INIT_FUNC_DEFS; 4964 4965 if(value == NULL) { 4966 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4967 } 4968 /* Dispatch */ 4969 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 4970 if(__type__ >= portmodDispatchTypeCount) { 4971 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 4972 } 4973 4974 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_reset_get) { 4975 pm_info_t pm_info; 4976 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 4977 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_reset_get(unit, port, pm_info, mode, opcode, value); 4978 _SOC_IF_ERR_EXIT(__rv__); 4979 } else { 4980 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_reset_get isn't implemented for driver type")); 4981 } 4982 4983 exit: 4984 SOC_FUNC_RETURN; 4985 4986 } 4987 4988 4989 int portmod_port_adv_remote_get(int unit, int port, int* value) 4990 { 4991 4992 portmod_dispatch_type_t __type__; 4993 int __rv__; 4994 SOC_INIT_FUNC_DEFS; 4995 4996 if(value == NULL) { 4997 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 4998 } 4999 /* Dispatch */ 5000 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5001 if(__type__ >= portmodDispatchTypeCount) { 5002 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5003 } 5004 5005 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_adv_remote_get) { 5006 pm_info_t pm_info; 5007 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5008 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_adv_remote_get(unit, port, pm_info, value); 5009 _SOC_IF_ERR_EXIT(__rv__); 5010 } else { 5011 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_adv_remote_get isn't implemented for driver type")); 5012 } 5013 5014 exit: 5015 SOC_FUNC_RETURN; 5016 5017 } 5018 5019 5020 int portmod_port_drv_name(int unit, int port) 5021 { 5022 5023 portmod_dispatch_type_t __type__; 5024 int __rv__; 5025 SOC_INIT_FUNC_DEFS; 5026 5027 /* Dispatch */ 5028 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5029 if(__type__ >= portmodDispatchTypeCount) { 5030 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5031 } 5032 5033 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_drv_name) { 5034 pm_info_t pm_info; 5035 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5036 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_drv_name(unit, port, pm_info); 5037 _SOC_IF_ERR_EXIT(__rv__); 5038 } else { 5039 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_drv_name isn't implemented for driver type")); 5040 } 5041 5042 exit: 5043 SOC_FUNC_RETURN; 5044 5045 } 5046 5047 5048 int portmod_port_drv_name_get(int unit, int port, char* name, int len) 5049 { 5050 5051 portmod_dispatch_type_t __type__; 5052 int __rv__; 5053 SOC_INIT_FUNC_DEFS; 5054 5055 if(name == NULL) { 5056 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("name NULL parameter")); 5057 } 5058 /* Dispatch */ 5059 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5060 if(__type__ >= portmodDispatchTypeCount) { 5061 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5062 } 5063 5064 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_drv_name_get) { 5065 pm_info_t pm_info; 5066 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5067 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_drv_name_get(unit, port, pm_info, name, len); 5068 _SOC_IF_ERR_EXIT(__rv__); 5069 } else { 5070 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_drv_name_get isn't implemented for driver type")); 5071 } 5072 5073 exit: 5074 SOC_FUNC_RETURN; 5075 5076 } 5077 5078 5079 int portmod_port_fec_enable_set(int unit, int port, uint32 phy_flags, uint32_t enable) 5080 { 5081 5082 portmod_dispatch_type_t __type__; 5083 int __rv__; 5084 SOC_INIT_FUNC_DEFS; 5085 5086 /* Dispatch */ 5087 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5088 if(__type__ >= portmodDispatchTypeCount) { 5089 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5090 } 5091 5092 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_fec_enable_set) { 5093 pm_info_t pm_info; 5094 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5095 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_fec_enable_set(unit, port, pm_info, phy_flags, enable); 5096 _SOC_IF_ERR_EXIT(__rv__); 5097 } else { 5098 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_fec_enable_set isn't implemented for driver type")); 5099 } 5100 5101 exit: 5102 SOC_FUNC_RETURN; 5103 5104 } 5105 5106 5107 int portmod_port_fec_enable_get(int unit, int port, uint32 phy_flags, uint32_t* enable) 5108 { 5109 5110 portmod_dispatch_type_t __type__; 5111 int __rv__; 5112 SOC_INIT_FUNC_DEFS; 5113 5114 if(enable == NULL) { 5115 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 5116 } 5117 /* Dispatch */ 5118 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5119 if(__type__ >= portmodDispatchTypeCount) { 5120 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5121 } 5122 5123 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_fec_enable_get) { 5124 pm_info_t pm_info; 5125 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5126 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_fec_enable_get(unit, port, pm_info, phy_flags, enable); 5127 _SOC_IF_ERR_EXIT(__rv__); 5128 } else { 5129 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_fec_enable_get isn't implemented for driver type")); 5130 } 5131 5132 exit: 5133 SOC_FUNC_RETURN; 5134 5135 } 5136 5137 5138 int portmod_port_ability_advert_set(int unit, int port, uint32 phy_flags, portmod_port_ability_t* ability) 5139 { 5140 5141 portmod_dispatch_type_t __type__; 5142 int __rv__; 5143 SOC_INIT_FUNC_DEFS; 5144 5145 if(ability == NULL) { 5146 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ability NULL parameter")); 5147 } 5148 /* Dispatch */ 5149 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5150 if(__type__ >= portmodDispatchTypeCount) { 5151 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5152 } 5153 5154 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ability_advert_set) { 5155 pm_info_t pm_info; 5156 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5157 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ability_advert_set(unit, port, pm_info, phy_flags, ability); 5158 _SOC_IF_ERR_EXIT(__rv__); 5159 } else { 5160 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ability_advert_set isn't implemented for driver type")); 5161 } 5162 5163 exit: 5164 SOC_FUNC_RETURN; 5165 5166 } 5167 5168 5169 int portmod_port_ability_advert_get(int unit, int port, uint32 phy_flags, portmod_port_ability_t* ability) 5170 { 5171 5172 portmod_dispatch_type_t __type__; 5173 int __rv__; 5174 SOC_INIT_FUNC_DEFS; 5175 5176 if(ability == NULL) { 5177 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ability NULL parameter")); 5178 } 5179 /* Dispatch */ 5180 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5181 if(__type__ >= portmodDispatchTypeCount) { 5182 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5183 } 5184 5185 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ability_advert_get) { 5186 pm_info_t pm_info; 5187 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5188 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ability_advert_get(unit, port, pm_info, phy_flags, ability); 5189 _SOC_IF_ERR_EXIT(__rv__); 5190 } else { 5191 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ability_advert_get isn't implemented for driver type")); 5192 } 5193 5194 exit: 5195 SOC_FUNC_RETURN; 5196 5197 } 5198 5199 5200 int portmod_port_ability_remote_get(int unit, int port, uint32 phy_flags, portmod_port_ability_t* ability) 5201 { 5202 5203 portmod_dispatch_type_t __type__; 5204 int __rv__; 5205 SOC_INIT_FUNC_DEFS; 5206 5207 if(ability == NULL) { 5208 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ability NULL parameter")); 5209 } 5210 /* Dispatch */ 5211 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5212 if(__type__ >= portmodDispatchTypeCount) { 5213 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5214 } 5215 5216 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ability_remote_get) { 5217 pm_info_t pm_info; 5218 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5219 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ability_remote_get(unit, port, pm_info, phy_flags, ability); 5220 _SOC_IF_ERR_EXIT(__rv__); 5221 } else { 5222 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ability_remote_get isn't implemented for driver type")); 5223 } 5224 5225 exit: 5226 SOC_FUNC_RETURN; 5227 5228 } 5229 5230 5231 int portmod_port_frame_spacing_stretch_set(int unit, int port, int spacing) 5232 { 5233 5234 portmod_dispatch_type_t __type__; 5235 int __rv__; 5236 SOC_INIT_FUNC_DEFS; 5237 5238 /* Dispatch */ 5239 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5240 if(__type__ >= portmodDispatchTypeCount) { 5241 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5242 } 5243 5244 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_frame_spacing_stretch_set) { 5245 pm_info_t pm_info; 5246 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5247 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_frame_spacing_stretch_set(unit, port, pm_info, spacing); 5248 _SOC_IF_ERR_EXIT(__rv__); 5249 } else { 5250 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_frame_spacing_stretch_set isn't implemented for driver type")); 5251 } 5252 5253 exit: 5254 SOC_FUNC_RETURN; 5255 5256 } 5257 5258 5259 int portmod_port_frame_spacing_stretch_get(int unit, int port, const int* spacing) 5260 { 5261 5262 portmod_dispatch_type_t __type__; 5263 int __rv__; 5264 SOC_INIT_FUNC_DEFS; 5265 5266 /* Dispatch */ 5267 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5268 if(__type__ >= portmodDispatchTypeCount) { 5269 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5270 } 5271 5272 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_frame_spacing_stretch_get) { 5273 pm_info_t pm_info; 5274 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5275 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_frame_spacing_stretch_get(unit, port, pm_info, spacing); 5276 _SOC_IF_ERR_EXIT(__rv__); 5277 } else { 5278 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_frame_spacing_stretch_get isn't implemented for driver type")); 5279 } 5280 5281 exit: 5282 SOC_FUNC_RETURN; 5283 5284 } 5285 5286 5287 int portmod_port_diag_fifo_status_get(int unit, int port, const portmod_fifo_status_t* diag_info) 5288 { 5289 5290 portmod_dispatch_type_t __type__; 5291 int __rv__; 5292 SOC_INIT_FUNC_DEFS; 5293 5294 if(SOC_E_NONE != portmod_fifo_status_t_validate(unit, diag_info)) { 5295 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("diag_info validation failed")); 5296 } 5297 5298 /* Dispatch */ 5299 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5300 if(__type__ >= portmodDispatchTypeCount) { 5301 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5302 } 5303 5304 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_diag_fifo_status_get) { 5305 pm_info_t pm_info; 5306 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5307 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_diag_fifo_status_get(unit, port, pm_info, diag_info); 5308 _SOC_IF_ERR_EXIT(__rv__); 5309 } else { 5310 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_diag_fifo_status_get isn't implemented for driver type")); 5311 } 5312 5313 exit: 5314 SOC_FUNC_RETURN; 5315 5316 } 5317 5318 5319 int portmod_port_rx_control_set(int unit, int port, const portmod_rx_control_t* rx_ctrl) 5320 { 5321 5322 portmod_dispatch_type_t __type__; 5323 int __rv__; 5324 SOC_INIT_FUNC_DEFS; 5325 5326 if(SOC_E_NONE != portmod_rx_control_t_validate(unit, rx_ctrl)) { 5327 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rx_ctrl validation failed")); 5328 } 5329 5330 /* Dispatch */ 5331 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5332 if(__type__ >= portmodDispatchTypeCount) { 5333 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5334 } 5335 5336 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rx_control_set) { 5337 pm_info_t pm_info; 5338 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5339 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rx_control_set(unit, port, pm_info, rx_ctrl); 5340 _SOC_IF_ERR_EXIT(__rv__); 5341 } else { 5342 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rx_control_set isn't implemented for driver type")); 5343 } 5344 5345 exit: 5346 SOC_FUNC_RETURN; 5347 5348 } 5349 5350 5351 int portmod_port_rx_control_get(int unit, int port, portmod_rx_control_t* rx_ctrl) 5352 { 5353 5354 portmod_dispatch_type_t __type__; 5355 int __rv__; 5356 SOC_INIT_FUNC_DEFS; 5357 5358 if(rx_ctrl == NULL) { 5359 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rx_ctrl NULL parameter")); 5360 } 5361 if(SOC_E_NONE != portmod_rx_control_t_init(unit, rx_ctrl)) { 5362 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rx_ctrl initialization failed")); 5363 } 5364 5365 /* Dispatch */ 5366 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5367 if(__type__ >= portmodDispatchTypeCount) { 5368 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5369 } 5370 5371 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rx_control_get) { 5372 pm_info_t pm_info; 5373 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5374 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rx_control_get(unit, port, pm_info, rx_ctrl); 5375 _SOC_IF_ERR_EXIT(__rv__); 5376 } else { 5377 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rx_control_get isn't implemented for driver type")); 5378 } 5379 5380 exit: 5381 SOC_FUNC_RETURN; 5382 5383 } 5384 5385 5386 int portmod_port_pfc_config_set(int unit, int port, const portmod_pfc_config_t* pfc_cfg) 5387 { 5388 5389 portmod_dispatch_type_t __type__; 5390 int __rv__; 5391 SOC_INIT_FUNC_DEFS; 5392 5393 if(SOC_E_NONE != portmod_pfc_config_t_validate(unit, pfc_cfg)) { 5394 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pfc_cfg validation failed")); 5395 } 5396 5397 /* Dispatch */ 5398 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5399 if(__type__ >= portmodDispatchTypeCount) { 5400 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5401 } 5402 5403 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pfc_config_set) { 5404 pm_info_t pm_info; 5405 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5406 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pfc_config_set(unit, port, pm_info, pfc_cfg); 5407 _SOC_IF_ERR_EXIT(__rv__); 5408 } else { 5409 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pfc_config_set isn't implemented for driver type")); 5410 } 5411 5412 exit: 5413 SOC_FUNC_RETURN; 5414 5415 } 5416 5417 5418 int portmod_port_pfc_config_get(int unit, int port, portmod_pfc_config_t* pfc_cfg) 5419 { 5420 5421 portmod_dispatch_type_t __type__; 5422 int __rv__; 5423 SOC_INIT_FUNC_DEFS; 5424 5425 if(pfc_cfg == NULL) { 5426 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pfc_cfg NULL parameter")); 5427 } 5428 if(SOC_E_NONE != portmod_pfc_config_t_init(unit, pfc_cfg)) { 5429 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pfc_cfg initialization failed")); 5430 } 5431 5432 /* Dispatch */ 5433 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5434 if(__type__ >= portmodDispatchTypeCount) { 5435 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5436 } 5437 5438 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pfc_config_get) { 5439 pm_info_t pm_info; 5440 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5441 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pfc_config_get(unit, port, pm_info, pfc_cfg); 5442 _SOC_IF_ERR_EXIT(__rv__); 5443 } else { 5444 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pfc_config_get isn't implemented for driver type")); 5445 } 5446 5447 exit: 5448 SOC_FUNC_RETURN; 5449 5450 } 5451 5452 5453 int portmod_port_eee_set(int unit, int port, const portmod_eee_t* eee) 5454 { 5455 5456 portmod_dispatch_type_t __type__; 5457 int __rv__; 5458 SOC_INIT_FUNC_DEFS; 5459 5460 if(SOC_E_NONE != portmod_eee_t_validate(unit, eee)) { 5461 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("eee validation failed")); 5462 } 5463 5464 /* Dispatch */ 5465 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5466 if(__type__ >= portmodDispatchTypeCount) { 5467 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5468 } 5469 5470 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_eee_set) { 5471 pm_info_t pm_info; 5472 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5473 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_eee_set(unit, port, pm_info, eee); 5474 _SOC_IF_ERR_EXIT(__rv__); 5475 } else { 5476 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_eee_set isn't implemented for driver type")); 5477 } 5478 5479 exit: 5480 SOC_FUNC_RETURN; 5481 5482 } 5483 5484 5485 int portmod_port_eee_get(int unit, int port, portmod_eee_t* eee) 5486 { 5487 5488 portmod_dispatch_type_t __type__; 5489 int __rv__; 5490 SOC_INIT_FUNC_DEFS; 5491 5492 if(eee == NULL) { 5493 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("eee NULL parameter")); 5494 } 5495 if(SOC_E_NONE != portmod_eee_t_init(unit, eee)) { 5496 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("eee initialization failed")); 5497 } 5498 5499 /* Dispatch */ 5500 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5501 if(__type__ >= portmodDispatchTypeCount) { 5502 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5503 } 5504 5505 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_eee_get) { 5506 pm_info_t pm_info; 5507 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5508 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_eee_get(unit, port, pm_info, eee); 5509 _SOC_IF_ERR_EXIT(__rv__); 5510 } else { 5511 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_eee_get isn't implemented for driver type")); 5512 } 5513 5514 exit: 5515 SOC_FUNC_RETURN; 5516 5517 } 5518 5519 5520 int portmod_port_eee_clock_set(int unit, int port, const portmod_eee_clock_t* eee_clk) 5521 { 5522 5523 portmod_dispatch_type_t __type__; 5524 int __rv__; 5525 SOC_INIT_FUNC_DEFS; 5526 5527 if(SOC_E_NONE != portmod_eee_clock_t_validate(unit, eee_clk)) { 5528 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("eee_clk validation failed")); 5529 } 5530 5531 /* Dispatch */ 5532 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5533 if(__type__ >= portmodDispatchTypeCount) { 5534 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5535 } 5536 5537 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_eee_clock_set) { 5538 pm_info_t pm_info; 5539 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5540 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_eee_clock_set(unit, port, pm_info, eee_clk); 5541 _SOC_IF_ERR_EXIT(__rv__); 5542 } else { 5543 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_eee_clock_set isn't implemented for driver type")); 5544 } 5545 5546 exit: 5547 SOC_FUNC_RETURN; 5548 5549 } 5550 5551 5552 int portmod_port_eee_clock_get(int unit, int port, portmod_eee_clock_t* eee_clk) 5553 { 5554 5555 portmod_dispatch_type_t __type__; 5556 int __rv__; 5557 SOC_INIT_FUNC_DEFS; 5558 5559 if(eee_clk == NULL) { 5560 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("eee_clk NULL parameter")); 5561 } 5562 if(SOC_E_NONE != portmod_eee_clock_t_init(unit, eee_clk)) { 5563 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("eee_clk initialization failed")); 5564 } 5565 5566 /* Dispatch */ 5567 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5568 if(__type__ >= portmodDispatchTypeCount) { 5569 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5570 } 5571 5572 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_eee_clock_get) { 5573 pm_info_t pm_info; 5574 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5575 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_eee_clock_get(unit, port, pm_info, eee_clk); 5576 _SOC_IF_ERR_EXIT(__rv__); 5577 } else { 5578 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_eee_clock_get isn't implemented for driver type")); 5579 } 5580 5581 exit: 5582 SOC_FUNC_RETURN; 5583 5584 } 5585 5586 5587 int portmod_port_vlan_tag_set(int unit, int port, const portmod_vlan_tag_t* vlan_tag) 5588 { 5589 5590 portmod_dispatch_type_t __type__; 5591 int __rv__; 5592 SOC_INIT_FUNC_DEFS; 5593 5594 if(SOC_E_NONE != portmod_vlan_tag_t_validate(unit, vlan_tag)) { 5595 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vlan_tag validation failed")); 5596 } 5597 5598 /* Dispatch */ 5599 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5600 if(__type__ >= portmodDispatchTypeCount) { 5601 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5602 } 5603 5604 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_vlan_tag_set) { 5605 pm_info_t pm_info; 5606 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5607 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_vlan_tag_set(unit, port, pm_info, vlan_tag); 5608 _SOC_IF_ERR_EXIT(__rv__); 5609 } else { 5610 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_vlan_tag_set isn't implemented for driver type")); 5611 } 5612 5613 exit: 5614 SOC_FUNC_RETURN; 5615 5616 } 5617 5618 5619 int portmod_port_vlan_tag_get(int unit, int port, portmod_vlan_tag_t* vlan_tag) 5620 { 5621 5622 portmod_dispatch_type_t __type__; 5623 int __rv__; 5624 SOC_INIT_FUNC_DEFS; 5625 5626 if(vlan_tag == NULL) { 5627 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vlan_tag NULL parameter")); 5628 } 5629 if(SOC_E_NONE != portmod_vlan_tag_t_init(unit, vlan_tag)) { 5630 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vlan_tag initialization failed")); 5631 } 5632 5633 /* Dispatch */ 5634 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5635 if(__type__ >= portmodDispatchTypeCount) { 5636 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5637 } 5638 5639 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_vlan_tag_get) { 5640 pm_info_t pm_info; 5641 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5642 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_vlan_tag_get(unit, port, pm_info, vlan_tag); 5643 _SOC_IF_ERR_EXIT(__rv__); 5644 } else { 5645 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_vlan_tag_get isn't implemented for driver type")); 5646 } 5647 5648 exit: 5649 SOC_FUNC_RETURN; 5650 5651 } 5652 5653 5654 int portmod_port_modid_set(int unit, int port, int value) 5655 { 5656 5657 portmod_dispatch_type_t __type__; 5658 int __rv__; 5659 SOC_INIT_FUNC_DEFS; 5660 5661 /* Dispatch */ 5662 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5663 if(__type__ >= portmodDispatchTypeCount) { 5664 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5665 } 5666 5667 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_modid_set) { 5668 pm_info_t pm_info; 5669 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5670 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_modid_set(unit, port, pm_info, value); 5671 _SOC_IF_ERR_EXIT(__rv__); 5672 } else { 5673 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_modid_set isn't implemented for driver type")); 5674 } 5675 5676 exit: 5677 SOC_FUNC_RETURN; 5678 5679 } 5680 5681 5682 int portmod_port_led_chain_config(int unit, int port, int value) 5683 { 5684 5685 portmod_dispatch_type_t __type__; 5686 int __rv__; 5687 SOC_INIT_FUNC_DEFS; 5688 5689 /* Dispatch */ 5690 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5691 if(__type__ >= portmodDispatchTypeCount) { 5692 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5693 } 5694 5695 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_led_chain_config) { 5696 pm_info_t pm_info; 5697 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5698 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_led_chain_config(unit, port, pm_info, value); 5699 _SOC_IF_ERR_EXIT(__rv__); 5700 } else { 5701 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_led_chain_config isn't implemented for driver type")); 5702 } 5703 5704 exit: 5705 SOC_FUNC_RETURN; 5706 5707 } 5708 5709 5710 int portmod_port_clear_rx_lss_status_set(int unit, int port, int lcl_fault, int rmt_fault) 5711 { 5712 5713 portmod_dispatch_type_t __type__; 5714 int __rv__; 5715 SOC_INIT_FUNC_DEFS; 5716 5717 /* Dispatch */ 5718 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5719 if(__type__ >= portmodDispatchTypeCount) { 5720 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5721 } 5722 5723 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_clear_rx_lss_status_set) { 5724 pm_info_t pm_info; 5725 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5726 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_clear_rx_lss_status_set(unit, port, pm_info, lcl_fault, rmt_fault); 5727 _SOC_IF_ERR_EXIT(__rv__); 5728 } else { 5729 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_clear_rx_lss_status_set isn't implemented for driver type")); 5730 } 5731 5732 exit: 5733 SOC_FUNC_RETURN; 5734 5735 } 5736 5737 5738 int portmod_port_clear_rx_lss_status_get(int unit, int port, int* lcl_fault, int* rmt_fault) 5739 { 5740 5741 portmod_dispatch_type_t __type__; 5742 int __rv__; 5743 SOC_INIT_FUNC_DEFS; 5744 5745 if(lcl_fault == NULL) { 5746 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lcl_fault NULL parameter")); 5747 } 5748 if(rmt_fault == NULL) { 5749 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rmt_fault NULL parameter")); 5750 } 5751 /* Dispatch */ 5752 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5753 if(__type__ >= portmodDispatchTypeCount) { 5754 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5755 } 5756 5757 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_clear_rx_lss_status_get) { 5758 pm_info_t pm_info; 5759 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 5760 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_clear_rx_lss_status_get(unit, port, pm_info, lcl_fault, rmt_fault); 5761 _SOC_IF_ERR_EXIT(__rv__); 5762 } else { 5763 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_clear_rx_lss_status_get isn't implemented for driver type")); 5764 } 5765 5766 exit: 5767 SOC_FUNC_RETURN; 5768 5769 } 5770 5771 5772 int portmod_lane_connection_t_validate(int unit, const portmod_lane_connection_t* portmod_lane_connection) 5773 { 5774 SOC_INIT_FUNC_DEFS; 5775 if(portmod_lane_connection == NULL) { 5776 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 5777 } 5778 5779 5780 5781 exit: 5782 SOC_FUNC_RETURN; 5783 5784 } 5785 5786 int portmod_lane_connection_t_init(int unit, portmod_lane_connection_t* portmod_lane_connection) 5787 { 5788 SOC_INIT_FUNC_DEFS; 5789 5790 if(portmod_lane_connection == NULL){ 5791 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_lane_connection NULL parameter")); 5792 } 5793 sal_memset(portmod_lane_connection, 0, sizeof(portmod_lane_connection_t)); 5794 portmod_lane_connection->core_index = PORTMOD_CORE_INDEX_INVALID; 5795 portmod_lane_connection->lane_index = PORTMOD_LANE_INDEX_INVALID; 5796 5797 5798 exit: 5799 SOC_FUNC_RETURN; 5800 5801 } 5802 5803 int portmod_phy_core_info_t_validate(int unit, const portmod_phy_core_info_t* portmod_phy_core_info) 5804 { 5805 SOC_INIT_FUNC_DEFS; 5806 if(portmod_phy_core_info == NULL) { 5807 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 5808 } 5809 5810 5811 5812 exit: 5813 SOC_FUNC_RETURN; 5814 5815 } 5816 5817 int portmod_phy_core_info_t_init(int unit, portmod_phy_core_info_t* portmod_phy_core_info) 5818 { 5819 SOC_INIT_FUNC_DEFS; 5820 5821 if(portmod_phy_core_info == NULL){ 5822 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_phy_core_info NULL parameter")); 5823 } 5824 sal_memset(portmod_phy_core_info, 0, sizeof(portmod_phy_core_info_t)); 5825 phymod_core_access_t_init(&portmod_phy_core_info->core_access); 5826 5827 5828 exit: 5829 SOC_FUNC_RETURN; 5830 5831 } 5832 5833 int portmod_xphy_lane_connection_t_validate(int unit, const portmod_xphy_lane_connection_t* portmod_xphy_lane_connection) 5834 { 5835 SOC_INIT_FUNC_DEFS; 5836 if(portmod_xphy_lane_connection == NULL) { 5837 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 5838 } 5839 5840 5841 5842 exit: 5843 SOC_FUNC_RETURN; 5844 5845 } 5846 5847 int portmod_xphy_lane_connection_t_init(int unit, portmod_xphy_lane_connection_t* portmod_xphy_lane_connection) 5848 { 5849 SOC_INIT_FUNC_DEFS; 5850 5851 if(portmod_xphy_lane_connection == NULL){ 5852 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_xphy_lane_connection NULL parameter")); 5853 } 5854 sal_memset(portmod_xphy_lane_connection, 0, sizeof(portmod_xphy_lane_connection_t)); 5855 portmod_xphy_lane_connection->xphy_id = PORTMOD_XPHY_ID_INVALID; 5856 portmod_xphy_lane_connection->ss_lane_mask = PORTMOD_LANE_INDEX_INVALID; 5857 portmod_xphy_lane_connection->ls_lane_mask = PORTMOD_LANE_INDEX_INVALID; 5858 portmod_xphy_lane_connection->rsvd1 = PORTMOD_LANE_INDEX_INVALID; 5859 portmod_xphy_lane_connection->rsvd2 = PORTMOD_LANE_INDEX_INVALID; 5860 5861 5862 exit: 5863 SOC_FUNC_RETURN; 5864 5865 } 5866 5867 int portmod_xphy_lane_attach_to_pm(int unit, pm_info_t pm_info, int iphy, int phyn, const portmod_xphy_lane_connection_t* lane_connection) 5868 { 5869 5870 portmod_dispatch_type_t __type__; 5871 int __rv__; 5872 SOC_INIT_FUNC_DEFS; 5873 5874 if(SOC_E_NONE != portmod_xphy_lane_connection_t_validate(unit, lane_connection)) { 5875 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_connection validation failed")); 5876 } 5877 5878 /* Dispatch */ 5879 __type__ = (pm_info)->type; 5880 if(__type__ >= portmodDispatchTypeCount) { 5881 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5882 } 5883 5884 if(NULL != __portmod__dispatch__[__type__]->f_portmod_xphy_lane_attach_to_pm) { 5885 __rv__ = __portmod__dispatch__[__type__]->f_portmod_xphy_lane_attach_to_pm(unit, pm_info, iphy, phyn, lane_connection); 5886 _SOC_IF_ERR_EXIT(__rv__); 5887 } else { 5888 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_xphy_lane_attach_to_pm isn't implemented for driver type")); 5889 } 5890 5891 exit: 5892 SOC_FUNC_RETURN; 5893 5894 } 5895 5896 5897 int portmod_xphy_lane_detach_from_pm(int unit, pm_info_t pm_info, int iphy, int phyn, portmod_xphy_lane_connection_t* lane_connection) 5898 { 5899 5900 portmod_dispatch_type_t __type__; 5901 int __rv__; 5902 SOC_INIT_FUNC_DEFS; 5903 5904 if(SOC_E_NONE != portmod_xphy_lane_connection_t_init(unit, lane_connection)) { 5905 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_connection initialization failed")); 5906 } 5907 5908 /* Dispatch */ 5909 __type__ = (pm_info)->type; 5910 if(__type__ >= portmodDispatchTypeCount) { 5911 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5912 } 5913 5914 if(NULL != __portmod__dispatch__[__type__]->f_portmod_xphy_lane_detach_from_pm) { 5915 __rv__ = __portmod__dispatch__[__type__]->f_portmod_xphy_lane_detach_from_pm(unit, pm_info, iphy, phyn, lane_connection); 5916 _SOC_IF_ERR_EXIT(__rv__); 5917 } else { 5918 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_xphy_lane_detach_from_pm isn't implemented for driver type")); 5919 } 5920 5921 exit: 5922 SOC_FUNC_RETURN; 5923 5924 } 5925 5926 5927 int portmod_ext_phy_lane_attach_to_pm(int unit, pm_info_t pm_info, int iphy, int phyn, const portmod_lane_connection_t* lane_connection) 5928 { 5929 5930 portmod_dispatch_type_t __type__; 5931 int __rv__; 5932 SOC_INIT_FUNC_DEFS; 5933 5934 if(SOC_E_NONE != portmod_lane_connection_t_validate(unit, lane_connection)) { 5935 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_connection validation failed")); 5936 } 5937 5938 /* Dispatch */ 5939 __type__ = (pm_info)->type; 5940 if(__type__ >= portmodDispatchTypeCount) { 5941 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5942 } 5943 5944 if(NULL != __portmod__dispatch__[__type__]->f_portmod_ext_phy_lane_attach_to_pm) { 5945 __rv__ = __portmod__dispatch__[__type__]->f_portmod_ext_phy_lane_attach_to_pm(unit, pm_info, iphy, phyn, lane_connection); 5946 _SOC_IF_ERR_EXIT(__rv__); 5947 } else { 5948 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_ext_phy_lane_attach_to_pm isn't implemented for driver type")); 5949 } 5950 5951 exit: 5952 SOC_FUNC_RETURN; 5953 5954 } 5955 5956 5957 int portmod_ext_phy_lane_detach_from_pm(int unit, pm_info_t pm_info, int iphy, int phyn, portmod_lane_connection_t* lane_connection) 5958 { 5959 5960 portmod_dispatch_type_t __type__; 5961 int __rv__; 5962 SOC_INIT_FUNC_DEFS; 5963 5964 if(SOC_E_NONE != portmod_lane_connection_t_init(unit, lane_connection)) { 5965 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_connection initialization failed")); 5966 } 5967 5968 /* Dispatch */ 5969 __type__ = (pm_info)->type; 5970 if(__type__ >= portmodDispatchTypeCount) { 5971 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5972 } 5973 5974 if(NULL != __portmod__dispatch__[__type__]->f_portmod_ext_phy_lane_detach_from_pm) { 5975 __rv__ = __portmod__dispatch__[__type__]->f_portmod_ext_phy_lane_detach_from_pm(unit, pm_info, iphy, phyn, lane_connection); 5976 _SOC_IF_ERR_EXIT(__rv__); 5977 } else { 5978 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_ext_phy_lane_detach_from_pm isn't implemented for driver type")); 5979 } 5980 5981 exit: 5982 SOC_FUNC_RETURN; 5983 5984 } 5985 5986 5987 int portmod_port_lag_failover_status_toggle(int unit, int port) 5988 { 5989 5990 portmod_dispatch_type_t __type__; 5991 int __rv__; 5992 SOC_INIT_FUNC_DEFS; 5993 5994 /* Dispatch */ 5995 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 5996 if(__type__ >= portmodDispatchTypeCount) { 5997 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 5998 } 5999 6000 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_status_toggle) { 6001 pm_info_t pm_info; 6002 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6003 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_status_toggle(unit, port, pm_info); 6004 _SOC_IF_ERR_EXIT(__rv__); 6005 } else { 6006 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lag_failover_status_toggle isn't implemented for driver type")); 6007 } 6008 6009 exit: 6010 SOC_FUNC_RETURN; 6011 6012 } 6013 6014 6015 int portmod_port_lag_failover_loopback_set(int unit, int port, int value) 6016 { 6017 6018 portmod_dispatch_type_t __type__; 6019 int __rv__; 6020 SOC_INIT_FUNC_DEFS; 6021 6022 /* Dispatch */ 6023 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6024 if(__type__ >= portmodDispatchTypeCount) { 6025 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6026 } 6027 6028 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_loopback_set) { 6029 pm_info_t pm_info; 6030 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6031 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_loopback_set(unit, port, pm_info, value); 6032 _SOC_IF_ERR_EXIT(__rv__); 6033 } else { 6034 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lag_failover_loopback_set isn't implemented for driver type")); 6035 } 6036 6037 exit: 6038 SOC_FUNC_RETURN; 6039 6040 } 6041 6042 6043 int portmod_port_lag_failover_loopback_get(int unit, int port, int* value) 6044 { 6045 6046 portmod_dispatch_type_t __type__; 6047 int __rv__; 6048 SOC_INIT_FUNC_DEFS; 6049 6050 if(value == NULL) { 6051 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 6052 } 6053 /* Dispatch */ 6054 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6055 if(__type__ >= portmodDispatchTypeCount) { 6056 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6057 } 6058 6059 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_loopback_get) { 6060 pm_info_t pm_info; 6061 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6062 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_loopback_get(unit, port, pm_info, value); 6063 _SOC_IF_ERR_EXIT(__rv__); 6064 } else { 6065 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lag_failover_loopback_get isn't implemented for driver type")); 6066 } 6067 6068 exit: 6069 SOC_FUNC_RETURN; 6070 6071 } 6072 6073 6074 int portmod_port_mode_set(int unit, int port, const portmod_port_mode_info_t* mode) 6075 { 6076 6077 portmod_dispatch_type_t __type__; 6078 int __rv__; 6079 SOC_INIT_FUNC_DEFS; 6080 6081 if(SOC_E_NONE != portmod_port_mode_info_t_validate(unit, mode)) { 6082 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode validation failed")); 6083 } 6084 6085 /* Dispatch */ 6086 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6087 if(__type__ >= portmodDispatchTypeCount) { 6088 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6089 } 6090 6091 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mode_set) { 6092 pm_info_t pm_info; 6093 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6094 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mode_set(unit, port, pm_info, mode); 6095 _SOC_IF_ERR_EXIT(__rv__); 6096 } else { 6097 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mode_set isn't implemented for driver type")); 6098 } 6099 6100 exit: 6101 SOC_FUNC_RETURN; 6102 6103 } 6104 6105 6106 int portmod_port_mode_get(int unit, int port, portmod_port_mode_info_t* mode) 6107 { 6108 6109 portmod_dispatch_type_t __type__; 6110 int __rv__; 6111 SOC_INIT_FUNC_DEFS; 6112 6113 if(mode == NULL) { 6114 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode NULL parameter")); 6115 } 6116 if(SOC_E_NONE != portmod_port_mode_info_t_init(unit, mode)) { 6117 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode initialization failed")); 6118 } 6119 6120 /* Dispatch */ 6121 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6122 if(__type__ >= portmodDispatchTypeCount) { 6123 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6124 } 6125 6126 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mode_get) { 6127 pm_info_t pm_info; 6128 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6129 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mode_get(unit, port, pm_info, mode); 6130 _SOC_IF_ERR_EXIT(__rv__); 6131 } else { 6132 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mode_get isn't implemented for driver type")); 6133 } 6134 6135 exit: 6136 SOC_FUNC_RETURN; 6137 6138 } 6139 6140 6141 int portmod_port_encap_set(int unit, int port, int flags, portmod_encap_t encap) 6142 { 6143 6144 portmod_dispatch_type_t __type__; 6145 int __rv__; 6146 SOC_INIT_FUNC_DEFS; 6147 6148 /* Dispatch */ 6149 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6150 if(__type__ >= portmodDispatchTypeCount) { 6151 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6152 } 6153 6154 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_encap_set) { 6155 pm_info_t pm_info; 6156 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6157 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_encap_set(unit, port, pm_info, flags, encap); 6158 _SOC_IF_ERR_EXIT(__rv__); 6159 } else { 6160 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_encap_set isn't implemented for driver type")); 6161 } 6162 6163 exit: 6164 SOC_FUNC_RETURN; 6165 6166 } 6167 6168 6169 int portmod_port_encap_get(int unit, int port, int* flags, portmod_encap_t* encap) 6170 { 6171 6172 portmod_dispatch_type_t __type__; 6173 int __rv__; 6174 SOC_INIT_FUNC_DEFS; 6175 6176 if(flags == NULL) { 6177 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("flags NULL parameter")); 6178 } 6179 if(encap == NULL) { 6180 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("encap NULL parameter")); 6181 } 6182 /* Dispatch */ 6183 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6184 if(__type__ >= portmodDispatchTypeCount) { 6185 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6186 } 6187 6188 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_encap_get) { 6189 pm_info_t pm_info; 6190 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6191 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_encap_get(unit, port, pm_info, flags, encap); 6192 _SOC_IF_ERR_EXIT(__rv__); 6193 } else { 6194 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_encap_get isn't implemented for driver type")); 6195 } 6196 6197 exit: 6198 SOC_FUNC_RETURN; 6199 6200 } 6201 6202 6203 int portmod_port_higig_mode_set(int unit, int port, int mode) 6204 { 6205 6206 portmod_dispatch_type_t __type__; 6207 int __rv__; 6208 SOC_INIT_FUNC_DEFS; 6209 6210 /* Dispatch */ 6211 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6212 if(__type__ >= portmodDispatchTypeCount) { 6213 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6214 } 6215 6216 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_higig_mode_set) { 6217 pm_info_t pm_info; 6218 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6219 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_higig_mode_set(unit, port, pm_info, mode); 6220 _SOC_IF_ERR_EXIT(__rv__); 6221 } else { 6222 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_higig_mode_set isn't implemented for driver type")); 6223 } 6224 6225 exit: 6226 SOC_FUNC_RETURN; 6227 6228 } 6229 6230 6231 int portmod_port_higig_mode_get(int unit, int port, int* mode) 6232 { 6233 6234 portmod_dispatch_type_t __type__; 6235 int __rv__; 6236 SOC_INIT_FUNC_DEFS; 6237 6238 if(mode == NULL) { 6239 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode NULL parameter")); 6240 } 6241 /* Dispatch */ 6242 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6243 if(__type__ >= portmodDispatchTypeCount) { 6244 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6245 } 6246 6247 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_higig_mode_get) { 6248 pm_info_t pm_info; 6249 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6250 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_higig_mode_get(unit, port, pm_info, mode); 6251 _SOC_IF_ERR_EXIT(__rv__); 6252 } else { 6253 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_higig_mode_get isn't implemented for driver type")); 6254 } 6255 6256 exit: 6257 SOC_FUNC_RETURN; 6258 6259 } 6260 6261 6262 int portmod_port_higig2_mode_set(int unit, int port, int mode) 6263 { 6264 6265 portmod_dispatch_type_t __type__; 6266 int __rv__; 6267 SOC_INIT_FUNC_DEFS; 6268 6269 /* Dispatch */ 6270 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6271 if(__type__ >= portmodDispatchTypeCount) { 6272 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6273 } 6274 6275 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_higig2_mode_set) { 6276 pm_info_t pm_info; 6277 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6278 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_higig2_mode_set(unit, port, pm_info, mode); 6279 _SOC_IF_ERR_EXIT(__rv__); 6280 } else { 6281 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_higig2_mode_set isn't implemented for driver type")); 6282 } 6283 6284 exit: 6285 SOC_FUNC_RETURN; 6286 6287 } 6288 6289 6290 int portmod_port_higig2_mode_get(int unit, int port, int* mode) 6291 { 6292 6293 portmod_dispatch_type_t __type__; 6294 int __rv__; 6295 SOC_INIT_FUNC_DEFS; 6296 6297 if(mode == NULL) { 6298 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("mode NULL parameter")); 6299 } 6300 /* Dispatch */ 6301 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6302 if(__type__ >= portmodDispatchTypeCount) { 6303 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6304 } 6305 6306 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_higig2_mode_get) { 6307 pm_info_t pm_info; 6308 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6309 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_higig2_mode_get(unit, port, pm_info, mode); 6310 _SOC_IF_ERR_EXIT(__rv__); 6311 } else { 6312 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_higig2_mode_get isn't implemented for driver type")); 6313 } 6314 6315 exit: 6316 SOC_FUNC_RETURN; 6317 6318 } 6319 6320 6321 int portmod_port_config_port_type_set(int unit, int port, int type) 6322 { 6323 6324 portmod_dispatch_type_t __type__; 6325 int __rv__; 6326 SOC_INIT_FUNC_DEFS; 6327 6328 /* Dispatch */ 6329 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6330 if(__type__ >= portmodDispatchTypeCount) { 6331 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6332 } 6333 6334 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_config_port_type_set) { 6335 pm_info_t pm_info; 6336 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6337 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_config_port_type_set(unit, port, pm_info, type); 6338 _SOC_IF_ERR_EXIT(__rv__); 6339 } else { 6340 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_config_port_type_set isn't implemented for driver type")); 6341 } 6342 6343 exit: 6344 SOC_FUNC_RETURN; 6345 6346 } 6347 6348 6349 int portmod_port_config_port_type_get(int unit, int port, int* type) 6350 { 6351 6352 portmod_dispatch_type_t __type__; 6353 int __rv__; 6354 SOC_INIT_FUNC_DEFS; 6355 6356 if(type == NULL) { 6357 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type NULL parameter")); 6358 } 6359 /* Dispatch */ 6360 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6361 if(__type__ >= portmodDispatchTypeCount) { 6362 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6363 } 6364 6365 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_config_port_type_get) { 6366 pm_info_t pm_info; 6367 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6368 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_config_port_type_get(unit, port, pm_info, type); 6369 _SOC_IF_ERR_EXIT(__rv__); 6370 } else { 6371 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_config_port_type_get isn't implemented for driver type")); 6372 } 6373 6374 exit: 6375 SOC_FUNC_RETURN; 6376 6377 } 6378 6379 6380 int portmod_port_trunk_hwfailover_config_set(int unit, int port, int hw_count) 6381 { 6382 6383 portmod_dispatch_type_t __type__; 6384 int __rv__; 6385 SOC_INIT_FUNC_DEFS; 6386 6387 /* Dispatch */ 6388 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6389 if(__type__ >= portmodDispatchTypeCount) { 6390 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6391 } 6392 6393 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_trunk_hwfailover_config_set) { 6394 pm_info_t pm_info; 6395 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6396 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_trunk_hwfailover_config_set(unit, port, pm_info, hw_count); 6397 _SOC_IF_ERR_EXIT(__rv__); 6398 } else { 6399 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_trunk_hwfailover_config_set isn't implemented for driver type")); 6400 } 6401 6402 exit: 6403 SOC_FUNC_RETURN; 6404 6405 } 6406 6407 6408 int portmod_port_trunk_hwfailover_config_get(int unit, int port, int* enable) 6409 { 6410 6411 portmod_dispatch_type_t __type__; 6412 int __rv__; 6413 SOC_INIT_FUNC_DEFS; 6414 6415 if(enable == NULL) { 6416 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 6417 } 6418 /* Dispatch */ 6419 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6420 if(__type__ >= portmodDispatchTypeCount) { 6421 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6422 } 6423 6424 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_trunk_hwfailover_config_get) { 6425 pm_info_t pm_info; 6426 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6427 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_trunk_hwfailover_config_get(unit, port, pm_info, enable); 6428 _SOC_IF_ERR_EXIT(__rv__); 6429 } else { 6430 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_trunk_hwfailover_config_get isn't implemented for driver type")); 6431 } 6432 6433 exit: 6434 SOC_FUNC_RETURN; 6435 6436 } 6437 6438 6439 int portmod_port_trunk_hwfailover_status_get(int unit, int port, int* loopback) 6440 { 6441 6442 portmod_dispatch_type_t __type__; 6443 int __rv__; 6444 SOC_INIT_FUNC_DEFS; 6445 6446 if(loopback == NULL) { 6447 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("loopback NULL parameter")); 6448 } 6449 /* Dispatch */ 6450 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6451 if(__type__ >= portmodDispatchTypeCount) { 6452 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6453 } 6454 6455 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_trunk_hwfailover_status_get) { 6456 pm_info_t pm_info; 6457 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6458 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_trunk_hwfailover_status_get(unit, port, pm_info, loopback); 6459 _SOC_IF_ERR_EXIT(__rv__); 6460 } else { 6461 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_trunk_hwfailover_status_get isn't implemented for driver type")); 6462 } 6463 6464 exit: 6465 SOC_FUNC_RETURN; 6466 6467 } 6468 6469 6470 int portmod_port_diag_ctrl(int unit, int port, uint32 inst, int op_type, int op_cmd, const void* arg) 6471 { 6472 6473 portmod_dispatch_type_t __type__; 6474 int __rv__; 6475 SOC_INIT_FUNC_DEFS; 6476 6477 /* Dispatch */ 6478 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6479 if(__type__ >= portmodDispatchTypeCount) { 6480 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6481 } 6482 6483 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_diag_ctrl) { 6484 pm_info_t pm_info; 6485 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6486 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_diag_ctrl(unit, port, pm_info, inst, op_type, op_cmd, arg); 6487 _SOC_IF_ERR_EXIT(__rv__); 6488 } else { 6489 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_diag_ctrl isn't implemented for driver type")); 6490 } 6491 6492 exit: 6493 SOC_FUNC_RETURN; 6494 6495 } 6496 6497 6498 int portmod_port_ref_clk_get(int unit, int port, int* ref_clk) 6499 { 6500 6501 portmod_dispatch_type_t __type__; 6502 int __rv__; 6503 SOC_INIT_FUNC_DEFS; 6504 6505 if(ref_clk == NULL) { 6506 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ref_clk NULL parameter")); 6507 } 6508 /* Dispatch */ 6509 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6510 if(__type__ >= portmodDispatchTypeCount) { 6511 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6512 } 6513 6514 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_ref_clk_get) { 6515 pm_info_t pm_info; 6516 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6517 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_ref_clk_get(unit, port, pm_info, ref_clk); 6518 _SOC_IF_ERR_EXIT(__rv__); 6519 } else { 6520 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_ref_clk_get isn't implemented for driver type")); 6521 } 6522 6523 exit: 6524 SOC_FUNC_RETURN; 6525 6526 } 6527 6528 6529 int portmod_port_lag_failover_disable(int unit, int port) 6530 { 6531 6532 portmod_dispatch_type_t __type__; 6533 int __rv__; 6534 SOC_INIT_FUNC_DEFS; 6535 6536 /* Dispatch */ 6537 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6538 if(__type__ >= portmodDispatchTypeCount) { 6539 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6540 } 6541 6542 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_disable) { 6543 pm_info_t pm_info; 6544 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6545 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lag_failover_disable(unit, port, pm_info); 6546 _SOC_IF_ERR_EXIT(__rv__); 6547 } else { 6548 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lag_failover_disable isn't implemented for driver type")); 6549 } 6550 6551 exit: 6552 SOC_FUNC_RETURN; 6553 6554 } 6555 6556 6557 int portmod_port_lag_remove_failover_lpbk_set(int unit, int port, int val) 6558 { 6559 6560 portmod_dispatch_type_t __type__; 6561 int __rv__; 6562 SOC_INIT_FUNC_DEFS; 6563 6564 /* Dispatch */ 6565 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6566 if(__type__ >= portmodDispatchTypeCount) { 6567 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6568 } 6569 6570 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lag_remove_failover_lpbk_set) { 6571 pm_info_t pm_info; 6572 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6573 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lag_remove_failover_lpbk_set(unit, port, pm_info, val); 6574 _SOC_IF_ERR_EXIT(__rv__); 6575 } else { 6576 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lag_remove_failover_lpbk_set isn't implemented for driver type")); 6577 } 6578 6579 exit: 6580 SOC_FUNC_RETURN; 6581 6582 } 6583 6584 6585 int portmod_port_lag_remove_failover_lpbk_get(int unit, int port, int* val) 6586 { 6587 6588 portmod_dispatch_type_t __type__; 6589 int __rv__; 6590 SOC_INIT_FUNC_DEFS; 6591 6592 if(val == NULL) { 6593 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("val NULL parameter")); 6594 } 6595 /* Dispatch */ 6596 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6597 if(__type__ >= portmodDispatchTypeCount) { 6598 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6599 } 6600 6601 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lag_remove_failover_lpbk_get) { 6602 pm_info_t pm_info; 6603 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6604 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lag_remove_failover_lpbk_get(unit, port, pm_info, val); 6605 _SOC_IF_ERR_EXIT(__rv__); 6606 } else { 6607 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lag_remove_failover_lpbk_get isn't implemented for driver type")); 6608 } 6609 6610 exit: 6611 SOC_FUNC_RETURN; 6612 6613 } 6614 6615 6616 int portmod_port_cntmaxsize_set(int unit, int port, int val) 6617 { 6618 6619 portmod_dispatch_type_t __type__; 6620 int __rv__; 6621 SOC_INIT_FUNC_DEFS; 6622 6623 /* Dispatch */ 6624 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6625 if(__type__ >= portmodDispatchTypeCount) { 6626 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6627 } 6628 6629 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_cntmaxsize_set) { 6630 pm_info_t pm_info; 6631 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6632 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_cntmaxsize_set(unit, port, pm_info, val); 6633 _SOC_IF_ERR_EXIT(__rv__); 6634 } else { 6635 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_cntmaxsize_set isn't implemented for driver type")); 6636 } 6637 6638 exit: 6639 SOC_FUNC_RETURN; 6640 6641 } 6642 6643 6644 int portmod_port_cntmaxsize_get(int unit, int port, int* val) 6645 { 6646 6647 portmod_dispatch_type_t __type__; 6648 int __rv__; 6649 SOC_INIT_FUNC_DEFS; 6650 6651 if(val == NULL) { 6652 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("val NULL parameter")); 6653 } 6654 /* Dispatch */ 6655 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6656 if(__type__ >= portmodDispatchTypeCount) { 6657 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6658 } 6659 6660 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_cntmaxsize_get) { 6661 pm_info_t pm_info; 6662 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6663 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_cntmaxsize_get(unit, port, pm_info, val); 6664 _SOC_IF_ERR_EXIT(__rv__); 6665 } else { 6666 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_cntmaxsize_get isn't implemented for driver type")); 6667 } 6668 6669 exit: 6670 SOC_FUNC_RETURN; 6671 6672 } 6673 6674 6675 int portmod_port_multi_get(int unit, int port, portmod_multi_get_t* multi_get) 6676 { 6677 6678 portmod_dispatch_type_t __type__; 6679 int __rv__; 6680 SOC_INIT_FUNC_DEFS; 6681 6682 if(multi_get == NULL) { 6683 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("multi_get NULL parameter")); 6684 } 6685 if(SOC_E_NONE != portmod_multi_get_t_validate(unit, multi_get)) { 6686 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("multi_get validation failed")); 6687 } 6688 6689 /* Dispatch */ 6690 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6691 if(__type__ >= portmodDispatchTypeCount) { 6692 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6693 } 6694 6695 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_multi_get) { 6696 pm_info_t pm_info; 6697 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6698 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_multi_get(unit, port, pm_info, multi_get); 6699 _SOC_IF_ERR_EXIT(__rv__); 6700 } else { 6701 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_multi_get isn't implemented for driver type")); 6702 } 6703 6704 exit: 6705 SOC_FUNC_RETURN; 6706 6707 } 6708 6709 6710 int portmod_port_drain_cell_get(int unit, int port, portmod_drain_cells_t* drain_cells) 6711 { 6712 6713 portmod_dispatch_type_t __type__; 6714 int __rv__; 6715 SOC_INIT_FUNC_DEFS; 6716 6717 if(drain_cells == NULL) { 6718 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("drain_cells NULL parameter")); 6719 } 6720 if(SOC_E_NONE != portmod_drain_cells_t_init(unit, drain_cells)) { 6721 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("drain_cells initialization failed")); 6722 } 6723 6724 /* Dispatch */ 6725 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6726 if(__type__ >= portmodDispatchTypeCount) { 6727 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6728 } 6729 6730 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_drain_cell_get) { 6731 pm_info_t pm_info; 6732 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6733 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_drain_cell_get(unit, port, pm_info, drain_cells); 6734 _SOC_IF_ERR_EXIT(__rv__); 6735 } else { 6736 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_drain_cell_get isn't implemented for driver type")); 6737 } 6738 6739 exit: 6740 SOC_FUNC_RETURN; 6741 6742 } 6743 6744 6745 int portmod_port_drain_cell_stop(int unit, int port, const portmod_drain_cells_t* drain_cells) 6746 { 6747 6748 portmod_dispatch_type_t __type__; 6749 int __rv__; 6750 SOC_INIT_FUNC_DEFS; 6751 6752 if(SOC_E_NONE != portmod_drain_cells_t_validate(unit, drain_cells)) { 6753 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("drain_cells validation failed")); 6754 } 6755 6756 /* Dispatch */ 6757 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6758 if(__type__ >= portmodDispatchTypeCount) { 6759 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6760 } 6761 6762 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_drain_cell_stop) { 6763 pm_info_t pm_info; 6764 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6765 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_drain_cell_stop(unit, port, pm_info, drain_cells); 6766 _SOC_IF_ERR_EXIT(__rv__); 6767 } else { 6768 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_drain_cell_stop isn't implemented for driver type")); 6769 } 6770 6771 exit: 6772 SOC_FUNC_RETURN; 6773 6774 } 6775 6776 6777 int portmod_port_drain_cell_start(int unit, int port) 6778 { 6779 6780 portmod_dispatch_type_t __type__; 6781 int __rv__; 6782 SOC_INIT_FUNC_DEFS; 6783 6784 /* Dispatch */ 6785 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6786 if(__type__ >= portmodDispatchTypeCount) { 6787 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6788 } 6789 6790 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_drain_cell_start) { 6791 pm_info_t pm_info; 6792 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6793 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_drain_cell_start(unit, port, pm_info); 6794 _SOC_IF_ERR_EXIT(__rv__); 6795 } else { 6796 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_drain_cell_start isn't implemented for driver type")); 6797 } 6798 6799 exit: 6800 SOC_FUNC_RETURN; 6801 6802 } 6803 6804 6805 int portmod_port_drain_cells_rx_enable(int unit, int port, int rx_en) 6806 { 6807 6808 portmod_dispatch_type_t __type__; 6809 int __rv__; 6810 SOC_INIT_FUNC_DEFS; 6811 6812 /* Dispatch */ 6813 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6814 if(__type__ >= portmodDispatchTypeCount) { 6815 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6816 } 6817 6818 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_drain_cells_rx_enable) { 6819 pm_info_t pm_info; 6820 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6821 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_drain_cells_rx_enable(unit, port, pm_info, rx_en); 6822 _SOC_IF_ERR_EXIT(__rv__); 6823 } else { 6824 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_drain_cells_rx_enable isn't implemented for driver type")); 6825 } 6826 6827 exit: 6828 SOC_FUNC_RETURN; 6829 6830 } 6831 6832 6833 int portmod_port_egress_queue_drain_rx_en(int unit, int port, int rx_en) 6834 { 6835 6836 portmod_dispatch_type_t __type__; 6837 int __rv__; 6838 SOC_INIT_FUNC_DEFS; 6839 6840 /* Dispatch */ 6841 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6842 if(__type__ >= portmodDispatchTypeCount) { 6843 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6844 } 6845 6846 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_egress_queue_drain_rx_en) { 6847 pm_info_t pm_info; 6848 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6849 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_egress_queue_drain_rx_en(unit, port, pm_info, rx_en); 6850 _SOC_IF_ERR_EXIT(__rv__); 6851 } else { 6852 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_egress_queue_drain_rx_en isn't implemented for driver type")); 6853 } 6854 6855 exit: 6856 SOC_FUNC_RETURN; 6857 6858 } 6859 6860 6861 int portmod_port_mac_ctrl_set(int unit, int port, uint64 ctrl) 6862 { 6863 6864 portmod_dispatch_type_t __type__; 6865 int __rv__; 6866 SOC_INIT_FUNC_DEFS; 6867 6868 /* Dispatch */ 6869 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6870 if(__type__ >= portmodDispatchTypeCount) { 6871 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6872 } 6873 6874 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_ctrl_set) { 6875 pm_info_t pm_info; 6876 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6877 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_ctrl_set(unit, port, pm_info, ctrl); 6878 _SOC_IF_ERR_EXIT(__rv__); 6879 } else { 6880 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_ctrl_set isn't implemented for driver type")); 6881 } 6882 6883 exit: 6884 SOC_FUNC_RETURN; 6885 6886 } 6887 6888 6889 int portmod_port_txfifo_cell_cnt_get(int unit, int port, uint32* cnt) 6890 { 6891 6892 portmod_dispatch_type_t __type__; 6893 int __rv__; 6894 SOC_INIT_FUNC_DEFS; 6895 6896 if(cnt == NULL) { 6897 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cnt NULL parameter")); 6898 } 6899 /* Dispatch */ 6900 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6901 if(__type__ >= portmodDispatchTypeCount) { 6902 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6903 } 6904 6905 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_txfifo_cell_cnt_get) { 6906 pm_info_t pm_info; 6907 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6908 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_txfifo_cell_cnt_get(unit, port, pm_info, cnt); 6909 _SOC_IF_ERR_EXIT(__rv__); 6910 } else { 6911 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_txfifo_cell_cnt_get isn't implemented for driver type")); 6912 } 6913 6914 exit: 6915 SOC_FUNC_RETURN; 6916 6917 } 6918 6919 6920 int portmod_port_egress_queue_drain_get(int unit, int port, uint64* ctrl, int* rxen) 6921 { 6922 6923 portmod_dispatch_type_t __type__; 6924 int __rv__; 6925 SOC_INIT_FUNC_DEFS; 6926 6927 if(ctrl == NULL) { 6928 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ctrl NULL parameter")); 6929 } 6930 if(rxen == NULL) { 6931 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rxen NULL parameter")); 6932 } 6933 /* Dispatch */ 6934 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6935 if(__type__ >= portmodDispatchTypeCount) { 6936 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6937 } 6938 6939 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_egress_queue_drain_get) { 6940 pm_info_t pm_info; 6941 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6942 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_egress_queue_drain_get(unit, port, pm_info, ctrl, rxen); 6943 _SOC_IF_ERR_EXIT(__rv__); 6944 } else { 6945 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_egress_queue_drain_get isn't implemented for driver type")); 6946 } 6947 6948 exit: 6949 SOC_FUNC_RETURN; 6950 6951 } 6952 6953 6954 int portmod_port_mac_reset_set(int unit, int port, int val) 6955 { 6956 6957 portmod_dispatch_type_t __type__; 6958 int __rv__; 6959 SOC_INIT_FUNC_DEFS; 6960 6961 /* Dispatch */ 6962 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6963 if(__type__ >= portmodDispatchTypeCount) { 6964 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6965 } 6966 6967 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_reset_set) { 6968 pm_info_t pm_info; 6969 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 6970 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_reset_set(unit, port, pm_info, val); 6971 _SOC_IF_ERR_EXIT(__rv__); 6972 } else { 6973 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_reset_set isn't implemented for driver type")); 6974 } 6975 6976 exit: 6977 SOC_FUNC_RETURN; 6978 6979 } 6980 6981 6982 int portmod_port_mac_reset_get(int unit, int port, int* val) 6983 { 6984 6985 portmod_dispatch_type_t __type__; 6986 int __rv__; 6987 SOC_INIT_FUNC_DEFS; 6988 6989 if(val == NULL) { 6990 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("val NULL parameter")); 6991 } 6992 /* Dispatch */ 6993 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 6994 if(__type__ >= portmodDispatchTypeCount) { 6995 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 6996 } 6997 6998 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_reset_get) { 6999 pm_info_t pm_info; 7000 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7001 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_reset_get(unit, port, pm_info, val); 7002 _SOC_IF_ERR_EXIT(__rv__); 7003 } else { 7004 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_reset_get isn't implemented for driver type")); 7005 } 7006 7007 exit: 7008 SOC_FUNC_RETURN; 7009 7010 } 7011 7012 7013 int portmod_port_soft_reset_toggle(int unit, int port, int idx) 7014 { 7015 7016 portmod_dispatch_type_t __type__; 7017 int __rv__; 7018 SOC_INIT_FUNC_DEFS; 7019 7020 /* Dispatch */ 7021 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7022 if(__type__ >= portmodDispatchTypeCount) { 7023 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7024 } 7025 7026 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_soft_reset_toggle) { 7027 pm_info_t pm_info; 7028 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7029 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_soft_reset_toggle(unit, port, pm_info, idx); 7030 _SOC_IF_ERR_EXIT(__rv__); 7031 } else { 7032 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_soft_reset_toggle isn't implemented for driver type")); 7033 } 7034 7035 exit: 7036 SOC_FUNC_RETURN; 7037 7038 } 7039 7040 7041 int portmod_port_mac_reset_check(int unit, int port, int enable, int* reset) 7042 { 7043 7044 portmod_dispatch_type_t __type__; 7045 int __rv__; 7046 SOC_INIT_FUNC_DEFS; 7047 7048 if(reset == NULL) { 7049 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("reset NULL parameter")); 7050 } 7051 /* Dispatch */ 7052 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7053 if(__type__ >= portmodDispatchTypeCount) { 7054 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7055 } 7056 7057 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_reset_check) { 7058 pm_info_t pm_info; 7059 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7060 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_reset_check(unit, port, pm_info, enable, reset); 7061 _SOC_IF_ERR_EXIT(__rv__); 7062 } else { 7063 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_reset_check isn't implemented for driver type")); 7064 } 7065 7066 exit: 7067 SOC_FUNC_RETURN; 7068 7069 } 7070 7071 7072 int portmod_port_core_num_get(int unit, int port, int* core_num) 7073 { 7074 7075 portmod_dispatch_type_t __type__; 7076 int __rv__; 7077 SOC_INIT_FUNC_DEFS; 7078 7079 if(core_num == NULL) { 7080 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_num NULL parameter")); 7081 } 7082 /* Dispatch */ 7083 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7084 if(__type__ >= portmodDispatchTypeCount) { 7085 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7086 } 7087 7088 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_core_num_get) { 7089 pm_info_t pm_info; 7090 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7091 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_core_num_get(unit, port, pm_info, core_num); 7092 _SOC_IF_ERR_EXIT(__rv__); 7093 } else { 7094 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_core_num_get isn't implemented for driver type")); 7095 } 7096 7097 exit: 7098 SOC_FUNC_RETURN; 7099 7100 } 7101 7102 7103 int portmod_port_higig_e2ecc_hdr_t_validate(int unit, const portmod_port_higig_e2ecc_hdr_t* portmod_port_higig_e2ecc_hdr) 7104 { 7105 SOC_INIT_FUNC_DEFS; 7106 if(portmod_port_higig_e2ecc_hdr == NULL) { 7107 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 7108 } 7109 7110 7111 7112 exit: 7113 SOC_FUNC_RETURN; 7114 7115 } 7116 7117 int portmod_port_higig_e2ecc_hdr_t_init(int unit, portmod_port_higig_e2ecc_hdr_t* portmod_port_higig_e2ecc_hdr) 7118 { 7119 SOC_INIT_FUNC_DEFS; 7120 7121 if(portmod_port_higig_e2ecc_hdr == NULL){ 7122 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_higig_e2ecc_hdr NULL parameter")); 7123 } 7124 sal_memset(portmod_port_higig_e2ecc_hdr, 0, sizeof(portmod_port_higig_e2ecc_hdr_t)); 7125 7126 7127 exit: 7128 SOC_FUNC_RETURN; 7129 7130 } 7131 7132 int portmod_port_e2ecc_hdr_set(int unit, int port, const portmod_port_higig_e2ecc_hdr_t* e2ecc_hdr) 7133 { 7134 7135 portmod_dispatch_type_t __type__; 7136 int __rv__; 7137 SOC_INIT_FUNC_DEFS; 7138 7139 if(SOC_E_NONE != portmod_port_higig_e2ecc_hdr_t_validate(unit, e2ecc_hdr)) { 7140 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("e2ecc_hdr validation failed")); 7141 } 7142 7143 /* Dispatch */ 7144 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7145 if(__type__ >= portmodDispatchTypeCount) { 7146 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7147 } 7148 7149 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_e2ecc_hdr_set) { 7150 pm_info_t pm_info; 7151 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7152 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_e2ecc_hdr_set(unit, port, pm_info, e2ecc_hdr); 7153 _SOC_IF_ERR_EXIT(__rv__); 7154 } else { 7155 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_e2ecc_hdr_set isn't implemented for driver type")); 7156 } 7157 7158 exit: 7159 SOC_FUNC_RETURN; 7160 7161 } 7162 7163 7164 int portmod_port_e2ecc_hdr_get(int unit, int port, portmod_port_higig_e2ecc_hdr_t* e2ecc_hdr) 7165 { 7166 7167 portmod_dispatch_type_t __type__; 7168 int __rv__; 7169 SOC_INIT_FUNC_DEFS; 7170 7171 if(e2ecc_hdr == NULL) { 7172 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("e2ecc_hdr NULL parameter")); 7173 } 7174 if(SOC_E_NONE != portmod_port_higig_e2ecc_hdr_t_init(unit, e2ecc_hdr)) { 7175 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("e2ecc_hdr initialization failed")); 7176 } 7177 7178 /* Dispatch */ 7179 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7180 if(__type__ >= portmodDispatchTypeCount) { 7181 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7182 } 7183 7184 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_e2ecc_hdr_get) { 7185 pm_info_t pm_info; 7186 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7187 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_e2ecc_hdr_get(unit, port, pm_info, e2ecc_hdr); 7188 _SOC_IF_ERR_EXIT(__rv__); 7189 } else { 7190 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_e2ecc_hdr_get isn't implemented for driver type")); 7191 } 7192 7193 exit: 7194 SOC_FUNC_RETURN; 7195 7196 } 7197 7198 7199 int portmod_port_e2e_enable_set(int unit, int port, int enable) 7200 { 7201 7202 portmod_dispatch_type_t __type__; 7203 int __rv__; 7204 SOC_INIT_FUNC_DEFS; 7205 7206 /* Dispatch */ 7207 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7208 if(__type__ >= portmodDispatchTypeCount) { 7209 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7210 } 7211 7212 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_e2e_enable_set) { 7213 pm_info_t pm_info; 7214 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7215 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_e2e_enable_set(unit, port, pm_info, enable); 7216 _SOC_IF_ERR_EXIT(__rv__); 7217 } else { 7218 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_e2e_enable_set isn't implemented for driver type")); 7219 } 7220 7221 exit: 7222 SOC_FUNC_RETURN; 7223 7224 } 7225 7226 7227 int portmod_port_e2e_enable_get(int unit, int port, int* enable) 7228 { 7229 7230 portmod_dispatch_type_t __type__; 7231 int __rv__; 7232 SOC_INIT_FUNC_DEFS; 7233 7234 if(enable == NULL) { 7235 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 7236 } 7237 /* Dispatch */ 7238 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7239 if(__type__ >= portmodDispatchTypeCount) { 7240 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7241 } 7242 7243 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_e2e_enable_get) { 7244 pm_info_t pm_info; 7245 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7246 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_e2e_enable_get(unit, port, pm_info, enable); 7247 _SOC_IF_ERR_EXIT(__rv__); 7248 } else { 7249 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_e2e_enable_get isn't implemented for driver type")); 7250 } 7251 7252 exit: 7253 SOC_FUNC_RETURN; 7254 7255 } 7256 7257 7258 int portmod_port_fallback_lane_get(int unit, int port, int* fallback_lane) 7259 { 7260 7261 portmod_dispatch_type_t __type__; 7262 int __rv__; 7263 SOC_INIT_FUNC_DEFS; 7264 7265 if(fallback_lane == NULL) { 7266 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("fallback_lane NULL parameter")); 7267 } 7268 /* Dispatch */ 7269 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7270 if(__type__ >= portmodDispatchTypeCount) { 7271 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7272 } 7273 7274 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_fallback_lane_get) { 7275 pm_info_t pm_info; 7276 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7277 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_fallback_lane_get(unit, port, pm_info, fallback_lane); 7278 _SOC_IF_ERR_EXIT(__rv__); 7279 } else { 7280 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_fallback_lane_get isn't implemented for driver type")); 7281 } 7282 7283 exit: 7284 SOC_FUNC_RETURN; 7285 7286 } 7287 7288 7289 int portmod_port_speed_get(int unit, int port, int* speed) 7290 { 7291 7292 portmod_dispatch_type_t __type__; 7293 int __rv__; 7294 SOC_INIT_FUNC_DEFS; 7295 7296 if(speed == NULL) { 7297 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed NULL parameter")); 7298 } 7299 /* Dispatch */ 7300 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7301 if(__type__ >= portmodDispatchTypeCount) { 7302 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7303 } 7304 7305 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_speed_get) { 7306 pm_info_t pm_info; 7307 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7308 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_speed_get(unit, port, pm_info, speed); 7309 _SOC_IF_ERR_EXIT(__rv__); 7310 } else { 7311 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_speed_get isn't implemented for driver type")); 7312 } 7313 7314 exit: 7315 SOC_FUNC_RETURN; 7316 7317 } 7318 7319 7320 int portmod_port_tsc_refclock_set(int unit, int port, int ref_in, int ref_out) 7321 { 7322 7323 portmod_dispatch_type_t __type__; 7324 int __rv__; 7325 SOC_INIT_FUNC_DEFS; 7326 7327 /* Dispatch */ 7328 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7329 if(__type__ >= portmodDispatchTypeCount) { 7330 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7331 } 7332 7333 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tsc_refclock_set) { 7334 pm_info_t pm_info; 7335 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7336 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tsc_refclock_set(unit, port, pm_info, ref_in, ref_out); 7337 _SOC_IF_ERR_EXIT(__rv__); 7338 } else { 7339 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tsc_refclock_set isn't implemented for driver type")); 7340 } 7341 7342 exit: 7343 SOC_FUNC_RETURN; 7344 7345 } 7346 7347 7348 int portmod_port_tsc_refclock_get(int unit, int port, int* ref_in, int* ref_out) 7349 { 7350 7351 portmod_dispatch_type_t __type__; 7352 int __rv__; 7353 SOC_INIT_FUNC_DEFS; 7354 7355 if(ref_in == NULL) { 7356 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ref_in NULL parameter")); 7357 } 7358 if(ref_out == NULL) { 7359 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ref_out NULL parameter")); 7360 } 7361 /* Dispatch */ 7362 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7363 if(__type__ >= portmodDispatchTypeCount) { 7364 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7365 } 7366 7367 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tsc_refclock_get) { 7368 pm_info_t pm_info; 7369 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7370 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tsc_refclock_get(unit, port, pm_info, ref_in, ref_out); 7371 _SOC_IF_ERR_EXIT(__rv__); 7372 } else { 7373 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tsc_refclock_get isn't implemented for driver type")); 7374 } 7375 7376 exit: 7377 SOC_FUNC_RETURN; 7378 7379 } 7380 7381 7382 int portmod_port_discard_set(int unit, int port, int discard) 7383 { 7384 7385 portmod_dispatch_type_t __type__; 7386 int __rv__; 7387 SOC_INIT_FUNC_DEFS; 7388 7389 /* Dispatch */ 7390 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7391 if(__type__ >= portmodDispatchTypeCount) { 7392 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7393 } 7394 7395 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_discard_set) { 7396 pm_info_t pm_info; 7397 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7398 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_discard_set(unit, port, pm_info, discard); 7399 _SOC_IF_ERR_EXIT(__rv__); 7400 } else { 7401 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_discard_set isn't implemented for driver type")); 7402 } 7403 7404 exit: 7405 SOC_FUNC_RETURN; 7406 7407 } 7408 7409 7410 int portmod_port_soft_reset_set(int unit, int port, int idx, int val, int flags) 7411 { 7412 7413 portmod_dispatch_type_t __type__; 7414 int __rv__; 7415 SOC_INIT_FUNC_DEFS; 7416 7417 /* Dispatch */ 7418 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7419 if(__type__ >= portmodDispatchTypeCount) { 7420 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7421 } 7422 7423 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_soft_reset_set) { 7424 pm_info_t pm_info; 7425 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7426 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_soft_reset_set(unit, port, pm_info, idx, val, flags); 7427 _SOC_IF_ERR_EXIT(__rv__); 7428 } else { 7429 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_soft_reset_set isn't implemented for driver type")); 7430 } 7431 7432 exit: 7433 SOC_FUNC_RETURN; 7434 7435 } 7436 7437 7438 int portmod_port_tx_down(int unit, int port) 7439 { 7440 7441 portmod_dispatch_type_t __type__; 7442 int __rv__; 7443 SOC_INIT_FUNC_DEFS; 7444 7445 /* Dispatch */ 7446 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7447 if(__type__ >= portmodDispatchTypeCount) { 7448 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7449 } 7450 7451 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_down) { 7452 pm_info_t pm_info; 7453 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7454 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_down(unit, port, pm_info); 7455 _SOC_IF_ERR_EXIT(__rv__); 7456 } else { 7457 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_down isn't implemented for driver type")); 7458 } 7459 7460 exit: 7461 SOC_FUNC_RETURN; 7462 7463 } 7464 7465 7466 int portmod_port_logical_lane_order_set(int unit, int port, const int* lane_order, int lane_order_size) 7467 { 7468 7469 portmod_dispatch_type_t __type__; 7470 int __rv__; 7471 SOC_INIT_FUNC_DEFS; 7472 7473 /* Dispatch */ 7474 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7475 if(__type__ >= portmodDispatchTypeCount) { 7476 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7477 } 7478 7479 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_logical_lane_order_set) { 7480 pm_info_t pm_info; 7481 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7482 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_logical_lane_order_set(unit, port, pm_info, lane_order, lane_order_size); 7483 _SOC_IF_ERR_EXIT(__rv__); 7484 } else { 7485 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_logical_lane_order_set isn't implemented for driver type")); 7486 } 7487 7488 exit: 7489 SOC_FUNC_RETURN; 7490 7491 } 7492 7493 7494 int portmod_port_logical_lane_order_get(int unit, int port, int lane_order_max_size, int* lane_order, int* lane_order_actual_size) 7495 { 7496 7497 portmod_dispatch_type_t __type__; 7498 int __rv__; 7499 SOC_INIT_FUNC_DEFS; 7500 7501 if(lane_order == NULL) { 7502 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_order NULL parameter")); 7503 } 7504 if(lane_order_actual_size == NULL) { 7505 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_order_actual_size NULL parameter")); 7506 } 7507 /* Dispatch */ 7508 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7509 if(__type__ >= portmodDispatchTypeCount) { 7510 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7511 } 7512 7513 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_logical_lane_order_get) { 7514 pm_info_t pm_info; 7515 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7516 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_logical_lane_order_get(unit, port, pm_info, lane_order_max_size, lane_order, lane_order_actual_size); 7517 _SOC_IF_ERR_EXIT(__rv__); 7518 } else { 7519 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_logical_lane_order_get isn't implemented for driver type")); 7520 } 7521 7522 exit: 7523 SOC_FUNC_RETURN; 7524 7525 } 7526 7527 7528 int portmod_port_pgw_reconfig(int unit, int port, const portmod_port_mode_info_t* pmode, int phy_port, int flags) 7529 { 7530 7531 portmod_dispatch_type_t __type__; 7532 int __rv__; 7533 SOC_INIT_FUNC_DEFS; 7534 7535 if(SOC_E_NONE != portmod_port_mode_info_t_validate(unit, pmode)) { 7536 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pmode validation failed")); 7537 } 7538 7539 /* Dispatch */ 7540 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7541 if(__type__ >= portmodDispatchTypeCount) { 7542 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7543 } 7544 7545 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pgw_reconfig) { 7546 pm_info_t pm_info; 7547 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7548 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pgw_reconfig(unit, port, pm_info, pmode, phy_port, flags); 7549 _SOC_IF_ERR_EXIT(__rv__); 7550 } else { 7551 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pgw_reconfig isn't implemented for driver type")); 7552 } 7553 7554 exit: 7555 SOC_FUNC_RETURN; 7556 7557 } 7558 7559 7560 int portmod_port_notify(int unit, int port, int link) 7561 { 7562 7563 portmod_dispatch_type_t __type__; 7564 int __rv__; 7565 SOC_INIT_FUNC_DEFS; 7566 7567 /* Dispatch */ 7568 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7569 if(__type__ >= portmodDispatchTypeCount) { 7570 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7571 } 7572 7573 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_notify) { 7574 pm_info_t pm_info; 7575 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7576 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_notify(unit, port, pm_info, link); 7577 _SOC_IF_ERR_EXIT(__rv__); 7578 } else { 7579 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_notify isn't implemented for driver type")); 7580 } 7581 7582 exit: 7583 SOC_FUNC_RETURN; 7584 7585 } 7586 7587 7588 int portmod_port_control_phy_timesync_set(int unit, int port, portmod_port_control_phy_timesync_t config, uint64 value) 7589 { 7590 7591 portmod_dispatch_type_t __type__; 7592 int __rv__; 7593 SOC_INIT_FUNC_DEFS; 7594 7595 /* Dispatch */ 7596 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7597 if(__type__ >= portmodDispatchTypeCount) { 7598 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7599 } 7600 7601 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_control_phy_timesync_set) { 7602 pm_info_t pm_info; 7603 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7604 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_control_phy_timesync_set(unit, port, pm_info, config, value); 7605 _SOC_IF_ERR_EXIT(__rv__); 7606 } else { 7607 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_control_phy_timesync_set isn't implemented for driver type")); 7608 } 7609 7610 exit: 7611 SOC_FUNC_RETURN; 7612 7613 } 7614 7615 7616 int portmod_port_control_phy_timesync_get(int unit, int port, portmod_port_control_phy_timesync_t config, uint64* value) 7617 { 7618 7619 portmod_dispatch_type_t __type__; 7620 int __rv__; 7621 SOC_INIT_FUNC_DEFS; 7622 7623 if(value == NULL) { 7624 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 7625 } 7626 /* Dispatch */ 7627 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7628 if(__type__ >= portmodDispatchTypeCount) { 7629 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7630 } 7631 7632 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_control_phy_timesync_get) { 7633 pm_info_t pm_info; 7634 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7635 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_control_phy_timesync_get(unit, port, pm_info, config, value); 7636 _SOC_IF_ERR_EXIT(__rv__); 7637 } else { 7638 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_control_phy_timesync_get isn't implemented for driver type")); 7639 } 7640 7641 exit: 7642 SOC_FUNC_RETURN; 7643 7644 } 7645 7646 7647 int portmod_port_timesync_config_set(int unit, int port, const portmod_phy_timesync_config_t* config) 7648 { 7649 7650 portmod_dispatch_type_t __type__; 7651 int __rv__; 7652 SOC_INIT_FUNC_DEFS; 7653 7654 /* Dispatch */ 7655 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7656 if(__type__ >= portmodDispatchTypeCount) { 7657 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7658 } 7659 7660 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_config_set) { 7661 pm_info_t pm_info; 7662 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7663 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_config_set(unit, port, pm_info, config); 7664 _SOC_IF_ERR_EXIT(__rv__); 7665 } else { 7666 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_config_set isn't implemented for driver type")); 7667 } 7668 7669 exit: 7670 SOC_FUNC_RETURN; 7671 7672 } 7673 7674 7675 int portmod_port_timesync_config_get(int unit, int port, portmod_phy_timesync_config_t* config) 7676 { 7677 7678 portmod_dispatch_type_t __type__; 7679 int __rv__; 7680 SOC_INIT_FUNC_DEFS; 7681 7682 if(config == NULL) { 7683 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 7684 } 7685 /* Dispatch */ 7686 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7687 if(__type__ >= portmodDispatchTypeCount) { 7688 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7689 } 7690 7691 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_config_get) { 7692 pm_info_t pm_info; 7693 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7694 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_config_get(unit, port, pm_info, config); 7695 _SOC_IF_ERR_EXIT(__rv__); 7696 } else { 7697 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_config_get isn't implemented for driver type")); 7698 } 7699 7700 exit: 7701 SOC_FUNC_RETURN; 7702 7703 } 7704 7705 7706 int portmod_port_timesync_enable_set(int unit, int port, uint32 enable) 7707 { 7708 7709 portmod_dispatch_type_t __type__; 7710 int __rv__; 7711 SOC_INIT_FUNC_DEFS; 7712 7713 /* Dispatch */ 7714 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7715 if(__type__ >= portmodDispatchTypeCount) { 7716 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7717 } 7718 7719 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_enable_set) { 7720 pm_info_t pm_info; 7721 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7722 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_enable_set(unit, port, pm_info, enable); 7723 _SOC_IF_ERR_EXIT(__rv__); 7724 } else { 7725 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_enable_set isn't implemented for driver type")); 7726 } 7727 7728 exit: 7729 SOC_FUNC_RETURN; 7730 7731 } 7732 7733 7734 int portmod_port_timesync_enable_get(int unit, int port, uint32* enable) 7735 { 7736 7737 portmod_dispatch_type_t __type__; 7738 int __rv__; 7739 SOC_INIT_FUNC_DEFS; 7740 7741 if(enable == NULL) { 7742 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 7743 } 7744 /* Dispatch */ 7745 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7746 if(__type__ >= portmodDispatchTypeCount) { 7747 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7748 } 7749 7750 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_enable_get) { 7751 pm_info_t pm_info; 7752 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7753 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_enable_get(unit, port, pm_info, enable); 7754 _SOC_IF_ERR_EXIT(__rv__); 7755 } else { 7756 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_enable_get isn't implemented for driver type")); 7757 } 7758 7759 exit: 7760 SOC_FUNC_RETURN; 7761 7762 } 7763 7764 7765 int portmod_port_timesync_nco_addend_set(int unit, int port, uint32 freq_step) 7766 { 7767 7768 portmod_dispatch_type_t __type__; 7769 int __rv__; 7770 SOC_INIT_FUNC_DEFS; 7771 7772 /* Dispatch */ 7773 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7774 if(__type__ >= portmodDispatchTypeCount) { 7775 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7776 } 7777 7778 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_nco_addend_set) { 7779 pm_info_t pm_info; 7780 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7781 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_nco_addend_set(unit, port, pm_info, freq_step); 7782 _SOC_IF_ERR_EXIT(__rv__); 7783 } else { 7784 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_nco_addend_set isn't implemented for driver type")); 7785 } 7786 7787 exit: 7788 SOC_FUNC_RETURN; 7789 7790 } 7791 7792 7793 int portmod_port_timesync_nco_addend_get(int unit, int port, uint32* freq_step) 7794 { 7795 7796 portmod_dispatch_type_t __type__; 7797 int __rv__; 7798 SOC_INIT_FUNC_DEFS; 7799 7800 if(freq_step == NULL) { 7801 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("freq_step NULL parameter")); 7802 } 7803 /* Dispatch */ 7804 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7805 if(__type__ >= portmodDispatchTypeCount) { 7806 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7807 } 7808 7809 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_nco_addend_get) { 7810 pm_info_t pm_info; 7811 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7812 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_nco_addend_get(unit, port, pm_info, freq_step); 7813 _SOC_IF_ERR_EXIT(__rv__); 7814 } else { 7815 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_nco_addend_get isn't implemented for driver type")); 7816 } 7817 7818 exit: 7819 SOC_FUNC_RETURN; 7820 7821 } 7822 7823 7824 int portmod_port_timesync_framesync_mode_set(int unit, int port, const portmod_timesync_framesync_t* framesync) 7825 { 7826 7827 portmod_dispatch_type_t __type__; 7828 int __rv__; 7829 SOC_INIT_FUNC_DEFS; 7830 7831 /* Dispatch */ 7832 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7833 if(__type__ >= portmodDispatchTypeCount) { 7834 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7835 } 7836 7837 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_framesync_mode_set) { 7838 pm_info_t pm_info; 7839 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7840 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_framesync_mode_set(unit, port, pm_info, framesync); 7841 _SOC_IF_ERR_EXIT(__rv__); 7842 } else { 7843 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_framesync_mode_set isn't implemented for driver type")); 7844 } 7845 7846 exit: 7847 SOC_FUNC_RETURN; 7848 7849 } 7850 7851 7852 int portmod_port_timesync_framesync_mode_get(int unit, int port, portmod_timesync_framesync_t* framesync) 7853 { 7854 7855 portmod_dispatch_type_t __type__; 7856 int __rv__; 7857 SOC_INIT_FUNC_DEFS; 7858 7859 if(framesync == NULL) { 7860 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("framesync NULL parameter")); 7861 } 7862 /* Dispatch */ 7863 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7864 if(__type__ >= portmodDispatchTypeCount) { 7865 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7866 } 7867 7868 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_framesync_mode_get) { 7869 pm_info_t pm_info; 7870 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7871 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_framesync_mode_get(unit, port, pm_info, framesync); 7872 _SOC_IF_ERR_EXIT(__rv__); 7873 } else { 7874 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_framesync_mode_get isn't implemented for driver type")); 7875 } 7876 7877 exit: 7878 SOC_FUNC_RETURN; 7879 7880 } 7881 7882 7883 int portmod_port_timesync_local_time_set(int unit, int port, uint64 local_time) 7884 { 7885 7886 portmod_dispatch_type_t __type__; 7887 int __rv__; 7888 SOC_INIT_FUNC_DEFS; 7889 7890 /* Dispatch */ 7891 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7892 if(__type__ >= portmodDispatchTypeCount) { 7893 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7894 } 7895 7896 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_local_time_set) { 7897 pm_info_t pm_info; 7898 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7899 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_local_time_set(unit, port, pm_info, local_time); 7900 _SOC_IF_ERR_EXIT(__rv__); 7901 } else { 7902 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_local_time_set isn't implemented for driver type")); 7903 } 7904 7905 exit: 7906 SOC_FUNC_RETURN; 7907 7908 } 7909 7910 7911 int portmod_port_timesync_local_time_get(int unit, int port, uint64* local_time) 7912 { 7913 7914 portmod_dispatch_type_t __type__; 7915 int __rv__; 7916 SOC_INIT_FUNC_DEFS; 7917 7918 if(local_time == NULL) { 7919 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("local_time NULL parameter")); 7920 } 7921 /* Dispatch */ 7922 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7923 if(__type__ >= portmodDispatchTypeCount) { 7924 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7925 } 7926 7927 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_local_time_get) { 7928 pm_info_t pm_info; 7929 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7930 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_local_time_get(unit, port, pm_info, local_time); 7931 _SOC_IF_ERR_EXIT(__rv__); 7932 } else { 7933 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_local_time_get isn't implemented for driver type")); 7934 } 7935 7936 exit: 7937 SOC_FUNC_RETURN; 7938 7939 } 7940 7941 7942 int portmod_port_timesync_load_ctrl_set(int unit, int port, uint32 load_once, uint32 load_always) 7943 { 7944 7945 portmod_dispatch_type_t __type__; 7946 int __rv__; 7947 SOC_INIT_FUNC_DEFS; 7948 7949 /* Dispatch */ 7950 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7951 if(__type__ >= portmodDispatchTypeCount) { 7952 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7953 } 7954 7955 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_load_ctrl_set) { 7956 pm_info_t pm_info; 7957 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7958 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_load_ctrl_set(unit, port, pm_info, load_once, load_always); 7959 _SOC_IF_ERR_EXIT(__rv__); 7960 } else { 7961 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_load_ctrl_set isn't implemented for driver type")); 7962 } 7963 7964 exit: 7965 SOC_FUNC_RETURN; 7966 7967 } 7968 7969 7970 int portmod_port_timesync_load_ctrl_get(int unit, int port, uint32* load_once, uint32* load_always) 7971 { 7972 7973 portmod_dispatch_type_t __type__; 7974 int __rv__; 7975 SOC_INIT_FUNC_DEFS; 7976 7977 if(load_once == NULL) { 7978 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("load_once NULL parameter")); 7979 } 7980 if(load_always == NULL) { 7981 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("load_always NULL parameter")); 7982 } 7983 /* Dispatch */ 7984 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 7985 if(__type__ >= portmodDispatchTypeCount) { 7986 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 7987 } 7988 7989 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_load_ctrl_get) { 7990 pm_info_t pm_info; 7991 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 7992 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_load_ctrl_get(unit, port, pm_info, load_once, load_always); 7993 _SOC_IF_ERR_EXIT(__rv__); 7994 } else { 7995 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_load_ctrl_get isn't implemented for driver type")); 7996 } 7997 7998 exit: 7999 SOC_FUNC_RETURN; 8000 8001 } 8002 8003 8004 int portmod_port_timesync_tx_timestamp_offset_set(int unit, int port, uint32 ts_offset) 8005 { 8006 8007 portmod_dispatch_type_t __type__; 8008 int __rv__; 8009 SOC_INIT_FUNC_DEFS; 8010 8011 /* Dispatch */ 8012 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8013 if(__type__ >= portmodDispatchTypeCount) { 8014 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8015 } 8016 8017 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_tx_timestamp_offset_set) { 8018 pm_info_t pm_info; 8019 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8020 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_tx_timestamp_offset_set(unit, port, pm_info, ts_offset); 8021 _SOC_IF_ERR_EXIT(__rv__); 8022 } else { 8023 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_tx_timestamp_offset_set isn't implemented for driver type")); 8024 } 8025 8026 exit: 8027 SOC_FUNC_RETURN; 8028 8029 } 8030 8031 8032 int portmod_port_timesync_tx_timestamp_offset_get(int unit, int port, uint32* ts_offset) 8033 { 8034 8035 portmod_dispatch_type_t __type__; 8036 int __rv__; 8037 SOC_INIT_FUNC_DEFS; 8038 8039 if(ts_offset == NULL) { 8040 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ts_offset NULL parameter")); 8041 } 8042 /* Dispatch */ 8043 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8044 if(__type__ >= portmodDispatchTypeCount) { 8045 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8046 } 8047 8048 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_tx_timestamp_offset_get) { 8049 pm_info_t pm_info; 8050 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8051 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_tx_timestamp_offset_get(unit, port, pm_info, ts_offset); 8052 _SOC_IF_ERR_EXIT(__rv__); 8053 } else { 8054 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_tx_timestamp_offset_get isn't implemented for driver type")); 8055 } 8056 8057 exit: 8058 SOC_FUNC_RETURN; 8059 8060 } 8061 8062 8063 int portmod_port_timesync_rx_timestamp_offset_set(int unit, int port, uint32 ts_offset) 8064 { 8065 8066 portmod_dispatch_type_t __type__; 8067 int __rv__; 8068 SOC_INIT_FUNC_DEFS; 8069 8070 /* Dispatch */ 8071 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8072 if(__type__ >= portmodDispatchTypeCount) { 8073 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8074 } 8075 8076 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_rx_timestamp_offset_set) { 8077 pm_info_t pm_info; 8078 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8079 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_rx_timestamp_offset_set(unit, port, pm_info, ts_offset); 8080 _SOC_IF_ERR_EXIT(__rv__); 8081 } else { 8082 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_rx_timestamp_offset_set isn't implemented for driver type")); 8083 } 8084 8085 exit: 8086 SOC_FUNC_RETURN; 8087 8088 } 8089 8090 8091 int portmod_port_timesync_rx_timestamp_offset_get(int unit, int port, uint32* ts_offset) 8092 { 8093 8094 portmod_dispatch_type_t __type__; 8095 int __rv__; 8096 SOC_INIT_FUNC_DEFS; 8097 8098 if(ts_offset == NULL) { 8099 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ts_offset NULL parameter")); 8100 } 8101 /* Dispatch */ 8102 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8103 if(__type__ >= portmodDispatchTypeCount) { 8104 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8105 } 8106 8107 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_rx_timestamp_offset_get) { 8108 pm_info_t pm_info; 8109 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8110 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_rx_timestamp_offset_get(unit, port, pm_info, ts_offset); 8111 _SOC_IF_ERR_EXIT(__rv__); 8112 } else { 8113 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_rx_timestamp_offset_get isn't implemented for driver type")); 8114 } 8115 8116 exit: 8117 SOC_FUNC_RETURN; 8118 8119 } 8120 8121 8122 int portmod_port_timestamp_adjust_set(int unit, int port, const soc_port_timestamp_adjust_t* ts_adjust) 8123 { 8124 8125 portmod_dispatch_type_t __type__; 8126 int __rv__; 8127 SOC_INIT_FUNC_DEFS; 8128 8129 /* Dispatch */ 8130 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8131 if(__type__ >= portmodDispatchTypeCount) { 8132 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8133 } 8134 8135 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timestamp_adjust_set) { 8136 pm_info_t pm_info; 8137 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8138 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timestamp_adjust_set(unit, port, pm_info, ts_adjust); 8139 _SOC_IF_ERR_EXIT(__rv__); 8140 } else { 8141 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timestamp_adjust_set isn't implemented for driver type")); 8142 } 8143 8144 exit: 8145 SOC_FUNC_RETURN; 8146 8147 } 8148 8149 8150 int portmod_port_timestamp_adjust_get(int unit, int port, soc_port_timestamp_adjust_t* ts_adjust) 8151 { 8152 8153 portmod_dispatch_type_t __type__; 8154 int __rv__; 8155 SOC_INIT_FUNC_DEFS; 8156 8157 if(ts_adjust == NULL) { 8158 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ts_adjust NULL parameter")); 8159 } 8160 /* Dispatch */ 8161 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8162 if(__type__ >= portmodDispatchTypeCount) { 8163 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8164 } 8165 8166 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timestamp_adjust_get) { 8167 pm_info_t pm_info; 8168 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8169 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timestamp_adjust_get(unit, port, pm_info, ts_adjust); 8170 _SOC_IF_ERR_EXIT(__rv__); 8171 } else { 8172 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timestamp_adjust_get isn't implemented for driver type")); 8173 } 8174 8175 exit: 8176 SOC_FUNC_RETURN; 8177 8178 } 8179 8180 8181 int portmod_port_phy_intr_enable_set(int unit, int port, uint32 intr_enable) 8182 { 8183 8184 portmod_dispatch_type_t __type__; 8185 int __rv__; 8186 SOC_INIT_FUNC_DEFS; 8187 8188 /* Dispatch */ 8189 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8190 if(__type__ >= portmodDispatchTypeCount) { 8191 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8192 } 8193 8194 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_enable_set) { 8195 pm_info_t pm_info; 8196 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8197 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_enable_set(unit, port, pm_info, intr_enable); 8198 _SOC_IF_ERR_EXIT(__rv__); 8199 } else { 8200 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_intr_enable_set isn't implemented for driver type")); 8201 } 8202 8203 exit: 8204 SOC_FUNC_RETURN; 8205 8206 } 8207 8208 8209 int portmod_port_phy_intr_enable_get(int unit, int port, uint32* intr_enable) 8210 { 8211 8212 portmod_dispatch_type_t __type__; 8213 int __rv__; 8214 SOC_INIT_FUNC_DEFS; 8215 8216 if(intr_enable == NULL) { 8217 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("intr_enable NULL parameter")); 8218 } 8219 /* Dispatch */ 8220 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8221 if(__type__ >= portmodDispatchTypeCount) { 8222 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8223 } 8224 8225 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_enable_get) { 8226 pm_info_t pm_info; 8227 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8228 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_enable_get(unit, port, pm_info, intr_enable); 8229 _SOC_IF_ERR_EXIT(__rv__); 8230 } else { 8231 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_intr_enable_get isn't implemented for driver type")); 8232 } 8233 8234 exit: 8235 SOC_FUNC_RETURN; 8236 8237 } 8238 8239 8240 int portmod_port_phy_intr_status_get(int unit, int port, uint32* intr_status) 8241 { 8242 8243 portmod_dispatch_type_t __type__; 8244 int __rv__; 8245 SOC_INIT_FUNC_DEFS; 8246 8247 if(intr_status == NULL) { 8248 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("intr_status NULL parameter")); 8249 } 8250 /* Dispatch */ 8251 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8252 if(__type__ >= portmodDispatchTypeCount) { 8253 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8254 } 8255 8256 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_status_get) { 8257 pm_info_t pm_info; 8258 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8259 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_status_get(unit, port, pm_info, intr_status); 8260 _SOC_IF_ERR_EXIT(__rv__); 8261 } else { 8262 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_intr_status_get isn't implemented for driver type")); 8263 } 8264 8265 exit: 8266 SOC_FUNC_RETURN; 8267 8268 } 8269 8270 8271 int portmod_port_phy_intr_status_clear(int unit, int port) 8272 { 8273 8274 portmod_dispatch_type_t __type__; 8275 int __rv__; 8276 SOC_INIT_FUNC_DEFS; 8277 8278 /* Dispatch */ 8279 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8280 if(__type__ >= portmodDispatchTypeCount) { 8281 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8282 } 8283 8284 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_status_clear) { 8285 pm_info_t pm_info; 8286 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8287 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_intr_status_clear(unit, port, pm_info); 8288 _SOC_IF_ERR_EXIT(__rv__); 8289 } else { 8290 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_intr_status_clear isn't implemented for driver type")); 8291 } 8292 8293 exit: 8294 SOC_FUNC_RETURN; 8295 8296 } 8297 8298 8299 int portmod_port_phy_timesync_do_sync(int unit, int port) 8300 { 8301 8302 portmod_dispatch_type_t __type__; 8303 int __rv__; 8304 SOC_INIT_FUNC_DEFS; 8305 8306 /* Dispatch */ 8307 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8308 if(__type__ >= portmodDispatchTypeCount) { 8309 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8310 } 8311 8312 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_timesync_do_sync) { 8313 pm_info_t pm_info; 8314 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8315 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_timesync_do_sync(unit, port, pm_info); 8316 _SOC_IF_ERR_EXIT(__rv__); 8317 } else { 8318 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_timesync_do_sync isn't implemented for driver type")); 8319 } 8320 8321 exit: 8322 SOC_FUNC_RETURN; 8323 8324 } 8325 8326 8327 int portmod_port_timesync_capture_timestamp_get(int unit, int port, uint64* cap_ts) 8328 { 8329 8330 portmod_dispatch_type_t __type__; 8331 int __rv__; 8332 SOC_INIT_FUNC_DEFS; 8333 8334 if(cap_ts == NULL) { 8335 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cap_ts NULL parameter")); 8336 } 8337 /* Dispatch */ 8338 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8339 if(__type__ >= portmodDispatchTypeCount) { 8340 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8341 } 8342 8343 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_capture_timestamp_get) { 8344 pm_info_t pm_info; 8345 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8346 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_capture_timestamp_get(unit, port, pm_info, cap_ts); 8347 _SOC_IF_ERR_EXIT(__rv__); 8348 } else { 8349 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_capture_timestamp_get isn't implemented for driver type")); 8350 } 8351 8352 exit: 8353 SOC_FUNC_RETURN; 8354 8355 } 8356 8357 8358 int portmod_port_timesync_heartbeat_timestamp_get(int unit, int port, uint64* hb_ts) 8359 { 8360 8361 portmod_dispatch_type_t __type__; 8362 int __rv__; 8363 SOC_INIT_FUNC_DEFS; 8364 8365 if(hb_ts == NULL) { 8366 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("hb_ts NULL parameter")); 8367 } 8368 /* Dispatch */ 8369 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8370 if(__type__ >= portmodDispatchTypeCount) { 8371 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8372 } 8373 8374 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_heartbeat_timestamp_get) { 8375 pm_info_t pm_info; 8376 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8377 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_heartbeat_timestamp_get(unit, port, pm_info, hb_ts); 8378 _SOC_IF_ERR_EXIT(__rv__); 8379 } else { 8380 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_heartbeat_timestamp_get isn't implemented for driver type")); 8381 } 8382 8383 exit: 8384 SOC_FUNC_RETURN; 8385 8386 } 8387 8388 8389 int portmod_port_edc_config_set(int unit, int port, const portmod_edc_config_t* config) 8390 { 8391 8392 portmod_dispatch_type_t __type__; 8393 int __rv__; 8394 SOC_INIT_FUNC_DEFS; 8395 8396 /* Dispatch */ 8397 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8398 if(__type__ >= portmodDispatchTypeCount) { 8399 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8400 } 8401 8402 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_edc_config_set) { 8403 pm_info_t pm_info; 8404 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8405 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_edc_config_set(unit, port, pm_info, config); 8406 _SOC_IF_ERR_EXIT(__rv__); 8407 } else { 8408 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_edc_config_set isn't implemented for driver type")); 8409 } 8410 8411 exit: 8412 SOC_FUNC_RETURN; 8413 8414 } 8415 8416 8417 int portmod_port_edc_config_get(int unit, int port, portmod_edc_config_t* config) 8418 { 8419 8420 portmod_dispatch_type_t __type__; 8421 int __rv__; 8422 SOC_INIT_FUNC_DEFS; 8423 8424 if(config == NULL) { 8425 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 8426 } 8427 /* Dispatch */ 8428 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8429 if(__type__ >= portmodDispatchTypeCount) { 8430 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8431 } 8432 8433 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_edc_config_get) { 8434 pm_info_t pm_info; 8435 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8436 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_edc_config_get(unit, port, pm_info, config); 8437 _SOC_IF_ERR_EXIT(__rv__); 8438 } else { 8439 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_edc_config_get isn't implemented for driver type")); 8440 } 8441 8442 exit: 8443 SOC_FUNC_RETURN; 8444 8445 } 8446 8447 8448 int portmod_port_interrupt_enable_set(int unit, int port, int intr_type, uint32 val) 8449 { 8450 8451 portmod_dispatch_type_t __type__; 8452 int __rv__; 8453 SOC_INIT_FUNC_DEFS; 8454 8455 /* Dispatch */ 8456 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8457 if(__type__ >= portmodDispatchTypeCount) { 8458 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8459 } 8460 8461 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interrupt_enable_set) { 8462 pm_info_t pm_info; 8463 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8464 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interrupt_enable_set(unit, port, pm_info, intr_type, val); 8465 _SOC_IF_ERR_EXIT(__rv__); 8466 } else { 8467 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interrupt_enable_set isn't implemented for driver type")); 8468 } 8469 8470 exit: 8471 SOC_FUNC_RETURN; 8472 8473 } 8474 8475 8476 int portmod_port_interrupt_enable_get(int unit, int port, int intr_type, uint32* val) 8477 { 8478 8479 portmod_dispatch_type_t __type__; 8480 int __rv__; 8481 SOC_INIT_FUNC_DEFS; 8482 8483 if(val == NULL) { 8484 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("val NULL parameter")); 8485 } 8486 /* Dispatch */ 8487 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8488 if(__type__ >= portmodDispatchTypeCount) { 8489 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8490 } 8491 8492 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interrupt_enable_get) { 8493 pm_info_t pm_info; 8494 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8495 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interrupt_enable_get(unit, port, pm_info, intr_type, val); 8496 _SOC_IF_ERR_EXIT(__rv__); 8497 } else { 8498 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interrupt_enable_get isn't implemented for driver type")); 8499 } 8500 8501 exit: 8502 SOC_FUNC_RETURN; 8503 8504 } 8505 8506 8507 int portmod_port_interrupt_get(int unit, int port, int intr_type, uint32* val) 8508 { 8509 8510 portmod_dispatch_type_t __type__; 8511 int __rv__; 8512 SOC_INIT_FUNC_DEFS; 8513 8514 if(val == NULL) { 8515 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("val NULL parameter")); 8516 } 8517 /* Dispatch */ 8518 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8519 if(__type__ >= portmodDispatchTypeCount) { 8520 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8521 } 8522 8523 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interrupt_get) { 8524 pm_info_t pm_info; 8525 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8526 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interrupt_get(unit, port, pm_info, intr_type, val); 8527 _SOC_IF_ERR_EXIT(__rv__); 8528 } else { 8529 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interrupt_get isn't implemented for driver type")); 8530 } 8531 8532 exit: 8533 SOC_FUNC_RETURN; 8534 8535 } 8536 8537 8538 int portmod_port_interrupts_get(int unit, int port, int arr_max_size, uint32* intr_arr, uint32* size) 8539 { 8540 8541 portmod_dispatch_type_t __type__; 8542 int __rv__; 8543 SOC_INIT_FUNC_DEFS; 8544 8545 if(intr_arr == NULL) { 8546 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("intr_arr NULL parameter")); 8547 } 8548 if(size == NULL) { 8549 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("size NULL parameter")); 8550 } 8551 /* Dispatch */ 8552 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8553 if(__type__ >= portmodDispatchTypeCount) { 8554 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8555 } 8556 8557 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_interrupts_get) { 8558 pm_info_t pm_info; 8559 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8560 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_interrupts_get(unit, port, pm_info, arr_max_size, intr_arr, size); 8561 _SOC_IF_ERR_EXIT(__rv__); 8562 } else { 8563 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_interrupts_get isn't implemented for driver type")); 8564 } 8565 8566 exit: 8567 SOC_FUNC_RETURN; 8568 8569 } 8570 8571 8572 int portmod_stat_val_t_validate(int unit, portmod_stat_val_t portmod_stat_val) 8573 { 8574 SOC_INIT_FUNC_DEFS; 8575 if(portmod_stat_val >= portmodCount) { 8576 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 8577 } 8578 8579 exit: 8580 SOC_FUNC_RETURN; 8581 8582 } 8583 8584 int portmod_port_check_legacy_phy(int unit, int port, int* legacy_phy) 8585 { 8586 8587 portmod_dispatch_type_t __type__; 8588 int __rv__; 8589 SOC_INIT_FUNC_DEFS; 8590 8591 if(legacy_phy == NULL) { 8592 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("legacy_phy NULL parameter")); 8593 } 8594 /* Dispatch */ 8595 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8596 if(__type__ >= portmodDispatchTypeCount) { 8597 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8598 } 8599 8600 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_check_legacy_phy) { 8601 pm_info_t pm_info; 8602 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8603 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_check_legacy_phy(unit, port, pm_info, legacy_phy); 8604 _SOC_IF_ERR_EXIT(__rv__); 8605 } else { 8606 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_check_legacy_phy isn't implemented for driver type")); 8607 } 8608 8609 exit: 8610 SOC_FUNC_RETURN; 8611 8612 } 8613 8614 8615 int portmod_port_failover_mode_set(int unit, int port, phymod_failover_mode_t failover) 8616 { 8617 8618 portmod_dispatch_type_t __type__; 8619 int __rv__; 8620 SOC_INIT_FUNC_DEFS; 8621 8622 /* Dispatch */ 8623 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8624 if(__type__ >= portmodDispatchTypeCount) { 8625 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8626 } 8627 8628 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_failover_mode_set) { 8629 pm_info_t pm_info; 8630 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8631 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_failover_mode_set(unit, port, pm_info, failover); 8632 _SOC_IF_ERR_EXIT(__rv__); 8633 } else { 8634 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_failover_mode_set isn't implemented for driver type")); 8635 } 8636 8637 exit: 8638 SOC_FUNC_RETURN; 8639 8640 } 8641 8642 8643 int portmod_port_failover_mode_get(int unit, int port, phymod_failover_mode_t* failover) 8644 { 8645 8646 portmod_dispatch_type_t __type__; 8647 int __rv__; 8648 SOC_INIT_FUNC_DEFS; 8649 8650 if(failover == NULL) { 8651 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("failover NULL parameter")); 8652 } 8653 /* Dispatch */ 8654 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8655 if(__type__ >= portmodDispatchTypeCount) { 8656 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8657 } 8658 8659 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_failover_mode_get) { 8660 pm_info_t pm_info; 8661 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8662 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_failover_mode_get(unit, port, pm_info, failover); 8663 _SOC_IF_ERR_EXIT(__rv__); 8664 } else { 8665 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_failover_mode_get isn't implemented for driver type")); 8666 } 8667 8668 exit: 8669 SOC_FUNC_RETURN; 8670 8671 } 8672 8673 8674 int portmod_port_mac_rsv_mask_set(int unit, int port, uint32 rsv_mask) 8675 { 8676 8677 portmod_dispatch_type_t __type__; 8678 int __rv__; 8679 SOC_INIT_FUNC_DEFS; 8680 8681 /* Dispatch */ 8682 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8683 if(__type__ >= portmodDispatchTypeCount) { 8684 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8685 } 8686 8687 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_rsv_mask_set) { 8688 pm_info_t pm_info; 8689 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8690 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_rsv_mask_set(unit, port, pm_info, rsv_mask); 8691 _SOC_IF_ERR_EXIT(__rv__); 8692 } else { 8693 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_rsv_mask_set isn't implemented for driver type")); 8694 } 8695 8696 exit: 8697 SOC_FUNC_RETURN; 8698 8699 } 8700 8701 8702 int portmod_port_mib_reset_toggle(int unit, int port, int port_index) 8703 { 8704 8705 portmod_dispatch_type_t __type__; 8706 int __rv__; 8707 SOC_INIT_FUNC_DEFS; 8708 8709 /* Dispatch */ 8710 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8711 if(__type__ >= portmodDispatchTypeCount) { 8712 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8713 } 8714 8715 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mib_reset_toggle) { 8716 pm_info_t pm_info; 8717 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8718 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mib_reset_toggle(unit, port, pm_info, port_index); 8719 _SOC_IF_ERR_EXIT(__rv__); 8720 } else { 8721 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mib_reset_toggle isn't implemented for driver type")); 8722 } 8723 8724 exit: 8725 SOC_FUNC_RETURN; 8726 8727 } 8728 8729 8730 int portmod_port_warmboot_db_restore(int unit, int port, const portmod_port_interface_config_t* intf_config, const portmod_port_init_config_t* init_config, phymod_operation_mode_t phy_op_mode) 8731 { 8732 8733 portmod_dispatch_type_t __type__; 8734 int __rv__; 8735 SOC_INIT_FUNC_DEFS; 8736 8737 if(SOC_E_NONE != portmod_port_interface_config_t_validate(unit, intf_config)) { 8738 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("intf_config validation failed")); 8739 } 8740 8741 if(SOC_E_NONE != portmod_port_init_config_t_validate(unit, init_config)) { 8742 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("init_config validation failed")); 8743 } 8744 8745 /* Dispatch */ 8746 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8747 if(__type__ >= portmodDispatchTypeCount) { 8748 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8749 } 8750 8751 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_warmboot_db_restore) { 8752 pm_info_t pm_info; 8753 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8754 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_warmboot_db_restore(unit, port, pm_info, intf_config, init_config, phy_op_mode); 8755 _SOC_IF_ERR_EXIT(__rv__); 8756 } else { 8757 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_warmboot_db_restore isn't implemented for driver type")); 8758 } 8759 8760 exit: 8761 SOC_FUNC_RETURN; 8762 8763 } 8764 8765 8766 int portmod_port_flow_control_set(int unit, int port, int merge_mode_en, int parallel_fc_en) 8767 { 8768 8769 portmod_dispatch_type_t __type__; 8770 int __rv__; 8771 SOC_INIT_FUNC_DEFS; 8772 8773 /* Dispatch */ 8774 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8775 if(__type__ >= portmodDispatchTypeCount) { 8776 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8777 } 8778 8779 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_flow_control_set) { 8780 pm_info_t pm_info; 8781 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8782 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_flow_control_set(unit, port, pm_info, merge_mode_en, parallel_fc_en); 8783 _SOC_IF_ERR_EXIT(__rv__); 8784 } else { 8785 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_flow_control_set isn't implemented for driver type")); 8786 } 8787 8788 exit: 8789 SOC_FUNC_RETURN; 8790 8791 } 8792 8793 8794 int portmod_port_update_dynamic_state(int unit, int port, uint32_t port_dynamic_state) 8795 { 8796 8797 portmod_dispatch_type_t __type__; 8798 int __rv__; 8799 SOC_INIT_FUNC_DEFS; 8800 8801 /* Dispatch */ 8802 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8803 if(__type__ >= portmodDispatchTypeCount) { 8804 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8805 } 8806 8807 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_update_dynamic_state) { 8808 pm_info_t pm_info; 8809 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8810 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_update_dynamic_state(unit, port, pm_info, port_dynamic_state); 8811 _SOC_IF_ERR_EXIT(__rv__); 8812 } else { 8813 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_update_dynamic_state isn't implemented for driver type")); 8814 } 8815 8816 exit: 8817 SOC_FUNC_RETURN; 8818 8819 } 8820 8821 8822 int portmod_port_phy_op_mode_get(int unit, int port, phymod_operation_mode_t* val) 8823 { 8824 8825 portmod_dispatch_type_t __type__; 8826 int __rv__; 8827 SOC_INIT_FUNC_DEFS; 8828 8829 if(val == NULL) { 8830 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("val NULL parameter")); 8831 } 8832 /* Dispatch */ 8833 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8834 if(__type__ >= portmodDispatchTypeCount) { 8835 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8836 } 8837 8838 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_phy_op_mode_get) { 8839 pm_info_t pm_info; 8840 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8841 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_phy_op_mode_get(unit, port, pm_info, val); 8842 _SOC_IF_ERR_EXIT(__rv__); 8843 } else { 8844 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_phy_op_mode_get isn't implemented for driver type")); 8845 } 8846 8847 exit: 8848 SOC_FUNC_RETURN; 8849 8850 } 8851 8852 8853 int portmod_port_lane_map_set(int unit, int port, uint32 flags, const phymod_lane_map_t* lane_map) 8854 { 8855 8856 portmod_dispatch_type_t __type__; 8857 int __rv__; 8858 SOC_INIT_FUNC_DEFS; 8859 8860 /* Dispatch */ 8861 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8862 if(__type__ >= portmodDispatchTypeCount) { 8863 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8864 } 8865 8866 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lane_map_set) { 8867 pm_info_t pm_info; 8868 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8869 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lane_map_set(unit, port, pm_info, flags, lane_map); 8870 _SOC_IF_ERR_EXIT(__rv__); 8871 } else { 8872 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lane_map_set isn't implemented for driver type")); 8873 } 8874 8875 exit: 8876 SOC_FUNC_RETURN; 8877 8878 } 8879 8880 8881 int portmod_port_lane_map_get(int unit, int port, uint32 flags, phymod_lane_map_t* lane_map) 8882 { 8883 8884 portmod_dispatch_type_t __type__; 8885 int __rv__; 8886 SOC_INIT_FUNC_DEFS; 8887 8888 if(lane_map == NULL) { 8889 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_map NULL parameter")); 8890 } 8891 /* Dispatch */ 8892 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8893 if(__type__ >= portmodDispatchTypeCount) { 8894 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8895 } 8896 8897 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lane_map_get) { 8898 pm_info_t pm_info; 8899 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8900 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lane_map_get(unit, port, pm_info, flags, lane_map); 8901 _SOC_IF_ERR_EXIT(__rv__); 8902 } else { 8903 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lane_map_get isn't implemented for driver type")); 8904 } 8905 8906 exit: 8907 SOC_FUNC_RETURN; 8908 8909 } 8910 8911 8912 int portmod_port_polarity_set(int unit, int port, const phymod_polarity_t* polarity) 8913 { 8914 8915 portmod_dispatch_type_t __type__; 8916 int __rv__; 8917 SOC_INIT_FUNC_DEFS; 8918 8919 /* Dispatch */ 8920 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8921 if(__type__ >= portmodDispatchTypeCount) { 8922 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8923 } 8924 8925 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_polarity_set) { 8926 pm_info_t pm_info; 8927 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8928 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_polarity_set(unit, port, pm_info, polarity); 8929 _SOC_IF_ERR_EXIT(__rv__); 8930 } else { 8931 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_polarity_set isn't implemented for driver type")); 8932 } 8933 8934 exit: 8935 SOC_FUNC_RETURN; 8936 8937 } 8938 8939 8940 int portmod_port_polarity_get(int unit, int port, phymod_polarity_t* polarity) 8941 { 8942 8943 portmod_dispatch_type_t __type__; 8944 int __rv__; 8945 SOC_INIT_FUNC_DEFS; 8946 8947 if(polarity == NULL) { 8948 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("polarity NULL parameter")); 8949 } 8950 /* Dispatch */ 8951 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8952 if(__type__ >= portmodDispatchTypeCount) { 8953 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8954 } 8955 8956 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_polarity_get) { 8957 pm_info_t pm_info; 8958 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8959 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_polarity_get(unit, port, pm_info, polarity); 8960 _SOC_IF_ERR_EXIT(__rv__); 8961 } else { 8962 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_polarity_get isn't implemented for driver type")); 8963 } 8964 8965 exit: 8966 SOC_FUNC_RETURN; 8967 8968 } 8969 8970 8971 int portmod_port_medium_config_set(int unit, int port, soc_port_medium_t medium, soc_phy_config_t* config) 8972 { 8973 8974 portmod_dispatch_type_t __type__; 8975 int __rv__; 8976 SOC_INIT_FUNC_DEFS; 8977 8978 if(config == NULL) { 8979 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 8980 } 8981 /* Dispatch */ 8982 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 8983 if(__type__ >= portmodDispatchTypeCount) { 8984 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 8985 } 8986 8987 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_medium_config_set) { 8988 pm_info_t pm_info; 8989 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 8990 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_medium_config_set(unit, port, pm_info, medium, config); 8991 _SOC_IF_ERR_EXIT(__rv__); 8992 } else { 8993 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_medium_config_set isn't implemented for driver type")); 8994 } 8995 8996 exit: 8997 SOC_FUNC_RETURN; 8998 8999 } 9000 9001 9002 int portmod_port_medium_config_get(int unit, int port, soc_port_medium_t medium, soc_phy_config_t* config) 9003 { 9004 9005 portmod_dispatch_type_t __type__; 9006 int __rv__; 9007 SOC_INIT_FUNC_DEFS; 9008 9009 if(config == NULL) { 9010 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 9011 } 9012 /* Dispatch */ 9013 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9014 if(__type__ >= portmodDispatchTypeCount) { 9015 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9016 } 9017 9018 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_medium_config_get) { 9019 pm_info_t pm_info; 9020 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9021 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_medium_config_get(unit, port, pm_info, medium, config); 9022 _SOC_IF_ERR_EXIT(__rv__); 9023 } else { 9024 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_medium_config_get isn't implemented for driver type")); 9025 } 9026 9027 exit: 9028 SOC_FUNC_RETURN; 9029 9030 } 9031 9032 9033 int portmod_port_medium_get(int unit, int port, soc_port_medium_t* medium) 9034 { 9035 9036 portmod_dispatch_type_t __type__; 9037 int __rv__; 9038 SOC_INIT_FUNC_DEFS; 9039 9040 if(medium == NULL) { 9041 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("medium NULL parameter")); 9042 } 9043 /* Dispatch */ 9044 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9045 if(__type__ >= portmodDispatchTypeCount) { 9046 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9047 } 9048 9049 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_medium_get) { 9050 pm_info_t pm_info; 9051 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9052 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_medium_get(unit, port, pm_info, medium); 9053 _SOC_IF_ERR_EXIT(__rv__); 9054 } else { 9055 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_medium_get isn't implemented for driver type")); 9056 } 9057 9058 exit: 9059 SOC_FUNC_RETURN; 9060 9061 } 9062 9063 9064 int portmod_pm_is_in_pm12x10(int unit, pm_info_t pm_info, int* in_pm12x10) 9065 { 9066 9067 portmod_dispatch_type_t __type__; 9068 int __rv__; 9069 SOC_INIT_FUNC_DEFS; 9070 9071 if(in_pm12x10 == NULL) { 9072 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("in_pm12x10 NULL parameter")); 9073 } 9074 /* Dispatch */ 9075 __type__ = (pm_info)->type; 9076 if(__type__ >= portmodDispatchTypeCount) { 9077 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9078 } 9079 9080 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_is_in_pm12x10) { 9081 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_is_in_pm12x10(unit, pm_info, in_pm12x10); 9082 _SOC_IF_ERR_EXIT(__rv__); 9083 } else { 9084 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_is_in_pm12x10 isn't implemented for driver type")); 9085 } 9086 9087 exit: 9088 SOC_FUNC_RETURN; 9089 9090 } 9091 9092 9093 int portmod_slow_read_rate_set(int unit, int port, int slow_read_rate) 9094 { 9095 9096 portmod_dispatch_type_t __type__; 9097 int __rv__; 9098 SOC_INIT_FUNC_DEFS; 9099 9100 /* Dispatch */ 9101 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9102 if(__type__ >= portmodDispatchTypeCount) { 9103 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9104 } 9105 9106 if(NULL != __portmod__dispatch__[__type__]->f_portmod_slow_read_rate_set) { 9107 pm_info_t pm_info; 9108 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9109 __rv__ = __portmod__dispatch__[__type__]->f_portmod_slow_read_rate_set(unit, port, pm_info, slow_read_rate); 9110 _SOC_IF_ERR_EXIT(__rv__); 9111 } else { 9112 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_slow_read_rate_set isn't implemented for driver type")); 9113 } 9114 9115 exit: 9116 SOC_FUNC_RETURN; 9117 9118 } 9119 9120 9121 int portmod_port_resources_t_validate(int unit, const portmod_port_resources_t* portmod_port_resources) 9122 { 9123 SOC_INIT_FUNC_DEFS; 9124 if(portmod_port_resources == NULL) { 9125 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 9126 } 9127 9128 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, portmod_port_resources->pm_type)) { 9129 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm_type validation failed")); 9130 } 9131 9132 9133 9134 exit: 9135 SOC_FUNC_RETURN; 9136 9137 } 9138 9139 int portmod_port_resources_t_init(int unit, portmod_port_resources_t* portmod_port_resources) 9140 { 9141 SOC_INIT_FUNC_DEFS; 9142 9143 if(portmod_port_resources == NULL){ 9144 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_resources NULL parameter")); 9145 } 9146 sal_memset(portmod_port_resources, 0, sizeof(portmod_port_resources_t)); 9147 portmod_port_resources->speed = 0; 9148 portmod_port_resources->num_lane = 0; 9149 portmod_port_resources->encap_mode = 0; 9150 portmod_port_resources->flag = 0; 9151 9152 9153 exit: 9154 SOC_FUNC_RETURN; 9155 9156 } 9157 9158 int portmod_port_pll_div_get(int unit, int port, const portmod_port_resources_t* port_resource, uint32_t* pll_div) 9159 { 9160 9161 portmod_dispatch_type_t __type__; 9162 int __rv__; 9163 SOC_INIT_FUNC_DEFS; 9164 9165 if(SOC_E_NONE != portmod_port_resources_t_validate(unit, port_resource)) { 9166 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("port_resource validation failed")); 9167 } 9168 9169 if(pll_div == NULL) { 9170 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pll_div NULL parameter")); 9171 } 9172 /* Dispatch */ 9173 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9174 if(__type__ >= portmodDispatchTypeCount) { 9175 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9176 } 9177 9178 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_pll_div_get) { 9179 pm_info_t pm_info; 9180 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9181 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_pll_div_get(unit, port, pm_info, port_resource, pll_div); 9182 _SOC_IF_ERR_EXIT(__rv__); 9183 } else { 9184 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_pll_div_get isn't implemented for driver type")); 9185 } 9186 9187 exit: 9188 SOC_FUNC_RETURN; 9189 9190 } 9191 9192 9193 int portmod_port_master_set(int unit, int port, int master_mode) 9194 { 9195 9196 portmod_dispatch_type_t __type__; 9197 int __rv__; 9198 SOC_INIT_FUNC_DEFS; 9199 9200 /* Dispatch */ 9201 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9202 if(__type__ >= portmodDispatchTypeCount) { 9203 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9204 } 9205 9206 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_master_set) { 9207 pm_info_t pm_info; 9208 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9209 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_master_set(unit, port, pm_info, master_mode); 9210 _SOC_IF_ERR_EXIT(__rv__); 9211 } else { 9212 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_master_set isn't implemented for driver type")); 9213 } 9214 9215 exit: 9216 SOC_FUNC_RETURN; 9217 9218 } 9219 9220 9221 int portmod_port_master_get(int unit, int port, int* master_mode) 9222 { 9223 9224 portmod_dispatch_type_t __type__; 9225 int __rv__; 9226 SOC_INIT_FUNC_DEFS; 9227 9228 if(master_mode == NULL) { 9229 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("master_mode NULL parameter")); 9230 } 9231 /* Dispatch */ 9232 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9233 if(__type__ >= portmodDispatchTypeCount) { 9234 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9235 } 9236 9237 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_master_get) { 9238 pm_info_t pm_info; 9239 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9240 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_master_get(unit, port, pm_info, master_mode); 9241 _SOC_IF_ERR_EXIT(__rv__); 9242 } else { 9243 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_master_get isn't implemented for driver type")); 9244 } 9245 9246 exit: 9247 SOC_FUNC_RETURN; 9248 9249 } 9250 9251 9252 int portmod_preemption_control_t_validate(int unit, portmod_preemption_control_t portmod_preemption_control) 9253 { 9254 SOC_INIT_FUNC_DEFS; 9255 if(portmod_preemption_control >= portmodPreemptionControlCount) { 9256 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 9257 } 9258 9259 exit: 9260 SOC_FUNC_RETURN; 9261 9262 } 9263 9264 int portmod_preemption_control_set(int unit, int port, portmod_preemption_control_t type, uint32 value) 9265 { 9266 9267 portmod_dispatch_type_t __type__; 9268 int __rv__; 9269 SOC_INIT_FUNC_DEFS; 9270 9271 if(SOC_E_NONE != portmod_preemption_control_t_validate(unit, type)) { 9272 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 9273 } 9274 9275 /* Dispatch */ 9276 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9277 if(__type__ >= portmodDispatchTypeCount) { 9278 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9279 } 9280 9281 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_control_set) { 9282 pm_info_t pm_info; 9283 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9284 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_control_set(unit, port, pm_info, type, value); 9285 _SOC_IF_ERR_EXIT(__rv__); 9286 } else { 9287 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_control_set isn't implemented for driver type")); 9288 } 9289 9290 exit: 9291 SOC_FUNC_RETURN; 9292 9293 } 9294 9295 9296 int portmod_preemption_control_get(int unit, int port, portmod_preemption_control_t type, uint32* value) 9297 { 9298 9299 portmod_dispatch_type_t __type__; 9300 int __rv__; 9301 SOC_INIT_FUNC_DEFS; 9302 9303 if(SOC_E_NONE != portmod_preemption_control_t_validate(unit, type)) { 9304 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 9305 } 9306 9307 if(value == NULL) { 9308 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 9309 } 9310 /* Dispatch */ 9311 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9312 if(__type__ >= portmodDispatchTypeCount) { 9313 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9314 } 9315 9316 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_control_get) { 9317 pm_info_t pm_info; 9318 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9319 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_control_get(unit, port, pm_info, type, value); 9320 _SOC_IF_ERR_EXIT(__rv__); 9321 } else { 9322 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_control_get isn't implemented for driver type")); 9323 } 9324 9325 exit: 9326 SOC_FUNC_RETURN; 9327 9328 } 9329 9330 9331 int portmod_preemption_tx_status_t_validate(int unit, portmod_preemption_tx_status_t portmod_preemption_tx_status) 9332 { 9333 SOC_INIT_FUNC_DEFS; 9334 if(portmod_preemption_tx_status >= portmodPreemptionTxStatusCount) { 9335 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 9336 } 9337 9338 exit: 9339 SOC_FUNC_RETURN; 9340 9341 } 9342 9343 int portmod_preemption_tx_status_get(int unit, int port, uint32* value) 9344 { 9345 9346 portmod_dispatch_type_t __type__; 9347 int __rv__; 9348 SOC_INIT_FUNC_DEFS; 9349 9350 if(value == NULL) { 9351 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 9352 } 9353 /* Dispatch */ 9354 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9355 if(__type__ >= portmodDispatchTypeCount) { 9356 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9357 } 9358 9359 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_tx_status_get) { 9360 pm_info_t pm_info; 9361 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9362 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_tx_status_get(unit, port, pm_info, value); 9363 _SOC_IF_ERR_EXIT(__rv__); 9364 } else { 9365 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_tx_status_get isn't implemented for driver type")); 9366 } 9367 9368 exit: 9369 SOC_FUNC_RETURN; 9370 9371 } 9372 9373 9374 int portmod_preemption_verify_status_type_t_validate(int unit, portmod_preemption_verify_status_type_t portmod_preemption_verify_status_type) 9375 { 9376 SOC_INIT_FUNC_DEFS; 9377 if(portmod_preemption_verify_status_type >= portmodPreemptionVerifyCount) { 9378 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 9379 } 9380 9381 exit: 9382 SOC_FUNC_RETURN; 9383 9384 } 9385 9386 int portmod_preemption_verify_status_t_validate(int unit, portmod_preemption_verify_status_t portmod_preemption_verify_status) 9387 { 9388 SOC_INIT_FUNC_DEFS; 9389 if(portmod_preemption_verify_status >= portmodPreemptionVerifyStatusCount) { 9390 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 9391 } 9392 9393 exit: 9394 SOC_FUNC_RETURN; 9395 9396 } 9397 9398 int portmod_preemption_verify_status_get(int unit, int port, portmod_preemption_verify_status_type_t type, uint32* value) 9399 { 9400 9401 portmod_dispatch_type_t __type__; 9402 int __rv__; 9403 SOC_INIT_FUNC_DEFS; 9404 9405 if(SOC_E_NONE != portmod_preemption_verify_status_type_t_validate(unit, type)) { 9406 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 9407 } 9408 9409 if(value == NULL) { 9410 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 9411 } 9412 /* Dispatch */ 9413 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9414 if(__type__ >= portmodDispatchTypeCount) { 9415 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9416 } 9417 9418 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_verify_status_get) { 9419 pm_info_t pm_info; 9420 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9421 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_verify_status_get(unit, port, pm_info, type, value); 9422 _SOC_IF_ERR_EXIT(__rv__); 9423 } else { 9424 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_verify_status_get isn't implemented for driver type")); 9425 } 9426 9427 exit: 9428 SOC_FUNC_RETURN; 9429 9430 } 9431 9432 9433 int portmod_preemption_force_rx_eop_mode_t_validate(int unit, portmod_preemption_force_rx_eop_mode_t portmod_preemption_force_rx_eop_mode) 9434 { 9435 SOC_INIT_FUNC_DEFS; 9436 if(portmod_preemption_force_rx_eop_mode >= portmodPreemptionForceCount) { 9437 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 9438 } 9439 9440 exit: 9441 SOC_FUNC_RETURN; 9442 9443 } 9444 9445 int portmod_preemption_force_rx_eop_mode_set(int unit, int port, portmod_preemption_force_rx_eop_mode_t type, uint32 value) 9446 { 9447 9448 portmod_dispatch_type_t __type__; 9449 int __rv__; 9450 SOC_INIT_FUNC_DEFS; 9451 9452 if(SOC_E_NONE != portmod_preemption_force_rx_eop_mode_t_validate(unit, type)) { 9453 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 9454 } 9455 9456 /* Dispatch */ 9457 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9458 if(__type__ >= portmodDispatchTypeCount) { 9459 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9460 } 9461 9462 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_force_rx_eop_mode_set) { 9463 pm_info_t pm_info; 9464 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9465 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_force_rx_eop_mode_set(unit, port, pm_info, type, value); 9466 _SOC_IF_ERR_EXIT(__rv__); 9467 } else { 9468 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_force_rx_eop_mode_set isn't implemented for driver type")); 9469 } 9470 9471 exit: 9472 SOC_FUNC_RETURN; 9473 9474 } 9475 9476 9477 int portmod_preemption_force_rx_eop_mode_get(int unit, int port, portmod_preemption_force_rx_eop_mode_t type, uint32* value) 9478 { 9479 9480 portmod_dispatch_type_t __type__; 9481 int __rv__; 9482 SOC_INIT_FUNC_DEFS; 9483 9484 if(SOC_E_NONE != portmod_preemption_force_rx_eop_mode_t_validate(unit, type)) { 9485 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 9486 } 9487 9488 if(value == NULL) { 9489 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 9490 } 9491 /* Dispatch */ 9492 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9493 if(__type__ >= portmodDispatchTypeCount) { 9494 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9495 } 9496 9497 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_force_rx_eop_mode_get) { 9498 pm_info_t pm_info; 9499 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9500 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_force_rx_eop_mode_get(unit, port, pm_info, type, value); 9501 _SOC_IF_ERR_EXIT(__rv__); 9502 } else { 9503 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_force_rx_eop_mode_get isn't implemented for driver type")); 9504 } 9505 9506 exit: 9507 SOC_FUNC_RETURN; 9508 9509 } 9510 9511 9512 int portmod_preemption_rx_timeout_set(int unit, int port, uint32 enable, uint32 timeout_cnt) 9513 { 9514 9515 portmod_dispatch_type_t __type__; 9516 int __rv__; 9517 SOC_INIT_FUNC_DEFS; 9518 9519 /* Dispatch */ 9520 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9521 if(__type__ >= portmodDispatchTypeCount) { 9522 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9523 } 9524 9525 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_rx_timeout_set) { 9526 pm_info_t pm_info; 9527 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9528 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_rx_timeout_set(unit, port, pm_info, enable, timeout_cnt); 9529 _SOC_IF_ERR_EXIT(__rv__); 9530 } else { 9531 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_rx_timeout_set isn't implemented for driver type")); 9532 } 9533 9534 exit: 9535 SOC_FUNC_RETURN; 9536 9537 } 9538 9539 9540 int portmod_preemption_rx_timeout_get(int unit, int port, uint32* enable, uint32* timeout_cnt) 9541 { 9542 9543 portmod_dispatch_type_t __type__; 9544 int __rv__; 9545 SOC_INIT_FUNC_DEFS; 9546 9547 if(enable == NULL) { 9548 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 9549 } 9550 if(timeout_cnt == NULL) { 9551 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("timeout_cnt NULL parameter")); 9552 } 9553 /* Dispatch */ 9554 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9555 if(__type__ >= portmodDispatchTypeCount) { 9556 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9557 } 9558 9559 if(NULL != __portmod__dispatch__[__type__]->f_portmod_preemption_rx_timeout_get) { 9560 pm_info_t pm_info; 9561 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9562 __rv__ = __portmod__dispatch__[__type__]->f_portmod_preemption_rx_timeout_get(unit, port, pm_info, enable, timeout_cnt); 9563 _SOC_IF_ERR_EXIT(__rv__); 9564 } else { 9565 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_preemption_rx_timeout_get isn't implemented for driver type")); 9566 } 9567 9568 exit: 9569 SOC_FUNC_RETURN; 9570 9571 } 9572 9573 9574 int portmod_port_lane_count_get(int unit, int port, int line_side, int* num_lanes) 9575 { 9576 9577 portmod_dispatch_type_t __type__; 9578 int __rv__; 9579 SOC_INIT_FUNC_DEFS; 9580 9581 if(num_lanes == NULL) { 9582 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("num_lanes NULL parameter")); 9583 } 9584 /* Dispatch */ 9585 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9586 if(__type__ >= portmodDispatchTypeCount) { 9587 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9588 } 9589 9590 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lane_count_get) { 9591 pm_info_t pm_info; 9592 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9593 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lane_count_get(unit, port, pm_info, line_side, num_lanes); 9594 _SOC_IF_ERR_EXIT(__rv__); 9595 } else { 9596 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lane_count_get isn't implemented for driver type")); 9597 } 9598 9599 exit: 9600 SOC_FUNC_RETURN; 9601 9602 } 9603 9604 9605 int portmod_port_timesync_tx_info_get(int unit, int port, portmod_fifo_status_t* tx_info) 9606 { 9607 9608 portmod_dispatch_type_t __type__; 9609 int __rv__; 9610 SOC_INIT_FUNC_DEFS; 9611 9612 if(tx_info == NULL) { 9613 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("tx_info NULL parameter")); 9614 } 9615 if(SOC_E_NONE != portmod_fifo_status_t_init(unit, tx_info)) { 9616 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("tx_info initialization failed")); 9617 } 9618 9619 /* Dispatch */ 9620 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9621 if(__type__ >= portmodDispatchTypeCount) { 9622 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9623 } 9624 9625 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_timesync_tx_info_get) { 9626 pm_info_t pm_info; 9627 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9628 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_timesync_tx_info_get(unit, port, pm_info, tx_info); 9629 _SOC_IF_ERR_EXIT(__rv__); 9630 } else { 9631 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_timesync_tx_info_get isn't implemented for driver type")); 9632 } 9633 9634 exit: 9635 SOC_FUNC_RETURN; 9636 9637 } 9638 9639 9640 int portmod_port_lane_mask_get(int unit, int port, const portmod_access_get_params_t* params, int* lane_mask, int* xphy_id) 9641 { 9642 9643 portmod_dispatch_type_t __type__; 9644 int __rv__; 9645 SOC_INIT_FUNC_DEFS; 9646 9647 if(SOC_E_NONE != portmod_access_get_params_t_validate(unit, params)) { 9648 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("params validation failed")); 9649 } 9650 9651 if(lane_mask == NULL) { 9652 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("lane_mask NULL parameter")); 9653 } 9654 if(xphy_id == NULL) { 9655 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("xphy_id NULL parameter")); 9656 } 9657 /* Dispatch */ 9658 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9659 if(__type__ >= portmodDispatchTypeCount) { 9660 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9661 } 9662 9663 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_lane_mask_get) { 9664 pm_info_t pm_info; 9665 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9666 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_lane_mask_get(unit, port, pm_info, params, lane_mask, xphy_id); 9667 _SOC_IF_ERR_EXIT(__rv__); 9668 } else { 9669 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_lane_mask_get isn't implemented for driver type")); 9670 } 9671 9672 exit: 9673 SOC_FUNC_RETURN; 9674 9675 } 9676 9677 9678 int portmod_link_recovery_t_validate(int unit, const portmod_link_recovery_t* portmod_link_recovery) 9679 { 9680 SOC_INIT_FUNC_DEFS; 9681 if(portmod_link_recovery == NULL) { 9682 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 9683 } 9684 9685 9686 9687 exit: 9688 SOC_FUNC_RETURN; 9689 9690 } 9691 9692 int portmod_link_recovery_t_init(int unit, portmod_link_recovery_t* portmod_link_recovery) 9693 { 9694 SOC_INIT_FUNC_DEFS; 9695 9696 if(portmod_link_recovery == NULL){ 9697 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_link_recovery NULL parameter")); 9698 } 9699 sal_memset(portmod_link_recovery, 0, sizeof(portmod_link_recovery_t)); 9700 9701 9702 exit: 9703 SOC_FUNC_RETURN; 9704 9705 } 9706 9707 int portmod_core_add(int unit, int pm_id, const portmod_port_add_info_t* add_info) 9708 { 9709 9710 portmod_dispatch_type_t __type__; 9711 int __rv__; 9712 SOC_INIT_FUNC_DEFS; 9713 9714 if(SOC_E_NONE != portmod_port_add_info_t_validate(unit, add_info)) { 9715 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("add_info validation failed")); 9716 } 9717 9718 /* Dispatch */ 9719 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 9720 if(__type__ >= portmodDispatchTypeCount) { 9721 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9722 } 9723 9724 if(NULL != __portmod__dispatch__[__type__]->f_portmod_core_add) { 9725 pm_info_t pm_info; 9726 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 9727 __rv__ = __portmod__dispatch__[__type__]->f_portmod_core_add(unit, pm_id, pm_info, add_info); 9728 _SOC_IF_ERR_EXIT(__rv__); 9729 } else { 9730 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_core_add isn't implemented for driver type")); 9731 } 9732 9733 exit: 9734 SOC_FUNC_RETURN; 9735 9736 } 9737 9738 9739 int portmod_pm_serdes_core_init(int unit, int pm_id, const portmod_port_add_info_t* add_info) 9740 { 9741 9742 portmod_dispatch_type_t __type__; 9743 int __rv__; 9744 SOC_INIT_FUNC_DEFS; 9745 9746 if(SOC_E_NONE != portmod_port_add_info_t_validate(unit, add_info)) { 9747 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("add_info validation failed")); 9748 } 9749 9750 /* Dispatch */ 9751 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 9752 if(__type__ >= portmodDispatchTypeCount) { 9753 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9754 } 9755 9756 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_serdes_core_init) { 9757 pm_info_t pm_info; 9758 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 9759 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_serdes_core_init(unit, pm_id, pm_info, add_info); 9760 _SOC_IF_ERR_EXIT(__rv__); 9761 } else { 9762 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_serdes_core_init isn't implemented for driver type")); 9763 } 9764 9765 exit: 9766 SOC_FUNC_RETURN; 9767 9768 } 9769 9770 9771 int portmod_pm_is_initialized(int unit, int pm_id, int* is_initialized) 9772 { 9773 9774 portmod_dispatch_type_t __type__; 9775 int __rv__; 9776 SOC_INIT_FUNC_DEFS; 9777 9778 if(is_initialized == NULL) { 9779 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("is_initialized NULL parameter")); 9780 } 9781 /* Dispatch */ 9782 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 9783 if(__type__ >= portmodDispatchTypeCount) { 9784 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9785 } 9786 9787 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_is_initialized) { 9788 pm_info_t pm_info; 9789 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 9790 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_is_initialized(unit, pm_id, pm_info, is_initialized); 9791 _SOC_IF_ERR_EXIT(__rv__); 9792 } else { 9793 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_is_initialized isn't implemented for driver type")); 9794 } 9795 9796 exit: 9797 SOC_FUNC_RETURN; 9798 9799 } 9800 9801 9802 int portmod_pmd_lane_config_t_validate(int unit, const portmod_pmd_lane_config_t* portmod_pmd_lane_config) 9803 { 9804 SOC_INIT_FUNC_DEFS; 9805 if(portmod_pmd_lane_config == NULL) { 9806 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 9807 } 9808 9809 9810 9811 exit: 9812 SOC_FUNC_RETURN; 9813 9814 } 9815 9816 int portmod_pmd_lane_config_t_init(int unit, portmod_pmd_lane_config_t* portmod_pmd_lane_config) 9817 { 9818 SOC_INIT_FUNC_DEFS; 9819 9820 if(portmod_pmd_lane_config == NULL){ 9821 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pmd_lane_config NULL parameter")); 9822 } 9823 sal_memset(portmod_pmd_lane_config, 0, sizeof(portmod_pmd_lane_config_t)); 9824 9825 9826 exit: 9827 SOC_FUNC_RETURN; 9828 9829 } 9830 9831 int portmod_port_speed_config_validate(int unit, int port, const portmod_speed_config_t* speed_config, portmod_pbmp_t* affected_pbmp) 9832 { 9833 9834 portmod_dispatch_type_t __type__; 9835 int __rv__; 9836 SOC_INIT_FUNC_DEFS; 9837 9838 if(SOC_E_NONE != portmod_speed_config_t_validate(unit, speed_config)) { 9839 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config validation failed")); 9840 } 9841 9842 if(affected_pbmp == NULL) { 9843 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("affected_pbmp NULL parameter")); 9844 } 9845 /* Dispatch */ 9846 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9847 if(__type__ >= portmodDispatchTypeCount) { 9848 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9849 } 9850 9851 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_speed_config_validate) { 9852 pm_info_t pm_info; 9853 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9854 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_speed_config_validate(unit, port, pm_info, speed_config, affected_pbmp); 9855 _SOC_IF_ERR_EXIT(__rv__); 9856 } else { 9857 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_speed_config_validate isn't implemented for driver type")); 9858 } 9859 9860 exit: 9861 SOC_FUNC_RETURN; 9862 9863 } 9864 9865 9866 int portmod_pm_enable(int unit, int pm_id, int enable) 9867 { 9868 9869 portmod_dispatch_type_t __type__; 9870 int __rv__; 9871 SOC_INIT_FUNC_DEFS; 9872 9873 /* Dispatch */ 9874 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 9875 if(__type__ >= portmodDispatchTypeCount) { 9876 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9877 } 9878 9879 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_enable) { 9880 pm_info_t pm_info; 9881 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 9882 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_enable(unit, pm_id, pm_info, enable); 9883 _SOC_IF_ERR_EXIT(__rv__); 9884 } else { 9885 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_enable isn't implemented for driver type")); 9886 } 9887 9888 exit: 9889 SOC_FUNC_RETURN; 9890 9891 } 9892 9893 9894 int portmod_pm_logical_pbmp_get(int unit, int pm_id, portmod_pbmp_t* logical_pbmp) 9895 { 9896 9897 portmod_dispatch_type_t __type__; 9898 int __rv__; 9899 SOC_INIT_FUNC_DEFS; 9900 9901 if(logical_pbmp == NULL) { 9902 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("logical_pbmp NULL parameter")); 9903 } 9904 /* Dispatch */ 9905 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 9906 if(__type__ >= portmodDispatchTypeCount) { 9907 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9908 } 9909 9910 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_logical_pbmp_get) { 9911 pm_info_t pm_info; 9912 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 9913 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_logical_pbmp_get(unit, pm_id, pm_info, logical_pbmp); 9914 _SOC_IF_ERR_EXIT(__rv__); 9915 } else { 9916 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_logical_pbmp_get isn't implemented for driver type")); 9917 } 9918 9919 exit: 9920 SOC_FUNC_RETURN; 9921 9922 } 9923 9924 9925 int portmod_pm_vco_reconfig(int unit, int pm_id, const portmod_vco_type_t* vco) 9926 { 9927 9928 portmod_dispatch_type_t __type__; 9929 int __rv__; 9930 SOC_INIT_FUNC_DEFS; 9931 9932 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, *vco)) { 9933 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco validation failed")); 9934 } 9935 9936 /* Dispatch */ 9937 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 9938 if(__type__ >= portmodDispatchTypeCount) { 9939 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9940 } 9941 9942 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_vco_reconfig) { 9943 pm_info_t pm_info; 9944 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 9945 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_vco_reconfig(unit, pm_id, pm_info, vco); 9946 _SOC_IF_ERR_EXIT(__rv__); 9947 } else { 9948 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_vco_reconfig isn't implemented for driver type")); 9949 } 9950 9951 exit: 9952 SOC_FUNC_RETURN; 9953 9954 } 9955 9956 9957 int portmod_port_speed_config_set(int unit, int port, const portmod_speed_config_t* speed_config) 9958 { 9959 9960 portmod_dispatch_type_t __type__; 9961 int __rv__; 9962 SOC_INIT_FUNC_DEFS; 9963 9964 if(SOC_E_NONE != portmod_speed_config_t_validate(unit, speed_config)) { 9965 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config validation failed")); 9966 } 9967 9968 /* Dispatch */ 9969 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 9970 if(__type__ >= portmodDispatchTypeCount) { 9971 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 9972 } 9973 9974 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_speed_config_set) { 9975 pm_info_t pm_info; 9976 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 9977 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_speed_config_set(unit, port, pm_info, speed_config); 9978 _SOC_IF_ERR_EXIT(__rv__); 9979 } else { 9980 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_speed_config_set isn't implemented for driver type")); 9981 } 9982 9983 exit: 9984 SOC_FUNC_RETURN; 9985 9986 } 9987 9988 9989 int portmod_port_speed_config_get(int unit, int port, portmod_speed_config_t* speed_config) 9990 { 9991 9992 portmod_dispatch_type_t __type__; 9993 int __rv__; 9994 SOC_INIT_FUNC_DEFS; 9995 9996 if(speed_config == NULL) { 9997 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config NULL parameter")); 9998 } 9999 if(SOC_E_NONE != portmod_speed_config_t_init(unit, speed_config)) { 10000 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config initialization failed")); 10001 } 10002 10003 /* Dispatch */ 10004 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10005 if(__type__ >= portmodDispatchTypeCount) { 10006 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10007 } 10008 10009 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_speed_config_get) { 10010 pm_info_t pm_info; 10011 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10012 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_speed_config_get(unit, port, pm_info, speed_config); 10013 _SOC_IF_ERR_EXIT(__rv__); 10014 } else { 10015 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_speed_config_get isn't implemented for driver type")); 10016 } 10017 10018 exit: 10019 SOC_FUNC_RETURN; 10020 10021 } 10022 10023 10024 int portmod_sbus_bcast_config_t_validate(int unit, const portmod_sbus_bcast_config_t* portmod_sbus_bcast_config) 10025 { 10026 SOC_INIT_FUNC_DEFS; 10027 if(portmod_sbus_bcast_config == NULL) { 10028 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 10029 } 10030 10031 10032 10033 exit: 10034 SOC_FUNC_RETURN; 10035 10036 } 10037 10038 int portmod_sbus_bcast_config_t_init(int unit, portmod_sbus_bcast_config_t* portmod_sbus_bcast_config) 10039 { 10040 SOC_INIT_FUNC_DEFS; 10041 10042 if(portmod_sbus_bcast_config == NULL){ 10043 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_sbus_bcast_config NULL parameter")); 10044 } 10045 sal_memset(portmod_sbus_bcast_config, 0, sizeof(portmod_sbus_bcast_config_t)); 10046 portmod_sbus_bcast_config->bcast_id = 0; 10047 portmod_sbus_bcast_config->chain_last = 0; 10048 10049 10050 exit: 10051 SOC_FUNC_RETURN; 10052 10053 } 10054 10055 int portmod_fw_bcast(int unit, pm_info_t pm_info, const portmod_sbus_bcast_config_t* sbus_bcast_cfg) 10056 { 10057 10058 portmod_dispatch_type_t __type__; 10059 int __rv__; 10060 SOC_INIT_FUNC_DEFS; 10061 10062 if(SOC_E_NONE != portmod_sbus_bcast_config_t_validate(unit, sbus_bcast_cfg)) { 10063 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("sbus_bcast_cfg validation failed")); 10064 } 10065 10066 /* Dispatch */ 10067 __type__ = (pm_info)->type; 10068 if(__type__ >= portmodDispatchTypeCount) { 10069 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10070 } 10071 10072 if(NULL != __portmod__dispatch__[__type__]->f_portmod_fw_bcast) { 10073 __rv__ = __portmod__dispatch__[__type__]->f_portmod_fw_bcast(unit, pm_info, sbus_bcast_cfg); 10074 _SOC_IF_ERR_EXIT(__rv__); 10075 } else { 10076 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_fw_bcast isn't implemented for driver type")); 10077 } 10078 10079 exit: 10080 SOC_FUNC_RETURN; 10081 10082 } 10083 10084 10085 int portmod_port_credits_enable_set(int unit, int port, int enable) 10086 { 10087 10088 portmod_dispatch_type_t __type__; 10089 int __rv__; 10090 SOC_INIT_FUNC_DEFS; 10091 10092 /* Dispatch */ 10093 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10094 if(__type__ >= portmodDispatchTypeCount) { 10095 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10096 } 10097 10098 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_credits_enable_set) { 10099 pm_info_t pm_info; 10100 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10101 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_credits_enable_set(unit, port, pm_info, enable); 10102 _SOC_IF_ERR_EXIT(__rv__); 10103 } else { 10104 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_credits_enable_set isn't implemented for driver type")); 10105 } 10106 10107 exit: 10108 SOC_FUNC_RETURN; 10109 10110 } 10111 10112 10113 #ifdef CPRIMOD_SUPPORT 10114 int portmod_cpri_stage_t_validate(int unit, portmod_cpri_stage_t portmod_cpri_stage) 10115 { 10116 SOC_INIT_FUNC_DEFS; 10117 if(portmod_cpri_stage >= portmodCpriStageCount) { 10118 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Parameter is out of range")); 10119 } 10120 10121 exit: 10122 SOC_FUNC_RETURN; 10123 10124 } 10125 #endif /* CPRIMOD_SUPPORT */ 10126 10127 #ifdef CPRIMOD_SUPPORT 10128 int portmod_cpri_port_stage_activate(int unit, int port, portmod_cpri_stage_t stage) 10129 { 10130 10131 portmod_dispatch_type_t __type__; 10132 int __rv__; 10133 SOC_INIT_FUNC_DEFS; 10134 10135 if(SOC_E_NONE != portmod_cpri_stage_t_validate(unit, stage)) { 10136 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("stage validation failed")); 10137 } 10138 10139 /* Dispatch */ 10140 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10141 if(__type__ >= portmodDispatchTypeCount) { 10142 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10143 } 10144 10145 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_stage_activate) { 10146 pm_info_t pm_info; 10147 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10148 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_stage_activate(unit, port, pm_info, stage); 10149 _SOC_IF_ERR_EXIT(__rv__); 10150 } else { 10151 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_stage_activate isn't implemented for driver type")); 10152 } 10153 10154 exit: 10155 SOC_FUNC_RETURN; 10156 10157 } 10158 #endif /* CPRIMOD_SUPPORT */ 10159 10160 10161 #ifdef CPRIMOD_SUPPORT 10162 int portmod_cpri_axc_frame_info_t_validate(int unit, const portmod_cpri_axc_frame_info_t* portmod_cpri_axc_frame_info) 10163 { 10164 SOC_INIT_FUNC_DEFS; 10165 if(portmod_cpri_axc_frame_info == NULL) { 10166 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 10167 } 10168 10169 10170 10171 exit: 10172 SOC_FUNC_RETURN; 10173 10174 } 10175 #endif /* CPRIMOD_SUPPORT */ 10176 10177 #ifdef CPRIMOD_SUPPORT 10178 int portmod_cpri_axc_frame_info_t_init(int unit, portmod_cpri_axc_frame_info_t* portmod_cpri_axc_frame_info) 10179 { 10180 SOC_INIT_FUNC_DEFS; 10181 10182 if(portmod_cpri_axc_frame_info == NULL){ 10183 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_axc_frame_info NULL parameter")); 10184 } 10185 sal_memset(portmod_cpri_axc_frame_info, 0, sizeof(portmod_cpri_axc_frame_info_t)); 10186 portmod_cpri_axc_frame_info->start_bit = 0; 10187 portmod_cpri_axc_frame_info->num_bits = 0; 10188 _SOC_IF_ERR_EXIT(cprimod_cpri_container_config_t_init(&portmod_cpri_axc_frame_info->container_info)); 10189 _SOC_IF_ERR_EXIT(cprimod_payload_size_info_t_init(&portmod_cpri_axc_frame_info->roe_payload_info)); 10190 _SOC_IF_ERR_EXIT(cprimod_encap_decap_data_config_t_init(&portmod_cpri_axc_frame_info->encap_data_info)); 10191 10192 10193 exit: 10194 SOC_FUNC_RETURN; 10195 10196 } 10197 #endif /* CPRIMOD_SUPPORT */ 10198 10199 #ifdef CPRIMOD_SUPPORT 10200 int portmod_cpri_port_rsvd4_tx_fsm_state_set(int unit, int port, cprimod_rsvd4_tx_fsm_state_t state) 10201 { 10202 10203 portmod_dispatch_type_t __type__; 10204 int __rv__; 10205 SOC_INIT_FUNC_DEFS; 10206 10207 /* Dispatch */ 10208 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10209 if(__type__ >= portmodDispatchTypeCount) { 10210 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10211 } 10212 10213 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_fsm_state_set) { 10214 pm_info_t pm_info; 10215 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10216 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_fsm_state_set(unit, port, pm_info, state); 10217 _SOC_IF_ERR_EXIT(__rv__); 10218 } else { 10219 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_tx_fsm_state_set isn't implemented for driver type")); 10220 } 10221 10222 exit: 10223 SOC_FUNC_RETURN; 10224 10225 } 10226 #endif /* CPRIMOD_SUPPORT */ 10227 10228 10229 #ifdef CPRIMOD_SUPPORT 10230 int portmod_cpri_port_rsvd4_tx_override_set(int unit, int port, cprimod_rsvd4_tx_overide_t parameter, int enable, int value) 10231 { 10232 10233 portmod_dispatch_type_t __type__; 10234 int __rv__; 10235 SOC_INIT_FUNC_DEFS; 10236 10237 /* Dispatch */ 10238 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10239 if(__type__ >= portmodDispatchTypeCount) { 10240 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10241 } 10242 10243 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_override_set) { 10244 pm_info_t pm_info; 10245 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10246 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_override_set(unit, port, pm_info, parameter, enable, value); 10247 _SOC_IF_ERR_EXIT(__rv__); 10248 } else { 10249 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_tx_override_set isn't implemented for driver type")); 10250 } 10251 10252 exit: 10253 SOC_FUNC_RETURN; 10254 10255 } 10256 #endif /* CPRIMOD_SUPPORT */ 10257 10258 10259 #ifdef CPRIMOD_SUPPORT 10260 int portmod_cpri_port_rsvd4_rx_override_set(int unit, int port, cprimod_rsvd4_rx_overide_t parameter, int enable, int value) 10261 { 10262 10263 portmod_dispatch_type_t __type__; 10264 int __rv__; 10265 SOC_INIT_FUNC_DEFS; 10266 10267 /* Dispatch */ 10268 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10269 if(__type__ >= portmodDispatchTypeCount) { 10270 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10271 } 10272 10273 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_override_set) { 10274 pm_info_t pm_info; 10275 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10276 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_override_set(unit, port, pm_info, parameter, enable, value); 10277 _SOC_IF_ERR_EXIT(__rv__); 10278 } else { 10279 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_rx_override_set isn't implemented for driver type")); 10280 } 10281 10282 exit: 10283 SOC_FUNC_RETURN; 10284 10285 } 10286 #endif /* CPRIMOD_SUPPORT */ 10287 10288 10289 #ifdef CPRIMOD_SUPPORT 10290 int portmod_cpri_port_rx_axc_frame_add(int unit, int port, uint32 axc_id, const portmod_cpri_axc_frame_info_t* frame_info) 10291 { 10292 10293 portmod_dispatch_type_t __type__; 10294 int __rv__; 10295 SOC_INIT_FUNC_DEFS; 10296 10297 if(SOC_E_NONE != portmod_cpri_axc_frame_info_t_validate(unit, frame_info)) { 10298 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("frame_info validation failed")); 10299 } 10300 10301 /* Dispatch */ 10302 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10303 if(__type__ >= portmodDispatchTypeCount) { 10304 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10305 } 10306 10307 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_axc_frame_add) { 10308 pm_info_t pm_info; 10309 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10310 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_axc_frame_add(unit, port, pm_info, axc_id, frame_info); 10311 _SOC_IF_ERR_EXIT(__rv__); 10312 } else { 10313 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_axc_frame_add isn't implemented for driver type")); 10314 } 10315 10316 exit: 10317 SOC_FUNC_RETURN; 10318 10319 } 10320 #endif /* CPRIMOD_SUPPORT */ 10321 10322 10323 #ifdef CPRIMOD_SUPPORT 10324 int portmod_cpri_port_rx_frame_optional_config_set(int unit, int port, cprimod_rx_config_field_t field, int value) 10325 { 10326 10327 portmod_dispatch_type_t __type__; 10328 int __rv__; 10329 SOC_INIT_FUNC_DEFS; 10330 10331 /* Dispatch */ 10332 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10333 if(__type__ >= portmodDispatchTypeCount) { 10334 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10335 } 10336 10337 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_frame_optional_config_set) { 10338 pm_info_t pm_info; 10339 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10340 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_frame_optional_config_set(unit, port, pm_info, field, value); 10341 _SOC_IF_ERR_EXIT(__rv__); 10342 } else { 10343 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_frame_optional_config_set isn't implemented for driver type")); 10344 } 10345 10346 exit: 10347 SOC_FUNC_RETURN; 10348 10349 } 10350 #endif /* CPRIMOD_SUPPORT */ 10351 10352 10353 #ifdef CPRIMOD_SUPPORT 10354 int portmod_cpri_port_rx_frame_optional_config_get(int unit, int port, cprimod_rx_config_field_t field, int* value) 10355 { 10356 10357 portmod_dispatch_type_t __type__; 10358 int __rv__; 10359 SOC_INIT_FUNC_DEFS; 10360 10361 if(value == NULL) { 10362 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 10363 } 10364 /* Dispatch */ 10365 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10366 if(__type__ >= portmodDispatchTypeCount) { 10367 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10368 } 10369 10370 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_frame_optional_config_get) { 10371 pm_info_t pm_info; 10372 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10373 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_frame_optional_config_get(unit, port, pm_info, field, value); 10374 _SOC_IF_ERR_EXIT(__rv__); 10375 } else { 10376 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_frame_optional_config_get isn't implemented for driver type")); 10377 } 10378 10379 exit: 10380 SOC_FUNC_RETURN; 10381 10382 } 10383 #endif /* CPRIMOD_SUPPORT */ 10384 10385 10386 #ifdef CPRIMOD_SUPPORT 10387 int portmod_cpri_port_tx_frame_optional_config_set(int unit, int port, cprimod_tx_config_field_t field, uint32 value) 10388 { 10389 10390 portmod_dispatch_type_t __type__; 10391 int __rv__; 10392 SOC_INIT_FUNC_DEFS; 10393 10394 /* Dispatch */ 10395 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10396 if(__type__ >= portmodDispatchTypeCount) { 10397 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10398 } 10399 10400 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_optional_config_set) { 10401 pm_info_t pm_info; 10402 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10403 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_optional_config_set(unit, port, pm_info, field, value); 10404 _SOC_IF_ERR_EXIT(__rv__); 10405 } else { 10406 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_optional_config_set isn't implemented for driver type")); 10407 } 10408 10409 exit: 10410 SOC_FUNC_RETURN; 10411 10412 } 10413 #endif /* CPRIMOD_SUPPORT */ 10414 10415 10416 #ifdef CPRIMOD_SUPPORT 10417 int portmod_cpri_port_tx_frame_optional_config_get(int unit, int port, cprimod_tx_config_field_t field, uint32* value) 10418 { 10419 10420 portmod_dispatch_type_t __type__; 10421 int __rv__; 10422 SOC_INIT_FUNC_DEFS; 10423 10424 if(value == NULL) { 10425 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 10426 } 10427 /* Dispatch */ 10428 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10429 if(__type__ >= portmodDispatchTypeCount) { 10430 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10431 } 10432 10433 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_optional_config_get) { 10434 pm_info_t pm_info; 10435 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10436 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_optional_config_get(unit, port, pm_info, field, value); 10437 _SOC_IF_ERR_EXIT(__rv__); 10438 } else { 10439 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_optional_config_get isn't implemented for driver type")); 10440 } 10441 10442 exit: 10443 SOC_FUNC_RETURN; 10444 10445 } 10446 #endif /* CPRIMOD_SUPPORT */ 10447 10448 10449 #ifdef CPRIMOD_SUPPORT 10450 int portmod_port_rsvd4_rx_frame_optional_config_set(int unit, int port, cprimod_rsvd4_rx_config_field_t field, int value) 10451 { 10452 10453 portmod_dispatch_type_t __type__; 10454 int __rv__; 10455 SOC_INIT_FUNC_DEFS; 10456 10457 /* Dispatch */ 10458 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10459 if(__type__ >= portmodDispatchTypeCount) { 10460 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10461 } 10462 10463 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_frame_optional_config_set) { 10464 pm_info_t pm_info; 10465 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10466 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_frame_optional_config_set(unit, port, pm_info, field, value); 10467 _SOC_IF_ERR_EXIT(__rv__); 10468 } else { 10469 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_rx_frame_optional_config_set isn't implemented for driver type")); 10470 } 10471 10472 exit: 10473 SOC_FUNC_RETURN; 10474 10475 } 10476 #endif /* CPRIMOD_SUPPORT */ 10477 10478 10479 #ifdef CPRIMOD_SUPPORT 10480 int portmod_port_rsvd4_rx_frame_optional_config_get(int unit, int port, cprimod_rsvd4_rx_config_field_t field, int* value) 10481 { 10482 10483 portmod_dispatch_type_t __type__; 10484 int __rv__; 10485 SOC_INIT_FUNC_DEFS; 10486 10487 if(value == NULL) { 10488 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 10489 } 10490 /* Dispatch */ 10491 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10492 if(__type__ >= portmodDispatchTypeCount) { 10493 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10494 } 10495 10496 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_frame_optional_config_get) { 10497 pm_info_t pm_info; 10498 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10499 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_frame_optional_config_get(unit, port, pm_info, field, value); 10500 _SOC_IF_ERR_EXIT(__rv__); 10501 } else { 10502 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_rx_frame_optional_config_get isn't implemented for driver type")); 10503 } 10504 10505 exit: 10506 SOC_FUNC_RETURN; 10507 10508 } 10509 #endif /* CPRIMOD_SUPPORT */ 10510 10511 10512 #ifdef CPRIMOD_SUPPORT 10513 int portmod_port_rsvd4_tx_frame_optional_config_set(int unit, int port, cprimod_rsvd4_tx_config_field_t field, int value) 10514 { 10515 10516 portmod_dispatch_type_t __type__; 10517 int __rv__; 10518 SOC_INIT_FUNC_DEFS; 10519 10520 /* Dispatch */ 10521 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10522 if(__type__ >= portmodDispatchTypeCount) { 10523 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10524 } 10525 10526 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_frame_optional_config_set) { 10527 pm_info_t pm_info; 10528 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10529 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_frame_optional_config_set(unit, port, pm_info, field, value); 10530 _SOC_IF_ERR_EXIT(__rv__); 10531 } else { 10532 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_tx_frame_optional_config_set isn't implemented for driver type")); 10533 } 10534 10535 exit: 10536 SOC_FUNC_RETURN; 10537 10538 } 10539 #endif /* CPRIMOD_SUPPORT */ 10540 10541 10542 #ifdef CPRIMOD_SUPPORT 10543 int portmod_port_rsvd4_tx_frame_optional_config_get(int unit, int port, cprimod_rsvd4_tx_config_field_t field, int* value) 10544 { 10545 10546 portmod_dispatch_type_t __type__; 10547 int __rv__; 10548 SOC_INIT_FUNC_DEFS; 10549 10550 if(value == NULL) { 10551 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 10552 } 10553 /* Dispatch */ 10554 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10555 if(__type__ >= portmodDispatchTypeCount) { 10556 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10557 } 10558 10559 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_frame_optional_config_get) { 10560 pm_info_t pm_info; 10561 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10562 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_frame_optional_config_get(unit, port, pm_info, field, value); 10563 _SOC_IF_ERR_EXIT(__rv__); 10564 } else { 10565 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_tx_frame_optional_config_get isn't implemented for driver type")); 10566 } 10567 10568 exit: 10569 SOC_FUNC_RETURN; 10570 10571 } 10572 #endif /* CPRIMOD_SUPPORT */ 10573 10574 10575 #ifdef CPRIMOD_SUPPORT 10576 int portmod_port_rsvd4_rx_speed_set(int unit, int port, cprimod_port_rsvd4_speed_mult_t speed) 10577 { 10578 10579 portmod_dispatch_type_t __type__; 10580 int __rv__; 10581 SOC_INIT_FUNC_DEFS; 10582 10583 /* Dispatch */ 10584 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10585 if(__type__ >= portmodDispatchTypeCount) { 10586 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10587 } 10588 10589 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_speed_set) { 10590 pm_info_t pm_info; 10591 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10592 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_speed_set(unit, port, pm_info, speed); 10593 _SOC_IF_ERR_EXIT(__rv__); 10594 } else { 10595 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_rx_speed_set isn't implemented for driver type")); 10596 } 10597 10598 exit: 10599 SOC_FUNC_RETURN; 10600 10601 } 10602 #endif /* CPRIMOD_SUPPORT */ 10603 10604 10605 #ifdef CPRIMOD_SUPPORT 10606 int portmod_port_rsvd4_rx_speed_get(int unit, int port, cprimod_port_rsvd4_speed_mult_t* speed) 10607 { 10608 10609 portmod_dispatch_type_t __type__; 10610 int __rv__; 10611 SOC_INIT_FUNC_DEFS; 10612 10613 if(speed == NULL) { 10614 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed NULL parameter")); 10615 } 10616 /* Dispatch */ 10617 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10618 if(__type__ >= portmodDispatchTypeCount) { 10619 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10620 } 10621 10622 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_speed_get) { 10623 pm_info_t pm_info; 10624 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10625 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_rx_speed_get(unit, port, pm_info, speed); 10626 _SOC_IF_ERR_EXIT(__rv__); 10627 } else { 10628 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_rx_speed_get isn't implemented for driver type")); 10629 } 10630 10631 exit: 10632 SOC_FUNC_RETURN; 10633 10634 } 10635 #endif /* CPRIMOD_SUPPORT */ 10636 10637 10638 #ifdef CPRIMOD_SUPPORT 10639 int portmod_port_rsvd4_tx_speed_set(int unit, int port, cprimod_port_rsvd4_speed_mult_t speed) 10640 { 10641 10642 portmod_dispatch_type_t __type__; 10643 int __rv__; 10644 SOC_INIT_FUNC_DEFS; 10645 10646 /* Dispatch */ 10647 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10648 if(__type__ >= portmodDispatchTypeCount) { 10649 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10650 } 10651 10652 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_speed_set) { 10653 pm_info_t pm_info; 10654 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10655 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_speed_set(unit, port, pm_info, speed); 10656 _SOC_IF_ERR_EXIT(__rv__); 10657 } else { 10658 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_tx_speed_set isn't implemented for driver type")); 10659 } 10660 10661 exit: 10662 SOC_FUNC_RETURN; 10663 10664 } 10665 #endif /* CPRIMOD_SUPPORT */ 10666 10667 10668 #ifdef CPRIMOD_SUPPORT 10669 int portmod_port_rsvd4_tx_speed_get(int unit, int port, cprimod_port_rsvd4_speed_mult_t* speed) 10670 { 10671 10672 portmod_dispatch_type_t __type__; 10673 int __rv__; 10674 SOC_INIT_FUNC_DEFS; 10675 10676 if(speed == NULL) { 10677 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed NULL parameter")); 10678 } 10679 /* Dispatch */ 10680 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10681 if(__type__ >= portmodDispatchTypeCount) { 10682 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10683 } 10684 10685 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_speed_get) { 10686 pm_info_t pm_info; 10687 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10688 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rsvd4_tx_speed_get(unit, port, pm_info, speed); 10689 _SOC_IF_ERR_EXIT(__rv__); 10690 } else { 10691 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rsvd4_tx_speed_get isn't implemented for driver type")); 10692 } 10693 10694 exit: 10695 SOC_FUNC_RETURN; 10696 10697 } 10698 #endif /* CPRIMOD_SUPPORT */ 10699 10700 10701 #ifdef CPRIMOD_SUPPORT 10702 int portmod_cpri_port_rx_axc_frame_delete(int unit, int port, uint32 axc_id) 10703 { 10704 10705 portmod_dispatch_type_t __type__; 10706 int __rv__; 10707 SOC_INIT_FUNC_DEFS; 10708 10709 /* Dispatch */ 10710 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10711 if(__type__ >= portmodDispatchTypeCount) { 10712 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10713 } 10714 10715 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_axc_frame_delete) { 10716 pm_info_t pm_info; 10717 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10718 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_axc_frame_delete(unit, port, pm_info, axc_id); 10719 _SOC_IF_ERR_EXIT(__rv__); 10720 } else { 10721 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_axc_frame_delete isn't implemented for driver type")); 10722 } 10723 10724 exit: 10725 SOC_FUNC_RETURN; 10726 10727 } 10728 #endif /* CPRIMOD_SUPPORT */ 10729 10730 10731 #ifdef CPRIMOD_SUPPORT 10732 int portmod_cpri_port_rx_axc_frame_get(int unit, int port, uint32 axc_id, uint32 from_get_all, portmod_cpri_axc_frame_info_t* frame_info) 10733 { 10734 10735 portmod_dispatch_type_t __type__; 10736 int __rv__; 10737 SOC_INIT_FUNC_DEFS; 10738 10739 if(frame_info == NULL) { 10740 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("frame_info NULL parameter")); 10741 } 10742 if(SOC_E_NONE != portmod_cpri_axc_frame_info_t_init(unit, frame_info)) { 10743 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("frame_info initialization failed")); 10744 } 10745 10746 /* Dispatch */ 10747 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10748 if(__type__ >= portmodDispatchTypeCount) { 10749 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10750 } 10751 10752 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_axc_frame_get) { 10753 pm_info_t pm_info; 10754 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10755 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_axc_frame_get(unit, port, pm_info, axc_id, from_get_all, frame_info); 10756 _SOC_IF_ERR_EXIT(__rv__); 10757 } else { 10758 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_axc_frame_get isn't implemented for driver type")); 10759 } 10760 10761 exit: 10762 SOC_FUNC_RETURN; 10763 10764 } 10765 #endif /* CPRIMOD_SUPPORT */ 10766 10767 10768 #ifdef CPRIMOD_SUPPORT 10769 int portmod_cpri_port_rsvd4_rx_fsm_state_set(int unit, int port, cprimod_rsvd4_rx_fsm_state_t state) 10770 { 10771 10772 portmod_dispatch_type_t __type__; 10773 int __rv__; 10774 SOC_INIT_FUNC_DEFS; 10775 10776 /* Dispatch */ 10777 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10778 if(__type__ >= portmodDispatchTypeCount) { 10779 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10780 } 10781 10782 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_fsm_state_set) { 10783 pm_info_t pm_info; 10784 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10785 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_fsm_state_set(unit, port, pm_info, state); 10786 _SOC_IF_ERR_EXIT(__rv__); 10787 } else { 10788 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_rx_fsm_state_set isn't implemented for driver type")); 10789 } 10790 10791 exit: 10792 SOC_FUNC_RETURN; 10793 10794 } 10795 #endif /* CPRIMOD_SUPPORT */ 10796 10797 10798 #ifdef CPRIMOD_SUPPORT 10799 int portmod_cpri_port_tx_axc_frame_add(int unit, int port, uint32 axc_id, const portmod_cpri_axc_frame_info_t* frame_info) 10800 { 10801 10802 portmod_dispatch_type_t __type__; 10803 int __rv__; 10804 SOC_INIT_FUNC_DEFS; 10805 10806 if(SOC_E_NONE != portmod_cpri_axc_frame_info_t_validate(unit, frame_info)) { 10807 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("frame_info validation failed")); 10808 } 10809 10810 /* Dispatch */ 10811 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10812 if(__type__ >= portmodDispatchTypeCount) { 10813 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10814 } 10815 10816 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_axc_frame_add) { 10817 pm_info_t pm_info; 10818 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10819 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_axc_frame_add(unit, port, pm_info, axc_id, frame_info); 10820 _SOC_IF_ERR_EXIT(__rv__); 10821 } else { 10822 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_axc_frame_add isn't implemented for driver type")); 10823 } 10824 10825 exit: 10826 SOC_FUNC_RETURN; 10827 10828 } 10829 #endif /* CPRIMOD_SUPPORT */ 10830 10831 10832 #ifdef CPRIMOD_SUPPORT 10833 int portmod_cpri_port_tx_axc_frame_delete(int unit, int port, uint32 axc_id) 10834 { 10835 10836 portmod_dispatch_type_t __type__; 10837 int __rv__; 10838 SOC_INIT_FUNC_DEFS; 10839 10840 /* Dispatch */ 10841 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10842 if(__type__ >= portmodDispatchTypeCount) { 10843 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10844 } 10845 10846 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_axc_frame_delete) { 10847 pm_info_t pm_info; 10848 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10849 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_axc_frame_delete(unit, port, pm_info, axc_id); 10850 _SOC_IF_ERR_EXIT(__rv__); 10851 } else { 10852 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_axc_frame_delete isn't implemented for driver type")); 10853 } 10854 10855 exit: 10856 SOC_FUNC_RETURN; 10857 10858 } 10859 #endif /* CPRIMOD_SUPPORT */ 10860 10861 10862 #ifdef CPRIMOD_SUPPORT 10863 int portmod_cpri_port_tx_axc_frame_get(int unit, int port, uint32 axc_id, uint32 from_get_all, portmod_cpri_axc_frame_info_t* frame_info) 10864 { 10865 10866 portmod_dispatch_type_t __type__; 10867 int __rv__; 10868 SOC_INIT_FUNC_DEFS; 10869 10870 if(frame_info == NULL) { 10871 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("frame_info NULL parameter")); 10872 } 10873 if(SOC_E_NONE != portmod_cpri_axc_frame_info_t_init(unit, frame_info)) { 10874 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("frame_info initialization failed")); 10875 } 10876 10877 /* Dispatch */ 10878 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10879 if(__type__ >= portmodDispatchTypeCount) { 10880 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10881 } 10882 10883 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_axc_frame_get) { 10884 pm_info_t pm_info; 10885 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10886 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_axc_frame_get(unit, port, pm_info, axc_id, from_get_all, frame_info); 10887 _SOC_IF_ERR_EXIT(__rv__); 10888 } else { 10889 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_axc_frame_get isn't implemented for driver type")); 10890 } 10891 10892 exit: 10893 SOC_FUNC_RETURN; 10894 10895 } 10896 #endif /* CPRIMOD_SUPPORT */ 10897 10898 10899 #ifdef CPRIMOD_SUPPORT 10900 int portmod_cpri_port_encap_set(int unit, int port, uint32 queue_num, const cprimod_encap_header_config_t* config) 10901 { 10902 10903 portmod_dispatch_type_t __type__; 10904 int __rv__; 10905 SOC_INIT_FUNC_DEFS; 10906 10907 /* Dispatch */ 10908 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10909 if(__type__ >= portmodDispatchTypeCount) { 10910 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10911 } 10912 10913 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_set) { 10914 pm_info_t pm_info; 10915 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10916 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_set(unit, port, pm_info, queue_num, config); 10917 _SOC_IF_ERR_EXIT(__rv__); 10918 } else { 10919 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_set isn't implemented for driver type")); 10920 } 10921 10922 exit: 10923 SOC_FUNC_RETURN; 10924 10925 } 10926 #endif /* CPRIMOD_SUPPORT */ 10927 10928 10929 #ifdef CPRIMOD_SUPPORT 10930 int portmod_cpri_port_encap_get(int unit, int port, uint32 queue_num, cprimod_encap_header_config_t* config) 10931 { 10932 10933 portmod_dispatch_type_t __type__; 10934 int __rv__; 10935 SOC_INIT_FUNC_DEFS; 10936 10937 if(config == NULL) { 10938 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 10939 } 10940 /* Dispatch */ 10941 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10942 if(__type__ >= portmodDispatchTypeCount) { 10943 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10944 } 10945 10946 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_get) { 10947 pm_info_t pm_info; 10948 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10949 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_get(unit, port, pm_info, queue_num, config); 10950 _SOC_IF_ERR_EXIT(__rv__); 10951 } else { 10952 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_get isn't implemented for driver type")); 10953 } 10954 10955 exit: 10956 SOC_FUNC_RETURN; 10957 10958 } 10959 #endif /* CPRIMOD_SUPPORT */ 10960 10961 10962 #ifdef CPRIMOD_SUPPORT 10963 int portmod_cpri_port_encap_roe_ordering_info_set(int unit, int port, uint32 index, const cprimod_encap_ordering_info_entry_t* config) 10964 { 10965 10966 portmod_dispatch_type_t __type__; 10967 int __rv__; 10968 SOC_INIT_FUNC_DEFS; 10969 10970 /* Dispatch */ 10971 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 10972 if(__type__ >= portmodDispatchTypeCount) { 10973 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 10974 } 10975 10976 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_info_set) { 10977 pm_info_t pm_info; 10978 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 10979 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_info_set(unit, port, pm_info, index, config); 10980 _SOC_IF_ERR_EXIT(__rv__); 10981 } else { 10982 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_roe_ordering_info_set isn't implemented for driver type")); 10983 } 10984 10985 exit: 10986 SOC_FUNC_RETURN; 10987 10988 } 10989 #endif /* CPRIMOD_SUPPORT */ 10990 10991 10992 #ifdef CPRIMOD_SUPPORT 10993 int portmod_cpri_port_encap_roe_ordering_info_get(int unit, int port, uint32 index, cprimod_encap_ordering_info_entry_t* config) 10994 { 10995 10996 portmod_dispatch_type_t __type__; 10997 int __rv__; 10998 SOC_INIT_FUNC_DEFS; 10999 11000 if(config == NULL) { 11001 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 11002 } 11003 /* Dispatch */ 11004 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11005 if(__type__ >= portmodDispatchTypeCount) { 11006 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11007 } 11008 11009 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_info_get) { 11010 pm_info_t pm_info; 11011 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11012 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_info_get(unit, port, pm_info, index, config); 11013 _SOC_IF_ERR_EXIT(__rv__); 11014 } else { 11015 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_roe_ordering_info_get isn't implemented for driver type")); 11016 } 11017 11018 exit: 11019 SOC_FUNC_RETURN; 11020 11021 } 11022 #endif /* CPRIMOD_SUPPORT */ 11023 11024 11025 #ifdef CPRIMOD_SUPPORT 11026 int portmod_cpri_port_encap_roe_ordering_sequence_offset_set(int unit, int port, uint32 queue_num, uint32 control, const cprimod_cpri_ordering_info_offset_t* config) 11027 { 11028 11029 portmod_dispatch_type_t __type__; 11030 int __rv__; 11031 SOC_INIT_FUNC_DEFS; 11032 11033 /* Dispatch */ 11034 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11035 if(__type__ >= portmodDispatchTypeCount) { 11036 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11037 } 11038 11039 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_sequence_offset_set) { 11040 pm_info_t pm_info; 11041 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11042 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_sequence_offset_set(unit, port, pm_info, queue_num, control, config); 11043 _SOC_IF_ERR_EXIT(__rv__); 11044 } else { 11045 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_roe_ordering_sequence_offset_set isn't implemented for driver type")); 11046 } 11047 11048 exit: 11049 SOC_FUNC_RETURN; 11050 11051 } 11052 #endif /* CPRIMOD_SUPPORT */ 11053 11054 11055 #ifdef CPRIMOD_SUPPORT 11056 int portmod_cpri_port_encap_roe_ordering_sequence_offset_get(int unit, int port, uint32 queue_num, uint32 control, cprimod_cpri_ordering_info_offset_t* config) 11057 { 11058 11059 portmod_dispatch_type_t __type__; 11060 int __rv__; 11061 SOC_INIT_FUNC_DEFS; 11062 11063 if(config == NULL) { 11064 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 11065 } 11066 /* Dispatch */ 11067 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11068 if(__type__ >= portmodDispatchTypeCount) { 11069 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11070 } 11071 11072 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_sequence_offset_get) { 11073 pm_info_t pm_info; 11074 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11075 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_roe_ordering_sequence_offset_get(unit, port, pm_info, queue_num, control, config); 11076 _SOC_IF_ERR_EXIT(__rv__); 11077 } else { 11078 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_roe_ordering_sequence_offset_get isn't implemented for driver type")); 11079 } 11080 11081 exit: 11082 SOC_FUNC_RETURN; 11083 11084 } 11085 #endif /* CPRIMOD_SUPPORT */ 11086 11087 11088 #ifdef CPRIMOD_SUPPORT 11089 int portmod_cpri_port_roe_encap_macda_entry_set(int unit, int port, uint32 index, cprimod_mac_addr_t mac_addr) 11090 { 11091 11092 portmod_dispatch_type_t __type__; 11093 int __rv__; 11094 SOC_INIT_FUNC_DEFS; 11095 11096 /* Dispatch */ 11097 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11098 if(__type__ >= portmodDispatchTypeCount) { 11099 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11100 } 11101 11102 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macda_entry_set) { 11103 pm_info_t pm_info; 11104 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11105 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macda_entry_set(unit, port, pm_info, index, mac_addr); 11106 _SOC_IF_ERR_EXIT(__rv__); 11107 } else { 11108 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_roe_encap_macda_entry_set isn't implemented for driver type")); 11109 } 11110 11111 exit: 11112 SOC_FUNC_RETURN; 11113 11114 } 11115 #endif /* CPRIMOD_SUPPORT */ 11116 11117 11118 #ifdef CPRIMOD_SUPPORT 11119 int portmod_cpri_port_roe_encap_macda_entry_get(int unit, int port, uint32 index, cprimod_mac_addr_t mac_addr) 11120 { 11121 11122 portmod_dispatch_type_t __type__; 11123 int __rv__; 11124 SOC_INIT_FUNC_DEFS; 11125 11126 /* Dispatch */ 11127 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11128 if(__type__ >= portmodDispatchTypeCount) { 11129 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11130 } 11131 11132 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macda_entry_get) { 11133 pm_info_t pm_info; 11134 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11135 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macda_entry_get(unit, port, pm_info, index, mac_addr); 11136 _SOC_IF_ERR_EXIT(__rv__); 11137 } else { 11138 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_roe_encap_macda_entry_get isn't implemented for driver type")); 11139 } 11140 11141 exit: 11142 SOC_FUNC_RETURN; 11143 11144 } 11145 #endif /* CPRIMOD_SUPPORT */ 11146 11147 11148 #ifdef CPRIMOD_SUPPORT 11149 int portmod_cpri_port_roe_encap_macsa_entry_set(int unit, int port, uint32 index, cprimod_mac_addr_t mac_addr) 11150 { 11151 11152 portmod_dispatch_type_t __type__; 11153 int __rv__; 11154 SOC_INIT_FUNC_DEFS; 11155 11156 /* Dispatch */ 11157 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11158 if(__type__ >= portmodDispatchTypeCount) { 11159 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11160 } 11161 11162 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macsa_entry_set) { 11163 pm_info_t pm_info; 11164 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11165 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macsa_entry_set(unit, port, pm_info, index, mac_addr); 11166 _SOC_IF_ERR_EXIT(__rv__); 11167 } else { 11168 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_roe_encap_macsa_entry_set isn't implemented for driver type")); 11169 } 11170 11171 exit: 11172 SOC_FUNC_RETURN; 11173 11174 } 11175 #endif /* CPRIMOD_SUPPORT */ 11176 11177 11178 #ifdef CPRIMOD_SUPPORT 11179 int portmod_cpri_port_roe_encap_macsa_entry_get(int unit, int port, uint32 index, cprimod_mac_addr_t mac_addr) 11180 { 11181 11182 portmod_dispatch_type_t __type__; 11183 int __rv__; 11184 SOC_INIT_FUNC_DEFS; 11185 11186 /* Dispatch */ 11187 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11188 if(__type__ >= portmodDispatchTypeCount) { 11189 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11190 } 11191 11192 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macsa_entry_get) { 11193 pm_info_t pm_info; 11194 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11195 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_macsa_entry_get(unit, port, pm_info, index, mac_addr); 11196 _SOC_IF_ERR_EXIT(__rv__); 11197 } else { 11198 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_roe_encap_macsa_entry_get isn't implemented for driver type")); 11199 } 11200 11201 exit: 11202 SOC_FUNC_RETURN; 11203 11204 } 11205 #endif /* CPRIMOD_SUPPORT */ 11206 11207 11208 #ifdef CPRIMOD_SUPPORT 11209 int portmod_cpri_port_roe_encap_vlan_entry_set(int unit, int port, uint32 index, cprimod_vlan_table_id_t table_id, uint32 vlan_id) 11210 { 11211 11212 portmod_dispatch_type_t __type__; 11213 int __rv__; 11214 SOC_INIT_FUNC_DEFS; 11215 11216 /* Dispatch */ 11217 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11218 if(__type__ >= portmodDispatchTypeCount) { 11219 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11220 } 11221 11222 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_vlan_entry_set) { 11223 pm_info_t pm_info; 11224 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11225 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_vlan_entry_set(unit, port, pm_info, index, table_id, vlan_id); 11226 _SOC_IF_ERR_EXIT(__rv__); 11227 } else { 11228 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_roe_encap_vlan_entry_set isn't implemented for driver type")); 11229 } 11230 11231 exit: 11232 SOC_FUNC_RETURN; 11233 11234 } 11235 #endif /* CPRIMOD_SUPPORT */ 11236 11237 11238 #ifdef CPRIMOD_SUPPORT 11239 int portmod_cpri_port_roe_encap_vlan_entry_get(int unit, int port, uint32 index, cprimod_vlan_table_id_t table_id, uint32* vlan_id) 11240 { 11241 11242 portmod_dispatch_type_t __type__; 11243 int __rv__; 11244 SOC_INIT_FUNC_DEFS; 11245 11246 if(vlan_id == NULL) { 11247 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vlan_id NULL parameter")); 11248 } 11249 /* Dispatch */ 11250 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11251 if(__type__ >= portmodDispatchTypeCount) { 11252 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11253 } 11254 11255 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_vlan_entry_get) { 11256 pm_info_t pm_info; 11257 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11258 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_roe_encap_vlan_entry_get(unit, port, pm_info, index, table_id, vlan_id); 11259 _SOC_IF_ERR_EXIT(__rv__); 11260 } else { 11261 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_roe_encap_vlan_entry_get isn't implemented for driver type")); 11262 } 11263 11264 exit: 11265 SOC_FUNC_RETURN; 11266 11267 } 11268 #endif /* CPRIMOD_SUPPORT */ 11269 11270 11271 #ifdef CPRIMOD_SUPPORT 11272 int portmod_cpri_port_decap_ethertype_config_set(int unit, int port, cprimod_ethertype_t pkt_type, uint16 ethtype) 11273 { 11274 11275 portmod_dispatch_type_t __type__; 11276 int __rv__; 11277 SOC_INIT_FUNC_DEFS; 11278 11279 /* Dispatch */ 11280 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11281 if(__type__ >= portmodDispatchTypeCount) { 11282 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11283 } 11284 11285 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_ethertype_config_set) { 11286 pm_info_t pm_info; 11287 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11288 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_ethertype_config_set(unit, port, pm_info, pkt_type, ethtype); 11289 _SOC_IF_ERR_EXIT(__rv__); 11290 } else { 11291 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_ethertype_config_set isn't implemented for driver type")); 11292 } 11293 11294 exit: 11295 SOC_FUNC_RETURN; 11296 11297 } 11298 #endif /* CPRIMOD_SUPPORT */ 11299 11300 11301 #ifdef CPRIMOD_SUPPORT 11302 int portmod_cpri_port_decap_ethertype_config_get(int unit, int port, cprimod_ethertype_t pkt_type, uint16* ethtype) 11303 { 11304 11305 portmod_dispatch_type_t __type__; 11306 int __rv__; 11307 SOC_INIT_FUNC_DEFS; 11308 11309 if(ethtype == NULL) { 11310 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ethtype NULL parameter")); 11311 } 11312 /* Dispatch */ 11313 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11314 if(__type__ >= portmodDispatchTypeCount) { 11315 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11316 } 11317 11318 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_ethertype_config_get) { 11319 pm_info_t pm_info; 11320 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11321 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_ethertype_config_get(unit, port, pm_info, pkt_type, ethtype); 11322 _SOC_IF_ERR_EXIT(__rv__); 11323 } else { 11324 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_ethertype_config_get isn't implemented for driver type")); 11325 } 11326 11327 exit: 11328 SOC_FUNC_RETURN; 11329 11330 } 11331 #endif /* CPRIMOD_SUPPORT */ 11332 11333 11334 #ifdef CPRIMOD_SUPPORT 11335 int portmod_cpri_port_encap_ethertype_config_set(int unit, int port, cprimod_ethertype_t pkt_type, uint16 ethtype) 11336 { 11337 11338 portmod_dispatch_type_t __type__; 11339 int __rv__; 11340 SOC_INIT_FUNC_DEFS; 11341 11342 /* Dispatch */ 11343 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11344 if(__type__ >= portmodDispatchTypeCount) { 11345 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11346 } 11347 11348 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_ethertype_config_set) { 11349 pm_info_t pm_info; 11350 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11351 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_ethertype_config_set(unit, port, pm_info, pkt_type, ethtype); 11352 _SOC_IF_ERR_EXIT(__rv__); 11353 } else { 11354 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_ethertype_config_set isn't implemented for driver type")); 11355 } 11356 11357 exit: 11358 SOC_FUNC_RETURN; 11359 11360 } 11361 #endif /* CPRIMOD_SUPPORT */ 11362 11363 11364 #ifdef CPRIMOD_SUPPORT 11365 int portmod_cpri_port_encap_ethertype_config_get(int unit, int port, cprimod_ethertype_t pkt_type, uint16* ethtype) 11366 { 11367 11368 portmod_dispatch_type_t __type__; 11369 int __rv__; 11370 SOC_INIT_FUNC_DEFS; 11371 11372 if(ethtype == NULL) { 11373 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ethtype NULL parameter")); 11374 } 11375 /* Dispatch */ 11376 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11377 if(__type__ >= portmodDispatchTypeCount) { 11378 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11379 } 11380 11381 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_ethertype_config_get) { 11382 pm_info_t pm_info; 11383 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11384 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_ethertype_config_get(unit, port, pm_info, pkt_type, ethtype); 11385 _SOC_IF_ERR_EXIT(__rv__); 11386 } else { 11387 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_ethertype_config_get isn't implemented for driver type")); 11388 } 11389 11390 exit: 11391 SOC_FUNC_RETURN; 11392 11393 } 11394 #endif /* CPRIMOD_SUPPORT */ 11395 11396 11397 #ifdef CPRIMOD_SUPPORT 11398 int portmod_cpri_port_decap_flow_config_set(int unit, int port, uint8 roe_subtype, uint32 queue_num, cprimod_cls_option_t cls_option, cprimod_cls_flow_type_t flow_type) 11399 { 11400 11401 portmod_dispatch_type_t __type__; 11402 int __rv__; 11403 SOC_INIT_FUNC_DEFS; 11404 11405 /* Dispatch */ 11406 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11407 if(__type__ >= portmodDispatchTypeCount) { 11408 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11409 } 11410 11411 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_config_set) { 11412 pm_info_t pm_info; 11413 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11414 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_config_set(unit, port, pm_info, roe_subtype, queue_num, cls_option, flow_type); 11415 _SOC_IF_ERR_EXIT(__rv__); 11416 } else { 11417 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_flow_config_set isn't implemented for driver type")); 11418 } 11419 11420 exit: 11421 SOC_FUNC_RETURN; 11422 11423 } 11424 #endif /* CPRIMOD_SUPPORT */ 11425 11426 11427 #ifdef CPRIMOD_SUPPORT 11428 int portmod_cpri_port_decap_flow_config_get(int unit, int port, uint8 roe_subtype, uint32* queue_num, cprimod_cls_option_t* cls_option, cprimod_cls_flow_type_t* flow_type) 11429 { 11430 11431 portmod_dispatch_type_t __type__; 11432 int __rv__; 11433 SOC_INIT_FUNC_DEFS; 11434 11435 if(queue_num == NULL) { 11436 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("queue_num NULL parameter")); 11437 } 11438 if(cls_option == NULL) { 11439 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cls_option NULL parameter")); 11440 } 11441 if(flow_type == NULL) { 11442 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("flow_type NULL parameter")); 11443 } 11444 /* Dispatch */ 11445 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11446 if(__type__ >= portmodDispatchTypeCount) { 11447 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11448 } 11449 11450 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_config_get) { 11451 pm_info_t pm_info; 11452 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11453 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_config_get(unit, port, pm_info, roe_subtype, queue_num, cls_option, flow_type); 11454 _SOC_IF_ERR_EXIT(__rv__); 11455 } else { 11456 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_flow_config_get isn't implemented for driver type")); 11457 } 11458 11459 exit: 11460 SOC_FUNC_RETURN; 11461 11462 } 11463 #endif /* CPRIMOD_SUPPORT */ 11464 11465 11466 #ifdef CPRIMOD_SUPPORT 11467 int portmod_cpri_port_decap_queue_to_ordering_info_index_set(int unit, int port, uint32 queue_num, uint32 ordering_info_index) 11468 { 11469 11470 portmod_dispatch_type_t __type__; 11471 int __rv__; 11472 SOC_INIT_FUNC_DEFS; 11473 11474 /* Dispatch */ 11475 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11476 if(__type__ >= portmodDispatchTypeCount) { 11477 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11478 } 11479 11480 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_to_ordering_info_index_set) { 11481 pm_info_t pm_info; 11482 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11483 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_to_ordering_info_index_set(unit, port, pm_info, queue_num, ordering_info_index); 11484 _SOC_IF_ERR_EXIT(__rv__); 11485 } else { 11486 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_queue_to_ordering_info_index_set isn't implemented for driver type")); 11487 } 11488 11489 exit: 11490 SOC_FUNC_RETURN; 11491 11492 } 11493 #endif /* CPRIMOD_SUPPORT */ 11494 11495 11496 #ifdef CPRIMOD_SUPPORT 11497 int portmod_cpri_port_decap_queue_to_ordering_info_index_get(int unit, int port, uint32 queue_num, uint32* ordering_info_index) 11498 { 11499 11500 portmod_dispatch_type_t __type__; 11501 int __rv__; 11502 SOC_INIT_FUNC_DEFS; 11503 11504 if(ordering_info_index == NULL) { 11505 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ordering_info_index NULL parameter")); 11506 } 11507 /* Dispatch */ 11508 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11509 if(__type__ >= portmodDispatchTypeCount) { 11510 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11511 } 11512 11513 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_to_ordering_info_index_get) { 11514 pm_info_t pm_info; 11515 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11516 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_to_ordering_info_index_get(unit, port, pm_info, queue_num, ordering_info_index); 11517 _SOC_IF_ERR_EXIT(__rv__); 11518 } else { 11519 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_queue_to_ordering_info_index_get isn't implemented for driver type")); 11520 } 11521 11522 exit: 11523 SOC_FUNC_RETURN; 11524 11525 } 11526 #endif /* CPRIMOD_SUPPORT */ 11527 11528 11529 #ifdef CPRIMOD_SUPPORT 11530 int portmod_cpri_port_decap_flow_to_queue_mapping_set(int unit, int port, uint32 flow_id, uint32 queue_num) 11531 { 11532 11533 portmod_dispatch_type_t __type__; 11534 int __rv__; 11535 SOC_INIT_FUNC_DEFS; 11536 11537 /* Dispatch */ 11538 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11539 if(__type__ >= portmodDispatchTypeCount) { 11540 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11541 } 11542 11543 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_to_queue_mapping_set) { 11544 pm_info_t pm_info; 11545 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11546 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_to_queue_mapping_set(unit, port, pm_info, flow_id, queue_num); 11547 _SOC_IF_ERR_EXIT(__rv__); 11548 } else { 11549 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_flow_to_queue_mapping_set isn't implemented for driver type")); 11550 } 11551 11552 exit: 11553 SOC_FUNC_RETURN; 11554 11555 } 11556 #endif /* CPRIMOD_SUPPORT */ 11557 11558 11559 #ifdef CPRIMOD_SUPPORT 11560 int portmod_cpri_port_decap_flow_to_queue_mapping_get(int unit, int port, uint32 flow_id, uint32* queue_num) 11561 { 11562 11563 portmod_dispatch_type_t __type__; 11564 int __rv__; 11565 SOC_INIT_FUNC_DEFS; 11566 11567 if(queue_num == NULL) { 11568 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("queue_num NULL parameter")); 11569 } 11570 /* Dispatch */ 11571 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11572 if(__type__ >= portmodDispatchTypeCount) { 11573 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11574 } 11575 11576 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_to_queue_mapping_get) { 11577 pm_info_t pm_info; 11578 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11579 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_flow_to_queue_mapping_get(unit, port, pm_info, flow_id, queue_num); 11580 _SOC_IF_ERR_EXIT(__rv__); 11581 } else { 11582 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_flow_to_queue_mapping_get isn't implemented for driver type")); 11583 } 11584 11585 exit: 11586 SOC_FUNC_RETURN; 11587 11588 } 11589 #endif /* CPRIMOD_SUPPORT */ 11590 11591 11592 #ifdef CPRIMOD_SUPPORT 11593 int portmod_cpri_port_decap_roe_ordering_info_set(int unit, int port, uint32 index, const cprimod_decap_ordering_info_entry_t* config) 11594 { 11595 11596 portmod_dispatch_type_t __type__; 11597 int __rv__; 11598 SOC_INIT_FUNC_DEFS; 11599 11600 /* Dispatch */ 11601 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11602 if(__type__ >= portmodDispatchTypeCount) { 11603 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11604 } 11605 11606 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_info_set) { 11607 pm_info_t pm_info; 11608 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11609 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_info_set(unit, port, pm_info, index, config); 11610 _SOC_IF_ERR_EXIT(__rv__); 11611 } else { 11612 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_roe_ordering_info_set isn't implemented for driver type")); 11613 } 11614 11615 exit: 11616 SOC_FUNC_RETURN; 11617 11618 } 11619 #endif /* CPRIMOD_SUPPORT */ 11620 11621 11622 #ifdef CPRIMOD_SUPPORT 11623 int portmod_cpri_port_decap_roe_ordering_info_get(int unit, int port, uint32 index, cprimod_decap_ordering_info_entry_t* config) 11624 { 11625 11626 portmod_dispatch_type_t __type__; 11627 int __rv__; 11628 SOC_INIT_FUNC_DEFS; 11629 11630 if(config == NULL) { 11631 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 11632 } 11633 /* Dispatch */ 11634 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11635 if(__type__ >= portmodDispatchTypeCount) { 11636 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11637 } 11638 11639 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_info_get) { 11640 pm_info_t pm_info; 11641 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11642 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_info_get(unit, port, pm_info, index, config); 11643 _SOC_IF_ERR_EXIT(__rv__); 11644 } else { 11645 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_roe_ordering_info_get isn't implemented for driver type")); 11646 } 11647 11648 exit: 11649 SOC_FUNC_RETURN; 11650 11651 } 11652 #endif /* CPRIMOD_SUPPORT */ 11653 11654 11655 #ifdef CPRIMOD_SUPPORT 11656 int portmod_cpri_port_decap_roe_ordering_sequence_offset_set(int unit, int port, uint32 queue_num, const cprimod_cpri_ordering_info_offset_t* config) 11657 { 11658 11659 portmod_dispatch_type_t __type__; 11660 int __rv__; 11661 SOC_INIT_FUNC_DEFS; 11662 11663 /* Dispatch */ 11664 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11665 if(__type__ >= portmodDispatchTypeCount) { 11666 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11667 } 11668 11669 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_sequence_offset_set) { 11670 pm_info_t pm_info; 11671 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11672 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_sequence_offset_set(unit, port, pm_info, queue_num, config); 11673 _SOC_IF_ERR_EXIT(__rv__); 11674 } else { 11675 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_roe_ordering_sequence_offset_set isn't implemented for driver type")); 11676 } 11677 11678 exit: 11679 SOC_FUNC_RETURN; 11680 11681 } 11682 #endif /* CPRIMOD_SUPPORT */ 11683 11684 11685 #ifdef CPRIMOD_SUPPORT 11686 int portmod_cpri_port_decap_roe_ordering_sequence_offset_get(int unit, int port, uint32 queue_num, cprimod_cpri_ordering_info_offset_t* config) 11687 { 11688 11689 portmod_dispatch_type_t __type__; 11690 int __rv__; 11691 SOC_INIT_FUNC_DEFS; 11692 11693 if(config == NULL) { 11694 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 11695 } 11696 /* Dispatch */ 11697 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11698 if(__type__ >= portmodDispatchTypeCount) { 11699 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11700 } 11701 11702 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_sequence_offset_get) { 11703 pm_info_t pm_info; 11704 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11705 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_roe_ordering_sequence_offset_get(unit, port, pm_info, queue_num, config); 11706 _SOC_IF_ERR_EXIT(__rv__); 11707 } else { 11708 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_roe_ordering_sequence_offset_get isn't implemented for driver type")); 11709 } 11710 11711 exit: 11712 SOC_FUNC_RETURN; 11713 11714 } 11715 #endif /* CPRIMOD_SUPPORT */ 11716 11717 11718 #ifdef CPRIMOD_SUPPORT 11719 int portmod_tx_frame_tgen_config_t_validate(int unit, const portmod_tx_frame_tgen_config_t* portmod_tx_frame_tgen_config) 11720 { 11721 SOC_INIT_FUNC_DEFS; 11722 if(portmod_tx_frame_tgen_config == NULL) { 11723 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 11724 } 11725 11726 11727 11728 exit: 11729 SOC_FUNC_RETURN; 11730 11731 } 11732 #endif /* CPRIMOD_SUPPORT */ 11733 11734 #ifdef CPRIMOD_SUPPORT 11735 int portmod_tx_frame_tgen_config_t_init(int unit, portmod_tx_frame_tgen_config_t* portmod_tx_frame_tgen_config) 11736 { 11737 SOC_INIT_FUNC_DEFS; 11738 11739 if(portmod_tx_frame_tgen_config == NULL){ 11740 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_tx_frame_tgen_config NULL parameter")); 11741 } 11742 sal_memset(portmod_tx_frame_tgen_config, 0, sizeof(portmod_tx_frame_tgen_config_t)); 11743 11744 11745 exit: 11746 SOC_FUNC_RETURN; 11747 11748 } 11749 #endif /* CPRIMOD_SUPPORT */ 11750 11751 #ifdef CPRIMOD_SUPPORT 11752 int portmod_cpri_port_tx_frame_tgen_config_set(int unit, int port, const portmod_tx_frame_tgen_config_t* config) 11753 { 11754 11755 portmod_dispatch_type_t __type__; 11756 int __rv__; 11757 SOC_INIT_FUNC_DEFS; 11758 11759 if(SOC_E_NONE != portmod_tx_frame_tgen_config_t_validate(unit, config)) { 11760 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 11761 } 11762 11763 /* Dispatch */ 11764 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11765 if(__type__ >= portmodDispatchTypeCount) { 11766 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11767 } 11768 11769 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_config_set) { 11770 pm_info_t pm_info; 11771 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11772 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_config_set(unit, port, pm_info, config); 11773 _SOC_IF_ERR_EXIT(__rv__); 11774 } else { 11775 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_tgen_config_set isn't implemented for driver type")); 11776 } 11777 11778 exit: 11779 SOC_FUNC_RETURN; 11780 11781 } 11782 #endif /* CPRIMOD_SUPPORT */ 11783 11784 11785 #ifdef CPRIMOD_SUPPORT 11786 int portmod_cpri_port_tx_frame_tgen_config_get(int unit, int port, portmod_tx_frame_tgen_config_t* config) 11787 { 11788 11789 portmod_dispatch_type_t __type__; 11790 int __rv__; 11791 SOC_INIT_FUNC_DEFS; 11792 11793 if(config == NULL) { 11794 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 11795 } 11796 if(SOC_E_NONE != portmod_tx_frame_tgen_config_t_init(unit, config)) { 11797 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config initialization failed")); 11798 } 11799 11800 /* Dispatch */ 11801 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11802 if(__type__ >= portmodDispatchTypeCount) { 11803 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11804 } 11805 11806 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_config_get) { 11807 pm_info_t pm_info; 11808 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11809 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_config_get(unit, port, pm_info, config); 11810 _SOC_IF_ERR_EXIT(__rv__); 11811 } else { 11812 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_tgen_config_get isn't implemented for driver type")); 11813 } 11814 11815 exit: 11816 SOC_FUNC_RETURN; 11817 11818 } 11819 #endif /* CPRIMOD_SUPPORT */ 11820 11821 11822 #ifdef CPRIMOD_SUPPORT 11823 int portmod_cpri_port_tx_frame_tgen_enable(int unit, int port, uint32 enable) 11824 { 11825 11826 portmod_dispatch_type_t __type__; 11827 int __rv__; 11828 SOC_INIT_FUNC_DEFS; 11829 11830 /* Dispatch */ 11831 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11832 if(__type__ >= portmodDispatchTypeCount) { 11833 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11834 } 11835 11836 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_enable) { 11837 pm_info_t pm_info; 11838 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11839 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_enable(unit, port, pm_info, enable); 11840 _SOC_IF_ERR_EXIT(__rv__); 11841 } else { 11842 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_tgen_enable isn't implemented for driver type")); 11843 } 11844 11845 exit: 11846 SOC_FUNC_RETURN; 11847 11848 } 11849 #endif /* CPRIMOD_SUPPORT */ 11850 11851 11852 #ifdef CPRIMOD_SUPPORT 11853 int portmod_cpri_port_tx_frame_tgen_ts_offset_set(int unit, int port, uint64 offset) 11854 { 11855 11856 portmod_dispatch_type_t __type__; 11857 int __rv__; 11858 SOC_INIT_FUNC_DEFS; 11859 11860 /* Dispatch */ 11861 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11862 if(__type__ >= portmodDispatchTypeCount) { 11863 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11864 } 11865 11866 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_ts_offset_set) { 11867 pm_info_t pm_info; 11868 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11869 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_ts_offset_set(unit, port, pm_info, offset); 11870 _SOC_IF_ERR_EXIT(__rv__); 11871 } else { 11872 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_tgen_ts_offset_set isn't implemented for driver type")); 11873 } 11874 11875 exit: 11876 SOC_FUNC_RETURN; 11877 11878 } 11879 #endif /* CPRIMOD_SUPPORT */ 11880 11881 11882 #ifdef CPRIMOD_SUPPORT 11883 int portmod_cpri_port_tx_frame_tgen_ts_offset_get(int unit, int port, uint64* offset) 11884 { 11885 11886 portmod_dispatch_type_t __type__; 11887 int __rv__; 11888 SOC_INIT_FUNC_DEFS; 11889 11890 if(offset == NULL) { 11891 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("offset NULL parameter")); 11892 } 11893 /* Dispatch */ 11894 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11895 if(__type__ >= portmodDispatchTypeCount) { 11896 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11897 } 11898 11899 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_ts_offset_get) { 11900 pm_info_t pm_info; 11901 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11902 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_tgen_ts_offset_get(unit, port, pm_info, offset); 11903 _SOC_IF_ERR_EXIT(__rv__); 11904 } else { 11905 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_tgen_ts_offset_get isn't implemented for driver type")); 11906 } 11907 11908 exit: 11909 SOC_FUNC_RETURN; 11910 11911 } 11912 #endif /* CPRIMOD_SUPPORT */ 11913 11914 11915 #ifdef CPRIMOD_SUPPORT 11916 int portmod_cpri_port_tx_frame_next_hfn_get(int unit, int port, uint32* hfn) 11917 { 11918 11919 portmod_dispatch_type_t __type__; 11920 int __rv__; 11921 SOC_INIT_FUNC_DEFS; 11922 11923 if(hfn == NULL) { 11924 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("hfn NULL parameter")); 11925 } 11926 /* Dispatch */ 11927 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11928 if(__type__ >= portmodDispatchTypeCount) { 11929 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11930 } 11931 11932 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_next_hfn_get) { 11933 pm_info_t pm_info; 11934 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11935 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_next_hfn_get(unit, port, pm_info, hfn); 11936 _SOC_IF_ERR_EXIT(__rv__); 11937 } else { 11938 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_next_hfn_get isn't implemented for driver type")); 11939 } 11940 11941 exit: 11942 SOC_FUNC_RETURN; 11943 11944 } 11945 #endif /* CPRIMOD_SUPPORT */ 11946 11947 11948 #ifdef CPRIMOD_SUPPORT 11949 int portmod_cpri_port_tx_frame_next_bfn_get(int unit, int port, uint32* bfn) 11950 { 11951 11952 portmod_dispatch_type_t __type__; 11953 int __rv__; 11954 SOC_INIT_FUNC_DEFS; 11955 11956 if(bfn == NULL) { 11957 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn NULL parameter")); 11958 } 11959 /* Dispatch */ 11960 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 11961 if(__type__ >= portmodDispatchTypeCount) { 11962 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 11963 } 11964 11965 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_next_bfn_get) { 11966 pm_info_t pm_info; 11967 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 11968 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_frame_next_bfn_get(unit, port, pm_info, bfn); 11969 _SOC_IF_ERR_EXIT(__rv__); 11970 } else { 11971 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_frame_next_bfn_get isn't implemented for driver type")); 11972 } 11973 11974 exit: 11975 SOC_FUNC_RETURN; 11976 11977 } 11978 #endif /* CPRIMOD_SUPPORT */ 11979 11980 11981 #ifdef CPRIMOD_SUPPORT 11982 int portmod_rsvd4_rx_flow_info_t_validate(int unit, const portmod_rsvd4_rx_flow_info_t* portmod_rsvd4_rx_flow_info) 11983 { 11984 SOC_INIT_FUNC_DEFS; 11985 if(portmod_rsvd4_rx_flow_info == NULL) { 11986 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 11987 } 11988 11989 11990 11991 exit: 11992 SOC_FUNC_RETURN; 11993 11994 } 11995 #endif /* CPRIMOD_SUPPORT */ 11996 11997 #ifdef CPRIMOD_SUPPORT 11998 int portmod_rsvd4_rx_flow_info_t_init(int unit, portmod_rsvd4_rx_flow_info_t* portmod_rsvd4_rx_flow_info) 11999 { 12000 SOC_INIT_FUNC_DEFS; 12001 12002 if(portmod_rsvd4_rx_flow_info == NULL){ 12003 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_rsvd4_rx_flow_info NULL parameter")); 12004 } 12005 sal_memset(portmod_rsvd4_rx_flow_info, 0, sizeof(portmod_rsvd4_rx_flow_info_t)); 12006 12007 12008 exit: 12009 SOC_FUNC_RETURN; 12010 12011 } 12012 #endif /* CPRIMOD_SUPPORT */ 12013 12014 #ifdef CPRIMOD_SUPPORT 12015 int portmod_rsvd4_tx_flow_info_t_validate(int unit, const portmod_rsvd4_tx_flow_info_t* portmod_rsvd4_tx_flow_info) 12016 { 12017 SOC_INIT_FUNC_DEFS; 12018 if(portmod_rsvd4_tx_flow_info == NULL) { 12019 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 12020 } 12021 12022 12023 12024 exit: 12025 SOC_FUNC_RETURN; 12026 12027 } 12028 #endif /* CPRIMOD_SUPPORT */ 12029 12030 #ifdef CPRIMOD_SUPPORT 12031 int portmod_rsvd4_tx_flow_info_t_init(int unit, portmod_rsvd4_tx_flow_info_t* portmod_rsvd4_tx_flow_info) 12032 { 12033 SOC_INIT_FUNC_DEFS; 12034 12035 if(portmod_rsvd4_tx_flow_info == NULL){ 12036 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_rsvd4_tx_flow_info NULL parameter")); 12037 } 12038 sal_memset(portmod_rsvd4_tx_flow_info, 0, sizeof(portmod_rsvd4_tx_flow_info_t)); 12039 12040 12041 exit: 12042 SOC_FUNC_RETURN; 12043 12044 } 12045 #endif /* CPRIMOD_SUPPORT */ 12046 12047 #ifdef CPRIMOD_SUPPORT 12048 int portmod_cpri_port_rsvd4_rx_flow_add(int unit, int port, uint32 flow_id, const portmod_rsvd4_rx_flow_info_t* info) 12049 { 12050 12051 portmod_dispatch_type_t __type__; 12052 int __rv__; 12053 SOC_INIT_FUNC_DEFS; 12054 12055 if(SOC_E_NONE != portmod_rsvd4_rx_flow_info_t_validate(unit, info)) { 12056 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("info validation failed")); 12057 } 12058 12059 /* Dispatch */ 12060 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12061 if(__type__ >= portmodDispatchTypeCount) { 12062 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12063 } 12064 12065 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_flow_add) { 12066 pm_info_t pm_info; 12067 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12068 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_flow_add(unit, port, pm_info, flow_id, info); 12069 _SOC_IF_ERR_EXIT(__rv__); 12070 } else { 12071 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_rx_flow_add isn't implemented for driver type")); 12072 } 12073 12074 exit: 12075 SOC_FUNC_RETURN; 12076 12077 } 12078 #endif /* CPRIMOD_SUPPORT */ 12079 12080 12081 #ifdef CPRIMOD_SUPPORT 12082 int portmod_cpri_port_rsvd4_rx_flow_delete(int unit, int port, uint32 flow_id) 12083 { 12084 12085 portmod_dispatch_type_t __type__; 12086 int __rv__; 12087 SOC_INIT_FUNC_DEFS; 12088 12089 /* Dispatch */ 12090 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12091 if(__type__ >= portmodDispatchTypeCount) { 12092 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12093 } 12094 12095 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_flow_delete) { 12096 pm_info_t pm_info; 12097 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12098 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_flow_delete(unit, port, pm_info, flow_id); 12099 _SOC_IF_ERR_EXIT(__rv__); 12100 } else { 12101 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_rx_flow_delete isn't implemented for driver type")); 12102 } 12103 12104 exit: 12105 SOC_FUNC_RETURN; 12106 12107 } 12108 #endif /* CPRIMOD_SUPPORT */ 12109 12110 12111 #ifdef CPRIMOD_SUPPORT 12112 int portmod_cpri_port_rsvd4_tx_flow_add(int unit, int port, uint32 flow_id, const portmod_rsvd4_tx_flow_info_t* info) 12113 { 12114 12115 portmod_dispatch_type_t __type__; 12116 int __rv__; 12117 SOC_INIT_FUNC_DEFS; 12118 12119 if(SOC_E_NONE != portmod_rsvd4_tx_flow_info_t_validate(unit, info)) { 12120 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("info validation failed")); 12121 } 12122 12123 /* Dispatch */ 12124 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12125 if(__type__ >= portmodDispatchTypeCount) { 12126 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12127 } 12128 12129 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_flow_add) { 12130 pm_info_t pm_info; 12131 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12132 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_flow_add(unit, port, pm_info, flow_id, info); 12133 _SOC_IF_ERR_EXIT(__rv__); 12134 } else { 12135 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_tx_flow_add isn't implemented for driver type")); 12136 } 12137 12138 exit: 12139 SOC_FUNC_RETURN; 12140 12141 } 12142 #endif /* CPRIMOD_SUPPORT */ 12143 12144 12145 #ifdef CPRIMOD_SUPPORT 12146 int portmod_cpri_port_rsvd4_tx_flow_delete(int unit, int port, uint32 flow_id) 12147 { 12148 12149 portmod_dispatch_type_t __type__; 12150 int __rv__; 12151 SOC_INIT_FUNC_DEFS; 12152 12153 /* Dispatch */ 12154 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12155 if(__type__ >= portmodDispatchTypeCount) { 12156 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12157 } 12158 12159 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_flow_delete) { 12160 pm_info_t pm_info; 12161 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12162 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_tx_flow_delete(unit, port, pm_info, flow_id); 12163 _SOC_IF_ERR_EXIT(__rv__); 12164 } else { 12165 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_tx_flow_delete isn't implemented for driver type")); 12166 } 12167 12168 exit: 12169 SOC_FUNC_RETURN; 12170 12171 } 12172 #endif /* CPRIMOD_SUPPORT */ 12173 12174 12175 #ifdef CPRIMOD_SUPPORT 12176 int portmod_cpri_port_rsvd4_dbm_entry_set(int unit, int port, uint32 profile_id, const cprimod_dbm_rule_entry_t* profile) 12177 { 12178 12179 portmod_dispatch_type_t __type__; 12180 int __rv__; 12181 SOC_INIT_FUNC_DEFS; 12182 12183 /* Dispatch */ 12184 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12185 if(__type__ >= portmodDispatchTypeCount) { 12186 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12187 } 12188 12189 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_entry_set) { 12190 pm_info_t pm_info; 12191 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12192 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_entry_set(unit, port, pm_info, profile_id, profile); 12193 _SOC_IF_ERR_EXIT(__rv__); 12194 } else { 12195 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_dbm_entry_set isn't implemented for driver type")); 12196 } 12197 12198 exit: 12199 SOC_FUNC_RETURN; 12200 12201 } 12202 #endif /* CPRIMOD_SUPPORT */ 12203 12204 12205 #ifdef CPRIMOD_SUPPORT 12206 int portmod_cpri_port_rsvd4_dbm_entry_get(int unit, int port, uint32 profile_id, cprimod_dbm_rule_entry_t* profile) 12207 { 12208 12209 portmod_dispatch_type_t __type__; 12210 int __rv__; 12211 SOC_INIT_FUNC_DEFS; 12212 12213 if(profile == NULL) { 12214 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("profile NULL parameter")); 12215 } 12216 /* Dispatch */ 12217 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12218 if(__type__ >= portmodDispatchTypeCount) { 12219 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12220 } 12221 12222 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_entry_get) { 12223 pm_info_t pm_info; 12224 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12225 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_entry_get(unit, port, pm_info, profile_id, profile); 12226 _SOC_IF_ERR_EXIT(__rv__); 12227 } else { 12228 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_dbm_entry_get isn't implemented for driver type")); 12229 } 12230 12231 exit: 12232 SOC_FUNC_RETURN; 12233 12234 } 12235 #endif /* CPRIMOD_SUPPORT */ 12236 12237 12238 #ifdef CPRIMOD_SUPPORT 12239 int portmod_cpri_port_rsvd4_secondary_dbm_entry_set(int unit, int port, uint32 profile_id, const cprimod_secondary_dbm_rule_entry_t* profile) 12240 { 12241 12242 portmod_dispatch_type_t __type__; 12243 int __rv__; 12244 SOC_INIT_FUNC_DEFS; 12245 12246 /* Dispatch */ 12247 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12248 if(__type__ >= portmodDispatchTypeCount) { 12249 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12250 } 12251 12252 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_secondary_dbm_entry_set) { 12253 pm_info_t pm_info; 12254 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12255 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_secondary_dbm_entry_set(unit, port, pm_info, profile_id, profile); 12256 _SOC_IF_ERR_EXIT(__rv__); 12257 } else { 12258 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_secondary_dbm_entry_set isn't implemented for driver type")); 12259 } 12260 12261 exit: 12262 SOC_FUNC_RETURN; 12263 12264 } 12265 #endif /* CPRIMOD_SUPPORT */ 12266 12267 12268 #ifdef CPRIMOD_SUPPORT 12269 int portmod_cpri_port_rsvd4_secondary_dbm_entry_get(int unit, int port, uint32 profile_id, cprimod_secondary_dbm_rule_entry_t* profile) 12270 { 12271 12272 portmod_dispatch_type_t __type__; 12273 int __rv__; 12274 SOC_INIT_FUNC_DEFS; 12275 12276 if(profile == NULL) { 12277 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("profile NULL parameter")); 12278 } 12279 /* Dispatch */ 12280 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12281 if(__type__ >= portmodDispatchTypeCount) { 12282 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12283 } 12284 12285 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_secondary_dbm_entry_get) { 12286 pm_info_t pm_info; 12287 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12288 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_secondary_dbm_entry_get(unit, port, pm_info, profile_id, profile); 12289 _SOC_IF_ERR_EXIT(__rv__); 12290 } else { 12291 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_secondary_dbm_entry_get isn't implemented for driver type")); 12292 } 12293 12294 exit: 12295 SOC_FUNC_RETURN; 12296 12297 } 12298 #endif /* CPRIMOD_SUPPORT */ 12299 12300 12301 #ifdef CPRIMOD_SUPPORT 12302 int portmod_cpri_port_rsvd4_modulo_rule_entry_set(int unit, int port, uint32 modulo_rule_num, cprimod_transmission_rule_type_t modulo_rule_type, const cprimod_modulo_rule_entry_t* modulo_rule) 12303 { 12304 12305 portmod_dispatch_type_t __type__; 12306 int __rv__; 12307 SOC_INIT_FUNC_DEFS; 12308 12309 /* Dispatch */ 12310 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12311 if(__type__ >= portmodDispatchTypeCount) { 12312 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12313 } 12314 12315 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_modulo_rule_entry_set) { 12316 pm_info_t pm_info; 12317 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12318 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_modulo_rule_entry_set(unit, port, pm_info, modulo_rule_num, modulo_rule_type, modulo_rule); 12319 _SOC_IF_ERR_EXIT(__rv__); 12320 } else { 12321 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_modulo_rule_entry_set isn't implemented for driver type")); 12322 } 12323 12324 exit: 12325 SOC_FUNC_RETURN; 12326 12327 } 12328 #endif /* CPRIMOD_SUPPORT */ 12329 12330 12331 #ifdef CPRIMOD_SUPPORT 12332 int portmod_cpri_port_rsvd4_modulo_rule_entry_get(int unit, int port, uint32 modulo_rule_num, cprimod_transmission_rule_type_t modulo_rule_type, cprimod_modulo_rule_entry_t* modulo_rule) 12333 { 12334 12335 portmod_dispatch_type_t __type__; 12336 int __rv__; 12337 SOC_INIT_FUNC_DEFS; 12338 12339 if(modulo_rule == NULL) { 12340 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("modulo_rule NULL parameter")); 12341 } 12342 /* Dispatch */ 12343 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12344 if(__type__ >= portmodDispatchTypeCount) { 12345 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12346 } 12347 12348 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_modulo_rule_entry_get) { 12349 pm_info_t pm_info; 12350 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12351 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_modulo_rule_entry_get(unit, port, pm_info, modulo_rule_num, modulo_rule_type, modulo_rule); 12352 _SOC_IF_ERR_EXIT(__rv__); 12353 } else { 12354 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_modulo_rule_entry_get isn't implemented for driver type")); 12355 } 12356 12357 exit: 12358 SOC_FUNC_RETURN; 12359 12360 } 12361 #endif /* CPRIMOD_SUPPORT */ 12362 12363 12364 #ifdef CPRIMOD_SUPPORT 12365 int portmod_cpri_port_rsvd4_dbm_position_entry_set(int unit, int port, uint32 index, const cprimod_dbm_pos_table_entry_t* pos_entry) 12366 { 12367 12368 portmod_dispatch_type_t __type__; 12369 int __rv__; 12370 SOC_INIT_FUNC_DEFS; 12371 12372 /* Dispatch */ 12373 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12374 if(__type__ >= portmodDispatchTypeCount) { 12375 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12376 } 12377 12378 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_position_entry_set) { 12379 pm_info_t pm_info; 12380 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12381 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_position_entry_set(unit, port, pm_info, index, pos_entry); 12382 _SOC_IF_ERR_EXIT(__rv__); 12383 } else { 12384 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_dbm_position_entry_set isn't implemented for driver type")); 12385 } 12386 12387 exit: 12388 SOC_FUNC_RETURN; 12389 12390 } 12391 #endif /* CPRIMOD_SUPPORT */ 12392 12393 12394 #ifdef CPRIMOD_SUPPORT 12395 int portmod_cpri_port_rsvd4_dbm_position_entry_get(int unit, int port, uint32 index, cprimod_dbm_pos_table_entry_t* pos_entry) 12396 { 12397 12398 portmod_dispatch_type_t __type__; 12399 int __rv__; 12400 SOC_INIT_FUNC_DEFS; 12401 12402 if(pos_entry == NULL) { 12403 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pos_entry NULL parameter")); 12404 } 12405 /* Dispatch */ 12406 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12407 if(__type__ >= portmodDispatchTypeCount) { 12408 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12409 } 12410 12411 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_position_entry_get) { 12412 pm_info_t pm_info; 12413 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12414 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_dbm_position_entry_get(unit, port, pm_info, index, pos_entry); 12415 _SOC_IF_ERR_EXIT(__rv__); 12416 } else { 12417 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_dbm_position_entry_get isn't implemented for driver type")); 12418 } 12419 12420 exit: 12421 SOC_FUNC_RETURN; 12422 12423 } 12424 #endif /* CPRIMOD_SUPPORT */ 12425 12426 12427 #ifdef CPRIMOD_SUPPORT 12428 int portmod_cpri_port_rsvd4_rx_master_frame_sync_config_set(int unit, int port, uint32 master_frame_number, uint64 master_frame_start_time) 12429 { 12430 12431 portmod_dispatch_type_t __type__; 12432 int __rv__; 12433 SOC_INIT_FUNC_DEFS; 12434 12435 /* Dispatch */ 12436 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12437 if(__type__ >= portmodDispatchTypeCount) { 12438 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12439 } 12440 12441 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_master_frame_sync_config_set) { 12442 pm_info_t pm_info; 12443 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12444 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_master_frame_sync_config_set(unit, port, pm_info, master_frame_number, master_frame_start_time); 12445 _SOC_IF_ERR_EXIT(__rv__); 12446 } else { 12447 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_rx_master_frame_sync_config_set isn't implemented for driver type")); 12448 } 12449 12450 exit: 12451 SOC_FUNC_RETURN; 12452 12453 } 12454 #endif /* CPRIMOD_SUPPORT */ 12455 12456 12457 #ifdef CPRIMOD_SUPPORT 12458 int portmod_cpri_port_rsvd4_rx_master_frame_sync_config_get(int unit, int port, uint32* master_frame_number, uint64* master_frame_start_time) 12459 { 12460 12461 portmod_dispatch_type_t __type__; 12462 int __rv__; 12463 SOC_INIT_FUNC_DEFS; 12464 12465 if(master_frame_number == NULL) { 12466 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("master_frame_number NULL parameter")); 12467 } 12468 if(master_frame_start_time == NULL) { 12469 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("master_frame_start_time NULL parameter")); 12470 } 12471 /* Dispatch */ 12472 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12473 if(__type__ >= portmodDispatchTypeCount) { 12474 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12475 } 12476 12477 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_master_frame_sync_config_get) { 12478 pm_info_t pm_info; 12479 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12480 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rsvd4_rx_master_frame_sync_config_get(unit, port, pm_info, master_frame_number, master_frame_start_time); 12481 _SOC_IF_ERR_EXIT(__rv__); 12482 } else { 12483 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rsvd4_rx_master_frame_sync_config_get isn't implemented for driver type")); 12484 } 12485 12486 exit: 12487 SOC_FUNC_RETURN; 12488 12489 } 12490 #endif /* CPRIMOD_SUPPORT */ 12491 12492 12493 int portmod_vcos_speed_config_t_validate(int unit, const portmod_vcos_speed_config_t* portmod_vcos_speed_config) 12494 { 12495 SOC_INIT_FUNC_DEFS; 12496 if(portmod_vcos_speed_config == NULL) { 12497 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 12498 } 12499 12500 if(SOC_E_NONE != portmod_core_port_enet_cpri_type_t_validate(unit, portmod_vcos_speed_config->port_type)) { 12501 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("port_type validation failed")); 12502 } 12503 12504 12505 12506 exit: 12507 SOC_FUNC_RETURN; 12508 12509 } 12510 12511 int portmod_vcos_speed_config_t_init(int unit, portmod_vcos_speed_config_t* portmod_vcos_speed_config) 12512 { 12513 SOC_INIT_FUNC_DEFS; 12514 12515 if(portmod_vcos_speed_config == NULL){ 12516 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_vcos_speed_config NULL parameter")); 12517 } 12518 sal_memset(portmod_vcos_speed_config, 0, sizeof(portmod_vcos_speed_config_t)); 12519 portmod_vcos_speed_config->num_lanes = 0; 12520 portmod_vcos_speed_config->ieee_mode = 0; 12521 portmod_vcos_speed_config->higig_mode = 0; 12522 portmod_vcos_speed_config->txpi_mode = 0; 12523 portmod_vcos_speed_config->eth_of_mixed_mode = 0; 12524 portmod_vcos_speed_config->port_type = 0; 12525 12526 12527 exit: 12528 SOC_FUNC_RETURN; 12529 12530 } 12531 12532 int portmod_dual_vcos_t_validate(int unit, const portmod_dual_vcos_t* portmod_dual_vcos) 12533 { 12534 SOC_INIT_FUNC_DEFS; 12535 if(portmod_dual_vcos == NULL) { 12536 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 12537 } 12538 12539 12540 12541 exit: 12542 SOC_FUNC_RETURN; 12543 12544 } 12545 12546 int portmod_dual_vcos_t_init(int unit, portmod_dual_vcos_t* portmod_dual_vcos) 12547 { 12548 SOC_INIT_FUNC_DEFS; 12549 12550 if(portmod_dual_vcos == NULL){ 12551 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_dual_vcos NULL parameter")); 12552 } 12553 sal_memset(portmod_dual_vcos, 0, sizeof(portmod_dual_vcos_t)); 12554 portmod_dual_vcos->vco_0 = 0; 12555 portmod_dual_vcos->vco_1 = 0; 12556 12557 12558 exit: 12559 SOC_FUNC_RETURN; 12560 12561 } 12562 12563 int portmod_port_vcos_get(int unit, int port, const portmod_vcos_speed_config_t* speed_config_list, int size, portmod_dual_vcos_t* dual_vco) 12564 { 12565 12566 portmod_dispatch_type_t __type__; 12567 int __rv__; 12568 SOC_INIT_FUNC_DEFS; 12569 12570 if(SOC_E_NONE != portmod_vcos_speed_config_t_validate(unit, speed_config_list)) { 12571 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config_list validation failed")); 12572 } 12573 12574 if(dual_vco == NULL) { 12575 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("dual_vco NULL parameter")); 12576 } 12577 if(SOC_E_NONE != portmod_dual_vcos_t_init(unit, dual_vco)) { 12578 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("dual_vco initialization failed")); 12579 } 12580 12581 /* Dispatch */ 12582 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12583 if(__type__ >= portmodDispatchTypeCount) { 12584 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12585 } 12586 12587 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_vcos_get) { 12588 pm_info_t pm_info; 12589 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12590 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_vcos_get(unit, port, pm_info, speed_config_list, size, dual_vco); 12591 _SOC_IF_ERR_EXIT(__rv__); 12592 } else { 12593 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_vcos_get isn't implemented for driver type")); 12594 } 12595 12596 exit: 12597 SOC_FUNC_RETURN; 12598 12599 } 12600 12601 12602 int portmod_port_mac_timestamp_enable_set(int unit, int port, int enable) 12603 { 12604 12605 portmod_dispatch_type_t __type__; 12606 int __rv__; 12607 SOC_INIT_FUNC_DEFS; 12608 12609 /* Dispatch */ 12610 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12611 if(__type__ >= portmodDispatchTypeCount) { 12612 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12613 } 12614 12615 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_timestamp_enable_set) { 12616 pm_info_t pm_info; 12617 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12618 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_timestamp_enable_set(unit, port, pm_info, enable); 12619 _SOC_IF_ERR_EXIT(__rv__); 12620 } else { 12621 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_timestamp_enable_set isn't implemented for driver type")); 12622 } 12623 12624 exit: 12625 SOC_FUNC_RETURN; 12626 12627 } 12628 12629 12630 int portmod_port_mac_timestamp_enable_get(int unit, int port, int* enable) 12631 { 12632 12633 portmod_dispatch_type_t __type__; 12634 int __rv__; 12635 SOC_INIT_FUNC_DEFS; 12636 12637 if(enable == NULL) { 12638 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 12639 } 12640 /* Dispatch */ 12641 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12642 if(__type__ >= portmodDispatchTypeCount) { 12643 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12644 } 12645 12646 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_mac_timestamp_enable_get) { 12647 pm_info_t pm_info; 12648 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12649 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_mac_timestamp_enable_get(unit, port, pm_info, enable); 12650 _SOC_IF_ERR_EXIT(__rv__); 12651 } else { 12652 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_mac_timestamp_enable_get isn't implemented for driver type")); 12653 } 12654 12655 exit: 12656 SOC_FUNC_RETURN; 12657 12658 } 12659 12660 12661 #ifdef CPRIMOD_SUPPORT 12662 int portmod_cpri_port_rx_cw_sync_info_get(int unit, int port, uint32* hyper_frame_num, uint32* radio_frame_num) 12663 { 12664 12665 portmod_dispatch_type_t __type__; 12666 int __rv__; 12667 SOC_INIT_FUNC_DEFS; 12668 12669 if(hyper_frame_num == NULL) { 12670 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("hyper_frame_num NULL parameter")); 12671 } 12672 if(radio_frame_num == NULL) { 12673 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("radio_frame_num NULL parameter")); 12674 } 12675 /* Dispatch */ 12676 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12677 if(__type__ >= portmodDispatchTypeCount) { 12678 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12679 } 12680 12681 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_sync_info_get) { 12682 pm_info_t pm_info; 12683 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12684 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_sync_info_get(unit, port, pm_info, hyper_frame_num, radio_frame_num); 12685 _SOC_IF_ERR_EXIT(__rv__); 12686 } else { 12687 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_cw_sync_info_get isn't implemented for driver type")); 12688 } 12689 12690 exit: 12691 SOC_FUNC_RETURN; 12692 12693 } 12694 #endif /* CPRIMOD_SUPPORT */ 12695 12696 12697 #ifdef CPRIMOD_SUPPORT 12698 int portmod_cpri_port_rx_cw_l1_signal_info_get(int unit, int port, portmod_cpri_cw_l1_protocol_info_t* l1_info) 12699 { 12700 12701 portmod_dispatch_type_t __type__; 12702 int __rv__; 12703 SOC_INIT_FUNC_DEFS; 12704 12705 if(l1_info == NULL) { 12706 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("l1_info NULL parameter")); 12707 } 12708 /* Dispatch */ 12709 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12710 if(__type__ >= portmodDispatchTypeCount) { 12711 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12712 } 12713 12714 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_l1_signal_info_get) { 12715 pm_info_t pm_info; 12716 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12717 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_l1_signal_info_get(unit, port, pm_info, l1_info); 12718 _SOC_IF_ERR_EXIT(__rv__); 12719 } else { 12720 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_cw_l1_signal_info_get isn't implemented for driver type")); 12721 } 12722 12723 exit: 12724 SOC_FUNC_RETURN; 12725 12726 } 12727 #endif /* CPRIMOD_SUPPORT */ 12728 12729 12730 #ifdef CPRIMOD_SUPPORT 12731 int portmod_cpri_port_rx_cw_l1_signal_signal_protection_set(int unit, int port, uint32 signal_map, uint32 enable) 12732 { 12733 12734 portmod_dispatch_type_t __type__; 12735 int __rv__; 12736 SOC_INIT_FUNC_DEFS; 12737 12738 /* Dispatch */ 12739 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12740 if(__type__ >= portmodDispatchTypeCount) { 12741 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12742 } 12743 12744 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_l1_signal_signal_protection_set) { 12745 pm_info_t pm_info; 12746 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12747 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_l1_signal_signal_protection_set(unit, port, pm_info, signal_map, enable); 12748 _SOC_IF_ERR_EXIT(__rv__); 12749 } else { 12750 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_cw_l1_signal_signal_protection_set isn't implemented for driver type")); 12751 } 12752 12753 exit: 12754 SOC_FUNC_RETURN; 12755 12756 } 12757 #endif /* CPRIMOD_SUPPORT */ 12758 12759 12760 #ifdef CPRIMOD_SUPPORT 12761 int portmod_cpri_port_rx_cw_l1_signal_signal_protection_get(int unit, int port, uint32 signal_map, uint32* enable) 12762 { 12763 12764 portmod_dispatch_type_t __type__; 12765 int __rv__; 12766 SOC_INIT_FUNC_DEFS; 12767 12768 if(enable == NULL) { 12769 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 12770 } 12771 /* Dispatch */ 12772 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12773 if(__type__ >= portmodDispatchTypeCount) { 12774 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12775 } 12776 12777 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_l1_signal_signal_protection_get) { 12778 pm_info_t pm_info; 12779 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12780 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_cw_l1_signal_signal_protection_get(unit, port, pm_info, signal_map, enable); 12781 _SOC_IF_ERR_EXIT(__rv__); 12782 } else { 12783 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_cw_l1_signal_signal_protection_get isn't implemented for driver type")); 12784 } 12785 12786 exit: 12787 SOC_FUNC_RETURN; 12788 12789 } 12790 #endif /* CPRIMOD_SUPPORT */ 12791 12792 12793 #ifdef CPRIMOD_SUPPORT 12794 int portmod_cpri_slow_hdlc_config_info_t_validate(int unit, const portmod_cpri_slow_hdlc_config_info_t* portmod_cpri_slow_hdlc_config_info) 12795 { 12796 SOC_INIT_FUNC_DEFS; 12797 if(portmod_cpri_slow_hdlc_config_info == NULL) { 12798 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 12799 } 12800 12801 12802 12803 exit: 12804 SOC_FUNC_RETURN; 12805 12806 } 12807 #endif /* CPRIMOD_SUPPORT */ 12808 12809 #ifdef CPRIMOD_SUPPORT 12810 int portmod_cpri_slow_hdlc_config_info_t_init(int unit, portmod_cpri_slow_hdlc_config_info_t* portmod_cpri_slow_hdlc_config_info) 12811 { 12812 SOC_INIT_FUNC_DEFS; 12813 12814 if(portmod_cpri_slow_hdlc_config_info == NULL){ 12815 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_slow_hdlc_config_info NULL parameter")); 12816 } 12817 sal_memset(portmod_cpri_slow_hdlc_config_info, 0, sizeof(portmod_cpri_slow_hdlc_config_info_t)); 12818 portmod_cpri_slow_hdlc_config_info->tx_crc_mode = 0; 12819 portmod_cpri_slow_hdlc_config_info->tx_flag_size = 0; 12820 portmod_cpri_slow_hdlc_config_info->tx_filling_flag_pattern = PORTMOD_CPRI_HDLC_FILLING_FLAG_PATTERN_7E; 12821 portmod_cpri_slow_hdlc_config_info->crc_init_val = 0; 12822 portmod_cpri_slow_hdlc_config_info->fcs_size = PORTMOD_CPRI_HDLC_FCS_SIZE_8_BITS; 12823 12824 12825 exit: 12826 SOC_FUNC_RETURN; 12827 12828 } 12829 #endif /* CPRIMOD_SUPPORT */ 12830 12831 #ifdef CPRIMOD_SUPPORT 12832 int portmod_cpri_port_cw_slow_hdlc_config_set(int unit, int port, const portmod_cpri_slow_hdlc_config_info_t* config_info) 12833 { 12834 12835 portmod_dispatch_type_t __type__; 12836 int __rv__; 12837 SOC_INIT_FUNC_DEFS; 12838 12839 if(SOC_E_NONE != portmod_cpri_slow_hdlc_config_info_t_validate(unit, config_info)) { 12840 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 12841 } 12842 12843 /* Dispatch */ 12844 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12845 if(__type__ >= portmodDispatchTypeCount) { 12846 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12847 } 12848 12849 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_slow_hdlc_config_set) { 12850 pm_info_t pm_info; 12851 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12852 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_slow_hdlc_config_set(unit, port, pm_info, config_info); 12853 _SOC_IF_ERR_EXIT(__rv__); 12854 } else { 12855 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_cw_slow_hdlc_config_set isn't implemented for driver type")); 12856 } 12857 12858 exit: 12859 SOC_FUNC_RETURN; 12860 12861 } 12862 #endif /* CPRIMOD_SUPPORT */ 12863 12864 12865 #ifdef CPRIMOD_SUPPORT 12866 int portmod_cpri_port_cw_slow_hdlc_config_get(int unit, int port, portmod_cpri_slow_hdlc_config_info_t* config_info) 12867 { 12868 12869 portmod_dispatch_type_t __type__; 12870 int __rv__; 12871 SOC_INIT_FUNC_DEFS; 12872 12873 if(config_info == NULL) { 12874 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 12875 } 12876 if(SOC_E_NONE != portmod_cpri_slow_hdlc_config_info_t_init(unit, config_info)) { 12877 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 12878 } 12879 12880 /* Dispatch */ 12881 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12882 if(__type__ >= portmodDispatchTypeCount) { 12883 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12884 } 12885 12886 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_slow_hdlc_config_get) { 12887 pm_info_t pm_info; 12888 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12889 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_slow_hdlc_config_get(unit, port, pm_info, config_info); 12890 _SOC_IF_ERR_EXIT(__rv__); 12891 } else { 12892 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_cw_slow_hdlc_config_get isn't implemented for driver type")); 12893 } 12894 12895 exit: 12896 SOC_FUNC_RETURN; 12897 12898 } 12899 #endif /* CPRIMOD_SUPPORT */ 12900 12901 12902 #ifdef CPRIMOD_SUPPORT 12903 int portmod_cpri_fast_eth_config_info_t_validate(int unit, const portmod_cpri_fast_eth_config_info_t* portmod_cpri_fast_eth_config_info) 12904 { 12905 SOC_INIT_FUNC_DEFS; 12906 if(portmod_cpri_fast_eth_config_info == NULL) { 12907 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 12908 } 12909 12910 12911 12912 exit: 12913 SOC_FUNC_RETURN; 12914 12915 } 12916 #endif /* CPRIMOD_SUPPORT */ 12917 12918 #ifdef CPRIMOD_SUPPORT 12919 int portmod_cpri_fast_eth_config_info_t_init(int unit, portmod_cpri_fast_eth_config_info_t* portmod_cpri_fast_eth_config_info) 12920 { 12921 SOC_INIT_FUNC_DEFS; 12922 12923 if(portmod_cpri_fast_eth_config_info == NULL){ 12924 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_fast_eth_config_info NULL parameter")); 12925 } 12926 sal_memset(portmod_cpri_fast_eth_config_info, 0, sizeof(portmod_cpri_fast_eth_config_info_t)); 12927 portmod_cpri_fast_eth_config_info->tx_crc_mode = 0; 12928 12929 12930 exit: 12931 SOC_FUNC_RETURN; 12932 12933 } 12934 #endif /* CPRIMOD_SUPPORT */ 12935 12936 #ifdef CPRIMOD_SUPPORT 12937 int portmod_cpri_port_cw_fast_eth_config_set(int unit, int port, const portmod_cpri_fast_eth_config_info_t* config_info) 12938 { 12939 12940 portmod_dispatch_type_t __type__; 12941 int __rv__; 12942 SOC_INIT_FUNC_DEFS; 12943 12944 if(SOC_E_NONE != portmod_cpri_fast_eth_config_info_t_validate(unit, config_info)) { 12945 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 12946 } 12947 12948 /* Dispatch */ 12949 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12950 if(__type__ >= portmodDispatchTypeCount) { 12951 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12952 } 12953 12954 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_fast_eth_config_set) { 12955 pm_info_t pm_info; 12956 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12957 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_fast_eth_config_set(unit, port, pm_info, config_info); 12958 _SOC_IF_ERR_EXIT(__rv__); 12959 } else { 12960 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_cw_fast_eth_config_set isn't implemented for driver type")); 12961 } 12962 12963 exit: 12964 SOC_FUNC_RETURN; 12965 12966 } 12967 #endif /* CPRIMOD_SUPPORT */ 12968 12969 12970 #ifdef CPRIMOD_SUPPORT 12971 int portmod_cpri_port_cw_fast_eth_config_get(int unit, int port, portmod_cpri_fast_eth_config_info_t* config_info) 12972 { 12973 12974 portmod_dispatch_type_t __type__; 12975 int __rv__; 12976 SOC_INIT_FUNC_DEFS; 12977 12978 if(config_info == NULL) { 12979 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 12980 } 12981 if(SOC_E_NONE != portmod_cpri_fast_eth_config_info_t_init(unit, config_info)) { 12982 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 12983 } 12984 12985 /* Dispatch */ 12986 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 12987 if(__type__ >= portmodDispatchTypeCount) { 12988 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 12989 } 12990 12991 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_fast_eth_config_get) { 12992 pm_info_t pm_info; 12993 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 12994 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_cw_fast_eth_config_get(unit, port, pm_info, config_info); 12995 _SOC_IF_ERR_EXIT(__rv__); 12996 } else { 12997 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_cw_fast_eth_config_get isn't implemented for driver type")); 12998 } 12999 13000 exit: 13001 SOC_FUNC_RETURN; 13002 13003 } 13004 #endif /* CPRIMOD_SUPPORT */ 13005 13006 13007 #ifdef CPRIMOD_SUPPORT 13008 int portmod_cpri_rx_vsd_config_info_t_validate(int unit, const portmod_cpri_rx_vsd_config_info_t* portmod_cpri_rx_vsd_config_info) 13009 { 13010 SOC_INIT_FUNC_DEFS; 13011 if(portmod_cpri_rx_vsd_config_info == NULL) { 13012 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13013 } 13014 13015 13016 13017 exit: 13018 SOC_FUNC_RETURN; 13019 13020 } 13021 #endif /* CPRIMOD_SUPPORT */ 13022 13023 #ifdef CPRIMOD_SUPPORT 13024 int portmod_cpri_rx_vsd_config_info_t_init(int unit, portmod_cpri_rx_vsd_config_info_t* portmod_cpri_rx_vsd_config_info) 13025 { 13026 SOC_INIT_FUNC_DEFS; 13027 13028 if(portmod_cpri_rx_vsd_config_info == NULL){ 13029 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_rx_vsd_config_info NULL parameter")); 13030 } 13031 sal_memset(portmod_cpri_rx_vsd_config_info, 0, sizeof(portmod_cpri_rx_vsd_config_info_t)); 13032 portmod_cpri_rx_vsd_config_info->subchan_size = 0; 13033 portmod_cpri_rx_vsd_config_info->subchan_bytes = 0; 13034 portmod_cpri_rx_vsd_config_info->flow_bytes = 0; 13035 13036 13037 exit: 13038 SOC_FUNC_RETURN; 13039 13040 } 13041 #endif /* CPRIMOD_SUPPORT */ 13042 13043 #ifdef CPRIMOD_SUPPORT 13044 int portmod_cpri_port_rx_vsd_config_set(int unit, int port, const portmod_cpri_rx_vsd_config_info_t* config_info) 13045 { 13046 13047 portmod_dispatch_type_t __type__; 13048 int __rv__; 13049 SOC_INIT_FUNC_DEFS; 13050 13051 if(SOC_E_NONE != portmod_cpri_rx_vsd_config_info_t_validate(unit, config_info)) { 13052 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 13053 } 13054 13055 /* Dispatch */ 13056 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13057 if(__type__ >= portmodDispatchTypeCount) { 13058 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13059 } 13060 13061 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_config_set) { 13062 pm_info_t pm_info; 13063 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13064 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_config_set(unit, port, pm_info, config_info); 13065 _SOC_IF_ERR_EXIT(__rv__); 13066 } else { 13067 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_config_set isn't implemented for driver type")); 13068 } 13069 13070 exit: 13071 SOC_FUNC_RETURN; 13072 13073 } 13074 #endif /* CPRIMOD_SUPPORT */ 13075 13076 13077 #ifdef CPRIMOD_SUPPORT 13078 int portmod_cpri_port_rx_vsd_config_get(int unit, int port, portmod_cpri_rx_vsd_config_info_t* config_info) 13079 { 13080 13081 portmod_dispatch_type_t __type__; 13082 int __rv__; 13083 SOC_INIT_FUNC_DEFS; 13084 13085 if(config_info == NULL) { 13086 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 13087 } 13088 if(SOC_E_NONE != portmod_cpri_rx_vsd_config_info_t_init(unit, config_info)) { 13089 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 13090 } 13091 13092 /* Dispatch */ 13093 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13094 if(__type__ >= portmodDispatchTypeCount) { 13095 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13096 } 13097 13098 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_config_get) { 13099 pm_info_t pm_info; 13100 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13101 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_config_get(unit, port, pm_info, config_info); 13102 _SOC_IF_ERR_EXIT(__rv__); 13103 } else { 13104 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_config_get isn't implemented for driver type")); 13105 } 13106 13107 exit: 13108 SOC_FUNC_RETURN; 13109 13110 } 13111 #endif /* CPRIMOD_SUPPORT */ 13112 13113 13114 #ifdef CPRIMOD_SUPPORT 13115 int portmod_cpri_tx_vsd_config_info_t_validate(int unit, const portmod_cpri_tx_vsd_config_info_t* portmod_cpri_tx_vsd_config_info) 13116 { 13117 SOC_INIT_FUNC_DEFS; 13118 if(portmod_cpri_tx_vsd_config_info == NULL) { 13119 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13120 } 13121 13122 13123 13124 exit: 13125 SOC_FUNC_RETURN; 13126 13127 } 13128 #endif /* CPRIMOD_SUPPORT */ 13129 13130 #ifdef CPRIMOD_SUPPORT 13131 int portmod_cpri_tx_vsd_config_info_t_init(int unit, portmod_cpri_tx_vsd_config_info_t* portmod_cpri_tx_vsd_config_info) 13132 { 13133 SOC_INIT_FUNC_DEFS; 13134 13135 if(portmod_cpri_tx_vsd_config_info == NULL){ 13136 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_tx_vsd_config_info NULL parameter")); 13137 } 13138 sal_memset(portmod_cpri_tx_vsd_config_info, 0, sizeof(portmod_cpri_tx_vsd_config_info_t)); 13139 portmod_cpri_tx_vsd_config_info->subchan_size = 0; 13140 portmod_cpri_tx_vsd_config_info->subchan_bytes = 0; 13141 portmod_cpri_tx_vsd_config_info->flow_bytes = 0; 13142 13143 13144 exit: 13145 SOC_FUNC_RETURN; 13146 13147 } 13148 #endif /* CPRIMOD_SUPPORT */ 13149 13150 #ifdef CPRIMOD_SUPPORT 13151 int portmod_cpri_port_tx_vsd_config_set(int unit, int port, const portmod_cpri_tx_vsd_config_info_t* config_info) 13152 { 13153 13154 portmod_dispatch_type_t __type__; 13155 int __rv__; 13156 SOC_INIT_FUNC_DEFS; 13157 13158 if(SOC_E_NONE != portmod_cpri_tx_vsd_config_info_t_validate(unit, config_info)) { 13159 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 13160 } 13161 13162 /* Dispatch */ 13163 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13164 if(__type__ >= portmodDispatchTypeCount) { 13165 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13166 } 13167 13168 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_config_set) { 13169 pm_info_t pm_info; 13170 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13171 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_config_set(unit, port, pm_info, config_info); 13172 _SOC_IF_ERR_EXIT(__rv__); 13173 } else { 13174 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_config_set isn't implemented for driver type")); 13175 } 13176 13177 exit: 13178 SOC_FUNC_RETURN; 13179 13180 } 13181 #endif /* CPRIMOD_SUPPORT */ 13182 13183 13184 #ifdef CPRIMOD_SUPPORT 13185 int portmod_cpri_port_tx_vsd_config_get(int unit, int port, portmod_cpri_tx_vsd_config_info_t* config_info) 13186 { 13187 13188 portmod_dispatch_type_t __type__; 13189 int __rv__; 13190 SOC_INIT_FUNC_DEFS; 13191 13192 if(config_info == NULL) { 13193 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 13194 } 13195 if(SOC_E_NONE != portmod_cpri_tx_vsd_config_info_t_init(unit, config_info)) { 13196 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 13197 } 13198 13199 /* Dispatch */ 13200 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13201 if(__type__ >= portmodDispatchTypeCount) { 13202 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13203 } 13204 13205 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_config_get) { 13206 pm_info_t pm_info; 13207 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13208 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_config_get(unit, port, pm_info, config_info); 13209 _SOC_IF_ERR_EXIT(__rv__); 13210 } else { 13211 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_config_get isn't implemented for driver type")); 13212 } 13213 13214 exit: 13215 SOC_FUNC_RETURN; 13216 13217 } 13218 #endif /* CPRIMOD_SUPPORT */ 13219 13220 13221 #ifdef CPRIMOD_SUPPORT 13222 int portmod_cpri_port_rx_vsd_flow_add(int unit, int port, uint32 group_id, const portmod_cpri_rx_vsd_flow_info_t* flow_info) 13223 { 13224 13225 portmod_dispatch_type_t __type__; 13226 int __rv__; 13227 SOC_INIT_FUNC_DEFS; 13228 13229 /* Dispatch */ 13230 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13231 if(__type__ >= portmodDispatchTypeCount) { 13232 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13233 } 13234 13235 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_flow_add) { 13236 pm_info_t pm_info; 13237 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13238 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_flow_add(unit, port, pm_info, group_id, flow_info); 13239 _SOC_IF_ERR_EXIT(__rv__); 13240 } else { 13241 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_flow_add isn't implemented for driver type")); 13242 } 13243 13244 exit: 13245 SOC_FUNC_RETURN; 13246 13247 } 13248 #endif /* CPRIMOD_SUPPORT */ 13249 13250 13251 #ifdef CPRIMOD_SUPPORT 13252 int portmod_cpri_port_rx_vsd_flow_get(int unit, int port, uint32 group_id, portmod_cpri_rx_vsd_flow_info_t* flow_info) 13253 { 13254 13255 portmod_dispatch_type_t __type__; 13256 int __rv__; 13257 SOC_INIT_FUNC_DEFS; 13258 13259 if(flow_info == NULL) { 13260 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("flow_info NULL parameter")); 13261 } 13262 /* Dispatch */ 13263 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13264 if(__type__ >= portmodDispatchTypeCount) { 13265 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13266 } 13267 13268 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_flow_get) { 13269 pm_info_t pm_info; 13270 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13271 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_flow_get(unit, port, pm_info, group_id, flow_info); 13272 _SOC_IF_ERR_EXIT(__rv__); 13273 } else { 13274 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_flow_get isn't implemented for driver type")); 13275 } 13276 13277 exit: 13278 SOC_FUNC_RETURN; 13279 13280 } 13281 #endif /* CPRIMOD_SUPPORT */ 13282 13283 13284 #ifdef CPRIMOD_SUPPORT 13285 int portmod_cpri_port_rx_vsd_flow_delete(int unit, int port, uint32 group_id) 13286 { 13287 13288 portmod_dispatch_type_t __type__; 13289 int __rv__; 13290 SOC_INIT_FUNC_DEFS; 13291 13292 /* Dispatch */ 13293 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13294 if(__type__ >= portmodDispatchTypeCount) { 13295 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13296 } 13297 13298 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_flow_delete) { 13299 pm_info_t pm_info; 13300 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13301 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_flow_delete(unit, port, pm_info, group_id); 13302 _SOC_IF_ERR_EXIT(__rv__); 13303 } else { 13304 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_flow_delete isn't implemented for driver type")); 13305 } 13306 13307 exit: 13308 SOC_FUNC_RETURN; 13309 13310 } 13311 #endif /* CPRIMOD_SUPPORT */ 13312 13313 13314 #ifdef CPRIMOD_SUPPORT 13315 int portmod_cpri_port_tx_vsd_flow_add(int unit, int port, uint32 group_id, const portmod_cpri_tx_vsd_flow_info_t* flow_info) 13316 { 13317 13318 portmod_dispatch_type_t __type__; 13319 int __rv__; 13320 SOC_INIT_FUNC_DEFS; 13321 13322 /* Dispatch */ 13323 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13324 if(__type__ >= portmodDispatchTypeCount) { 13325 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13326 } 13327 13328 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_flow_add) { 13329 pm_info_t pm_info; 13330 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13331 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_flow_add(unit, port, pm_info, group_id, flow_info); 13332 _SOC_IF_ERR_EXIT(__rv__); 13333 } else { 13334 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_flow_add isn't implemented for driver type")); 13335 } 13336 13337 exit: 13338 SOC_FUNC_RETURN; 13339 13340 } 13341 #endif /* CPRIMOD_SUPPORT */ 13342 13343 13344 #ifdef CPRIMOD_SUPPORT 13345 int portmod_cpri_port_tx_vsd_flow_delete(int unit, int port, uint32 group_id) 13346 { 13347 13348 portmod_dispatch_type_t __type__; 13349 int __rv__; 13350 SOC_INIT_FUNC_DEFS; 13351 13352 /* Dispatch */ 13353 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13354 if(__type__ >= portmodDispatchTypeCount) { 13355 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13356 } 13357 13358 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_flow_delete) { 13359 pm_info_t pm_info; 13360 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13361 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_flow_delete(unit, port, pm_info, group_id); 13362 _SOC_IF_ERR_EXIT(__rv__); 13363 } else { 13364 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_flow_delete isn't implemented for driver type")); 13365 } 13366 13367 exit: 13368 SOC_FUNC_RETURN; 13369 13370 } 13371 #endif /* CPRIMOD_SUPPORT */ 13372 13373 13374 #ifdef CPRIMOD_SUPPORT 13375 int portmod_cpri_port_tx_vsd_flow_get(int unit, int port, uint32 group_id, portmod_cpri_tx_vsd_flow_info_t* flow_info) 13376 { 13377 13378 portmod_dispatch_type_t __type__; 13379 int __rv__; 13380 SOC_INIT_FUNC_DEFS; 13381 13382 if(flow_info == NULL) { 13383 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("flow_info NULL parameter")); 13384 } 13385 /* Dispatch */ 13386 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13387 if(__type__ >= portmodDispatchTypeCount) { 13388 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13389 } 13390 13391 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_flow_get) { 13392 pm_info_t pm_info; 13393 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13394 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_flow_get(unit, port, pm_info, group_id, flow_info); 13395 _SOC_IF_ERR_EXIT(__rv__); 13396 } else { 13397 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_flow_get isn't implemented for driver type")); 13398 } 13399 13400 exit: 13401 SOC_FUNC_RETURN; 13402 13403 } 13404 #endif /* CPRIMOD_SUPPORT */ 13405 13406 13407 #ifdef CPRIMOD_SUPPORT 13408 int portmod_cpri_port_encap_queue_control_tag_to_flow_map_set(int unit, int port, uint32 tag_id, uint32 flow_id) 13409 { 13410 13411 portmod_dispatch_type_t __type__; 13412 int __rv__; 13413 SOC_INIT_FUNC_DEFS; 13414 13415 /* Dispatch */ 13416 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13417 if(__type__ >= portmodDispatchTypeCount) { 13418 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13419 } 13420 13421 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_queue_control_tag_to_flow_map_set) { 13422 pm_info_t pm_info; 13423 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13424 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_queue_control_tag_to_flow_map_set(unit, port, pm_info, tag_id, flow_id); 13425 _SOC_IF_ERR_EXIT(__rv__); 13426 } else { 13427 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_queue_control_tag_to_flow_map_set isn't implemented for driver type")); 13428 } 13429 13430 exit: 13431 SOC_FUNC_RETURN; 13432 13433 } 13434 #endif /* CPRIMOD_SUPPORT */ 13435 13436 13437 #ifdef CPRIMOD_SUPPORT 13438 int portmod_cpri_port_encap_queue_control_tag_to_flow_map_get(int unit, int port, uint32 tag_id, uint32* flow_id) 13439 { 13440 13441 portmod_dispatch_type_t __type__; 13442 int __rv__; 13443 SOC_INIT_FUNC_DEFS; 13444 13445 if(flow_id == NULL) { 13446 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("flow_id NULL parameter")); 13447 } 13448 /* Dispatch */ 13449 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13450 if(__type__ >= portmodDispatchTypeCount) { 13451 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13452 } 13453 13454 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_queue_control_tag_to_flow_map_get) { 13455 pm_info_t pm_info; 13456 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13457 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_queue_control_tag_to_flow_map_get(unit, port, pm_info, tag_id, flow_id); 13458 _SOC_IF_ERR_EXIT(__rv__); 13459 } else { 13460 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_queue_control_tag_to_flow_map_get isn't implemented for driver type")); 13461 } 13462 13463 exit: 13464 SOC_FUNC_RETURN; 13465 13466 } 13467 #endif /* CPRIMOD_SUPPORT */ 13468 13469 13470 #ifdef CPRIMOD_SUPPORT 13471 int portmod_cpri_rx_vsd_raw_config_t_validate(int unit, const portmod_cpri_rx_vsd_raw_config_t* portmod_cpri_rx_vsd_raw_config) 13472 { 13473 SOC_INIT_FUNC_DEFS; 13474 if(portmod_cpri_rx_vsd_raw_config == NULL) { 13475 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13476 } 13477 13478 13479 13480 exit: 13481 SOC_FUNC_RETURN; 13482 13483 } 13484 #endif /* CPRIMOD_SUPPORT */ 13485 13486 #ifdef CPRIMOD_SUPPORT 13487 int portmod_cpri_rx_vsd_raw_config_t_init(int unit, portmod_cpri_rx_vsd_raw_config_t* portmod_cpri_rx_vsd_raw_config) 13488 { 13489 SOC_INIT_FUNC_DEFS; 13490 13491 if(portmod_cpri_rx_vsd_raw_config == NULL){ 13492 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_rx_vsd_raw_config NULL parameter")); 13493 } 13494 sal_memset(portmod_cpri_rx_vsd_raw_config, 0, sizeof(portmod_cpri_rx_vsd_raw_config_t)); 13495 portmod_cpri_rx_vsd_raw_config->filter_mode = 0; 13496 13497 13498 exit: 13499 SOC_FUNC_RETURN; 13500 13501 } 13502 #endif /* CPRIMOD_SUPPORT */ 13503 13504 #ifdef CPRIMOD_SUPPORT 13505 int portmod_cpri_port_rx_vsd_raw_config_set(int unit, int port, uint32 index, const portmod_cpri_rx_vsd_raw_config_t* config_info) 13506 { 13507 13508 portmod_dispatch_type_t __type__; 13509 int __rv__; 13510 SOC_INIT_FUNC_DEFS; 13511 13512 if(SOC_E_NONE != portmod_cpri_rx_vsd_raw_config_t_validate(unit, config_info)) { 13513 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 13514 } 13515 13516 /* Dispatch */ 13517 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13518 if(__type__ >= portmodDispatchTypeCount) { 13519 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13520 } 13521 13522 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_raw_config_set) { 13523 pm_info_t pm_info; 13524 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13525 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_raw_config_set(unit, port, pm_info, index, config_info); 13526 _SOC_IF_ERR_EXIT(__rv__); 13527 } else { 13528 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_raw_config_set isn't implemented for driver type")); 13529 } 13530 13531 exit: 13532 SOC_FUNC_RETURN; 13533 13534 } 13535 #endif /* CPRIMOD_SUPPORT */ 13536 13537 13538 #ifdef CPRIMOD_SUPPORT 13539 int portmod_cpri_port_rx_vsd_raw_config_get(int unit, int port, uint32 index, portmod_cpri_rx_vsd_raw_config_t* config_info) 13540 { 13541 13542 portmod_dispatch_type_t __type__; 13543 int __rv__; 13544 SOC_INIT_FUNC_DEFS; 13545 13546 if(config_info == NULL) { 13547 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 13548 } 13549 if(SOC_E_NONE != portmod_cpri_rx_vsd_raw_config_t_init(unit, config_info)) { 13550 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 13551 } 13552 13553 /* Dispatch */ 13554 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13555 if(__type__ >= portmodDispatchTypeCount) { 13556 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13557 } 13558 13559 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_raw_config_get) { 13560 pm_info_t pm_info; 13561 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13562 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_vsd_raw_config_get(unit, port, pm_info, index, config_info); 13563 _SOC_IF_ERR_EXIT(__rv__); 13564 } else { 13565 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_vsd_raw_config_get isn't implemented for driver type")); 13566 } 13567 13568 exit: 13569 SOC_FUNC_RETURN; 13570 13571 } 13572 #endif /* CPRIMOD_SUPPORT */ 13573 13574 13575 #ifdef CPRIMOD_SUPPORT 13576 int portmod_cpri_tx_vsd_raw_config_t_validate(int unit, const portmod_cpri_tx_vsd_raw_config_t* portmod_cpri_tx_vsd_raw_config) 13577 { 13578 SOC_INIT_FUNC_DEFS; 13579 if(portmod_cpri_tx_vsd_raw_config == NULL) { 13580 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13581 } 13582 13583 13584 13585 exit: 13586 SOC_FUNC_RETURN; 13587 13588 } 13589 #endif /* CPRIMOD_SUPPORT */ 13590 13591 #ifdef CPRIMOD_SUPPORT 13592 int portmod_cpri_tx_vsd_raw_config_t_init(int unit, portmod_cpri_tx_vsd_raw_config_t* portmod_cpri_tx_vsd_raw_config) 13593 { 13594 SOC_INIT_FUNC_DEFS; 13595 13596 if(portmod_cpri_tx_vsd_raw_config == NULL){ 13597 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_tx_vsd_raw_config NULL parameter")); 13598 } 13599 sal_memset(portmod_cpri_tx_vsd_raw_config, 0, sizeof(portmod_cpri_tx_vsd_raw_config_t)); 13600 portmod_cpri_tx_vsd_raw_config->map_mode = 0; 13601 13602 13603 exit: 13604 SOC_FUNC_RETURN; 13605 13606 } 13607 #endif /* CPRIMOD_SUPPORT */ 13608 13609 #ifdef CPRIMOD_SUPPORT 13610 int portmod_cpri_port_tx_vsd_raw_config_set(int unit, int port, uint32 index, const portmod_cpri_tx_vsd_raw_config_t* config_info) 13611 { 13612 13613 portmod_dispatch_type_t __type__; 13614 int __rv__; 13615 SOC_INIT_FUNC_DEFS; 13616 13617 if(SOC_E_NONE != portmod_cpri_tx_vsd_raw_config_t_validate(unit, config_info)) { 13618 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 13619 } 13620 13621 /* Dispatch */ 13622 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13623 if(__type__ >= portmodDispatchTypeCount) { 13624 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13625 } 13626 13627 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_config_set) { 13628 pm_info_t pm_info; 13629 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13630 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_config_set(unit, port, pm_info, index, config_info); 13631 _SOC_IF_ERR_EXIT(__rv__); 13632 } else { 13633 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_raw_config_set isn't implemented for driver type")); 13634 } 13635 13636 exit: 13637 SOC_FUNC_RETURN; 13638 13639 } 13640 #endif /* CPRIMOD_SUPPORT */ 13641 13642 13643 #ifdef CPRIMOD_SUPPORT 13644 int portmod_cpri_port_tx_vsd_raw_config_get(int unit, int port, uint32 index, portmod_cpri_tx_vsd_raw_config_t* config_info) 13645 { 13646 13647 portmod_dispatch_type_t __type__; 13648 int __rv__; 13649 SOC_INIT_FUNC_DEFS; 13650 13651 if(config_info == NULL) { 13652 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 13653 } 13654 if(SOC_E_NONE != portmod_cpri_tx_vsd_raw_config_t_init(unit, config_info)) { 13655 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 13656 } 13657 13658 /* Dispatch */ 13659 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13660 if(__type__ >= portmodDispatchTypeCount) { 13661 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13662 } 13663 13664 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_config_get) { 13665 pm_info_t pm_info; 13666 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13667 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_config_get(unit, port, pm_info, index, config_info); 13668 _SOC_IF_ERR_EXIT(__rv__); 13669 } else { 13670 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_raw_config_get isn't implemented for driver type")); 13671 } 13672 13673 exit: 13674 SOC_FUNC_RETURN; 13675 13676 } 13677 #endif /* CPRIMOD_SUPPORT */ 13678 13679 13680 #ifdef CPRIMOD_SUPPORT 13681 int portmod_cpri_port_tx_vsd_raw_filter_set(int unit, int port, uint32 bfn0_value, uint32 bfn0_mask, uint32 bfn1_value, uint32 bfn1_mask) 13682 { 13683 13684 portmod_dispatch_type_t __type__; 13685 int __rv__; 13686 SOC_INIT_FUNC_DEFS; 13687 13688 /* Dispatch */ 13689 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13690 if(__type__ >= portmodDispatchTypeCount) { 13691 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13692 } 13693 13694 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_filter_set) { 13695 pm_info_t pm_info; 13696 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13697 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_filter_set(unit, port, pm_info, bfn0_value, bfn0_mask, bfn1_value, bfn1_mask); 13698 _SOC_IF_ERR_EXIT(__rv__); 13699 } else { 13700 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_raw_filter_set isn't implemented for driver type")); 13701 } 13702 13703 exit: 13704 SOC_FUNC_RETURN; 13705 13706 } 13707 #endif /* CPRIMOD_SUPPORT */ 13708 13709 13710 #ifdef CPRIMOD_SUPPORT 13711 int portmod_cpri_port_tx_vsd_raw_filter_get(int unit, int port, uint32* bfn0_value, uint32* bfn0_mask, uint32* bfn1_value, uint32* bfn1_mask) 13712 { 13713 13714 portmod_dispatch_type_t __type__; 13715 int __rv__; 13716 SOC_INIT_FUNC_DEFS; 13717 13718 if(bfn0_value == NULL) { 13719 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn0_value NULL parameter")); 13720 } 13721 if(bfn0_mask == NULL) { 13722 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn0_mask NULL parameter")); 13723 } 13724 if(bfn1_value == NULL) { 13725 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn1_value NULL parameter")); 13726 } 13727 if(bfn1_mask == NULL) { 13728 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn1_mask NULL parameter")); 13729 } 13730 /* Dispatch */ 13731 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13732 if(__type__ >= portmodDispatchTypeCount) { 13733 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13734 } 13735 13736 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_filter_get) { 13737 pm_info_t pm_info; 13738 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13739 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_vsd_raw_filter_get(unit, port, pm_info, bfn0_value, bfn0_mask, bfn1_value, bfn1_mask); 13740 _SOC_IF_ERR_EXIT(__rv__); 13741 } else { 13742 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_vsd_raw_filter_get isn't implemented for driver type")); 13743 } 13744 13745 exit: 13746 SOC_FUNC_RETURN; 13747 13748 } 13749 #endif /* CPRIMOD_SUPPORT */ 13750 13751 13752 #ifdef CPRIMOD_SUPPORT 13753 int portmod_cpri_rx_brcm_rsvd5_config_t_validate(int unit, const portmod_cpri_rx_brcm_rsvd5_config_t* portmod_cpri_rx_brcm_rsvd5_config) 13754 { 13755 SOC_INIT_FUNC_DEFS; 13756 if(portmod_cpri_rx_brcm_rsvd5_config == NULL) { 13757 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13758 } 13759 13760 13761 13762 exit: 13763 SOC_FUNC_RETURN; 13764 13765 } 13766 #endif /* CPRIMOD_SUPPORT */ 13767 13768 #ifdef CPRIMOD_SUPPORT 13769 int portmod_cpri_rx_brcm_rsvd5_config_t_init(int unit, portmod_cpri_rx_brcm_rsvd5_config_t* portmod_cpri_rx_brcm_rsvd5_config) 13770 { 13771 SOC_INIT_FUNC_DEFS; 13772 13773 if(portmod_cpri_rx_brcm_rsvd5_config == NULL){ 13774 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_rx_brcm_rsvd5_config NULL parameter")); 13775 } 13776 sal_memset(portmod_cpri_rx_brcm_rsvd5_config, 0, sizeof(portmod_cpri_rx_brcm_rsvd5_config_t)); 13777 13778 13779 exit: 13780 SOC_FUNC_RETURN; 13781 13782 } 13783 #endif /* CPRIMOD_SUPPORT */ 13784 13785 #ifdef CPRIMOD_SUPPORT 13786 int portmod_cpri_port_rx_brcm_rsvd5_config_set(int unit, int port, const portmod_cpri_rx_brcm_rsvd5_config_t* config_info) 13787 { 13788 13789 portmod_dispatch_type_t __type__; 13790 int __rv__; 13791 SOC_INIT_FUNC_DEFS; 13792 13793 if(SOC_E_NONE != portmod_cpri_rx_brcm_rsvd5_config_t_validate(unit, config_info)) { 13794 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 13795 } 13796 13797 /* Dispatch */ 13798 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13799 if(__type__ >= portmodDispatchTypeCount) { 13800 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13801 } 13802 13803 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_brcm_rsvd5_config_set) { 13804 pm_info_t pm_info; 13805 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13806 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_brcm_rsvd5_config_set(unit, port, pm_info, config_info); 13807 _SOC_IF_ERR_EXIT(__rv__); 13808 } else { 13809 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_brcm_rsvd5_config_set isn't implemented for driver type")); 13810 } 13811 13812 exit: 13813 SOC_FUNC_RETURN; 13814 13815 } 13816 #endif /* CPRIMOD_SUPPORT */ 13817 13818 13819 #ifdef CPRIMOD_SUPPORT 13820 int portmod_cpri_port_rx_brcm_rsvd5_config_get(int unit, int port, portmod_cpri_rx_brcm_rsvd5_config_t* config_info) 13821 { 13822 13823 portmod_dispatch_type_t __type__; 13824 int __rv__; 13825 SOC_INIT_FUNC_DEFS; 13826 13827 if(config_info == NULL) { 13828 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 13829 } 13830 if(SOC_E_NONE != portmod_cpri_rx_brcm_rsvd5_config_t_init(unit, config_info)) { 13831 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 13832 } 13833 13834 /* Dispatch */ 13835 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13836 if(__type__ >= portmodDispatchTypeCount) { 13837 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13838 } 13839 13840 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_brcm_rsvd5_config_get) { 13841 pm_info_t pm_info; 13842 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13843 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_brcm_rsvd5_config_get(unit, port, pm_info, config_info); 13844 _SOC_IF_ERR_EXIT(__rv__); 13845 } else { 13846 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_brcm_rsvd5_config_get isn't implemented for driver type")); 13847 } 13848 13849 exit: 13850 SOC_FUNC_RETURN; 13851 13852 } 13853 #endif /* CPRIMOD_SUPPORT */ 13854 13855 13856 #ifdef CPRIMOD_SUPPORT 13857 int portmod_cpri_tx_brcm_rsvd5_config_t_validate(int unit, const portmod_cpri_tx_brcm_rsvd5_config_t* portmod_cpri_tx_brcm_rsvd5_config) 13858 { 13859 SOC_INIT_FUNC_DEFS; 13860 if(portmod_cpri_tx_brcm_rsvd5_config == NULL) { 13861 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13862 } 13863 13864 13865 13866 exit: 13867 SOC_FUNC_RETURN; 13868 13869 } 13870 #endif /* CPRIMOD_SUPPORT */ 13871 13872 #ifdef CPRIMOD_SUPPORT 13873 int portmod_cpri_tx_brcm_rsvd5_config_t_init(int unit, portmod_cpri_tx_brcm_rsvd5_config_t* portmod_cpri_tx_brcm_rsvd5_config) 13874 { 13875 SOC_INIT_FUNC_DEFS; 13876 13877 if(portmod_cpri_tx_brcm_rsvd5_config == NULL){ 13878 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_tx_brcm_rsvd5_config NULL parameter")); 13879 } 13880 sal_memset(portmod_cpri_tx_brcm_rsvd5_config, 0, sizeof(portmod_cpri_tx_brcm_rsvd5_config_t)); 13881 13882 13883 exit: 13884 SOC_FUNC_RETURN; 13885 13886 } 13887 #endif /* CPRIMOD_SUPPORT */ 13888 13889 #ifdef CPRIMOD_SUPPORT 13890 int portmod_cpri_port_tx_brcm_rsvd5_config_set(int unit, int port, const portmod_cpri_tx_brcm_rsvd5_config_t* config_info) 13891 { 13892 13893 portmod_dispatch_type_t __type__; 13894 int __rv__; 13895 SOC_INIT_FUNC_DEFS; 13896 13897 if(SOC_E_NONE != portmod_cpri_tx_brcm_rsvd5_config_t_validate(unit, config_info)) { 13898 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 13899 } 13900 13901 /* Dispatch */ 13902 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13903 if(__type__ >= portmodDispatchTypeCount) { 13904 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13905 } 13906 13907 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_brcm_rsvd5_config_set) { 13908 pm_info_t pm_info; 13909 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13910 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_brcm_rsvd5_config_set(unit, port, pm_info, config_info); 13911 _SOC_IF_ERR_EXIT(__rv__); 13912 } else { 13913 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_brcm_rsvd5_config_set isn't implemented for driver type")); 13914 } 13915 13916 exit: 13917 SOC_FUNC_RETURN; 13918 13919 } 13920 #endif /* CPRIMOD_SUPPORT */ 13921 13922 13923 #ifdef CPRIMOD_SUPPORT 13924 int portmod_cpri_port_tx_brcm_rsvd5_config_get(int unit, int port, portmod_cpri_tx_brcm_rsvd5_config_t* config_info) 13925 { 13926 13927 portmod_dispatch_type_t __type__; 13928 int __rv__; 13929 SOC_INIT_FUNC_DEFS; 13930 13931 if(config_info == NULL) { 13932 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 13933 } 13934 if(SOC_E_NONE != portmod_cpri_tx_brcm_rsvd5_config_t_init(unit, config_info)) { 13935 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 13936 } 13937 13938 /* Dispatch */ 13939 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 13940 if(__type__ >= portmodDispatchTypeCount) { 13941 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 13942 } 13943 13944 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_brcm_rsvd5_config_get) { 13945 pm_info_t pm_info; 13946 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 13947 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_brcm_rsvd5_config_get(unit, port, pm_info, config_info); 13948 _SOC_IF_ERR_EXIT(__rv__); 13949 } else { 13950 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_brcm_rsvd5_config_get isn't implemented for driver type")); 13951 } 13952 13953 exit: 13954 SOC_FUNC_RETURN; 13955 13956 } 13957 #endif /* CPRIMOD_SUPPORT */ 13958 13959 13960 #ifdef CPRIMOD_SUPPORT 13961 int portmod_cpri_rx_gcw_config_t_validate(int unit, const portmod_cpri_rx_gcw_config_t* portmod_cpri_rx_gcw_config) 13962 { 13963 SOC_INIT_FUNC_DEFS; 13964 if(portmod_cpri_rx_gcw_config == NULL) { 13965 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 13966 } 13967 13968 13969 13970 exit: 13971 SOC_FUNC_RETURN; 13972 13973 } 13974 #endif /* CPRIMOD_SUPPORT */ 13975 13976 #ifdef CPRIMOD_SUPPORT 13977 int portmod_cpri_rx_gcw_config_t_init(int unit, portmod_cpri_rx_gcw_config_t* portmod_cpri_rx_gcw_config) 13978 { 13979 SOC_INIT_FUNC_DEFS; 13980 13981 if(portmod_cpri_rx_gcw_config == NULL){ 13982 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_rx_gcw_config NULL parameter")); 13983 } 13984 sal_memset(portmod_cpri_rx_gcw_config, 0, sizeof(portmod_cpri_rx_gcw_config_t)); 13985 portmod_cpri_rx_gcw_config->mask = 0; 13986 portmod_cpri_rx_gcw_config->filter_mode = 0; 13987 13988 13989 exit: 13990 SOC_FUNC_RETURN; 13991 13992 } 13993 #endif /* CPRIMOD_SUPPORT */ 13994 13995 #ifdef CPRIMOD_SUPPORT 13996 int portmod_cpri_tx_gcw_config_t_validate(int unit, const portmod_cpri_tx_gcw_config_t* portmod_cpri_tx_gcw_config) 13997 { 13998 SOC_INIT_FUNC_DEFS; 13999 if(portmod_cpri_tx_gcw_config == NULL) { 14000 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 14001 } 14002 14003 14004 14005 exit: 14006 SOC_FUNC_RETURN; 14007 14008 } 14009 #endif /* CPRIMOD_SUPPORT */ 14010 14011 #ifdef CPRIMOD_SUPPORT 14012 int portmod_cpri_tx_gcw_config_t_init(int unit, portmod_cpri_tx_gcw_config_t* portmod_cpri_tx_gcw_config) 14013 { 14014 SOC_INIT_FUNC_DEFS; 14015 14016 if(portmod_cpri_tx_gcw_config == NULL){ 14017 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_tx_gcw_config NULL parameter")); 14018 } 14019 sal_memset(portmod_cpri_tx_gcw_config, 0, sizeof(portmod_cpri_tx_gcw_config_t)); 14020 portmod_cpri_tx_gcw_config->mask = 0; 14021 14022 14023 exit: 14024 SOC_FUNC_RETURN; 14025 14026 } 14027 #endif /* CPRIMOD_SUPPORT */ 14028 14029 #ifdef CPRIMOD_SUPPORT 14030 int portmod_cpri_port_rx_gcw_config_set(int unit, int port, uint32 index, const portmod_cpri_rx_gcw_config_t* config_info) 14031 { 14032 14033 portmod_dispatch_type_t __type__; 14034 int __rv__; 14035 SOC_INIT_FUNC_DEFS; 14036 14037 if(SOC_E_NONE != portmod_cpri_rx_gcw_config_t_validate(unit, config_info)) { 14038 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 14039 } 14040 14041 /* Dispatch */ 14042 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14043 if(__type__ >= portmodDispatchTypeCount) { 14044 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14045 } 14046 14047 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_gcw_config_set) { 14048 pm_info_t pm_info; 14049 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14050 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_gcw_config_set(unit, port, pm_info, index, config_info); 14051 _SOC_IF_ERR_EXIT(__rv__); 14052 } else { 14053 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_gcw_config_set isn't implemented for driver type")); 14054 } 14055 14056 exit: 14057 SOC_FUNC_RETURN; 14058 14059 } 14060 #endif /* CPRIMOD_SUPPORT */ 14061 14062 14063 #ifdef CPRIMOD_SUPPORT 14064 int portmod_cpri_port_rx_gcw_config_get(int unit, int port, uint32 index, portmod_cpri_rx_gcw_config_t* config_info) 14065 { 14066 14067 portmod_dispatch_type_t __type__; 14068 int __rv__; 14069 SOC_INIT_FUNC_DEFS; 14070 14071 if(config_info == NULL) { 14072 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 14073 } 14074 if(SOC_E_NONE != portmod_cpri_rx_gcw_config_t_init(unit, config_info)) { 14075 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 14076 } 14077 14078 /* Dispatch */ 14079 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14080 if(__type__ >= portmodDispatchTypeCount) { 14081 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14082 } 14083 14084 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_gcw_config_get) { 14085 pm_info_t pm_info; 14086 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14087 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_gcw_config_get(unit, port, pm_info, index, config_info); 14088 _SOC_IF_ERR_EXIT(__rv__); 14089 } else { 14090 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_gcw_config_get isn't implemented for driver type")); 14091 } 14092 14093 exit: 14094 SOC_FUNC_RETURN; 14095 14096 } 14097 #endif /* CPRIMOD_SUPPORT */ 14098 14099 14100 #ifdef CPRIMOD_SUPPORT 14101 int portmod_cpri_port_tx_gcw_config_set(int unit, int port, uint32 index, const portmod_cpri_tx_gcw_config_t* config_info) 14102 { 14103 14104 portmod_dispatch_type_t __type__; 14105 int __rv__; 14106 SOC_INIT_FUNC_DEFS; 14107 14108 if(SOC_E_NONE != portmod_cpri_tx_gcw_config_t_validate(unit, config_info)) { 14109 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 14110 } 14111 14112 /* Dispatch */ 14113 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14114 if(__type__ >= portmodDispatchTypeCount) { 14115 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14116 } 14117 14118 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_config_set) { 14119 pm_info_t pm_info; 14120 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14121 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_config_set(unit, port, pm_info, index, config_info); 14122 _SOC_IF_ERR_EXIT(__rv__); 14123 } else { 14124 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_gcw_config_set isn't implemented for driver type")); 14125 } 14126 14127 exit: 14128 SOC_FUNC_RETURN; 14129 14130 } 14131 #endif /* CPRIMOD_SUPPORT */ 14132 14133 14134 #ifdef CPRIMOD_SUPPORT 14135 int portmod_cpri_port_tx_gcw_config_get(int unit, int port, uint32 index, portmod_cpri_tx_gcw_config_t* config_info) 14136 { 14137 14138 portmod_dispatch_type_t __type__; 14139 int __rv__; 14140 SOC_INIT_FUNC_DEFS; 14141 14142 if(config_info == NULL) { 14143 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 14144 } 14145 if(SOC_E_NONE != portmod_cpri_tx_gcw_config_t_init(unit, config_info)) { 14146 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 14147 } 14148 14149 /* Dispatch */ 14150 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14151 if(__type__ >= portmodDispatchTypeCount) { 14152 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14153 } 14154 14155 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_config_get) { 14156 pm_info_t pm_info; 14157 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14158 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_config_get(unit, port, pm_info, index, config_info); 14159 _SOC_IF_ERR_EXIT(__rv__); 14160 } else { 14161 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_gcw_config_get isn't implemented for driver type")); 14162 } 14163 14164 exit: 14165 SOC_FUNC_RETURN; 14166 14167 } 14168 #endif /* CPRIMOD_SUPPORT */ 14169 14170 14171 #ifdef CPRIMOD_SUPPORT 14172 int portmod_cpri_port_tx_gcw_filter_set(int unit, int port, uint32 bfn0_value, uint32 bfn0_mask, uint32 bfn1_value, uint32 bfn1_mask) 14173 { 14174 14175 portmod_dispatch_type_t __type__; 14176 int __rv__; 14177 SOC_INIT_FUNC_DEFS; 14178 14179 /* Dispatch */ 14180 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14181 if(__type__ >= portmodDispatchTypeCount) { 14182 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14183 } 14184 14185 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_filter_set) { 14186 pm_info_t pm_info; 14187 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14188 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_filter_set(unit, port, pm_info, bfn0_value, bfn0_mask, bfn1_value, bfn1_mask); 14189 _SOC_IF_ERR_EXIT(__rv__); 14190 } else { 14191 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_gcw_filter_set isn't implemented for driver type")); 14192 } 14193 14194 exit: 14195 SOC_FUNC_RETURN; 14196 14197 } 14198 #endif /* CPRIMOD_SUPPORT */ 14199 14200 14201 #ifdef CPRIMOD_SUPPORT 14202 int portmod_cpri_port_tx_gcw_filter_get(int unit, int port, uint32* bfn0_value, uint32* bfn0_mask, uint32* bfn1_value, uint32* bfn1_mask) 14203 { 14204 14205 portmod_dispatch_type_t __type__; 14206 int __rv__; 14207 SOC_INIT_FUNC_DEFS; 14208 14209 if(bfn0_value == NULL) { 14210 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn0_value NULL parameter")); 14211 } 14212 if(bfn0_mask == NULL) { 14213 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn0_mask NULL parameter")); 14214 } 14215 if(bfn1_value == NULL) { 14216 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn1_value NULL parameter")); 14217 } 14218 if(bfn1_mask == NULL) { 14219 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bfn1_mask NULL parameter")); 14220 } 14221 /* Dispatch */ 14222 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14223 if(__type__ >= portmodDispatchTypeCount) { 14224 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14225 } 14226 14227 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_filter_get) { 14228 pm_info_t pm_info; 14229 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14230 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_filter_get(unit, port, pm_info, bfn0_value, bfn0_mask, bfn1_value, bfn1_mask); 14231 _SOC_IF_ERR_EXIT(__rv__); 14232 } else { 14233 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_gcw_filter_get isn't implemented for driver type")); 14234 } 14235 14236 exit: 14237 SOC_FUNC_RETURN; 14238 14239 } 14240 #endif /* CPRIMOD_SUPPORT */ 14241 14242 14243 #ifdef CPRIMOD_SUPPORT 14244 int portmod_cpri_port_tx_cw_sync_info_set(int unit, int port, uint32 hyper_frame_num, uint32 radio_frame_num) 14245 { 14246 14247 portmod_dispatch_type_t __type__; 14248 int __rv__; 14249 SOC_INIT_FUNC_DEFS; 14250 14251 /* Dispatch */ 14252 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14253 if(__type__ >= portmodDispatchTypeCount) { 14254 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14255 } 14256 14257 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_cw_sync_info_set) { 14258 pm_info_t pm_info; 14259 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14260 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_cw_sync_info_set(unit, port, pm_info, hyper_frame_num, radio_frame_num); 14261 _SOC_IF_ERR_EXIT(__rv__); 14262 } else { 14263 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_cw_sync_info_set isn't implemented for driver type")); 14264 } 14265 14266 exit: 14267 SOC_FUNC_RETURN; 14268 14269 } 14270 #endif /* CPRIMOD_SUPPORT */ 14271 14272 14273 #ifdef CPRIMOD_SUPPORT 14274 int portmod_cpri_port_tx_cw_sync_info_get(int unit, int port, uint32* hyper_frame_num, uint32* radio_frame_num) 14275 { 14276 14277 portmod_dispatch_type_t __type__; 14278 int __rv__; 14279 SOC_INIT_FUNC_DEFS; 14280 14281 if(hyper_frame_num == NULL) { 14282 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("hyper_frame_num NULL parameter")); 14283 } 14284 if(radio_frame_num == NULL) { 14285 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("radio_frame_num NULL parameter")); 14286 } 14287 /* Dispatch */ 14288 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14289 if(__type__ >= portmodDispatchTypeCount) { 14290 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14291 } 14292 14293 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_cw_sync_info_get) { 14294 pm_info_t pm_info; 14295 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14296 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_cw_sync_info_get(unit, port, pm_info, hyper_frame_num, radio_frame_num); 14297 _SOC_IF_ERR_EXIT(__rv__); 14298 } else { 14299 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_cw_sync_info_get isn't implemented for driver type")); 14300 } 14301 14302 exit: 14303 SOC_FUNC_RETURN; 14304 14305 } 14306 #endif /* CPRIMOD_SUPPORT */ 14307 14308 14309 #ifdef CPRIMOD_SUPPORT 14310 int portmod_cpri_port_tx_cw_l1_config_set(int unit, int port, const portmod_cpri_cw_l1_config_info_t* control_info) 14311 { 14312 14313 portmod_dispatch_type_t __type__; 14314 int __rv__; 14315 SOC_INIT_FUNC_DEFS; 14316 14317 /* Dispatch */ 14318 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14319 if(__type__ >= portmodDispatchTypeCount) { 14320 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14321 } 14322 14323 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_cw_l1_config_set) { 14324 pm_info_t pm_info; 14325 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14326 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_cw_l1_config_set(unit, port, pm_info, control_info); 14327 _SOC_IF_ERR_EXIT(__rv__); 14328 } else { 14329 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_cw_l1_config_set isn't implemented for driver type")); 14330 } 14331 14332 exit: 14333 SOC_FUNC_RETURN; 14334 14335 } 14336 #endif /* CPRIMOD_SUPPORT */ 14337 14338 14339 int portmod_control_flow_config_t_validate(int unit, const portmod_control_flow_config_t* portmod_control_flow_config) 14340 { 14341 SOC_INIT_FUNC_DEFS; 14342 if(portmod_control_flow_config == NULL) { 14343 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 14344 } 14345 14346 14347 14348 exit: 14349 SOC_FUNC_RETURN; 14350 14351 } 14352 14353 int portmod_control_flow_config_t_init(int unit, portmod_control_flow_config_t* portmod_control_flow_config) 14354 { 14355 SOC_INIT_FUNC_DEFS; 14356 14357 if(portmod_control_flow_config == NULL){ 14358 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_control_flow_config NULL parameter")); 14359 } 14360 sal_memset(portmod_control_flow_config, 0, sizeof(portmod_control_flow_config_t)); 14361 portmod_control_flow_config->proc_type = 0; 14362 14363 14364 exit: 14365 SOC_FUNC_RETURN; 14366 14367 } 14368 14369 #ifdef CPRIMOD_SUPPORT 14370 int portmod_rsvd4_rx_control_flow_add(int unit, int port, uint32 flow_id, const portmod_control_flow_config_t* config) 14371 { 14372 14373 portmod_dispatch_type_t __type__; 14374 int __rv__; 14375 SOC_INIT_FUNC_DEFS; 14376 14377 if(SOC_E_NONE != portmod_control_flow_config_t_validate(unit, config)) { 14378 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 14379 } 14380 14381 /* Dispatch */ 14382 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14383 if(__type__ >= portmodDispatchTypeCount) { 14384 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14385 } 14386 14387 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_control_flow_add) { 14388 pm_info_t pm_info; 14389 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14390 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_control_flow_add(unit, port, pm_info, flow_id, config); 14391 _SOC_IF_ERR_EXIT(__rv__); 14392 } else { 14393 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_rx_control_flow_add isn't implemented for driver type")); 14394 } 14395 14396 exit: 14397 SOC_FUNC_RETURN; 14398 14399 } 14400 #endif /* CPRIMOD_SUPPORT */ 14401 14402 14403 #ifdef CPRIMOD_SUPPORT 14404 int portmod_rsvd4_rx_control_flow_delete(int unit, int port, uint32 flow_id, const portmod_control_flow_config_t* config) 14405 { 14406 14407 portmod_dispatch_type_t __type__; 14408 int __rv__; 14409 SOC_INIT_FUNC_DEFS; 14410 14411 if(SOC_E_NONE != portmod_control_flow_config_t_validate(unit, config)) { 14412 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 14413 } 14414 14415 /* Dispatch */ 14416 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14417 if(__type__ >= portmodDispatchTypeCount) { 14418 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14419 } 14420 14421 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_control_flow_delete) { 14422 pm_info_t pm_info; 14423 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14424 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_control_flow_delete(unit, port, pm_info, flow_id, config); 14425 _SOC_IF_ERR_EXIT(__rv__); 14426 } else { 14427 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_rx_control_flow_delete isn't implemented for driver type")); 14428 } 14429 14430 exit: 14431 SOC_FUNC_RETURN; 14432 14433 } 14434 #endif /* CPRIMOD_SUPPORT */ 14435 14436 14437 #ifdef CPRIMOD_SUPPORT 14438 int portmod_rsvd4_fast_eth_config_set(int unit, int port, const portmod_cpri_fast_eth_config_t* config_info) 14439 { 14440 14441 portmod_dispatch_type_t __type__; 14442 int __rv__; 14443 SOC_INIT_FUNC_DEFS; 14444 14445 /* Dispatch */ 14446 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14447 if(__type__ >= portmodDispatchTypeCount) { 14448 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14449 } 14450 14451 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_fast_eth_config_set) { 14452 pm_info_t pm_info; 14453 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14454 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_fast_eth_config_set(unit, port, pm_info, config_info); 14455 _SOC_IF_ERR_EXIT(__rv__); 14456 } else { 14457 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_fast_eth_config_set isn't implemented for driver type")); 14458 } 14459 14460 exit: 14461 SOC_FUNC_RETURN; 14462 14463 } 14464 #endif /* CPRIMOD_SUPPORT */ 14465 14466 14467 int portmod_sync_profile_entry_t_validate(int unit, const portmod_sync_profile_entry_t* portmod_sync_profile_entry) 14468 { 14469 SOC_INIT_FUNC_DEFS; 14470 if(portmod_sync_profile_entry == NULL) { 14471 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 14472 } 14473 14474 14475 14476 exit: 14477 SOC_FUNC_RETURN; 14478 14479 } 14480 14481 int portmod_sync_profile_entry_t_init(int unit, portmod_sync_profile_entry_t* portmod_sync_profile_entry) 14482 { 14483 SOC_INIT_FUNC_DEFS; 14484 14485 if(portmod_sync_profile_entry == NULL){ 14486 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_sync_profile_entry NULL parameter")); 14487 } 14488 sal_memset(portmod_sync_profile_entry, 0, sizeof(portmod_sync_profile_entry_t)); 14489 portmod_sync_profile_entry->count_cycle = 0; 14490 14491 14492 exit: 14493 SOC_FUNC_RETURN; 14494 14495 } 14496 14497 #ifdef CPRIMOD_SUPPORT 14498 int portmod_rsvd4_rx_sync_profile_entry_set(int unit, int port, uint32 profile_id, const portmod_sync_profile_entry_t* entry) 14499 { 14500 14501 portmod_dispatch_type_t __type__; 14502 int __rv__; 14503 SOC_INIT_FUNC_DEFS; 14504 14505 if(SOC_E_NONE != portmod_sync_profile_entry_t_validate(unit, entry)) { 14506 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("entry validation failed")); 14507 } 14508 14509 /* Dispatch */ 14510 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14511 if(__type__ >= portmodDispatchTypeCount) { 14512 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14513 } 14514 14515 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_sync_profile_entry_set) { 14516 pm_info_t pm_info; 14517 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14518 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_sync_profile_entry_set(unit, port, pm_info, profile_id, entry); 14519 _SOC_IF_ERR_EXIT(__rv__); 14520 } else { 14521 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_rx_sync_profile_entry_set isn't implemented for driver type")); 14522 } 14523 14524 exit: 14525 SOC_FUNC_RETURN; 14526 14527 } 14528 #endif /* CPRIMOD_SUPPORT */ 14529 14530 14531 #ifdef CPRIMOD_SUPPORT 14532 int portmod_rsvd4_rx_sync_profile_entry_get(int unit, int port, uint32 profile_id, portmod_sync_profile_entry_t* entry) 14533 { 14534 14535 portmod_dispatch_type_t __type__; 14536 int __rv__; 14537 SOC_INIT_FUNC_DEFS; 14538 14539 if(entry == NULL) { 14540 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("entry NULL parameter")); 14541 } 14542 if(SOC_E_NONE != portmod_sync_profile_entry_t_init(unit, entry)) { 14543 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("entry initialization failed")); 14544 } 14545 14546 /* Dispatch */ 14547 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14548 if(__type__ >= portmodDispatchTypeCount) { 14549 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14550 } 14551 14552 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_sync_profile_entry_get) { 14553 pm_info_t pm_info; 14554 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14555 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_rx_sync_profile_entry_get(unit, port, pm_info, profile_id, entry); 14556 _SOC_IF_ERR_EXIT(__rv__); 14557 } else { 14558 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_rx_sync_profile_entry_get isn't implemented for driver type")); 14559 } 14560 14561 exit: 14562 SOC_FUNC_RETURN; 14563 14564 } 14565 #endif /* CPRIMOD_SUPPORT */ 14566 14567 14568 int portmod_rx_tag_config_set(int unit, int port, uint32 default_tag, uint32 no_match_tag) 14569 { 14570 14571 portmod_dispatch_type_t __type__; 14572 int __rv__; 14573 SOC_INIT_FUNC_DEFS; 14574 14575 /* Dispatch */ 14576 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14577 if(__type__ >= portmodDispatchTypeCount) { 14578 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14579 } 14580 14581 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rx_tag_config_set) { 14582 pm_info_t pm_info; 14583 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14584 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rx_tag_config_set(unit, port, pm_info, default_tag, no_match_tag); 14585 _SOC_IF_ERR_EXIT(__rv__); 14586 } else { 14587 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rx_tag_config_set isn't implemented for driver type")); 14588 } 14589 14590 exit: 14591 SOC_FUNC_RETURN; 14592 14593 } 14594 14595 14596 int portmod_rx_tag_gen_entry_add(int unit, int port, const portmod_tag_gen_entry_t* entry) 14597 { 14598 14599 portmod_dispatch_type_t __type__; 14600 int __rv__; 14601 SOC_INIT_FUNC_DEFS; 14602 14603 /* Dispatch */ 14604 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14605 if(__type__ >= portmodDispatchTypeCount) { 14606 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14607 } 14608 14609 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rx_tag_gen_entry_add) { 14610 pm_info_t pm_info; 14611 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14612 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rx_tag_gen_entry_add(unit, port, pm_info, entry); 14613 _SOC_IF_ERR_EXIT(__rv__); 14614 } else { 14615 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rx_tag_gen_entry_add isn't implemented for driver type")); 14616 } 14617 14618 exit: 14619 SOC_FUNC_RETURN; 14620 14621 } 14622 14623 14624 int portmod_rx_tag_gen_entry_delete(int unit, int port, const portmod_tag_gen_entry_t* entry) 14625 { 14626 14627 portmod_dispatch_type_t __type__; 14628 int __rv__; 14629 SOC_INIT_FUNC_DEFS; 14630 14631 /* Dispatch */ 14632 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14633 if(__type__ >= portmodDispatchTypeCount) { 14634 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14635 } 14636 14637 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rx_tag_gen_entry_delete) { 14638 pm_info_t pm_info; 14639 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14640 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rx_tag_gen_entry_delete(unit, port, pm_info, entry); 14641 _SOC_IF_ERR_EXIT(__rv__); 14642 } else { 14643 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rx_tag_gen_entry_delete isn't implemented for driver type")); 14644 } 14645 14646 exit: 14647 SOC_FUNC_RETURN; 14648 14649 } 14650 14651 14652 #ifdef CPRIMOD_SUPPORT 14653 int portmod_rsvd4_tx_control_flow_group_member_add(int unit, int port, uint32 group_id, uint32 priority, uint32 queue_num, portmod_control_msg_proc_type_t proc_type) 14654 { 14655 14656 portmod_dispatch_type_t __type__; 14657 int __rv__; 14658 SOC_INIT_FUNC_DEFS; 14659 14660 /* Dispatch */ 14661 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14662 if(__type__ >= portmodDispatchTypeCount) { 14663 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14664 } 14665 14666 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_group_member_add) { 14667 pm_info_t pm_info; 14668 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14669 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_group_member_add(unit, port, pm_info, group_id, priority, queue_num, proc_type); 14670 _SOC_IF_ERR_EXIT(__rv__); 14671 } else { 14672 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_flow_group_member_add isn't implemented for driver type")); 14673 } 14674 14675 exit: 14676 SOC_FUNC_RETURN; 14677 14678 } 14679 #endif /* CPRIMOD_SUPPORT */ 14680 14681 14682 #ifdef CPRIMOD_SUPPORT 14683 int portmod_rsvd4_tx_control_flow_group_member_delete(int unit, int port, uint32 group_id, uint32 priority) 14684 { 14685 14686 portmod_dispatch_type_t __type__; 14687 int __rv__; 14688 SOC_INIT_FUNC_DEFS; 14689 14690 /* Dispatch */ 14691 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14692 if(__type__ >= portmodDispatchTypeCount) { 14693 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14694 } 14695 14696 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_group_member_delete) { 14697 pm_info_t pm_info; 14698 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14699 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_group_member_delete(unit, port, pm_info, group_id, priority); 14700 _SOC_IF_ERR_EXIT(__rv__); 14701 } else { 14702 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_flow_group_member_delete isn't implemented for driver type")); 14703 } 14704 14705 exit: 14706 SOC_FUNC_RETURN; 14707 14708 } 14709 #endif /* CPRIMOD_SUPPORT */ 14710 14711 14712 #ifdef CPRIMOD_SUPPORT 14713 int portmod_rsvd4_tx_eth_message_config_set(int unit, int port, uint32 msg_node, uint32 msg_subnode, uint32 msg_type, uint32 msg_padding) 14714 { 14715 14716 portmod_dispatch_type_t __type__; 14717 int __rv__; 14718 SOC_INIT_FUNC_DEFS; 14719 14720 /* Dispatch */ 14721 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14722 if(__type__ >= portmodDispatchTypeCount) { 14723 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14724 } 14725 14726 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_eth_message_config_set) { 14727 pm_info_t pm_info; 14728 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14729 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_eth_message_config_set(unit, port, pm_info, msg_node, msg_subnode, msg_type, msg_padding); 14730 _SOC_IF_ERR_EXIT(__rv__); 14731 } else { 14732 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_eth_message_config_set isn't implemented for driver type")); 14733 } 14734 14735 exit: 14736 SOC_FUNC_RETURN; 14737 14738 } 14739 #endif /* CPRIMOD_SUPPORT */ 14740 14741 14742 #ifdef CPRIMOD_SUPPORT 14743 int portmod_rsvd4_tx_single_raw_message_config_set(int unit, int port, uint32 msg_id, uint32 msg_type) 14744 { 14745 14746 portmod_dispatch_type_t __type__; 14747 int __rv__; 14748 SOC_INIT_FUNC_DEFS; 14749 14750 /* Dispatch */ 14751 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14752 if(__type__ >= portmodDispatchTypeCount) { 14753 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14754 } 14755 14756 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_single_raw_message_config_set) { 14757 pm_info_t pm_info; 14758 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14759 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_single_raw_message_config_set(unit, port, pm_info, msg_id, msg_type); 14760 _SOC_IF_ERR_EXIT(__rv__); 14761 } else { 14762 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_single_raw_message_config_set isn't implemented for driver type")); 14763 } 14764 14765 exit: 14766 SOC_FUNC_RETURN; 14767 14768 } 14769 #endif /* CPRIMOD_SUPPORT */ 14770 14771 14772 #ifdef CPRIMOD_SUPPORT 14773 int portmod_rsvd4_tx_config_info_t_validate(int unit, const portmod_rsvd4_tx_config_info_t* portmod_rsvd4_tx_config_info) 14774 { 14775 SOC_INIT_FUNC_DEFS; 14776 if(portmod_rsvd4_tx_config_info == NULL) { 14777 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 14778 } 14779 14780 14781 14782 exit: 14783 SOC_FUNC_RETURN; 14784 14785 } 14786 #endif /* CPRIMOD_SUPPORT */ 14787 14788 #ifdef CPRIMOD_SUPPORT 14789 int portmod_rsvd4_tx_config_info_t_init(int unit, portmod_rsvd4_tx_config_info_t* portmod_rsvd4_tx_config_info) 14790 { 14791 SOC_INIT_FUNC_DEFS; 14792 14793 if(portmod_rsvd4_tx_config_info == NULL){ 14794 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_rsvd4_tx_config_info NULL parameter")); 14795 } 14796 sal_memset(portmod_rsvd4_tx_config_info, 0, sizeof(portmod_rsvd4_tx_config_info_t)); 14797 portmod_rsvd4_tx_config_info->proc_type = 0; 14798 14799 14800 exit: 14801 SOC_FUNC_RETURN; 14802 14803 } 14804 #endif /* CPRIMOD_SUPPORT */ 14805 14806 #ifdef CPRIMOD_SUPPORT 14807 int portmod_rsvd4_tx_control_flow_config_set(int unit, int port, uint32 flow_id, const portmod_rsvd4_tx_config_info_t* config_info) 14808 { 14809 14810 portmod_dispatch_type_t __type__; 14811 int __rv__; 14812 SOC_INIT_FUNC_DEFS; 14813 14814 if(SOC_E_NONE != portmod_rsvd4_tx_config_info_t_validate(unit, config_info)) { 14815 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 14816 } 14817 14818 /* Dispatch */ 14819 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14820 if(__type__ >= portmodDispatchTypeCount) { 14821 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14822 } 14823 14824 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_config_set) { 14825 pm_info_t pm_info; 14826 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14827 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_config_set(unit, port, pm_info, flow_id, config_info); 14828 _SOC_IF_ERR_EXIT(__rv__); 14829 } else { 14830 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_flow_config_set isn't implemented for driver type")); 14831 } 14832 14833 exit: 14834 SOC_FUNC_RETURN; 14835 14836 } 14837 #endif /* CPRIMOD_SUPPORT */ 14838 14839 14840 #ifdef CPRIMOD_SUPPORT 14841 int portmod_rsvd4_tx_control_flow_config_get(int unit, int port, uint32 flow_id, portmod_rsvd4_tx_config_info_t* config_info) 14842 { 14843 14844 portmod_dispatch_type_t __type__; 14845 int __rv__; 14846 SOC_INIT_FUNC_DEFS; 14847 14848 if(config_info == NULL) { 14849 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 14850 } 14851 if(SOC_E_NONE != portmod_rsvd4_tx_config_info_t_init(unit, config_info)) { 14852 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 14853 } 14854 14855 /* Dispatch */ 14856 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14857 if(__type__ >= portmodDispatchTypeCount) { 14858 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14859 } 14860 14861 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_config_get) { 14862 pm_info_t pm_info; 14863 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14864 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_config_get(unit, port, pm_info, flow_id, config_info); 14865 _SOC_IF_ERR_EXIT(__rv__); 14866 } else { 14867 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_flow_config_get isn't implemented for driver type")); 14868 } 14869 14870 exit: 14871 SOC_FUNC_RETURN; 14872 14873 } 14874 #endif /* CPRIMOD_SUPPORT */ 14875 14876 14877 #ifdef CPRIMOD_SUPPORT 14878 int portmod_rsvd4_tx_control_flow_header_index_set(int unit, int port, uint32 roe_flow_id, uint32 index) 14879 { 14880 14881 portmod_dispatch_type_t __type__; 14882 int __rv__; 14883 SOC_INIT_FUNC_DEFS; 14884 14885 /* Dispatch */ 14886 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14887 if(__type__ >= portmodDispatchTypeCount) { 14888 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14889 } 14890 14891 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_header_index_set) { 14892 pm_info_t pm_info; 14893 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14894 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_header_index_set(unit, port, pm_info, roe_flow_id, index); 14895 _SOC_IF_ERR_EXIT(__rv__); 14896 } else { 14897 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_flow_header_index_set isn't implemented for driver type")); 14898 } 14899 14900 exit: 14901 SOC_FUNC_RETURN; 14902 14903 } 14904 #endif /* CPRIMOD_SUPPORT */ 14905 14906 14907 #ifdef CPRIMOD_SUPPORT 14908 int portmod_rsvd4_tx_control_flow_header_index_get(int unit, int port, uint32 roe_flow_id, uint32* index) 14909 { 14910 14911 portmod_dispatch_type_t __type__; 14912 int __rv__; 14913 SOC_INIT_FUNC_DEFS; 14914 14915 if(index == NULL) { 14916 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("index NULL parameter")); 14917 } 14918 /* Dispatch */ 14919 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14920 if(__type__ >= portmodDispatchTypeCount) { 14921 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14922 } 14923 14924 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_header_index_get) { 14925 pm_info_t pm_info; 14926 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14927 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_flow_header_index_get(unit, port, pm_info, roe_flow_id, index); 14928 _SOC_IF_ERR_EXIT(__rv__); 14929 } else { 14930 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_flow_header_index_get isn't implemented for driver type")); 14931 } 14932 14933 exit: 14934 SOC_FUNC_RETURN; 14935 14936 } 14937 #endif /* CPRIMOD_SUPPORT */ 14938 14939 14940 #ifdef CPRIMOD_SUPPORT 14941 int portmod_rsvd4_tx_control_header_entry_set(int unit, int port, uint32 index, uint32 header_node, uint32 header_subnode, uint32 payload_node) 14942 { 14943 14944 portmod_dispatch_type_t __type__; 14945 int __rv__; 14946 SOC_INIT_FUNC_DEFS; 14947 14948 /* Dispatch */ 14949 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14950 if(__type__ >= portmodDispatchTypeCount) { 14951 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14952 } 14953 14954 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_header_entry_set) { 14955 pm_info_t pm_info; 14956 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14957 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_header_entry_set(unit, port, pm_info, index, header_node, header_subnode, payload_node); 14958 _SOC_IF_ERR_EXIT(__rv__); 14959 } else { 14960 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_header_entry_set isn't implemented for driver type")); 14961 } 14962 14963 exit: 14964 SOC_FUNC_RETURN; 14965 14966 } 14967 #endif /* CPRIMOD_SUPPORT */ 14968 14969 14970 #ifdef CPRIMOD_SUPPORT 14971 int portmod_rsvd4_tx_control_header_entry_get(int unit, int port, uint32 index, uint32* header_node, uint32* header_subnode, uint32* payload_node) 14972 { 14973 14974 portmod_dispatch_type_t __type__; 14975 int __rv__; 14976 SOC_INIT_FUNC_DEFS; 14977 14978 if(header_node == NULL) { 14979 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("header_node NULL parameter")); 14980 } 14981 if(header_subnode == NULL) { 14982 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("header_subnode NULL parameter")); 14983 } 14984 if(payload_node == NULL) { 14985 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("payload_node NULL parameter")); 14986 } 14987 /* Dispatch */ 14988 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 14989 if(__type__ >= portmodDispatchTypeCount) { 14990 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 14991 } 14992 14993 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_header_entry_get) { 14994 pm_info_t pm_info; 14995 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 14996 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_control_header_entry_get(unit, port, pm_info, index, header_node, header_subnode, payload_node); 14997 _SOC_IF_ERR_EXIT(__rv__); 14998 } else { 14999 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_control_header_entry_get isn't implemented for driver type")); 15000 } 15001 15002 exit: 15003 SOC_FUNC_RETURN; 15004 15005 } 15006 #endif /* CPRIMOD_SUPPORT */ 15007 15008 15009 #ifdef CPRIMOD_SUPPORT 15010 int portmod_rsvd4_tx_single_tunnel_message_config_set(int unit, int port, portmod_cpri_crc_option_t crc_option) 15011 { 15012 15013 portmod_dispatch_type_t __type__; 15014 int __rv__; 15015 SOC_INIT_FUNC_DEFS; 15016 15017 /* Dispatch */ 15018 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15019 if(__type__ >= portmodDispatchTypeCount) { 15020 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15021 } 15022 15023 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_single_tunnel_message_config_set) { 15024 pm_info_t pm_info; 15025 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15026 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_tx_single_tunnel_message_config_set(unit, port, pm_info, crc_option); 15027 _SOC_IF_ERR_EXIT(__rv__); 15028 } else { 15029 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_tx_single_tunnel_message_config_set isn't implemented for driver type")); 15030 } 15031 15032 exit: 15033 SOC_FUNC_RETURN; 15034 15035 } 15036 #endif /* CPRIMOD_SUPPORT */ 15037 15038 15039 int portmod_txpi_override_t_validate(int unit, const portmod_txpi_override_t* portmod_txpi_override) 15040 { 15041 SOC_INIT_FUNC_DEFS; 15042 if(portmod_txpi_override == NULL) { 15043 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 15044 } 15045 15046 15047 15048 exit: 15049 SOC_FUNC_RETURN; 15050 15051 } 15052 15053 int portmod_txpi_override_t_init(int unit, portmod_txpi_override_t* portmod_txpi_override) 15054 { 15055 SOC_INIT_FUNC_DEFS; 15056 15057 if(portmod_txpi_override == NULL){ 15058 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_txpi_override NULL parameter")); 15059 } 15060 sal_memset(portmod_txpi_override, 0, sizeof(portmod_txpi_override_t)); 15061 15062 15063 exit: 15064 SOC_FUNC_RETURN; 15065 15066 } 15067 15068 int portmod_port_txpi_override_set(int unit, int port, const portmod_txpi_override_t* override) 15069 { 15070 15071 portmod_dispatch_type_t __type__; 15072 int __rv__; 15073 SOC_INIT_FUNC_DEFS; 15074 15075 if(SOC_E_NONE != portmod_txpi_override_t_validate(unit, override)) { 15076 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("override validation failed")); 15077 } 15078 15079 /* Dispatch */ 15080 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15081 if(__type__ >= portmodDispatchTypeCount) { 15082 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15083 } 15084 15085 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_txpi_override_set) { 15086 pm_info_t pm_info; 15087 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15088 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_txpi_override_set(unit, port, pm_info, override); 15089 _SOC_IF_ERR_EXIT(__rv__); 15090 } else { 15091 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_txpi_override_set isn't implemented for driver type")); 15092 } 15093 15094 exit: 15095 SOC_FUNC_RETURN; 15096 15097 } 15098 15099 15100 int portmod_port_txpi_override_get(int unit, int port, portmod_txpi_override_t* override) 15101 { 15102 15103 portmod_dispatch_type_t __type__; 15104 int __rv__; 15105 SOC_INIT_FUNC_DEFS; 15106 15107 if(override == NULL) { 15108 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("override NULL parameter")); 15109 } 15110 if(SOC_E_NONE != portmod_txpi_override_t_init(unit, override)) { 15111 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("override initialization failed")); 15112 } 15113 15114 /* Dispatch */ 15115 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15116 if(__type__ >= portmodDispatchTypeCount) { 15117 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15118 } 15119 15120 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_txpi_override_get) { 15121 pm_info_t pm_info; 15122 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15123 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_txpi_override_get(unit, port, pm_info, override); 15124 _SOC_IF_ERR_EXIT(__rv__); 15125 } else { 15126 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_txpi_override_get isn't implemented for driver type")); 15127 } 15128 15129 exit: 15130 SOC_FUNC_RETURN; 15131 15132 } 15133 15134 15135 int portmod_port_txpi_sdm_data_get(int unit, int port, int* value) 15136 { 15137 15138 portmod_dispatch_type_t __type__; 15139 int __rv__; 15140 SOC_INIT_FUNC_DEFS; 15141 15142 if(value == NULL) { 15143 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 15144 } 15145 /* Dispatch */ 15146 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15147 if(__type__ >= portmodDispatchTypeCount) { 15148 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15149 } 15150 15151 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_txpi_sdm_data_get) { 15152 pm_info_t pm_info; 15153 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15154 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_txpi_sdm_data_get(unit, port, pm_info, value); 15155 _SOC_IF_ERR_EXIT(__rv__); 15156 } else { 15157 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_txpi_sdm_data_get isn't implemented for driver type")); 15158 } 15159 15160 exit: 15161 SOC_FUNC_RETURN; 15162 15163 } 15164 15165 15166 int portmod_pm8x50_capability_t_validate(int unit, const portmod_pm8x50_capability_t* portmod_pm8x50_capability) 15167 { 15168 SOC_INIT_FUNC_DEFS; 15169 if(portmod_pm8x50_capability == NULL) { 15170 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 15171 } 15172 15173 15174 15175 exit: 15176 SOC_FUNC_RETURN; 15177 15178 } 15179 15180 int portmod_pm8x50_capability_t_init(int unit, portmod_pm8x50_capability_t* portmod_pm8x50_capability) 15181 { 15182 SOC_INIT_FUNC_DEFS; 15183 15184 if(portmod_pm8x50_capability == NULL){ 15185 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm8x50_capability NULL parameter")); 15186 } 15187 sal_memset(portmod_pm8x50_capability, 0, sizeof(portmod_pm8x50_capability_t)); 15188 portmod_pm8x50_capability->num_lanes = 8; 15189 portmod_pm8x50_capability->num_cores = 1; 15190 portmod_pm8x50_capability->num_plls = 2; 15191 portmod_pm8x50_capability->num_vcos = 3; 15192 15193 15194 exit: 15195 SOC_FUNC_RETURN; 15196 15197 } 15198 15199 int portmod_pm_capability_t_validate(int unit, const portmod_pm_capability_t* portmod_pm_capability) 15200 { 15201 SOC_INIT_FUNC_DEFS; 15202 if(portmod_pm_capability == NULL) { 15203 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 15204 } 15205 15206 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, portmod_pm_capability->type)) { 15207 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("type validation failed")); 15208 } 15209 15210 15211 15212 exit: 15213 SOC_FUNC_RETURN; 15214 15215 } 15216 15217 int portmod_pm_capability_t_init(int unit, portmod_pm_capability_t* portmod_pm_capability) 15218 { 15219 SOC_INIT_FUNC_DEFS; 15220 15221 if(portmod_pm_capability == NULL){ 15222 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_capability NULL parameter")); 15223 } 15224 sal_memset(portmod_pm_capability, 0, sizeof(portmod_pm_capability_t)); 15225 portmod_pm_capability->type = portmodDispatchTypeCount; 15226 15227 15228 exit: 15229 SOC_FUNC_RETURN; 15230 15231 } 15232 15233 int portmod_pm_vco_setting_t_validate(int unit, const portmod_pm_vco_setting_t* portmod_pm_vco_setting) 15234 { 15235 SOC_INIT_FUNC_DEFS; 15236 if(portmod_pm_vco_setting == NULL) { 15237 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 15238 } 15239 15240 if(SOC_E_NONE != portmod_speed_config_t_validate(unit, portmod_pm_vco_setting->speed_config_list)) { 15241 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("speed_config_list validation failed")); 15242 } 15243 15244 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, portmod_pm_vco_setting->tvco)) { 15245 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("tvco validation failed")); 15246 } 15247 15248 if(SOC_E_NONE != portmod_vco_type_t_validate(unit, portmod_pm_vco_setting->ovco)) { 15249 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ovco validation failed")); 15250 } 15251 15252 15253 15254 exit: 15255 SOC_FUNC_RETURN; 15256 15257 } 15258 15259 int portmod_pm_vco_setting_t_init(int unit, portmod_pm_vco_setting_t* portmod_pm_vco_setting) 15260 { 15261 SOC_INIT_FUNC_DEFS; 15262 15263 if(portmod_pm_vco_setting == NULL){ 15264 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_pm_vco_setting NULL parameter")); 15265 } 15266 sal_memset(portmod_pm_vco_setting, 0, sizeof(portmod_pm_vco_setting_t)); 15267 portmod_pm_vco_setting->tvco = portmodVCOInvalid; 15268 portmod_pm_vco_setting->ovco = portmodVCOInvalid; 15269 15270 15271 exit: 15272 SOC_FUNC_RETURN; 15273 15274 } 15275 15276 int portmod_pm_speed_config_validate(int unit, int pm_id, const portmod_pbmp_t* ports, int flag, portmod_pm_vco_setting_t* vco_setting) 15277 { 15278 15279 portmod_dispatch_type_t __type__; 15280 int __rv__; 15281 SOC_INIT_FUNC_DEFS; 15282 15283 if(vco_setting == NULL) { 15284 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco_setting NULL parameter")); 15285 } 15286 if(SOC_E_NONE != portmod_pm_vco_setting_t_validate(unit, vco_setting)) { 15287 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco_setting validation failed")); 15288 } 15289 15290 /* Dispatch */ 15291 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 15292 if(__type__ >= portmodDispatchTypeCount) { 15293 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15294 } 15295 15296 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_speed_config_validate) { 15297 pm_info_t pm_info; 15298 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 15299 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_speed_config_validate(unit, pm_id, pm_info, ports, flag, vco_setting); 15300 _SOC_IF_ERR_EXIT(__rv__); 15301 } else { 15302 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_speed_config_validate isn't implemented for driver type")); 15303 } 15304 15305 exit: 15306 SOC_FUNC_RETURN; 15307 15308 } 15309 15310 15311 int portmod_pm_vcos_get(int unit, portmod_dispatch_type_t pm_type, uint32 flags, portmod_pm_vco_setting_t* vco_select) 15312 { 15313 15314 portmod_dispatch_type_t __type__; 15315 int __rv__; 15316 SOC_INIT_FUNC_DEFS; 15317 15318 if(SOC_E_NONE != portmod_dispatch_type_t_validate(unit, pm_type)) { 15319 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm_type validation failed")); 15320 } 15321 15322 if(vco_select == NULL) { 15323 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco_select NULL parameter")); 15324 } 15325 if(SOC_E_NONE != portmod_pm_vco_setting_t_validate(unit, vco_select)) { 15326 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco_select validation failed")); 15327 } 15328 15329 /* Dispatch */ 15330 __type__ = (pm_type); 15331 if(__type__ >= portmodDispatchTypeCount) { 15332 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15333 } 15334 15335 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_vcos_get) { 15336 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_vcos_get(unit, pm_type, flags, vco_select); 15337 _SOC_IF_ERR_EXIT(__rv__); 15338 } else { 15339 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_vcos_get isn't implemented for driver type")); 15340 } 15341 15342 exit: 15343 SOC_FUNC_RETURN; 15344 15345 } 15346 15347 15348 int portmod_pm_specific_vcos_get(int unit, const portmod_pm_capability_t* pm_cap, portmod_pm_vco_setting_t* vco_select) 15349 { 15350 15351 portmod_dispatch_type_t __type__; 15352 int __rv__; 15353 SOC_INIT_FUNC_DEFS; 15354 15355 if(SOC_E_NONE != portmod_pm_capability_t_validate(unit, pm_cap)) { 15356 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("pm_cap validation failed")); 15357 } 15358 15359 if(vco_select == NULL) { 15360 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco_select NULL parameter")); 15361 } 15362 if(SOC_E_NONE != portmod_pm_vco_setting_t_init(unit, vco_select)) { 15363 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("vco_select initialization failed")); 15364 } 15365 15366 /* Dispatch */ 15367 __type__ = (pm_cap)->type; 15368 if(__type__ >= portmodDispatchTypeCount) { 15369 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15370 } 15371 15372 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_specific_vcos_get) { 15373 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_specific_vcos_get(unit, pm_cap, vco_select); 15374 _SOC_IF_ERR_EXIT(__rv__); 15375 } else { 15376 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_specific_vcos_get isn't implemented for driver type")); 15377 } 15378 15379 exit: 15380 SOC_FUNC_RETURN; 15381 15382 } 15383 15384 15385 int portmod_port_autoneg_ability_advert_set(int unit, int port, int num_abilities, const portmod_port_speed_ability_t* abilities) 15386 { 15387 15388 portmod_dispatch_type_t __type__; 15389 int __rv__; 15390 SOC_INIT_FUNC_DEFS; 15391 15392 if(SOC_E_NONE != portmod_port_speed_ability_t_validate(unit, abilities)) { 15393 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities validation failed")); 15394 } 15395 15396 /* Dispatch */ 15397 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15398 if(__type__ >= portmodDispatchTypeCount) { 15399 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15400 } 15401 15402 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_autoneg_ability_advert_set) { 15403 pm_info_t pm_info; 15404 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15405 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_autoneg_ability_advert_set(unit, port, pm_info, num_abilities, abilities); 15406 _SOC_IF_ERR_EXIT(__rv__); 15407 } else { 15408 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_autoneg_ability_advert_set isn't implemented for driver type")); 15409 } 15410 15411 exit: 15412 SOC_FUNC_RETURN; 15413 15414 } 15415 15416 15417 int portmod_port_autoneg_ability_advert_get(int unit, int port, int max_num_abilities, portmod_port_speed_ability_t* abilities, int* actual_num_abilities) 15418 { 15419 15420 portmod_dispatch_type_t __type__; 15421 int __rv__; 15422 SOC_INIT_FUNC_DEFS; 15423 15424 if(abilities == NULL) { 15425 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities NULL parameter")); 15426 } 15427 if(SOC_E_NONE != portmod_port_speed_ability_t_init(unit, abilities)) { 15428 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities initialization failed")); 15429 } 15430 15431 if(actual_num_abilities == NULL) { 15432 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("actual_num_abilities NULL parameter")); 15433 } 15434 /* Dispatch */ 15435 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15436 if(__type__ >= portmodDispatchTypeCount) { 15437 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15438 } 15439 15440 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_autoneg_ability_advert_get) { 15441 pm_info_t pm_info; 15442 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15443 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_autoneg_ability_advert_get(unit, port, pm_info, max_num_abilities, abilities, actual_num_abilities); 15444 _SOC_IF_ERR_EXIT(__rv__); 15445 } else { 15446 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_autoneg_ability_advert_get isn't implemented for driver type")); 15447 } 15448 15449 exit: 15450 SOC_FUNC_RETURN; 15451 15452 } 15453 15454 15455 int portmod_port_autoneg_ability_remote_get(int unit, int port, int max_num_abilities, portmod_port_speed_ability_t* abilities, int* actual_num_abilities) 15456 { 15457 15458 portmod_dispatch_type_t __type__; 15459 int __rv__; 15460 SOC_INIT_FUNC_DEFS; 15461 15462 if(abilities == NULL) { 15463 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities NULL parameter")); 15464 } 15465 if(SOC_E_NONE != portmod_port_speed_ability_t_init(unit, abilities)) { 15466 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("abilities initialization failed")); 15467 } 15468 15469 if(actual_num_abilities == NULL) { 15470 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("actual_num_abilities NULL parameter")); 15471 } 15472 /* Dispatch */ 15473 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15474 if(__type__ >= portmodDispatchTypeCount) { 15475 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15476 } 15477 15478 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_autoneg_ability_remote_get) { 15479 pm_info_t pm_info; 15480 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15481 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_autoneg_ability_remote_get(unit, port, pm_info, max_num_abilities, abilities, actual_num_abilities); 15482 _SOC_IF_ERR_EXIT(__rv__); 15483 } else { 15484 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_autoneg_ability_remote_get isn't implemented for driver type")); 15485 } 15486 15487 exit: 15488 SOC_FUNC_RETURN; 15489 15490 } 15491 15492 15493 #ifdef CPRIMOD_SUPPORT 15494 int portmod_cpri_port_interrupt_link_status_get(int unit, int port, const int* is_link_intr_status) 15495 { 15496 15497 portmod_dispatch_type_t __type__; 15498 int __rv__; 15499 SOC_INIT_FUNC_DEFS; 15500 15501 /* Dispatch */ 15502 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15503 if(__type__ >= portmodDispatchTypeCount) { 15504 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15505 } 15506 15507 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_interrupt_link_status_get) { 15508 pm_info_t pm_info; 15509 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15510 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_interrupt_link_status_get(unit, port, pm_info, is_link_intr_status); 15511 _SOC_IF_ERR_EXIT(__rv__); 15512 } else { 15513 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_interrupt_link_status_get isn't implemented for driver type")); 15514 } 15515 15516 exit: 15517 SOC_FUNC_RETURN; 15518 15519 } 15520 #endif /* CPRIMOD_SUPPORT */ 15521 15522 15523 int portmod_cpri_port_intr_info_t_validate(int unit, const portmod_cpri_port_intr_info_t* portmod_cpri_port_intr_info) 15524 { 15525 SOC_INIT_FUNC_DEFS; 15526 if(portmod_cpri_port_intr_info == NULL) { 15527 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 15528 } 15529 15530 15531 15532 exit: 15533 SOC_FUNC_RETURN; 15534 15535 } 15536 15537 int portmod_cpri_port_intr_info_t_init(int unit, portmod_cpri_port_intr_info_t* portmod_cpri_port_intr_info) 15538 { 15539 SOC_INIT_FUNC_DEFS; 15540 15541 if(portmod_cpri_port_intr_info == NULL){ 15542 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_port_intr_info NULL parameter")); 15543 } 15544 sal_memset(portmod_cpri_port_intr_info, 0, sizeof(portmod_cpri_port_intr_info_t)); 15545 portmod_cpri_port_intr_info->cpri_intr_type = _shrCpriIntrCount; 15546 15547 15548 exit: 15549 SOC_FUNC_RETURN; 15550 15551 } 15552 15553 #ifdef CPRIMOD_SUPPORT 15554 int portmod_cpri_port_interrupt_enable_set(int unit, int port, portmod_cpri_port_intr_type_t cpri_intr_type, int data, int enable) 15555 { 15556 15557 portmod_dispatch_type_t __type__; 15558 int __rv__; 15559 SOC_INIT_FUNC_DEFS; 15560 15561 /* Dispatch */ 15562 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15563 if(__type__ >= portmodDispatchTypeCount) { 15564 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15565 } 15566 15567 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_interrupt_enable_set) { 15568 pm_info_t pm_info; 15569 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15570 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_interrupt_enable_set(unit, port, pm_info, cpri_intr_type, data, enable); 15571 _SOC_IF_ERR_EXIT(__rv__); 15572 } else { 15573 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_interrupt_enable_set isn't implemented for driver type")); 15574 } 15575 15576 exit: 15577 SOC_FUNC_RETURN; 15578 15579 } 15580 #endif /* CPRIMOD_SUPPORT */ 15581 15582 15583 #ifdef CPRIMOD_SUPPORT 15584 int portmod_cpri_port_interrupt_process(int unit, int port) 15585 { 15586 15587 portmod_dispatch_type_t __type__; 15588 int __rv__; 15589 SOC_INIT_FUNC_DEFS; 15590 15591 /* Dispatch */ 15592 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15593 if(__type__ >= portmodDispatchTypeCount) { 15594 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15595 } 15596 15597 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_interrupt_process) { 15598 pm_info_t pm_info; 15599 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15600 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_interrupt_process(unit, port, pm_info); 15601 _SOC_IF_ERR_EXIT(__rv__); 15602 } else { 15603 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_interrupt_process isn't implemented for driver type")); 15604 } 15605 15606 exit: 15607 SOC_FUNC_RETURN; 15608 15609 } 15610 #endif /* CPRIMOD_SUPPORT */ 15611 15612 15613 #ifdef CPRIMOD_SUPPORT 15614 int portmod_fast_clk_bit_time_period_set(int unit, int port, uint32 bit_time_period) 15615 { 15616 15617 portmod_dispatch_type_t __type__; 15618 int __rv__; 15619 SOC_INIT_FUNC_DEFS; 15620 15621 /* Dispatch */ 15622 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15623 if(__type__ >= portmodDispatchTypeCount) { 15624 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15625 } 15626 15627 if(NULL != __portmod__dispatch__[__type__]->f_portmod_fast_clk_bit_time_period_set) { 15628 pm_info_t pm_info; 15629 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15630 __rv__ = __portmod__dispatch__[__type__]->f_portmod_fast_clk_bit_time_period_set(unit, port, pm_info, bit_time_period); 15631 _SOC_IF_ERR_EXIT(__rv__); 15632 } else { 15633 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_fast_clk_bit_time_period_set isn't implemented for driver type")); 15634 } 15635 15636 exit: 15637 SOC_FUNC_RETURN; 15638 15639 } 15640 #endif /* CPRIMOD_SUPPORT */ 15641 15642 15643 #ifdef CPRIMOD_SUPPORT 15644 int portmod_fast_clk_bit_time_period_get(int unit, int port, uint32* bit_time_period) 15645 { 15646 15647 portmod_dispatch_type_t __type__; 15648 int __rv__; 15649 SOC_INIT_FUNC_DEFS; 15650 15651 if(bit_time_period == NULL) { 15652 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bit_time_period NULL parameter")); 15653 } 15654 /* Dispatch */ 15655 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15656 if(__type__ >= portmodDispatchTypeCount) { 15657 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15658 } 15659 15660 if(NULL != __portmod__dispatch__[__type__]->f_portmod_fast_clk_bit_time_period_get) { 15661 pm_info_t pm_info; 15662 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15663 __rv__ = __portmod__dispatch__[__type__]->f_portmod_fast_clk_bit_time_period_get(unit, port, pm_info, bit_time_period); 15664 _SOC_IF_ERR_EXIT(__rv__); 15665 } else { 15666 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_fast_clk_bit_time_period_get isn't implemented for driver type")); 15667 } 15668 15669 exit: 15670 SOC_FUNC_RETURN; 15671 15672 } 15673 #endif /* CPRIMOD_SUPPORT */ 15674 15675 15676 #ifdef CPRIMOD_SUPPORT 15677 int portmod_1588_bit_time_period_set(int unit, int port, portmod_direction_t direction, cprimod_port_speed_t speed) 15678 { 15679 15680 portmod_dispatch_type_t __type__; 15681 int __rv__; 15682 SOC_INIT_FUNC_DEFS; 15683 15684 /* Dispatch */ 15685 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15686 if(__type__ >= portmodDispatchTypeCount) { 15687 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15688 } 15689 15690 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_bit_time_period_set) { 15691 pm_info_t pm_info; 15692 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15693 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_bit_time_period_set(unit, port, pm_info, direction, speed); 15694 _SOC_IF_ERR_EXIT(__rv__); 15695 } else { 15696 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_bit_time_period_set isn't implemented for driver type")); 15697 } 15698 15699 exit: 15700 SOC_FUNC_RETURN; 15701 15702 } 15703 #endif /* CPRIMOD_SUPPORT */ 15704 15705 15706 #ifdef CPRIMOD_SUPPORT 15707 int portmod_1588_bit_time_period_get(int unit, int port, portmod_direction_t direction, uint32* bit_time_period) 15708 { 15709 15710 portmod_dispatch_type_t __type__; 15711 int __rv__; 15712 SOC_INIT_FUNC_DEFS; 15713 15714 if(bit_time_period == NULL) { 15715 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("bit_time_period NULL parameter")); 15716 } 15717 /* Dispatch */ 15718 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15719 if(__type__ >= portmodDispatchTypeCount) { 15720 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15721 } 15722 15723 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_bit_time_period_get) { 15724 pm_info_t pm_info; 15725 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15726 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_bit_time_period_get(unit, port, pm_info, direction, bit_time_period); 15727 _SOC_IF_ERR_EXIT(__rv__); 15728 } else { 15729 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_bit_time_period_get isn't implemented for driver type")); 15730 } 15731 15732 exit: 15733 SOC_FUNC_RETURN; 15734 15735 } 15736 #endif /* CPRIMOD_SUPPORT */ 15737 15738 15739 #ifdef CPRIMOD_SUPPORT 15740 int portmod_1588_timestamp_capture_config_set(int unit, int port, portmod_direction_t direction, const cprimod_1588_capture_config_t* config) 15741 { 15742 15743 portmod_dispatch_type_t __type__; 15744 int __rv__; 15745 SOC_INIT_FUNC_DEFS; 15746 15747 /* Dispatch */ 15748 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15749 if(__type__ >= portmodDispatchTypeCount) { 15750 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15751 } 15752 15753 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_capture_config_set) { 15754 pm_info_t pm_info; 15755 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15756 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_capture_config_set(unit, port, pm_info, direction, config); 15757 _SOC_IF_ERR_EXIT(__rv__); 15758 } else { 15759 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_capture_config_set isn't implemented for driver type")); 15760 } 15761 15762 exit: 15763 SOC_FUNC_RETURN; 15764 15765 } 15766 #endif /* CPRIMOD_SUPPORT */ 15767 15768 15769 #ifdef CPRIMOD_SUPPORT 15770 int portmod_1588_timestamp_capture_config_get(int unit, int port, portmod_direction_t direction, cprimod_1588_capture_config_t* config) 15771 { 15772 15773 portmod_dispatch_type_t __type__; 15774 int __rv__; 15775 SOC_INIT_FUNC_DEFS; 15776 15777 if(config == NULL) { 15778 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 15779 } 15780 /* Dispatch */ 15781 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15782 if(__type__ >= portmodDispatchTypeCount) { 15783 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15784 } 15785 15786 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_capture_config_get) { 15787 pm_info_t pm_info; 15788 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15789 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_capture_config_get(unit, port, pm_info, direction, config); 15790 _SOC_IF_ERR_EXIT(__rv__); 15791 } else { 15792 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_capture_config_get isn't implemented for driver type")); 15793 } 15794 15795 exit: 15796 SOC_FUNC_RETURN; 15797 15798 } 15799 #endif /* CPRIMOD_SUPPORT */ 15800 15801 15802 #ifdef CPRIMOD_SUPPORT 15803 int portmod_1588_captured_timestamp_get(int unit, int port, portmod_direction_t direction, portmod_1588_ts_type_t ts_type, uint8 mx_cnt, uint8* count, uint64* captured_time) 15804 { 15805 15806 portmod_dispatch_type_t __type__; 15807 int __rv__; 15808 SOC_INIT_FUNC_DEFS; 15809 15810 if(count == NULL) { 15811 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("count NULL parameter")); 15812 } 15813 if(captured_time == NULL) { 15814 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("captured_time NULL parameter")); 15815 } 15816 /* Dispatch */ 15817 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15818 if(__type__ >= portmodDispatchTypeCount) { 15819 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15820 } 15821 15822 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_captured_timestamp_get) { 15823 pm_info_t pm_info; 15824 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15825 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_captured_timestamp_get(unit, port, pm_info, direction, ts_type, mx_cnt, count, captured_time); 15826 _SOC_IF_ERR_EXIT(__rv__); 15827 } else { 15828 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_captured_timestamp_get isn't implemented for driver type")); 15829 } 15830 15831 exit: 15832 SOC_FUNC_RETURN; 15833 15834 } 15835 #endif /* CPRIMOD_SUPPORT */ 15836 15837 15838 #ifdef CPRIMOD_SUPPORT 15839 int portmod_1588_timestamp_adjust_set(int unit, int port, portmod_direction_t direction, const cprimod_1588_time_t* adjust_time) 15840 { 15841 15842 portmod_dispatch_type_t __type__; 15843 int __rv__; 15844 SOC_INIT_FUNC_DEFS; 15845 15846 /* Dispatch */ 15847 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15848 if(__type__ >= portmodDispatchTypeCount) { 15849 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15850 } 15851 15852 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_adjust_set) { 15853 pm_info_t pm_info; 15854 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15855 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_adjust_set(unit, port, pm_info, direction, adjust_time); 15856 _SOC_IF_ERR_EXIT(__rv__); 15857 } else { 15858 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_adjust_set isn't implemented for driver type")); 15859 } 15860 15861 exit: 15862 SOC_FUNC_RETURN; 15863 15864 } 15865 #endif /* CPRIMOD_SUPPORT */ 15866 15867 15868 #ifdef CPRIMOD_SUPPORT 15869 int portmod_1588_timestamp_adjust_get(int unit, int port, portmod_direction_t direction, cprimod_1588_time_t* adjust_time) 15870 { 15871 15872 portmod_dispatch_type_t __type__; 15873 int __rv__; 15874 SOC_INIT_FUNC_DEFS; 15875 15876 if(adjust_time == NULL) { 15877 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("adjust_time NULL parameter")); 15878 } 15879 /* Dispatch */ 15880 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15881 if(__type__ >= portmodDispatchTypeCount) { 15882 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15883 } 15884 15885 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_adjust_get) { 15886 pm_info_t pm_info; 15887 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15888 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_adjust_get(unit, port, pm_info, direction, adjust_time); 15889 _SOC_IF_ERR_EXIT(__rv__); 15890 } else { 15891 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_adjust_get isn't implemented for driver type")); 15892 } 15893 15894 exit: 15895 SOC_FUNC_RETURN; 15896 15897 } 15898 #endif /* CPRIMOD_SUPPORT */ 15899 15900 15901 #ifdef CPRIMOD_SUPPORT 15902 int portmod_1588_timestamp_fifo_config_set(int unit, int port, portmod_direction_t direction, uint16 modulo) 15903 { 15904 15905 portmod_dispatch_type_t __type__; 15906 int __rv__; 15907 SOC_INIT_FUNC_DEFS; 15908 15909 /* Dispatch */ 15910 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15911 if(__type__ >= portmodDispatchTypeCount) { 15912 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15913 } 15914 15915 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_fifo_config_set) { 15916 pm_info_t pm_info; 15917 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15918 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_fifo_config_set(unit, port, pm_info, direction, modulo); 15919 _SOC_IF_ERR_EXIT(__rv__); 15920 } else { 15921 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_fifo_config_set isn't implemented for driver type")); 15922 } 15923 15924 exit: 15925 SOC_FUNC_RETURN; 15926 15927 } 15928 #endif /* CPRIMOD_SUPPORT */ 15929 15930 15931 #ifdef CPRIMOD_SUPPORT 15932 int portmod_1588_timestamp_fifo_config_get(int unit, int port, portmod_direction_t direction, uint16* modulo) 15933 { 15934 15935 portmod_dispatch_type_t __type__; 15936 int __rv__; 15937 SOC_INIT_FUNC_DEFS; 15938 15939 if(modulo == NULL) { 15940 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("modulo NULL parameter")); 15941 } 15942 /* Dispatch */ 15943 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15944 if(__type__ >= portmodDispatchTypeCount) { 15945 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15946 } 15947 15948 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_fifo_config_get) { 15949 pm_info_t pm_info; 15950 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15951 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_fifo_config_get(unit, port, pm_info, direction, modulo); 15952 _SOC_IF_ERR_EXIT(__rv__); 15953 } else { 15954 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_fifo_config_get isn't implemented for driver type")); 15955 } 15956 15957 exit: 15958 SOC_FUNC_RETURN; 15959 15960 } 15961 #endif /* CPRIMOD_SUPPORT */ 15962 15963 15964 #ifdef CPRIMOD_SUPPORT 15965 int portmod_1588_timestamp_cmic_config_set(int unit, int port, portmod_direction_t direction, uint16 modulo) 15966 { 15967 15968 portmod_dispatch_type_t __type__; 15969 int __rv__; 15970 SOC_INIT_FUNC_DEFS; 15971 15972 /* Dispatch */ 15973 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 15974 if(__type__ >= portmodDispatchTypeCount) { 15975 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 15976 } 15977 15978 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_cmic_config_set) { 15979 pm_info_t pm_info; 15980 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 15981 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_cmic_config_set(unit, port, pm_info, direction, modulo); 15982 _SOC_IF_ERR_EXIT(__rv__); 15983 } else { 15984 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_cmic_config_set isn't implemented for driver type")); 15985 } 15986 15987 exit: 15988 SOC_FUNC_RETURN; 15989 15990 } 15991 #endif /* CPRIMOD_SUPPORT */ 15992 15993 15994 #ifdef CPRIMOD_SUPPORT 15995 int portmod_1588_timestamp_cmic_config_get(int unit, int port, portmod_direction_t direction, uint16* modulo) 15996 { 15997 15998 portmod_dispatch_type_t __type__; 15999 int __rv__; 16000 SOC_INIT_FUNC_DEFS; 16001 16002 if(modulo == NULL) { 16003 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("modulo NULL parameter")); 16004 } 16005 /* Dispatch */ 16006 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16007 if(__type__ >= portmodDispatchTypeCount) { 16008 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16009 } 16010 16011 if(NULL != __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_cmic_config_get) { 16012 pm_info_t pm_info; 16013 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16014 __rv__ = __portmod__dispatch__[__type__]->f_portmod_1588_timestamp_cmic_config_get(unit, port, pm_info, direction, modulo); 16015 _SOC_IF_ERR_EXIT(__rv__); 16016 } else { 16017 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_1588_timestamp_cmic_config_get isn't implemented for driver type")); 16018 } 16019 16020 exit: 16021 SOC_FUNC_RETURN; 16022 16023 } 16024 #endif /* CPRIMOD_SUPPORT */ 16025 16026 16027 int portmod_port_tx_set(int unit, int port, const phymod_tx_t* tx) 16028 { 16029 16030 portmod_dispatch_type_t __type__; 16031 int __rv__; 16032 SOC_INIT_FUNC_DEFS; 16033 16034 /* Dispatch */ 16035 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16036 if(__type__ >= portmodDispatchTypeCount) { 16037 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16038 } 16039 16040 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_set) { 16041 pm_info_t pm_info; 16042 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16043 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_set(unit, port, pm_info, tx); 16044 _SOC_IF_ERR_EXIT(__rv__); 16045 } else { 16046 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_set isn't implemented for driver type")); 16047 } 16048 16049 exit: 16050 SOC_FUNC_RETURN; 16051 16052 } 16053 16054 16055 int portmod_port_tx_get(int unit, int port, phymod_tx_t* tx) 16056 { 16057 16058 portmod_dispatch_type_t __type__; 16059 int __rv__; 16060 SOC_INIT_FUNC_DEFS; 16061 16062 if(tx == NULL) { 16063 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("tx NULL parameter")); 16064 } 16065 /* Dispatch */ 16066 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16067 if(__type__ >= portmodDispatchTypeCount) { 16068 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16069 } 16070 16071 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_tx_get) { 16072 pm_info_t pm_info; 16073 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16074 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_tx_get(unit, port, pm_info, tx); 16075 _SOC_IF_ERR_EXIT(__rv__); 16076 } else { 16077 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_tx_get isn't implemented for driver type")); 16078 } 16079 16080 exit: 16081 SOC_FUNC_RETURN; 16082 16083 } 16084 16085 16086 int portmod_port_synce_clk_ctrl_t_validate(int unit, const portmod_port_synce_clk_ctrl_t* portmod_port_synce_clk_ctrl) 16087 { 16088 SOC_INIT_FUNC_DEFS; 16089 if(portmod_port_synce_clk_ctrl == NULL) { 16090 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 16091 } 16092 16093 16094 16095 exit: 16096 SOC_FUNC_RETURN; 16097 16098 } 16099 16100 int portmod_port_synce_clk_ctrl_t_init(int unit, portmod_port_synce_clk_ctrl_t* portmod_port_synce_clk_ctrl) 16101 { 16102 SOC_INIT_FUNC_DEFS; 16103 16104 if(portmod_port_synce_clk_ctrl == NULL){ 16105 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_synce_clk_ctrl NULL parameter")); 16106 } 16107 sal_memset(portmod_port_synce_clk_ctrl, 0, sizeof(portmod_port_synce_clk_ctrl_t)); 16108 16109 16110 exit: 16111 SOC_FUNC_RETURN; 16112 16113 } 16114 16115 int portmod_port_synce_clk_ctrl_set(int unit, int port, const portmod_port_synce_clk_ctrl_t* cfg) 16116 { 16117 16118 portmod_dispatch_type_t __type__; 16119 int __rv__; 16120 SOC_INIT_FUNC_DEFS; 16121 16122 if(SOC_E_NONE != portmod_port_synce_clk_ctrl_t_validate(unit, cfg)) { 16123 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cfg validation failed")); 16124 } 16125 16126 /* Dispatch */ 16127 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16128 if(__type__ >= portmodDispatchTypeCount) { 16129 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16130 } 16131 16132 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_synce_clk_ctrl_set) { 16133 pm_info_t pm_info; 16134 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16135 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_synce_clk_ctrl_set(unit, port, pm_info, cfg); 16136 _SOC_IF_ERR_EXIT(__rv__); 16137 } else { 16138 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_synce_clk_ctrl_set isn't implemented for driver type")); 16139 } 16140 16141 exit: 16142 SOC_FUNC_RETURN; 16143 16144 } 16145 16146 16147 int portmod_port_synce_clk_ctrl_get(int unit, int port, portmod_port_synce_clk_ctrl_t* cfg) 16148 { 16149 16150 portmod_dispatch_type_t __type__; 16151 int __rv__; 16152 SOC_INIT_FUNC_DEFS; 16153 16154 if(cfg == NULL) { 16155 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cfg NULL parameter")); 16156 } 16157 if(SOC_E_NONE != portmod_port_synce_clk_ctrl_t_init(unit, cfg)) { 16158 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("cfg initialization failed")); 16159 } 16160 16161 /* Dispatch */ 16162 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16163 if(__type__ >= portmodDispatchTypeCount) { 16164 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16165 } 16166 16167 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_synce_clk_ctrl_get) { 16168 pm_info_t pm_info; 16169 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16170 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_synce_clk_ctrl_get(unit, port, pm_info, cfg); 16171 _SOC_IF_ERR_EXIT(__rv__); 16172 } else { 16173 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_synce_clk_ctrl_get isn't implemented for driver type")); 16174 } 16175 16176 exit: 16177 SOC_FUNC_RETURN; 16178 16179 } 16180 16181 16182 #ifdef CPRIMOD_SUPPORT 16183 int portmod_cpri_rx_agnostic_config_info_t_validate(int unit, const portmod_cpri_rx_agnostic_config_info_t* portmod_cpri_rx_agnostic_config_info) 16184 { 16185 SOC_INIT_FUNC_DEFS; 16186 if(portmod_cpri_rx_agnostic_config_info == NULL) { 16187 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 16188 } 16189 16190 16191 16192 exit: 16193 SOC_FUNC_RETURN; 16194 16195 } 16196 #endif /* CPRIMOD_SUPPORT */ 16197 16198 #ifdef CPRIMOD_SUPPORT 16199 int portmod_cpri_rx_agnostic_config_info_t_init(int unit, portmod_cpri_rx_agnostic_config_info_t* portmod_cpri_rx_agnostic_config_info) 16200 { 16201 SOC_INIT_FUNC_DEFS; 16202 16203 if(portmod_cpri_rx_agnostic_config_info == NULL){ 16204 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_rx_agnostic_config_info NULL parameter")); 16205 } 16206 sal_memset(portmod_cpri_rx_agnostic_config_info, 0, sizeof(portmod_cpri_rx_agnostic_config_info_t)); 16207 portmod_cpri_rx_agnostic_config_info->sync_mode = PORTMOD_CPRI_FRAME_SYNC_MODE_BASIC; 16208 portmod_cpri_rx_agnostic_config_info->basic_frame_offset = 0; 16209 portmod_cpri_rx_agnostic_config_info->hyper_frame_offset = 0; 16210 portmod_cpri_rx_agnostic_config_info->radio_frame_offset = 0; 16211 portmod_cpri_rx_agnostic_config_info->payload_multiple = PORTMOD_CPRI_PAYLOAD_MULTIPLE_1X; 16212 portmod_cpri_rx_agnostic_config_info->pres_mod_count = 0; 16213 portmod_cpri_rx_agnostic_config_info->ordering_info_option = PORTMOD_CPRI_ROE_ORDERING_INFO_OPTION_TIMESTAMP; 16214 16215 16216 exit: 16217 SOC_FUNC_RETURN; 16218 16219 } 16220 #endif /* CPRIMOD_SUPPORT */ 16221 16222 #ifdef CPRIMOD_SUPPORT 16223 int portmod_cpri_port_rx_agnostic_config_set(int unit, int port, int enable, const portmod_cpri_rx_agnostic_config_info_t* config_info) 16224 { 16225 16226 portmod_dispatch_type_t __type__; 16227 int __rv__; 16228 SOC_INIT_FUNC_DEFS; 16229 16230 if(SOC_E_NONE != portmod_cpri_rx_agnostic_config_info_t_validate(unit, config_info)) { 16231 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 16232 } 16233 16234 /* Dispatch */ 16235 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16236 if(__type__ >= portmodDispatchTypeCount) { 16237 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16238 } 16239 16240 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_agnostic_config_set) { 16241 pm_info_t pm_info; 16242 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16243 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_agnostic_config_set(unit, port, pm_info, enable, config_info); 16244 _SOC_IF_ERR_EXIT(__rv__); 16245 } else { 16246 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_agnostic_config_set isn't implemented for driver type")); 16247 } 16248 16249 exit: 16250 SOC_FUNC_RETURN; 16251 16252 } 16253 #endif /* CPRIMOD_SUPPORT */ 16254 16255 16256 #ifdef CPRIMOD_SUPPORT 16257 int portmod_cpri_port_rx_agnostic_config_get(int unit, int port, int* enable, portmod_cpri_rx_agnostic_config_info_t* config_info) 16258 { 16259 16260 portmod_dispatch_type_t __type__; 16261 int __rv__; 16262 SOC_INIT_FUNC_DEFS; 16263 16264 if(enable == NULL) { 16265 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 16266 } 16267 if(config_info == NULL) { 16268 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 16269 } 16270 if(SOC_E_NONE != portmod_cpri_rx_agnostic_config_info_t_init(unit, config_info)) { 16271 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 16272 } 16273 16274 /* Dispatch */ 16275 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16276 if(__type__ >= portmodDispatchTypeCount) { 16277 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16278 } 16279 16280 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_agnostic_config_get) { 16281 pm_info_t pm_info; 16282 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16283 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_agnostic_config_get(unit, port, pm_info, enable, config_info); 16284 _SOC_IF_ERR_EXIT(__rv__); 16285 } else { 16286 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_agnostic_config_get isn't implemented for driver type")); 16287 } 16288 16289 exit: 16290 SOC_FUNC_RETURN; 16291 16292 } 16293 #endif /* CPRIMOD_SUPPORT */ 16294 16295 16296 #ifdef CPRIMOD_SUPPORT 16297 int portmod_cpri_tx_agnostic_config_info_t_validate(int unit, const portmod_cpri_tx_agnostic_config_info_t* portmod_cpri_tx_agnostic_config_info) 16298 { 16299 SOC_INIT_FUNC_DEFS; 16300 if(portmod_cpri_tx_agnostic_config_info == NULL) { 16301 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 16302 } 16303 16304 16305 16306 exit: 16307 SOC_FUNC_RETURN; 16308 16309 } 16310 #endif /* CPRIMOD_SUPPORT */ 16311 16312 #ifdef CPRIMOD_SUPPORT 16313 int portmod_cpri_tx_agnostic_config_info_t_init(int unit, portmod_cpri_tx_agnostic_config_info_t* portmod_cpri_tx_agnostic_config_info) 16314 { 16315 SOC_INIT_FUNC_DEFS; 16316 16317 if(portmod_cpri_tx_agnostic_config_info == NULL){ 16318 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_tx_agnostic_config_info NULL parameter")); 16319 } 16320 sal_memset(portmod_cpri_tx_agnostic_config_info, 0, sizeof(portmod_cpri_tx_agnostic_config_info_t)); 16321 portmod_cpri_tx_agnostic_config_info->sync_mode = PORTMOD_CPRI_FRAME_SYNC_MODE_BASIC; 16322 portmod_cpri_tx_agnostic_config_info->basic_frame_offset = 0; 16323 portmod_cpri_tx_agnostic_config_info->hyper_frame_offset = 0; 16324 portmod_cpri_tx_agnostic_config_info->radio_frame_offset = 0; 16325 portmod_cpri_tx_agnostic_config_info->payload_multiple = PORTMOD_CPRI_PAYLOAD_MULTIPLE_1X; 16326 portmod_cpri_tx_agnostic_config_info->queue_mod_count = 0; 16327 portmod_cpri_tx_agnostic_config_info->pres_mod_count = 0; 16328 portmod_cpri_tx_agnostic_config_info->pres_mod_offset = 0; 16329 portmod_cpri_tx_agnostic_config_info->ordering_info_option = PORTMOD_CPRI_ROE_ORDERING_INFO_OPTION_TIMESTAMP; 16330 16331 16332 exit: 16333 SOC_FUNC_RETURN; 16334 16335 } 16336 #endif /* CPRIMOD_SUPPORT */ 16337 16338 #ifdef CPRIMOD_SUPPORT 16339 int portmod_cpri_port_tx_agnostic_config_set(int unit, int port, int enable, const portmod_cpri_tx_agnostic_config_info_t* config_info) 16340 { 16341 16342 portmod_dispatch_type_t __type__; 16343 int __rv__; 16344 SOC_INIT_FUNC_DEFS; 16345 16346 if(SOC_E_NONE != portmod_cpri_tx_agnostic_config_info_t_validate(unit, config_info)) { 16347 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 16348 } 16349 16350 /* Dispatch */ 16351 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16352 if(__type__ >= portmodDispatchTypeCount) { 16353 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16354 } 16355 16356 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_agnostic_config_set) { 16357 pm_info_t pm_info; 16358 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16359 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_agnostic_config_set(unit, port, pm_info, enable, config_info); 16360 _SOC_IF_ERR_EXIT(__rv__); 16361 } else { 16362 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_agnostic_config_set isn't implemented for driver type")); 16363 } 16364 16365 exit: 16366 SOC_FUNC_RETURN; 16367 16368 } 16369 #endif /* CPRIMOD_SUPPORT */ 16370 16371 16372 #ifdef CPRIMOD_SUPPORT 16373 int portmod_cpri_port_tx_agnostic_config_get(int unit, int port, int* enable, portmod_cpri_tx_agnostic_config_info_t* config_info) 16374 { 16375 16376 portmod_dispatch_type_t __type__; 16377 int __rv__; 16378 SOC_INIT_FUNC_DEFS; 16379 16380 if(enable == NULL) { 16381 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 16382 } 16383 if(config_info == NULL) { 16384 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 16385 } 16386 if(SOC_E_NONE != portmod_cpri_tx_agnostic_config_info_t_init(unit, config_info)) { 16387 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 16388 } 16389 16390 /* Dispatch */ 16391 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16392 if(__type__ >= portmodDispatchTypeCount) { 16393 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16394 } 16395 16396 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_agnostic_config_get) { 16397 pm_info_t pm_info; 16398 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16399 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_agnostic_config_get(unit, port, pm_info, enable, config_info); 16400 _SOC_IF_ERR_EXIT(__rv__); 16401 } else { 16402 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_agnostic_config_get isn't implemented for driver type")); 16403 } 16404 16405 exit: 16406 SOC_FUNC_RETURN; 16407 16408 } 16409 #endif /* CPRIMOD_SUPPORT */ 16410 16411 16412 #ifdef CPRIMOD_SUPPORT 16413 int portmod_cpri_port_encap_presentation_time_config_set(int unit, int port, portmod_presentation_time_attribute_t attribute, const portmod_presentation_time_t* time) 16414 { 16415 16416 portmod_dispatch_type_t __type__; 16417 int __rv__; 16418 SOC_INIT_FUNC_DEFS; 16419 16420 /* Dispatch */ 16421 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16422 if(__type__ >= portmodDispatchTypeCount) { 16423 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16424 } 16425 16426 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_presentation_time_config_set) { 16427 pm_info_t pm_info; 16428 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16429 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_presentation_time_config_set(unit, port, pm_info, attribute, time); 16430 _SOC_IF_ERR_EXIT(__rv__); 16431 } else { 16432 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_presentation_time_config_set isn't implemented for driver type")); 16433 } 16434 16435 exit: 16436 SOC_FUNC_RETURN; 16437 16438 } 16439 #endif /* CPRIMOD_SUPPORT */ 16440 16441 16442 #ifdef CPRIMOD_SUPPORT 16443 int portmod_cpri_port_encap_presentation_time_config_get(int unit, int port, portmod_presentation_time_attribute_t attribute, portmod_presentation_time_t* time) 16444 { 16445 16446 portmod_dispatch_type_t __type__; 16447 int __rv__; 16448 SOC_INIT_FUNC_DEFS; 16449 16450 if(time == NULL) { 16451 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("time NULL parameter")); 16452 } 16453 /* Dispatch */ 16454 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16455 if(__type__ >= portmodDispatchTypeCount) { 16456 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16457 } 16458 16459 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_presentation_time_config_get) { 16460 pm_info_t pm_info; 16461 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16462 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_encap_presentation_time_config_get(unit, port, pm_info, attribute, time); 16463 _SOC_IF_ERR_EXIT(__rv__); 16464 } else { 16465 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_encap_presentation_time_config_get isn't implemented for driver type")); 16466 } 16467 16468 exit: 16469 SOC_FUNC_RETURN; 16470 16471 } 16472 #endif /* CPRIMOD_SUPPORT */ 16473 16474 16475 #ifdef CPRIMOD_SUPPORT 16476 int portmod_cpri_port_decap_presentation_time_config_set(int unit, int port, const portmod_decap_presentation_time_config_t* config) 16477 { 16478 16479 portmod_dispatch_type_t __type__; 16480 int __rv__; 16481 SOC_INIT_FUNC_DEFS; 16482 16483 /* Dispatch */ 16484 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16485 if(__type__ >= portmodDispatchTypeCount) { 16486 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16487 } 16488 16489 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_presentation_time_config_set) { 16490 pm_info_t pm_info; 16491 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16492 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_presentation_time_config_set(unit, port, pm_info, config); 16493 _SOC_IF_ERR_EXIT(__rv__); 16494 } else { 16495 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_presentation_time_config_set isn't implemented for driver type")); 16496 } 16497 16498 exit: 16499 SOC_FUNC_RETURN; 16500 16501 } 16502 #endif /* CPRIMOD_SUPPORT */ 16503 16504 16505 #ifdef CPRIMOD_SUPPORT 16506 int portmod_cpri_port_decap_presentation_time_config_get(int unit, int port, portmod_decap_presentation_time_config_t* config) 16507 { 16508 16509 portmod_dispatch_type_t __type__; 16510 int __rv__; 16511 SOC_INIT_FUNC_DEFS; 16512 16513 if(config == NULL) { 16514 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 16515 } 16516 /* Dispatch */ 16517 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16518 if(__type__ >= portmodDispatchTypeCount) { 16519 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16520 } 16521 16522 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_presentation_time_config_get) { 16523 pm_info_t pm_info; 16524 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16525 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_presentation_time_config_get(unit, port, pm_info, config); 16526 _SOC_IF_ERR_EXIT(__rv__); 16527 } else { 16528 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_presentation_time_config_get isn't implemented for driver type")); 16529 } 16530 16531 exit: 16532 SOC_FUNC_RETURN; 16533 16534 } 16535 #endif /* CPRIMOD_SUPPORT */ 16536 16537 16538 #ifdef CPRIMOD_SUPPORT 16539 int portmod_cpri_port_compression_lookup_table_set(int unit, int port, int table_depth, const uint32* table) 16540 { 16541 16542 portmod_dispatch_type_t __type__; 16543 int __rv__; 16544 SOC_INIT_FUNC_DEFS; 16545 16546 /* Dispatch */ 16547 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16548 if(__type__ >= portmodDispatchTypeCount) { 16549 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16550 } 16551 16552 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_lookup_table_set) { 16553 pm_info_t pm_info; 16554 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16555 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_lookup_table_set(unit, port, pm_info, table_depth, table); 16556 _SOC_IF_ERR_EXIT(__rv__); 16557 } else { 16558 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_compression_lookup_table_set isn't implemented for driver type")); 16559 } 16560 16561 exit: 16562 SOC_FUNC_RETURN; 16563 16564 } 16565 #endif /* CPRIMOD_SUPPORT */ 16566 16567 16568 #ifdef CPRIMOD_SUPPORT 16569 int portmod_cpri_port_compression_lookup_table_get(int unit, int port, int max_depth, int* table_depth, uint32* table) 16570 { 16571 16572 portmod_dispatch_type_t __type__; 16573 int __rv__; 16574 SOC_INIT_FUNC_DEFS; 16575 16576 if(table_depth == NULL) { 16577 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("table_depth NULL parameter")); 16578 } 16579 if(table == NULL) { 16580 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("table NULL parameter")); 16581 } 16582 /* Dispatch */ 16583 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16584 if(__type__ >= portmodDispatchTypeCount) { 16585 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16586 } 16587 16588 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_lookup_table_get) { 16589 pm_info_t pm_info; 16590 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16591 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_lookup_table_get(unit, port, pm_info, max_depth, table_depth, table); 16592 _SOC_IF_ERR_EXIT(__rv__); 16593 } else { 16594 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_compression_lookup_table_get isn't implemented for driver type")); 16595 } 16596 16597 exit: 16598 SOC_FUNC_RETURN; 16599 16600 } 16601 #endif /* CPRIMOD_SUPPORT */ 16602 16603 16604 #ifdef CPRIMOD_SUPPORT 16605 int portmod_cpri_port_decompression_lookup_table_set(int unit, int port, int table_depth, const uint32* table) 16606 { 16607 16608 portmod_dispatch_type_t __type__; 16609 int __rv__; 16610 SOC_INIT_FUNC_DEFS; 16611 16612 /* Dispatch */ 16613 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16614 if(__type__ >= portmodDispatchTypeCount) { 16615 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16616 } 16617 16618 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_lookup_table_set) { 16619 pm_info_t pm_info; 16620 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16621 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_lookup_table_set(unit, port, pm_info, table_depth, table); 16622 _SOC_IF_ERR_EXIT(__rv__); 16623 } else { 16624 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decompression_lookup_table_set isn't implemented for driver type")); 16625 } 16626 16627 exit: 16628 SOC_FUNC_RETURN; 16629 16630 } 16631 #endif /* CPRIMOD_SUPPORT */ 16632 16633 16634 #ifdef CPRIMOD_SUPPORT 16635 int portmod_cpri_port_decompression_lookup_table_get(int unit, int port, int max_depth, int* table_depth, uint32* table) 16636 { 16637 16638 portmod_dispatch_type_t __type__; 16639 int __rv__; 16640 SOC_INIT_FUNC_DEFS; 16641 16642 if(table_depth == NULL) { 16643 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("table_depth NULL parameter")); 16644 } 16645 if(table == NULL) { 16646 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("table NULL parameter")); 16647 } 16648 /* Dispatch */ 16649 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16650 if(__type__ >= portmodDispatchTypeCount) { 16651 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16652 } 16653 16654 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_lookup_table_get) { 16655 pm_info_t pm_info; 16656 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16657 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_lookup_table_get(unit, port, pm_info, max_depth, table_depth, table); 16658 _SOC_IF_ERR_EXIT(__rv__); 16659 } else { 16660 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decompression_lookup_table_get isn't implemented for driver type")); 16661 } 16662 16663 exit: 16664 SOC_FUNC_RETURN; 16665 16666 } 16667 #endif /* CPRIMOD_SUPPORT */ 16668 16669 16670 #ifdef CPRIMOD_SUPPORT 16671 int portmod_cpri_port_decap_queue_flow_control_set(int unit, int port, uint32 queue_num, int enable, uint32_t xon_threshold, uint32_t xoff_threshold) 16672 { 16673 16674 portmod_dispatch_type_t __type__; 16675 int __rv__; 16676 SOC_INIT_FUNC_DEFS; 16677 16678 /* Dispatch */ 16679 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16680 if(__type__ >= portmodDispatchTypeCount) { 16681 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16682 } 16683 16684 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_flow_control_set) { 16685 pm_info_t pm_info; 16686 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16687 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_flow_control_set(unit, port, pm_info, queue_num, enable, xon_threshold, xoff_threshold); 16688 _SOC_IF_ERR_EXIT(__rv__); 16689 } else { 16690 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_queue_flow_control_set isn't implemented for driver type")); 16691 } 16692 16693 exit: 16694 SOC_FUNC_RETURN; 16695 16696 } 16697 #endif /* CPRIMOD_SUPPORT */ 16698 16699 16700 #ifdef CPRIMOD_SUPPORT 16701 int portmod_cpri_port_decap_queue_flow_control_get(int unit, int port, uint32 queue_num, int* enable, uint32_t* xon_threshold, uint32_t* xoff_threshold) 16702 { 16703 16704 portmod_dispatch_type_t __type__; 16705 int __rv__; 16706 SOC_INIT_FUNC_DEFS; 16707 16708 if(enable == NULL) { 16709 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 16710 } 16711 if(xon_threshold == NULL) { 16712 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("xon_threshold NULL parameter")); 16713 } 16714 if(xoff_threshold == NULL) { 16715 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("xoff_threshold NULL parameter")); 16716 } 16717 /* Dispatch */ 16718 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16719 if(__type__ >= portmodDispatchTypeCount) { 16720 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16721 } 16722 16723 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_flow_control_get) { 16724 pm_info_t pm_info; 16725 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16726 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decap_queue_flow_control_get(unit, port, pm_info, queue_num, enable, xon_threshold, xoff_threshold); 16727 _SOC_IF_ERR_EXIT(__rv__); 16728 } else { 16729 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decap_queue_flow_control_get isn't implemented for driver type")); 16730 } 16731 16732 exit: 16733 SOC_FUNC_RETURN; 16734 16735 } 16736 #endif /* CPRIMOD_SUPPORT */ 16737 16738 16739 #ifdef CPRIMOD_SUPPORT 16740 int portmod_fec_timestamp_config_t_validate(int unit, const portmod_fec_timestamp_config_t* portmod_fec_timestamp_config) 16741 { 16742 SOC_INIT_FUNC_DEFS; 16743 if(portmod_fec_timestamp_config == NULL) { 16744 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 16745 } 16746 16747 16748 16749 exit: 16750 SOC_FUNC_RETURN; 16751 16752 } 16753 #endif /* CPRIMOD_SUPPORT */ 16754 16755 #ifdef CPRIMOD_SUPPORT 16756 int portmod_fec_timestamp_config_t_init(int unit, portmod_fec_timestamp_config_t* portmod_fec_timestamp_config) 16757 { 16758 SOC_INIT_FUNC_DEFS; 16759 16760 if(portmod_fec_timestamp_config == NULL){ 16761 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_fec_timestamp_config NULL parameter")); 16762 } 16763 sal_memset(portmod_fec_timestamp_config, 0, sizeof(portmod_fec_timestamp_config_t)); 16764 portmod_fec_timestamp_config->enable = 0; 16765 portmod_fec_timestamp_config->fec_fifo_ts_source_select = 1; 16766 portmod_fec_timestamp_config->fec_cmic_ts_source_select = 0; 16767 portmod_fec_timestamp_config->control_bit_offset_0 = 0; 16768 portmod_fec_timestamp_config->control_bit_offset_1 = 0x45; 16769 portmod_fec_timestamp_config->control_bit_offset_2 = 0x85; 16770 portmod_fec_timestamp_config->control_bit_offset_3 = 0xc5; 16771 16772 16773 exit: 16774 SOC_FUNC_RETURN; 16775 16776 } 16777 #endif /* CPRIMOD_SUPPORT */ 16778 16779 #ifdef CPRIMOD_SUPPORT 16780 int portmod_cpri_port_fec_enable_set(int unit, int port, portmod_direction_t dir, int enable) 16781 { 16782 16783 portmod_dispatch_type_t __type__; 16784 int __rv__; 16785 SOC_INIT_FUNC_DEFS; 16786 16787 /* Dispatch */ 16788 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16789 if(__type__ >= portmodDispatchTypeCount) { 16790 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16791 } 16792 16793 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_enable_set) { 16794 pm_info_t pm_info; 16795 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16796 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_enable_set(unit, port, pm_info, dir, enable); 16797 _SOC_IF_ERR_EXIT(__rv__); 16798 } else { 16799 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_fec_enable_set isn't implemented for driver type")); 16800 } 16801 16802 exit: 16803 SOC_FUNC_RETURN; 16804 16805 } 16806 #endif /* CPRIMOD_SUPPORT */ 16807 16808 16809 #ifdef CPRIMOD_SUPPORT 16810 int portmod_cpri_port_fec_enable_get(int unit, int port, portmod_direction_t dir, int* enable) 16811 { 16812 16813 portmod_dispatch_type_t __type__; 16814 int __rv__; 16815 SOC_INIT_FUNC_DEFS; 16816 16817 if(enable == NULL) { 16818 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 16819 } 16820 /* Dispatch */ 16821 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16822 if(__type__ >= portmodDispatchTypeCount) { 16823 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16824 } 16825 16826 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_enable_get) { 16827 pm_info_t pm_info; 16828 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16829 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_enable_get(unit, port, pm_info, dir, enable); 16830 _SOC_IF_ERR_EXIT(__rv__); 16831 } else { 16832 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_fec_enable_get isn't implemented for driver type")); 16833 } 16834 16835 exit: 16836 SOC_FUNC_RETURN; 16837 16838 } 16839 #endif /* CPRIMOD_SUPPORT */ 16840 16841 16842 #ifdef CPRIMOD_SUPPORT 16843 int portmod_cpri_port_fec_timestamp_config_set(int unit, int port, portmod_direction_t dir, const portmod_fec_timestamp_config_t* config) 16844 { 16845 16846 portmod_dispatch_type_t __type__; 16847 int __rv__; 16848 SOC_INIT_FUNC_DEFS; 16849 16850 if(SOC_E_NONE != portmod_fec_timestamp_config_t_validate(unit, config)) { 16851 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 16852 } 16853 16854 /* Dispatch */ 16855 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16856 if(__type__ >= portmodDispatchTypeCount) { 16857 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16858 } 16859 16860 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_timestamp_config_set) { 16861 pm_info_t pm_info; 16862 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16863 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_timestamp_config_set(unit, port, pm_info, dir, config); 16864 _SOC_IF_ERR_EXIT(__rv__); 16865 } else { 16866 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_fec_timestamp_config_set isn't implemented for driver type")); 16867 } 16868 16869 exit: 16870 SOC_FUNC_RETURN; 16871 16872 } 16873 #endif /* CPRIMOD_SUPPORT */ 16874 16875 16876 #ifdef CPRIMOD_SUPPORT 16877 int portmod_cpri_port_fec_timestamp_config_get(int unit, int port, portmod_direction_t dir, portmod_fec_timestamp_config_t* config) 16878 { 16879 16880 portmod_dispatch_type_t __type__; 16881 int __rv__; 16882 SOC_INIT_FUNC_DEFS; 16883 16884 if(config == NULL) { 16885 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config NULL parameter")); 16886 } 16887 if(SOC_E_NONE != portmod_fec_timestamp_config_t_init(unit, config)) { 16888 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config initialization failed")); 16889 } 16890 16891 /* Dispatch */ 16892 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16893 if(__type__ >= portmodDispatchTypeCount) { 16894 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16895 } 16896 16897 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_timestamp_config_get) { 16898 pm_info_t pm_info; 16899 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16900 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_timestamp_config_get(unit, port, pm_info, dir, config); 16901 _SOC_IF_ERR_EXIT(__rv__); 16902 } else { 16903 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_fec_timestamp_config_get isn't implemented for driver type")); 16904 } 16905 16906 exit: 16907 SOC_FUNC_RETURN; 16908 16909 } 16910 #endif /* CPRIMOD_SUPPORT */ 16911 16912 16913 #ifdef CPRIMOD_SUPPORT 16914 int portmod_cpri_port_fec_aux_config_set(int unit, int port, portmod_fec_aux_config_para_t parameter_id, uint32 value) 16915 { 16916 16917 portmod_dispatch_type_t __type__; 16918 int __rv__; 16919 SOC_INIT_FUNC_DEFS; 16920 16921 /* Dispatch */ 16922 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16923 if(__type__ >= portmodDispatchTypeCount) { 16924 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16925 } 16926 16927 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_aux_config_set) { 16928 pm_info_t pm_info; 16929 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16930 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_aux_config_set(unit, port, pm_info, parameter_id, value); 16931 _SOC_IF_ERR_EXIT(__rv__); 16932 } else { 16933 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_fec_aux_config_set isn't implemented for driver type")); 16934 } 16935 16936 exit: 16937 SOC_FUNC_RETURN; 16938 16939 } 16940 #endif /* CPRIMOD_SUPPORT */ 16941 16942 16943 #ifdef CPRIMOD_SUPPORT 16944 int portmod_cpri_port_fec_aux_config_get(int unit, int port, portmod_fec_aux_config_para_t parameter_id, uint32* value) 16945 { 16946 16947 portmod_dispatch_type_t __type__; 16948 int __rv__; 16949 SOC_INIT_FUNC_DEFS; 16950 16951 if(value == NULL) { 16952 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("value NULL parameter")); 16953 } 16954 /* Dispatch */ 16955 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 16956 if(__type__ >= portmodDispatchTypeCount) { 16957 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 16958 } 16959 16960 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_aux_config_get) { 16961 pm_info_t pm_info; 16962 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 16963 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_fec_aux_config_get(unit, port, pm_info, parameter_id, value); 16964 _SOC_IF_ERR_EXIT(__rv__); 16965 } else { 16966 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_fec_aux_config_get isn't implemented for driver type")); 16967 } 16968 16969 exit: 16970 SOC_FUNC_RETURN; 16971 16972 } 16973 #endif /* CPRIMOD_SUPPORT */ 16974 16975 16976 int portmod_ecc_intr_info_t_validate(int unit, const portmod_ecc_intr_info_t* portmod_ecc_intr_info) 16977 { 16978 SOC_INIT_FUNC_DEFS; 16979 if(portmod_ecc_intr_info == NULL) { 16980 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 16981 } 16982 16983 16984 16985 exit: 16986 SOC_FUNC_RETURN; 16987 16988 } 16989 16990 int portmod_ecc_intr_info_t_init(int unit, portmod_ecc_intr_info_t* portmod_ecc_intr_info) 16991 { 16992 SOC_INIT_FUNC_DEFS; 16993 16994 if(portmod_ecc_intr_info == NULL){ 16995 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_ecc_intr_info NULL parameter")); 16996 } 16997 sal_memset(portmod_ecc_intr_info, 0, sizeof(portmod_ecc_intr_info_t)); 16998 portmod_ecc_intr_info->port = 0; 16999 portmod_ecc_intr_info->err_mem_info = INVALIDm; 17000 portmod_ecc_intr_info->ecc_reg_info = 0; 17001 portmod_ecc_intr_info->ecc_num_bits_err = 0; 17002 portmod_ecc_intr_info->err_addr = 0; 17003 portmod_ecc_intr_info->mem_str = NULL; 17004 17005 17006 exit: 17007 SOC_FUNC_RETURN; 17008 17009 } 17010 17011 #ifdef CPRIMOD_SUPPORT 17012 int portmod_cpri_port_ecc_interrupt_enable_set(int unit, int port, int enable) 17013 { 17014 17015 portmod_dispatch_type_t __type__; 17016 int __rv__; 17017 SOC_INIT_FUNC_DEFS; 17018 17019 /* Dispatch */ 17020 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17021 if(__type__ >= portmodDispatchTypeCount) { 17022 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17023 } 17024 17025 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_ecc_interrupt_enable_set) { 17026 pm_info_t pm_info; 17027 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17028 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_ecc_interrupt_enable_set(unit, port, pm_info, enable); 17029 _SOC_IF_ERR_EXIT(__rv__); 17030 } else { 17031 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_ecc_interrupt_enable_set isn't implemented for driver type")); 17032 } 17033 17034 exit: 17035 SOC_FUNC_RETURN; 17036 17037 } 17038 #endif /* CPRIMOD_SUPPORT */ 17039 17040 17041 #ifdef CPRIMOD_SUPPORT 17042 int portmod_cpri_port_ecc_interrupt_status_get(int unit, int port, const portmod_cpri_ecc_intr_info_t* ecc_err_info) 17043 { 17044 17045 portmod_dispatch_type_t __type__; 17046 int __rv__; 17047 SOC_INIT_FUNC_DEFS; 17048 17049 /* Dispatch */ 17050 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17051 if(__type__ >= portmodDispatchTypeCount) { 17052 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17053 } 17054 17055 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_ecc_interrupt_status_get) { 17056 pm_info_t pm_info; 17057 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17058 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_ecc_interrupt_status_get(unit, port, pm_info, ecc_err_info); 17059 _SOC_IF_ERR_EXIT(__rv__); 17060 } else { 17061 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_ecc_interrupt_status_get isn't implemented for driver type")); 17062 } 17063 17064 exit: 17065 SOC_FUNC_RETURN; 17066 17067 } 17068 #endif /* CPRIMOD_SUPPORT */ 17069 17070 17071 #ifdef CPRIMOD_SUPPORT 17072 int portmod_cpri_init(int unit, int port) 17073 { 17074 17075 portmod_dispatch_type_t __type__; 17076 int __rv__; 17077 SOC_INIT_FUNC_DEFS; 17078 17079 /* Dispatch */ 17080 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17081 if(__type__ >= portmodDispatchTypeCount) { 17082 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17083 } 17084 17085 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_init) { 17086 pm_info_t pm_info; 17087 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17088 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_init(unit, port, pm_info); 17089 _SOC_IF_ERR_EXIT(__rv__); 17090 } else { 17091 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_init isn't implemented for driver type")); 17092 } 17093 17094 exit: 17095 SOC_FUNC_RETURN; 17096 17097 } 17098 #endif /* CPRIMOD_SUPPORT */ 17099 17100 17101 #ifdef CPRIMOD_SUPPORT 17102 int portmod_cpri_port_rx_gcw_word_get(int unit, int port, int group_index, uint16* gcw_word) 17103 { 17104 17105 portmod_dispatch_type_t __type__; 17106 int __rv__; 17107 SOC_INIT_FUNC_DEFS; 17108 17109 if(gcw_word == NULL) { 17110 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("gcw_word NULL parameter")); 17111 } 17112 /* Dispatch */ 17113 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17114 if(__type__ >= portmodDispatchTypeCount) { 17115 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17116 } 17117 17118 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_gcw_word_get) { 17119 pm_info_t pm_info; 17120 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17121 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_gcw_word_get(unit, port, pm_info, group_index, gcw_word); 17122 _SOC_IF_ERR_EXIT(__rv__); 17123 } else { 17124 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_gcw_word_get isn't implemented for driver type")); 17125 } 17126 17127 exit: 17128 SOC_FUNC_RETURN; 17129 17130 } 17131 #endif /* CPRIMOD_SUPPORT */ 17132 17133 17134 #ifdef CPRIMOD_SUPPORT 17135 int portmod_cpri_port_tx_gcw_word_set(int unit, int port, int group_index, uint16 gcw_word) 17136 { 17137 17138 portmod_dispatch_type_t __type__; 17139 int __rv__; 17140 SOC_INIT_FUNC_DEFS; 17141 17142 /* Dispatch */ 17143 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17144 if(__type__ >= portmodDispatchTypeCount) { 17145 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17146 } 17147 17148 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_word_set) { 17149 pm_info_t pm_info; 17150 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17151 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_gcw_word_set(unit, port, pm_info, group_index, gcw_word); 17152 _SOC_IF_ERR_EXIT(__rv__); 17153 } else { 17154 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_gcw_word_set isn't implemented for driver type")); 17155 } 17156 17157 exit: 17158 SOC_FUNC_RETURN; 17159 17160 } 17161 #endif /* CPRIMOD_SUPPORT */ 17162 17163 17164 int portmod_pm_interrupt_process(int unit, int pm_id, portmod_ecc_intr_info_t* ecc_err_info) 17165 { 17166 17167 portmod_dispatch_type_t __type__; 17168 int __rv__; 17169 SOC_INIT_FUNC_DEFS; 17170 17171 if(ecc_err_info == NULL) { 17172 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ecc_err_info NULL parameter")); 17173 } 17174 if(SOC_E_NONE != portmod_ecc_intr_info_t_init(unit, ecc_err_info)) { 17175 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("ecc_err_info initialization failed")); 17176 } 17177 17178 /* Dispatch */ 17179 _SOC_IF_ERR_EXIT(portmod_pm_id_pm_type_get(unit, pm_id, &__type__)); 17180 if(__type__ >= portmodDispatchTypeCount) { 17181 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17182 } 17183 17184 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_interrupt_process) { 17185 pm_info_t pm_info; 17186 _SOC_IF_ERR_EXIT(portmod_pm_info_from_pm_id_get(unit, pm_id, &pm_info)); 17187 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_interrupt_process(unit, pm_id, pm_info, ecc_err_info); 17188 _SOC_IF_ERR_EXIT(__rv__); 17189 } else { 17190 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_interrupt_process isn't implemented for driver type")); 17191 } 17192 17193 exit: 17194 SOC_FUNC_RETURN; 17195 17196 } 17197 17198 17199 int portmod_pm_core_num_get(int unit, pm_info_t pm_info, int* core_num) 17200 { 17201 17202 portmod_dispatch_type_t __type__; 17203 int __rv__; 17204 SOC_INIT_FUNC_DEFS; 17205 17206 if(core_num == NULL) { 17207 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("core_num NULL parameter")); 17208 } 17209 /* Dispatch */ 17210 __type__ = (pm_info)->type; 17211 if(__type__ >= portmodDispatchTypeCount) { 17212 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17213 } 17214 17215 if(NULL != __portmod__dispatch__[__type__]->f_portmod_pm_core_num_get) { 17216 __rv__ = __portmod__dispatch__[__type__]->f_portmod_pm_core_num_get(unit, pm_info, core_num); 17217 _SOC_IF_ERR_EXIT(__rv__); 17218 } else { 17219 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_pm_core_num_get isn't implemented for driver type")); 17220 } 17221 17222 exit: 17223 SOC_FUNC_RETURN; 17224 17225 } 17226 17227 17228 int portmod_port_rlm_config_t_validate(int unit, const portmod_port_rlm_config_t* portmod_port_rlm_config) 17229 { 17230 SOC_INIT_FUNC_DEFS; 17231 if(portmod_port_rlm_config == NULL) { 17232 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17233 } 17234 17235 17236 17237 exit: 17238 SOC_FUNC_RETURN; 17239 17240 } 17241 17242 int portmod_port_rlm_config_t_init(int unit, portmod_port_rlm_config_t* portmod_port_rlm_config) 17243 { 17244 SOC_INIT_FUNC_DEFS; 17245 17246 if(portmod_port_rlm_config == NULL){ 17247 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_rlm_config NULL parameter")); 17248 } 17249 sal_memset(portmod_port_rlm_config, 0, sizeof(portmod_port_rlm_config_t)); 17250 17251 17252 exit: 17253 SOC_FUNC_RETURN; 17254 17255 } 17256 17257 int portmod_port_rlm_config_set(int unit, int port, int enable, const portmod_port_rlm_config_t* rlm_config) 17258 { 17259 17260 portmod_dispatch_type_t __type__; 17261 int __rv__; 17262 SOC_INIT_FUNC_DEFS; 17263 17264 if(SOC_E_NONE != portmod_port_rlm_config_t_validate(unit, rlm_config)) { 17265 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rlm_config validation failed")); 17266 } 17267 17268 /* Dispatch */ 17269 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17270 if(__type__ >= portmodDispatchTypeCount) { 17271 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17272 } 17273 17274 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rlm_config_set) { 17275 pm_info_t pm_info; 17276 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17277 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rlm_config_set(unit, port, pm_info, enable, rlm_config); 17278 _SOC_IF_ERR_EXIT(__rv__); 17279 } else { 17280 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rlm_config_set isn't implemented for driver type")); 17281 } 17282 17283 exit: 17284 SOC_FUNC_RETURN; 17285 17286 } 17287 17288 17289 int portmod_port_rlm_config_get(int unit, int port, int* enable, portmod_port_rlm_config_t* rlm_status) 17290 { 17291 17292 portmod_dispatch_type_t __type__; 17293 int __rv__; 17294 SOC_INIT_FUNC_DEFS; 17295 17296 if(enable == NULL) { 17297 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 17298 } 17299 if(rlm_status == NULL) { 17300 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rlm_status NULL parameter")); 17301 } 17302 if(SOC_E_NONE != portmod_port_rlm_config_t_init(unit, rlm_status)) { 17303 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rlm_status initialization failed")); 17304 } 17305 17306 /* Dispatch */ 17307 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17308 if(__type__ >= portmodDispatchTypeCount) { 17309 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17310 } 17311 17312 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rlm_config_get) { 17313 pm_info_t pm_info; 17314 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17315 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rlm_config_get(unit, port, pm_info, enable, rlm_status); 17316 _SOC_IF_ERR_EXIT(__rv__); 17317 } else { 17318 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rlm_config_get isn't implemented for driver type")); 17319 } 17320 17321 exit: 17322 SOC_FUNC_RETURN; 17323 17324 } 17325 17326 17327 int portmod_port_rlm_status_t_validate(int unit, const portmod_port_rlm_status_t* portmod_port_rlm_status) 17328 { 17329 SOC_INIT_FUNC_DEFS; 17330 if(portmod_port_rlm_status == NULL) { 17331 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17332 } 17333 17334 17335 17336 exit: 17337 SOC_FUNC_RETURN; 17338 17339 } 17340 17341 int portmod_port_rlm_status_t_init(int unit, portmod_port_rlm_status_t* portmod_port_rlm_status) 17342 { 17343 SOC_INIT_FUNC_DEFS; 17344 17345 if(portmod_port_rlm_status == NULL){ 17346 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_port_rlm_status NULL parameter")); 17347 } 17348 sal_memset(portmod_port_rlm_status, 0, sizeof(portmod_port_rlm_status_t)); 17349 portmod_port_rlm_status->rlm_disabled = 0; 17350 17351 17352 exit: 17353 SOC_FUNC_RETURN; 17354 17355 } 17356 17357 int portmod_port_rlm_status_get(int unit, int port, portmod_port_rlm_status_t* rlm_status) 17358 { 17359 17360 portmod_dispatch_type_t __type__; 17361 int __rv__; 17362 SOC_INIT_FUNC_DEFS; 17363 17364 if(rlm_status == NULL) { 17365 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rlm_status NULL parameter")); 17366 } 17367 if(SOC_E_NONE != portmod_port_rlm_status_t_init(unit, rlm_status)) { 17368 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("rlm_status initialization failed")); 17369 } 17370 17371 /* Dispatch */ 17372 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17373 if(__type__ >= portmodDispatchTypeCount) { 17374 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17375 } 17376 17377 if(NULL != __portmod__dispatch__[__type__]->f_portmod_port_rlm_status_get) { 17378 pm_info_t pm_info; 17379 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17380 __rv__ = __portmod__dispatch__[__type__]->f_portmod_port_rlm_status_get(unit, port, pm_info, rlm_status); 17381 _SOC_IF_ERR_EXIT(__rv__); 17382 } else { 17383 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_port_rlm_status_get isn't implemented for driver type")); 17384 } 17385 17386 exit: 17387 SOC_FUNC_RETURN; 17388 17389 } 17390 17391 17392 #ifdef CPRIMOD_SUPPORT 17393 int portmod_cpri_rx_tunnel_mode_config_t_validate(int unit, const portmod_cpri_rx_tunnel_mode_config_t* portmod_cpri_rx_tunnel_mode_config) 17394 { 17395 SOC_INIT_FUNC_DEFS; 17396 if(portmod_cpri_rx_tunnel_mode_config == NULL) { 17397 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17398 } 17399 17400 17401 17402 exit: 17403 SOC_FUNC_RETURN; 17404 17405 } 17406 #endif /* CPRIMOD_SUPPORT */ 17407 17408 #ifdef CPRIMOD_SUPPORT 17409 int portmod_cpri_rx_tunnel_mode_config_t_init(int unit, portmod_cpri_rx_tunnel_mode_config_t* portmod_cpri_rx_tunnel_mode_config) 17410 { 17411 SOC_INIT_FUNC_DEFS; 17412 17413 if(portmod_cpri_rx_tunnel_mode_config == NULL){ 17414 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_rx_tunnel_mode_config NULL parameter")); 17415 } 17416 sal_memset(portmod_cpri_rx_tunnel_mode_config, 0, sizeof(portmod_cpri_rx_tunnel_mode_config_t)); 17417 portmod_cpri_rx_tunnel_mode_config->payload_size = 0; 17418 portmod_cpri_rx_tunnel_mode_config->pres_mod_count = 0; 17419 portmod_cpri_rx_tunnel_mode_config->ordering_info_option = PORTMOD_CPRI_ROE_ORDERING_INFO_OPTION_TIMESTAMP; 17420 17421 17422 exit: 17423 SOC_FUNC_RETURN; 17424 17425 } 17426 #endif /* CPRIMOD_SUPPORT */ 17427 17428 #ifdef CPRIMOD_SUPPORT 17429 int portmod_cpri_port_rx_tunnel_mode_config_set(int unit, int port, int enable, const portmod_cpri_rx_tunnel_mode_config_t* config_info) 17430 { 17431 17432 portmod_dispatch_type_t __type__; 17433 int __rv__; 17434 SOC_INIT_FUNC_DEFS; 17435 17436 if(SOC_E_NONE != portmod_cpri_rx_tunnel_mode_config_t_validate(unit, config_info)) { 17437 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 17438 } 17439 17440 /* Dispatch */ 17441 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17442 if(__type__ >= portmodDispatchTypeCount) { 17443 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17444 } 17445 17446 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_tunnel_mode_config_set) { 17447 pm_info_t pm_info; 17448 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17449 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_tunnel_mode_config_set(unit, port, pm_info, enable, config_info); 17450 _SOC_IF_ERR_EXIT(__rv__); 17451 } else { 17452 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_tunnel_mode_config_set isn't implemented for driver type")); 17453 } 17454 17455 exit: 17456 SOC_FUNC_RETURN; 17457 17458 } 17459 #endif /* CPRIMOD_SUPPORT */ 17460 17461 17462 #ifdef CPRIMOD_SUPPORT 17463 int portmod_cpri_port_rx_tunnel_mode_config_get(int unit, int port, int* enable, portmod_cpri_rx_tunnel_mode_config_t* config_info) 17464 { 17465 17466 portmod_dispatch_type_t __type__; 17467 int __rv__; 17468 SOC_INIT_FUNC_DEFS; 17469 17470 if(enable == NULL) { 17471 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 17472 } 17473 if(config_info == NULL) { 17474 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 17475 } 17476 if(SOC_E_NONE != portmod_cpri_rx_tunnel_mode_config_t_init(unit, config_info)) { 17477 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 17478 } 17479 17480 /* Dispatch */ 17481 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17482 if(__type__ >= portmodDispatchTypeCount) { 17483 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17484 } 17485 17486 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_tunnel_mode_config_get) { 17487 pm_info_t pm_info; 17488 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17489 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_rx_tunnel_mode_config_get(unit, port, pm_info, enable, config_info); 17490 _SOC_IF_ERR_EXIT(__rv__); 17491 } else { 17492 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_rx_tunnel_mode_config_get isn't implemented for driver type")); 17493 } 17494 17495 exit: 17496 SOC_FUNC_RETURN; 17497 17498 } 17499 #endif /* CPRIMOD_SUPPORT */ 17500 17501 17502 #ifdef CPRIMOD_SUPPORT 17503 int portmod_cpri_tx_tunnel_mode_config_t_validate(int unit, const portmod_cpri_tx_tunnel_mode_config_t* portmod_cpri_tx_tunnel_mode_config) 17504 { 17505 SOC_INIT_FUNC_DEFS; 17506 if(portmod_cpri_tx_tunnel_mode_config == NULL) { 17507 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17508 } 17509 17510 17511 17512 exit: 17513 SOC_FUNC_RETURN; 17514 17515 } 17516 #endif /* CPRIMOD_SUPPORT */ 17517 17518 #ifdef CPRIMOD_SUPPORT 17519 int portmod_cpri_tx_tunnel_mode_config_t_init(int unit, portmod_cpri_tx_tunnel_mode_config_t* portmod_cpri_tx_tunnel_mode_config) 17520 { 17521 SOC_INIT_FUNC_DEFS; 17522 17523 if(portmod_cpri_tx_tunnel_mode_config == NULL){ 17524 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_tx_tunnel_mode_config NULL parameter")); 17525 } 17526 sal_memset(portmod_cpri_tx_tunnel_mode_config, 0, sizeof(portmod_cpri_tx_tunnel_mode_config_t)); 17527 portmod_cpri_tx_tunnel_mode_config->payload_size = 0; 17528 portmod_cpri_tx_tunnel_mode_config->queue_mod_count = 0; 17529 portmod_cpri_tx_tunnel_mode_config->pres_mod_count = 0; 17530 portmod_cpri_tx_tunnel_mode_config->pres_mod_offset = 0; 17531 portmod_cpri_tx_tunnel_mode_config->ordering_info_option = PORTMOD_CPRI_ROE_ORDERING_INFO_OPTION_TIMESTAMP; 17532 17533 17534 exit: 17535 SOC_FUNC_RETURN; 17536 17537 } 17538 #endif /* CPRIMOD_SUPPORT */ 17539 17540 #ifdef CPRIMOD_SUPPORT 17541 int portmod_cpri_port_tx_tunnel_mode_config_set(int unit, int port, int enable, const portmod_cpri_tx_tunnel_mode_config_t* config_info) 17542 { 17543 17544 portmod_dispatch_type_t __type__; 17545 int __rv__; 17546 SOC_INIT_FUNC_DEFS; 17547 17548 if(SOC_E_NONE != portmod_cpri_tx_tunnel_mode_config_t_validate(unit, config_info)) { 17549 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 17550 } 17551 17552 /* Dispatch */ 17553 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17554 if(__type__ >= portmodDispatchTypeCount) { 17555 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17556 } 17557 17558 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_tunnel_mode_config_set) { 17559 pm_info_t pm_info; 17560 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17561 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_tunnel_mode_config_set(unit, port, pm_info, enable, config_info); 17562 _SOC_IF_ERR_EXIT(__rv__); 17563 } else { 17564 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_tunnel_mode_config_set isn't implemented for driver type")); 17565 } 17566 17567 exit: 17568 SOC_FUNC_RETURN; 17569 17570 } 17571 #endif /* CPRIMOD_SUPPORT */ 17572 17573 17574 #ifdef CPRIMOD_SUPPORT 17575 int portmod_cpri_port_tx_tunnel_mode_config_get(int unit, int port, int* enable, portmod_cpri_tx_tunnel_mode_config_t* config_info) 17576 { 17577 17578 portmod_dispatch_type_t __type__; 17579 int __rv__; 17580 SOC_INIT_FUNC_DEFS; 17581 17582 if(enable == NULL) { 17583 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 17584 } 17585 if(config_info == NULL) { 17586 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 17587 } 17588 if(SOC_E_NONE != portmod_cpri_tx_tunnel_mode_config_t_init(unit, config_info)) { 17589 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 17590 } 17591 17592 /* Dispatch */ 17593 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17594 if(__type__ >= portmodDispatchTypeCount) { 17595 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17596 } 17597 17598 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_tunnel_mode_config_get) { 17599 pm_info_t pm_info; 17600 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17601 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_tx_tunnel_mode_config_get(unit, port, pm_info, enable, config_info); 17602 _SOC_IF_ERR_EXIT(__rv__); 17603 } else { 17604 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_tx_tunnel_mode_config_get isn't implemented for driver type")); 17605 } 17606 17607 exit: 17608 SOC_FUNC_RETURN; 17609 17610 } 17611 #endif /* CPRIMOD_SUPPORT */ 17612 17613 17614 #ifdef CPRIMOD_SUPPORT 17615 int portmod_rsvd4_rx_agnostic_config_t_validate(int unit, const portmod_rsvd4_rx_agnostic_config_t* portmod_rsvd4_rx_agnostic_config) 17616 { 17617 SOC_INIT_FUNC_DEFS; 17618 if(portmod_rsvd4_rx_agnostic_config == NULL) { 17619 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17620 } 17621 17622 17623 17624 exit: 17625 SOC_FUNC_RETURN; 17626 17627 } 17628 #endif /* CPRIMOD_SUPPORT */ 17629 17630 #ifdef CPRIMOD_SUPPORT 17631 int portmod_rsvd4_rx_agnostic_config_t_init(int unit, portmod_rsvd4_rx_agnostic_config_t* portmod_rsvd4_rx_agnostic_config) 17632 { 17633 SOC_INIT_FUNC_DEFS; 17634 17635 if(portmod_rsvd4_rx_agnostic_config == NULL){ 17636 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_rsvd4_rx_agnostic_config NULL parameter")); 17637 } 17638 sal_memset(portmod_rsvd4_rx_agnostic_config, 0, sizeof(portmod_rsvd4_rx_agnostic_config_t)); 17639 portmod_rsvd4_rx_agnostic_config->payload_multiple = 0; 17640 portmod_rsvd4_rx_agnostic_config->pres_mod_count = 0; 17641 portmod_rsvd4_rx_agnostic_config->ordering_info_option = PORTMOD_CPRI_ROE_ORDERING_INFO_OPTION_TIMESTAMP; 17642 17643 17644 exit: 17645 SOC_FUNC_RETURN; 17646 17647 } 17648 #endif /* CPRIMOD_SUPPORT */ 17649 17650 #ifdef CPRIMOD_SUPPORT 17651 int portmod_rsvd4_port_rx_agnostic_config_set(int unit, int port, int enable, const portmod_rsvd4_rx_agnostic_config_t* config_info) 17652 { 17653 17654 portmod_dispatch_type_t __type__; 17655 int __rv__; 17656 SOC_INIT_FUNC_DEFS; 17657 17658 if(SOC_E_NONE != portmod_rsvd4_rx_agnostic_config_t_validate(unit, config_info)) { 17659 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 17660 } 17661 17662 /* Dispatch */ 17663 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17664 if(__type__ >= portmodDispatchTypeCount) { 17665 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17666 } 17667 17668 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_rx_agnostic_config_set) { 17669 pm_info_t pm_info; 17670 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17671 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_rx_agnostic_config_set(unit, port, pm_info, enable, config_info); 17672 _SOC_IF_ERR_EXIT(__rv__); 17673 } else { 17674 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_port_rx_agnostic_config_set isn't implemented for driver type")); 17675 } 17676 17677 exit: 17678 SOC_FUNC_RETURN; 17679 17680 } 17681 #endif /* CPRIMOD_SUPPORT */ 17682 17683 17684 #ifdef CPRIMOD_SUPPORT 17685 int portmod_rsvd4_port_rx_agnostic_config_get(int unit, int port, int* enable, portmod_rsvd4_rx_agnostic_config_t* config_info) 17686 { 17687 17688 portmod_dispatch_type_t __type__; 17689 int __rv__; 17690 SOC_INIT_FUNC_DEFS; 17691 17692 if(enable == NULL) { 17693 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 17694 } 17695 if(config_info == NULL) { 17696 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 17697 } 17698 if(SOC_E_NONE != portmod_rsvd4_rx_agnostic_config_t_init(unit, config_info)) { 17699 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 17700 } 17701 17702 /* Dispatch */ 17703 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17704 if(__type__ >= portmodDispatchTypeCount) { 17705 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17706 } 17707 17708 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_rx_agnostic_config_get) { 17709 pm_info_t pm_info; 17710 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17711 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_rx_agnostic_config_get(unit, port, pm_info, enable, config_info); 17712 _SOC_IF_ERR_EXIT(__rv__); 17713 } else { 17714 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_port_rx_agnostic_config_get isn't implemented for driver type")); 17715 } 17716 17717 exit: 17718 SOC_FUNC_RETURN; 17719 17720 } 17721 #endif /* CPRIMOD_SUPPORT */ 17722 17723 17724 #ifdef CPRIMOD_SUPPORT 17725 int portmod_rsvd4_tx_agnostic_config_t_validate(int unit, const portmod_rsvd4_tx_agnostic_config_t* portmod_rsvd4_tx_agnostic_config) 17726 { 17727 SOC_INIT_FUNC_DEFS; 17728 if(portmod_rsvd4_tx_agnostic_config == NULL) { 17729 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17730 } 17731 17732 17733 17734 exit: 17735 SOC_FUNC_RETURN; 17736 17737 } 17738 #endif /* CPRIMOD_SUPPORT */ 17739 17740 #ifdef CPRIMOD_SUPPORT 17741 int portmod_rsvd4_tx_agnostic_config_t_init(int unit, portmod_rsvd4_tx_agnostic_config_t* portmod_rsvd4_tx_agnostic_config) 17742 { 17743 SOC_INIT_FUNC_DEFS; 17744 17745 if(portmod_rsvd4_tx_agnostic_config == NULL){ 17746 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_rsvd4_tx_agnostic_config NULL parameter")); 17747 } 17748 sal_memset(portmod_rsvd4_tx_agnostic_config, 0, sizeof(portmod_rsvd4_tx_agnostic_config_t)); 17749 portmod_rsvd4_tx_agnostic_config->payload_multiple = 0; 17750 portmod_rsvd4_tx_agnostic_config->queue_mod_count = 0; 17751 portmod_rsvd4_tx_agnostic_config->pres_mod_count = 0; 17752 portmod_rsvd4_tx_agnostic_config->pres_mod_offset = 0; 17753 portmod_rsvd4_tx_agnostic_config->ordering_info_option = PORTMOD_CPRI_ROE_ORDERING_INFO_OPTION_TIMESTAMP; 17754 17755 17756 exit: 17757 SOC_FUNC_RETURN; 17758 17759 } 17760 #endif /* CPRIMOD_SUPPORT */ 17761 17762 #ifdef CPRIMOD_SUPPORT 17763 int portmod_rsvd4_port_tx_agnostic_config_set(int unit, int port, int enable, const portmod_rsvd4_tx_agnostic_config_t* config_info) 17764 { 17765 17766 portmod_dispatch_type_t __type__; 17767 int __rv__; 17768 SOC_INIT_FUNC_DEFS; 17769 17770 if(SOC_E_NONE != portmod_rsvd4_tx_agnostic_config_t_validate(unit, config_info)) { 17771 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info validation failed")); 17772 } 17773 17774 /* Dispatch */ 17775 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17776 if(__type__ >= portmodDispatchTypeCount) { 17777 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17778 } 17779 17780 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_tx_agnostic_config_set) { 17781 pm_info_t pm_info; 17782 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17783 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_tx_agnostic_config_set(unit, port, pm_info, enable, config_info); 17784 _SOC_IF_ERR_EXIT(__rv__); 17785 } else { 17786 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_port_tx_agnostic_config_set isn't implemented for driver type")); 17787 } 17788 17789 exit: 17790 SOC_FUNC_RETURN; 17791 17792 } 17793 #endif /* CPRIMOD_SUPPORT */ 17794 17795 17796 #ifdef CPRIMOD_SUPPORT 17797 int portmod_rsvd4_port_tx_agnostic_config_get(int unit, int port, int* enable, portmod_rsvd4_tx_agnostic_config_t* config_info) 17798 { 17799 17800 portmod_dispatch_type_t __type__; 17801 int __rv__; 17802 SOC_INIT_FUNC_DEFS; 17803 17804 if(enable == NULL) { 17805 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("enable NULL parameter")); 17806 } 17807 if(config_info == NULL) { 17808 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info NULL parameter")); 17809 } 17810 if(SOC_E_NONE != portmod_rsvd4_tx_agnostic_config_t_init(unit, config_info)) { 17811 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config_info initialization failed")); 17812 } 17813 17814 /* Dispatch */ 17815 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17816 if(__type__ >= portmodDispatchTypeCount) { 17817 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17818 } 17819 17820 if(NULL != __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_tx_agnostic_config_get) { 17821 pm_info_t pm_info; 17822 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17823 __rv__ = __portmod__dispatch__[__type__]->f_portmod_rsvd4_port_tx_agnostic_config_get(unit, port, pm_info, enable, config_info); 17824 _SOC_IF_ERR_EXIT(__rv__); 17825 } else { 17826 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_rsvd4_port_tx_agnostic_config_get isn't implemented for driver type")); 17827 } 17828 17829 exit: 17830 SOC_FUNC_RETURN; 17831 17832 } 17833 #endif /* CPRIMOD_SUPPORT */ 17834 17835 17836 #ifdef CPRIMOD_SUPPORT 17837 int portmod_cpri_port_frame_config_t_validate(int unit, const portmod_cpri_port_frame_config_t* portmod_cpri_port_frame_config) 17838 { 17839 SOC_INIT_FUNC_DEFS; 17840 if(portmod_cpri_port_frame_config == NULL) { 17841 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("NULL parameter")); 17842 } 17843 17844 17845 17846 exit: 17847 SOC_FUNC_RETURN; 17848 17849 } 17850 #endif /* CPRIMOD_SUPPORT */ 17851 17852 #ifdef CPRIMOD_SUPPORT 17853 int portmod_cpri_port_frame_config_t_init(int unit, portmod_cpri_port_frame_config_t* portmod_cpri_port_frame_config) 17854 { 17855 SOC_INIT_FUNC_DEFS; 17856 17857 if(portmod_cpri_port_frame_config == NULL){ 17858 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("portmod_cpri_port_frame_config NULL parameter")); 17859 } 17860 sal_memset(portmod_cpri_port_frame_config, 0, sizeof(portmod_cpri_port_frame_config_t)); 17861 portmod_cpri_port_frame_config->frame_type = PORTMOD_CPRI_ROE_FRAME_FORMAT_IEEE1914; 17862 portmod_cpri_port_frame_config->decap_primary_key = PORTMOD_CPRI_ECPRI_HEADER_FIELD_BYTE_0; 17863 portmod_cpri_port_frame_config->decap_secondary_key = PORTMOD_CPRI_ECPRI_HEADER_FIELD_BYTE_1; 17864 17865 17866 exit: 17867 SOC_FUNC_RETURN; 17868 17869 } 17870 #endif /* CPRIMOD_SUPPORT */ 17871 17872 #ifdef CPRIMOD_SUPPORT 17873 int portmod_cpri_port_frame_config_set(int unit, int port, const portmod_cpri_port_frame_config_t* config) 17874 { 17875 17876 portmod_dispatch_type_t __type__; 17877 int __rv__; 17878 SOC_INIT_FUNC_DEFS; 17879 17880 if(SOC_E_NONE != portmod_cpri_port_frame_config_t_validate(unit, config)) { 17881 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("config validation failed")); 17882 } 17883 17884 /* Dispatch */ 17885 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17886 if(__type__ >= portmodDispatchTypeCount) { 17887 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17888 } 17889 17890 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_frame_config_set) { 17891 pm_info_t pm_info; 17892 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17893 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_frame_config_set(unit, port, pm_info, config); 17894 _SOC_IF_ERR_EXIT(__rv__); 17895 } else { 17896 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_frame_config_set isn't implemented for driver type")); 17897 } 17898 17899 exit: 17900 SOC_FUNC_RETURN; 17901 17902 } 17903 #endif /* CPRIMOD_SUPPORT */ 17904 17905 17906 #ifdef CPRIMOD_SUPPORT 17907 int portmod_cpri_port_compression_saturation_config_set(int unit, int port, uint32 threshold_value) 17908 { 17909 17910 portmod_dispatch_type_t __type__; 17911 int __rv__; 17912 SOC_INIT_FUNC_DEFS; 17913 17914 /* Dispatch */ 17915 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17916 if(__type__ >= portmodDispatchTypeCount) { 17917 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17918 } 17919 17920 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_saturation_config_set) { 17921 pm_info_t pm_info; 17922 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17923 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_saturation_config_set(unit, port, pm_info, threshold_value); 17924 _SOC_IF_ERR_EXIT(__rv__); 17925 } else { 17926 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_compression_saturation_config_set isn't implemented for driver type")); 17927 } 17928 17929 exit: 17930 SOC_FUNC_RETURN; 17931 17932 } 17933 #endif /* CPRIMOD_SUPPORT */ 17934 17935 17936 #ifdef CPRIMOD_SUPPORT 17937 int portmod_cpri_port_compression_saturation_config_get(int unit, int port, uint32* threshold_value) 17938 { 17939 17940 portmod_dispatch_type_t __type__; 17941 int __rv__; 17942 SOC_INIT_FUNC_DEFS; 17943 17944 if(threshold_value == NULL) { 17945 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("threshold_value NULL parameter")); 17946 } 17947 /* Dispatch */ 17948 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17949 if(__type__ >= portmodDispatchTypeCount) { 17950 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17951 } 17952 17953 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_saturation_config_get) { 17954 pm_info_t pm_info; 17955 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17956 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_compression_saturation_config_get(unit, port, pm_info, threshold_value); 17957 _SOC_IF_ERR_EXIT(__rv__); 17958 } else { 17959 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_compression_saturation_config_get isn't implemented for driver type")); 17960 } 17961 17962 exit: 17963 SOC_FUNC_RETURN; 17964 17965 } 17966 #endif /* CPRIMOD_SUPPORT */ 17967 17968 17969 #ifdef CPRIMOD_SUPPORT 17970 int portmod_cpri_port_decompression_saturation_config_set(int unit, int port, uint32 sat_value) 17971 { 17972 17973 portmod_dispatch_type_t __type__; 17974 int __rv__; 17975 SOC_INIT_FUNC_DEFS; 17976 17977 /* Dispatch */ 17978 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 17979 if(__type__ >= portmodDispatchTypeCount) { 17980 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 17981 } 17982 17983 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_saturation_config_set) { 17984 pm_info_t pm_info; 17985 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 17986 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_saturation_config_set(unit, port, pm_info, sat_value); 17987 _SOC_IF_ERR_EXIT(__rv__); 17988 } else { 17989 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decompression_saturation_config_set isn't implemented for driver type")); 17990 } 17991 17992 exit: 17993 SOC_FUNC_RETURN; 17994 17995 } 17996 #endif /* CPRIMOD_SUPPORT */ 17997 17998 17999 #ifdef CPRIMOD_SUPPORT 18000 int portmod_cpri_port_decompression_saturation_config_get(int unit, int port, uint32* sat_value) 18001 { 18002 18003 portmod_dispatch_type_t __type__; 18004 int __rv__; 18005 SOC_INIT_FUNC_DEFS; 18006 18007 if(sat_value == NULL) { 18008 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("sat_value NULL parameter")); 18009 } 18010 /* Dispatch */ 18011 _SOC_IF_ERR_EXIT(portmod_port_pm_type_get(unit, port, &port, &__type__)); 18012 if(__type__ >= portmodDispatchTypeCount) { 18013 _SOC_EXIT_WITH_ERR(SOC_E_PARAM, ("Driver is out of range")); 18014 } 18015 18016 if(NULL != __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_saturation_config_get) { 18017 pm_info_t pm_info; 18018 _SOC_IF_ERR_EXIT(portmod_pm_info_get(unit, port, &pm_info)); 18019 __rv__ = __portmod__dispatch__[__type__]->f_portmod_cpri_port_decompression_saturation_config_get(unit, port, pm_info, sat_value); 18020 _SOC_IF_ERR_EXIT(__rv__); 18021 } else { 18022 _SOC_EXIT_WITH_ERR(SOC_E_UNAVAIL, ("portmod_cpri_port_decompression_saturation_config_get isn't implemented for driver type")); 18023 } 18024 18025 exit: 18026 SOC_FUNC_RETURN; 18027 18028 } 18029 #endif /* CPRIMOD_SUPPORT */ 18030 18031 18032 18033 #undef _ERR_MSG_MODULE_NAME