target/linux/mediatek/files-5.4/drivers/net/phy/rtk/rtl8367c/trap.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 Trap module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <trap.h>
  21 #include <string.h>
  22
  23 #include <rtl8367c_asicdrv.h>
  24 #include <rtl8367c_asicdrv_port.h>
  25 #include <rtl8367c_asicdrv_igmp.h>
  26 #include <rtl8367c_asicdrv_rma.h>
  27 #include <rtl8367c_asicdrv_eav.h>
  28 #include <rtl8367c_asicdrv_oam.h>
  29 #include <rtl8367c_asicdrv_svlan.h>
  30 #include <rtl8367c_asicdrv_unknownMulticast.h>
  31 #include <rtl8367c_asicdrv_dot1x.h>
  32
  33 /* Function Name:
  34  *      rtk_trap_unknownUnicastPktAction_set
  35  * Description:
  36  *      Set unknown unicast packet action configuration.
  37  * Input:
  38  *      port            - ingress port ID for unknown unicast packet
  39  *      ucast_action    - Unknown unicast action.
  40  * Output:
  41  *      None
  42  * Return:
  43  *      RT_ERR_OK                  - OK
  44  *      RT_ERR_FAILED              - Failed
  45  *      RT_ERR_SMI                 - SMI access error
  46  *      RT_ERR_NOT_ALLOWED         - Invalid action.
  47  *      RT_ERR_INPUT               - Invalid input parameters.
  48  * Note:
  49  *      This API can set unknown unicast packet action configuration.
  50  *      The unknown unicast action is as following:
  51  *          - UCAST_ACTION_FORWARD_PMASK
  52  *          - UCAST_ACTION_DROP
  53  *          - UCAST_ACTION_TRAP2CPU
  54  *          - UCAST_ACTION_FLOODING
  55  */
  56 rtk_api_ret_t rtk_trap_unknownUnicastPktAction_set(rtk_port_t port, rtk_trap_ucast_action_t ucast_action)
  57 {
  58     rtk_api_ret_t retVal;
  59
  60     /* Check initialization state */
  61     RTK_CHK_INIT_STATE();
  62
  63     /* check port valid */
  64     RTK_CHK_PORT_VALID(port);
  65
  66     if (ucast_action >= UCAST_ACTION_END)
  67         return RT_ERR_INPUT;
  68
  69     if ((retVal = rtl8367c_setAsicPortUnknownDaBehavior(rtk_switch_port_L2P_get(port), ucast_action)) != RT_ERR_OK)
  70         return retVal;
  71
  72     return RT_ERR_OK;
  73 }
  74
  75 /* Function Name:
  76  *      rtk_trap_unknownUnicastPktAction_get
  77  * Description:
  78  *      Get unknown unicast packet action configuration.
  79  * Input:
  80  *      port            - ingress port ID for unknown unicast packet
  81  * Output:
  82  *      pUcast_action   - Unknown unicast action.
  83  * Return:
  84  *      RT_ERR_OK                  - OK
  85  *      RT_ERR_FAILED              - Failed
  86  *      RT_ERR_SMI                 - SMI access error
  87  *      RT_ERR_NOT_ALLOWED         - Invalid action.
  88  *      RT_ERR_INPUT               - Invalid input parameters.
  89  *      RT_ERR_NULL_POINTER        - Null pointer
  90  * Note:
  91  *      This API can get unknown unicast packet action configuration.
  92  *      The unknown unicast action is as following:
  93  *          - UCAST_ACTION_FORWARD_PMASK
  94  *          - UCAST_ACTION_DROP
  95  *          - UCAST_ACTION_TRAP2CPU
  96  *          - UCAST_ACTION_FLOODING
  97  */
  98 rtk_api_ret_t rtk_trap_unknownUnicastPktAction_get(rtk_port_t port, rtk_trap_ucast_action_t *pUcast_action)
  99 {
 100     rtk_api_ret_t retVal;
 101
 102     /* Check initialization state */
 103     RTK_CHK_INIT_STATE();
 104
 105     /* check port valid */
 106     RTK_CHK_PORT_VALID(port);
 107
 108     if (NULL == pUcast_action)
 109         return RT_ERR_NULL_POINTER;
 110
 111     if ((retVal = rtl8367c_getAsicPortUnknownDaBehavior(rtk_switch_port_L2P_get(port), pUcast_action)) != RT_ERR_OK)
 112         return retVal;
 113
 114     return RT_ERR_OK;
 115 }
 116
 117 /* Function Name:
 118  *      rtk_trap_unknownMacPktAction_set
 119  * Description:
 120  *      Set unknown source MAC packet action configuration.
 121  * Input:
 122  *      ucast_action    - Unknown source MAC action.
 123  * Output:
 124  *      None
 125  * Return:
 126  *      RT_ERR_OK                  - OK
 127  *      RT_ERR_FAILED              - Failed
 128  *      RT_ERR_SMI                 - SMI access error
 129  *      RT_ERR_NOT_ALLOWED         - Invalid action.
 130  *      RT_ERR_INPUT               - Invalid input parameters.
 131  * Note:
 132  *      This API can set unknown unicast packet action configuration.
 133  *      The unknown unicast action is as following:
 134  *          - UCAST_ACTION_FORWARD_PMASK
 135  *          - UCAST_ACTION_DROP
 136  *          - UCAST_ACTION_TRAP2CPU
 137  */
 138 rtk_api_ret_t rtk_trap_unknownMacPktAction_set(rtk_trap_ucast_action_t ucast_action)
 139 {
 140     rtk_api_ret_t retVal;
 141
 142     /* Check initialization state */
 143     RTK_CHK_INIT_STATE();
 144
 145     if (ucast_action >= UCAST_ACTION_FLOODING)
 146         return RT_ERR_INPUT;
 147
 148     if ((retVal = rtl8367c_setAsicPortUnknownSaBehavior(ucast_action)) != RT_ERR_OK)
 149         return retVal;
 150
 151     return RT_ERR_OK;
 152 }
 153
 154 /* Function Name:
 155  *      rtk_trap_unknownMacPktAction_get
 156  * Description:
 157  *      Get unknown source MAC packet action configuration.
 158  * Input:
 159  *      None.
 160  * Output:
 161  *      pUcast_action   - Unknown source MAC action.
 162  * Return:
 163  *      RT_ERR_OK                  - OK
 164  *      RT_ERR_FAILED              - Failed
 165  *      RT_ERR_SMI                 - SMI access error
 166  *      RT_ERR_NULL_POINTER        - Null Pointer.
 167  *      RT_ERR_INPUT               - Invalid input parameters.
 168  * Note:
 169  *
 170  */
 171 rtk_api_ret_t rtk_trap_unknownMacPktAction_get(rtk_trap_ucast_action_t *pUcast_action)
 172 {
 173     rtk_api_ret_t retVal;
 174
 175     /* Check initialization state */
 176     RTK_CHK_INIT_STATE();
 177
 178     if(NULL == pUcast_action)
 179         return RT_ERR_NULL_POINTER;
 180
 181     if ((retVal = rtl8367c_getAsicPortUnknownSaBehavior(pUcast_action)) != RT_ERR_OK)
 182         return retVal;
 183
 184     return RT_ERR_OK;
 185 }
 186
 187 /* Function Name:
 188  *      rtk_trap_unmatchMacPktAction_set
 189  * Description:
 190  *      Set unmatch source MAC packet action configuration.
 191  * Input:
 192  *      ucast_action    - Unknown source MAC action.
 193  * Output:
 194  *      None
 195  * Return:
 196  *      RT_ERR_OK                  - OK
 197  *      RT_ERR_FAILED              - Failed
 198  *      RT_ERR_SMI                 - SMI access error
 199  *      RT_ERR_NOT_ALLOWED         - Invalid action.
 200  *      RT_ERR_INPUT               - Invalid input parameters.
 201  * Note:
 202  *      This API can set unknown unicast packet action configuration.
 203  *      The unknown unicast action is as following:
 204  *          - UCAST_ACTION_FORWARD_PMASK
 205  *          - UCAST_ACTION_DROP
 206  *          - UCAST_ACTION_TRAP2CPU
 207  */
 208 rtk_api_ret_t rtk_trap_unmatchMacPktAction_set(rtk_trap_ucast_action_t ucast_action)
 209 {
 210     rtk_api_ret_t retVal;
 211
 212     /* Check initialization state */
 213     RTK_CHK_INIT_STATE();
 214
 215     if (ucast_action >= UCAST_ACTION_FLOODING)
 216         return RT_ERR_INPUT;
 217
 218     if ((retVal = rtl8367c_setAsicPortUnmatchedSaBehavior(ucast_action)) != RT_ERR_OK)
 219         return retVal;
 220
 221     return RT_ERR_OK;
 222 }
 223
 224 /* Function Name:
 225  *      rtk_trap_unmatchMacPktAction_get
 226  * Description:
 227  *      Get unmatch source MAC packet action configuration.
 228  * Input:
 229  *      None.
 230  * Output:
 231  *      pUcast_action   - Unknown source MAC action.
 232  * Return:
 233  *      RT_ERR_OK                  - OK
 234  *      RT_ERR_FAILED              - Failed
 235  *      RT_ERR_SMI                 - SMI access error
 236  *      RT_ERR_NOT_ALLOWED         - Invalid action.
 237  *      RT_ERR_INPUT               - Invalid input parameters.
 238  * Note:
 239  *      This API can set unknown unicast packet action configuration.
 240  *      The unknown unicast action is as following:
 241  *          - UCAST_ACTION_FORWARD_PMASK
 242  *          - UCAST_ACTION_DROP
 243  *          - UCAST_ACTION_TRAP2CPU
 244  */
 245 rtk_api_ret_t rtk_trap_unmatchMacPktAction_get(rtk_trap_ucast_action_t *pUcast_action)
 246 {
 247     rtk_api_ret_t retVal;
 248
 249     /* Check initialization state */
 250     RTK_CHK_INIT_STATE();
 251
 252     if(NULL == pUcast_action)
 253         return RT_ERR_NULL_POINTER;
 254
 255     if ((retVal = rtl8367c_getAsicPortUnmatchedSaBehavior(pUcast_action)) != RT_ERR_OK)
 256         return retVal;
 257
 258     return RT_ERR_OK;
 259 }
 260
 261 /* Function Name:
 262  *      rtk_trap_unmatchMacMoving_set
 263  * Description:
 264  *      Set unmatch source MAC packet moving state.
 265  * Input:
 266  *      port        - Port ID.
 267  *      enable      - ENABLED: allow SA moving, DISABLE: don't allow SA moving.
 268  * Output:
 269  *      None
 270  * Return:
 271  *      RT_ERR_OK                  - OK
 272  *      RT_ERR_FAILED              - Failed
 273  *      RT_ERR_SMI                 - SMI access error
 274  *      RT_ERR_NOT_ALLOWED         - Invalid action.
 275  *      RT_ERR_INPUT               - Invalid input parameters.
 276  * Note:
 277  */
 278 rtk_api_ret_t rtk_trap_unmatchMacMoving_set(rtk_port_t port, rtk_enable_t enable)
 279 {
 280     rtk_api_ret_t retVal;
 281
 282     /* Check initialization state */
 283     RTK_CHK_INIT_STATE();
 284
 285     /* check port valid */
 286     RTK_CHK_PORT_VALID(port);
 287
 288     if(enable >= RTK_ENABLE_END)
 289         return RT_ERR_INPUT;
 290
 291     if ((retVal = rtl8367c_setAsicPortUnmatchedSaMoving(rtk_switch_port_L2P_get(port), enable)) != RT_ERR_OK)
 292         return retVal;
 293
 294     return RT_ERR_OK;
 295 }
 296
 297 /* Function Name:
 298  *      rtk_trap_unmatchMacMoving_get
 299  * Description:
 300  *      Set unmatch source MAC packet moving state.
 301  * Input:
 302  *      port        - Port ID.
 303  * Output:
 304  *      pEnable     - ENABLED: allow SA moving, DISABLE: don't allow SA moving.
 305  * Return:
 306  *      RT_ERR_OK                  - OK
 307  *      RT_ERR_FAILED              - Failed
 308  *      RT_ERR_SMI                 - SMI access error
 309  *      RT_ERR_NOT_ALLOWED         - Invalid action.
 310  *      RT_ERR_INPUT               - Invalid input parameters.
 311  * Note:
 312  */
 313 rtk_api_ret_t rtk_trap_unmatchMacMoving_get(rtk_port_t port, rtk_enable_t *pEnable)
 314 {
 315     rtk_api_ret_t retVal;
 316
 317     /* Check initialization state */
 318     RTK_CHK_INIT_STATE();
 319
 320     /* check port valid */
 321     RTK_CHK_PORT_VALID(port);
 322
 323     if(NULL == pEnable)
 324         return RT_ERR_NULL_POINTER;
 325
 326     if ((retVal = rtl8367c_getAsicPortUnmatchedSaMoving(rtk_switch_port_L2P_get(port), pEnable)) != RT_ERR_OK)
 327         return retVal;
 328
 329     return RT_ERR_OK;
 330 }
 331
 332 /* Function Name:
 333  *      rtk_trap_unknownMcastPktAction_set
 334  * Description:
 335  *      Set behavior of unknown multicast
 336  * Input:
 337  *      port            - Port id.
 338  *      type            - unknown multicast packet type.
 339  *      mcast_action    - unknown multicast action.
 340  * Output:
 341  *      None
 342  * Return:
 343  *      RT_ERR_OK           - OK
 344  *      RT_ERR_FAILED       - Failed
 345  *      RT_ERR_SMI          - SMI access error
 346  *      RT_ERR_PORT_ID         - Invalid port number.
 347  *      RT_ERR_NOT_ALLOWED     - Invalid action.
 348  *      RT_ERR_INPUT         - Invalid input parameters.
 349  * Note:
 350  *      When receives an unknown multicast packet, switch may trap, drop or flood this packet
 351  *      (1) The unknown multicast packet type is as following:
 352  *          - MCAST_L2
 353  *          - MCAST_IPV4
 354  *          - MCAST_IPV6
 355  *      (2) The unknown multicast action is as following:
 356  *          - MCAST_ACTION_FORWARD
 357  *          - MCAST_ACTION_DROP
 358  *          - MCAST_ACTION_TRAP2CPU
 359  */
 360 rtk_api_ret_t rtk_trap_unknownMcastPktAction_set(rtk_port_t port, rtk_mcast_type_t type, rtk_trap_mcast_action_t mcast_action)
 361 {
 362     rtk_api_ret_t retVal;
 363     rtk_uint32 rawAction;
 364
 365     /* Check initialization state */
 366     RTK_CHK_INIT_STATE();
 367
 368     /* Check Port Valid */
 369     RTK_CHK_PORT_VALID(port);
 370
 371     if (type >= MCAST_END)
 372         return RT_ERR_INPUT;
 373
 374     if (mcast_action >= MCAST_ACTION_END)
 375         return RT_ERR_INPUT;
 376
 377
 378     switch (type)
 379     {
 380         case MCAST_L2:
 381             if (MCAST_ACTION_ROUTER_PORT == mcast_action)
 382                 return RT_ERR_INPUT;
 383             else if(MCAST_ACTION_DROP_EX_RMA == mcast_action)
 384                 rawAction = L2_UNKOWN_MULTICAST_DROP_EXCLUDE_RMA;
 385             else
 386                 rawAction = (rtk_uint32)mcast_action;
 387
 388             if ((retVal = rtl8367c_setAsicUnknownL2MulticastBehavior(rtk_switch_port_L2P_get(port), rawAction)) != RT_ERR_OK)
 389                 return retVal;
 390
 391             break;
 392         case MCAST_IPV4:
 393             if (MCAST_ACTION_DROP_EX_RMA == mcast_action)
 394                 return RT_ERR_INPUT;
 395             else
 396                 rawAction = (rtk_uint32)mcast_action;
 397
 398             if ((retVal = rtl8367c_setAsicUnknownIPv4MulticastBehavior(rtk_switch_port_L2P_get(port), rawAction)) != RT_ERR_OK)
 399                 return retVal;
 400
 401             break;
 402         case MCAST_IPV6:
 403             if (MCAST_ACTION_DROP_EX_RMA == mcast_action)
 404                 return RT_ERR_INPUT;
 405             else
 406                 rawAction = (rtk_uint32)mcast_action;
 407
 408             if ((retVal = rtl8367c_setAsicUnknownIPv6MulticastBehavior(rtk_switch_port_L2P_get(port), rawAction)) != RT_ERR_OK)
 409                 return retVal;
 410
 411             break;
 412         default:
 413             break;
 414     }
 415
 416     return RT_ERR_OK;
 417 }
 418
 419 /* Function Name:
 420  *      rtk_trap_unknownMcastPktAction_get
 421  * Description:
 422  *      Get behavior of unknown multicast
 423  * Input:
 424  *      type - unknown multicast packet type.
 425  * Output:
 426  *      pMcast_action - unknown multicast action.
 427  * Return:
 428  *      RT_ERR_OK                  - OK
 429  *      RT_ERR_FAILED              - Failed
 430  *      RT_ERR_SMI                 - SMI access error
 431  *      RT_ERR_PORT_ID             - Invalid port number.
 432  *      RT_ERR_NOT_ALLOWED         - Invalid operation.
 433  *      RT_ERR_INPUT             - Invalid input parameters.
 434  * Note:
 435  *      When receives an unknown multicast packet, switch may trap, drop or flood this packet
 436  *      (1) The unknown multicast packet type is as following:
 437  *          - MCAST_L2
 438  *          - MCAST_IPV4
 439  *          - MCAST_IPV6
 440  *      (2) The unknown multicast action is as following:
 441  *          - MCAST_ACTION_FORWARD
 442  *          - MCAST_ACTION_DROP
 443  *          - MCAST_ACTION_TRAP2CPU
 444  */
 445 rtk_api_ret_t rtk_trap_unknownMcastPktAction_get(rtk_port_t port, rtk_mcast_type_t type, rtk_trap_mcast_action_t *pMcast_action)
 446 {
 447     rtk_api_ret_t retVal;
 448     rtk_uint32 rawAction;
 449
 450     /* Check initialization state */
 451     RTK_CHK_INIT_STATE();
 452
 453     /* Check Port Valid */
 454     RTK_CHK_PORT_VALID(port);
 455
 456     if (type >= MCAST_END)
 457         return RT_ERR_INPUT;
 458
 459     if(NULL == pMcast_action)
 460         return RT_ERR_NULL_POINTER;
 461
 462     switch (type)
 463     {
 464         case MCAST_L2:
 465             if ((retVal = rtl8367c_getAsicUnknownL2MulticastBehavior(rtk_switch_port_L2P_get(port), &rawAction)) != RT_ERR_OK)
 466                 return retVal;
 467
 468             if(L2_UNKOWN_MULTICAST_DROP_EXCLUDE_RMA == rawAction)
 469                 *pMcast_action = MCAST_ACTION_DROP_EX_RMA;
 470             else
 471                 *pMcast_action = (rtk_trap_mcast_action_t)rawAction;
 472
 473             break;
 474         case MCAST_IPV4:
 475             if ((retVal = rtl8367c_getAsicUnknownIPv4MulticastBehavior(rtk_switch_port_L2P_get(port), &rawAction)) != RT_ERR_OK)
 476                 return retVal;
 477
 478             *pMcast_action = (rtk_trap_mcast_action_t)rawAction;
 479             break;
 480         case MCAST_IPV6:
 481             if ((retVal = rtl8367c_getAsicUnknownIPv6MulticastBehavior(rtk_switch_port_L2P_get(port), &rawAction)) != RT_ERR_OK)
 482                 return retVal;
 483
 484             *pMcast_action = (rtk_trap_mcast_action_t)rawAction;
 485             break;
 486         default:
 487             break;
 488     }
 489
 490     return RT_ERR_OK;
 491 }
 492
 493 /* Function Name:
 494  *      rtk_trap_lldpEnable_set
 495  * Description:
 496  *      Set LLDP enable.
 497  * Input:
 498  *      enabled - LLDP enable, 0: follow RMA, 1: use LLDP action.
 499  * Output:
 500  *      None
 501  * Return:
 502  *      RT_ERR_OK                  - OK
 503  *      RT_ERR_FAILED              - Failed
 504  *      RT_ERR_SMI                 - SMI access error
 505  *      RT_ERR_NOT_ALLOWED         - Invalid action.
 506  *      RT_ERR_INPUT             - Invalid input parameters.
 507  * Note:
 508  *      - DMAC                                                 Assignment
 509  *      - 01:80:c2:00:00:0e ethertype = 0x88CC    LLDP
 510  *      - 01:80:c2:00:00:03 ethertype = 0x88CC
 511  *      - 01:80:c2:00:00:00 ethertype = 0x88CC
 512
 513  */
 514 rtk_api_ret_t rtk_trap_lldpEnable_set(rtk_enable_t enabled)
 515 {
 516     rtk_api_ret_t retVal;
 517     rtl8367c_rma_t rmacfg;
 518     rtk_enable_t tmp;
 519
 520     /* Check initialization state */
 521     RTK_CHK_INIT_STATE();
 522
 523     if (enabled >= RTK_ENABLE_END)
 524         return RT_ERR_ENABLE;
 525
 526     if ((retVal = rtl8367c_getAsicRmaLldp(&tmp, &rmacfg)) != RT_ERR_OK)
 527         return retVal;
 528
 529     if ((retVal = rtl8367c_setAsicRmaLldp(enabled, &rmacfg)) != RT_ERR_OK)
 530         return retVal;
 531
 532     return RT_ERR_OK;
 533 }
 534
 535 /* Function Name:
 536  *      rtk_trap_lldpEnable_get
 537  * Description:
 538  *      Get LLDP status.
 539  * Input:
 540  *      None
 541  * Output:
 542  *      pEnabled - LLDP enable, 0: follow RMA, 1: use LLDP action.
 543  * Return:
 544  *      RT_ERR_OK           - OK
 545  *      RT_ERR_FAILED       - Failed
 546  *      RT_ERR_SMI          - SMI access error
 547  *      RT_ERR_INPUT         - Invalid input parameters.
 548  * Note:
 549  *      LLDP is as following definition.
 550  *      - DMAC                                                 Assignment
 551  *      - 01:80:c2:00:00:0e ethertype = 0x88CC    LLDP
 552  *      - 01:80:c2:00:00:03 ethertype = 0x88CC
 553  *      - 01:80:c2:00:00:00 ethertype = 0x88CC
 554  */
 555 rtk_api_ret_t rtk_trap_lldpEnable_get(rtk_enable_t *pEnabled)
 556 {
 557     rtk_api_ret_t retVal;
 558     rtl8367c_rma_t rmacfg;
 559
 560     /* Check initialization state */
 561     RTK_CHK_INIT_STATE();
 562
 563     if(NULL == pEnabled)
 564         return RT_ERR_NULL_POINTER;
 565
 566     if ((retVal = rtl8367c_getAsicRmaLldp(pEnabled, &rmacfg)) != RT_ERR_OK)
 567         return retVal;
 568
 569     return RT_ERR_OK;
 570 }
 571
 572 /* Function Name:
 573  *      rtk_trap_reasonTrapToCpuPriority_set
 574  * Description:
 575  *      Set priority value of a packet that trapped to CPU port according to specific reason.
 576  * Input:
 577  *      type     - reason that trap to CPU port.
 578  *      priority - internal priority that is going to be set for specific trap reason.
 579  * Output:
 580  *      None.
 581  * Return:
 582  *      RT_ERR_OK
 583  *      RT_ERR_FAILED
 584  *      RT_ERR_NOT_INIT - The module is not initial
 585  *      RT_ERR_INPUT    - Invalid input parameter
 586  * Note:
 587  *      Currently the trap reason that supported are listed as follows:
 588  *      - TRAP_REASON_RMA
 589  *      - TRAP_REASON_OAM
 590  *      - TRAP_REASON_1XUNAUTH
 591  *      - TRAP_REASON_VLANSTACK
 592  *      - TRAP_REASON_UNKNOWNMC
 593  */
 594 rtk_api_ret_t rtk_trap_reasonTrapToCpuPriority_set(rtk_trap_reason_type_t type, rtk_pri_t priority)
 595 {
 596     rtk_api_ret_t retVal;
 597     rtl8367c_rma_t rmacfg;
 598
 599     /* Check initialization state */
 600     RTK_CHK_INIT_STATE();
 601
 602     if (type >= TRAP_REASON_END)
 603         return RT_ERR_INPUT;
 604
 605     if (priority > RTL8367C_PRIMAX)
 606         return  RT_ERR_QOS_INT_PRIORITY;
 607
 608     switch (type)
 609     {
 610         case TRAP_REASON_RMA:
 611             if ((retVal = rtl8367c_getAsicRma(0, &rmacfg)) != RT_ERR_OK)
 612                 return retVal;
 613             rmacfg.trap_priority= priority;
 614             if ((retVal = rtl8367c_setAsicRma(0, &rmacfg)) != RT_ERR_OK)
 615                 return retVal;
 616
 617             break;
 618         case TRAP_REASON_OAM:
 619             if ((retVal = rtl8367c_setAsicOamCpuPri(priority)) != RT_ERR_OK)
 620                 return retVal;
 621
 622             break;
 623         case TRAP_REASON_1XUNAUTH:
 624             if ((retVal = rtl8367c_setAsic1xTrapPriority(priority)) != RT_ERR_OK)
 625                 return retVal;
 626
 627             break;
 628         case TRAP_REASON_VLANSTACK:
 629             if ((retVal = rtl8367c_setAsicSvlanTrapPriority(priority)) != RT_ERR_OK)
 630                 return retVal;
 631
 632             break;
 633         case TRAP_REASON_UNKNOWNMC:
 634             if ((retVal = rtl8367c_setAsicUnknownMulticastTrapPriority(priority)) != RT_ERR_OK)
 635                 return retVal;
 636
 637             break;
 638         default:
 639             return RT_ERR_CHIP_NOT_SUPPORTED;
 640     }
 641
 642
 643     return RT_ERR_OK;
 644 }
 645
 646
 647 /* Function Name:
 648  *      rtk_trap_reasonTrapToCpuPriority_get
 649  * Description:
 650  *      Get priority value of a packet that trapped to CPU port according to specific reason.
 651  * Input:
 652  *      type      - reason that trap to CPU port.
 653  * Output:
 654  *      pPriority - configured internal priority for such reason.
 655  * Return:
 656  *      RT_ERR_OK
 657  *      RT_ERR_FAILED
 658  *      RT_ERR_NOT_INIT     - The module is not initial
 659  *      RT_ERR_INPUT        - Invalid input parameter
 660  *      RT_ERR_NULL_POINTER - NULL pointer
 661  * Note:
 662  *      Currently the trap reason that supported are listed as follows:
 663  *      - TRAP_REASON_RMA
 664  *      - TRAP_REASON_OAM
 665  *      - TRAP_REASON_1XUNAUTH
 666  *      - TRAP_REASON_VLANSTACK
 667  *      - TRAP_REASON_UNKNOWNMC
 668  */
 669 rtk_api_ret_t rtk_trap_reasonTrapToCpuPriority_get(rtk_trap_reason_type_t type, rtk_pri_t *pPriority)
 670 {
 671     rtk_api_ret_t retVal;
 672     rtl8367c_rma_t rmacfg;
 673
 674     /* Check initialization state */
 675     RTK_CHK_INIT_STATE();
 676
 677     if (type >= TRAP_REASON_END)
 678         return RT_ERR_INPUT;
 679
 680     if(NULL == pPriority)
 681         return RT_ERR_NULL_POINTER;
 682
 683     switch (type)
 684     {
 685         case TRAP_REASON_RMA:
 686             if ((retVal = rtl8367c_getAsicRma(0, &rmacfg)) != RT_ERR_OK)
 687                 return retVal;
 688             *pPriority = rmacfg.trap_priority;
 689
 690             break;
 691         case TRAP_REASON_OAM:
 692             if ((retVal = rtl8367c_getAsicOamCpuPri(pPriority)) != RT_ERR_OK)
 693                 return retVal;
 694
 695             break;
 696         case TRAP_REASON_1XUNAUTH:
 697             if ((retVal = rtl8367c_getAsic1xTrapPriority(pPriority)) != RT_ERR_OK)
 698                 return retVal;
 699
 700             break;
 701         case TRAP_REASON_VLANSTACK:
 702             if ((retVal = rtl8367c_getAsicSvlanTrapPriority(pPriority)) != RT_ERR_OK)
 703                 return retVal;
 704
 705             break;
 706         case TRAP_REASON_UNKNOWNMC:
 707             if ((retVal = rtl8367c_getAsicUnknownMulticastTrapPriority(pPriority)) != RT_ERR_OK)
 708                 return retVal;
 709
 710             break;
 711         default:
 712             return RT_ERR_CHIP_NOT_SUPPORTED;
 713
 714     }
 715
 716     return RT_ERR_OK;
 717 }
 718
 719
 720
 721 /* Function Name:
 722  *      rtk_trap_rmaAction_set
 723  * Description:
 724  *      Set Reserved multicast address action configuration.
 725  * Input:
 726  *      type    - rma type.
 727  *      rma_action - RMA action.
 728  * Output:
 729  *      None
 730  * Return:
 731  *      RT_ERR_OK           - OK
 732  *      RT_ERR_FAILED       - Failed
 733  *      RT_ERR_SMI          - SMI access error
 734  *      RT_ERR_INPUT        - Invalid input parameters.
 735  * Note:
 736  *
 737  *      There are 48 types of Reserved Multicast Address frame for application usage.
 738  *      (1)They are as following definition.
 739  *      - TRAP_BRG_GROUP,
 740  *      - TRAP_FD_PAUSE,
 741  *      - TRAP_SP_MCAST,
 742  *      - TRAP_1X_PAE,
 743  *      - TRAP_UNDEF_BRG_04,
 744  *      - TRAP_UNDEF_BRG_05,
 745  *      - TRAP_UNDEF_BRG_06,
 746  *      - TRAP_UNDEF_BRG_07,
 747  *      - TRAP_PROVIDER_BRIDGE_GROUP_ADDRESS,
 748  *      - TRAP_UNDEF_BRG_09,
 749  *      - TRAP_UNDEF_BRG_0A,
 750  *      - TRAP_UNDEF_BRG_0B,
 751  *      - TRAP_UNDEF_BRG_0C,
 752  *      - TRAP_PROVIDER_BRIDGE_GVRP_ADDRESS,
 753  *      - TRAP_8021AB,
 754  *      - TRAP_UNDEF_BRG_0F,
 755  *      - TRAP_BRG_MNGEMENT,
 756  *      - TRAP_UNDEFINED_11,
 757  *      - TRAP_UNDEFINED_12,
 758  *      - TRAP_UNDEFINED_13,
 759  *      - TRAP_UNDEFINED_14,
 760  *      - TRAP_UNDEFINED_15,
 761  *      - TRAP_UNDEFINED_16,
 762  *      - TRAP_UNDEFINED_17,
 763  *      - TRAP_UNDEFINED_18,
 764  *      - TRAP_UNDEFINED_19,
 765  *      - TRAP_UNDEFINED_1A,
 766  *      - TRAP_UNDEFINED_1B,
 767  *      - TRAP_UNDEFINED_1C,
 768  *      - TRAP_UNDEFINED_1D,
 769  *      - TRAP_UNDEFINED_1E,
 770  *      - TRAP_UNDEFINED_1F,
 771  *      - TRAP_GMRP,
 772  *      - TRAP_GVRP,
 773  *      - TRAP_UNDEF_GARP_22,
 774  *      - TRAP_UNDEF_GARP_23,
 775  *      - TRAP_UNDEF_GARP_24,
 776  *      - TRAP_UNDEF_GARP_25,
 777  *      - TRAP_UNDEF_GARP_26,
 778  *      - TRAP_UNDEF_GARP_27,
 779  *      - TRAP_UNDEF_GARP_28,
 780  *      - TRAP_UNDEF_GARP_29,
 781  *      - TRAP_UNDEF_GARP_2A,
 782  *      - TRAP_UNDEF_GARP_2B,
 783  *      - TRAP_UNDEF_GARP_2C,
 784  *      - TRAP_UNDEF_GARP_2D,
 785  *      - TRAP_UNDEF_GARP_2E,
 786  *      - TRAP_UNDEF_GARP_2F,
 787  *      - TRAP_CDP.
 788  *      - TRAP_CSSTP.
 789  *      - TRAP_LLDP.
 790  *      (2) The RMA action is as following:
 791  *      - RMA_ACTION_FORWARD
 792  *      - RMA_ACTION_TRAP2CPU
 793  *      - RMA_ACTION_DROP
 794  *      - RMA_ACTION_FORWARD_EXCLUDE_CPU
 795  */
 796 rtk_api_ret_t rtk_trap_rmaAction_set(rtk_trap_type_t type, rtk_trap_rma_action_t rma_action)
 797 {
 798     rtk_api_ret_t retVal;
 799     rtl8367c_rma_t rmacfg;
 800     rtk_uint32 tmp;
 801
 802     /* Check initialization state */
 803     RTK_CHK_INIT_STATE();
 804
 805     if (type >= TRAP_END)
 806         return RT_ERR_INPUT;
 807
 808     if (rma_action >= RMA_ACTION_END)
 809         return RT_ERR_RMA_ACTION;
 810
 811     if (type >= 0 && type <= TRAP_UNDEF_GARP_2F)
 812     {
 813         if ((retVal = rtl8367c_getAsicRma(type, &rmacfg)) != RT_ERR_OK)
 814             return retVal;
 815
 816         rmacfg.operation = rma_action;
 817
 818         if ((retVal = rtl8367c_setAsicRma(type, &rmacfg)) != RT_ERR_OK)
 819             return retVal;
 820     }
 821     else if (type == TRAP_CDP)
 822     {
 823         if ((retVal = rtl8367c_getAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
 824             return retVal;
 825
 826         rmacfg.operation = rma_action;
 827
 828         if ((retVal = rtl8367c_setAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
 829             return retVal;
 830     }
 831     else if (type  == TRAP_CSSTP)
 832     {
 833         if ((retVal = rtl8367c_getAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
 834             return retVal;
 835
 836         rmacfg.operation = rma_action;
 837
 838         if ((retVal = rtl8367c_setAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
 839             return retVal;
 840     }
 841     else if (type  == TRAP_LLDP)
 842     {
 843         if ((retVal = rtl8367c_getAsicRmaLldp(&tmp, &rmacfg)) != RT_ERR_OK)
 844             return retVal;
 845
 846         rmacfg.operation = rma_action;
 847
 848         if ((retVal = rtl8367c_setAsicRmaLldp(tmp, &rmacfg)) != RT_ERR_OK)
 849             return retVal;
 850     }
 851     else
 852         return RT_ERR_INPUT;
 853
 854     return RT_ERR_OK;
 855 }
 856
 857 /* Function Name:
 858  *      rtk_trap_rmaAction_get
 859  * Description:
 860  *      Get Reserved multicast address action configuration.
 861  * Input:
 862  *      type - rma type.
 863  * Output:
 864  *      pRma_action - RMA action.
 865  * Return:
 866  *      RT_ERR_OK           - OK
 867  *      RT_ERR_FAILED       - Failed
 868  *      RT_ERR_SMI          - SMI access error
 869  *      RT_ERR_INPUT        - Invalid input parameters.
 870  * Note:
 871  *      There are 48 types of Reserved Multicast Address frame for application usage.
 872  *      (1)They are as following definition.
 873  *      - TRAP_BRG_GROUP,
 874  *      - TRAP_FD_PAUSE,
 875  *      - TRAP_SP_MCAST,
 876  *      - TRAP_1X_PAE,
 877  *      - TRAP_UNDEF_BRG_04,
 878  *      - TRAP_UNDEF_BRG_05,
 879  *      - TRAP_UNDEF_BRG_06,
 880  *      - TRAP_UNDEF_BRG_07,
 881  *      - TRAP_PROVIDER_BRIDGE_GROUP_ADDRESS,
 882  *      - TRAP_UNDEF_BRG_09,
 883  *      - TRAP_UNDEF_BRG_0A,
 884  *      - TRAP_UNDEF_BRG_0B,
 885  *      - TRAP_UNDEF_BRG_0C,
 886  *      - TRAP_PROVIDER_BRIDGE_GVRP_ADDRESS,
 887  *      - TRAP_8021AB,
 888  *      - TRAP_UNDEF_BRG_0F,
 889  *      - TRAP_BRG_MNGEMENT,
 890  *      - TRAP_UNDEFINED_11,
 891  *      - TRAP_UNDEFINED_12,
 892  *      - TRAP_UNDEFINED_13,
 893  *      - TRAP_UNDEFINED_14,
 894  *      - TRAP_UNDEFINED_15,
 895  *      - TRAP_UNDEFINED_16,
 896  *      - TRAP_UNDEFINED_17,
 897  *      - TRAP_UNDEFINED_18,
 898  *      - TRAP_UNDEFINED_19,
 899  *      - TRAP_UNDEFINED_1A,
 900  *      - TRAP_UNDEFINED_1B,
 901  *      - TRAP_UNDEFINED_1C,
 902  *      - TRAP_UNDEFINED_1D,
 903  *      - TRAP_UNDEFINED_1E,
 904  *      - TRAP_UNDEFINED_1F,
 905  *      - TRAP_GMRP,
 906  *      - TRAP_GVRP,
 907  *      - TRAP_UNDEF_GARP_22,
 908  *      - TRAP_UNDEF_GARP_23,
 909  *      - TRAP_UNDEF_GARP_24,
 910  *      - TRAP_UNDEF_GARP_25,
 911  *      - TRAP_UNDEF_GARP_26,
 912  *      - TRAP_UNDEF_GARP_27,
 913  *      - TRAP_UNDEF_GARP_28,
 914  *      - TRAP_UNDEF_GARP_29,
 915  *      - TRAP_UNDEF_GARP_2A,
 916  *      - TRAP_UNDEF_GARP_2B,
 917  *      - TRAP_UNDEF_GARP_2C,
 918  *      - TRAP_UNDEF_GARP_2D,
 919  *      - TRAP_UNDEF_GARP_2E,
 920  *      - TRAP_UNDEF_GARP_2F,
 921  *      - TRAP_CDP.
 922  *      - TRAP_CSSTP.
 923  *      - TRAP_LLDP.
 924  *      (2) The RMA action is as following:
 925  *      - RMA_ACTION_FORWARD
 926  *      - RMA_ACTION_TRAP2CPU
 927  *      - RMA_ACTION_DROP
 928  *      - RMA_ACTION_FORWARD_EXCLUDE_CPU
 929  */
 930 rtk_api_ret_t rtk_trap_rmaAction_get(rtk_trap_type_t type, rtk_trap_rma_action_t *pRma_action)
 931 {
 932     rtk_api_ret_t retVal;
 933     rtl8367c_rma_t rmacfg;
 934     rtk_uint32 tmp;
 935
 936     /* Check initialization state */
 937     RTK_CHK_INIT_STATE();
 938
 939     if (type >= TRAP_END)
 940         return RT_ERR_INPUT;
 941
 942     if(NULL == pRma_action)
 943         return RT_ERR_NULL_POINTER;
 944
 945     if (type >= 0 && type <= TRAP_UNDEF_GARP_2F)
 946     {
 947         if ((retVal = rtl8367c_getAsicRma(type, &rmacfg)) != RT_ERR_OK)
 948             return retVal;
 949
 950         *pRma_action = rmacfg.operation;
 951     }
 952     else if (type == TRAP_CDP)
 953     {
 954         if ((retVal = rtl8367c_getAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
 955             return retVal;
 956
 957         *pRma_action = rmacfg.operation;
 958     }
 959     else if (type == TRAP_CSSTP)
 960     {
 961         if ((retVal = rtl8367c_getAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
 962             return retVal;
 963
 964         *pRma_action = rmacfg.operation;
 965     }
 966     else if (type == TRAP_LLDP)
 967     {
 968         if ((retVal = rtl8367c_getAsicRmaLldp(&tmp,&rmacfg)) != RT_ERR_OK)
 969             return retVal;
 970
 971         *pRma_action = rmacfg.operation;
 972     }
 973     else
 974         return RT_ERR_INPUT;
 975
 976     return RT_ERR_OK;
 977 }
 978
 979 /* Function Name:
 980  *      rtk_trap_rmaKeepFormat_set
 981  * Description:
 982  *      Set Reserved multicast address keep format configuration.
 983  * Input:
 984  *      type    - rma type.
 985  *      enable - enable keep format.
 986  * Output:
 987  *      None
 988  * Return:
 989  *      RT_ERR_OK           - OK
 990  *      RT_ERR_FAILED       - Failed
 991  *      RT_ERR_SMI          - SMI access error
 992  *      RT_ERR_INPUT        - Invalid input parameters.
 993  *      RT_ERR_ENABLE       - Invalid IFG parameter
 994  * Note:
 995  *
 996  *      There are 48 types of Reserved Multicast Address frame for application usage.
 997  *      They are as following definition.
 998  *      - TRAP_BRG_GROUP,
 999  *      - TRAP_FD_PAUSE,
1000  *      - TRAP_SP_MCAST,
1001  *      - TRAP_1X_PAE,
1002  *      - TRAP_UNDEF_BRG_04,
1003  *      - TRAP_UNDEF_BRG_05,
1004  *      - TRAP_UNDEF_BRG_06,
1005  *      - TRAP_UNDEF_BRG_07,
1006  *      - TRAP_PROVIDER_BRIDGE_GROUP_ADDRESS,
1007  *      - TRAP_UNDEF_BRG_09,
1008  *      - TRAP_UNDEF_BRG_0A,
1009  *      - TRAP_UNDEF_BRG_0B,
1010  *      - TRAP_UNDEF_BRG_0C,
1011  *      - TRAP_PROVIDER_BRIDGE_GVRP_ADDRESS,
1012  *      - TRAP_8021AB,
1013  *      - TRAP_UNDEF_BRG_0F,
1014  *      - TRAP_BRG_MNGEMENT,
1015  *      - TRAP_UNDEFINED_11,
1016  *      - TRAP_UNDEFINED_12,
1017  *      - TRAP_UNDEFINED_13,
1018  *      - TRAP_UNDEFINED_14,
1019  *      - TRAP_UNDEFINED_15,
1020  *      - TRAP_UNDEFINED_16,
1021  *      - TRAP_UNDEFINED_17,
1022  *      - TRAP_UNDEFINED_18,
1023  *      - TRAP_UNDEFINED_19,
1024  *      - TRAP_UNDEFINED_1A,
1025  *      - TRAP_UNDEFINED_1B,
1026  *      - TRAP_UNDEFINED_1C,
1027  *      - TRAP_UNDEFINED_1D,
1028  *      - TRAP_UNDEFINED_1E,
1029  *      - TRAP_UNDEFINED_1F,
1030  *      - TRAP_GMRP,
1031  *      - TRAP_GVRP,
1032  *      - TRAP_UNDEF_GARP_22,
1033  *      - TRAP_UNDEF_GARP_23,
1034  *      - TRAP_UNDEF_GARP_24,
1035  *      - TRAP_UNDEF_GARP_25,
1036  *      - TRAP_UNDEF_GARP_26,
1037  *      - TRAP_UNDEF_GARP_27,
1038  *      - TRAP_UNDEF_GARP_28,
1039  *      - TRAP_UNDEF_GARP_29,
1040  *      - TRAP_UNDEF_GARP_2A,
1041  *      - TRAP_UNDEF_GARP_2B,
1042  *      - TRAP_UNDEF_GARP_2C,
1043  *      - TRAP_UNDEF_GARP_2D,
1044  *      - TRAP_UNDEF_GARP_2E,
1045  *      - TRAP_UNDEF_GARP_2F,
1046  *      - TRAP_CDP.
1047  *      - TRAP_CSSTP.
1048  *      - TRAP_LLDP.
1049  */
1050 rtk_api_ret_t rtk_trap_rmaKeepFormat_set(rtk_trap_type_t type, rtk_enable_t enable)
1051 {
1052     rtk_api_ret_t retVal;
1053     rtl8367c_rma_t rmacfg;
1054     rtk_uint32 tmp;
1055
1056     /* Check initialization state */
1057     RTK_CHK_INIT_STATE();
1058
1059     if (type >= TRAP_END)
1060         return RT_ERR_INPUT;
1061
1062     if (enable >= RTK_ENABLE_END)
1063         return RT_ERR_INPUT;
1064
1065     if (type >= 0 && type <= TRAP_UNDEF_GARP_2F)
1066     {
1067         if ((retVal = rtl8367c_getAsicRma(type, &rmacfg)) != RT_ERR_OK)
1068             return retVal;
1069
1070         rmacfg.keep_format = enable;
1071
1072         if ((retVal = rtl8367c_setAsicRma(type, &rmacfg)) != RT_ERR_OK)
1073             return retVal;
1074     }
1075     else if (type == TRAP_CDP)
1076     {
1077         if ((retVal = rtl8367c_getAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
1078             return retVal;
1079
1080         rmacfg.keep_format = enable;
1081
1082         if ((retVal = rtl8367c_setAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
1083             return retVal;
1084     }
1085     else if (type  == TRAP_CSSTP)
1086     {
1087         if ((retVal = rtl8367c_getAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
1088             return retVal;
1089
1090         rmacfg.keep_format = enable;
1091
1092         if ((retVal = rtl8367c_setAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
1093             return retVal;
1094     }
1095     else if (type  == TRAP_LLDP)
1096     {
1097         if ((retVal = rtl8367c_getAsicRmaLldp(&tmp, &rmacfg)) != RT_ERR_OK)
1098             return retVal;
1099
1100         rmacfg.keep_format = enable;
1101
1102         if ((retVal = rtl8367c_setAsicRmaLldp(tmp, &rmacfg)) != RT_ERR_OK)
1103             return retVal;
1104     }
1105     else
1106         return RT_ERR_INPUT;
1107
1108     return RT_ERR_OK;
1109 }
1110
1111 /* Function Name:
1112  *      rtk_trap_rmaKeepFormat_get
1113  * Description:
1114  *      Get Reserved multicast address action configuration.
1115  * Input:
1116  *      type - rma type.
1117  * Output:
1118  *      pEnable - keep format status.
1119  * Return:
1120  *      RT_ERR_OK           - OK
1121  *      RT_ERR_FAILED       - Failed
1122  *      RT_ERR_SMI          - SMI access error
1123  *      RT_ERR_INPUT        - Invalid input parameters.
1124  * Note:
1125  *      There are 48 types of Reserved Multicast Address frame for application usage.
1126  *      They are as following definition.
1127  *      - TRAP_BRG_GROUP,
1128  *      - TRAP_FD_PAUSE,
1129  *      - TRAP_SP_MCAST,
1130  *      - TRAP_1X_PAE,
1131  *      - TRAP_UNDEF_BRG_04,
1132  *      - TRAP_UNDEF_BRG_05,
1133  *      - TRAP_UNDEF_BRG_06,
1134  *      - TRAP_UNDEF_BRG_07,
1135  *      - TRAP_PROVIDER_BRIDGE_GROUP_ADDRESS,
1136  *      - TRAP_UNDEF_BRG_09,
1137  *      - TRAP_UNDEF_BRG_0A,
1138  *      - TRAP_UNDEF_BRG_0B,
1139  *      - TRAP_UNDEF_BRG_0C,
1140  *      - TRAP_PROVIDER_BRIDGE_GVRP_ADDRESS,
1141  *      - TRAP_8021AB,
1142  *      - TRAP_UNDEF_BRG_0F,
1143  *      - TRAP_BRG_MNGEMENT,
1144  *      - TRAP_UNDEFINED_11,
1145  *      - TRAP_UNDEFINED_12,
1146  *      - TRAP_UNDEFINED_13,
1147  *      - TRAP_UNDEFINED_14,
1148  *      - TRAP_UNDEFINED_15,
1149  *      - TRAP_UNDEFINED_16,
1150  *      - TRAP_UNDEFINED_17,
1151  *      - TRAP_UNDEFINED_18,
1152  *      - TRAP_UNDEFINED_19,
1153  *      - TRAP_UNDEFINED_1A,
1154  *      - TRAP_UNDEFINED_1B,
1155  *      - TRAP_UNDEFINED_1C,
1156  *      - TRAP_UNDEFINED_1D,
1157  *      - TRAP_UNDEFINED_1E,
1158  *      - TRAP_UNDEFINED_1F,
1159  *      - TRAP_GMRP,
1160  *      - TRAP_GVRP,
1161  *      - TRAP_UNDEF_GARP_22,
1162  *      - TRAP_UNDEF_GARP_23,
1163  *      - TRAP_UNDEF_GARP_24,
1164  *      - TRAP_UNDEF_GARP_25,
1165  *      - TRAP_UNDEF_GARP_26,
1166  *      - TRAP_UNDEF_GARP_27,
1167  *      - TRAP_UNDEF_GARP_28,
1168  *      - TRAP_UNDEF_GARP_29,
1169  *      - TRAP_UNDEF_GARP_2A,
1170  *      - TRAP_UNDEF_GARP_2B,
1171  *      - TRAP_UNDEF_GARP_2C,
1172  *      - TRAP_UNDEF_GARP_2D,
1173  *      - TRAP_UNDEF_GARP_2E,
1174  *      - TRAP_UNDEF_GARP_2F,
1175  *      - TRAP_CDP.
1176  *      - TRAP_CSSTP.
1177  *      - TRAP_LLDP.
1178  */
1179 rtk_api_ret_t rtk_trap_rmaKeepFormat_get(rtk_trap_type_t type, rtk_enable_t *pEnable)
1180 {
1181     rtk_api_ret_t retVal;
1182     rtl8367c_rma_t rmacfg;
1183     rtk_uint32 tmp;
1184
1185     /* Check initialization state */
1186     RTK_CHK_INIT_STATE();
1187
1188     if (type >= TRAP_END)
1189         return RT_ERR_INPUT;
1190
1191     if(NULL == pEnable)
1192         return RT_ERR_NULL_POINTER;
1193
1194     if (type >= 0 && type <= TRAP_UNDEF_GARP_2F)
1195     {
1196         if ((retVal = rtl8367c_getAsicRma(type, &rmacfg)) != RT_ERR_OK)
1197             return retVal;
1198
1199         *pEnable = rmacfg.keep_format;
1200     }
1201     else if (type == TRAP_CDP)
1202     {
1203         if ((retVal = rtl8367c_getAsicRmaCdp(&rmacfg)) != RT_ERR_OK)
1204             return retVal;
1205
1206         *pEnable = rmacfg.keep_format;
1207     }
1208     else if (type == TRAP_CSSTP)
1209     {
1210         if ((retVal = rtl8367c_getAsicRmaCsstp(&rmacfg)) != RT_ERR_OK)
1211             return retVal;
1212
1213         *pEnable = rmacfg.keep_format;
1214     }
1215     else if (type == TRAP_LLDP)
1216     {
1217         if ((retVal = rtl8367c_getAsicRmaLldp(&tmp,&rmacfg)) != RT_ERR_OK)
1218             return retVal;
1219
1220         *pEnable = rmacfg.keep_format;
1221     }
1222     else
1223         return RT_ERR_INPUT;
1224
1225     return RT_ERR_OK;
1226 }
1227
1228
1229