target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_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 : RTL8367C switch high-level API for RTL8367C
  14  * Feature : LED related functions
  15  *
  16  */
  17 #include <rtl8367c_asicdrv_led.h>
  18 /* Function Name:
  19  *      rtl8367c_setAsicLedIndicateInfoConfig
  20  * Description:
  21  *      Set Leds indicated information mode
  22  * Input:
  23  *      ledno   - LED group number. There are 1 to 1 led mapping to each port in each led group
  24  *      config  - Support 16 types configuration
  25  * Output:
  26  *      None
  27  * Return:
  28  *      RT_ERR_OK           - Success
  29  *      RT_ERR_SMI          - SMI access error
  30  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
  31  * Note:
  32  *      The API can set LED indicated information configuration for each LED group with 1 to 1 led mapping to each port.
  33  *      Definition        LED Statuses            Description
  34  *      0000        LED_Off                LED pin Tri-State.
  35  *      0001        Dup/Col                Collision, Full duplex Indicator. Blinking every 43ms when collision happens. Low for full duplex, and high for half duplex mode.
  36  *      0010        Link/Act               Link, Activity Indicator. Low for link established. Link/Act Blinks every 43ms when the corresponding port is transmitting or receiving.
  37  *      0011        Spd1000                1000Mb/s Speed Indicator. Low for 1000Mb/s.
  38  *      0100        Spd100                 100Mb/s Speed Indicator. Low for 100Mb/s.
  39  *      0101        Spd10                  10Mb/s Speed Indicator. Low for 10Mb/s.
  40  *      0110        Spd1000/Act            1000Mb/s Speed/Activity Indicator. Low for 1000Mb/s. Blinks every 43ms when the corresponding port is transmitting or receiving.
  41  *      0111        Spd100/Act             100Mb/s Speed/Activity Indicator. Low for 100Mb/s. Blinks every 43ms when the corresponding port is transmitting or receiving.
  42  *      1000        Spd10/Act              10Mb/s Speed/Activity Indicator. Low for 10Mb/s. Blinks every 43ms when the corresponding port is transmitting or receiving.
  43  *      1001        Spd100 (10)/Act        10/100Mb/s Speed/Activity Indicator. Low for 10/100Mb/s. Blinks every 43ms when the corresponding port is transmitting or receiving.
  44  *      1010        Fiber                  Fiber link Indicator. Low for Fiber.
  45  *      1011        Fault                  Auto-negotiation     Fault Indicator. Low for Fault.
  46  *      1100        Link/Rx                Link, Activity Indicator. Low for link established. Link/Rx Blinks every 43ms when the corresponding port is transmitting.
  47  *      1101        Link/Tx                Link, Activity Indicator. Low for link established. Link/Tx Blinks every 43ms when the corresponding port is receiving.
  48  *      1110        Master                 Link on Master Indicator. Low for link Master established.
  49  *      1111        LED_Force              Force LED output, LED output value reference
  50  */
  51 ret_t rtl8367c_setAsicLedIndicateInfoConfig(rtk_uint32 ledno, rtk_uint32 config)
  52 {
  53     ret_t   retVal;
  54     CONST rtk_uint16 bits[RTL8367C_LEDGROUPNO] = {RTL8367C_LED0_CFG_MASK, RTL8367C_LED1_CFG_MASK, RTL8367C_LED2_CFG_MASK};
  55
  56     if(ledno >= RTL8367C_LEDGROUPNO)
  57         return RT_ERR_OUT_OF_RANGE;
  58
  59     if(config >= LEDCONF_END)
  60         return RT_ERR_OUT_OF_RANGE;
  61
  62     retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_CONFIGURATION, RTL8367C_LED_CONFIG_SEL_OFFSET, 0);
  63     if(retVal != RT_ERR_OK)
  64         return retVal;
  65
  66     return rtl8367c_setAsicRegBits(RTL8367C_REG_LED_CONFIGURATION, bits[ledno], config);
  67 }
  68 /* Function Name:
  69  *      rtl8367c_getAsicLedIndicateInfoConfig
  70  * Description:
  71  *      Get Leds indicated information mode
  72  * Input:
  73  *      ledno   - LED group number. There are 1 to 1 led mapping to each port in each led group
  74  *      pConfig     - Support 16 types configuration
  75  * Output:
  76  *      None
  77  * Return:
  78  *      RT_ERR_OK           - Success
  79  *      RT_ERR_SMI          - SMI access error
  80  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
  81  * Note:
  82  *      None
  83  */
  84 ret_t rtl8367c_getAsicLedIndicateInfoConfig(rtk_uint32 ledno, rtk_uint32* pConfig)
  85 {
  86     CONST rtk_uint16 bits[RTL8367C_LEDGROUPNO]= {RTL8367C_LED0_CFG_MASK, RTL8367C_LED1_CFG_MASK, RTL8367C_LED2_CFG_MASK};
  87
  88     if(ledno >= RTL8367C_LEDGROUPNO)
  89         return RT_ERR_OUT_OF_RANGE;
  90
  91     /* Get register value */
  92     return rtl8367c_getAsicRegBits(RTL8367C_REG_LED_CONFIGURATION, bits[ledno], pConfig);
  93 }
  94 /* Function Name:
  95  *      rtl8367c_setAsicLedGroupMode
  96  * Description:
  97  *      Set Led Group mode
  98  * Input:
  99  *      mode    - LED mode
 100  * Output:
 101  *      None
 102  * Return:
 103  *      RT_ERR_OK           - Success
 104  *      RT_ERR_SMI          - SMI access error
 105  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 106  * Note:
 107  *      None
 108  */
 109 ret_t rtl8367c_setAsicLedGroupMode(rtk_uint32 mode)
 110 {
 111     ret_t retVal;
 112
 113     /* Invalid input parameter */
 114     if(mode >= RTL8367C_LED_MODE_END)
 115         return RT_ERR_OUT_OF_RANGE;
 116
 117     retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_CONFIGURATION, RTL8367C_LED_CONFIG_SEL_OFFSET, 1);
 118     if(retVal != RT_ERR_OK)
 119         return retVal;
 120
 121     return rtl8367c_setAsicRegBits(RTL8367C_REG_LED_CONFIGURATION, RTL8367C_DATA_LED_MASK, mode);
 122 }
 123 /* Function Name:
 124  *      rtl8367c_getAsicLedGroupMode
 125  * Description:
 126  *      Get Led Group mode
 127  * Input:
 128  *      pMode   - LED mode
 129  * Output:
 130  *      None
 131  * Return:
 132  *      RT_ERR_OK   - Success
 133  *      RT_ERR_SMI  - SMI access error
 134  * Note:
 135  *      None
 136  */
 137 ret_t rtl8367c_getAsicLedGroupMode(rtk_uint32* pMode)
 138 {
 139     ret_t retVal;
 140     rtk_uint32 regData;
 141
 142     retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LED_CONFIGURATION, RTL8367C_LED_CONFIG_SEL_OFFSET, &regData);
 143     if(retVal != RT_ERR_OK)
 144         return retVal;
 145
 146     if(regData!=1)
 147         return RT_ERR_FAILED;
 148
 149     return rtl8367c_getAsicRegBits(RTL8367C_REG_LED_CONFIGURATION, RTL8367C_DATA_LED_MASK, pMode);
 150 }
 151 /* Function Name:
 152  *      rtl8367c_setAsicForceLeds
 153  * Description:
 154  *      Set group LED mode
 155  * Input:
 156  *      port    - Physical port number (0~7)
 157  *      group   - LED group number
 158  *      mode    - LED mode
 159  * Output:
 160  *      None
 161  * Return:
 162  *      RT_ERR_OK           - Success
 163  *      RT_ERR_SMI          - SMI access error
 164  *      RT_ERR_PORT_ID      - Invalid port number
 165  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 166  * Note:
 167  *      None
 168  */
 169 ret_t rtl8367c_setAsicForceLed(rtk_uint32 port, rtk_uint32 group, rtk_uint32 mode)
 170 {
 171     rtk_uint16 regAddr;
 172     ret_t retVal;
 173
 174     /* Invalid input parameter */
 175     if(port > RTL8367C_PORTIDMAX)
 176         return RT_ERR_PORT_ID;
 177
 178     if(group >= RTL8367C_LEDGROUPNO)
 179         return RT_ERR_OUT_OF_RANGE;
 180
 181     if(mode >= LEDFORCEMODE_END)
 182         return RT_ERR_OUT_OF_RANGE;
 183     /* Set Related Registers */
 184     if(port < 8){
 185         regAddr = RTL8367C_LED_FORCE_MODE_BASE + (group << 1);
 186         if((retVal = rtl8367c_setAsicRegBits(regAddr, 0x3 << (port * 2), mode)) != RT_ERR_OK)
 187             return retVal;
 188     }else if(port >= 8){
 189         regAddr = RTL8367C_REG_CPU_FORCE_LED0_CFG1 + (group << 1);
 190         if((retVal = rtl8367c_setAsicRegBits(regAddr, 0x3 << ((port-8) * 2), mode)) != RT_ERR_OK)
 191             return retVal;
 192     }
 193
 194     return RT_ERR_OK;
 195 }
 196 /* Function Name:
 197  *      rtl8367c_getAsicForceLed
 198  * Description:
 199  *      Get group LED mode
 200  * Input:
 201  *      port    - Physical port number (0~7)
 202  *      group   - LED group number
 203  *      pMode   - LED mode
 204  * Output:
 205  *      None
 206  * Return:
 207  *      RT_ERR_OK           - Success
 208  *      RT_ERR_SMI          - SMI access error
 209  *      RT_ERR_PORT_ID      - Invalid port number
 210  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 211  * Note:
 212  *      None
 213  */
 214 ret_t rtl8367c_getAsicForceLed(rtk_uint32 port, rtk_uint32 group, rtk_uint32* pMode)
 215 {
 216     rtk_uint16 regAddr;
 217     ret_t retVal;
 218
 219     /* Invalid input parameter */
 220     if(port > RTL8367C_PORTIDMAX)
 221         return RT_ERR_PORT_ID;
 222
 223     if(group >= RTL8367C_LEDGROUPNO)
 224         return RT_ERR_INPUT;
 225
 226     /* Get Related Registers */
 227     if(port < 8){
 228         regAddr = RTL8367C_LED_FORCE_MODE_BASE + (group << 1);
 229         if((retVal = rtl8367c_getAsicRegBits(regAddr, 0x3 << (port * 2), pMode)) != RT_ERR_OK)
 230             return retVal;
 231     }else if(port >= 8){
 232         regAddr = RTL8367C_REG_CPU_FORCE_LED0_CFG1 + (group << 1);
 233         if((retVal = rtl8367c_getAsicRegBits(regAddr, 0x3 << ((port-8) * 2), pMode)) != RT_ERR_OK)
 234             return retVal;
 235     }
 236
 237     return RT_ERR_OK;
 238 }
 239 /* Function Name:
 240  *      rtl8367c_setAsicForceGroupLed
 241  * Description:
 242  *      Turn on/off Led of all ports
 243  * Input:
 244  *      group   - LED group number
 245  *      mode    - 0b00:normal mode, 0b01:force blink, 0b10:force off, 0b11:force on
 246  * Output:
 247  *      None
 248  * Return:
 249  *      RT_ERR_OK           - Success
 250  *      RT_ERR_SMI          - SMI access error
 251  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 252  * Note:
 253  *      None
 254  */
 255 ret_t rtl8367c_setAsicForceGroupLed(rtk_uint32 groupmask, rtk_uint32 mode)
 256 {
 257     ret_t retVal;
 258     rtk_uint32 i,bitmask;
 259     CONST rtk_uint16 bits[3]= {0x0004,0x0010,0x0040};
 260
 261     /* Invalid input parameter */
 262     if(groupmask > RTL8367C_LEDGROUPMASK)
 263         return RT_ERR_OUT_OF_RANGE;
 264
 265     if(mode >= LEDFORCEMODE_END)
 266         return RT_ERR_OUT_OF_RANGE;
 267
 268     bitmask = 0;
 269     for(i = 0; i <  RTL8367C_LEDGROUPNO; i++)
 270     {
 271         if(groupmask & (1 << i))
 272         {
 273             bitmask = bitmask | bits[i];
 274         }
 275
 276     }
 277
 278     retVal = rtl8367c_setAsicRegBits(RTL8367C_LED_FORCE_CTRL, RTL8367C_LED_FORCE_MODE_MASK, bitmask);
 279
 280     retVal = rtl8367c_setAsicRegBits(RTL8367C_LED_FORCE_CTRL, RTL8367C_FORCE_MODE_MASK, mode);
 281
 282     if(LEDFORCEMODE_NORMAL == mode)
 283         retVal = rtl8367c_setAsicRegBits(RTL8367C_LED_FORCE_CTRL, RTL8367C_LED_FORCE_MODE_MASK, 0);
 284
 285     return retVal;
 286 }
 287 /* Function Name:
 288  *      rtl8367c_getAsicForceGroupLed
 289  * Description:
 290  *      Turn on/off Led of all ports
 291  * Input:
 292  *      group   - LED group number
 293  *      pMode   - 0b00:normal mode, 0b01:force blink, 0b10:force off, 0b11:force on
 294  * Output:
 295  *      None
 296  * Return:
 297  *      RT_ERR_OK           - Success
 298  *      RT_ERR_SMI          - SMI access error
 299  * Note:
 300  *      None
 301  */
 302 ret_t rtl8367c_getAsicForceGroupLed(rtk_uint32* groupmask, rtk_uint32* pMode)
 303 {
 304     ret_t retVal;
 305     rtk_uint32 i,regData;
 306     CONST rtk_uint16 bits[3] = {0x0004,0x0010,0x0040};
 307
 308     /* Get Related Registers */
 309     if((retVal = rtl8367c_getAsicRegBits(RTL8367C_LED_FORCE_CTRL, RTL8367C_LED_FORCE_MODE_MASK, &regData)) != RT_ERR_OK)
 310         return retVal;
 311
 312     for(i = 0; i< RTL8367C_LEDGROUPNO; i++)
 313     {
 314         if((regData & bits[i]) == bits[i])
 315         {
 316             *groupmask = *groupmask | (1 << i);
 317         }
 318     }
 319
 320     return rtl8367c_getAsicRegBits(RTL8367C_LED_FORCE_CTRL, RTL8367C_FORCE_MODE_MASK, pMode);
 321 }
 322 /* Function Name:
 323  *      rtl8367c_setAsicLedBlinkRate
 324  * Description:
 325  *      Set led blinking rate at mode 0 to mode 3
 326  * Input:
 327  *      blinkRate   - Support 6 blink rates
 328  * Output:
 329  *      None
 330  * Return:
 331  *      RT_ERR_OK           - Success
 332  *      RT_ERR_SMI          - SMI access error
 333  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 334  * Note:
 335  *      LED blink rate can be at 43ms, 84ms, 120ms, 170ms, 340ms and 670ms
 336  */
 337 ret_t rtl8367c_setAsicLedBlinkRate(rtk_uint32 blinkRate)
 338 {
 339     if(blinkRate >= LEDBLINKRATE_END)
 340         return RT_ERR_OUT_OF_RANGE;
 341
 342     return rtl8367c_setAsicRegBits(RTL8367C_REG_LED_MODE, RTL8367C_SEL_LEDRATE_MASK, blinkRate);
 343 }
 344 /* Function Name:
 345  *      rtl8367c_getAsicLedBlinkRate
 346  * Description:
 347  *      Get led blinking rate at mode 0 to mode 3
 348  * Input:
 349  *      pBlinkRate  - Support 6 blink rates
 350  * Output:
 351  *      None
 352  * Return:
 353  *      RT_ERR_OK           - Success
 354  *      RT_ERR_SMI          - SMI access error
 355  * Note:
 356  *      None
 357  */
 358 ret_t rtl8367c_getAsicLedBlinkRate(rtk_uint32* pBlinkRate)
 359 {
 360     return rtl8367c_getAsicRegBits(RTL8367C_REG_LED_MODE, RTL8367C_SEL_LEDRATE_MASK, pBlinkRate);
 361 }
 362 /* Function Name:
 363  *      rtl8367c_setAsicLedForceBlinkRate
 364  * Description:
 365  *      Set LEd blinking rate for force mode led
 366  * Input:
 367  *      blinkRate   - Support 6 blink rates
 368  * Output:
 369  *      None
 370  * Return:
 371  *      RT_ERR_OK           - Success
 372  *      RT_ERR_SMI          - SMI access error
 373  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 374  * Note:
 375  *      None
 376  */
 377 ret_t rtl8367c_setAsicLedForceBlinkRate(rtk_uint32 blinkRate)
 378 {
 379     if(blinkRate >= LEDFORCERATE_END)
 380         return RT_ERR_OUT_OF_RANGE;
 381
 382     return rtl8367c_setAsicRegBits(RTL8367C_REG_LED_MODE, RTL8367C_FORCE_RATE_MASK, blinkRate);
 383 }
 384 /* Function Name:
 385  *      rtl8367c_getAsicLedForceBlinkRate
 386  * Description:
 387  *      Get LED blinking rate for force mode led
 388  * Input:
 389  *      pBlinkRate  - Support 6 blink rates
 390  * Output:
 391  *      None
 392  * Return:
 393  *      RT_ERR_OK           - Success
 394  *      RT_ERR_SMI          - SMI access error
 395  * Note:
 396  *      None
 397  */
 398 ret_t rtl8367c_getAsicLedForceBlinkRate(rtk_uint32* pBlinkRate)
 399 {
 400      return rtl8367c_getAsicRegBits(RTL8367C_REG_LED_MODE, RTL8367C_FORCE_RATE_MASK, pBlinkRate);
 401 }
 402
 403 /*
 404 @func ret_t | rtl8367c_setAsicLedGroupEnable | Turn on/off Led of all system ports
 405 @parm rtk_uint32 | group | LED group id.
 406 @parm rtk_uint32 | portmask | LED port mask.
 407 @rvalue RT_ERR_OK | Success.
 408 @rvalue RT_ERR_SMI | SMI access error.
 409 @rvalue RT_ERR_PORT_ID | Invalid port number.
 410 @rvalue RT_ERR_INPUT | Invalid input value.
 411 @comm
 412     The API can turn on/off leds of dedicated port while indicated information configuration of LED group is set to force mode.
 413  */
 414 ret_t rtl8367c_setAsicLedGroupEnable(rtk_uint32 group, rtk_uint32 portmask)
 415 {
 416     ret_t retVal;
 417     rtk_uint32 regAddr;
 418     rtk_uint32 regDataMask;
 419
 420     if ( group >= RTL8367C_LEDGROUPNO )
 421         return RT_ERR_INPUT;
 422
 423     regAddr = RTL8367C_REG_PARA_LED_IO_EN1 + group/2;
 424     regDataMask = 0xFF << ((group%2)*8);
 425     retVal = rtl8367c_setAsicRegBits(regAddr, regDataMask, portmask&0xff);
 426     if(retVal != RT_ERR_OK)
 427         return retVal;
 428
 429     regAddr = RTL8367C_REG_PARA_LED_IO_EN3;
 430     regDataMask = 0x3 << (group*2);
 431     retVal = rtl8367c_setAsicRegBits(regAddr, regDataMask, (portmask>>8)&0x7);
 432     if(retVal != RT_ERR_OK)
 433         return retVal;
 434
 435
 436     return RT_ERR_OK;
 437 }
 438
 439 /*
 440 @func ret_t | rtl8367c_getAsicLedGroupEnable | Get on/off status of Led of all system ports
 441 @parm rtk_uint32 | group | LED group id.
 442 @parm rtk_uint32 | *portmask | LED port mask.
 443 @rvalue RT_ERR_OK | Success.
 444 @rvalue RT_ERR_SMI | SMI access error.
 445 @rvalue RT_ERR_PORT_ID | Invalid port number.
 446 @rvalue RT_ERR_INPUT | Invalid input value.
 447 @comm
 448     The API can turn on/off leds of dedicated port while indicated information configuration of LED group is set to force mode.
 449  */
 450 ret_t rtl8367c_getAsicLedGroupEnable(rtk_uint32 group, rtk_uint32 *portmask)
 451 {
 452     ret_t retVal;
 453     rtk_uint32 regAddr;
 454     rtk_uint32 regDataMask,regData;
 455
 456     if ( group >= RTL8367C_LEDGROUPNO )
 457         return RT_ERR_INPUT;
 458
 459     regAddr = RTL8367C_REG_PARA_LED_IO_EN1 + group/2;
 460     regDataMask = 0xFF << ((group%2)*8);
 461     retVal = rtl8367c_getAsicRegBits(regAddr, regDataMask, portmask);
 462     if(retVal != RT_ERR_OK)
 463         return retVal;
 464
 465
 466     regAddr = RTL8367C_REG_PARA_LED_IO_EN3;
 467     regDataMask = 0x3 << (group*2);
 468     retVal = rtl8367c_getAsicRegBits(regAddr, regDataMask, &regData);
 469     if(retVal != RT_ERR_OK)
 470         return retVal;
 471
 472     *portmask = (regData << 8) | *portmask;
 473
 474     return RT_ERR_OK;
 475 }
 476
 477 /*
 478 @func ret_t | rtl8367c_setAsicLedOperationMode | Set LED operation mode
 479 @parm rtk_uint32 | mode | LED mode. 1:scan mode 1, 2:parallel mode, 3:mdx mode (serial mode)
 480 @rvalue RT_ERR_OK | Success.
 481 @rvalue RT_ERR_SMI | SMI access error.
 482 @rvalue RT_ERR_INPUT | Invalid input value.
 483 @comm
 484     The API can turn on/off led serial mode and set signal to active high/low.
 485  */
 486 ret_t rtl8367c_setAsicLedOperationMode(rtk_uint32 mode)
 487 {
 488     ret_t retVal;
 489
 490     /* Invalid input parameter */
 491     if( mode >= LEDOP_END)
 492         return RT_ERR_INPUT;
 493
 494     switch(mode)
 495     {
 496         case LEDOP_PARALLEL:
 497             if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_LED_SELECT_OFFSET, 0))!=  RT_ERR_OK)
 498                 return retVal;
 499             /*Disable serial CLK mode*/
 500             if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SCAN0_LED_IO_EN1,RTL8367C_LED_SERI_CLK_EN_OFFSET, 0))!=  RT_ERR_OK)
 501                 return retVal;
 502             /*Disable serial DATA mode*/
 503             if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SCAN0_LED_IO_EN1,RTL8367C_LED_SERI_DATA_EN_OFFSET, 0))!=  RT_ERR_OK)
 504                 return retVal;
 505             break;
 506         case LEDOP_SERIAL:
 507             if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_LED_SELECT_OFFSET, 1))!=  RT_ERR_OK)
 508                 return retVal;
 509             /*Enable serial CLK mode*/
 510             if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SCAN0_LED_IO_EN1,RTL8367C_LED_SERI_CLK_EN_OFFSET, 1))!=  RT_ERR_OK)
 511                 return retVal;
 512             /*Enable serial DATA mode*/
 513             if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_SCAN0_LED_IO_EN1,RTL8367C_LED_SERI_DATA_EN_OFFSET, 1))!=  RT_ERR_OK)
 514                 return retVal;
 515             break;
 516         default:
 517             return RT_ERR_INPUT;
 518             break;
 519     }
 520
 521     return RT_ERR_OK;
 522 }
 523
 524
 525 /*
 526 @func ret_t | rtl8367c_getAsicLedOperationMode | Get LED OP mode setup
 527 @parm rtk_uint32*| mode | LED mode. 1:scan mode 1, 2:parallel mode, 3:mdx mode (serial mode)
 528 @rvalue RT_ERR_OK | Success.
 529 @rvalue RT_ERR_SMI | SMI access error.
 530 @rvalue RT_ERR_INPUT | Invalid input value.
 531 @comm
 532     The API can get LED serial mode setup and get signal active high/low.
 533  */
 534 ret_t rtl8367c_getAsicLedOperationMode(rtk_uint32 *mode)
 535 {
 536     ret_t retVal;
 537     rtk_uint32 regData;
 538
 539     if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_LED_SELECT_OFFSET, &regData))!=  RT_ERR_OK)
 540         return retVal;
 541
 542     if (regData == 1)
 543         *mode = LEDOP_SERIAL;
 544     else if (regData == 0)
 545         *mode = LEDOP_PARALLEL;
 546     else
 547         return RT_ERR_FAILED;
 548
 549     return RT_ERR_OK;
 550 }
 551
 552 /*
 553 @func ret_t | rtl8367c_setAsicLedSerialModeConfig | Set LED serial mode
 554 @parm rtk_uint32 | active | Active High or Low.
 555 @rvalue RT_ERR_OK | Success.
 556 @rvalue RT_ERR_SMI | SMI access error.
 557 @rvalue RT_ERR_INPUT | Invalid input value.
 558 @comm
 559     The API can turn on/off led serial mode and set signal to active high/low.
 560  */
 561 ret_t rtl8367c_setAsicLedSerialModeConfig(rtk_uint32 active, rtk_uint32 serimode)
 562 {
 563     ret_t retVal;
 564
 565     /* Invalid input parameter */
 566     if( active >= LEDSERACT_MAX)
 567         return RT_ERR_INPUT;
 568     if( serimode >= LEDSER_MAX)
 569         return RT_ERR_INPUT;
 570
 571     /* Set Active High or Low */
 572     if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_SERI_LED_ACT_LOW_OFFSET, active)) !=  RT_ERR_OK)
 573         return retVal;
 574
 575     /*set to 8G mode (not 16G mode)*/
 576     if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_MODE, RTL8367C_DLINK_TIME_OFFSET, serimode))!=  RT_ERR_OK)
 577         return retVal;
 578
 579
 580     return RT_ERR_OK;
 581 }
 582
 583
 584 /*
 585 @func ret_t | rtl8367c_getAsicLedSerialModeConfig | Get LED serial mode setup
 586 @parm rtk_uint32*| active | Active High or Low.
 587 @rvalue RT_ERR_OK | Success.
 588 @rvalue RT_ERR_SMI | SMI access error.
 589 @rvalue RT_ERR_INPUT | Invalid input value.
 590 @comm
 591     The API can get LED serial mode setup and get signal active high/low.
 592  */
 593 ret_t rtl8367c_getAsicLedSerialModeConfig(rtk_uint32 *active, rtk_uint32 *serimode)
 594 {
 595     ret_t retVal;
 596
 597     if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_SERI_LED_ACT_LOW_OFFSET, active))!=  RT_ERR_OK)
 598         return retVal;
 599
 600     /*get to 8G mode (not 16G mode)*/
 601     if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LED_MODE, RTL8367C_DLINK_TIME_OFFSET, serimode))!=  RT_ERR_OK)
 602         return retVal;
 603
 604     return RT_ERR_OK;
 605 }
 606
 607
 608 /*
 609 @func ret_t | rtl8367c_setAsicLedOutputEnable | Set LED output enable
 610 @parm rtk_uint32 | enabled | enable or disalbe.
 611 @rvalue RT_ERR_OK | Success.
 612 @rvalue RT_ERR_SMI | SMI access error.
 613 @rvalue RT_ERR_INPUT | Invalid input value.
 614 @comm
 615     The API can turn on/off LED output Enable
 616  */
 617 ret_t rtl8367c_setAsicLedOutputEnable(rtk_uint32 enabled)
 618 {
 619     ret_t retVal;
 620     rtk_uint32 regdata;
 621
 622     if (enabled == 1)
 623         regdata = 0;
 624     else
 625         regdata = 1;
 626
 627     /* Enable/Disable H/W IGMP/MLD */
 628     retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_LED_IO_DISABLE_OFFSET, regdata);
 629
 630     return retVal;
 631 }
 632
 633
 634 /*
 635 @func ret_t | rtl8367c_getAsicLedOutputEnable | Get LED serial mode setup
 636 @parm rtk_uint32*| active | Active High or Low.
 637 @rvalue RT_ERR_OK | Success.
 638 @rvalue RT_ERR_SMI | SMI access error.
 639 @rvalue RT_ERR_INPUT | Invalid input value.
 640 @comm
 641     The API can get LED serial mode setup and get signal active high/low.
 642  */
 643 ret_t rtl8367c_getAsicLedOutputEnable(rtk_uint32 *ptr_enabled)
 644 {
 645     ret_t retVal;
 646     rtk_uint32 regdata;
 647
 648     retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LED_SYS_CONFIG, RTL8367C_LED_IO_DISABLE_OFFSET, &regdata);
 649     if (retVal != RT_ERR_OK)
 650         return retVal;
 651
 652     if (regdata == 1)
 653         *ptr_enabled = 0;
 654     else
 655         *ptr_enabled = 1;
 656
 657     return RT_ERR_OK;
 658 }
 659
 660 /* Function Name:
 661  *      rtl8367c_setAsicLedSerialOutput
 662  * Description:
 663  *      Set serial LED output group and portmask.
 664  * Input:
 665  *      output      - Serial LED output group
 666  *      pmask       - Serial LED output portmask
 667  * Output:
 668  *      None
 669  * Return:
 670  *      RT_ERR_OK           - Success
 671  *      RT_ERR_SMI          - SMI access error
 672  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 673  * Note:
 674  *      None
 675  */
 676 ret_t rtl8367c_setAsicLedSerialOutput(rtk_uint32 output, rtk_uint32 pmask)
 677 {
 678     ret_t retVal;
 679
 680     retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SERIAL_LED_CTRL, RTL8367C_SERIAL_LED_GROUP_NUM_MASK, output);
 681     if (retVal != RT_ERR_OK)
 682         return retVal;
 683
 684     retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SERIAL_LED_CTRL, RTL8367C_SERIAL_LED_PORT_EN_MASK, pmask);
 685     if (retVal != RT_ERR_OK)
 686         return retVal;
 687
 688     return RT_ERR_OK;
 689 }
 690
 691 /* Function Name:
 692  *      rtl8367c_getAsicLedSerialOutput
 693  * Description:
 694  *      Get serial LED output group and portmask.
 695  * Input:
 696  *      None
 697  * Output:
 698  *      pOutput      - Serial LED output group
 699  *      pPmask       - Serial LED output portmask
 700  * Return:
 701  *      RT_ERR_OK           - Success
 702  *      RT_ERR_SMI          - SMI access error
 703  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 704  * Note:
 705  *      None
 706  */
 707 ret_t rtl8367c_getAsicLedSerialOutput(rtk_uint32 *pOutput, rtk_uint32 *pPmask)
 708 {
 709     ret_t retVal;
 710
 711     if(pOutput == NULL)
 712         return RT_ERR_NULL_POINTER;
 713
 714     if(pPmask == NULL)
 715         return RT_ERR_NULL_POINTER;
 716
 717     retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SERIAL_LED_CTRL, RTL8367C_SERIAL_LED_GROUP_NUM_MASK, pOutput);
 718     if (retVal != RT_ERR_OK)
 719         return retVal;
 720
 721     retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SERIAL_LED_CTRL, RTL8367C_SERIAL_LED_PORT_EN_MASK, pPmask);
 722     if (retVal != RT_ERR_OK)
 723         return retVal;
 724
 725     return RT_ERR_OK;
 726 }
 727