target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_mib.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 : MIB related functions
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv_mib.h>
  19 /* Function Name:
  20  *      rtl8367c_setAsicMIBsCounterReset
  21  * Description:
  22  *      Reset global/queue manage or per-port MIB counter
  23  * Input:
  24  *      greset  - Global reset
  25  *      qmreset - Queue maganement reset
  26  *      portmask    - Port reset mask
  27  * Output:
  28  *      None
  29  * Return:
  30  *      RT_ERR_OK               - Success
  31  *      RT_ERR_SMI              - SMI access error
  32  * Note:
  33  *      None
  34  */
  35 ret_t rtl8367c_setAsicMIBsCounterReset(rtk_uint32 greset, rtk_uint32 qmreset, rtk_uint32 portmask)
  36 {
  37     ret_t retVal;
  38     rtk_uint32 regData;
  39     rtk_uint32 regBits;
  40
  41     regBits = RTL8367C_GLOBAL_RESET_MASK |
  42                 RTL8367C_QM_RESET_MASK |
  43                     RTL8367C_MIB_PORT07_MASK |
  44                     ((rtk_uint32)0x7 << 13);
  45     regData = ((greset << RTL8367C_GLOBAL_RESET_OFFSET) & RTL8367C_GLOBAL_RESET_MASK) |
  46                 ((qmreset << RTL8367C_QM_RESET_OFFSET) & RTL8367C_QM_RESET_MASK) |
  47                 (((portmask & 0xFF) << RTL8367C_PORT0_RESET_OFFSET) & RTL8367C_MIB_PORT07_MASK) |
  48                 (((portmask >> 8)&0x7) << 13);
  49
  50
  51     retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_MIB_CTRL0, regBits, (regData >> RTL8367C_PORT0_RESET_OFFSET));
  52
  53     return retVal;
  54 }
  55 /* Function Name:
  56  *      rtl8367c_getAsicMIBsCounter
  57  * Description:
  58  *      Get MIBs counter
  59  * Input:
  60  *      port        - Physical port number (0~7)
  61  *      mibIdx      - MIB counter index
  62  *      pCounter    - MIB retrived counter
  63  * Output:
  64  *      None
  65  * Return:
  66  *      RT_ERR_OK               - Success
  67  *      RT_ERR_SMI              - SMI access error
  68  *      RT_ERR_PORT_ID          - Invalid port number
  69  *      RT_ERR_BUSYWAIT_TIMEOUT - MIB is busy at retrieving
  70  *      RT_ERR_STAT_CNTR_FAIL   - MIB is resetting
  71  * Note:
  72  *      Before MIBs counter retrieving, writting accessing address to ASIC at first and check the MIB
  73  *      control register status. If busy bit of MIB control is set, that means MIB counter have been
  74  *      waiting for preparing, then software must wait atfer this busy flag reset by ASIC. This driver
  75  *      did not recycle reading user desired counter. Software must use driver again to get MIB counter
  76  *      if return value is not RT_ERR_OK.
  77  */
  78 ret_t rtl8367c_getAsicMIBsCounter(rtk_uint32 port, RTL8367C_MIBCOUNTER mibIdx, rtk_uint64* pCounter)
  79 {
  80     ret_t retVal;
  81     rtk_uint32 regAddr;
  82     rtk_uint32 regData;
  83     rtk_uint32 mibAddr;
  84     rtk_uint32 mibOff=0;
  85
  86     /* address offset to MIBs counter */
  87     CONST rtk_uint16 mibLength[RTL8367C_MIBS_NUMBER]= {
  88         4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
  89         4,2,2,2,2,2,2,2,2,
  90         4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
  91         2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};
  92
  93     rtk_uint16 i;
  94     rtk_uint64 mibCounter;
  95
  96
  97     if(port > RTL8367C_PORTIDMAX)
  98         return RT_ERR_PORT_ID;
  99
 100     if(mibIdx >= RTL8367C_MIBS_NUMBER)
 101         return RT_ERR_STAT_INVALID_CNTR;
 102
 103     if(dot1dTpLearnedEntryDiscards == mibIdx)
 104     {
 105         mibAddr = RTL8367C_MIB_LEARNENTRYDISCARD_OFFSET;
 106     }
 107     else
 108     {
 109         i = 0;
 110         mibOff = RTL8367C_MIB_PORT_OFFSET * port;
 111
 112         if(port > 7)
 113             mibOff = mibOff + 68;
 114
 115         while(i < mibIdx)
 116         {
 117             mibOff += mibLength[i];
 118             i++;
 119         }
 120
 121         mibAddr = mibOff;
 122     }
 123
 124
 125     /*writing access counter address first*/
 126     /*This address is SRAM address, and SRAM address = MIB register address >> 2*/
 127     /*then ASIC will prepare 64bits counter wait for being retrived*/
 128     /*Write Mib related address to access control register*/
 129     retVal = rtl8367c_setAsicReg(RTL8367C_REG_MIB_ADDRESS, (mibAddr >> 2));
 130     if(retVal != RT_ERR_OK)
 131         return retVal;
 132
 133
 134
 135     /* polling busy flag */
 136     i = 100;
 137     while(i > 0)
 138     {
 139         /*read MIB control register*/
 140         retVal = rtl8367c_getAsicReg(RTL8367C_MIB_CTRL_REG,&regData);
 141         if(retVal != RT_ERR_OK)
 142             return retVal;
 143
 144         if((regData & RTL8367C_MIB_CTRL0_BUSY_FLAG_MASK) == 0)
 145         {
 146             break;
 147         }
 148
 149         i--;
 150     }
 151
 152     if(regData & RTL8367C_MIB_CTRL0_BUSY_FLAG_MASK)
 153         return RT_ERR_BUSYWAIT_TIMEOUT;
 154
 155     if(regData & RTL8367C_RESET_FLAG_MASK)
 156         return RT_ERR_STAT_CNTR_FAIL;
 157
 158     mibCounter = 0;
 159     i = mibLength[mibIdx];
 160     if(4 == i)
 161         regAddr = RTL8367C_MIB_COUNTER_BASE_REG + 3;
 162     else
 163         regAddr = RTL8367C_MIB_COUNTER_BASE_REG + ((mibOff + 1) % 4);
 164
 165     while(i)
 166     {
 167         retVal = rtl8367c_getAsicReg(regAddr, &regData);
 168         if(retVal != RT_ERR_OK)
 169             return retVal;
 170
 171         mibCounter = (mibCounter << 16) | (regData & 0xFFFF);
 172
 173         regAddr --;
 174         i --;
 175
 176     }
 177
 178     *pCounter = mibCounter;
 179
 180     return RT_ERR_OK;
 181 }
 182
 183 /* Function Name:
 184  *      rtl8367c_getAsicMIBsLogCounter
 185  * Description:
 186  *      Get MIBs Loggin counter
 187  * Input:
 188  *      index       - The index of 32 logging counter (0 ~ 31)
 189  * Output:
 190  *      None
 191  * Return:
 192  *      RT_ERR_OK               - Success
 193  *      RT_ERR_SMI              - SMI access error
 194  *      RT_ERR_ENTRY_INDEX      - Wrong index
 195  *      RT_ERR_BUSYWAIT_TIMEOUT - MIB is busy at retrieving
 196  *      RT_ERR_STAT_CNTR_FAIL   - MIB is resetting
 197  * Note:
 198  *      This API get 32 logging counter
 199  */
 200 ret_t rtl8367c_getAsicMIBsLogCounter(rtk_uint32 index, rtk_uint32 *pCounter)
 201 {
 202     ret_t retVal;
 203     rtk_uint32 regAddr;
 204     rtk_uint32 regData;
 205     rtk_uint32 mibAddr;
 206     rtk_uint16 i;
 207     rtk_uint64 mibCounter;
 208
 209     if(index > RTL8367C_MIB_MAX_LOG_CNT_IDX)
 210         return RT_ERR_ENTRY_INDEX;
 211
 212     mibAddr = RTL8367C_MIB_LOG_CNT_OFFSET + ((index / 2) * 4);
 213
 214     retVal = rtl8367c_setAsicReg(RTL8367C_REG_MIB_ADDRESS, (mibAddr >> 2));
 215     if(retVal != RT_ERR_OK)
 216         return retVal;
 217
 218     /*read MIB control register*/
 219     retVal = rtl8367c_getAsicReg(RTL8367C_MIB_CTRL_REG, &regData);
 220     if(retVal != RT_ERR_OK)
 221         return retVal;
 222
 223     if(regData & RTL8367C_MIB_CTRL0_BUSY_FLAG_MASK)
 224         return RT_ERR_BUSYWAIT_TIMEOUT;
 225
 226     if(regData & RTL8367C_RESET_FLAG_MASK)
 227         return RT_ERR_STAT_CNTR_FAIL;
 228
 229     mibCounter = 0;
 230     if((index % 2) == 1)
 231         regAddr = RTL8367C_MIB_COUNTER_BASE_REG + 3;
 232     else
 233         regAddr = RTL8367C_MIB_COUNTER_BASE_REG + 1;
 234
 235     for(i = 0; i <= 1; i++)
 236     {
 237         retVal = rtl8367c_getAsicReg(regAddr, &regData);
 238
 239         if(retVal != RT_ERR_OK)
 240             return retVal;
 241
 242         mibCounter = (mibCounter << 16) | (regData & 0xFFFF);
 243
 244         regAddr --;
 245     }
 246
 247     *pCounter = mibCounter;
 248     return RT_ERR_OK;
 249 }
 250
 251 /* Function Name:
 252  *      rtl8367c_getAsicMIBsControl
 253  * Description:
 254  *      Get MIB control register
 255  * Input:
 256  *      pMask       - MIB control status mask bit[0]-busy bit[1]
 257  * Output:
 258  *      None
 259  * Return:
 260  *      RT_ERR_OK               - Success
 261  *      RT_ERR_SMI              - SMI access error
 262  * Note:
 263  *      Software need to check this control register atfer doing port resetting or global resetting
 264  */
 265 ret_t rtl8367c_getAsicMIBsControl(rtk_uint32* pMask)
 266 {
 267     ret_t retVal;
 268     rtk_uint32 regData;
 269
 270     retVal = rtl8367c_getAsicReg(RTL8367C_MIB_CTRL_REG, &regData);
 271     if(retVal != RT_ERR_OK)
 272         return retVal;
 273
 274     *pMask = regData & (RTL8367C_MIB_CTRL0_BUSY_FLAG_MASK | RTL8367C_RESET_FLAG_MASK);
 275
 276     return RT_ERR_OK;
 277 }
 278 /* Function Name:
 279  *      rtl8367c_setAsicMIBsResetValue
 280  * Description:
 281  *      Reset all counter to 0 or 1
 282  * Input:
 283  *      value           - Reset to value 0 or 1
 284  * Output:
 285  *      None
 286  * Return:
 287  *      RT_ERR_OK       - Success
 288  *      RT_ERR_SMI      - SMI access error
 289  * Note:
 290  *      None
 291  */
 292 ret_t rtl8367c_setAsicMIBsResetValue(rtk_uint32 value)
 293 {
 294     return rtl8367c_setAsicRegBit(RTL8367C_REG_MIB_CTRL0, RTL8367C_RESET_VALUE_OFFSET, value);
 295 }
 296 /* Function Name:
 297  *      rtl8367c_getAsicMIBsResetValue
 298  * Description:
 299  *      Reset all counter to 0 or 1
 300  * Input:
 301  *      value           - Reset to value 0 or 1
 302  * Output:
 303  *      None
 304  * Return:
 305  *      RT_ERR_OK       - Success
 306  *      RT_ERR_SMI      - SMI access error
 307  * Note:
 308  *      None
 309  */
 310 ret_t rtl8367c_getAsicMIBsResetValue(rtk_uint32* value)
 311 {
 312     return rtl8367c_getAsicRegBit(RTL8367C_REG_MIB_CTRL0, RTL8367C_RESET_VALUE_OFFSET, value);
 313 }
 314
 315 /* Function Name:
 316  *      rtl8367c_setAsicMIBsUsageMode
 317  * Description:
 318  *      MIB update mode
 319  * Input:
 320  *      mode            - 1: latch all MIBs by timer 0:normal free run counting
 321  * Output:
 322  *      None
 323  * Return:
 324  *      RT_ERR_OK       - Success
 325  *      RT_ERR_SMI      - SMI access error
 326  * Note:
 327  *      None
 328  */
 329 ret_t rtl8367c_setAsicMIBsUsageMode(rtk_uint32 mode)
 330 {
 331     return rtl8367c_setAsicRegBit(RTL8367C_REG_MIB_CTRL4, RTL8367C_MIB_USAGE_MODE_OFFSET, mode);
 332 }
 333 /* Function Name:
 334  *      rtl8367c_getAsicMIBsUsageMode
 335  * Description:
 336  *      MIB update mode
 337  * Input:
 338  *      pMode           - 1: latch all MIBs by timer 0:normal free run counting
 339  * Output:
 340  *      None
 341  * Return:
 342  *      RT_ERR_OK       - Success
 343  *      RT_ERR_SMI      - SMI access error
 344  * Note:
 345  *      None
 346  */
 347 ret_t rtl8367c_getAsicMIBsUsageMode(rtk_uint32* pMode)
 348 {
 349     return rtl8367c_getAsicRegBit(RTL8367C_REG_MIB_CTRL4, RTL8367C_MIB_USAGE_MODE_OFFSET, pMode);
 350 }
 351
 352 /* Function Name:
 353  *      rtl8367c_setAsicMIBsTimer
 354  * Description:
 355  *      MIB latching timer
 356  * Input:
 357  *      timer           - latch timer, unit 1 second
 358  * Output:
 359  *      None
 360  * Return:
 361  *      RT_ERR_OK       - Success
 362  *      RT_ERR_SMI      - SMI access error
 363  * Note:
 364  *      None
 365  */
 366 ret_t rtl8367c_setAsicMIBsTimer(rtk_uint32 timer)
 367 {
 368     return rtl8367c_setAsicRegBits(RTL8367C_REG_MIB_CTRL4, RTL8367C_MIB_TIMER_MASK, timer);
 369 }
 370 /* Function Name:
 371  *      rtl8367c_getAsicMIBsTimer
 372  * Description:
 373  *      MIB latching timer
 374  * Input:
 375  *      pTimer          - latch timer, unit 1 second
 376  * Output:
 377  *      None
 378  * Return:
 379  *      RT_ERR_OK       - Success
 380  *      RT_ERR_SMI      - SMI access error
 381  * Note:
 382  *      None
 383  */
 384 ret_t rtl8367c_getAsicMIBsTimer(rtk_uint32* pTimer)
 385 {
 386     return rtl8367c_getAsicRegBits(RTL8367C_REG_MIB_CTRL4, RTL8367C_MIB_TIMER_MASK, pTimer);
 387 }
 388 /* Function Name:
 389  *      rtl8367c_setAsicMIBsLoggingMode
 390  * Description:
 391  *      MIB logging counter mode
 392  * Input:
 393  *      index   - logging counter mode index (0~15)
 394  *      mode    - 0:32-bits mode 1:64-bits mode
 395  * Output:
 396  *      None
 397  * Return:
 398  *      RT_ERR_OK               - Success
 399  *      RT_ERR_SMI              - SMI access error
 400  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 401  * Note:
 402  *      None
 403  */
 404 ret_t rtl8367c_setAsicMIBsLoggingMode(rtk_uint32 index, rtk_uint32 mode)
 405 {
 406     if(index > RTL8367C_MIB_MAX_LOG_MODE_IDX)
 407         return RT_ERR_OUT_OF_RANGE;
 408
 409     return rtl8367c_setAsicRegBit(RTL8367C_REG_MIB_CTRL3, index,mode);
 410 }
 411 /* Function Name:
 412  *      rtl8367c_getAsicMIBsLoggingMode
 413  * Description:
 414  *      MIB logging counter mode
 415  * Input:
 416  *      index   - logging counter mode index (0~15)
 417  *      pMode   - 0:32-bits mode 1:64-bits mode
 418  * Output:
 419  *      None
 420  * Return:
 421  *      RT_ERR_OK               - Success
 422  *      RT_ERR_SMI              - SMI access error
 423  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 424  * Note:
 425  *      None
 426  */
 427 ret_t rtl8367c_getAsicMIBsLoggingMode(rtk_uint32 index, rtk_uint32* pMode)
 428 {
 429     if(index > RTL8367C_MIB_MAX_LOG_MODE_IDX)
 430         return RT_ERR_OUT_OF_RANGE;
 431
 432     return rtl8367c_getAsicRegBit(RTL8367C_REG_MIB_CTRL3, index,pMode);
 433 }
 434
 435 /* Function Name:
 436  *      rtl8367c_setAsicMIBsLoggingType
 437  * Description:
 438  *      MIB logging counter type
 439  * Input:
 440  *      index   - logging counter mode index (0~15)
 441  *      type    - 0:Packet count 1:Byte count
 442  * Output:
 443  *      None
 444  * Return:
 445  *      RT_ERR_OK               - Success
 446  *      RT_ERR_SMI              - SMI access error
 447  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 448  * Note:
 449  *      None
 450  */
 451 ret_t rtl8367c_setAsicMIBsLoggingType(rtk_uint32 index, rtk_uint32 type)
 452 {
 453     if(index > RTL8367C_MIB_MAX_LOG_MODE_IDX)
 454         return RT_ERR_OUT_OF_RANGE;
 455
 456     return rtl8367c_setAsicRegBit(RTL8367C_REG_MIB_CTRL5, index,type);
 457 }
 458
 459 /* Function Name:
 460  *      rtl8367c_getAsicMIBsLoggingType
 461  * Description:
 462  *      MIB logging counter type
 463  * Input:
 464  *      index   - logging counter mode index (0~15)
 465  *      pType   - 0:Packet count 1:Byte count
 466  * Output:
 467  *      None
 468  * Return:
 469  *      RT_ERR_OK               - Success
 470  *      RT_ERR_SMI              - SMI access error
 471  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 472  * Note:
 473  *      None
 474  */
 475 ret_t rtl8367c_getAsicMIBsLoggingType(rtk_uint32 index, rtk_uint32* pType)
 476 {
 477     if(index > RTL8367C_MIB_MAX_LOG_MODE_IDX)
 478         return RT_ERR_OUT_OF_RANGE;
 479
 480     return rtl8367c_getAsicRegBit(RTL8367C_REG_MIB_CTRL5, index,pType);
 481 }
 482
 483 /* Function Name:
 484  *      rtl8367c_setAsicMIBsResetLoggingCounter
 485  * Description:
 486  *      MIB logging counter type
 487  * Input:
 488  *      index   - logging counter index (0~31)
 489  * Output:
 490  *      None
 491  * Return:
 492  *      RT_ERR_OK               - Success
 493  *      RT_ERR_SMI              - SMI access error
 494  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 495  * Note:
 496  *      None
 497  */
 498 ret_t rtl8367c_setAsicMIBsResetLoggingCounter(rtk_uint32 index)
 499 {
 500     ret_t retVal;
 501
 502     if(index > RTL8367C_MIB_MAX_LOG_CNT_IDX)
 503         return RT_ERR_OUT_OF_RANGE;
 504
 505     if(index < 16)
 506         retVal = rtl8367c_setAsicReg(RTL8367C_REG_MIB_CTRL1, 1<<index);
 507     else
 508         retVal = rtl8367c_setAsicReg(RTL8367C_REG_MIB_CTRL2, 1<<(index-16));
 509
 510     return retVal;
 511 }
 512
 513 /* Function Name:
 514  *      rtl8367c_setAsicMIBsLength
 515  * Description:
 516  *      Set MIB length couting mode
 517  * Input:
 518  *      txLengthMode    - 0: tag length doesn't be counted. 1: tag length is counted.
 519  *      rxLengthMode    - 0: tag length doesn't be counted. 1: tag length is counted.
 520  * Output:
 521  *      None
 522  * Return:
 523  *      RT_ERR_OK               - Success
 524  *      RT_ERR_SMI              - SMI access error
 525  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 526  * Note:
 527  *      None
 528  */
 529 ret_t rtl8367c_setAsicMIBsLength(rtk_uint32 txLengthMode, rtk_uint32 rxLengthMode)
 530 {
 531     ret_t retVal;
 532
 533     if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_MIB_RMON_LEN_CTRL, RTL8367C_TX_LENGTH_CTRL_OFFSET, txLengthMode)) != RT_ERR_OK)
 534         return retVal;
 535
 536     if( (retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_MIB_RMON_LEN_CTRL, RTL8367C_RX_LENGTH_CTRL_OFFSET, rxLengthMode)) != RT_ERR_OK)
 537         return retVal;
 538
 539     return RT_ERR_OK;
 540 }
 541
 542 /* Function Name:
 543  *      rtl8367c_setAsicMIBsLength
 544  * Description:
 545  *      Set MIB length couting mode
 546  * Input:
 547  *      None.
 548  * Output:
 549  *      pTxLengthMode - 0: tag length doesn't be counted. 1: tag length is counted.
 550  *      pRxLengthMode - 0: tag length doesn't be counted. 1: tag length is counted.
 551  * Return:
 552  *      RT_ERR_OK               - Success
 553  *      RT_ERR_SMI              - SMI access error
 554  *      RT_ERR_OUT_OF_RANGE     - input parameter out of range
 555  * Note:
 556  *      None
 557  */
 558 ret_t rtl8367c_getAsicMIBsLength(rtk_uint32 *pTxLengthMode, rtk_uint32 *pRxLengthMode)
 559 {
 560     ret_t retVal;
 561
 562     if( (retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_MIB_RMON_LEN_CTRL, RTL8367C_TX_LENGTH_CTRL_OFFSET, pTxLengthMode)) != RT_ERR_OK)
 563         return retVal;
 564
 565     if( (retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_MIB_RMON_LEN_CTRL, RTL8367C_RX_LENGTH_CTRL_OFFSET, pRxLengthMode)) != RT_ERR_OK)
 566         return retVal;
 567
 568     return RT_ERR_OK;
 569 }
 570