projects / openwrt / staging / rmilecki.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mediatek: mt7622: add Linux 5.10 support
[openwrt/staging/rmilecki.git] / target / linux / mediatek / files-5.10 / drivers / net / phy / rtk / rtl8367c / 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 : RTK switch high-level API for RTL8367/RTL8367C
14 * Feature : Here is a list of all functions and variables in VLAN module.
15 *
16 */
17
18 #include <rtk_switch.h>
19 #include <rtk_error.h>
20 #include <vlan.h>
21 #include <rate.h>
22 #include <string.h>
23
24 #include <rtl8367c_asicdrv.h>
25 #include <rtl8367c_asicdrv_vlan.h>
26 #include <rtl8367c_asicdrv_dot1x.h>
27
28 typedef enum vlan_mbrCfgType_e
29 {
30 MBRCFG_UNUSED = 0,
31 MBRCFG_USED_BY_VLAN,
32 MBRCFG_END
33 }vlan_mbrCfgType_t;
34
35 static rtk_vlan_t vlan_mbrCfgVid[RTL8367C_CVIDXNO];
36 static vlan_mbrCfgType_t vlan_mbrCfgUsage[RTL8367C_CVIDXNO];
37
38 /* Function Name:
39 * rtk_vlan_init
40 * Description:
41 * Initialize VLAN.
42 * Input:
43 * None
44 * Output:
45 * None
46 * Return:
47 * RT_ERR_OK - OK
48 * RT_ERR_FAILED - Failed
49 * RT_ERR_SMI - SMI access error
50 * Note:
51 * VLAN is disabled by default. User has to call this API to enable VLAN before
52 * using it. And It will set a default VLAN(vid 1) including all ports and set
53 * all ports PVID to the default VLAN.
54 */
55 rtk_api_ret_t rtk_vlan_init(void)
56 {
57 rtk_api_ret_t retVal;
58 rtk_uint32 i;
59 rtl8367c_user_vlan4kentry vlan4K;
60 rtl8367c_vlanconfiguser vlanMC;
61
62 /* Check initialization state */
63 RTK_CHK_INIT_STATE();
64
65 /* Clean Database */
66 memset(vlan_mbrCfgVid, 0x00, sizeof(rtk_vlan_t) * RTL8367C_CVIDXNO);
67 memset(vlan_mbrCfgUsage, 0x00, sizeof(vlan_mbrCfgType_t) * RTL8367C_CVIDXNO);
68
69 /* clean 32 VLAN member configuration */
70 for (i = 0; i <= RTL8367C_CVIDXMAX; i++)
71 {
72 vlanMC.evid = 0;
73 vlanMC.mbr = 0;
74 vlanMC.fid_msti = 0;
75 vlanMC.envlanpol = 0;
76 vlanMC.meteridx = 0;
77 vlanMC.vbpen = 0;
78 vlanMC.vbpri = 0;
79 if ((retVal = rtl8367c_setAsicVlanMemberConfig(i, &vlanMC)) != RT_ERR_OK)
80 return retVal;
81 }
82
83 /* Set a default VLAN with vid 1 to 4K table for all ports */
84 memset(&vlan4K, 0, sizeof(rtl8367c_user_vlan4kentry));
85 vlan4K.vid = 1;
86 vlan4K.mbr = RTK_PHY_PORTMASK_ALL;
87 vlan4K.untag = RTK_PHY_PORTMASK_ALL;
88 vlan4K.fid_msti = 0;
89 if ((retVal = rtl8367c_setAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
90 return retVal;
91
92 /* Also set the default VLAN to 32 member configuration index 0 */
93 memset(&vlanMC, 0, sizeof(rtl8367c_vlanconfiguser));
94 vlanMC.evid = 1;
95 vlanMC.mbr = RTK_PHY_PORTMASK_ALL;
96 vlanMC.fid_msti = 0;
97 if ((retVal = rtl8367c_setAsicVlanMemberConfig(0, &vlanMC)) != RT_ERR_OK)
98 return retVal;
99
100 /* Set all ports PVID to default VLAN and tag-mode to original */
101 RTK_SCAN_ALL_PHY_PORTMASK(i)
102 {
103 if ((retVal = rtl8367c_setAsicVlanPortBasedVID(i, 0, 0)) != RT_ERR_OK)
104 return retVal;
105 if ((retVal = rtl8367c_setAsicVlanEgressTagMode(i, EG_TAG_MODE_ORI)) != RT_ERR_OK)
106 return retVal;
107 }
108
109 /* Updata Databse */
110 vlan_mbrCfgUsage[0] = MBRCFG_USED_BY_VLAN;
111 vlan_mbrCfgVid[0] = 1;
112
113 /* Enable Ingress filter */
114 RTK_SCAN_ALL_PHY_PORTMASK(i)
115 {
116 if ((retVal = rtl8367c_setAsicVlanIngressFilter(i, ENABLED)) != RT_ERR_OK)
117 return retVal;
118 }
119
120 /* enable VLAN */
121 if ((retVal = rtl8367c_setAsicVlanFilter(ENABLED)) != RT_ERR_OK)
122 return retVal;
123
124 return RT_ERR_OK;
125 }
126
127 /* Function Name:
128 * rtk_vlan_set
129 * Description:
130 * Set a VLAN entry.
131 * Input:
132 * vid - VLAN ID to configure.
133 * pVlanCfg - VLAN Configuration
134 * Output:
135 * None
136 * Return:
137 * RT_ERR_OK - OK
138 * RT_ERR_FAILED - Failed
139 * RT_ERR_SMI - SMI access error
140 * RT_ERR_INPUT - Invalid input parameters.
141 * RT_ERR_L2_FID - Invalid FID.
142 * RT_ERR_VLAN_PORT_MBR_EXIST - Invalid member port mask.
143 * RT_ERR_VLAN_VID - Invalid VID parameter.
144 * Note:
145 *
146 */
147 rtk_api_ret_t rtk_vlan_set(rtk_vlan_t vid, rtk_vlan_cfg_t *pVlanCfg)
148 {
149 rtk_api_ret_t retVal;
150 rtk_uint32 phyMbrPmask;
151 rtk_uint32 phyUntagPmask;
152 rtl8367c_user_vlan4kentry vlan4K;
153 rtl8367c_vlanconfiguser vlanMC;
154 rtk_uint32 idx;
155 rtk_uint32 empty_index = 0xffff;
156 rtk_uint32 update_evid = 0;
157
158 /* Check initialization state */
159 RTK_CHK_INIT_STATE();
160
161 /* vid must be 0~8191 */
162 if (vid > RTL8367C_EVIDMAX)
163 return RT_ERR_VLAN_VID;
164
165 /* Null pointer check */
166 if(NULL == pVlanCfg)
167 return RT_ERR_NULL_POINTER;
168
169 /* Check port mask valid */
170 RTK_CHK_PORTMASK_VALID(&(pVlanCfg->mbr));
171
172 if (vid <= RTL8367C_VIDMAX)
173 {
174 /* Check untag port mask valid */
175 RTK_CHK_PORTMASK_VALID(&(pVlanCfg->untag));
176 }
177
178 /* IVL_EN */
179 if(pVlanCfg->ivl_en >= RTK_ENABLE_END)
180 return RT_ERR_ENABLE;
181
182 /* fid must be 0~15 */
183 if(pVlanCfg->fid_msti > RTL8367C_FIDMAX)
184 return RT_ERR_L2_FID;
185
186 /* Policing */
187 if(pVlanCfg->envlanpol >= RTK_ENABLE_END)
188 return RT_ERR_ENABLE;
189
190 /* Meter ID */
191 if(pVlanCfg->meteridx > RTK_MAX_METER_ID)
192 return RT_ERR_INPUT;
193
194 /* VLAN based priority */
195 if(pVlanCfg->vbpen >= RTK_ENABLE_END)
196 return RT_ERR_ENABLE;
197
198 /* Priority */
199 if(pVlanCfg->vbpri > RTL8367C_PRIMAX)
200 return RT_ERR_INPUT;
201
202 /* Get physical port mask */
203 if(rtk_switch_portmask_L2P_get(&(pVlanCfg->mbr), &phyMbrPmask) != RT_ERR_OK)
204 return RT_ERR_FAILED;
205
206 if(rtk_switch_portmask_L2P_get(&(pVlanCfg->untag), &phyUntagPmask) != RT_ERR_OK)
207 return RT_ERR_FAILED;
208
209 if (vid <= RTL8367C_VIDMAX)
210 {
211 /* update 4K table */
212 memset(&vlan4K, 0, sizeof(rtl8367c_user_vlan4kentry));
213 vlan4K.vid = vid;
214
215 vlan4K.mbr = (phyMbrPmask & 0xFFFF);
216 vlan4K.untag = (phyUntagPmask & 0xFFFF);
217
218 vlan4K.ivl_svl = pVlanCfg->ivl_en;
219 vlan4K.fid_msti = pVlanCfg->fid_msti;
220 vlan4K.envlanpol = pVlanCfg->envlanpol;
221 vlan4K.meteridx = pVlanCfg->meteridx;
222 vlan4K.vbpen = pVlanCfg->vbpen;
223 vlan4K.vbpri = pVlanCfg->vbpri;
224
225 if ((retVal = rtl8367c_setAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
226 return retVal;
227
228 /* Update Member configuration if exist */
229 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
230 {
231 if(vlan_mbrCfgUsage[idx] == MBRCFG_USED_BY_VLAN)
232 {
233 if(vlan_mbrCfgVid[idx] == vid)
234 {
235 /* Found! Update */
236 if(phyMbrPmask == 0x00)
237 {
238 /* Member port = 0x00, delete this VLAN from Member Configuration */
239 memset(&vlanMC, 0x00, sizeof(rtl8367c_vlanconfiguser));
240 if ((retVal = rtl8367c_setAsicVlanMemberConfig(idx, &vlanMC)) != RT_ERR_OK)
241 return retVal;
242
243 /* Clear Database */
244 vlan_mbrCfgUsage[idx] = MBRCFG_UNUSED;
245 vlan_mbrCfgVid[idx] = 0;
246 }
247 else
248 {
249 /* Normal VLAN config, update to member configuration */
250 vlanMC.evid = vid;
251 vlanMC.mbr = vlan4K.mbr;
252 vlanMC.fid_msti = vlan4K.fid_msti;
253 vlanMC.meteridx = vlan4K.meteridx;
254 vlanMC.envlanpol= vlan4K.envlanpol;
255 vlanMC.vbpen = vlan4K.vbpen;
256 vlanMC.vbpri = vlan4K.vbpri;
257 if ((retVal = rtl8367c_setAsicVlanMemberConfig(idx, &vlanMC)) != RT_ERR_OK)
258 return retVal;
259 }
260
261 break;
262 }
263 }
264 }
265 }
266 else
267 {
268 /* vid > 4095 */
269 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
270 {
271 if(vlan_mbrCfgUsage[idx] == MBRCFG_USED_BY_VLAN)
272 {
273 if(vlan_mbrCfgVid[idx] == vid)
274 {
275 /* Found! Update */
276 if(phyMbrPmask == 0x00)
277 {
278 /* Member port = 0x00, delete this VLAN from Member Configuration */
279 memset(&vlanMC, 0x00, sizeof(rtl8367c_vlanconfiguser));
280 if ((retVal = rtl8367c_setAsicVlanMemberConfig(idx, &vlanMC)) != RT_ERR_OK)
281 return retVal;
282
283 /* Clear Database */
284 vlan_mbrCfgUsage[idx] = MBRCFG_UNUSED;
285 vlan_mbrCfgVid[idx] = 0;
286 }
287 else
288 {
289 /* Normal VLAN config, update to member configuration */
290 vlanMC.evid = vid;
291 vlanMC.mbr = phyMbrPmask;
292 vlanMC.fid_msti = pVlanCfg->fid_msti;
293 vlanMC.meteridx = pVlanCfg->meteridx;
294 vlanMC.envlanpol= pVlanCfg->envlanpol;
295 vlanMC.vbpen = pVlanCfg->vbpen;
296 vlanMC.vbpri = pVlanCfg->vbpri;
297 if ((retVal = rtl8367c_setAsicVlanMemberConfig(idx, &vlanMC)) != RT_ERR_OK)
298 return retVal;
299
300 break;
301 }
302
303 update_evid = 1;
304 }
305 }
306
307 if(vlan_mbrCfgUsage[idx] == MBRCFG_UNUSED)
308 {
309 if(0xffff == empty_index)
310 empty_index = idx;
311 }
312 }
313
314 /* doesn't find out same EVID entry and there is empty index in member configuration */
315 if( (phyMbrPmask != 0x00) && (update_evid == 0) && (empty_index != 0xFFFF) )
316 {
317 vlanMC.evid = vid;
318 vlanMC.mbr = phyMbrPmask;
319 vlanMC.fid_msti = pVlanCfg->fid_msti;
320 vlanMC.meteridx = pVlanCfg->meteridx;
321 vlanMC.envlanpol= pVlanCfg->envlanpol;
322 vlanMC.vbpen = pVlanCfg->vbpen;
323 vlanMC.vbpri = pVlanCfg->vbpri;
324 if ((retVal = rtl8367c_setAsicVlanMemberConfig(empty_index, &vlanMC)) != RT_ERR_OK)
325 return retVal;
326
327 vlan_mbrCfgUsage[empty_index] = MBRCFG_USED_BY_VLAN;
328 vlan_mbrCfgVid[empty_index] = vid;
329
330 }
331 }
332
333 return RT_ERR_OK;
334 }
335
336 /* Function Name:
337 * rtk_vlan_get
338 * Description:
339 * Get a VLAN entry.
340 * Input:
341 * vid - VLAN ID to configure.
342 * Output:
343 * pVlanCfg - VLAN Configuration
344 * Return:
345 * RT_ERR_OK - OK
346 * RT_ERR_FAILED - Failed
347 * RT_ERR_SMI - SMI access error
348 * RT_ERR_INPUT - Invalid input parameters.
349 * RT_ERR_VLAN_VID - Invalid VID parameter.
350 * Note:
351 *
352 */
353 rtk_api_ret_t rtk_vlan_get(rtk_vlan_t vid, rtk_vlan_cfg_t *pVlanCfg)
354 {
355 rtk_api_ret_t retVal;
356 rtk_uint32 phyMbrPmask;
357 rtk_uint32 phyUntagPmask;
358 rtl8367c_user_vlan4kentry vlan4K;
359 rtl8367c_vlanconfiguser vlanMC;
360 rtk_uint32 idx;
361
362 /* Check initialization state */
363 RTK_CHK_INIT_STATE();
364
365 /* vid must be 0~8191 */
366 if (vid > RTL8367C_EVIDMAX)
367 return RT_ERR_VLAN_VID;
368
369 /* Null pointer check */
370 if(NULL == pVlanCfg)
371 return RT_ERR_NULL_POINTER;
372
373 if (vid <= RTL8367C_VIDMAX)
374 {
375 vlan4K.vid = vid;
376
377 if ((retVal = rtl8367c_getAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
378 return retVal;
379
380 phyMbrPmask = vlan4K.mbr;
381 phyUntagPmask = vlan4K.untag;
382 if(rtk_switch_portmask_P2L_get(phyMbrPmask, &(pVlanCfg->mbr)) != RT_ERR_OK)
383 return RT_ERR_FAILED;
384
385 if(rtk_switch_portmask_P2L_get(phyUntagPmask, &(pVlanCfg->untag)) != RT_ERR_OK)
386 return RT_ERR_FAILED;
387
388 pVlanCfg->ivl_en = vlan4K.ivl_svl;
389 pVlanCfg->fid_msti = vlan4K.fid_msti;
390 pVlanCfg->envlanpol = vlan4K.envlanpol;
391 pVlanCfg->meteridx = vlan4K.meteridx;
392 pVlanCfg->vbpen = vlan4K.vbpen;
393 pVlanCfg->vbpri = vlan4K.vbpri;
394 }
395 else
396 {
397 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
398 {
399 if(vlan_mbrCfgUsage[idx] == MBRCFG_USED_BY_VLAN)
400 {
401 if(vlan_mbrCfgVid[idx] == vid)
402 {
403 if ((retVal = rtl8367c_getAsicVlanMemberConfig(idx, &vlanMC)) != RT_ERR_OK)
404 return retVal;
405
406 phyMbrPmask = vlanMC.mbr;
407 if(rtk_switch_portmask_P2L_get(phyMbrPmask, &(pVlanCfg->mbr)) != RT_ERR_OK)
408 return RT_ERR_FAILED;
409
410 pVlanCfg->untag.bits[0] = 0;
411 pVlanCfg->ivl_en = 0;
412 pVlanCfg->fid_msti = vlanMC.fid_msti;
413 pVlanCfg->envlanpol = vlanMC.envlanpol;
414 pVlanCfg->meteridx = vlanMC.meteridx;
415 pVlanCfg->vbpen = vlanMC.vbpen;
416 pVlanCfg->vbpri = vlanMC.vbpri;
417 }
418 }
419 }
420 }
421
422 return RT_ERR_OK;
423 }
424
425 /* Function Name:
426 * rtk_vlan_egrFilterEnable_set
427 * Description:
428 * Set VLAN egress filter.
429 * Input:
430 * egrFilter - Egress filtering
431 * Output:
432 * None.
433 * Return:
434 * RT_ERR_OK - OK
435 * RT_ERR_FAILED - Failed
436 * RT_ERR_SMI - SMI access error
437 * RT_ERR_ENABLE - Invalid input parameters.
438 * Note:
439 *
440 */
441 rtk_api_ret_t rtk_vlan_egrFilterEnable_set(rtk_enable_t egrFilter)
442 {
443 rtk_api_ret_t retVal;
444
445 /* Check initialization state */
446 RTK_CHK_INIT_STATE();
447
448 if(egrFilter >= RTK_ENABLE_END)
449 return RT_ERR_ENABLE;
450
451 /* enable VLAN */
452 if ((retVal = rtl8367c_setAsicVlanFilter((rtk_uint32)egrFilter)) != RT_ERR_OK)
453 return retVal;
454
455 return RT_ERR_OK;
456 }
457
458 /* Function Name:
459 * rtk_vlan_egrFilterEnable_get
460 * Description:
461 * Get VLAN egress filter.
462 * Input:
463 * pEgrFilter - Egress filtering
464 * Output:
465 * None.
466 * Return:
467 * RT_ERR_OK - OK
468 * RT_ERR_FAILED - Failed
469 * RT_ERR_SMI - SMI access error
470 * RT_ERR_NULL_POINTER - NULL Pointer.
471 * Note:
472 *
473 */
474 rtk_api_ret_t rtk_vlan_egrFilterEnable_get(rtk_enable_t *pEgrFilter)
475 {
476 rtk_api_ret_t retVal;
477 rtk_uint32 state;
478
479 /* Check initialization state */
480 RTK_CHK_INIT_STATE();
481
482 if(NULL == pEgrFilter)
483 return RT_ERR_NULL_POINTER;
484
485 /* enable VLAN */
486 if ((retVal = rtl8367c_getAsicVlanFilter(&state)) != RT_ERR_OK)
487 return retVal;
488
489 *pEgrFilter = (rtk_enable_t)state;
490 return RT_ERR_OK;
491 }
492
493 /* Function Name:
494 * rtk_vlan_mbrCfg_set
495 * Description:
496 * Set a VLAN Member Configuration entry by index.
497 * Input:
498 * idx - Index of VLAN Member Configuration.
499 * pMbrcfg - VLAN member Configuration.
500 * Output:
501 * None.
502 * Return:
503 * RT_ERR_OK - OK
504 * RT_ERR_FAILED - Failed
505 * RT_ERR_SMI - SMI access error
506 * RT_ERR_INPUT - Invalid input parameters.
507 * RT_ERR_VLAN_VID - Invalid VID parameter.
508 * Note:
509 * Set a VLAN Member Configuration entry by index.
510 */
511 rtk_api_ret_t rtk_vlan_mbrCfg_set(rtk_uint32 idx, rtk_vlan_mbrcfg_t *pMbrcfg)
512 {
513 rtk_api_ret_t retVal;
514 rtk_uint32 phyMbrPmask;
515 rtl8367c_vlanconfiguser mbrCfg;
516
517 /* Check initialization state */
518 RTK_CHK_INIT_STATE();
519
520 /* Error check */
521 if(pMbrcfg == NULL)
522 return RT_ERR_NULL_POINTER;
523
524 if(idx > RTL8367C_CVIDXMAX)
525 return RT_ERR_INPUT;
526
527 if(pMbrcfg->evid > RTL8367C_EVIDMAX)
528 return RT_ERR_INPUT;
529
530 if(pMbrcfg->fid_msti > RTL8367C_FIDMAX)
531 return RT_ERR_L2_FID;
532
533 if(pMbrcfg->envlanpol >= RTK_ENABLE_END)
534 return RT_ERR_ENABLE;
535
536 if(pMbrcfg->meteridx > RTK_MAX_METER_ID)
537 return RT_ERR_FILTER_METER_ID;
538
539 if(pMbrcfg->vbpen >= RTK_ENABLE_END)
540 return RT_ERR_ENABLE;
541
542 if(pMbrcfg->vbpri > RTL8367C_PRIMAX)
543 return RT_ERR_QOS_INT_PRIORITY;
544
545 /* Check port mask valid */
546 RTK_CHK_PORTMASK_VALID(&(pMbrcfg->mbr));
547
548 mbrCfg.evid = pMbrcfg->evid;
549 mbrCfg.fid_msti = pMbrcfg->fid_msti;
550 mbrCfg.envlanpol = pMbrcfg->envlanpol;
551 mbrCfg.meteridx = pMbrcfg->meteridx;
552 mbrCfg.vbpen = pMbrcfg->vbpen;
553 mbrCfg.vbpri = pMbrcfg->vbpri;
554
555 if(rtk_switch_portmask_L2P_get(&(pMbrcfg->mbr), &phyMbrPmask) != RT_ERR_OK)
556 return RT_ERR_FAILED;
557
558 mbrCfg.mbr = phyMbrPmask;
559
560 if ((retVal = rtl8367c_setAsicVlanMemberConfig(idx, &mbrCfg)) != RT_ERR_OK)
561 return retVal;
562
563 /* Update Database */
564 if( (mbrCfg.evid == 0) && (mbrCfg.mbr == 0) )
565 {
566 vlan_mbrCfgUsage[idx] = MBRCFG_UNUSED;
567 vlan_mbrCfgVid[idx] = 0;
568 }
569 else
570 {
571 vlan_mbrCfgUsage[idx] = MBRCFG_USED_BY_VLAN;
572 vlan_mbrCfgVid[idx] = mbrCfg.evid;
573 }
574
575 return RT_ERR_OK;
576
577 }
578
579 /* Function Name:
580 * rtk_vlan_mbrCfg_get
581 * Description:
582 * Get a VLAN Member Configuration entry by index.
583 * Input:
584 * idx - Index of VLAN Member Configuration.
585 * Output:
586 * pMbrcfg - VLAN member Configuration.
587 * Return:
588 * RT_ERR_OK - OK
589 * RT_ERR_FAILED - Failed
590 * RT_ERR_SMI - SMI access error
591 * RT_ERR_INPUT - Invalid input parameters.
592 * RT_ERR_VLAN_VID - Invalid VID parameter.
593 * Note:
594 * Get a VLAN Member Configuration entry by index.
595 */
596 rtk_api_ret_t rtk_vlan_mbrCfg_get(rtk_uint32 idx, rtk_vlan_mbrcfg_t *pMbrcfg)
597 {
598 rtk_api_ret_t retVal;
599 rtk_uint32 phyMbrPmask;
600 rtl8367c_vlanconfiguser mbrCfg;
601
602 /* Check initialization state */
603 RTK_CHK_INIT_STATE();
604
605 /* Error check */
606 if(pMbrcfg == NULL)
607 return RT_ERR_NULL_POINTER;
608
609 if(idx > RTL8367C_CVIDXMAX)
610 return RT_ERR_INPUT;
611
612 memset(&mbrCfg, 0x00, sizeof(rtl8367c_vlanconfiguser));
613 if ((retVal = rtl8367c_getAsicVlanMemberConfig(idx, &mbrCfg)) != RT_ERR_OK)
614 return retVal;
615
616 pMbrcfg->evid = mbrCfg.evid;
617 pMbrcfg->fid_msti = mbrCfg.fid_msti;
618 pMbrcfg->envlanpol = mbrCfg.envlanpol;
619 pMbrcfg->meteridx = mbrCfg.meteridx;
620 pMbrcfg->vbpen = mbrCfg.vbpen;
621 pMbrcfg->vbpri = mbrCfg.vbpri;
622
623 phyMbrPmask = mbrCfg.mbr;
624 if(rtk_switch_portmask_P2L_get(phyMbrPmask, &(pMbrcfg->mbr)) != RT_ERR_OK)
625 return RT_ERR_FAILED;
626
627 return RT_ERR_OK;
628 }
629
630 /* Function Name:
631 * rtk_vlan_portPvid_set
632 * Description:
633 * Set port to specified VLAN ID(PVID).
634 * Input:
635 * port - Port id.
636 * pvid - Specified VLAN ID.
637 * priority - 802.1p priority for the PVID.
638 * Output:
639 * None
640 * Return:
641 * RT_ERR_OK - OK
642 * RT_ERR_FAILED - Failed
643 * RT_ERR_SMI - SMI access error
644 * RT_ERR_PORT_ID - Invalid port number.
645 * RT_ERR_VLAN_PRIORITY - Invalid priority.
646 * RT_ERR_VLAN_ENTRY_NOT_FOUND - VLAN entry not found.
647 * RT_ERR_VLAN_VID - Invalid VID parameter.
648 * Note:
649 * The API is used for Port-based VLAN. The untagged frame received from the
650 * port will be classified to the specified VLAN and assigned to the specified priority.
651 */
652 rtk_api_ret_t rtk_vlan_portPvid_set(rtk_port_t port, rtk_vlan_t pvid, rtk_pri_t priority)
653 {
654 rtk_api_ret_t retVal;
655 rtk_uint32 index;
656
657 /* Check initialization state */
658 RTK_CHK_INIT_STATE();
659
660 /* Check Port Valid */
661 RTK_CHK_PORT_VALID(port);
662
663 /* vid must be 0~8191 */
664 if (pvid > RTL8367C_EVIDMAX)
665 return RT_ERR_VLAN_VID;
666
667 /* priority must be 0~7 */
668 if (priority > RTL8367C_PRIMAX)
669 return RT_ERR_VLAN_PRIORITY;
670
671 if((retVal = rtk_vlan_checkAndCreateMbr(pvid, &index)) != RT_ERR_OK)
672 return retVal;
673
674 if ((retVal = rtl8367c_setAsicVlanPortBasedVID(rtk_switch_port_L2P_get(port), index, priority)) != RT_ERR_OK)
675 return retVal;
676
677 return RT_ERR_OK;
678 }
679
680 /* Function Name:
681 * rtk_vlan_portPvid_get
682 * Description:
683 * Get VLAN ID(PVID) on specified port.
684 * Input:
685 * port - Port id.
686 * Output:
687 * pPvid - Specified VLAN ID.
688 * pPriority - 802.1p priority for the PVID.
689 * Return:
690 * RT_ERR_OK - OK
691 * RT_ERR_FAILED - Failed
692 * RT_ERR_SMI - SMI access error
693 * RT_ERR_INPUT - Invalid input parameters.
694 * RT_ERR_PORT_ID - Invalid port number.
695 * Note:
696 * The API can get the PVID and 802.1p priority for the PVID of Port-based VLAN.
697 */
698 rtk_api_ret_t rtk_vlan_portPvid_get(rtk_port_t port, rtk_vlan_t *pPvid, rtk_pri_t *pPriority)
699 {
700 rtk_api_ret_t retVal;
701 rtk_uint32 index, pri;
702 rtl8367c_vlanconfiguser mbrCfg;
703
704 /* Check initialization state */
705 RTK_CHK_INIT_STATE();
706
707 /* Check Port Valid */
708 RTK_CHK_PORT_VALID(port);
709
710 if(NULL == pPvid)
711 return RT_ERR_NULL_POINTER;
712
713 if(NULL == pPriority)
714 return RT_ERR_NULL_POINTER;
715
716 if ((retVal = rtl8367c_getAsicVlanPortBasedVID(rtk_switch_port_L2P_get(port), &index, &pri)) != RT_ERR_OK)
717 return retVal;
718
719 memset(&mbrCfg, 0x00, sizeof(rtl8367c_vlanconfiguser));
720 if ((retVal = rtl8367c_getAsicVlanMemberConfig(index, &mbrCfg)) != RT_ERR_OK)
721 return retVal;
722
723 *pPvid = mbrCfg.evid;
724 *pPriority = pri;
725
726 return RT_ERR_OK;
727 }
728
729 /* Function Name:
730 * rtk_vlan_portIgrFilterEnable_set
731 * Description:
732 * Set VLAN ingress for each port.
733 * Input:
734 * port - Port id.
735 * igr_filter - VLAN ingress function enable status.
736 * Output:
737 * None
738 * Return:
739 * RT_ERR_OK - OK
740 * RT_ERR_FAILED - Failed
741 * RT_ERR_SMI - SMI access error
742 * RT_ERR_PORT_ID - Invalid port number
743 * RT_ERR_ENABLE - Invalid enable input
744 * Note:
745 * The status of vlan ingress filter is as following:
746 * - DISABLED
747 * - ENABLED
748 * While VLAN function is enabled, ASIC will decide VLAN ID for each received frame and get belonged member
749 * ports from VLAN table. If received port is not belonged to VLAN member ports, ASIC will drop received frame if VLAN ingress function is enabled.
750 */
751 rtk_api_ret_t rtk_vlan_portIgrFilterEnable_set(rtk_port_t port, rtk_enable_t igr_filter)
752 {
753 rtk_api_ret_t retVal;
754
755 /* Check initialization state */
756 RTK_CHK_INIT_STATE();
757
758 /* Check Port Valid */
759 RTK_CHK_PORT_VALID(port);
760
761 if (igr_filter >= RTK_ENABLE_END)
762 return RT_ERR_ENABLE;
763
764 if ((retVal = rtl8367c_setAsicVlanIngressFilter(rtk_switch_port_L2P_get(port), igr_filter)) != RT_ERR_OK)
765 return retVal;
766
767 return RT_ERR_OK;
768 }
769
770 /* Function Name:
771 * rtk_vlan_portIgrFilterEnable_get
772 * Description:
773 * Get VLAN Ingress Filter
774 * Input:
775 * port - Port id.
776 * Output:
777 * pIgr_filter - VLAN ingress function enable status.
778 * Return:
779 * RT_ERR_OK - OK
780 * RT_ERR_FAILED - Failed
781 * RT_ERR_SMI - SMI access error
782 * RT_ERR_INPUT - Invalid input parameters.
783 * RT_ERR_PORT_ID - Invalid port number.
784 * Note:
785 * The API can Get the VLAN ingress filter status.
786 * The status of vlan ingress filter is as following:
787 * - DISABLED
788 * - ENABLED
789 */
790 rtk_api_ret_t rtk_vlan_portIgrFilterEnable_get(rtk_port_t port, rtk_enable_t *pIgr_filter)
791 {
792 rtk_api_ret_t retVal;
793
794 /* Check initialization state */
795 RTK_CHK_INIT_STATE();
796
797 /* Check Port Valid */
798 RTK_CHK_PORT_VALID(port);
799
800 if(NULL == pIgr_filter)
801 return RT_ERR_NULL_POINTER;
802
803 if ((retVal = rtl8367c_getAsicVlanIngressFilter(rtk_switch_port_L2P_get(port), pIgr_filter)) != RT_ERR_OK)
804 return retVal;
805
806 return RT_ERR_OK;
807 }
808
809 /* Function Name:
810 * rtk_vlan_portAcceptFrameType_set
811 * Description:
812 * Set VLAN accept_frame_type
813 * Input:
814 * port - Port id.
815 * accept_frame_type - accept frame type
816 * Output:
817 * None
818 * Return:
819 * RT_ERR_OK - OK
820 * RT_ERR_FAILED - Failed
821 * RT_ERR_SMI - SMI access error
822 * RT_ERR_PORT_ID - Invalid port number.
823 * RT_ERR_VLAN_ACCEPT_FRAME_TYPE - Invalid frame type.
824 * Note:
825 * The API is used for checking 802.1Q tagged frames.
826 * The accept frame type as following:
827 * - ACCEPT_FRAME_TYPE_ALL
828 * - ACCEPT_FRAME_TYPE_TAG_ONLY
829 * - ACCEPT_FRAME_TYPE_UNTAG_ONLY
830 */
831 rtk_api_ret_t rtk_vlan_portAcceptFrameType_set(rtk_port_t port, rtk_vlan_acceptFrameType_t accept_frame_type)
832 {
833 rtk_api_ret_t retVal;
834
835 /* Check initialization state */
836 RTK_CHK_INIT_STATE();
837
838 /* Check Port Valid */
839 RTK_CHK_PORT_VALID(port);
840
841 if (accept_frame_type >= ACCEPT_FRAME_TYPE_END)
842 return RT_ERR_VLAN_ACCEPT_FRAME_TYPE;
843
844 if ((retVal = rtl8367c_setAsicVlanAccpetFrameType(rtk_switch_port_L2P_get(port), (rtl8367c_accframetype)accept_frame_type)) != RT_ERR_OK)
845 return retVal;
846
847 return RT_ERR_OK;
848 }
849
850 /* Function Name:
851 * rtk_vlan_portAcceptFrameType_get
852 * Description:
853 * Get VLAN accept_frame_type
854 * Input:
855 * port - Port id.
856 * Output:
857 * pAccept_frame_type - accept frame type
858 * Return:
859 * RT_ERR_OK - OK
860 * RT_ERR_FAILED - Failed
861 * RT_ERR_SMI - SMI access error
862 * RT_ERR_INPUT - Invalid input parameters.
863 * RT_ERR_PORT_ID - Invalid port number.
864 * Note:
865 * The API can Get the VLAN ingress filter.
866 * The accept frame type as following:
867 * - ACCEPT_FRAME_TYPE_ALL
868 * - ACCEPT_FRAME_TYPE_TAG_ONLY
869 * - ACCEPT_FRAME_TYPE_UNTAG_ONLY
870 */
871 rtk_api_ret_t rtk_vlan_portAcceptFrameType_get(rtk_port_t port, rtk_vlan_acceptFrameType_t *pAccept_frame_type)
872 {
873 rtk_api_ret_t retVal;
874 rtl8367c_accframetype acc_frm_type;
875
876 /* Check initialization state */
877 RTK_CHK_INIT_STATE();
878
879 /* Check Port Valid */
880 RTK_CHK_PORT_VALID(port);
881
882 if(NULL == pAccept_frame_type)
883 return RT_ERR_NULL_POINTER;
884
885 if ((retVal = rtl8367c_getAsicVlanAccpetFrameType(rtk_switch_port_L2P_get(port), &acc_frm_type)) != RT_ERR_OK)
886 return retVal;
887
888 *pAccept_frame_type = (rtk_vlan_acceptFrameType_t)acc_frm_type;
889
890 return RT_ERR_OK;
891 }
892
893 /* Function Name:
894 * rtk_vlan_protoAndPortBasedVlan_add
895 * Description:
896 * Add the protocol-and-port-based vlan to the specified port of device.
897 * Input:
898 * port - Port id.
899 * pInfo - Protocol and port based VLAN configuration information.
900 * Output:
901 * None
902 * Return:
903 * RT_ERR_OK - OK
904 * RT_ERR_FAILED - Failed
905 * RT_ERR_SMI - SMI access error
906 * RT_ERR_PORT_ID - Invalid port number.
907 * RT_ERR_VLAN_VID - Invalid VID parameter.
908 * RT_ERR_VLAN_PRIORITY - Invalid priority.
909 * RT_ERR_TBL_FULL - Table is full.
910 * RT_ERR_OUT_OF_RANGE - input out of range.
911 * Note:
912 * The incoming packet which match the protocol-and-port-based vlan will use the configure vid for ingress pipeline
913 * The frame type is shown in the following:
914 * - FRAME_TYPE_ETHERNET
915 * - FRAME_TYPE_RFC1042
916 * - FRAME_TYPE_LLCOTHER
917 */
918 rtk_api_ret_t rtk_vlan_protoAndPortBasedVlan_add(rtk_port_t port, rtk_vlan_protoAndPortInfo_t *pInfo)
919 {
920 rtk_api_ret_t retVal, i;
921 rtk_uint32 exist, empty, used, index;
922 rtl8367c_protocolgdatacfg ppb_data_cfg;
923 rtl8367c_protocolvlancfg ppb_vlan_cfg;
924 rtl8367c_provlan_frametype tmp;
925
926 /* Check initialization state */
927 RTK_CHK_INIT_STATE();
928
929 /* Check Port Valid */
930 RTK_CHK_PORT_VALID(port);
931
932 if(NULL == pInfo)
933 return RT_ERR_NULL_POINTER;
934
935 if (pInfo->proto_type > RTK_MAX_NUM_OF_PROTO_TYPE)
936 return RT_ERR_OUT_OF_RANGE;
937
938 if (pInfo->frame_type >= FRAME_TYPE_END)
939 return RT_ERR_OUT_OF_RANGE;
940
941 if (pInfo->cvid > RTL8367C_VIDMAX)
942 return RT_ERR_VLAN_VID;
943
944 if (pInfo->cpri > RTL8367C_PRIMAX)
945 return RT_ERR_VLAN_PRIORITY;
946
947 exist = 0xFF;
948 empty = 0xFF;
949 for (i = RTL8367C_PROTOVLAN_GIDX_MAX; i >= 0; i--)
950 {
951 if ((retVal = rtl8367c_getAsicVlanProtocolBasedGroupData(i, &ppb_data_cfg)) != RT_ERR_OK)
952 return retVal;
953 tmp = pInfo->frame_type;
954 if (ppb_data_cfg.etherType == pInfo->proto_type && ppb_data_cfg.frameType == tmp)
955 {
956 /*Already exist*/
957 exist = i;
958 break;
959 }
960 else if (ppb_data_cfg.etherType == 0 && ppb_data_cfg.frameType == 0)
961 {
962 /*find empty index*/
963 empty = i;
964 }
965 }
966
967 used = 0xFF;
968 /*No empty and exist index*/
969 if (0xFF == exist && 0xFF == empty)
970 return RT_ERR_TBL_FULL;
971 else if (exist<RTL8367C_PROTOVLAN_GROUPNO)
972 {
973 /*exist index*/
974 used = exist;
975 }
976 else if (empty<RTL8367C_PROTOVLAN_GROUPNO)
977 {
978 /*No exist index, but have empty index*/
979 ppb_data_cfg.frameType = pInfo->frame_type;
980 ppb_data_cfg.etherType = pInfo->proto_type;
981 if ((retVal = rtl8367c_setAsicVlanProtocolBasedGroupData(empty, &ppb_data_cfg)) != RT_ERR_OK)
982 return retVal;
983 used = empty;
984 }
985 else
986 return RT_ERR_FAILED;
987
988 if((retVal = rtk_vlan_checkAndCreateMbr(pInfo->cvid, &index)) != RT_ERR_OK)
989 return retVal;
990
991 ppb_vlan_cfg.vlan_idx = index;
992 ppb_vlan_cfg.valid = TRUE;
993 ppb_vlan_cfg.priority = pInfo->cpri;
994 if ((retVal = rtl8367c_setAsicVlanPortAndProtocolBased(rtk_switch_port_L2P_get(port), used, &ppb_vlan_cfg)) != RT_ERR_OK)
995 return retVal;
996
997 return RT_ERR_OK;
998 }
999
1000 /* Function Name:
1001 * rtk_vlan_protoAndPortBasedVlan_get
1002 * Description:
1003 * Get the protocol-and-port-based vlan to the specified port of device.
1004 * Input:
1005 * port - Port id.
1006 * proto_type - protocol-and-port-based vlan protocol type.
1007 * frame_type - protocol-and-port-based vlan frame type.
1008 * Output:
1009 * pInfo - Protocol and port based VLAN configuration information.
1010 * Return:
1011 * RT_ERR_OK - OK
1012 * RT_ERR_FAILED - Failed
1013 * RT_ERR_SMI - SMI access error
1014 * RT_ERR_PORT_ID - Invalid port number.
1015 * RT_ERR_OUT_OF_RANGE - input out of range.
1016 * RT_ERR_TBL_FULL - Table is full.
1017 * Note:
1018 * The incoming packet which match the protocol-and-port-based vlan will use the configure vid for ingress pipeline
1019 * The frame type is shown in the following:
1020 * - FRAME_TYPE_ETHERNET
1021 * - FRAME_TYPE_RFC1042
1022 * - FRAME_TYPE_LLCOTHER
1023 */
1024 rtk_api_ret_t rtk_vlan_protoAndPortBasedVlan_get(rtk_port_t port, rtk_vlan_proto_type_t proto_type, rtk_vlan_protoVlan_frameType_t frame_type, rtk_vlan_protoAndPortInfo_t *pInfo)
1025 {
1026 rtk_api_ret_t retVal;
1027 rtk_uint32 i;
1028 rtk_uint32 ppb_idx;
1029 rtl8367c_protocolgdatacfg ppb_data_cfg;
1030 rtl8367c_protocolvlancfg ppb_vlan_cfg;
1031
1032 /* Check initialization state */
1033 RTK_CHK_INIT_STATE();
1034
1035 /* Check Port Valid */
1036 RTK_CHK_PORT_VALID(port);
1037
1038 if (proto_type > RTK_MAX_NUM_OF_PROTO_TYPE)
1039 return RT_ERR_OUT_OF_RANGE;
1040
1041 if (frame_type >= FRAME_TYPE_END)
1042 return RT_ERR_OUT_OF_RANGE;
1043
1044 ppb_idx = 0;
1045
1046 for (i = 0; i<= RTL8367C_PROTOVLAN_GIDX_MAX; i++)
1047 {
1048 if ((retVal = rtl8367c_getAsicVlanProtocolBasedGroupData(i, &ppb_data_cfg)) != RT_ERR_OK)
1049 return retVal;
1050
1051 if ( (ppb_data_cfg.frameType == (rtl8367c_provlan_frametype)frame_type) && (ppb_data_cfg.etherType == proto_type) )
1052 {
1053 ppb_idx = i;
1054 break;
1055 }
1056 else if (RTL8367C_PROTOVLAN_GIDX_MAX == i)
1057 return RT_ERR_TBL_FULL;
1058 }
1059
1060 if ((retVal = rtl8367c_getAsicVlanPortAndProtocolBased(rtk_switch_port_L2P_get(port), ppb_idx, &ppb_vlan_cfg)) != RT_ERR_OK)
1061 return retVal;
1062
1063 if (FALSE == ppb_vlan_cfg.valid)
1064 return RT_ERR_FAILED;
1065
1066 pInfo->frame_type = frame_type;
1067 pInfo->proto_type = proto_type;
1068 pInfo->cvid = vlan_mbrCfgVid[ppb_vlan_cfg.vlan_idx];
1069 pInfo->cpri = ppb_vlan_cfg.priority;
1070
1071 return RT_ERR_OK;
1072 }
1073
1074 /* Function Name:
1075 * rtk_vlan_protoAndPortBasedVlan_del
1076 * Description:
1077 * Delete the protocol-and-port-based vlan from the specified port of device.
1078 * Input:
1079 * port - Port id.
1080 * proto_type - protocol-and-port-based vlan protocol type.
1081 * frame_type - protocol-and-port-based vlan frame type.
1082 * Output:
1083 * None
1084 * Return:
1085 * RT_ERR_OK - OK
1086 * RT_ERR_FAILED - Failed
1087 * RT_ERR_SMI - SMI access error
1088 * RT_ERR_PORT_ID - Invalid port number.
1089 * RT_ERR_OUT_OF_RANGE - input out of range.
1090 * RT_ERR_TBL_FULL - Table is full.
1091 * Note:
1092 * The incoming packet which match the protocol-and-port-based vlan will use the configure vid for ingress pipeline
1093 * The frame type is shown in the following:
1094 * - FRAME_TYPE_ETHERNET
1095 * - FRAME_TYPE_RFC1042
1096 * - FRAME_TYPE_LLCOTHER
1097 */
1098 rtk_api_ret_t rtk_vlan_protoAndPortBasedVlan_del(rtk_port_t port, rtk_vlan_proto_type_t proto_type, rtk_vlan_protoVlan_frameType_t frame_type)
1099 {
1100 rtk_api_ret_t retVal;
1101 rtk_uint32 i, bUsed;
1102 rtk_uint32 ppb_idx;
1103 rtl8367c_protocolgdatacfg ppb_data_cfg;
1104 rtl8367c_protocolvlancfg ppb_vlan_cfg;
1105
1106 /* Check initialization state */
1107 RTK_CHK_INIT_STATE();
1108
1109 /* Check Port Valid */
1110 RTK_CHK_PORT_VALID(port);
1111
1112 if (proto_type > RTK_MAX_NUM_OF_PROTO_TYPE)
1113 return RT_ERR_OUT_OF_RANGE;
1114
1115 if (frame_type >= FRAME_TYPE_END)
1116 return RT_ERR_OUT_OF_RANGE;
1117
1118 ppb_idx = 0;
1119
1120 for (i = 0; i<= RTL8367C_PROTOVLAN_GIDX_MAX; i++)
1121 {
1122 if ((retVal = rtl8367c_getAsicVlanProtocolBasedGroupData(i, &ppb_data_cfg)) != RT_ERR_OK)
1123 return retVal;
1124
1125 if ( (ppb_data_cfg.frameType == (rtl8367c_provlan_frametype)frame_type) && (ppb_data_cfg.etherType == proto_type) )
1126 {
1127 ppb_idx = i;
1128 ppb_vlan_cfg.valid = FALSE;
1129 ppb_vlan_cfg.vlan_idx = 0;
1130 ppb_vlan_cfg.priority = 0;
1131 if ((retVal = rtl8367c_setAsicVlanPortAndProtocolBased(rtk_switch_port_L2P_get(port), ppb_idx, &ppb_vlan_cfg)) != RT_ERR_OK)
1132 return retVal;
1133 }
1134 }
1135
1136 bUsed = FALSE;
1137 RTK_SCAN_ALL_PHY_PORTMASK(i)
1138 {
1139 if ((retVal = rtl8367c_getAsicVlanPortAndProtocolBased(i, ppb_idx, &ppb_vlan_cfg)) != RT_ERR_OK)
1140 return retVal;
1141
1142 if (TRUE == ppb_vlan_cfg.valid)
1143 {
1144 bUsed = TRUE;
1145 break;
1146 }
1147 }
1148
1149 if (FALSE == bUsed) /*No Port use this PPB Index, Delete it*/
1150 {
1151 ppb_data_cfg.etherType=0;
1152 ppb_data_cfg.frameType=0;
1153 if ((retVal = rtl8367c_setAsicVlanProtocolBasedGroupData(ppb_idx, &ppb_data_cfg)) != RT_ERR_OK)
1154 return retVal;
1155 }
1156
1157 return RT_ERR_OK;
1158 }
1159
1160 /* Function Name:
1161 * rtk_vlan_protoAndPortBasedVlan_delAll
1162 * Description:
1163 * Delete all protocol-and-port-based vlans from the specified port of device.
1164 * Input:
1165 * port - Port id.
1166 * Output:
1167 * None
1168 * Return:
1169 * RT_ERR_OK - OK
1170 * RT_ERR_FAILED - Failed
1171 * RT_ERR_SMI - SMI access error
1172 * RT_ERR_PORT_ID - Invalid port number.
1173 * RT_ERR_OUT_OF_RANGE - input out of range.
1174 * Note:
1175 * The incoming packet which match the protocol-and-port-based vlan will use the configure vid for ingress pipeline
1176 * Delete all flow table protocol-and-port-based vlan entries.
1177 */
1178 rtk_api_ret_t rtk_vlan_protoAndPortBasedVlan_delAll(rtk_port_t port)
1179 {
1180 rtk_api_ret_t retVal;
1181 rtk_uint32 i, j, bUsed[4];
1182 rtl8367c_protocolgdatacfg ppb_data_cfg;
1183 rtl8367c_protocolvlancfg ppb_vlan_cfg;
1184
1185 /* Check initialization state */
1186 RTK_CHK_INIT_STATE();
1187
1188 /* Check Port Valid */
1189 RTK_CHK_PORT_VALID(port);
1190
1191 for (i = 0; i<= RTL8367C_PROTOVLAN_GIDX_MAX; i++)
1192 {
1193 ppb_vlan_cfg.valid = FALSE;
1194 ppb_vlan_cfg.vlan_idx = 0;
1195 ppb_vlan_cfg.priority = 0;
1196 if ((retVal = rtl8367c_setAsicVlanPortAndProtocolBased(rtk_switch_port_L2P_get(port), i, &ppb_vlan_cfg)) != RT_ERR_OK)
1197 return retVal;
1198 }
1199
1200 bUsed[0] = FALSE;
1201 bUsed[1] = FALSE;
1202 bUsed[2] = FALSE;
1203 bUsed[3] = FALSE;
1204 RTK_SCAN_ALL_PHY_PORTMASK(i)
1205 {
1206 for (j = 0; j <= RTL8367C_PROTOVLAN_GIDX_MAX; j++)
1207 {
1208 if ((retVal = rtl8367c_getAsicVlanPortAndProtocolBased(i,j, &ppb_vlan_cfg)) != RT_ERR_OK)
1209 return retVal;
1210
1211 if (TRUE == ppb_vlan_cfg.valid)
1212 {
1213 bUsed[j] = TRUE;
1214 }
1215 }
1216 }
1217
1218 for (i = 0; i<= RTL8367C_PROTOVLAN_GIDX_MAX; i++)
1219 {
1220 if (FALSE == bUsed[i]) /*No Port use this PPB Index, Delete it*/
1221 {
1222 ppb_data_cfg.etherType=0;
1223 ppb_data_cfg.frameType=0;
1224 if ((retVal = rtl8367c_setAsicVlanProtocolBasedGroupData(i, &ppb_data_cfg)) != RT_ERR_OK)
1225 return retVal;
1226 }
1227 }
1228
1229
1230
1231 return RT_ERR_OK;
1232 }
1233
1234 /* Function Name:
1235 * rtk_vlan_tagMode_set
1236 * Description:
1237 * Set CVLAN egress tag mode
1238 * Input:
1239 * port - Port id.
1240 * tag_mode - The egress tag mode.
1241 * Output:
1242 * None
1243 * Return:
1244 * RT_ERR_OK - OK
1245 * RT_ERR_FAILED - Failed
1246 * RT_ERR_SMI - SMI access error
1247 * RT_ERR_PORT_ID - Invalid port number.
1248 * RT_ERR_INPUT - Invalid input parameter.
1249 * RT_ERR_ENABLE - Invalid enable input.
1250 * Note:
1251 * The API can set Egress tag mode. There are 4 mode for egress tag:
1252 * - VLAN_TAG_MODE_ORIGINAL,
1253 * - VLAN_TAG_MODE_KEEP_FORMAT,
1254 * - VLAN_TAG_MODE_PRI.
1255 * - VLAN_TAG_MODE_REAL_KEEP_FORMAT,
1256 */
1257 rtk_api_ret_t rtk_vlan_tagMode_set(rtk_port_t port, rtk_vlan_tagMode_t tag_mode)
1258 {
1259 rtk_api_ret_t retVal;
1260
1261 /* Check initialization state */
1262 RTK_CHK_INIT_STATE();
1263
1264 /* Check Port Valid */
1265 RTK_CHK_PORT_VALID(port);
1266
1267 if (tag_mode >= VLAN_TAG_MODE_END)
1268 return RT_ERR_PORT_ID;
1269
1270 if ((retVal = rtl8367c_setAsicVlanEgressTagMode(rtk_switch_port_L2P_get(port), tag_mode)) != RT_ERR_OK)
1271 return retVal;
1272
1273 return RT_ERR_OK;
1274 }
1275
1276 /* Function Name:
1277 * rtk_vlan_tagMode_get
1278 * Description:
1279 * Get CVLAN egress tag mode
1280 * Input:
1281 * port - Port id.
1282 * Output:
1283 * pTag_mode - The egress tag mode.
1284 * Return:
1285 * RT_ERR_OK - OK
1286 * RT_ERR_FAILED - Failed
1287 * RT_ERR_SMI - SMI access error
1288 * RT_ERR_INPUT - Invalid input parameters.
1289 * RT_ERR_PORT_ID - Invalid port number.
1290 * Note:
1291 * The API can get Egress tag mode. There are 4 mode for egress tag:
1292 * - VLAN_TAG_MODE_ORIGINAL,
1293 * - VLAN_TAG_MODE_KEEP_FORMAT,
1294 * - VLAN_TAG_MODE_PRI.
1295 * - VLAN_TAG_MODE_REAL_KEEP_FORMAT,
1296 */
1297 rtk_api_ret_t rtk_vlan_tagMode_get(rtk_port_t port, rtk_vlan_tagMode_t *pTag_mode)
1298 {
1299 rtk_api_ret_t retVal;
1300 rtl8367c_egtagmode mode;
1301
1302 /* Check initialization state */
1303 RTK_CHK_INIT_STATE();
1304
1305 /* Check Port Valid */
1306 RTK_CHK_PORT_VALID(port);
1307
1308 if(NULL == pTag_mode)
1309 return RT_ERR_NULL_POINTER;
1310
1311 if ((retVal = rtl8367c_getAsicVlanEgressTagMode(rtk_switch_port_L2P_get(port), &mode)) != RT_ERR_OK)
1312 return retVal;
1313
1314 *pTag_mode = (rtk_vlan_tagMode_t)mode;
1315 return RT_ERR_OK;
1316 }
1317
1318 /* Function Name:
1319 * rtk_vlan_transparent_set
1320 * Description:
1321 * Set VLAN transparent mode
1322 * Input:
1323 * egr_port - Egress Port id.
1324 * pIgr_pmask - Ingress Port Mask.
1325 * Output:
1326 * None.
1327 * Return:
1328 * RT_ERR_OK - OK
1329 * RT_ERR_FAILED - Failed
1330 * RT_ERR_SMI - SMI access error
1331 * RT_ERR_INPUT - Invalid input parameters.
1332 * RT_ERR_PORT_ID - Invalid port number.
1333 * Note:
1334 * None.
1335 */
1336 rtk_api_ret_t rtk_vlan_transparent_set(rtk_port_t egr_port, rtk_portmask_t *pIgr_pmask)
1337 {
1338 rtk_api_ret_t retVal;
1339 rtk_uint32 pmask;
1340
1341 /* Check initialization state */
1342 RTK_CHK_INIT_STATE();
1343
1344 /* Check Port Valid */
1345 RTK_CHK_PORT_VALID(egr_port);
1346
1347 if(NULL == pIgr_pmask)
1348 return RT_ERR_NULL_POINTER;
1349
1350 RTK_CHK_PORTMASK_VALID(pIgr_pmask);
1351
1352 if(rtk_switch_portmask_L2P_get(pIgr_pmask, &pmask) != RT_ERR_OK)
1353 return RT_ERR_FAILED;
1354
1355 if ((retVal = rtl8367c_setAsicVlanTransparent(rtk_switch_port_L2P_get(egr_port), pmask)) != RT_ERR_OK)
1356 return retVal;
1357
1358 return RT_ERR_OK;
1359 }
1360
1361 /* Function Name:
1362 * rtk_vlan_transparent_get
1363 * Description:
1364 * Get VLAN transparent mode
1365 * Input:
1366 * egr_port - Egress Port id.
1367 * Output:
1368 * pIgr_pmask - Ingress Port Mask
1369 * Return:
1370 * RT_ERR_OK - OK
1371 * RT_ERR_FAILED - Failed
1372 * RT_ERR_SMI - SMI access error
1373 * RT_ERR_INPUT - Invalid input parameters.
1374 * RT_ERR_PORT_ID - Invalid port number.
1375 * Note:
1376 * None.
1377 */
1378 rtk_api_ret_t rtk_vlan_transparent_get(rtk_port_t egr_port, rtk_portmask_t *pIgr_pmask)
1379 {
1380 rtk_api_ret_t retVal;
1381 rtk_uint32 pmask;
1382
1383 /* Check initialization state */
1384 RTK_CHK_INIT_STATE();
1385
1386 /* Check Port Valid */
1387 RTK_CHK_PORT_VALID(egr_port);
1388
1389 if(NULL == pIgr_pmask)
1390 return RT_ERR_NULL_POINTER;
1391
1392 if ((retVal = rtl8367c_getAsicVlanTransparent(rtk_switch_port_L2P_get(egr_port), &pmask)) != RT_ERR_OK)
1393 return retVal;
1394
1395 if(rtk_switch_portmask_P2L_get(pmask, pIgr_pmask) != RT_ERR_OK)
1396 return RT_ERR_FAILED;
1397
1398 return RT_ERR_OK;
1399 }
1400
1401 /* Function Name:
1402 * rtk_vlan_keep_set
1403 * Description:
1404 * Set VLAN egress keep mode
1405 * Input:
1406 * egr_port - Egress Port id.
1407 * pIgr_pmask - Ingress Port Mask.
1408 * Output:
1409 * None.
1410 * Return:
1411 * RT_ERR_OK - OK
1412 * RT_ERR_FAILED - Failed
1413 * RT_ERR_SMI - SMI access error
1414 * RT_ERR_INPUT - Invalid input parameters.
1415 * RT_ERR_PORT_ID - Invalid port number.
1416 * Note:
1417 * None.
1418 */
1419 rtk_api_ret_t rtk_vlan_keep_set(rtk_port_t egr_port, rtk_portmask_t *pIgr_pmask)
1420 {
1421 rtk_api_ret_t retVal;
1422 rtk_uint32 pmask;
1423
1424 /* Check initialization state */
1425 RTK_CHK_INIT_STATE();
1426
1427 /* Check Port Valid */
1428 RTK_CHK_PORT_VALID(egr_port);
1429
1430 if(NULL == pIgr_pmask)
1431 return RT_ERR_NULL_POINTER;
1432
1433 RTK_CHK_PORTMASK_VALID(pIgr_pmask);
1434
1435 if(rtk_switch_portmask_L2P_get(pIgr_pmask, &pmask) != RT_ERR_OK)
1436 return RT_ERR_FAILED;
1437
1438 if ((retVal = rtl8367c_setAsicVlanEgressKeep(rtk_switch_port_L2P_get(egr_port), pmask)) != RT_ERR_OK)
1439 return retVal;
1440
1441 return RT_ERR_OK;
1442 }
1443
1444 /* Function Name:
1445 * rtk_vlan_keep_get
1446 * Description:
1447 * Get VLAN egress keep mode
1448 * Input:
1449 * egr_port - Egress Port id.
1450 * Output:
1451 * pIgr_pmask - Ingress Port Mask
1452 * Return:
1453 * RT_ERR_OK - OK
1454 * RT_ERR_FAILED - Failed
1455 * RT_ERR_SMI - SMI access error
1456 * RT_ERR_INPUT - Invalid input parameters.
1457 * RT_ERR_PORT_ID - Invalid port number.
1458 * Note:
1459 * None.
1460 */
1461 rtk_api_ret_t rtk_vlan_keep_get(rtk_port_t egr_port, rtk_portmask_t *pIgr_pmask)
1462 {
1463 rtk_api_ret_t retVal;
1464 rtk_uint32 pmask;
1465
1466 /* Check initialization state */
1467 RTK_CHK_INIT_STATE();
1468
1469 /* Check Port Valid */
1470 RTK_CHK_PORT_VALID(egr_port);
1471
1472 if(NULL == pIgr_pmask)
1473 return RT_ERR_NULL_POINTER;
1474
1475 if ((retVal = rtl8367c_getAsicVlanEgressKeep(rtk_switch_port_L2P_get(egr_port), &pmask)) != RT_ERR_OK)
1476 return retVal;
1477
1478 if(rtk_switch_portmask_P2L_get(pmask, pIgr_pmask) != RT_ERR_OK)
1479 return RT_ERR_FAILED;
1480
1481 return RT_ERR_OK;
1482 }
1483
1484 /* Function Name:
1485 * rtk_vlan_stg_set
1486 * Description:
1487 * Set spanning tree group instance of the vlan to the specified device
1488 * Input:
1489 * vid - Specified VLAN ID.
1490 * stg - spanning tree group instance.
1491 * Output:
1492 * None
1493 * Return:
1494 * RT_ERR_OK - OK
1495 * RT_ERR_FAILED - Failed
1496 * RT_ERR_SMI - SMI access error
1497 * RT_ERR_MSTI - Invalid msti parameter
1498 * RT_ERR_INPUT - Invalid input parameter.
1499 * RT_ERR_VLAN_VID - Invalid VID parameter.
1500 * Note:
1501 * The API can set spanning tree group instance of the vlan to the specified device.
1502 */
1503 rtk_api_ret_t rtk_vlan_stg_set(rtk_vlan_t vid, rtk_stp_msti_id_t stg)
1504 {
1505 rtk_api_ret_t retVal;
1506 rtl8367c_user_vlan4kentry vlan4K;
1507
1508 /* Check initialization state */
1509 RTK_CHK_INIT_STATE();
1510
1511 /* vid must be 0~4095 */
1512 if (vid > RTL8367C_VIDMAX)
1513 return RT_ERR_VLAN_VID;
1514
1515 /* priority must be 0~15 */
1516 if (stg > RTL8367C_MSTIMAX)
1517 return RT_ERR_MSTI;
1518
1519 /* update 4K table */
1520 vlan4K.vid = vid;
1521 if ((retVal = rtl8367c_getAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
1522 return retVal;
1523
1524 vlan4K.fid_msti= stg;
1525 if ((retVal = rtl8367c_setAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
1526 return retVal;
1527
1528 return RT_ERR_OK;
1529 }
1530
1531 /* Function Name:
1532 * rtk_vlan_stg_get
1533 * Description:
1534 * Get spanning tree group instance of the vlan to the specified device
1535 * Input:
1536 * vid - Specified VLAN ID.
1537 * Output:
1538 * pStg - spanning tree group instance.
1539 * Return:
1540 * RT_ERR_OK - OK
1541 * RT_ERR_FAILED - Failed
1542 * RT_ERR_SMI - SMI access error
1543 * RT_ERR_INPUT - Invalid input parameters.
1544 * RT_ERR_VLAN_VID - Invalid VID parameter.
1545 * Note:
1546 * The API can get spanning tree group instance of the vlan to the specified device.
1547 */
1548 rtk_api_ret_t rtk_vlan_stg_get(rtk_vlan_t vid, rtk_stp_msti_id_t *pStg)
1549 {
1550 rtk_api_ret_t retVal;
1551 rtl8367c_user_vlan4kentry vlan4K;
1552
1553 /* Check initialization state */
1554 RTK_CHK_INIT_STATE();
1555
1556 /* vid must be 0~4095 */
1557 if (vid > RTL8367C_VIDMAX)
1558 return RT_ERR_VLAN_VID;
1559
1560 if(NULL == pStg)
1561 return RT_ERR_NULL_POINTER;
1562
1563 /* update 4K table */
1564 vlan4K.vid = vid;
1565 if ((retVal = rtl8367c_getAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
1566 return retVal;
1567
1568 *pStg = vlan4K.fid_msti;
1569
1570 return RT_ERR_OK;
1571 }
1572
1573 /* Function Name:
1574 * rtk_vlan_portFid_set
1575 * Description:
1576 * Set port-based filtering database
1577 * Input:
1578 * port - Port id.
1579 * enable - ebable port-based FID
1580 * fid - Specified filtering database.
1581 * Output:
1582 * None
1583 * Return:
1584 * RT_ERR_OK - OK
1585 * RT_ERR_FAILED - Failed
1586 * RT_ERR_SMI - SMI access error
1587 * RT_ERR_L2_FID - Invalid fid.
1588 * RT_ERR_INPUT - Invalid input parameter.
1589 * RT_ERR_PORT_ID - Invalid port ID.
1590 * Note:
1591 * The API can set port-based filtering database. If the function is enabled, all input
1592 * packets will be assigned to the port-based fid regardless vlan tag.
1593 */
1594 rtk_api_ret_t rtk_vlan_portFid_set(rtk_port_t port, rtk_enable_t enable, rtk_fid_t fid)
1595 {
1596 rtk_api_ret_t retVal;
1597
1598 /* Check initialization state */
1599 RTK_CHK_INIT_STATE();
1600
1601 /* Check Port Valid */
1602 RTK_CHK_PORT_VALID(port);
1603
1604 if (enable>=RTK_ENABLE_END)
1605 return RT_ERR_ENABLE;
1606
1607 /* fid must be 0~4095 */
1608 if (fid > RTK_FID_MAX)
1609 return RT_ERR_L2_FID;
1610
1611 if ((retVal = rtl8367c_setAsicPortBasedFidEn(rtk_switch_port_L2P_get(port), enable))!=RT_ERR_OK)
1612 return retVal;
1613
1614 if ((retVal = rtl8367c_setAsicPortBasedFid(rtk_switch_port_L2P_get(port), fid))!=RT_ERR_OK)
1615 return retVal;
1616
1617 return RT_ERR_OK;
1618 }
1619
1620 /* Function Name:
1621 * rtk_vlan_portFid_get
1622 * Description:
1623 * Get port-based filtering database
1624 * Input:
1625 * port - Port id.
1626 * Output:
1627 * pEnable - ebable port-based FID
1628 * pFid - Specified filtering database.
1629 * Return:
1630 * RT_ERR_OK - OK
1631 * RT_ERR_FAILED - Failed
1632 * RT_ERR_SMI - SMI access error
1633 * RT_ERR_INPUT - Invalid input parameters.
1634 * RT_ERR_PORT_ID - Invalid port ID.
1635 * Note:
1636 * The API can get port-based filtering database status. If the function is enabled, all input
1637 * packets will be assigned to the port-based fid regardless vlan tag.
1638 */
1639 rtk_api_ret_t rtk_vlan_portFid_get(rtk_port_t port, rtk_enable_t *pEnable, rtk_fid_t *pFid)
1640 {
1641 rtk_api_ret_t retVal;
1642
1643 /* Check initialization state */
1644 RTK_CHK_INIT_STATE();
1645
1646 /* Check Port Valid */
1647 RTK_CHK_PORT_VALID(port);
1648
1649 if(NULL == pEnable)
1650 return RT_ERR_NULL_POINTER;
1651
1652 if(NULL == pFid)
1653 return RT_ERR_NULL_POINTER;
1654
1655 if ((retVal = rtl8367c_getAsicPortBasedFidEn(rtk_switch_port_L2P_get(port), pEnable))!=RT_ERR_OK)
1656 return retVal;
1657
1658 if ((retVal = rtl8367c_getAsicPortBasedFid(rtk_switch_port_L2P_get(port), pFid))!=RT_ERR_OK)
1659 return retVal;
1660
1661 return RT_ERR_OK;
1662 }
1663
1664 /* Function Name:
1665 * rtk_vlan_UntagDscpPriorityEnable_set
1666 * Description:
1667 * Set Untag DSCP priority assign
1668 * Input:
1669 * enable - state of Untag DSCP priority assign
1670 * Output:
1671 * None
1672 * Return:
1673 * RT_ERR_OK - OK
1674 * RT_ERR_FAILED - Failed
1675 * RT_ERR_SMI - SMI access error
1676 * RT_ERR_ENABLE - Invalid input parameters.
1677 * Note:
1678 *
1679 */
1680 rtk_api_ret_t rtk_vlan_UntagDscpPriorityEnable_set(rtk_enable_t enable)
1681 {
1682 rtk_api_ret_t retVal;
1683
1684 /* Check initialization state */
1685 RTK_CHK_INIT_STATE();
1686
1687 if(enable >= RTK_ENABLE_END)
1688 return RT_ERR_ENABLE;
1689
1690 if ((retVal = rtl8367c_setAsicVlanUntagDscpPriorityEn((rtk_uint32)enable)) != RT_ERR_OK)
1691 return retVal;
1692
1693 return RT_ERR_OK;
1694 }
1695
1696 /* Function Name:
1697 * rtk_vlan_UntagDscpPriorityEnable_get
1698 * Description:
1699 * Get Untag DSCP priority assign
1700 * Input:
1701 * None
1702 * Output:
1703 * pEnable - state of Untag DSCP priority assign
1704 * Return:
1705 * RT_ERR_OK - OK
1706 * RT_ERR_FAILED - Failed
1707 * RT_ERR_SMI - SMI access error
1708 * RT_ERR_NULL_POINTER - Null pointer
1709 * Note:
1710 *
1711 */
1712 rtk_api_ret_t rtk_vlan_UntagDscpPriorityEnable_get(rtk_enable_t *pEnable)
1713 {
1714 rtk_api_ret_t retVal;
1715 rtk_uint32 value;
1716
1717 /* Check initialization state */
1718 RTK_CHK_INIT_STATE();
1719
1720 if(NULL == pEnable)
1721 return RT_ERR_NULL_POINTER;
1722
1723 if ((retVal = rtl8367c_getAsicVlanUntagDscpPriorityEn(&value)) != RT_ERR_OK)
1724 return retVal;
1725
1726 *pEnable = (rtk_enable_t)value;
1727 return RT_ERR_OK;
1728 }
1729
1730 /* Function Name:
1731 * rtk_stp_mstpState_set
1732 * Description:
1733 * Configure spanning tree state per each port.
1734 * Input:
1735 * port - Port id
1736 * msti - Multiple spanning tree instance.
1737 * stp_state - Spanning tree state for msti
1738 * Output:
1739 * None
1740 * Return:
1741 * RT_ERR_OK - OK
1742 * RT_ERR_FAILED - Failed
1743 * RT_ERR_SMI - SMI access error
1744 * RT_ERR_PORT_ID - Invalid port number.
1745 * RT_ERR_MSTI - Invalid msti parameter.
1746 * RT_ERR_MSTP_STATE - Invalid STP state.
1747 * Note:
1748 * System supports per-port multiple spanning tree state for each msti.
1749 * There are four states supported by ASIC.
1750 * - STP_STATE_DISABLED
1751 * - STP_STATE_BLOCKING
1752 * - STP_STATE_LEARNING
1753 * - STP_STATE_FORWARDING
1754 */
1755 rtk_api_ret_t rtk_stp_mstpState_set(rtk_stp_msti_id_t msti, rtk_port_t port, rtk_stp_state_t stp_state)
1756 {
1757 rtk_api_ret_t retVal;
1758
1759 /* Check initialization state */
1760 RTK_CHK_INIT_STATE();
1761
1762 /* Check Port Valid */
1763 RTK_CHK_PORT_VALID(port);
1764
1765 if (msti > RTK_MAX_NUM_OF_MSTI)
1766 return RT_ERR_MSTI;
1767
1768 if (stp_state >= STP_STATE_END)
1769 return RT_ERR_MSTP_STATE;
1770
1771 if ((retVal = rtl8367c_setAsicSpanningTreeStatus(rtk_switch_port_L2P_get(port), msti, stp_state)) != RT_ERR_OK)
1772 return retVal;
1773
1774 return RT_ERR_OK;
1775 }
1776
1777 /* Function Name:
1778 * rtk_stp_mstpState_get
1779 * Description:
1780 * Get spanning tree state per each port.
1781 * Input:
1782 * port - Port id.
1783 * msti - Multiple spanning tree instance.
1784 * Output:
1785 * pStp_state - Spanning tree state for msti
1786 * Return:
1787 * RT_ERR_OK - OK
1788 * RT_ERR_FAILED - Failed
1789 * RT_ERR_SMI - SMI access error
1790 * RT_ERR_PORT_ID - Invalid port number.
1791 * RT_ERR_MSTI - Invalid msti parameter.
1792 * Note:
1793 * System supports per-port multiple spanning tree state for each msti.
1794 * There are four states supported by ASIC.
1795 * - STP_STATE_DISABLED
1796 * - STP_STATE_BLOCKING
1797 * - STP_STATE_LEARNING
1798 * - STP_STATE_FORWARDING
1799 */
1800 rtk_api_ret_t rtk_stp_mstpState_get(rtk_stp_msti_id_t msti, rtk_port_t port, rtk_stp_state_t *pStp_state)
1801 {
1802 rtk_api_ret_t retVal;
1803
1804 /* Check initialization state */
1805 RTK_CHK_INIT_STATE();
1806
1807 /* Check Port Valid */
1808 RTK_CHK_PORT_VALID(port);
1809
1810 if (msti > RTK_MAX_NUM_OF_MSTI)
1811 return RT_ERR_MSTI;
1812
1813 if(NULL == pStp_state)
1814 return RT_ERR_NULL_POINTER;
1815
1816 if ((retVal = rtl8367c_getAsicSpanningTreeStatus(rtk_switch_port_L2P_get(port), msti, pStp_state)) != RT_ERR_OK)
1817 return retVal;
1818
1819 return RT_ERR_OK;
1820 }
1821
1822 /* Function Name:
1823 * rtk_vlan_checkAndCreateMbr
1824 * Description:
1825 * Check and create Member configuration and return index
1826 * Input:
1827 * vid - VLAN id.
1828 * Output:
1829 * pIndex - Member configuration index
1830 * Return:
1831 * RT_ERR_OK - OK
1832 * RT_ERR_FAILED - Failed
1833 * RT_ERR_SMI - SMI access error
1834 * RT_ERR_VLAN_VID - Invalid VLAN ID.
1835 * RT_ERR_VLAN_ENTRY_NOT_FOUND - VLAN not found
1836 * RT_ERR_TBL_FULL - Member Configuration table full
1837 * Note:
1838 *
1839 */
1840 rtk_api_ret_t rtk_vlan_checkAndCreateMbr(rtk_vlan_t vid, rtk_uint32 *pIndex)
1841 {
1842 rtk_api_ret_t retVal;
1843 rtl8367c_user_vlan4kentry vlan4K;
1844 rtl8367c_vlanconfiguser vlanMC;
1845 rtk_uint32 idx;
1846 rtk_uint32 empty_idx = 0xFFFF;
1847
1848 /* Check initialization state */
1849 RTK_CHK_INIT_STATE();
1850
1851 /* vid must be 0~8191 */
1852 if (vid > RTL8367C_EVIDMAX)
1853 return RT_ERR_VLAN_VID;
1854
1855 /* Null pointer check */
1856 if(NULL == pIndex)
1857 return RT_ERR_NULL_POINTER;
1858
1859 /* Get 4K VLAN */
1860 if (vid <= RTL8367C_VIDMAX)
1861 {
1862 memset(&vlan4K, 0x00, sizeof(rtl8367c_user_vlan4kentry));
1863 vlan4K.vid = vid;
1864 if ((retVal = rtl8367c_getAsicVlan4kEntry(&vlan4K)) != RT_ERR_OK)
1865 return retVal;
1866 }
1867
1868 /* Search exist entry */
1869 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
1870 {
1871 if(vlan_mbrCfgUsage[idx] == MBRCFG_USED_BY_VLAN)
1872 {
1873 if(vlan_mbrCfgVid[idx] == vid)
1874 {
1875 /* Found! return index */
1876 *pIndex = idx;
1877 return RT_ERR_OK;
1878 }
1879 }
1880 }
1881
1882 /* Not found, Read H/W Member Configuration table to update database */
1883 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
1884 {
1885 if ((retVal = rtl8367c_getAsicVlanMemberConfig(idx, &vlanMC)) != RT_ERR_OK)
1886 return retVal;
1887
1888 if( (vlanMC.evid == 0) && (vlanMC.mbr == 0x00))
1889 {
1890 vlan_mbrCfgUsage[idx] = MBRCFG_UNUSED;
1891 vlan_mbrCfgVid[idx] = 0;
1892 }
1893 else
1894 {
1895 vlan_mbrCfgUsage[idx] = MBRCFG_USED_BY_VLAN;
1896 vlan_mbrCfgVid[idx] = vlanMC.evid;
1897 }
1898 }
1899
1900 /* Search exist entry again */
1901 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
1902 {
1903 if(vlan_mbrCfgUsage[idx] == MBRCFG_USED_BY_VLAN)
1904 {
1905 if(vlan_mbrCfgVid[idx] == vid)
1906 {
1907 /* Found! return index */
1908 *pIndex = idx;
1909 return RT_ERR_OK;
1910 }
1911 }
1912 }
1913
1914 /* try to look up an empty index */
1915 for (idx = 0; idx <= RTL8367C_CVIDXMAX; idx++)
1916 {
1917 if(vlan_mbrCfgUsage[idx] == MBRCFG_UNUSED)
1918 {
1919 empty_idx = idx;
1920 break;
1921 }
1922 }
1923
1924 if(empty_idx == 0xFFFF)
1925 {
1926 /* No empty index */
1927 return RT_ERR_TBL_FULL;
1928 }
1929
1930 if (vid > RTL8367C_VIDMAX)
1931 {
1932 /* > 4K, there is no 4K entry, create on member configuration directly */
1933 memset(&vlanMC, 0x00, sizeof(rtl8367c_vlanconfiguser));
1934 vlanMC.evid = vid;
1935 if ((retVal = rtl8367c_setAsicVlanMemberConfig(empty_idx, &vlanMC)) != RT_ERR_OK)
1936 return retVal;
1937 }
1938 else
1939 {
1940 /* Copy from 4K table */
1941 vlanMC.evid = vid;
1942 vlanMC.mbr = vlan4K.mbr;
1943 vlanMC.fid_msti = vlan4K.fid_msti;
1944 vlanMC.meteridx= vlan4K.meteridx;
1945 vlanMC.envlanpol= vlan4K.envlanpol;
1946 vlanMC.vbpen = vlan4K.vbpen;
1947 vlanMC.vbpri = vlan4K.vbpri;
1948 if ((retVal = rtl8367c_setAsicVlanMemberConfig(empty_idx, &vlanMC)) != RT_ERR_OK)
1949 return retVal;
1950 }
1951
1952 /* Update Database */
1953 vlan_mbrCfgUsage[empty_idx] = MBRCFG_USED_BY_VLAN;
1954 vlan_mbrCfgVid[empty_idx] = vid;
1955
1956 *pIndex = empty_idx;
1957 return RT_ERR_OK;
1958 }
1959
1960 /* Function Name:
1961 * rtk_vlan_reservedVidAction_set
1962 * Description:
1963 * Set Action of VLAN ID = 0 & 4095 tagged packet
1964 * Input:
1965 * action_vid0 - Action for VID 0.
1966 * action_vid4095 - Action for VID 4095.
1967 * Output:
1968 * None.
1969 * Return:
1970 * RT_ERR_OK - OK
1971 * RT_ERR_FAILED - Failed
1972 * RT_ERR_SMI - SMI access error
1973 * RT_ERR_INPUT - Error Input
1974 * Note:
1975 *
1976 */
1977 rtk_api_ret_t rtk_vlan_reservedVidAction_set(rtk_vlan_resVidAction_t action_vid0, rtk_vlan_resVidAction_t action_vid4095)
1978 {
1979 rtk_api_ret_t retVal;
1980
1981 /* Check initialization state */
1982 RTK_CHK_INIT_STATE();
1983
1984 if(action_vid0 >= RESVID_ACTION_END)
1985 return RT_ERR_INPUT;
1986
1987 if(action_vid4095 >= RESVID_ACTION_END)
1988 return RT_ERR_INPUT;
1989
1990 if ((retVal = rtl8367c_setReservedVidAction((rtk_uint32)action_vid0, (rtk_uint32)action_vid4095)) != RT_ERR_OK)
1991 return retVal;
1992
1993 return RT_ERR_OK;
1994 }
1995
1996 /* Function Name:
1997 * rtk_vlan_reservedVidAction_get
1998 * Description:
1999 * Get Action of VLAN ID = 0 & 4095 tagged packet
2000 * Input:
2001 * pAction_vid0 - Action for VID 0.
2002 * pAction_vid4095 - Action for VID 4095.
2003 * Output:
2004 * None.
2005 * Return:
2006 * RT_ERR_OK - OK
2007 * RT_ERR_FAILED - Failed
2008 * RT_ERR_SMI - SMI access error
2009 * RT_ERR_NULL_POINTER - NULL Pointer
2010 * Note:
2011 *
2012 */
2013 rtk_api_ret_t rtk_vlan_reservedVidAction_get(rtk_vlan_resVidAction_t *pAction_vid0, rtk_vlan_resVidAction_t *pAction_vid4095)
2014 {
2015 rtk_api_ret_t retVal;
2016
2017 /* Check initialization state */
2018 RTK_CHK_INIT_STATE();
2019
2020 if(pAction_vid0 == NULL)
2021 return RT_ERR_NULL_POINTER;
2022
2023 if(pAction_vid4095 == NULL)
2024 return RT_ERR_NULL_POINTER;
2025
2026 if ((retVal = rtl8367c_getReservedVidAction((rtk_uint32 *)pAction_vid0, (rtk_uint32 *)pAction_vid4095)) != RT_ERR_OK)
2027 return retVal;
2028
2029 return RT_ERR_OK;
2030 }
2031
2032 /* Function Name:
2033 * rtk_vlan_realKeepRemarkEnable_set
2034 * Description:
2035 * Set Real keep 1p remarking feature
2036 * Input:
2037 * enabled - State of 1p remarking at real keep packet
2038 * Output:
2039 * None.
2040 * Return:
2041 * RT_ERR_OK - OK
2042 * RT_ERR_FAILED - Failed
2043 * RT_ERR_SMI - SMI access error
2044 * RT_ERR_INPUT - Error Input
2045 * Note:
2046 *
2047 */
2048 rtk_api_ret_t rtk_vlan_realKeepRemarkEnable_set(rtk_enable_t enabled)
2049 {
2050 rtk_api_ret_t retVal;
2051
2052 /* Check initialization state */
2053 RTK_CHK_INIT_STATE();
2054
2055 if(enabled >= RTK_ENABLE_END)
2056 return RT_ERR_INPUT;
2057
2058 if ((retVal = rtl8367c_setRealKeepRemarkEn((rtk_uint32)enabled)) != RT_ERR_OK)
2059 return retVal;
2060
2061 return RT_ERR_OK;
2062 }
2063
2064 /* Function Name:
2065 * rtk_vlan_realKeepRemarkEnable_get
2066 * Description:
2067 * Get Real keep 1p remarking feature
2068 * Input:
2069 * None.
2070 * Output:
2071 * pEnabled - State of 1p remarking at real keep packet
2072 * Return:
2073 * RT_ERR_OK - OK
2074 * RT_ERR_FAILED - Failed
2075 * RT_ERR_SMI - SMI access error
2076 * RT_ERR_INPUT - Error Input
2077 * Note:
2078 *
2079 */
2080 rtk_api_ret_t rtk_vlan_realKeepRemarkEnable_get(rtk_enable_t *pEnabled)
2081 {
2082 rtk_api_ret_t retVal;
2083
2084 /* Check initialization state */
2085 RTK_CHK_INIT_STATE();
2086
2087 if(NULL == pEnabled)
2088 return RT_ERR_NULL_POINTER;
2089
2090 if ((retVal = rtl8367c_getRealKeepRemarkEn((rtk_uint32 *)pEnabled)) != RT_ERR_OK)
2091 return retVal;
2092
2093 return RT_ERR_OK;
2094 }
2095
2096 /* Function Name:
2097 * rtk_vlan_reset
2098 * Description:
2099 * Reset VLAN
2100 * Input:
2101 * None.
2102 * Output:
2103 * pEnabled - State of 1p remarking at real keep packet
2104 * Return:
2105 * RT_ERR_OK - OK
2106 * RT_ERR_FAILED - Failed
2107 * RT_ERR_SMI - SMI access error
2108 * RT_ERR_INPUT - Error Input
2109 * Note:
2110 *
2111 */
2112 rtk_api_ret_t rtk_vlan_reset(void)
2113 {
2114 rtk_api_ret_t retVal;
2115
2116 /* Check initialization state */
2117 RTK_CHK_INIT_STATE();
2118
2119 if ((retVal = rtl8367c_resetVlan()) != RT_ERR_OK)
2120 return retVal;
2121
2122 return RT_ERR_OK;
2123 }
2124
Rafal Mileckis staging tree