target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/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 : RTK switch high-level API for RTL8367/RTL8367C
  14  * Feature : Here is a list of all functions and variables in Storm module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <storm.h>
  21 #include <rate.h>
  22 #include <string.h>
  23 #include <rtl8367c_asicdrv.h>
  24 #include <rtl8367c_asicdrv_storm.h>
  25 #include <rtl8367c_asicdrv_meter.h>
  26 #include <rtl8367c_asicdrv_rma.h>
  27 #include <rtl8367c_asicdrv_igmp.h>
  28
  29 /* Function Name:
  30  *      rtk_rate_stormControlMeterIdx_set
  31  * Description:
  32  *      Set the storm control meter index.
  33  * Input:
  34  *      port       - port id
  35  *      storm_type - storm group type
  36  *      index       - storm control meter index.
  37  * Output:
  38  *      None.
  39  * Return:
  40  *      RT_ERR_OK
  41  *      RT_ERR_FAILED
  42  *      RT_ERR_PORT_ID - Invalid port id
  43  *      RT_ERR_FILTER_METER_ID  - Invalid meter
  44  * Note:
  45  *
  46  */
  47 rtk_api_ret_t rtk_rate_stormControlMeterIdx_set(rtk_port_t port, rtk_rate_storm_group_t stormType, rtk_uint32 index)
  48 {
  49     rtk_api_ret_t retVal;
  50
  51     /* Check initialization state */
  52     RTK_CHK_INIT_STATE();
  53
  54     /* Check Port Valid */
  55     RTK_CHK_PORT_VALID(port);
  56
  57     if (stormType >= STORM_GROUP_END)
  58         return RT_ERR_SFC_UNKNOWN_GROUP;
  59
  60     if (index > RTK_MAX_METER_ID)
  61         return RT_ERR_FILTER_METER_ID;
  62
  63     switch (stormType)
  64     {
  65         case STORM_GROUP_UNKNOWN_UNICAST:
  66             if ((retVal = rtl8367c_setAsicStormFilterUnknownUnicastMeter(rtk_switch_port_L2P_get(port), index))!=RT_ERR_OK)
  67                 return retVal;
  68             break;
  69         case STORM_GROUP_UNKNOWN_MULTICAST:
  70             if ((retVal = rtl8367c_setAsicStormFilterUnknownMulticastMeter(rtk_switch_port_L2P_get(port), index))!=RT_ERR_OK)
  71                 return retVal;
  72             break;
  73         case STORM_GROUP_MULTICAST:
  74             if ((retVal = rtl8367c_setAsicStormFilterMulticastMeter(rtk_switch_port_L2P_get(port), index))!=RT_ERR_OK)
  75                 return retVal;
  76             break;
  77         case STORM_GROUP_BROADCAST:
  78             if ((retVal = rtl8367c_setAsicStormFilterBroadcastMeter(rtk_switch_port_L2P_get(port), index))!=RT_ERR_OK)
  79                 return retVal;
  80             break;
  81         default:
  82             break;
  83     }
  84
  85     return RT_ERR_OK;
  86 }
  87
  88 /* Function Name:
  89  *      rtk_rate_stormControlMeterIdx_get
  90  * Description:
  91  *      Get the storm control meter index.
  92  * Input:
  93  *      port       - port id
  94  *      storm_type - storm group type
  95  * Output:
  96  *      pIndex     - storm control meter index.
  97  * Return:
  98  *      RT_ERR_OK
  99  *      RT_ERR_FAILED
 100  *      RT_ERR_PORT_ID - Invalid port id
 101  *      RT_ERR_FILTER_METER_ID  - Invalid meter
 102  * Note:
 103  *
 104  */
 105 rtk_api_ret_t rtk_rate_stormControlMeterIdx_get(rtk_port_t port, rtk_rate_storm_group_t stormType, rtk_uint32 *pIndex)
 106 {
 107     rtk_api_ret_t retVal;
 108
 109     /* Check initialization state */
 110     RTK_CHK_INIT_STATE();
 111
 112     /* Check Port Valid */
 113     RTK_CHK_PORT_VALID(port);
 114
 115     if (stormType >= STORM_GROUP_END)
 116         return RT_ERR_SFC_UNKNOWN_GROUP;
 117
 118     if (NULL == pIndex )
 119         return RT_ERR_NULL_POINTER;
 120
 121     switch (stormType)
 122     {
 123         case STORM_GROUP_UNKNOWN_UNICAST:
 124             if ((retVal = rtl8367c_getAsicStormFilterUnknownUnicastMeter(rtk_switch_port_L2P_get(port), pIndex))!=RT_ERR_OK)
 125                 return retVal;
 126             break;
 127         case STORM_GROUP_UNKNOWN_MULTICAST:
 128             if ((retVal = rtl8367c_getAsicStormFilterUnknownMulticastMeter(rtk_switch_port_L2P_get(port), pIndex))!=RT_ERR_OK)
 129                 return retVal;
 130             break;
 131         case STORM_GROUP_MULTICAST:
 132             if ((retVal = rtl8367c_getAsicStormFilterMulticastMeter(rtk_switch_port_L2P_get(port), pIndex))!=RT_ERR_OK)
 133                 return retVal;
 134             break;
 135         case STORM_GROUP_BROADCAST:
 136             if ((retVal = rtl8367c_getAsicStormFilterBroadcastMeter(rtk_switch_port_L2P_get(port), pIndex))!=RT_ERR_OK)
 137                 return retVal;
 138             break;
 139         default:
 140             break;
 141     }
 142
 143     return RT_ERR_OK;
 144 }
 145
 146 /* Function Name:
 147  *      rtk_rate_stormControlPortEnable_set
 148  * Description:
 149  *      Set enable status of storm control on specified port.
 150  * Input:
 151  *      port       - port id
 152  *      stormType  - storm group type
 153  *      enable     - enable status of storm control
 154  * Output:
 155  *      None
 156  * Return:
 157  *      RT_ERR_OK
 158  *      RT_ERR_FAILED
 159  *      RT_ERR_NOT_INIT          - The module is not initial
 160  *      RT_ERR_PORT_ID           - invalid port id
 161  *      RT_ERR_INPUT             - invalid input parameter
 162  * Note:
 163  *
 164  */
 165 rtk_api_ret_t rtk_rate_stormControlPortEnable_set(rtk_port_t port, rtk_rate_storm_group_t stormType, rtk_enable_t enable)
 166 {
 167     rtk_api_ret_t retVal;
 168
 169     /* Check initialization state */
 170     RTK_CHK_INIT_STATE();
 171
 172     /* Check Port Valid */
 173     RTK_CHK_PORT_VALID(port);
 174
 175     if (stormType >= STORM_GROUP_END)
 176         return RT_ERR_SFC_UNKNOWN_GROUP;
 177
 178     if (enable >= RTK_ENABLE_END)
 179         return RT_ERR_ENABLE;
 180
 181     switch (stormType)
 182     {
 183         case STORM_GROUP_UNKNOWN_UNICAST:
 184             if ((retVal = rtl8367c_setAsicStormFilterUnknownUnicastEnable(rtk_switch_port_L2P_get(port), enable)) != RT_ERR_OK)
 185                 return retVal;
 186             break;
 187         case STORM_GROUP_UNKNOWN_MULTICAST:
 188             if ((retVal = rtl8367c_setAsicStormFilterUnknownMulticastEnable(rtk_switch_port_L2P_get(port), enable)) != RT_ERR_OK)
 189                 return retVal;
 190             break;
 191         case STORM_GROUP_MULTICAST:
 192             if ((retVal = rtl8367c_setAsicStormFilterMulticastEnable(rtk_switch_port_L2P_get(port), enable)) != RT_ERR_OK)
 193                 return retVal;
 194             break;
 195         case STORM_GROUP_BROADCAST:
 196             if ((retVal = rtl8367c_setAsicStormFilterBroadcastEnable(rtk_switch_port_L2P_get(port), enable)) != RT_ERR_OK)
 197                 return retVal;
 198             break;
 199         default:
 200             break;
 201     }
 202
 203     return RT_ERR_OK;
 204 }
 205
 206 /* Function Name:
 207  *      rtk_rate_stormControlPortEnable_set
 208  * Description:
 209  *      Set enable status of storm control on specified port.
 210  * Input:
 211  *      port       - port id
 212  *      stormType  - storm group type
 213  * Output:
 214  *      pEnable     - enable status of storm control
 215  * Return:
 216  *      RT_ERR_OK
 217  *      RT_ERR_FAILED
 218  *      RT_ERR_NOT_INIT          - The module is not initial
 219  *      RT_ERR_PORT_ID           - invalid port id
 220  *      RT_ERR_INPUT             - invalid input parameter
 221  * Note:
 222  *
 223  */
 224 rtk_api_ret_t rtk_rate_stormControlPortEnable_get(rtk_port_t port, rtk_rate_storm_group_t stormType, rtk_enable_t *pEnable)
 225 {
 226     rtk_api_ret_t retVal;
 227
 228     /* Check initialization state */
 229     RTK_CHK_INIT_STATE();
 230
 231     /* Check Port Valid */
 232     RTK_CHK_PORT_VALID(port);
 233
 234     if (stormType >= STORM_GROUP_END)
 235         return RT_ERR_SFC_UNKNOWN_GROUP;
 236
 237     if (NULL == pEnable)
 238         return RT_ERR_ENABLE;
 239
 240     switch (stormType)
 241     {
 242         case STORM_GROUP_UNKNOWN_UNICAST:
 243             if ((retVal = rtl8367c_getAsicStormFilterUnknownUnicastEnable(rtk_switch_port_L2P_get(port), pEnable)) != RT_ERR_OK)
 244                 return retVal;
 245             break;
 246         case STORM_GROUP_UNKNOWN_MULTICAST:
 247             if ((retVal = rtl8367c_getAsicStormFilterUnknownMulticastEnable(rtk_switch_port_L2P_get(port), pEnable)) != RT_ERR_OK)
 248                 return retVal;
 249             break;
 250         case STORM_GROUP_MULTICAST:
 251             if ((retVal = rtl8367c_getAsicStormFilterMulticastEnable(rtk_switch_port_L2P_get(port), pEnable)) != RT_ERR_OK)
 252                 return retVal;
 253             break;
 254         case STORM_GROUP_BROADCAST:
 255             if ((retVal = rtl8367c_getAsicStormFilterBroadcastEnable(rtk_switch_port_L2P_get(port), pEnable)) != RT_ERR_OK)
 256                 return retVal;
 257             break;
 258         default:
 259             break;
 260     }
 261
 262     return RT_ERR_OK;
 263 }
 264
 265 /* Function Name:
 266  *      rtk_storm_bypass_set
 267  * Description:
 268  *      Set bypass storm filter control configuration.
 269  * Input:
 270  *      type    - Bypass storm filter control type.
 271  *      enable  - Bypass status.
 272  * Output:
 273  *      None
 274  * Return:
 275  *      RT_ERR_OK           - OK
 276  *      RT_ERR_FAILED       - Failed
 277  *      RT_ERR_SMI          - SMI access error
 278  *      RT_ERR_INPUT        - Invalid input parameters.
 279  *      RT_ERR_ENABLE       - Invalid IFG parameter
 280  * Note:
 281  *
 282  *      This API can set per-port bypass stomr filter control frame type including RMA and igmp.
 283  *      The bypass frame type is as following:
 284  *      - BYPASS_BRG_GROUP,
 285  *      - BYPASS_FD_PAUSE,
 286  *      - BYPASS_SP_MCAST,
 287  *      - BYPASS_1X_PAE,
 288  *      - BYPASS_UNDEF_BRG_04,
 289  *      - BYPASS_UNDEF_BRG_05,
 290  *      - BYPASS_UNDEF_BRG_06,
 291  *      - BYPASS_UNDEF_BRG_07,
 292  *      - BYPASS_PROVIDER_BRIDGE_GROUP_ADDRESS,
 293  *      - BYPASS_UNDEF_BRG_09,
 294  *      - BYPASS_UNDEF_BRG_0A,
 295  *      - BYPASS_UNDEF_BRG_0B,
 296  *      - BYPASS_UNDEF_BRG_0C,
 297  *      - BYPASS_PROVIDER_BRIDGE_GVRP_ADDRESS,
 298  *      - BYPASS_8021AB,
 299  *      - BYPASS_UNDEF_BRG_0F,
 300  *      - BYPASS_BRG_MNGEMENT,
 301  *      - BYPASS_UNDEFINED_11,
 302  *      - BYPASS_UNDEFINED_12,
 303  *      - BYPASS_UNDEFINED_13,
 304  *      - BYPASS_UNDEFINED_14,
 305  *      - BYPASS_UNDEFINED_15,
 306  *      - BYPASS_UNDEFINED_16,
 307  *      - BYPASS_UNDEFINED_17,
 308  *      - BYPASS_UNDEFINED_18,
 309  *      - BYPASS_UNDEFINED_19,
 310  *      - BYPASS_UNDEFINED_1A,
 311  *      - BYPASS_UNDEFINED_1B,
 312  *      - BYPASS_UNDEFINED_1C,
 313  *      - BYPASS_UNDEFINED_1D,
 314  *      - BYPASS_UNDEFINED_1E,
 315  *      - BYPASS_UNDEFINED_1F,
 316  *      - BYPASS_GMRP,
 317  *      - BYPASS_GVRP,
 318  *      - BYPASS_UNDEF_GARP_22,
 319  *      - BYPASS_UNDEF_GARP_23,
 320  *      - BYPASS_UNDEF_GARP_24,
 321  *      - BYPASS_UNDEF_GARP_25,
 322  *      - BYPASS_UNDEF_GARP_26,
 323  *      - BYPASS_UNDEF_GARP_27,
 324  *      - BYPASS_UNDEF_GARP_28,
 325  *      - BYPASS_UNDEF_GARP_29,
 326  *      - BYPASS_UNDEF_GARP_2A,
 327  *      - BYPASS_UNDEF_GARP_2B,
 328  *      - BYPASS_UNDEF_GARP_2C,
 329  *      - BYPASS_UNDEF_GARP_2D,
 330  *      - BYPASS_UNDEF_GARP_2E,
 331  *      - BYPASS_UNDEF_GARP_2F,
 332  *      - BYPASS_IGMP.
 333  *      - BYPASS_CDP.
 334  *      - BYPASS_CSSTP.
 335  *      - BYPASS_LLDP.
 336  */
 337 rtk_api_ret_t rtk_storm_bypass_set(rtk_storm_bypass_t type, rtk_enable_t enable)
 338 {
 339     rtk_api_ret_t retVal;
 340     rtl8367c_rma_t rmacfg;
 341     rtk_uint32 tmp;
 342
 343     /* Check initialization state */
 344     RTK_CHK_INIT_STATE();
 345
 346     if (type >= BYPASS_END)
 347         return RT_ERR_INPUT;
 348
 349     if (enable >= RTK_ENABLE_END)
 350         return RT_ERR_INPUT;
 351
 352     if (type >= 0 && type <= BYPASS_UNDEF_GARP_2F)
 353     {
 354         if ((retVal = rtl8367c_getAsicRma(type, &rmacfg)) != RT_ERR_OK)
 355             return retVal;
 356
 357         rmacfg.discard_storm_filter = enable;
 358
 359         if ((retVal = rtl8367c_setAsicRma(type, &rmacfg)) != RT_ERR_OK)
 360             return retVal;
 361     }
 362     else if(type == BYPASS_IGMP)
 363     {
 364         if ((retVal = rtl8367c_setAsicIGMPBypassStormCTRL(enable)) != RT_ERR_OK)
 365             return retVal;
 366     }
 367     else if (type == BYPASS_CDP)
 368     {
 369         if ((retVal = rtl8367c_getAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
 370             return retVal;
 371
 372         rmacfg.discard_storm_filter = enable;
 373
 374         if ((retVal = rtl8367c_setAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
 375             return retVal;
 376     }
 377     else if (type  == BYPASS_CSSTP)
 378     {
 379         if ((retVal = rtl8367c_getAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
 380             return retVal;
 381
 382         rmacfg.discard_storm_filter = enable;
 383
 384         if ((retVal = rtl8367c_setAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
 385             return retVal;
 386     }
 387     else if (type  == BYPASS_LLDP)
 388     {
 389         if ((retVal = rtl8367c_getAsicRmaLldp(&tmp, &rmacfg)) != RT_ERR_OK)
 390             return retVal;
 391
 392         rmacfg.discard_storm_filter = enable;
 393
 394         if ((retVal = rtl8367c_setAsicRmaLldp(tmp, &rmacfg)) != RT_ERR_OK)
 395             return retVal;
 396     }
 397     else
 398         return RT_ERR_INPUT;
 399
 400     return RT_ERR_OK;
 401 }
 402
 403 /* Function Name:
 404  *      rtk_storm_bypass_get
 405  * Description:
 406  *      Get bypass storm filter control configuration.
 407  * Input:
 408  *      type - Bypass storm filter control type.
 409  * Output:
 410  *      pEnable - Bypass status.
 411  * Return:
 412  *      RT_ERR_OK           - OK
 413  *      RT_ERR_FAILED       - Failed
 414  *      RT_ERR_SMI          - SMI access error
 415  *      RT_ERR_INPUT        - Invalid input parameters.
 416  * Note:
 417  *      This API can get per-port bypass stomr filter control frame type including RMA and igmp.
 418  *      The bypass frame type is as following:
 419  *      - BYPASS_BRG_GROUP,
 420  *      - BYPASS_FD_PAUSE,
 421  *      - BYPASS_SP_MCAST,
 422  *      - BYPASS_1X_PAE,
 423  *      - BYPASS_UNDEF_BRG_04,
 424  *      - BYPASS_UNDEF_BRG_05,
 425  *      - BYPASS_UNDEF_BRG_06,
 426  *      - BYPASS_UNDEF_BRG_07,
 427  *      - BYPASS_PROVIDER_BRIDGE_GROUP_ADDRESS,
 428  *      - BYPASS_UNDEF_BRG_09,
 429  *      - BYPASS_UNDEF_BRG_0A,
 430  *      - BYPASS_UNDEF_BRG_0B,
 431  *      - BYPASS_UNDEF_BRG_0C,
 432  *      - BYPASS_PROVIDER_BRIDGE_GVRP_ADDRESS,
 433  *      - BYPASS_8021AB,
 434  *      - BYPASS_UNDEF_BRG_0F,
 435  *      - BYPASS_BRG_MNGEMENT,
 436  *      - BYPASS_UNDEFINED_11,
 437  *      - BYPASS_UNDEFINED_12,
 438  *      - BYPASS_UNDEFINED_13,
 439  *      - BYPASS_UNDEFINED_14,
 440  *      - BYPASS_UNDEFINED_15,
 441  *      - BYPASS_UNDEFINED_16,
 442  *      - BYPASS_UNDEFINED_17,
 443  *      - BYPASS_UNDEFINED_18,
 444  *      - BYPASS_UNDEFINED_19,
 445  *      - BYPASS_UNDEFINED_1A,
 446  *      - BYPASS_UNDEFINED_1B,
 447  *      - BYPASS_UNDEFINED_1C,
 448  *      - BYPASS_UNDEFINED_1D,
 449  *      - BYPASS_UNDEFINED_1E,
 450  *      - BYPASS_UNDEFINED_1F,
 451  *      - BYPASS_GMRP,
 452  *      - BYPASS_GVRP,
 453  *      - BYPASS_UNDEF_GARP_22,
 454  *      - BYPASS_UNDEF_GARP_23,
 455  *      - BYPASS_UNDEF_GARP_24,
 456  *      - BYPASS_UNDEF_GARP_25,
 457  *      - BYPASS_UNDEF_GARP_26,
 458  *      - BYPASS_UNDEF_GARP_27,
 459  *      - BYPASS_UNDEF_GARP_28,
 460  *      - BYPASS_UNDEF_GARP_29,
 461  *      - BYPASS_UNDEF_GARP_2A,
 462  *      - BYPASS_UNDEF_GARP_2B,
 463  *      - BYPASS_UNDEF_GARP_2C,
 464  *      - BYPASS_UNDEF_GARP_2D,
 465  *      - BYPASS_UNDEF_GARP_2E,
 466  *      - BYPASS_UNDEF_GARP_2F,
 467  *      - BYPASS_IGMP.
 468  *      - BYPASS_CDP.
 469  *      - BYPASS_CSSTP.
 470  *      - BYPASS_LLDP.
 471  */
 472 rtk_api_ret_t rtk_storm_bypass_get(rtk_storm_bypass_t type, rtk_enable_t *pEnable)
 473 {
 474     rtk_api_ret_t retVal;
 475     rtl8367c_rma_t rmacfg;
 476     rtk_uint32 tmp;
 477
 478     /* Check initialization state */
 479     RTK_CHK_INIT_STATE();
 480
 481     if (type >= BYPASS_END)
 482         return RT_ERR_INPUT;
 483
 484     if(NULL == pEnable)
 485         return RT_ERR_NULL_POINTER;
 486
 487     if (type >= 0 && type <= BYPASS_UNDEF_GARP_2F)
 488     {
 489         if ((retVal = rtl8367c_getAsicRma(type, &rmacfg)) != RT_ERR_OK)
 490             return retVal;
 491
 492         *pEnable = rmacfg.discard_storm_filter;
 493     }
 494     else if(type == BYPASS_IGMP)
 495     {
 496         if ((retVal = rtl8367c_getAsicIGMPBypassStormCTRL(pEnable)) != RT_ERR_OK)
 497             return retVal;
 498     }
 499     else if (type == BYPASS_CDP)
 500     {
 501         if ((retVal = rtl8367c_getAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
 502             return retVal;
 503
 504         *pEnable = rmacfg.discard_storm_filter;
 505     }
 506     else if (type == BYPASS_CSSTP)
 507     {
 508         if ((retVal = rtl8367c_getAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
 509             return retVal;
 510
 511         *pEnable = rmacfg.discard_storm_filter;
 512     }
 513     else if (type == BYPASS_LLDP)
 514     {
 515         if ((retVal = rtl8367c_getAsicRmaLldp(&tmp,&rmacfg)) != RT_ERR_OK)
 516             return retVal;
 517
 518         *pEnable = rmacfg.discard_storm_filter;
 519     }
 520     else
 521         return RT_ERR_INPUT;
 522
 523     return RT_ERR_OK;
 524 }
 525
 526 /* Function Name:
 527  *      rtk_rate_stormControlExtPortmask_set
 528  * Description:
 529  *      Set externsion storm control port mask
 530  * Input:
 531  *      pPortmask  - port mask
 532  * Output:
 533  *      None
 534  * Return:
 535  *      RT_ERR_OK
 536  *      RT_ERR_FAILED
 537  *      RT_ERR_NOT_INIT          - The module is not initial
 538  *      RT_ERR_INPUT             - invalid input parameter
 539  * Note:
 540  *
 541  */
 542 rtk_api_ret_t rtk_rate_stormControlExtPortmask_set(rtk_portmask_t *pPortmask)
 543 {
 544     rtk_api_ret_t retVal;
 545     rtk_uint32 pmask;
 546
 547     /* Check initialization state */
 548     RTK_CHK_INIT_STATE();
 549
 550     if(NULL == pPortmask)
 551         return RT_ERR_NULL_POINTER;
 552
 553     if ((retVal = rtk_switch_portmask_L2P_get(pPortmask, &pmask)) != RT_ERR_OK)
 554         return retVal;
 555
 556     if ((retVal = rtl8367c_setAsicStormFilterExtEnablePortMask(pmask)) != RT_ERR_OK)
 557         return retVal;
 558
 559     return RT_ERR_OK;
 560 }
 561
 562 /* Function Name:
 563  *      rtk_rate_stormControlExtPortmask_get
 564  * Description:
 565  *      Set externsion storm control port mask
 566  * Input:
 567  *      None
 568  * Output:
 569  *      pPortmask  - port mask
 570  * Return:
 571  *      RT_ERR_OK
 572  *      RT_ERR_FAILED
 573  *      RT_ERR_NOT_INIT          - The module is not initial
 574  *      RT_ERR_INPUT             - invalid input parameter
 575  * Note:
 576  *
 577  */
 578 rtk_api_ret_t rtk_rate_stormControlExtPortmask_get(rtk_portmask_t *pPortmask)
 579 {
 580     rtk_api_ret_t retVal;
 581     rtk_uint32 pmask;
 582
 583     /* Check initialization state */
 584     RTK_CHK_INIT_STATE();
 585
 586     if(NULL == pPortmask)
 587         return RT_ERR_NULL_POINTER;
 588
 589     if ((retVal = rtl8367c_getAsicStormFilterExtEnablePortMask(&pmask)) != RT_ERR_OK)
 590         return retVal;
 591
 592     if ((retVal = rtk_switch_portmask_P2L_get(pmask, pPortmask)) != RT_ERR_OK)
 593         return retVal;
 594
 595     return RT_ERR_OK;
 596 }
 597
 598 /* Function Name:
 599  *      rtk_rate_stormControlExtEnable_set
 600  * Description:
 601  *      Set externsion storm control state
 602  * Input:
 603  *      stormType   - storm group type
 604  *      enable      - externsion storm control state
 605  * Output:
 606  *      None
 607  * Return:
 608  *      RT_ERR_OK
 609  *      RT_ERR_FAILED
 610  *      RT_ERR_NOT_INIT          - The module is not initial
 611  *      RT_ERR_INPUT             - invalid input parameter
 612  * Note:
 613  *
 614  */
 615 rtk_api_ret_t rtk_rate_stormControlExtEnable_set(rtk_rate_storm_group_t stormType, rtk_enable_t enable)
 616 {
 617     rtk_api_ret_t retVal;
 618
 619     /* Check initialization state */
 620     RTK_CHK_INIT_STATE();
 621
 622     if (stormType >= STORM_GROUP_END)
 623         return RT_ERR_SFC_UNKNOWN_GROUP;
 624
 625     if (enable >= RTK_ENABLE_END)
 626         return RT_ERR_ENABLE;
 627
 628     switch (stormType)
 629     {
 630         case STORM_GROUP_UNKNOWN_UNICAST:
 631             if ((retVal = rtl8367c_setAsicStormFilterExtUnknownUnicastEnable(enable)) != RT_ERR_OK)
 632                 return retVal;
 633             break;
 634         case STORM_GROUP_UNKNOWN_MULTICAST:
 635             if ((retVal = rtl8367c_setAsicStormFilterExtUnknownMulticastEnable(enable)) != RT_ERR_OK)
 636                 return retVal;
 637             break;
 638         case STORM_GROUP_MULTICAST:
 639             if ((retVal = rtl8367c_setAsicStormFilterExtMulticastEnable(enable)) != RT_ERR_OK)
 640                 return retVal;
 641             break;
 642         case STORM_GROUP_BROADCAST:
 643             if ((retVal = rtl8367c_setAsicStormFilterExtBroadcastEnable(enable)) != RT_ERR_OK)
 644                 return retVal;
 645             break;
 646         default:
 647             break;
 648     }
 649
 650     return RT_ERR_OK;
 651 }
 652
 653 /* Function Name:
 654  *      rtk_rate_stormControlExtEnable_get
 655  * Description:
 656  *      Get externsion storm control state
 657  * Input:
 658  *      stormType   - storm group type
 659  * Output:
 660  *      pEnable     - externsion storm control state
 661  * Return:
 662  *      RT_ERR_OK
 663  *      RT_ERR_FAILED
 664  *      RT_ERR_NOT_INIT          - The module is not initial
 665  *      RT_ERR_INPUT             - invalid input parameter
 666  * Note:
 667  *
 668  */
 669 rtk_api_ret_t rtk_rate_stormControlExtEnable_get(rtk_rate_storm_group_t stormType, rtk_enable_t *pEnable)
 670 {
 671     rtk_api_ret_t retVal;
 672
 673     /* Check initialization state */
 674     RTK_CHK_INIT_STATE();
 675
 676     if (stormType >= STORM_GROUP_END)
 677         return RT_ERR_SFC_UNKNOWN_GROUP;
 678
 679     if (NULL == pEnable)
 680         return RT_ERR_NULL_POINTER;
 681
 682     switch (stormType)
 683     {
 684         case STORM_GROUP_UNKNOWN_UNICAST:
 685             if ((retVal = rtl8367c_getAsicStormFilterExtUnknownUnicastEnable((rtk_uint32 *)pEnable)) != RT_ERR_OK)
 686                 return retVal;
 687             break;
 688         case STORM_GROUP_UNKNOWN_MULTICAST:
 689             if ((retVal = rtl8367c_getAsicStormFilterExtUnknownMulticastEnable((rtk_uint32 *)pEnable)) != RT_ERR_OK)
 690                 return retVal;
 691             break;
 692         case STORM_GROUP_MULTICAST:
 693             if ((retVal = rtl8367c_getAsicStormFilterExtMulticastEnable((rtk_uint32 *)pEnable)) != RT_ERR_OK)
 694                 return retVal;
 695             break;
 696         case STORM_GROUP_BROADCAST:
 697             if ((retVal = rtl8367c_getAsicStormFilterExtBroadcastEnable((rtk_uint32 *)pEnable)) != RT_ERR_OK)
 698                 return retVal;
 699             break;
 700         default:
 701             break;
 702     }
 703
 704     return RT_ERR_OK;
 705 }
 706
 707 /* Function Name:
 708  *      rtk_rate_stormControlExtMeterIdx_set
 709  * Description:
 710  *      Set externsion storm control meter index
 711  * Input:
 712  *      stormType   - storm group type
 713  *      index       - externsion storm control state
 714  * Output:
 715  *      None
 716  * Return:
 717  *      RT_ERR_OK
 718  *      RT_ERR_FAILED
 719  *      RT_ERR_NOT_INIT          - The module is not initial
 720  *      RT_ERR_INPUT             - invalid input parameter
 721  * Note:
 722  *
 723  */
 724 rtk_api_ret_t rtk_rate_stormControlExtMeterIdx_set(rtk_rate_storm_group_t stormType, rtk_uint32 index)
 725 {
 726     rtk_api_ret_t retVal;
 727
 728     /* Check initialization state */
 729     RTK_CHK_INIT_STATE();
 730
 731     if (stormType >= STORM_GROUP_END)
 732         return RT_ERR_SFC_UNKNOWN_GROUP;
 733
 734     if (index > RTK_MAX_METER_ID)
 735         return RT_ERR_FILTER_METER_ID;
 736
 737     switch (stormType)
 738     {
 739         case STORM_GROUP_UNKNOWN_UNICAST:
 740             if ((retVal = rtl8367c_setAsicStormFilterExtUnknownUnicastMeter(index))!=RT_ERR_OK)
 741                 return retVal;
 742             break;
 743         case STORM_GROUP_UNKNOWN_MULTICAST:
 744             if ((retVal = rtl8367c_setAsicStormFilterExtUnknownMulticastMeter(index))!=RT_ERR_OK)
 745                 return retVal;
 746             break;
 747         case STORM_GROUP_MULTICAST:
 748             if ((retVal = rtl8367c_setAsicStormFilterExtMulticastMeter(index))!=RT_ERR_OK)
 749                 return retVal;
 750             break;
 751         case STORM_GROUP_BROADCAST:
 752             if ((retVal = rtl8367c_setAsicStormFilterExtBroadcastMeter(index))!=RT_ERR_OK)
 753                 return retVal;
 754             break;
 755         default:
 756             break;
 757     }
 758
 759     return RT_ERR_OK;
 760 }
 761
 762 /* Function Name:
 763  *      rtk_rate_stormControlExtMeterIdx_get
 764  * Description:
 765  *      Get externsion storm control meter index
 766  * Input:
 767  *      stormType   - storm group type
 768  *      pIndex      - externsion storm control state
 769  * Output:
 770  *      None
 771  * Return:
 772  *      RT_ERR_OK
 773  *      RT_ERR_FAILED
 774  *      RT_ERR_NOT_INIT          - The module is not initial
 775  *      RT_ERR_INPUT             - invalid input parameter
 776  * Note:
 777  *
 778  */
 779 rtk_api_ret_t rtk_rate_stormControlExtMeterIdx_get(rtk_rate_storm_group_t stormType, rtk_uint32 *pIndex)
 780 {
 781     rtk_api_ret_t retVal;
 782
 783     /* Check initialization state */
 784     RTK_CHK_INIT_STATE();
 785
 786     if (stormType >= STORM_GROUP_END)
 787         return RT_ERR_SFC_UNKNOWN_GROUP;
 788
 789     if(NULL == pIndex)
 790         return RT_ERR_NULL_POINTER;
 791
 792     switch (stormType)
 793     {
 794         case STORM_GROUP_UNKNOWN_UNICAST:
 795             if ((retVal = rtl8367c_getAsicStormFilterExtUnknownUnicastMeter(pIndex))!=RT_ERR_OK)
 796                 return retVal;
 797             break;
 798         case STORM_GROUP_UNKNOWN_MULTICAST:
 799             if ((retVal = rtl8367c_getAsicStormFilterExtUnknownMulticastMeter(pIndex))!=RT_ERR_OK)
 800                 return retVal;
 801             break;
 802         case STORM_GROUP_MULTICAST:
 803             if ((retVal = rtl8367c_getAsicStormFilterExtMulticastMeter(pIndex))!=RT_ERR_OK)
 804                 return retVal;
 805             break;
 806         case STORM_GROUP_BROADCAST:
 807             if ((retVal = rtl8367c_getAsicStormFilterExtBroadcastMeter(pIndex))!=RT_ERR_OK)
 808                 return retVal;
 809             break;
 810         default:
 811             break;
 812     }
 813
 814     return RT_ERR_OK;
 815 }
 816