phymod_dispatch.c (268500B)
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 <phymod/phymod.h> 14 #include <phymod/phymod_system.h> 15 #include <phymod/phymod.h> 16 #include <phymod/phymod_dispatch.h> 17 18 #ifdef PHYMOD_EAGLE_SUPPORT 19 extern __phymod__dispatch__t__ phymod_eagle_driver; 20 #endif 21 #ifdef PHYMOD_FALCON_SUPPORT 22 extern __phymod__dispatch__t__ phymod_falcon_driver; 23 #endif 24 #ifdef PHYMOD_QSGMIIE_SUPPORT 25 extern __phymod__dispatch__t__ phymod_qsgmiie_driver; 26 #endif 27 #ifdef PHYMOD_TSCE_SUPPORT 28 extern __phymod__dispatch__t__ phymod_tsce_driver; 29 #endif 30 #ifdef PHYMOD_TSCF_SUPPORT 31 extern __phymod__dispatch__t__ phymod_tscf_driver; 32 #endif 33 #ifdef PHYMOD_PHY8806X_SUPPORT 34 extern __phymod__dispatch__t__ phymod_phy8806x_driver; 35 #endif 36 #ifdef PHYMOD_FURIA_SUPPORT 37 extern __phymod__dispatch__t__ phymod_furia_driver; 38 #endif 39 #ifdef PHYMOD_VIPER_SUPPORT 40 extern __phymod__dispatch__t__ phymod_viper_driver; 41 #endif 42 #ifdef PHYMOD_SESTO_SUPPORT 43 extern __phymod__dispatch__t__ phymod_sesto_driver; 44 #endif 45 #ifdef PHYMOD_QUADRA28_SUPPORT 46 extern __phymod__dispatch__t__ phymod_quadra28_driver; 47 #endif 48 #ifdef PHYMOD_QTCE_SUPPORT 49 extern __phymod__dispatch__t__ phymod_qtce_driver; 50 #endif 51 #ifdef PHYMOD_HURACAN_SUPPORT 52 extern __phymod__dispatch__t__ phymod_huracan_driver; 53 #endif 54 #ifdef PHYMOD_MADURA_SUPPORT 55 extern __phymod__dispatch__t__ phymod_madura_driver; 56 #endif 57 #ifdef PHYMOD_FURIA_SUPPORT 58 extern __phymod__dispatch__t__ phymod_furia_82212_driver; 59 #endif 60 #ifdef PHYMOD_DINO_SUPPORT 61 extern __phymod__dispatch__t__ phymod_dino_driver; 62 #endif 63 #ifdef PHYMOD_TSCE_DPLL_SUPPORT 64 extern __phymod__dispatch__t__ phymod_tsce_dpll_driver; 65 #endif 66 #ifdef PHYMOD_EAGLE_DPLL_SUPPORT 67 extern __phymod__dispatch__t__ phymod_eagle_dpll_driver; 68 #endif 69 #ifdef PHYMOD_TSCF16_SUPPORT 70 extern __phymod__dispatch__t__ phymod_tscf16_driver; 71 #endif 72 #ifdef PHYMOD_FALCON16_SUPPORT 73 extern __phymod__dispatch__t__ phymod_falcon16_driver; 74 #endif 75 #ifdef PHYMOD_MERLIN16_SUPPORT 76 extern __phymod__dispatch__t__ phymod_merlin16_driver; 77 #endif 78 #ifdef PHYMOD_TSCE16_SUPPORT 79 extern __phymod__dispatch__t__ phymod_tsce16_driver; 80 #endif 81 #ifdef PHYMOD_TSCF_GEN3_SUPPORT 82 extern __phymod__dispatch__t__ phymod_tscf_gen3_driver; 83 #endif 84 #ifdef PHYMOD_FALCON_DPLL_SUPPORT 85 extern __phymod__dispatch__t__ phymod_falcon_dpll_driver; 86 #endif 87 #ifdef PHYMOD_BLACKHAWK_SUPPORT 88 extern __phymod__dispatch__t__ phymod_blackhawk_driver; 89 #endif 90 #ifdef PHYMOD_TSCBH_SUPPORT 91 extern __phymod__dispatch__t__ phymod_tscbh_driver; 92 #endif 93 #ifdef PHYMOD_QTCE16_SUPPORT 94 extern __phymod__dispatch__t__ phymod_qtce16_driver; 95 #endif 96 #ifdef PHYMOD_NULL_SUPPORT 97 extern __phymod__dispatch__t__ phymod_null_driver; 98 #endif 99 __phymod__dispatch__t__ phymod_Invalid_driver = {NULL}; 100 #ifdef PHYMOD_BLACKHAWK7_V1L8P2_SUPPORT 101 extern __phymod__dispatch__t__ phymod_blackhawk7_v1l8p2_driver; 102 #endif 103 #ifdef PHYMOD_TSCBH_GEN2_SUPPORT 104 extern __phymod__dispatch__t__ phymod_tscbh_gen2_driver; 105 #endif 106 #ifdef PHYMOD_MERLIN7_SUPPORT 107 extern __phymod__dispatch__t__ phymod_merlin7_driver; 108 #endif 109 #ifdef PHYMOD_TSCE7_SUPPORT 110 extern __phymod__dispatch__t__ phymod_tsce7_driver; 111 #endif 112 113 __phymod__dispatch__t__* __phymod__dispatch__[phymodDispatchTypeCount] = { 114 #ifdef PHYMOD_EAGLE_SUPPORT 115 &phymod_eagle_driver, 116 #endif 117 #ifdef PHYMOD_FALCON_SUPPORT 118 &phymod_falcon_driver, 119 #endif 120 #ifdef PHYMOD_QSGMIIE_SUPPORT 121 &phymod_qsgmiie_driver, 122 #endif 123 #ifdef PHYMOD_TSCE_SUPPORT 124 &phymod_tsce_driver, 125 #endif 126 #ifdef PHYMOD_TSCF_SUPPORT 127 &phymod_tscf_driver, 128 #endif 129 #ifdef PHYMOD_PHY8806X_SUPPORT 130 &phymod_phy8806x_driver, 131 #endif 132 #ifdef PHYMOD_FURIA_SUPPORT 133 &phymod_furia_driver, 134 #endif 135 #ifdef PHYMOD_VIPER_SUPPORT 136 &phymod_viper_driver, 137 #endif 138 #ifdef PHYMOD_SESTO_SUPPORT 139 &phymod_sesto_driver, 140 #endif 141 #ifdef PHYMOD_QUADRA28_SUPPORT 142 &phymod_quadra28_driver, 143 #endif 144 #ifdef PHYMOD_QTCE_SUPPORT 145 &phymod_qtce_driver, 146 #endif 147 #ifdef PHYMOD_HURACAN_SUPPORT 148 &phymod_huracan_driver, 149 #endif 150 #ifdef PHYMOD_MADURA_SUPPORT 151 &phymod_madura_driver, 152 #endif 153 #ifdef PHYMOD_FURIA_SUPPORT 154 &phymod_furia_82212_driver, 155 #endif 156 #ifdef PHYMOD_DINO_SUPPORT 157 &phymod_dino_driver, 158 #endif 159 #ifdef PHYMOD_TSCE_DPLL_SUPPORT 160 &phymod_tsce_dpll_driver, 161 #endif 162 #ifdef PHYMOD_EAGLE_DPLL_SUPPORT 163 &phymod_eagle_dpll_driver, 164 #endif 165 #ifdef PHYMOD_TSCF16_SUPPORT 166 &phymod_tscf16_driver, 167 #endif 168 #ifdef PHYMOD_FALCON16_SUPPORT 169 &phymod_falcon16_driver, 170 #endif 171 #ifdef PHYMOD_MERLIN16_SUPPORT 172 &phymod_merlin16_driver, 173 #endif 174 #ifdef PHYMOD_TSCE16_SUPPORT 175 &phymod_tsce16_driver, 176 #endif 177 #ifdef PHYMOD_TSCF_GEN3_SUPPORT 178 &phymod_tscf_gen3_driver, 179 #endif 180 #ifdef PHYMOD_FALCON_DPLL_SUPPORT 181 &phymod_falcon_dpll_driver, 182 #endif 183 #ifdef PHYMOD_BLACKHAWK_SUPPORT 184 &phymod_blackhawk_driver, 185 #endif 186 #ifdef PHYMOD_TSCBH_SUPPORT 187 &phymod_tscbh_driver, 188 #endif 189 #ifdef PHYMOD_QTCE16_SUPPORT 190 &phymod_qtce16_driver, 191 #endif 192 #ifdef PHYMOD_NULL_SUPPORT 193 &phymod_null_driver, 194 #endif 195 &phymod_Invalid_driver, 196 #ifdef PHYMOD_BLACKHAWK7_V1L8P2_SUPPORT 197 &phymod_blackhawk7_v1l8p2_driver, 198 #endif 199 #ifdef PHYMOD_TSCBH_GEN2_SUPPORT 200 &phymod_tscbh_gen2_driver, 201 #endif 202 #ifdef PHYMOD_MERLIN7_SUPPORT 203 &phymod_merlin7_driver, 204 #endif 205 #ifdef PHYMOD_TSCE7_SUPPORT 206 &phymod_tsce7_driver, 207 #endif 208 209 }; 210 211 int phymod_dispatch_type_t_validate(phymod_dispatch_type_t phymod_dispatch_type) 212 { 213 if(phymod_dispatch_type >= phymodDispatchTypeCount) { 214 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 215 } 216 217 return PHYMOD_E_NONE; 218 219 } 220 221 int phymod_mem_type_t_validate(phymod_mem_type_t phymod_mem_type) 222 { 223 if(phymod_mem_type >= phymodMemCount) { 224 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 225 } 226 227 return PHYMOD_E_NONE; 228 229 } 230 231 int phymod_bus_t_validate(const phymod_bus_t* phymod_bus) 232 { 233 if(phymod_bus == NULL) { 234 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 235 } 236 237 PHYMOD_NULL_CHECK(phymod_bus->bus_name); 238 PHYMOD_NULL_CHECK(phymod_bus->read); 239 PHYMOD_NULL_CHECK(phymod_bus->write); 240 241 242 return PHYMOD_E_NONE; 243 244 } 245 246 int phymod_bus_t_init(phymod_bus_t* phymod_bus) 247 { 248 249 if(phymod_bus == NULL){ 250 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_bus NULL parameter"))); 251 } 252 PHYMOD_MEMSET(phymod_bus, 0, sizeof(phymod_bus_t)); 253 phymod_bus->bus_name = NULL; 254 phymod_bus->read = NULL; 255 phymod_bus->write = NULL; 256 phymod_bus->is_write_disabled = NULL; 257 phymod_bus->mutex_take = NULL; 258 phymod_bus->mutex_give = NULL; 259 phymod_bus->mem_read = NULL; 260 phymod_bus->mem_write = NULL; 261 phymod_bus->bus_capabilities = 0; 262 263 264 return PHYMOD_E_NONE; 265 266 } 267 268 int phymod_access_t_validate(const phymod_access_t* phymod_access) 269 { 270 if(phymod_access == NULL) { 271 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 272 } 273 274 PHYMOD_NULL_CHECK(phymod_access->bus); 275 if(PHYMOD_E_OK != phymod_bus_t_validate(phymod_access->bus)) { 276 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("bus validation failed"))); 277 } 278 279 280 281 return PHYMOD_E_NONE; 282 283 } 284 285 int phymod_access_t_init(phymod_access_t* phymod_access) 286 { 287 288 if(phymod_access == NULL){ 289 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_access NULL parameter"))); 290 } 291 PHYMOD_MEMSET(phymod_access, 0, sizeof(phymod_access_t)); 292 phymod_access->user_acc = NULL; 293 phymod_access->ext_acc = NULL; 294 phymod_access->bus = NULL; 295 phymod_access->flags = 0; 296 phymod_access->lane_mask = 0; 297 phymod_access->addr = 0; 298 phymod_access->devad = 0; 299 phymod_access->pll_idx = 0; 300 phymod_access->tvco_pll_index = 1; 301 phymod_access->pmd_info_ptr = NULL; 302 303 304 return PHYMOD_E_NONE; 305 306 } 307 308 int phymod_port_loc_t_validate(phymod_port_loc_t phymod_port_loc) 309 { 310 if(phymod_port_loc >= phymodPortCount) { 311 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 312 } 313 314 return PHYMOD_E_NONE; 315 316 } 317 318 int phymod_core_access_t_validate(const phymod_core_access_t* phymod_core_access) 319 { 320 if(phymod_core_access == NULL) { 321 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 322 } 323 324 if(PHYMOD_E_OK != phymod_port_loc_t_validate(phymod_core_access->port_loc)) { 325 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("port_loc validation failed"))); 326 } 327 328 if(PHYMOD_E_OK != phymod_access_t_validate(&phymod_core_access->access)) { 329 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("access validation failed"))); 330 } 331 332 if(PHYMOD_E_OK != phymod_dispatch_type_t_validate(phymod_core_access->type)) { 333 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("type validation failed"))); 334 } 335 336 337 338 return PHYMOD_E_NONE; 339 340 } 341 342 int phymod_core_access_t_init(phymod_core_access_t* phymod_core_access) 343 { 344 345 if(phymod_core_access == NULL){ 346 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_core_access NULL parameter"))); 347 } 348 PHYMOD_MEMSET(phymod_core_access, 0, sizeof(phymod_core_access_t)); 349 phymod_core_access->port_loc = phymodPortLocDC; 350 phymod_core_access->device_op_mode = 0; 351 if(PHYMOD_E_OK != phymod_access_t_init(&phymod_core_access->access)) { 352 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("access initialization failed"))); 353 } 354 355 phymod_core_access->type = phymodDispatchTypeInvalid; 356 357 358 return PHYMOD_E_NONE; 359 360 } 361 362 int phymod_phy_access_t_validate(const phymod_phy_access_t* phymod_phy_access) 363 { 364 if(phymod_phy_access == NULL) { 365 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 366 } 367 368 if(PHYMOD_E_OK != phymod_port_loc_t_validate(phymod_phy_access->port_loc)) { 369 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("port_loc validation failed"))); 370 } 371 372 if(PHYMOD_E_OK != phymod_access_t_validate(&phymod_phy_access->access)) { 373 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("access validation failed"))); 374 } 375 376 if(PHYMOD_E_OK != phymod_dispatch_type_t_validate(phymod_phy_access->type)) { 377 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("type validation failed"))); 378 } 379 380 381 382 return PHYMOD_E_NONE; 383 384 } 385 386 int phymod_phy_access_t_init(phymod_phy_access_t* phymod_phy_access) 387 { 388 389 if(phymod_phy_access == NULL){ 390 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_access NULL parameter"))); 391 } 392 PHYMOD_MEMSET(phymod_phy_access, 0, sizeof(phymod_phy_access_t)); 393 phymod_phy_access->port_loc = phymodPortLocDC; 394 phymod_phy_access->device_op_mode = 0; 395 if(PHYMOD_E_OK != phymod_access_t_init(&phymod_phy_access->access)) { 396 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("access initialization failed"))); 397 } 398 399 phymod_phy_access->type = phymodDispatchTypeInvalid; 400 401 402 return PHYMOD_E_NONE; 403 404 } 405 406 int phymod_port_config_t_validate(const phymod_port_config_t* phymod_port_config) 407 { 408 if(phymod_port_config == NULL) { 409 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 410 } 411 412 413 414 return PHYMOD_E_NONE; 415 416 } 417 418 int phymod_port_config_t_init(phymod_port_config_t* phymod_port_config) 419 { 420 421 if(phymod_port_config == NULL){ 422 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_port_config NULL parameter"))); 423 } 424 PHYMOD_MEMSET(phymod_port_config, 0, sizeof(phymod_port_config_t)); 425 426 427 return PHYMOD_E_NONE; 428 429 } 430 431 int phymod_value_override_t_validate(const phymod_value_override_t* phymod_value_override) 432 { 433 if(phymod_value_override == NULL) { 434 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 435 } 436 437 PHYMOD_ERR_VALUE_CHECK(phymod_value_override->enable, 0xFFFFFFFF); 438 PHYMOD_ERR_VALUE_CHECK(phymod_value_override->value, 0xFFFFFFFF); 439 440 441 return PHYMOD_E_NONE; 442 443 } 444 445 int phymod_value_override_t_init(phymod_value_override_t* phymod_value_override) 446 { 447 448 if(phymod_value_override == NULL){ 449 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_value_override NULL parameter"))); 450 } 451 PHYMOD_MEMSET(phymod_value_override, 0, sizeof(phymod_value_override_t)); 452 phymod_value_override->enable = 0xFFFFFFFF; 453 phymod_value_override->value = 0xFFFFFFFF; 454 455 456 return PHYMOD_E_NONE; 457 458 } 459 460 int phymod_core_identify(const phymod_core_access_t* core, uint32_t core_id, uint32_t* is_identified) 461 { 462 463 phymod_dispatch_type_t __type__; 464 int __rv__; 465 466 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 467 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 468 } 469 470 if(is_identified == NULL) { 471 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("is_identified NULL parameter"))); 472 } 473 /* Dispatch */ 474 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 475 if(__type__ >= phymodDispatchTypeCount) { 476 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 477 } 478 479 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_identify) { 480 PHYMOD_LOCK_TAKE(core); 481 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_identify(core, core_id, is_identified); 482 PHYMOD_LOCK_GIVE(core); 483 PHYMOD_IF_ERR_RETURN(__rv__); 484 } else { 485 return PHYMOD_E_UNAVAIL; 486 } 487 488 return PHYMOD_E_NONE; 489 490 } 491 492 493 int phymod_core_version_t_validate(phymod_core_version_t phymod_core_version) 494 { 495 if(phymod_core_version >= phymodCoreVersionCount) { 496 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 497 } 498 499 return PHYMOD_E_NONE; 500 501 } 502 503 int phymod_core_info_t_validate(const phymod_core_info_t* phymod_core_info) 504 { 505 if(phymod_core_info == NULL) { 506 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 507 } 508 509 if(PHYMOD_E_OK != phymod_core_version_t_validate(phymod_core_info->core_version)) { 510 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core_version validation failed"))); 511 } 512 513 514 515 return PHYMOD_E_NONE; 516 517 } 518 519 int phymod_core_info_t_init(phymod_core_info_t* phymod_core_info) 520 { 521 522 if(phymod_core_info == NULL){ 523 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_core_info NULL parameter"))); 524 } 525 PHYMOD_MEMSET(phymod_core_info, 0, sizeof(phymod_core_info_t)); 526 527 528 return PHYMOD_E_NONE; 529 530 } 531 532 int phymod_core_info_get(const phymod_core_access_t* core, phymod_core_info_t* info) 533 { 534 535 phymod_dispatch_type_t __type__; 536 int __rv__; 537 538 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 539 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 540 } 541 542 if(info == NULL) { 543 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("info NULL parameter"))); 544 } 545 if(PHYMOD_E_OK != phymod_core_info_t_init(info)) { 546 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("info initialization failed"))); 547 } 548 549 /* Dispatch */ 550 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 551 if(__type__ >= phymodDispatchTypeCount) { 552 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 553 } 554 555 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_info_get) { 556 PHYMOD_LOCK_TAKE(core); 557 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_info_get(core, info); 558 PHYMOD_LOCK_GIVE(core); 559 PHYMOD_IF_ERR_RETURN(__rv__); 560 } else { 561 return PHYMOD_E_UNAVAIL; 562 } 563 564 return PHYMOD_E_NONE; 565 566 } 567 568 569 int phymod_lane_map_t_validate(const phymod_lane_map_t* phymod_lane_map) 570 { 571 if(phymod_lane_map == NULL) { 572 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 573 } 574 575 576 577 return PHYMOD_E_NONE; 578 579 } 580 581 int phymod_lane_map_t_init(phymod_lane_map_t* phymod_lane_map) 582 { 583 584 if(phymod_lane_map == NULL){ 585 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_lane_map NULL parameter"))); 586 } 587 PHYMOD_MEMSET(phymod_lane_map, 0, sizeof(phymod_lane_map_t)); 588 phymod_lane_map->num_of_lanes = 0; 589 590 591 return PHYMOD_E_NONE; 592 593 } 594 595 int phymod_core_lane_map_set(const phymod_core_access_t* core, const phymod_lane_map_t* lane_map) 596 { 597 598 phymod_dispatch_type_t __type__; 599 int __rv__; 600 601 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 602 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 603 } 604 605 if(PHYMOD_E_OK != phymod_lane_map_t_validate(lane_map)) { 606 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_map validation failed"))); 607 } 608 609 /* Dispatch */ 610 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 611 if(__type__ >= phymodDispatchTypeCount) { 612 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 613 } 614 615 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_lane_map_set) { 616 PHYMOD_LOCK_TAKE(core); 617 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_lane_map_set(core, lane_map); 618 PHYMOD_LOCK_GIVE(core); 619 PHYMOD_IF_ERR_RETURN(__rv__); 620 } else { 621 return PHYMOD_E_UNAVAIL; 622 } 623 624 return PHYMOD_E_NONE; 625 626 } 627 628 629 int phymod_core_lane_map_get(const phymod_core_access_t* core, phymod_lane_map_t* lane_map) 630 { 631 632 phymod_dispatch_type_t __type__; 633 int __rv__; 634 635 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 636 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 637 } 638 639 if(lane_map == NULL) { 640 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_map NULL parameter"))); 641 } 642 if(PHYMOD_E_OK != phymod_lane_map_t_init(lane_map)) { 643 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_map initialization failed"))); 644 } 645 646 /* Dispatch */ 647 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 648 if(__type__ >= phymodDispatchTypeCount) { 649 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 650 } 651 652 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_lane_map_get) { 653 PHYMOD_LOCK_TAKE(core); 654 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_lane_map_get(core, lane_map); 655 PHYMOD_LOCK_GIVE(core); 656 PHYMOD_IF_ERR_RETURN(__rv__); 657 } else { 658 return PHYMOD_E_UNAVAIL; 659 } 660 661 return PHYMOD_E_NONE; 662 663 } 664 665 666 int phymod_reset_mode_t_validate(phymod_reset_mode_t phymod_reset_mode) 667 { 668 if(phymod_reset_mode >= phymodResetModeCount) { 669 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 670 } 671 672 return PHYMOD_E_NONE; 673 674 } 675 676 int phymod_reset_direction_t_validate(phymod_reset_direction_t phymod_reset_direction) 677 { 678 if(phymod_reset_direction >= phymodResetDirectionCount) { 679 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 680 } 681 682 return PHYMOD_E_NONE; 683 684 } 685 686 int phymod_core_reset_set(const phymod_core_access_t* core, phymod_reset_mode_t reset_mode, phymod_reset_direction_t direction) 687 { 688 689 phymod_dispatch_type_t __type__; 690 int __rv__; 691 692 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 693 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 694 } 695 696 if(PHYMOD_E_OK != phymod_reset_mode_t_validate(reset_mode)) { 697 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("reset_mode validation failed"))); 698 } 699 700 if(PHYMOD_E_OK != phymod_reset_direction_t_validate(direction)) { 701 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("direction validation failed"))); 702 } 703 704 /* Dispatch */ 705 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 706 if(__type__ >= phymodDispatchTypeCount) { 707 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 708 } 709 710 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_reset_set) { 711 PHYMOD_LOCK_TAKE(core); 712 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_reset_set(core, reset_mode, direction); 713 PHYMOD_LOCK_GIVE(core); 714 PHYMOD_IF_ERR_RETURN(__rv__); 715 } else { 716 return PHYMOD_E_UNAVAIL; 717 } 718 719 return PHYMOD_E_NONE; 720 721 } 722 723 724 int phymod_core_reset_get(const phymod_core_access_t* core, phymod_reset_mode_t reset_mode, phymod_reset_direction_t* direction) 725 { 726 727 phymod_dispatch_type_t __type__; 728 int __rv__; 729 730 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 731 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 732 } 733 734 if(PHYMOD_E_OK != phymod_reset_mode_t_validate(reset_mode)) { 735 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("reset_mode validation failed"))); 736 } 737 738 if(direction == NULL) { 739 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("direction NULL parameter"))); 740 } 741 /* Dispatch */ 742 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 743 if(__type__ >= phymodDispatchTypeCount) { 744 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 745 } 746 747 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_reset_get) { 748 PHYMOD_LOCK_TAKE(core); 749 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_reset_get(core, reset_mode, direction); 750 PHYMOD_LOCK_GIVE(core); 751 PHYMOD_IF_ERR_RETURN(__rv__); 752 } else { 753 return PHYMOD_E_UNAVAIL; 754 } 755 756 return PHYMOD_E_NONE; 757 758 } 759 760 761 int phymod_core_firmware_info_t_validate(const phymod_core_firmware_info_t* phymod_core_firmware_info) 762 { 763 if(phymod_core_firmware_info == NULL) { 764 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 765 } 766 767 768 769 return PHYMOD_E_NONE; 770 771 } 772 773 int phymod_core_firmware_info_t_init(phymod_core_firmware_info_t* phymod_core_firmware_info) 774 { 775 776 if(phymod_core_firmware_info == NULL){ 777 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_core_firmware_info NULL parameter"))); 778 } 779 PHYMOD_MEMSET(phymod_core_firmware_info, 0, sizeof(phymod_core_firmware_info_t)); 780 phymod_core_firmware_info->fw_version = 0xFFFFFFFF; 781 phymod_core_firmware_info->fw_crc = 0xFFFFFFFF; 782 783 784 return PHYMOD_E_NONE; 785 786 } 787 788 int phymod_core_firmware_info_get(const phymod_core_access_t* core, phymod_core_firmware_info_t* fw_info) 789 { 790 791 phymod_dispatch_type_t __type__; 792 int __rv__; 793 794 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 795 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 796 } 797 798 if(fw_info == NULL) { 799 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_info NULL parameter"))); 800 } 801 if(PHYMOD_E_OK != phymod_core_firmware_info_t_init(fw_info)) { 802 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_info initialization failed"))); 803 } 804 805 /* Dispatch */ 806 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 807 if(__type__ >= phymodDispatchTypeCount) { 808 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 809 } 810 811 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_firmware_info_get) { 812 PHYMOD_LOCK_TAKE(core); 813 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_firmware_info_get(core, fw_info); 814 PHYMOD_LOCK_GIVE(core); 815 PHYMOD_IF_ERR_RETURN(__rv__); 816 } else { 817 return PHYMOD_E_UNAVAIL; 818 } 819 820 return PHYMOD_E_NONE; 821 822 } 823 824 825 int phymod_firmware_media_type_t_validate(phymod_firmware_media_type_t phymod_firmware_media_type) 826 { 827 if(phymod_firmware_media_type >= phymodFirmwareMediaTypeCount) { 828 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 829 } 830 831 return PHYMOD_E_NONE; 832 833 } 834 835 int phymod_firmware_core_config_t_validate(const phymod_firmware_core_config_t* phymod_firmware_core_config) 836 { 837 if(phymod_firmware_core_config == NULL) { 838 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 839 } 840 841 842 843 return PHYMOD_E_NONE; 844 845 } 846 847 int phymod_firmware_core_config_t_init(phymod_firmware_core_config_t* phymod_firmware_core_config) 848 { 849 850 if(phymod_firmware_core_config == NULL){ 851 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_firmware_core_config NULL parameter"))); 852 } 853 PHYMOD_MEMSET(phymod_firmware_core_config, 0, sizeof(phymod_firmware_core_config_t)); 854 phymod_firmware_core_config->CoreConfigFromPCS = 0x0; 855 phymod_firmware_core_config->VcoRate = 0; 856 phymod_firmware_core_config->disable_write_pll_iqp = 0; 857 phymod_firmware_core_config->osr_2p5_available = 0; 858 859 860 return PHYMOD_E_NONE; 861 862 } 863 864 int phymod_phy_firmware_core_config_set(const phymod_phy_access_t* phy, phymod_firmware_core_config_t fw_core_config) 865 { 866 867 phymod_dispatch_type_t __type__; 868 int __rv__; 869 870 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 871 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 872 } 873 874 if(PHYMOD_E_OK != phymod_firmware_core_config_t_validate(&fw_core_config)) { 875 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_core_config validation failed"))); 876 } 877 878 /* Dispatch */ 879 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 880 if(__type__ >= phymodDispatchTypeCount) { 881 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 882 } 883 884 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_firmware_core_config_set) { 885 PHYMOD_LOCK_TAKE(phy); 886 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_firmware_core_config_set(phy, fw_core_config); 887 PHYMOD_LOCK_GIVE(phy); 888 PHYMOD_IF_ERR_RETURN(__rv__); 889 } else { 890 return PHYMOD_E_UNAVAIL; 891 } 892 893 return PHYMOD_E_NONE; 894 895 } 896 897 898 int phymod_phy_firmware_core_config_get(const phymod_phy_access_t* phy, phymod_firmware_core_config_t* fw_core_config) 899 { 900 901 phymod_dispatch_type_t __type__; 902 int __rv__; 903 904 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 905 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 906 } 907 908 if(fw_core_config == NULL) { 909 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_core_config NULL parameter"))); 910 } 911 if(PHYMOD_E_OK != phymod_firmware_core_config_t_init(fw_core_config)) { 912 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_core_config initialization failed"))); 913 } 914 915 /* Dispatch */ 916 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 917 if(__type__ >= phymodDispatchTypeCount) { 918 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 919 } 920 921 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_firmware_core_config_get) { 922 PHYMOD_LOCK_TAKE(phy); 923 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_firmware_core_config_get(phy, fw_core_config); 924 PHYMOD_LOCK_GIVE(phy); 925 PHYMOD_IF_ERR_RETURN(__rv__); 926 } else { 927 return PHYMOD_E_UNAVAIL; 928 } 929 930 return PHYMOD_E_NONE; 931 932 } 933 934 935 int phymod_firmware_lane_config_t_validate(const phymod_firmware_lane_config_t* phymod_firmware_lane_config) 936 { 937 if(phymod_firmware_lane_config == NULL) { 938 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 939 } 940 941 if(PHYMOD_E_OK != phymod_firmware_media_type_t_validate(phymod_firmware_lane_config->MediaType)) { 942 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("MediaType validation failed"))); 943 } 944 945 946 947 return PHYMOD_E_NONE; 948 949 } 950 951 int phymod_firmware_lane_config_t_init(phymod_firmware_lane_config_t* phymod_firmware_lane_config) 952 { 953 954 if(phymod_firmware_lane_config == NULL){ 955 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_firmware_lane_config NULL parameter"))); 956 } 957 PHYMOD_MEMSET(phymod_firmware_lane_config, 0, sizeof(phymod_firmware_lane_config_t)); 958 phymod_firmware_lane_config->LaneConfigFromPCS = 0x0; 959 phymod_firmware_lane_config->AnEnabled = 0; 960 phymod_firmware_lane_config->DfeOn = 0; 961 phymod_firmware_lane_config->ForceBrDfe = 0; 962 phymod_firmware_lane_config->LpDfeOn = 0; 963 phymod_firmware_lane_config->UnreliableLos = 0; 964 phymod_firmware_lane_config->ScramblingDisable = 0; 965 phymod_firmware_lane_config->Cl72AutoPolEn = 0; 966 phymod_firmware_lane_config->Cl72RestTO = 0; 967 phymod_firmware_lane_config->ForceExtenedReach = 0; 968 phymod_firmware_lane_config->ForceNormalReach = 0; 969 phymod_firmware_lane_config->LpPrecoderEnabled = 0; 970 phymod_firmware_lane_config->ForcePAM4Mode = 0; 971 phymod_firmware_lane_config->ForceNRZMode = 0; 972 973 974 return PHYMOD_E_NONE; 975 976 } 977 978 int phymod_phy_firmware_lane_config_set(const phymod_phy_access_t* phy, phymod_firmware_lane_config_t fw_lane_config) 979 { 980 981 phymod_dispatch_type_t __type__; 982 int __rv__; 983 984 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 985 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 986 } 987 988 if(PHYMOD_E_OK != phymod_firmware_lane_config_t_validate(&fw_lane_config)) { 989 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_lane_config validation failed"))); 990 } 991 992 /* Dispatch */ 993 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 994 if(__type__ >= phymodDispatchTypeCount) { 995 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 996 } 997 998 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_firmware_lane_config_set) { 999 PHYMOD_LOCK_TAKE(phy); 1000 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_firmware_lane_config_set(phy, fw_lane_config); 1001 PHYMOD_LOCK_GIVE(phy); 1002 PHYMOD_IF_ERR_RETURN(__rv__); 1003 } else { 1004 return PHYMOD_E_UNAVAIL; 1005 } 1006 1007 return PHYMOD_E_NONE; 1008 1009 } 1010 1011 1012 int phymod_phy_firmware_lane_config_get(const phymod_phy_access_t* phy, phymod_firmware_lane_config_t* fw_lane_config) 1013 { 1014 1015 phymod_dispatch_type_t __type__; 1016 int __rv__; 1017 1018 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1019 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1020 } 1021 1022 if(fw_lane_config == NULL) { 1023 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_lane_config NULL parameter"))); 1024 } 1025 if(PHYMOD_E_OK != phymod_firmware_lane_config_t_init(fw_lane_config)) { 1026 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fw_lane_config initialization failed"))); 1027 } 1028 1029 /* Dispatch */ 1030 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1031 if(__type__ >= phymodDispatchTypeCount) { 1032 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1033 } 1034 1035 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_firmware_lane_config_get) { 1036 PHYMOD_LOCK_TAKE(phy); 1037 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_firmware_lane_config_get(phy, fw_lane_config); 1038 PHYMOD_LOCK_GIVE(phy); 1039 PHYMOD_IF_ERR_RETURN(__rv__); 1040 } else { 1041 return PHYMOD_E_UNAVAIL; 1042 } 1043 1044 return PHYMOD_E_NONE; 1045 1046 } 1047 1048 1049 int phymod_sequencer_operation_t_validate(phymod_sequencer_operation_t phymod_sequencer_operation) 1050 { 1051 if(phymod_sequencer_operation >= phymodSeqOpCount) { 1052 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1053 } 1054 1055 return PHYMOD_E_NONE; 1056 1057 } 1058 1059 int phymod_core_pll_sequencer_restart(const phymod_core_access_t* core, uint32_t flags, phymod_sequencer_operation_t operation) 1060 { 1061 1062 phymod_dispatch_type_t __type__; 1063 int __rv__; 1064 1065 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 1066 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 1067 } 1068 1069 if(PHYMOD_E_OK != phymod_sequencer_operation_t_validate(operation)) { 1070 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("operation validation failed"))); 1071 } 1072 1073 /* Dispatch */ 1074 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 1075 if(__type__ >= phymodDispatchTypeCount) { 1076 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1077 } 1078 1079 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_pll_sequencer_restart) { 1080 PHYMOD_LOCK_TAKE(core); 1081 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_pll_sequencer_restart(core, flags, operation); 1082 PHYMOD_LOCK_GIVE(core); 1083 PHYMOD_IF_ERR_RETURN(__rv__); 1084 } else { 1085 return PHYMOD_E_UNAVAIL; 1086 } 1087 1088 return PHYMOD_E_NONE; 1089 1090 } 1091 1092 1093 int phymod_core_event_t_validate(phymod_core_event_t phymod_core_event) 1094 { 1095 if(phymod_core_event >= phymodCoreEventCount) { 1096 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1097 } 1098 1099 return PHYMOD_E_NONE; 1100 1101 } 1102 1103 int phymod_core_wait_event(const phymod_core_access_t* core, phymod_core_event_t event, uint32_t timeout) 1104 { 1105 1106 phymod_dispatch_type_t __type__; 1107 int __rv__; 1108 1109 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 1110 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 1111 } 1112 1113 if(PHYMOD_E_OK != phymod_core_event_t_validate(event)) { 1114 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("event validation failed"))); 1115 } 1116 1117 /* Dispatch */ 1118 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 1119 if(__type__ >= phymodDispatchTypeCount) { 1120 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1121 } 1122 1123 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_wait_event) { 1124 PHYMOD_LOCK_TAKE(core); 1125 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_wait_event(core, event, timeout); 1126 PHYMOD_LOCK_GIVE(core); 1127 PHYMOD_IF_ERR_RETURN(__rv__); 1128 } else { 1129 return PHYMOD_E_UNAVAIL; 1130 } 1131 1132 return PHYMOD_E_NONE; 1133 1134 } 1135 1136 1137 int phymod_phy_rx_restart(const phymod_phy_access_t* phy) 1138 { 1139 1140 phymod_dispatch_type_t __type__; 1141 int __rv__; 1142 1143 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1144 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1145 } 1146 1147 /* Dispatch */ 1148 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1149 if(__type__ >= phymodDispatchTypeCount) { 1150 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1151 } 1152 1153 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_restart) { 1154 PHYMOD_LOCK_TAKE(phy); 1155 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_restart(phy); 1156 PHYMOD_LOCK_GIVE(phy); 1157 PHYMOD_IF_ERR_RETURN(__rv__); 1158 } else { 1159 return PHYMOD_E_UNAVAIL; 1160 } 1161 1162 return PHYMOD_E_NONE; 1163 1164 } 1165 1166 1167 int phymod_polarity_t_validate(const phymod_polarity_t* phymod_polarity) 1168 { 1169 if(phymod_polarity == NULL) { 1170 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1171 } 1172 1173 1174 1175 return PHYMOD_E_NONE; 1176 1177 } 1178 1179 int phymod_polarity_t_init(phymod_polarity_t* phymod_polarity) 1180 { 1181 1182 if(phymod_polarity == NULL){ 1183 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_polarity NULL parameter"))); 1184 } 1185 PHYMOD_MEMSET(phymod_polarity, 0, sizeof(phymod_polarity_t)); 1186 phymod_polarity->rx_polarity = 0x0; 1187 phymod_polarity->tx_polarity = 0x0; 1188 1189 1190 return PHYMOD_E_NONE; 1191 1192 } 1193 1194 int phymod_phy_polarity_set(const phymod_phy_access_t* phy, const phymod_polarity_t* polarity) 1195 { 1196 1197 phymod_dispatch_type_t __type__; 1198 int __rv__; 1199 1200 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1201 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1202 } 1203 1204 if(PHYMOD_E_OK != phymod_polarity_t_validate(polarity)) { 1205 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity validation failed"))); 1206 } 1207 1208 /* Dispatch */ 1209 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1210 if(__type__ >= phymodDispatchTypeCount) { 1211 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1212 } 1213 1214 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_polarity_set) { 1215 PHYMOD_LOCK_TAKE(phy); 1216 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_polarity_set(phy, polarity); 1217 PHYMOD_LOCK_GIVE(phy); 1218 PHYMOD_IF_ERR_RETURN(__rv__); 1219 } else { 1220 return PHYMOD_E_UNAVAIL; 1221 } 1222 1223 return PHYMOD_E_NONE; 1224 1225 } 1226 1227 1228 int phymod_phy_polarity_get(const phymod_phy_access_t* phy, phymod_polarity_t* polarity) 1229 { 1230 1231 phymod_dispatch_type_t __type__; 1232 int __rv__; 1233 1234 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1235 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1236 } 1237 1238 if(polarity == NULL) { 1239 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity NULL parameter"))); 1240 } 1241 if(PHYMOD_E_OK != phymod_polarity_t_init(polarity)) { 1242 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity initialization failed"))); 1243 } 1244 1245 /* Dispatch */ 1246 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1247 if(__type__ >= phymodDispatchTypeCount) { 1248 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1249 } 1250 1251 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_polarity_get) { 1252 PHYMOD_LOCK_TAKE(phy); 1253 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_polarity_get(phy, polarity); 1254 PHYMOD_LOCK_GIVE(phy); 1255 PHYMOD_IF_ERR_RETURN(__rv__); 1256 } else { 1257 return PHYMOD_E_UNAVAIL; 1258 } 1259 1260 return PHYMOD_E_NONE; 1261 1262 } 1263 1264 1265 int phymod_drivermode_t_validate(phymod_drivermode_t phymod_drivermode) 1266 { 1267 if(phymod_drivermode >= phymodTxDriverModeCount) { 1268 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1269 } 1270 1271 return PHYMOD_E_NONE; 1272 1273 } 1274 1275 int phymod_tx_tap_mode_t_validate(phymod_tx_tap_mode_t phymod_tx_tap_mode) 1276 { 1277 if(phymod_tx_tap_mode >= phymodTxTapModeCount) { 1278 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1279 } 1280 1281 return PHYMOD_E_NONE; 1282 1283 } 1284 1285 int phymod_phy_signalling_method_t_validate(phymod_phy_signalling_method_t phymod_phy_signalling_method) 1286 { 1287 if(phymod_phy_signalling_method >= phymodSignallingMethodCount) { 1288 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1289 } 1290 1291 return PHYMOD_E_NONE; 1292 1293 } 1294 1295 int phymod_tx_t_validate(const phymod_tx_t* phymod_tx) 1296 { 1297 if(phymod_tx == NULL) { 1298 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1299 } 1300 1301 1302 1303 return PHYMOD_E_NONE; 1304 1305 } 1306 1307 int phymod_tx_t_init(phymod_tx_t* phymod_tx) 1308 { 1309 1310 if(phymod_tx == NULL){ 1311 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_tx NULL parameter"))); 1312 } 1313 PHYMOD_MEMSET(phymod_tx, 0, sizeof(phymod_tx_t)); 1314 phymod_tx->pre = -1; 1315 phymod_tx->main = -1; 1316 phymod_tx->post = -1; 1317 phymod_tx->post2 = -1; 1318 phymod_tx->post3 = -1; 1319 phymod_tx->amp = -1; 1320 phymod_tx->drivermode = -1; 1321 phymod_tx->pre2 = -1; 1322 phymod_tx->tap_mode = phymodTxTapMode6Tap; 1323 phymod_tx->rpara = -1; 1324 phymod_tx->sig_method = phymodSignallingMethodNRZ; 1325 1326 1327 return PHYMOD_E_NONE; 1328 1329 } 1330 1331 int phymod_phy_tx_set(const phymod_phy_access_t* phy, const phymod_tx_t* tx) 1332 { 1333 1334 phymod_dispatch_type_t __type__; 1335 int __rv__; 1336 1337 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1338 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1339 } 1340 1341 if(PHYMOD_E_OK != phymod_tx_t_validate(tx)) { 1342 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx validation failed"))); 1343 } 1344 1345 /* Dispatch */ 1346 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1347 if(__type__ >= phymodDispatchTypeCount) { 1348 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1349 } 1350 1351 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_set) { 1352 PHYMOD_LOCK_TAKE(phy); 1353 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_set(phy, tx); 1354 PHYMOD_LOCK_GIVE(phy); 1355 PHYMOD_IF_ERR_RETURN(__rv__); 1356 } else { 1357 return PHYMOD_E_UNAVAIL; 1358 } 1359 1360 return PHYMOD_E_NONE; 1361 1362 } 1363 1364 1365 int phymod_phy_tx_get(const phymod_phy_access_t* phy, phymod_tx_t* tx) 1366 { 1367 1368 phymod_dispatch_type_t __type__; 1369 int __rv__; 1370 1371 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1372 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1373 } 1374 1375 if(tx == NULL) { 1376 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx NULL parameter"))); 1377 } 1378 if(PHYMOD_E_OK != phymod_tx_t_init(tx)) { 1379 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx initialization failed"))); 1380 } 1381 1382 /* Dispatch */ 1383 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1384 if(__type__ >= phymodDispatchTypeCount) { 1385 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1386 } 1387 1388 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_get) { 1389 PHYMOD_LOCK_TAKE(phy); 1390 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_get(phy, tx); 1391 PHYMOD_LOCK_GIVE(phy); 1392 PHYMOD_IF_ERR_RETURN(__rv__); 1393 } else { 1394 return PHYMOD_E_UNAVAIL; 1395 } 1396 1397 return PHYMOD_E_NONE; 1398 1399 } 1400 1401 1402 int phymod_phy_training_tx_fir_post_set(const phymod_phy_access_t* phy, uint8_t tx_post) 1403 { 1404 1405 phymod_dispatch_type_t __type__; 1406 int __rv__; 1407 1408 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1409 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1410 } 1411 1412 /* Dispatch */ 1413 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1414 if(__type__ >= phymodDispatchTypeCount) { 1415 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1416 } 1417 1418 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_training_tx_fir_post_set) { 1419 PHYMOD_LOCK_TAKE(phy); 1420 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_training_tx_fir_post_set(phy, tx_post); 1421 PHYMOD_LOCK_GIVE(phy); 1422 PHYMOD_IF_ERR_RETURN(__rv__); 1423 } else { 1424 return PHYMOD_E_UNAVAIL; 1425 } 1426 1427 return PHYMOD_E_NONE; 1428 1429 } 1430 1431 1432 int phymod_media_typed_t_validate(phymod_media_typed_t phymod_media_typed) 1433 { 1434 if(phymod_media_typed >= phymodMediaTypeCount) { 1435 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1436 } 1437 1438 return PHYMOD_E_NONE; 1439 1440 } 1441 1442 int phymod_phy_media_type_tx_get(const phymod_phy_access_t* phy, phymod_media_typed_t media, phymod_tx_t* tx) 1443 { 1444 1445 phymod_dispatch_type_t __type__; 1446 int __rv__; 1447 1448 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1449 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1450 } 1451 1452 if(PHYMOD_E_OK != phymod_media_typed_t_validate(media)) { 1453 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("media validation failed"))); 1454 } 1455 1456 if(tx == NULL) { 1457 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx NULL parameter"))); 1458 } 1459 if(PHYMOD_E_OK != phymod_tx_t_init(tx)) { 1460 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx initialization failed"))); 1461 } 1462 1463 /* Dispatch */ 1464 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1465 if(__type__ >= phymodDispatchTypeCount) { 1466 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1467 } 1468 1469 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_media_type_tx_get) { 1470 PHYMOD_LOCK_TAKE(phy); 1471 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_media_type_tx_get(phy, media, tx); 1472 PHYMOD_LOCK_GIVE(phy); 1473 PHYMOD_IF_ERR_RETURN(__rv__); 1474 } else { 1475 return PHYMOD_E_UNAVAIL; 1476 } 1477 1478 return PHYMOD_E_NONE; 1479 1480 } 1481 1482 1483 int phymod_tx_override_t_validate(const phymod_tx_override_t* phymod_tx_override) 1484 { 1485 if(phymod_tx_override == NULL) { 1486 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1487 } 1488 1489 if(PHYMOD_E_OK != phymod_value_override_t_validate(&phymod_tx_override->phase_interpolator)) { 1490 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phase_interpolator validation failed"))); 1491 } 1492 1493 1494 1495 return PHYMOD_E_NONE; 1496 1497 } 1498 1499 int phymod_tx_override_t_init(phymod_tx_override_t* phymod_tx_override) 1500 { 1501 1502 if(phymod_tx_override == NULL){ 1503 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_tx_override NULL parameter"))); 1504 } 1505 PHYMOD_MEMSET(phymod_tx_override, 0, sizeof(phymod_tx_override_t)); 1506 if(PHYMOD_E_OK != phymod_value_override_t_init(&phymod_tx_override->phase_interpolator)) { 1507 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phase_interpolator initialization failed"))); 1508 } 1509 1510 1511 1512 return PHYMOD_E_NONE; 1513 1514 } 1515 1516 int phymod_phy_tx_override_set(const phymod_phy_access_t* phy, const phymod_tx_override_t* tx_override) 1517 { 1518 1519 phymod_dispatch_type_t __type__; 1520 int __rv__; 1521 1522 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1523 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1524 } 1525 1526 if(PHYMOD_E_OK != phymod_tx_override_t_validate(tx_override)) { 1527 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_override validation failed"))); 1528 } 1529 1530 /* Dispatch */ 1531 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1532 if(__type__ >= phymodDispatchTypeCount) { 1533 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1534 } 1535 1536 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_override_set) { 1537 PHYMOD_LOCK_TAKE(phy); 1538 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_override_set(phy, tx_override); 1539 PHYMOD_LOCK_GIVE(phy); 1540 PHYMOD_IF_ERR_RETURN(__rv__); 1541 } else { 1542 return PHYMOD_E_UNAVAIL; 1543 } 1544 1545 return PHYMOD_E_NONE; 1546 1547 } 1548 1549 1550 int phymod_phy_tx_override_get(const phymod_phy_access_t* phy, phymod_tx_override_t* tx_override) 1551 { 1552 1553 phymod_dispatch_type_t __type__; 1554 int __rv__; 1555 1556 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1557 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1558 } 1559 1560 if(tx_override == NULL) { 1561 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_override NULL parameter"))); 1562 } 1563 if(PHYMOD_E_OK != phymod_tx_override_t_init(tx_override)) { 1564 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_override initialization failed"))); 1565 } 1566 1567 /* Dispatch */ 1568 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1569 if(__type__ >= phymodDispatchTypeCount) { 1570 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1571 } 1572 1573 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_override_get) { 1574 PHYMOD_LOCK_TAKE(phy); 1575 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_override_get(phy, tx_override); 1576 PHYMOD_LOCK_GIVE(phy); 1577 PHYMOD_IF_ERR_RETURN(__rv__); 1578 } else { 1579 return PHYMOD_E_UNAVAIL; 1580 } 1581 1582 return PHYMOD_E_NONE; 1583 1584 } 1585 1586 1587 int phymod_txpi_config_t_validate(const phymod_txpi_config_t* phymod_txpi_config) 1588 { 1589 if(phymod_txpi_config == NULL) { 1590 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1591 } 1592 1593 1594 1595 return PHYMOD_E_NONE; 1596 1597 } 1598 1599 int phymod_txpi_config_t_init(phymod_txpi_config_t* phymod_txpi_config) 1600 { 1601 1602 if(phymod_txpi_config == NULL){ 1603 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_txpi_config NULL parameter"))); 1604 } 1605 PHYMOD_MEMSET(phymod_txpi_config, 0, sizeof(phymod_txpi_config_t)); 1606 1607 1608 return PHYMOD_E_NONE; 1609 1610 } 1611 1612 int phymod_phy_txpi_config_set(const phymod_phy_access_t* phy, const phymod_txpi_config_t* config) 1613 { 1614 1615 phymod_dispatch_type_t __type__; 1616 int __rv__; 1617 1618 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1619 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1620 } 1621 1622 if(PHYMOD_E_OK != phymod_txpi_config_t_validate(config)) { 1623 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config validation failed"))); 1624 } 1625 1626 /* Dispatch */ 1627 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1628 if(__type__ >= phymodDispatchTypeCount) { 1629 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1630 } 1631 1632 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_txpi_config_set) { 1633 PHYMOD_LOCK_TAKE(phy); 1634 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_txpi_config_set(phy, config); 1635 PHYMOD_LOCK_GIVE(phy); 1636 PHYMOD_IF_ERR_RETURN(__rv__); 1637 } else { 1638 return PHYMOD_E_UNAVAIL; 1639 } 1640 1641 return PHYMOD_E_NONE; 1642 1643 } 1644 1645 1646 int phymod_phy_txpi_config_get(const phymod_phy_access_t* phy, phymod_txpi_config_t* config) 1647 { 1648 1649 phymod_dispatch_type_t __type__; 1650 int __rv__; 1651 1652 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1653 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1654 } 1655 1656 if(config == NULL) { 1657 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config NULL parameter"))); 1658 } 1659 if(PHYMOD_E_OK != phymod_txpi_config_t_init(config)) { 1660 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config initialization failed"))); 1661 } 1662 1663 /* Dispatch */ 1664 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1665 if(__type__ >= phymodDispatchTypeCount) { 1666 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1667 } 1668 1669 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_txpi_config_get) { 1670 PHYMOD_LOCK_TAKE(phy); 1671 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_txpi_config_get(phy, config); 1672 PHYMOD_LOCK_GIVE(phy); 1673 PHYMOD_IF_ERR_RETURN(__rv__); 1674 } else { 1675 return PHYMOD_E_UNAVAIL; 1676 } 1677 1678 return PHYMOD_E_NONE; 1679 1680 } 1681 1682 1683 int phymod_rx_t_validate(const phymod_rx_t* phymod_rx) 1684 { 1685 if(phymod_rx == NULL) { 1686 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1687 } 1688 1689 if(PHYMOD_E_OK != phymod_value_override_t_validate(&phymod_rx->peaking_filter)) { 1690 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("peaking_filter validation failed"))); 1691 } 1692 1693 1694 1695 return PHYMOD_E_NONE; 1696 1697 } 1698 1699 int phymod_rx_t_init(phymod_rx_t* phymod_rx) 1700 { 1701 int _array_iter; 1702 1703 1704 if(phymod_rx == NULL){ 1705 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_rx NULL parameter"))); 1706 } 1707 PHYMOD_MEMSET(phymod_rx, 0, sizeof(phymod_rx_t)); 1708 if(PHYMOD_E_OK != phymod_value_override_t_init(&phymod_rx->vga)) { 1709 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("vga initialization failed"))); 1710 } 1711 1712 for(_array_iter = 0 ; _array_iter < PHYMOD_NUM_DFE_TAPS ; _array_iter++){ 1713 if(PHYMOD_E_OK != phymod_value_override_t_init(&phymod_rx->dfe[_array_iter])) { 1714 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("dfe initialization failed"))); 1715 } 1716 } 1717 1718 if(PHYMOD_E_OK != phymod_value_override_t_init(&phymod_rx->peaking_filter)) { 1719 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("peaking_filter initialization failed"))); 1720 } 1721 1722 if(PHYMOD_E_OK != phymod_value_override_t_init(&phymod_rx->low_freq_peaking_filter)) { 1723 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("low_freq_peaking_filter initialization failed"))); 1724 } 1725 1726 if(PHYMOD_E_OK != phymod_value_override_t_init(&phymod_rx->high_freq_peaking_filter)) { 1727 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("high_freq_peaking_filter initialization failed"))); 1728 } 1729 1730 1731 1732 return PHYMOD_E_NONE; 1733 1734 } 1735 1736 int phymod_phy_rx_set(const phymod_phy_access_t* phy, const phymod_rx_t* rx) 1737 { 1738 1739 phymod_dispatch_type_t __type__; 1740 int __rv__; 1741 1742 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1743 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1744 } 1745 1746 if(PHYMOD_E_OK != phymod_rx_t_validate(rx)) { 1747 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx validation failed"))); 1748 } 1749 1750 /* Dispatch */ 1751 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1752 if(__type__ >= phymodDispatchTypeCount) { 1753 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1754 } 1755 1756 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_set) { 1757 PHYMOD_LOCK_TAKE(phy); 1758 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_set(phy, rx); 1759 PHYMOD_LOCK_GIVE(phy); 1760 PHYMOD_IF_ERR_RETURN(__rv__); 1761 } else { 1762 return PHYMOD_E_UNAVAIL; 1763 } 1764 1765 return PHYMOD_E_NONE; 1766 1767 } 1768 1769 1770 int phymod_phy_rx_get(const phymod_phy_access_t* phy, phymod_rx_t* rx) 1771 { 1772 1773 phymod_dispatch_type_t __type__; 1774 int __rv__; 1775 1776 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1777 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1778 } 1779 1780 if(rx == NULL) { 1781 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx NULL parameter"))); 1782 } 1783 if(PHYMOD_E_OK != phymod_rx_t_init(rx)) { 1784 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx initialization failed"))); 1785 } 1786 1787 /* Dispatch */ 1788 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1789 if(__type__ >= phymodDispatchTypeCount) { 1790 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1791 } 1792 1793 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_get) { 1794 PHYMOD_LOCK_TAKE(phy); 1795 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_get(phy, rx); 1796 PHYMOD_LOCK_GIVE(phy); 1797 PHYMOD_IF_ERR_RETURN(__rv__); 1798 } else { 1799 return PHYMOD_E_UNAVAIL; 1800 } 1801 1802 return PHYMOD_E_NONE; 1803 1804 } 1805 1806 1807 int phymod_phy_rx_adaptation_resume(const phymod_phy_access_t* phy) 1808 { 1809 1810 phymod_dispatch_type_t __type__; 1811 int __rv__; 1812 1813 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1814 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1815 } 1816 1817 /* Dispatch */ 1818 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1819 if(__type__ >= phymodDispatchTypeCount) { 1820 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1821 } 1822 1823 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_adaptation_resume) { 1824 PHYMOD_LOCK_TAKE(phy); 1825 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_adaptation_resume(phy); 1826 PHYMOD_LOCK_GIVE(phy); 1827 PHYMOD_IF_ERR_RETURN(__rv__); 1828 } else { 1829 return PHYMOD_E_UNAVAIL; 1830 } 1831 1832 return PHYMOD_E_NONE; 1833 1834 } 1835 1836 1837 int phymod_phy_reset_t_validate(const phymod_phy_reset_t* phymod_phy_reset) 1838 { 1839 if(phymod_phy_reset == NULL) { 1840 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1841 } 1842 1843 if(PHYMOD_E_OK != phymod_reset_direction_t_validate(phymod_phy_reset->rx)) { 1844 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx validation failed"))); 1845 } 1846 1847 if(PHYMOD_E_OK != phymod_reset_direction_t_validate(phymod_phy_reset->tx)) { 1848 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx validation failed"))); 1849 } 1850 1851 1852 1853 return PHYMOD_E_NONE; 1854 1855 } 1856 1857 int phymod_phy_reset_t_init(phymod_phy_reset_t* phymod_phy_reset) 1858 { 1859 1860 if(phymod_phy_reset == NULL){ 1861 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_reset NULL parameter"))); 1862 } 1863 PHYMOD_MEMSET(phymod_phy_reset, 0, sizeof(phymod_phy_reset_t)); 1864 1865 1866 return PHYMOD_E_NONE; 1867 1868 } 1869 1870 int phymod_phy_reset_set(const phymod_phy_access_t* phy, const phymod_phy_reset_t* reset) 1871 { 1872 1873 phymod_dispatch_type_t __type__; 1874 int __rv__; 1875 1876 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1877 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1878 } 1879 1880 if(PHYMOD_E_OK != phymod_phy_reset_t_validate(reset)) { 1881 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("reset validation failed"))); 1882 } 1883 1884 /* Dispatch */ 1885 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1886 if(__type__ >= phymodDispatchTypeCount) { 1887 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1888 } 1889 1890 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_reset_set) { 1891 PHYMOD_LOCK_TAKE(phy); 1892 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_reset_set(phy, reset); 1893 PHYMOD_LOCK_GIVE(phy); 1894 PHYMOD_IF_ERR_RETURN(__rv__); 1895 } else { 1896 return PHYMOD_E_UNAVAIL; 1897 } 1898 1899 return PHYMOD_E_NONE; 1900 1901 } 1902 1903 1904 int phymod_phy_reset_get(const phymod_phy_access_t* phy, phymod_phy_reset_t* reset) 1905 { 1906 1907 phymod_dispatch_type_t __type__; 1908 int __rv__; 1909 1910 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1911 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1912 } 1913 1914 if(reset == NULL) { 1915 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("reset NULL parameter"))); 1916 } 1917 if(PHYMOD_E_OK != phymod_phy_reset_t_init(reset)) { 1918 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("reset initialization failed"))); 1919 } 1920 1921 /* Dispatch */ 1922 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 1923 if(__type__ >= phymodDispatchTypeCount) { 1924 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 1925 } 1926 1927 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_reset_get) { 1928 PHYMOD_LOCK_TAKE(phy); 1929 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_reset_get(phy, reset); 1930 PHYMOD_LOCK_GIVE(phy); 1931 PHYMOD_IF_ERR_RETURN(__rv__); 1932 } else { 1933 return PHYMOD_E_UNAVAIL; 1934 } 1935 1936 return PHYMOD_E_NONE; 1937 1938 } 1939 1940 1941 int phymod_power_t_validate(phymod_power_t phymod_power) 1942 { 1943 if(phymod_power >= phymodPowerCount) { 1944 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 1945 } 1946 1947 return PHYMOD_E_NONE; 1948 1949 } 1950 1951 int phymod_phy_power_t_validate(const phymod_phy_power_t* phymod_phy_power) 1952 { 1953 if(phymod_phy_power == NULL) { 1954 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 1955 } 1956 1957 if(PHYMOD_E_OK != phymod_power_t_validate(phymod_phy_power->rx)) { 1958 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx validation failed"))); 1959 } 1960 1961 if(PHYMOD_E_OK != phymod_power_t_validate(phymod_phy_power->tx)) { 1962 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx validation failed"))); 1963 } 1964 1965 1966 1967 return PHYMOD_E_NONE; 1968 1969 } 1970 1971 int phymod_phy_power_t_init(phymod_phy_power_t* phymod_phy_power) 1972 { 1973 1974 if(phymod_phy_power == NULL){ 1975 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_power NULL parameter"))); 1976 } 1977 PHYMOD_MEMSET(phymod_phy_power, 0, sizeof(phymod_phy_power_t)); 1978 1979 1980 return PHYMOD_E_NONE; 1981 1982 } 1983 1984 int phymod_phy_power_set(const phymod_phy_access_t* phy, const phymod_phy_power_t* power) 1985 { 1986 1987 phymod_dispatch_type_t __type__; 1988 int __rv__; 1989 1990 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 1991 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 1992 } 1993 1994 if(PHYMOD_E_OK != phymod_phy_power_t_validate(power)) { 1995 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("power validation failed"))); 1996 } 1997 1998 /* Dispatch */ 1999 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2000 if(__type__ >= phymodDispatchTypeCount) { 2001 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2002 } 2003 2004 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_power_set) { 2005 PHYMOD_LOCK_TAKE(phy); 2006 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_power_set(phy, power); 2007 PHYMOD_LOCK_GIVE(phy); 2008 PHYMOD_IF_ERR_RETURN(__rv__); 2009 } else { 2010 return PHYMOD_E_UNAVAIL; 2011 } 2012 2013 return PHYMOD_E_NONE; 2014 2015 } 2016 2017 2018 int phymod_phy_power_get(const phymod_phy_access_t* phy, phymod_phy_power_t* power) 2019 { 2020 2021 phymod_dispatch_type_t __type__; 2022 int __rv__; 2023 2024 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2025 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2026 } 2027 2028 if(power == NULL) { 2029 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("power NULL parameter"))); 2030 } 2031 if(PHYMOD_E_OK != phymod_phy_power_t_init(power)) { 2032 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("power initialization failed"))); 2033 } 2034 2035 /* Dispatch */ 2036 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2037 if(__type__ >= phymodDispatchTypeCount) { 2038 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2039 } 2040 2041 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_power_get) { 2042 PHYMOD_LOCK_TAKE(phy); 2043 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_power_get(phy, power); 2044 PHYMOD_LOCK_GIVE(phy); 2045 PHYMOD_IF_ERR_RETURN(__rv__); 2046 } else { 2047 return PHYMOD_E_UNAVAIL; 2048 } 2049 2050 return PHYMOD_E_NONE; 2051 2052 } 2053 2054 2055 int phymod_phy_hg2_codec_t_validate(phymod_phy_hg2_codec_t phymod_phy_hg2_codec) 2056 { 2057 if(phymod_phy_hg2_codec >= phymodBcmHG2CodecCount) { 2058 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2059 } 2060 2061 return PHYMOD_E_NONE; 2062 2063 } 2064 2065 int phymod_phy_hg2_codec_control_set(const phymod_phy_access_t* phy, phymod_phy_hg2_codec_t hg2_codec) 2066 { 2067 2068 phymod_dispatch_type_t __type__; 2069 int __rv__; 2070 2071 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2072 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2073 } 2074 2075 if(PHYMOD_E_OK != phymod_phy_hg2_codec_t_validate(hg2_codec)) { 2076 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("hg2_codec validation failed"))); 2077 } 2078 2079 /* Dispatch */ 2080 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2081 if(__type__ >= phymodDispatchTypeCount) { 2082 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2083 } 2084 2085 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_hg2_codec_control_set) { 2086 PHYMOD_LOCK_TAKE(phy); 2087 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_hg2_codec_control_set(phy, hg2_codec); 2088 PHYMOD_LOCK_GIVE(phy); 2089 PHYMOD_IF_ERR_RETURN(__rv__); 2090 } else { 2091 return PHYMOD_E_UNAVAIL; 2092 } 2093 2094 return PHYMOD_E_NONE; 2095 2096 } 2097 2098 2099 int phymod_phy_hg2_codec_control_get(const phymod_phy_access_t* phy, phymod_phy_hg2_codec_t* hg2_codec) 2100 { 2101 2102 phymod_dispatch_type_t __type__; 2103 int __rv__; 2104 2105 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2106 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2107 } 2108 2109 if(hg2_codec == NULL) { 2110 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("hg2_codec NULL parameter"))); 2111 } 2112 /* Dispatch */ 2113 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2114 if(__type__ >= phymodDispatchTypeCount) { 2115 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2116 } 2117 2118 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_hg2_codec_control_get) { 2119 PHYMOD_LOCK_TAKE(phy); 2120 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_hg2_codec_control_get(phy, hg2_codec); 2121 PHYMOD_LOCK_GIVE(phy); 2122 PHYMOD_IF_ERR_RETURN(__rv__); 2123 } else { 2124 return PHYMOD_E_UNAVAIL; 2125 } 2126 2127 return PHYMOD_E_NONE; 2128 2129 } 2130 2131 2132 int phymod_phy_tx_lane_control_t_validate(phymod_phy_tx_lane_control_t phymod_phy_tx_lane_control) 2133 { 2134 if(phymod_phy_tx_lane_control >= phymodTxCount) { 2135 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2136 } 2137 2138 return PHYMOD_E_NONE; 2139 2140 } 2141 2142 int phymod_autoneg_oui_t_validate(const phymod_autoneg_oui_t* phymod_autoneg_oui) 2143 { 2144 if(phymod_autoneg_oui == NULL) { 2145 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 2146 } 2147 2148 2149 2150 return PHYMOD_E_NONE; 2151 2152 } 2153 2154 int phymod_autoneg_oui_t_init(phymod_autoneg_oui_t* phymod_autoneg_oui) 2155 { 2156 2157 if(phymod_autoneg_oui == NULL){ 2158 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_autoneg_oui NULL parameter"))); 2159 } 2160 PHYMOD_MEMSET(phymod_autoneg_oui, 0, sizeof(phymod_autoneg_oui_t)); 2161 phymod_autoneg_oui->oui = 0; 2162 phymod_autoneg_oui->oui_override_bam73_adv = 0; 2163 phymod_autoneg_oui->oui_override_bam73_det = 0; 2164 phymod_autoneg_oui->oui_override_hpam_adv = 0; 2165 phymod_autoneg_oui->oui_override_hpam_det = 0; 2166 phymod_autoneg_oui->oui_override_bam37_adv = 0; 2167 phymod_autoneg_oui->oui_override_bam37_det = 0; 2168 2169 2170 return PHYMOD_E_NONE; 2171 2172 } 2173 2174 int phymod_phy_rx_lane_control_t_validate(phymod_phy_rx_lane_control_t phymod_phy_rx_lane_control) 2175 { 2176 if(phymod_phy_rx_lane_control >= phymodRxCount) { 2177 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2178 } 2179 2180 return PHYMOD_E_NONE; 2181 2182 } 2183 2184 int phymod_phy_tx_lane_control_set(const phymod_phy_access_t* phy, phymod_phy_tx_lane_control_t tx_control) 2185 { 2186 2187 phymod_dispatch_type_t __type__; 2188 int __rv__; 2189 2190 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2191 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2192 } 2193 2194 if(PHYMOD_E_OK != phymod_phy_tx_lane_control_t_validate(tx_control)) { 2195 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_control validation failed"))); 2196 } 2197 2198 /* Dispatch */ 2199 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2200 if(__type__ >= phymodDispatchTypeCount) { 2201 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2202 } 2203 2204 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_lane_control_set) { 2205 PHYMOD_LOCK_TAKE(phy); 2206 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_lane_control_set(phy, tx_control); 2207 PHYMOD_LOCK_GIVE(phy); 2208 PHYMOD_IF_ERR_RETURN(__rv__); 2209 } else { 2210 return PHYMOD_E_UNAVAIL; 2211 } 2212 2213 return PHYMOD_E_NONE; 2214 2215 } 2216 2217 2218 int phymod_phy_tx_lane_control_get(const phymod_phy_access_t* phy, phymod_phy_tx_lane_control_t* tx_control) 2219 { 2220 2221 phymod_dispatch_type_t __type__; 2222 int __rv__; 2223 2224 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2225 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2226 } 2227 2228 if(tx_control == NULL) { 2229 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_control NULL parameter"))); 2230 } 2231 /* Dispatch */ 2232 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2233 if(__type__ >= phymodDispatchTypeCount) { 2234 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2235 } 2236 2237 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_lane_control_get) { 2238 PHYMOD_LOCK_TAKE(phy); 2239 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_lane_control_get(phy, tx_control); 2240 PHYMOD_LOCK_GIVE(phy); 2241 PHYMOD_IF_ERR_RETURN(__rv__); 2242 } else { 2243 return PHYMOD_E_UNAVAIL; 2244 } 2245 2246 return PHYMOD_E_NONE; 2247 2248 } 2249 2250 2251 int phymod_phy_rx_lane_control_set(const phymod_phy_access_t* phy, phymod_phy_rx_lane_control_t rx_control) 2252 { 2253 2254 phymod_dispatch_type_t __type__; 2255 int __rv__; 2256 2257 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2258 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2259 } 2260 2261 if(PHYMOD_E_OK != phymod_phy_rx_lane_control_t_validate(rx_control)) { 2262 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_control validation failed"))); 2263 } 2264 2265 /* Dispatch */ 2266 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2267 if(__type__ >= phymodDispatchTypeCount) { 2268 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2269 } 2270 2271 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_lane_control_set) { 2272 PHYMOD_LOCK_TAKE(phy); 2273 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_lane_control_set(phy, rx_control); 2274 PHYMOD_LOCK_GIVE(phy); 2275 PHYMOD_IF_ERR_RETURN(__rv__); 2276 } else { 2277 return PHYMOD_E_UNAVAIL; 2278 } 2279 2280 return PHYMOD_E_NONE; 2281 2282 } 2283 2284 2285 int phymod_phy_rx_lane_control_get(const phymod_phy_access_t* phy, phymod_phy_rx_lane_control_t* rx_control) 2286 { 2287 2288 phymod_dispatch_type_t __type__; 2289 int __rv__; 2290 2291 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2292 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2293 } 2294 2295 if(rx_control == NULL) { 2296 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_control NULL parameter"))); 2297 } 2298 /* Dispatch */ 2299 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2300 if(__type__ >= phymodDispatchTypeCount) { 2301 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2302 } 2303 2304 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_lane_control_get) { 2305 PHYMOD_LOCK_TAKE(phy); 2306 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_lane_control_get(phy, rx_control); 2307 PHYMOD_LOCK_GIVE(phy); 2308 PHYMOD_IF_ERR_RETURN(__rv__); 2309 } else { 2310 return PHYMOD_E_UNAVAIL; 2311 } 2312 2313 return PHYMOD_E_NONE; 2314 2315 } 2316 2317 2318 int phymod_phy_fec_enable_set(const phymod_phy_access_t* phy, uint32_t enable) 2319 { 2320 2321 phymod_dispatch_type_t __type__; 2322 int __rv__; 2323 2324 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2325 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2326 } 2327 2328 /* Dispatch */ 2329 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2330 if(__type__ >= phymodDispatchTypeCount) { 2331 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2332 } 2333 2334 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_fec_enable_set) { 2335 PHYMOD_LOCK_TAKE(phy); 2336 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_fec_enable_set(phy, enable); 2337 PHYMOD_LOCK_GIVE(phy); 2338 PHYMOD_IF_ERR_RETURN(__rv__); 2339 } else { 2340 return PHYMOD_E_UNAVAIL; 2341 } 2342 2343 return PHYMOD_E_NONE; 2344 2345 } 2346 2347 2348 int phymod_phy_fec_enable_get(const phymod_phy_access_t* phy, uint32_t* enable) 2349 { 2350 2351 phymod_dispatch_type_t __type__; 2352 int __rv__; 2353 2354 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2355 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2356 } 2357 2358 if(enable == NULL) { 2359 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 2360 } 2361 /* Dispatch */ 2362 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2363 if(__type__ >= phymodDispatchTypeCount) { 2364 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2365 } 2366 2367 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_fec_enable_get) { 2368 PHYMOD_LOCK_TAKE(phy); 2369 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_fec_enable_get(phy, enable); 2370 PHYMOD_LOCK_GIVE(phy); 2371 PHYMOD_IF_ERR_RETURN(__rv__); 2372 } else { 2373 return PHYMOD_E_UNAVAIL; 2374 } 2375 2376 return PHYMOD_E_NONE; 2377 2378 } 2379 2380 2381 int phymod_phy_fec_override_set(const phymod_phy_access_t* phy, uint32_t enable) 2382 { 2383 2384 phymod_dispatch_type_t __type__; 2385 int __rv__; 2386 2387 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2388 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2389 } 2390 2391 /* Dispatch */ 2392 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2393 if(__type__ >= phymodDispatchTypeCount) { 2394 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2395 } 2396 2397 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_fec_override_set) { 2398 PHYMOD_LOCK_TAKE(phy); 2399 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_fec_override_set(phy, enable); 2400 PHYMOD_LOCK_GIVE(phy); 2401 PHYMOD_IF_ERR_RETURN(__rv__); 2402 } else { 2403 return PHYMOD_E_UNAVAIL; 2404 } 2405 2406 return PHYMOD_E_NONE; 2407 2408 } 2409 2410 2411 int phymod_phy_fec_override_get(const phymod_phy_access_t* phy, uint32_t* enable) 2412 { 2413 2414 phymod_dispatch_type_t __type__; 2415 int __rv__; 2416 2417 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2418 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2419 } 2420 2421 if(enable == NULL) { 2422 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 2423 } 2424 /* Dispatch */ 2425 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2426 if(__type__ >= phymodDispatchTypeCount) { 2427 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2428 } 2429 2430 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_fec_override_get) { 2431 PHYMOD_LOCK_TAKE(phy); 2432 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_fec_override_get(phy, enable); 2433 PHYMOD_LOCK_GIVE(phy); 2434 PHYMOD_IF_ERR_RETURN(__rv__); 2435 } else { 2436 return PHYMOD_E_UNAVAIL; 2437 } 2438 2439 return PHYMOD_E_NONE; 2440 2441 } 2442 2443 2444 int phymod_phy_forced_speed_line_side_set(const phymod_phy_access_t* phy, uint32_t speed) 2445 { 2446 2447 phymod_dispatch_type_t __type__; 2448 int __rv__; 2449 2450 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2451 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2452 } 2453 2454 /* Dispatch */ 2455 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2456 if(__type__ >= phymodDispatchTypeCount) { 2457 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2458 } 2459 2460 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_forced_speed_line_side_set) { 2461 PHYMOD_LOCK_TAKE(phy); 2462 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_forced_speed_line_side_set(phy, speed); 2463 PHYMOD_LOCK_GIVE(phy); 2464 PHYMOD_IF_ERR_RETURN(__rv__); 2465 } else { 2466 return PHYMOD_E_UNAVAIL; 2467 } 2468 2469 return PHYMOD_E_NONE; 2470 2471 } 2472 2473 2474 int phymod_phy_forced_speed_line_side_get(const phymod_phy_access_t* phy, uint32_t* speed) 2475 { 2476 2477 phymod_dispatch_type_t __type__; 2478 int __rv__; 2479 2480 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2481 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2482 } 2483 2484 if(speed == NULL) { 2485 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("speed NULL parameter"))); 2486 } 2487 /* Dispatch */ 2488 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2489 if(__type__ >= phymodDispatchTypeCount) { 2490 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2491 } 2492 2493 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_forced_speed_line_side_get) { 2494 PHYMOD_LOCK_TAKE(phy); 2495 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_forced_speed_line_side_get(phy, speed); 2496 PHYMOD_LOCK_GIVE(phy); 2497 PHYMOD_IF_ERR_RETURN(__rv__); 2498 } else { 2499 return PHYMOD_E_UNAVAIL; 2500 } 2501 2502 return PHYMOD_E_NONE; 2503 2504 } 2505 2506 2507 int phymod_phy_autoneg_line_side_set(const phymod_phy_access_t* phy, uint32_t enable) 2508 { 2509 2510 phymod_dispatch_type_t __type__; 2511 int __rv__; 2512 2513 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2514 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2515 } 2516 2517 /* Dispatch */ 2518 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2519 if(__type__ >= phymodDispatchTypeCount) { 2520 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2521 } 2522 2523 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_line_side_set) { 2524 PHYMOD_LOCK_TAKE(phy); 2525 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_line_side_set(phy, enable); 2526 PHYMOD_LOCK_GIVE(phy); 2527 PHYMOD_IF_ERR_RETURN(__rv__); 2528 } else { 2529 return PHYMOD_E_UNAVAIL; 2530 } 2531 2532 return PHYMOD_E_NONE; 2533 2534 } 2535 2536 2537 int phymod_phy_autoneg_line_side_get(const phymod_phy_access_t* phy, uint32_t* enable) 2538 { 2539 2540 phymod_dispatch_type_t __type__; 2541 int __rv__; 2542 2543 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2544 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2545 } 2546 2547 if(enable == NULL) { 2548 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 2549 } 2550 /* Dispatch */ 2551 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2552 if(__type__ >= phymodDispatchTypeCount) { 2553 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2554 } 2555 2556 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_line_side_get) { 2557 PHYMOD_LOCK_TAKE(phy); 2558 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_line_side_get(phy, enable); 2559 PHYMOD_LOCK_GIVE(phy); 2560 PHYMOD_IF_ERR_RETURN(__rv__); 2561 } else { 2562 return PHYMOD_E_UNAVAIL; 2563 } 2564 2565 return PHYMOD_E_NONE; 2566 2567 } 2568 2569 2570 int phymod_phy_flow_control_mode_set(const phymod_phy_access_t* phy, uint32_t mode, uint32_t ingress) 2571 { 2572 2573 phymod_dispatch_type_t __type__; 2574 int __rv__; 2575 2576 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2577 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2578 } 2579 2580 /* Dispatch */ 2581 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2582 if(__type__ >= phymodDispatchTypeCount) { 2583 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2584 } 2585 2586 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_flow_control_mode_set) { 2587 PHYMOD_LOCK_TAKE(phy); 2588 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_flow_control_mode_set(phy, mode, ingress); 2589 PHYMOD_LOCK_GIVE(phy); 2590 PHYMOD_IF_ERR_RETURN(__rv__); 2591 } else { 2592 return PHYMOD_E_UNAVAIL; 2593 } 2594 2595 return PHYMOD_E_NONE; 2596 2597 } 2598 2599 2600 int phymod_phy_flow_control_mode_get(const phymod_phy_access_t* phy, uint32_t ingress, uint32_t* mode) 2601 { 2602 2603 phymod_dispatch_type_t __type__; 2604 int __rv__; 2605 2606 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2607 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2608 } 2609 2610 if(mode == NULL) { 2611 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mode NULL parameter"))); 2612 } 2613 /* Dispatch */ 2614 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2615 if(__type__ >= phymodDispatchTypeCount) { 2616 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2617 } 2618 2619 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_flow_control_mode_get) { 2620 PHYMOD_LOCK_TAKE(phy); 2621 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_flow_control_mode_get(phy, ingress, mode); 2622 PHYMOD_LOCK_GIVE(phy); 2623 PHYMOD_IF_ERR_RETURN(__rv__); 2624 } else { 2625 return PHYMOD_E_UNAVAIL; 2626 } 2627 2628 return PHYMOD_E_NONE; 2629 2630 } 2631 2632 2633 int phymod_phy_psm_cos_bmp_set(const phymod_phy_access_t* phy, uint32_t cos_bmp) 2634 { 2635 2636 phymod_dispatch_type_t __type__; 2637 int __rv__; 2638 2639 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2640 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2641 } 2642 2643 /* Dispatch */ 2644 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2645 if(__type__ >= phymodDispatchTypeCount) { 2646 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2647 } 2648 2649 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_psm_cos_bmp_set) { 2650 PHYMOD_LOCK_TAKE(phy); 2651 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_psm_cos_bmp_set(phy, cos_bmp); 2652 PHYMOD_LOCK_GIVE(phy); 2653 PHYMOD_IF_ERR_RETURN(__rv__); 2654 } else { 2655 return PHYMOD_E_UNAVAIL; 2656 } 2657 2658 return PHYMOD_E_NONE; 2659 2660 } 2661 2662 2663 int phymod_phy_psm_cos_bmp_get(const phymod_phy_access_t* phy, uint32_t* cos_bmp) 2664 { 2665 2666 phymod_dispatch_type_t __type__; 2667 int __rv__; 2668 2669 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2670 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2671 } 2672 2673 if(cos_bmp == NULL) { 2674 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("cos_bmp NULL parameter"))); 2675 } 2676 /* Dispatch */ 2677 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2678 if(__type__ >= phymodDispatchTypeCount) { 2679 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2680 } 2681 2682 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_psm_cos_bmp_get) { 2683 PHYMOD_LOCK_TAKE(phy); 2684 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_psm_cos_bmp_get(phy, cos_bmp); 2685 PHYMOD_LOCK_GIVE(phy); 2686 PHYMOD_IF_ERR_RETURN(__rv__); 2687 } else { 2688 return PHYMOD_E_UNAVAIL; 2689 } 2690 2691 return PHYMOD_E_NONE; 2692 2693 } 2694 2695 2696 int phymod_phy_pfc_use_ip_cos_set(const phymod_phy_access_t* phy, uint32_t enable) 2697 { 2698 2699 phymod_dispatch_type_t __type__; 2700 int __rv__; 2701 2702 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2703 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2704 } 2705 2706 /* Dispatch */ 2707 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2708 if(__type__ >= phymodDispatchTypeCount) { 2709 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2710 } 2711 2712 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pfc_use_ip_cos_set) { 2713 PHYMOD_LOCK_TAKE(phy); 2714 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pfc_use_ip_cos_set(phy, enable); 2715 PHYMOD_LOCK_GIVE(phy); 2716 PHYMOD_IF_ERR_RETURN(__rv__); 2717 } else { 2718 return PHYMOD_E_UNAVAIL; 2719 } 2720 2721 return PHYMOD_E_NONE; 2722 2723 } 2724 2725 2726 int phymod_phy_pfc_use_ip_cos_get(const phymod_phy_access_t* phy, uint32_t* enable) 2727 { 2728 2729 phymod_dispatch_type_t __type__; 2730 int __rv__; 2731 2732 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2733 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2734 } 2735 2736 if(enable == NULL) { 2737 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 2738 } 2739 /* Dispatch */ 2740 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2741 if(__type__ >= phymodDispatchTypeCount) { 2742 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2743 } 2744 2745 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pfc_use_ip_cos_get) { 2746 PHYMOD_LOCK_TAKE(phy); 2747 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pfc_use_ip_cos_get(phy, enable); 2748 PHYMOD_LOCK_GIVE(phy); 2749 PHYMOD_IF_ERR_RETURN(__rv__); 2750 } else { 2751 return PHYMOD_E_UNAVAIL; 2752 } 2753 2754 return PHYMOD_E_NONE; 2755 2756 } 2757 2758 2759 int phymod_phy_autoneg_oui_set(const phymod_phy_access_t* phy, phymod_autoneg_oui_t an_oui) 2760 { 2761 2762 phymod_dispatch_type_t __type__; 2763 int __rv__; 2764 2765 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2766 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2767 } 2768 2769 if(PHYMOD_E_OK != phymod_autoneg_oui_t_validate(&an_oui)) { 2770 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_oui validation failed"))); 2771 } 2772 2773 /* Dispatch */ 2774 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2775 if(__type__ >= phymodDispatchTypeCount) { 2776 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2777 } 2778 2779 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_oui_set) { 2780 PHYMOD_LOCK_TAKE(phy); 2781 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_oui_set(phy, an_oui); 2782 PHYMOD_LOCK_GIVE(phy); 2783 PHYMOD_IF_ERR_RETURN(__rv__); 2784 } else { 2785 return PHYMOD_E_UNAVAIL; 2786 } 2787 2788 return PHYMOD_E_NONE; 2789 2790 } 2791 2792 2793 int phymod_phy_autoneg_oui_get(const phymod_phy_access_t* phy, phymod_autoneg_oui_t* an_oui) 2794 { 2795 2796 phymod_dispatch_type_t __type__; 2797 int __rv__; 2798 2799 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2800 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2801 } 2802 2803 if(an_oui == NULL) { 2804 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_oui NULL parameter"))); 2805 } 2806 if(PHYMOD_E_OK != phymod_autoneg_oui_t_init(an_oui)) { 2807 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_oui initialization failed"))); 2808 } 2809 2810 /* Dispatch */ 2811 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2812 if(__type__ >= phymodDispatchTypeCount) { 2813 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2814 } 2815 2816 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_oui_get) { 2817 PHYMOD_LOCK_TAKE(phy); 2818 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_oui_get(phy, an_oui); 2819 PHYMOD_LOCK_GIVE(phy); 2820 PHYMOD_IF_ERR_RETURN(__rv__); 2821 } else { 2822 return PHYMOD_E_UNAVAIL; 2823 } 2824 2825 return PHYMOD_E_NONE; 2826 2827 } 2828 2829 2830 int phymod_phy_eee_set(const phymod_phy_access_t* phy, uint32_t enable) 2831 { 2832 2833 phymod_dispatch_type_t __type__; 2834 int __rv__; 2835 2836 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2837 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2838 } 2839 2840 /* Dispatch */ 2841 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2842 if(__type__ >= phymodDispatchTypeCount) { 2843 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2844 } 2845 2846 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_eee_set) { 2847 PHYMOD_LOCK_TAKE(phy); 2848 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_eee_set(phy, enable); 2849 PHYMOD_LOCK_GIVE(phy); 2850 PHYMOD_IF_ERR_RETURN(__rv__); 2851 } else { 2852 return PHYMOD_E_UNAVAIL; 2853 } 2854 2855 return PHYMOD_E_NONE; 2856 2857 } 2858 2859 2860 int phymod_phy_eee_get(const phymod_phy_access_t* phy, uint32_t* enable) 2861 { 2862 2863 phymod_dispatch_type_t __type__; 2864 int __rv__; 2865 2866 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2867 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2868 } 2869 2870 if(enable == NULL) { 2871 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 2872 } 2873 /* Dispatch */ 2874 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2875 if(__type__ >= phymodDispatchTypeCount) { 2876 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 2877 } 2878 2879 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_eee_get) { 2880 PHYMOD_LOCK_TAKE(phy); 2881 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_eee_get(phy, enable); 2882 PHYMOD_LOCK_GIVE(phy); 2883 PHYMOD_IF_ERR_RETURN(__rv__); 2884 } else { 2885 return PHYMOD_E_UNAVAIL; 2886 } 2887 2888 return PHYMOD_E_NONE; 2889 2890 } 2891 2892 2893 int phymod_interface_t_validate(phymod_interface_t phymod_interface) 2894 { 2895 if(phymod_interface >= phymodInterfaceCount) { 2896 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2897 } 2898 2899 return PHYMOD_E_NONE; 2900 2901 } 2902 2903 int phymod_ref_clk_t_validate(phymod_ref_clk_t phymod_ref_clk) 2904 { 2905 if(phymod_ref_clk >= phymodRefClkCount) { 2906 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2907 } 2908 2909 return PHYMOD_E_NONE; 2910 2911 } 2912 2913 int phymod_triple_core_t_validate(phymod_triple_core_t phymod_triple_core) 2914 { 2915 if(phymod_triple_core >= phymodTripleCoreCount) { 2916 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2917 } 2918 2919 return PHYMOD_E_NONE; 2920 2921 } 2922 2923 int phymod_otn_type_t_validate(phymod_otn_type_t phymod_otn_type) 2924 { 2925 if(phymod_otn_type >= phymodOTNCount) { 2926 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 2927 } 2928 2929 return PHYMOD_E_NONE; 2930 2931 } 2932 2933 int phymod_phy_inf_config_t_validate(const phymod_phy_inf_config_t* phymod_phy_inf_config) 2934 { 2935 if(phymod_phy_inf_config == NULL) { 2936 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 2937 } 2938 2939 if(PHYMOD_E_OK != phymod_interface_t_validate(phymod_phy_inf_config->interface_type)) { 2940 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("interface_type validation failed"))); 2941 } 2942 2943 if(PHYMOD_E_OK != phymod_ref_clk_t_validate(phymod_phy_inf_config->ref_clock)) { 2944 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ref_clock validation failed"))); 2945 } 2946 2947 if(PHYMOD_E_OK != phymod_ref_clk_t_validate(phymod_phy_inf_config->com_clock)) { 2948 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("com_clock validation failed"))); 2949 } 2950 2951 if(PHYMOD_E_OK != phymod_otn_type_t_validate(phymod_phy_inf_config->otn_type)) { 2952 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("otn_type validation failed"))); 2953 } 2954 2955 2956 2957 return PHYMOD_E_NONE; 2958 2959 } 2960 2961 int phymod_phy_inf_config_t_init(phymod_phy_inf_config_t* phymod_phy_inf_config) 2962 { 2963 2964 if(phymod_phy_inf_config == NULL){ 2965 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_inf_config NULL parameter"))); 2966 } 2967 PHYMOD_MEMSET(phymod_phy_inf_config, 0, sizeof(phymod_phy_inf_config_t)); 2968 phymod_phy_inf_config->interface_type = phymodInterfaceBypass; 2969 phymod_phy_inf_config->data_rate = 0; 2970 phymod_phy_inf_config->interface_modes = 0; 2971 phymod_phy_inf_config->ref_clock = 0; 2972 phymod_phy_inf_config->com_clock = 0; 2973 phymod_phy_inf_config->pll_divider_req = 0; 2974 phymod_phy_inf_config->device_aux_modes = NULL; 2975 phymod_phy_inf_config->otn_type = phymodOTNOTU1; 2976 2977 2978 return PHYMOD_E_NONE; 2979 2980 } 2981 2982 int phymod_phy_interface_config_set(const phymod_phy_access_t* phy, uint32_t flags, const phymod_phy_inf_config_t* config) 2983 { 2984 2985 phymod_dispatch_type_t __type__; 2986 int __rv__; 2987 2988 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 2989 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 2990 } 2991 2992 if(PHYMOD_E_OK != phymod_phy_inf_config_t_validate(config)) { 2993 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config validation failed"))); 2994 } 2995 2996 /* Dispatch */ 2997 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 2998 if(__type__ >= phymodDispatchTypeCount) { 2999 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3000 } 3001 3002 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_interface_config_set) { 3003 PHYMOD_LOCK_TAKE(phy); 3004 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_interface_config_set(phy, flags, config); 3005 PHYMOD_LOCK_GIVE(phy); 3006 PHYMOD_IF_ERR_RETURN(__rv__); 3007 } else { 3008 return PHYMOD_E_UNAVAIL; 3009 } 3010 3011 return PHYMOD_E_NONE; 3012 3013 } 3014 3015 3016 int phymod_phy_interface_config_get(const phymod_phy_access_t* phy, uint32_t flags, phymod_ref_clk_t ref_clock, phymod_phy_inf_config_t* config) 3017 { 3018 3019 phymod_dispatch_type_t __type__; 3020 int __rv__; 3021 3022 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3023 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3024 } 3025 3026 if(PHYMOD_E_OK != phymod_ref_clk_t_validate(ref_clock)) { 3027 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ref_clock validation failed"))); 3028 } 3029 3030 if(config == NULL) { 3031 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config NULL parameter"))); 3032 } 3033 if(PHYMOD_E_OK != phymod_phy_inf_config_t_init(config)) { 3034 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config initialization failed"))); 3035 } 3036 3037 /* Dispatch */ 3038 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3039 if(__type__ >= phymodDispatchTypeCount) { 3040 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3041 } 3042 3043 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_interface_config_get) { 3044 PHYMOD_LOCK_TAKE(phy); 3045 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_interface_config_get(phy, flags, ref_clock, config); 3046 PHYMOD_LOCK_GIVE(phy); 3047 PHYMOD_IF_ERR_RETURN(__rv__); 3048 } else { 3049 return PHYMOD_E_UNAVAIL; 3050 } 3051 3052 return PHYMOD_E_NONE; 3053 3054 } 3055 3056 3057 int phymod_phy_cl72_set(const phymod_phy_access_t* phy, uint32_t cl72_en) 3058 { 3059 3060 phymod_dispatch_type_t __type__; 3061 int __rv__; 3062 3063 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3064 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3065 } 3066 3067 /* Dispatch */ 3068 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3069 if(__type__ >= phymodDispatchTypeCount) { 3070 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3071 } 3072 3073 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_cl72_set) { 3074 PHYMOD_LOCK_TAKE(phy); 3075 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_cl72_set(phy, cl72_en); 3076 PHYMOD_LOCK_GIVE(phy); 3077 PHYMOD_IF_ERR_RETURN(__rv__); 3078 } else { 3079 return PHYMOD_E_UNAVAIL; 3080 } 3081 3082 return PHYMOD_E_NONE; 3083 3084 } 3085 3086 3087 int phymod_phy_cl72_get(const phymod_phy_access_t* phy, uint32_t* cl72_en) 3088 { 3089 3090 phymod_dispatch_type_t __type__; 3091 int __rv__; 3092 3093 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3094 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3095 } 3096 3097 if(cl72_en == NULL) { 3098 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("cl72_en NULL parameter"))); 3099 } 3100 /* Dispatch */ 3101 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3102 if(__type__ >= phymodDispatchTypeCount) { 3103 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3104 } 3105 3106 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_cl72_get) { 3107 PHYMOD_LOCK_TAKE(phy); 3108 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_cl72_get(phy, cl72_en); 3109 PHYMOD_LOCK_GIVE(phy); 3110 PHYMOD_IF_ERR_RETURN(__rv__); 3111 } else { 3112 return PHYMOD_E_UNAVAIL; 3113 } 3114 3115 return PHYMOD_E_NONE; 3116 3117 } 3118 3119 3120 int phymod_cl72_status_t_validate(const phymod_cl72_status_t* phymod_cl72_status) 3121 { 3122 if(phymod_cl72_status == NULL) { 3123 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3124 } 3125 3126 3127 3128 return PHYMOD_E_NONE; 3129 3130 } 3131 3132 int phymod_cl72_status_t_init(phymod_cl72_status_t* phymod_cl72_status) 3133 { 3134 3135 if(phymod_cl72_status == NULL){ 3136 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_cl72_status NULL parameter"))); 3137 } 3138 PHYMOD_MEMSET(phymod_cl72_status, 0, sizeof(phymod_cl72_status_t)); 3139 3140 3141 return PHYMOD_E_NONE; 3142 3143 } 3144 3145 int phymod_phy_cl72_status_get(const phymod_phy_access_t* phy, phymod_cl72_status_t* status) 3146 { 3147 3148 phymod_dispatch_type_t __type__; 3149 int __rv__; 3150 3151 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3152 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3153 } 3154 3155 if(status == NULL) { 3156 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("status NULL parameter"))); 3157 } 3158 if(PHYMOD_E_OK != phymod_cl72_status_t_init(status)) { 3159 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("status initialization failed"))); 3160 } 3161 3162 /* Dispatch */ 3163 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3164 if(__type__ >= phymodDispatchTypeCount) { 3165 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3166 } 3167 3168 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_cl72_status_get) { 3169 PHYMOD_LOCK_TAKE(phy); 3170 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_cl72_status_get(phy, status); 3171 PHYMOD_LOCK_GIVE(phy); 3172 PHYMOD_IF_ERR_RETURN(__rv__); 3173 } else { 3174 return PHYMOD_E_UNAVAIL; 3175 } 3176 3177 return PHYMOD_E_NONE; 3178 3179 } 3180 3181 3182 int phymod_an_mode_type_t_validate(phymod_an_mode_type_t phymod_an_mode_type) 3183 { 3184 if(phymod_an_mode_type >= phymod_AN_MODE_Count) { 3185 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3186 } 3187 3188 return PHYMOD_E_NONE; 3189 3190 } 3191 3192 int phymod_cl37_sgmii_speed_t_validate(phymod_cl37_sgmii_speed_t phymod_cl37_sgmii_speed) 3193 { 3194 if(phymod_cl37_sgmii_speed >= phymod_CL37_SGMII_Count) { 3195 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3196 } 3197 3198 return PHYMOD_E_NONE; 3199 3200 } 3201 3202 int phymod_autoneg_ability_t_validate(const phymod_autoneg_ability_t* phymod_autoneg_ability) 3203 { 3204 if(phymod_autoneg_ability == NULL) { 3205 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3206 } 3207 3208 if(PHYMOD_E_OK != phymod_cl37_sgmii_speed_t_validate(phymod_autoneg_ability->sgmii_speed)) { 3209 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("sgmii_speed validation failed"))); 3210 } 3211 3212 3213 3214 return PHYMOD_E_NONE; 3215 3216 } 3217 3218 int phymod_autoneg_ability_t_init(phymod_autoneg_ability_t* phymod_autoneg_ability) 3219 { 3220 3221 if(phymod_autoneg_ability == NULL){ 3222 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_autoneg_ability NULL parameter"))); 3223 } 3224 PHYMOD_MEMSET(phymod_autoneg_ability, 0, sizeof(phymod_autoneg_ability_t)); 3225 phymod_autoneg_ability->an_cap = 0; 3226 phymod_autoneg_ability->cl73bam_cap = 0; 3227 phymod_autoneg_ability->cl37bam_cap = 0; 3228 phymod_autoneg_ability->an_fec = 0; 3229 phymod_autoneg_ability->an_cl72 = 0; 3230 phymod_autoneg_ability->an_hg2 = 0; 3231 phymod_autoneg_ability->capabilities = 0; 3232 phymod_autoneg_ability->an_master_lane = 0; 3233 3234 3235 return PHYMOD_E_NONE; 3236 3237 } 3238 3239 int phymod_phy_autoneg_ability_set(const phymod_phy_access_t* phy, const phymod_autoneg_ability_t* an_ability_set_type) 3240 { 3241 3242 phymod_dispatch_type_t __type__; 3243 int __rv__; 3244 3245 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3246 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3247 } 3248 3249 if(PHYMOD_E_OK != phymod_autoneg_ability_t_validate(an_ability_set_type)) { 3250 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ability_set_type validation failed"))); 3251 } 3252 3253 /* Dispatch */ 3254 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3255 if(__type__ >= phymodDispatchTypeCount) { 3256 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3257 } 3258 3259 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_ability_set) { 3260 PHYMOD_LOCK_TAKE(phy); 3261 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_ability_set(phy, an_ability_set_type); 3262 PHYMOD_LOCK_GIVE(phy); 3263 PHYMOD_IF_ERR_RETURN(__rv__); 3264 } else { 3265 return PHYMOD_E_UNAVAIL; 3266 } 3267 3268 return PHYMOD_E_NONE; 3269 3270 } 3271 3272 3273 int phymod_phy_autoneg_ability_get(const phymod_phy_access_t* phy, phymod_autoneg_ability_t* an_ability_get_type) 3274 { 3275 3276 phymod_dispatch_type_t __type__; 3277 int __rv__; 3278 3279 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3280 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3281 } 3282 3283 if(an_ability_get_type == NULL) { 3284 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ability_get_type NULL parameter"))); 3285 } 3286 if(PHYMOD_E_OK != phymod_autoneg_ability_t_init(an_ability_get_type)) { 3287 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ability_get_type initialization failed"))); 3288 } 3289 3290 /* Dispatch */ 3291 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3292 if(__type__ >= phymodDispatchTypeCount) { 3293 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3294 } 3295 3296 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_ability_get) { 3297 PHYMOD_LOCK_TAKE(phy); 3298 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_ability_get(phy, an_ability_get_type); 3299 PHYMOD_LOCK_GIVE(phy); 3300 PHYMOD_IF_ERR_RETURN(__rv__); 3301 } else { 3302 return PHYMOD_E_UNAVAIL; 3303 } 3304 3305 return PHYMOD_E_NONE; 3306 3307 } 3308 3309 3310 int phymod_phy_autoneg_remote_ability_get(const phymod_phy_access_t* phy, phymod_autoneg_ability_t* an_ability_get_type) 3311 { 3312 3313 phymod_dispatch_type_t __type__; 3314 int __rv__; 3315 3316 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3317 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3318 } 3319 3320 if(an_ability_get_type == NULL) { 3321 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ability_get_type NULL parameter"))); 3322 } 3323 if(PHYMOD_E_OK != phymod_autoneg_ability_t_init(an_ability_get_type)) { 3324 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ability_get_type initialization failed"))); 3325 } 3326 3327 /* Dispatch */ 3328 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3329 if(__type__ >= phymodDispatchTypeCount) { 3330 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3331 } 3332 3333 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_remote_ability_get) { 3334 PHYMOD_LOCK_TAKE(phy); 3335 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_remote_ability_get(phy, an_ability_get_type); 3336 PHYMOD_LOCK_GIVE(phy); 3337 PHYMOD_IF_ERR_RETURN(__rv__); 3338 } else { 3339 return PHYMOD_E_UNAVAIL; 3340 } 3341 3342 return PHYMOD_E_NONE; 3343 3344 } 3345 3346 3347 int phymod_autoneg_control_t_validate(const phymod_autoneg_control_t* phymod_autoneg_control) 3348 { 3349 if(phymod_autoneg_control == NULL) { 3350 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3351 } 3352 3353 if(PHYMOD_E_OK != phymod_an_mode_type_t_validate(phymod_autoneg_control->an_mode)) { 3354 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_mode validation failed"))); 3355 } 3356 3357 switch(phymod_autoneg_control->enable) { 3358 case 0: 3359 case 1: 3360 break; 3361 default: 3362 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable not allowed value"))); 3363 break; 3364 } 3365 3366 3367 3368 return PHYMOD_E_NONE; 3369 3370 } 3371 3372 int phymod_autoneg_control_t_init(phymod_autoneg_control_t* phymod_autoneg_control) 3373 { 3374 3375 if(phymod_autoneg_control == NULL){ 3376 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_autoneg_control NULL parameter"))); 3377 } 3378 PHYMOD_MEMSET(phymod_autoneg_control, 0, sizeof(phymod_autoneg_control_t)); 3379 phymod_autoneg_control->an_mode = 0; 3380 phymod_autoneg_control->num_lane_adv = 0; 3381 phymod_autoneg_control->flags = 0; 3382 phymod_autoneg_control->enable = 0; 3383 3384 3385 return PHYMOD_E_NONE; 3386 3387 } 3388 3389 int phymod_phy_autoneg_set(const phymod_phy_access_t* phy, const phymod_autoneg_control_t* an) 3390 { 3391 3392 phymod_dispatch_type_t __type__; 3393 int __rv__; 3394 3395 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3396 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3397 } 3398 3399 if(PHYMOD_E_OK != phymod_autoneg_control_t_validate(an)) { 3400 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an validation failed"))); 3401 } 3402 3403 /* Dispatch */ 3404 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3405 if(__type__ >= phymodDispatchTypeCount) { 3406 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3407 } 3408 3409 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_set) { 3410 PHYMOD_LOCK_TAKE(phy); 3411 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_set(phy, an); 3412 PHYMOD_LOCK_GIVE(phy); 3413 PHYMOD_IF_ERR_RETURN(__rv__); 3414 } else { 3415 return PHYMOD_E_UNAVAIL; 3416 } 3417 3418 return PHYMOD_E_NONE; 3419 3420 } 3421 3422 3423 int phymod_phy_autoneg_get(const phymod_phy_access_t* phy, phymod_autoneg_control_t* an, uint32_t* an_done) 3424 { 3425 3426 phymod_dispatch_type_t __type__; 3427 int __rv__; 3428 3429 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3430 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3431 } 3432 3433 if(an == NULL) { 3434 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an NULL parameter"))); 3435 } 3436 if(PHYMOD_E_OK != phymod_autoneg_control_t_init(an)) { 3437 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an initialization failed"))); 3438 } 3439 3440 if(an_done == NULL) { 3441 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_done NULL parameter"))); 3442 } 3443 /* Dispatch */ 3444 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3445 if(__type__ >= phymodDispatchTypeCount) { 3446 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3447 } 3448 3449 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_get) { 3450 PHYMOD_LOCK_TAKE(phy); 3451 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_get(phy, an, an_done); 3452 PHYMOD_LOCK_GIVE(phy); 3453 PHYMOD_IF_ERR_RETURN(__rv__); 3454 } else { 3455 return PHYMOD_E_UNAVAIL; 3456 } 3457 3458 return PHYMOD_E_NONE; 3459 3460 } 3461 3462 3463 int phymod_phy_autoneg_restart_set(const phymod_phy_access_t* phy, const phymod_autoneg_control_t* an) 3464 { 3465 3466 phymod_dispatch_type_t __type__; 3467 int __rv__; 3468 3469 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3470 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3471 } 3472 3473 if(PHYMOD_E_OK != phymod_autoneg_control_t_validate(an)) { 3474 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an validation failed"))); 3475 } 3476 3477 /* Dispatch */ 3478 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3479 if(__type__ >= phymodDispatchTypeCount) { 3480 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3481 } 3482 3483 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_restart_set) { 3484 PHYMOD_LOCK_TAKE(phy); 3485 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_restart_set(phy, an); 3486 PHYMOD_LOCK_GIVE(phy); 3487 PHYMOD_IF_ERR_RETURN(__rv__); 3488 } else { 3489 return PHYMOD_E_UNAVAIL; 3490 } 3491 3492 return PHYMOD_E_NONE; 3493 3494 } 3495 3496 3497 int phymod_autoneg_status_t_validate(const phymod_autoneg_status_t* phymod_autoneg_status) 3498 { 3499 if(phymod_autoneg_status == NULL) { 3500 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3501 } 3502 3503 if(PHYMOD_E_OK != phymod_interface_t_validate(phymod_autoneg_status->interface)) { 3504 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("interface validation failed"))); 3505 } 3506 3507 3508 3509 return PHYMOD_E_NONE; 3510 3511 } 3512 3513 int phymod_autoneg_status_t_init(phymod_autoneg_status_t* phymod_autoneg_status) 3514 { 3515 3516 if(phymod_autoneg_status == NULL){ 3517 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_autoneg_status NULL parameter"))); 3518 } 3519 PHYMOD_MEMSET(phymod_autoneg_status, 0, sizeof(phymod_autoneg_status_t)); 3520 3521 3522 return PHYMOD_E_NONE; 3523 3524 } 3525 3526 int phymod_phy_autoneg_status_get(const phymod_phy_access_t* phy, phymod_autoneg_status_t* status) 3527 { 3528 3529 phymod_dispatch_type_t __type__; 3530 int __rv__; 3531 3532 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3533 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3534 } 3535 3536 if(status == NULL) { 3537 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("status NULL parameter"))); 3538 } 3539 if(PHYMOD_E_OK != phymod_autoneg_status_t_init(status)) { 3540 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("status initialization failed"))); 3541 } 3542 3543 /* Dispatch */ 3544 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3545 if(__type__ >= phymodDispatchTypeCount) { 3546 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3547 } 3548 3549 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_status_get) { 3550 PHYMOD_LOCK_TAKE(phy); 3551 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_status_get(phy, status); 3552 PHYMOD_LOCK_GIVE(phy); 3553 PHYMOD_IF_ERR_RETURN(__rv__); 3554 } else { 3555 return PHYMOD_E_UNAVAIL; 3556 } 3557 3558 return PHYMOD_E_NONE; 3559 3560 } 3561 3562 3563 int phymod_firmware_load_force_t_validate(phymod_firmware_load_force_t phymod_firmware_load_force) 3564 { 3565 if(phymod_firmware_load_force >= phymodFirmwareLoadCount) { 3566 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3567 } 3568 3569 return PHYMOD_E_NONE; 3570 3571 } 3572 3573 int phymod_firmware_load_method_t_validate(phymod_firmware_load_method_t phymod_firmware_load_method) 3574 { 3575 if(phymod_firmware_load_method >= phymodFirmwareLoadMethodCount) { 3576 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3577 } 3578 3579 return PHYMOD_E_NONE; 3580 3581 } 3582 3583 int phymod_datapath_t_validate(phymod_datapath_t phymod_datapath) 3584 { 3585 if(phymod_datapath >= phymodDatapathCount) { 3586 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3587 } 3588 3589 return PHYMOD_E_NONE; 3590 3591 } 3592 3593 int phymod_tx_input_voltage_t_validate(phymod_tx_input_voltage_t phymod_tx_input_voltage) 3594 { 3595 if(phymod_tx_input_voltage >= phymodTxInputVoltageCount) { 3596 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3597 } 3598 3599 return PHYMOD_E_NONE; 3600 3601 } 3602 3603 int phymod_afe_pll_t_validate(const phymod_afe_pll_t* phymod_afe_pll) 3604 { 3605 if(phymod_afe_pll == NULL) { 3606 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3607 } 3608 3609 3610 3611 return PHYMOD_E_NONE; 3612 3613 } 3614 3615 int phymod_afe_pll_t_init(phymod_afe_pll_t* phymod_afe_pll) 3616 { 3617 3618 if(phymod_afe_pll == NULL){ 3619 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_afe_pll NULL parameter"))); 3620 } 3621 PHYMOD_MEMSET(phymod_afe_pll, 0, sizeof(phymod_afe_pll_t)); 3622 phymod_afe_pll->afe_pll_change_default = 0; 3623 phymod_afe_pll->ams_pll_iqp = 0xf; 3624 phymod_afe_pll->ams_pll_en_hrz = 0; 3625 3626 3627 return PHYMOD_E_NONE; 3628 3629 } 3630 3631 int phymod_core_init_config_t_validate(const phymod_core_init_config_t* phymod_core_init_config) 3632 { 3633 if(phymod_core_init_config == NULL) { 3634 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3635 } 3636 3637 if(PHYMOD_E_OK != phymod_lane_map_t_validate(&phymod_core_init_config->lane_map)) { 3638 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_map validation failed"))); 3639 } 3640 3641 if(PHYMOD_E_OK != phymod_polarity_t_validate(&phymod_core_init_config->polarity_map)) { 3642 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity_map validation failed"))); 3643 } 3644 3645 if(PHYMOD_E_OK != phymod_firmware_load_method_t_validate(phymod_core_init_config->firmware_load_method)) { 3646 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("firmware_load_method validation failed"))); 3647 } 3648 3649 if(PHYMOD_E_OK != phymod_firmware_core_config_t_validate(&phymod_core_init_config->firmware_core_config)) { 3650 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("firmware_core_config validation failed"))); 3651 } 3652 3653 if(PHYMOD_E_OK != phymod_phy_inf_config_t_validate(&phymod_core_init_config->interface)) { 3654 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("interface validation failed"))); 3655 } 3656 3657 if(PHYMOD_E_OK != phymod_datapath_t_validate(phymod_core_init_config->op_datapath)) { 3658 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("op_datapath validation failed"))); 3659 } 3660 3661 if(PHYMOD_E_OK != phymod_tx_input_voltage_t_validate(phymod_core_init_config->tx_input_voltage)) { 3662 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_input_voltage validation failed"))); 3663 } 3664 3665 if(PHYMOD_E_OK != phymod_afe_pll_t_validate(&phymod_core_init_config->afe_pll)) { 3666 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("afe_pll validation failed"))); 3667 } 3668 3669 3670 3671 return PHYMOD_E_NONE; 3672 3673 } 3674 3675 int phymod_core_init_config_t_init(phymod_core_init_config_t* phymod_core_init_config) 3676 { 3677 3678 if(phymod_core_init_config == NULL){ 3679 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_core_init_config NULL parameter"))); 3680 } 3681 PHYMOD_MEMSET(phymod_core_init_config, 0, sizeof(phymod_core_init_config_t)); 3682 if(PHYMOD_E_OK != phymod_lane_map_t_init(&phymod_core_init_config->lane_map)) { 3683 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_map initialization failed"))); 3684 } 3685 3686 if(PHYMOD_E_OK != phymod_polarity_t_init(&phymod_core_init_config->polarity_map)) { 3687 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity_map initialization failed"))); 3688 } 3689 3690 phymod_core_init_config->firmware_load_method = phymodFirmwareLoadMethodInternal; 3691 phymod_core_init_config->firmware_loader = NULL; 3692 if(PHYMOD_E_OK != phymod_firmware_core_config_t_init(&phymod_core_init_config->firmware_core_config)) { 3693 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("firmware_core_config initialization failed"))); 3694 } 3695 3696 if(PHYMOD_E_OK != phymod_phy_inf_config_t_init(&phymod_core_init_config->interface)) { 3697 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("interface initialization failed"))); 3698 } 3699 3700 phymod_core_init_config->flags = 0; 3701 if(PHYMOD_E_OK != phymod_afe_pll_t_init(&phymod_core_init_config->afe_pll)) { 3702 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("afe_pll initialization failed"))); 3703 } 3704 3705 3706 3707 return PHYMOD_E_NONE; 3708 3709 } 3710 3711 int phymod_core_status_t_validate(const phymod_core_status_t* phymod_core_status) 3712 { 3713 if(phymod_core_status == NULL) { 3714 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3715 } 3716 3717 3718 3719 return PHYMOD_E_NONE; 3720 3721 } 3722 3723 int phymod_core_status_t_init(phymod_core_status_t* phymod_core_status) 3724 { 3725 3726 if(phymod_core_status == NULL){ 3727 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_core_status NULL parameter"))); 3728 } 3729 PHYMOD_MEMSET(phymod_core_status, 0, sizeof(phymod_core_status_t)); 3730 3731 3732 return PHYMOD_E_NONE; 3733 3734 } 3735 3736 int phymod_core_init(const phymod_core_access_t* core, const phymod_core_init_config_t* init_config, const phymod_core_status_t* core_status) 3737 { 3738 3739 phymod_dispatch_type_t __type__; 3740 int __rv__; 3741 3742 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 3743 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 3744 } 3745 3746 if(PHYMOD_E_OK != phymod_core_init_config_t_validate(init_config)) { 3747 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("init_config validation failed"))); 3748 } 3749 3750 if(PHYMOD_E_OK != phymod_core_status_t_validate(core_status)) { 3751 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core_status validation failed"))); 3752 } 3753 3754 /* Dispatch */ 3755 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 3756 if(__type__ >= phymodDispatchTypeCount) { 3757 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3758 } 3759 3760 if(NULL != __phymod__dispatch__[__type__]->f_phymod_core_init) { 3761 PHYMOD_LOCK_TAKE(core); 3762 __rv__ = __phymod__dispatch__[__type__]->f_phymod_core_init(core, init_config, core_status); 3763 PHYMOD_LOCK_GIVE(core); 3764 PHYMOD_IF_ERR_RETURN(__rv__); 3765 } else { 3766 return PHYMOD_E_UNAVAIL; 3767 } 3768 3769 return PHYMOD_E_NONE; 3770 3771 } 3772 3773 3774 int phymod_phy_pll_multiplier_get(const phymod_phy_access_t* phy, uint32_t* core_vco_pll_multiplier) 3775 { 3776 3777 phymod_dispatch_type_t __type__; 3778 int __rv__; 3779 3780 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3781 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3782 } 3783 3784 if(core_vco_pll_multiplier == NULL) { 3785 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core_vco_pll_multiplier NULL parameter"))); 3786 } 3787 /* Dispatch */ 3788 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3789 if(__type__ >= phymodDispatchTypeCount) { 3790 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3791 } 3792 3793 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pll_multiplier_get) { 3794 PHYMOD_LOCK_TAKE(phy); 3795 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pll_multiplier_get(phy, core_vco_pll_multiplier); 3796 PHYMOD_LOCK_GIVE(phy); 3797 PHYMOD_IF_ERR_RETURN(__rv__); 3798 } else { 3799 return PHYMOD_E_UNAVAIL; 3800 } 3801 3802 return PHYMOD_E_NONE; 3803 3804 } 3805 3806 3807 int phymod_operation_mode_t_validate(phymod_operation_mode_t phymod_operation_mode) 3808 { 3809 if(phymod_operation_mode >= phymodOperationModeCount) { 3810 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3811 } 3812 3813 return PHYMOD_E_NONE; 3814 3815 } 3816 3817 int phymod_autoneg_link_qualifier_t_validate(phymod_autoneg_link_qualifier_t phymod_autoneg_link_qualifier) 3818 { 3819 if(phymod_autoneg_link_qualifier >= phymodAutonegLinkQualifierCount) { 3820 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3821 } 3822 3823 return PHYMOD_E_NONE; 3824 3825 } 3826 3827 int phymod_rx_los_t_validate(const phymod_rx_los_t* phymod_rx_los) 3828 { 3829 if(phymod_rx_los == NULL) { 3830 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3831 } 3832 3833 3834 3835 return PHYMOD_E_NONE; 3836 3837 } 3838 3839 int phymod_rx_los_t_init(phymod_rx_los_t* phymod_rx_los) 3840 { 3841 3842 if(phymod_rx_los == NULL){ 3843 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_rx_los NULL parameter"))); 3844 } 3845 PHYMOD_MEMSET(phymod_rx_los, 0, sizeof(phymod_rx_los_t)); 3846 3847 3848 return PHYMOD_E_NONE; 3849 3850 } 3851 3852 int phymod_phy_init_config_t_validate(const phymod_phy_init_config_t* phymod_phy_init_config) 3853 { 3854 if(phymod_phy_init_config == NULL) { 3855 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 3856 } 3857 3858 if(PHYMOD_E_OK != phymod_polarity_t_validate(&phymod_phy_init_config->polarity)) { 3859 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity validation failed"))); 3860 } 3861 3862 if(PHYMOD_E_OK != phymod_operation_mode_t_validate(phymod_phy_init_config->op_mode)) { 3863 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("op_mode validation failed"))); 3864 } 3865 3866 if(PHYMOD_E_OK != phymod_autoneg_link_qualifier_t_validate(phymod_phy_init_config->an_link_qualifier)) { 3867 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_link_qualifier validation failed"))); 3868 } 3869 3870 if(PHYMOD_E_OK != phymod_phy_inf_config_t_validate(&phymod_phy_init_config->interface)) { 3871 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("interface validation failed"))); 3872 } 3873 3874 if(PHYMOD_E_OK != phymod_rx_los_t_validate(&phymod_phy_init_config->rx_los)) { 3875 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_los validation failed"))); 3876 } 3877 3878 3879 3880 return PHYMOD_E_NONE; 3881 3882 } 3883 3884 int phymod_phy_init_config_t_init(phymod_phy_init_config_t* phymod_phy_init_config) 3885 { 3886 int _array_iter; 3887 3888 3889 if(phymod_phy_init_config == NULL){ 3890 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_init_config NULL parameter"))); 3891 } 3892 PHYMOD_MEMSET(phymod_phy_init_config, 0, sizeof(phymod_phy_init_config_t)); 3893 if(PHYMOD_E_OK != phymod_polarity_t_init(&phymod_phy_init_config->polarity)) { 3894 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("polarity initialization failed"))); 3895 } 3896 3897 for(_array_iter = 0 ; _array_iter < PHYMOD_MAX_LANES_PER_CORE ; _array_iter++){ 3898 if(PHYMOD_E_OK != phymod_tx_t_init(&phymod_phy_init_config->tx[_array_iter])) { 3899 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx initialization failed"))); 3900 } 3901 } 3902 3903 if(PHYMOD_E_OK != phymod_phy_inf_config_t_init(&phymod_phy_init_config->interface)) { 3904 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("interface initialization failed"))); 3905 } 3906 3907 if(PHYMOD_E_OK != phymod_rx_los_t_init(&phymod_phy_init_config->rx_los)) { 3908 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_los initialization failed"))); 3909 } 3910 3911 for(_array_iter = 0 ; _array_iter < PHYMOD_MAX_LANES_PER_CORE ; _array_iter++){ 3912 if(PHYMOD_E_OK != phymod_tx_t_init(&phymod_phy_init_config->ext_phy_tx[_array_iter])) { 3913 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ext_phy_tx initialization failed"))); 3914 } 3915 } 3916 3917 phymod_phy_init_config->flags = 0; 3918 3919 3920 return PHYMOD_E_NONE; 3921 3922 } 3923 3924 int phymod_phy_init(const phymod_phy_access_t* phy, const phymod_phy_init_config_t* init_config) 3925 { 3926 3927 phymod_dispatch_type_t __type__; 3928 int __rv__; 3929 3930 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3931 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3932 } 3933 3934 if(PHYMOD_E_OK != phymod_phy_init_config_t_validate(init_config)) { 3935 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("init_config validation failed"))); 3936 } 3937 3938 /* Dispatch */ 3939 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3940 if(__type__ >= phymodDispatchTypeCount) { 3941 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3942 } 3943 3944 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_init) { 3945 PHYMOD_LOCK_TAKE(phy); 3946 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_init(phy, init_config); 3947 PHYMOD_LOCK_GIVE(phy); 3948 PHYMOD_IF_ERR_RETURN(__rv__); 3949 } else { 3950 return PHYMOD_E_UNAVAIL; 3951 } 3952 3953 return PHYMOD_E_NONE; 3954 3955 } 3956 3957 3958 int phymod_loopback_mode_t_validate(phymod_loopback_mode_t phymod_loopback_mode) 3959 { 3960 if(phymod_loopback_mode >= phymodLoopbackCount) { 3961 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 3962 } 3963 3964 return PHYMOD_E_NONE; 3965 3966 } 3967 3968 int phymod_phy_loopback_set(const phymod_phy_access_t* phy, phymod_loopback_mode_t loopback, uint32_t enable) 3969 { 3970 3971 phymod_dispatch_type_t __type__; 3972 int __rv__; 3973 3974 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 3975 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 3976 } 3977 3978 if(PHYMOD_E_OK != phymod_loopback_mode_t_validate(loopback)) { 3979 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("loopback validation failed"))); 3980 } 3981 3982 /* Dispatch */ 3983 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 3984 if(__type__ >= phymodDispatchTypeCount) { 3985 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 3986 } 3987 3988 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_loopback_set) { 3989 PHYMOD_LOCK_TAKE(phy); 3990 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_loopback_set(phy, loopback, enable); 3991 PHYMOD_LOCK_GIVE(phy); 3992 PHYMOD_IF_ERR_RETURN(__rv__); 3993 } else { 3994 return PHYMOD_E_UNAVAIL; 3995 } 3996 3997 return PHYMOD_E_NONE; 3998 3999 } 4000 4001 4002 int phymod_phy_loopback_get(const phymod_phy_access_t* phy, phymod_loopback_mode_t loopback, uint32_t* enable) 4003 { 4004 4005 phymod_dispatch_type_t __type__; 4006 int __rv__; 4007 4008 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4009 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4010 } 4011 4012 if(PHYMOD_E_OK != phymod_loopback_mode_t_validate(loopback)) { 4013 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("loopback validation failed"))); 4014 } 4015 4016 if(enable == NULL) { 4017 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 4018 } 4019 /* Dispatch */ 4020 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4021 if(__type__ >= phymodDispatchTypeCount) { 4022 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4023 } 4024 4025 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_loopback_get) { 4026 PHYMOD_LOCK_TAKE(phy); 4027 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_loopback_get(phy, loopback, enable); 4028 PHYMOD_LOCK_GIVE(phy); 4029 PHYMOD_IF_ERR_RETURN(__rv__); 4030 } else { 4031 return PHYMOD_E_UNAVAIL; 4032 } 4033 4034 return PHYMOD_E_NONE; 4035 4036 } 4037 4038 4039 int phymod_phy_rx_pmd_locked_get(const phymod_phy_access_t* phy, uint32_t* rx_pmd_locked) 4040 { 4041 4042 phymod_dispatch_type_t __type__; 4043 int __rv__; 4044 4045 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4046 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4047 } 4048 4049 if(rx_pmd_locked == NULL) { 4050 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_pmd_locked NULL parameter"))); 4051 } 4052 /* Dispatch */ 4053 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4054 if(__type__ >= phymodDispatchTypeCount) { 4055 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4056 } 4057 4058 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_pmd_locked_get) { 4059 PHYMOD_LOCK_TAKE(phy); 4060 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_pmd_locked_get(phy, rx_pmd_locked); 4061 PHYMOD_LOCK_GIVE(phy); 4062 PHYMOD_IF_ERR_RETURN(__rv__); 4063 } else { 4064 return PHYMOD_E_UNAVAIL; 4065 } 4066 4067 return PHYMOD_E_NONE; 4068 4069 } 4070 4071 4072 int phymod_phy_rx_signal_detect_get(const phymod_phy_access_t* phy, uint32_t* rx_signal_detect) 4073 { 4074 4075 phymod_dispatch_type_t __type__; 4076 int __rv__; 4077 4078 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4079 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4080 } 4081 4082 if(rx_signal_detect == NULL) { 4083 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_signal_detect NULL parameter"))); 4084 } 4085 /* Dispatch */ 4086 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4087 if(__type__ >= phymodDispatchTypeCount) { 4088 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4089 } 4090 4091 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_signal_detect_get) { 4092 PHYMOD_LOCK_TAKE(phy); 4093 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_signal_detect_get(phy, rx_signal_detect); 4094 PHYMOD_LOCK_GIVE(phy); 4095 PHYMOD_IF_ERR_RETURN(__rv__); 4096 } else { 4097 return PHYMOD_E_UNAVAIL; 4098 } 4099 4100 return PHYMOD_E_NONE; 4101 4102 } 4103 4104 4105 int phymod_phy_link_status_get(const phymod_phy_access_t* phy, uint32_t* link_status) 4106 { 4107 4108 phymod_dispatch_type_t __type__; 4109 int __rv__; 4110 4111 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4112 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4113 } 4114 4115 if(link_status == NULL) { 4116 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("link_status NULL parameter"))); 4117 } 4118 /* Dispatch */ 4119 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4120 if(__type__ >= phymodDispatchTypeCount) { 4121 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4122 } 4123 4124 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_link_status_get) { 4125 PHYMOD_LOCK_TAKE(phy); 4126 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_link_status_get(phy, link_status); 4127 PHYMOD_LOCK_GIVE(phy); 4128 PHYMOD_IF_ERR_RETURN(__rv__); 4129 } else { 4130 return PHYMOD_E_UNAVAIL; 4131 } 4132 4133 return PHYMOD_E_NONE; 4134 4135 } 4136 4137 4138 int phymod_phy_status_dump(const phymod_phy_access_t* phy) 4139 { 4140 4141 phymod_dispatch_type_t __type__; 4142 int __rv__; 4143 4144 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4145 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4146 } 4147 4148 /* Dispatch */ 4149 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4150 if(__type__ >= phymodDispatchTypeCount) { 4151 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4152 } 4153 4154 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_status_dump) { 4155 PHYMOD_LOCK_TAKE(phy); 4156 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_status_dump(phy); 4157 PHYMOD_LOCK_GIVE(phy); 4158 PHYMOD_IF_ERR_RETURN(__rv__); 4159 } else { 4160 return PHYMOD_E_UNAVAIL; 4161 } 4162 4163 return PHYMOD_E_NONE; 4164 4165 } 4166 4167 4168 int phymod_pcs_userspeed_mode_t_validate(phymod_pcs_userspeed_mode_t phymod_pcs_userspeed_mode) 4169 { 4170 if(phymod_pcs_userspeed_mode >= phymodPcsUserSpeedModeCount) { 4171 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4172 } 4173 4174 return PHYMOD_E_NONE; 4175 4176 } 4177 4178 int phymod_pcs_userspeed_param_t_validate(phymod_pcs_userspeed_param_t phymod_pcs_userspeed_param) 4179 { 4180 if(phymod_pcs_userspeed_param >= phymodPcsUserSpeedParamCount) { 4181 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4182 } 4183 4184 return PHYMOD_E_NONE; 4185 4186 } 4187 4188 int phymod_pcs_userspeed_config_t_validate(const phymod_pcs_userspeed_config_t* phymod_pcs_userspeed_config) 4189 { 4190 if(phymod_pcs_userspeed_config == NULL) { 4191 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 4192 } 4193 4194 if(PHYMOD_E_OK != phymod_pcs_userspeed_mode_t_validate(phymod_pcs_userspeed_config->mode)) { 4195 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mode validation failed"))); 4196 } 4197 4198 if(PHYMOD_E_OK != phymod_pcs_userspeed_param_t_validate(phymod_pcs_userspeed_config->param)) { 4199 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("param validation failed"))); 4200 } 4201 4202 4203 4204 return PHYMOD_E_NONE; 4205 4206 } 4207 4208 int phymod_pcs_userspeed_config_t_init(phymod_pcs_userspeed_config_t* phymod_pcs_userspeed_config) 4209 { 4210 4211 if(phymod_pcs_userspeed_config == NULL){ 4212 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_pcs_userspeed_config NULL parameter"))); 4213 } 4214 PHYMOD_MEMSET(phymod_pcs_userspeed_config, 0, sizeof(phymod_pcs_userspeed_config_t)); 4215 4216 4217 return PHYMOD_E_NONE; 4218 4219 } 4220 4221 int phymod_phy_pcs_userspeed_set(const phymod_phy_access_t* phy, const phymod_pcs_userspeed_config_t* config) 4222 { 4223 4224 phymod_dispatch_type_t __type__; 4225 int __rv__; 4226 4227 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4228 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4229 } 4230 4231 if(PHYMOD_E_OK != phymod_pcs_userspeed_config_t_validate(config)) { 4232 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config validation failed"))); 4233 } 4234 4235 /* Dispatch */ 4236 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4237 if(__type__ >= phymodDispatchTypeCount) { 4238 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4239 } 4240 4241 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pcs_userspeed_set) { 4242 PHYMOD_LOCK_TAKE(phy); 4243 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pcs_userspeed_set(phy, config); 4244 PHYMOD_LOCK_GIVE(phy); 4245 PHYMOD_IF_ERR_RETURN(__rv__); 4246 } else { 4247 return PHYMOD_E_UNAVAIL; 4248 } 4249 4250 return PHYMOD_E_NONE; 4251 4252 } 4253 4254 4255 int phymod_phy_pcs_userspeed_get(const phymod_phy_access_t* phy, phymod_pcs_userspeed_config_t* config) 4256 { 4257 4258 phymod_dispatch_type_t __type__; 4259 int __rv__; 4260 4261 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4262 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4263 } 4264 4265 if(config == NULL) { 4266 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config NULL parameter"))); 4267 } 4268 if(PHYMOD_E_OK != phymod_pcs_userspeed_config_t_init(config)) { 4269 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config initialization failed"))); 4270 } 4271 4272 /* Dispatch */ 4273 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4274 if(__type__ >= phymodDispatchTypeCount) { 4275 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4276 } 4277 4278 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pcs_userspeed_get) { 4279 PHYMOD_LOCK_TAKE(phy); 4280 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pcs_userspeed_get(phy, config); 4281 PHYMOD_LOCK_GIVE(phy); 4282 PHYMOD_IF_ERR_RETURN(__rv__); 4283 } else { 4284 return PHYMOD_E_UNAVAIL; 4285 } 4286 4287 return PHYMOD_E_NONE; 4288 4289 } 4290 4291 4292 int phymod_phy_reg_read(const phymod_phy_access_t* phy, uint32_t reg_addr, uint32_t* val) 4293 { 4294 4295 phymod_dispatch_type_t __type__; 4296 int __rv__; 4297 4298 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4299 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4300 } 4301 4302 if(val == NULL) { 4303 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("val NULL parameter"))); 4304 } 4305 /* Dispatch */ 4306 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4307 if(__type__ >= phymodDispatchTypeCount) { 4308 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4309 } 4310 4311 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_reg_read) { 4312 PHYMOD_LOCK_TAKE(phy); 4313 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_reg_read(phy, reg_addr, val); 4314 PHYMOD_LOCK_GIVE(phy); 4315 PHYMOD_IF_ERR_RETURN(__rv__); 4316 } else { 4317 return PHYMOD_E_UNAVAIL; 4318 } 4319 4320 return PHYMOD_E_NONE; 4321 4322 } 4323 4324 4325 int phymod_phy_reg_write(const phymod_phy_access_t* phy, uint32_t reg_addr, uint32_t val) 4326 { 4327 4328 phymod_dispatch_type_t __type__; 4329 int __rv__; 4330 4331 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4332 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4333 } 4334 4335 /* Dispatch */ 4336 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4337 if(__type__ >= phymodDispatchTypeCount) { 4338 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4339 } 4340 4341 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_reg_write) { 4342 PHYMOD_LOCK_TAKE(phy); 4343 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_reg_write(phy, reg_addr, val); 4344 PHYMOD_LOCK_GIVE(phy); 4345 PHYMOD_IF_ERR_RETURN(__rv__); 4346 } else { 4347 return PHYMOD_E_UNAVAIL; 4348 } 4349 4350 return PHYMOD_E_NONE; 4351 4352 } 4353 4354 4355 int phymod_phy_private_read(const phymod_phy_access_t* phy, uint32_t addr, uint32_t* val) 4356 { 4357 4358 phymod_dispatch_type_t __type__; 4359 int __rv__; 4360 4361 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4362 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4363 } 4364 4365 if(val == NULL) { 4366 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("val NULL parameter"))); 4367 } 4368 /* Dispatch */ 4369 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4370 if(__type__ >= phymodDispatchTypeCount) { 4371 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4372 } 4373 4374 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_private_read) { 4375 PHYMOD_LOCK_TAKE(phy); 4376 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_private_read(phy, addr, val); 4377 PHYMOD_LOCK_GIVE(phy); 4378 PHYMOD_IF_ERR_RETURN(__rv__); 4379 } else { 4380 return PHYMOD_E_UNAVAIL; 4381 } 4382 4383 return PHYMOD_E_NONE; 4384 4385 } 4386 4387 4388 int phymod_phy_private_write(const phymod_phy_access_t* phy, uint32_t addr, uint32_t val) 4389 { 4390 4391 phymod_dispatch_type_t __type__; 4392 int __rv__; 4393 4394 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4395 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4396 } 4397 4398 /* Dispatch */ 4399 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4400 if(__type__ >= phymodDispatchTypeCount) { 4401 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4402 } 4403 4404 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_private_write) { 4405 PHYMOD_LOCK_TAKE(phy); 4406 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_private_write(phy, addr, val); 4407 PHYMOD_LOCK_GIVE(phy); 4408 PHYMOD_IF_ERR_RETURN(__rv__); 4409 } else { 4410 return PHYMOD_E_UNAVAIL; 4411 } 4412 4413 return PHYMOD_E_NONE; 4414 4415 } 4416 4417 4418 int phymod_phy_rev_id(const phymod_phy_access_t* phy, uint32_t* rev_id) 4419 { 4420 4421 phymod_dispatch_type_t __type__; 4422 int __rv__; 4423 4424 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4425 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4426 } 4427 4428 if(rev_id == NULL) { 4429 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rev_id NULL parameter"))); 4430 } 4431 /* Dispatch */ 4432 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4433 if(__type__ >= phymodDispatchTypeCount) { 4434 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4435 } 4436 4437 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rev_id) { 4438 PHYMOD_LOCK_TAKE(phy); 4439 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rev_id(phy, rev_id); 4440 PHYMOD_LOCK_GIVE(phy); 4441 PHYMOD_IF_ERR_RETURN(__rv__); 4442 } else { 4443 return PHYMOD_E_UNAVAIL; 4444 } 4445 4446 return PHYMOD_E_NONE; 4447 4448 } 4449 4450 4451 int phymod_phy_lane_cross_switch_map_set(const phymod_phy_access_t* phy, const uint32_t* tx_array) 4452 { 4453 4454 phymod_dispatch_type_t __type__; 4455 int __rv__; 4456 4457 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4458 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4459 } 4460 4461 /* Dispatch */ 4462 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4463 if(__type__ >= phymodDispatchTypeCount) { 4464 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4465 } 4466 4467 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_lane_cross_switch_map_set) { 4468 PHYMOD_LOCK_TAKE(phy); 4469 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_lane_cross_switch_map_set(phy, tx_array); 4470 PHYMOD_LOCK_GIVE(phy); 4471 PHYMOD_IF_ERR_RETURN(__rv__); 4472 } else { 4473 return PHYMOD_E_UNAVAIL; 4474 } 4475 4476 return PHYMOD_E_NONE; 4477 4478 } 4479 4480 4481 int phymod_phy_lane_cross_switch_map_get(const phymod_phy_access_t* phy, uint32_t* tx_array) 4482 { 4483 4484 phymod_dispatch_type_t __type__; 4485 int __rv__; 4486 4487 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4488 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4489 } 4490 4491 if(tx_array == NULL) { 4492 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_array NULL parameter"))); 4493 } 4494 /* Dispatch */ 4495 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4496 if(__type__ >= phymodDispatchTypeCount) { 4497 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4498 } 4499 4500 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_lane_cross_switch_map_get) { 4501 PHYMOD_LOCK_TAKE(phy); 4502 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_lane_cross_switch_map_get(phy, tx_array); 4503 PHYMOD_LOCK_GIVE(phy); 4504 PHYMOD_IF_ERR_RETURN(__rv__); 4505 } else { 4506 return PHYMOD_E_UNAVAIL; 4507 } 4508 4509 return PHYMOD_E_NONE; 4510 4511 } 4512 4513 4514 int phymod_phy_intr_enable_set(const phymod_phy_access_t* phy, uint32_t enable) 4515 { 4516 4517 phymod_dispatch_type_t __type__; 4518 int __rv__; 4519 4520 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4521 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4522 } 4523 4524 /* Dispatch */ 4525 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4526 if(__type__ >= phymodDispatchTypeCount) { 4527 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4528 } 4529 4530 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_intr_enable_set) { 4531 PHYMOD_LOCK_TAKE(phy); 4532 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_intr_enable_set(phy, enable); 4533 PHYMOD_LOCK_GIVE(phy); 4534 PHYMOD_IF_ERR_RETURN(__rv__); 4535 } else { 4536 return PHYMOD_E_UNAVAIL; 4537 } 4538 4539 return PHYMOD_E_NONE; 4540 4541 } 4542 4543 4544 int phymod_phy_intr_enable_get(const phymod_phy_access_t* phy, uint32_t* enable) 4545 { 4546 4547 phymod_dispatch_type_t __type__; 4548 int __rv__; 4549 4550 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4551 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4552 } 4553 4554 if(enable == NULL) { 4555 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 4556 } 4557 /* Dispatch */ 4558 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4559 if(__type__ >= phymodDispatchTypeCount) { 4560 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4561 } 4562 4563 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_intr_enable_get) { 4564 PHYMOD_LOCK_TAKE(phy); 4565 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_intr_enable_get(phy, enable); 4566 PHYMOD_LOCK_GIVE(phy); 4567 PHYMOD_IF_ERR_RETURN(__rv__); 4568 } else { 4569 return PHYMOD_E_UNAVAIL; 4570 } 4571 4572 return PHYMOD_E_NONE; 4573 4574 } 4575 4576 4577 int phymod_phy_intr_status_get(const phymod_phy_access_t* phy, uint32_t* intr_status) 4578 { 4579 4580 phymod_dispatch_type_t __type__; 4581 int __rv__; 4582 4583 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4584 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4585 } 4586 4587 if(intr_status == NULL) { 4588 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("intr_status NULL parameter"))); 4589 } 4590 /* Dispatch */ 4591 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4592 if(__type__ >= phymodDispatchTypeCount) { 4593 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4594 } 4595 4596 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_intr_status_get) { 4597 PHYMOD_LOCK_TAKE(phy); 4598 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_intr_status_get(phy, intr_status); 4599 PHYMOD_LOCK_GIVE(phy); 4600 PHYMOD_IF_ERR_RETURN(__rv__); 4601 } else { 4602 return PHYMOD_E_UNAVAIL; 4603 } 4604 4605 return PHYMOD_E_NONE; 4606 4607 } 4608 4609 4610 int phymod_phy_intr_status_clear(const phymod_phy_access_t* phy, uint32_t intr_clr) 4611 { 4612 4613 phymod_dispatch_type_t __type__; 4614 int __rv__; 4615 4616 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4617 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4618 } 4619 4620 /* Dispatch */ 4621 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4622 if(__type__ >= phymodDispatchTypeCount) { 4623 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4624 } 4625 4626 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_intr_status_clear) { 4627 PHYMOD_LOCK_TAKE(phy); 4628 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_intr_status_clear(phy, intr_clr); 4629 PHYMOD_LOCK_GIVE(phy); 4630 PHYMOD_IF_ERR_RETURN(__rv__); 4631 } else { 4632 return PHYMOD_E_UNAVAIL; 4633 } 4634 4635 return PHYMOD_E_NONE; 4636 4637 } 4638 4639 4640 int phymod_phy_i2c_read(const phymod_phy_access_t* phy, uint32_t flags, uint32_t addr, uint32_t offset, uint32_t size, uint8_t* data) 4641 { 4642 4643 phymod_dispatch_type_t __type__; 4644 int __rv__; 4645 4646 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4647 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4648 } 4649 4650 if(data == NULL) { 4651 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("data NULL parameter"))); 4652 } 4653 /* Dispatch */ 4654 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4655 if(__type__ >= phymodDispatchTypeCount) { 4656 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4657 } 4658 4659 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_i2c_read) { 4660 PHYMOD_LOCK_TAKE(phy); 4661 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_i2c_read(phy, flags, addr, offset, size, data); 4662 PHYMOD_LOCK_GIVE(phy); 4663 PHYMOD_IF_ERR_RETURN(__rv__); 4664 } else { 4665 return PHYMOD_E_UNAVAIL; 4666 } 4667 4668 return PHYMOD_E_NONE; 4669 4670 } 4671 4672 4673 int phymod_phy_i2c_write(const phymod_phy_access_t* phy, uint32_t flags, uint32_t addr, uint32_t offset, uint32_t size, const uint8_t* data) 4674 { 4675 4676 phymod_dispatch_type_t __type__; 4677 int __rv__; 4678 4679 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4680 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4681 } 4682 4683 /* Dispatch */ 4684 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4685 if(__type__ >= phymodDispatchTypeCount) { 4686 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4687 } 4688 4689 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_i2c_write) { 4690 PHYMOD_LOCK_TAKE(phy); 4691 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_i2c_write(phy, flags, addr, offset, size, data); 4692 PHYMOD_LOCK_GIVE(phy); 4693 PHYMOD_IF_ERR_RETURN(__rv__); 4694 } else { 4695 return PHYMOD_E_UNAVAIL; 4696 } 4697 4698 return PHYMOD_E_NONE; 4699 4700 } 4701 4702 4703 int phymod_gpio_mode_t_validate(phymod_gpio_mode_t phymod_gpio_mode) 4704 { 4705 if(phymod_gpio_mode >= phymodGpioModeCount) { 4706 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4707 } 4708 4709 return PHYMOD_E_NONE; 4710 4711 } 4712 4713 int phymod_phy_gpio_config_set(const phymod_phy_access_t* phy, int pin_no, phymod_gpio_mode_t gpio_mode) 4714 { 4715 4716 phymod_dispatch_type_t __type__; 4717 int __rv__; 4718 4719 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4720 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4721 } 4722 4723 if(PHYMOD_E_OK != phymod_gpio_mode_t_validate(gpio_mode)) { 4724 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("gpio_mode validation failed"))); 4725 } 4726 4727 /* Dispatch */ 4728 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4729 if(__type__ >= phymodDispatchTypeCount) { 4730 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4731 } 4732 4733 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_gpio_config_set) { 4734 PHYMOD_LOCK_TAKE(phy); 4735 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_gpio_config_set(phy, pin_no, gpio_mode); 4736 PHYMOD_LOCK_GIVE(phy); 4737 PHYMOD_IF_ERR_RETURN(__rv__); 4738 } else { 4739 return PHYMOD_E_UNAVAIL; 4740 } 4741 4742 return PHYMOD_E_NONE; 4743 4744 } 4745 4746 4747 int phymod_phy_gpio_config_get(const phymod_phy_access_t* phy, int pin_no, phymod_gpio_mode_t* gpio_mode) 4748 { 4749 4750 phymod_dispatch_type_t __type__; 4751 int __rv__; 4752 4753 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4754 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4755 } 4756 4757 if(gpio_mode == NULL) { 4758 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("gpio_mode NULL parameter"))); 4759 } 4760 /* Dispatch */ 4761 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4762 if(__type__ >= phymodDispatchTypeCount) { 4763 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4764 } 4765 4766 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_gpio_config_get) { 4767 PHYMOD_LOCK_TAKE(phy); 4768 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_gpio_config_get(phy, pin_no, gpio_mode); 4769 PHYMOD_LOCK_GIVE(phy); 4770 PHYMOD_IF_ERR_RETURN(__rv__); 4771 } else { 4772 return PHYMOD_E_UNAVAIL; 4773 } 4774 4775 return PHYMOD_E_NONE; 4776 4777 } 4778 4779 4780 int phymod_phy_gpio_pin_value_set(const phymod_phy_access_t* phy, int pin_no, int value) 4781 { 4782 4783 phymod_dispatch_type_t __type__; 4784 int __rv__; 4785 4786 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4787 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4788 } 4789 4790 /* Dispatch */ 4791 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4792 if(__type__ >= phymodDispatchTypeCount) { 4793 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4794 } 4795 4796 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_gpio_pin_value_set) { 4797 PHYMOD_LOCK_TAKE(phy); 4798 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_gpio_pin_value_set(phy, pin_no, value); 4799 PHYMOD_LOCK_GIVE(phy); 4800 PHYMOD_IF_ERR_RETURN(__rv__); 4801 } else { 4802 return PHYMOD_E_UNAVAIL; 4803 } 4804 4805 return PHYMOD_E_NONE; 4806 4807 } 4808 4809 4810 int phymod_phy_gpio_pin_value_get(const phymod_phy_access_t* phy, int pin_no, int* value) 4811 { 4812 4813 phymod_dispatch_type_t __type__; 4814 int __rv__; 4815 4816 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 4817 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 4818 } 4819 4820 if(value == NULL) { 4821 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("value NULL parameter"))); 4822 } 4823 /* Dispatch */ 4824 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 4825 if(__type__ >= phymodDispatchTypeCount) { 4826 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 4827 } 4828 4829 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_gpio_pin_value_get) { 4830 PHYMOD_LOCK_TAKE(phy); 4831 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_gpio_pin_value_get(phy, pin_no, value); 4832 PHYMOD_LOCK_GIVE(phy); 4833 PHYMOD_IF_ERR_RETURN(__rv__); 4834 } else { 4835 return PHYMOD_E_UNAVAIL; 4836 } 4837 4838 return PHYMOD_E_NONE; 4839 4840 } 4841 4842 4843 int phymod_osr_mode_t_validate(phymod_osr_mode_t phymod_osr_mode) 4844 { 4845 if(phymod_osr_mode >= phymodOversampleModeCount) { 4846 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4847 } 4848 4849 return PHYMOD_E_NONE; 4850 4851 } 4852 4853 int phymod_timesync_timer_mode_t_validate(phymod_timesync_timer_mode_t phymod_timesync_timer_mode) 4854 { 4855 if(phymod_timesync_timer_mode >= phymodTimesyncTimerModeCount) { 4856 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4857 } 4858 4859 return PHYMOD_E_NONE; 4860 4861 } 4862 4863 int phymod_timesync_global_mode_t_validate(phymod_timesync_global_mode_t phymod_timesync_global_mode) 4864 { 4865 if(phymod_timesync_global_mode >= phymodTimesyncGLobalModeCount) { 4866 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4867 } 4868 4869 return PHYMOD_E_NONE; 4870 4871 } 4872 4873 int phymod_timesync_framesync_mode_t_validate(phymod_timesync_framesync_mode_t phymod_timesync_framesync_mode) 4874 { 4875 if(phymod_timesync_framesync_mode >= phymodTimesyncFramsyncModeCount) { 4876 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4877 } 4878 4879 return PHYMOD_E_NONE; 4880 4881 } 4882 4883 int phymod_timesync_syncout_mode_t_validate(phymod_timesync_syncout_mode_t phymod_timesync_syncout_mode) 4884 { 4885 if(phymod_timesync_syncout_mode >= phymodTimesyncSyncoutModeCount) { 4886 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4887 } 4888 4889 return PHYMOD_E_NONE; 4890 4891 } 4892 4893 int phymod_timesync_event_msg_action_t_validate(phymod_timesync_event_msg_action_t phymod_timesync_event_msg_action) 4894 { 4895 if(phymod_timesync_event_msg_action >= phymodTimesyncEventMsgActionCount) { 4896 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 4897 } 4898 4899 return PHYMOD_E_NONE; 4900 4901 } 4902 4903 int phymod_timesync_timer_adjust_t_validate(const phymod_timesync_timer_adjust_t* phymod_timesync_timer_adjust) 4904 { 4905 if(phymod_timesync_timer_adjust == NULL) { 4906 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 4907 } 4908 4909 if(PHYMOD_E_OK != phymod_timesync_timer_mode_t_validate(phymod_timesync_timer_adjust->mode)) { 4910 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mode validation failed"))); 4911 } 4912 4913 4914 4915 return PHYMOD_E_NONE; 4916 4917 } 4918 4919 int phymod_timesync_timer_adjust_t_init(phymod_timesync_timer_adjust_t* phymod_timesync_timer_adjust) 4920 { 4921 4922 if(phymod_timesync_timer_adjust == NULL){ 4923 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_timer_adjust NULL parameter"))); 4924 } 4925 PHYMOD_MEMSET(phymod_timesync_timer_adjust, 0, sizeof(phymod_timesync_timer_adjust_t)); 4926 4927 4928 return PHYMOD_E_NONE; 4929 4930 } 4931 4932 int phymod_timesync_inband_ctrl_t_validate(const phymod_timesync_inband_ctrl_t* phymod_timesync_inband_ctrl) 4933 { 4934 if(phymod_timesync_inband_ctrl == NULL) { 4935 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 4936 } 4937 4938 if(PHYMOD_E_OK != phymod_timesync_timer_mode_t_validate(phymod_timesync_inband_ctrl->timer_mode)) { 4939 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("timer_mode validation failed"))); 4940 } 4941 4942 4943 4944 return PHYMOD_E_NONE; 4945 4946 } 4947 4948 int phymod_timesync_inband_ctrl_t_init(phymod_timesync_inband_ctrl_t* phymod_timesync_inband_ctrl) 4949 { 4950 4951 if(phymod_timesync_inband_ctrl == NULL){ 4952 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_inband_ctrl NULL parameter"))); 4953 } 4954 PHYMOD_MEMSET(phymod_timesync_inband_ctrl, 0, sizeof(phymod_timesync_inband_ctrl_t)); 4955 4956 4957 return PHYMOD_E_NONE; 4958 4959 } 4960 4961 int phymod_timesync_framesync_t_validate(const phymod_timesync_framesync_t* phymod_timesync_framesync) 4962 { 4963 if(phymod_timesync_framesync == NULL) { 4964 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 4965 } 4966 4967 if(PHYMOD_E_OK != phymod_timesync_framesync_mode_t_validate(phymod_timesync_framesync->mode)) { 4968 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mode validation failed"))); 4969 } 4970 4971 4972 4973 return PHYMOD_E_NONE; 4974 4975 } 4976 4977 int phymod_timesync_framesync_t_init(phymod_timesync_framesync_t* phymod_timesync_framesync) 4978 { 4979 4980 if(phymod_timesync_framesync == NULL){ 4981 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_framesync NULL parameter"))); 4982 } 4983 PHYMOD_MEMSET(phymod_timesync_framesync, 0, sizeof(phymod_timesync_framesync_t)); 4984 4985 4986 return PHYMOD_E_NONE; 4987 4988 } 4989 4990 int phymod_timesync_syncout_t_validate(const phymod_timesync_syncout_t* phymod_timesync_syncout) 4991 { 4992 if(phymod_timesync_syncout == NULL) { 4993 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 4994 } 4995 4996 4997 4998 return PHYMOD_E_NONE; 4999 5000 } 5001 5002 int phymod_timesync_syncout_t_init(phymod_timesync_syncout_t* phymod_timesync_syncout) 5003 { 5004 5005 if(phymod_timesync_syncout == NULL){ 5006 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_syncout NULL parameter"))); 5007 } 5008 PHYMOD_MEMSET(phymod_timesync_syncout, 0, sizeof(phymod_timesync_syncout_t)); 5009 5010 5011 return PHYMOD_E_NONE; 5012 5013 } 5014 5015 int phymod_timesync_timespec_t_validate(const phymod_timesync_timespec_t* phymod_timesync_timespec) 5016 { 5017 if(phymod_timesync_timespec == NULL) { 5018 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 5019 } 5020 5021 5022 5023 return PHYMOD_E_NONE; 5024 5025 } 5026 5027 int phymod_timesync_timespec_t_init(phymod_timesync_timespec_t* phymod_timesync_timespec) 5028 { 5029 5030 if(phymod_timesync_timespec == NULL){ 5031 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_timespec NULL parameter"))); 5032 } 5033 PHYMOD_MEMSET(phymod_timesync_timespec, 0, sizeof(phymod_timesync_timespec_t)); 5034 5035 5036 return PHYMOD_E_NONE; 5037 5038 } 5039 5040 int phymod_timesync_mpls_label_t_validate(const phymod_timesync_mpls_label_t* phymod_timesync_mpls_label) 5041 { 5042 if(phymod_timesync_mpls_label == NULL) { 5043 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 5044 } 5045 5046 5047 5048 return PHYMOD_E_NONE; 5049 5050 } 5051 5052 int phymod_timesync_mpls_label_t_init(phymod_timesync_mpls_label_t* phymod_timesync_mpls_label) 5053 { 5054 5055 if(phymod_timesync_mpls_label == NULL){ 5056 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_mpls_label NULL parameter"))); 5057 } 5058 PHYMOD_MEMSET(phymod_timesync_mpls_label, 0, sizeof(phymod_timesync_mpls_label_t)); 5059 5060 5061 return PHYMOD_E_NONE; 5062 5063 } 5064 5065 int phymod_timesync_mpls_ctrl_t_validate(const phymod_timesync_mpls_ctrl_t* phymod_timesync_mpls_ctrl) 5066 { 5067 if(phymod_timesync_mpls_ctrl == NULL) { 5068 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 5069 } 5070 5071 5072 5073 return PHYMOD_E_NONE; 5074 5075 } 5076 5077 int phymod_timesync_mpls_ctrl_t_init(phymod_timesync_mpls_ctrl_t* phymod_timesync_mpls_ctrl) 5078 { 5079 int _array_iter; 5080 5081 5082 if(phymod_timesync_mpls_ctrl == NULL){ 5083 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_mpls_ctrl NULL parameter"))); 5084 } 5085 PHYMOD_MEMSET(phymod_timesync_mpls_ctrl, 0, sizeof(phymod_timesync_mpls_ctrl_t)); 5086 for(_array_iter = 0 ; _array_iter < 10 ; _array_iter++){ 5087 if(PHYMOD_E_OK != phymod_timesync_mpls_label_t_init(&phymod_timesync_mpls_ctrl->labels[_array_iter])) { 5088 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("labels initialization failed"))); 5089 } 5090 } 5091 5092 5093 5094 return PHYMOD_E_NONE; 5095 5096 } 5097 5098 int phymod_timesync_config_t_validate(const phymod_timesync_config_t* phymod_timesync_config) 5099 { 5100 if(phymod_timesync_config == NULL) { 5101 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 5102 } 5103 5104 if(PHYMOD_E_OK != phymod_timesync_timer_adjust_t_validate(&phymod_timesync_config->timer_adjust)) { 5105 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("timer_adjust validation failed"))); 5106 } 5107 5108 if(PHYMOD_E_OK != phymod_timesync_inband_ctrl_t_validate(&phymod_timesync_config->inband_ctrl)) { 5109 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("inband_ctrl validation failed"))); 5110 } 5111 5112 if(PHYMOD_E_OK != phymod_timesync_global_mode_t_validate(phymod_timesync_config->gmode)) { 5113 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("gmode validation failed"))); 5114 } 5115 5116 if(PHYMOD_E_OK != phymod_timesync_syncout_t_validate(&phymod_timesync_config->syncout)) { 5117 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("syncout validation failed"))); 5118 } 5119 5120 if(PHYMOD_E_OK != phymod_timesync_timespec_t_validate(&phymod_timesync_config->original_timecode)) { 5121 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("original_timecode validation failed"))); 5122 } 5123 5124 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->tx_sync_mode)) { 5125 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_sync_mode validation failed"))); 5126 } 5127 5128 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->tx_delay_req_mode)) { 5129 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_delay_req_mode validation failed"))); 5130 } 5131 5132 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->tx_pdelay_req_mode)) { 5133 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_pdelay_req_mode validation failed"))); 5134 } 5135 5136 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->tx_pdelay_resp_mode)) { 5137 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_pdelay_resp_mode validation failed"))); 5138 } 5139 5140 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->rx_sync_mode)) { 5141 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_sync_mode validation failed"))); 5142 } 5143 5144 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->rx_delay_req_mode)) { 5145 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_delay_req_mode validation failed"))); 5146 } 5147 5148 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->rx_pdelay_req_mode)) { 5149 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_pdelay_req_mode validation failed"))); 5150 } 5151 5152 if(PHYMOD_E_OK != phymod_timesync_event_msg_action_t_validate(phymod_timesync_config->rx_pdelay_resp_mode)) { 5153 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_pdelay_resp_mode validation failed"))); 5154 } 5155 5156 if(PHYMOD_E_OK != phymod_timesync_mpls_ctrl_t_validate(&phymod_timesync_config->mpls_ctrl)) { 5157 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mpls_ctrl validation failed"))); 5158 } 5159 5160 5161 5162 return PHYMOD_E_NONE; 5163 5164 } 5165 5166 int phymod_timesync_config_t_init(phymod_timesync_config_t* phymod_timesync_config) 5167 { 5168 5169 if(phymod_timesync_config == NULL){ 5170 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_timesync_config NULL parameter"))); 5171 } 5172 PHYMOD_MEMSET(phymod_timesync_config, 0, sizeof(phymod_timesync_config_t)); 5173 if(PHYMOD_E_OK != phymod_timesync_timer_adjust_t_init(&phymod_timesync_config->timer_adjust)) { 5174 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("timer_adjust initialization failed"))); 5175 } 5176 5177 if(PHYMOD_E_OK != phymod_timesync_inband_ctrl_t_init(&phymod_timesync_config->inband_ctrl)) { 5178 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("inband_ctrl initialization failed"))); 5179 } 5180 5181 if(PHYMOD_E_OK != phymod_timesync_syncout_t_init(&phymod_timesync_config->syncout)) { 5182 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("syncout initialization failed"))); 5183 } 5184 5185 if(PHYMOD_E_OK != phymod_timesync_timespec_t_init(&phymod_timesync_config->original_timecode)) { 5186 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("original_timecode initialization failed"))); 5187 } 5188 5189 if(PHYMOD_E_OK != phymod_timesync_mpls_ctrl_t_init(&phymod_timesync_config->mpls_ctrl)) { 5190 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mpls_ctrl initialization failed"))); 5191 } 5192 5193 5194 5195 return PHYMOD_E_NONE; 5196 5197 } 5198 5199 int phymod_timesync_compensation_mode_t_validate(phymod_timesync_compensation_mode_t phymod_timesync_compensation_mode) 5200 { 5201 if(phymod_timesync_compensation_mode >= phymodTimesyncCompensationModeCount) { 5202 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 5203 } 5204 5205 return PHYMOD_E_NONE; 5206 5207 } 5208 5209 int phymod_timesync_config_set(const phymod_phy_access_t* phy, const phymod_timesync_config_t* config) 5210 { 5211 5212 phymod_dispatch_type_t __type__; 5213 int __rv__; 5214 5215 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5216 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5217 } 5218 5219 if(PHYMOD_E_OK != phymod_timesync_config_t_validate(config)) { 5220 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config validation failed"))); 5221 } 5222 5223 /* Dispatch */ 5224 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5225 if(__type__ >= phymodDispatchTypeCount) { 5226 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5227 } 5228 5229 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_config_set) { 5230 PHYMOD_LOCK_TAKE(phy); 5231 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_config_set(phy, config); 5232 PHYMOD_LOCK_GIVE(phy); 5233 PHYMOD_IF_ERR_RETURN(__rv__); 5234 } else { 5235 return PHYMOD_E_UNAVAIL; 5236 } 5237 5238 return PHYMOD_E_NONE; 5239 5240 } 5241 5242 5243 int phymod_timesync_config_get(const phymod_phy_access_t* phy, phymod_timesync_config_t* config) 5244 { 5245 5246 phymod_dispatch_type_t __type__; 5247 int __rv__; 5248 5249 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5250 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5251 } 5252 5253 if(config == NULL) { 5254 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config NULL parameter"))); 5255 } 5256 if(PHYMOD_E_OK != phymod_timesync_config_t_init(config)) { 5257 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("config initialization failed"))); 5258 } 5259 5260 /* Dispatch */ 5261 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5262 if(__type__ >= phymodDispatchTypeCount) { 5263 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5264 } 5265 5266 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_config_get) { 5267 PHYMOD_LOCK_TAKE(phy); 5268 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_config_get(phy, config); 5269 PHYMOD_LOCK_GIVE(phy); 5270 PHYMOD_IF_ERR_RETURN(__rv__); 5271 } else { 5272 return PHYMOD_E_UNAVAIL; 5273 } 5274 5275 return PHYMOD_E_NONE; 5276 5277 } 5278 5279 5280 int phymod_timesync_enable_set(const phymod_phy_access_t* phy, uint32_t flags, uint32_t enable) 5281 { 5282 5283 phymod_dispatch_type_t __type__; 5284 int __rv__; 5285 5286 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5287 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5288 } 5289 5290 /* Dispatch */ 5291 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5292 if(__type__ >= phymodDispatchTypeCount) { 5293 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5294 } 5295 5296 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_enable_set) { 5297 PHYMOD_LOCK_TAKE(phy); 5298 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_enable_set(phy, flags, enable); 5299 PHYMOD_LOCK_GIVE(phy); 5300 PHYMOD_IF_ERR_RETURN(__rv__); 5301 } else { 5302 return PHYMOD_E_UNAVAIL; 5303 } 5304 5305 return PHYMOD_E_NONE; 5306 5307 } 5308 5309 5310 int phymod_timesync_enable_get(const phymod_phy_access_t* phy, uint32_t flags, uint32_t* enable) 5311 { 5312 5313 phymod_dispatch_type_t __type__; 5314 int __rv__; 5315 5316 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5317 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5318 } 5319 5320 if(enable == NULL) { 5321 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 5322 } 5323 /* Dispatch */ 5324 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5325 if(__type__ >= phymodDispatchTypeCount) { 5326 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5327 } 5328 5329 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_enable_get) { 5330 PHYMOD_LOCK_TAKE(phy); 5331 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_enable_get(phy, flags, enable); 5332 PHYMOD_LOCK_GIVE(phy); 5333 PHYMOD_IF_ERR_RETURN(__rv__); 5334 } else { 5335 return PHYMOD_E_UNAVAIL; 5336 } 5337 5338 return PHYMOD_E_NONE; 5339 5340 } 5341 5342 5343 int phymod_timesync_nco_addend_set(const phymod_phy_access_t* phy, uint32_t freq_step) 5344 { 5345 5346 phymod_dispatch_type_t __type__; 5347 int __rv__; 5348 5349 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5350 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5351 } 5352 5353 /* Dispatch */ 5354 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5355 if(__type__ >= phymodDispatchTypeCount) { 5356 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5357 } 5358 5359 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_nco_addend_set) { 5360 PHYMOD_LOCK_TAKE(phy); 5361 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_nco_addend_set(phy, freq_step); 5362 PHYMOD_LOCK_GIVE(phy); 5363 PHYMOD_IF_ERR_RETURN(__rv__); 5364 } else { 5365 return PHYMOD_E_UNAVAIL; 5366 } 5367 5368 return PHYMOD_E_NONE; 5369 5370 } 5371 5372 5373 int phymod_timesync_nco_addend_get(const phymod_phy_access_t* phy, uint32_t* freq_step) 5374 { 5375 5376 phymod_dispatch_type_t __type__; 5377 int __rv__; 5378 5379 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5380 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5381 } 5382 5383 if(freq_step == NULL) { 5384 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("freq_step NULL parameter"))); 5385 } 5386 /* Dispatch */ 5387 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5388 if(__type__ >= phymodDispatchTypeCount) { 5389 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5390 } 5391 5392 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_nco_addend_get) { 5393 PHYMOD_LOCK_TAKE(phy); 5394 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_nco_addend_get(phy, freq_step); 5395 PHYMOD_LOCK_GIVE(phy); 5396 PHYMOD_IF_ERR_RETURN(__rv__); 5397 } else { 5398 return PHYMOD_E_UNAVAIL; 5399 } 5400 5401 return PHYMOD_E_NONE; 5402 5403 } 5404 5405 5406 int phymod_timesync_framesync_mode_set(const phymod_phy_access_t* phy, const phymod_timesync_framesync_t* framesync) 5407 { 5408 5409 phymod_dispatch_type_t __type__; 5410 int __rv__; 5411 5412 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5413 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5414 } 5415 5416 if(PHYMOD_E_OK != phymod_timesync_framesync_t_validate(framesync)) { 5417 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("framesync validation failed"))); 5418 } 5419 5420 /* Dispatch */ 5421 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5422 if(__type__ >= phymodDispatchTypeCount) { 5423 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5424 } 5425 5426 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_framesync_mode_set) { 5427 PHYMOD_LOCK_TAKE(phy); 5428 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_framesync_mode_set(phy, framesync); 5429 PHYMOD_LOCK_GIVE(phy); 5430 PHYMOD_IF_ERR_RETURN(__rv__); 5431 } else { 5432 return PHYMOD_E_UNAVAIL; 5433 } 5434 5435 return PHYMOD_E_NONE; 5436 5437 } 5438 5439 5440 int phymod_timesync_framesync_mode_get(const phymod_phy_access_t* phy, phymod_timesync_framesync_t* framesync) 5441 { 5442 5443 phymod_dispatch_type_t __type__; 5444 int __rv__; 5445 5446 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5447 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5448 } 5449 5450 if(framesync == NULL) { 5451 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("framesync NULL parameter"))); 5452 } 5453 if(PHYMOD_E_OK != phymod_timesync_framesync_t_init(framesync)) { 5454 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("framesync initialization failed"))); 5455 } 5456 5457 /* Dispatch */ 5458 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5459 if(__type__ >= phymodDispatchTypeCount) { 5460 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5461 } 5462 5463 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_framesync_mode_get) { 5464 PHYMOD_LOCK_TAKE(phy); 5465 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_framesync_mode_get(phy, framesync); 5466 PHYMOD_LOCK_GIVE(phy); 5467 PHYMOD_IF_ERR_RETURN(__rv__); 5468 } else { 5469 return PHYMOD_E_UNAVAIL; 5470 } 5471 5472 return PHYMOD_E_NONE; 5473 5474 } 5475 5476 5477 int phymod_timesync_local_time_set(const phymod_phy_access_t* phy, uint64_t local_time) 5478 { 5479 5480 phymod_dispatch_type_t __type__; 5481 int __rv__; 5482 5483 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5484 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5485 } 5486 5487 /* Dispatch */ 5488 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5489 if(__type__ >= phymodDispatchTypeCount) { 5490 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5491 } 5492 5493 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_local_time_set) { 5494 PHYMOD_LOCK_TAKE(phy); 5495 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_local_time_set(phy, local_time); 5496 PHYMOD_LOCK_GIVE(phy); 5497 PHYMOD_IF_ERR_RETURN(__rv__); 5498 } else { 5499 return PHYMOD_E_UNAVAIL; 5500 } 5501 5502 return PHYMOD_E_NONE; 5503 5504 } 5505 5506 5507 int phymod_timesync_local_time_get(const phymod_phy_access_t* phy, uint64_t* local_time) 5508 { 5509 5510 phymod_dispatch_type_t __type__; 5511 int __rv__; 5512 5513 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5514 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5515 } 5516 5517 if(local_time == NULL) { 5518 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("local_time NULL parameter"))); 5519 } 5520 /* Dispatch */ 5521 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5522 if(__type__ >= phymodDispatchTypeCount) { 5523 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5524 } 5525 5526 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_local_time_get) { 5527 PHYMOD_LOCK_TAKE(phy); 5528 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_local_time_get(phy, local_time); 5529 PHYMOD_LOCK_GIVE(phy); 5530 PHYMOD_IF_ERR_RETURN(__rv__); 5531 } else { 5532 return PHYMOD_E_UNAVAIL; 5533 } 5534 5535 return PHYMOD_E_NONE; 5536 5537 } 5538 5539 5540 int phymod_timesync_load_ctrl_set(const phymod_phy_access_t* phy, uint32_t load_once, uint32_t load_always) 5541 { 5542 5543 phymod_dispatch_type_t __type__; 5544 int __rv__; 5545 5546 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5547 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5548 } 5549 5550 /* Dispatch */ 5551 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5552 if(__type__ >= phymodDispatchTypeCount) { 5553 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5554 } 5555 5556 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_load_ctrl_set) { 5557 PHYMOD_LOCK_TAKE(phy); 5558 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_load_ctrl_set(phy, load_once, load_always); 5559 PHYMOD_LOCK_GIVE(phy); 5560 PHYMOD_IF_ERR_RETURN(__rv__); 5561 } else { 5562 return PHYMOD_E_UNAVAIL; 5563 } 5564 5565 return PHYMOD_E_NONE; 5566 5567 } 5568 5569 5570 int phymod_timesync_load_ctrl_get(const phymod_phy_access_t* phy, uint32_t* load_once, uint32_t* load_always) 5571 { 5572 5573 phymod_dispatch_type_t __type__; 5574 int __rv__; 5575 5576 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5577 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5578 } 5579 5580 if(load_once == NULL) { 5581 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("load_once NULL parameter"))); 5582 } 5583 if(load_always == NULL) { 5584 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("load_always NULL parameter"))); 5585 } 5586 /* Dispatch */ 5587 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5588 if(__type__ >= phymodDispatchTypeCount) { 5589 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5590 } 5591 5592 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_load_ctrl_get) { 5593 PHYMOD_LOCK_TAKE(phy); 5594 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_load_ctrl_get(phy, load_once, load_always); 5595 PHYMOD_LOCK_GIVE(phy); 5596 PHYMOD_IF_ERR_RETURN(__rv__); 5597 } else { 5598 return PHYMOD_E_UNAVAIL; 5599 } 5600 5601 return PHYMOD_E_NONE; 5602 5603 } 5604 5605 5606 int phymod_timesync_tx_timestamp_offset_set(const phymod_phy_access_t* phy, uint32_t ts_offset) 5607 { 5608 5609 phymod_dispatch_type_t __type__; 5610 int __rv__; 5611 5612 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5613 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5614 } 5615 5616 /* Dispatch */ 5617 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5618 if(__type__ >= phymodDispatchTypeCount) { 5619 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5620 } 5621 5622 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_tx_timestamp_offset_set) { 5623 PHYMOD_LOCK_TAKE(phy); 5624 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_tx_timestamp_offset_set(phy, ts_offset); 5625 PHYMOD_LOCK_GIVE(phy); 5626 PHYMOD_IF_ERR_RETURN(__rv__); 5627 } else { 5628 return PHYMOD_E_UNAVAIL; 5629 } 5630 5631 return PHYMOD_E_NONE; 5632 5633 } 5634 5635 5636 int phymod_timesync_tx_timestamp_offset_get(const phymod_phy_access_t* phy, uint32_t* ts_offset) 5637 { 5638 5639 phymod_dispatch_type_t __type__; 5640 int __rv__; 5641 5642 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5643 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5644 } 5645 5646 if(ts_offset == NULL) { 5647 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ts_offset NULL parameter"))); 5648 } 5649 /* Dispatch */ 5650 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5651 if(__type__ >= phymodDispatchTypeCount) { 5652 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5653 } 5654 5655 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_tx_timestamp_offset_get) { 5656 PHYMOD_LOCK_TAKE(phy); 5657 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_tx_timestamp_offset_get(phy, ts_offset); 5658 PHYMOD_LOCK_GIVE(phy); 5659 PHYMOD_IF_ERR_RETURN(__rv__); 5660 } else { 5661 return PHYMOD_E_UNAVAIL; 5662 } 5663 5664 return PHYMOD_E_NONE; 5665 5666 } 5667 5668 5669 int phymod_timesync_rx_timestamp_offset_set(const phymod_phy_access_t* phy, uint32_t ts_offset) 5670 { 5671 5672 phymod_dispatch_type_t __type__; 5673 int __rv__; 5674 5675 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5676 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5677 } 5678 5679 /* Dispatch */ 5680 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5681 if(__type__ >= phymodDispatchTypeCount) { 5682 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5683 } 5684 5685 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_rx_timestamp_offset_set) { 5686 PHYMOD_LOCK_TAKE(phy); 5687 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_rx_timestamp_offset_set(phy, ts_offset); 5688 PHYMOD_LOCK_GIVE(phy); 5689 PHYMOD_IF_ERR_RETURN(__rv__); 5690 } else { 5691 return PHYMOD_E_UNAVAIL; 5692 } 5693 5694 return PHYMOD_E_NONE; 5695 5696 } 5697 5698 5699 int phymod_timesync_rx_timestamp_offset_get(const phymod_phy_access_t* phy, uint32_t* ts_offset) 5700 { 5701 5702 phymod_dispatch_type_t __type__; 5703 int __rv__; 5704 5705 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5706 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5707 } 5708 5709 if(ts_offset == NULL) { 5710 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ts_offset NULL parameter"))); 5711 } 5712 /* Dispatch */ 5713 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5714 if(__type__ >= phymodDispatchTypeCount) { 5715 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5716 } 5717 5718 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_rx_timestamp_offset_get) { 5719 PHYMOD_LOCK_TAKE(phy); 5720 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_rx_timestamp_offset_get(phy, ts_offset); 5721 PHYMOD_LOCK_GIVE(phy); 5722 PHYMOD_IF_ERR_RETURN(__rv__); 5723 } else { 5724 return PHYMOD_E_UNAVAIL; 5725 } 5726 5727 return PHYMOD_E_NONE; 5728 5729 } 5730 5731 5732 int phymod_timesync_capture_timestamp_get(const phymod_phy_access_t* phy, uint64_t* cap_ts) 5733 { 5734 5735 phymod_dispatch_type_t __type__; 5736 int __rv__; 5737 5738 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5739 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5740 } 5741 5742 if(cap_ts == NULL) { 5743 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("cap_ts NULL parameter"))); 5744 } 5745 /* Dispatch */ 5746 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5747 if(__type__ >= phymodDispatchTypeCount) { 5748 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5749 } 5750 5751 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_capture_timestamp_get) { 5752 PHYMOD_LOCK_TAKE(phy); 5753 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_capture_timestamp_get(phy, cap_ts); 5754 PHYMOD_LOCK_GIVE(phy); 5755 PHYMOD_IF_ERR_RETURN(__rv__); 5756 } else { 5757 return PHYMOD_E_UNAVAIL; 5758 } 5759 5760 return PHYMOD_E_NONE; 5761 5762 } 5763 5764 5765 int phymod_timesync_heartbeat_timestamp_get(const phymod_phy_access_t* phy, uint64_t* hb_ts) 5766 { 5767 5768 phymod_dispatch_type_t __type__; 5769 int __rv__; 5770 5771 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5772 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5773 } 5774 5775 if(hb_ts == NULL) { 5776 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("hb_ts NULL parameter"))); 5777 } 5778 /* Dispatch */ 5779 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5780 if(__type__ >= phymodDispatchTypeCount) { 5781 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5782 } 5783 5784 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_heartbeat_timestamp_get) { 5785 PHYMOD_LOCK_TAKE(phy); 5786 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_heartbeat_timestamp_get(phy, hb_ts); 5787 PHYMOD_LOCK_GIVE(phy); 5788 PHYMOD_IF_ERR_RETURN(__rv__); 5789 } else { 5790 return PHYMOD_E_UNAVAIL; 5791 } 5792 5793 return PHYMOD_E_NONE; 5794 5795 } 5796 5797 5798 int phymod_timesync_do_sync(const phymod_phy_access_t* phy) 5799 { 5800 5801 phymod_dispatch_type_t __type__; 5802 int __rv__; 5803 5804 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5805 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5806 } 5807 5808 /* Dispatch */ 5809 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5810 if(__type__ >= phymodDispatchTypeCount) { 5811 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5812 } 5813 5814 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_do_sync) { 5815 PHYMOD_LOCK_TAKE(phy); 5816 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_do_sync(phy); 5817 PHYMOD_LOCK_GIVE(phy); 5818 PHYMOD_IF_ERR_RETURN(__rv__); 5819 } else { 5820 return PHYMOD_E_UNAVAIL; 5821 } 5822 5823 return PHYMOD_E_NONE; 5824 5825 } 5826 5827 5828 int phymod_timesync_offset_set(const phymod_core_access_t* core, uint32_t ts_offset) 5829 { 5830 5831 phymod_dispatch_type_t __type__; 5832 int __rv__; 5833 5834 if(PHYMOD_E_OK != phymod_core_access_t_validate(core)) { 5835 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core validation failed"))); 5836 } 5837 5838 /* Dispatch */ 5839 PHYMOD_DRIVER_TYPE_GET(core,&__type__); 5840 if(__type__ >= phymodDispatchTypeCount) { 5841 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5842 } 5843 5844 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_offset_set) { 5845 PHYMOD_LOCK_TAKE(core); 5846 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_offset_set(core, ts_offset); 5847 PHYMOD_LOCK_GIVE(core); 5848 PHYMOD_IF_ERR_RETURN(__rv__); 5849 } else { 5850 return PHYMOD_E_UNAVAIL; 5851 } 5852 5853 return PHYMOD_E_NONE; 5854 5855 } 5856 5857 5858 int phymod_timesync_adjust_set(const phymod_phy_access_t* phy, phymod_timesync_compensation_mode_t ts_am_norm_mode) 5859 { 5860 5861 phymod_dispatch_type_t __type__; 5862 int __rv__; 5863 5864 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5865 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5866 } 5867 5868 if(PHYMOD_E_OK != phymod_timesync_compensation_mode_t_validate(ts_am_norm_mode)) { 5869 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ts_am_norm_mode validation failed"))); 5870 } 5871 5872 /* Dispatch */ 5873 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5874 if(__type__ >= phymodDispatchTypeCount) { 5875 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5876 } 5877 5878 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_adjust_set) { 5879 PHYMOD_LOCK_TAKE(phy); 5880 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_adjust_set(phy, ts_am_norm_mode); 5881 PHYMOD_LOCK_GIVE(phy); 5882 PHYMOD_IF_ERR_RETURN(__rv__); 5883 } else { 5884 return PHYMOD_E_UNAVAIL; 5885 } 5886 5887 return PHYMOD_E_NONE; 5888 5889 } 5890 5891 5892 int phymod_edc_config_method_t_validate(phymod_edc_config_method_t phymod_edc_config_method) 5893 { 5894 if(phymod_edc_config_method >= phymodEdcConfigMethodCount) { 5895 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 5896 } 5897 5898 return PHYMOD_E_NONE; 5899 5900 } 5901 5902 int phymod_edc_config_t_validate(const phymod_edc_config_t* phymod_edc_config) 5903 { 5904 if(phymod_edc_config == NULL) { 5905 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 5906 } 5907 5908 if(PHYMOD_E_OK != phymod_edc_config_method_t_validate(phymod_edc_config->method)) { 5909 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("method validation failed"))); 5910 } 5911 5912 5913 5914 return PHYMOD_E_NONE; 5915 5916 } 5917 5918 int phymod_edc_config_t_init(phymod_edc_config_t* phymod_edc_config) 5919 { 5920 5921 if(phymod_edc_config == NULL){ 5922 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_edc_config NULL parameter"))); 5923 } 5924 PHYMOD_MEMSET(phymod_edc_config, 0, sizeof(phymod_edc_config_t)); 5925 5926 5927 return PHYMOD_E_NONE; 5928 5929 } 5930 5931 int phymod_edc_config_set(const phymod_phy_access_t* phy, const phymod_edc_config_t* edc_config) 5932 { 5933 5934 phymod_dispatch_type_t __type__; 5935 int __rv__; 5936 5937 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5938 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5939 } 5940 5941 if(PHYMOD_E_OK != phymod_edc_config_t_validate(edc_config)) { 5942 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("edc_config validation failed"))); 5943 } 5944 5945 /* Dispatch */ 5946 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5947 if(__type__ >= phymodDispatchTypeCount) { 5948 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5949 } 5950 5951 if(NULL != __phymod__dispatch__[__type__]->f_phymod_edc_config_set) { 5952 PHYMOD_LOCK_TAKE(phy); 5953 __rv__ = __phymod__dispatch__[__type__]->f_phymod_edc_config_set(phy, edc_config); 5954 PHYMOD_LOCK_GIVE(phy); 5955 PHYMOD_IF_ERR_RETURN(__rv__); 5956 } else { 5957 return PHYMOD_E_UNAVAIL; 5958 } 5959 5960 return PHYMOD_E_NONE; 5961 5962 } 5963 5964 5965 int phymod_edc_config_get(const phymod_phy_access_t* phy, phymod_edc_config_t* edc_config) 5966 { 5967 5968 phymod_dispatch_type_t __type__; 5969 int __rv__; 5970 5971 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 5972 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 5973 } 5974 5975 if(edc_config == NULL) { 5976 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("edc_config NULL parameter"))); 5977 } 5978 if(PHYMOD_E_OK != phymod_edc_config_t_init(edc_config)) { 5979 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("edc_config initialization failed"))); 5980 } 5981 5982 /* Dispatch */ 5983 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 5984 if(__type__ >= phymodDispatchTypeCount) { 5985 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 5986 } 5987 5988 if(NULL != __phymod__dispatch__[__type__]->f_phymod_edc_config_get) { 5989 PHYMOD_LOCK_TAKE(phy); 5990 __rv__ = __phymod__dispatch__[__type__]->f_phymod_edc_config_get(phy, edc_config); 5991 PHYMOD_LOCK_GIVE(phy); 5992 PHYMOD_IF_ERR_RETURN(__rv__); 5993 } else { 5994 return PHYMOD_E_UNAVAIL; 5995 } 5996 5997 return PHYMOD_E_NONE; 5998 5999 } 6000 6001 6002 int phymod_core_mode_t_validate(phymod_core_mode_t phymod_core_mode) 6003 { 6004 if(phymod_core_mode >= phymodCoreModeCount) { 6005 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 6006 } 6007 6008 return PHYMOD_E_NONE; 6009 6010 } 6011 6012 int phymod_phy_core_mode_set(const phymod_phy_access_t* phy, phymod_core_mode_t core_mode) 6013 { 6014 6015 phymod_dispatch_type_t __type__; 6016 int __rv__; 6017 6018 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6019 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6020 } 6021 6022 if(PHYMOD_E_OK != phymod_core_mode_t_validate(core_mode)) { 6023 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core_mode validation failed"))); 6024 } 6025 6026 /* Dispatch */ 6027 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6028 if(__type__ >= phymodDispatchTypeCount) { 6029 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6030 } 6031 6032 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_core_mode_set) { 6033 PHYMOD_LOCK_TAKE(phy); 6034 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_core_mode_set(phy, core_mode); 6035 PHYMOD_LOCK_GIVE(phy); 6036 PHYMOD_IF_ERR_RETURN(__rv__); 6037 } else { 6038 return PHYMOD_E_UNAVAIL; 6039 } 6040 6041 return PHYMOD_E_NONE; 6042 6043 } 6044 6045 6046 int phymod_phy_core_mode_get(const phymod_phy_access_t* phy, phymod_core_mode_t* core_mode) 6047 { 6048 6049 phymod_dispatch_type_t __type__; 6050 int __rv__; 6051 6052 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6053 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6054 } 6055 6056 if(core_mode == NULL) { 6057 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("core_mode NULL parameter"))); 6058 } 6059 /* Dispatch */ 6060 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6061 if(__type__ >= phymodDispatchTypeCount) { 6062 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6063 } 6064 6065 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_core_mode_get) { 6066 PHYMOD_LOCK_TAKE(phy); 6067 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_core_mode_get(phy, core_mode); 6068 PHYMOD_LOCK_GIVE(phy); 6069 PHYMOD_IF_ERR_RETURN(__rv__); 6070 } else { 6071 return PHYMOD_E_UNAVAIL; 6072 } 6073 6074 return PHYMOD_E_NONE; 6075 6076 } 6077 6078 6079 int phymod_failover_mode_t_validate(phymod_failover_mode_t phymod_failover_mode) 6080 { 6081 if(phymod_failover_mode >= phymodFailovermodeCount) { 6082 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 6083 } 6084 6085 return PHYMOD_E_NONE; 6086 6087 } 6088 6089 int phymod_failover_mode_set(const phymod_phy_access_t* phy, phymod_failover_mode_t failover_mode) 6090 { 6091 6092 phymod_dispatch_type_t __type__; 6093 int __rv__; 6094 6095 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6096 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6097 } 6098 6099 if(PHYMOD_E_OK != phymod_failover_mode_t_validate(failover_mode)) { 6100 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("failover_mode validation failed"))); 6101 } 6102 6103 /* Dispatch */ 6104 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6105 if(__type__ >= phymodDispatchTypeCount) { 6106 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6107 } 6108 6109 if(NULL != __phymod__dispatch__[__type__]->f_phymod_failover_mode_set) { 6110 PHYMOD_LOCK_TAKE(phy); 6111 __rv__ = __phymod__dispatch__[__type__]->f_phymod_failover_mode_set(phy, failover_mode); 6112 PHYMOD_LOCK_GIVE(phy); 6113 PHYMOD_IF_ERR_RETURN(__rv__); 6114 } else { 6115 return PHYMOD_E_UNAVAIL; 6116 } 6117 6118 return PHYMOD_E_NONE; 6119 6120 } 6121 6122 6123 int phymod_failover_mode_get(const phymod_phy_access_t* phy, phymod_failover_mode_t* failover_mode) 6124 { 6125 6126 phymod_dispatch_type_t __type__; 6127 int __rv__; 6128 6129 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6130 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6131 } 6132 6133 if(failover_mode == NULL) { 6134 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("failover_mode NULL parameter"))); 6135 } 6136 /* Dispatch */ 6137 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6138 if(__type__ >= phymodDispatchTypeCount) { 6139 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6140 } 6141 6142 if(NULL != __phymod__dispatch__[__type__]->f_phymod_failover_mode_get) { 6143 PHYMOD_LOCK_TAKE(phy); 6144 __rv__ = __phymod__dispatch__[__type__]->f_phymod_failover_mode_get(phy, failover_mode); 6145 PHYMOD_LOCK_GIVE(phy); 6146 PHYMOD_IF_ERR_RETURN(__rv__); 6147 } else { 6148 return PHYMOD_E_UNAVAIL; 6149 } 6150 6151 return PHYMOD_E_NONE; 6152 6153 } 6154 6155 6156 int phymod_port_init(const phymod_phy_access_t* phy, const phymod_port_config_t* port_config) 6157 { 6158 6159 phymod_dispatch_type_t __type__; 6160 int __rv__; 6161 6162 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6163 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6164 } 6165 6166 if(PHYMOD_E_OK != phymod_port_config_t_validate(port_config)) { 6167 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("port_config validation failed"))); 6168 } 6169 6170 /* Dispatch */ 6171 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6172 if(__type__ >= phymodDispatchTypeCount) { 6173 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6174 } 6175 6176 if(NULL != __phymod__dispatch__[__type__]->f_phymod_port_init) { 6177 PHYMOD_LOCK_TAKE(phy); 6178 __rv__ = __phymod__dispatch__[__type__]->f_phymod_port_init(phy, port_config); 6179 PHYMOD_LOCK_GIVE(phy); 6180 PHYMOD_IF_ERR_RETURN(__rv__); 6181 } else { 6182 return PHYMOD_E_UNAVAIL; 6183 } 6184 6185 return PHYMOD_E_NONE; 6186 6187 } 6188 6189 6190 int phymod_an_try_enable_control_t_validate(const phymod_an_try_enable_control_t* phymod_an_try_enable_control) 6191 { 6192 if(phymod_an_try_enable_control == NULL) { 6193 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6194 } 6195 6196 if(PHYMOD_E_OK != phymod_an_mode_type_t_validate(phymod_an_try_enable_control->an_mode)) { 6197 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_mode validation failed"))); 6198 } 6199 6200 switch(phymod_an_try_enable_control->enable) { 6201 case 0: 6202 case 1: 6203 break; 6204 default: 6205 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable not allowed value"))); 6206 break; 6207 } 6208 6209 6210 6211 return PHYMOD_E_NONE; 6212 6213 } 6214 6215 int phymod_an_try_enable_control_t_init(phymod_an_try_enable_control_t* phymod_an_try_enable_control) 6216 { 6217 6218 if(phymod_an_try_enable_control == NULL){ 6219 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_an_try_enable_control NULL parameter"))); 6220 } 6221 PHYMOD_MEMSET(phymod_an_try_enable_control, 0, sizeof(phymod_an_try_enable_control_t)); 6222 phymod_an_try_enable_control->an_mode = 0; 6223 phymod_an_try_enable_control->num_lane_adv = 0; 6224 phymod_an_try_enable_control->flags = 0; 6225 phymod_an_try_enable_control->enable = 0; 6226 phymod_an_try_enable_control->speed = 0; 6227 6228 6229 return PHYMOD_E_NONE; 6230 6231 } 6232 6233 int phymod_phy_an_status_t_validate(const phymod_phy_an_status_t* phymod_phy_an_status) 6234 { 6235 if(phymod_phy_an_status == NULL) { 6236 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6237 } 6238 6239 6240 6241 return PHYMOD_E_NONE; 6242 6243 } 6244 6245 int phymod_phy_an_status_t_init(phymod_phy_an_status_t* phymod_phy_an_status) 6246 { 6247 6248 if(phymod_phy_an_status == NULL){ 6249 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_an_status NULL parameter"))); 6250 } 6251 PHYMOD_MEMSET(phymod_phy_an_status, 0, sizeof(phymod_phy_an_status_t)); 6252 6253 6254 return PHYMOD_E_NONE; 6255 6256 } 6257 6258 int phymod_phy_autoneg_try_enable(const phymod_phy_access_t* phy, const phymod_an_try_enable_control_t* an, phymod_phy_an_status_t* an_status) 6259 { 6260 6261 phymod_dispatch_type_t __type__; 6262 int __rv__; 6263 6264 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6265 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6266 } 6267 6268 if(PHYMOD_E_OK != phymod_an_try_enable_control_t_validate(an)) { 6269 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an validation failed"))); 6270 } 6271 6272 if(an_status == NULL) { 6273 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_status NULL parameter"))); 6274 } 6275 if(PHYMOD_E_OK != phymod_phy_an_status_t_init(an_status)) { 6276 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_status initialization failed"))); 6277 } 6278 6279 /* Dispatch */ 6280 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6281 if(__type__ >= phymodDispatchTypeCount) { 6282 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6283 } 6284 6285 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_try_enable) { 6286 PHYMOD_LOCK_TAKE(phy); 6287 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_try_enable(phy, an, an_status); 6288 PHYMOD_LOCK_GIVE(phy); 6289 PHYMOD_IF_ERR_RETURN(__rv__); 6290 } else { 6291 return PHYMOD_E_UNAVAIL; 6292 } 6293 6294 return PHYMOD_E_NONE; 6295 6296 } 6297 6298 6299 int phymod_debug_ether(const phymod_phy_access_t* phy) 6300 { 6301 6302 phymod_dispatch_type_t __type__; 6303 int __rv__; 6304 6305 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6306 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6307 } 6308 6309 /* Dispatch */ 6310 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6311 if(__type__ >= phymodDispatchTypeCount) { 6312 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6313 } 6314 6315 if(NULL != __phymod__dispatch__[__type__]->f_phymod_debug_ether) { 6316 PHYMOD_LOCK_TAKE(phy); 6317 __rv__ = __phymod__dispatch__[__type__]->f_phymod_debug_ether(phy); 6318 PHYMOD_LOCK_GIVE(phy); 6319 PHYMOD_IF_ERR_RETURN(__rv__); 6320 } else { 6321 return PHYMOD_E_UNAVAIL; 6322 } 6323 6324 return PHYMOD_E_NONE; 6325 6326 } 6327 6328 6329 int phymod_reset_interface(const phymod_phy_access_t* phy) 6330 { 6331 6332 phymod_dispatch_type_t __type__; 6333 int __rv__; 6334 6335 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6336 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6337 } 6338 6339 /* Dispatch */ 6340 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6341 if(__type__ >= phymodDispatchTypeCount) { 6342 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6343 } 6344 6345 if(NULL != __phymod__dispatch__[__type__]->f_phymod_reset_interface) { 6346 PHYMOD_LOCK_TAKE(phy); 6347 __rv__ = __phymod__dispatch__[__type__]->f_phymod_reset_interface(phy); 6348 PHYMOD_LOCK_GIVE(phy); 6349 PHYMOD_IF_ERR_RETURN(__rv__); 6350 } else { 6351 return PHYMOD_E_UNAVAIL; 6352 } 6353 6354 return PHYMOD_E_NONE; 6355 6356 } 6357 6358 6359 int phymod_phy_short_chn_mode_enable_set(const phymod_phy_access_t* phy, uint32_t enable) 6360 { 6361 6362 phymod_dispatch_type_t __type__; 6363 int __rv__; 6364 6365 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6366 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6367 } 6368 6369 /* Dispatch */ 6370 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6371 if(__type__ >= phymodDispatchTypeCount) { 6372 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6373 } 6374 6375 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_short_chn_mode_enable_set) { 6376 PHYMOD_LOCK_TAKE(phy); 6377 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_short_chn_mode_enable_set(phy, enable); 6378 PHYMOD_LOCK_GIVE(phy); 6379 PHYMOD_IF_ERR_RETURN(__rv__); 6380 } else { 6381 return PHYMOD_E_UNAVAIL; 6382 } 6383 6384 return PHYMOD_E_NONE; 6385 6386 } 6387 6388 6389 int phymod_phy_short_chn_mode_enable_get(const phymod_phy_access_t* phy, uint32_t* enable, uint32_t* status) 6390 { 6391 6392 phymod_dispatch_type_t __type__; 6393 int __rv__; 6394 6395 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6396 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6397 } 6398 6399 if(enable == NULL) { 6400 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 6401 } 6402 if(status == NULL) { 6403 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("status NULL parameter"))); 6404 } 6405 /* Dispatch */ 6406 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6407 if(__type__ >= phymodDispatchTypeCount) { 6408 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6409 } 6410 6411 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_short_chn_mode_enable_get) { 6412 PHYMOD_LOCK_TAKE(phy); 6413 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_short_chn_mode_enable_get(phy, enable, status); 6414 PHYMOD_LOCK_GIVE(phy); 6415 PHYMOD_IF_ERR_RETURN(__rv__); 6416 } else { 6417 return PHYMOD_E_UNAVAIL; 6418 } 6419 6420 return PHYMOD_E_NONE; 6421 6422 } 6423 6424 6425 int phymod_port_enable_set(const phymod_phy_access_t* phy, uint32_t enable) 6426 { 6427 6428 phymod_dispatch_type_t __type__; 6429 int __rv__; 6430 6431 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6432 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6433 } 6434 6435 /* Dispatch */ 6436 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6437 if(__type__ >= phymodDispatchTypeCount) { 6438 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6439 } 6440 6441 if(NULL != __phymod__dispatch__[__type__]->f_phymod_port_enable_set) { 6442 PHYMOD_LOCK_TAKE(phy); 6443 __rv__ = __phymod__dispatch__[__type__]->f_phymod_port_enable_set(phy, enable); 6444 PHYMOD_LOCK_GIVE(phy); 6445 PHYMOD_IF_ERR_RETURN(__rv__); 6446 } else { 6447 return PHYMOD_E_UNAVAIL; 6448 } 6449 6450 return PHYMOD_E_NONE; 6451 6452 } 6453 6454 6455 int phymod_port_enable_get(const phymod_phy_access_t* phy, uint32_t* enable) 6456 { 6457 6458 phymod_dispatch_type_t __type__; 6459 int __rv__; 6460 6461 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6462 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6463 } 6464 6465 if(enable == NULL) { 6466 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 6467 } 6468 /* Dispatch */ 6469 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6470 if(__type__ >= phymodDispatchTypeCount) { 6471 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6472 } 6473 6474 if(NULL != __phymod__dispatch__[__type__]->f_phymod_port_enable_get) { 6475 PHYMOD_LOCK_TAKE(phy); 6476 __rv__ = __phymod__dispatch__[__type__]->f_phymod_port_enable_get(phy, enable); 6477 PHYMOD_LOCK_GIVE(phy); 6478 PHYMOD_IF_ERR_RETURN(__rv__); 6479 } else { 6480 return PHYMOD_E_UNAVAIL; 6481 } 6482 6483 return PHYMOD_E_NONE; 6484 6485 } 6486 6487 6488 int phymod_eye_margin_mode_t_validate(phymod_eye_margin_mode_t phymod_eye_margin_mode) 6489 { 6490 if(phymod_eye_margin_mode >= phymod_eye_marign_Count) { 6491 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 6492 } 6493 6494 return PHYMOD_E_NONE; 6495 6496 } 6497 6498 int phymod_phy_eye_margin_est_get(const phymod_phy_access_t* phy, phymod_eye_margin_mode_t eye_margin_mode, uint32_t* value) 6499 { 6500 6501 phymod_dispatch_type_t __type__; 6502 int __rv__; 6503 6504 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6505 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6506 } 6507 6508 if(PHYMOD_E_OK != phymod_eye_margin_mode_t_validate(eye_margin_mode)) { 6509 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("eye_margin_mode validation failed"))); 6510 } 6511 6512 if(value == NULL) { 6513 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("value NULL parameter"))); 6514 } 6515 /* Dispatch */ 6516 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6517 if(__type__ >= phymodDispatchTypeCount) { 6518 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6519 } 6520 6521 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_eye_margin_est_get) { 6522 PHYMOD_LOCK_TAKE(phy); 6523 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_eye_margin_est_get(phy, eye_margin_mode, value); 6524 PHYMOD_LOCK_GIVE(phy); 6525 PHYMOD_IF_ERR_RETURN(__rv__); 6526 } else { 6527 return PHYMOD_E_UNAVAIL; 6528 } 6529 6530 return PHYMOD_E_NONE; 6531 6532 } 6533 6534 6535 int phymod_multi_data_t_validate(const phymod_multi_data_t* phymod_multi_data) 6536 { 6537 if(phymod_multi_data == NULL) { 6538 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6539 } 6540 6541 6542 6543 return PHYMOD_E_NONE; 6544 6545 } 6546 6547 int phymod_multi_data_t_init(phymod_multi_data_t* phymod_multi_data) 6548 { 6549 6550 if(phymod_multi_data == NULL){ 6551 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_multi_data NULL parameter"))); 6552 } 6553 PHYMOD_MEMSET(phymod_multi_data, 0, sizeof(phymod_multi_data_t)); 6554 6555 6556 return PHYMOD_E_NONE; 6557 6558 } 6559 6560 int phymod_phy_multi_get(const phymod_phy_access_t* phy, phymod_multi_data_t* multi_data) 6561 { 6562 6563 phymod_dispatch_type_t __type__; 6564 int __rv__; 6565 6566 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6567 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6568 } 6569 6570 if(multi_data == NULL) { 6571 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("multi_data NULL parameter"))); 6572 } 6573 if(PHYMOD_E_OK != phymod_multi_data_t_validate(multi_data)) { 6574 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("multi_data validation failed"))); 6575 } 6576 6577 /* Dispatch */ 6578 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6579 if(__type__ >= phymodDispatchTypeCount) { 6580 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6581 } 6582 6583 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_multi_get) { 6584 PHYMOD_LOCK_TAKE(phy); 6585 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_multi_get(phy, multi_data); 6586 PHYMOD_LOCK_GIVE(phy); 6587 PHYMOD_IF_ERR_RETURN(__rv__); 6588 } else { 6589 return PHYMOD_E_UNAVAIL; 6590 } 6591 6592 return PHYMOD_E_NONE; 6593 6594 } 6595 6596 6597 int phymod_tsce_pll_multiplier_t_validate(phymod_tsce_pll_multiplier_t phymod_tsce_pll_multiplier) 6598 { 6599 if(phymod_tsce_pll_multiplier >= phymod_TSCE_PLL_Count) { 6600 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 6601 } 6602 6603 return PHYMOD_E_NONE; 6604 6605 } 6606 6607 int phymod_tscf_pll_multiplier_t_validate(phymod_tscf_pll_multiplier_t phymod_tscf_pll_multiplier) 6608 { 6609 if(phymod_tscf_pll_multiplier >= phymod_TSCF_PLL_Count) { 6610 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 6611 } 6612 6613 return PHYMOD_E_NONE; 6614 6615 } 6616 6617 int phymod_tscbh_pll_multiplier_t_validate(phymod_tscbh_pll_multiplier_t phymod_tscbh_pll_multiplier) 6618 { 6619 if(phymod_tscbh_pll_multiplier >= phymod_TSCBH_PLL_Count) { 6620 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 6621 } 6622 6623 return PHYMOD_E_NONE; 6624 6625 } 6626 6627 int phymod_phy_rescal_set(const phymod_phy_access_t* phy, uint32_t enable, uint32_t value) 6628 { 6629 6630 phymod_dispatch_type_t __type__; 6631 int __rv__; 6632 6633 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6634 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6635 } 6636 6637 /* Dispatch */ 6638 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6639 if(__type__ >= phymodDispatchTypeCount) { 6640 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6641 } 6642 6643 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rescal_set) { 6644 PHYMOD_LOCK_TAKE(phy); 6645 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rescal_set(phy, enable, value); 6646 PHYMOD_LOCK_GIVE(phy); 6647 PHYMOD_IF_ERR_RETURN(__rv__); 6648 } else { 6649 return PHYMOD_E_UNAVAIL; 6650 } 6651 6652 return PHYMOD_E_NONE; 6653 6654 } 6655 6656 6657 int phymod_phy_rescal_get(const phymod_phy_access_t* phy, uint32_t* value) 6658 { 6659 6660 phymod_dispatch_type_t __type__; 6661 int __rv__; 6662 6663 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6664 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6665 } 6666 6667 if(value == NULL) { 6668 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("value NULL parameter"))); 6669 } 6670 /* Dispatch */ 6671 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6672 if(__type__ >= phymodDispatchTypeCount) { 6673 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6674 } 6675 6676 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rescal_get) { 6677 PHYMOD_LOCK_TAKE(phy); 6678 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rescal_get(phy, value); 6679 PHYMOD_LOCK_GIVE(phy); 6680 PHYMOD_IF_ERR_RETURN(__rv__); 6681 } else { 6682 return PHYMOD_E_UNAVAIL; 6683 } 6684 6685 return PHYMOD_E_NONE; 6686 6687 } 6688 6689 6690 int phymod_an_page_t_validate(const phymod_an_page_t* phymod_an_page) 6691 { 6692 if(phymod_an_page == NULL) { 6693 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6694 } 6695 6696 6697 6698 return PHYMOD_E_NONE; 6699 6700 } 6701 6702 int phymod_an_page_t_init(phymod_an_page_t* phymod_an_page) 6703 { 6704 6705 if(phymod_an_page == NULL){ 6706 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_an_page NULL parameter"))); 6707 } 6708 PHYMOD_MEMSET(phymod_an_page, 0, sizeof(phymod_an_page_t)); 6709 phymod_an_page->page_0 = 0; 6710 phymod_an_page->page_1 = 0; 6711 phymod_an_page->page_2 = 0; 6712 6713 6714 return PHYMOD_E_NONE; 6715 6716 } 6717 6718 int phymod_sw_an_ctrl_status_t_validate(const phymod_sw_an_ctrl_status_t* phymod_sw_an_ctrl_status) 6719 { 6720 if(phymod_sw_an_ctrl_status == NULL) { 6721 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6722 } 6723 6724 6725 6726 return PHYMOD_E_NONE; 6727 6728 } 6729 6730 int phymod_sw_an_ctrl_status_t_init(phymod_sw_an_ctrl_status_t* phymod_sw_an_ctrl_status) 6731 { 6732 6733 if(phymod_sw_an_ctrl_status == NULL){ 6734 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_sw_an_ctrl_status NULL parameter"))); 6735 } 6736 PHYMOD_MEMSET(phymod_sw_an_ctrl_status, 0, sizeof(phymod_sw_an_ctrl_status_t)); 6737 phymod_sw_an_ctrl_status->seq_restart = 0; 6738 phymod_sw_an_ctrl_status->lp_page_rdy = 0; 6739 phymod_sw_an_ctrl_status->page_req = 0; 6740 phymod_sw_an_ctrl_status->an_completed = 0; 6741 6742 6743 return PHYMOD_E_NONE; 6744 6745 } 6746 6747 int phymod_an_pages_t_validate(const phymod_an_pages_t* phymod_an_pages) 6748 { 6749 if(phymod_an_pages == NULL) { 6750 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6751 } 6752 6753 if(PHYMOD_E_OK != phymod_an_page_t_validate(&phymod_an_pages->base_page)) { 6754 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("base_page validation failed"))); 6755 } 6756 6757 if(PHYMOD_E_OK != phymod_an_page_t_validate(&phymod_an_pages->msg_page)) { 6758 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("msg_page validation failed"))); 6759 } 6760 6761 if(PHYMOD_E_OK != phymod_an_page_t_validate(&phymod_an_pages->ufmt_page)) { 6762 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ufmt_page validation failed"))); 6763 } 6764 6765 if(PHYMOD_E_OK != phymod_an_page_t_validate(&phymod_an_pages->null_page)) { 6766 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("null_page validation failed"))); 6767 } 6768 6769 6770 6771 return PHYMOD_E_NONE; 6772 6773 } 6774 6775 int phymod_an_pages_t_init(phymod_an_pages_t* phymod_an_pages) 6776 { 6777 6778 if(phymod_an_pages == NULL){ 6779 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_an_pages NULL parameter"))); 6780 } 6781 PHYMOD_MEMSET(phymod_an_pages, 0, sizeof(phymod_an_pages_t)); 6782 if(PHYMOD_E_OK != phymod_an_page_t_init(&phymod_an_pages->base_page)) { 6783 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("base_page initialization failed"))); 6784 } 6785 6786 if(PHYMOD_E_OK != phymod_an_page_t_init(&phymod_an_pages->msg_page)) { 6787 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("msg_page initialization failed"))); 6788 } 6789 6790 if(PHYMOD_E_OK != phymod_an_page_t_init(&phymod_an_pages->ufmt_page)) { 6791 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ufmt_page initialization failed"))); 6792 } 6793 6794 if(PHYMOD_E_OK != phymod_an_page_t_init(&phymod_an_pages->null_page)) { 6795 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("null_page initialization failed"))); 6796 } 6797 6798 6799 6800 return PHYMOD_E_NONE; 6801 6802 } 6803 6804 int phymod_sw_an_ctxt_t_validate(const phymod_sw_an_ctxt_t* phymod_sw_an_ctxt) 6805 { 6806 if(phymod_sw_an_ctxt == NULL) { 6807 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 6808 } 6809 6810 if(PHYMOD_E_OK != phymod_an_pages_t_validate(&phymod_sw_an_ctxt->tx_pages)) { 6811 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_pages validation failed"))); 6812 } 6813 6814 if(PHYMOD_E_OK != phymod_an_pages_t_validate(&phymod_sw_an_ctxt->rx_pages)) { 6815 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_pages validation failed"))); 6816 } 6817 6818 if(PHYMOD_E_OK != phymod_an_mode_type_t_validate(phymod_sw_an_ctxt->an_mode)) { 6819 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_mode validation failed"))); 6820 } 6821 6822 6823 6824 return PHYMOD_E_NONE; 6825 6826 } 6827 6828 int phymod_sw_an_ctxt_t_init(phymod_sw_an_ctxt_t* phymod_sw_an_ctxt) 6829 { 6830 6831 if(phymod_sw_an_ctxt == NULL){ 6832 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_sw_an_ctxt NULL parameter"))); 6833 } 6834 PHYMOD_MEMSET(phymod_sw_an_ctxt, 0, sizeof(phymod_sw_an_ctxt_t)); 6835 if(PHYMOD_E_OK != phymod_an_pages_t_init(&phymod_sw_an_ctxt->tx_pages)) { 6836 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx_pages initialization failed"))); 6837 } 6838 6839 if(PHYMOD_E_OK != phymod_an_pages_t_init(&phymod_sw_an_ctxt->rx_pages)) { 6840 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_pages initialization failed"))); 6841 } 6842 6843 6844 6845 return PHYMOD_E_NONE; 6846 6847 } 6848 6849 int phymod_phy_sw_an_control_status_get(const phymod_phy_access_t* phy, phymod_sw_an_ctrl_status_t* an_ctrl_status) 6850 { 6851 6852 phymod_dispatch_type_t __type__; 6853 int __rv__; 6854 6855 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6856 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6857 } 6858 6859 if(an_ctrl_status == NULL) { 6860 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctrl_status NULL parameter"))); 6861 } 6862 if(PHYMOD_E_OK != phymod_sw_an_ctrl_status_t_init(an_ctrl_status)) { 6863 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctrl_status initialization failed"))); 6864 } 6865 6866 /* Dispatch */ 6867 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6868 if(__type__ >= phymodDispatchTypeCount) { 6869 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6870 } 6871 6872 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_control_status_get) { 6873 PHYMOD_LOCK_TAKE(phy); 6874 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_control_status_get(phy, an_ctrl_status); 6875 PHYMOD_LOCK_GIVE(phy); 6876 PHYMOD_IF_ERR_RETURN(__rv__); 6877 } else { 6878 return PHYMOD_E_UNAVAIL; 6879 } 6880 6881 return PHYMOD_E_NONE; 6882 6883 } 6884 6885 6886 int phymod_phy_sw_an_base_page_exchange_handler(const phymod_phy_access_t* phy, phymod_sw_an_ctxt_t* an_ctxt) 6887 { 6888 6889 phymod_dispatch_type_t __type__; 6890 int __rv__; 6891 6892 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6893 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6894 } 6895 6896 if(an_ctxt == NULL) { 6897 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctxt NULL parameter"))); 6898 } 6899 if(PHYMOD_E_OK != phymod_sw_an_ctxt_t_validate(an_ctxt)) { 6900 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctxt validation failed"))); 6901 } 6902 6903 /* Dispatch */ 6904 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6905 if(__type__ >= phymodDispatchTypeCount) { 6906 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6907 } 6908 6909 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_base_page_exchange_handler) { 6910 PHYMOD_LOCK_TAKE(phy); 6911 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_base_page_exchange_handler(phy, an_ctxt); 6912 PHYMOD_LOCK_GIVE(phy); 6913 PHYMOD_IF_ERR_RETURN(__rv__); 6914 } else { 6915 return PHYMOD_E_UNAVAIL; 6916 } 6917 6918 return PHYMOD_E_NONE; 6919 6920 } 6921 6922 6923 int phymod_phy_sw_an_lp_page_rdy_handler(const phymod_phy_access_t* phy, phymod_sw_an_ctxt_t* an_ctxt) 6924 { 6925 6926 phymod_dispatch_type_t __type__; 6927 int __rv__; 6928 6929 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6930 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6931 } 6932 6933 if(an_ctxt == NULL) { 6934 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctxt NULL parameter"))); 6935 } 6936 if(PHYMOD_E_OK != phymod_sw_an_ctxt_t_validate(an_ctxt)) { 6937 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctxt validation failed"))); 6938 } 6939 6940 /* Dispatch */ 6941 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6942 if(__type__ >= phymodDispatchTypeCount) { 6943 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6944 } 6945 6946 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_lp_page_rdy_handler) { 6947 PHYMOD_LOCK_TAKE(phy); 6948 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_lp_page_rdy_handler(phy, an_ctxt); 6949 PHYMOD_LOCK_GIVE(phy); 6950 PHYMOD_IF_ERR_RETURN(__rv__); 6951 } else { 6952 return PHYMOD_E_UNAVAIL; 6953 } 6954 6955 return PHYMOD_E_NONE; 6956 6957 } 6958 6959 6960 int phymod_phy_sw_an_advert_set(const phymod_phy_access_t* phy, const phymod_autoneg_ability_t* an_ability_set_type, phymod_sw_an_ctxt_t* an_ctxt) 6961 { 6962 6963 phymod_dispatch_type_t __type__; 6964 int __rv__; 6965 6966 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 6967 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 6968 } 6969 6970 if(PHYMOD_E_OK != phymod_autoneg_ability_t_validate(an_ability_set_type)) { 6971 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ability_set_type validation failed"))); 6972 } 6973 6974 if(an_ctxt == NULL) { 6975 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctxt NULL parameter"))); 6976 } 6977 if(PHYMOD_E_OK != phymod_sw_an_ctxt_t_validate(an_ctxt)) { 6978 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_ctxt validation failed"))); 6979 } 6980 6981 /* Dispatch */ 6982 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 6983 if(__type__ >= phymodDispatchTypeCount) { 6984 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 6985 } 6986 6987 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_advert_set) { 6988 PHYMOD_LOCK_TAKE(phy); 6989 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_sw_an_advert_set(phy, an_ability_set_type, an_ctxt); 6990 PHYMOD_LOCK_GIVE(phy); 6991 PHYMOD_IF_ERR_RETURN(__rv__); 6992 } else { 6993 return PHYMOD_E_UNAVAIL; 6994 } 6995 6996 return PHYMOD_E_NONE; 6997 6998 } 6999 7000 7001 int phymod_phy_sw_autoneg_enable(const phymod_phy_access_t* phy, int enable) 7002 { 7003 7004 phymod_dispatch_type_t __type__; 7005 int __rv__; 7006 7007 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7008 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7009 } 7010 7011 /* Dispatch */ 7012 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7013 if(__type__ >= phymodDispatchTypeCount) { 7014 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7015 } 7016 7017 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_sw_autoneg_enable) { 7018 PHYMOD_LOCK_TAKE(phy); 7019 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_sw_autoneg_enable(phy, enable); 7020 PHYMOD_LOCK_GIVE(phy); 7021 PHYMOD_IF_ERR_RETURN(__rv__); 7022 } else { 7023 return PHYMOD_E_UNAVAIL; 7024 } 7025 7026 return PHYMOD_E_NONE; 7027 7028 } 7029 7030 7031 int phymod_fec_type_t_validate(phymod_fec_type_t phymod_fec_type) 7032 { 7033 if(phymod_fec_type >= phymod_fec_Count) { 7034 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 7035 } 7036 7037 return PHYMOD_E_NONE; 7038 7039 } 7040 7041 int phymod_dfe_mode_t_validate(phymod_dfe_mode_t phymod_dfe_mode) 7042 { 7043 if(phymod_dfe_mode >= phymod_dfe_Count) { 7044 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 7045 } 7046 7047 return PHYMOD_E_NONE; 7048 7049 } 7050 7051 int phymod_phy_speed_config_t_validate(const phymod_phy_speed_config_t* phymod_phy_speed_config) 7052 { 7053 if(phymod_phy_speed_config == NULL) { 7054 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7055 } 7056 7057 if(PHYMOD_E_OK != phymod_fec_type_t_validate(phymod_phy_speed_config->fec_type)) { 7058 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fec_type validation failed"))); 7059 } 7060 7061 if(PHYMOD_E_OK != phymod_firmware_lane_config_t_validate(&phymod_phy_speed_config->pmd_lane_config)) { 7062 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("pmd_lane_config validation failed"))); 7063 } 7064 7065 7066 7067 return PHYMOD_E_NONE; 7068 7069 } 7070 7071 int phymod_phy_speed_config_t_init(phymod_phy_speed_config_t* phymod_phy_speed_config) 7072 { 7073 7074 if(phymod_phy_speed_config == NULL){ 7075 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_speed_config NULL parameter"))); 7076 } 7077 PHYMOD_MEMSET(phymod_phy_speed_config, 0, sizeof(phymod_phy_speed_config_t)); 7078 phymod_phy_speed_config->data_rate = 0; 7079 phymod_phy_speed_config->fec_type = 0; 7080 phymod_phy_speed_config->linkTraining = 0; 7081 phymod_phy_speed_config->flags = 0; 7082 phymod_phy_speed_config->PAM4_channel_loss = 0; 7083 if(PHYMOD_E_OK != phymod_firmware_lane_config_t_init(&phymod_phy_speed_config->pmd_lane_config)) { 7084 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("pmd_lane_config initialization failed"))); 7085 } 7086 7087 7088 7089 return PHYMOD_E_NONE; 7090 7091 } 7092 7093 int phymod_phy_pll_state_t_validate(const phymod_phy_pll_state_t* phymod_phy_pll_state) 7094 { 7095 if(phymod_phy_pll_state == NULL) { 7096 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7097 } 7098 7099 7100 7101 return PHYMOD_E_NONE; 7102 7103 } 7104 7105 int phymod_phy_pll_state_t_init(phymod_phy_pll_state_t* phymod_phy_pll_state) 7106 { 7107 7108 if(phymod_phy_pll_state == NULL){ 7109 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_phy_pll_state NULL parameter"))); 7110 } 7111 PHYMOD_MEMSET(phymod_phy_pll_state, 0, sizeof(phymod_phy_pll_state_t)); 7112 phymod_phy_pll_state->pll0_lanes_bitmap = 0; 7113 phymod_phy_pll_state->pll1_lanes_bitmap = 0; 7114 7115 7116 return PHYMOD_E_NONE; 7117 7118 } 7119 7120 int phymod_phy_speed_config_set(const phymod_phy_access_t* phy, const phymod_phy_speed_config_t* speed_config, const phymod_phy_pll_state_t* old_pll_state, phymod_phy_pll_state_t* new_pll_state) 7121 { 7122 7123 phymod_dispatch_type_t __type__; 7124 int __rv__; 7125 7126 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7127 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7128 } 7129 7130 if(PHYMOD_E_OK != phymod_phy_speed_config_t_validate(speed_config)) { 7131 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("speed_config validation failed"))); 7132 } 7133 7134 if(PHYMOD_E_OK != phymod_phy_pll_state_t_validate(old_pll_state)) { 7135 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("old_pll_state validation failed"))); 7136 } 7137 7138 if(new_pll_state == NULL) { 7139 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("new_pll_state NULL parameter"))); 7140 } 7141 if(PHYMOD_E_OK != phymod_phy_pll_state_t_init(new_pll_state)) { 7142 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("new_pll_state initialization failed"))); 7143 } 7144 7145 /* Dispatch */ 7146 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7147 if(__type__ >= phymodDispatchTypeCount) { 7148 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7149 } 7150 7151 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_speed_config_set) { 7152 PHYMOD_LOCK_TAKE(phy); 7153 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_speed_config_set(phy, speed_config, old_pll_state, new_pll_state); 7154 PHYMOD_LOCK_GIVE(phy); 7155 PHYMOD_IF_ERR_RETURN(__rv__); 7156 } else { 7157 return PHYMOD_E_UNAVAIL; 7158 } 7159 7160 return PHYMOD_E_NONE; 7161 7162 } 7163 7164 7165 int phymod_phy_speed_config_get(const phymod_phy_access_t* phy, phymod_phy_speed_config_t* speed_config) 7166 { 7167 7168 phymod_dispatch_type_t __type__; 7169 int __rv__; 7170 7171 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7172 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7173 } 7174 7175 if(speed_config == NULL) { 7176 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("speed_config NULL parameter"))); 7177 } 7178 if(PHYMOD_E_OK != phymod_phy_speed_config_t_validate(speed_config)) { 7179 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("speed_config validation failed"))); 7180 } 7181 7182 /* Dispatch */ 7183 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7184 if(__type__ >= phymodDispatchTypeCount) { 7185 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7186 } 7187 7188 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_speed_config_get) { 7189 PHYMOD_LOCK_TAKE(phy); 7190 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_speed_config_get(phy, speed_config); 7191 PHYMOD_LOCK_GIVE(phy); 7192 PHYMOD_IF_ERR_RETURN(__rv__); 7193 } else { 7194 return PHYMOD_E_UNAVAIL; 7195 } 7196 7197 return PHYMOD_E_NONE; 7198 7199 } 7200 7201 7202 int phymod_phy_op_mode_get(const phymod_phy_access_t* phy, phymod_operation_mode_t* op_mode) 7203 { 7204 7205 phymod_dispatch_type_t __type__; 7206 int __rv__; 7207 7208 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7209 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7210 } 7211 7212 if(op_mode == NULL) { 7213 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("op_mode NULL parameter"))); 7214 } 7215 /* Dispatch */ 7216 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7217 if(__type__ >= phymodDispatchTypeCount) { 7218 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7219 } 7220 7221 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_op_mode_get) { 7222 PHYMOD_LOCK_TAKE(phy); 7223 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_op_mode_get(phy, op_mode); 7224 PHYMOD_LOCK_GIVE(phy); 7225 PHYMOD_IF_ERR_RETURN(__rv__); 7226 } else { 7227 return PHYMOD_E_UNAVAIL; 7228 } 7229 7230 return PHYMOD_E_NONE; 7231 7232 } 7233 7234 7235 int phymod_dual_plls_t_validate(const phymod_dual_plls_t* phymod_dual_plls) 7236 { 7237 if(phymod_dual_plls == NULL) { 7238 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7239 } 7240 7241 7242 7243 return PHYMOD_E_NONE; 7244 7245 } 7246 7247 int phymod_dual_plls_t_init(phymod_dual_plls_t* phymod_dual_plls) 7248 { 7249 7250 if(phymod_dual_plls == NULL){ 7251 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_dual_plls NULL parameter"))); 7252 } 7253 PHYMOD_MEMSET(phymod_dual_plls, 0, sizeof(phymod_dual_plls_t)); 7254 phymod_dual_plls->pll0_div = 0; 7255 phymod_dual_plls->pll1_div = 0; 7256 7257 7258 return PHYMOD_E_NONE; 7259 7260 } 7261 7262 int phymod_phy_tx_taps_default_get(const phymod_phy_access_t* phy, phymod_phy_signalling_method_t mode, phymod_tx_t* tx) 7263 { 7264 7265 phymod_dispatch_type_t __type__; 7266 int __rv__; 7267 7268 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7269 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7270 } 7271 7272 if(PHYMOD_E_OK != phymod_phy_signalling_method_t_validate(mode)) { 7273 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mode validation failed"))); 7274 } 7275 7276 if(tx == NULL) { 7277 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx NULL parameter"))); 7278 } 7279 if(PHYMOD_E_OK != phymod_tx_t_init(tx)) { 7280 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("tx initialization failed"))); 7281 } 7282 7283 /* Dispatch */ 7284 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7285 if(__type__ >= phymodDispatchTypeCount) { 7286 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7287 } 7288 7289 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_taps_default_get) { 7290 PHYMOD_LOCK_TAKE(phy); 7291 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_taps_default_get(phy, mode, tx); 7292 PHYMOD_LOCK_GIVE(phy); 7293 PHYMOD_IF_ERR_RETURN(__rv__); 7294 } else { 7295 return PHYMOD_E_UNAVAIL; 7296 } 7297 7298 return PHYMOD_E_NONE; 7299 7300 } 7301 7302 7303 int phymod_phy_lane_config_default_get(const phymod_phy_access_t* phy, phymod_phy_signalling_method_t mode, phymod_firmware_lane_config_t* lane_config) 7304 { 7305 7306 phymod_dispatch_type_t __type__; 7307 int __rv__; 7308 7309 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7310 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7311 } 7312 7313 if(PHYMOD_E_OK != phymod_phy_signalling_method_t_validate(mode)) { 7314 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("mode validation failed"))); 7315 } 7316 7317 if(lane_config == NULL) { 7318 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_config NULL parameter"))); 7319 } 7320 if(PHYMOD_E_OK != phymod_firmware_lane_config_t_init(lane_config)) { 7321 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("lane_config initialization failed"))); 7322 } 7323 7324 /* Dispatch */ 7325 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7326 if(__type__ >= phymodDispatchTypeCount) { 7327 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7328 } 7329 7330 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_lane_config_default_get) { 7331 PHYMOD_LOCK_TAKE(phy); 7332 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_lane_config_default_get(phy, mode, lane_config); 7333 PHYMOD_LOCK_GIVE(phy); 7334 PHYMOD_IF_ERR_RETURN(__rv__); 7335 } else { 7336 return PHYMOD_E_UNAVAIL; 7337 } 7338 7339 return PHYMOD_E_NONE; 7340 7341 } 7342 7343 7344 int phymod_firmware_load_info_t_validate(const phymod_firmware_load_info_t* phymod_firmware_load_info) 7345 { 7346 if(phymod_firmware_load_info == NULL) { 7347 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7348 } 7349 7350 7351 7352 return PHYMOD_E_NONE; 7353 7354 } 7355 7356 int phymod_firmware_load_info_t_init(phymod_firmware_load_info_t* phymod_firmware_load_info) 7357 { 7358 7359 if(phymod_firmware_load_info == NULL){ 7360 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_firmware_load_info NULL parameter"))); 7361 } 7362 PHYMOD_MEMSET(phymod_firmware_load_info, 0, sizeof(phymod_firmware_load_info_t)); 7363 phymod_firmware_load_info->ucode_ptr = NULL; 7364 phymod_firmware_load_info->ucode_len = 0; 7365 7366 7367 return PHYMOD_E_NONE; 7368 7369 } 7370 7371 int phymod_phy_firmware_load_info_get(const phymod_phy_access_t* phy, phymod_firmware_load_info_t* info) 7372 { 7373 7374 phymod_dispatch_type_t __type__; 7375 int __rv__; 7376 7377 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7378 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7379 } 7380 7381 if(info == NULL) { 7382 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("info NULL parameter"))); 7383 } 7384 if(PHYMOD_E_OK != phymod_firmware_load_info_t_init(info)) { 7385 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("info initialization failed"))); 7386 } 7387 7388 /* Dispatch */ 7389 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7390 if(__type__ >= phymodDispatchTypeCount) { 7391 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7392 } 7393 7394 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_firmware_load_info_get) { 7395 PHYMOD_LOCK_TAKE(phy); 7396 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_firmware_load_info_get(phy, info); 7397 PHYMOD_LOCK_GIVE(phy); 7398 PHYMOD_IF_ERR_RETURN(__rv__); 7399 } else { 7400 return PHYMOD_E_UNAVAIL; 7401 } 7402 7403 return PHYMOD_E_NONE; 7404 7405 } 7406 7407 7408 int phymod_pause_type_t_validate(phymod_pause_type_t phymod_pause_type) 7409 { 7410 if(phymod_pause_type >= phymod_pause_Count) { 7411 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 7412 } 7413 7414 return PHYMOD_E_NONE; 7415 7416 } 7417 7418 int phymod_channel_type_t_validate(phymod_channel_type_t phymod_channel_type) 7419 { 7420 if(phymod_channel_type >= phymod_channel_Count) { 7421 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 7422 } 7423 7424 return PHYMOD_E_NONE; 7425 7426 } 7427 7428 int phymod_autoneg_advert_ability_t_validate(const phymod_autoneg_advert_ability_t* phymod_autoneg_advert_ability) 7429 { 7430 if(phymod_autoneg_advert_ability == NULL) { 7431 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7432 } 7433 7434 if(PHYMOD_E_OK != phymod_fec_type_t_validate(phymod_autoneg_advert_ability->fec)) { 7435 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fec validation failed"))); 7436 } 7437 7438 if(PHYMOD_E_OK != phymod_pause_type_t_validate(phymod_autoneg_advert_ability->pause)) { 7439 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("pause validation failed"))); 7440 } 7441 7442 if(PHYMOD_E_OK != phymod_firmware_media_type_t_validate(phymod_autoneg_advert_ability->medium)) { 7443 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("medium validation failed"))); 7444 } 7445 7446 if(PHYMOD_E_OK != phymod_an_mode_type_t_validate(phymod_autoneg_advert_ability->an_mode)) { 7447 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_mode validation failed"))); 7448 } 7449 7450 7451 7452 return PHYMOD_E_NONE; 7453 7454 } 7455 7456 int phymod_autoneg_advert_ability_t_init(phymod_autoneg_advert_ability_t* phymod_autoneg_advert_ability) 7457 { 7458 7459 if(phymod_autoneg_advert_ability == NULL){ 7460 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_autoneg_advert_ability NULL parameter"))); 7461 } 7462 PHYMOD_MEMSET(phymod_autoneg_advert_ability, 0, sizeof(phymod_autoneg_advert_ability_t)); 7463 phymod_autoneg_advert_ability->speed = 0; 7464 phymod_autoneg_advert_ability->resolved_num_lanes = 0; 7465 phymod_autoneg_advert_ability->fec = 0; 7466 phymod_autoneg_advert_ability->pause = 0; 7467 phymod_autoneg_advert_ability->medium = 0; 7468 7469 7470 return PHYMOD_E_NONE; 7471 7472 } 7473 7474 int phymod_autoneg_advert_abilities_t_validate(const phymod_autoneg_advert_abilities_t* phymod_autoneg_advert_abilities) 7475 { 7476 if(phymod_autoneg_advert_abilities == NULL) { 7477 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7478 } 7479 7480 if(PHYMOD_E_OK != phymod_autoneg_advert_ability_t_validate(phymod_autoneg_advert_abilities->autoneg_abilities)) { 7481 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("autoneg_abilities validation failed"))); 7482 } 7483 7484 7485 7486 return PHYMOD_E_NONE; 7487 7488 } 7489 7490 int phymod_autoneg_advert_abilities_t_init(phymod_autoneg_advert_abilities_t* phymod_autoneg_advert_abilities) 7491 { 7492 7493 if(phymod_autoneg_advert_abilities == NULL){ 7494 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_autoneg_advert_abilities NULL parameter"))); 7495 } 7496 PHYMOD_MEMSET(phymod_autoneg_advert_abilities, 0, sizeof(phymod_autoneg_advert_abilities_t)); 7497 phymod_autoneg_advert_abilities->num_abilities = 0; 7498 7499 7500 return PHYMOD_E_NONE; 7501 7502 } 7503 7504 int phymod_phy_autoneg_advert_ability_set(const phymod_phy_access_t* phy, const phymod_autoneg_advert_abilities_t* an_advert_abilities, const phymod_phy_pll_state_t* old_pll_adv_state, phymod_phy_pll_state_t* new_pll_adv_state) 7505 { 7506 7507 phymod_dispatch_type_t __type__; 7508 int __rv__; 7509 7510 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7511 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7512 } 7513 7514 if(PHYMOD_E_OK != phymod_autoneg_advert_abilities_t_validate(an_advert_abilities)) { 7515 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_advert_abilities validation failed"))); 7516 } 7517 7518 if(PHYMOD_E_OK != phymod_phy_pll_state_t_validate(old_pll_adv_state)) { 7519 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("old_pll_adv_state validation failed"))); 7520 } 7521 7522 if(new_pll_adv_state == NULL) { 7523 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("new_pll_adv_state NULL parameter"))); 7524 } 7525 if(PHYMOD_E_OK != phymod_phy_pll_state_t_init(new_pll_adv_state)) { 7526 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("new_pll_adv_state initialization failed"))); 7527 } 7528 7529 /* Dispatch */ 7530 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7531 if(__type__ >= phymodDispatchTypeCount) { 7532 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7533 } 7534 7535 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_advert_ability_set) { 7536 PHYMOD_LOCK_TAKE(phy); 7537 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_advert_ability_set(phy, an_advert_abilities, old_pll_adv_state, new_pll_adv_state); 7538 PHYMOD_LOCK_GIVE(phy); 7539 PHYMOD_IF_ERR_RETURN(__rv__); 7540 } else { 7541 return PHYMOD_E_UNAVAIL; 7542 } 7543 7544 return PHYMOD_E_NONE; 7545 7546 } 7547 7548 7549 int phymod_phy_autoneg_advert_ability_get(const phymod_phy_access_t* phy, phymod_autoneg_advert_abilities_t* an_advert_abilities) 7550 { 7551 7552 phymod_dispatch_type_t __type__; 7553 int __rv__; 7554 7555 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7556 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7557 } 7558 7559 if(an_advert_abilities == NULL) { 7560 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_advert_abilities NULL parameter"))); 7561 } 7562 if(PHYMOD_E_OK != phymod_autoneg_advert_abilities_t_validate(an_advert_abilities)) { 7563 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_advert_abilities validation failed"))); 7564 } 7565 7566 /* Dispatch */ 7567 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7568 if(__type__ >= phymodDispatchTypeCount) { 7569 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7570 } 7571 7572 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_advert_ability_get) { 7573 PHYMOD_LOCK_TAKE(phy); 7574 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_advert_ability_get(phy, an_advert_abilities); 7575 PHYMOD_LOCK_GIVE(phy); 7576 PHYMOD_IF_ERR_RETURN(__rv__); 7577 } else { 7578 return PHYMOD_E_UNAVAIL; 7579 } 7580 7581 return PHYMOD_E_NONE; 7582 7583 } 7584 7585 7586 int phymod_phy_autoneg_remote_advert_ability_get(const phymod_phy_access_t* phy, phymod_autoneg_advert_abilities_t* an_advert_abilities) 7587 { 7588 7589 phymod_dispatch_type_t __type__; 7590 int __rv__; 7591 7592 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7593 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7594 } 7595 7596 if(an_advert_abilities == NULL) { 7597 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_advert_abilities NULL parameter"))); 7598 } 7599 if(PHYMOD_E_OK != phymod_autoneg_advert_abilities_t_validate(an_advert_abilities)) { 7600 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("an_advert_abilities validation failed"))); 7601 } 7602 7603 /* Dispatch */ 7604 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7605 if(__type__ >= phymodDispatchTypeCount) { 7606 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7607 } 7608 7609 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_remote_advert_ability_get) { 7610 PHYMOD_LOCK_TAKE(phy); 7611 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_autoneg_remote_advert_ability_get(phy, an_advert_abilities); 7612 PHYMOD_LOCK_GIVE(phy); 7613 PHYMOD_IF_ERR_RETURN(__rv__); 7614 } else { 7615 return PHYMOD_E_UNAVAIL; 7616 } 7617 7618 return PHYMOD_E_NONE; 7619 7620 } 7621 7622 7623 int phymod_phy_bond_in_pwrdn_override(const phymod_phy_access_t* phy, uint32_t enable) 7624 { 7625 7626 phymod_dispatch_type_t __type__; 7627 int __rv__; 7628 7629 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7630 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7631 } 7632 7633 /* Dispatch */ 7634 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7635 if(__type__ >= phymodDispatchTypeCount) { 7636 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7637 } 7638 7639 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_bond_in_pwrdn_override) { 7640 PHYMOD_LOCK_TAKE(phy); 7641 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_bond_in_pwrdn_override(phy, enable); 7642 PHYMOD_LOCK_GIVE(phy); 7643 PHYMOD_IF_ERR_RETURN(__rv__); 7644 } else { 7645 return PHYMOD_E_UNAVAIL; 7646 } 7647 7648 return PHYMOD_E_NONE; 7649 7650 } 7651 7652 7653 int phymod_phy_tx_pam4_precoder_enable_set(const phymod_phy_access_t* phy, int enable) 7654 { 7655 7656 phymod_dispatch_type_t __type__; 7657 int __rv__; 7658 7659 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7660 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7661 } 7662 7663 /* Dispatch */ 7664 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7665 if(__type__ >= phymodDispatchTypeCount) { 7666 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7667 } 7668 7669 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_pam4_precoder_enable_set) { 7670 PHYMOD_LOCK_TAKE(phy); 7671 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_pam4_precoder_enable_set(phy, enable); 7672 PHYMOD_LOCK_GIVE(phy); 7673 PHYMOD_IF_ERR_RETURN(__rv__); 7674 } else { 7675 return PHYMOD_E_UNAVAIL; 7676 } 7677 7678 return PHYMOD_E_NONE; 7679 7680 } 7681 7682 7683 int phymod_phy_tx_pam4_precoder_enable_get(const phymod_phy_access_t* phy, int* enable) 7684 { 7685 7686 phymod_dispatch_type_t __type__; 7687 int __rv__; 7688 7689 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7690 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7691 } 7692 7693 if(enable == NULL) { 7694 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 7695 } 7696 /* Dispatch */ 7697 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7698 if(__type__ >= phymodDispatchTypeCount) { 7699 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7700 } 7701 7702 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_pam4_precoder_enable_get) { 7703 PHYMOD_LOCK_TAKE(phy); 7704 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_pam4_precoder_enable_get(phy, enable); 7705 PHYMOD_LOCK_GIVE(phy); 7706 PHYMOD_IF_ERR_RETURN(__rv__); 7707 } else { 7708 return PHYMOD_E_UNAVAIL; 7709 } 7710 7711 return PHYMOD_E_NONE; 7712 7713 } 7714 7715 7716 int phymod_phy_tx_phase_lock_set(const phymod_phy_access_t* phy, uint8_t enable) 7717 { 7718 7719 phymod_dispatch_type_t __type__; 7720 int __rv__; 7721 7722 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7723 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7724 } 7725 7726 /* Dispatch */ 7727 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7728 if(__type__ >= phymodDispatchTypeCount) { 7729 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7730 } 7731 7732 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_tx_phase_lock_set) { 7733 PHYMOD_LOCK_TAKE(phy); 7734 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_tx_phase_lock_set(phy, enable); 7735 PHYMOD_LOCK_GIVE(phy); 7736 PHYMOD_IF_ERR_RETURN(__rv__); 7737 } else { 7738 return PHYMOD_E_UNAVAIL; 7739 } 7740 7741 return PHYMOD_E_NONE; 7742 7743 } 7744 7745 7746 int phymod_phy_pll_reconfig(const phymod_phy_access_t* phy, uint8_t pll_index, uint32_t pll_div) 7747 { 7748 7749 phymod_dispatch_type_t __type__; 7750 int __rv__; 7751 7752 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7753 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7754 } 7755 7756 /* Dispatch */ 7757 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7758 if(__type__ >= phymodDispatchTypeCount) { 7759 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7760 } 7761 7762 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pll_reconfig) { 7763 PHYMOD_LOCK_TAKE(phy); 7764 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pll_reconfig(phy, pll_index, pll_div); 7765 PHYMOD_LOCK_GIVE(phy); 7766 PHYMOD_IF_ERR_RETURN(__rv__); 7767 } else { 7768 return PHYMOD_E_UNAVAIL; 7769 } 7770 7771 return PHYMOD_E_NONE; 7772 7773 } 7774 7775 7776 int phymod_phy_pll_pwrdn(const phymod_phy_access_t* phy, uint32_t pll_index, uint32_t pwrdn) 7777 { 7778 7779 phymod_dispatch_type_t __type__; 7780 int __rv__; 7781 7782 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7783 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7784 } 7785 7786 /* Dispatch */ 7787 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7788 if(__type__ >= phymodDispatchTypeCount) { 7789 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7790 } 7791 7792 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pll_pwrdn) { 7793 PHYMOD_LOCK_TAKE(phy); 7794 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pll_pwrdn(phy, pll_index, pwrdn); 7795 PHYMOD_LOCK_GIVE(phy); 7796 PHYMOD_IF_ERR_RETURN(__rv__); 7797 } else { 7798 return PHYMOD_E_UNAVAIL; 7799 } 7800 7801 return PHYMOD_E_NONE; 7802 7803 } 7804 7805 7806 int phymod_phy_linkdown_transmit_set(const phymod_phy_access_t* phy, uint32_t enable) 7807 { 7808 7809 phymod_dispatch_type_t __type__; 7810 int __rv__; 7811 7812 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7813 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7814 } 7815 7816 /* Dispatch */ 7817 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7818 if(__type__ >= phymodDispatchTypeCount) { 7819 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7820 } 7821 7822 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_linkdown_transmit_set) { 7823 PHYMOD_LOCK_TAKE(phy); 7824 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_linkdown_transmit_set(phy, enable); 7825 PHYMOD_LOCK_GIVE(phy); 7826 PHYMOD_IF_ERR_RETURN(__rv__); 7827 } else { 7828 return PHYMOD_E_UNAVAIL; 7829 } 7830 7831 return PHYMOD_E_NONE; 7832 7833 } 7834 7835 7836 int phymod_phy_linkdown_transmit_get(const phymod_phy_access_t* phy, uint32_t* enable) 7837 { 7838 7839 phymod_dispatch_type_t __type__; 7840 int __rv__; 7841 7842 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7843 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7844 } 7845 7846 if(enable == NULL) { 7847 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 7848 } 7849 /* Dispatch */ 7850 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7851 if(__type__ >= phymodDispatchTypeCount) { 7852 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7853 } 7854 7855 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_linkdown_transmit_get) { 7856 PHYMOD_LOCK_TAKE(phy); 7857 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_linkdown_transmit_get(phy, enable); 7858 PHYMOD_LOCK_GIVE(phy); 7859 PHYMOD_IF_ERR_RETURN(__rv__); 7860 } else { 7861 return PHYMOD_E_UNAVAIL; 7862 } 7863 7864 return PHYMOD_E_NONE; 7865 7866 } 7867 7868 7869 int phymod_synce_clk_ctrl_t_validate(const phymod_synce_clk_ctrl_t* phymod_synce_clk_ctrl) 7870 { 7871 if(phymod_synce_clk_ctrl == NULL) { 7872 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 7873 } 7874 7875 7876 7877 return PHYMOD_E_NONE; 7878 7879 } 7880 7881 int phymod_synce_clk_ctrl_t_init(phymod_synce_clk_ctrl_t* phymod_synce_clk_ctrl) 7882 { 7883 7884 if(phymod_synce_clk_ctrl == NULL){ 7885 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_synce_clk_ctrl NULL parameter"))); 7886 } 7887 PHYMOD_MEMSET(phymod_synce_clk_ctrl, 0, sizeof(phymod_synce_clk_ctrl_t)); 7888 phymod_synce_clk_ctrl->stg0_mode = -1; 7889 phymod_synce_clk_ctrl->stg1_mode = -1; 7890 7891 7892 return PHYMOD_E_NONE; 7893 7894 } 7895 7896 int phymod_phy_synce_clk_ctrl_set(const phymod_phy_access_t* phy, phymod_synce_clk_ctrl_t cfg) 7897 { 7898 7899 phymod_dispatch_type_t __type__; 7900 int __rv__; 7901 7902 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7903 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7904 } 7905 7906 if(PHYMOD_E_OK != phymod_synce_clk_ctrl_t_validate(&cfg)) { 7907 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("cfg validation failed"))); 7908 } 7909 7910 /* Dispatch */ 7911 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7912 if(__type__ >= phymodDispatchTypeCount) { 7913 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7914 } 7915 7916 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_synce_clk_ctrl_set) { 7917 PHYMOD_LOCK_TAKE(phy); 7918 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_synce_clk_ctrl_set(phy, cfg); 7919 PHYMOD_LOCK_GIVE(phy); 7920 PHYMOD_IF_ERR_RETURN(__rv__); 7921 } else { 7922 return PHYMOD_E_UNAVAIL; 7923 } 7924 7925 return PHYMOD_E_NONE; 7926 7927 } 7928 7929 7930 int phymod_phy_synce_clk_ctrl_get(const phymod_phy_access_t* phy, phymod_synce_clk_ctrl_t* cfg) 7931 { 7932 7933 phymod_dispatch_type_t __type__; 7934 int __rv__; 7935 7936 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7937 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7938 } 7939 7940 if(cfg == NULL) { 7941 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("cfg NULL parameter"))); 7942 } 7943 if(PHYMOD_E_OK != phymod_synce_clk_ctrl_t_init(cfg)) { 7944 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("cfg initialization failed"))); 7945 } 7946 7947 /* Dispatch */ 7948 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7949 if(__type__ >= phymodDispatchTypeCount) { 7950 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7951 } 7952 7953 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_synce_clk_ctrl_get) { 7954 PHYMOD_LOCK_TAKE(phy); 7955 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_synce_clk_ctrl_get(phy, cfg); 7956 PHYMOD_LOCK_GIVE(phy); 7957 PHYMOD_IF_ERR_RETURN(__rv__); 7958 } else { 7959 return PHYMOD_E_UNAVAIL; 7960 } 7961 7962 return PHYMOD_E_NONE; 7963 7964 } 7965 7966 7967 int phymod_phy_pcs_enable_set(const phymod_phy_access_t* phy, uint32_t enable) 7968 { 7969 7970 phymod_dispatch_type_t __type__; 7971 int __rv__; 7972 7973 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 7974 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 7975 } 7976 7977 /* Dispatch */ 7978 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 7979 if(__type__ >= phymodDispatchTypeCount) { 7980 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 7981 } 7982 7983 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pcs_enable_set) { 7984 PHYMOD_LOCK_TAKE(phy); 7985 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pcs_enable_set(phy, enable); 7986 PHYMOD_LOCK_GIVE(phy); 7987 PHYMOD_IF_ERR_RETURN(__rv__); 7988 } else { 7989 return PHYMOD_E_UNAVAIL; 7990 } 7991 7992 return PHYMOD_E_NONE; 7993 7994 } 7995 7996 7997 int phymod_phy_rx_ppm_get(const phymod_phy_access_t* phy, int16_t* rx_ppm) 7998 { 7999 8000 phymod_dispatch_type_t __type__; 8001 int __rv__; 8002 8003 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8004 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8005 } 8006 8007 if(rx_ppm == NULL) { 8008 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("rx_ppm NULL parameter"))); 8009 } 8010 /* Dispatch */ 8011 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8012 if(__type__ >= phymodDispatchTypeCount) { 8013 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8014 } 8015 8016 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_rx_ppm_get) { 8017 PHYMOD_LOCK_TAKE(phy); 8018 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_rx_ppm_get(phy, rx_ppm); 8019 PHYMOD_LOCK_GIVE(phy); 8020 PHYMOD_IF_ERR_RETURN(__rv__); 8021 } else { 8022 return PHYMOD_E_UNAVAIL; 8023 } 8024 8025 return PHYMOD_E_NONE; 8026 8027 } 8028 8029 8030 int phymod_phy_channel_loss_hint_set(const phymod_phy_access_t* phy, uint32_t channel_loss) 8031 { 8032 8033 phymod_dispatch_type_t __type__; 8034 int __rv__; 8035 8036 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8037 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8038 } 8039 8040 /* Dispatch */ 8041 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8042 if(__type__ >= phymodDispatchTypeCount) { 8043 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8044 } 8045 8046 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_channel_loss_hint_set) { 8047 PHYMOD_LOCK_TAKE(phy); 8048 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_channel_loss_hint_set(phy, channel_loss); 8049 PHYMOD_LOCK_GIVE(phy); 8050 PHYMOD_IF_ERR_RETURN(__rv__); 8051 } else { 8052 return PHYMOD_E_UNAVAIL; 8053 } 8054 8055 return PHYMOD_E_NONE; 8056 8057 } 8058 8059 8060 int phymod_phy_channel_loss_hint_get(const phymod_phy_access_t* phy, uint32_t* channel_loss) 8061 { 8062 8063 phymod_dispatch_type_t __type__; 8064 int __rv__; 8065 8066 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8067 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8068 } 8069 8070 if(channel_loss == NULL) { 8071 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("channel_loss NULL parameter"))); 8072 } 8073 /* Dispatch */ 8074 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8075 if(__type__ >= phymodDispatchTypeCount) { 8076 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8077 } 8078 8079 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_channel_loss_hint_get) { 8080 PHYMOD_LOCK_TAKE(phy); 8081 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_channel_loss_hint_get(phy, channel_loss); 8082 PHYMOD_LOCK_GIVE(phy); 8083 PHYMOD_IF_ERR_RETURN(__rv__); 8084 } else { 8085 return PHYMOD_E_UNAVAIL; 8086 } 8087 8088 return PHYMOD_E_NONE; 8089 8090 } 8091 8092 8093 int phymod_interrupt_type_t_validate(phymod_interrupt_type_t phymod_interrupt_type) 8094 { 8095 if(phymod_interrupt_type >= phymodIntrCount) { 8096 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 8097 } 8098 8099 return PHYMOD_E_NONE; 8100 8101 } 8102 8103 int phymod_intr_handler(const phymod_phy_access_t* phy, phymod_interrupt_type_t type, uint32_t* is_handled) 8104 { 8105 8106 phymod_dispatch_type_t __type__; 8107 int __rv__; 8108 8109 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8110 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8111 } 8112 8113 if(PHYMOD_E_OK != phymod_interrupt_type_t_validate(type)) { 8114 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("type validation failed"))); 8115 } 8116 8117 if(is_handled == NULL) { 8118 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("is_handled NULL parameter"))); 8119 } 8120 /* Dispatch */ 8121 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8122 if(__type__ >= phymodDispatchTypeCount) { 8123 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8124 } 8125 8126 if(NULL != __phymod__dispatch__[__type__]->f_phymod_intr_handler) { 8127 PHYMOD_LOCK_TAKE(phy); 8128 __rv__ = __phymod__dispatch__[__type__]->f_phymod_intr_handler(phy, type, is_handled); 8129 PHYMOD_LOCK_GIVE(phy); 8130 PHYMOD_IF_ERR_RETURN(__rv__); 8131 } else { 8132 return PHYMOD_E_UNAVAIL; 8133 } 8134 8135 return PHYMOD_E_NONE; 8136 8137 } 8138 8139 8140 int phymod_ts_fifo_status_t_validate(const phymod_ts_fifo_status_t* phymod_ts_fifo_status) 8141 { 8142 if(phymod_ts_fifo_status == NULL) { 8143 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("NULL parameter"))); 8144 } 8145 8146 8147 8148 return PHYMOD_E_NONE; 8149 8150 } 8151 8152 int phymod_ts_fifo_status_t_init(phymod_ts_fifo_status_t* phymod_ts_fifo_status) 8153 { 8154 8155 if(phymod_ts_fifo_status == NULL){ 8156 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phymod_ts_fifo_status NULL parameter"))); 8157 } 8158 PHYMOD_MEMSET(phymod_ts_fifo_status, 0, sizeof(phymod_ts_fifo_status_t)); 8159 8160 8161 return PHYMOD_E_NONE; 8162 8163 } 8164 8165 int phymod_timesync_tx_info_get(const phymod_phy_access_t* phy, phymod_ts_fifo_status_t* ts_tx_info) 8166 { 8167 8168 phymod_dispatch_type_t __type__; 8169 int __rv__; 8170 8171 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8172 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8173 } 8174 8175 if(ts_tx_info == NULL) { 8176 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ts_tx_info NULL parameter"))); 8177 } 8178 if(PHYMOD_E_OK != phymod_ts_fifo_status_t_init(ts_tx_info)) { 8179 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("ts_tx_info initialization failed"))); 8180 } 8181 8182 /* Dispatch */ 8183 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8184 if(__type__ >= phymodDispatchTypeCount) { 8185 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8186 } 8187 8188 if(NULL != __phymod__dispatch__[__type__]->f_phymod_timesync_tx_info_get) { 8189 PHYMOD_LOCK_TAKE(phy); 8190 __rv__ = __phymod__dispatch__[__type__]->f_phymod_timesync_tx_info_get(phy, ts_tx_info); 8191 PHYMOD_LOCK_GIVE(phy); 8192 PHYMOD_IF_ERR_RETURN(__rv__); 8193 } else { 8194 return PHYMOD_E_UNAVAIL; 8195 } 8196 8197 return PHYMOD_E_NONE; 8198 8199 } 8200 8201 8202 int phymod_master_mode_t_validate(phymod_master_mode_t phymod_master_mode) 8203 { 8204 if(phymod_master_mode >= phymodMSCount) { 8205 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 8206 } 8207 8208 return PHYMOD_E_NONE; 8209 8210 } 8211 8212 int phymod_phy_master_set(const phymod_phy_access_t* phy, phymod_master_mode_t master_mode) 8213 { 8214 8215 phymod_dispatch_type_t __type__; 8216 int __rv__; 8217 8218 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8219 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8220 } 8221 8222 if(PHYMOD_E_OK != phymod_master_mode_t_validate(master_mode)) { 8223 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("master_mode validation failed"))); 8224 } 8225 8226 /* Dispatch */ 8227 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8228 if(__type__ >= phymodDispatchTypeCount) { 8229 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8230 } 8231 8232 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_master_set) { 8233 PHYMOD_LOCK_TAKE(phy); 8234 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_master_set(phy, master_mode); 8235 PHYMOD_LOCK_GIVE(phy); 8236 PHYMOD_IF_ERR_RETURN(__rv__); 8237 } else { 8238 return PHYMOD_E_UNAVAIL; 8239 } 8240 8241 return PHYMOD_E_NONE; 8242 8243 } 8244 8245 8246 int phymod_phy_master_get(const phymod_phy_access_t* phy, phymod_master_mode_t* master_mode) 8247 { 8248 8249 phymod_dispatch_type_t __type__; 8250 int __rv__; 8251 8252 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8253 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8254 } 8255 8256 if(master_mode == NULL) { 8257 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("master_mode NULL parameter"))); 8258 } 8259 /* Dispatch */ 8260 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8261 if(__type__ >= phymodDispatchTypeCount) { 8262 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8263 } 8264 8265 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_master_get) { 8266 PHYMOD_LOCK_TAKE(phy); 8267 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_master_get(phy, master_mode); 8268 PHYMOD_LOCK_GIVE(phy); 8269 PHYMOD_IF_ERR_RETURN(__rv__); 8270 } else { 8271 return PHYMOD_E_UNAVAIL; 8272 } 8273 8274 return PHYMOD_E_NONE; 8275 8276 } 8277 8278 8279 int phymod_phy_pcs_lane_swap_adjust(const phymod_phy_access_t* phy, uint32_t active_lane_map, uint32_t original_tx_lane_map, uint32_t original_rx_lane_map) 8280 { 8281 8282 phymod_dispatch_type_t __type__; 8283 int __rv__; 8284 8285 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8286 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8287 } 8288 8289 /* Dispatch */ 8290 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8291 if(__type__ >= phymodDispatchTypeCount) { 8292 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8293 } 8294 8295 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pcs_lane_swap_adjust) { 8296 PHYMOD_LOCK_TAKE(phy); 8297 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pcs_lane_swap_adjust(phy, active_lane_map, original_tx_lane_map, original_rx_lane_map); 8298 PHYMOD_LOCK_GIVE(phy); 8299 PHYMOD_IF_ERR_RETURN(__rv__); 8300 } else { 8301 return PHYMOD_E_UNAVAIL; 8302 } 8303 8304 return PHYMOD_E_NONE; 8305 8306 } 8307 8308 8309 int phymod_phy_load_speed_id_entry(const phymod_phy_access_t* phy, uint32_t speed, uint32_t num_lane, phymod_fec_type_t fec_type) 8310 { 8311 8312 phymod_dispatch_type_t __type__; 8313 int __rv__; 8314 8315 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8316 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8317 } 8318 8319 if(PHYMOD_E_OK != phymod_fec_type_t_validate(fec_type)) { 8320 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("fec_type validation failed"))); 8321 } 8322 8323 /* Dispatch */ 8324 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8325 if(__type__ >= phymodDispatchTypeCount) { 8326 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8327 } 8328 8329 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_load_speed_id_entry) { 8330 PHYMOD_LOCK_TAKE(phy); 8331 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_load_speed_id_entry(phy, speed, num_lane, fec_type); 8332 PHYMOD_LOCK_GIVE(phy); 8333 PHYMOD_IF_ERR_RETURN(__rv__); 8334 } else { 8335 return PHYMOD_E_UNAVAIL; 8336 } 8337 8338 return PHYMOD_E_NONE; 8339 8340 } 8341 8342 8343 int phymod_override_type_t_validate(phymod_override_type_t phymod_override_type) 8344 { 8345 if(phymod_override_type >= phymodPMDCount) { 8346 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 8347 } 8348 8349 return PHYMOD_E_NONE; 8350 8351 } 8352 8353 int phymod_phy_pmd_override_enable_set(const phymod_phy_access_t* phy, phymod_override_type_t pmd_override_type, uint32_t override_enable, uint32_t override_val) 8354 { 8355 8356 phymod_dispatch_type_t __type__; 8357 int __rv__; 8358 8359 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8360 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8361 } 8362 8363 if(PHYMOD_E_OK != phymod_override_type_t_validate(pmd_override_type)) { 8364 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("pmd_override_type validation failed"))); 8365 } 8366 8367 /* Dispatch */ 8368 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8369 if(__type__ >= phymodDispatchTypeCount) { 8370 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8371 } 8372 8373 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pmd_override_enable_set) { 8374 PHYMOD_LOCK_TAKE(phy); 8375 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pmd_override_enable_set(phy, pmd_override_type, override_enable, override_val); 8376 PHYMOD_LOCK_GIVE(phy); 8377 PHYMOD_IF_ERR_RETURN(__rv__); 8378 } else { 8379 return PHYMOD_E_UNAVAIL; 8380 } 8381 8382 return PHYMOD_E_NONE; 8383 8384 } 8385 8386 8387 int phymod_duplex_mode_t_validate(phymod_duplex_mode_t phymod_duplex_mode) 8388 { 8389 if(phymod_duplex_mode >= phymodDuplexCount) { 8390 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Parameter is out of range"))); 8391 } 8392 8393 return PHYMOD_E_NONE; 8394 8395 } 8396 8397 int phymod_phy_duplex_set(const phymod_phy_access_t* phy, phymod_duplex_mode_t duplex) 8398 { 8399 8400 phymod_dispatch_type_t __type__; 8401 int __rv__; 8402 8403 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8404 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8405 } 8406 8407 if(PHYMOD_E_OK != phymod_duplex_mode_t_validate(duplex)) { 8408 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("duplex validation failed"))); 8409 } 8410 8411 /* Dispatch */ 8412 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8413 if(__type__ >= phymodDispatchTypeCount) { 8414 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8415 } 8416 8417 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_duplex_set) { 8418 PHYMOD_LOCK_TAKE(phy); 8419 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_duplex_set(phy, duplex); 8420 PHYMOD_LOCK_GIVE(phy); 8421 PHYMOD_IF_ERR_RETURN(__rv__); 8422 } else { 8423 return PHYMOD_E_UNAVAIL; 8424 } 8425 8426 return PHYMOD_E_NONE; 8427 8428 } 8429 8430 8431 int phymod_phy_duplex_get(const phymod_phy_access_t* phy, phymod_duplex_mode_t* duplex) 8432 { 8433 8434 phymod_dispatch_type_t __type__; 8435 int __rv__; 8436 8437 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8438 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8439 } 8440 8441 if(duplex == NULL) { 8442 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("duplex NULL parameter"))); 8443 } 8444 /* Dispatch */ 8445 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8446 if(__type__ >= phymodDispatchTypeCount) { 8447 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8448 } 8449 8450 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_duplex_get) { 8451 PHYMOD_LOCK_TAKE(phy); 8452 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_duplex_get(phy, duplex); 8453 PHYMOD_LOCK_GIVE(phy); 8454 PHYMOD_IF_ERR_RETURN(__rv__); 8455 } else { 8456 return PHYMOD_E_UNAVAIL; 8457 } 8458 8459 return PHYMOD_E_NONE; 8460 8461 } 8462 8463 8464 int phymod_phy_pmd_info_init(const phymod_phy_access_t* phy) 8465 { 8466 8467 phymod_dispatch_type_t __type__; 8468 int __rv__; 8469 8470 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8471 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8472 } 8473 8474 /* Dispatch */ 8475 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8476 if(__type__ >= phymodDispatchTypeCount) { 8477 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8478 } 8479 8480 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pmd_info_init) { 8481 PHYMOD_LOCK_TAKE(phy); 8482 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pmd_info_init(phy); 8483 PHYMOD_LOCK_GIVE(phy); 8484 PHYMOD_IF_ERR_RETURN(__rv__); 8485 } else { 8486 return PHYMOD_E_UNAVAIL; 8487 } 8488 8489 return PHYMOD_E_NONE; 8490 8491 } 8492 8493 8494 int phymod_phy_pll_powerdown_get(const phymod_phy_access_t* phy, uint32_t pll_index, uint32_t* powerdown) 8495 { 8496 8497 phymod_dispatch_type_t __type__; 8498 int __rv__; 8499 8500 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8501 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8502 } 8503 8504 if(powerdown == NULL) { 8505 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("powerdown NULL parameter"))); 8506 } 8507 /* Dispatch */ 8508 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8509 if(__type__ >= phymodDispatchTypeCount) { 8510 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8511 } 8512 8513 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pll_powerdown_get) { 8514 PHYMOD_LOCK_TAKE(phy); 8515 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pll_powerdown_get(phy, pll_index, powerdown); 8516 PHYMOD_LOCK_GIVE(phy); 8517 PHYMOD_IF_ERR_RETURN(__rv__); 8518 } else { 8519 return PHYMOD_E_UNAVAIL; 8520 } 8521 8522 return PHYMOD_E_NONE; 8523 8524 } 8525 8526 8527 int phymod_phy_pmd_info_size_get(const phymod_phy_access_t* phy, uint32_t* size) 8528 { 8529 8530 phymod_dispatch_type_t __type__; 8531 int __rv__; 8532 8533 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8534 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8535 } 8536 8537 if(size == NULL) { 8538 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("size NULL parameter"))); 8539 } 8540 /* Dispatch */ 8541 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8542 if(__type__ >= phymodDispatchTypeCount) { 8543 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8544 } 8545 8546 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_pmd_info_size_get) { 8547 PHYMOD_LOCK_TAKE(phy); 8548 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_pmd_info_size_get(phy, size); 8549 PHYMOD_LOCK_GIVE(phy); 8550 PHYMOD_IF_ERR_RETURN(__rv__); 8551 } else { 8552 return PHYMOD_E_UNAVAIL; 8553 } 8554 8555 return PHYMOD_E_NONE; 8556 8557 } 8558 8559 8560 int phymod_phy_fec_bypass_indication_set(const phymod_phy_access_t* phy, uint32_t enable) 8561 { 8562 8563 phymod_dispatch_type_t __type__; 8564 int __rv__; 8565 8566 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8567 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8568 } 8569 8570 /* Dispatch */ 8571 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8572 if(__type__ >= phymodDispatchTypeCount) { 8573 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8574 } 8575 8576 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_fec_bypass_indication_set) { 8577 PHYMOD_LOCK_TAKE(phy); 8578 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_fec_bypass_indication_set(phy, enable); 8579 PHYMOD_LOCK_GIVE(phy); 8580 PHYMOD_IF_ERR_RETURN(__rv__); 8581 } else { 8582 return PHYMOD_E_UNAVAIL; 8583 } 8584 8585 return PHYMOD_E_NONE; 8586 8587 } 8588 8589 8590 int phymod_phy_fec_bypass_indication_get(const phymod_phy_access_t* phy, uint32_t* enable) 8591 { 8592 8593 phymod_dispatch_type_t __type__; 8594 int __rv__; 8595 8596 if(PHYMOD_E_OK != phymod_phy_access_t_validate(phy)) { 8597 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("phy validation failed"))); 8598 } 8599 8600 if(enable == NULL) { 8601 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("enable NULL parameter"))); 8602 } 8603 /* Dispatch */ 8604 PHYMOD_DRIVER_TYPE_GET(phy,&__type__); 8605 if(__type__ >= phymodDispatchTypeCount) { 8606 PHYMOD_RETURN_WITH_ERR(PHYMOD_E_PARAM, (_PHYMOD_MSG("Driver is out of range"))); 8607 } 8608 8609 if(NULL != __phymod__dispatch__[__type__]->f_phymod_phy_fec_bypass_indication_get) { 8610 PHYMOD_LOCK_TAKE(phy); 8611 __rv__ = __phymod__dispatch__[__type__]->f_phymod_phy_fec_bypass_indication_get(phy, enable); 8612 PHYMOD_LOCK_GIVE(phy); 8613 PHYMOD_IF_ERR_RETURN(__rv__); 8614 } else { 8615 return PHYMOD_E_UNAVAIL; 8616 } 8617 8618 return PHYMOD_E_NONE; 8619 8620 } 8621 8622