target/linux/mediatek/files/drivers/net/phy/rtk/rtl8367c/led.c

   1 /*
   2  * Copyright (C) 2013 Realtek Semiconductor Corp.
   3  * All Rights Reserved.
   4  *
   5  * Unless you and Realtek execute a separate written software license
   6  * agreement governing use of this software, this software is licensed
   7  * to you under the terms of the GNU General Public License version 2,
   8  * available at https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
   9  *
  10  * $Revision: 76306 $
  11  * $Date: 2017-03-08 15:13:58 +0800 (週三, 08 三月 2017) $
  12  *
  13  * Purpose : RTK switch high-level API for RTL8367/RTL8367C
  14  * Feature : Here is a list of all functions and variables in LED module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <led.h>
  21 #include <string.h>
  22
  23 #include <rtl8367c_asicdrv.h>
  24 #include <rtl8367c_asicdrv_led.h>
  25
  26
  27 /* Function Name:
  28  *      rtk_led_enable_set
  29  * Description:
  30  *      Set Led enable congiuration
  31  * Input:
  32  *      group       - LED group id.
  33  *      pPortmask   - LED enable port mask.
  34  * Output:
  35  *      None
  36  * Return:
  37  *      RT_ERR_OK           - OK
  38  *      RT_ERR_FAILED       - Failed
  39  *      RT_ERR_SMI          - SMI access error
  40  *      RT_ERR_INPUT        - Invalid input parameters.
  41  *      RT_ERR_PORT_MASK    - Error portmask
  42  * Note:
  43  *      The API can be used to enable LED per port per group.
  44  */
  45 rtk_api_ret_t rtk_led_enable_set(rtk_led_group_t group, rtk_portmask_t *pPortmask)
  46 {
  47     rtk_api_ret_t retVal;
  48     rtk_uint32 pmask;
  49     rtk_port_t port;
  50
  51     /* Check initialization state */
  52     RTK_CHK_INIT_STATE();
  53
  54     if (group >= LED_GROUP_END)
  55         return RT_ERR_INPUT;
  56
  57     RTK_CHK_PORTMASK_VALID(pPortmask);
  58
  59     RTK_PORTMASK_SCAN((*pPortmask), port)
  60     {
  61         if(rtk_switch_isCPUPort(port) == RT_ERR_OK)
  62             return RT_ERR_PORT_MASK;
  63     }
  64
  65     if((retVal = rtk_switch_portmask_L2P_get(pPortmask, &pmask)) != RT_ERR_OK)
  66         return retVal;
  67
  68     if ((retVal = rtl8367c_setAsicLedGroupEnable(group, pmask)) != RT_ERR_OK)
  69         return retVal;
  70
  71     return RT_ERR_OK;
  72 }
  73
  74 /* Function Name:
  75  *      rtk_led_enable_get
  76  * Description:
  77  *      Get Led enable congiuration
  78  * Input:
  79  *      group - LED group id.
  80  * Output:
  81  *      pPortmask - LED enable port mask.
  82  * Return:
  83  *      RT_ERR_OK           - OK
  84  *      RT_ERR_FAILED       - Failed
  85  *      RT_ERR_SMI          - SMI access error
  86  *      RT_ERR_INPUT        - Invalid input parameters.
  87  * Note:
  88  *      The API can be used to get LED enable status.
  89  */
  90 rtk_api_ret_t rtk_led_enable_get(rtk_led_group_t group, rtk_portmask_t *pPortmask)
  91 {
  92     rtk_api_ret_t retVal;
  93     rtk_uint32 pmask;
  94
  95     /* Check initialization state */
  96     RTK_CHK_INIT_STATE();
  97
  98     if (group >= LED_GROUP_END)
  99         return RT_ERR_INPUT;
 100
 101     if ((retVal = rtl8367c_getAsicLedGroupEnable(group, &pmask)) != RT_ERR_OK)
 102         return retVal;
 103
 104     if((retVal = rtk_switch_portmask_P2L_get(pmask, pPortmask)) != RT_ERR_OK)
 105         return retVal;
 106
 107     return RT_ERR_OK;
 108
 109 }
 110
 111 /* Function Name:
 112  *      rtk_led_operation_set
 113  * Description:
 114  *      Set Led operation mode
 115  * Input:
 116  *      mode - LED operation mode.
 117  * Output:
 118  *      None
 119  * Return:
 120  *      RT_ERR_OK           - OK
 121  *      RT_ERR_FAILED       - Failed
 122  *      RT_ERR_SMI          - SMI access error
 123  *      RT_ERR_INPUT        - Invalid input parameters.
 124  * Note:
 125  *      The API can set Led operation mode.
 126  *      The modes that can be set are as following:
 127  *      - LED_OP_SCAN,
 128  *      - LED_OP_PARALLEL,
 129  *      - LED_OP_SERIAL,
 130  */
 131 rtk_api_ret_t rtk_led_operation_set(rtk_led_operation_t mode)
 132 {
 133     rtk_api_ret_t retVal;
 134     rtk_uint32 regData;
 135
 136     /* Check initialization state */
 137     RTK_CHK_INIT_STATE();
 138
 139     if ( mode >= LED_OP_END)
 140       return RT_ERR_INPUT;
 141
 142     switch (mode)
 143     {
 144         case LED_OP_PARALLEL:
 145             regData = LEDOP_PARALLEL;
 146             break;
 147         case LED_OP_SERIAL:
 148             regData = LEDOP_SERIAL;
 149             break;
 150         default:
 151             return RT_ERR_CHIP_NOT_SUPPORTED;
 152             break;
 153     }
 154
 155     if ((retVal = rtl8367c_setAsicLedOperationMode(regData)) != RT_ERR_OK)
 156         return retVal;
 157
 158     return RT_ERR_OK;
 159 }
 160
 161 /* Function Name:
 162  *      rtk_led_operation_get
 163  * Description:
 164  *      Get Led operation mode
 165  * Input:
 166  *      None
 167  * Output:
 168  *      pMode - Support LED operation mode.
 169  * Return:
 170  *      RT_ERR_OK           - OK
 171  *      RT_ERR_FAILED       - Failed
 172  *      RT_ERR_SMI          - SMI access error
 173  *      RT_ERR_INPUT        - Invalid input parameters.
 174  * Note:
 175  *      The API can get Led operation mode.
 176  *      The modes that can be set are as following:
 177  *      - LED_OP_SCAN,
 178  *      - LED_OP_PARALLEL,
 179  *      - LED_OP_SERIAL,
 180  */
 181 rtk_api_ret_t rtk_led_operation_get(rtk_led_operation_t *pMode)
 182 {
 183     rtk_api_ret_t retVal;
 184     rtk_uint32 regData;
 185
 186     /* Check initialization state */
 187     RTK_CHK_INIT_STATE();
 188
 189     if(NULL == pMode)
 190         return RT_ERR_NULL_POINTER;
 191
 192     if ((retVal = rtl8367c_getAsicLedOperationMode(&regData)) != RT_ERR_OK)
 193         return retVal;
 194
 195     if (regData == LEDOP_SERIAL)
 196         *pMode = LED_OP_SERIAL;
 197     else if (regData ==LEDOP_PARALLEL)
 198         *pMode = LED_OP_PARALLEL;
 199     else
 200        return RT_ERR_FAILED;
 201
 202     return RT_ERR_OK;
 203 }
 204
 205 /* Function Name:
 206  *      rtk_led_modeForce_set
 207  * Description:
 208  *      Set Led group to congiuration force mode
 209  * Input:
 210  *      port    - port ID
 211  *      group   - Support LED group id.
 212  *      mode    - Support LED force mode.
 213  * Output:
 214  *      None
 215  * Return:
 216  *      RT_ERR_OK           - OK
 217  *      RT_ERR_FAILED       - Failed
 218  *      RT_ERR_SMI          - SMI access error
 219  *      RT_ERR_INPUT        - Invalid input parameters.
 220  *      RT_ERR_PORT_ID      - Error Port ID
 221  * Note:
 222  *      The API can force to one force mode.
 223  *      The force modes that can be set are as following:
 224  *      - LED_FORCE_NORMAL,
 225  *      - LED_FORCE_BLINK,
 226  *      - LED_FORCE_OFF,
 227  *      - LED_FORCE_ON.
 228  */
 229 rtk_api_ret_t rtk_led_modeForce_set(rtk_port_t port, rtk_led_group_t group, rtk_led_force_mode_t mode)
 230 {
 231     rtk_api_ret_t retVal;
 232
 233     /* Check initialization state */
 234     RTK_CHK_INIT_STATE();
 235
 236     /* Check Port Valid */
 237     RTK_CHK_PORT_VALID(port);
 238
 239     /* No LED for CPU port */
 240     if(rtk_switch_isCPUPort(port) == RT_ERR_OK)
 241         return RT_ERR_PORT_ID;
 242
 243     if (group >= LED_GROUP_END)
 244         return RT_ERR_INPUT;
 245
 246     if (mode >= LED_FORCE_END)
 247         return RT_ERR_NOT_ALLOWED;
 248
 249     if ((retVal = rtl8367c_setAsicForceLed(rtk_switch_port_L2P_get(port), group, mode)) != RT_ERR_OK)
 250         return retVal;
 251
 252     return RT_ERR_OK;
 253 }
 254
 255 /* Function Name:
 256  *      rtk_led_modeForce_get
 257  * Description:
 258  *      Get Led group to congiuration force mode
 259  * Input:
 260  *      port  - port ID
 261  *      group - Support LED group id.
 262  *      pMode - Support LED force mode.
 263  * Output:
 264  *      None
 265  * Return:
 266  *      RT_ERR_OK           - OK
 267  *      RT_ERR_FAILED       - Failed
 268  *      RT_ERR_SMI          - SMI access error
 269  *      RT_ERR_INPUT        - Invalid input parameters.
 270  *      RT_ERR_PORT_ID      - Error Port ID
 271  * Note:
 272  *      The API can get forced Led group mode.
 273  *      The force modes that can be set are as following:
 274  *      - LED_FORCE_NORMAL,
 275  *      - LED_FORCE_BLINK,
 276  *      - LED_FORCE_OFF,
 277  *      - LED_FORCE_ON.
 278  */
 279 rtk_api_ret_t rtk_led_modeForce_get(rtk_port_t port, rtk_led_group_t group, rtk_led_force_mode_t *pMode)
 280 {
 281     rtk_api_ret_t retVal;
 282
 283     /* Check initialization state */
 284     RTK_CHK_INIT_STATE();
 285
 286     /* Check Port Valid */
 287     RTK_CHK_PORT_VALID(port);
 288
 289     /* No LED for CPU port */
 290     if(rtk_switch_isCPUPort(port) == RT_ERR_OK)
 291         return RT_ERR_PORT_ID;
 292
 293     if (group >= LED_GROUP_END)
 294         return RT_ERR_INPUT;
 295
 296     if (NULL == pMode)
 297         return RT_ERR_NULL_POINTER;
 298
 299     if ((retVal = rtl8367c_getAsicForceLed(rtk_switch_port_L2P_get(port), group, pMode)) != RT_ERR_OK)
 300         return retVal;
 301
 302     return RT_ERR_OK;
 303 }
 304
 305 /* Function Name:
 306  *      rtk_led_blinkRate_set
 307  * Description:
 308  *      Set LED blinking rate
 309  * Input:
 310  *      blinkRate - blinking rate.
 311  * Output:
 312  *      None
 313  * Return:
 314  *      RT_ERR_OK           - OK
 315  *      RT_ERR_FAILED       - Failed
 316  *      RT_ERR_SMI          - SMI access error
 317  *      RT_ERR_INPUT        - Invalid input parameters.
 318  * Note:
 319  *      ASIC support 6 types of LED blinking rates at 43ms, 84ms, 120ms, 170ms, 340ms and 670ms.
 320  */
 321 rtk_api_ret_t rtk_led_blinkRate_set(rtk_led_blink_rate_t blinkRate)
 322 {
 323     rtk_api_ret_t retVal;
 324
 325     /* Check initialization state */
 326     RTK_CHK_INIT_STATE();
 327
 328     if (blinkRate >= LED_BLINKRATE_END)
 329         return RT_ERR_FAILED;
 330
 331     if ((retVal = rtl8367c_setAsicLedBlinkRate(blinkRate)) != RT_ERR_OK)
 332         return retVal;
 333
 334     return RT_ERR_OK;
 335 }
 336
 337 /* Function Name:
 338  *      rtk_led_blinkRate_get
 339  * Description:
 340  *      Get LED blinking rate at mode 0 to mode 3
 341  * Input:
 342  *      None
 343  * Output:
 344  *      pBlinkRate - blinking rate.
 345  * Return:
 346  *      RT_ERR_OK           - OK
 347  *      RT_ERR_FAILED       - Failed
 348  *      RT_ERR_SMI          - SMI access error
 349  *      RT_ERR_INPUT        - Invalid input parameters.
 350  * Note:
 351  *      There are  6 types of LED blinking rates at 43ms, 84ms, 120ms, 170ms, 340ms and 670ms.
 352  */
 353 rtk_api_ret_t rtk_led_blinkRate_get(rtk_led_blink_rate_t *pBlinkRate)
 354 {
 355     rtk_api_ret_t retVal;
 356
 357     /* Check initialization state */
 358     RTK_CHK_INIT_STATE();
 359
 360     if(NULL == pBlinkRate)
 361         return RT_ERR_NULL_POINTER;
 362
 363     if ((retVal = rtl8367c_getAsicLedBlinkRate(pBlinkRate)) != RT_ERR_OK)
 364         return retVal;
 365
 366     return RT_ERR_OK;
 367 }
 368
 369 /* Function Name:
 370  *      rtk_led_groupConfig_set
 371  * Description:
 372  *      Set per group Led to congiuration mode
 373  * Input:
 374  *      group   - LED group.
 375  *      config  - LED configuration
 376  * Output:
 377  *      None
 378  * Return:
 379  *      RT_ERR_OK           - OK
 380  *      RT_ERR_FAILED       - Failed
 381  *      RT_ERR_SMI          - SMI access error
 382  *      RT_ERR_INPUT        - Invalid input parameters.
 383  * Note:
 384  *      The API can set LED indicated information configuration for each LED group with 1 to 1 led mapping to each port.
 385  *      - Definition  LED Statuses      Description
 386  *      - 0000        LED_Off           LED pin Tri-State.
 387  *      - 0001        Dup/Col           Collision, Full duplex Indicator.
 388  *      - 0010        Link/Act          Link, Activity Indicator.
 389  *      - 0011        Spd1000           1000Mb/s Speed Indicator.
 390  *      - 0100        Spd100            100Mb/s Speed Indicator.
 391  *      - 0101        Spd10             10Mb/s Speed Indicator.
 392  *      - 0110        Spd1000/Act       1000Mb/s Speed/Activity Indicator.
 393  *      - 0111        Spd100/Act        100Mb/s Speed/Activity Indicator.
 394  *      - 1000        Spd10/Act         10Mb/s Speed/Activity Indicator.
 395  *      - 1001        Spd100 (10)/Act   10/100Mb/s Speed/Activity Indicator.
 396  *      - 1010        LoopDetect        LoopDetect Indicator.
 397  *      - 1011        EEE               EEE Indicator.
 398  *      - 1100        Link/Rx           Link, Activity Indicator.
 399  *      - 1101        Link/Tx           Link, Activity Indicator.
 400  *      - 1110        Master            Link on Master Indicator.
 401  *      - 1111        Act               Activity Indicator. Low for link established.
 402  */
 403 rtk_api_ret_t rtk_led_groupConfig_set(rtk_led_group_t group, rtk_led_congig_t config)
 404 {
 405     rtk_api_ret_t retVal;
 406
 407     /* Check initialization state */
 408     RTK_CHK_INIT_STATE();
 409
 410     if (LED_GROUP_END <= group)
 411         return RT_ERR_FAILED;
 412
 413     if (LED_CONFIG_END <= config)
 414         return RT_ERR_FAILED;
 415
 416     if ((retVal = rtl8367c_setAsicLedIndicateInfoConfig(group, config)) != RT_ERR_OK)
 417         return retVal;
 418
 419     return RT_ERR_OK;
 420 }
 421
 422 /* Function Name:
 423  *      rtk_led_groupConfig_get
 424  * Description:
 425  *      Get Led group congiuration mode
 426  * Input:
 427  *      group - LED group.
 428  * Output:
 429  *      pConfig - LED configuration.
 430  * Return:
 431  *      RT_ERR_OK           - OK
 432  *      RT_ERR_FAILED       - Failed
 433  *      RT_ERR_SMI          - SMI access error
 434  *      RT_ERR_INPUT        - Invalid input parameters.
 435  * Note:
 436  *       The API can get LED indicated information configuration for each LED group.
 437  */
 438 rtk_api_ret_t rtk_led_groupConfig_get(rtk_led_group_t group, rtk_led_congig_t *pConfig)
 439 {
 440     rtk_api_ret_t retVal;
 441
 442     /* Check initialization state */
 443     RTK_CHK_INIT_STATE();
 444
 445     if (LED_GROUP_END <= group)
 446         return RT_ERR_FAILED;
 447
 448     if(NULL == pConfig)
 449         return RT_ERR_NULL_POINTER;
 450
 451     if ((retVal = rtl8367c_getAsicLedIndicateInfoConfig(group, pConfig)) != RT_ERR_OK)
 452         return retVal;
 453
 454     return RT_ERR_OK;
 455 }
 456
 457 /* Function Name:
 458  *      rtk_led_groupAbility_set
 459  * Description:
 460  *      Configure per group Led ability
 461  * Input:
 462  *      group    - LED group.
 463  *      pAbility - LED ability
 464  * Output:
 465  *      None
 466  * Return:
 467  *      RT_ERR_OK           - OK
 468  *      RT_ERR_FAILED       - Failed
 469  *      RT_ERR_SMI          - SMI access error
 470  *      RT_ERR_INPUT        - Invalid input parameters.
 471  * Note:
 472  *      None.
 473  */
 474
 475 rtk_api_ret_t rtk_led_groupAbility_set(rtk_led_group_t group, rtk_led_ability_t *pAbility)
 476 {
 477     rtk_api_ret_t retVal;
 478     rtk_uint32 regData;
 479
 480     /* Check initialization state */
 481     RTK_CHK_INIT_STATE();
 482
 483     if (LED_GROUP_END <= group)
 484         return RT_ERR_FAILED;
 485
 486     if(pAbility == NULL)
 487         return RT_ERR_NULL_POINTER;
 488
 489     if( (pAbility->link_10m >= RTK_ENABLE_END) || (pAbility->link_100m >= RTK_ENABLE_END)||
 490         (pAbility->link_500m >= RTK_ENABLE_END) || (pAbility->link_1000m >= RTK_ENABLE_END)||
 491         (pAbility->act_rx >= RTK_ENABLE_END) || (pAbility->act_tx >= RTK_ENABLE_END) )
 492     {
 493         return RT_ERR_INPUT;
 494     }
 495
 496     if ((retVal = rtl8367c_getAsicReg(RTL8367C_REG_LED0_DATA_CTRL + (rtk_uint32)group, &regData)) != RT_ERR_OK)
 497         return retVal;
 498
 499     if(pAbility->link_10m == ENABLED)
 500         regData |= 0x0001;
 501     else
 502         regData &= ~0x0001;
 503
 504     if(pAbility->link_100m == ENABLED)
 505         regData |= 0x0002;
 506     else
 507         regData &= ~0x0002;
 508
 509     if(pAbility->link_500m == ENABLED)
 510         regData |= 0x0004;
 511     else
 512         regData &= ~0x0004;
 513
 514     if(pAbility->link_1000m == ENABLED)
 515         regData |= 0x0008;
 516     else
 517         regData &= ~0x0008;
 518
 519     if(pAbility->act_rx == ENABLED)
 520         regData |= 0x0010;
 521     else
 522         regData &= ~0x0010;
 523
 524     if(pAbility->act_tx == ENABLED)
 525         regData |= 0x0020;
 526     else
 527         regData &= ~0x0020;
 528
 529     regData |= (0x0001 << 6);
 530
 531     if ((retVal = rtl8367c_setAsicReg(RTL8367C_REG_LED0_DATA_CTRL + (rtk_uint32)group, regData)) != RT_ERR_OK)
 532         return retVal;
 533
 534     return RT_ERR_OK;
 535 }
 536
 537 /* Function Name:
 538  *      rtk_led_groupAbility_get
 539  * Description:
 540  *      Get per group Led ability
 541  * Input:
 542  *      group    - LED group.
 543  *      pAbility - LED ability
 544  * Output:
 545  *      None
 546  * Return:
 547  *      RT_ERR_OK           - OK
 548  *      RT_ERR_FAILED       - Failed
 549  *      RT_ERR_SMI          - SMI access error
 550  *      RT_ERR_INPUT        - Invalid input parameters.
 551  * Note:
 552  *      None.
 553  */
 554
 555 rtk_api_ret_t rtk_led_groupAbility_get(rtk_led_group_t group, rtk_led_ability_t *pAbility)
 556 {
 557     rtk_api_ret_t retVal;
 558     rtk_uint32 regData;
 559
 560     /* Check initialization state */
 561     RTK_CHK_INIT_STATE();
 562
 563     if (LED_GROUP_END <= group)
 564         return RT_ERR_FAILED;
 565
 566     if(pAbility == NULL)
 567         return RT_ERR_NULL_POINTER;
 568
 569     if ((retVal = rtl8367c_getAsicReg(RTL8367C_REG_LED0_DATA_CTRL + (rtk_uint32)group, &regData)) != RT_ERR_OK)
 570         return retVal;
 571
 572     pAbility->link_10m = (regData & 0x0001) ? ENABLED : DISABLED;
 573     pAbility->link_100m = (regData & 0x0002) ? ENABLED : DISABLED;
 574     pAbility->link_500m = (regData & 0x0004) ? ENABLED : DISABLED;
 575     pAbility->link_1000m = (regData & 0x0008) ? ENABLED : DISABLED;
 576     pAbility->act_rx = (regData & 0x0010) ? ENABLED : DISABLED;
 577     pAbility->act_tx = (regData & 0x0020) ? ENABLED : DISABLED;
 578
 579     return RT_ERR_OK;
 580 }
 581
 582
 583 /* Function Name:
 584  *      rtk_led_serialMode_set
 585  * Description:
 586  *      Set Led serial mode active congiuration
 587  * Input:
 588  *      active - LED group.
 589  * Output:
 590  *      None
 591  * Return:
 592  *      RT_ERR_OK           - OK
 593  *      RT_ERR_FAILED       - Failed
 594  *      RT_ERR_SMI          - SMI access error
 595  *      RT_ERR_INPUT        - Invalid input parameters.
 596  * Note:
 597  *      The API can set LED serial mode active congiuration.
 598  */
 599 rtk_api_ret_t rtk_led_serialMode_set(rtk_led_active_t active)
 600 {
 601     rtk_api_ret_t retVal;
 602
 603     /* Check initialization state */
 604     RTK_CHK_INIT_STATE();
 605
 606     if ( active >= LED_ACTIVE_END)
 607         return RT_ERR_INPUT;
 608
 609      if ((retVal = rtl8367c_setAsicLedSerialModeConfig(active,1))!=RT_ERR_OK)
 610         return retVal;
 611
 612     return RT_ERR_OK;
 613 }
 614
 615 /* Function Name:
 616  *      rtk_led_serialMode_get
 617  * Description:
 618  *      Get Led group congiuration mode
 619  * Input:
 620  *      group - LED group.
 621  * Output:
 622  *      pConfig - LED configuration.
 623  * Return:
 624  *      RT_ERR_OK           - OK
 625  *      RT_ERR_FAILED       - Failed
 626  *      RT_ERR_SMI          - SMI access error
 627  *      RT_ERR_INPUT        - Invalid input parameters.
 628  * Note:
 629  *       The API can get LED serial mode active configuration.
 630  */
 631 rtk_api_ret_t rtk_led_serialMode_get(rtk_led_active_t *pActive)
 632 {
 633     rtk_api_ret_t retVal;
 634     rtk_uint32 regData;
 635
 636     /* Check initialization state */
 637     RTK_CHK_INIT_STATE();
 638
 639     if(NULL == pActive)
 640         return RT_ERR_NULL_POINTER;
 641
 642     if ((retVal = rtl8367c_getAsicLedSerialModeConfig(pActive,&regData))!=RT_ERR_OK)
 643         return retVal;
 644
 645     return RT_ERR_OK;
 646 }
 647
 648 /* Function Name:
 649  *      rtk_led_OutputEnable_set
 650  * Description:
 651  *      This API set LED I/O state.
 652  * Input:
 653  *      enabled     - LED I/O state
 654  * Output:
 655  *      None.
 656  * Return:
 657  *      RT_ERR_OK              - OK
 658  *      RT_ERR_FAILED          - Failed
 659  *      RT_ERR_SMI             - SMI access error
 660  *      RT_ERR_INPUT           - Error parameter
 661  * Note:
 662  *      This API set LED I/O state.
 663  */
 664 rtk_api_ret_t rtk_led_OutputEnable_set(rtk_enable_t state)
 665 {
 666     rtk_api_ret_t retVal;
 667
 668     /* Check initialization state */
 669     RTK_CHK_INIT_STATE();
 670
 671     if (state >= RTK_ENABLE_END)
 672         return RT_ERR_INPUT;
 673
 674     if ((retVal = rtl8367c_setAsicLedOutputEnable(state))!=RT_ERR_OK)
 675         return retVal;
 676
 677     return RT_ERR_OK;
 678 }
 679
 680 /* Function Name:
 681  *      rtk_led_OutputEnable_get
 682  * Description:
 683  *      This API get LED I/O state.
 684  * Input:
 685  *      None.
 686  * Output:
 687  *      pEnabled        - LED I/O state
 688  * Return:
 689  *      RT_ERR_OK              - OK
 690  *      RT_ERR_FAILED          - Failed
 691  *      RT_ERR_SMI             - SMI access error
 692  *      RT_ERR_INPUT           - Error parameter
 693  * Note:
 694  *      This API set current LED I/O  state.
 695  */
 696 rtk_api_ret_t rtk_led_OutputEnable_get(rtk_enable_t *pState)
 697 {
 698     rtk_api_ret_t retVal;
 699
 700     /* Check initialization state */
 701     RTK_CHK_INIT_STATE();
 702
 703     if(pState == NULL)
 704         return RT_ERR_NULL_POINTER;
 705
 706     if ((retVal = rtl8367c_getAsicLedOutputEnable(pState))!=RT_ERR_OK)
 707         return retVal;
 708
 709     return RT_ERR_OK;
 710
 711 }
 712
 713 /* Function Name:
 714  *      rtk_led_serialModePortmask_set
 715  * Description:
 716  *      This API configure Serial LED output Group and portmask
 717  * Input:
 718  *      output          - output group
 719  *      pPortmask       - output portmask
 720  * Output:
 721  *      None.
 722  * Return:
 723  *      RT_ERR_OK              - OK
 724  *      RT_ERR_FAILED          - Failed
 725  *      RT_ERR_SMI             - SMI access error
 726  *      RT_ERR_INPUT           - Error parameter
 727  * Note:
 728  *      None.
 729  */
 730 rtk_api_ret_t rtk_led_serialModePortmask_set(rtk_led_serialOutput_t output, rtk_portmask_t *pPortmask)
 731 {
 732     rtk_api_ret_t retVal;
 733     rtk_uint32 pmask;
 734
 735     /* Check initialization state */
 736     RTK_CHK_INIT_STATE();
 737
 738     if(output >= SERIAL_LED_END)
 739         return RT_ERR_INPUT;
 740
 741     if(pPortmask == NULL)
 742         return RT_ERR_NULL_POINTER;
 743
 744     if ((retVal = rtk_switch_portmask_L2P_get(pPortmask, &pmask)) != RT_ERR_OK)
 745         return retVal;
 746
 747     if ((retVal = rtl8367c_setAsicLedSerialOutput((rtk_uint32)output, pmask))!=RT_ERR_OK)
 748         return retVal;
 749
 750     return RT_ERR_OK;
 751 }
 752
 753 /* Function Name:
 754  *      rtk_led_serialModePortmask_get
 755  * Description:
 756  *      This API get Serial LED output Group and portmask
 757  * Input:
 758  *      None.
 759  * Output:
 760  *      pOutput         - output group
 761  *      pPortmask       - output portmask
 762  * Return:
 763  *      RT_ERR_OK              - OK
 764  *      RT_ERR_FAILED          - Failed
 765  *      RT_ERR_SMI             - SMI access error
 766  *      RT_ERR_INPUT           - Error parameter
 767  * Note:
 768  *      None.
 769  */
 770 rtk_api_ret_t rtk_led_serialModePortmask_get(rtk_led_serialOutput_t *pOutput, rtk_portmask_t *pPortmask)
 771 {
 772     rtk_api_ret_t retVal;
 773     rtk_uint32 pmask;
 774
 775     /* Check initialization state */
 776     RTK_CHK_INIT_STATE();
 777
 778     if(pOutput == NULL)
 779         return RT_ERR_NULL_POINTER;
 780
 781     if(pPortmask == NULL)
 782         return RT_ERR_NULL_POINTER;
 783
 784     if ((retVal = rtl8367c_getAsicLedSerialOutput((rtk_uint32 *)pOutput, &pmask))!=RT_ERR_OK)
 785         return retVal;
 786
 787     if((retVal = rtk_switch_portmask_P2L_get(pmask, pPortmask)) != RT_ERR_OK)
 788         return retVal;
 789
 790     return RT_ERR_OK;
 791 }
 792