target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/stat.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 MIB module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <stat.h>
  21 #include <string.h>
  22
  23 #include <rtl8367c_asicdrv.h>
  24 #include <rtl8367c_asicdrv_mib.h>
  25
  26 /* Function Name:
  27  *      rtk_stat_global_reset
  28  * Description:
  29  *      Reset global MIB counter.
  30  * Input:
  31  *      None
  32  * Output:
  33  *      None
  34  * Return:
  35  *      RT_ERR_OK           - OK
  36  *      RT_ERR_FAILED       - Failed
  37  *      RT_ERR_SMI          - SMI access error
  38  * Note:
  39  *      Reset MIB counter of ports. API will use global reset while port mask is all-ports.
  40  */
  41 rtk_api_ret_t rtk_stat_global_reset(void)
  42 {
  43     rtk_api_ret_t retVal;
  44
  45     /* Check initialization state */
  46     RTK_CHK_INIT_STATE();
  47
  48     if ((retVal = rtl8367c_setAsicMIBsCounterReset(TRUE,FALSE, 0)) != RT_ERR_OK)
  49         return retVal;
  50
  51     return RT_ERR_OK;
  52 }
  53
  54 /* Function Name:
  55  *      rtk_stat_port_reset
  56  * Description:
  57  *      Reset per port MIB counter by port.
  58  * Input:
  59  *      port - port id.
  60  * Output:
  61  *      None
  62  * Return:
  63  *      RT_ERR_OK           - OK
  64  *      RT_ERR_FAILED       - Failed
  65  *      RT_ERR_SMI          - SMI access error
  66  * Note:
  67  *
  68  */
  69 rtk_api_ret_t rtk_stat_port_reset(rtk_port_t port)
  70 {
  71     rtk_api_ret_t retVal;
  72
  73     /* Check initialization state */
  74     RTK_CHK_INIT_STATE();
  75
  76     /* Check port valid */
  77     RTK_CHK_PORT_VALID(port);
  78
  79     if ((retVal = rtl8367c_setAsicMIBsCounterReset(FALSE,FALSE,1 << rtk_switch_port_L2P_get(port))) != RT_ERR_OK)
  80         return retVal;
  81
  82     return RT_ERR_OK;
  83 }
  84
  85 /* Function Name:
  86  *      rtk_stat_queueManage_reset
  87  * Description:
  88  *      Reset queue manage MIB counter.
  89  * Input:
  90  *      None
  91  * Output:
  92  *      None
  93  * Return:
  94  *      RT_ERR_OK           - OK
  95  *      RT_ERR_FAILED       - Failed
  96  *      RT_ERR_SMI          - SMI access error
  97  * Note:
  98  *
  99  */
 100 rtk_api_ret_t rtk_stat_queueManage_reset(void)
 101 {
 102     rtk_api_ret_t retVal;
 103
 104     /* Check initialization state */
 105     RTK_CHK_INIT_STATE();
 106
 107     if ((retVal = rtl8367c_setAsicMIBsCounterReset(FALSE,TRUE,0)) != RT_ERR_OK)
 108         return retVal;
 109
 110     return RT_ERR_OK;
 111 }
 112
 113
 114 /* Function Name:
 115  *      rtk_stat_global_get
 116  * Description:
 117  *      Get global MIB counter
 118  * Input:
 119  *      cntr_idx - global counter index.
 120  * Output:
 121  *      pCntr - global counter value.
 122  * Return:
 123  *      RT_ERR_OK           - OK
 124  *      RT_ERR_FAILED       - Failed
 125  *      RT_ERR_SMI          - SMI access error
 126  *      RT_ERR_INPUT        - Invalid input parameters.
 127  * Note:
 128  *      Get global MIB counter by index definition.
 129  */
 130 rtk_api_ret_t rtk_stat_global_get(rtk_stat_global_type_t cntr_idx, rtk_stat_counter_t *pCntr)
 131 {
 132     rtk_api_ret_t retVal;
 133
 134     /* Check initialization state */
 135     RTK_CHK_INIT_STATE();
 136
 137     if(NULL == pCntr)
 138         return RT_ERR_NULL_POINTER;
 139
 140     if (cntr_idx!=DOT1D_TP_LEARNED_ENTRY_DISCARDS_INDEX)
 141         return RT_ERR_STAT_INVALID_GLOBAL_CNTR;
 142
 143     if ((retVal = rtl8367c_getAsicMIBsCounter(0, cntr_idx, pCntr)) != RT_ERR_OK)
 144         return retVal;
 145
 146     return RT_ERR_OK;
 147 }
 148
 149 /* Function Name:
 150  *      rtk_stat_global_getAll
 151  * Description:
 152  *      Get all global MIB counter
 153  * Input:
 154  *      None
 155  * Output:
 156  *      pGlobal_cntrs - global counter structure.
 157  * Return:
 158  *      RT_ERR_OK           - OK
 159  *      RT_ERR_FAILED       - Failed
 160  *      RT_ERR_SMI          - SMI access error
 161  *      RT_ERR_INPUT        - Invalid input parameters.
 162  * Note:
 163  *      Get all global MIB counter by index definition.
 164  */
 165 rtk_api_ret_t rtk_stat_global_getAll(rtk_stat_global_cntr_t *pGlobal_cntrs)
 166 {
 167     rtk_api_ret_t retVal;
 168
 169     /* Check initialization state */
 170     RTK_CHK_INIT_STATE();
 171
 172     if(NULL == pGlobal_cntrs)
 173         return RT_ERR_NULL_POINTER;
 174
 175     if ((retVal = rtl8367c_getAsicMIBsCounter(0,DOT1D_TP_LEARNED_ENTRY_DISCARDS_INDEX, &pGlobal_cntrs->dot1dTpLearnedEntryDiscards)) != RT_ERR_OK)
 176         return retVal;
 177
 178     return RT_ERR_OK;
 179 }
 180
 181 #define MIB_NOT_SUPPORT     (0xFFFF)
 182 static rtk_api_ret_t _get_asic_mib_idx(rtk_stat_port_type_t cnt_idx, RTL8367C_MIBCOUNTER *pMib_idx)
 183 {
 184     RTL8367C_MIBCOUNTER mib_asic_idx[STAT_PORT_CNTR_END]=
 185     {
 186         ifInOctets,                     /* STAT_IfInOctets */
 187         dot3StatsFCSErrors,             /* STAT_Dot3StatsFCSErrors */
 188         dot3StatsSymbolErrors,          /* STAT_Dot3StatsSymbolErrors */
 189         dot3InPauseFrames,              /* STAT_Dot3InPauseFrames */
 190         dot3ControlInUnknownOpcodes,    /* STAT_Dot3ControlInUnknownOpcodes */
 191         etherStatsFragments,            /* STAT_EtherStatsFragments */
 192         etherStatsJabbers,              /* STAT_EtherStatsJabbers */
 193         ifInUcastPkts,                  /* STAT_IfInUcastPkts */
 194         etherStatsDropEvents,           /* STAT_EtherStatsDropEvents */
 195         etherStatsOctets,               /* STAT_EtherStatsOctets */
 196         etherStatsUnderSizePkts,        /* STAT_EtherStatsUnderSizePkts */
 197         etherOversizeStats,             /* STAT_EtherOversizeStats */
 198         etherStatsPkts64Octets,         /* STAT_EtherStatsPkts64Octets */
 199         etherStatsPkts65to127Octets,    /* STAT_EtherStatsPkts65to127Octets */
 200         etherStatsPkts128to255Octets,   /* STAT_EtherStatsPkts128to255Octets */
 201         etherStatsPkts256to511Octets,   /* STAT_EtherStatsPkts256to511Octets */
 202         etherStatsPkts512to1023Octets,  /* STAT_EtherStatsPkts512to1023Octets */
 203         etherStatsPkts1024to1518Octets, /* STAT_EtherStatsPkts1024to1518Octets */
 204         ifInMulticastPkts,              /* STAT_EtherStatsMulticastPkts */
 205         ifInBroadcastPkts,              /* STAT_EtherStatsBroadcastPkts */
 206         ifOutOctets,                    /* STAT_IfOutOctets */
 207         dot3StatsSingleCollisionFrames, /* STAT_Dot3StatsSingleCollisionFrames */
 208         dot3StatMultipleCollisionFrames,/* STAT_Dot3StatsMultipleCollisionFrames */
 209         dot3sDeferredTransmissions,     /* STAT_Dot3StatsDeferredTransmissions */
 210         dot3StatsLateCollisions,        /* STAT_Dot3StatsLateCollisions */
 211         etherStatsCollisions,           /* STAT_EtherStatsCollisions */
 212         dot3StatsExcessiveCollisions,   /* STAT_Dot3StatsExcessiveCollisions */
 213         dot3OutPauseFrames,             /* STAT_Dot3OutPauseFrames */
 214         MIB_NOT_SUPPORT,                /* STAT_Dot1dBasePortDelayExceededDiscards */
 215         dot1dTpPortInDiscards,          /* STAT_Dot1dTpPortInDiscards */
 216         ifOutUcastPkts,                 /* STAT_IfOutUcastPkts */
 217         ifOutMulticastPkts,             /* STAT_IfOutMulticastPkts */
 218         ifOutBroadcastPkts,             /* STAT_IfOutBroadcastPkts */
 219         outOampduPkts,                  /* STAT_OutOampduPkts */
 220         inOampduPkts,                   /* STAT_InOampduPkts */
 221         MIB_NOT_SUPPORT,                /* STAT_PktgenPkts */
 222         inMldChecksumError,             /* STAT_InMldChecksumError */
 223         inIgmpChecksumError,            /* STAT_InIgmpChecksumError */
 224         inMldSpecificQuery,             /* STAT_InMldSpecificQuery */
 225         inMldGeneralQuery,              /* STAT_InMldGeneralQuery */
 226         inIgmpSpecificQuery,            /* STAT_InIgmpSpecificQuery */
 227         inIgmpGeneralQuery,             /* STAT_InIgmpGeneralQuery */
 228         inMldLeaves,                    /* STAT_InMldLeaves */
 229         inIgmpLeaves,                   /* STAT_InIgmpInterfaceLeaves */
 230         inIgmpJoinsSuccess,             /* STAT_InIgmpJoinsSuccess */
 231         inIgmpJoinsFail,                /* STAT_InIgmpJoinsFail */
 232         inMldJoinsSuccess,              /* STAT_InMldJoinsSuccess */
 233         inMldJoinsFail,                 /* STAT_InMldJoinsFail */
 234         inReportSuppressionDrop,        /* STAT_InReportSuppressionDrop */
 235         inLeaveSuppressionDrop,         /* STAT_InLeaveSuppressionDrop */
 236         outIgmpReports,                 /* STAT_OutIgmpReports */
 237         outIgmpLeaves,                  /* STAT_OutIgmpLeaves */
 238         outIgmpGeneralQuery,            /* STAT_OutIgmpGeneralQuery */
 239         outIgmpSpecificQuery,           /* STAT_OutIgmpSpecificQuery */
 240         outMldReports,                  /* STAT_OutMldReports */
 241         outMldLeaves,                   /* STAT_OutMldLeaves */
 242         outMldGeneralQuery,             /* STAT_OutMldGeneralQuery */
 243         outMldSpecificQuery,            /* STAT_OutMldSpecificQuery */
 244         inKnownMulticastPkts,           /* STAT_InKnownMulticastPkts */
 245         ifInMulticastPkts,              /* STAT_IfInMulticastPkts */
 246         ifInBroadcastPkts,              /* STAT_IfInBroadcastPkts */
 247         ifOutDiscards                   /* STAT_IfOutDiscards */
 248     };
 249
 250     if(cnt_idx >= STAT_PORT_CNTR_END)
 251         return RT_ERR_STAT_INVALID_PORT_CNTR;
 252
 253     if(mib_asic_idx[cnt_idx] == MIB_NOT_SUPPORT)
 254         return RT_ERR_CHIP_NOT_SUPPORTED;
 255
 256     *pMib_idx = mib_asic_idx[cnt_idx];
 257     return RT_ERR_OK;
 258 }
 259
 260 /* Function Name:
 261  *      rtk_stat_port_get
 262  * Description:
 263  *      Get per port MIB counter by index
 264  * Input:
 265  *      port        - port id.
 266  *      cntr_idx    - port counter index.
 267  * Output:
 268  *      pCntr - MIB retrived counter.
 269  * Return:
 270  *      RT_ERR_OK           - OK
 271  *      RT_ERR_FAILED       - Failed
 272  *      RT_ERR_SMI          - SMI access error
 273  * Note:
 274  *      Get per port MIB counter by index definition.
 275  */
 276 rtk_api_ret_t rtk_stat_port_get(rtk_port_t port, rtk_stat_port_type_t cntr_idx, rtk_stat_counter_t *pCntr)
 277 {
 278     rtk_api_ret_t       retVal;
 279     RTL8367C_MIBCOUNTER mib_idx;
 280     rtk_stat_counter_t  second_cnt;
 281
 282     /* Check initialization state */
 283     RTK_CHK_INIT_STATE();
 284
 285     if(NULL == pCntr)
 286         return RT_ERR_NULL_POINTER;
 287
 288     /* Check port valid */
 289     RTK_CHK_PORT_VALID(port);
 290
 291     if (cntr_idx>=STAT_PORT_CNTR_END)
 292         return RT_ERR_STAT_INVALID_PORT_CNTR;
 293
 294     if((retVal = _get_asic_mib_idx(cntr_idx, &mib_idx)) != RT_ERR_OK)
 295         return retVal;
 296
 297     if(mib_idx == MIB_NOT_SUPPORT)
 298         return RT_ERR_CHIP_NOT_SUPPORTED;
 299
 300     if ((retVal = rtl8367c_getAsicMIBsCounter(rtk_switch_port_L2P_get(port), mib_idx, pCntr)) != RT_ERR_OK)
 301         return retVal;
 302
 303     if(cntr_idx == STAT_EtherStatsMulticastPkts)
 304     {
 305         if((retVal = _get_asic_mib_idx(STAT_IfOutMulticastPkts, &mib_idx)) != RT_ERR_OK)
 306             return retVal;
 307
 308         if((retVal = rtl8367c_getAsicMIBsCounter(rtk_switch_port_L2P_get(port), mib_idx, &second_cnt)) != RT_ERR_OK)
 309             return retVal;
 310
 311         *pCntr += second_cnt;
 312     }
 313
 314     if(cntr_idx == STAT_EtherStatsBroadcastPkts)
 315     {
 316         if((retVal = _get_asic_mib_idx(STAT_IfOutBroadcastPkts, &mib_idx)) != RT_ERR_OK)
 317             return retVal;
 318
 319         if((retVal = rtl8367c_getAsicMIBsCounter(rtk_switch_port_L2P_get(port), mib_idx, &second_cnt)) != RT_ERR_OK)
 320             return retVal;
 321
 322         *pCntr += second_cnt;
 323     }
 324
 325     return RT_ERR_OK;
 326 }
 327
 328 /* Function Name:
 329  *      rtk_stat_port_getAll
 330  * Description:
 331  *      Get all counters of one specified port in the specified device.
 332  * Input:
 333  *      port - port id.
 334  * Output:
 335  *      pPort_cntrs - buffer pointer of counter value.
 336  * Return:
 337  *      RT_ERR_OK           - OK
 338  *      RT_ERR_FAILED       - Failed
 339  *      RT_ERR_SMI          - SMI access error
 340  *      RT_ERR_INPUT        - Invalid input parameters.
 341  * Note:
 342  *      Get all MIB counters of one port.
 343  */
 344 rtk_api_ret_t rtk_stat_port_getAll(rtk_port_t port, rtk_stat_port_cntr_t *pPort_cntrs)
 345 {
 346     rtk_api_ret_t retVal;
 347     rtk_uint32 mibIndex;
 348     rtk_uint64 mibCounter;
 349     rtk_uint32 *accessPtr;
 350     /* address offset to MIBs counter */
 351     CONST_T rtk_uint16 mibLength[STAT_PORT_CNTR_END]= {
 352         2,1,1,1,1,1,1,1,1,
 353         2,1,1,1,1,1,1,1,1,1,1,
 354         2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 355         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
 356
 357     /* Check initialization state */
 358     RTK_CHK_INIT_STATE();
 359
 360     if(NULL == pPort_cntrs)
 361         return RT_ERR_NULL_POINTER;
 362
 363     /* Check port valid */
 364     RTK_CHK_PORT_VALID(port);
 365
 366     accessPtr = (rtk_uint32*)pPort_cntrs;
 367     for (mibIndex=0;mibIndex<STAT_PORT_CNTR_END;mibIndex++)
 368     {
 369         if ((retVal = rtk_stat_port_get(port, mibIndex, &mibCounter)) != RT_ERR_OK)
 370         {
 371             if (retVal == RT_ERR_CHIP_NOT_SUPPORTED)
 372                 mibCounter = 0;
 373             else
 374                 return retVal;
 375         }
 376
 377         if (2 == mibLength[mibIndex])
 378             *(rtk_uint64*)accessPtr = mibCounter;
 379         else if (1 == mibLength[mibIndex])
 380             *accessPtr = mibCounter;
 381         else
 382             return RT_ERR_FAILED;
 383
 384         accessPtr+=mibLength[mibIndex];
 385     }
 386
 387     return RT_ERR_OK;
 388 }
 389
 390 /* Function Name:
 391  *      rtk_stat_logging_counterCfg_set
 392  * Description:
 393  *      Set the type and mode of Logging Counter
 394  * Input:
 395  *      idx     - The index of Logging Counter. Should be even number only.(0,2,4,6,8.....30)
 396  *      mode    - 32 bits or 64 bits mode
 397  *      type    - Packet counter or byte counter
 398  * Output:
 399  *      None.
 400  * Return:
 401  *      RT_ERR_OK           - OK
 402  *      RT_ERR_OUT_OF_RANGE - Out of range.
 403  *      RT_ERR_FAILED       - Failed
 404  *      RT_ERR_SMI          - SMI access error
 405  *      RT_ERR_INPUT        - Invalid input parameters.
 406  * Note:
 407  *      Set the type and mode of Logging Counter.
 408  */
 409 rtk_api_ret_t rtk_stat_logging_counterCfg_set(rtk_uint32 idx, rtk_logging_counter_mode_t mode, rtk_logging_counter_type_t type)
 410 {
 411     rtk_api_ret_t retVal;
 412
 413     /* Check initialization state */
 414     RTK_CHK_INIT_STATE();
 415
 416     if(idx > RTL8367C_MIB_MAX_LOG_CNT_IDX)
 417         return RT_ERR_OUT_OF_RANGE;
 418
 419     if((idx % 2) == 1)
 420         return RT_ERR_INPUT;
 421
 422     if(mode >= LOGGING_MODE_END)
 423         return RT_ERR_OUT_OF_RANGE;
 424
 425     if(type >= LOGGING_TYPE_END)
 426         return RT_ERR_OUT_OF_RANGE;
 427
 428     if((retVal = rtl8367c_setAsicMIBsLoggingType((idx / 2), (rtk_uint32)type)) != RT_ERR_OK)
 429         return retVal;
 430
 431     if((retVal = rtl8367c_setAsicMIBsLoggingMode((idx / 2), (rtk_uint32)mode)) != RT_ERR_OK)
 432         return retVal;
 433
 434     return RT_ERR_OK;
 435 }
 436
 437 /* Function Name:
 438  *      rtk_stat_logging_counterCfg_get
 439  * Description:
 440  *      Get the type and mode of Logging Counter
 441  * Input:
 442  *      idx     - The index of Logging Counter. Should be even number only.(0,2,4,6,8.....30)
 443  * Output:
 444  *      pMode   - 32 bits or 64 bits mode
 445  *      pType   - Packet counter or byte counter
 446  * Return:
 447  *      RT_ERR_OK           - OK
 448  *      RT_ERR_OUT_OF_RANGE - Out of range.
 449  *      RT_ERR_FAILED       - Failed
 450  *      RT_ERR_NULL_POINTER - NULL Pointer
 451  *      RT_ERR_SMI          - SMI access error
 452  *      RT_ERR_INPUT        - Invalid input parameters.
 453  * Note:
 454  *      Get the type and mode of Logging Counter.
 455  */
 456 rtk_api_ret_t rtk_stat_logging_counterCfg_get(rtk_uint32 idx, rtk_logging_counter_mode_t *pMode, rtk_logging_counter_type_t *pType)
 457 {
 458     rtk_api_ret_t   retVal;
 459     rtk_uint32      type, mode;
 460
 461     /* Check initialization state */
 462     RTK_CHK_INIT_STATE();
 463
 464     if(idx > RTL8367C_MIB_MAX_LOG_CNT_IDX)
 465         return RT_ERR_OUT_OF_RANGE;
 466
 467     if((idx % 2) == 1)
 468         return RT_ERR_INPUT;
 469
 470     if(pMode == NULL)
 471         return RT_ERR_NULL_POINTER;
 472
 473     if(pType == NULL)
 474         return RT_ERR_NULL_POINTER;
 475
 476     if((retVal = rtl8367c_getAsicMIBsLoggingType((idx / 2), &type)) != RT_ERR_OK)
 477         return retVal;
 478
 479     if((retVal = rtl8367c_getAsicMIBsLoggingMode((idx / 2), &mode)) != RT_ERR_OK)
 480         return retVal;
 481
 482     *pMode = (rtk_logging_counter_mode_t)mode;
 483     *pType = (rtk_logging_counter_type_t)type;
 484
 485     return RT_ERR_OK;
 486 }
 487
 488
 489 /* Function Name:
 490  *      rtk_stat_logging_counter_reset
 491  * Description:
 492  *      Reset Logging Counter
 493  * Input:
 494  *      idx     - The index of Logging Counter. (0~31)
 495  * Output:
 496  *      None.
 497  * Return:
 498  *      RT_ERR_OK           - OK
 499  *      RT_ERR_OUT_OF_RANGE - Out of range.
 500  *      RT_ERR_FAILED       - Failed
 501  *      RT_ERR_SMI          - SMI access error
 502  * Note:
 503  *      Reset Logging Counter.
 504  */
 505 rtk_api_ret_t rtk_stat_logging_counter_reset(rtk_uint32 idx)
 506 {
 507     rtk_api_ret_t   retVal;
 508
 509     /* Check initialization state */
 510     RTK_CHK_INIT_STATE();
 511
 512     if(idx > RTL8367C_MIB_MAX_LOG_CNT_IDX)
 513         return RT_ERR_OUT_OF_RANGE;
 514
 515     if((retVal = rtl8367c_setAsicMIBsResetLoggingCounter(idx)) != RT_ERR_OK)
 516         return retVal;
 517
 518     return RT_ERR_OK;
 519 }
 520
 521 /* Function Name:
 522  *      rtk_stat_logging_counter_get
 523  * Description:
 524  *      Get Logging Counter
 525  * Input:
 526  *      idx     - The index of Logging Counter. (0~31)
 527  * Output:
 528  *      pCnt    - Logging counter value
 529  * Return:
 530  *      RT_ERR_OK           - OK
 531  *      RT_ERR_OUT_OF_RANGE - Out of range.
 532  *      RT_ERR_FAILED       - Failed
 533  *      RT_ERR_SMI          - SMI access error
 534  * Note:
 535  *      Get Logging Counter.
 536  */
 537 rtk_api_ret_t rtk_stat_logging_counter_get(rtk_uint32 idx, rtk_uint32 *pCnt)
 538 {
 539     rtk_api_ret_t   retVal;
 540
 541     /* Check initialization state */
 542     RTK_CHK_INIT_STATE();
 543
 544     if(NULL == pCnt)
 545         return RT_ERR_NULL_POINTER;
 546
 547     if(idx > RTL8367C_MIB_MAX_LOG_CNT_IDX)
 548         return RT_ERR_OUT_OF_RANGE;
 549
 550     if((retVal = rtl8367c_getAsicMIBsLogCounter(idx, pCnt)) != RT_ERR_OK)
 551         return retVal;
 552
 553     return RT_ERR_OK;
 554 }
 555
 556 /* Function Name:
 557  *      rtk_stat_lengthMode_set
 558  * Description:
 559  *      Set Legnth mode.
 560  * Input:
 561  *      txMode     - The length counting mode
 562  *      rxMode     - The length counting mode
 563  * Output:
 564  *      None.
 565  * Return:
 566  *      RT_ERR_OK           - OK
 567  *      RT_ERR_INPUT        - Out of range.
 568  *      RT_ERR_FAILED       - Failed
 569  *      RT_ERR_SMI          - SMI access error
 570  * Note:
 571  *
 572  */
 573 rtk_api_ret_t rtk_stat_lengthMode_set(rtk_stat_lengthMode_t txMode, rtk_stat_lengthMode_t rxMode)
 574 {
 575     rtk_api_ret_t   retVal;
 576
 577     /* Check initialization state */
 578     RTK_CHK_INIT_STATE();
 579
 580     if(txMode >= LENGTH_MODE_END)
 581         return RT_ERR_INPUT;
 582
 583     if(rxMode >= LENGTH_MODE_END)
 584         return RT_ERR_INPUT;
 585
 586     if((retVal = rtl8367c_setAsicMIBsLength((rtk_uint32)txMode, (rtk_uint32)rxMode)) != RT_ERR_OK)
 587         return retVal;
 588
 589     return RT_ERR_OK;
 590 }
 591
 592 /* Function Name:
 593  *      rtk_stat_lengthMode_get
 594  * Description:
 595  *      Get Legnth mode.
 596  * Input:
 597  *      None.
 598  * Output:
 599  *      pTxMode       - The length counting mode
 600  *      pRxMode       - The length counting mode
 601  * Return:
 602  *      RT_ERR_OK           - OK
 603  *      RT_ERR_INPUT        - Out of range.
 604  *      RT_ERR_FAILED       - Failed
 605  *      RT_ERR_SMI          - SMI access error
 606  * Note:
 607  */
 608 rtk_api_ret_t rtk_stat_lengthMode_get(rtk_stat_lengthMode_t *pTxMode, rtk_stat_lengthMode_t *pRxMode)
 609 {
 610     rtk_api_ret_t   retVal;
 611
 612     /* Check initialization state */
 613     RTK_CHK_INIT_STATE();
 614
 615     if(NULL == pTxMode)
 616         return RT_ERR_NULL_POINTER;
 617
 618     if(NULL == pRxMode)
 619         return RT_ERR_NULL_POINTER;
 620
 621     if((retVal = rtl8367c_getAsicMIBsLength((rtk_uint32 *)pTxMode, (rtk_uint32 *)pRxMode)) != RT_ERR_OK)
 622         return retVal;
 623
 624     return RT_ERR_OK;
 625 }
 626