target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_storm.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 : Storm control filtering related functions
  15  *
  16  */
  17
  18 #include <rtl8367c_asicdrv_storm.h>
  19 /* Function Name:
  20  *      rtl8367c_setAsicStormFilterBroadcastEnable
  21  * Description:
  22  *      Set per-port broadcast storm filter enable/disable
  23  * Input:
  24  *      port    - Physical port number (0~7)
  25  *      enabled - 1: enabled, 0: disabled
  26  * Output:
  27  *      None
  28  * Return:
  29  *      RT_ERR_OK       - Success
  30  *      RT_ERR_SMI      - SMI access error
  31  *      RT_ERR_PORT_ID  - Invalid port number
  32  * Note:
  33  *      None
  34  */
  35 ret_t rtl8367c_setAsicStormFilterBroadcastEnable(rtk_uint32 port, rtk_uint32 enabled)
  36 {
  37     if(port >= RTL8367C_PORTNO)
  38         return RT_ERR_PORT_ID;
  39
  40     return rtl8367c_setAsicRegBit(RTL8367C_STORM_BCAST_REG, port, enabled);
  41 }
  42 /* Function Name:
  43  *      rtl8367c_getAsicStormFilterBroadcastEnable
  44  * Description:
  45  *      Get per-port broadcast storm filter enable/disable
  46  * Input:
  47  *      port    - Physical port number (0~7)
  48  *      pEnabled - 1: enabled, 0: disabled
  49  * Output:
  50  *      None
  51  * Return:
  52  *      RT_ERR_OK       - Success
  53  *      RT_ERR_SMI      - SMI access error
  54  *      RT_ERR_PORT_ID  - Invalid port number
  55  * Note:
  56  *      None
  57  */
  58 ret_t rtl8367c_getAsicStormFilterBroadcastEnable(rtk_uint32 port, rtk_uint32 *pEnabled)
  59 {
  60     if(port >= RTL8367C_PORTNO)
  61         return RT_ERR_PORT_ID;
  62
  63     return rtl8367c_getAsicRegBit(RTL8367C_STORM_BCAST_REG, port, pEnabled);
  64 }
  65 /* Function Name:
  66  *      rtl8367c_setAsicStormFilterBroadcastMeter
  67  * Description:
  68  *      Set per-port broadcast storm filter meter
  69  * Input:
  70  *      port    - Physical port number (0~7)
  71  *      meter   - meter index (0~31)
  72  * Output:
  73  *      None
  74  * Return:
  75  *      RT_ERR_OK               - Success
  76  *      RT_ERR_SMI              - SMI access error
  77  *      RT_ERR_PORT_ID          - Invalid port number
  78  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
  79  * Note:
  80  *      None
  81  */
  82 ret_t rtl8367c_setAsicStormFilterBroadcastMeter(rtk_uint32 port, rtk_uint32 meter)
  83 {
  84     if(port >= RTL8367C_PORTNO)
  85         return RT_ERR_PORT_ID;
  86
  87     if(meter > RTL8367C_METERMAX)
  88         return RT_ERR_FILTER_METER_ID;
  89
  90     return rtl8367c_setAsicRegBits(RTL8367C_STORM_BCAST_METER_CTRL_REG(port), RTL8367C_STORM_BCAST_METER_CTRL_MASK(port), meter);
  91 }
  92 /* Function Name:
  93  *      rtl8367c_getAsicStormFilterBroadcastMeter
  94  * Description:
  95  *      Get per-port broadcast storm filter meter
  96  * Input:
  97  *      port    - Physical port number (0~7)
  98  *      pMeter  - meter index (0~31)
  99  * Output:
 100  *      None
 101  * Return:
 102  *      RT_ERR_OK       - Success
 103  *      RT_ERR_SMI      - SMI access error
 104  *      RT_ERR_PORT_ID  - Invalid port number
 105  * Note:
 106  *      None
 107  */
 108 ret_t rtl8367c_getAsicStormFilterBroadcastMeter(rtk_uint32 port, rtk_uint32 *pMeter)
 109 {
 110     if(port >= RTL8367C_PORTNO)
 111         return RT_ERR_PORT_ID;
 112
 113     return rtl8367c_getAsicRegBits(RTL8367C_STORM_BCAST_METER_CTRL_REG(port), RTL8367C_STORM_BCAST_METER_CTRL_MASK(port), pMeter);
 114 }
 115 /* Function Name:
 116  *      rtl8367c_setAsicStormFilterMulticastEnable
 117  * Description:
 118  *      Set per-port multicast storm filter enable/disable
 119  * Input:
 120  *      port    - Physical port number (0~7)
 121  *      enabled - 1: enabled, 0: disabled
 122  * Output:
 123  *      None
 124  * Return:
 125  *      RT_ERR_OK       - Success
 126  *      RT_ERR_SMI      - SMI access error
 127  *      RT_ERR_PORT_ID  - Invalid port number
 128  * Note:
 129  *      None
 130  */
 131 ret_t rtl8367c_setAsicStormFilterMulticastEnable(rtk_uint32 port, rtk_uint32 enabled)
 132 {
 133     if(port >= RTL8367C_PORTNO)
 134         return RT_ERR_PORT_ID;
 135
 136     return rtl8367c_setAsicRegBit(RTL8367C_STORM_MCAST_REG, port, enabled);
 137 }
 138 /* Function Name:
 139  *      rtl8367c_getAsicStormFilterMulticastEnable
 140  * Description:
 141  *      Get per-port multicast storm filter enable/disable
 142  * Input:
 143  *      port    - Physical port number (0~7)
 144  *      pEnabled - 1: enabled, 0: disabled
 145  * Output:
 146  *      None
 147  * Return:
 148  *      RT_ERR_OK       - Success
 149  *      RT_ERR_SMI      - SMI access error
 150  *      RT_ERR_PORT_ID  - Invalid port number
 151  * Note:
 152  *      None
 153  */
 154 ret_t rtl8367c_getAsicStormFilterMulticastEnable(rtk_uint32 port, rtk_uint32 *pEnabled)
 155 {
 156     if(port >= RTL8367C_PORTNO)
 157         return RT_ERR_PORT_ID;
 158
 159     return rtl8367c_getAsicRegBit(RTL8367C_STORM_MCAST_REG, port, pEnabled);
 160 }
 161 /* Function Name:
 162  *      rtl8367c_setAsicStormFilterMulticastMeter
 163  * Description:
 164  *      Set per-port multicast storm filter meter
 165  * Input:
 166  *      port    - Physical port number (0~7)
 167  *      meter   - meter index (0~31)
 168  * Output:
 169  *      None
 170  * Return:
 171  *      RT_ERR_OK               - Success
 172  *      RT_ERR_SMI              - SMI access error
 173  *      RT_ERR_PORT_ID          - Invalid port number
 174  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 175  * Note:
 176  *      None
 177  */
 178 ret_t rtl8367c_setAsicStormFilterMulticastMeter(rtk_uint32 port, rtk_uint32 meter)
 179 {
 180     if(port >= RTL8367C_PORTNO)
 181         return RT_ERR_PORT_ID;
 182
 183     if(meter > RTL8367C_METERMAX)
 184         return RT_ERR_FILTER_METER_ID;
 185
 186     return rtl8367c_setAsicRegBits(RTL8367C_STORM_MCAST_METER_CTRL_REG(port), RTL8367C_STORM_MCAST_METER_CTRL_MASK(port), meter);
 187 }
 188 /* Function Name:
 189  *      rtl8367c_getAsicStormFilterMulticastMeter
 190  * Description:
 191  *      Get per-port multicast storm filter meter
 192  * Input:
 193  *      port    - Physical port number (0~7)
 194  *      pMeter  - meter index (0~31)
 195  * Output:
 196  *      None
 197  * Return:
 198  *      RT_ERR_OK       - Success
 199  *      RT_ERR_SMI      - SMI access error
 200  *      RT_ERR_PORT_ID  - Invalid port number
 201  * Note:
 202  *      None
 203  */
 204 ret_t rtl8367c_getAsicStormFilterMulticastMeter(rtk_uint32 port, rtk_uint32 *pMeter)
 205 {
 206     if(port >= RTL8367C_PORTNO)
 207         return RT_ERR_PORT_ID;
 208
 209     return rtl8367c_getAsicRegBits(RTL8367C_STORM_MCAST_METER_CTRL_REG(port), RTL8367C_STORM_MCAST_METER_CTRL_MASK(port), pMeter);
 210 }
 211 /* Function Name:
 212  *      rtl8367c_setAsicStormFilterUnknownMulticastEnable
 213  * Description:
 214  *      Set per-port unknown multicast storm filter enable/disable
 215  * Input:
 216  *      port    - Physical port number (0~7)
 217  *      enabled - 1: enabled, 0: disabled
 218  * Output:
 219  *      None
 220  * Return:
 221  *      RT_ERR_OK       - Success
 222  *      RT_ERR_SMI      - SMI access error
 223  *      RT_ERR_PORT_ID  - Invalid port number
 224  * Note:
 225  *      None
 226  */
 227 ret_t rtl8367c_setAsicStormFilterUnknownMulticastEnable(rtk_uint32 port, rtk_uint32 enabled)
 228 {
 229     if(port >= RTL8367C_PORTNO)
 230         return RT_ERR_PORT_ID;
 231
 232     return rtl8367c_setAsicRegBit(RTL8367C_STORM_UNKNOWN_MCAST_REG, port, enabled);
 233 }
 234 /* Function Name:
 235  *      rtl8367c_getAsicStormFilterUnknownMulticastEnable
 236  * Description:
 237  *      Get per-port unknown multicast storm filter enable/disable
 238  * Input:
 239  *      port    - Physical port number (0~7)
 240  *      pEnabled - 1: enabled, 0: disabled
 241  * Output:
 242  *      None
 243  * Return:
 244  *      RT_ERR_OK       - Success
 245  *      RT_ERR_SMI      - SMI access error
 246  *      RT_ERR_PORT_ID  - Invalid port number
 247  * Note:
 248  *      None
 249  */
 250 ret_t rtl8367c_getAsicStormFilterUnknownMulticastEnable(rtk_uint32 port, rtk_uint32 *pEnabled)
 251 {
 252     if(port >= RTL8367C_PORTNO)
 253         return RT_ERR_PORT_ID;
 254
 255     return rtl8367c_getAsicRegBit(RTL8367C_STORM_UNKNOWN_MCAST_REG, port, pEnabled);
 256 }
 257 /* Function Name:
 258  *      rtl8367c_setAsicStormFilterUnknownMulticastMeter
 259  * Description:
 260  *      Set per-port unknown multicast storm filter meter
 261  * Input:
 262  *      port    - Physical port number (0~7)
 263  *      meter   - meter index (0~31)
 264  * Output:
 265  *      None
 266  * Return:
 267  *      RT_ERR_OK               - Success
 268  *      RT_ERR_SMI              - SMI access error
 269  *      RT_ERR_PORT_ID          - Invalid port number
 270  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 271  * Note:
 272  *      None
 273  */
 274 ret_t rtl8367c_setAsicStormFilterUnknownMulticastMeter(rtk_uint32 port, rtk_uint32 meter)
 275 {
 276     ret_t retVal;
 277
 278     if(port >= RTL8367C_PORTNO)
 279         return RT_ERR_PORT_ID;
 280
 281     if(meter > RTL8367C_METERMAX)
 282         return RT_ERR_FILTER_METER_ID;
 283
 284     if(port < 8)
 285     {
 286         retVal = rtl8367c_setAsicRegBits(RTL8367C_STORM_UNMC_METER_CTRL_REG(port), RTL8367C_STORM_UNMC_METER_CTRL_MASK(port), meter);
 287         if(retVal != RT_ERR_OK)
 288             return retVal;
 289     }
 290     else
 291     {
 292         retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_UNMC_METER_CTRL4 + ((port - 8) >> 1), RTL8367C_STORM_UNMC_METER_CTRL_MASK(port), meter);
 293         if(retVal != RT_ERR_OK)
 294             return retVal;
 295     }
 296
 297     return RT_ERR_OK;
 298 }
 299 /* Function Name:
 300  *      rtl8367c_getAsicStormFilterUnknownMulticastMeter
 301  * Description:
 302  *      Get per-port unknown multicast storm filter meter
 303  * Input:
 304  *      port    - Physical port number (0~7)
 305  *      pMeter  - meter index (0~31)
 306  * Output:
 307  *      None
 308  * Return:
 309  *      RT_ERR_OK       - Success
 310  *      RT_ERR_SMI      - SMI access error
 311  *      RT_ERR_PORT_ID  - Invalid port number
 312  * Note:
 313  *      None
 314  */
 315 ret_t rtl8367c_getAsicStormFilterUnknownMulticastMeter(rtk_uint32 port, rtk_uint32 *pMeter)
 316 {
 317     ret_t retVal;
 318
 319     if(port >= RTL8367C_PORTNO)
 320         return RT_ERR_PORT_ID;
 321
 322     if(port < 8)
 323     {
 324         retVal = rtl8367c_getAsicRegBits(RTL8367C_STORM_UNMC_METER_CTRL_REG(port), RTL8367C_STORM_UNMC_METER_CTRL_MASK(port), pMeter);
 325         if(retVal != RT_ERR_OK)
 326             return retVal;
 327     }
 328     else
 329     {
 330         retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_UNMC_METER_CTRL4 + ((port - 8) >> 1), RTL8367C_STORM_UNMC_METER_CTRL_MASK(port), pMeter);
 331         if(retVal != RT_ERR_OK)
 332             return retVal;
 333     }
 334
 335     return RT_ERR_OK;
 336 }
 337 /* Function Name:
 338  *      rtl8367c_setAsicStormFilterUnknownUnicastEnable
 339  * Description:
 340  *      Set per-port unknown unicast storm filter enable/disable
 341  * Input:
 342  *      port    - Physical port number (0~7)
 343  *      enabled - 1: enabled, 0: disabled
 344  * Output:
 345  *      None
 346  * Return:
 347  *      RT_ERR_OK       - Success
 348  *      RT_ERR_SMI      - SMI access error
 349  *      RT_ERR_PORT_ID  - Invalid port number
 350  * Note:
 351  *      None
 352  */
 353 ret_t rtl8367c_setAsicStormFilterUnknownUnicastEnable(rtk_uint32 port, rtk_uint32 enabled)
 354 {
 355     if(port >= RTL8367C_PORTNO)
 356         return RT_ERR_PORT_ID;
 357
 358     return rtl8367c_setAsicRegBit(RTL8367C_STORM_UNKNOWN_UCAST_REG, port, enabled);
 359 }
 360 /* Function Name:
 361  *      rtl8367c_getAsicStormFilterUnknownUnicastEnable
 362  * Description:
 363  *      get per-port unknown unicast storm filter enable/disable
 364  * Input:
 365  *      port    - Physical port number (0~7)
 366  *      pEnabled - 1: enabled, 0: disabled
 367  * Output:
 368  *      None
 369  * Return:
 370  *      RT_ERR_OK       - Success
 371  *      RT_ERR_SMI      - SMI access error
 372  *      RT_ERR_PORT_ID  - Invalid port number
 373  * Note:
 374  *      None
 375  */
 376 ret_t rtl8367c_getAsicStormFilterUnknownUnicastEnable(rtk_uint32 port, rtk_uint32 *pEnabled)
 377 {
 378     if(port >= RTL8367C_PORTNO)
 379         return RT_ERR_PORT_ID;
 380
 381     return rtl8367c_getAsicRegBit(RTL8367C_STORM_UNKNOWN_UCAST_REG, port, pEnabled);
 382 }
 383 /* Function Name:
 384  *      rtl8367c_setAsicStormFilterUnknownUnicastMeter
 385  * Description:
 386  *      Set per-port unknown unicast storm filter meter
 387  * Input:
 388  *      port    - Physical port number (0~7)
 389  *      meter   - meter index (0~31)
 390  * Output:
 391  *      None
 392  * Return:
 393  *      RT_ERR_OK               - Success
 394  *      RT_ERR_SMI              - SMI access error
 395  *      RT_ERR_PORT_ID          - Invalid port number
 396  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 397  * Note:
 398  *      None
 399  */
 400 ret_t rtl8367c_setAsicStormFilterUnknownUnicastMeter(rtk_uint32 port, rtk_uint32 meter)
 401 {
 402     if(port >= RTL8367C_PORTNO)
 403         return RT_ERR_PORT_ID;
 404
 405     if(meter > RTL8367C_METERMAX)
 406         return RT_ERR_FILTER_METER_ID;
 407
 408     return rtl8367c_setAsicRegBits(RTL8367C_STORM_UNDA_METER_CTRL_REG(port), RTL8367C_STORM_UNDA_METER_CTRL_MASK(port), meter);
 409 }
 410 /* Function Name:
 411  *      rtl8367c_getAsicStormFilterUnknownUnicastMeter
 412  * Description:
 413  *      Get per-port unknown unicast storm filter meter
 414  * Input:
 415  *      port    - Physical port number (0~7)
 416  *      pMeter  - meter index (0~31)
 417  * Output:
 418  *      None
 419  * Return:
 420  *      RT_ERR_OK       - Success
 421  *      RT_ERR_SMI      - SMI access error
 422  *      RT_ERR_PORT_ID  - Invalid port number
 423  * Note:
 424  *      None
 425  */
 426 ret_t rtl8367c_getAsicStormFilterUnknownUnicastMeter(rtk_uint32 port, rtk_uint32 *pMeter)
 427 {
 428     if(port >= RTL8367C_PORTNO)
 429         return RT_ERR_PORT_ID;
 430
 431     return rtl8367c_getAsicRegBits(RTL8367C_STORM_UNDA_METER_CTRL_REG(port), RTL8367C_STORM_UNDA_METER_CTRL_MASK(port), pMeter);
 432 }
 433
 434 /* Function Name:
 435  *      rtl8367c_setAsicStormFilterExtBroadcastMeter
 436  * Description:
 437  *      Set extension broadcast storm filter meter
 438  * Input:
 439  *      meter   - meter index (0~31)
 440  * Output:
 441  *      None
 442  * Return:
 443  *      RT_ERR_OK               - Success
 444  *      RT_ERR_SMI              - SMI access error
 445  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 446  * Note:
 447  *      None
 448  */
 449 ret_t rtl8367c_setAsicStormFilterExtBroadcastMeter(rtk_uint32 meter)
 450 {
 451     if(meter > RTL8367C_METERMAX)
 452         return RT_ERR_FILTER_METER_ID;
 453
 454     return rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG0, RTL8367C_BC_STORM_EXT_METERIDX_MASK, meter);
 455 }
 456
 457 /* Function Name:
 458  *      rtl8367c_getAsicStormFilterExtBroadcastMeter
 459  * Description:
 460  *      get extension broadcast storm filter meter
 461  * Input:
 462  *      None
 463  * Output:
 464  *      pMeter  - meter index (0~31)
 465  * Return:
 466  *      RT_ERR_OK               - Success
 467  *      RT_ERR_SMI              - SMI access error
 468  *      RT_ERR_NULL_POINTER     - Invalid meter index
 469  * Note:
 470  *      None
 471  */
 472 ret_t rtl8367c_getAsicStormFilterExtBroadcastMeter(rtk_uint32 *pMeter)
 473 {
 474     if(NULL == pMeter)
 475         return RT_ERR_NULL_POINTER;
 476
 477     return rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG0, RTL8367C_BC_STORM_EXT_METERIDX_MASK, pMeter);
 478 }
 479
 480 /* Function Name:
 481  *      rtl8367c_setAsicStormFilterExtMulticastMeter
 482  * Description:
 483  *      Set extension multicast storm filter meter
 484  * Input:
 485  *      meter   - meter index (0~31)
 486  * Output:
 487  *      None
 488  * Return:
 489  *      RT_ERR_OK               - Success
 490  *      RT_ERR_SMI              - SMI access error
 491  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 492  * Note:
 493  *      None
 494  */
 495 ret_t rtl8367c_setAsicStormFilterExtMulticastMeter(rtk_uint32 meter)
 496 {
 497     if(meter > RTL8367C_METERMAX)
 498         return RT_ERR_FILTER_METER_ID;
 499
 500     return rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG0, RTL8367C_MC_STORM_EXT_METERIDX_MASK, meter);
 501 }
 502
 503 /* Function Name:
 504  *      rtl8367c_getAsicStormFilterExtMulticastMeter
 505  * Description:
 506  *      get extension multicast storm filter meter
 507  * Input:
 508  *      None
 509  * Output:
 510  *      pMeter  - meter index (0~31)
 511  * Return:
 512  *      RT_ERR_OK               - Success
 513  *      RT_ERR_SMI              - SMI access error
 514  *      RT_ERR_NULL_POINTER     - Invalid meter index
 515  * Note:
 516  *      None
 517  */
 518 ret_t rtl8367c_getAsicStormFilterExtMulticastMeter(rtk_uint32 *pMeter)
 519 {
 520     if(NULL == pMeter)
 521         return RT_ERR_NULL_POINTER;
 522
 523     return rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG0, RTL8367C_MC_STORM_EXT_METERIDX_MASK, pMeter);
 524 }
 525
 526 /* Function Name:
 527  *      rtl8367c_setAsicStormFilterExtUnknownMulticastMeter
 528  * Description:
 529  *      Set extension unknown multicast storm filter meter
 530  * Input:
 531  *      meter   - meter index (0~31)
 532  * Output:
 533  *      None
 534  * Return:
 535  *      RT_ERR_OK               - Success
 536  *      RT_ERR_SMI              - SMI access error
 537  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 538  * Note:
 539  *      None
 540  */
 541 ret_t rtl8367c_setAsicStormFilterExtUnknownMulticastMeter(rtk_uint32 meter)
 542 {
 543     if(meter > RTL8367C_METERMAX)
 544         return RT_ERR_FILTER_METER_ID;
 545
 546     return rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG1, RTL8367C_UNMC_STORM_EXT_METERIDX_MASK, meter);
 547 }
 548
 549 /* Function Name:
 550  *      rtl8367c_getAsicStormFilterExtUnknownMulticastMeter
 551  * Description:
 552  *      get extension unknown multicast storm filter meter
 553  * Input:
 554  *      None
 555  * Output:
 556  *      pMeter  - meter index (0~31)
 557  * Return:
 558  *      RT_ERR_OK               - Success
 559  *      RT_ERR_SMI              - SMI access error
 560  *      RT_ERR_NULL_POINTER     - Invalid meter index
 561  * Note:
 562  *      None
 563  */
 564 ret_t rtl8367c_getAsicStormFilterExtUnknownMulticastMeter(rtk_uint32 *pMeter)
 565 {
 566     if(NULL == pMeter)
 567         return RT_ERR_NULL_POINTER;
 568
 569     return rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG1, RTL8367C_UNMC_STORM_EXT_METERIDX_MASK, pMeter);
 570 }
 571
 572 /* Function Name:
 573  *      rtl8367c_setAsicStormFilterExtUnknownUnicastMeter
 574  * Description:
 575  *      Set extension unknown unicast storm filter meter
 576  * Input:
 577  *      meter   - meter index (0~31)
 578  * Output:
 579  *      None
 580  * Return:
 581  *      RT_ERR_OK               - Success
 582  *      RT_ERR_SMI              - SMI access error
 583  *      RT_ERR_FILTER_METER_ID  - Invalid meter index
 584  * Note:
 585  *      None
 586  */
 587 ret_t rtl8367c_setAsicStormFilterExtUnknownUnicastMeter(rtk_uint32 meter)
 588 {
 589     if(meter > RTL8367C_METERMAX)
 590         return RT_ERR_FILTER_METER_ID;
 591
 592     return rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG1, RTL8367C_UNUC_STORM_EXT_METERIDX_MASK, meter);
 593 }
 594
 595 /* Function Name:
 596  *      rtl8367c_getAsicStormFilterExtUnknownUnicastMeter
 597  * Description:
 598  *      get extension unknown unicast storm filter meter
 599  * Input:
 600  *      None
 601  * Output:
 602  *      pMeter  - meter index (0~31)
 603  * Return:
 604  *      RT_ERR_OK               - Success
 605  *      RT_ERR_SMI              - SMI access error
 606  *      RT_ERR_NULL_POINTER     - Invalid meter index
 607  * Note:
 608  *      None
 609  */
 610 ret_t rtl8367c_getAsicStormFilterExtUnknownUnicastMeter(rtk_uint32 *pMeter)
 611 {
 612     if(NULL == pMeter)
 613         return RT_ERR_NULL_POINTER;
 614
 615     return rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_EXT_MTRIDX_CFG1, RTL8367C_UNUC_STORM_EXT_METERIDX_MASK, pMeter);
 616 }
 617
 618 /* Function Name:
 619  *      rtl8367c_setAsicStormFilterExtBroadcastEnable
 620  * Description:
 621  *      Set extension broadcast storm filter state
 622  * Input:
 623  *      enabled     - state
 624  * Output:
 625  *      None
 626  * Return:
 627  *      RT_ERR_OK               - Success
 628  *      RT_ERR_SMI              - SMI access error
 629  * Note:
 630  *      None
 631  */
 632 ret_t rtl8367c_setAsicStormFilterExtBroadcastEnable(rtk_uint32 enabled)
 633 {
 634     return rtl8367c_setAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_BCAST_EXT_EN_OFFSET, enabled);
 635 }
 636
 637 /* Function Name:
 638  *      rtl8367c_getAsicStormFilterExtBroadcastEnable
 639  * Description:
 640  *      Get extension broadcast storm filter state
 641  * Input:
 642  *      None
 643  * Output:
 644  *      pEnabled    - state
 645  * Return:
 646  *      RT_ERR_OK               - Success
 647  *      RT_ERR_SMI              - SMI access error
 648  *      RT_ERR_NULL_POINTER     - Null pointer
 649  * Note:
 650  *      None
 651  */
 652 ret_t rtl8367c_getAsicStormFilterExtBroadcastEnable(rtk_uint32 *pEnabled)
 653 {
 654     if(NULL == pEnabled)
 655         return RT_ERR_NULL_POINTER;
 656
 657     return rtl8367c_getAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_BCAST_EXT_EN_OFFSET, pEnabled);
 658 }
 659
 660 /* Function Name:
 661  *      rtl8367c_setAsicStormFilterExtMulticastEnable
 662  * Description:
 663  *      Set extension multicast storm filter state
 664  * Input:
 665  *      enabled     - state
 666  * Output:
 667  *      None
 668  * Return:
 669  *      RT_ERR_OK               - Success
 670  *      RT_ERR_SMI              - SMI access error
 671  * Note:
 672  *      None
 673  */
 674 ret_t rtl8367c_setAsicStormFilterExtMulticastEnable(rtk_uint32 enabled)
 675 {
 676     return rtl8367c_setAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_MCAST_EXT_EN_OFFSET, enabled);
 677 }
 678
 679 /* Function Name:
 680  *      rtl8367c_getAsicStormFilterExtMulticastEnable
 681  * Description:
 682  *      Get extension multicast storm filter state
 683  * Input:
 684  *      None
 685  * Output:
 686  *      pEnabled    - state
 687  * Return:
 688  *      RT_ERR_OK               - Success
 689  *      RT_ERR_SMI              - SMI access error
 690  *      RT_ERR_NULL_POINTER     - Null pointer
 691  * Note:
 692  *      None
 693  */
 694 ret_t rtl8367c_getAsicStormFilterExtMulticastEnable(rtk_uint32 *pEnabled)
 695 {
 696     if(NULL == pEnabled)
 697         return RT_ERR_NULL_POINTER;
 698
 699     return rtl8367c_getAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_MCAST_EXT_EN_OFFSET, pEnabled);
 700 }
 701
 702 /* Function Name:
 703  *      rtl8367c_setAsicStormFilterExtUnknownMulticastEnable
 704  * Description:
 705  *      Set extension unknown multicast storm filter state
 706  * Input:
 707  *      enabled     - state
 708  * Output:
 709  *      None
 710  * Return:
 711  *      RT_ERR_OK               - Success
 712  *      RT_ERR_SMI              - SMI access error
 713  * Note:
 714  *      None
 715  */
 716 ret_t rtl8367c_setAsicStormFilterExtUnknownMulticastEnable(rtk_uint32 enabled)
 717 {
 718     return rtl8367c_setAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_UNKNOWN_MCAST_EXT_EN_OFFSET, enabled);
 719 }
 720
 721 /* Function Name:
 722  *      rtl8367c_getAsicStormFilterExtUnknownMulticastEnable
 723  * Description:
 724  *      Get extension unknown multicast storm filter state
 725  * Input:
 726  *      None
 727  * Output:
 728  *      pEnabled    - state
 729  * Return:
 730  *      RT_ERR_OK               - Success
 731  *      RT_ERR_SMI              - SMI access error
 732  *      RT_ERR_NULL_POINTER     - Null pointer
 733  * Note:
 734  *      None
 735  */
 736 ret_t rtl8367c_getAsicStormFilterExtUnknownMulticastEnable(rtk_uint32 *pEnabled)
 737 {
 738     if(NULL == pEnabled)
 739         return RT_ERR_NULL_POINTER;
 740
 741     return rtl8367c_getAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_UNKNOWN_MCAST_EXT_EN_OFFSET, pEnabled);
 742 }
 743
 744 /* Function Name:
 745  *      rtl8367c_setAsicStormFilterExtUnknownUnicastEnable
 746  * Description:
 747  *      Set extension unknown unicast storm filter state
 748  * Input:
 749  *      enabled     - state
 750  * Output:
 751  *      None
 752  * Return:
 753  *      RT_ERR_OK               - Success
 754  *      RT_ERR_SMI              - SMI access error
 755  * Note:
 756  *      None
 757  */
 758 ret_t rtl8367c_setAsicStormFilterExtUnknownUnicastEnable(rtk_uint32 enabled)
 759 {
 760     return rtl8367c_setAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_UNKNOWN_UCAST_EXT_EN_OFFSET, enabled);
 761 }
 762
 763 /* Function Name:
 764  *      rtl8367c_getAsicStormFilterExtUnknownUnicastEnable
 765  * Description:
 766  *      Get extension unknown unicast storm filter state
 767  * Input:
 768  *      None
 769  * Output:
 770  *      pEnabled    - state
 771  * Return:
 772  *      RT_ERR_OK               - Success
 773  *      RT_ERR_SMI              - SMI access error
 774  *      RT_ERR_NULL_POINTER     - Null pointer
 775  * Note:
 776  *      None
 777  */
 778 ret_t rtl8367c_getAsicStormFilterExtUnknownUnicastEnable(rtk_uint32 *pEnabled)
 779 {
 780     if(NULL == pEnabled)
 781         return RT_ERR_NULL_POINTER;
 782
 783     return rtl8367c_getAsicRegBit(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_UNKNOWN_UCAST_EXT_EN_OFFSET, pEnabled);
 784 }
 785
 786 /* Function Name:
 787  *      rtl8367c_setAsicStormFilterExtEnablePortMask
 788  * Description:
 789  *      Set extension storm filter port mask
 790  * Input:
 791  *      portmask    - port mask
 792  * Output:
 793  *      None
 794  * Return:
 795  *      RT_ERR_OK               - Success
 796  *      RT_ERR_SMI              - SMI access error
 797  * Note:
 798  *      None
 799  */
 800 ret_t rtl8367c_setAsicStormFilterExtEnablePortMask(rtk_uint32 portmask)
 801 {
 802     ret_t retVal;
 803
 804     retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_EXT_EN_PORTMASK_MASK, portmask & 0x3FF);
 805     if(retVal != RT_ERR_OK)
 806         return retVal;
 807
 808     retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_EXT_EN_PORTMASK_EXT_MASK, (portmask >> 10)&1);
 809     if(retVal != RT_ERR_OK)
 810         return retVal;
 811
 812     return RT_ERR_OK;
 813 }
 814
 815 /* Function Name:
 816  *      rtl8367c_getAsicStormFilterExtEnablePortMask
 817  * Description:
 818  *      Get extension storm filter port mask
 819  * Input:
 820  *      portmask    - port mask
 821  * Output:
 822  *      None
 823  * Return:
 824  *      RT_ERR_OK               - Success
 825  *      RT_ERR_SMI              - SMI access error
 826  *      RT_ERR_NULL_POINTER     - Null pointer
 827  * Note:
 828  *      None
 829  */
 830 ret_t rtl8367c_getAsicStormFilterExtEnablePortMask(rtk_uint32 *pPortmask)
 831 {
 832     rtk_uint32 tmpPmsk;
 833     ret_t retVal;
 834
 835     if(NULL == pPortmask)
 836         return RT_ERR_NULL_POINTER;
 837
 838     retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_EXT_EN_PORTMASK_MASK, &tmpPmsk);
 839     if(retVal != RT_ERR_OK)
 840         return retVal;
 841     *pPortmask = tmpPmsk & 0x3ff;
 842
 843     retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_STORM_EXT_CFG, RTL8367C_STORM_EXT_EN_PORTMASK_EXT_MASK, &tmpPmsk);
 844     if(retVal != RT_ERR_OK)
 845         return retVal;
 846     *pPortmask |= (tmpPmsk & 1) << 10;
 847
 848     return RT_ERR_OK;
 849 }
 850
 851