target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/svlan.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 SVLAN module.
  15  *
  16  */
  17
  18 #include <rtk_switch.h>
  19 #include <rtk_error.h>
  20 #include <svlan.h>
  21 #include <vlan.h>
  22 #include <string.h>
  23
  24 #include <rtl8367c_asicdrv.h>
  25 #include <rtl8367c_asicdrv_svlan.h>
  26
  27 rtk_uint8               svlan_mbrCfgUsage[RTL8367C_SVIDXNO];
  28 rtk_uint16              svlan_mbrCfgVid[RTL8367C_SVIDXNO];
  29 rtk_svlan_lookupType_t  svlan_lookupType;
  30 /* Function Name:
  31  *      rtk_svlan_init
  32  * Description:
  33  *      Initialize SVLAN Configuration
  34  * Input:
  35  *      None
  36  * Output:
  37  *      None
  38  * Return:
  39  *      RT_ERR_OK           - OK
  40  *      RT_ERR_FAILED       - Failed
  41  *      RT_ERR_SMI          - SMI access error
  42  * Note:
  43  *      Ether type of S-tag in 802.1ad is 0x88a8 and there are existed ether type 0x9100 and 0x9200 for Q-in-Q SLAN design.
  44  *      User can set mathced ether type as service provider supported protocol.
  45  */
  46 rtk_api_ret_t rtk_svlan_init(void)
  47 {
  48     rtk_uint32 i;
  49     rtk_api_ret_t retVal;
  50     rtl8367c_svlan_memconf_t svlanMemConf;
  51     rtl8367c_svlan_s2c_t svlanSP2CConf;
  52     rtl8367c_svlan_mc2s_t svlanMC2SConf;
  53     rtk_uint32 svidx;
  54
  55     /* Check initialization state */
  56     RTK_CHK_INIT_STATE();
  57
  58     /*default use C-priority*/
  59     if ((retVal = rtl8367c_setAsicSvlanPrioritySel(SPRISEL_CTAGPRI)) != RT_ERR_OK)
  60         return retVal;
  61
  62     /*Drop SVLAN untag frame*/
  63     if ((retVal = rtl8367c_setAsicSvlanIngressUntag(UNTAG_DROP)) != RT_ERR_OK)
  64         return retVal;
  65
  66     /*Drop SVLAN unmatch frame*/
  67     if ((retVal = rtl8367c_setAsicSvlanIngressUnmatch(UNMATCH_DROP)) != RT_ERR_OK)
  68         return retVal;
  69
  70     /*Set TPID to 0x88a8*/
  71     if ((retVal = rtl8367c_setAsicSvlanTpid(0x88a8)) != RT_ERR_OK)
  72         return retVal;
  73
  74     /*Clean Uplink Port Mask to none*/
  75     if ((retVal = rtl8367c_setAsicSvlanUplinkPortMask(0)) != RT_ERR_OK)
  76         return retVal;
  77
  78     /*Clean SVLAN Member Configuration*/
  79     for (i=0; i<= RTL8367C_SVIDXMAX; i++)
  80     {
  81         memset(&svlanMemConf, 0, sizeof(rtl8367c_svlan_memconf_t));
  82         if ((retVal = rtl8367c_setAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
  83             return retVal;
  84     }
  85
  86     /*Clean C2S Configuration*/
  87     for (i=0; i<= RTL8367C_C2SIDXMAX; i++)
  88     {
  89         if ((retVal = rtl8367c_setAsicSvlanC2SConf(i, 0,0,0)) != RT_ERR_OK)
  90             return retVal;
  91     }
  92
  93     /*Clean SP2C Configuration*/
  94     for (i=0; i <= RTL8367C_SP2CMAX ; i++)
  95     {
  96         memset(&svlanSP2CConf, 0, sizeof(rtl8367c_svlan_s2c_t));
  97         if ((retVal = rtl8367c_setAsicSvlanSP2CConf(i, &svlanSP2CConf)) != RT_ERR_OK)
  98             return retVal;
  99     }
 100
 101     /*Clean MC2S Configuration*/
 102     for (i=0 ; i<= RTL8367C_MC2SIDXMAX; i++)
 103     {
 104         memset(&svlanMC2SConf, 0, sizeof(rtl8367c_svlan_mc2s_t));
 105         if ((retVal = rtl8367c_setAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
 106             return retVal;
 107     }
 108
 109
 110     if ((retVal = rtk_svlan_lookupType_set(SVLAN_LOOKUP_S64MBRCGF)) != RT_ERR_OK)
 111         return retVal;
 112
 113
 114     for (svidx = 0; svidx <= RTL8367C_SVIDXMAX; svidx++)
 115     {
 116         svlan_mbrCfgUsage[svidx] = FALSE;
 117     }
 118
 119
 120     return RT_ERR_OK;
 121 }
 122
 123 /* Function Name:
 124  *      rtk_svlan_servicePort_add
 125  * Description:
 126  *      Add one service port in the specified device
 127  * Input:
 128  *      port - Port id.
 129  * Output:
 130  *      None
 131  * Return:
 132  *      RT_ERR_OK           - OK
 133  *      RT_ERR_FAILED       - Failed
 134  *      RT_ERR_SMI          - SMI access error
 135  *      RT_ERR_PORT_ID      - Invalid port number.
 136  *      RT_ERR_INPUT        - Invalid input parameters.
 137  * Note:
 138  *      This API is setting which port is connected to provider switch. All frames receiving from this port must
 139  *      contain accept SVID in S-tag field.
 140  */
 141 rtk_api_ret_t rtk_svlan_servicePort_add(rtk_port_t port)
 142 {
 143     rtk_api_ret_t retVal;
 144     rtk_uint32 pmsk;
 145
 146     /* Check initialization state */
 147     RTK_CHK_INIT_STATE();
 148
 149     /* check port valid */
 150     RTK_CHK_PORT_VALID(port);
 151
 152     if ((retVal = rtl8367c_getAsicSvlanUplinkPortMask(&pmsk)) != RT_ERR_OK)
 153         return retVal;
 154
 155     pmsk = pmsk | (1<<rtk_switch_port_L2P_get(port));
 156
 157     if ((retVal = rtl8367c_setAsicSvlanUplinkPortMask(pmsk)) != RT_ERR_OK)
 158         return retVal;
 159
 160     return RT_ERR_OK;
 161 }
 162
 163 /* Function Name:
 164  *      rtk_svlan_servicePort_get
 165  * Description:
 166  *      Get service ports in the specified device.
 167  * Input:
 168  *      None
 169  * Output:
 170  *      pSvlan_portmask - pointer buffer of svlan ports.
 171  * Return:
 172  *      RT_ERR_OK          - OK
 173  *      RT_ERR_FAILED      - Failed
 174  *      RT_ERR_SMI         - SMI access error
 175  * Note:
 176  *      This API is setting which port is connected to provider switch. All frames receiving from this port must
 177  *      contain accept SVID in S-tag field.
 178  */
 179 rtk_api_ret_t rtk_svlan_servicePort_get(rtk_portmask_t *pSvlan_portmask)
 180 {
 181     rtk_api_ret_t retVal;
 182     rtk_uint32 phyMbrPmask;
 183
 184     /* Check initialization state */
 185     RTK_CHK_INIT_STATE();
 186
 187     if(NULL == pSvlan_portmask)
 188         return RT_ERR_NULL_POINTER;
 189
 190     if ((retVal = rtl8367c_getAsicSvlanUplinkPortMask(&phyMbrPmask)) != RT_ERR_OK)
 191         return retVal;
 192
 193     if(rtk_switch_portmask_P2L_get(phyMbrPmask, pSvlan_portmask) != RT_ERR_OK)
 194         return RT_ERR_FAILED;
 195
 196
 197     return RT_ERR_OK;
 198 }
 199
 200 /* Function Name:
 201  *      rtk_svlan_servicePort_del
 202  * Description:
 203  *      Delete one service port in the specified device
 204  * Input:
 205  *      port - Port id.
 206  * Output:
 207  *      None
 208  * Return:
 209  *      RT_ERR_OK           - OK
 210  *      RT_ERR_FAILED       - Failed
 211  *      RT_ERR_SMI          - SMI access error
 212  *      RT_ERR_PORT_ID      - Invalid port number.
 213  * Note:
 214  *      This API is removing SVLAN service port in the specified device.
 215  */
 216 rtk_api_ret_t rtk_svlan_servicePort_del(rtk_port_t port)
 217 {
 218     rtk_api_ret_t retVal;
 219     rtk_uint32 pmsk;
 220
 221     /* Check initialization state */
 222     RTK_CHK_INIT_STATE();
 223
 224     /* check port valid */
 225     RTK_CHK_PORT_VALID(port);
 226
 227     if ((retVal = rtl8367c_getAsicSvlanUplinkPortMask(&pmsk)) != RT_ERR_OK)
 228         return retVal;
 229
 230     pmsk = pmsk & ~(1<<rtk_switch_port_L2P_get(port));
 231
 232     if ((retVal = rtl8367c_setAsicSvlanUplinkPortMask(pmsk)) != RT_ERR_OK)
 233         return retVal;
 234
 235     return RT_ERR_OK;
 236 }
 237
 238 /* Function Name:
 239  *      rtk_svlan_tpidEntry_set
 240  * Description:
 241  *      Configure accepted S-VLAN ether type.
 242  * Input:
 243  *      svlan_tag_id - Ether type of S-tag frame parsing in uplink ports.
 244  * Output:
 245  *      None
 246  * Return:
 247  *      RT_ERR_OK           - OK
 248  *      RT_ERR_FAILED       - Failed
 249  *      RT_ERR_SMI          - SMI access error
 250  *      RT_ERR_INPUT        - Invalid input parameter.
 251  * Note:
 252  *      Ether type of S-tag in 802.1ad is 0x88a8 and there are existed ether type 0x9100 and 0x9200 for Q-in-Q SLAN design.
 253  *      User can set mathced ether type as service provider supported protocol.
 254  */
 255 rtk_api_ret_t rtk_svlan_tpidEntry_set(rtk_svlan_tpid_t svlan_tag_id)
 256 {
 257     rtk_api_ret_t retVal;
 258
 259     /* Check initialization state */
 260     RTK_CHK_INIT_STATE();
 261
 262     if (svlan_tag_id>RTK_MAX_NUM_OF_PROTO_TYPE)
 263         return RT_ERR_INPUT;
 264
 265     if ((retVal = rtl8367c_setAsicSvlanTpid(svlan_tag_id)) != RT_ERR_OK)
 266         return retVal;
 267
 268     return RT_ERR_OK;
 269 }
 270
 271 /* Function Name:
 272  *      rtk_svlan_tpidEntry_get
 273  * Description:
 274  *      Get accepted S-VLAN ether type setting.
 275  * Input:
 276  *      None
 277  * Output:
 278  *      pSvlan_tag_id -  Ether type of S-tag frame parsing in uplink ports.
 279  * Return:
 280  *      RT_ERR_OK           - OK
 281  *      RT_ERR_FAILED       - Failed
 282  *      RT_ERR_SMI          - SMI access error
 283  * Note:
 284  *      This API is setting which port is connected to provider switch. All frames receiving from this port must
 285  *      contain accept SVID in S-tag field.
 286  */
 287 rtk_api_ret_t rtk_svlan_tpidEntry_get(rtk_svlan_tpid_t *pSvlan_tag_id)
 288 {
 289     rtk_api_ret_t retVal;
 290
 291     /* Check initialization state */
 292     RTK_CHK_INIT_STATE();
 293
 294     if(NULL == pSvlan_tag_id)
 295         return RT_ERR_NULL_POINTER;
 296
 297     if ((retVal = rtl8367c_getAsicSvlanTpid(pSvlan_tag_id)) != RT_ERR_OK)
 298         return retVal;
 299
 300     return RT_ERR_OK;
 301 }
 302
 303 /* Function Name:
 304  *      rtk_svlan_priorityRef_set
 305  * Description:
 306  *      Set S-VLAN upstream priority reference setting.
 307  * Input:
 308  *      ref - reference selection parameter.
 309  * Output:
 310  *      None
 311  * Return:
 312  *      RT_ERR_OK           - OK
 313  *      RT_ERR_FAILED       - Failed
 314  *      RT_ERR_SMI          - SMI access error
 315  *      RT_ERR_INPUT        - Invalid input parameter.
 316  * Note:
 317  *      The API can set the upstream SVLAN tag priority reference source. The related priority
 318  *      sources are as following:
 319  *      - REF_INTERNAL_PRI,
 320  *      - REF_CTAG_PRI,
 321  *      - REF_SVLAN_PRI,
 322  *      - REF_PB_PRI.
 323  */
 324 rtk_api_ret_t rtk_svlan_priorityRef_set(rtk_svlan_pri_ref_t ref)
 325 {
 326     rtk_api_ret_t retVal;
 327
 328     /* Check initialization state */
 329     RTK_CHK_INIT_STATE();
 330
 331     if (ref >= REF_PRI_END)
 332         return RT_ERR_INPUT;
 333
 334     if ((retVal = rtl8367c_setAsicSvlanPrioritySel(ref)) != RT_ERR_OK)
 335         return retVal;
 336
 337     return RT_ERR_OK;
 338 }
 339
 340 /* Function Name:
 341  *      rtk_svlan_priorityRef_get
 342  * Description:
 343  *      Get S-VLAN upstream priority reference setting.
 344  * Input:
 345  *      None
 346  * Output:
 347  *      pRef - reference selection parameter.
 348  * Return:
 349  *      RT_ERR_OK           - OK
 350  *      RT_ERR_FAILED       - Failed
 351  *      RT_ERR_SMI          - SMI access error
 352  * Note:
 353  *      The API can get the upstream SVLAN tag priority reference source. The related priority
 354  *      sources are as following:
 355  *      - REF_INTERNAL_PRI,
 356  *      - REF_CTAG_PRI,
 357  *      - REF_SVLAN_PRI,
 358  *      - REF_PB_PRI
 359  */
 360 rtk_api_ret_t rtk_svlan_priorityRef_get(rtk_svlan_pri_ref_t *pRef)
 361 {
 362     rtk_api_ret_t retVal;
 363
 364     /* Check initialization state */
 365     RTK_CHK_INIT_STATE();
 366
 367     if(NULL == pRef)
 368         return RT_ERR_NULL_POINTER;
 369
 370     if ((retVal = rtl8367c_getAsicSvlanPrioritySel(pRef)) != RT_ERR_OK)
 371         return retVal;
 372
 373     return RT_ERR_OK;
 374 }
 375
 376 /* Function Name:
 377  *      rtk_svlan_memberPortEntry_set
 378  * Description:
 379  *      Configure system SVLAN member content
 380  * Input:
 381  *      svid - SVLAN id
 382  *      psvlan_cfg - SVLAN member configuration
 383  * Output:
 384  *      None
 385  * Return:
 386  *      RT_ERR_OK               - OK
 387  *      RT_ERR_FAILED           - Failed
 388  *      RT_ERR_SMI              - SMI access error
 389  *      RT_ERR_INPUT            - Invalid input parameter.
 390  *      RT_ERR_SVLAN_VID        - Invalid SVLAN VID parameter.
 391  *      RT_ERR_PORT_MASK        - Invalid portmask.
 392  *      RT_ERR_SVLAN_TABLE_FULL - SVLAN configuration is full.
 393  * Note:
 394  *      The API can set system 64 accepted s-tag frame format. Only 64 SVID S-tag frame will be accpeted
 395  *      to receiving from uplink ports. Other SVID S-tag frame or S-untagged frame will be droped by default setup.
 396  *      - rtk_svlan_memberCfg_t->svid is SVID of SVLAN member configuration.
 397  *      - rtk_svlan_memberCfg_t->memberport is member port mask of SVLAN member configuration.
 398  *      - rtk_svlan_memberCfg_t->fid is filtering database of SVLAN member configuration.
 399  *      - rtk_svlan_memberCfg_t->priority is priority of SVLAN member configuration.
 400  */
 401 rtk_api_ret_t rtk_svlan_memberPortEntry_set(rtk_vlan_t svid, rtk_svlan_memberCfg_t *pSvlan_cfg)
 402 {
 403     rtk_api_ret_t retVal;
 404     rtk_int32 i;
 405     rtk_uint32 empty_idx;
 406     rtl8367c_svlan_memconf_t svlanMemConf;
 407     rtk_uint32 phyMbrPmask;
 408     rtk_vlan_cfg_t vlanCfg;
 409
 410     /* Check initialization state */
 411     RTK_CHK_INIT_STATE();
 412
 413     if(NULL == pSvlan_cfg)
 414         return RT_ERR_NULL_POINTER;
 415
 416     if(svid > RTL8367C_VIDMAX)
 417         return RT_ERR_SVLAN_VID;
 418
 419     RTK_CHK_PORTMASK_VALID(&(pSvlan_cfg->memberport));
 420
 421     RTK_CHK_PORTMASK_VALID(&(pSvlan_cfg->untagport));
 422
 423     if (pSvlan_cfg->fiden > ENABLED)
 424         return RT_ERR_ENABLE;
 425
 426     if (pSvlan_cfg->fid > RTL8367C_FIDMAX)
 427         return RT_ERR_L2_FID;
 428
 429     if (pSvlan_cfg->priority > RTL8367C_PRIMAX)
 430         return RT_ERR_VLAN_PRIORITY;
 431
 432     if (pSvlan_cfg->efiden > ENABLED)
 433         return RT_ERR_ENABLE;
 434
 435     if (pSvlan_cfg->efid > RTL8367C_EFIDMAX)
 436         return RT_ERR_L2_FID;
 437
 438     if(SVLAN_LOOKUP_C4KVLAN == svlan_lookupType)
 439     {
 440         if ((retVal = rtk_vlan_get(svid, &vlanCfg)) != RT_ERR_OK)
 441             return retVal;
 442
 443         vlanCfg.mbr = pSvlan_cfg->memberport;
 444         vlanCfg.untag = pSvlan_cfg->untagport;
 445
 446         if ((retVal = rtk_vlan_set(svid, &vlanCfg)) != RT_ERR_OK)
 447             return retVal;
 448
 449         empty_idx = 0xFF;
 450
 451         for (i = 0; i<= RTL8367C_SVIDXMAX; i++)
 452         {
 453             if (svid == svlan_mbrCfgVid[i] && TRUE == svlan_mbrCfgUsage[i])
 454             {
 455                 memset(&svlanMemConf, 0, sizeof(rtl8367c_svlan_memconf_t));
 456                 svlanMemConf.vs_svid        = svid;
 457                 svlanMemConf.vs_efiden      = pSvlan_cfg->efiden;
 458                 svlanMemConf.vs_efid        = pSvlan_cfg->efid;
 459                 svlanMemConf.vs_priority    = pSvlan_cfg->priority;
 460
 461                 /*for create check*/
 462                 if(0 == svlanMemConf.vs_efiden && 0 == svlanMemConf.vs_efid)
 463                     svlanMemConf.vs_efid = 1;
 464
 465                 if ((retVal = rtl8367c_setAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
 466                     return retVal;
 467
 468                 return RT_ERR_OK;
 469             }
 470             else if (FALSE == svlan_mbrCfgUsage[i] && 0xFF == empty_idx)
 471             {
 472                 empty_idx = i;
 473             }
 474         }
 475
 476         if (empty_idx != 0xFF)
 477         {
 478             svlan_mbrCfgUsage[empty_idx] = TRUE;
 479             svlan_mbrCfgVid[empty_idx] = svid;
 480
 481             memset(&svlanMemConf, 0, sizeof(rtl8367c_svlan_memconf_t));
 482             svlanMemConf.vs_svid        = svid;
 483             svlanMemConf.vs_efiden      = pSvlan_cfg->efiden;
 484             svlanMemConf.vs_efid        = pSvlan_cfg->efid;
 485             svlanMemConf.vs_priority    = pSvlan_cfg->priority;
 486
 487             /*for create check*/
 488             if(0 == svlanMemConf.vs_efiden && 0 == svlanMemConf.vs_efid)
 489                 svlanMemConf.vs_efid = 1;
 490
 491             if ((retVal = rtl8367c_setAsicSvlanMemberConfiguration(empty_idx, &svlanMemConf)) != RT_ERR_OK)
 492                 return retVal;
 493
 494         }
 495
 496         return RT_ERR_OK;
 497     }
 498
 499
 500     empty_idx = 0xFF;
 501
 502     for (i = 0; i<= RTL8367C_SVIDXMAX; i++)
 503     {
 504         /*
 505         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
 506             return retVal;
 507         */
 508         if (svid == svlan_mbrCfgVid[i] && TRUE == svlan_mbrCfgUsage[i])
 509         {
 510             svlanMemConf.vs_svid = svid;
 511
 512             if(rtk_switch_portmask_L2P_get(&(pSvlan_cfg->memberport), &phyMbrPmask) != RT_ERR_OK)
 513                 return RT_ERR_FAILED;
 514
 515             svlanMemConf.vs_member = phyMbrPmask;
 516
 517             if(rtk_switch_portmask_L2P_get(&(pSvlan_cfg->untagport), &phyMbrPmask) != RT_ERR_OK)
 518                 return RT_ERR_FAILED;
 519
 520             svlanMemConf.vs_untag = phyMbrPmask;
 521
 522             svlanMemConf.vs_force_fid   = pSvlan_cfg->fiden;
 523             svlanMemConf.vs_fid_msti    = pSvlan_cfg->fid;
 524             svlanMemConf.vs_priority    = pSvlan_cfg->priority;
 525             svlanMemConf.vs_efiden      = pSvlan_cfg->efiden;
 526             svlanMemConf.vs_efid        = pSvlan_cfg->efid;
 527
 528             /*all items are reset means deleting*/
 529             if( 0 == svlanMemConf.vs_member &&
 530                 0 == svlanMemConf.vs_untag &&
 531                 0 == svlanMemConf.vs_force_fid &&
 532                 0 == svlanMemConf.vs_fid_msti &&
 533                 0 == svlanMemConf.vs_priority &&
 534                 0 == svlanMemConf.vs_efiden &&
 535                 0 == svlanMemConf.vs_efid)
 536             {
 537                 svlan_mbrCfgUsage[i] = FALSE;
 538                 svlan_mbrCfgVid[i] = 0;
 539
 540                 /* Clear SVID also */
 541                 svlanMemConf.vs_svid = 0;
 542             }
 543             else
 544             {
 545                 svlan_mbrCfgUsage[i] = TRUE;
 546                 svlan_mbrCfgVid[i] = svlanMemConf.vs_svid;
 547
 548                 if(0 == svlanMemConf.vs_svid)
 549                 {
 550                     /*for create check*/
 551                     if(0 == svlanMemConf.vs_efiden && 0 == svlanMemConf.vs_efid)
 552                     {
 553                         svlanMemConf.vs_efid = 1;
 554                     }
 555                 }
 556             }
 557
 558             if ((retVal = rtl8367c_setAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
 559                 return retVal;
 560
 561             return RT_ERR_OK;
 562         }
 563         else if (FALSE == svlan_mbrCfgUsage[i] && 0xFF == empty_idx)
 564         {
 565             empty_idx = i;
 566         }
 567     }
 568
 569     if (empty_idx != 0xFF)
 570     {
 571         memset(&svlanMemConf, 0, sizeof(rtl8367c_svlan_memconf_t));
 572         svlanMemConf.vs_svid = svid;
 573
 574         if(rtk_switch_portmask_L2P_get(&(pSvlan_cfg->memberport), &phyMbrPmask) != RT_ERR_OK)
 575             return RT_ERR_FAILED;
 576
 577         svlanMemConf.vs_member = phyMbrPmask;
 578
 579         if(rtk_switch_portmask_L2P_get(&(pSvlan_cfg->untagport), &phyMbrPmask) != RT_ERR_OK)
 580             return RT_ERR_FAILED;
 581
 582         svlanMemConf.vs_untag = phyMbrPmask;
 583
 584         svlanMemConf.vs_force_fid   = pSvlan_cfg->fiden;
 585         svlanMemConf.vs_fid_msti    = pSvlan_cfg->fid;
 586         svlanMemConf.vs_priority    = pSvlan_cfg->priority;
 587
 588         svlanMemConf.vs_efiden      = pSvlan_cfg->efiden;
 589         svlanMemConf.vs_efid        = pSvlan_cfg->efid;
 590
 591         /*change efid for empty svid 0*/
 592         if(0 == svlanMemConf.vs_svid)
 593         {   /*for create check*/
 594             if(0 == svlanMemConf.vs_efiden && 0 == svlanMemConf.vs_efid)
 595             {
 596                 svlanMemConf.vs_efid = 1;
 597             }
 598         }
 599
 600         svlan_mbrCfgUsage[empty_idx] = TRUE;
 601         svlan_mbrCfgVid[empty_idx] = svlanMemConf.vs_svid;
 602
 603         if ((retVal = rtl8367c_setAsicSvlanMemberConfiguration(empty_idx, &svlanMemConf)) != RT_ERR_OK)
 604         {
 605             return retVal;
 606         }
 607
 608         return RT_ERR_OK;
 609     }
 610
 611     return RT_ERR_SVLAN_TABLE_FULL;
 612 }
 613
 614 /* Function Name:
 615  *      rtk_svlan_memberPortEntry_get
 616  * Description:
 617  *      Get SVLAN member Configure.
 618  * Input:
 619  *      svid - SVLAN id
 620  * Output:
 621  *      pSvlan_cfg - SVLAN member configuration
 622  * Return:
 623  *      RT_ERR_OK                       - OK
 624  *      RT_ERR_FAILED                   - Failed
 625  *      RT_ERR_SMI                      - SMI access error
 626  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
 627  *      RT_ERR_INPUT                    - Invalid input parameters.
 628  * Note:
 629  *      The API can get system 64 accepted s-tag frame format. Only 64 SVID S-tag frame will be accpeted
 630  *      to receiving from uplink ports. Other SVID S-tag frame or S-untagged frame will be droped.
 631  */
 632 rtk_api_ret_t rtk_svlan_memberPortEntry_get(rtk_vlan_t svid, rtk_svlan_memberCfg_t *pSvlan_cfg)
 633 {
 634     rtk_api_ret_t retVal;
 635     rtk_uint32 i;
 636     rtl8367c_svlan_memconf_t svlanMemConf;
 637
 638     /* Check initialization state */
 639     RTK_CHK_INIT_STATE();
 640
 641     if(NULL == pSvlan_cfg)
 642         return RT_ERR_NULL_POINTER;
 643
 644     if (svid > RTL8367C_VIDMAX)
 645         return RT_ERR_SVLAN_VID;
 646
 647
 648     for (i = 0; i<= RTL8367C_SVIDXMAX; i++)
 649     {
 650         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
 651             return retVal;
 652
 653         if (svid == svlanMemConf.vs_svid)
 654         {
 655             pSvlan_cfg->svid        = svlanMemConf.vs_svid;
 656
 657             if(rtk_switch_portmask_P2L_get(svlanMemConf.vs_member,&(pSvlan_cfg->memberport)) != RT_ERR_OK)
 658                 return RT_ERR_FAILED;
 659
 660             if(rtk_switch_portmask_P2L_get(svlanMemConf.vs_untag,&(pSvlan_cfg->untagport)) != RT_ERR_OK)
 661                 return RT_ERR_FAILED;
 662
 663             pSvlan_cfg->fiden       = svlanMemConf.vs_force_fid;
 664             pSvlan_cfg->fid         = svlanMemConf.vs_fid_msti;
 665             pSvlan_cfg->priority    = svlanMemConf.vs_priority;
 666             pSvlan_cfg->efiden      = svlanMemConf.vs_efiden;
 667             pSvlan_cfg->efid        = svlanMemConf.vs_efid;
 668
 669             return RT_ERR_OK;
 670         }
 671     }
 672
 673     return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
 674
 675 }
 676
 677 /* Function Name:
 678  *      rtk_svlan_memberPortEntry_adv_set
 679  * Description:
 680  *      Configure system SVLAN member by index
 681  * Input:
 682  *      idx         - Index (0 ~ 63)
 683  *      psvlan_cfg  - SVLAN member configuration
 684  * Output:
 685  *      None
 686  * Return:
 687  *      RT_ERR_OK               - OK
 688  *      RT_ERR_FAILED           - Failed
 689  *      RT_ERR_SMI              - SMI access error
 690  *      RT_ERR_INPUT            - Invalid input parameter.
 691  *      RT_ERR_SVLAN_VID        - Invalid SVLAN VID parameter.
 692  *      RT_ERR_PORT_MASK        - Invalid portmask.
 693  *      RT_ERR_SVLAN_TABLE_FULL - SVLAN configuration is full.
 694  * Note:
 695  *      The API can set system 64 accepted s-tag frame format by index.
 696  *      - rtk_svlan_memberCfg_t->svid is SVID of SVLAN member configuration.
 697  *      - rtk_svlan_memberCfg_t->memberport is member port mask of SVLAN member configuration.
 698  *      - rtk_svlan_memberCfg_t->fid is filtering database of SVLAN member configuration.
 699  *      - rtk_svlan_memberCfg_t->priority is priority of SVLAN member configuration.
 700  */
 701 rtk_api_ret_t rtk_svlan_memberPortEntry_adv_set(rtk_uint32 idx, rtk_svlan_memberCfg_t *pSvlan_cfg)
 702 {
 703     rtk_api_ret_t retVal;
 704     rtl8367c_svlan_memconf_t svlanMemConf;
 705     rtk_uint32 phyMbrPmask;
 706
 707     /* Check initialization state */
 708     RTK_CHK_INIT_STATE();
 709
 710     if(NULL == pSvlan_cfg)
 711         return RT_ERR_NULL_POINTER;
 712
 713     if (idx > RTL8367C_SVIDXMAX)
 714         return RT_ERR_SVLAN_ENTRY_INDEX;
 715
 716     if (pSvlan_cfg->svid>RTL8367C_VIDMAX)
 717         return RT_ERR_SVLAN_VID;
 718
 719     RTK_CHK_PORTMASK_VALID(&(pSvlan_cfg->memberport));
 720
 721     RTK_CHK_PORTMASK_VALID(&(pSvlan_cfg->untagport));
 722
 723     if (pSvlan_cfg->fiden > ENABLED)
 724         return RT_ERR_ENABLE;
 725
 726     if (pSvlan_cfg->fid > RTL8367C_FIDMAX)
 727         return RT_ERR_L2_FID;
 728
 729     if (pSvlan_cfg->priority > RTL8367C_PRIMAX)
 730         return RT_ERR_VLAN_PRIORITY;
 731
 732     if (pSvlan_cfg->efiden > ENABLED)
 733         return RT_ERR_ENABLE;
 734
 735     if (pSvlan_cfg->efid > RTL8367C_EFIDMAX)
 736         return RT_ERR_L2_FID;
 737
 738     memset(&svlanMemConf, 0, sizeof(rtl8367c_svlan_memconf_t));
 739     svlanMemConf.vs_svid        = pSvlan_cfg->svid;
 740     if(rtk_switch_portmask_L2P_get(&(pSvlan_cfg->memberport), &phyMbrPmask) != RT_ERR_OK)
 741         return RT_ERR_FAILED;
 742
 743     svlanMemConf.vs_member = phyMbrPmask;
 744
 745     if(rtk_switch_portmask_L2P_get(&(pSvlan_cfg->untagport), &phyMbrPmask) != RT_ERR_OK)
 746         return RT_ERR_FAILED;
 747
 748     svlanMemConf.vs_untag = phyMbrPmask;
 749
 750
 751     svlanMemConf.vs_force_fid   = pSvlan_cfg->fiden;
 752     svlanMemConf.vs_fid_msti    = pSvlan_cfg->fid;
 753     svlanMemConf.vs_priority    = pSvlan_cfg->priority;
 754     svlanMemConf.vs_efiden      = pSvlan_cfg->efiden;
 755     svlanMemConf.vs_efid        = pSvlan_cfg->efid;
 756
 757     if(0 == svlanMemConf.vs_svid &&
 758         0 == svlanMemConf.vs_member &&
 759         0 == svlanMemConf.vs_untag &&
 760         0 == svlanMemConf.vs_force_fid &&
 761         0 == svlanMemConf.vs_fid_msti &&
 762         0 == svlanMemConf.vs_priority &&
 763         0 == svlanMemConf.vs_efiden &&
 764         0 == svlanMemConf.vs_efid)
 765     {
 766         svlan_mbrCfgUsage[idx] = FALSE;
 767         svlan_mbrCfgVid[idx] = 0;
 768     }
 769     else
 770     {
 771         svlan_mbrCfgUsage[idx] = TRUE;
 772         svlan_mbrCfgVid[idx] = svlanMemConf.vs_svid;
 773     }
 774
 775     if ((retVal = rtl8367c_setAsicSvlanMemberConfiguration(idx, &svlanMemConf)) != RT_ERR_OK)
 776         return retVal;
 777
 778
 779     return RT_ERR_OK;
 780 }
 781
 782 /* Function Name:
 783  *      rtk_svlan_memberPortEntry_adv_get
 784  * Description:
 785  *      Get SVLAN member Configure by index.
 786  * Input:
 787  *      idx         - Index (0 ~ 63)
 788  * Output:
 789  *      pSvlan_cfg  - SVLAN member configuration
 790  * Return:
 791  *      RT_ERR_OK                       - OK
 792  *      RT_ERR_FAILED                   - Failed
 793  *      RT_ERR_SMI                      - SMI access error
 794  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
 795  *      RT_ERR_INPUT                    - Invalid input parameters.
 796  * Note:
 797  *      The API can get system 64 accepted s-tag frame format. Only 64 SVID S-tag frame will be accpeted
 798  *      to receiving from uplink ports. Other SVID S-tag frame or S-untagged frame will be droped.
 799  */
 800 rtk_api_ret_t rtk_svlan_memberPortEntry_adv_get(rtk_uint32 idx, rtk_svlan_memberCfg_t *pSvlan_cfg)
 801 {
 802     rtk_api_ret_t retVal;
 803     rtl8367c_svlan_memconf_t svlanMemConf;
 804
 805     /* Check initialization state */
 806     RTK_CHK_INIT_STATE();
 807
 808     if(NULL == pSvlan_cfg)
 809         return RT_ERR_NULL_POINTER;
 810
 811     if (idx > RTL8367C_SVIDXMAX)
 812         return RT_ERR_SVLAN_ENTRY_INDEX;
 813
 814     if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(idx, &svlanMemConf)) != RT_ERR_OK)
 815         return retVal;
 816
 817     pSvlan_cfg->svid        = svlanMemConf.vs_svid;
 818     if(rtk_switch_portmask_P2L_get(svlanMemConf.vs_member,&(pSvlan_cfg->memberport)) != RT_ERR_OK)
 819         return RT_ERR_FAILED;
 820
 821     if(rtk_switch_portmask_P2L_get(svlanMemConf.vs_untag,&(pSvlan_cfg->untagport)) != RT_ERR_OK)
 822         return RT_ERR_FAILED;
 823
 824     pSvlan_cfg->fiden       = svlanMemConf.vs_force_fid;
 825     pSvlan_cfg->fid         = svlanMemConf.vs_fid_msti;
 826     pSvlan_cfg->priority    = svlanMemConf.vs_priority;
 827     pSvlan_cfg->efiden      = svlanMemConf.vs_efiden;
 828     pSvlan_cfg->efid        = svlanMemConf.vs_efid;
 829
 830     return RT_ERR_OK;
 831
 832 }
 833
 834 /* Function Name:
 835  *      rtk_svlan_defaultSvlan_set
 836  * Description:
 837  *      Configure default egress SVLAN.
 838  * Input:
 839  *      port - Source port
 840  *      svid - SVLAN id
 841  * Output:
 842  *      None
 843  * Return:
 844  *      RT_ERR_OK                       - OK
 845  *      RT_ERR_FAILED                   - Failed
 846  *      RT_ERR_SMI                      - SMI access error
 847  *      RT_ERR_INPUT                    - Invalid input parameter.
 848  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
 849  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
 850  * Note:
 851  *      The API can set port n S-tag format index while receiving frame from port n
 852  *      is transmit through uplink port with s-tag field
 853  */
 854 rtk_api_ret_t rtk_svlan_defaultSvlan_set(rtk_port_t port, rtk_vlan_t svid)
 855 {
 856     rtk_api_ret_t retVal;
 857     rtk_uint32 i;
 858     rtl8367c_svlan_memconf_t svlanMemConf;
 859
 860     /* Check initialization state */
 861     RTK_CHK_INIT_STATE();
 862
 863     /* Check port Valid */
 864     RTK_CHK_PORT_VALID(port);
 865
 866     /* svid must be 0~4095 */
 867     if (svid > RTL8367C_VIDMAX)
 868         return RT_ERR_SVLAN_VID;
 869
 870     for (i = 0; i < RTL8367C_SVIDXNO; i++)
 871     {
 872         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
 873             return retVal;
 874
 875         if (svid == svlanMemConf.vs_svid)
 876         {
 877             if ((retVal = rtl8367c_setAsicSvlanDefaultVlan(rtk_switch_port_L2P_get(port), i)) != RT_ERR_OK)
 878                 return retVal;
 879
 880             return RT_ERR_OK;
 881         }
 882     }
 883
 884     return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
 885 }
 886
 887 /* Function Name:
 888  *      rtk_svlan_defaultSvlan_get
 889  * Description:
 890  *      Get the configure default egress SVLAN.
 891  * Input:
 892  *      port - Source port
 893  * Output:
 894  *      pSvid - SVLAN VID
 895  * Return:
 896  *      RT_ERR_OK           - OK
 897  *      RT_ERR_FAILED       - Failed
 898  *      RT_ERR_SMI          - SMI access error
 899  *      RT_ERR_INPUT        - Invalid input parameters.
 900  * Note:
 901  *      The API can get port n S-tag format index while receiving frame from port n
 902  *      is transmit through uplink port with s-tag field
 903  */
 904 rtk_api_ret_t rtk_svlan_defaultSvlan_get(rtk_port_t port, rtk_vlan_t *pSvid)
 905 {
 906     rtk_api_ret_t retVal;
 907     rtk_uint32 idx;
 908     rtl8367c_svlan_memconf_t svlanMemConf;
 909
 910     /* Check initialization state */
 911     RTK_CHK_INIT_STATE();
 912
 913     if(NULL == pSvid)
 914         return RT_ERR_NULL_POINTER;
 915
 916     /* Check port Valid */
 917     RTK_CHK_PORT_VALID(port);
 918
 919     if ((retVal = rtl8367c_getAsicSvlanDefaultVlan(rtk_switch_port_L2P_get(port), &idx)) != RT_ERR_OK)
 920         return retVal;
 921
 922     if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(idx, &svlanMemConf)) != RT_ERR_OK)
 923         return retVal;
 924
 925     *pSvid = svlanMemConf.vs_svid;
 926
 927     return RT_ERR_OK;
 928 }
 929
 930 /* Function Name:
 931  *      rtk_svlan_c2s_add
 932  * Description:
 933  *      Configure SVLAN C2S table
 934  * Input:
 935  *      vid - VLAN ID
 936  *      src_port - Ingress Port
 937  *      svid - SVLAN VID
 938  * Output:
 939  *      None
 940  * Return:
 941  *      RT_ERR_OK           - OK
 942  *      RT_ERR_FAILED       - Failed
 943  *      RT_ERR_SMI          - SMI access error
 944  *      RT_ERR_PORT_ID      - Invalid port ID.
 945  *      RT_ERR_SVLAN_VID    - Invalid SVLAN VID parameter.
 946  *      RT_ERR_VLAN_VID     - Invalid VID parameter.
 947  *      RT_ERR_OUT_OF_RANGE - input out of range.
 948  *      RT_ERR_INPUT        - Invalid input parameters.
 949  * Note:
 950  *      The API can set system C2S configuration. ASIC will check upstream's VID and assign related
 951  *      SVID to mathed packet. There are 128 SVLAN C2S configurations.
 952  */
 953 rtk_api_ret_t rtk_svlan_c2s_add(rtk_vlan_t vid, rtk_port_t src_port, rtk_vlan_t svid)
 954 {
 955     rtk_api_ret_t retVal, i;
 956     rtk_uint32 empty_idx;
 957     rtk_uint32 evid, pmsk, svidx, c2s_svidx;
 958     rtl8367c_svlan_memconf_t svlanMemConf;
 959     rtk_port_t phyPort;
 960     rtk_uint16 doneFlag;
 961
 962
 963     /* Check initialization state */
 964     RTK_CHK_INIT_STATE();
 965
 966
 967     if (vid > RTL8367C_VIDMAX)
 968         return RT_ERR_VLAN_VID;
 969
 970     if (svid > RTL8367C_VIDMAX)
 971         return RT_ERR_SVLAN_VID;
 972
 973     /* Check port Valid */
 974     RTK_CHK_PORT_VALID(src_port);
 975
 976     phyPort = rtk_switch_port_L2P_get(src_port);
 977
 978     empty_idx = 0xFFFF;
 979     svidx = 0xFFFF;
 980     doneFlag = FALSE;
 981
 982     for (i = 0; i<= RTL8367C_SVIDXMAX; i++)
 983     {
 984         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
 985             return retVal;
 986
 987         if (svid == svlanMemConf.vs_svid)
 988         {
 989             svidx = i;
 990             break;
 991         }
 992     }
 993
 994     if (0xFFFF == svidx)
 995         return RT_ERR_SVLAN_VID;
 996
 997     for (i=RTL8367C_C2SIDXMAX; i>=0; i--)
 998     {
 999         if ((retVal = rtl8367c_getAsicSvlanC2SConf(i, &evid, &pmsk, &c2s_svidx)) != RT_ERR_OK)
1000                 return retVal;
1001
1002         if (evid == vid)
1003         {
1004             /* Check Src_port */
1005             if(pmsk & (1 << phyPort))
1006             {
1007                 /* Check SVIDX */
1008                 if(c2s_svidx == svidx)
1009                 {
1010                     /* All the same, do nothing */
1011                 }
1012                 else
1013                 {
1014                     /* New svidx, remove src_port and find a new slot to add a new enrty */
1015                     pmsk = pmsk & ~(1 << phyPort);
1016                     if(pmsk == 0)
1017                         c2s_svidx = 0;
1018
1019                     if ((retVal = rtl8367c_setAsicSvlanC2SConf(i, vid, pmsk, c2s_svidx)) != RT_ERR_OK)
1020                         return retVal;
1021                 }
1022             }
1023             else
1024             {
1025                 if(c2s_svidx == svidx && doneFlag == FALSE)
1026                 {
1027                     pmsk = pmsk | (1 << phyPort);
1028                     if ((retVal = rtl8367c_setAsicSvlanC2SConf(i, vid, pmsk, svidx)) != RT_ERR_OK)
1029                         return retVal;
1030
1031                     doneFlag = TRUE;
1032                 }
1033             }
1034         }
1035         else if (evid==0&&pmsk==0)
1036         {
1037             empty_idx = i;
1038         }
1039     }
1040
1041     if (0xFFFF != empty_idx && doneFlag ==FALSE)
1042     {
1043        if ((retVal = rtl8367c_setAsicSvlanC2SConf(empty_idx, vid, (1<<phyPort), svidx)) != RT_ERR_OK)
1044            return retVal;
1045
1046        return RT_ERR_OK;
1047     }
1048     else if(doneFlag == TRUE)
1049     {
1050         return RT_ERR_OK;
1051     }
1052
1053     return RT_ERR_OUT_OF_RANGE;
1054 }
1055
1056 /* Function Name:
1057  *      rtk_svlan_c2s_del
1058  * Description:
1059  *      Delete one C2S entry
1060  * Input:
1061  *      vid - VLAN ID
1062  *      src_port - Ingress Port
1063  *      svid - SVLAN VID
1064  * Output:
1065  *      None
1066  * Return:
1067  *      RT_ERR_OK               - OK
1068  *      RT_ERR_FAILED           - Failed
1069  *      RT_ERR_SMI              - SMI access error
1070  *      RT_ERR_VLAN_VID         - Invalid VID parameter.
1071  *      RT_ERR_PORT_ID          - Invalid port ID.
1072  *      RT_ERR_OUT_OF_RANGE     - input out of range.
1073  * Note:
1074  *      The API can delete system C2S configuration. There are 128 SVLAN C2S configurations.
1075  */
1076 rtk_api_ret_t rtk_svlan_c2s_del(rtk_vlan_t vid, rtk_port_t src_port)
1077 {
1078     rtk_api_ret_t retVal;
1079     rtk_uint32 i;
1080     rtk_uint32 evid, pmsk, svidx;
1081     rtk_port_t phyPort;
1082
1083     /* Check initialization state */
1084     RTK_CHK_INIT_STATE();
1085
1086     if (vid > RTL8367C_EVIDMAX)
1087         return RT_ERR_VLAN_VID;
1088
1089     /* Check port Valid */
1090     RTK_CHK_PORT_VALID(src_port);
1091     phyPort = rtk_switch_port_L2P_get(src_port);
1092
1093     for (i = 0; i <= RTL8367C_C2SIDXMAX; i++)
1094     {
1095         if ((retVal = rtl8367c_getAsicSvlanC2SConf(i, &evid, &pmsk, &svidx)) != RT_ERR_OK)
1096             return retVal;
1097
1098         if (evid == vid)
1099         {
1100             if(pmsk & (1 << phyPort))
1101             {
1102                 pmsk = pmsk & ~(1 << phyPort);
1103                 if(pmsk == 0)
1104                 {
1105                     vid = 0;
1106                     svidx = 0;
1107                 }
1108
1109                 if ((retVal = rtl8367c_setAsicSvlanC2SConf(i, vid, pmsk, svidx)) != RT_ERR_OK)
1110                     return retVal;
1111
1112                 return RT_ERR_OK;
1113             }
1114         }
1115     }
1116
1117     return RT_ERR_OUT_OF_RANGE;
1118 }
1119
1120 /* Function Name:
1121  *      rtk_svlan_c2s_get
1122  * Description:
1123  *      Get configure SVLAN C2S table
1124  * Input:
1125  *      vid - VLAN ID
1126  *      src_port - Ingress Port
1127  * Output:
1128  *      pSvid - SVLAN ID
1129  * Return:
1130  *      RT_ERR_OK           - OK
1131  *      RT_ERR_FAILED       - Failed
1132  *      RT_ERR_SMI          - SMI access error
1133  *      RT_ERR_INPUT        - Invalid input parameters.
1134  *      RT_ERR_PORT_ID      - Invalid port ID.
1135  *      RT_ERR_OUT_OF_RANGE - input out of range.
1136  * Note:
1137  *     The API can get system C2S configuration. There are 128 SVLAN C2S configurations.
1138  */
1139 rtk_api_ret_t rtk_svlan_c2s_get(rtk_vlan_t vid, rtk_port_t src_port, rtk_vlan_t *pSvid)
1140 {
1141     rtk_api_ret_t retVal;
1142     rtk_uint32 i;
1143     rtk_uint32 evid, pmsk, svidx;
1144     rtl8367c_svlan_memconf_t svlanMemConf;
1145     rtk_port_t phyPort;
1146
1147     /* Check initialization state */
1148     RTK_CHK_INIT_STATE();
1149
1150     if(NULL == pSvid)
1151         return RT_ERR_NULL_POINTER;
1152
1153     if (vid > RTL8367C_VIDMAX)
1154         return RT_ERR_VLAN_VID;
1155
1156     /* Check port Valid */
1157     RTK_CHK_PORT_VALID(src_port);
1158     phyPort = rtk_switch_port_L2P_get(src_port);
1159
1160     for (i = 0; i <= RTL8367C_C2SIDXMAX; i++)
1161     {
1162         if ((retVal = rtl8367c_getAsicSvlanC2SConf(i, &evid, &pmsk, &svidx)) != RT_ERR_OK)
1163             return retVal;
1164
1165         if (evid == vid)
1166         {
1167             if(pmsk & (1 << phyPort))
1168             {
1169                 if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(svidx, &svlanMemConf)) != RT_ERR_OK)
1170                     return retVal;
1171
1172                 *pSvid = svlanMemConf.vs_svid;
1173                 return RT_ERR_OK;
1174             }
1175         }
1176     }
1177
1178     return RT_ERR_OUT_OF_RANGE;
1179 }
1180
1181 /* Function Name:
1182  *      rtk_svlan_untag_action_set
1183  * Description:
1184  *      Configure Action of downstream UnStag packet
1185  * Input:
1186  *      action  - Action for UnStag
1187  *      svid    - The SVID assigned to UnStag packet
1188  * Output:
1189  *      None
1190  * Return:
1191  *      RT_ERR_OK                       - OK
1192  *      RT_ERR_FAILED                   - Failed
1193  *      RT_ERR_SMI                      - SMI access error
1194  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1195  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1196  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1197  *      RT_ERR_INPUT                    - Invalid input parameters.
1198  * Note:
1199  *      The API can configure action of downstream Un-Stag packet. A SVID assigned
1200  *      to the un-stag is also supported by this API. The parameter of svid is
1201  *      only referenced when the action is set to UNTAG_ASSIGN
1202  */
1203 rtk_api_ret_t rtk_svlan_untag_action_set(rtk_svlan_untag_action_t action, rtk_vlan_t svid)
1204 {
1205     rtk_api_ret_t   retVal;
1206     rtk_uint32      i;
1207     rtl8367c_svlan_memconf_t svlanMemConf;
1208
1209     /* Check initialization state */
1210     RTK_CHK_INIT_STATE();
1211
1212     if (action >= UNTAG_END)
1213         return RT_ERR_OUT_OF_RANGE;
1214
1215     if(action == UNTAG_ASSIGN)
1216     {
1217         if (svid > RTL8367C_VIDMAX)
1218             return RT_ERR_SVLAN_VID;
1219     }
1220
1221     if ((retVal = rtl8367c_setAsicSvlanIngressUntag((rtk_uint32)action)) != RT_ERR_OK)
1222         return retVal;
1223
1224     if(action == UNTAG_ASSIGN)
1225     {
1226         for (i = 0; i < RTL8367C_SVIDXNO; i++)
1227         {
1228             if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
1229                 return retVal;
1230
1231             if (svid == svlanMemConf.vs_svid)
1232             {
1233                 if ((retVal = rtl8367c_setAsicSvlanUntagVlan(i)) != RT_ERR_OK)
1234                     return retVal;
1235
1236                 return RT_ERR_OK;
1237             }
1238         }
1239
1240         return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
1241     }
1242
1243     return RT_ERR_OK;
1244 }
1245
1246 /* Function Name:
1247  *      rtk_svlan_untag_action_get
1248  * Description:
1249  *      Get Action of downstream UnStag packet
1250  * Input:
1251  *      None
1252  * Output:
1253  *      pAction  - Action for UnStag
1254  *      pSvid    - The SVID assigned to UnStag packet
1255  * Return:
1256  *      RT_ERR_OK                       - OK
1257  *      RT_ERR_FAILED                   - Failed
1258  *      RT_ERR_SMI                      - SMI access error
1259  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1260  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1261  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1262  *      RT_ERR_INPUT                    - Invalid input parameters.
1263  * Note:
1264  *      The API can Get action of downstream Un-Stag packet. A SVID assigned
1265  *      to the un-stag is also retrieved by this API. The parameter pSvid is
1266  *      only refernced when the action is UNTAG_ASSIGN
1267  */
1268 rtk_api_ret_t rtk_svlan_untag_action_get(rtk_svlan_untag_action_t *pAction, rtk_vlan_t *pSvid)
1269 {
1270     rtk_api_ret_t   retVal;
1271     rtk_uint32      svidx;
1272     rtl8367c_svlan_memconf_t svlanMemConf;
1273
1274     /* Check initialization state */
1275     RTK_CHK_INIT_STATE();
1276
1277     if(NULL == pAction || NULL == pSvid)
1278         return RT_ERR_NULL_POINTER;
1279
1280     if ((retVal = rtl8367c_getAsicSvlanIngressUntag(pAction)) != RT_ERR_OK)
1281         return retVal;
1282
1283     if(*pAction == UNTAG_ASSIGN)
1284     {
1285         if ((retVal = rtl8367c_getAsicSvlanUntagVlan(&svidx)) != RT_ERR_OK)
1286             return retVal;
1287
1288         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(svidx, &svlanMemConf)) != RT_ERR_OK)
1289             return retVal;
1290
1291         *pSvid = svlanMemConf.vs_svid;
1292     }
1293
1294     return RT_ERR_OK;
1295 }
1296
1297 /* Function Name:
1298  *      rtk_svlan_unmatch_action_set
1299  * Description:
1300  *      Configure Action of downstream Unmatch packet
1301  * Input:
1302  *      action  - Action for Unmatch
1303  *      svid    - The SVID assigned to Unmatch packet
1304  * Output:
1305  *      None
1306  * Return:
1307  *      RT_ERR_OK                       - OK
1308  *      RT_ERR_FAILED                   - Failed
1309  *      RT_ERR_SMI                      - SMI access error
1310  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1311  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1312  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1313  *      RT_ERR_INPUT                    - Invalid input parameters.
1314  * Note:
1315  *      The API can configure action of downstream Un-match packet. A SVID assigned
1316  *      to the un-match is also supported by this API. The parameter od svid is
1317  *      only refernced when the action is set to UNMATCH_ASSIGN
1318  */
1319 rtk_api_ret_t rtk_svlan_unmatch_action_set(rtk_svlan_unmatch_action_t action, rtk_vlan_t svid)
1320 {
1321     rtk_api_ret_t   retVal;
1322     rtk_uint32      i;
1323     rtl8367c_svlan_memconf_t svlanMemConf;
1324
1325     /* Check initialization state */
1326     RTK_CHK_INIT_STATE();
1327
1328     if (action >= UNMATCH_END)
1329         return RT_ERR_OUT_OF_RANGE;
1330
1331     if (action == UNMATCH_ASSIGN)
1332     {
1333         if (svid > RTL8367C_VIDMAX)
1334             return RT_ERR_SVLAN_VID;
1335     }
1336
1337     if ((retVal = rtl8367c_setAsicSvlanIngressUnmatch((rtk_uint32)action)) != RT_ERR_OK)
1338         return retVal;
1339
1340     if(action == UNMATCH_ASSIGN)
1341     {
1342         for (i = 0; i < RTL8367C_SVIDXNO; i++)
1343         {
1344             if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
1345                 return retVal;
1346
1347             if (svid == svlanMemConf.vs_svid)
1348             {
1349                 if ((retVal = rtl8367c_setAsicSvlanUnmatchVlan(i)) != RT_ERR_OK)
1350                     return retVal;
1351
1352                 return RT_ERR_OK;
1353             }
1354         }
1355
1356         return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
1357     }
1358
1359     return RT_ERR_OK;
1360 }
1361
1362 /* Function Name:
1363  *      rtk_svlan_unmatch_action_get
1364  * Description:
1365  *      Get Action of downstream Unmatch packet
1366  * Input:
1367  *      None
1368  * Output:
1369  *      pAction  - Action for Unmatch
1370  *      pSvid    - The SVID assigned to Unmatch packet
1371  * Return:
1372  *      RT_ERR_OK                       - OK
1373  *      RT_ERR_FAILED                   - Failed
1374  *      RT_ERR_SMI                      - SMI access error
1375  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1376  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1377  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1378  *      RT_ERR_INPUT                    - Invalid input parameters.
1379  * Note:
1380  *      The API can Get action of downstream Un-match packet. A SVID assigned
1381  *      to the un-match is also retrieved by this API. The parameter pSvid is
1382  *      only refernced when the action is UNMATCH_ASSIGN
1383  */
1384 rtk_api_ret_t rtk_svlan_unmatch_action_get(rtk_svlan_unmatch_action_t *pAction, rtk_vlan_t *pSvid)
1385 {
1386     rtk_api_ret_t   retVal;
1387     rtk_uint32      svidx;
1388     rtl8367c_svlan_memconf_t svlanMemConf;
1389
1390     /* Check initialization state */
1391     RTK_CHK_INIT_STATE();
1392
1393     if(NULL == pAction || NULL == pSvid)
1394         return RT_ERR_NULL_POINTER;
1395
1396     if ((retVal = rtl8367c_getAsicSvlanIngressUnmatch(pAction)) != RT_ERR_OK)
1397         return retVal;
1398
1399     if(*pAction == UNMATCH_ASSIGN)
1400     {
1401         if ((retVal = rtl8367c_getAsicSvlanUnmatchVlan(&svidx)) != RT_ERR_OK)
1402             return retVal;
1403
1404         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(svidx, &svlanMemConf)) != RT_ERR_OK)
1405             return retVal;
1406
1407         *pSvid = svlanMemConf.vs_svid;
1408     }
1409
1410     return RT_ERR_OK;
1411 }
1412
1413 /* Function Name:
1414  *      rtk_svlan_unassign_action_set
1415  * Description:
1416  *      Configure Action of upstream without svid assign action
1417  * Input:
1418  *      action  - Action for Un-assign
1419  * Output:
1420  *      None
1421  * Return:
1422  *      RT_ERR_OK                       - OK
1423  *      RT_ERR_FAILED                   - Failed
1424  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1425  *      RT_ERR_INPUT                    - Invalid input parameters.
1426  * Note:
1427  *      The API can configure action of upstream Un-assign svid packet. If action is not
1428  *      trap to CPU, the port-based SVID sure be assign as system need
1429  */
1430 rtk_api_ret_t rtk_svlan_unassign_action_set(rtk_svlan_unassign_action_t action)
1431 {
1432     rtk_api_ret_t   retVal;
1433
1434     /* Check initialization state */
1435     RTK_CHK_INIT_STATE();
1436
1437     if (action >= UNASSIGN_END)
1438         return RT_ERR_OUT_OF_RANGE;
1439
1440     retVal = rtl8367c_setAsicSvlanEgressUnassign((rtk_uint32)action);
1441
1442     return retVal;
1443 }
1444
1445 /* Function Name:
1446  *      rtk_svlan_unassign_action_get
1447  * Description:
1448  *      Get action of upstream without svid assignment
1449  * Input:
1450  *      None
1451  * Output:
1452  *      pAction  - Action for Un-assign
1453  * Return:
1454  *      RT_ERR_OK                       - OK
1455  *      RT_ERR_FAILED                   - Failed
1456  * Note:
1457  *      None
1458  */
1459 rtk_api_ret_t rtk_svlan_unassign_action_get(rtk_svlan_unassign_action_t *pAction)
1460 {
1461     rtk_api_ret_t   retVal;
1462
1463     /* Check initialization state */
1464     RTK_CHK_INIT_STATE();
1465
1466     if(NULL == pAction)
1467         return RT_ERR_NULL_POINTER;
1468
1469     retVal = rtl8367c_getAsicSvlanEgressUnassign(pAction);
1470
1471     return retVal;
1472 }
1473
1474 /* Function Name:
1475  *      rtk_svlan_dmac_vidsel_set
1476  * Description:
1477  *      Set DMAC CVID selection
1478  * Input:
1479  *      port    - Port
1480  *      enable  - state of DMAC CVID Selection
1481  * Output:
1482  *      None.
1483  * Return:
1484  *      RT_ERR_OK                       - OK
1485  *      RT_ERR_FAILED                   - Failed
1486  *      RT_ERR_SMI                      - SMI access error
1487  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1488  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1489  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1490  *      RT_ERR_INPUT                    - Invalid input parameters.
1491  * Note:
1492  *      This API can set DMAC CVID Selection state
1493  */
1494 rtk_api_ret_t rtk_svlan_dmac_vidsel_set(rtk_port_t port, rtk_enable_t enable)
1495 {
1496     rtk_api_ret_t   retVal;
1497
1498     /* Check initialization state */
1499     RTK_CHK_INIT_STATE();
1500
1501     /* Check port Valid */
1502     RTK_CHK_PORT_VALID(port);
1503
1504     if (enable >= RTK_ENABLE_END)
1505         return RT_ERR_ENABLE;
1506
1507     if ((retVal = rtl8367c_setAsicSvlanDmacCvidSel(rtk_switch_port_L2P_get(port), enable)) != RT_ERR_OK)
1508             return retVal;
1509
1510     return RT_ERR_OK;
1511 }
1512
1513 /* Function Name:
1514  *      rtk_svlan_dmac_vidsel_get
1515  * Description:
1516  *      Get DMAC CVID selection
1517  * Input:
1518  *      port    - Port
1519  * Output:
1520  *      pEnable - state of DMAC CVID Selection
1521  * Return:
1522  *      RT_ERR_OK                       - OK
1523  *      RT_ERR_FAILED                   - Failed
1524  *      RT_ERR_SMI                      - SMI access error
1525  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1526  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1527  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1528  *      RT_ERR_INPUT                    - Invalid input parameters.
1529  * Note:
1530  *      This API can get DMAC CVID Selection state
1531  */
1532 rtk_api_ret_t rtk_svlan_dmac_vidsel_get(rtk_port_t port, rtk_enable_t *pEnable)
1533 {
1534     rtk_api_ret_t   retVal;
1535
1536     /* Check initialization state */
1537     RTK_CHK_INIT_STATE();
1538
1539     if(NULL == pEnable)
1540         return RT_ERR_NULL_POINTER;
1541
1542     /* Check port Valid */
1543     RTK_CHK_PORT_VALID(port);
1544
1545     if ((retVal = rtl8367c_getAsicSvlanDmacCvidSel(rtk_switch_port_L2P_get(port), pEnable)) != RT_ERR_OK)
1546             return retVal;
1547
1548     return RT_ERR_OK;
1549 }
1550
1551 /* Function Name:
1552  *      rtk_svlan_ipmc2s_add
1553  * Description:
1554  *      add ip multicast address to SVLAN
1555  * Input:
1556  *      svid    - SVLAN VID
1557  *      ipmc    - ip multicast address
1558  *      ipmcMsk - ip multicast mask
1559  * Output:
1560  *      None
1561  * Return:
1562  *      RT_ERR_OK                       - OK
1563  *      RT_ERR_FAILED                   - Failed
1564  *      RT_ERR_SMI                      - SMI access error
1565  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1566  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1567  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1568  *      RT_ERR_INPUT                    - Invalid input parameters.
1569  * Note:
1570  *      The API can set IP mutlicast to SVID configuration. If upstream packet is IPv4 multicast
1571  *      packet and DIP is matched MC2S configuration, ASIC will assign egress SVID to the packet.
1572  *      There are 32 SVLAN multicast configurations for IP and L2 multicast.
1573  */
1574 rtk_api_ret_t rtk_svlan_ipmc2s_add(ipaddr_t ipmc, ipaddr_t ipmcMsk,rtk_vlan_t svid)
1575 {
1576     rtk_api_ret_t retVal, i;
1577     rtk_uint32 empty_idx;
1578     rtk_uint32 svidx;
1579     rtl8367c_svlan_memconf_t svlanMemConf;
1580     rtl8367c_svlan_mc2s_t svlanMC2SConf;
1581
1582     /* Check initialization state */
1583     RTK_CHK_INIT_STATE();
1584
1585     if (svid > RTL8367C_VIDMAX)
1586         return RT_ERR_SVLAN_VID;
1587
1588     if ((ipmc&0xF0000000)!=0xE0000000)
1589         return RT_ERR_INPUT;
1590
1591     svidx = 0xFFFF;
1592
1593     for (i = 0; i < RTL8367C_SVIDXNO; i++)
1594     {
1595         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
1596             return retVal;
1597
1598         if (svid == svlanMemConf.vs_svid)
1599         {
1600             svidx = i;
1601             break;
1602         }
1603     }
1604
1605     if (0xFFFF == svidx)
1606             return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
1607
1608
1609     empty_idx = 0xFFFF;
1610
1611     for (i = RTL8367C_MC2SIDXMAX; i >= 0; i--)
1612     {
1613         if ((retVal = rtl8367c_getAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1614             return retVal;
1615
1616         if (TRUE == svlanMC2SConf.valid)
1617         {
1618             if (svlanMC2SConf.format == SVLAN_MC2S_MODE_IP &&
1619                 svlanMC2SConf.sdata==ipmc&&
1620                 svlanMC2SConf.smask==ipmcMsk)
1621             {
1622                 svlanMC2SConf.svidx = svidx;
1623                 if ((retVal = rtl8367c_setAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1624                     return retVal;
1625             }
1626         }
1627         else
1628         {
1629             empty_idx = i;
1630         }
1631     }
1632
1633     if (empty_idx!=0xFFFF)
1634     {
1635         svlanMC2SConf.valid = TRUE;
1636         svlanMC2SConf.svidx = svidx;
1637         svlanMC2SConf.format = SVLAN_MC2S_MODE_IP;
1638         svlanMC2SConf.sdata = ipmc;
1639         svlanMC2SConf.smask = ipmcMsk;
1640         if ((retVal = rtl8367c_setAsicSvlanMC2SConf(empty_idx, &svlanMC2SConf)) != RT_ERR_OK)
1641             return retVal;
1642         return RT_ERR_OK;
1643     }
1644
1645     return RT_ERR_OUT_OF_RANGE;
1646
1647 }
1648
1649 /* Function Name:
1650  *      rtk_svlan_ipmc2s_del
1651  * Description:
1652  *      delete ip multicast address to SVLAN
1653  * Input:
1654  *      ipmc    - ip multicast address
1655  *      ipmcMsk - ip multicast mask
1656  * Output:
1657  *      None
1658  * Return:
1659  *      RT_ERR_OK               - OK
1660  *      RT_ERR_FAILED           - Failed
1661  *      RT_ERR_SMI              - SMI access error
1662  *      RT_ERR_SVLAN_VID        - Invalid SVLAN VID parameter.
1663  *      RT_ERR_OUT_OF_RANGE     - input out of range.
1664  * Note:
1665  *      The API can delete IP mutlicast to SVID configuration. There are 32 SVLAN multicast configurations for IP and L2 multicast.
1666  */
1667 rtk_api_ret_t rtk_svlan_ipmc2s_del(ipaddr_t ipmc, ipaddr_t ipmcMsk)
1668 {
1669     rtk_api_ret_t retVal;
1670     rtk_uint32 i;
1671     rtl8367c_svlan_mc2s_t svlanMC2SConf;
1672
1673     /* Check initialization state */
1674     RTK_CHK_INIT_STATE();
1675
1676     if ((ipmc&0xF0000000)!=0xE0000000)
1677         return RT_ERR_INPUT;
1678
1679     for (i = 0; i <= RTL8367C_MC2SIDXMAX; i++)
1680     {
1681         if ((retVal = rtl8367c_getAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1682             return retVal;
1683
1684         if (TRUE == svlanMC2SConf.valid)
1685         {
1686             if (svlanMC2SConf.format == SVLAN_MC2S_MODE_IP &&
1687                 svlanMC2SConf.sdata==ipmc&&
1688                 svlanMC2SConf.smask==ipmcMsk)
1689             {
1690                 memset(&svlanMC2SConf, 0, sizeof(rtl8367c_svlan_mc2s_t));
1691                 if ((retVal = rtl8367c_setAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1692                     return retVal;
1693                 return RT_ERR_OK;
1694             }
1695         }
1696     }
1697
1698     return RT_ERR_OUT_OF_RANGE;
1699 }
1700
1701 /* Function Name:
1702  *      rtk_svlan_ipmc2s_get
1703  * Description:
1704  *      Get ip multicast address to SVLAN
1705  * Input:
1706  *      ipmc    - ip multicast address
1707  *      ipmcMsk - ip multicast mask
1708  * Output:
1709  *      pSvid - SVLAN VID
1710  * Return:
1711  *      RT_ERR_OK           - OK
1712  *      RT_ERR_FAILED       - Failed
1713  *      RT_ERR_SMI          - SMI access error
1714  *      RT_ERR_INPUT        - Invalid input parameters.
1715  *      RT_ERR_OUT_OF_RANGE - input out of range.
1716  * Note:
1717  *      The API can get IP mutlicast to SVID configuration. There are 32 SVLAN multicast configurations for IP and L2 multicast.
1718  */
1719 rtk_api_ret_t rtk_svlan_ipmc2s_get(ipaddr_t ipmc, ipaddr_t ipmcMsk, rtk_vlan_t *pSvid)
1720 {
1721     rtk_api_ret_t retVal;
1722     rtk_uint32 i;
1723     rtl8367c_svlan_memconf_t svlanMemConf;
1724     rtl8367c_svlan_mc2s_t svlanMC2SConf;
1725
1726     /* Check initialization state */
1727     RTK_CHK_INIT_STATE();
1728
1729     if(NULL == pSvid)
1730         return RT_ERR_NULL_POINTER;
1731
1732     if ((ipmc&0xF0000000)!=0xE0000000)
1733         return RT_ERR_INPUT;
1734
1735     for (i = 0; i <= RTL8367C_MC2SIDXMAX; i++)
1736     {
1737         if ((retVal = rtl8367c_getAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1738             return retVal;
1739
1740         if (TRUE == svlanMC2SConf.valid &&
1741             svlanMC2SConf.format == SVLAN_MC2S_MODE_IP &&
1742             svlanMC2SConf.sdata == ipmc &&
1743             svlanMC2SConf.smask == ipmcMsk)
1744         {
1745             if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(svlanMC2SConf.svidx, &svlanMemConf)) != RT_ERR_OK)
1746                 return retVal;
1747             *pSvid = svlanMemConf.vs_svid;
1748             return RT_ERR_OK;
1749         }
1750     }
1751
1752     return RT_ERR_OUT_OF_RANGE;
1753 }
1754
1755 /* Function Name:
1756  *      rtk_svlan_l2mc2s_add
1757  * Description:
1758  *      Add L2 multicast address to SVLAN
1759  * Input:
1760  *      mac     - L2 multicast address
1761  *      macMsk  - L2 multicast address mask
1762  *      svid    - SVLAN VID
1763  * Output:
1764  *      None
1765  * Return:
1766  *      RT_ERR_OK                       - OK
1767  *      RT_ERR_FAILED                   - Failed
1768  *      RT_ERR_SMI                      - SMI access error
1769  *      RT_ERR_SVLAN_VID                - Invalid SVLAN VID parameter.
1770  *      RT_ERR_SVLAN_ENTRY_NOT_FOUND    - specified svlan entry not found.
1771  *      RT_ERR_OUT_OF_RANGE             - input out of range.
1772  *      RT_ERR_INPUT                    - Invalid input parameters.
1773  * Note:
1774  *      The API can set L2 Mutlicast to SVID configuration. If upstream packet is L2 multicast
1775  *      packet and DMAC is matched, ASIC will assign egress SVID to the packet. There are 32
1776  *      SVLAN multicast configurations for IP and L2 multicast.
1777  */
1778 rtk_api_ret_t rtk_svlan_l2mc2s_add(rtk_mac_t mac, rtk_mac_t macMsk, rtk_vlan_t svid)
1779 {
1780     rtk_api_ret_t retVal, i;
1781     rtk_uint32 empty_idx;
1782     rtk_uint32 svidx, l2add, l2Mask;
1783     rtl8367c_svlan_memconf_t svlanMemConf;
1784     rtl8367c_svlan_mc2s_t svlanMC2SConf;
1785
1786     /* Check initialization state */
1787     RTK_CHK_INIT_STATE();
1788
1789     if (svid > RTL8367C_VIDMAX)
1790         return RT_ERR_SVLAN_VID;
1791
1792     if (mac.octet[0]!= 1&&mac.octet[1]!=0)
1793         return RT_ERR_INPUT;
1794
1795     l2add = (mac.octet[2] << 24) | (mac.octet[3] << 16) | (mac.octet[4] << 8) | mac.octet[5];
1796     l2Mask = (macMsk.octet[2] << 24) | (macMsk.octet[3] << 16) | (macMsk.octet[4] << 8) | macMsk.octet[5];
1797
1798     svidx = 0xFFFF;
1799
1800     for (i = 0; i < RTL8367C_SVIDXNO; i++)
1801     {
1802         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
1803             return retVal;
1804
1805         if (svid == svlanMemConf.vs_svid)
1806         {
1807             svidx = i;
1808             break;
1809         }
1810     }
1811
1812     if (0xFFFF == svidx)
1813         return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
1814
1815     empty_idx = 0xFFFF;
1816
1817     for (i = RTL8367C_MC2SIDXMAX; i >=0; i--)
1818     {
1819         if ((retVal = rtl8367c_getAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1820             return retVal;
1821
1822         if (TRUE == svlanMC2SConf.valid)
1823         {
1824             if (svlanMC2SConf.format == SVLAN_MC2S_MODE_MAC &&
1825                 svlanMC2SConf.sdata==l2add&&
1826                 svlanMC2SConf.smask==l2Mask)
1827             {
1828                 svlanMC2SConf.svidx = svidx;
1829                 if ((retVal = rtl8367c_setAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1830                     return retVal;
1831             }
1832         }
1833         else
1834         {
1835             empty_idx = i;
1836         }
1837     }
1838
1839     if (empty_idx!=0xFFFF)
1840     {
1841         svlanMC2SConf.valid = TRUE;
1842         svlanMC2SConf.svidx = svidx;
1843         svlanMC2SConf.format = SVLAN_MC2S_MODE_MAC;
1844         svlanMC2SConf.sdata = l2add;
1845         svlanMC2SConf.smask = l2Mask;
1846
1847         if ((retVal = rtl8367c_setAsicSvlanMC2SConf(empty_idx, &svlanMC2SConf)) != RT_ERR_OK)
1848             return retVal;
1849         return RT_ERR_OK;
1850     }
1851
1852     return RT_ERR_OUT_OF_RANGE;
1853 }
1854
1855 /* Function Name:
1856  *      rtk_svlan_l2mc2s_del
1857  * Description:
1858  *      delete L2 multicast address to SVLAN
1859  * Input:
1860  *      mac     - L2 multicast address
1861  *      macMsk  - L2 multicast address mask
1862  * Output:
1863  *      None
1864  * Return:
1865  *      RT_ERR_OK               - OK
1866  *      RT_ERR_FAILED           - Failed
1867  *      RT_ERR_SMI              - SMI access error
1868  *      RT_ERR_SVLAN_VID        - Invalid SVLAN VID parameter.
1869  *      RT_ERR_OUT_OF_RANGE     - input out of range.
1870  * Note:
1871  *      The API can delete Mutlicast to SVID configuration. There are 32 SVLAN multicast configurations for IP and L2 multicast.
1872  */
1873 rtk_api_ret_t rtk_svlan_l2mc2s_del(rtk_mac_t mac, rtk_mac_t macMsk)
1874 {
1875     rtk_api_ret_t retVal;
1876     rtk_uint32 i;
1877     rtk_uint32 l2add, l2Mask;
1878     rtl8367c_svlan_mc2s_t svlanMC2SConf;
1879
1880     /* Check initialization state */
1881     RTK_CHK_INIT_STATE();
1882
1883     if (mac.octet[0]!= 1&&mac.octet[1]!=0)
1884         return RT_ERR_INPUT;
1885
1886     l2add = (mac.octet[2] << 24) | (mac.octet[3] << 16) | (mac.octet[4] << 8) | mac.octet[5];
1887     l2Mask = (macMsk.octet[2] << 24) | (macMsk.octet[3] << 16) | (macMsk.octet[4] << 8) | macMsk.octet[5];
1888
1889     for (i = 0; i <= RTL8367C_MC2SIDXMAX; i++)
1890     {
1891         if ((retVal = rtl8367c_getAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1892             return retVal;
1893
1894         if (TRUE == svlanMC2SConf.valid)
1895         {
1896             if (svlanMC2SConf.format == SVLAN_MC2S_MODE_MAC &&
1897                 svlanMC2SConf.sdata==l2add&&
1898                 svlanMC2SConf.smask==l2Mask)
1899             {
1900                 memset(&svlanMC2SConf, 0, sizeof(rtl8367c_svlan_mc2s_t));
1901                 if ((retVal = rtl8367c_setAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1902                     return retVal;
1903                 return RT_ERR_OK;
1904             }
1905         }
1906     }
1907
1908     return RT_ERR_OUT_OF_RANGE;
1909 }
1910
1911 /* Function Name:
1912  *      rtk_svlan_l2mc2s_get
1913  * Description:
1914  *      Get L2 multicast address to SVLAN
1915  * Input:
1916  *      mac     - L2 multicast address
1917  *      macMsk  - L2 multicast address mask
1918  * Output:
1919  *      pSvid - SVLAN VID
1920  * Return:
1921  *      RT_ERR_OK               - OK
1922  *      RT_ERR_FAILED           - Failed
1923  *      RT_ERR_SMI              - SMI access error
1924  *      RT_ERR_INPUT            - Invalid input parameters.
1925  *      RT_ERR_OUT_OF_RANGE     - input out of range.
1926  * Note:
1927  *      The API can get L2 mutlicast to SVID configuration. There are 32 SVLAN multicast configurations for IP and L2 multicast.
1928  */
1929 rtk_api_ret_t rtk_svlan_l2mc2s_get(rtk_mac_t mac, rtk_mac_t macMsk, rtk_vlan_t *pSvid)
1930 {
1931     rtk_api_ret_t retVal;
1932     rtk_uint32 i;
1933     rtk_uint32 l2add,l2Mask;
1934     rtl8367c_svlan_memconf_t svlanMemConf;
1935     rtl8367c_svlan_mc2s_t svlanMC2SConf;
1936
1937     /* Check initialization state */
1938     RTK_CHK_INIT_STATE();
1939
1940     if(NULL == pSvid)
1941         return RT_ERR_NULL_POINTER;
1942
1943     if (mac.octet[0]!= 1&&mac.octet[1]!=0)
1944         return RT_ERR_INPUT;
1945
1946     l2add = (mac.octet[2] << 24) | (mac.octet[3] << 16) | (mac.octet[4] << 8) | mac.octet[5];
1947     l2Mask = (macMsk.octet[2] << 24) | (macMsk.octet[3] << 16) | (macMsk.octet[4] << 8) | macMsk.octet[5];
1948
1949     for (i = 0; i <= RTL8367C_MC2SIDXMAX; i++)
1950     {
1951         if ((retVal = rtl8367c_getAsicSvlanMC2SConf(i, &svlanMC2SConf)) != RT_ERR_OK)
1952             return retVal;
1953
1954         if (TRUE == svlanMC2SConf.valid)
1955         {
1956             if (svlanMC2SConf.format == SVLAN_MC2S_MODE_MAC &&
1957                 svlanMC2SConf.sdata==l2add&&
1958                 svlanMC2SConf.smask==l2Mask)
1959             {
1960                 if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(svlanMC2SConf.svidx, &svlanMemConf)) != RT_ERR_OK)
1961                     return retVal;
1962                 *pSvid = svlanMemConf.vs_svid;
1963
1964                 return RT_ERR_OK;
1965             }
1966         }
1967     }
1968
1969     return RT_ERR_OUT_OF_RANGE;
1970 }
1971
1972 /* Function Name:
1973  *      rtk_svlan_sp2c_add
1974  * Description:
1975  *      Add system SP2C configuration
1976  * Input:
1977  *      cvid        - VLAN ID
1978  *      dst_port    - Destination port of SVLAN to CVLAN configuration
1979  *      svid        - SVLAN VID
1980  * Output:
1981  *      None
1982  * Return:
1983  *      RT_ERR_OK           - OK
1984  *      RT_ERR_FAILED       - Failed
1985  *      RT_ERR_SMI          - SMI access error
1986  *      RT_ERR_PORT_ID      - Invalid port number.
1987  *      RT_ERR_SVLAN_VID    - Invalid SVLAN VID parameter.
1988  *      RT_ERR_VLAN_VID     - Invalid VID parameter.
1989  *      RT_ERR_OUT_OF_RANGE - input out of range.
1990  *      RT_ERR_INPUT        - Invalid input parameters.
1991  * Note:
1992  *      The API can add SVID & Destination Port to CVLAN configuration. The downstream frames with assigned
1993  *      SVID will be add C-tag with assigned CVID if the output port is the assigned destination port.
1994  *      There are 128 SP2C configurations.
1995  */
1996 rtk_api_ret_t rtk_svlan_sp2c_add(rtk_vlan_t svid, rtk_port_t dst_port, rtk_vlan_t cvid)
1997 {
1998     rtk_api_ret_t retVal, i;
1999     rtk_uint32 empty_idx, svidx;
2000     rtl8367c_svlan_memconf_t svlanMemConf;
2001     rtl8367c_svlan_s2c_t svlanSP2CConf;
2002     rtk_port_t port;
2003
2004     /* Check initialization state */
2005     RTK_CHK_INIT_STATE();
2006
2007     if (svid > RTL8367C_VIDMAX)
2008         return RT_ERR_SVLAN_VID;
2009
2010     if (cvid > RTL8367C_VIDMAX)
2011         return RT_ERR_VLAN_VID;
2012
2013     /* Check port Valid */
2014     RTK_CHK_PORT_VALID(dst_port);
2015     port = rtk_switch_port_L2P_get(dst_port);
2016
2017     svidx = 0xFFFF;
2018
2019     for (i = 0; i < RTL8367C_SVIDXNO; i++)
2020     {
2021         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
2022             return retVal;
2023
2024         if (svid == svlanMemConf.vs_svid)
2025         {
2026             svidx = i;
2027             break;
2028         }
2029     }
2030
2031     if (0xFFFF == svidx)
2032         return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
2033
2034     empty_idx = 0xFFFF;
2035
2036     for (i=RTL8367C_SP2CMAX; i >=0 ; i--)
2037     {
2038         if ((retVal = rtl8367c_getAsicSvlanSP2CConf(i, &svlanSP2CConf)) != RT_ERR_OK)
2039             return retVal;
2040
2041         if ( (svlanSP2CConf.svidx == svidx) && (svlanSP2CConf.dstport == port) && (svlanSP2CConf.valid == 1))
2042         {
2043             empty_idx = i;
2044             break;
2045         }
2046         else if (svlanSP2CConf.valid == 0)
2047         {
2048             empty_idx = i;
2049         }
2050     }
2051
2052     if (empty_idx!=0xFFFF)
2053     {
2054         svlanSP2CConf.valid     = 1;
2055         svlanSP2CConf.vid       = cvid;
2056         svlanSP2CConf.svidx     = svidx;
2057         svlanSP2CConf.dstport   = port;
2058
2059         if ((retVal = rtl8367c_setAsicSvlanSP2CConf(empty_idx, &svlanSP2CConf)) != RT_ERR_OK)
2060             return retVal;
2061         return RT_ERR_OK;
2062     }
2063
2064     return RT_ERR_OUT_OF_RANGE;
2065
2066 }
2067
2068 /* Function Name:
2069  *      rtk_svlan_sp2c_get
2070  * Description:
2071  *      Get configure system SP2C content
2072  * Input:
2073  *      svid        - SVLAN VID
2074  *      dst_port    - Destination port of SVLAN to CVLAN configuration
2075  * Output:
2076  *      pCvid - VLAN ID
2077  * Return:
2078  *      RT_ERR_OK           - OK
2079  *      RT_ERR_FAILED       - Failed
2080  *      RT_ERR_SMI          - SMI access error
2081  *      RT_ERR_INPUT        - Invalid input parameters.
2082  *      RT_ERR_OUT_OF_RANGE - input out of range.
2083  *      RT_ERR_PORT_ID      - Invalid port number.
2084  *      RT_ERR_SVLAN_VID    - Invalid SVLAN VID parameter.
2085  * Note:
2086  *     The API can get SVID & Destination Port to CVLAN configuration. There are 128 SP2C configurations.
2087  */
2088 rtk_api_ret_t rtk_svlan_sp2c_get(rtk_vlan_t svid, rtk_port_t dst_port, rtk_vlan_t *pCvid)
2089 {
2090     rtk_api_ret_t retVal;
2091     rtk_uint32 i, svidx;
2092     rtl8367c_svlan_memconf_t svlanMemConf;
2093     rtl8367c_svlan_s2c_t svlanSP2CConf;
2094
2095     /* Check initialization state */
2096     RTK_CHK_INIT_STATE();
2097
2098     if(NULL == pCvid)
2099         return RT_ERR_NULL_POINTER;
2100
2101     if (svid > RTL8367C_VIDMAX)
2102         return RT_ERR_SVLAN_VID;
2103
2104     /* Check port Valid */
2105     RTK_CHK_PORT_VALID(dst_port);
2106     dst_port = rtk_switch_port_L2P_get(dst_port);
2107
2108     svidx = 0xFFFF;
2109
2110     for (i = 0; i < RTL8367C_SVIDXNO; i++)
2111     {
2112         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
2113             return retVal;
2114
2115         if (svid == svlanMemConf.vs_svid)
2116         {
2117             svidx = i;
2118             break;
2119         }
2120     }
2121
2122     if (0xFFFF == svidx)
2123         return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
2124
2125     for (i = 0; i <= RTL8367C_SP2CMAX; i++)
2126     {
2127         if ((retVal = rtl8367c_getAsicSvlanSP2CConf(i, &svlanSP2CConf)) != RT_ERR_OK)
2128             return retVal;
2129
2130         if ( (svlanSP2CConf.svidx == svidx) && (svlanSP2CConf.dstport == dst_port) && (svlanSP2CConf.valid == 1) )
2131         {
2132             *pCvid = svlanSP2CConf.vid;
2133             return RT_ERR_OK;
2134         }
2135     }
2136
2137     return RT_ERR_OUT_OF_RANGE;
2138 }
2139
2140 /* Function Name:
2141  *      rtk_svlan_sp2c_del
2142  * Description:
2143  *      Delete system SP2C configuration
2144  * Input:
2145  *      svid        - SVLAN VID
2146  *      dst_port    - Destination port of SVLAN to CVLAN configuration
2147  * Output:
2148  *      None
2149  * Return:
2150  *      RT_ERR_OK           - OK
2151  *      RT_ERR_FAILED       - Failed
2152  *      RT_ERR_SMI          - SMI access error
2153  *      RT_ERR_PORT_ID      - Invalid port number.
2154  *      RT_ERR_SVLAN_VID    - Invalid SVLAN VID parameter.
2155  *      RT_ERR_OUT_OF_RANGE - input out of range.
2156  * Note:
2157  *      The API can delete SVID & Destination Port to CVLAN configuration. There are 128 SP2C configurations.
2158  */
2159 rtk_api_ret_t rtk_svlan_sp2c_del(rtk_vlan_t svid, rtk_port_t dst_port)
2160 {
2161     rtk_api_ret_t retVal;
2162     rtk_uint32 i, svidx;
2163     rtl8367c_svlan_memconf_t svlanMemConf;
2164     rtl8367c_svlan_s2c_t svlanSP2CConf;
2165
2166     /* Check initialization state */
2167     RTK_CHK_INIT_STATE();
2168
2169     if (svid > RTL8367C_VIDMAX)
2170         return RT_ERR_SVLAN_VID;
2171
2172     /* Check port Valid */
2173     RTK_CHK_PORT_VALID(dst_port);
2174     dst_port = rtk_switch_port_L2P_get(dst_port);
2175
2176     svidx = 0xFFFF;
2177
2178     for (i = 0; i < RTL8367C_SVIDXNO; i++)
2179     {
2180         if ((retVal = rtl8367c_getAsicSvlanMemberConfiguration(i, &svlanMemConf)) != RT_ERR_OK)
2181             return retVal;
2182
2183         if (svid == svlanMemConf.vs_svid)
2184         {
2185             svidx = i;
2186             break;
2187         }
2188     }
2189
2190     if (0xFFFF == svidx)
2191         return RT_ERR_SVLAN_ENTRY_NOT_FOUND;
2192
2193     for (i = 0; i <= RTL8367C_SP2CMAX; i++)
2194     {
2195         if ((retVal = rtl8367c_getAsicSvlanSP2CConf(i, &svlanSP2CConf)) != RT_ERR_OK)
2196             return retVal;
2197
2198         if ( (svlanSP2CConf.svidx == svidx) && (svlanSP2CConf.dstport == dst_port) && (svlanSP2CConf.valid == 1) )
2199         {
2200             svlanSP2CConf.valid     = 0;
2201             svlanSP2CConf.vid       = 0;
2202             svlanSP2CConf.svidx     = 0;
2203             svlanSP2CConf.dstport   = 0;
2204
2205             if ((retVal = rtl8367c_setAsicSvlanSP2CConf(i, &svlanSP2CConf)) != RT_ERR_OK)
2206                 return retVal;
2207             return RT_ERR_OK;
2208         }
2209
2210     }
2211
2212     return RT_ERR_OUT_OF_RANGE;
2213 }
2214
2215 /* Function Name:
2216  *      rtk_svlan_lookupType_set
2217  * Description:
2218  *      Set lookup type of SVLAN
2219  * Input:
2220  *      type        - lookup type
2221  * Output:
2222  *      None
2223  * Return:
2224  *      RT_ERR_OK
2225  *      RT_ERR_FAILED
2226  * Note:
2227  *      none
2228  */
2229 rtk_api_ret_t rtk_svlan_lookupType_set(rtk_svlan_lookupType_t type)
2230 {
2231     rtk_api_ret_t   retVal;
2232
2233     /* Check initialization state */
2234     RTK_CHK_INIT_STATE();
2235
2236     if (type >= SVLAN_LOOKUP_END)
2237         return RT_ERR_CHIP_NOT_SUPPORTED;
2238
2239
2240     svlan_lookupType = type;
2241
2242     retVal = rtl8367c_setAsicSvlanLookupType((rtk_uint32)type);
2243
2244     return retVal;
2245 }
2246
2247 /* Function Name:
2248  *      rtk_svlan_lookupType_get
2249  * Description:
2250  *      Get lookup type of SVLAN
2251  * Input:
2252  *      pType       - lookup type
2253  * Output:
2254  *      None
2255  * Return:
2256  *      RT_ERR_OK
2257  *      RT_ERR_FAILED
2258  * Note:
2259  *      none
2260  */
2261 rtk_api_ret_t rtk_svlan_lookupType_get(rtk_svlan_lookupType_t *pType)
2262 {
2263     rtk_api_ret_t   retVal;
2264
2265     /* Check initialization state */
2266     RTK_CHK_INIT_STATE();
2267
2268     if(NULL == pType)
2269         return RT_ERR_NULL_POINTER;
2270
2271     retVal = rtl8367c_getAsicSvlanLookupType(pType);
2272
2273     svlan_lookupType = *pType;
2274
2275     return retVal;
2276 }
2277
2278 /* Function Name:
2279  *      rtk_svlan_trapPri_set
2280  * Description:
2281  *      Set svlan trap priority
2282  * Input:
2283  *      priority - priority for trap packets
2284  * Output:
2285  *      None
2286  * Return:
2287  *      RT_ERR_OK
2288  *      RT_ERR_FAILED
2289  *      RT_ERR_QOS_INT_PRIORITY
2290  * Note:
2291  *      None
2292  */
2293 rtk_api_ret_t rtk_svlan_trapPri_set(rtk_pri_t priority)
2294 {
2295     rtk_api_ret_t   retVal;
2296
2297     RTK_CHK_INIT_STATE();
2298
2299     if(priority > RTL8367C_PRIMAX)
2300         return RT_ERR_OUT_OF_RANGE;
2301
2302     retVal = rtl8367c_setAsicSvlanTrapPriority(priority);
2303
2304     return retVal;
2305 }   /* end of rtk_svlan_trapPri_set */
2306
2307 /* Function Name:
2308  *      rtk_svlan_trapPri_get
2309  * Description:
2310  *      Get svlan trap priority
2311  * Input:
2312  *      None
2313  * Output:
2314  *      pPriority - priority for trap packets
2315  * Return:
2316  *      RT_ERR_OK
2317  *      RT_ERR_FAILED
2318  *      RT_ERR_NULL_POINTER - input parameter may be null pointer
2319  * Note:
2320  *      None
2321  */
2322 rtk_api_ret_t rtk_svlan_trapPri_get(rtk_pri_t *pPriority)
2323 {
2324     rtk_api_ret_t   retVal;
2325
2326     RTK_CHK_INIT_STATE();
2327
2328     if(NULL == pPriority)
2329         return RT_ERR_NULL_POINTER;
2330
2331     retVal = rtl8367c_getAsicSvlanTrapPriority(pPriority);
2332
2333     return retVal;
2334 }   /* end of rtk_svlan_trapPri_get */
2335
2336
2337 /* Function Name:
2338  *      rtk_svlan_checkAndCreateMbr
2339  * Description:
2340  *      Check and create Member configuration and return index
2341  * Input:
2342  *      vid  - VLAN id.
2343  * Output:
2344  *      pIndex  - Member configuration index
2345  * Return:
2346  *      RT_ERR_OK           - OK
2347  *      RT_ERR_FAILED       - Failed
2348  *      RT_ERR_SMI          - SMI access error
2349  *      RT_ERR_VLAN_VID     - Invalid VLAN ID.
2350  *      RT_ERR_TBL_FULL     - Member Configuration table full
2351  * Note:
2352  *
2353  */
2354 rtk_api_ret_t rtk_svlan_checkAndCreateMbr(rtk_vlan_t vid, rtk_uint32 *pIndex)
2355 {
2356     rtk_api_ret_t retVal;
2357     rtk_uint32 svidx;
2358     rtk_uint32 empty_idx = 0xFFFF;
2359     rtl8367c_svlan_memconf_t svlan_cfg;
2360
2361     /* Check initialization state */
2362     RTK_CHK_INIT_STATE();
2363
2364     /* vid must be 0~4095 */
2365     if (vid > RTL8367C_VIDMAX)
2366         return RT_ERR_VLAN_VID;
2367
2368     /* Null pointer check */
2369     if(NULL == pIndex)
2370         return RT_ERR_NULL_POINTER;
2371
2372     /* Search exist entry */
2373     for (svidx = 0; svidx <= RTL8367C_SVIDXMAX; svidx++)
2374     {
2375         if(svlan_mbrCfgUsage[svidx] == TRUE)
2376         {
2377             if(svlan_mbrCfgVid[svidx] == vid)
2378             {
2379                 /* Found! return index */
2380                 *pIndex = svidx;
2381                 return RT_ERR_OK;
2382             }
2383         }
2384         else if(empty_idx == 0xFFFF)
2385         {
2386             empty_idx = svidx;
2387         }
2388
2389     }
2390
2391     if(empty_idx == 0xFFFF)
2392     {
2393         /* No empty index */
2394         return RT_ERR_TBL_FULL;
2395     }
2396
2397     svlan_mbrCfgUsage[empty_idx] = TRUE;
2398     svlan_mbrCfgVid[empty_idx] = vid;
2399
2400     memset(&svlan_cfg, 0, sizeof(rtl8367c_svlan_memconf_t));
2401
2402     svlan_cfg.vs_svid = vid;
2403     /*for create check*/
2404     if(vid == 0)
2405     {
2406         svlan_cfg.vs_efid = 1;
2407     }
2408
2409     if((retVal = rtl8367c_setAsicSvlanMemberConfiguration(empty_idx, &svlan_cfg)) != RT_ERR_OK)
2410         return retVal;
2411
2412     *pIndex = empty_idx;
2413     return RT_ERR_OK;
2414 }
2415