target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_rldp.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: 42321 $
  11  * $Date: 2013-08-26 13:51:29 +0800 (週一, 26 八月 2013) $
  12  *
  13  * Purpose : RTL8367C switch high-level API for RTL8367C
  14  * Feature : RLDP related functions
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv_rldp.h>
  19 /* Function Name:
  20  *      rtl8367c_setAsicRldp
  21  * Description:
  22  *      Set RLDP function enable/disable
  23  * Input:
  24  *      enabled     - 1: enabled, 0: disabled
  25  * Output:
  26  *      None
  27  * Return:
  28  *      RT_ERR_OK   - Success
  29  *      RT_ERR_SMI  - SMI access error
  30  * Note:
  31  *      None
  32  */
  33 ret_t rtl8367c_setAsicRldp(rtk_uint32 enabled)
  34 {
  35     return rtl8367c_setAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_ENABLE_OFFSET, enabled);
  36 }
  37 /* Function Name:
  38  *      rtl8367c_getAsicRldp
  39  * Description:
  40  *      Get RLDP function enable/disable
  41  * Input:
  42  *      pEnabled    - 1: enabled, 0: disabled
  43  * Output:
  44  *      None
  45  * Return:
  46  *      RT_ERR_OK   - Success
  47  *      RT_ERR_SMI  - SMI access error
  48  * Note:
  49  *      None
  50  */
  51 ret_t rtl8367c_getAsicRldp(rtk_uint32 *pEnabled)
  52 {
  53     return rtl8367c_getAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_ENABLE_OFFSET, pEnabled);
  54 }
  55 /* Function Name:
  56  *      rtl8367c_setAsicRldpEnable8051
  57  * Description:
  58  *      Set RLDP function handled by ASIC or 8051
  59  * Input:
  60  *      enabled     - 1: enabled 8051, 0: disabled 8051 (RLDP is handled by ASIC)
  61  * Output:
  62  *      None
  63  * Return:
  64  *      RT_ERR_OK   - Success
  65  *      RT_ERR_SMI  - SMI access error
  66  * Note:
  67  *      None
  68  */
  69 ret_t rtl8367c_setAsicRldpEnable8051(rtk_uint32 enabled)
  70 {
  71     return rtl8367c_setAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_8051_ENABLE_OFFSET, enabled);
  72 }
  73 /* Function Name:
  74  *      rtl8367c_setAsicRldrtl8367c_getAsicRldpEnable8051pEnable8051
  75  * Description:
  76  *      Get RLDP function handled by ASIC or 8051
  77  * Input:
  78  *      pEnabled    - 1: enabled 8051, 0: disabled 8051 (RLDP is handled by ASIC)
  79  * Output:
  80  *      None
  81  * Return:
  82  *      RT_ERR_OK   - Success
  83  *      RT_ERR_SMI  - SMI access error
  84  * Note:
  85  *      None
  86  */
  87 ret_t rtl8367c_getAsicRldpEnable8051(rtk_uint32 *pEnabled)
  88 {
  89     return rtl8367c_getAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_8051_ENABLE_OFFSET, pEnabled);
  90 }
  91 /* Function Name:
  92  *      rtl8367c_setAsicRldpCompareRandomNumber
  93  * Description:
  94  *      Set enable compare the random number field and seed field of RLDP frame
  95  * Input:
  96  *      enabled     - 1: enabled comparing random number, 0: disabled comparing random number
  97  * Output:
  98  *      None
  99  * Return:
 100  *      RT_ERR_OK   - Success
 101  *      RT_ERR_SMI  - SMI access error
 102  * Note:
 103  *      None
 104  */
 105 ret_t rtl8367c_setAsicRldpCompareRandomNumber(rtk_uint32 enabled)
 106 {
 107     return rtl8367c_setAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_COMP_ID_OFFSET, enabled);
 108 }
 109 /* Function Name:
 110  *      rtl8367c_getAsicRldpCompareRandomNumber
 111  * Description:
 112  *      Get enable compare the random number field and seed field of RLDP frame
 113  * Input:
 114  *      pEnabled    - 1: enabled comparing random number, 0: disabled comparing random number
 115  * Output:
 116  *      None
 117  * Return:
 118  *      RT_ERR_OK   - Success
 119  *      RT_ERR_SMI  - SMI access error
 120  * Note:
 121  *      None
 122  */
 123 ret_t rtl8367c_getAsicRldpCompareRandomNumber(rtk_uint32 *pEnabled)
 124 {
 125     return rtl8367c_getAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_COMP_ID_OFFSET, pEnabled);
 126 }
 127 /* Function Name:
 128  *      rtl8367c_setAsicRldpIndicatorSource
 129  * Description:
 130  *      Set buzzer and LED source when detecting a loop
 131  * Input:
 132  *      src     - 0: ASIC, 1: 8051
 133  * Output:
 134  *      None
 135  * Return:
 136  *      RT_ERR_OK   - Success
 137  *      RT_ERR_SMI  - SMI access error
 138  * Note:
 139  *      None
 140  */
 141 ret_t rtl8367c_setAsicRldpIndicatorSource(rtk_uint32 src)
 142 {
 143     return rtl8367c_setAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_INDICATOR_SOURCE_OFFSET, src);
 144 }
 145 /* Function Name:
 146  *      rtl8367c_getAsicRldpIndicatorSource
 147  * Description:
 148  *      Get buzzer and LED source when detecting a loop
 149  * Input:
 150  *      pSrc    - 0: ASIC, 1: 8051
 151  * Output:
 152  *      None
 153  * Return:
 154  *      RT_ERR_OK   - Success
 155  *      RT_ERR_SMI  - SMI access error
 156  * Note:
 157  *      None
 158  */
 159 ret_t rtl8367c_getAsicRldpIndicatorSource(rtk_uint32 *pSrc)
 160 {
 161     return rtl8367c_getAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_INDICATOR_SOURCE_OFFSET, pSrc);
 162 }
 163 /* Function Name:
 164  *      rtl8367c_setAsicRldpCheckingStatePara
 165  * Description:
 166  *      Set retry count and retry period of checking state
 167  * Input:
 168  *      retryCount  - 0~0xFF (times)
 169  *      retryPeriod - 0~0xFFFF (ms)
 170  * Output:
 171  *      None
 172  * Return:
 173  *      RT_ERR_OK           - Success
 174  *      RT_ERR_SMI          - SMI access error
 175  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 176  * Note:
 177  *      None
 178  */
 179 ret_t rtl8367c_setAsicRldpCheckingStatePara(rtk_uint32 retryCount, rtk_uint32 retryPeriod)
 180 {
 181     ret_t retVal;
 182
 183     if(retryCount > 0xFF)
 184         return RT_ERR_OUT_OF_RANGE;
 185     if(retryPeriod > RTL8367C_REGDATAMAX)
 186         return RT_ERR_OUT_OF_RANGE;
 187
 188     retVal = rtl8367c_setAsicRegBits(RTL8367C_RLDP_RETRY_COUNT_REG, RTL8367C_RLDP_RETRY_COUNT_CHKSTATE_MASK, retryCount);
 189     if(retVal != RT_ERR_OK)
 190         return retVal;
 191
 192     return rtl8367c_setAsicReg(RTL8367C_RLDP_RETRY_PERIOD_CHKSTATE_REG, retryPeriod);
 193 }
 194 /* Function Name:
 195  *      rtl8367c_getAsicRldpCheckingStatePara
 196  * Description:
 197  *      Get retry count and retry period of checking state
 198  * Input:
 199  *      pRetryCount     - 0~0xFF (times)
 200  *      pRetryPeriod    - 0~0xFFFF (ms)
 201  * Output:
 202  *      None
 203  * Return:
 204  *      RT_ERR_OK           - Success
 205  *      RT_ERR_SMI          - SMI access error
 206  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 207  * Note:
 208  *      None
 209  */
 210 ret_t rtl8367c_getAsicRldpCheckingStatePara(rtk_uint32 *pRetryCount, rtk_uint32 *pRetryPeriod)
 211 {
 212     ret_t retVal;
 213
 214     retVal = rtl8367c_getAsicRegBits(RTL8367C_RLDP_RETRY_COUNT_REG, RTL8367C_RLDP_RETRY_COUNT_CHKSTATE_MASK, pRetryCount);
 215     if(retVal != RT_ERR_OK)
 216         return retVal;
 217
 218     return rtl8367c_getAsicReg(RTL8367C_RLDP_RETRY_PERIOD_CHKSTATE_REG, pRetryPeriod);
 219 }
 220 /* Function Name:
 221  *      rtl8367c_setAsicRldpLoopStatePara
 222  * Description:
 223  *      Set retry count and retry period of loop state
 224  * Input:
 225  *      retryCount  - 0~0xFF (times)
 226  *      retryPeriod - 0~0xFFFF (ms)
 227  * Output:
 228  *      None
 229  * Return:
 230  *      RT_ERR_OK           - Success
 231  *      RT_ERR_SMI          - SMI access error
 232  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 233  * Note:
 234  *      None
 235  */
 236 ret_t rtl8367c_setAsicRldpLoopStatePara(rtk_uint32 retryCount, rtk_uint32 retryPeriod)
 237 {
 238     ret_t retVal;
 239
 240     if(retryCount > 0xFF)
 241         return RT_ERR_OUT_OF_RANGE;
 242
 243     if(retryPeriod > RTL8367C_REGDATAMAX)
 244         return RT_ERR_OUT_OF_RANGE;
 245
 246     retVal = rtl8367c_setAsicRegBits(RTL8367C_RLDP_RETRY_COUNT_REG, RTL8367C_RLDP_RETRY_COUNT_LOOPSTATE_MASK, retryCount);
 247     if(retVal != RT_ERR_OK)
 248         return retVal;
 249
 250     return rtl8367c_setAsicReg(RTL8367C_RLDP_RETRY_PERIOD_LOOPSTATE_REG, retryPeriod);
 251 }
 252 /* Function Name:
 253  *      rtl8367c_getAsicRldpLoopStatePara
 254  * Description:
 255  *      Get retry count and retry period of loop state
 256  * Input:
 257  *      pRetryCount     - 0~0xFF (times)
 258  *      pRetryPeriod    - 0~0xFFFF (ms)
 259  * Output:
 260  *      None
 261  * Return:
 262  *      RT_ERR_OK           - Success
 263  *      RT_ERR_SMI          - SMI access error
 264  *      RT_ERR_OUT_OF_RANGE - input parameter out of range
 265  * Note:
 266  *      None
 267  */
 268 ret_t rtl8367c_getAsicRldpLoopStatePara(rtk_uint32 *pRetryCount, rtk_uint32 *pRetryPeriod)
 269 {
 270     ret_t retVal;
 271
 272     retVal = rtl8367c_getAsicRegBits(RTL8367C_RLDP_RETRY_COUNT_REG, RTL8367C_RLDP_RETRY_COUNT_LOOPSTATE_MASK, pRetryCount);
 273     if(retVal != RT_ERR_OK)
 274         return retVal;
 275
 276     return rtl8367c_getAsicReg(RTL8367C_RLDP_RETRY_PERIOD_LOOPSTATE_REG, pRetryPeriod);
 277 }
 278 /* Function Name:
 279  *      rtl8367c_setAsicRldpTxPortmask
 280  * Description:
 281  *      Set portmask that send/forward RLDP frame
 282  * Input:
 283  *      portmask    - 0~0xFF
 284  * Output:
 285  *      None
 286  * Return:
 287  *      RT_ERR_OK           - Success
 288  *      RT_ERR_SMI          - SMI access error
 289  *      RT_ERR_PORT_MASK    - Invalid portmask
 290  * Note:
 291  *      None
 292  */
 293 ret_t rtl8367c_setAsicRldpTxPortmask(rtk_uint32 portmask)
 294 {
 295     if(portmask > RTL8367C_PORTMASK)
 296         return RT_ERR_PORT_MASK;
 297
 298     return rtl8367c_setAsicReg(RTL8367C_RLDP_TX_PMSK_REG, portmask);
 299 }
 300 /* Function Name:
 301  *      rtl8367c_getAsicRldpTxPortmask
 302  * Description:
 303  *      Get portmask that send/forward RLDP frame
 304  * Input:
 305  *      pPortmask   - 0~0xFF
 306  * Output:
 307  *      None
 308  * Return:
 309  *      RT_ERR_OK   - Success
 310  *      RT_ERR_SMI  - SMI access error
 311  * Note:
 312  *      None
 313  */
 314 ret_t rtl8367c_getAsicRldpTxPortmask(rtk_uint32 *pPortmask)
 315 {
 316     return rtl8367c_getAsicReg(RTL8367C_RLDP_TX_PMSK_REG, pPortmask);
 317 }
 318 /* Function Name:
 319  *      rtl8367c_setAsicRldpMagicNum
 320  * Description:
 321  *      Set Random seed of RLDP
 322  * Input:
 323  *      seed    - MAC
 324  * Output:
 325  *      None
 326  * Return:
 327  *      RT_ERR_OK   - Success
 328  *      RT_ERR_SMI  - SMI access error
 329  * Note:
 330  *      None
 331  */
 332 ret_t rtl8367c_setAsicRldpMagicNum(ether_addr_t seed)
 333 {
 334     ret_t retVal;
 335     rtk_uint32 regData;
 336     rtk_uint16 *accessPtr;
 337     rtk_uint32 i;
 338
 339     accessPtr = (rtk_uint16*)&seed;
 340
 341     for (i = 0; i < 3; i++)
 342     {
 343         regData = *accessPtr;
 344         retVal = rtl8367c_setAsicReg(RTL8367C_RLDP_MAGIC_NUM_REG_BASE + i, regData);
 345         if(retVal != RT_ERR_OK)
 346             return retVal;
 347
 348         accessPtr++;
 349     }
 350
 351     return retVal;
 352 }
 353 /* Function Name:
 354  *      rtl8367c_getAsicRldpMagicNum
 355  * Description:
 356  *      Get Random seed of RLDP
 357  * Input:
 358  *      pSeed   - MAC
 359  * Output:
 360  *      None
 361  * Return:
 362  *      RT_ERR_OK   - Success
 363  *      RT_ERR_SMI  - SMI access error
 364  * Note:
 365  *      None
 366  */
 367 ret_t rtl8367c_getAsicRldpMagicNum(ether_addr_t *pSeed)
 368 {
 369     ret_t retVal;
 370     rtk_uint32 regData;
 371     rtk_uint16 *accessPtr;
 372     rtk_uint32 i;
 373
 374     accessPtr = (rtk_uint16*)pSeed;
 375
 376     for(i = 0; i < 3; i++)
 377     {
 378         retVal = rtl8367c_getAsicReg(RTL8367C_RLDP_MAGIC_NUM_REG_BASE + i, &regData);
 379         if(retVal != RT_ERR_OK)
 380             return retVal;
 381
 382         *accessPtr = regData;
 383         accessPtr++;
 384     }
 385
 386     return retVal;
 387 }
 388
 389 /* Function Name:
 390  *      rtl8367c_getAsicRldpLoopedPortmask
 391  * Description:
 392  *      Get looped portmask
 393  * Input:
 394  *      pPortmask   - 0~0xFF
 395  * Output:
 396  *      None
 397  * Return:
 398  *      RT_ERR_OK   - Success
 399  *      RT_ERR_SMI  - SMI access error
 400  * Note:
 401  *      None
 402  */
 403 ret_t rtl8367c_getAsicRldpLoopedPortmask(rtk_uint32 *pPortmask)
 404 {
 405     return rtl8367c_getAsicReg(RTL8367C_RLDP_LOOP_PMSK_REG, pPortmask);
 406 }
 407 /* Function Name:
 408  *      rtl8367c_getAsicRldpRandomNumber
 409  * Description:
 410  *      Get Random number of RLDP
 411  * Input:
 412  *      pRandNumber     - MAC
 413  * Output:
 414  *      None
 415  * Return:
 416  *      RT_ERR_OK   - Success
 417  *      RT_ERR_SMI  - SMI access error
 418  * Note:
 419  *      None
 420  */
 421 ret_t rtl8367c_getAsicRldpRandomNumber(ether_addr_t *pRandNumber)
 422 {
 423     ret_t retVal;
 424     rtk_uint32 regData;
 425     rtk_int16 accessPtr[3];
 426     rtk_uint32 i;
 427
 428     for(i = 0; i < 3; i++)
 429     {
 430         retVal = rtl8367c_getAsicReg(RTL8367C_RLDP_RAND_NUM_REG_BASE+ i, &regData);
 431         if(retVal != RT_ERR_OK)
 432             return retVal;
 433
 434         accessPtr[i] = regData;
 435     }
 436
 437     memcpy(pRandNumber, accessPtr, 6);
 438     return retVal;
 439 }
 440 /* Function Name:
 441  *      rtl8367c_getAsicRldpLoopedPortmask
 442  * Description:
 443  *      Get port number of looped pair
 444  * Input:
 445  *      port        - Physical port number (0~7)
 446  *      pLoopedPair     - port (0~7)
 447  * Output:
 448  *      None
 449  * Return:
 450  *      RT_ERR_OK       - Success
 451  *      RT_ERR_SMI      - SMI access error
 452  *      RT_ERR_PORT_ID  - Invalid port number
 453  * Note:
 454  *      None
 455  */
 456 ret_t rtl8367c_getAsicRldpLoopedPortPair(rtk_uint32 port, rtk_uint32 *pLoopedPair)
 457 {
 458     if(port > RTL8367C_PORTIDMAX)
 459         return RT_ERR_PORT_ID;
 460
 461     if(port < 8)
 462         return rtl8367c_getAsicRegBits(RTL8367C_RLDP_LOOP_PORT_REG(port), RTL8367C_RLDP_LOOP_PORT_MASK(port), pLoopedPair);
 463     else
 464         return rtl8367c_getAsicRegBits(RTL8367C_REG_RLDP_LOOP_PORT_REG4 + ((port - 8) >> 1), RTL8367C_RLDP_LOOP_PORT_MASK(port), pLoopedPair);
 465 }
 466 /* Function Name:
 467  *      rtl8367c_setAsicRlppTrap8051
 468  * Description:
 469  *      Set trap RLPP packet to 8051
 470  * Input:
 471  *      enabled     - 1: enabled, 0: disabled
 472  * Output:
 473  *      None
 474  * Return:
 475  *      RT_ERR_OK   - Success
 476  *      RT_ERR_SMI  - SMI access error
 477  * Note:
 478  *      None
 479  */
 480 ret_t rtl8367c_setAsicRlppTrap8051(rtk_uint32 enabled)
 481 {
 482     return rtl8367c_setAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLPP_8051_TRAP_OFFSET, enabled);
 483 }
 484 /* Function Name:
 485  *      rtl8367c_getAsicRlppTrap8051
 486  * Description:
 487  *      Get trap RLPP packet to 8051
 488  * Input:
 489  *      pEnabled    - 1: enabled, 0: disabled
 490  * Output:
 491  *      None
 492  * Return:
 493  *      RT_ERR_OK   - Success
 494  *      RT_ERR_SMI  - SMI access error
 495  * Note:
 496  *      None
 497  */
 498 ret_t rtl8367c_getAsicRlppTrap8051(rtk_uint32 *pEnabled)
 499 {
 500     return rtl8367c_getAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLPP_8051_TRAP_OFFSET, pEnabled);
 501 }
 502 /* Function Name:
 503  *      rtl8367c_setAsicRldpLeaveLoopedPortmask
 504  * Description:
 505  *      Clear leaved looped portmask
 506  * Input:
 507  *      portmask    - 0~0xFF
 508  * Output:
 509  *      None
 510  * Return:
 511  *      RT_ERR_OK   - Success
 512  *      RT_ERR_SMI  - SMI access error
 513  * Note:
 514  *      None
 515  */
 516 ret_t rtl8367c_setAsicRldpLeaveLoopedPortmask(rtk_uint32 portmask)
 517 {
 518     return rtl8367c_setAsicReg(RTL8367C_REG_RLDP_RELEASED_INDICATOR, portmask);
 519 }
 520 /* Function Name:
 521  *      rtl8367c_getAsicRldpLeaveLoopedPortmask
 522  * Description:
 523  *      Get leaved looped portmask
 524  * Input:
 525  *      pPortmask   - 0~0xFF
 526  * Output:
 527  *      None
 528  * Return:
 529  *      RT_ERR_OK   - Success
 530  *      RT_ERR_SMI  - SMI access error
 531  * Note:
 532  *      None
 533  */
 534 ret_t rtl8367c_getAsicRldpLeaveLoopedPortmask(rtk_uint32 *pPortmask)
 535 {
 536     return rtl8367c_getAsicReg(RTL8367C_REG_RLDP_RELEASED_INDICATOR, pPortmask);
 537 }
 538 /* Function Name:
 539  *      rtl8367c_setAsicRldpEnterLoopedPortmask
 540  * Description:
 541  *      Clear enter loop portmask
 542  * Input:
 543  *      portmask    - 0~0xFF
 544  * Output:
 545  *      None
 546  * Return:
 547  *      RT_ERR_OK   - Success
 548  *      RT_ERR_SMI  - SMI access error
 549  * Note:
 550  *      None
 551  */
 552 ret_t rtl8367c_setAsicRldpEnterLoopedPortmask(rtk_uint32 portmask)
 553 {
 554     return rtl8367c_setAsicReg(RTL8367C_REG_RLDP_LOOPED_INDICATOR, portmask);
 555 }
 556 /* Function Name:
 557  *      rtl8367c_getAsicRldpEnterLoopedPortmask
 558  * Description:
 559  *      Get enter loop portmask
 560  * Input:
 561  *      pPortmask   - 0~0xFF
 562  * Output:
 563  *      None
 564  * Return:
 565  *      RT_ERR_OK   - Success
 566  *      RT_ERR_SMI  - SMI access error
 567  * Note:
 568  *      None
 569  */
 570 ret_t rtl8367c_getAsicRldpEnterLoopedPortmask(rtk_uint32 *pPortmask)
 571 {
 572     return rtl8367c_getAsicReg(RTL8367C_REG_RLDP_LOOPED_INDICATOR, pPortmask);
 573 }
 574
 575 /* Function Name:
 576  *      rtl8367c_setAsicRldpTriggerMode
 577  * Description:
 578  *      Set trigger RLDP mode
 579  * Input:
 580  *      mode    - 1: Periodically, 0: SA moving
 581  * Output:
 582  *      None
 583  * Return:
 584  *      RT_ERR_OK   - Success
 585  *      RT_ERR_SMI  - SMI access error
 586  * Note:
 587  *      None
 588  */
 589 ret_t rtl8367c_setAsicRldpTriggerMode(rtk_uint32 enabled)
 590 {
 591     return rtl8367c_setAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_TRIGGER_MODE_OFFSET, enabled);
 592 }
 593 /* Function Name:
 594  *      rtl8367c_getAsicRldpTriggerMode
 595  * Description:
 596  *      Get trigger RLDP mode
 597  * Input:
 598  *      pMode   - - 1: Periodically, 0: SA moving
 599  * Output:
 600  *      None
 601  * Return:
 602  *      RT_ERR_OK   - Success
 603  *      RT_ERR_SMI  - SMI access error
 604  * Note:
 605  *      None
 606  */
 607 ret_t rtl8367c_getAsicRldpTriggerMode(rtk_uint32 *pEnabled)
 608 {
 609     return rtl8367c_getAsicRegBit(RTL8367C_REG_RLDP_CTRL0, RTL8367C_RLDP_TRIGGER_MODE_OFFSET, pEnabled);
 610 }
 611
 612 /* Function Name:
 613  *      rtl8367c_setAsicRldp8051Portmask
 614  * Description:
 615  *      Set 8051/CPU configured looped portmask
 616  * Input:
 617  *      portmask    - 0~0xFF
 618  * Output:
 619  *      None
 620  * Return:
 621  *      RT_ERR_OK           - Success
 622  *      RT_ERR_SMI          - SMI access error
 623  *      RT_ERR_PORT_MASK    - Invalid portmask
 624  * Note:
 625  *      None
 626  */
 627 ret_t rtl8367c_setAsicRldp8051Portmask(rtk_uint32 portmask)
 628 {
 629     ret_t retVal;
 630     if(portmask > RTL8367C_PORTMASK)
 631         return RT_ERR_PORT_MASK;
 632
 633     retVal = rtl8367c_setAsicRegBits(RTL8367C_RLDP_CTRL0_REG,RTL8367C_RLDP_8051_LOOP_PORTMSK_MASK,portmask & 0xff);
 634     if(retVal != RT_ERR_OK)
 635         return retVal;
 636
 637     retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_RLDP_CTRL5,RTL8367C_RLDP_CTRL5_MASK,(portmask >> 8) & 7);
 638     if(retVal != RT_ERR_OK)
 639         return retVal;
 640
 641     return RT_ERR_OK;
 642 }
 643 /* Function Name:
 644  *      rtl8367c_getAsicRldp8051Portmask
 645  * Description:
 646  *      Get 8051/CPU configured looped portmask
 647  * Input:
 648  *      pPortmask   - 0~0xFF
 649  * Output:
 650  *      None
 651  * Return:
 652  *      RT_ERR_OK   - Success
 653  *      RT_ERR_SMI  - SMI access error
 654  * Note:
 655  *      None
 656  */
 657 ret_t rtl8367c_getAsicRldp8051Portmask(rtk_uint32 *pPortmask)
 658 {
 659     rtk_uint32 tmpPmsk;
 660     ret_t retVal;
 661
 662     retVal = rtl8367c_getAsicRegBits(RTL8367C_RLDP_CTRL0_REG,RTL8367C_RLDP_8051_LOOP_PORTMSK_MASK,&tmpPmsk);
 663     if(retVal != RT_ERR_OK)
 664         return retVal;
 665     *pPortmask = tmpPmsk & 0xff;
 666
 667     retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_RLDP_CTRL5,RTL8367C_RLDP_CTRL5_MASK,&tmpPmsk);
 668     if(retVal != RT_ERR_OK)
 669         return retVal;
 670     *pPortmask |= (tmpPmsk & 7) <<8;
 671
 672     return RT_ERR_OK;
 673 }
 674