2 * Copyright (C) 2013 Realtek Semiconductor Corp.
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
11 * $Date: 2017-03-08 15:13:58 +0800 (週三, 08 三月 2017) $
13 * Purpose : RTL8367C switch high-level API for RTL8367C
14 * Feature : LUT related functions
18 #include <rtl8367c_asicdrv_lut.h>
22 static void _rtl8367c_fdbStUser2Smi( rtl8367c_luttb
*pLutSt
, rtk_uint16
*pFdbSmi
)
27 if(pLutSt
->l3vidlookup
)
29 pFdbSmi
[0] = (pLutSt
->sip
& 0x0000FFFF);
30 pFdbSmi
[1] = (pLutSt
->sip
& 0xFFFF0000) >> 16;
32 pFdbSmi
[2] = (pLutSt
->dip
& 0x0000FFFF);
33 pFdbSmi
[3] = (pLutSt
->dip
& 0x0FFF0000) >> 16;
35 pFdbSmi
[3] |= (pLutSt
->l3lookup
& 0x0001) << 12;
36 pFdbSmi
[3] |= (pLutSt
->l3vidlookup
& 0x0001) << 13;
37 pFdbSmi
[3] |= ((pLutSt
->mbr
& 0x0300) >> 8) << 14;
39 pFdbSmi
[4] |= (pLutSt
->mbr
& 0x00FF);
40 pFdbSmi
[4] |= (pLutSt
->l3_vid
& 0x00FF) << 8;
42 pFdbSmi
[5] |= ((pLutSt
->l3_vid
& 0x0F00) >> 8);
43 pFdbSmi
[5] |= (pLutSt
->nosalearn
& 0x0001) << 5;
44 pFdbSmi
[5] |= ((pLutSt
->mbr
& 0x0400) >> 10) << 7;
48 pFdbSmi
[0] = (pLutSt
->sip
& 0x0000FFFF);
49 pFdbSmi
[1] = (pLutSt
->sip
& 0xFFFF0000) >> 16;
51 pFdbSmi
[2] = (pLutSt
->dip
& 0x0000FFFF);
52 pFdbSmi
[3] = (pLutSt
->dip
& 0x0FFF0000) >> 16;
54 pFdbSmi
[3] |= (pLutSt
->l3lookup
& 0x0001) << 12;
55 pFdbSmi
[3] |= (pLutSt
->l3vidlookup
& 0x0001) << 13;
56 pFdbSmi
[3] |= ((pLutSt
->mbr
& 0x0300) >> 8) << 14;
58 pFdbSmi
[4] |= (pLutSt
->mbr
& 0x00FF);
59 pFdbSmi
[4] |= (pLutSt
->igmpidx
& 0x00FF) << 8;
61 pFdbSmi
[5] |= (pLutSt
->igmp_asic
& 0x0001);
62 pFdbSmi
[5] |= (pLutSt
->lut_pri
& 0x0007) << 1;
63 pFdbSmi
[5] |= (pLutSt
->fwd_en
& 0x0001) << 4;
64 pFdbSmi
[5] |= (pLutSt
->nosalearn
& 0x0001) << 5;
65 pFdbSmi
[5] |= ((pLutSt
->mbr
& 0x0400) >> 10) << 7;
68 else if(pLutSt
->mac
.octet
[0] & 0x01) /*Multicast L2 Lookup*/
70 pFdbSmi
[0] |= pLutSt
->mac
.octet
[5];
71 pFdbSmi
[0] |= pLutSt
->mac
.octet
[4] << 8;
73 pFdbSmi
[1] |= pLutSt
->mac
.octet
[3];
74 pFdbSmi
[1] |= pLutSt
->mac
.octet
[2] << 8;
76 pFdbSmi
[2] |= pLutSt
->mac
.octet
[1];
77 pFdbSmi
[2] |= pLutSt
->mac
.octet
[0] << 8;
79 pFdbSmi
[3] |= pLutSt
->cvid_fid
;
80 pFdbSmi
[3] |= (pLutSt
->l3lookup
& 0x0001) << 12;
81 pFdbSmi
[3] |= (pLutSt
->ivl_svl
& 0x0001) << 13;
82 pFdbSmi
[3] |= ((pLutSt
->mbr
& 0x0300) >> 8) << 14;
84 pFdbSmi
[4] |= (pLutSt
->mbr
& 0x00FF);
85 pFdbSmi
[4] |= (pLutSt
->igmpidx
& 0x00FF) << 8;
87 pFdbSmi
[5] |= pLutSt
->igmp_asic
;
88 pFdbSmi
[5] |= (pLutSt
->lut_pri
& 0x0007) << 1;
89 pFdbSmi
[5] |= (pLutSt
->fwd_en
& 0x0001) << 4;
90 pFdbSmi
[5] |= (pLutSt
->nosalearn
& 0x0001) << 5;
91 pFdbSmi
[5] |= ((pLutSt
->mbr
& 0x0400) >> 10) << 7;
93 else /*Asic auto-learning*/
95 pFdbSmi
[0] |= pLutSt
->mac
.octet
[5];
96 pFdbSmi
[0] |= pLutSt
->mac
.octet
[4] << 8;
98 pFdbSmi
[1] |= pLutSt
->mac
.octet
[3];
99 pFdbSmi
[1] |= pLutSt
->mac
.octet
[2] << 8;
101 pFdbSmi
[2] |= pLutSt
->mac
.octet
[1];
102 pFdbSmi
[2] |= pLutSt
->mac
.octet
[0] << 8;
104 pFdbSmi
[3] |= pLutSt
->cvid_fid
;
105 pFdbSmi
[3] |= (pLutSt
->l3lookup
& 0x0001) << 12;
106 pFdbSmi
[3] |= (pLutSt
->ivl_svl
& 0x0001) << 13;
107 pFdbSmi
[3] |= ((pLutSt
->spa
& 0x0008) >> 3) << 15;
109 pFdbSmi
[4] |= pLutSt
->efid
;
110 pFdbSmi
[4] |= (pLutSt
->fid
& 0x000F) << 3;
111 pFdbSmi
[4] |= (pLutSt
->sa_en
& 0x0001) << 7;
112 pFdbSmi
[4] |= (pLutSt
->spa
& 0x0007) << 8;
113 pFdbSmi
[4] |= (pLutSt
->age
& 0x0007) << 11;
114 pFdbSmi
[4] |= (pLutSt
->auth
& 0x0001) << 14;
115 pFdbSmi
[4] |= (pLutSt
->sa_block
& 0x0001) << 15;
117 pFdbSmi
[5] |= pLutSt
->da_block
;
118 pFdbSmi
[5] |= (pLutSt
->lut_pri
& 0x0007) << 1;
119 pFdbSmi
[5] |= (pLutSt
->fwd_en
& 0x0001) << 4;
120 pFdbSmi
[5] |= (pLutSt
->nosalearn
& 0x0001) << 5;
125 static void _rtl8367c_fdbStSmi2User( rtl8367c_luttb
*pLutSt
, rtk_uint16
*pFdbSmi
)
128 if(pFdbSmi
[3] & 0x1000)
130 if(pFdbSmi
[3] & 0x2000)
132 pLutSt
->sip
= pFdbSmi
[0] | (pFdbSmi
[1] << 16);
133 pLutSt
->dip
= pFdbSmi
[2] | ((pFdbSmi
[3] & 0x0FFF) << 16);
135 pLutSt
->mbr
= (pFdbSmi
[4] & 0x00FF) | (((pFdbSmi
[3] & 0xC000) >> 14) << 8) | (((pFdbSmi
[5] & 0x0080) >> 7) << 10);
136 pLutSt
->l3_vid
= ((pFdbSmi
[4] & 0xFF00) >> 8) | (pFdbSmi
[5] & 0x000F);
138 pLutSt
->l3lookup
= (pFdbSmi
[3] & 0x1000) >> 12;
139 pLutSt
->l3vidlookup
= (pFdbSmi
[3] & 0x2000) >> 13;
140 pLutSt
->nosalearn
= (pFdbSmi
[5] & 0x0020) >> 5;
144 pLutSt
->sip
= pFdbSmi
[0] | (pFdbSmi
[1] << 16);
145 pLutSt
->dip
= pFdbSmi
[2] | ((pFdbSmi
[3] & 0x0FFF) << 16);
147 pLutSt
->lut_pri
= (pFdbSmi
[5] & 0x000E) >> 1;
148 pLutSt
->fwd_en
= (pFdbSmi
[5] & 0x0010) >> 4;
150 pLutSt
->mbr
= (pFdbSmi
[4] & 0x00FF) | (((pFdbSmi
[3] & 0xC000) >> 14) << 8) | (((pFdbSmi
[5] & 0x0080) >> 7) << 10);
151 pLutSt
->igmpidx
= (pFdbSmi
[4] & 0xFF00) >> 8;
153 pLutSt
->igmp_asic
= (pFdbSmi
[5] & 0x0001);
154 pLutSt
->l3lookup
= (pFdbSmi
[3] & 0x1000) >> 12;
155 pLutSt
->nosalearn
= (pFdbSmi
[5] & 0x0020) >> 5;
158 else if(pFdbSmi
[2] & 0x0100) /*Multicast L2 Lookup*/
160 pLutSt
->mac
.octet
[0] = (pFdbSmi
[2] & 0xFF00) >> 8;
161 pLutSt
->mac
.octet
[1] = (pFdbSmi
[2] & 0x00FF);
162 pLutSt
->mac
.octet
[2] = (pFdbSmi
[1] & 0xFF00) >> 8;
163 pLutSt
->mac
.octet
[3] = (pFdbSmi
[1] & 0x00FF);
164 pLutSt
->mac
.octet
[4] = (pFdbSmi
[0] & 0xFF00) >> 8;
165 pLutSt
->mac
.octet
[5] = (pFdbSmi
[0] & 0x00FF);
167 pLutSt
->cvid_fid
= pFdbSmi
[3] & 0x0FFF;
168 pLutSt
->lut_pri
= (pFdbSmi
[5] & 0x000E) >> 1;
169 pLutSt
->fwd_en
= (pFdbSmi
[5] & 0x0010) >> 4;
171 pLutSt
->mbr
= (pFdbSmi
[4] & 0x00FF) | (((pFdbSmi
[3] & 0xC000) >> 14) << 8) | (((pFdbSmi
[5] & 0x0080) >> 7) << 10);
172 pLutSt
->igmpidx
= (pFdbSmi
[4] & 0xFF00) >> 8;
174 pLutSt
->igmp_asic
= (pFdbSmi
[5] & 0x0001);
175 pLutSt
->l3lookup
= (pFdbSmi
[3] & 0x1000) >> 12;
176 pLutSt
->ivl_svl
= (pFdbSmi
[3] & 0x2000) >> 13;
177 pLutSt
->nosalearn
= (pFdbSmi
[5] & 0x0020) >> 5;
179 else /*Asic auto-learning*/
181 pLutSt
->mac
.octet
[0] = (pFdbSmi
[2] & 0xFF00) >> 8;
182 pLutSt
->mac
.octet
[1] = (pFdbSmi
[2] & 0x00FF);
183 pLutSt
->mac
.octet
[2] = (pFdbSmi
[1] & 0xFF00) >> 8;
184 pLutSt
->mac
.octet
[3] = (pFdbSmi
[1] & 0x00FF);
185 pLutSt
->mac
.octet
[4] = (pFdbSmi
[0] & 0xFF00) >> 8;
186 pLutSt
->mac
.octet
[5] = (pFdbSmi
[0] & 0x00FF);
188 pLutSt
->cvid_fid
= pFdbSmi
[3] & 0x0FFF;
189 pLutSt
->lut_pri
= (pFdbSmi
[5] & 0x000E) >> 1;
190 pLutSt
->fwd_en
= (pFdbSmi
[5] & 0x0010) >> 4;
192 pLutSt
->sa_en
= (pFdbSmi
[4] & 0x0080) >> 7;
193 pLutSt
->auth
= (pFdbSmi
[4] & 0x4000) >> 14;
194 pLutSt
->spa
= ((pFdbSmi
[4] & 0x0700) >> 8) | (((pFdbSmi
[3] & 0x8000) >> 15) << 3);
195 pLutSt
->age
= (pFdbSmi
[4] & 0x3800) >> 11;
196 pLutSt
->fid
= (pFdbSmi
[4] & 0x0078) >> 3;
197 pLutSt
->efid
= (pFdbSmi
[4] & 0x0007);
198 pLutSt
->sa_block
= (pFdbSmi
[4] & 0x8000) >> 15;
200 pLutSt
->da_block
= (pFdbSmi
[5] & 0x0001);
201 pLutSt
->l3lookup
= (pFdbSmi
[3] & 0x1000) >> 12;
202 pLutSt
->ivl_svl
= (pFdbSmi
[3] & 0x2000) >> 13;
203 pLutSt
->nosalearn
= (pFdbSmi
[3] & 0x0020) >> 5;
208 * rtl8367c_setAsicLutIpMulticastLookup
210 * Set Lut IP multicast lookup function
212 * enabled - 1: enabled, 0: disabled
216 * RT_ERR_OK - Success
217 * RT_ERR_SMI - SMI access error
221 ret_t
rtl8367c_setAsicLutIpMulticastLookup(rtk_uint32 enabled
)
223 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_LUT_IPMC_HASH_OFFSET
, enabled
);
226 * rtl8367c_getAsicLutIpMulticastLookup
228 * Get Lut IP multicast lookup function
230 * pEnabled - 1: enabled, 0: disabled
234 * RT_ERR_OK - Success
235 * RT_ERR_SMI - SMI access error
239 ret_t
rtl8367c_getAsicLutIpMulticastLookup(rtk_uint32
* pEnabled
)
241 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_LUT_IPMC_HASH_OFFSET
, pEnabled
);
245 * rtl8367c_setAsicLutIpMulticastLookup
247 * Set Lut IP multicast + VID lookup function
249 * enabled - 1: enabled, 0: disabled
253 * RT_ERR_OK - Success
254 * RT_ERR_SMI - SMI access error
258 ret_t
rtl8367c_setAsicLutIpMulticastVidLookup(rtk_uint32 enabled
)
260 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG2
, RTL8367C_LUT_IPMC_VID_HASH_OFFSET
, enabled
);
264 * rtl8367c_getAsicLutIpMulticastVidLookup
266 * Get Lut IP multicast lookup function
268 * pEnabled - 1: enabled, 0: disabled
272 * RT_ERR_OK - Success
273 * RT_ERR_SMI - SMI access error
277 ret_t
rtl8367c_getAsicLutIpMulticastVidLookup(rtk_uint32
* pEnabled
)
279 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG2
, RTL8367C_LUT_IPMC_VID_HASH_OFFSET
, pEnabled
);
283 * rtl8367c_setAsicLutIpLookupMethod
285 * Set Lut IP lookup hash with DIP or {DIP,SIP} pair
287 * type - 1: When DIP can be found in IPMC_GROUP_TABLE, use DIP+SIP Hash, otherwise, use DIP+(SIP=0.0.0.0) Hash.
288 * 0: When DIP can be found in IPMC_GROUP_TABLE, use DIP+(SIP=0.0.0.0) Hash, otherwise use DIP+SIP Hash.
292 * RT_ERR_OK - Success
293 * RT_ERR_SMI - SMI access error
297 ret_t
rtl8367c_setAsicLutIpLookupMethod(rtk_uint32 type
)
299 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_LUT_IPMC_LOOKUP_OP_OFFSET
, type
);
302 * rtl8367c_getAsicLutIpLookupMethod
304 * Get Lut IP lookup hash with DIP or {DIP,SIP} pair
306 * pType - 1: When DIP can be found in IPMC_GROUP_TABLE, use DIP+SIP Hash, otherwise, use DIP+(SIP=0.0.0.0) Hash.
307 * 0: When DIP can be found in IPMC_GROUP_TABLE, use DIP+(SIP=0.0.0.0) Hash, otherwise use DIP+SIP Hash.
311 * RT_ERR_OK - Success
312 * RT_ERR_SMI - SMI access error
316 ret_t
rtl8367c_getAsicLutIpLookupMethod(rtk_uint32
* pType
)
318 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_LUT_IPMC_LOOKUP_OP_OFFSET
, pType
);
321 * rtl8367c_setAsicLutAgeTimerSpeed
323 * Set LUT agging out speed
325 * timer - Agging out timer 0:Has been aged out
326 * speed - Agging out speed 0-fastest 3-slowest
330 * RT_ERR_OK - Success
331 * RT_ERR_SMI - SMI access error
332 * RT_ERR_OUT_OF_RANGE - input parameter out of range
336 ret_t
rtl8367c_setAsicLutAgeTimerSpeed(rtk_uint32 timer
, rtk_uint32 speed
)
338 if(timer
>RTL8367C_LUT_AGETIMERMAX
)
339 return RT_ERR_OUT_OF_RANGE
;
341 if(speed
>RTL8367C_LUT_AGESPEEDMAX
)
342 return RT_ERR_OUT_OF_RANGE
;
344 return rtl8367c_setAsicRegBits(RTL8367C_REG_LUT_CFG
, RTL8367C_AGE_TIMER_MASK
| RTL8367C_AGE_SPEED_MASK
, (timer
<< RTL8367C_AGE_TIMER_OFFSET
) | (speed
<< RTL8367C_AGE_SPEED_OFFSET
));
347 * rtl8367c_getAsicLutAgeTimerSpeed
349 * Get LUT agging out speed
351 * pTimer - Agging out timer 0:Has been aged out
352 * pSpeed - Agging out speed 0-fastest 3-slowest
356 * RT_ERR_OK - Success
357 * RT_ERR_SMI - SMI access error
358 * RT_ERR_OUT_OF_RANGE - input parameter out of range
362 ret_t
rtl8367c_getAsicLutAgeTimerSpeed(rtk_uint32
* pTimer
, rtk_uint32
* pSpeed
)
367 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_LUT_CFG
, ®Data
);
368 if(retVal
!= RT_ERR_OK
)
371 *pTimer
= (regData
& RTL8367C_AGE_TIMER_MASK
) >> RTL8367C_AGE_TIMER_OFFSET
;
373 *pSpeed
= (regData
& RTL8367C_AGE_SPEED_MASK
) >> RTL8367C_AGE_SPEED_OFFSET
;
379 * rtl8367c_setAsicLutCamTbUsage
381 * Configure Lut CAM table usage
383 * enabled - L2 CAM table usage 1: enabled, 0: disabled
387 * RT_ERR_OK - Success
388 * RT_ERR_SMI - SMI access error
392 ret_t
rtl8367c_setAsicLutCamTbUsage(rtk_uint32 enabled
)
396 retVal
= rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_BCAM_DISABLE_OFFSET
, enabled
? 0 : 1);
401 * rtl8367c_getAsicLutCamTbUsage
403 * Get Lut CAM table usage
405 * pEnabled - L2 CAM table usage 1: enabled, 0: disabled
409 * RT_ERR_OK - Success
410 * RT_ERR_SMI - SMI access error
414 ret_t
rtl8367c_getAsicLutCamTbUsage(rtk_uint32
* pEnabled
)
419 if ((retVal
= rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_BCAM_DISABLE_OFFSET
, ®Data
)) != RT_ERR_OK
)
422 *pEnabled
= regData
? 0 : 1;
426 * rtl8367c_setAsicLutLearnLimitNo
428 * Set per-Port auto learning limit number
430 * port - Physical port number (0~7)
431 * number - ASIC auto learning entries limit number
435 * RT_ERR_OK - Success
436 * RT_ERR_SMI - SMI access error
437 * RT_ERR_PORT_ID - Invalid port number
438 * RT_ERR_LIMITED_L2ENTRY_NUM - Invalid auto learning limit number
442 /*ÐÞ¸Ä: RTL8367C_PORTIDMAX, RTL8367C_LUT_LEARNLIMITMAX, RTL8367C_LUT_PORT_LEARN_LIMITNO_REG*/
443 ret_t
rtl8367c_setAsicLutLearnLimitNo(rtk_uint32 port
, rtk_uint32 number
)
445 if(port
> RTL8367C_PORTIDMAX
)
446 return RT_ERR_PORT_ID
;
448 if(number
> RTL8367C_LUT_LEARNLIMITMAX
)
449 return RT_ERR_LIMITED_L2ENTRY_NUM
;
452 return rtl8367c_setAsicReg(RTL8367C_LUT_PORT_LEARN_LIMITNO_REG(port
), number
);
454 return rtl8367c_setAsicReg(RTL8367C_REG_LUT_PORT8_LEARN_LIMITNO
+port
-8, number
);
458 * rtl8367c_getAsicLutLearnLimitNo
460 * Get per-Port auto learning limit number
462 * port - Physical port number (0~7)
463 * pNumber - ASIC auto learning entries limit number
467 * RT_ERR_OK - Success
468 * RT_ERR_SMI - SMI access error
469 * RT_ERR_PORT_ID - Invalid port number
473 /*ÐÞ¸Ä: RTL8367C_PORTIDMAX, RTL8367C_LUT_PORT_LEARN_LIMITNO_REG*/
474 ret_t
rtl8367c_getAsicLutLearnLimitNo(rtk_uint32 port
, rtk_uint32
* pNumber
)
476 if(port
> RTL8367C_PORTIDMAX
)
477 return RT_ERR_PORT_ID
;
480 return rtl8367c_getAsicReg(RTL8367C_LUT_PORT_LEARN_LIMITNO_REG(port
), pNumber
);
482 return rtl8367c_getAsicReg(RTL8367C_REG_LUT_PORT8_LEARN_LIMITNO
+port
-8, pNumber
);
486 * rtl8367c_setAsicSystemLutLearnLimitNo
488 * Set system auto learning limit number
490 * number - ASIC auto learning entries limit number
494 * RT_ERR_OK - Success
495 * RT_ERR_SMI - SMI access error
496 * RT_ERR_PORT_ID - Invalid port number
497 * RT_ERR_LIMITED_L2ENTRY_NUM - Invalid auto learning limit number
501 /*ÐÞ¸Ä: RTL8367C_LUT_LEARNLIMITMAX*/
502 ret_t
rtl8367c_setAsicSystemLutLearnLimitNo(rtk_uint32 number
)
504 if(number
> RTL8367C_LUT_LEARNLIMITMAX
)
505 return RT_ERR_LIMITED_L2ENTRY_NUM
;
507 return rtl8367c_setAsicReg(RTL8367C_REG_LUT_SYS_LEARN_LIMITNO
, number
);
511 * rtl8367c_getAsicSystemLutLearnLimitNo
513 * Get system auto learning limit number
515 * port - Physical port number (0~7)
516 * pNumber - ASIC auto learning entries limit number
520 * RT_ERR_OK - Success
521 * RT_ERR_SMI - SMI access error
522 * RT_ERR_PORT_ID - Invalid port number
526 ret_t
rtl8367c_getAsicSystemLutLearnLimitNo(rtk_uint32
*pNumber
)
529 return RT_ERR_NULL_POINTER
;
531 return rtl8367c_getAsicReg(RTL8367C_REG_LUT_SYS_LEARN_LIMITNO
, pNumber
);
535 * rtl8367c_setAsicLutLearnOverAct
537 * Set auto learn over limit number action
539 * action - Learn over action 0:normal, 1:drop 2:trap
543 * RT_ERR_OK - Success
544 * RT_ERR_SMI - SMI access error
545 * RT_ERR_NOT_ALLOWED - Invalid learn over action
549 ret_t
rtl8367c_setAsicLutLearnOverAct(rtk_uint32 action
)
551 if(action
>= LRNOVERACT_END
)
552 return RT_ERR_NOT_ALLOWED
;
554 return rtl8367c_setAsicRegBits(RTL8367C_REG_PORT_SECURITY_CTRL
, RTL8367C_LUT_LEARN_OVER_ACT_MASK
, action
);
557 * rtl8367c_getAsicLutLearnOverAct
559 * Get auto learn over limit number action
561 * pAction - Learn over action 0:normal, 1:drop 2:trap
565 * RT_ERR_OK - Success
566 * RT_ERR_SMI - SMI access error
570 ret_t
rtl8367c_getAsicLutLearnOverAct(rtk_uint32
* pAction
)
572 return rtl8367c_getAsicRegBits(RTL8367C_REG_PORT_SECURITY_CTRL
, RTL8367C_LUT_LEARN_OVER_ACT_MASK
, pAction
);
576 * rtl8367c_setAsicSystemLutLearnOverAct
578 * Set system auto learn over limit number action
580 * action - Learn over action 0:normal, 1:drop, 2:trap
584 * RT_ERR_OK - Success
585 * RT_ERR_SMI - SMI access error
586 * RT_ERR_NOT_ALLOWED - Invalid learn over action
590 ret_t
rtl8367c_setAsicSystemLutLearnOverAct(rtk_uint32 action
)
592 if(action
>= LRNOVERACT_END
)
593 return RT_ERR_NOT_ALLOWED
;
595 return rtl8367c_setAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL
, RTL8367C_LUT_SYSTEM_LEARN_OVER_ACT_MASK
, action
);
599 * rtl8367c_getAsicSystemLutLearnOverAct
601 * Get system auto learn over limit number action
603 * pAction - Learn over action 0:normal, 1:drop 2:trap
607 * RT_ERR_OK - Success
608 * RT_ERR_SMI - SMI access error
612 ret_t
rtl8367c_getAsicSystemLutLearnOverAct(rtk_uint32
*pAction
)
615 return RT_ERR_NULL_POINTER
;
617 return rtl8367c_getAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL
, RTL8367C_LUT_SYSTEM_LEARN_OVER_ACT_MASK
, pAction
);
621 * rtl8367c_setAsicSystemLutLearnPortMask
623 * Set system auto learn limit port mask
625 * portmask - port mask of system learning limit
629 * RT_ERR_OK - Success
630 * RT_ERR_SMI - SMI access error
631 * RT_ERR_PORT_MASK - Error port mask
635 /*ÐÞ¸Ä: RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK*/
636 ret_t
rtl8367c_setAsicSystemLutLearnPortMask(rtk_uint32 portmask
)
640 if(portmask
> RTL8367C_PORTMASK
)
641 return RT_ERR_PORT_MASK
;
643 retVal
= rtl8367c_setAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL
, RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK
, portmask
& 0xff);
644 if(retVal
!= RT_ERR_OK
)
646 retVal
= rtl8367c_setAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL
, RTL8367C_LUT_SYSTEM_LEARN_PMASK1_MASK
, (portmask
>>8) & 0x7);
647 if(retVal
!= RT_ERR_OK
)
655 * rtl8367c_getAsicSystemLutLearnPortMask
657 * Get system auto learn limit port mask
661 * pPortmask - port mask of system learning limit
663 * RT_ERR_OK - Success
664 * RT_ERR_SMI - SMI access error
665 * RT_ERR_NULL_POINTER - NULL pointer
669 /*ÐÞ¸Ä: RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK*/
670 ret_t
rtl8367c_getAsicSystemLutLearnPortMask(rtk_uint32
*pPortmask
)
675 if(NULL
== pPortmask
)
676 return RT_ERR_NULL_POINTER
;
678 retVal
= rtl8367c_getAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL
, RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK
, &tmpmask
);
679 if(retVal
!= RT_ERR_OK
)
681 *pPortmask
= tmpmask
& 0xff;
682 retVal
= rtl8367c_getAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL
, RTL8367C_LUT_SYSTEM_LEARN_PMASK1_MASK
, &tmpmask
);
683 if(retVal
!= RT_ERR_OK
)
685 *pPortmask
|= (tmpmask
& 0x7) << 8;
691 * rtl8367c_setAsicL2LookupTb
693 * Set filtering database entry
695 * pL2Table - L2 table entry writing to 8K+64 filtering database
699 * RT_ERR_OK - Success
700 * RT_ERR_SMI - SMI access error
704 ret_t
rtl8367c_setAsicL2LookupTb(rtl8367c_luttb
*pL2Table
)
708 rtk_uint16
*accessPtr
;
710 rtk_uint16 smil2Table
[RTL8367C_LUT_TABLE_SIZE
];
712 rtk_uint32 busyCounter
;
714 memset(smil2Table
, 0x00, sizeof(rtk_uint16
) * RTL8367C_LUT_TABLE_SIZE
);
715 _rtl8367c_fdbStUser2Smi(pL2Table
, smil2Table
);
717 if(pL2Table
->wait_time
== 0)
718 busyCounter
= RTL8367C_LUT_BUSY_CHECK_NO
;
720 busyCounter
= pL2Table
->wait_time
;
724 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG
, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET
,®Data
);
725 if(retVal
!= RT_ERR_OK
)
728 pL2Table
->lookup_busy
= regData
;
734 return RT_ERR_BUSYWAIT_TIMEOUT
;
737 accessPtr
= smil2Table
;
738 regData
= *accessPtr
;
739 for(i
= 0; i
< RTL8367C_LUT_ENTRY_SIZE
; i
++)
741 retVal
= rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_WRDATA_BASE
+ i
, regData
);
742 if(retVal
!= RT_ERR_OK
)
746 regData
= *accessPtr
;
750 tblCmd
= (RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE
,TB_TARGET_L2
)) & (RTL8367C_TABLE_TYPE_MASK
| RTL8367C_COMMAND_TYPE_MASK
);
752 retVal
= rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_CTRL_REG
, tblCmd
);
753 if(retVal
!= RT_ERR_OK
)
756 if(pL2Table
->wait_time
== 0)
757 busyCounter
= RTL8367C_LUT_BUSY_CHECK_NO
;
759 busyCounter
= pL2Table
->wait_time
;
763 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG
, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET
,®Data
);
764 if(retVal
!= RT_ERR_OK
)
767 pL2Table
->lookup_busy
= regData
;
773 return RT_ERR_BUSYWAIT_TIMEOUT
;
776 /*Read access status*/
777 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG
, RTL8367C_HIT_STATUS_OFFSET
, ®Data
);
778 if(retVal
!= RT_ERR_OK
)
781 pL2Table
->lookup_hit
= regData
;
782 if(!pL2Table
->lookup_hit
)
783 return RT_ERR_FAILED
;
785 /*Read access address*/
787 retVal = rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_TYPE_MASK | RTL8367C_TABLE_LUT_ADDR_ADDRESS_MASK,®Data);
788 if(retVal != RT_ERR_OK)
791 pL2Table->address = regData;*/
793 retVal
= rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_STATUS_REG
, ®Data
);
794 if(retVal
!= RT_ERR_OK
)
797 pL2Table
->address
= (regData
& 0x7ff) | ((regData
& 0x4000) >> 3) | ((regData
& 0x800) << 1);
798 pL2Table
->lookup_busy
= 0;
803 * rtl8367c_getAsicL2LookupTb
805 * Get filtering database entry
807 * pL2Table - L2 table entry writing to 2K+64 filtering database
811 * RT_ERR_OK - Success
812 * RT_ERR_SMI - SMI access error
813 * RT_ERR_INPUT - Invalid input parameter
814 * RT_ERR_BUSYWAIT_TIMEOUT - LUT is busy at retrieving
818 ret_t
rtl8367c_getAsicL2LookupTb(rtk_uint32 method
, rtl8367c_luttb
*pL2Table
)
822 rtk_uint16
* accessPtr
;
824 rtk_uint16 smil2Table
[RTL8367C_LUT_TABLE_SIZE
];
825 rtk_uint32 busyCounter
;
828 if(pL2Table
->wait_time
== 0)
829 busyCounter
= RTL8367C_LUT_BUSY_CHECK_NO
;
831 busyCounter
= pL2Table
->wait_time
;
835 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG
, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET
,®Data
);
836 if(retVal
!= RT_ERR_OK
)
839 pL2Table
->lookup_busy
= regData
;
840 if(!pL2Table
->lookup_busy
)
845 return RT_ERR_BUSYWAIT_TIMEOUT
;
849 tblCmd
= (method
<< RTL8367C_ACCESS_METHOD_OFFSET
) & RTL8367C_ACCESS_METHOD_MASK
;
853 case LUTREADMETHOD_ADDRESS
:
854 case LUTREADMETHOD_NEXT_ADDRESS
:
855 case LUTREADMETHOD_NEXT_L2UC
:
856 case LUTREADMETHOD_NEXT_L2MC
:
857 case LUTREADMETHOD_NEXT_L3MC
:
858 case LUTREADMETHOD_NEXT_L2L3MC
:
859 retVal
= rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_ADDR_REG
, pL2Table
->address
);
860 if(retVal
!= RT_ERR_OK
)
863 case LUTREADMETHOD_MAC
:
864 memset(smil2Table
, 0x00, sizeof(rtk_uint16
) * RTL8367C_LUT_TABLE_SIZE
);
865 _rtl8367c_fdbStUser2Smi(pL2Table
, smil2Table
);
867 accessPtr
= smil2Table
;
868 regData
= *accessPtr
;
869 for(i
=0; i
<RTL8367C_LUT_ENTRY_SIZE
; i
++)
871 retVal
= rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_WRDATA_BASE
+ i
, regData
);
872 if(retVal
!= RT_ERR_OK
)
876 regData
= *accessPtr
;
880 case LUTREADMETHOD_NEXT_L2UCSPA
:
881 retVal
= rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_ADDR_REG
, pL2Table
->address
);
882 if(retVal
!= RT_ERR_OK
)
885 tblCmd
= tblCmd
| ((pL2Table
->spa
<< RTL8367C_TABLE_ACCESS_CTRL_SPA_OFFSET
) & RTL8367C_TABLE_ACCESS_CTRL_SPA_MASK
);
892 tblCmd
= tblCmd
| ((RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ
,TB_TARGET_L2
)) & (RTL8367C_TABLE_TYPE_MASK
| RTL8367C_COMMAND_TYPE_MASK
));
894 retVal
= rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_CTRL_REG
, tblCmd
);
895 if(retVal
!= RT_ERR_OK
)
898 if(pL2Table
->wait_time
== 0)
899 busyCounter
= RTL8367C_LUT_BUSY_CHECK_NO
;
901 busyCounter
= pL2Table
->wait_time
;
905 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG
, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET
,®Data
);
906 if(retVal
!= RT_ERR_OK
)
909 pL2Table
->lookup_busy
= regData
;
910 if(!pL2Table
->lookup_busy
)
915 return RT_ERR_BUSYWAIT_TIMEOUT
;
918 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG
, RTL8367C_HIT_STATUS_OFFSET
,®Data
);
919 if(retVal
!= RT_ERR_OK
)
921 pL2Table
->lookup_hit
= regData
;
922 if(!pL2Table
->lookup_hit
)
923 return RT_ERR_L2_ENTRY_NOTFOUND
;
925 /*Read access address*/
926 //retVal = rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_TYPE_MASK | RTL8367C_TABLE_LUT_ADDR_ADDRESS_MASK,®Data);
927 retVal
= rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_STATUS_REG
, ®Data
);
928 if(retVal
!= RT_ERR_OK
)
931 pL2Table
->address
= (regData
& 0x7ff) | ((regData
& 0x4000) >> 3) | ((regData
& 0x800) << 1);
934 memset(smil2Table
, 0x00, sizeof(rtk_uint16
) * RTL8367C_LUT_TABLE_SIZE
);
936 accessPtr
= smil2Table
;
938 for(i
= 0; i
< RTL8367C_LUT_ENTRY_SIZE
; i
++)
940 retVal
= rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_RDDATA_BASE
+ i
, ®Data
);
941 if(retVal
!= RT_ERR_OK
)
944 *accessPtr
= regData
;
949 _rtl8367c_fdbStSmi2User(pL2Table
, smil2Table
);
954 * rtl8367c_getAsicLutLearnNo
956 * Get per-Port auto learning number
958 * port - Physical port number (0~7)
959 * pNumber - ASIC auto learning entries number
963 * RT_ERR_OK - Success
964 * RT_ERR_SMI - SMI access error
965 * RT_ERR_PORT_ID - Invalid port number
969 /*ÐÞ¸ÄRTL8367C_PORTIDMAX, RTL8367C_REG_L2_LRN_CNT_REG, port10 reg is not contnious, wait for updating of base.h*/
970 ret_t
rtl8367c_getAsicLutLearnNo(rtk_uint32 port
, rtk_uint32
* pNumber
)
974 if(port
> RTL8367C_PORTIDMAX
)
975 return RT_ERR_PORT_ID
;
979 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_L2_LRN_CNT_REG(port
), pNumber
);
980 if (retVal
!= RT_ERR_OK
)
985 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_L2_LRN_CNT_CTRL10
, pNumber
);
986 if (retVal
!= RT_ERR_OK
)
994 * rtl8367c_setAsicLutFlushAll
996 * Flush all entries in LUT. Includes static & dynamic entries
1002 * RT_ERR_OK - Success
1003 * RT_ERR_SMI - SMI access error
1007 ret_t
rtl8367c_setAsicLutFlushAll(void)
1009 return rtl8367c_setAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL3
, RTL8367C_L2_FLUSH_CTRL3_OFFSET
, 1);
1013 * rtl8367c_getAsicLutFlushAllStatus
1015 * Get Flush all status, 1:Busy, 0 normal
1019 * pBusyStatus - Busy state
1021 * RT_ERR_OK - Success
1022 * RT_ERR_SMI - SMI access error
1023 * RT_ERR_NULL_POINTER - Null pointer
1027 ret_t
rtl8367c_getAsicLutFlushAllStatus(rtk_uint32
*pBusyStatus
)
1029 if(NULL
== pBusyStatus
)
1030 return RT_ERR_NULL_POINTER
;
1032 return rtl8367c_getAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL3
, RTL8367C_L2_FLUSH_CTRL3_OFFSET
, pBusyStatus
);
1036 * rtl8367c_setAsicLutForceFlush
1038 * Set per port force flush setting
1040 * portmask - portmask(0~0xFF)
1044 * RT_ERR_OK - Success
1045 * RT_ERR_SMI - SMI access error
1046 * RT_ERR_PORT_MASK - Invalid portmask
1050 /*port8~port10µÄÉèÖÃÔÚÁíÍâÒ»¸öregister, wait for updating of base.h, reg.h*/
1051 ret_t
rtl8367c_setAsicLutForceFlush(rtk_uint32 portmask
)
1055 if(portmask
> RTL8367C_PORTMASK
)
1056 return RT_ERR_PORT_MASK
;
1058 retVal
= rtl8367c_setAsicRegBits(RTL8367C_FORCE_FLUSH_REG
, RTL8367C_FORCE_FLUSH_PORTMASK_MASK
, portmask
& 0xff);
1059 if(retVal
!= RT_ERR_OK
)
1062 retVal
= rtl8367c_setAsicRegBits(RTL8367C_REG_FORCE_FLUSH1
, RTL8367C_PORTMASK1_MASK
, (portmask
>> 8) & 0x7);
1063 if(retVal
!= RT_ERR_OK
)
1069 * rtl8367c_getAsicLutForceFlushStatus
1071 * Get per port force flush status
1073 * pPortmask - portmask(0~0xFF)
1077 * RT_ERR_OK - Success
1078 * RT_ERR_SMI - SMI access error
1082 /*port8~port10µÄÉèÖÃÔÚÁíÍâÒ»¸öregister, wait for updating of base.h, reg.h*/
1083 ret_t
rtl8367c_getAsicLutForceFlushStatus(rtk_uint32
*pPortmask
)
1088 retVal
= rtl8367c_getAsicRegBits(RTL8367C_FORCE_FLUSH_REG
, RTL8367C_BUSY_STATUS_MASK
,&tmpMask
);
1089 if(retVal
!= RT_ERR_OK
)
1091 *pPortmask
= tmpMask
& 0xff;
1093 retVal
= rtl8367c_getAsicRegBits(RTL8367C_REG_FORCE_FLUSH1
, RTL8367C_BUSY_STATUS1_MASK
,&tmpMask
);
1094 if(retVal
!= RT_ERR_OK
)
1096 *pPortmask
|= (tmpMask
& 7) << 8;
1101 * rtl8367c_setAsicLutFlushMode
1103 * Set user force L2 pLutSt table flush mode
1105 * mode - 0:Port based 1: Port + VLAN based 2:Port + FID/MSTI based
1109 * RT_ERR_OK - Success
1110 * RT_ERR_SMI - SMI access error
1111 * RT_ERR_NOT_ALLOWED - Actions not allowed by the function
1115 ret_t
rtl8367c_setAsicLutFlushMode(rtk_uint32 mode
)
1117 if( mode
>= FLUSHMDOE_END
)
1118 return RT_ERR_NOT_ALLOWED
;
1120 return rtl8367c_setAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL2
, RTL8367C_LUT_FLUSH_MODE_MASK
, mode
);
1123 * rtl8367c_getAsicLutFlushMode
1125 * Get user force L2 pLutSt table flush mode
1127 * pMode - 0:Port based 1: Port + VLAN based 2:Port + FID/MSTI based
1131 * RT_ERR_OK - Success
1132 * RT_ERR_SMI - SMI access error
1136 ret_t
rtl8367c_getAsicLutFlushMode(rtk_uint32
* pMode
)
1138 return rtl8367c_getAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL2
, RTL8367C_LUT_FLUSH_MODE_MASK
, pMode
);
1141 * rtl8367c_setAsicLutFlushType
1143 * Get L2 LUT flush type
1145 * type - 0: dynamice unicast; 1: both dynamic and static unicast entry
1149 * RT_ERR_OK - Success
1150 * RT_ERR_SMI - SMI access error
1154 ret_t
rtl8367c_setAsicLutFlushType(rtk_uint32 type
)
1156 return rtl8367c_setAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL2
, RTL8367C_LUT_FLUSH_TYPE_OFFSET
,type
);
1159 * rtl8367c_getAsicLutFlushType
1161 * Set L2 LUT flush type
1163 * pType - 0: dynamice unicast; 1: both dynamic and static unicast entry
1167 * RT_ERR_OK - Success
1168 * RT_ERR_SMI - SMI access error
1172 ret_t
rtl8367c_getAsicLutFlushType(rtk_uint32
* pType
)
1174 return rtl8367c_getAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL2
, RTL8367C_LUT_FLUSH_TYPE_OFFSET
,pType
);
1179 * rtl8367c_setAsicLutFlushVid
1181 * Set VID of Port + VID pLutSt flush mode
1183 * vid - Vid (0~4095)
1187 * RT_ERR_OK - Success
1188 * RT_ERR_SMI - SMI access error
1189 * RT_ERR_VLAN_VID - Invalid VID parameter (0~4095)
1193 ret_t
rtl8367c_setAsicLutFlushVid(rtk_uint32 vid
)
1195 if( vid
> RTL8367C_VIDMAX
)
1196 return RT_ERR_VLAN_VID
;
1198 return rtl8367c_setAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1
, RTL8367C_LUT_FLUSH_VID_MASK
, vid
);
1201 * rtl8367c_getAsicLutFlushVid
1203 * Get VID of Port + VID pLutSt flush mode
1205 * pVid - Vid (0~4095)
1209 * RT_ERR_OK - Success
1210 * RT_ERR_SMI - SMI access error
1214 ret_t
rtl8367c_getAsicLutFlushVid(rtk_uint32
* pVid
)
1216 return rtl8367c_getAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1
, RTL8367C_LUT_FLUSH_VID_MASK
, pVid
);
1219 * rtl8367c_setAsicPortFlusdFid
1221 * Set FID of Port + FID pLutSt flush mode
1223 * fid - FID/MSTI for force flush
1227 * RT_ERR_OK - Success
1228 * RT_ERR_SMI - SMI access error
1229 * RT_ERR_L2_FID - Invalid FID (0~15)
1233 ret_t
rtl8367c_setAsicLutFlushFid(rtk_uint32 fid
)
1235 if( fid
> RTL8367C_FIDMAX
)
1236 return RT_ERR_L2_FID
;
1238 return rtl8367c_setAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1
, RTL8367C_LUT_FLUSH_FID_MASK
, fid
);
1241 * rtl8367c_getAsicLutFlushFid
1243 * Get FID of Port + FID pLutSt flush mode
1245 * pFid - FID/MSTI for force flush
1249 * RT_ERR_OK - Success
1250 * RT_ERR_SMI - SMI access error
1254 ret_t
rtl8367c_getAsicLutFlushFid(rtk_uint32
* pFid
)
1256 return rtl8367c_getAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1
, RTL8367C_LUT_FLUSH_FID_MASK
, pFid
);
1259 * rtl8367c_setAsicLutDisableAging
1261 * Set L2 LUT aging per port setting
1263 * port - Physical port number (0~7)
1264 * disabled - 0: enable aging; 1: disabling aging
1268 * RT_ERR_OK - Success
1269 * RT_ERR_SMI - SMI access error
1270 * RT_ERR_PORT_ID - Invalid port number
1274 /*ÐÞ¸ÄRTL8367C_PORTIDMAX*/
1275 ret_t
rtl8367c_setAsicLutDisableAging(rtk_uint32 port
, rtk_uint32 disabled
)
1277 if(port
> RTL8367C_PORTIDMAX
)
1278 return RT_ERR_PORT_ID
;
1280 return rtl8367c_setAsicRegBit(RTL8367C_LUT_AGEOUT_CTRL_REG
, port
, disabled
);
1283 * rtl8367c_getAsicLutDisableAging
1285 * Get L2 LUT aging per port setting
1287 * port - Physical port number (0~7)
1288 * pDisabled - 0: enable aging; 1: disabling aging
1292 * RT_ERR_OK - Success
1293 * RT_ERR_SMI - SMI access error
1294 * RT_ERR_PORT_ID - Invalid port number
1298 /*ÐÞ¸ÄRTL8367C_PORTIDMAX*/
1299 ret_t
rtl8367c_getAsicLutDisableAging(rtk_uint32 port
, rtk_uint32
*pDisabled
)
1301 if(port
> RTL8367C_PORTIDMAX
)
1302 return RT_ERR_PORT_ID
;
1304 return rtl8367c_getAsicRegBit(RTL8367C_LUT_AGEOUT_CTRL_REG
, port
, pDisabled
);
1308 * rtl8367c_setAsicLutIPMCGroup
1310 * Set IPMC Group Table
1312 * index - the entry index in table (0 ~ 63)
1313 * group_addr - the multicast group address (224.0.0.0 ~ 239.255.255.255)
1320 * RT_ERR_OK - Success
1321 * RT_ERR_SMI - SMI access error
1322 * RT_ERR_INPUT - Invalid parameter
1326 ret_t
rtl8367c_setAsicLutIPMCGroup(rtk_uint32 index
, ipaddr_t group_addr
, rtk_uint32 vid
, rtk_uint32 pmask
, rtk_uint32 valid
)
1328 rtk_uint32 regAddr
, regData
, bitoffset
;
1332 if(index
> RTL8367C_LUT_IPMCGRP_TABLE_MAX
)
1333 return RT_ERR_INPUT
;
1335 if (vid
> RTL8367C_VIDMAX
)
1336 return RT_ERR_VLAN_VID
;
1338 ipData
= group_addr
;
1340 if( (ipData
& 0xF0000000) != 0xE0000000) /* not in 224.0.0.0 ~ 239.255.255.255 */
1341 return RT_ERR_INPUT
;
1344 regAddr
= RTL8367C_REG_IPMC_GROUP_ENTRY0_H
+ (index
* 2);
1345 regData
= ((ipData
& 0x0FFFFFFF) >> 16);
1347 if( (retVal
= rtl8367c_setAsicReg(regAddr
, regData
)) != RT_ERR_OK
)
1351 regData
= (ipData
& 0x0000FFFF);
1353 if( (retVal
= rtl8367c_setAsicReg(regAddr
, regData
)) != RT_ERR_OK
)
1357 regAddr
= RTL8367C_REG_IPMC_GROUP_VID_00
+ index
;
1360 if( (retVal
= rtl8367c_setAsicReg(regAddr
, regData
)) != RT_ERR_OK
)
1364 regAddr
= RTL8367C_REG_IPMC_GROUP_PMSK_00
+ index
;
1367 if( (retVal
= rtl8367c_setAsicReg(regAddr
, regData
)) != RT_ERR_OK
)
1371 regAddr
= RTL8367C_REG_IPMC_GROUP_VALID_15_0
+ (index
/ 16);
1372 bitoffset
= index
% 16;
1373 if( (retVal
= rtl8367c_setAsicRegBit(regAddr
, bitoffset
, valid
)) != RT_ERR_OK
)
1380 * rtl8367c_getAsicLutIPMCGroup
1382 * Set IPMC Group Table
1384 * index - the entry index in table (0 ~ 63)
1386 * pGroup_addr - the multicast group address (224.0.0.0 ~ 239.255.255.255)
1389 * pValid - Valid bit
1391 * RT_ERR_OK - Success
1392 * RT_ERR_SMI - SMI access error
1393 * RT_ERR_INPUT - Invalid parameter
1397 ret_t
rtl8367c_getAsicLutIPMCGroup(rtk_uint32 index
, ipaddr_t
*pGroup_addr
, rtk_uint32
*pVid
, rtk_uint32
*pPmask
, rtk_uint32
*pValid
)
1399 rtk_uint32 regAddr
, regData
, bitoffset
;
1403 if(index
> RTL8367C_LUT_IPMCGRP_TABLE_MAX
)
1404 return RT_ERR_INPUT
;
1406 if (NULL
== pGroup_addr
)
1407 return RT_ERR_NULL_POINTER
;
1410 return RT_ERR_NULL_POINTER
;
1413 return RT_ERR_NULL_POINTER
;
1416 regAddr
= RTL8367C_REG_IPMC_GROUP_ENTRY0_H
+ (index
* 2);
1417 if( (retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
)) != RT_ERR_OK
)
1420 *pGroup_addr
= (((regData
& 0x00000FFF) << 16) | 0xE0000000);
1423 if( (retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
)) != RT_ERR_OK
)
1426 ipData
= (*pGroup_addr
| (regData
& 0x0000FFFF));
1427 *pGroup_addr
= ipData
;
1430 regAddr
= RTL8367C_REG_IPMC_GROUP_VID_00
+ index
;
1431 if( (retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
)) != RT_ERR_OK
)
1437 regAddr
= RTL8367C_REG_IPMC_GROUP_PMSK_00
+ index
;
1438 if( (retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
)) != RT_ERR_OK
)
1444 regAddr
= RTL8367C_REG_IPMC_GROUP_VALID_15_0
+ (index
/ 16);
1445 bitoffset
= index
% 16;
1446 if( (retVal
= rtl8367c_getAsicRegBit(regAddr
, bitoffset
, ®Data
)) != RT_ERR_OK
)
1455 * rtl8367c_setAsicLutLinkDownForceAging
1457 * Set LUT link down aging setting.
1459 * enable - link down aging setting
1463 * RT_ERR_OK - Success
1464 * RT_ERR_SMI - SMI access error
1465 * RT_ERR_ENABLE - Invalid parameter
1469 ret_t
rtl8367c_setAsicLutLinkDownForceAging(rtk_uint32 enable
)
1472 return RT_ERR_ENABLE
;
1474 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_LINKDOWN_AGEOUT_OFFSET
, enable
? 0 : 1);
1478 * rtl8367c_getAsicLutLinkDownForceAging
1480 * Get LUT link down aging setting.
1482 * pEnable - link down aging setting
1486 * RT_ERR_OK - Success
1487 * RT_ERR_SMI - SMI access error
1488 * RT_ERR_ENABLE - Invalid parameter
1492 ret_t
rtl8367c_getAsicLutLinkDownForceAging(rtk_uint32
*pEnable
)
1497 if ((retVal
= rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG
, RTL8367C_LINKDOWN_AGEOUT_OFFSET
, &value
)) != RT_ERR_OK
)
1500 *pEnable
= value
? 0 : 1;
1505 * rtl8367c_setAsicLutIpmcFwdRouterPort
1507 * Set IPMC packet forward to rounter port also or not
1509 * enable - 1: Inlcude router port, 0, exclude router port
1513 * RT_ERR_OK - Success
1514 * RT_ERR_SMI - SMI access error
1515 * RT_ERR_ENABLE Invalid parameter
1519 ret_t
rtl8367c_setAsicLutIpmcFwdRouterPort(rtk_uint32 enable
)
1522 return RT_ERR_ENABLE
;
1524 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG2
, RTL8367C_LUT_IPMC_FWD_RPORT_OFFSET
, enable
);
1528 * rtl8367c_getAsicLutIpmcFwdRouterPort
1530 * Get IPMC packet forward to rounter port also or not
1534 * pEnable - 1: Inlcude router port, 0, exclude router port
1536 * RT_ERR_OK - Success
1537 * RT_ERR_SMI - SMI access error
1538 * RT_ERR_NULL_POINTER - Null pointer
1542 ret_t
rtl8367c_getAsicLutIpmcFwdRouterPort(rtk_uint32
*pEnable
)
1545 return RT_ERR_NULL_POINTER
;
1547 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG2
, RTL8367C_LUT_IPMC_FWD_RPORT_OFFSET
, pEnable
);