projects / openwrt / openwrt.git / blob
? search:


d9ccd97118c4511a86f2c2bebb9c5bdde091b8b0
[openwrt/openwrt.git] / target / linux / mediatek / files-5.10 / drivers / net / phy / rtk / rtl8367c / rtl8367c_asicdrv_acl.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 : ACL related function drivers
15 *
16 */
17 #include <rtl8367c_asicdrv_acl.h>
18
19 #include <string.h>
20
21 #if defined(CONFIG_RTL8367C_ASICDRV_TEST)
22 rtl8367c_aclrulesmi Rtl8370sVirtualAclRuleTable[RTL8367C_ACLRULENO];
23 rtk_uint16 Rtl8370sVirtualAclActTable[RTL8367C_ACLRULENO][RTL8367C_ACL_ACT_TABLE_LEN];
24 #endif
25
26 /*
27 Exchange structure type define with MMI and SMI
28 */
29 static void _rtl8367c_aclRuleStSmi2User( rtl8367c_aclrule *pAclUser, rtl8367c_aclrulesmi *pAclSmi)
30 {
31 rtk_uint8 *care_ptr, *data_ptr;
32 rtk_uint8 care_tmp, data_tmp;
33 rtk_uint32 i;
34
35 pAclUser->data_bits.active_portmsk = (((pAclSmi->data_bits_ext.rule_info >> 1) & 0x0007) << 8) | ((pAclSmi->data_bits.rule_info >> 8) & 0x00FF);
36 pAclUser->data_bits.type = (pAclSmi->data_bits.rule_info & 0x0007);
37 pAclUser->data_bits.tag_exist = (pAclSmi->data_bits.rule_info & 0x00F8) >> 3;
38
39 care_ptr = (rtk_uint8*)&pAclSmi->care_bits;
40 data_ptr = (rtk_uint8*)&pAclSmi->data_bits;
41
42 for ( i = 0; i < sizeof(struct acl_rule_smi_st); i++)
43 {
44 care_tmp = *(care_ptr + i) ^ (*(data_ptr + i));
45 data_tmp = *(data_ptr + i);
46
47 *(care_ptr + i) = care_tmp;
48 *(data_ptr + i) = data_tmp;
49 }
50
51 care_ptr = (rtk_uint8*)&pAclSmi->care_bits_ext;
52 data_ptr = (rtk_uint8*)&pAclSmi->data_bits_ext;
53 care_tmp = (*care_ptr) ^ (*data_ptr);
54 data_tmp = (*data_ptr);
55 *care_ptr = care_tmp;
56 *data_ptr = data_tmp;
57
58 for(i = 0; i < RTL8367C_ACLRULEFIELDNO; i++)
59 pAclUser->data_bits.field[i] = pAclSmi->data_bits.field[i];
60
61 pAclUser->valid = pAclSmi->valid;
62
63 pAclUser->care_bits.active_portmsk = (((pAclSmi->care_bits_ext.rule_info >> 1) & 0x0007) << 8) | ((pAclSmi->care_bits.rule_info >> 8) & 0x00FF);
64 pAclUser->care_bits.type = (pAclSmi->care_bits.rule_info & 0x0007);
65 pAclUser->care_bits.tag_exist = (pAclSmi->care_bits.rule_info & 0x00F8) >> 3;
66
67 for(i = 0; i < RTL8367C_ACLRULEFIELDNO; i++)
68 pAclUser->care_bits.field[i] = pAclSmi->care_bits.field[i];
69 }
70
71 /*
72 Exchange structure type define with MMI and SMI
73 */
74 static void _rtl8367c_aclRuleStUser2Smi(rtl8367c_aclrule *pAclUser, rtl8367c_aclrulesmi *pAclSmi)
75 {
76 rtk_uint8 *care_ptr, *data_ptr;
77 rtk_uint8 care_tmp, data_tmp;
78 rtk_uint32 i;
79
80 pAclSmi->data_bits_ext.rule_info = ((pAclUser->data_bits.active_portmsk >> 8) & 0x7) << 1;
81 pAclSmi->data_bits.rule_info = ((pAclUser->data_bits.active_portmsk & 0xff) << 8) | ((pAclUser->data_bits.tag_exist & 0x1F) << 3) | (pAclUser->data_bits.type & 0x07);
82
83 for(i = 0;i < RTL8367C_ACLRULEFIELDNO; i++)
84 pAclSmi->data_bits.field[i] = pAclUser->data_bits.field[i];
85
86 pAclSmi->valid = pAclUser->valid;
87
88 pAclSmi->care_bits_ext.rule_info = ((pAclUser->care_bits.active_portmsk >> 8) & 0x7) << 1;
89 pAclSmi->care_bits.rule_info = ((pAclUser->care_bits.active_portmsk & 0xff) << 8) | ((pAclUser->care_bits.tag_exist & 0x1F) << 3) | (pAclUser->care_bits.type & 0x07);
90
91 for(i = 0; i < RTL8367C_ACLRULEFIELDNO; i++)
92 pAclSmi->care_bits.field[i] = pAclUser->care_bits.field[i];
93
94 care_ptr = (rtk_uint8*)&pAclSmi->care_bits;
95 data_ptr = (rtk_uint8*)&pAclSmi->data_bits;
96
97 for ( i = 0; i < sizeof(struct acl_rule_smi_st); i++)
98 {
99 care_tmp = *(care_ptr + i) & ~(*(data_ptr + i));
100 data_tmp = *(care_ptr + i) & *(data_ptr + i);
101
102 *(care_ptr + i) = care_tmp;
103 *(data_ptr + i) = data_tmp;
104 }
105
106 care_ptr = (rtk_uint8*)&pAclSmi->care_bits_ext;
107 data_ptr = (rtk_uint8*)&pAclSmi->data_bits_ext;
108 care_tmp = *care_ptr & ~(*data_ptr);
109 data_tmp = *care_ptr & *data_ptr;
110
111 *care_ptr = care_tmp;
112 *data_ptr = data_tmp;
113 }
114
115 /*
116 Exchange structure type define with MMI and SMI
117 */
118 static void _rtl8367c_aclActStSmi2User(rtl8367c_acl_act_t *pAclUser, rtk_uint16 *pAclSmi)
119 {
120 pAclUser->cact = (pAclSmi[0] & 0x00C0) >> 6;
121 pAclUser->cvidx_cact = (pAclSmi[0] & 0x003F) | (((pAclSmi[3] & 0x0008) >> 3) << 6);
122
123 pAclUser->sact = (pAclSmi[0] & 0xC000) >> 14;
124 pAclUser->svidx_sact = ((pAclSmi[0] & 0x3F00) >> 8) | (((pAclSmi[3] & 0x0010) >> 4) << 6);
125
126 pAclUser->aclmeteridx = (pAclSmi[1] & 0x003F) | (((pAclSmi[3] & 0x0020) >> 5) << 6);
127
128 pAclUser->fwdact = (pAclSmi[1] & 0xC000) >> 14;
129 pAclUser->fwdpmask = ((pAclSmi[1] & 0x3FC0) >> 6) | (((pAclSmi[3] & 0x01C0) >> 6) << 8);
130
131 pAclUser->priact = (pAclSmi[2] & 0x00C0) >> 6;
132 pAclUser->pridx = (pAclSmi[2] & 0x003F) | (((pAclSmi[3] & 0x0200) >> 9) << 6);
133
134 pAclUser->aclint = (pAclSmi[2] & 0x2000) >> 13;
135 pAclUser->gpio_en = (pAclSmi[2] & 0x1000) >> 12;
136 pAclUser->gpio_pin = (pAclSmi[2] & 0x0F00) >> 8;
137
138 pAclUser->cact_ext = (pAclSmi[2] & 0xC000) >> 14;
139 pAclUser->tag_fmt = (pAclSmi[3] & 0x0003);
140 pAclUser->fwdact_ext = (pAclSmi[3] & 0x0004) >> 2;
141 }
142
143 /*
144 Exchange structure type define with MMI and SMI
145 */
146 static void _rtl8367c_aclActStUser2Smi(rtl8367c_acl_act_t *pAclUser, rtk_uint16 *pAclSmi)
147 {
148 pAclSmi[0] |= (pAclUser->cvidx_cact & 0x003F);
149 pAclSmi[0] |= (pAclUser->cact & 0x0003) << 6;
150 pAclSmi[0] |= (pAclUser->svidx_sact & 0x003F) << 8;
151 pAclSmi[0] |= (pAclUser->sact & 0x0003) << 14;
152
153 pAclSmi[1] |= (pAclUser->aclmeteridx & 0x003F);
154 pAclSmi[1] |= (pAclUser->fwdpmask & 0x00FF) << 6;
155 pAclSmi[1] |= (pAclUser->fwdact & 0x0003) << 14;
156
157 pAclSmi[2] |= (pAclUser->pridx & 0x003F);
158 pAclSmi[2] |= (pAclUser->priact & 0x0003) << 6;
159 pAclSmi[2] |= (pAclUser->gpio_pin & 0x000F) << 8;
160 pAclSmi[2] |= (pAclUser->gpio_en & 0x0001) << 12;
161 pAclSmi[2] |= (pAclUser->aclint & 0x0001) << 13;
162 pAclSmi[2] |= (pAclUser->cact_ext & 0x0003) << 14;
163
164 pAclSmi[3] |= (pAclUser->tag_fmt & 0x0003);
165 pAclSmi[3] |= (pAclUser->fwdact_ext & 0x0001) << 2;
166 pAclSmi[3] |= ((pAclUser->cvidx_cact & 0x0040) >> 6) << 3;
167 pAclSmi[3] |= ((pAclUser->svidx_sact & 0x0040) >> 6) << 4;
168 pAclSmi[3] |= ((pAclUser->aclmeteridx & 0x0040) >> 6) << 5;
169 pAclSmi[3] |= ((pAclUser->fwdpmask & 0x0700) >> 8) << 6;
170 pAclSmi[3] |= ((pAclUser->pridx & 0x0040) >> 6) << 9;
171 }
172
173 /* Function Name:
174 * rtl8367c_setAsicAcl
175 * Description:
176 * Set port acl function enable/disable
177 * Input:
178 * port - Physical port number (0~10)
179 * enabled - 1: enabled, 0: disabled
180 * Output:
181 * None
182 * Return:
183 * RT_ERR_OK - Success
184 * RT_ERR_SMI - SMI access error
185 * RT_ERR_PORT_ID - Invalid port number
186 * Note:
187 * None
188 */
189 ret_t rtl8367c_setAsicAcl(rtk_uint32 port, rtk_uint32 enabled)
190 {
191 if(port > RTL8367C_PORTIDMAX)
192 return RT_ERR_PORT_ID;
193
194 return rtl8367c_setAsicRegBit(RTL8367C_ACL_ENABLE_REG, port, enabled);
195 }
196 /* Function Name:
197 * rtl8367c_getAsicAcl
198 * Description:
199 * Get port acl function enable/disable
200 * Input:
201 * port - Physical port number (0~10)
202 * enabled - 1: enabled, 0: disabled
203 * Output:
204 * None
205 * Return:
206 * RT_ERR_OK - Success
207 * RT_ERR_SMI - SMI access error
208 * RT_ERR_PORT_ID - Invalid port number
209 * Note:
210 * None
211 */
212 ret_t rtl8367c_getAsicAcl(rtk_uint32 port, rtk_uint32* pEnabled)
213 {
214 if(port > RTL8367C_PORTIDMAX)
215 return RT_ERR_PORT_ID;
216
217 return rtl8367c_getAsicRegBit(RTL8367C_ACL_ENABLE_REG, port, pEnabled);
218 }
219 /* Function Name:
220 * rtl8367c_setAsicAclUnmatchedPermit
221 * Description:
222 * Set port acl function unmatched permit action
223 * Input:
224 * port - Physical port number (0~10)
225 * enabled - 1: enabled, 0: disabled
226 * Output:
227 * None
228 * Return:
229 * RT_ERR_OK - Success
230 * RT_ERR_SMI - SMI access error
231 * RT_ERR_PORT_ID - Invalid port number
232 * Note:
233 * None
234 */
235 ret_t rtl8367c_setAsicAclUnmatchedPermit(rtk_uint32 port, rtk_uint32 enabled)
236 {
237 if(port > RTL8367C_PORTIDMAX)
238 return RT_ERR_PORT_ID;
239
240 return rtl8367c_setAsicRegBit(RTL8367C_ACL_UNMATCH_PERMIT_REG, port, enabled);
241 }
242 /* Function Name:
243 * rtl8367c_getAsicAclUnmatchedPermit
244 * Description:
245 * Get port acl function unmatched permit action
246 * Input:
247 * port - Physical port number (0~10)
248 * enabled - 1: enabled, 0: disabled
249 * Output:
250 * None
251 * Return:
252 * RT_ERR_OK - Success
253 * RT_ERR_SMI - SMI access error
254 * RT_ERR_PORT_ID - Invalid port number
255 * Note:
256 * None
257 */
258 ret_t rtl8367c_getAsicAclUnmatchedPermit(rtk_uint32 port, rtk_uint32* pEnabled)
259 {
260 if(port > RTL8367C_PORTIDMAX)
261 return RT_ERR_PORT_ID;
262
263 return rtl8367c_getAsicRegBit(RTL8367C_ACL_UNMATCH_PERMIT_REG, port, pEnabled);
264 }
265
266 /* Function Name:
267 * rtl8367c_setAsicAclRule
268 * Description:
269 * Set acl rule content
270 * Input:
271 * index - ACL rule index (0-95) of 96 ACL rules
272 * pAclRule - ACL rule stucture for setting
273 * Output:
274 * None
275 * Return:
276 * RT_ERR_OK - Success
277 * RT_ERR_SMI - SMI access error
278 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
279 * Note:
280 * System supported 95 shared 289-bit ACL ingress rule. Index was available at range 0-95 only.
281 * If software want to modify ACL rule, the ACL function should be disable at first or unspecify
282 * acl action will be executed.
283 * One ACL rule structure has three parts setting:
284 * Bit 0-147 Data Bits of this Rule
285 * Bit 148 Valid Bit
286 * Bit 149-296 Care Bits of this Rule
287 * There are four kinds of field in Data Bits and Care Bits: Active Portmask, Type, Tag Exist, and 8 fields
288 */
289 ret_t rtl8367c_setAsicAclRule(rtk_uint32 index, rtl8367c_aclrule* pAclRule)
290 {
291 rtl8367c_aclrulesmi aclRuleSmi;
292 rtk_uint16* tableAddr;
293 rtk_uint32 regAddr;
294 rtk_uint32 regData;
295 rtk_uint32 i;
296 ret_t retVal;
297
298 if(index > RTL8367C_ACLRULEMAX)
299 return RT_ERR_OUT_OF_RANGE;
300
301 memset(&aclRuleSmi, 0x00, sizeof(rtl8367c_aclrulesmi));
302
303 _rtl8367c_aclRuleStUser2Smi(pAclRule, &aclRuleSmi);
304
305 /* Write valid bit = 0 */
306 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
307 if(index >= 64)
308 regData = RTL8367C_ACLRULETBADDR2(DATABITS, index);
309 else
310 regData = RTL8367C_ACLRULETBADDR(DATABITS, index);
311 retVal = rtl8367c_setAsicReg(regAddr,regData);
312 if(retVal !=RT_ERR_OK)
313 return retVal;
314
315 retVal = rtl8367c_setAsicRegBits(RTL8367C_TABLE_ACCESS_WRDATA_REG(RTL8367C_ACLRULETBLEN), 0x1, 0);
316 if(retVal !=RT_ERR_OK)
317 return retVal;
318
319 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
320 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE, TB_TARGET_ACLRULE);
321 retVal = rtl8367c_setAsicReg(regAddr, regData);
322 if(retVal !=RT_ERR_OK)
323 return retVal;
324
325
326
327 /* Write ACS_ADR register */
328 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
329 if(index >= 64)
330 regData = RTL8367C_ACLRULETBADDR2(CAREBITS, index);
331 else
332 regData = RTL8367C_ACLRULETBADDR(CAREBITS, index);
333 retVal = rtl8367c_setAsicReg(regAddr, regData);
334 if(retVal != RT_ERR_OK)
335 return retVal;
336
337 /* Write Care Bits to ACS_DATA registers */
338 tableAddr = (rtk_uint16*)&aclRuleSmi.care_bits;
339 regAddr = RTL8367C_TABLE_ACCESS_WRDATA_BASE;
340
341 for(i = 0; i < RTL8367C_ACLRULETBLEN; i++)
342 {
343 regData = *tableAddr;
344 retVal = rtl8367c_setAsicReg(regAddr, regData);
345 if(retVal != RT_ERR_OK)
346 return retVal;
347
348 regAddr++;
349 tableAddr++;
350 }
351 retVal = rtl8367c_setAsicRegBits(RTL8367C_TABLE_ACCESS_WRDATA_REG(RTL8367C_ACLRULETBLEN), (0x0007 << 1), (aclRuleSmi.care_bits_ext.rule_info >> 1) & 0x0007);
352 if(retVal != RT_ERR_OK)
353 return retVal;
354
355 /* Write ACS_CMD register */
356 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
357 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE, TB_TARGET_ACLRULE);
358 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK,regData);
359 if(retVal != RT_ERR_OK)
360 return retVal;
361
362
363
364 /* Write ACS_ADR register for data bits */
365 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
366 if(index >= 64)
367 regData = RTL8367C_ACLRULETBADDR2(DATABITS, index);
368 else
369 regData = RTL8367C_ACLRULETBADDR(DATABITS, index);
370
371 retVal = rtl8367c_setAsicReg(regAddr, regData);
372 if(retVal != RT_ERR_OK)
373 return retVal;
374
375 /* Write Data Bits to ACS_DATA registers */
376 tableAddr = (rtk_uint16*)&aclRuleSmi.data_bits;
377 regAddr = RTL8367C_TABLE_ACCESS_WRDATA_BASE;
378
379 for(i = 0; i < RTL8367C_ACLRULETBLEN; i++)
380 {
381 regData = *tableAddr;
382 retVal = rtl8367c_setAsicReg(regAddr, regData);
383 if(retVal != RT_ERR_OK)
384 return retVal;
385
386 regAddr++;
387 tableAddr++;
388 }
389
390 retVal = rtl8367c_setAsicRegBit(RTL8367C_TABLE_ACCESS_WRDATA_REG(RTL8367C_ACLRULETBLEN), 0, aclRuleSmi.valid);
391 if(retVal != RT_ERR_OK)
392 return retVal;
393 retVal = rtl8367c_setAsicRegBits(RTL8367C_TABLE_ACCESS_WRDATA_REG(RTL8367C_ACLRULETBLEN), (0x0007 << 1), (aclRuleSmi.data_bits_ext.rule_info >> 1) & 0x0007);
394 if(retVal != RT_ERR_OK)
395 return retVal;
396
397 /* Write ACS_CMD register for care bits*/
398 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
399 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE, TB_TARGET_ACLRULE);
400 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData);
401 if(retVal != RT_ERR_OK)
402 return retVal;
403
404 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
405 memcpy(&Rtl8370sVirtualAclRuleTable[index], &aclRuleSmi, sizeof(rtl8367c_aclrulesmi));
406 #endif
407
408 return RT_ERR_OK;
409 }
410 /* Function Name:
411 * rtl8367c_getAsicAclRule
412 * Description:
413 * Get acl rule content
414 * Input:
415 * index - ACL rule index (0-63) of 64 ACL rules
416 * pAclRule - ACL rule stucture for setting
417 * Output:
418 * None
419 * Return:
420 * RT_ERR_OK - Success
421 * RT_ERR_SMI - SMI access error
422 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-63)
423 * Note:
424 * None
425 */
426 ret_t rtl8367c_getAsicAclRule(rtk_uint32 index, rtl8367c_aclrule *pAclRule)
427 {
428 rtl8367c_aclrulesmi aclRuleSmi;
429 rtk_uint32 regAddr, regData;
430 ret_t retVal;
431 rtk_uint16* tableAddr;
432 rtk_uint32 i;
433
434 if(index > RTL8367C_ACLRULEMAX)
435 return RT_ERR_OUT_OF_RANGE;
436
437 memset(&aclRuleSmi, 0x00, sizeof(rtl8367c_aclrulesmi));
438
439 /* Write ACS_ADR register for data bits */
440 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
441 if(index >= 64)
442 regData = RTL8367C_ACLRULETBADDR2(DATABITS, index);
443 else
444 regData = RTL8367C_ACLRULETBADDR(DATABITS, index);
445
446 retVal = rtl8367c_setAsicReg(regAddr, regData);
447 if(retVal != RT_ERR_OK)
448 return retVal;
449
450
451 /* Write ACS_CMD register */
452 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
453 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ, TB_TARGET_ACLRULE);
454 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData);
455 if(retVal != RT_ERR_OK)
456 return retVal;
457
458 /* Read Data Bits */
459 regAddr = RTL8367C_TABLE_ACCESS_RDDATA_BASE;
460 tableAddr = (rtk_uint16*)&aclRuleSmi.data_bits;
461 for(i = 0; i < RTL8367C_ACLRULETBLEN; i++)
462 {
463 retVal = rtl8367c_getAsicReg(regAddr, &regData);
464 if(retVal != RT_ERR_OK)
465 return retVal;
466
467 *tableAddr = regData;
468
469 regAddr ++;
470 tableAddr ++;
471 }
472
473 /* Read Valid Bit */
474 retVal = rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_RDDATA_REG(RTL8367C_ACLRULETBLEN), 0, &regData);
475 if(retVal != RT_ERR_OK)
476 return retVal;
477 aclRuleSmi.valid = regData & 0x1;
478 /* Read active_portmsk_ext Bits */
479 retVal = rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_RDDATA_REG(RTL8367C_ACLRULETBLEN), 0x7<<1, &regData);
480 if(retVal != RT_ERR_OK)
481 return retVal;
482 aclRuleSmi.data_bits_ext.rule_info = (regData % 0x0007) << 1;
483
484
485 /* Write ACS_ADR register for carebits*/
486 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
487 if(index >= 64)
488 regData = RTL8367C_ACLRULETBADDR2(CAREBITS, index);
489 else
490 regData = RTL8367C_ACLRULETBADDR(CAREBITS, index);
491
492 retVal = rtl8367c_setAsicReg(regAddr, regData);
493 if(retVal != RT_ERR_OK)
494 return retVal;
495
496 /* Write ACS_CMD register */
497 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
498 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ, TB_TARGET_ACLRULE);
499 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData);
500 if(retVal != RT_ERR_OK)
501 return retVal;
502
503 /* Read Care Bits */
504 regAddr = RTL8367C_TABLE_ACCESS_RDDATA_BASE;
505 tableAddr = (rtk_uint16*)&aclRuleSmi.care_bits;
506 for(i = 0; i < RTL8367C_ACLRULETBLEN; i++)
507 {
508 retVal = rtl8367c_getAsicReg(regAddr, &regData);
509 if(retVal != RT_ERR_OK)
510 return retVal;
511
512 *tableAddr = regData;
513
514 regAddr ++;
515 tableAddr ++;
516 }
517 /* Read active_portmsk_ext care Bits */
518 retVal = rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_RDDATA_REG(RTL8367C_ACLRULETBLEN), 0x7<<1, &regData);
519 if(retVal != RT_ERR_OK)
520 return retVal;
521 aclRuleSmi.care_bits_ext.rule_info = (regData & 0x0007) << 1;
522
523 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
524 memcpy(&aclRuleSmi,&Rtl8370sVirtualAclRuleTable[index], sizeof(rtl8367c_aclrulesmi));
525 #endif
526
527 _rtl8367c_aclRuleStSmi2User(pAclRule, &aclRuleSmi);
528
529 return RT_ERR_OK;
530 }
531 /* Function Name:
532 * rtl8367c_setAsicAclNot
533 * Description:
534 * Set rule comparison result inversion / no inversion
535 * Input:
536 * index - ACL rule index (0-95) of 96 ACL rules
537 * not - 1: inverse, 0: don't inverse
538 * Output:
539 * None
540 * Return:
541 * RT_ERR_OK - Success
542 * RT_ERR_SMI - SMI access error
543 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
544 * Note:
545 * None
546 */
547 ret_t rtl8367c_setAsicAclNot(rtk_uint32 index, rtk_uint32 not)
548 {
549 if(index > RTL8367C_ACLRULEMAX)
550 return RT_ERR_OUT_OF_RANGE;
551
552 if(index < 64)
553 return rtl8367c_setAsicRegBit(RTL8367C_ACL_ACTION_CTRL_REG(index), RTL8367C_ACL_OP_NOT_OFFSET(index), not);
554 else
555 return rtl8367c_setAsicRegBit(RTL8367C_ACL_ACTION_CTRL2_REG(index), RTL8367C_ACL_OP_NOT_OFFSET(index), not);
556
557 }
558 /* Function Name:
559 * rtl8367c_getAsicAcl
560 * Description:
561 * Get rule comparison result inversion / no inversion
562 * Input:
563 * index - ACL rule index (0-95) of 95 ACL rules
564 * pNot - 1: inverse, 0: don't inverse
565 * Output:
566 * None
567 * Return:
568 * RT_ERR_OK - Success
569 * RT_ERR_SMI - SMI access error
570 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
571 * Note:
572 * None
573 */
574 ret_t rtl8367c_getAsicAclNot(rtk_uint32 index, rtk_uint32* pNot)
575 {
576 if(index > RTL8367C_ACLRULEMAX)
577 return RT_ERR_OUT_OF_RANGE;
578
579 if(index < 64)
580 return rtl8367c_getAsicRegBit(RTL8367C_ACL_ACTION_CTRL_REG(index), RTL8367C_ACL_OP_NOT_OFFSET(index), pNot);
581 else
582 return rtl8367c_getAsicRegBit(RTL8367C_ACL_ACTION_CTRL2_REG(index), RTL8367C_ACL_OP_NOT_OFFSET(index), pNot);
583
584 }
585 /* Function Name:
586 * rtl8367c_setAsicAclTemplate
587 * Description:
588 * Set fields of a ACL Template
589 * Input:
590 * index - ACL template index(0~4)
591 * pAclType - ACL type stucture for setting
592 * Output:
593 * None
594 * Return:
595 * RT_ERR_OK - Success
596 * RT_ERR_SMI - SMI access error
597 * RT_ERR_OUT_OF_RANGE - Invalid ACL template index(0~4)
598 * Note:
599 * The API can set type field of the 5 ACL rule templates.
600 * Each type has 8 fields. One field means what data in one field of a ACL rule means
601 * 8 fields of ACL rule 0~95 is descripted by one type in ACL group
602 */
603 ret_t rtl8367c_setAsicAclTemplate(rtk_uint32 index, rtl8367c_acltemplate_t* pAclType)
604 {
605 ret_t retVal;
606 rtk_uint32 i;
607 rtk_uint32 regAddr, regData;
608
609 if(index >= RTL8367C_ACLTEMPLATENO)
610 return RT_ERR_OUT_OF_RANGE;
611
612 regAddr = RTL8367C_ACL_RULE_TEMPLATE_CTRL_REG(index);
613
614 for(i = 0; i < (RTL8367C_ACLRULEFIELDNO/2); i++)
615 {
616 regData = pAclType->field[i*2+1];
617 regData = regData << 8 | pAclType->field[i*2];
618
619 retVal = rtl8367c_setAsicReg(regAddr + i, regData);
620
621 if(retVal != RT_ERR_OK)
622 return retVal;
623 }
624
625 return retVal;
626 }
627 /* Function Name:
628 * rtl8367c_getAsicAclTemplate
629 * Description:
630 * Get fields of a ACL Template
631 * Input:
632 * index - ACL template index(0~4)
633 * pAclType - ACL type stucture for setting
634 * Output:
635 * None
636 * Return:
637 * RT_ERR_OK - Success
638 * RT_ERR_SMI - SMI access error
639 * RT_ERR_OUT_OF_RANGE - Invalid ACL template index(0~4)
640 * Note:
641 * None
642 */
643 ret_t rtl8367c_getAsicAclTemplate(rtk_uint32 index, rtl8367c_acltemplate_t *pAclType)
644 {
645 ret_t retVal;
646 rtk_uint32 i;
647 rtk_uint32 regData, regAddr;
648
649 if(index >= RTL8367C_ACLTEMPLATENO)
650 return RT_ERR_OUT_OF_RANGE;
651
652 regAddr = RTL8367C_ACL_RULE_TEMPLATE_CTRL_REG(index);
653
654 for(i = 0; i < (RTL8367C_ACLRULEFIELDNO/2); i++)
655 {
656 retVal = rtl8367c_getAsicReg(regAddr + i,&regData);
657 if(retVal != RT_ERR_OK)
658 return retVal;
659
660 pAclType->field[i*2] = regData & 0xFF;
661 pAclType->field[i*2 + 1] = (regData >> 8) & 0xFF;
662 }
663
664 return RT_ERR_OK;
665 }
666 /* Function Name:
667 * rtl8367c_setAsicAclAct
668 * Description:
669 * Set ACL rule matched Action
670 * Input:
671 * index - ACL rule index (0-95) of 96 ACL rules
672 * pAclAct - ACL action stucture for setting
673 * Output:
674 * None
675 * Return:
676 * RT_ERR_OK - Success
677 * RT_ERR_SMI - SMI access error
678 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
679 * Note:
680 * None
681 */
682 ret_t rtl8367c_setAsicAclAct(rtk_uint32 index, rtl8367c_acl_act_t* pAclAct)
683 {
684 rtk_uint16 aclActSmi[RTL8367C_ACL_ACT_TABLE_LEN];
685 ret_t retVal;
686 rtk_uint32 regAddr, regData;
687 rtk_uint16* tableAddr;
688 rtk_uint32 i;
689
690 if(index > RTL8367C_ACLRULEMAX)
691 return RT_ERR_OUT_OF_RANGE;
692
693 memset(aclActSmi, 0x00, sizeof(rtk_uint16) * RTL8367C_ACL_ACT_TABLE_LEN);
694 _rtl8367c_aclActStUser2Smi(pAclAct, aclActSmi);
695
696 /* Write ACS_ADR register for data bits */
697 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
698 regData = index;
699 retVal = rtl8367c_setAsicReg(regAddr, regData);
700 if(retVal != RT_ERR_OK)
701 return retVal;
702
703 /* Write Data Bits to ACS_DATA registers */
704 tableAddr = aclActSmi;
705 regAddr = RTL8367C_TABLE_ACCESS_WRDATA_BASE;
706
707 for(i = 0; i < RTL8367C_ACLACTTBLEN; i++)
708 {
709 regData = *tableAddr;
710 retVal = rtl8367c_setAsicReg(regAddr, regData);
711 if(retVal != RT_ERR_OK)
712 return retVal;
713
714 regAddr++;
715 tableAddr++;
716 }
717
718 /* Write ACS_CMD register for care bits*/
719 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
720 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_WRITE, TB_TARGET_ACLACT);
721 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData);
722 if(retVal != RT_ERR_OK)
723 return retVal;
724
725 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
726 memcpy(&Rtl8370sVirtualAclActTable[index][0], aclActSmi, sizeof(rtk_uint16) * RTL8367C_ACL_ACT_TABLE_LEN);
727 #endif
728
729 return RT_ERR_OK;
730 }
731 /* Function Name:
732 * rtl8367c_getAsicAclAct
733 * Description:
734 * Get ACL rule matched Action
735 * Input:
736 * index - ACL rule index (0-95) of 96 ACL rules
737 * pAclAct - ACL action stucture for setting
738 * Output:
739 * None
740 * Return:
741 * RT_ERR_OK - Success
742 * RT_ERR_SMI - SMI access error
743 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
744 * Note:
745 * None
746 */
747 ret_t rtl8367c_getAsicAclAct(rtk_uint32 index, rtl8367c_acl_act_t *pAclAct)
748 {
749 rtk_uint16 aclActSmi[RTL8367C_ACL_ACT_TABLE_LEN];
750 ret_t retVal;
751 rtk_uint32 regAddr, regData;
752 rtk_uint16 *tableAddr;
753 rtk_uint32 i;
754
755 if(index > RTL8367C_ACLRULEMAX)
756 return RT_ERR_OUT_OF_RANGE;
757
758 memset(aclActSmi, 0x00, sizeof(rtk_uint16) * RTL8367C_ACL_ACT_TABLE_LEN);
759
760 /* Write ACS_ADR register for data bits */
761 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
762 regData = index;
763 retVal = rtl8367c_setAsicReg(regAddr, regData);
764 if(retVal != RT_ERR_OK)
765 return retVal;
766
767 /* Write ACS_CMD register */
768 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
769 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ, TB_TARGET_ACLACT);
770 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData);
771 if(retVal != RT_ERR_OK)
772 return retVal;
773
774 /* Read Data Bits */
775 regAddr = RTL8367C_TABLE_ACCESS_RDDATA_BASE;
776 tableAddr = aclActSmi;
777 for(i = 0; i < RTL8367C_ACLACTTBLEN; i++)
778 {
779 retVal = rtl8367c_getAsicReg(regAddr, &regData);
780 if(retVal != RT_ERR_OK)
781 return retVal;
782
783 *tableAddr = regData;
784
785 regAddr ++;
786 tableAddr ++;
787 }
788
789 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
790 memcpy(aclActSmi, &Rtl8370sVirtualAclActTable[index][0], sizeof(rtk_uint16) * RTL8367C_ACL_ACT_TABLE_LEN);
791 #endif
792
793 _rtl8367c_aclActStSmi2User(pAclAct, aclActSmi);
794
795 return RT_ERR_OK;
796 }
797 /* Function Name:
798 * rtl8367c_setAsicAclActCtrl
799 * Description:
800 * Set ACL rule matched Action Control Bits
801 * Input:
802 * index - ACL rule index (0-95) of 96 ACL rules
803 * aclActCtrl - 6 ACL Control Bits
804 * Output:
805 * None
806 * Return:
807 * RT_ERR_OK - Success
808 * RT_ERR_SMI - SMI access error
809 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
810 * Note:
811 * ACL Action Control Bits Indicate which actions will be take when a rule matches
812 */
813 ret_t rtl8367c_setAsicAclActCtrl(rtk_uint32 index, rtk_uint32 aclActCtrl)
814 {
815 ret_t retVal;
816
817 if(index > RTL8367C_ACLRULEMAX)
818 return RT_ERR_OUT_OF_RANGE;
819
820 if(index >= 64)
821 retVal = rtl8367c_setAsicRegBits(RTL8367C_ACL_ACTION_CTRL2_REG(index), RTL8367C_ACL_OP_ACTION_MASK(index), aclActCtrl);
822 else
823 retVal = rtl8367c_setAsicRegBits(RTL8367C_ACL_ACTION_CTRL_REG(index), RTL8367C_ACL_OP_ACTION_MASK(index), aclActCtrl);
824
825 return retVal;
826 }
827 /* Function Name:
828 * rtl8367c_getAsicAclActCtrl
829 * Description:
830 * Get ACL rule matched Action Control Bits
831 * Input:
832 * index - ACL rule index (0-95) of 96 ACL rules
833 * pAclActCtrl - 6 ACL Control Bits
834 * Output:
835 * None
836 * Return:
837 * RT_ERR_OK - Success
838 * RT_ERR_SMI - SMI access error
839 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
840 * Note:
841 * None
842 */
843 ret_t rtl8367c_getAsicAclActCtrl(rtk_uint32 index, rtk_uint32 *pAclActCtrl)
844 {
845 ret_t retVal;
846 rtk_uint32 regData;
847
848 if(index > RTL8367C_ACLRULEMAX)
849 return RT_ERR_OUT_OF_RANGE;
850
851 if(index >= 64)
852 retVal = rtl8367c_getAsicRegBits(RTL8367C_ACL_ACTION_CTRL2_REG(index), RTL8367C_ACL_OP_ACTION_MASK(index), &regData);
853 else
854 retVal = rtl8367c_getAsicRegBits(RTL8367C_ACL_ACTION_CTRL_REG(index), RTL8367C_ACL_OP_ACTION_MASK(index), &regData);
855
856 if(retVal != RT_ERR_OK)
857 return retVal;
858
859 *pAclActCtrl = regData;
860
861 return RT_ERR_OK;
862 }
863 /* Function Name:
864 * rtl8367c_setAsicAclPortRange
865 * Description:
866 * Set ACL TCP/UDP range check
867 * Input:
868 * index - TCP/UDP port range check table index
869 * type - Range check type
870 * upperPort - TCP/UDP port range upper bound
871 * lowerPort - TCP/UDP port range lower bound
872 * Output:
873 * None
874 * Return:
875 * RT_ERR_OK - Success
876 * RT_ERR_SMI - SMI access error
877 * RT_ERR_OUT_OF_RANGE - Invalid TCP/UDP port range check table index
878 * Note:
879 * None
880 */
881 ret_t rtl8367c_setAsicAclPortRange(rtk_uint32 index, rtk_uint32 type, rtk_uint32 upperPort, rtk_uint32 lowerPort)
882 {
883 ret_t retVal;
884
885 if(index > RTL8367C_ACLRANGEMAX)
886 return RT_ERR_OUT_OF_RANGE;
887
888 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL2 + index*3, RTL8367C_ACL_SDPORT_RANGE_ENTRY0_CTRL2_MASK, type);
889 if(retVal != RT_ERR_OK)
890 return retVal;
891
892 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL1 + index*3, upperPort);
893 if(retVal != RT_ERR_OK)
894 return retVal;
895
896 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL0 + index*3, lowerPort);
897 if(retVal != RT_ERR_OK)
898 return retVal;
899
900 return RT_ERR_OK;
901 }
902 /* Function Name:
903 * rtl8367c_getAsicAclPortRange
904 * Description:
905 * Get ACL TCP/UDP range check
906 * Input:
907 * index - TCP/UDP port range check table index
908 * pType - Range check type
909 * pUpperPort - TCP/UDP port range upper bound
910 * pLowerPort - TCP/UDP port range lower bound
911 * Output:
912 * None
913 * Return:
914 * RT_ERR_OK - Success
915 * RT_ERR_SMI - SMI access error
916 * RT_ERR_OUT_OF_RANGE - Invalid TCP/UDP port range check table index
917 * Note:
918 * None
919 */
920 ret_t rtl8367c_getAsicAclPortRange(rtk_uint32 index, rtk_uint32* pType, rtk_uint32* pUpperPort, rtk_uint32* pLowerPort)
921 {
922 ret_t retVal;
923
924 if(index > RTL8367C_ACLRANGEMAX)
925 return RT_ERR_OUT_OF_RANGE;
926
927 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL2 + index*3, RTL8367C_ACL_SDPORT_RANGE_ENTRY0_CTRL2_MASK, pType);
928 if(retVal != RT_ERR_OK)
929 return retVal;
930
931 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL1 + index*3, pUpperPort);
932 if(retVal != RT_ERR_OK)
933 return retVal;
934
935 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL0 + index*3, pLowerPort);
936 if(retVal != RT_ERR_OK)
937 return retVal;
938
939 return RT_ERR_OK;
940 }
941 /* Function Name:
942 * rtl8367c_setAsicAclVidRange
943 * Description:
944 * Set ACL VID range check
945 * Input:
946 * index - ACL VID range check index(0~15)
947 * type - Range check type
948 * upperVid - VID range upper bound
949 * lowerVid - VID range lower bound
950 * Output:
951 * None
952 * Return:
953 * RT_ERR_OK - Success
954 * RT_ERR_SMI - SMI access error
955 * RT_ERR_OUT_OF_RANGE - Invalid ACL VID range check index(0~15)
956 * Note:
957 * None
958 */
959 ret_t rtl8367c_setAsicAclVidRange(rtk_uint32 index, rtk_uint32 type, rtk_uint32 upperVid, rtk_uint32 lowerVid)
960 {
961 ret_t retVal;
962 rtk_uint32 regData;
963
964 if(index > RTL8367C_ACLRANGEMAX)
965 return RT_ERR_OUT_OF_RANGE;
966
967 regData = ((type << RTL8367C_ACL_VID_RANGE_ENTRY0_CTRL1_CHECK0_TYPE_OFFSET) & RTL8367C_ACL_VID_RANGE_ENTRY0_CTRL1_CHECK0_TYPE_MASK) |
968 (upperVid & RTL8367C_ACL_VID_RANGE_ENTRY0_CTRL1_CHECK0_HIGH_MASK);
969
970 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL1 + index*2, regData);
971 if(retVal != RT_ERR_OK)
972 return retVal;
973
974 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL0 + index*2, lowerVid);
975 if(retVal != RT_ERR_OK)
976 return retVal;
977
978 return RT_ERR_OK;
979 }
980 /* Function Name:
981 * rtl8367c_getAsicAclVidRange
982 * Description:
983 * Get ACL VID range check
984 * Input:
985 * index - ACL VID range check index(0~15)
986 * pType - Range check type
987 * pUpperVid - VID range upper bound
988 * pLowerVid - VID range lower bound
989 * Output:
990 * None
991 * Return:
992 * RT_ERR_OK - Success
993 * RT_ERR_SMI - SMI access error
994 * RT_ERR_OUT_OF_RANGE - Invalid ACL VID range check index(0~15)
995 * Note:
996 * None
997 */
998 ret_t rtl8367c_getAsicAclVidRange(rtk_uint32 index, rtk_uint32* pType, rtk_uint32* pUpperVid, rtk_uint32* pLowerVid)
999 {
1000 ret_t retVal;
1001 rtk_uint32 regData;
1002
1003 if(index > RTL8367C_ACLRANGEMAX)
1004 return RT_ERR_OUT_OF_RANGE;
1005
1006 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL1 + index*2, &regData);
1007 if(retVal != RT_ERR_OK)
1008 return retVal;
1009
1010 *pType = (regData & RTL8367C_ACL_VID_RANGE_ENTRY0_CTRL1_CHECK0_TYPE_MASK) >> RTL8367C_ACL_VID_RANGE_ENTRY0_CTRL1_CHECK0_TYPE_OFFSET;
1011 *pUpperVid = regData & RTL8367C_ACL_VID_RANGE_ENTRY0_CTRL1_CHECK0_HIGH_MASK;
1012
1013 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL0 + index*2, pLowerVid);
1014 if(retVal != RT_ERR_OK)
1015 return retVal;
1016
1017 return RT_ERR_OK;
1018 }
1019 /* Function Name:
1020 * rtl8367c_setAsicAclIpRange
1021 * Description:
1022 * Set ACL IP range check
1023 * Input:
1024 * index - ACL IP range check index(0~15)
1025 * type - Range check type
1026 * upperIp - IP range upper bound
1027 * lowerIp - IP range lower bound
1028 * Output:
1029 * None
1030 * Return:
1031 * RT_ERR_OK - Success
1032 * RT_ERR_SMI - SMI access error
1033 * RT_ERR_OUT_OF_RANGE - Invalid ACL IP range check index(0~15)
1034 * Note:
1035 * None
1036 */
1037 ret_t rtl8367c_setAsicAclIpRange(rtk_uint32 index, rtk_uint32 type, ipaddr_t upperIp, ipaddr_t lowerIp)
1038 {
1039 ret_t retVal;
1040 rtk_uint32 regData;
1041 ipaddr_t ipData;
1042
1043 if(index > RTL8367C_ACLRANGEMAX)
1044 return RT_ERR_OUT_OF_RANGE;
1045
1046 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL4 + index*5, RTL8367C_ACL_IP_RANGE_ENTRY0_CTRL4_MASK, type);
1047 if(retVal != RT_ERR_OK)
1048 return retVal;
1049
1050 ipData = upperIp;
1051
1052 regData = ipData & 0xFFFF;
1053 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL2 + index*5, regData);
1054 if(retVal != RT_ERR_OK)
1055 return retVal;
1056
1057 regData = (ipData>>16) & 0xFFFF;
1058 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL3 + index*5, regData);
1059 if(retVal != RT_ERR_OK)
1060 return retVal;
1061
1062 ipData = lowerIp;
1063
1064 regData = ipData & 0xFFFF;
1065 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL0 + index*5, regData);
1066 if(retVal != RT_ERR_OK)
1067 return retVal;
1068
1069 regData = (ipData>>16) & 0xFFFF;
1070 retVal = rtl8367c_setAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL1 + index*5, regData);
1071 if(retVal != RT_ERR_OK)
1072 return retVal;
1073
1074 return RT_ERR_OK;
1075 }
1076 /* Function Name:
1077 * rtl8367c_getAsicAclIpRange
1078 * Description:
1079 * Get ACL IP range check
1080 * Input:
1081 * index - ACL IP range check index(0~15)
1082 * pType - Range check type
1083 * pUpperIp - IP range upper bound
1084 * pLowerIp - IP range lower bound
1085 * Output:
1086 * None
1087 * Return:
1088 * RT_ERR_OK - Success
1089 * RT_ERR_SMI - SMI access error
1090 * RT_ERR_OUT_OF_RANGE - Invalid ACL IP range check index(0~15)
1091 * Note:
1092 * None
1093 */
1094 ret_t rtl8367c_getAsicAclIpRange(rtk_uint32 index, rtk_uint32* pType, ipaddr_t* pUpperIp, ipaddr_t* pLowerIp)
1095 {
1096 ret_t retVal;
1097 rtk_uint32 regData;
1098 ipaddr_t ipData;
1099
1100 if(index > RTL8367C_ACLRANGEMAX)
1101 return RT_ERR_OUT_OF_RANGE;
1102
1103 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL4 + index*5, RTL8367C_ACL_IP_RANGE_ENTRY0_CTRL4_MASK, pType);
1104 if(retVal != RT_ERR_OK)
1105 return retVal;
1106
1107 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL2 + index*5, &regData);
1108 if(retVal != RT_ERR_OK)
1109 return retVal;
1110 ipData = regData;
1111
1112
1113 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL3 + index*5, &regData);
1114 if(retVal != RT_ERR_OK)
1115 return retVal;
1116
1117 ipData = (regData <<16) | ipData;
1118 *pUpperIp = ipData;
1119
1120
1121 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL0 + index*5, &regData);
1122 if(retVal != RT_ERR_OK)
1123 return retVal;
1124 ipData = regData;
1125
1126
1127 retVal = rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL1 + index*5, &regData);
1128 if(retVal != RT_ERR_OK)
1129 return retVal;
1130
1131 ipData = (regData << 16) | ipData;
1132 *pLowerIp = ipData;
1133
1134 return RT_ERR_OK;
1135 }
1136
1137 /* Function Name:
1138 * rtl8367c_setAsicAclGpioPolarity
1139 * Description:
1140 * Set ACL Goip control palarity
1141 * Input:
1142 * polarity - 1: High, 0: Low
1143 * Output:
1144 * None
1145 * Return:
1146 * RT_ERR_OK - Success
1147 * RT_ERR_SMI - SMI access error
1148 * Note:
1149 * none
1150 */
1151 ret_t rtl8367c_setAsicAclGpioPolarity(rtk_uint32 polarity)
1152 {
1153 return rtl8367c_setAsicRegBit(RTL8367C_REG_ACL_GPIO_POLARITY, RTL8367C_ACL_GPIO_POLARITY_OFFSET, polarity);
1154 }
1155 /* Function Name:
1156 * rtl8367c_getAsicAclGpioPolarity
1157 * Description:
1158 * Get ACL Goip control palarity
1159 * Input:
1160 * pPolarity - 1: High, 0: Low
1161 * Output:
1162 * None
1163 * Return:
1164 * RT_ERR_OK - Success
1165 * RT_ERR_SMI - SMI access error
1166 * Note:
1167 * none
1168 */
1169 ret_t rtl8367c_getAsicAclGpioPolarity(rtk_uint32* pPolarity)
1170 {
1171 return rtl8367c_getAsicRegBit(RTL8367C_REG_ACL_GPIO_POLARITY, RTL8367C_ACL_GPIO_POLARITY_OFFSET, pPolarity);
1172 }
1173
OpenWrt Source Repository