target/linux/mediatek/files-5.10/drivers/net/phy/rtk/rtl8367c/rtl8367c_asicdrv_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 : RTL8367C switch high-level API for RTL8367C
  14  * Feature : SVLAN related functions
  15  *
  16  */
  17 #include <rtl8367c_asicdrv_svlan.h>
  18
  19 #include <string.h>
  20
  21 static void _rtl8367c_svlanConfStUser2Smi( rtl8367c_svlan_memconf_t *pUserSt, rtk_uint16 *pSmiSt)
  22 {
  23     pSmiSt[0] |= (pUserSt->vs_member & 0x00FF);
  24     pSmiSt[0] |= (pUserSt->vs_untag & 0x00FF) << 8;
  25
  26     pSmiSt[1] |= (pUserSt->vs_fid_msti & 0x000F);
  27     pSmiSt[1] |= (pUserSt->vs_priority & 0x0007) << 4;
  28     pSmiSt[1] |= (pUserSt->vs_force_fid & 0x0001) << 7;
  29
  30     pSmiSt[2] |= (pUserSt->vs_svid & 0x0FFF);
  31     pSmiSt[2] |= (pUserSt->vs_efiden & 0x0001) << 12;
  32     pSmiSt[2] |= (pUserSt->vs_efid & 0x0007) << 13;
  33
  34     pSmiSt[3] |= ((pUserSt->vs_member & 0x0700) >> 8);
  35     pSmiSt[3] |= ((pUserSt->vs_untag & 0x0700) >> 8) << 3;
  36 }
  37
  38 static void _rtl8367c_svlanConfStSmi2User( rtl8367c_svlan_memconf_t *pUserSt, rtk_uint16 *pSmiSt)
  39 {
  40
  41     pUserSt->vs_member = (pSmiSt[0] & 0x00FF) | ((pSmiSt[3] & 0x0007) << 8);
  42     pUserSt->vs_untag = ((pSmiSt[0] & 0xFF00) >> 8) | (((pSmiSt[3] & 0x0038) >> 3) << 8);
  43
  44     pUserSt->vs_fid_msti = (pSmiSt[1] & 0x000F);
  45     pUserSt->vs_priority = (pSmiSt[1] & 0x0070) >> 4;
  46     pUserSt->vs_force_fid = (pSmiSt[1] & 0x0080) >> 7;
  47
  48     pUserSt->vs_svid = (pSmiSt[2] & 0x0FFF);
  49     pUserSt->vs_efiden = (pSmiSt[2] & 0x1000) >> 12;
  50     pUserSt->vs_efid = (pSmiSt[2] & 0xE000) >> 13;
  51 }
  52
  53 static void _rtl8367c_svlanMc2sStUser2Smi(rtl8367c_svlan_mc2s_t *pUserSt, rtk_uint16 *pSmiSt)
  54 {
  55     pSmiSt[0] |= (pUserSt->svidx & 0x003F);
  56     pSmiSt[0] |= (pUserSt->format & 0x0001) << 6;
  57     pSmiSt[0] |= (pUserSt->valid & 0x0001) << 7;
  58
  59     pSmiSt[1] = (rtk_uint16)(pUserSt->smask & 0x0000FFFF);
  60     pSmiSt[2] = (rtk_uint16)((pUserSt->smask & 0xFFFF0000) >> 16);
  61
  62     pSmiSt[3] = (rtk_uint16)(pUserSt->sdata & 0x0000FFFF);
  63     pSmiSt[4] = (rtk_uint16)((pUserSt->sdata & 0xFFFF0000) >> 16);
  64 }
  65
  66 static void _rtl8367c_svlanMc2sStSmi2User(rtl8367c_svlan_mc2s_t *pUserSt, rtk_uint16 *pSmiSt)
  67 {
  68     pUserSt->svidx = (pSmiSt[0] & 0x003F);
  69     pUserSt->format = (pSmiSt[0] & 0x0040) >> 6;
  70     pUserSt->valid = (pSmiSt[0] & 0x0080) >> 7;
  71
  72     pUserSt->smask = pSmiSt[1] | (pSmiSt[2] << 16);
  73     pUserSt->sdata = pSmiSt[3] | (pSmiSt[4] << 16);
  74 }
  75
  76 static void _rtl8367c_svlanSp2cStUser2Smi(rtl8367c_svlan_s2c_t *pUserSt, rtk_uint16 *pSmiSt)
  77 {
  78     pSmiSt[0] |= (pUserSt->dstport & 0x0007);
  79     pSmiSt[0] |= (pUserSt->svidx & 0x003F) << 3;
  80     pSmiSt[0] |= ((pUserSt->dstport & 0x0008) >> 3) << 9;
  81
  82     pSmiSt[1] |= (pUserSt->vid & 0x0FFF);
  83     pSmiSt[1] |= (pUserSt->valid & 0x0001) << 12;
  84 }
  85
  86 static void _rtl8367c_svlanSp2cStSmi2User(rtl8367c_svlan_s2c_t *pUserSt, rtk_uint16 *pSmiSt)
  87 {
  88     pUserSt->dstport = (((pSmiSt[0] & 0x0200) >> 9) << 3) | (pSmiSt[0] & 0x0007);
  89     pUserSt->svidx   = (pSmiSt[0] & 0x01F8) >> 3;
  90     pUserSt->vid     = (pSmiSt[1] & 0x0FFF);
  91     pUserSt->valid   = (pSmiSt[1] & 0x1000) >> 12;
  92 }
  93
  94 /* Function Name:
  95  *      rtl8367c_setAsicSvlanUplinkPortMask
  96  * Description:
  97  *      Set uplink ports mask
  98  * Input:
  99  *      portMask    - Uplink port mask setting
 100  * Output:
 101  *      None
 102  * Return:
 103  *      RT_ERR_OK   - Success
 104  *      RT_ERR_SMI  - SMI access error
 105  * Note:
 106  *      None
 107  */
 108 ret_t rtl8367c_setAsicSvlanUplinkPortMask(rtk_uint32 portMask)
 109 {
 110     return rtl8367c_setAsicReg(RTL8367C_REG_SVLAN_UPLINK_PORTMASK, portMask);
 111 }
 112 /* Function Name:
 113  *      rtl8367c_getAsicSvlanUplinkPortMask
 114  * Description:
 115  *      Get uplink ports mask
 116  * Input:
 117  *      pPortmask   - Uplink port mask setting
 118  * Output:
 119  *      None
 120  * Return:
 121  *      RT_ERR_OK   - Success
 122  *      RT_ERR_SMI  - SMI access error
 123  * Note:
 124  *      None
 125  */
 126 ret_t rtl8367c_getAsicSvlanUplinkPortMask(rtk_uint32* pPortmask)
 127 {
 128     return rtl8367c_getAsicReg(RTL8367C_REG_SVLAN_UPLINK_PORTMASK, pPortmask);
 129 }
 130 /* Function Name:
 131  *      rtl8367c_setAsicSvlanTpid
 132  * Description:
 133  *      Set accepted S-VLAN ether type. The default ether type of S-VLAN is 0x88a8
 134  * Input:
 135  *      protocolType    - Ether type of S-tag frame parsing in uplink ports
 136  * Output:
 137  *      None
 138  * Return:
 139  *      RT_ERR_OK   - Success
 140  *      RT_ERR_SMI  - SMI access error
 141  * Note:
 142  *      Ether type of S-tag in 802.1ad is 0x88a8 and there are existed ether type 0x9100 and 0x9200
 143  *      for Q-in-Q SLAN design. User can set mathced ether type as service provider supported protocol
 144  */
 145 ret_t rtl8367c_setAsicSvlanTpid(rtk_uint32 protocolType)
 146 {
 147     return rtl8367c_setAsicReg(RTL8367C_REG_VS_TPID, protocolType);
 148 }
 149 /* Function Name:
 150  *      rtl8367c_getAsicReg
 151  * Description:
 152  *      Get accepted S-VLAN ether type. The default ether type of S-VLAN is 0x88a8
 153  * Input:
 154  *      pProtocolType   - Ether type of S-tag frame parsing in uplink ports
 155  * Output:
 156  *      None
 157  * Return:
 158  *      RT_ERR_OK   - Success
 159  *      RT_ERR_SMI  - SMI access error
 160  * Note:
 161  *      None
 162  */
 163 ret_t rtl8367c_getAsicSvlanTpid(rtk_uint32* pProtocolType)
 164 {
 165     return rtl8367c_getAsicReg(RTL8367C_REG_VS_TPID, pProtocolType);
 166 }
 167 /* Function Name:
 168  *      rtl8367c_setAsicSvlanPrioritySel
 169  * Description:
 170  *      Set SVLAN priority field setting
 171  * Input:
 172  *      priSel  - S-priority assignment method, 0:internal priority 1:C-tag priority 2:using Svlan member configuration
 173  * Output:
 174  *      None
 175  * Return:
 176  *      RT_ERR_OK       - Success
 177  *      RT_ERR_SMI      - SMI access error
 178  *      RT_ERR_INPUT    - Invalid input parameter
 179  * Note:
 180  *      None
 181  */
 182 ret_t rtl8367c_setAsicSvlanPrioritySel(rtk_uint32 priSel)
 183 {
 184     if(priSel >= SPRISEL_END)
 185         return RT_ERR_QOS_INT_PRIORITY;
 186
 187     return rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_SPRISEL_MASK, priSel);
 188 }
 189 /* Function Name:
 190  *      rtl8367c_getAsicSvlanPrioritySel
 191  * Description:
 192  *      Get SVLAN priority field setting
 193  * Input:
 194  *      pPriSel     - S-priority assignment method, 0:internal priority 1:C-tag priority 2:using Svlan member configuration
 195  * Output:
 196  *      None
 197  * Return:
 198  *      RT_ERR_OK   - Success
 199  *      RT_ERR_SMI  - SMI access error
 200  * Note:
 201  *      None
 202  */
 203 ret_t rtl8367c_getAsicSvlanPrioritySel(rtk_uint32* pPriSel)
 204 {
 205     return rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_SPRISEL_MASK, pPriSel);
 206 }
 207 /* Function Name:
 208  *      rtl8367c_setAsicSvlanTrapPriority
 209  * Description:
 210  *      Set trap to CPU priority assignment
 211  * Input:
 212  *      priority    - Priority assignment
 213  * Output:
 214  *      None
 215  * Return:
 216  *      RT_ERR_OK               - Success
 217  *      RT_ERR_SMI              - SMI access error
 218  *      RT_ERR_QOS_INT_PRIORITY - Invalid priority
 219  * Note:
 220  *      None
 221  */
 222 ret_t rtl8367c_setAsicSvlanTrapPriority(rtk_uint32 priority)
 223 {
 224     if(priority > RTL8367C_PRIMAX)
 225         return RT_ERR_QOS_INT_PRIORITY;
 226
 227     return rtl8367c_setAsicRegBits(RTL8367C_REG_QOS_TRAP_PRIORITY0, RTL8367C_SVLAN_PRIOIRTY_MASK, priority);
 228 }
 229 /* Function Name:
 230  *      rtl8367c_getAsicSvlanTrapPriority
 231  * Description:
 232  *      Get trap to CPU priority assignment
 233  * Input:
 234  *      pPriority   - Priority assignment
 235  * Output:
 236  *      None
 237  * Return:
 238  *      RT_ERR_OK   - Success
 239  *      RT_ERR_SMI  - SMI access error
 240  * Note:
 241  *      None
 242  */
 243 ret_t rtl8367c_getAsicSvlanTrapPriority(rtk_uint32* pPriority)
 244 {
 245     return rtl8367c_getAsicRegBits(RTL8367C_REG_QOS_TRAP_PRIORITY0, RTL8367C_SVLAN_PRIOIRTY_MASK, pPriority);
 246 }
 247 /* Function Name:
 248  *      rtl8367c_setAsicSvlanDefaultVlan
 249  * Description:
 250  *      Set default egress SVLAN
 251  * Input:
 252  *      port    - Physical port number (0~10)
 253  *      index   - index SVLAN member configuration
 254  * Output:
 255  *      None
 256  * Return:
 257  *      RT_ERR_OK                   - Success
 258  *      RT_ERR_SMI                  - SMI access error
 259  *      RT_ERR_PORT_ID              - Invalid port number
 260  *      RT_ERR_SVLAN_ENTRY_INDEX    - Invalid SVLAN index parameter
 261  * Note:
 262  *      None
 263  */
 264 ret_t rtl8367c_setAsicSvlanDefaultVlan(rtk_uint32 port, rtk_uint32 index)
 265 {
 266     ret_t retVal;
 267
 268     if(port > RTL8367C_PORTIDMAX)
 269         return RT_ERR_PORT_ID;
 270
 271     if(index > RTL8367C_SVIDXMAX)
 272         return RT_ERR_SVLAN_ENTRY_INDEX;
 273
 274     if(port < 8){
 275         if(port & 1)
 276             retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL0 + (port >> 1), RTL8367C_VS_PORT1_SVIDX_MASK,index);
 277         else
 278             retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL0 + (port >> 1), RTL8367C_VS_PORT0_SVIDX_MASK,index);
 279     }else{
 280         switch(port){
 281             case 8:
 282                 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL4, RTL8367C_VS_PORT8_SVIDX_MASK,index);
 283                 break;
 284
 285             case 9:
 286                 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL4, RTL8367C_VS_PORT9_SVIDX_MASK,index);
 287                 break;
 288
 289             case 10:
 290                 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL5, RTL8367C_SVLAN_PORTBASED_SVIDX_CTRL5_MASK,index);
 291                 break;
 292         }
 293     }
 294
 295     return retVal;
 296 }
 297 /* Function Name:
 298  *      rtl8367c_getAsicSvlanDefaultVlan
 299  * Description:
 300  *      Get default egress SVLAN
 301  * Input:
 302  *      port    - Physical port number (0~7)
 303  *      pIndex  - index SVLAN member configuration
 304  * Output:
 305  *      None
 306  * Return:
 307  *      RT_ERR_OK       - Success
 308  *      RT_ERR_SMI      - SMI access error
 309  *      RT_ERR_PORT_ID  - Invalid port number
 310  * Note:
 311  *      None
 312  */
 313 ret_t rtl8367c_getAsicSvlanDefaultVlan(rtk_uint32 port, rtk_uint32* pIndex)
 314 {
 315     ret_t retVal;
 316
 317     if(port > RTL8367C_PORTIDMAX)
 318         return RT_ERR_PORT_ID;
 319
 320     if(port < 8){
 321         if(port & 1)
 322             retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL0 + (port >> 1), RTL8367C_VS_PORT1_SVIDX_MASK,pIndex);
 323         else
 324             retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL0 + (port >> 1), RTL8367C_VS_PORT0_SVIDX_MASK,pIndex);
 325     }else{
 326         switch(port){
 327             case 8:
 328                 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL4, RTL8367C_VS_PORT8_SVIDX_MASK,pIndex);
 329                 break;
 330
 331             case 9:
 332                 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL4, RTL8367C_VS_PORT9_SVIDX_MASK,pIndex);
 333                 break;
 334
 335             case 10:
 336                 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_PORTBASED_SVIDX_CTRL5, RTL8367C_SVLAN_PORTBASED_SVIDX_CTRL5_MASK,pIndex);
 337                 break;
 338         }
 339     }
 340
 341     return retVal;
 342
 343 }
 344 /* Function Name:
 345  *      rtl8367c_setAsicSvlanIngressUntag
 346  * Description:
 347  *      Set action received un-Stag frame from unplink port
 348  * Input:
 349  *      mode        - 0:Drop 1:Trap 2:Assign SVLAN
 350  * Output:
 351  *      None
 352  * Return:
 353  *      RT_ERR_OK   - Success
 354  *      RT_ERR_SMI  - SMI access error
 355  * Note:
 356  *      None
 357  */
 358 ret_t rtl8367c_setAsicSvlanIngressUntag(rtk_uint32 mode)
 359 {
 360     return rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_UNTAG_MASK, mode);
 361 }
 362 /* Function Name:
 363  *      rtl8367c_getAsicSvlanIngressUntag
 364  * Description:
 365  *      Get action received un-Stag frame from unplink port
 366  * Input:
 367  *      pMode       - 0:Drop 1:Trap 2:Assign SVLAN
 368  * Output:
 369  *      None
 370  * Return:
 371  *      RT_ERR_OK   - Success
 372  *      RT_ERR_SMI  - SMI access error
 373  * Note:
 374  *      None
 375  */
 376 ret_t rtl8367c_getAsicSvlanIngressUntag(rtk_uint32* pMode)
 377 {
 378     return rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_UNTAG_MASK, pMode);
 379 }
 380 /* Function Name:
 381  *      rtl8367c_setAsicSvlanIngressUnmatch
 382  * Description:
 383  *      Set action received unmatched Stag frame from unplink port
 384  * Input:
 385  *      mode        - 0:Drop 1:Trap 2:Assign SVLAN
 386  * Output:
 387  *      None
 388  * Return:
 389  *      RT_ERR_OK   - Success
 390  *      RT_ERR_SMI  - SMI access error
 391  * Note:
 392  *      None
 393  */
 394 ret_t rtl8367c_setAsicSvlanIngressUnmatch(rtk_uint32 mode)
 395 {
 396     return rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_UNMAT_MASK, mode);
 397 }
 398 /* Function Name:
 399  *      rtl8367c_getAsicSvlanIngressUnmatch
 400  * Description:
 401  *      Get action received unmatched Stag frame from unplink port
 402  * Input:
 403  *      pMode       - 0:Drop 1:Trap 2:Assign SVLAN
 404  * Output:
 405  *      None
 406  * Return:
 407  *      RT_ERR_OK   - Success
 408  *      RT_ERR_SMI  - SMI access error
 409  * Note:
 410  *      None
 411  */
 412 ret_t rtl8367c_getAsicSvlanIngressUnmatch(rtk_uint32* pMode)
 413 {
 414     return rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_UNMAT_MASK, pMode);
 415
 416 }
 417 /* Function Name:
 418  *      rtl8367c_setAsicSvlanEgressUnassign
 419  * Description:
 420  *      Set unplink stream without egress SVID action
 421  * Input:
 422  *      enabled     - 1:Trap egress unassigned frames to CPU, 0: Use SVLAN setup in VS_CPSVIDX as egress SVID
 423  * Output:
 424  *      None
 425  * Return:
 426  *      RT_ERR_OK   - Success
 427  *      RT_ERR_SMI  - SMI access error
 428  * Note:
 429  *      None
 430  */
 431 ret_t rtl8367c_setAsicSvlanEgressUnassign(rtk_uint32 enabled)
 432 {
 433     return rtl8367c_setAsicRegBit(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_UIFSEG_OFFSET, enabled);
 434 }
 435 /* Function Name:
 436  *      rtl8367c_getAsicSvlanEgressUnassign
 437  * Description:
 438  *      Get unplink stream without egress SVID action
 439  * Input:
 440  *      pEnabled    - 1:Trap egress unassigned frames to CPU, 0: Use SVLAN setup in VS_CPSVIDX as egress SVID
 441  * Output:
 442  *      None
 443  * Return:
 444  *      RT_ERR_OK   - Success
 445  *      RT_ERR_SMI  - SMI access error
 446  * Note:
 447  *      None
 448  */
 449 ret_t rtl8367c_getAsicSvlanEgressUnassign(rtk_uint32* pEnabled)
 450 {
 451     return rtl8367c_getAsicRegBit(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_UIFSEG_OFFSET, pEnabled);
 452 }
 453
 454
 455 /* Function Name:
 456  *      rtl8367c_setAsicSvlanMemberConfiguration
 457  * Description:
 458  *      Set system 64 S-tag content
 459  * Input:
 460  *      index           - index of 64 s-tag configuration
 461  *      pSvlanMemCfg    - SVLAN member configuration
 462  * Output:
 463  *      None
 464  * Return:
 465  *      RT_ERR_OK                   - Success
 466  *      RT_ERR_SMI                  - SMI access error
 467  *      RT_ERR_SVLAN_ENTRY_INDEX    - Invalid SVLAN index parameter
 468  * Note:
 469  *      None
 470  */
 471 ret_t rtl8367c_setAsicSvlanMemberConfiguration(rtk_uint32 index, rtl8367c_svlan_memconf_t* pSvlanMemCfg)
 472 {
 473     ret_t retVal;
 474     rtk_uint32 regAddr, regData;
 475     rtk_uint16 *accessPtr;
 476     rtk_uint32 i;
 477     rtk_uint16 smiSvlanMemConf[RTL8367C_SVLAN_MEMCONF_LEN];
 478
 479     if(index > RTL8367C_SVIDXMAX)
 480         return RT_ERR_SVLAN_ENTRY_INDEX;
 481
 482     memset(smiSvlanMemConf, 0x00, sizeof(rtk_uint16) * RTL8367C_SVLAN_MEMCONF_LEN);
 483     _rtl8367c_svlanConfStUser2Smi(pSvlanMemCfg, smiSvlanMemConf);
 484
 485     accessPtr = smiSvlanMemConf;
 486
 487     regData = *accessPtr;
 488     for(i = 0; i < 3; i++)
 489     {
 490         retVal = rtl8367c_setAsicReg(RTL8367C_SVLAN_MEMBERCFG_BASE_REG(index) + i, regData);
 491         if(retVal != RT_ERR_OK)
 492             return retVal;
 493
 494         accessPtr ++;
 495         regData = *accessPtr;
 496     }
 497
 498     if(index < 63)
 499         regAddr = RTL8367C_REG_SVLAN_MEMBERCFG0_CTRL4+index;
 500     else if(index == 63)
 501         regAddr = RTL8367C_REG_SVLAN_MEMBERCFG63_CTRL4;
 502
 503     retVal = rtl8367c_setAsicReg(regAddr, regData);
 504     if(retVal != RT_ERR_OK)
 505         return retVal;
 506
 507     return RT_ERR_OK;
 508
 509 }
 510 /* Function Name:
 511  *      rtl8367c_getAsicSvlanMemberConfiguration
 512  * Description:
 513  *      Get system 64 S-tag content
 514  * Input:
 515  *      index           - index of 64 s-tag configuration
 516  *      pSvlanMemCfg    - SVLAN member configuration
 517  * Output:
 518  *      None
 519  * Return:
 520  *      RT_ERR_OK                   - Success
 521  *      RT_ERR_SMI                  - SMI access error
 522  *      RT_ERR_SVLAN_ENTRY_INDEX    - Invalid SVLAN index parameter
 523  * Note:
 524  *      None
 525  */
 526 ret_t rtl8367c_getAsicSvlanMemberConfiguration(rtk_uint32 index,rtl8367c_svlan_memconf_t* pSvlanMemCfg)
 527 {
 528     ret_t retVal;
 529     rtk_uint32 regAddr,regData;
 530     rtk_uint16 *accessPtr;
 531     rtk_uint32 i;
 532     rtk_uint16 smiSvlanMemConf[RTL8367C_SVLAN_MEMCONF_LEN];
 533
 534     if(index > RTL8367C_SVIDXMAX)
 535         return RT_ERR_SVLAN_ENTRY_INDEX;
 536
 537     memset(smiSvlanMemConf, 0x00, sizeof(rtk_uint16) * RTL8367C_SVLAN_MEMCONF_LEN);
 538
 539     accessPtr = smiSvlanMemConf;
 540
 541     for(i = 0; i < 3; i++)
 542     {
 543         retVal = rtl8367c_getAsicReg(RTL8367C_SVLAN_MEMBERCFG_BASE_REG(index) + i, &regData);
 544         if(retVal != RT_ERR_OK)
 545             return retVal;
 546
 547         *accessPtr = regData;
 548
 549         accessPtr ++;
 550     }
 551
 552     if(index < 63)
 553         regAddr = RTL8367C_REG_SVLAN_MEMBERCFG0_CTRL4+index;
 554     else if(index == 63)
 555         regAddr = RTL8367C_REG_SVLAN_MEMBERCFG63_CTRL4;
 556
 557     retVal = rtl8367c_getAsicReg(regAddr, &regData);
 558     if(retVal != RT_ERR_OK)
 559         return retVal;
 560
 561     *accessPtr = regData;
 562
 563     _rtl8367c_svlanConfStSmi2User(pSvlanMemCfg, smiSvlanMemConf);
 564
 565     return RT_ERR_OK;
 566 }
 567 /* Function Name:
 568  *      rtl8367c_setAsicSvlanC2SConf
 569  * Description:
 570  *      Set SVLAN C2S table
 571  * Input:
 572  *      index   - index of 128 Svlan C2S configuration
 573  *      evid    - Enhanced VID
 574  *      portmask    - available c2s port mask
 575  *      svidx   - index of 64 Svlan member configuration
 576  * Output:
 577  *      None
 578  * Return:
 579  *      RT_ERR_OK           - Success
 580  *      RT_ERR_SMI          - SMI access error
 581  *      RT_ERR_ENTRY_INDEX  - Invalid entry index
 582  * Note:
 583  *      ASIC will check upstream's VID and assign related SVID to mathed packet
 584  */
 585 ret_t rtl8367c_setAsicSvlanC2SConf(rtk_uint32 index, rtk_uint32 evid, rtk_uint32 portmask, rtk_uint32 svidx)
 586 {
 587     ret_t retVal;
 588
 589     if(index > RTL8367C_C2SIDXMAX)
 590         return RT_ERR_ENTRY_INDEX;
 591
 592     retVal = rtl8367c_setAsicReg(RTL8367C_SVLAN_C2SCFG_BASE_REG(index), svidx);
 593     if(retVal != RT_ERR_OK)
 594         return retVal;
 595
 596     retVal = rtl8367c_setAsicReg(RTL8367C_SVLAN_C2SCFG_BASE_REG(index) + 1, portmask);
 597     if(retVal != RT_ERR_OK)
 598         return retVal;
 599
 600     retVal = rtl8367c_setAsicReg(RTL8367C_SVLAN_C2SCFG_BASE_REG(index) + 2, evid);
 601     if(retVal != RT_ERR_OK)
 602         return retVal;
 603
 604     return RT_ERR_OK;
 605 }
 606 /* Function Name:
 607  *      rtl8367c_getAsicSvlanC2SConf
 608  * Description:
 609  *      Get SVLAN C2S table
 610  * Input:
 611  *      index   - index of 128 Svlan C2S configuration
 612  *      pEvid   - Enhanced VID
 613  *      pPortmask   - available c2s port mask
 614  *      pSvidx  - index of 64 Svlan member configuration
 615  * Output:
 616  *      None
 617  * Return:
 618  *      RT_ERR_OK           - Success
 619  *      RT_ERR_SMI          - SMI access error
 620  *      RT_ERR_ENTRY_INDEX  - Invalid entry index
 621  * Note:
 622  *      None
 623  */
 624 ret_t rtl8367c_getAsicSvlanC2SConf(rtk_uint32 index, rtk_uint32* pEvid, rtk_uint32* pPortmask, rtk_uint32* pSvidx)
 625 {
 626     ret_t retVal;
 627
 628     if(index > RTL8367C_C2SIDXMAX)
 629         return RT_ERR_ENTRY_INDEX;
 630
 631     retVal = rtl8367c_getAsicReg(RTL8367C_SVLAN_C2SCFG_BASE_REG(index), pSvidx);
 632     if(retVal != RT_ERR_OK)
 633         return retVal;
 634
 635     retVal = rtl8367c_getAsicReg(RTL8367C_SVLAN_C2SCFG_BASE_REG(index) + 1, pPortmask);
 636     if(retVal != RT_ERR_OK)
 637         return retVal;
 638
 639     retVal = rtl8367c_getAsicReg(RTL8367C_SVLAN_C2SCFG_BASE_REG(index) + 2, pEvid);
 640     if(retVal != RT_ERR_OK)
 641         return retVal;
 642
 643     return RT_ERR_OK;
 644 }
 645
 646 /* Function Name:
 647  *      rtl8367c_setAsicSvlanMC2SConf
 648  * Description:
 649  *      Set system MC2S content
 650  * Input:
 651  *      index           - index of 32 SVLAN 32 MC2S configuration
 652  *      pSvlanMc2sCfg   - SVLAN Multicast to SVLAN member configuration
 653  * Output:
 654  *      None
 655  * Return:
 656  *      RT_ERR_OK           - Success
 657  *      RT_ERR_SMI          - SMI access error
 658  *      RT_ERR_ENTRY_INDEX  - Invalid entry index
 659  * Note:
 660  *      If upstream packet is L2 multicast or IPv4 multicast packet and DMAC/DIP is matched MC2S
 661  *      configuration, ASIC will assign egress SVID to the packet
 662  */
 663 ret_t rtl8367c_setAsicSvlanMC2SConf(rtk_uint32 index,rtl8367c_svlan_mc2s_t* pSvlanMc2sCfg)
 664 {
 665     ret_t retVal;
 666     rtk_uint32 regData;
 667     rtk_uint16 *accessPtr;
 668     rtk_uint32 i;
 669     rtk_uint16 smiSvlanMC2S[RTL8367C_SVLAN_MC2S_LEN];
 670
 671     if(index > RTL8367C_MC2SIDXMAX)
 672         return RT_ERR_ENTRY_INDEX;
 673
 674     memset(smiSvlanMC2S, 0x00, sizeof(rtk_uint16) * RTL8367C_SVLAN_MC2S_LEN);
 675     _rtl8367c_svlanMc2sStUser2Smi(pSvlanMc2sCfg, smiSvlanMC2S);
 676
 677     accessPtr = smiSvlanMC2S;
 678
 679     regData = *accessPtr;
 680     for(i = 0; i < 5; i++)
 681     {
 682         retVal = rtl8367c_setAsicReg(RTL8367C_SVLAN_MCAST2S_ENTRY_BASE_REG(index) + i, regData);
 683         if(retVal != RT_ERR_OK)
 684             return retVal;
 685
 686         accessPtr ++;
 687         regData = *accessPtr;
 688     }
 689
 690     return retVal;
 691 }
 692 /* Function Name:
 693  *      rtl8367c_getAsicSvlanMC2SConf
 694  * Description:
 695  *      Get system MC2S content
 696  * Input:
 697  *      index           - index of 32 SVLAN 32 MC2S configuration
 698  *      pSvlanMc2sCfg   - SVLAN Multicast to SVLAN member configuration
 699  * Output:
 700  *      None
 701  * Return:
 702  *      RT_ERR_OK           - Success
 703  *      RT_ERR_SMI          - SMI access error
 704  *      RT_ERR_ENTRY_INDEX  - Invalid entry index
 705  * Note:
 706  *      None
 707  */
 708 ret_t rtl8367c_getAsicSvlanMC2SConf(rtk_uint32 index, rtl8367c_svlan_mc2s_t* pSvlanMc2sCfg)
 709 {
 710     ret_t retVal;
 711     rtk_uint32 regData;
 712     rtk_uint16 *accessPtr;
 713     rtk_uint32 i;
 714     rtk_uint16 smiSvlanMC2S[RTL8367C_SVLAN_MC2S_LEN];
 715
 716     if(index > RTL8367C_MC2SIDXMAX)
 717         return RT_ERR_ENTRY_INDEX;
 718
 719     memset(smiSvlanMC2S, 0x00, sizeof(rtk_uint16) * RTL8367C_SVLAN_MC2S_LEN);
 720
 721     accessPtr = smiSvlanMC2S;
 722
 723     for(i = 0; i < 5; i++)
 724     {
 725         retVal = rtl8367c_getAsicReg(RTL8367C_SVLAN_MCAST2S_ENTRY_BASE_REG(index) + i, &regData);
 726         if(retVal != RT_ERR_OK)
 727             return retVal;
 728
 729         *accessPtr = regData;
 730         accessPtr ++;
 731     }
 732
 733
 734     _rtl8367c_svlanMc2sStSmi2User(pSvlanMc2sCfg, smiSvlanMC2S);
 735
 736     return RT_ERR_OK;
 737 }
 738
 739 /* Function Name:
 740  *      rtl8367c_setAsicSvlanSP2CConf
 741  * Description:
 742  *      Set system 128 SP2C content
 743  * Input:
 744  *      index           - index of 128 SVLAN & Port to CVLAN configuration
 745  *      pSvlanSp2cCfg   - SVLAN & Port to CVLAN configuration
 746  * Output:
 747  *      None
 748  * Return:
 749  *      RT_ERR_OK           - Success
 750  *      RT_ERR_SMI          - SMI access error
 751  *      RT_ERR_ENTRY_INDEX  - Invalid entry index
 752  * Note:
 753  *      None
 754  */
 755 ret_t rtl8367c_setAsicSvlanSP2CConf(rtk_uint32 index, rtl8367c_svlan_s2c_t* pSvlanSp2cCfg)
 756 {
 757     ret_t retVal;
 758     rtk_uint32 regData;
 759     rtk_uint16 *accessPtr;
 760     rtk_uint32 i;
 761     rtk_uint16 smiSvlanSP2C[RTL8367C_SVLAN_SP2C_LEN];
 762
 763     if(index > RTL8367C_SP2CMAX)
 764         return RT_ERR_ENTRY_INDEX;
 765
 766     memset(smiSvlanSP2C, 0x00, sizeof(rtk_uint16) * RTL8367C_SVLAN_SP2C_LEN);
 767     _rtl8367c_svlanSp2cStUser2Smi(pSvlanSp2cCfg,smiSvlanSP2C);
 768
 769     accessPtr = smiSvlanSP2C;
 770
 771     regData = *accessPtr;
 772     for(i = 0; i < 2; i++)
 773     {
 774         retVal = rtl8367c_setAsicReg(RTL8367C_SVLAN_S2C_ENTRY_BASE_REG(index) + i, regData);
 775         if(retVal != RT_ERR_OK)
 776             return retVal;
 777
 778         accessPtr ++;
 779         regData = *accessPtr;
 780     }
 781
 782     return retVal;
 783 }
 784 /* Function Name:
 785  *      rtl8367c_getAsicSvlanSP2CConf
 786  * Description:
 787  *      Get system 128 SP2C content
 788  * Input:
 789  *      index           - index of 128 SVLAN & Port to CVLAN configuration
 790  *      pSvlanSp2cCfg   - SVLAN & Port to CVLAN configuration
 791  * Output:
 792  *      None
 793  * Return:
 794  *      RT_ERR_OK           - Success
 795  *      RT_ERR_SMI          - SMI access error
 796  *      RT_ERR_ENTRY_INDEX  - Invalid entry index
 797  * Note:
 798  *      None
 799  */
 800 ret_t rtl8367c_getAsicSvlanSP2CConf(rtk_uint32 index,rtl8367c_svlan_s2c_t* pSvlanSp2cCfg)
 801 {
 802     ret_t retVal;
 803     rtk_uint32 regData;
 804     rtk_uint16 *accessPtr;
 805     rtk_uint32 i;
 806     rtk_uint16 smiSvlanSP2C[RTL8367C_SVLAN_SP2C_LEN];
 807
 808     if(index > RTL8367C_SP2CMAX)
 809         return RT_ERR_ENTRY_INDEX;
 810
 811     memset(smiSvlanSP2C, 0x00, sizeof(rtk_uint16) * RTL8367C_SVLAN_SP2C_LEN);
 812
 813     accessPtr = smiSvlanSP2C;
 814
 815     for(i = 0; i < 2; i++)
 816     {
 817         retVal = rtl8367c_getAsicReg(RTL8367C_SVLAN_S2C_ENTRY_BASE_REG(index) + i, &regData);
 818         if(retVal != RT_ERR_OK)
 819             return retVal;
 820
 821         *accessPtr = regData;
 822
 823         accessPtr ++;
 824     }
 825
 826     _rtl8367c_svlanSp2cStSmi2User(pSvlanSp2cCfg, smiSvlanSP2C);
 827
 828     return RT_ERR_OK;
 829 }
 830 /* Function Name:
 831  *      rtl8367c_setAsicSvlanDmacCvidSel
 832  * Description:
 833  *      Set downstream CVID decision by DMAC
 834  * Input:
 835  *      port        - Physical port number (0~7)
 836  *      enabled     - 0:disabled, 1:enabled
 837  * Output:
 838  *      None
 839  * Return:
 840  *      RT_ERR_OK       - Success
 841  *      RT_ERR_SMI      - SMI access error
 842  *      RT_ERR_PORT_ID  - Invalid port number
 843  * Note:
 844  *      None
 845  */
 846 ret_t rtl8367c_setAsicSvlanDmacCvidSel(rtk_uint32 port, rtk_uint32 enabled)
 847 {
 848     if(port > RTL8367C_PORTIDMAX)
 849         return RT_ERR_PORT_ID;
 850
 851     if(port < 8)
 852         return rtl8367c_setAsicRegBit(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_PORT0_DMACVIDSEL_OFFSET + port, enabled);
 853     else
 854         return rtl8367c_setAsicRegBit(RTL8367C_REG_SVLAN_CFG_EXT, RTL8367C_VS_PORT8_DMACVIDSEL_OFFSET + (port-8), enabled);
 855 }
 856 /* Function Name:
 857  *      rtl8367c_getAsicSvlanDmacCvidSel
 858  * Description:
 859  *      Get downstream CVID decision by DMAC
 860  * Input:
 861  *      port        - Physical port number (0~7)
 862  *      pEnabled    - 0:disabled, 1:enabled
 863  * Output:
 864  *      None
 865  * Return:
 866  *      RT_ERR_OK       - Success
 867  *      RT_ERR_SMI      - SMI access error
 868  *      RT_ERR_PORT_ID  - Invalid port number
 869  * Note:
 870  *      None
 871  */
 872 ret_t rtl8367c_getAsicSvlanDmacCvidSel(rtk_uint32 port, rtk_uint32* pEnabled)
 873 {
 874     if(port > RTL8367C_PORTIDMAX)
 875         return RT_ERR_PORT_ID;
 876
 877     if(port < 8)
 878         return rtl8367c_getAsicRegBit(RTL8367C_REG_SVLAN_CFG, RTL8367C_VS_PORT0_DMACVIDSEL_OFFSET + port, pEnabled);
 879     else
 880         return rtl8367c_getAsicRegBit(RTL8367C_REG_SVLAN_CFG_EXT, RTL8367C_VS_PORT8_DMACVIDSEL_OFFSET + (port-8), pEnabled);
 881 }
 882 /* Function Name:
 883  *      rtl8367c_setAsicSvlanUntagVlan
 884  * Description:
 885  *      Set default ingress untag SVLAN
 886  * Input:
 887  *      index   - index SVLAN member configuration
 888  * Output:
 889  *      None
 890  * Return:
 891  *      RT_ERR_OK                   - Success
 892  *      RT_ERR_SMI                  - SMI access error
 893  *      RT_ERR_SVLAN_ENTRY_INDEX    - Invalid SVLAN index parameter
 894  * Note:
 895  *      None
 896  */
 897 ret_t rtl8367c_setAsicSvlanUntagVlan(rtk_uint32 index)
 898 {
 899     if(index > RTL8367C_SVIDXMAX)
 900         return RT_ERR_SVLAN_ENTRY_INDEX;
 901
 902     return rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_UNTAG_UNMAT_CFG, RTL8367C_VS_UNTAG_SVIDX_MASK, index);
 903 }
 904 /* Function Name:
 905  *      rtl8367c_getAsicSvlanUntagVlan
 906  * Description:
 907  *      Get default ingress untag SVLAN
 908  * Input:
 909  *      pIndex  - index SVLAN member configuration
 910  * Output:
 911  *      None
 912  * Return:
 913  *      RT_ERR_OK       - Success
 914  *      RT_ERR_SMI      - SMI access error
 915  * Note:
 916  *      None
 917  */
 918 ret_t rtl8367c_getAsicSvlanUntagVlan(rtk_uint32* pIndex)
 919 {
 920     return rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_UNTAG_UNMAT_CFG, RTL8367C_VS_UNTAG_SVIDX_MASK, pIndex);
 921 }
 922
 923 /* Function Name:
 924  *      rtl8367c_setAsicSvlanUnmatchVlan
 925  * Description:
 926  *      Set default ingress unmatch SVLAN
 927  * Input:
 928  *      index   - index SVLAN member configuration
 929  * Output:
 930  *      None
 931  * Return:
 932  *      RT_ERR_OK                   - Success
 933  *      RT_ERR_SMI                  - SMI access error
 934  *      RT_ERR_SVLAN_ENTRY_INDEX    - Invalid SVLAN index parameter
 935  * Note:
 936  *      None
 937  */
 938 ret_t rtl8367c_setAsicSvlanUnmatchVlan(rtk_uint32 index)
 939 {
 940     if(index > RTL8367C_SVIDXMAX)
 941         return RT_ERR_SVLAN_ENTRY_INDEX;
 942
 943     return rtl8367c_setAsicRegBits(RTL8367C_REG_SVLAN_UNTAG_UNMAT_CFG, RTL8367C_VS_UNMAT_SVIDX_MASK, index);
 944 }
 945 /* Function Name:
 946  *      rtl8367c_getAsicSvlanUnmatchVlan
 947  * Description:
 948  *      Get default ingress unmatch SVLAN
 949  * Input:
 950  *      pIndex  - index SVLAN member configuration
 951  * Output:
 952  *      None
 953  * Return:
 954  *      RT_ERR_OK       - Success
 955  *      RT_ERR_SMI      - SMI access error
 956  * Note:
 957  *      None
 958  */
 959 ret_t rtl8367c_getAsicSvlanUnmatchVlan(rtk_uint32* pIndex)
 960 {
 961     return rtl8367c_getAsicRegBits(RTL8367C_REG_SVLAN_UNTAG_UNMAT_CFG, RTL8367C_VS_UNMAT_SVIDX_MASK, pIndex);
 962 }
 963
 964
 965 /* Function Name:
 966  *      rtl8367c_setAsicSvlanLookupType
 967  * Description:
 968  *      Set svlan lookup table selection
 969  * Input:
 970  *      type    - lookup type
 971  * Output:
 972  *      None
 973  * Return:
 974  *      RT_ERR_OK                   - Success
 975  *      RT_ERR_SMI                  - SMI access error
 976  * Note:
 977  *      None
 978  */
 979 ret_t rtl8367c_setAsicSvlanLookupType(rtk_uint32 type)
 980 {
 981     return rtl8367c_setAsicRegBit(RTL8367C_REG_SVLAN_LOOKUP_TYPE, RTL8367C_SVLAN_LOOKUP_TYPE_OFFSET, type);
 982 }
 983
 984 /* Function Name:
 985  *      rtl8367c_getAsicSvlanLookupType
 986  * Description:
 987  *      Get svlan lookup table selection
 988  * Input:
 989  *      pType   - lookup type
 990  * Output:
 991  *      None
 992  * Return:
 993  *      RT_ERR_OK                   - Success
 994  *      RT_ERR_SMI                  - SMI access error
 995  * Note:
 996  *      None
 997  */
 998 ret_t rtl8367c_getAsicSvlanLookupType(rtk_uint32* pType)
 999 {
1000     return rtl8367c_getAsicRegBit(RTL8367C_REG_SVLAN_LOOKUP_TYPE, RTL8367C_SVLAN_LOOKUP_TYPE_OFFSET, pType);
1001 }
1002
1003