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 / rtl8367c_asicdrv_lut.c
1 /*
2 * Copyright (C) 2013 Realtek Semiconductor Corp.
3 * All Rights Reserved.
4 *
5 * Unless you and Realtek execute a separate written software license
6 * agreement governing use of this software, this software is licensed
7 * to you under the terms of the GNU General Public License version 2,
8 * available at https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
9 *
10 * $Revision: 76306 $
11 * $Date: 2017-03-08 15:13:58 +0800 (週三, 08 三月 2017) $
12 *
13 * Purpose : RTL8367C switch high-level API for RTL8367C
14 * Feature : LUT related functions
15 *
16 */
17
18 #include <rtl8367c_asicdrv_lut.h>
19
20 #include <string.h>
21
22 static void _rtl8367c_fdbStUser2Smi( rtl8367c_luttb *pLutSt, rtk_uint16 *pFdbSmi)
23 {
24 /* L3 lookup */
25 if(pLutSt->l3lookup)
26 {
27 if(pLutSt->l3vidlookup)
28 {
29 pFdbSmi[0] = (pLutSt->sip & 0x0000FFFF);
30 pFdbSmi[1] = (pLutSt->sip & 0xFFFF0000) >> 16;
31
32 pFdbSmi[2] = (pLutSt->dip & 0x0000FFFF);
33 pFdbSmi[3] = (pLutSt->dip & 0x0FFF0000) >> 16;
34
35 pFdbSmi[3] |= (pLutSt->l3lookup & 0x0001) << 12;
36 pFdbSmi[3] |= (pLutSt->l3vidlookup & 0x0001) << 13;
37 pFdbSmi[3] |= ((pLutSt->mbr & 0x0300) >> 8) << 14;
38
39 pFdbSmi[4] |= (pLutSt->mbr & 0x00FF);
40 pFdbSmi[4] |= (pLutSt->l3_vid & 0x00FF) << 8;
41
42 pFdbSmi[5] |= ((pLutSt->l3_vid & 0x0F00) >> 8);
43 pFdbSmi[5] |= (pLutSt->nosalearn & 0x0001) << 5;
44 pFdbSmi[5] |= ((pLutSt->mbr & 0x0400) >> 10) << 7;
45 }
46 else
47 {
48 pFdbSmi[0] = (pLutSt->sip & 0x0000FFFF);
49 pFdbSmi[1] = (pLutSt->sip & 0xFFFF0000) >> 16;
50
51 pFdbSmi[2] = (pLutSt->dip & 0x0000FFFF);
52 pFdbSmi[3] = (pLutSt->dip & 0x0FFF0000) >> 16;
53
54 pFdbSmi[3] |= (pLutSt->l3lookup & 0x0001) << 12;
55 pFdbSmi[3] |= (pLutSt->l3vidlookup & 0x0001) << 13;
56 pFdbSmi[3] |= ((pLutSt->mbr & 0x0300) >> 8) << 14;
57
58 pFdbSmi[4] |= (pLutSt->mbr & 0x00FF);
59 pFdbSmi[4] |= (pLutSt->igmpidx & 0x00FF) << 8;
60
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;
66 }
67 }
68 else if(pLutSt->mac.octet[0] & 0x01) /*Multicast L2 Lookup*/
69 {
70 pFdbSmi[0] |= pLutSt->mac.octet[5];
71 pFdbSmi[0] |= pLutSt->mac.octet[4] << 8;
72
73 pFdbSmi[1] |= pLutSt->mac.octet[3];
74 pFdbSmi[1] |= pLutSt->mac.octet[2] << 8;
75
76 pFdbSmi[2] |= pLutSt->mac.octet[1];
77 pFdbSmi[2] |= pLutSt->mac.octet[0] << 8;
78
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;
83
84 pFdbSmi[4] |= (pLutSt->mbr & 0x00FF);
85 pFdbSmi[4] |= (pLutSt->igmpidx & 0x00FF) << 8;
86
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;
92 }
93 else /*Asic auto-learning*/
94 {
95 pFdbSmi[0] |= pLutSt->mac.octet[5];
96 pFdbSmi[0] |= pLutSt->mac.octet[4] << 8;
97
98 pFdbSmi[1] |= pLutSt->mac.octet[3];
99 pFdbSmi[1] |= pLutSt->mac.octet[2] << 8;
100
101 pFdbSmi[2] |= pLutSt->mac.octet[1];
102 pFdbSmi[2] |= pLutSt->mac.octet[0] << 8;
103
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;
108
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;
116
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;
121 }
122 }
123
124
125 static void _rtl8367c_fdbStSmi2User( rtl8367c_luttb *pLutSt, rtk_uint16 *pFdbSmi)
126 {
127 /*L3 lookup*/
128 if(pFdbSmi[3] & 0x1000)
129 {
130 if(pFdbSmi[3] & 0x2000)
131 {
132 pLutSt->sip = pFdbSmi[0] | (pFdbSmi[1] << 16);
133 pLutSt->dip = pFdbSmi[2] | ((pFdbSmi[3] & 0x0FFF) << 16);
134
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);
137
138 pLutSt->l3lookup = (pFdbSmi[3] & 0x1000) >> 12;
139 pLutSt->l3vidlookup = (pFdbSmi[3] & 0x2000) >> 13;
140 pLutSt->nosalearn = (pFdbSmi[5] & 0x0020) >> 5;
141 }
142 else
143 {
144 pLutSt->sip = pFdbSmi[0] | (pFdbSmi[1] << 16);
145 pLutSt->dip = pFdbSmi[2] | ((pFdbSmi[3] & 0x0FFF) << 16);
146
147 pLutSt->lut_pri = (pFdbSmi[5] & 0x000E) >> 1;
148 pLutSt->fwd_en = (pFdbSmi[5] & 0x0010) >> 4;
149
150 pLutSt->mbr = (pFdbSmi[4] & 0x00FF) | (((pFdbSmi[3] & 0xC000) >> 14) << 8) | (((pFdbSmi[5] & 0x0080) >> 7) << 10);
151 pLutSt->igmpidx = (pFdbSmi[4] & 0xFF00) >> 8;
152
153 pLutSt->igmp_asic = (pFdbSmi[5] & 0x0001);
154 pLutSt->l3lookup = (pFdbSmi[3] & 0x1000) >> 12;
155 pLutSt->nosalearn = (pFdbSmi[5] & 0x0020) >> 5;
156 }
157 }
158 else if(pFdbSmi[2] & 0x0100) /*Multicast L2 Lookup*/
159 {
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);
166
167 pLutSt->cvid_fid = pFdbSmi[3] & 0x0FFF;
168 pLutSt->lut_pri = (pFdbSmi[5] & 0x000E) >> 1;
169 pLutSt->fwd_en = (pFdbSmi[5] & 0x0010) >> 4;
170
171 pLutSt->mbr = (pFdbSmi[4] & 0x00FF) | (((pFdbSmi[3] & 0xC000) >> 14) << 8) | (((pFdbSmi[5] & 0x0080) >> 7) << 10);
172 pLutSt->igmpidx = (pFdbSmi[4] & 0xFF00) >> 8;
173
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;
178 }
179 else /*Asic auto-learning*/
180 {
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);
187
188 pLutSt->cvid_fid = pFdbSmi[3] & 0x0FFF;
189 pLutSt->lut_pri = (pFdbSmi[5] & 0x000E) >> 1;
190 pLutSt->fwd_en = (pFdbSmi[5] & 0x0010) >> 4;
191
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;
199
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;
204 }
205 }
206
207 /* Function Name:
208 * rtl8367c_setAsicLutIpMulticastLookup
209 * Description:
210 * Set Lut IP multicast lookup function
211 * Input:
212 * enabled - 1: enabled, 0: disabled
213 * Output:
214 * None
215 * Return:
216 * RT_ERR_OK - Success
217 * RT_ERR_SMI - SMI access error
218 * Note:
219 * None
220 */
221 ret_t rtl8367c_setAsicLutIpMulticastLookup(rtk_uint32 enabled)
222 {
223 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_LUT_IPMC_HASH_OFFSET, enabled);
224 }
225 /* Function Name:
226 * rtl8367c_getAsicLutIpMulticastLookup
227 * Description:
228 * Get Lut IP multicast lookup function
229 * Input:
230 * pEnabled - 1: enabled, 0: disabled
231 * Output:
232 * None
233 * Return:
234 * RT_ERR_OK - Success
235 * RT_ERR_SMI - SMI access error
236 * Note:
237 * None
238 */
239 ret_t rtl8367c_getAsicLutIpMulticastLookup(rtk_uint32* pEnabled)
240 {
241 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_LUT_IPMC_HASH_OFFSET, pEnabled);
242 }
243
244 /* Function Name:
245 * rtl8367c_setAsicLutIpMulticastLookup
246 * Description:
247 * Set Lut IP multicast + VID lookup function
248 * Input:
249 * enabled - 1: enabled, 0: disabled
250 * Output:
251 * None
252 * Return:
253 * RT_ERR_OK - Success
254 * RT_ERR_SMI - SMI access error
255 * Note:
256 * None
257 */
258 ret_t rtl8367c_setAsicLutIpMulticastVidLookup(rtk_uint32 enabled)
259 {
260 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG2, RTL8367C_LUT_IPMC_VID_HASH_OFFSET, enabled);
261 }
262
263 /* Function Name:
264 * rtl8367c_getAsicLutIpMulticastVidLookup
265 * Description:
266 * Get Lut IP multicast lookup function
267 * Input:
268 * pEnabled - 1: enabled, 0: disabled
269 * Output:
270 * None
271 * Return:
272 * RT_ERR_OK - Success
273 * RT_ERR_SMI - SMI access error
274 * Note:
275 * None
276 */
277 ret_t rtl8367c_getAsicLutIpMulticastVidLookup(rtk_uint32* pEnabled)
278 {
279 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG2, RTL8367C_LUT_IPMC_VID_HASH_OFFSET, pEnabled);
280 }
281
282 /* Function Name:
283 * rtl8367c_setAsicLutIpLookupMethod
284 * Description:
285 * Set Lut IP lookup hash with DIP or {DIP,SIP} pair
286 * Input:
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.
289 * Output:
290 * None
291 * Return:
292 * RT_ERR_OK - Success
293 * RT_ERR_SMI - SMI access error
294 * Note:
295 * None
296 */
297 ret_t rtl8367c_setAsicLutIpLookupMethod(rtk_uint32 type)
298 {
299 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_LUT_IPMC_LOOKUP_OP_OFFSET, type);
300 }
301 /* Function Name:
302 * rtl8367c_getAsicLutIpLookupMethod
303 * Description:
304 * Get Lut IP lookup hash with DIP or {DIP,SIP} pair
305 * Input:
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.
308 * Output:
309 * None
310 * Return:
311 * RT_ERR_OK - Success
312 * RT_ERR_SMI - SMI access error
313 * Note:
314 * None
315 */
316 ret_t rtl8367c_getAsicLutIpLookupMethod(rtk_uint32* pType)
317 {
318 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_LUT_IPMC_LOOKUP_OP_OFFSET, pType);
319 }
320 /* Function Name:
321 * rtl8367c_setAsicLutAgeTimerSpeed
322 * Description:
323 * Set LUT agging out speed
324 * Input:
325 * timer - Agging out timer 0:Has been aged out
326 * speed - Agging out speed 0-fastest 3-slowest
327 * Output:
328 * None
329 * Return:
330 * RT_ERR_OK - Success
331 * RT_ERR_SMI - SMI access error
332 * RT_ERR_OUT_OF_RANGE - input parameter out of range
333 * Note:
334 * None
335 */
336 ret_t rtl8367c_setAsicLutAgeTimerSpeed(rtk_uint32 timer, rtk_uint32 speed)
337 {
338 if(timer>RTL8367C_LUT_AGETIMERMAX)
339 return RT_ERR_OUT_OF_RANGE;
340
341 if(speed >RTL8367C_LUT_AGESPEEDMAX)
342 return RT_ERR_OUT_OF_RANGE;
343
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));
345 }
346 /* Function Name:
347 * rtl8367c_getAsicLutAgeTimerSpeed
348 * Description:
349 * Get LUT agging out speed
350 * Input:
351 * pTimer - Agging out timer 0:Has been aged out
352 * pSpeed - Agging out speed 0-fastest 3-slowest
353 * Output:
354 * None
355 * Return:
356 * RT_ERR_OK - Success
357 * RT_ERR_SMI - SMI access error
358 * RT_ERR_OUT_OF_RANGE - input parameter out of range
359 * Note:
360 * None
361 */
362 ret_t rtl8367c_getAsicLutAgeTimerSpeed(rtk_uint32* pTimer, rtk_uint32* pSpeed)
363 {
364 rtk_uint32 regData;
365 ret_t retVal;
366
367 retVal = rtl8367c_getAsicReg(RTL8367C_REG_LUT_CFG, &regData);
368 if(retVal != RT_ERR_OK)
369 return retVal;
370
371 *pTimer = (regData & RTL8367C_AGE_TIMER_MASK) >> RTL8367C_AGE_TIMER_OFFSET;
372
373 *pSpeed = (regData & RTL8367C_AGE_SPEED_MASK) >> RTL8367C_AGE_SPEED_OFFSET;
374
375 return RT_ERR_OK;
376
377 }
378 /* Function Name:
379 * rtl8367c_setAsicLutCamTbUsage
380 * Description:
381 * Configure Lut CAM table usage
382 * Input:
383 * enabled - L2 CAM table usage 1: enabled, 0: disabled
384 * Output:
385 * None
386 * Return:
387 * RT_ERR_OK - Success
388 * RT_ERR_SMI - SMI access error
389 * Note:
390 * None
391 */
392 ret_t rtl8367c_setAsicLutCamTbUsage(rtk_uint32 enabled)
393 {
394 ret_t retVal;
395
396 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_BCAM_DISABLE_OFFSET, enabled ? 0 : 1);
397
398 return retVal;
399 }
400 /* Function Name:
401 * rtl8367c_getAsicLutCamTbUsage
402 * Description:
403 * Get Lut CAM table usage
404 * Input:
405 * pEnabled - L2 CAM table usage 1: enabled, 0: disabled
406 * Output:
407 * None
408 * Return:
409 * RT_ERR_OK - Success
410 * RT_ERR_SMI - SMI access error
411 * Note:
412 * None
413 */
414 ret_t rtl8367c_getAsicLutCamTbUsage(rtk_uint32* pEnabled)
415 {
416 ret_t retVal;
417 rtk_uint32 regData;
418
419 if ((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_BCAM_DISABLE_OFFSET, &regData)) != RT_ERR_OK)
420 return retVal;
421
422 *pEnabled = regData ? 0 : 1;
423 return RT_ERR_OK;
424 }
425 /* Function Name:
426 * rtl8367c_setAsicLutLearnLimitNo
427 * Description:
428 * Set per-Port auto learning limit number
429 * Input:
430 * port - Physical port number (0~7)
431 * number - ASIC auto learning entries limit number
432 * Output:
433 * None
434 * Return:
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
439 * Note:
440 * None
441 */
442 /*ÐÞ¸Ä: RTL8367C_PORTIDMAX, RTL8367C_LUT_LEARNLIMITMAX, RTL8367C_LUT_PORT_LEARN_LIMITNO_REG*/
443 ret_t rtl8367c_setAsicLutLearnLimitNo(rtk_uint32 port, rtk_uint32 number)
444 {
445 if(port > RTL8367C_PORTIDMAX)
446 return RT_ERR_PORT_ID;
447
448 if(number > RTL8367C_LUT_LEARNLIMITMAX)
449 return RT_ERR_LIMITED_L2ENTRY_NUM;
450
451 if(port < 8)
452 return rtl8367c_setAsicReg(RTL8367C_LUT_PORT_LEARN_LIMITNO_REG(port), number);
453 else
454 return rtl8367c_setAsicReg(RTL8367C_REG_LUT_PORT8_LEARN_LIMITNO+port-8, number);
455
456 }
457 /* Function Name:
458 * rtl8367c_getAsicLutLearnLimitNo
459 * Description:
460 * Get per-Port auto learning limit number
461 * Input:
462 * port - Physical port number (0~7)
463 * pNumber - ASIC auto learning entries limit number
464 * Output:
465 * None
466 * Return:
467 * RT_ERR_OK - Success
468 * RT_ERR_SMI - SMI access error
469 * RT_ERR_PORT_ID - Invalid port number
470 * Note:
471 * None
472 */
473 /*ÐÞ¸Ä: RTL8367C_PORTIDMAX, RTL8367C_LUT_PORT_LEARN_LIMITNO_REG*/
474 ret_t rtl8367c_getAsicLutLearnLimitNo(rtk_uint32 port, rtk_uint32* pNumber)
475 {
476 if(port > RTL8367C_PORTIDMAX)
477 return RT_ERR_PORT_ID;
478
479 if(port < 8)
480 return rtl8367c_getAsicReg(RTL8367C_LUT_PORT_LEARN_LIMITNO_REG(port), pNumber);
481 else
482 return rtl8367c_getAsicReg(RTL8367C_REG_LUT_PORT8_LEARN_LIMITNO+port-8, pNumber);
483 }
484
485 /* Function Name:
486 * rtl8367c_setAsicSystemLutLearnLimitNo
487 * Description:
488 * Set system auto learning limit number
489 * Input:
490 * number - ASIC auto learning entries limit number
491 * Output:
492 * None
493 * Return:
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
498 * Note:
499 * None
500 */
501 /*ÐÞ¸Ä: RTL8367C_LUT_LEARNLIMITMAX*/
502 ret_t rtl8367c_setAsicSystemLutLearnLimitNo(rtk_uint32 number)
503 {
504 if(number > RTL8367C_LUT_LEARNLIMITMAX)
505 return RT_ERR_LIMITED_L2ENTRY_NUM;
506
507 return rtl8367c_setAsicReg(RTL8367C_REG_LUT_SYS_LEARN_LIMITNO, number);
508 }
509
510 /* Function Name:
511 * rtl8367c_getAsicSystemLutLearnLimitNo
512 * Description:
513 * Get system auto learning limit number
514 * Input:
515 * port - Physical port number (0~7)
516 * pNumber - ASIC auto learning entries limit number
517 * Output:
518 * None
519 * Return:
520 * RT_ERR_OK - Success
521 * RT_ERR_SMI - SMI access error
522 * RT_ERR_PORT_ID - Invalid port number
523 * Note:
524 * None
525 */
526 ret_t rtl8367c_getAsicSystemLutLearnLimitNo(rtk_uint32 *pNumber)
527 {
528 if(NULL == pNumber)
529 return RT_ERR_NULL_POINTER;
530
531 return rtl8367c_getAsicReg(RTL8367C_REG_LUT_SYS_LEARN_LIMITNO, pNumber);
532 }
533
534 /* Function Name:
535 * rtl8367c_setAsicLutLearnOverAct
536 * Description:
537 * Set auto learn over limit number action
538 * Input:
539 * action - Learn over action 0:normal, 1:drop 2:trap
540 * Output:
541 * None
542 * Return:
543 * RT_ERR_OK - Success
544 * RT_ERR_SMI - SMI access error
545 * RT_ERR_NOT_ALLOWED - Invalid learn over action
546 * Note:
547 * None
548 */
549 ret_t rtl8367c_setAsicLutLearnOverAct(rtk_uint32 action)
550 {
551 if(action >= LRNOVERACT_END)
552 return RT_ERR_NOT_ALLOWED;
553
554 return rtl8367c_setAsicRegBits(RTL8367C_REG_PORT_SECURITY_CTRL, RTL8367C_LUT_LEARN_OVER_ACT_MASK, action);
555 }
556 /* Function Name:
557 * rtl8367c_getAsicLutLearnOverAct
558 * Description:
559 * Get auto learn over limit number action
560 * Input:
561 * pAction - Learn over action 0:normal, 1:drop 2:trap
562 * Output:
563 * None
564 * Return:
565 * RT_ERR_OK - Success
566 * RT_ERR_SMI - SMI access error
567 * Note:
568 * None
569 */
570 ret_t rtl8367c_getAsicLutLearnOverAct(rtk_uint32* pAction)
571 {
572 return rtl8367c_getAsicRegBits(RTL8367C_REG_PORT_SECURITY_CTRL, RTL8367C_LUT_LEARN_OVER_ACT_MASK, pAction);
573 }
574
575 /* Function Name:
576 * rtl8367c_setAsicSystemLutLearnOverAct
577 * Description:
578 * Set system auto learn over limit number action
579 * Input:
580 * action - Learn over action 0:normal, 1:drop, 2:trap
581 * Output:
582 * None
583 * Return:
584 * RT_ERR_OK - Success
585 * RT_ERR_SMI - SMI access error
586 * RT_ERR_NOT_ALLOWED - Invalid learn over action
587 * Note:
588 * None
589 */
590 ret_t rtl8367c_setAsicSystemLutLearnOverAct(rtk_uint32 action)
591 {
592 if(action >= LRNOVERACT_END)
593 return RT_ERR_NOT_ALLOWED;
594
595 return rtl8367c_setAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL, RTL8367C_LUT_SYSTEM_LEARN_OVER_ACT_MASK, action);
596 }
597
598 /* Function Name:
599 * rtl8367c_getAsicSystemLutLearnOverAct
600 * Description:
601 * Get system auto learn over limit number action
602 * Input:
603 * pAction - Learn over action 0:normal, 1:drop 2:trap
604 * Output:
605 * None
606 * Return:
607 * RT_ERR_OK - Success
608 * RT_ERR_SMI - SMI access error
609 * Note:
610 * None
611 */
612 ret_t rtl8367c_getAsicSystemLutLearnOverAct(rtk_uint32 *pAction)
613 {
614 if(NULL == pAction)
615 return RT_ERR_NULL_POINTER;
616
617 return rtl8367c_getAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL, RTL8367C_LUT_SYSTEM_LEARN_OVER_ACT_MASK, pAction);
618 }
619
620 /* Function Name:
621 * rtl8367c_setAsicSystemLutLearnPortMask
622 * Description:
623 * Set system auto learn limit port mask
624 * Input:
625 * portmask - port mask of system learning limit
626 * Output:
627 * None
628 * Return:
629 * RT_ERR_OK - Success
630 * RT_ERR_SMI - SMI access error
631 * RT_ERR_PORT_MASK - Error port mask
632 * Note:
633 * None
634 */
635 /*ÐÞ¸Ä: RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK*/
636 ret_t rtl8367c_setAsicSystemLutLearnPortMask(rtk_uint32 portmask)
637 {
638 ret_t retVal;
639
640 if(portmask > RTL8367C_PORTMASK)
641 return RT_ERR_PORT_MASK;
642
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)
645 return retVal;
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)
648 return retVal;
649
650 return RT_ERR_OK;
651
652 }
653
654 /* Function Name:
655 * rtl8367c_getAsicSystemLutLearnPortMask
656 * Description:
657 * Get system auto learn limit port mask
658 * Input:
659 * None
660 * Output:
661 * pPortmask - port mask of system learning limit
662 * Return:
663 * RT_ERR_OK - Success
664 * RT_ERR_SMI - SMI access error
665 * RT_ERR_NULL_POINTER - NULL pointer
666 * Note:
667 * None
668 */
669 /*ÐÞ¸Ä: RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK*/
670 ret_t rtl8367c_getAsicSystemLutLearnPortMask(rtk_uint32 *pPortmask)
671 {
672 rtk_uint32 tmpmask;
673 ret_t retVal;
674
675 if(NULL == pPortmask)
676 return RT_ERR_NULL_POINTER;
677
678 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_LUT_LRN_SYS_LMT_CTRL, RTL8367C_LUT_SYSTEM_LEARN_PMASK_MASK, &tmpmask);
679 if(retVal != RT_ERR_OK)
680 return retVal;
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)
684 return retVal;
685 *pPortmask |= (tmpmask & 0x7) << 8;
686
687 return RT_ERR_OK;
688 }
689
690 /* Function Name:
691 * rtl8367c_setAsicL2LookupTb
692 * Description:
693 * Set filtering database entry
694 * Input:
695 * pL2Table - L2 table entry writing to 8K+64 filtering database
696 * Output:
697 * None
698 * Return:
699 * RT_ERR_OK - Success
700 * RT_ERR_SMI - SMI access error
701 * Note:
702 * None
703 */
704 ret_t rtl8367c_setAsicL2LookupTb(rtl8367c_luttb *pL2Table)
705 {
706 ret_t retVal;
707 rtk_uint32 regData;
708 rtk_uint16 *accessPtr;
709 rtk_uint32 i;
710 rtk_uint16 smil2Table[RTL8367C_LUT_TABLE_SIZE];
711 rtk_uint32 tblCmd;
712 rtk_uint32 busyCounter;
713
714 memset(smil2Table, 0x00, sizeof(rtk_uint16) * RTL8367C_LUT_TABLE_SIZE);
715 _rtl8367c_fdbStUser2Smi(pL2Table, smil2Table);
716
717 if(pL2Table->wait_time == 0)
718 busyCounter = RTL8367C_LUT_BUSY_CHECK_NO;
719 else
720 busyCounter = pL2Table->wait_time;
721
722 while(busyCounter)
723 {
724 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,&regData);
725 if(retVal != RT_ERR_OK)
726 return retVal;
727
728 pL2Table->lookup_busy = regData;
729 if(!regData)
730 break;
731
732 busyCounter --;
733 if(busyCounter == 0)
734 return RT_ERR_BUSYWAIT_TIMEOUT;
735 }
736
737 accessPtr = smil2Table;
738 regData = *accessPtr;
739 for(i = 0; i < RTL8367C_LUT_ENTRY_SIZE; i++)
740 {
741 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_WRDATA_BASE + i, regData);
742 if(retVal != RT_ERR_OK)
743 return retVal;
744
745 accessPtr ++;
746 regData = *accessPtr;
747
748 }
749
750 tblCmd = (RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE,TB_TARGET_L2)) & (RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK);
751 /* Write Command */
752 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_CTRL_REG, tblCmd);
753 if(retVal != RT_ERR_OK)
754 return retVal;
755
756 if(pL2Table->wait_time == 0)
757 busyCounter = RTL8367C_LUT_BUSY_CHECK_NO;
758 else
759 busyCounter = pL2Table->wait_time;
760
761 while(busyCounter)
762 {
763 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,&regData);
764 if(retVal != RT_ERR_OK)
765 return retVal;
766
767 pL2Table->lookup_busy = regData;
768 if(!regData)
769 break;
770
771 busyCounter --;
772 if(busyCounter == 0)
773 return RT_ERR_BUSYWAIT_TIMEOUT;
774 }
775
776 /*Read access status*/
777 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_HIT_STATUS_OFFSET, &regData);
778 if(retVal != RT_ERR_OK)
779 return retVal;
780
781 pL2Table->lookup_hit = regData;
782 if(!pL2Table->lookup_hit)
783 return RT_ERR_FAILED;
784
785 /*Read access address*/
786 /*
787 retVal = rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_TYPE_MASK | RTL8367C_TABLE_LUT_ADDR_ADDRESS_MASK,&regData);
788 if(retVal != RT_ERR_OK)
789 return retVal;
790
791 pL2Table->address = regData;*/
792
793 retVal = rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_STATUS_REG, &regData);
794 if(retVal != RT_ERR_OK)
795 return retVal;
796
797 pL2Table->address = (regData & 0x7ff) | ((regData & 0x4000) >> 3) | ((regData & 0x800) << 1);
798 pL2Table->lookup_busy = 0;
799
800 return RT_ERR_OK;
801 }
802 /* Function Name:
803 * rtl8367c_getAsicL2LookupTb
804 * Description:
805 * Get filtering database entry
806 * Input:
807 * pL2Table - L2 table entry writing to 2K+64 filtering database
808 * Output:
809 * None
810 * Return:
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
815 * Note:
816 * None
817 */
818 ret_t rtl8367c_getAsicL2LookupTb(rtk_uint32 method, rtl8367c_luttb *pL2Table)
819 {
820 ret_t retVal;
821 rtk_uint32 regData;
822 rtk_uint16* accessPtr;
823 rtk_uint32 i;
824 rtk_uint16 smil2Table[RTL8367C_LUT_TABLE_SIZE];
825 rtk_uint32 busyCounter;
826 rtk_uint32 tblCmd;
827
828 if(pL2Table->wait_time == 0)
829 busyCounter = RTL8367C_LUT_BUSY_CHECK_NO;
830 else
831 busyCounter = pL2Table->wait_time;
832
833 while(busyCounter)
834 {
835 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,&regData);
836 if(retVal != RT_ERR_OK)
837 return retVal;
838
839 pL2Table->lookup_busy = regData;
840 if(!pL2Table->lookup_busy)
841 break;
842
843 busyCounter --;
844 if(busyCounter == 0)
845 return RT_ERR_BUSYWAIT_TIMEOUT;
846 }
847
848
849 tblCmd = (method << RTL8367C_ACCESS_METHOD_OFFSET) & RTL8367C_ACCESS_METHOD_MASK;
850
851 switch(method)
852 {
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)
861 return retVal;
862 break;
863 case LUTREADMETHOD_MAC:
864 memset(smil2Table, 0x00, sizeof(rtk_uint16) * RTL8367C_LUT_TABLE_SIZE);
865 _rtl8367c_fdbStUser2Smi(pL2Table, smil2Table);
866
867 accessPtr = smil2Table;
868 regData = *accessPtr;
869 for(i=0; i<RTL8367C_LUT_ENTRY_SIZE; i++)
870 {
871 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_WRDATA_BASE + i, regData);
872 if(retVal != RT_ERR_OK)
873 return retVal;
874
875 accessPtr ++;
876 regData = *accessPtr;
877
878 }
879 break;
880 case LUTREADMETHOD_NEXT_L2UCSPA:
881 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_ADDR_REG, pL2Table->address);
882 if(retVal != RT_ERR_OK)
883 return retVal;
884
885 tblCmd = tblCmd | ((pL2Table->spa << RTL8367C_TABLE_ACCESS_CTRL_SPA_OFFSET) & RTL8367C_TABLE_ACCESS_CTRL_SPA_MASK);
886
887 break;
888 default:
889 return RT_ERR_INPUT;
890 }
891
892 tblCmd = tblCmd | ((RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ,TB_TARGET_L2)) & (RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK));
893 /* Read Command */
894 retVal = rtl8367c_setAsicReg(RTL8367C_TABLE_ACCESS_CTRL_REG, tblCmd);
895 if(retVal != RT_ERR_OK)
896 return retVal;
897
898 if(pL2Table->wait_time == 0)
899 busyCounter = RTL8367C_LUT_BUSY_CHECK_NO;
900 else
901 busyCounter = pL2Table->wait_time;
902
903 while(busyCounter)
904 {
905 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,&regData);
906 if(retVal != RT_ERR_OK)
907 return retVal;
908
909 pL2Table->lookup_busy = regData;
910 if(!pL2Table->lookup_busy)
911 break;
912
913 busyCounter --;
914 if(busyCounter == 0)
915 return RT_ERR_BUSYWAIT_TIMEOUT;
916 }
917
918 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_STATUS_REG, RTL8367C_HIT_STATUS_OFFSET,&regData);
919 if(retVal != RT_ERR_OK)
920 return retVal;
921 pL2Table->lookup_hit = regData;
922 if(!pL2Table->lookup_hit)
923 return RT_ERR_L2_ENTRY_NOTFOUND;
924
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,&regData);
927 retVal = rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_STATUS_REG, &regData);
928 if(retVal != RT_ERR_OK)
929 return retVal;
930
931 pL2Table->address = (regData & 0x7ff) | ((regData & 0x4000) >> 3) | ((regData & 0x800) << 1);
932
933 /*read L2 entry */
934 memset(smil2Table, 0x00, sizeof(rtk_uint16) * RTL8367C_LUT_TABLE_SIZE);
935
936 accessPtr = smil2Table;
937
938 for(i = 0; i < RTL8367C_LUT_ENTRY_SIZE; i++)
939 {
940 retVal = rtl8367c_getAsicReg(RTL8367C_TABLE_ACCESS_RDDATA_BASE + i, &regData);
941 if(retVal != RT_ERR_OK)
942 return retVal;
943
944 *accessPtr = regData;
945
946 accessPtr ++;
947 }
948
949 _rtl8367c_fdbStSmi2User(pL2Table, smil2Table);
950
951 return RT_ERR_OK;
952 }
953 /* Function Name:
954 * rtl8367c_getAsicLutLearnNo
955 * Description:
956 * Get per-Port auto learning number
957 * Input:
958 * port - Physical port number (0~7)
959 * pNumber - ASIC auto learning entries number
960 * Output:
961 * None
962 * Return:
963 * RT_ERR_OK - Success
964 * RT_ERR_SMI - SMI access error
965 * RT_ERR_PORT_ID - Invalid port number
966 * Note:
967 * None
968 */
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)
971 {
972 ret_t retVal;
973
974 if(port > RTL8367C_PORTIDMAX)
975 return RT_ERR_PORT_ID;
976
977 if(port < 10)
978 {
979 retVal = rtl8367c_getAsicReg(RTL8367C_REG_L2_LRN_CNT_REG(port), pNumber);
980 if (retVal != RT_ERR_OK)
981 return retVal;
982 }
983 else
984 {
985 retVal = rtl8367c_getAsicReg(RTL8367C_REG_L2_LRN_CNT_CTRL10, pNumber);
986 if (retVal != RT_ERR_OK)
987 return retVal;
988 }
989
990 return RT_ERR_OK;
991 }
992
993 /* Function Name:
994 * rtl8367c_setAsicLutFlushAll
995 * Description:
996 * Flush all entries in LUT. Includes static & dynamic entries
997 * Input:
998 * None
999 * Output:
1000 * None
1001 * Return:
1002 * RT_ERR_OK - Success
1003 * RT_ERR_SMI - SMI access error
1004 * Note:
1005 * None
1006 */
1007 ret_t rtl8367c_setAsicLutFlushAll(void)
1008 {
1009 return rtl8367c_setAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL3, RTL8367C_L2_FLUSH_CTRL3_OFFSET, 1);
1010 }
1011
1012 /* Function Name:
1013 * rtl8367c_getAsicLutFlushAllStatus
1014 * Description:
1015 * Get Flush all status, 1:Busy, 0 normal
1016 * Input:
1017 * None
1018 * Output:
1019 * pBusyStatus - Busy state
1020 * Return:
1021 * RT_ERR_OK - Success
1022 * RT_ERR_SMI - SMI access error
1023 * RT_ERR_NULL_POINTER - Null pointer
1024 * Note:
1025 * None
1026 */
1027 ret_t rtl8367c_getAsicLutFlushAllStatus(rtk_uint32 *pBusyStatus)
1028 {
1029 if(NULL == pBusyStatus)
1030 return RT_ERR_NULL_POINTER;
1031
1032 return rtl8367c_getAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL3, RTL8367C_L2_FLUSH_CTRL3_OFFSET, pBusyStatus);
1033 }
1034
1035 /* Function Name:
1036 * rtl8367c_setAsicLutForceFlush
1037 * Description:
1038 * Set per port force flush setting
1039 * Input:
1040 * portmask - portmask(0~0xFF)
1041 * Output:
1042 * None
1043 * Return:
1044 * RT_ERR_OK - Success
1045 * RT_ERR_SMI - SMI access error
1046 * RT_ERR_PORT_MASK - Invalid portmask
1047 * Note:
1048 * None
1049 */
1050 /*port8~port10µÄÉèÖÃÔÚÁíÍâÒ»¸öregister, wait for updating of base.h, reg.h*/
1051 ret_t rtl8367c_setAsicLutForceFlush(rtk_uint32 portmask)
1052 {
1053 ret_t retVal;
1054
1055 if(portmask > RTL8367C_PORTMASK)
1056 return RT_ERR_PORT_MASK;
1057
1058 retVal = rtl8367c_setAsicRegBits(RTL8367C_FORCE_FLUSH_REG, RTL8367C_FORCE_FLUSH_PORTMASK_MASK, portmask & 0xff);
1059 if(retVal != RT_ERR_OK)
1060 return retVal;
1061
1062 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_FORCE_FLUSH1, RTL8367C_PORTMASK1_MASK, (portmask >> 8) & 0x7);
1063 if(retVal != RT_ERR_OK)
1064 return retVal;
1065
1066 return RT_ERR_OK;
1067 }
1068 /* Function Name:
1069 * rtl8367c_getAsicLutForceFlushStatus
1070 * Description:
1071 * Get per port force flush status
1072 * Input:
1073 * pPortmask - portmask(0~0xFF)
1074 * Output:
1075 * None
1076 * Return:
1077 * RT_ERR_OK - Success
1078 * RT_ERR_SMI - SMI access error
1079 * Note:
1080 * None
1081 */
1082 /*port8~port10µÄÉèÖÃÔÚÁíÍâÒ»¸öregister, wait for updating of base.h, reg.h*/
1083 ret_t rtl8367c_getAsicLutForceFlushStatus(rtk_uint32 *pPortmask)
1084 {
1085 rtk_uint32 tmpMask;
1086 ret_t retVal;
1087
1088 retVal = rtl8367c_getAsicRegBits(RTL8367C_FORCE_FLUSH_REG, RTL8367C_BUSY_STATUS_MASK,&tmpMask);
1089 if(retVal != RT_ERR_OK)
1090 return retVal;
1091 *pPortmask = tmpMask & 0xff;
1092
1093 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_FORCE_FLUSH1, RTL8367C_BUSY_STATUS1_MASK,&tmpMask);
1094 if(retVal != RT_ERR_OK)
1095 return retVal;
1096 *pPortmask |= (tmpMask & 7) << 8;
1097
1098 return RT_ERR_OK;
1099 }
1100 /* Function Name:
1101 * rtl8367c_setAsicLutFlushMode
1102 * Description:
1103 * Set user force L2 pLutSt table flush mode
1104 * Input:
1105 * mode - 0:Port based 1: Port + VLAN based 2:Port + FID/MSTI based
1106 * Output:
1107 * None
1108 * Return:
1109 * RT_ERR_OK - Success
1110 * RT_ERR_SMI - SMI access error
1111 * RT_ERR_NOT_ALLOWED - Actions not allowed by the function
1112 * Note:
1113 * None
1114 */
1115 ret_t rtl8367c_setAsicLutFlushMode(rtk_uint32 mode)
1116 {
1117 if( mode >= FLUSHMDOE_END )
1118 return RT_ERR_NOT_ALLOWED;
1119
1120 return rtl8367c_setAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL2, RTL8367C_LUT_FLUSH_MODE_MASK, mode);
1121 }
1122 /* Function Name:
1123 * rtl8367c_getAsicLutFlushMode
1124 * Description:
1125 * Get user force L2 pLutSt table flush mode
1126 * Input:
1127 * pMode - 0:Port based 1: Port + VLAN based 2:Port + FID/MSTI based
1128 * Output:
1129 * None
1130 * Return:
1131 * RT_ERR_OK - Success
1132 * RT_ERR_SMI - SMI access error
1133 * Note:
1134 * None
1135 */
1136 ret_t rtl8367c_getAsicLutFlushMode(rtk_uint32* pMode)
1137 {
1138 return rtl8367c_getAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL2, RTL8367C_LUT_FLUSH_MODE_MASK, pMode);
1139 }
1140 /* Function Name:
1141 * rtl8367c_setAsicLutFlushType
1142 * Description:
1143 * Get L2 LUT flush type
1144 * Input:
1145 * type - 0: dynamice unicast; 1: both dynamic and static unicast entry
1146 * Output:
1147 * None
1148 * Return:
1149 * RT_ERR_OK - Success
1150 * RT_ERR_SMI - SMI access error
1151 * Note:
1152 * None
1153 */
1154 ret_t rtl8367c_setAsicLutFlushType(rtk_uint32 type)
1155 {
1156 return rtl8367c_setAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL2, RTL8367C_LUT_FLUSH_TYPE_OFFSET,type);
1157 }
1158 /* Function Name:
1159 * rtl8367c_getAsicLutFlushType
1160 * Description:
1161 * Set L2 LUT flush type
1162 * Input:
1163 * pType - 0: dynamice unicast; 1: both dynamic and static unicast entry
1164 * Output:
1165 * None
1166 * Return:
1167 * RT_ERR_OK - Success
1168 * RT_ERR_SMI - SMI access error
1169 * Note:
1170 * None
1171 */
1172 ret_t rtl8367c_getAsicLutFlushType(rtk_uint32* pType)
1173 {
1174 return rtl8367c_getAsicRegBit(RTL8367C_REG_L2_FLUSH_CTRL2, RTL8367C_LUT_FLUSH_TYPE_OFFSET,pType);
1175 }
1176
1177
1178 /* Function Name:
1179 * rtl8367c_setAsicLutFlushVid
1180 * Description:
1181 * Set VID of Port + VID pLutSt flush mode
1182 * Input:
1183 * vid - Vid (0~4095)
1184 * Output:
1185 * None
1186 * Return:
1187 * RT_ERR_OK - Success
1188 * RT_ERR_SMI - SMI access error
1189 * RT_ERR_VLAN_VID - Invalid VID parameter (0~4095)
1190 * Note:
1191 * None
1192 */
1193 ret_t rtl8367c_setAsicLutFlushVid(rtk_uint32 vid)
1194 {
1195 if( vid > RTL8367C_VIDMAX )
1196 return RT_ERR_VLAN_VID;
1197
1198 return rtl8367c_setAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1, RTL8367C_LUT_FLUSH_VID_MASK, vid);
1199 }
1200 /* Function Name:
1201 * rtl8367c_getAsicLutFlushVid
1202 * Description:
1203 * Get VID of Port + VID pLutSt flush mode
1204 * Input:
1205 * pVid - Vid (0~4095)
1206 * Output:
1207 * None
1208 * Return:
1209 * RT_ERR_OK - Success
1210 * RT_ERR_SMI - SMI access error
1211 * Note:
1212 * None
1213 */
1214 ret_t rtl8367c_getAsicLutFlushVid(rtk_uint32* pVid)
1215 {
1216 return rtl8367c_getAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1, RTL8367C_LUT_FLUSH_VID_MASK, pVid);
1217 }
1218 /* Function Name:
1219 * rtl8367c_setAsicPortFlusdFid
1220 * Description:
1221 * Set FID of Port + FID pLutSt flush mode
1222 * Input:
1223 * fid - FID/MSTI for force flush
1224 * Output:
1225 * None
1226 * Return:
1227 * RT_ERR_OK - Success
1228 * RT_ERR_SMI - SMI access error
1229 * RT_ERR_L2_FID - Invalid FID (0~15)
1230 * Note:
1231 * None
1232 */
1233 ret_t rtl8367c_setAsicLutFlushFid(rtk_uint32 fid)
1234 {
1235 if( fid > RTL8367C_FIDMAX )
1236 return RT_ERR_L2_FID;
1237
1238 return rtl8367c_setAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1, RTL8367C_LUT_FLUSH_FID_MASK, fid);
1239 }
1240 /* Function Name:
1241 * rtl8367c_getAsicLutFlushFid
1242 * Description:
1243 * Get FID of Port + FID pLutSt flush mode
1244 * Input:
1245 * pFid - FID/MSTI for force flush
1246 * Output:
1247 * None
1248 * Return:
1249 * RT_ERR_OK - Success
1250 * RT_ERR_SMI - SMI access error
1251 * Note:
1252 * None
1253 */
1254 ret_t rtl8367c_getAsicLutFlushFid(rtk_uint32* pFid)
1255 {
1256 return rtl8367c_getAsicRegBits(RTL8367C_REG_L2_FLUSH_CTRL1, RTL8367C_LUT_FLUSH_FID_MASK, pFid);
1257 }
1258 /* Function Name:
1259 * rtl8367c_setAsicLutDisableAging
1260 * Description:
1261 * Set L2 LUT aging per port setting
1262 * Input:
1263 * port - Physical port number (0~7)
1264 * disabled - 0: enable aging; 1: disabling aging
1265 * Output:
1266 * None
1267 * Return:
1268 * RT_ERR_OK - Success
1269 * RT_ERR_SMI - SMI access error
1270 * RT_ERR_PORT_ID - Invalid port number
1271 * Note:
1272 * None
1273 */
1274 /*ÐÞ¸ÄRTL8367C_PORTIDMAX*/
1275 ret_t rtl8367c_setAsicLutDisableAging(rtk_uint32 port, rtk_uint32 disabled)
1276 {
1277 if(port > RTL8367C_PORTIDMAX)
1278 return RT_ERR_PORT_ID;
1279
1280 return rtl8367c_setAsicRegBit(RTL8367C_LUT_AGEOUT_CTRL_REG, port, disabled);
1281 }
1282 /* Function Name:
1283 * rtl8367c_getAsicLutDisableAging
1284 * Description:
1285 * Get L2 LUT aging per port setting
1286 * Input:
1287 * port - Physical port number (0~7)
1288 * pDisabled - 0: enable aging; 1: disabling aging
1289 * Output:
1290 * None
1291 * Return:
1292 * RT_ERR_OK - Success
1293 * RT_ERR_SMI - SMI access error
1294 * RT_ERR_PORT_ID - Invalid port number
1295 * Note:
1296 * None
1297 */
1298 /*ÐÞ¸ÄRTL8367C_PORTIDMAX*/
1299 ret_t rtl8367c_getAsicLutDisableAging(rtk_uint32 port, rtk_uint32 *pDisabled)
1300 {
1301 if(port > RTL8367C_PORTIDMAX)
1302 return RT_ERR_PORT_ID;
1303
1304 return rtl8367c_getAsicRegBit(RTL8367C_LUT_AGEOUT_CTRL_REG, port, pDisabled);
1305 }
1306
1307 /* Function Name:
1308 * rtl8367c_setAsicLutIPMCGroup
1309 * Description:
1310 * Set IPMC Group Table
1311 * Input:
1312 * index - the entry index in table (0 ~ 63)
1313 * group_addr - the multicast group address (224.0.0.0 ~ 239.255.255.255)
1314 * vid - VLAN ID
1315 * pmask - portmask
1316 * valid - valid bit
1317 * Output:
1318 * None
1319 * Return:
1320 * RT_ERR_OK - Success
1321 * RT_ERR_SMI - SMI access error
1322 * RT_ERR_INPUT - Invalid parameter
1323 * Note:
1324 * None
1325 */
1326 ret_t rtl8367c_setAsicLutIPMCGroup(rtk_uint32 index, ipaddr_t group_addr, rtk_uint32 vid, rtk_uint32 pmask, rtk_uint32 valid)
1327 {
1328 rtk_uint32 regAddr, regData, bitoffset;
1329 ipaddr_t ipData;
1330 ret_t retVal;
1331
1332 if(index > RTL8367C_LUT_IPMCGRP_TABLE_MAX)
1333 return RT_ERR_INPUT;
1334
1335 if (vid > RTL8367C_VIDMAX)
1336 return RT_ERR_VLAN_VID;
1337
1338 ipData = group_addr;
1339
1340 if( (ipData & 0xF0000000) != 0xE0000000) /* not in 224.0.0.0 ~ 239.255.255.255 */
1341 return RT_ERR_INPUT;
1342
1343 /* Group Address */
1344 regAddr = RTL8367C_REG_IPMC_GROUP_ENTRY0_H + (index * 2);
1345 regData = ((ipData & 0x0FFFFFFF) >> 16);
1346
1347 if( (retVal = rtl8367c_setAsicReg(regAddr, regData)) != RT_ERR_OK)
1348 return retVal;
1349
1350 regAddr++;
1351 regData = (ipData & 0x0000FFFF);
1352
1353 if( (retVal = rtl8367c_setAsicReg(regAddr, regData)) != RT_ERR_OK)
1354 return retVal;
1355
1356 /* VID */
1357 regAddr = RTL8367C_REG_IPMC_GROUP_VID_00 + index;
1358 regData = vid;
1359
1360 if( (retVal = rtl8367c_setAsicReg(regAddr, regData)) != RT_ERR_OK)
1361 return retVal;
1362
1363 /* portmask */
1364 regAddr = RTL8367C_REG_IPMC_GROUP_PMSK_00 + index;
1365 regData = pmask;
1366
1367 if( (retVal = rtl8367c_setAsicReg(regAddr, regData)) != RT_ERR_OK)
1368 return retVal;
1369
1370 /* valid */
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)
1374 return retVal;
1375
1376 return RT_ERR_OK;
1377 }
1378
1379 /* Function Name:
1380 * rtl8367c_getAsicLutIPMCGroup
1381 * Description:
1382 * Set IPMC Group Table
1383 * Input:
1384 * index - the entry index in table (0 ~ 63)
1385 * Output:
1386 * pGroup_addr - the multicast group address (224.0.0.0 ~ 239.255.255.255)
1387 * pVid - VLAN ID
1388 * pPmask - portmask
1389 * pValid - Valid bit
1390 * Return:
1391 * RT_ERR_OK - Success
1392 * RT_ERR_SMI - SMI access error
1393 * RT_ERR_INPUT - Invalid parameter
1394 * Note:
1395 * None
1396 */
1397 ret_t rtl8367c_getAsicLutIPMCGroup(rtk_uint32 index, ipaddr_t *pGroup_addr, rtk_uint32 *pVid, rtk_uint32 *pPmask, rtk_uint32 *pValid)
1398 {
1399 rtk_uint32 regAddr, regData, bitoffset;
1400 ipaddr_t ipData;
1401 ret_t retVal;
1402
1403 if(index > RTL8367C_LUT_IPMCGRP_TABLE_MAX)
1404 return RT_ERR_INPUT;
1405
1406 if (NULL == pGroup_addr)
1407 return RT_ERR_NULL_POINTER;
1408
1409 if (NULL == pVid)
1410 return RT_ERR_NULL_POINTER;
1411
1412 if (NULL == pPmask)
1413 return RT_ERR_NULL_POINTER;
1414
1415 /* Group address */
1416 regAddr = RTL8367C_REG_IPMC_GROUP_ENTRY0_H + (index * 2);
1417 if( (retVal = rtl8367c_getAsicReg(regAddr, &regData)) != RT_ERR_OK)
1418 return retVal;
1419
1420 *pGroup_addr = (((regData & 0x00000FFF) << 16) | 0xE0000000);
1421
1422 regAddr++;
1423 if( (retVal = rtl8367c_getAsicReg(regAddr, &regData)) != RT_ERR_OK)
1424 return retVal;
1425
1426 ipData = (*pGroup_addr | (regData & 0x0000FFFF));
1427 *pGroup_addr = ipData;
1428
1429 /* VID */
1430 regAddr = RTL8367C_REG_IPMC_GROUP_VID_00 + index;
1431 if( (retVal = rtl8367c_getAsicReg(regAddr, &regData)) != RT_ERR_OK)
1432 return retVal;
1433
1434 *pVid = regData;
1435
1436 /* portmask */
1437 regAddr = RTL8367C_REG_IPMC_GROUP_PMSK_00 + index;
1438 if( (retVal = rtl8367c_getAsicReg(regAddr, &regData)) != RT_ERR_OK)
1439 return retVal;
1440
1441 *pPmask = regData;
1442
1443 /* valid */
1444 regAddr = RTL8367C_REG_IPMC_GROUP_VALID_15_0 + (index / 16);
1445 bitoffset = index % 16;
1446 if( (retVal = rtl8367c_getAsicRegBit(regAddr, bitoffset, &regData)) != RT_ERR_OK)
1447 return retVal;
1448
1449 *pValid = regData;
1450
1451 return RT_ERR_OK;
1452 }
1453
1454 /* Function Name:
1455 * rtl8367c_setAsicLutLinkDownForceAging
1456 * Description:
1457 * Set LUT link down aging setting.
1458 * Input:
1459 * enable - link down aging setting
1460 * Output:
1461 * None
1462 * Return:
1463 * RT_ERR_OK - Success
1464 * RT_ERR_SMI - SMI access error
1465 * RT_ERR_ENABLE - Invalid parameter
1466 * Note:
1467 * None
1468 */
1469 ret_t rtl8367c_setAsicLutLinkDownForceAging(rtk_uint32 enable)
1470 {
1471 if(enable > 1)
1472 return RT_ERR_ENABLE;
1473
1474 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_LINKDOWN_AGEOUT_OFFSET, enable ? 0 : 1);
1475 }
1476
1477 /* Function Name:
1478 * rtl8367c_getAsicLutLinkDownForceAging
1479 * Description:
1480 * Get LUT link down aging setting.
1481 * Input:
1482 * pEnable - link down aging setting
1483 * Output:
1484 * None
1485 * Return:
1486 * RT_ERR_OK - Success
1487 * RT_ERR_SMI - SMI access error
1488 * RT_ERR_ENABLE - Invalid parameter
1489 * Note:
1490 * None
1491 */
1492 ret_t rtl8367c_getAsicLutLinkDownForceAging(rtk_uint32 *pEnable)
1493 {
1494 rtk_uint32 value;
1495 ret_t retVal;
1496
1497 if ((retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG, RTL8367C_LINKDOWN_AGEOUT_OFFSET, &value)) != RT_ERR_OK)
1498 return retVal;
1499
1500 *pEnable = value ? 0 : 1;
1501 return RT_ERR_OK;
1502 }
1503
1504 /* Function Name:
1505 * rtl8367c_setAsicLutIpmcFwdRouterPort
1506 * Description:
1507 * Set IPMC packet forward to rounter port also or not
1508 * Input:
1509 * enable - 1: Inlcude router port, 0, exclude router port
1510 * Output:
1511 * None
1512 * Return:
1513 * RT_ERR_OK - Success
1514 * RT_ERR_SMI - SMI access error
1515 * RT_ERR_ENABLE Invalid parameter
1516 * Note:
1517 * None
1518 */
1519 ret_t rtl8367c_setAsicLutIpmcFwdRouterPort(rtk_uint32 enable)
1520 {
1521 if(enable > 1)
1522 return RT_ERR_ENABLE;
1523
1524 return rtl8367c_setAsicRegBit(RTL8367C_REG_LUT_CFG2, RTL8367C_LUT_IPMC_FWD_RPORT_OFFSET, enable);
1525 }
1526
1527 /* Function Name:
1528 * rtl8367c_getAsicLutIpmcFwdRouterPort
1529 * Description:
1530 * Get IPMC packet forward to rounter port also or not
1531 * Input:
1532 * None
1533 * Output:
1534 * pEnable - 1: Inlcude router port, 0, exclude router port
1535 * Return:
1536 * RT_ERR_OK - Success
1537 * RT_ERR_SMI - SMI access error
1538 * RT_ERR_NULL_POINTER - Null pointer
1539 * Note:
1540 * None
1541 */
1542 ret_t rtl8367c_getAsicLutIpmcFwdRouterPort(rtk_uint32 *pEnable)
1543 {
1544 if(NULL == pEnable)
1545 return RT_ERR_NULL_POINTER;
1546
1547 return rtl8367c_getAsicRegBit(RTL8367C_REG_LUT_CFG2, RTL8367C_LUT_IPMC_FWD_RPORT_OFFSET, pEnable);
1548 }
1549
Rafal Mileckis staging tree