projects / openwrt / staging / mkresin.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mediatek: add patches for 5.15 and kernel config for mt7622
[openwrt/staging/mkresin.git] / target / linux / mediatek / files / drivers / net / phy / rtk / rtl8367c / rtl8367c_asicdrv_vlan.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 : VLAN related functions
15 *
16 */
17 #include <rtl8367c_asicdrv_vlan.h>
18
19 #include <string.h>
20
21 #if defined(CONFIG_RTL8367C_ASICDRV_TEST)
22 rtl8367c_user_vlan4kentry Rtl8370sVirtualVlanTable[RTL8367C_VIDMAX + 1];
23 #endif
24
25 static void _rtl8367c_VlanMCStUser2Smi(rtl8367c_vlanconfiguser *pVlanCg, rtk_uint16 *pSmiVlanCfg)
26 {
27 pSmiVlanCfg[0] |= pVlanCg->mbr & 0x07FF;
28
29 pSmiVlanCfg[1] |= pVlanCg->fid_msti & 0x000F;
30
31 pSmiVlanCfg[2] |= pVlanCg->vbpen & 0x0001;
32 pSmiVlanCfg[2] |= (pVlanCg->vbpri & 0x0007) << 1;
33 pSmiVlanCfg[2] |= (pVlanCg->envlanpol & 0x0001) << 4;
34 pSmiVlanCfg[2] |= (pVlanCg->meteridx & 0x003F) << 5;
35
36 pSmiVlanCfg[3] |= pVlanCg->evid & 0x1FFF;
37 }
38
39 static void _rtl8367c_VlanMCStSmi2User(rtk_uint16 *pSmiVlanCfg, rtl8367c_vlanconfiguser *pVlanCg)
40 {
41 pVlanCg->mbr = pSmiVlanCfg[0] & 0x07FF;
42 pVlanCg->fid_msti = pSmiVlanCfg[1] & 0x000F;
43 pVlanCg->meteridx = (pSmiVlanCfg[2] >> 5) & 0x003F;
44 pVlanCg->envlanpol = (pSmiVlanCfg[2] >> 4) & 0x0001;
45 pVlanCg->vbpri = (pSmiVlanCfg[2] >> 1) & 0x0007;
46 pVlanCg->vbpen = pSmiVlanCfg[2] & 0x0001;
47 pVlanCg->evid = pSmiVlanCfg[3] & 0x1FFF;
48 }
49
50 static void _rtl8367c_Vlan4kStUser2Smi(rtl8367c_user_vlan4kentry *pUserVlan4kEntry, rtk_uint16 *pSmiVlan4kEntry)
51 {
52 pSmiVlan4kEntry[0] |= (pUserVlan4kEntry->mbr & 0x00FF);
53 pSmiVlan4kEntry[0] |= (pUserVlan4kEntry->untag & 0x00FF) << 8;
54
55 pSmiVlan4kEntry[1] |= (pUserVlan4kEntry->fid_msti & 0x000F);
56 pSmiVlan4kEntry[1] |= (pUserVlan4kEntry->vbpen & 0x0001) << 4;
57 pSmiVlan4kEntry[1] |= (pUserVlan4kEntry->vbpri & 0x0007) << 5;
58 pSmiVlan4kEntry[1] |= (pUserVlan4kEntry->envlanpol & 0x0001) << 8;
59 pSmiVlan4kEntry[1] |= (pUserVlan4kEntry->meteridx & 0x001F) << 9;
60 pSmiVlan4kEntry[1] |= (pUserVlan4kEntry->ivl_svl & 0x0001) << 14;
61
62 pSmiVlan4kEntry[2] |= ((pUserVlan4kEntry->mbr & 0x0700) >> 8);
63 pSmiVlan4kEntry[2] |= ((pUserVlan4kEntry->untag & 0x0700) >> 8) << 3;
64 pSmiVlan4kEntry[2] |= ((pUserVlan4kEntry->meteridx & 0x0020) >> 5) << 6;
65 }
66
67
68 static void _rtl8367c_Vlan4kStSmi2User(rtk_uint16 *pSmiVlan4kEntry, rtl8367c_user_vlan4kentry *pUserVlan4kEntry)
69 {
70 pUserVlan4kEntry->mbr = (pSmiVlan4kEntry[0] & 0x00FF) | ((pSmiVlan4kEntry[2] & 0x0007) << 8);
71 pUserVlan4kEntry->untag = ((pSmiVlan4kEntry[0] & 0xFF00) >> 8) | (((pSmiVlan4kEntry[2] & 0x0038) >> 3) << 8);
72 pUserVlan4kEntry->fid_msti = pSmiVlan4kEntry[1] & 0x000F;
73 pUserVlan4kEntry->vbpen = (pSmiVlan4kEntry[1] & 0x0010) >> 4;
74 pUserVlan4kEntry->vbpri = (pSmiVlan4kEntry[1] & 0x00E0) >> 5;
75 pUserVlan4kEntry->envlanpol = (pSmiVlan4kEntry[1] & 0x0100) >> 8;
76 pUserVlan4kEntry->meteridx = ((pSmiVlan4kEntry[1] & 0x3E00) >> 9) | (((pSmiVlan4kEntry[2] & 0x0040) >> 6) << 5);
77 pUserVlan4kEntry->ivl_svl = (pSmiVlan4kEntry[1] & 0x4000) >> 14;
78 }
79
80 /* Function Name:
81 * rtl8367c_setAsicVlanMemberConfig
82 * Description:
83 * Set 32 VLAN member configurations
84 * Input:
85 * index - VLAN member configuration index (0~31)
86 * pVlanCg - VLAN member configuration
87 * Output:
88 * None
89 * Return:
90 * RT_ERR_OK - Success
91 * RT_ERR_SMI - SMI access error
92 * RT_ERR_INPUT - Invalid input parameter
93 * RT_ERR_L2_FID - Invalid FID
94 * RT_ERR_PORT_MASK - Invalid portmask
95 * RT_ERR_FILTER_METER_ID - Invalid meter
96 * RT_ERR_QOS_INT_PRIORITY - Invalid priority
97 * RT_ERR_VLAN_ENTRY_NOT_FOUND - Invalid VLAN member configuration index
98 * Note:
99 * None
100 */
101 ret_t rtl8367c_setAsicVlanMemberConfig(rtk_uint32 index, rtl8367c_vlanconfiguser *pVlanCg)
102 {
103 ret_t retVal;
104 rtk_uint32 regAddr;
105 rtk_uint32 regData;
106 rtk_uint16 *tableAddr;
107 rtk_uint32 page_idx;
108 rtk_uint16 smi_vlancfg[RTL8367C_VLAN_MBRCFG_LEN];
109
110 /* Error Checking */
111 if(index > RTL8367C_CVIDXMAX)
112 return RT_ERR_VLAN_ENTRY_NOT_FOUND;
113
114 if(pVlanCg->evid > RTL8367C_EVIDMAX)
115 return RT_ERR_INPUT;
116
117
118 if(pVlanCg->mbr > RTL8367C_PORTMASK)
119 return RT_ERR_PORT_MASK;
120
121 if(pVlanCg->fid_msti > RTL8367C_FIDMAX)
122 return RT_ERR_L2_FID;
123
124 if(pVlanCg->meteridx > RTL8367C_METERMAX)
125 return RT_ERR_FILTER_METER_ID;
126
127 if(pVlanCg->vbpri > RTL8367C_PRIMAX)
128 return RT_ERR_QOS_INT_PRIORITY;
129
130 memset(smi_vlancfg, 0x00, sizeof(rtk_uint16) * RTL8367C_VLAN_MBRCFG_LEN);
131 _rtl8367c_VlanMCStUser2Smi(pVlanCg, smi_vlancfg);
132 tableAddr = smi_vlancfg;
133
134 for(page_idx = 0; page_idx < 4; page_idx++) /* 4 pages per VLAN Member Config */
135 {
136 regAddr = RTL8367C_VLAN_MEMBER_CONFIGURATION_BASE + (index * 4) + page_idx;
137 regData = *tableAddr;
138
139 retVal = rtl8367c_setAsicReg(regAddr, regData);
140 if(retVal != RT_ERR_OK)
141 return retVal;
142
143 tableAddr++;
144 }
145
146 return RT_ERR_OK;
147 }
148 /* Function Name:
149 * rtl8367c_getAsicVlanMemberConfig
150 * Description:
151 * Get 32 VLAN member configurations
152 * Input:
153 * index - VLAN member configuration index (0~31)
154 * pVlanCg - VLAN member configuration
155 * Output:
156 * None
157 * Return:
158 * RT_ERR_OK - Success
159 * RT_ERR_SMI - SMI access error
160 * RT_ERR_INPUT - Invalid input parameter
161 * RT_ERR_VLAN_ENTRY_NOT_FOUND - Invalid VLAN member configuration index
162 * Note:
163 * None
164 */
165 ret_t rtl8367c_getAsicVlanMemberConfig(rtk_uint32 index, rtl8367c_vlanconfiguser *pVlanCg)
166 {
167 ret_t retVal;
168 rtk_uint32 page_idx;
169 rtk_uint32 regAddr;
170 rtk_uint32 regData;
171 rtk_uint16 *tableAddr;
172 rtk_uint16 smi_vlancfg[RTL8367C_VLAN_MBRCFG_LEN];
173
174 if(index > RTL8367C_CVIDXMAX)
175 return RT_ERR_VLAN_ENTRY_NOT_FOUND;
176
177 memset(smi_vlancfg, 0x00, sizeof(rtk_uint16) * RTL8367C_VLAN_MBRCFG_LEN);
178 tableAddr = smi_vlancfg;
179
180 for(page_idx = 0; page_idx < 4; page_idx++) /* 4 pages per VLAN Member Config */
181 {
182 regAddr = RTL8367C_VLAN_MEMBER_CONFIGURATION_BASE + (index * 4) + page_idx;
183
184 retVal = rtl8367c_getAsicReg(regAddr, &regData);
185 if(retVal != RT_ERR_OK)
186 return retVal;
187
188 *tableAddr = (rtk_uint16)regData;
189 tableAddr++;
190 }
191
192 _rtl8367c_VlanMCStSmi2User(smi_vlancfg, pVlanCg);
193 return RT_ERR_OK;
194 }
195 /* Function Name:
196 * rtl8367c_setAsicVlan4kEntry
197 * Description:
198 * Set VID mapped entry to 4K VLAN table
199 * Input:
200 * pVlan4kEntry - 4K VLAN configuration
201 * Output:
202 * None
203 * Return:
204 * RT_ERR_OK - Success
205 * RT_ERR_SMI - SMI access error
206 * RT_ERR_INPUT - Invalid input parameter
207 * RT_ERR_L2_FID - Invalid FID
208 * RT_ERR_VLAN_VID - Invalid VID parameter (0~4095)
209 * RT_ERR_PORT_MASK - Invalid portmask
210 * RT_ERR_FILTER_METER_ID - Invalid meter
211 * RT_ERR_QOS_INT_PRIORITY - Invalid priority
212 * Note:
213 * None
214 */
215 ret_t rtl8367c_setAsicVlan4kEntry(rtl8367c_user_vlan4kentry *pVlan4kEntry )
216 {
217 rtk_uint16 vlan_4k_entry[RTL8367C_VLAN_4KTABLE_LEN];
218 rtk_uint32 page_idx;
219 rtk_uint16 *tableAddr;
220 ret_t retVal;
221 rtk_uint32 regData;
222
223 if(pVlan4kEntry->vid > RTL8367C_VIDMAX)
224 return RT_ERR_VLAN_VID;
225
226 if(pVlan4kEntry->mbr > RTL8367C_PORTMASK)
227 return RT_ERR_PORT_MASK;
228
229 if(pVlan4kEntry->untag > RTL8367C_PORTMASK)
230 return RT_ERR_PORT_MASK;
231
232 if(pVlan4kEntry->fid_msti > RTL8367C_FIDMAX)
233 return RT_ERR_L2_FID;
234
235 if(pVlan4kEntry->meteridx > RTL8367C_METERMAX)
236 return RT_ERR_FILTER_METER_ID;
237
238 if(pVlan4kEntry->vbpri > RTL8367C_PRIMAX)
239 return RT_ERR_QOS_INT_PRIORITY;
240
241 memset(vlan_4k_entry, 0x00, sizeof(rtk_uint16) * RTL8367C_VLAN_4KTABLE_LEN);
242 _rtl8367c_Vlan4kStUser2Smi(pVlan4kEntry, vlan_4k_entry);
243
244 /* Prepare Data */
245 tableAddr = vlan_4k_entry;
246 for(page_idx = 0; page_idx < RTL8367C_VLAN_4KTABLE_LEN; page_idx++)
247 {
248 regData = *tableAddr;
249 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_WRDATA_BASE + page_idx, regData);
250 if(retVal != RT_ERR_OK)
251 return retVal;
252
253 tableAddr++;
254 }
255
256 /* Write Address (VLAN_ID) */
257 regData = pVlan4kEntry->vid;
258 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_ADDR_REG, regData);
259 if(retVal != RT_ERR_OK)
260 return retVal;
261
262 /* Write Command */
263 retVal = rtl8367c_setAsicRegBits(RTL8367C_TABLE_ACCESS_CTRL_REG, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK,RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE,TB_TARGET_CVLAN));
264 if(retVal != RT_ERR_OK)
265 return retVal;
266
267 #if defined(CONFIG_RTL8367C_ASICDRV_TEST)
268 memcpy(&Rtl8370sVirtualVlanTable[pVlan4kEntry->vid], pVlan4kEntry, sizeof(rtl8367c_user_vlan4kentry));
269 #endif
270
271 return RT_ERR_OK;
272 }
273 /* Function Name:
274 * rtl8367c_getAsicVlan4kEntry
275 * Description:
276 * Get VID mapped entry to 4K VLAN table
277 * Input:
278 * pVlan4kEntry - 4K VLAN configuration
279 * Output:
280 * None
281 * Return:
282 * RT_ERR_OK - Success
283 * RT_ERR_SMI - SMI access error
284 * RT_ERR_VLAN_VID - Invalid VID parameter (0~4095)
285 * RT_ERR_BUSYWAIT_TIMEOUT - LUT is busy at retrieving
286 * Note:
287 * None
288 */
289 ret_t rtl8367c_getAsicVlan4kEntry(rtl8367c_user_vlan4kentry *pVlan4kEntry )
290 {
291 rtk_uint16 vlan_4k_entry[RTL8367C_VLAN_4KTABLE_LEN];
292 rtk_uint32 page_idx;
293 rtk_uint16 *tableAddr;
294 ret_t retVal;
295 rtk_uint32 regData;
296 rtk_uint32 busyCounter;
297
298 if(pVlan4kEntry->vid > RTL8367C_VIDMAX)
299 return RT_ERR_VLAN_VID;
300
301 /* Polling status */
302 busyCounter = RTL8367C_VLAN_BUSY_CHECK_NO;
303 while(busyCounter)
304 {
305 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,&regData);
306 if(retVal != RT_ERR_OK)
307 return retVal;
308
309 if(regData == 0)
310 break;
311
312 busyCounter --;
313 if(busyCounter == 0)
314 return RT_ERR_BUSYWAIT_TIMEOUT;
315 }
316
317 /* Write Address (VLAN_ID) */
318 regData = pVlan4kEntry->vid;
319 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_ADDR_REG, regData);
320 if(retVal != RT_ERR_OK)
321 return retVal;
322
323 /* Read Command */
324 retVal = rtl8367c_setAsicRegBits(RTL8367C_TABLE_ACCESS_CTRL_REG, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ,TB_TARGET_CVLAN));
325 if(retVal != RT_ERR_OK)
326 return retVal;
327
328 /* Polling status */
329 busyCounter = RTL8367C_VLAN_BUSY_CHECK_NO;
330 while(busyCounter)
331 {
332 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,&regData);
333 if(retVal != RT_ERR_OK)
334 return retVal;
335
336 if(regData == 0)
337 break;
338
339 busyCounter --;
340 if(busyCounter == 0)
341 return RT_ERR_BUSYWAIT_TIMEOUT;
342 }
343
344 /* Read VLAN data from register */
345 tableAddr = vlan_4k_entry;
346 for(page_idx = 0; page_idx < RTL8367C_VLAN_4KTABLE_LEN; page_idx++)
347 {
348 retVal = rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_RDDATA_BASE + page_idx, &regData);
349 if(retVal != RT_ERR_OK)
350 return retVal;
351
352 *tableAddr = regData;
353 tableAddr++;
354 }
355
356 _rtl8367c_Vlan4kStSmi2User(vlan_4k_entry, pVlan4kEntry);
357
358 #if defined(CONFIG_RTL8367C_ASICDRV_TEST)
359 memcpy(pVlan4kEntry, &Rtl8370sVirtualVlanTable[pVlan4kEntry->vid], sizeof(rtl8367c_user_vlan4kentry));
360 #endif
361
362 return RT_ERR_OK;
363 }
364 /* Function Name:
365 * rtl8367c_setAsicVlanAccpetFrameType
366 * Description:
367 * Set per-port acceptable frame type
368 * Input:
369 * port - Physical port number (0~10)
370 * frameType - The acceptable frame type
371 * Output:
372 * None
373 * Return:
374 * RT_ERR_OK - Success
375 * RT_ERR_SMI - SMI access error
376 * RT_ERR_PORT_ID - Invalid port number
377 * RT_ERR_VLAN_ACCEPT_FRAME_TYPE - Invalid frame type
378 * Note:
379 * None
380 */
381 ret_t rtl8367c_setAsicVlanAccpetFrameType(rtk_uint32 port, rtl8367c_accframetype frameType)
382 {
383 if(port > RTL8367C_PORTIDMAX)
384 return RT_ERR_PORT_ID;
385
386 if(frameType >= FRAME_TYPE_MAX_BOUND)
387 return RT_ERR_VLAN_ACCEPT_FRAME_TYPE;
388
389 return rtl8367c_setAsicRegBits(RTL8367C_VLAN_ACCEPT_FRAME_TYPE_REG(port), RTL8367C_VLAN_ACCEPT_FRAME_TYPE_MASK(port), frameType);
390 }
391 /* Function Name:
392 * rtl8367c_getAsicVlanAccpetFrameType
393 * Description:
394 * Get per-port acceptable frame type
395 * Input:
396 * port - Physical port number (0~10)
397 * pFrameType - The acceptable frame type
398 * Output:
399 * None
400 * Return:
401 * RT_ERR_OK - Success
402 * RT_ERR_SMI - SMI access error
403 * RT_ERR_PORT_ID - Invalid port number
404 * RT_ERR_VLAN_ACCEPT_FRAME_TYPE - Invalid frame type
405 * Note:
406 * None
407 */
408 ret_t rtl8367c_getAsicVlanAccpetFrameType(rtk_uint32 port, rtl8367c_accframetype *pFrameType)
409 {
410 rtk_uint32 regData;
411 ret_t retVal;
412
413 if(port > RTL8367C_PORTIDMAX)
414 return RT_ERR_PORT_ID;
415
416 if((retVal = rtl8367c_getAsicRegBits(RTL8367C_VLAN_ACCEPT_FRAME_TYPE_REG(port), RTL8367C_VLAN_ACCEPT_FRAME_TYPE_MASK(port), &regData)) != RT_ERR_OK)
417 return retVal;
418
419 *pFrameType = (rtl8367c_accframetype)regData;
420 return RT_ERR_OK;
421 }
422 /* Function Name:
423 * rtl8367c_setAsicVlanIngressFilter
424 * Description:
425 * Set VLAN Ingress Filter
426 * Input:
427 * port - Physical port number (0~10)
428 * enabled - Enable or disable Ingress filter
429 * Output:
430 * None
431 * Return:
432 * RT_ERR_OK - Success
433 * RT_ERR_SMI - SMI access error
434 * RT_ERR_PORT_ID - Invalid port number
435 * Note:
436 * None
437 */
438 ret_t rtl8367c_setAsicVlanIngressFilter(rtk_uint32 port, rtk_uint32 enabled)
439 {
440 if(port > RTL8367C_PORTIDMAX)
441 return RT_ERR_PORT_ID;
442
443 return rtl8367c_setAsicRegBit(RTL8367C_VLAN_INGRESS_REG, port, enabled);
444 }
445 /* Function Name:
446 * rtl8367c_getAsicVlanIngressFilter
447 * Description:
448 * Get VLAN Ingress Filter
449 * Input:
450 * port - Physical port number (0~10)
451 * pEnable - Enable or disable Ingress filter
452 * Output:
453 * None
454 * Return:
455 * RT_ERR_OK - Success
456 * RT_ERR_SMI - SMI access error
457 * RT_ERR_PORT_ID - Invalid port number
458 * Note:
459 * None
460 */
461 ret_t rtl8367c_getAsicVlanIngressFilter(rtk_uint32 port, rtk_uint32 *pEnable)
462 {
463 if(port > RTL8367C_PORTIDMAX)
464 return RT_ERR_PORT_ID;
465
466 return rtl8367c_getAsicRegBit(RTL8367C_VLAN_INGRESS_REG, port, pEnable);
467 }
468 /* Function Name:
469 * rtl8367c_setAsicVlanEgressTagMode
470 * Description:
471 * Set CVLAN egress tag mode
472 * Input:
473 * port - Physical port number (0~10)
474 * tagMode - The egress tag mode. Including Original mode, Keep tag mode and Priority tag mode
475 * Output:
476 * None
477 * Return:
478 * RT_ERR_OK - Success
479 * RT_ERR_SMI - SMI access error
480 * RT_ERR_INPUT - Invalid input parameter
481 * RT_ERR_PORT_ID - Invalid port number
482 * Note:
483 * None
484 */
485 ret_t rtl8367c_setAsicVlanEgressTagMode(rtk_uint32 port, rtl8367c_egtagmode tagMode)
486 {
487 if(port > RTL8367C_PORTIDMAX)
488 return RT_ERR_PORT_ID;
489
490 if(tagMode >= EG_TAG_MODE_END)
491 return RT_ERR_INPUT;
492
493 return rtl8367c_setAsicRegBits(RTL8367C_PORT_MISC_CFG_REG(port), RTL8367C_VLAN_EGRESS_MDOE_MASK, tagMode);
494 }
495 /* Function Name:
496 * rtl8367c_getAsicVlanEgressTagMode
497 * Description:
498 * Get CVLAN egress tag mode
499 * Input:
500 * port - Physical port number (0~10)
501 * pTagMode - The egress tag mode. Including Original mode, Keep tag mode and Priority tag mode
502 * Output:
503 * None
504 * Return:
505 * RT_ERR_OK - Success
506 * RT_ERR_SMI - SMI access error
507 * RT_ERR_PORT_ID - Invalid port number
508 * Note:
509 * None
510 */
511 ret_t rtl8367c_getAsicVlanEgressTagMode(rtk_uint32 port, rtl8367c_egtagmode *pTagMode)
512 {
513 rtk_uint32 regData;
514 ret_t retVal;
515
516 if(port > RTL8367C_PORTIDMAX)
517 return RT_ERR_PORT_ID;
518
519 if((retVal = rtl8367c_getAsicRegBits(RTL8367C_PORT_MISC_CFG_REG(port), RTL8367C_VLAN_EGRESS_MDOE_MASK, &regData)) != RT_ERR_OK)
520 return retVal;
521
522 *pTagMode = (rtl8367c_egtagmode)regData;
523 return RT_ERR_OK;
524 }
525 /* Function Name:
526 * rtl8367c_setAsicVlanPortBasedVID
527 * Description:
528 * Set port based VID which is indexed to 32 VLAN member configurations
529 * Input:
530 * port - Physical port number (0~10)
531 * index - Index to VLAN member configuration
532 * pri - 1Q Port based VLAN priority
533 * Output:
534 * None
535 * Return:
536 * RT_ERR_OK - Success
537 * RT_ERR_SMI - SMI access error
538 * RT_ERR_PORT_ID - Invalid port number
539 * RT_ERR_QOS_INT_PRIORITY - Invalid priority
540 * RT_ERR_VLAN_ENTRY_NOT_FOUND - Invalid VLAN member configuration index
541 * Note:
542 * None
543 */
544 ret_t rtl8367c_setAsicVlanPortBasedVID(rtk_uint32 port, rtk_uint32 index, rtk_uint32 pri)
545 {
546 rtk_uint32 regAddr, bit_mask;
547 ret_t retVal;
548
549 if(port > RTL8367C_PORTIDMAX)
550 return RT_ERR_PORT_ID;
551
552 if(index > RTL8367C_CVIDXMAX)
553 return RT_ERR_VLAN_ENTRY_NOT_FOUND;
554
555 if(pri > RTL8367C_PRIMAX)
556 return RT_ERR_QOS_INT_PRIORITY;
557
558 regAddr = RTL8367C_VLAN_PVID_CTRL_REG(port);
559 bit_mask = RTL8367C_PORT_VIDX_MASK(port);
560 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, index);
561 if(retVal != RT_ERR_OK)
562 return retVal;
563
564 regAddr = RTL8367C_VLAN_PORTBASED_PRIORITY_REG(port);
565 bit_mask = RTL8367C_VLAN_PORTBASED_PRIORITY_MASK(port);
566 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, pri);
567 if(retVal != RT_ERR_OK)
568 return retVal;
569
570 return RT_ERR_OK;
571 }
572 /* Function Name:
573 * rtl8367c_getAsicVlanPortBasedVID
574 * Description:
575 * Get port based VID which is indexed to 32 VLAN member configurations
576 * Input:
577 * port - Physical port number (0~10)
578 * pIndex - Index to VLAN member configuration
579 * pPri - 1Q Port based VLAN priority
580 * Output:
581 * None
582 * Return:
583 * RT_ERR_OK - Success
584 * RT_ERR_SMI - SMI access error
585 * RT_ERR_PORT_ID - Invalid port number
586 * Note:
587 * None
588 */
589 ret_t rtl8367c_getAsicVlanPortBasedVID(rtk_uint32 port, rtk_uint32 *pIndex, rtk_uint32 *pPri)
590 {
591 rtk_uint32 regAddr,bit_mask;
592 ret_t retVal;
593
594 if(port > RTL8367C_PORTIDMAX)
595 return RT_ERR_PORT_ID;
596
597 regAddr = RTL8367C_VLAN_PVID_CTRL_REG(port);
598 bit_mask = RTL8367C_PORT_VIDX_MASK(port);
599 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, pIndex);
600 if(retVal != RT_ERR_OK)
601 return retVal;
602
603 regAddr = RTL8367C_VLAN_PORTBASED_PRIORITY_REG(port);
604 bit_mask = RTL8367C_VLAN_PORTBASED_PRIORITY_MASK(port);
605 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, pPri);
606 if(retVal != RT_ERR_OK)
607 return retVal;
608
609 return RT_ERR_OK;
610 }
611 /* Function Name:
612 * rtl8367c_setAsicVlanProtocolBasedGroupData
613 * Description:
614 * Set protocol and port based group database
615 * Input:
616 * index - Index to VLAN member configuration
617 * pPbCfg - Protocol and port based group database entry
618 * Output:
619 * None
620 * Return:
621 * RT_ERR_OK - Success
622 * RT_ERR_SMI - SMI access error
623 * RT_ERR_INPUT - Invalid input parameter
624 * RT_ERR_VLAN_PROTO_AND_PORT - Invalid protocol base group database index
625 * Note:
626 * None
627 */
628 ret_t rtl8367c_setAsicVlanProtocolBasedGroupData(rtk_uint32 index, rtl8367c_protocolgdatacfg *pPbCfg)
629 {
630 rtk_uint32 frameType;
631 rtk_uint32 etherType;
632 ret_t retVal;
633
634 /* Error Checking */
635 if(index > RTL8367C_PROTOVLAN_GIDX_MAX)
636 return RT_ERR_VLAN_PROTO_AND_PORT;
637
638 if(pPbCfg->frameType >= PPVLAN_FRAME_TYPE_END )
639 return RT_ERR_INPUT;
640
641 frameType = pPbCfg->frameType;
642 etherType = pPbCfg->etherType;
643
644 /* Frame type */
645 retVal = rtl8367c_setAsicRegBits(RTL8367C_VLAN_PPB_FRAMETYPE_REG(index), RTL8367C_VLAN_PPB_FRAMETYPE_MASK, frameType);
646 if(retVal != RT_ERR_OK)
647 return retVal;
648
649 /* Ether type */
650 retVal = rtl8367c_setAsicReg(RTL8367C_VLAN_PPB_ETHERTYPR_REG(index), etherType);
651 if(retVal != RT_ERR_OK)
652 return retVal;
653
654 return RT_ERR_OK;
655 }
656 /* Function Name:
657 * rtl8367c_getAsicVlanProtocolBasedGroupData
658 * Description:
659 * Get protocol and port based group database
660 * Input:
661 * index - Index to VLAN member configuration
662 * pPbCfg - Protocol and port based group database entry
663 * Output:
664 * None
665 * Return:
666 * RT_ERR_OK - Success
667 * RT_ERR_SMI - SMI access error
668 * RT_ERR_INPUT - Invalid input parameter
669 * RT_ERR_VLAN_PROTO_AND_PORT - Invalid protocol base group database index
670 * Note:
671 * None
672 */
673 ret_t rtl8367c_getAsicVlanProtocolBasedGroupData(rtk_uint32 index, rtl8367c_protocolgdatacfg *pPbCfg)
674 {
675 rtk_uint32 frameType;
676 rtk_uint32 etherType;
677 ret_t retVal;
678
679 /* Error Checking */
680 if(index > RTL8367C_PROTOVLAN_GIDX_MAX)
681 return RT_ERR_VLAN_PROTO_AND_PORT;
682
683 /* Read Frame type */
684 retVal = rtl8367c_getAsicRegBits(RTL8367C_VLAN_PPB_FRAMETYPE_REG(index), RTL8367C_VLAN_PPB_FRAMETYPE_MASK, &frameType);
685 if(retVal != RT_ERR_OK)
686 return retVal;
687
688 /* Read Ether type */
689 retVal = rtl8367c_getAsicReg(RTL8367C_VLAN_PPB_ETHERTYPR_REG(index), &etherType);
690 if(retVal != RT_ERR_OK)
691 return retVal;
692
693
694 pPbCfg->frameType = frameType;
695 pPbCfg->etherType = etherType;
696 return RT_ERR_OK;
697 }
698 /* Function Name:
699 * rtl8367c_setAsicVlanPortAndProtocolBased
700 * Description:
701 * Set protocol and port based VLAN configuration
702 * Input:
703 * port - Physical port number (0~10)
704 * index - Index of protocol and port based database index
705 * pPpbCfg - Protocol and port based VLAN configuration
706 * Output:
707 * None
708 * Return:
709 * RT_ERR_OK - Success
710 * RT_ERR_SMI - SMI access error
711 * RT_ERR_INPUT - Invalid input parameter
712 * RT_ERR_PORT_ID - Invalid port number
713 * RT_ERR_QOS_INT_PRIORITY - Invalid priority
714 * RT_ERR_VLAN_PROTO_AND_PORT - Invalid protocol base group database index
715 * RT_ERR_VLAN_ENTRY_NOT_FOUND - Invalid VLAN member configuration index
716 * Note:
717 * None
718 */
719 ret_t rtl8367c_setAsicVlanPortAndProtocolBased(rtk_uint32 port, rtk_uint32 index, rtl8367c_protocolvlancfg *pPpbCfg)
720 {
721 rtk_uint32 reg_addr, bit_mask, bit_value;
722 ret_t retVal;
723
724 /* Error Checking */
725 if(port > RTL8367C_PORTIDMAX)
726 return RT_ERR_PORT_ID;
727
728 if(index > RTL8367C_PROTOVLAN_GIDX_MAX)
729 return RT_ERR_VLAN_PROTO_AND_PORT;
730
731 if( (pPpbCfg->valid != FALSE) && (pPpbCfg->valid != TRUE) )
732 return RT_ERR_INPUT;
733
734 if(pPpbCfg->vlan_idx > RTL8367C_CVIDXMAX)
735 return RT_ERR_VLAN_ENTRY_NOT_FOUND;
736
737 if(pPpbCfg->priority > RTL8367C_PRIMAX)
738 return RT_ERR_QOS_INT_PRIORITY;
739
740 /* Valid bit */
741 reg_addr = RTL8367C_VLAN_PPB_VALID_REG(index);
742 bit_mask = 0x0001 << port;
743 bit_value = ((TRUE == pPpbCfg->valid) ? 0x1 : 0x0);
744 retVal = rtl8367c_setAsicRegBits(reg_addr, bit_mask, bit_value);
745 if(retVal != RT_ERR_OK)
746 return retVal;
747
748 /* Calculate the actual register address for CVLAN index*/
749 if(port < 8)
750 {
751 reg_addr = RTL8367C_VLAN_PPB_CTRL_REG(index, port);
752 bit_mask = RTL8367C_VLAN_PPB_CTRL_MASK(port);
753 }
754 else if(port == 8)
755 {
756 reg_addr = RTL8367C_REG_VLAN_PPB0_CTRL4;
757 bit_mask = RTL8367C_VLAN_PPB0_CTRL4_PORT8_INDEX_MASK;
758 }
759 else if(port == 9)
760 {
761 reg_addr = RTL8367C_REG_VLAN_PPB0_CTRL4;
762 bit_mask = RTL8367C_VLAN_PPB0_CTRL4_PORT9_INDEX_MASK;
763 }
764 else if(port == 10)
765 {
766 reg_addr = RTL8367C_REG_VLAN_PPB0_CTRL4;
767 bit_mask = RTL8367C_VLAN_PPB0_CTRL4_PORT10_INDEX_MASK;
768 }
769
770 bit_value = pPpbCfg->vlan_idx;
771 retVal = rtl8367c_setAsicRegBits(reg_addr, bit_mask, bit_value);
772 if(retVal != RT_ERR_OK)
773 return retVal;
774
775 /* write priority */
776 reg_addr = RTL8367C_VLAN_PPB_PRIORITY_ITEM_REG(port, index);
777 bit_mask = RTL8367C_VLAN_PPB_PRIORITY_ITEM_MASK(port);
778 bit_value = pPpbCfg->priority;
779 retVal = rtl8367c_setAsicRegBits(reg_addr, bit_mask, bit_value);
780 if(retVal != RT_ERR_OK)
781 return retVal;
782
783 return RT_ERR_OK;
784 }
785 /* Function Name:
786 * rtl8367c_getAsicVlanPortAndProtocolBased
787 * Description:
788 * Get protocol and port based VLAN configuration
789 * Input:
790 * port - Physical port number (0~7)
791 * index - Index of protocol and port based database index
792 * pPpbCfg - Protocol and port based VLAN configuration
793 * Output:
794 * None
795 * Return:
796 * RT_ERR_OK - Success
797 * RT_ERR_SMI - SMI access error
798 * RT_ERR_INPUT - Invalid input parameter
799 * RT_ERR_PORT_ID - Invalid port number
800 * RT_ERR_VLAN_PROTO_AND_PORT - Invalid protocol base group database index
801 * Note:
802 * None
803 */
804 ret_t rtl8367c_getAsicVlanPortAndProtocolBased(rtk_uint32 port, rtk_uint32 index, rtl8367c_protocolvlancfg *pPpbCfg)
805 {
806 rtk_uint32 reg_addr, bit_mask, bit_value;
807 ret_t retVal;
808
809 /* Error Checking */
810 if(port > RTL8367C_PORTIDMAX)
811 return RT_ERR_PORT_ID;
812
813 if(index > RTL8367C_PROTOVLAN_GIDX_MAX)
814 return RT_ERR_VLAN_PROTO_AND_PORT;
815
816 if(pPpbCfg == NULL)
817 return RT_ERR_INPUT;
818
819 /* Valid bit */
820 reg_addr = RTL8367C_VLAN_PPB_VALID_REG(index);
821 bit_mask = 0x0001 << port;
822 retVal = rtl8367c_getAsicRegBits(reg_addr, bit_mask, &bit_value);
823 if(retVal != RT_ERR_OK)
824 return retVal;
825
826 pPpbCfg->valid = bit_value;
827
828 /* CVLAN index */
829 if(port < 8)
830 {
831 reg_addr = RTL8367C_VLAN_PPB_CTRL_REG(index, port);
832 bit_mask = RTL8367C_VLAN_PPB_CTRL_MASK(port);
833 }
834 else if(port == 8)
835 {
836 reg_addr = RTL8367C_REG_VLAN_PPB0_CTRL4;
837 bit_mask = RTL8367C_VLAN_PPB0_CTRL4_PORT8_INDEX_MASK;
838 }
839 else if(port == 9)
840 {
841 reg_addr = RTL8367C_REG_VLAN_PPB0_CTRL4;
842 bit_mask = RTL8367C_VLAN_PPB0_CTRL4_PORT9_INDEX_MASK;
843 }
844 else if(port == 10)
845 {
846 reg_addr = RTL8367C_REG_VLAN_PPB0_CTRL4;
847 bit_mask = RTL8367C_VLAN_PPB0_CTRL4_PORT10_INDEX_MASK;
848 }
849
850 retVal = rtl8367c_getAsicRegBits(reg_addr, bit_mask, &bit_value);
851 if(retVal != RT_ERR_OK)
852 return retVal;
853
854 pPpbCfg->vlan_idx = bit_value;
855
856
857 /* priority */
858 reg_addr = RTL8367C_VLAN_PPB_PRIORITY_ITEM_REG(port,index);
859 bit_mask = RTL8367C_VLAN_PPB_PRIORITY_ITEM_MASK(port);
860 retVal = rtl8367c_getAsicRegBits(reg_addr, bit_mask, &bit_value);
861 if(retVal != RT_ERR_OK)
862 return retVal;
863
864 pPpbCfg->priority = bit_value;
865 return RT_ERR_OK;
866 }
867 /* Function Name:
868 * rtl8367c_setAsicVlanFilter
869 * Description:
870 * Set enable CVLAN filtering function
871 * Input:
872 * enabled - 1: enabled, 0: disabled
873 * Output:
874 * None
875 * Return:
876 * RT_ERR_OK - Success
877 * RT_ERR_SMI - SMI access error
878 * Note:
879 * None
880 */
881 ret_t rtl8367c_setAsicVlanFilter(rtk_uint32 enabled)
882 {
883 return rtl8367c_setAsicRegBit(RTL8367C_REG_VLAN_CTRL, RTL8367C_VLAN_CTRL_OFFSET, enabled);
884 }
885 /* Function Name:
886 * rtl8367c_getAsicVlanFilter
887 * Description:
888 * Get enable CVLAN filtering function
889 * Input:
890 * pEnabled - 1: enabled, 0: disabled
891 * Output:
892 * None
893 * Return:
894 * RT_ERR_OK - Success
895 * RT_ERR_SMI - SMI access error
896 * Note:
897 * None
898 */
899 ret_t rtl8367c_getAsicVlanFilter(rtk_uint32* pEnabled)
900 {
901 return rtl8367c_getAsicRegBit(RTL8367C_REG_VLAN_CTRL, RTL8367C_VLAN_CTRL_OFFSET, pEnabled);
902 }
903 /* Function Name:
904 * rtl8367c_setAsicVlanUntagDscpPriorityEn
905 * Description:
906 * Set enable Dscp to untag 1Q priority
907 * Input:
908 * enabled - 1: enabled, 0: disabled
909 * Output:
910 * None
911 * Return:
912 * RT_ERR_OK - Success
913 * RT_ERR_SMI - SMI access error
914 * Note:
915 * None
916 */
917 ret_t rtl8367c_setAsicVlanUntagDscpPriorityEn(rtk_uint32 enabled)
918 {
919 return rtl8367c_setAsicRegBit(RTL8367C_REG_UNTAG_DSCP_PRI_CFG, RTL8367C_UNTAG_DSCP_PRI_CFG_OFFSET, enabled);
920 }
921 /* Function Name:
922 * rtl8367c_getAsicVlanUntagDscpPriorityEn
923 * Description:
924 * Get enable Dscp to untag 1Q priority
925 * Input:
926 * enabled - 1: enabled, 0: disabled
927 * Output:
928 * None
929 * Return:
930 * RT_ERR_OK - Success
931 * RT_ERR_SMI - SMI access error
932 * Note:
933 * None
934 */
935 ret_t rtl8367c_getAsicVlanUntagDscpPriorityEn(rtk_uint32* enabled)
936 {
937 return rtl8367c_getAsicRegBit(RTL8367C_REG_UNTAG_DSCP_PRI_CFG, RTL8367C_UNTAG_DSCP_PRI_CFG_OFFSET, enabled);
938 }
939 /* Function Name:
940 * rtl8367c_setAsicPortBasedFid
941 * Description:
942 * Set port based FID
943 * Input:
944 * port - Physical port number (0~10)
945 * fid - Port based fid
946 * Output:
947 * None
948 * Return:
949 * RT_ERR_OK - Success
950 * RT_ERR_SMI - SMI access error
951 * RT_ERR_L2_FID - Invalid FID
952 * RT_ERR_PORT_ID - Invalid port number
953 * Note:
954 * None
955 */
956 ret_t rtl8367c_setAsicPortBasedFid(rtk_uint32 port, rtk_uint32 fid)
957 {
958 rtk_uint32 reg_addr;
959
960 if(port > RTL8367C_PORTIDMAX)
961 return RT_ERR_PORT_ID;
962
963 if(fid > RTL8367C_FIDMAX)
964 return RT_ERR_L2_FID;
965
966 if(port < 8)
967 return rtl8367c_setAsicReg(RTL8367C_PORT_PBFID_REG(port),fid);
968 else {
969 reg_addr = RTL8367C_REG_PORT8_PBFID + port-8;
970 return rtl8367c_setAsicReg(reg_addr, fid);
971 }
972
973 }
974 /* Function Name:
975 * rtl8367c_getAsicPortBasedFid
976 * Description:
977 * Get port based FID
978 * Input:
979 * port - Physical port number (0~7)
980 * pFid - Port based fid
981 * Output:
982 * None
983 * Return:
984 * RT_ERR_OK - Success
985 * RT_ERR_SMI - SMI access error
986 * RT_ERR_PORT_ID - Invalid port number
987 * Note:
988 * None
989 */
990 ret_t rtl8367c_getAsicPortBasedFid(rtk_uint32 port, rtk_uint32* pFid)
991 {
992 rtk_uint32 reg_addr;
993
994 if(port > RTL8367C_PORTIDMAX)
995 return RT_ERR_PORT_ID;
996
997 if(port < 8)
998 return rtl8367c_getAsicReg(RTL8367C_PORT_PBFID_REG(port), pFid);
999 else{
1000 reg_addr = RTL8367C_REG_PORT8_PBFID + port-8;
1001 return rtl8367c_getAsicReg(reg_addr, pFid);
1002 }
1003 }
1004 /* Function Name:
1005 * rtl8367c_setAsicPortBasedFidEn
1006 * Description:
1007 * Set port based FID selection enable
1008 * Input:
1009 * port - Physical port number (0~10)
1010 * enabled - 1: enabled, 0: disabled
1011 * Output:
1012 * None
1013 * Return:
1014 * RT_ERR_OK - Success
1015 * RT_ERR_SMI - SMI access error
1016 * RT_ERR_PORT_ID - Invalid port number
1017 * Note:
1018 * None
1019 */
1020 ret_t rtl8367c_setAsicPortBasedFidEn(rtk_uint32 port, rtk_uint32 enabled)
1021 {
1022 if(port > RTL8367C_PORTIDMAX)
1023 return RT_ERR_PORT_ID;
1024
1025 return rtl8367c_setAsicRegBit(RTL8367C_REG_PORT_PBFIDEN,port, enabled);
1026 }
1027 /* Function Name:
1028 * rtl8367c_getAsicPortBasedFidEn
1029 * Description:
1030 * Get port based FID selection enable
1031 * Input:
1032 * port - Physical port number (0~10)
1033 * pEnabled - 1: enabled, 0: disabled
1034 * Output:
1035 * None
1036 * Return:
1037 * RT_ERR_OK - Success
1038 * RT_ERR_SMI - SMI access error
1039 * RT_ERR_PORT_ID - Invalid port number
1040 * Note:
1041 * None
1042 */
1043 ret_t rtl8367c_getAsicPortBasedFidEn(rtk_uint32 port, rtk_uint32* pEnabled)
1044 {
1045 if(port > RTL8367C_PORTIDMAX)
1046 return RT_ERR_PORT_ID;
1047
1048 return rtl8367c_getAsicRegBit(RTL8367C_REG_PORT_PBFIDEN,port, pEnabled);
1049 }
1050 /* Function Name:
1051 * rtl8367c_setAsicSpanningTreeStatus
1052 * Description:
1053 * Set spanning tree state per each port
1054 * Input:
1055 * port - Physical port number (0~10)
1056 * msti - Multiple spanning tree instance
1057 * state - Spanning tree state for msti
1058 * Output:
1059 * None
1060 * Return:
1061 * RT_ERR_OK - Success
1062 * RT_ERR_SMI - SMI access error
1063 * RT_ERR_MSTI - Invalid msti parameter
1064 * RT_ERR_PORT_ID - Invalid port number
1065 * RT_ERR_MSTP_STATE - Invalid port number
1066 * Note:
1067 * None
1068 */
1069 ret_t rtl8367c_setAsicSpanningTreeStatus(rtk_uint32 port, rtk_uint32 msti, rtk_uint32 state)
1070 {
1071 rtk_uint32 reg_addr,bits_msk;
1072
1073 if(port > RTL8367C_PORTIDMAX)
1074 return RT_ERR_PORT_ID;
1075
1076 if(msti > RTL8367C_MSTIMAX)
1077 return RT_ERR_MSTI;
1078
1079 if(state > STPST_FORWARDING)
1080 return RT_ERR_MSTP_STATE;
1081
1082 if(port < 8)
1083 return rtl8367c_setAsicRegBits(RTL8367C_VLAN_MSTI_REG(msti,port), RTL8367C_VLAN_MSTI_MASK(port),state);
1084 else{
1085 reg_addr = RTL8367C_VLAN_MSTI_REG(msti,port);
1086 switch(port){
1087 case 8: bits_msk = RTL8367C_VLAN_MSTI0_CTRL1_PORT8_STATE_MASK;break;
1088 case 9: bits_msk = RTL8367C_VLAN_MSTI0_CTRL1_PORT9_STATE_MASK;break;
1089 case 10: bits_msk = RTL8367C_VLAN_MSTI0_CTRL1_PORT10_STATE_MASK;break;
1090 }
1091 return rtl8367c_setAsicRegBits(reg_addr, bits_msk,state);
1092 }
1093 }
1094 /* Function Name:
1095 * rtl8367c_getAsicSpanningTreeStatus
1096 * Description:
1097 * Set spanning tree state per each port
1098 * Input:
1099 * port - Physical port number (0~10)
1100 * msti - Multiple spanning tree instance
1101 * pState - Spanning tree state for msti
1102 * Output:
1103 * None
1104 * Return:
1105 * RT_ERR_OK - Success
1106 * RT_ERR_SMI - SMI access error
1107 * RT_ERR_MSTI - Invalid msti parameter
1108 * RT_ERR_PORT_ID - Invalid port number
1109 * Note:
1110 * None
1111 */
1112 ret_t rtl8367c_getAsicSpanningTreeStatus(rtk_uint32 port, rtk_uint32 msti, rtk_uint32* pState)
1113 {
1114 rtk_uint32 reg_addr,bits_msk;
1115
1116 if(port > RTL8367C_PORTIDMAX)
1117 return RT_ERR_PORT_ID;
1118
1119 if(msti > RTL8367C_MSTIMAX)
1120 return RT_ERR_MSTI;
1121
1122 if(port < 8)
1123 return rtl8367c_getAsicRegBits(RTL8367C_VLAN_MSTI_REG(msti,port), RTL8367C_VLAN_MSTI_MASK(port), pState);
1124 else{
1125 reg_addr = RTL8367C_VLAN_MSTI_REG(msti,port);
1126 switch(port){
1127 case 8: bits_msk = RTL8367C_VLAN_MSTI0_CTRL1_PORT8_STATE_MASK;break;
1128 case 9: bits_msk = RTL8367C_VLAN_MSTI0_CTRL1_PORT9_STATE_MASK;break;
1129 case 10: bits_msk = RTL8367C_VLAN_MSTI0_CTRL1_PORT10_STATE_MASK;break;
1130 }
1131 return rtl8367c_getAsicRegBits(reg_addr, bits_msk, pState);
1132 }
1133
1134 }
1135
1136 /* Function Name:
1137 * rtl8367c_setAsicVlanTransparent
1138 * Description:
1139 * Set VLAN transparent
1140 * Input:
1141 * port - Physical port number (0~10)
1142 * portmask - portmask(0~0xFF)
1143 * Output:
1144 * None
1145 * Return:
1146 * RT_ERR_OK - Success
1147 * RT_ERR_SMI - SMI access error
1148 * RT_ERR_PORT_MASK - Invalid portmask
1149 * RT_ERR_PORT_ID - Invalid port number
1150 * Note:
1151 * None
1152 */
1153 ret_t rtl8367c_setAsicVlanTransparent(rtk_uint32 port, rtk_uint32 portmask)
1154 {
1155 if(port > RTL8367C_PORTIDMAX)
1156 return RT_ERR_PORT_ID;
1157
1158 if(portmask > RTL8367C_PORTMASK)
1159 return RT_ERR_PORT_MASK;
1160
1161 return rtl8367c_setAsicRegBits(RTL8367C_REG_VLAN_EGRESS_TRANS_CTRL0 + port, RTL8367C_VLAN_EGRESS_TRANS_CTRL0_MASK, portmask);
1162 }
1163
1164 /* Function Name:
1165 * rtl8367c_getAsicVlanTransparent
1166 * Description:
1167 * Get VLAN transparent
1168 * Input:
1169 * port - Physical port number (0~10)
1170 * Output:
1171 * pPortmask - Ingress port mask
1172 * Return:
1173 * RT_ERR_OK - Success
1174 * RT_ERR_SMI - SMI access error
1175 * RT_ERR_PORT_MASK - Invalid portmask
1176 * RT_ERR_PORT_ID - Invalid port number
1177 * Note:
1178 * None
1179 */
1180 ret_t rtl8367c_getAsicVlanTransparent(rtk_uint32 port, rtk_uint32 *pPortmask)
1181 {
1182 if(port > RTL8367C_PORTIDMAX)
1183 return RT_ERR_PORT_ID;
1184
1185 return rtl8367c_getAsicRegBits(RTL8367C_REG_VLAN_EGRESS_TRANS_CTRL0 + port, RTL8367C_VLAN_EGRESS_TRANS_CTRL0_MASK, pPortmask);
1186 }
1187
1188 /* Function Name:
1189 * rtl8367c_setAsicVlanEgressKeep
1190 * Description:
1191 * Set per egress port VLAN keep mode
1192 * Input:
1193 * port - Physical port number (0~10)
1194 * portmask - portmask(0~0xFF)
1195 * Output:
1196 * None
1197 * Return:
1198 * RT_ERR_OK - Success
1199 * RT_ERR_SMI - SMI access error
1200 * RT_ERR_PORT_MASK - Invalid portmask
1201 * RT_ERR_PORT_ID - Invalid port number
1202 * Note:
1203 * None
1204 */
1205 ret_t rtl8367c_setAsicVlanEgressKeep(rtk_uint32 port, rtk_uint32 portmask)
1206 {
1207 rtk_uint32 regAddr, bit_mask;
1208 ret_t retVal;
1209
1210 if(port > RTL8367C_PORTIDMAX)
1211 return RT_ERR_PORT_ID;
1212
1213 if(portmask > RTL8367C_PORTMASK)
1214 return RT_ERR_PORT_MASK;
1215
1216 if(port < 8){
1217 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL0 + (port>>1),RTL8367C_PORT0_VLAN_KEEP_MASK_MASK<<((port&1)*8),portmask & 0xff);
1218 if(retVal != RT_ERR_OK)
1219 return retVal;
1220 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL0_EXT + (port>>1);
1221 bit_mask = RTL8367C_PORT0_VLAN_KEEP_MASK_EXT_MASK;
1222 bit_mask <<= (port&1)*3;
1223 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, (portmask>>8)&0x7);
1224 if(retVal != RT_ERR_OK)
1225 return retVal;
1226 }
1227 else{
1228 switch(port){
1229 case 8:
1230 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4;
1231 bit_mask = RTL8367C_PORT8_VLAN_KEEP_MASK_MASK;
1232 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, portmask & 0xff);
1233 if(retVal != RT_ERR_OK)
1234 return retVal;
1235 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4_EXT;
1236 bit_mask = RTL8367C_PORT8_VLAN_KEEP_MASK_EXT_MASK;
1237 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, (portmask>>8)&0x7);
1238 if(retVal != RT_ERR_OK)
1239 return retVal;
1240 break;
1241
1242 case 9:
1243 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4;
1244 bit_mask = RTL8367C_PORT9_VLAN_KEEP_MASK_MASK;
1245 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, portmask & 0xff);
1246 if(retVal != RT_ERR_OK)
1247 return retVal;
1248 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4_EXT;
1249 bit_mask = RTL8367C_PORT9_VLAN_KEEP_MASK_EXT_MASK;
1250 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, (portmask>>8)&0x7);
1251 if(retVal != RT_ERR_OK)
1252 return retVal;
1253 break;
1254
1255 case 10:
1256 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL5;
1257 bit_mask = RTL8367C_VLAN_EGRESS_KEEP_CTRL5_MASK;
1258 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, portmask & 0xff);
1259 if(retVal != RT_ERR_OK)
1260 return retVal;
1261 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL5_EXT;
1262 bit_mask = RTL8367C_VLAN_EGRESS_KEEP_CTRL5_EXT_MASK;
1263 retVal = rtl8367c_setAsicRegBits(regAddr, bit_mask, (portmask>>8)&0x7);
1264 if(retVal != RT_ERR_OK)
1265 return retVal;
1266 break;
1267 }
1268 }
1269
1270 return RT_ERR_OK;
1271 }
1272
1273 /* Function Name:
1274 * rtl8367c_getAsicVlanEgressKeep
1275 * Description:
1276 * Get per egress port VLAN keep mode
1277 * Input:
1278 * port - Physical port number (0~7)
1279 * pPortmask - portmask(0~0xFF)
1280 * Output:
1281 * None
1282 * Return:
1283 * RT_ERR_OK - Success
1284 * RT_ERR_SMI - SMI access error
1285 * RT_ERR_PORT_ID - Invalid port number
1286 * Note:
1287 * None
1288 */
1289 ret_t rtl8367c_getAsicVlanEgressKeep(rtk_uint32 port, rtk_uint32* pPortmask)
1290 {
1291 rtk_uint32 regAddr, bit_mask, regval_l, regval_h;
1292 ret_t retVal;
1293
1294 if(port > RTL8367C_PORTIDMAX)
1295 return RT_ERR_PORT_ID;
1296
1297 if(port < 8){
1298 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL0 + (port>>1),RTL8367C_PORT0_VLAN_KEEP_MASK_MASK<<((port&1)*8),&regval_l);
1299 if(retVal != RT_ERR_OK)
1300 return retVal;
1301 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL0_EXT + (port>>1);
1302 bit_mask = RTL8367C_PORT0_VLAN_KEEP_MASK_EXT_MASK;
1303 bit_mask <<= (port&1)*3;
1304 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_h);
1305 if(retVal != RT_ERR_OK)
1306 return retVal;
1307 *pPortmask = (regval_h << 8) | regval_l;
1308 }
1309 else{
1310 switch(port){
1311 case 8:
1312 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4;
1313 bit_mask = RTL8367C_PORT8_VLAN_KEEP_MASK_MASK;
1314 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_l);
1315 if(retVal != RT_ERR_OK)
1316 return retVal;
1317 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4_EXT;
1318 bit_mask = RTL8367C_PORT8_VLAN_KEEP_MASK_EXT_MASK;
1319 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_h);
1320 if(retVal != RT_ERR_OK)
1321 return retVal;
1322
1323 *pPortmask = (regval_h << 8) | regval_l;
1324 break;
1325
1326 case 9:
1327 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4;
1328 bit_mask = RTL8367C_PORT9_VLAN_KEEP_MASK_MASK;
1329 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_l);
1330 if(retVal != RT_ERR_OK)
1331 return retVal;
1332 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL4_EXT;
1333 bit_mask = RTL8367C_PORT9_VLAN_KEEP_MASK_EXT_MASK;
1334 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_h);
1335 if(retVal != RT_ERR_OK)
1336 return retVal;
1337
1338 *pPortmask = (regval_h << 8) | regval_l;
1339 break;
1340
1341 case 10:
1342 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL5;
1343 bit_mask = RTL8367C_VLAN_EGRESS_KEEP_CTRL5_MASK;
1344 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_l);
1345 if(retVal != RT_ERR_OK)
1346 return retVal;
1347 regAddr = RTL8367C_REG_VLAN_EGRESS_KEEP_CTRL5_EXT;
1348 bit_mask = RTL8367C_VLAN_EGRESS_KEEP_CTRL5_EXT_MASK;
1349 retVal = rtl8367c_getAsicRegBits(regAddr, bit_mask, &regval_h);
1350 if(retVal != RT_ERR_OK)
1351 return retVal;
1352
1353 *pPortmask = (regval_h << 8) | regval_l;
1354 break;
1355 }
1356 }
1357
1358 return RT_ERR_OK;
1359 }
1360
1361 /* Function Name:
1362 * rtl8367c_setReservedVidAction
1363 * Description:
1364 * Set reserved VID action
1365 * Input:
1366 * vid0Action - VID 0 action
1367 * vid4095Action - VID 4095 action
1368 * Output:
1369 * None
1370 * Return:
1371 * RT_ERR_OK - Success
1372 * RT_ERR_SMI - SMI access error
1373 * RT_ERR_INPUT - Error input
1374 * Note:
1375 * None
1376 */
1377 ret_t rtl8367c_setReservedVidAction(rtk_uint32 vid0Action, rtk_uint32 vid4095Action)
1378 {
1379 ret_t retVal;
1380
1381 if(vid0Action >= RES_VID_ACT_END)
1382 return RT_ERR_INPUT;
1383
1384 if(vid4095Action >= RES_VID_ACT_END)
1385 return RT_ERR_INPUT;
1386
1387 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL, RTL8367C_VLAN_VID0_TYPE_OFFSET, vid0Action)) != RT_ERR_OK)
1388 return retVal;
1389
1390 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL, RTL8367C_VLAN_VID4095_TYPE_OFFSET, vid4095Action)) != RT_ERR_OK)
1391 return retVal;
1392
1393 return RT_ERR_OK;
1394 }
1395
1396 /* Function Name:
1397 * rtl8367c_getReservedVidAction
1398 * Description:
1399 * Get reserved VID action
1400 * Input:
1401 * pVid0Action - VID 0 action
1402 * pVid4095Action - VID 4095 action
1403 * Output:
1404 * None
1405 * Return:
1406 * RT_ERR_OK - Success
1407 * RT_ERR_SMI - SMI access error
1408 * RT_ERR_NULL_POINTER - Null pointer
1409 * Note:
1410 * None
1411 */
1412 ret_t rtl8367c_getReservedVidAction(rtk_uint32 *pVid0Action, rtk_uint32 *pVid4095Action)
1413 {
1414 ret_t retVal;
1415
1416 if(pVid0Action == NULL)
1417 return RT_ERR_NULL_POINTER;
1418
1419 if(pVid4095Action == NULL)
1420 return RT_ERR_NULL_POINTER;
1421
1422 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL, RTL8367C_VLAN_VID0_TYPE_OFFSET, pVid0Action)) != RT_ERR_OK)
1423 return retVal;
1424
1425 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL, RTL8367C_VLAN_VID4095_TYPE_OFFSET, pVid4095Action)) != RT_ERR_OK)
1426 return retVal;
1427
1428 return RT_ERR_OK;
1429
1430 }
1431
1432 /* Function Name:
1433 * rtl8367c_setRealKeepRemarkEn
1434 * Description:
1435 * Set Real Keep Remark
1436 * Input:
1437 * enabled - 0: 1P remarking is forbidden at real keep packet, 1: 1P remarking is enabled at real keep packet
1438 * Output:
1439 * None
1440 * Return:
1441 * RT_ERR_OK - Success
1442 * RT_ERR_SMI - SMI access error
1443 * RT_ERR_INPUT - Error input
1444 * Note:
1445 * None
1446 */
1447 ret_t rtl8367c_setRealKeepRemarkEn(rtk_uint32 enabled)
1448 {
1449 ret_t retVal;
1450
1451 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL, RTL8367C_VLAN_1P_REMARK_BYPASS_REALKEEP_OFFSET, enabled)) != RT_ERR_OK)
1452 return retVal;
1453
1454 return RT_ERR_OK;
1455 }
1456
1457 /* Function Name:
1458 * rtl8367c_getRealKeepRemarkEn
1459 * Description:
1460 * Get Real Keep Remark
1461 * Input:
1462 * None
1463 * Output:
1464 * pEnabled - 0: 1P remarking is forbidden at real keep packet, 1: 1P remarking is enabled at real keep packet
1465 * Return:
1466 * RT_ERR_OK - Success
1467 * RT_ERR_SMI - SMI access error
1468 * RT_ERR_INPUT - Error input
1469 * Note:
1470 * None
1471 */
1472 ret_t rtl8367c_getRealKeepRemarkEn(rtk_uint32 *pEnabled)
1473 {
1474 ret_t retVal;
1475
1476 if((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL, RTL8367C_VLAN_1P_REMARK_BYPASS_REALKEEP_OFFSET, pEnabled)) != RT_ERR_OK)
1477 return retVal;
1478
1479 return RT_ERR_OK;
1480 }
1481
1482 /* Function Name:
1483 * rtl8367c_resetVlan
1484 * Description:
1485 * Reset VLAN table
1486 * Input:
1487 * None.
1488 * Output:
1489 * None.
1490 * Return:
1491 * RT_ERR_OK - Success
1492 * RT_ERR_SMI - SMI access error
1493 * Note:
1494 * None
1495 */
1496 ret_t rtl8367c_resetVlan(void)
1497 {
1498 ret_t retVal;
1499
1500 if((retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_VLAN_EXT_CTRL2, RTL8367C_VLAN_EXT_CTRL2_OFFSET, 1)) != RT_ERR_OK)
1501 return retVal;
1502
1503 return RT_ERR_OK;
1504 }
1505
Staging tree of Mathias Kresin