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 : ACL related function drivers
17 #include <rtl8367c_asicdrv_acl.h>
21 #if defined(CONFIG_RTL8367C_ASICDRV_TEST)
22 rtl8367c_aclrulesmi Rtl8370sVirtualAclRuleTable
[RTL8367C_ACLRULENO
];
23 rtk_uint16 Rtl8370sVirtualAclActTable
[RTL8367C_ACLRULENO
][RTL8367C_ACL_ACT_TABLE_LEN
];
27 Exchange structure type define with MMI and SMI
29 static void _rtl8367c_aclRuleStSmi2User( rtl8367c_aclrule
*pAclUser
, rtl8367c_aclrulesmi
*pAclSmi
)
31 rtk_uint8
*care_ptr
, *data_ptr
;
32 rtk_uint8 care_tmp
, data_tmp
;
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;
39 care_ptr
= (rtk_uint8
*)&pAclSmi
->care_bits
;
40 data_ptr
= (rtk_uint8
*)&pAclSmi
->data_bits
;
42 for ( i
= 0; i
< sizeof(struct acl_rule_smi_st
); i
++)
44 care_tmp
= *(care_ptr
+ i
) ^ (*(data_ptr
+ i
));
45 data_tmp
= *(data_ptr
+ i
);
47 *(care_ptr
+ i
) = care_tmp
;
48 *(data_ptr
+ i
) = data_tmp
;
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
);
58 for(i
= 0; i
< RTL8367C_ACLRULEFIELDNO
; i
++)
59 pAclUser
->data_bits
.field
[i
] = pAclSmi
->data_bits
.field
[i
];
61 pAclUser
->valid
= pAclSmi
->valid
;
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;
67 for(i
= 0; i
< RTL8367C_ACLRULEFIELDNO
; i
++)
68 pAclUser
->care_bits
.field
[i
] = pAclSmi
->care_bits
.field
[i
];
72 Exchange structure type define with MMI and SMI
74 static void _rtl8367c_aclRuleStUser2Smi(rtl8367c_aclrule
*pAclUser
, rtl8367c_aclrulesmi
*pAclSmi
)
76 rtk_uint8
*care_ptr
, *data_ptr
;
77 rtk_uint8 care_tmp
, data_tmp
;
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);
83 for(i
= 0;i
< RTL8367C_ACLRULEFIELDNO
; i
++)
84 pAclSmi
->data_bits
.field
[i
] = pAclUser
->data_bits
.field
[i
];
86 pAclSmi
->valid
= pAclUser
->valid
;
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);
91 for(i
= 0; i
< RTL8367C_ACLRULEFIELDNO
; i
++)
92 pAclSmi
->care_bits
.field
[i
] = pAclUser
->care_bits
.field
[i
];
94 care_ptr
= (rtk_uint8
*)&pAclSmi
->care_bits
;
95 data_ptr
= (rtk_uint8
*)&pAclSmi
->data_bits
;
97 for ( i
= 0; i
< sizeof(struct acl_rule_smi_st
); i
++)
99 care_tmp
= *(care_ptr
+ i
) & ~(*(data_ptr
+ i
));
100 data_tmp
= *(care_ptr
+ i
) & *(data_ptr
+ i
);
102 *(care_ptr
+ i
) = care_tmp
;
103 *(data_ptr
+ i
) = data_tmp
;
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
;
111 *care_ptr
= care_tmp
;
112 *data_ptr
= data_tmp
;
116 Exchange structure type define with MMI and SMI
118 static void _rtl8367c_aclActStSmi2User(rtl8367c_acl_act_t
*pAclUser
, rtk_uint16
*pAclSmi
)
120 pAclUser
->cact
= (pAclSmi
[0] & 0x00C0) >> 6;
121 pAclUser
->cvidx_cact
= (pAclSmi
[0] & 0x003F) | (((pAclSmi
[3] & 0x0008) >> 3) << 6);
123 pAclUser
->sact
= (pAclSmi
[0] & 0xC000) >> 14;
124 pAclUser
->svidx_sact
= ((pAclSmi
[0] & 0x3F00) >> 8) | (((pAclSmi
[3] & 0x0010) >> 4) << 6);
126 pAclUser
->aclmeteridx
= (pAclSmi
[1] & 0x003F) | (((pAclSmi
[3] & 0x0020) >> 5) << 6);
128 pAclUser
->fwdact
= (pAclSmi
[1] & 0xC000) >> 14;
129 pAclUser
->fwdpmask
= ((pAclSmi
[1] & 0x3FC0) >> 6) | (((pAclSmi
[3] & 0x01C0) >> 6) << 8);
131 pAclUser
->priact
= (pAclSmi
[2] & 0x00C0) >> 6;
132 pAclUser
->pridx
= (pAclSmi
[2] & 0x003F) | (((pAclSmi
[3] & 0x0200) >> 9) << 6);
134 pAclUser
->aclint
= (pAclSmi
[2] & 0x2000) >> 13;
135 pAclUser
->gpio_en
= (pAclSmi
[2] & 0x1000) >> 12;
136 pAclUser
->gpio_pin
= (pAclSmi
[2] & 0x0F00) >> 8;
138 pAclUser
->cact_ext
= (pAclSmi
[2] & 0xC000) >> 14;
139 pAclUser
->tag_fmt
= (pAclSmi
[3] & 0x0003);
140 pAclUser
->fwdact_ext
= (pAclSmi
[3] & 0x0004) >> 2;
144 Exchange structure type define with MMI and SMI
146 static void _rtl8367c_aclActStUser2Smi(rtl8367c_acl_act_t
*pAclUser
, rtk_uint16
*pAclSmi
)
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;
153 pAclSmi
[1] |= (pAclUser
->aclmeteridx
& 0x003F);
154 pAclSmi
[1] |= (pAclUser
->fwdpmask
& 0x00FF) << 6;
155 pAclSmi
[1] |= (pAclUser
->fwdact
& 0x0003) << 14;
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;
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;
174 * rtl8367c_setAsicAcl
176 * Set port acl function enable/disable
178 * port - Physical port number (0~10)
179 * enabled - 1: enabled, 0: disabled
183 * RT_ERR_OK - Success
184 * RT_ERR_SMI - SMI access error
185 * RT_ERR_PORT_ID - Invalid port number
189 ret_t
rtl8367c_setAsicAcl(rtk_uint32 port
, rtk_uint32 enabled
)
191 if(port
> RTL8367C_PORTIDMAX
)
192 return RT_ERR_PORT_ID
;
194 return rtl8367c_setAsicRegBit(RTL8367C_ACL_ENABLE_REG
, port
, enabled
);
197 * rtl8367c_getAsicAcl
199 * Get port acl function enable/disable
201 * port - Physical port number (0~10)
202 * enabled - 1: enabled, 0: disabled
206 * RT_ERR_OK - Success
207 * RT_ERR_SMI - SMI access error
208 * RT_ERR_PORT_ID - Invalid port number
212 ret_t
rtl8367c_getAsicAcl(rtk_uint32 port
, rtk_uint32
* pEnabled
)
214 if(port
> RTL8367C_PORTIDMAX
)
215 return RT_ERR_PORT_ID
;
217 return rtl8367c_getAsicRegBit(RTL8367C_ACL_ENABLE_REG
, port
, pEnabled
);
220 * rtl8367c_setAsicAclUnmatchedPermit
222 * Set port acl function unmatched permit action
224 * port - Physical port number (0~10)
225 * enabled - 1: enabled, 0: disabled
229 * RT_ERR_OK - Success
230 * RT_ERR_SMI - SMI access error
231 * RT_ERR_PORT_ID - Invalid port number
235 ret_t
rtl8367c_setAsicAclUnmatchedPermit(rtk_uint32 port
, rtk_uint32 enabled
)
237 if(port
> RTL8367C_PORTIDMAX
)
238 return RT_ERR_PORT_ID
;
240 return rtl8367c_setAsicRegBit(RTL8367C_ACL_UNMATCH_PERMIT_REG
, port
, enabled
);
243 * rtl8367c_getAsicAclUnmatchedPermit
245 * Get port acl function unmatched permit action
247 * port - Physical port number (0~10)
248 * enabled - 1: enabled, 0: disabled
252 * RT_ERR_OK - Success
253 * RT_ERR_SMI - SMI access error
254 * RT_ERR_PORT_ID - Invalid port number
258 ret_t
rtl8367c_getAsicAclUnmatchedPermit(rtk_uint32 port
, rtk_uint32
* pEnabled
)
260 if(port
> RTL8367C_PORTIDMAX
)
261 return RT_ERR_PORT_ID
;
263 return rtl8367c_getAsicRegBit(RTL8367C_ACL_UNMATCH_PERMIT_REG
, port
, pEnabled
);
267 * rtl8367c_setAsicAclRule
269 * Set acl rule content
271 * index - ACL rule index (0-95) of 96 ACL rules
272 * pAclRule - ACL rule stucture for setting
276 * RT_ERR_OK - Success
277 * RT_ERR_SMI - SMI access error
278 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
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
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
289 ret_t
rtl8367c_setAsicAclRule(rtk_uint32 index
, rtl8367c_aclrule
* pAclRule
)
291 rtl8367c_aclrulesmi aclRuleSmi
;
292 rtk_uint16
* tableAddr
;
298 if(index
> RTL8367C_ACLRULEMAX
)
299 return RT_ERR_OUT_OF_RANGE
;
301 memset(&aclRuleSmi
, 0x00, sizeof(rtl8367c_aclrulesmi
));
303 _rtl8367c_aclRuleStUser2Smi(pAclRule
, &aclRuleSmi
);
305 /* Write valid bit = 0 */
306 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
308 regData
= RTL8367C_ACLRULETBADDR2(DATABITS
, index
);
310 regData
= RTL8367C_ACLRULETBADDR(DATABITS
, index
);
311 retVal
= rtl8367c_setAsicReg(regAddr
,regData
);
312 if(retVal
!=RT_ERR_OK
)
315 retVal
= rtl8367c_setAsicRegBits(RTL8367C_TABLE_ACCESS_WRDATA_REG(RTL8367C_ACLRULETBLEN
), 0x1, 0);
316 if(retVal
!=RT_ERR_OK
)
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
)
327 /* Write ACS_ADR register */
328 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
330 regData
= RTL8367C_ACLRULETBADDR2(CAREBITS
, index
);
332 regData
= RTL8367C_ACLRULETBADDR(CAREBITS
, index
);
333 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
334 if(retVal
!= RT_ERR_OK
)
337 /* Write Care Bits to ACS_DATA registers */
338 tableAddr
= (rtk_uint16
*)&aclRuleSmi
.care_bits
;
339 regAddr
= RTL8367C_TABLE_ACCESS_WRDATA_BASE
;
341 for(i
= 0; i
< RTL8367C_ACLRULETBLEN
; i
++)
343 regData
= *tableAddr
;
344 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
345 if(retVal
!= RT_ERR_OK
)
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
)
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
)
364 /* Write ACS_ADR register for data bits */
365 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
367 regData
= RTL8367C_ACLRULETBADDR2(DATABITS
, index
);
369 regData
= RTL8367C_ACLRULETBADDR(DATABITS
, index
);
371 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
372 if(retVal
!= RT_ERR_OK
)
375 /* Write Data Bits to ACS_DATA registers */
376 tableAddr
= (rtk_uint16
*)&aclRuleSmi
.data_bits
;
377 regAddr
= RTL8367C_TABLE_ACCESS_WRDATA_BASE
;
379 for(i
= 0; i
< RTL8367C_ACLRULETBLEN
; i
++)
381 regData
= *tableAddr
;
382 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
383 if(retVal
!= RT_ERR_OK
)
390 retVal
= rtl8367c_setAsicRegBit(RTL8367C_TABLE_ACCESS_WRDATA_REG(RTL8367C_ACLRULETBLEN
), 0, aclRuleSmi
.valid
);
391 if(retVal
!= RT_ERR_OK
)
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
)
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
)
404 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
405 memcpy(&Rtl8370sVirtualAclRuleTable
[index
], &aclRuleSmi
, sizeof(rtl8367c_aclrulesmi
));
411 * rtl8367c_getAsicAclRule
413 * Get acl rule content
415 * index - ACL rule index (0-63) of 64 ACL rules
416 * pAclRule - ACL rule stucture for setting
420 * RT_ERR_OK - Success
421 * RT_ERR_SMI - SMI access error
422 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-63)
426 ret_t
rtl8367c_getAsicAclRule(rtk_uint32 index
, rtl8367c_aclrule
*pAclRule
)
428 rtl8367c_aclrulesmi aclRuleSmi
;
429 rtk_uint32 regAddr
, regData
;
431 rtk_uint16
* tableAddr
;
434 if(index
> RTL8367C_ACLRULEMAX
)
435 return RT_ERR_OUT_OF_RANGE
;
437 memset(&aclRuleSmi
, 0x00, sizeof(rtl8367c_aclrulesmi
));
439 /* Write ACS_ADR register for data bits */
440 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
442 regData
= RTL8367C_ACLRULETBADDR2(DATABITS
, index
);
444 regData
= RTL8367C_ACLRULETBADDR(DATABITS
, index
);
446 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
447 if(retVal
!= RT_ERR_OK
)
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
)
459 regAddr
= RTL8367C_TABLE_ACCESS_RDDATA_BASE
;
460 tableAddr
= (rtk_uint16
*)&aclRuleSmi
.data_bits
;
461 for(i
= 0; i
< RTL8367C_ACLRULETBLEN
; i
++)
463 retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
);
464 if(retVal
!= RT_ERR_OK
)
467 *tableAddr
= regData
;
474 retVal
= rtl8367c_getAsicRegBit(RTL8367C_TABLE_ACCESS_RDDATA_REG(RTL8367C_ACLRULETBLEN
), 0, ®Data
);
475 if(retVal
!= RT_ERR_OK
)
477 aclRuleSmi
.valid
= regData
& 0x1;
478 /* Read active_portmsk_ext Bits */
479 retVal
= rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_RDDATA_REG(RTL8367C_ACLRULETBLEN
), 0x7<<1, ®Data
);
480 if(retVal
!= RT_ERR_OK
)
482 aclRuleSmi
.data_bits_ext
.rule_info
= (regData
% 0x0007) << 1;
485 /* Write ACS_ADR register for carebits*/
486 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
488 regData
= RTL8367C_ACLRULETBADDR2(CAREBITS
, index
);
490 regData
= RTL8367C_ACLRULETBADDR(CAREBITS
, index
);
492 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
493 if(retVal
!= RT_ERR_OK
)
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
)
504 regAddr
= RTL8367C_TABLE_ACCESS_RDDATA_BASE
;
505 tableAddr
= (rtk_uint16
*)&aclRuleSmi
.care_bits
;
506 for(i
= 0; i
< RTL8367C_ACLRULETBLEN
; i
++)
508 retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
);
509 if(retVal
!= RT_ERR_OK
)
512 *tableAddr
= regData
;
517 /* Read active_portmsk_ext care Bits */
518 retVal
= rtl8367c_getAsicRegBits(RTL8367C_TABLE_ACCESS_RDDATA_REG(RTL8367C_ACLRULETBLEN
), 0x7<<1, ®Data
);
519 if(retVal
!= RT_ERR_OK
)
521 aclRuleSmi
.care_bits_ext
.rule_info
= (regData
& 0x0007) << 1;
523 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
524 memcpy(&aclRuleSmi
,&Rtl8370sVirtualAclRuleTable
[index
], sizeof(rtl8367c_aclrulesmi
));
527 _rtl8367c_aclRuleStSmi2User(pAclRule
, &aclRuleSmi
);
532 * rtl8367c_setAsicAclNot
534 * Set rule comparison result inversion / no inversion
536 * index - ACL rule index (0-95) of 96 ACL rules
537 * not - 1: inverse, 0: don't inverse
541 * RT_ERR_OK - Success
542 * RT_ERR_SMI - SMI access error
543 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
547 ret_t
rtl8367c_setAsicAclNot(rtk_uint32 index
, rtk_uint32
not)
549 if(index
> RTL8367C_ACLRULEMAX
)
550 return RT_ERR_OUT_OF_RANGE
;
553 return rtl8367c_setAsicRegBit(RTL8367C_ACL_ACTION_CTRL_REG(index
), RTL8367C_ACL_OP_NOT_OFFSET(index
), not);
555 return rtl8367c_setAsicRegBit(RTL8367C_ACL_ACTION_CTRL2_REG(index
), RTL8367C_ACL_OP_NOT_OFFSET(index
), not);
559 * rtl8367c_getAsicAcl
561 * Get rule comparison result inversion / no inversion
563 * index - ACL rule index (0-95) of 95 ACL rules
564 * pNot - 1: inverse, 0: don't inverse
568 * RT_ERR_OK - Success
569 * RT_ERR_SMI - SMI access error
570 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
574 ret_t
rtl8367c_getAsicAclNot(rtk_uint32 index
, rtk_uint32
* pNot
)
576 if(index
> RTL8367C_ACLRULEMAX
)
577 return RT_ERR_OUT_OF_RANGE
;
580 return rtl8367c_getAsicRegBit(RTL8367C_ACL_ACTION_CTRL_REG(index
), RTL8367C_ACL_OP_NOT_OFFSET(index
), pNot
);
582 return rtl8367c_getAsicRegBit(RTL8367C_ACL_ACTION_CTRL2_REG(index
), RTL8367C_ACL_OP_NOT_OFFSET(index
), pNot
);
586 * rtl8367c_setAsicAclTemplate
588 * Set fields of a ACL Template
590 * index - ACL template index(0~4)
591 * pAclType - ACL type stucture for setting
595 * RT_ERR_OK - Success
596 * RT_ERR_SMI - SMI access error
597 * RT_ERR_OUT_OF_RANGE - Invalid ACL template index(0~4)
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
603 ret_t
rtl8367c_setAsicAclTemplate(rtk_uint32 index
, rtl8367c_acltemplate_t
* pAclType
)
607 rtk_uint32 regAddr
, regData
;
609 if(index
>= RTL8367C_ACLTEMPLATENO
)
610 return RT_ERR_OUT_OF_RANGE
;
612 regAddr
= RTL8367C_ACL_RULE_TEMPLATE_CTRL_REG(index
);
614 for(i
= 0; i
< (RTL8367C_ACLRULEFIELDNO
/2); i
++)
616 regData
= pAclType
->field
[i
*2+1];
617 regData
= regData
<< 8 | pAclType
->field
[i
*2];
619 retVal
= rtl8367c_setAsicReg(regAddr
+ i
, regData
);
621 if(retVal
!= RT_ERR_OK
)
628 * rtl8367c_getAsicAclTemplate
630 * Get fields of a ACL Template
632 * index - ACL template index(0~4)
633 * pAclType - ACL type stucture for setting
637 * RT_ERR_OK - Success
638 * RT_ERR_SMI - SMI access error
639 * RT_ERR_OUT_OF_RANGE - Invalid ACL template index(0~4)
643 ret_t
rtl8367c_getAsicAclTemplate(rtk_uint32 index
, rtl8367c_acltemplate_t
*pAclType
)
647 rtk_uint32 regData
, regAddr
;
649 if(index
>= RTL8367C_ACLTEMPLATENO
)
650 return RT_ERR_OUT_OF_RANGE
;
652 regAddr
= RTL8367C_ACL_RULE_TEMPLATE_CTRL_REG(index
);
654 for(i
= 0; i
< (RTL8367C_ACLRULEFIELDNO
/2); i
++)
656 retVal
= rtl8367c_getAsicReg(regAddr
+ i
,®Data
);
657 if(retVal
!= RT_ERR_OK
)
660 pAclType
->field
[i
*2] = regData
& 0xFF;
661 pAclType
->field
[i
*2 + 1] = (regData
>> 8) & 0xFF;
667 * rtl8367c_setAsicAclAct
669 * Set ACL rule matched Action
671 * index - ACL rule index (0-95) of 96 ACL rules
672 * pAclAct - ACL action stucture for setting
676 * RT_ERR_OK - Success
677 * RT_ERR_SMI - SMI access error
678 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
682 ret_t
rtl8367c_setAsicAclAct(rtk_uint32 index
, rtl8367c_acl_act_t
* pAclAct
)
684 rtk_uint16 aclActSmi
[RTL8367C_ACL_ACT_TABLE_LEN
];
686 rtk_uint32 regAddr
, regData
;
687 rtk_uint16
* tableAddr
;
690 if(index
> RTL8367C_ACLRULEMAX
)
691 return RT_ERR_OUT_OF_RANGE
;
693 memset(aclActSmi
, 0x00, sizeof(rtk_uint16
) * RTL8367C_ACL_ACT_TABLE_LEN
);
694 _rtl8367c_aclActStUser2Smi(pAclAct
, aclActSmi
);
696 /* Write ACS_ADR register for data bits */
697 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
699 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
700 if(retVal
!= RT_ERR_OK
)
703 /* Write Data Bits to ACS_DATA registers */
704 tableAddr
= aclActSmi
;
705 regAddr
= RTL8367C_TABLE_ACCESS_WRDATA_BASE
;
707 for(i
= 0; i
< RTL8367C_ACLACTTBLEN
; i
++)
709 regData
= *tableAddr
;
710 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
711 if(retVal
!= RT_ERR_OK
)
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
)
725 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
726 memcpy(&Rtl8370sVirtualAclActTable
[index
][0], aclActSmi
, sizeof(rtk_uint16
) * RTL8367C_ACL_ACT_TABLE_LEN
);
732 * rtl8367c_getAsicAclAct
734 * Get ACL rule matched Action
736 * index - ACL rule index (0-95) of 96 ACL rules
737 * pAclAct - ACL action stucture for setting
741 * RT_ERR_OK - Success
742 * RT_ERR_SMI - SMI access error
743 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
747 ret_t
rtl8367c_getAsicAclAct(rtk_uint32 index
, rtl8367c_acl_act_t
*pAclAct
)
749 rtk_uint16 aclActSmi
[RTL8367C_ACL_ACT_TABLE_LEN
];
751 rtk_uint32 regAddr
, regData
;
752 rtk_uint16
*tableAddr
;
755 if(index
> RTL8367C_ACLRULEMAX
)
756 return RT_ERR_OUT_OF_RANGE
;
758 memset(aclActSmi
, 0x00, sizeof(rtk_uint16
) * RTL8367C_ACL_ACT_TABLE_LEN
);
760 /* Write ACS_ADR register for data bits */
761 regAddr
= RTL8367C_TABLE_ACCESS_ADDR_REG
;
763 retVal
= rtl8367c_setAsicReg(regAddr
, regData
);
764 if(retVal
!= RT_ERR_OK
)
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
)
775 regAddr
= RTL8367C_TABLE_ACCESS_RDDATA_BASE
;
776 tableAddr
= aclActSmi
;
777 for(i
= 0; i
< RTL8367C_ACLACTTBLEN
; i
++)
779 retVal
= rtl8367c_getAsicReg(regAddr
, ®Data
);
780 if(retVal
!= RT_ERR_OK
)
783 *tableAddr
= regData
;
789 #ifdef CONFIG_RTL8367C_ASICDRV_TEST
790 memcpy(aclActSmi
, &Rtl8370sVirtualAclActTable
[index
][0], sizeof(rtk_uint16
) * RTL8367C_ACL_ACT_TABLE_LEN
);
793 _rtl8367c_aclActStSmi2User(pAclAct
, aclActSmi
);
798 * rtl8367c_setAsicAclActCtrl
800 * Set ACL rule matched Action Control Bits
802 * index - ACL rule index (0-95) of 96 ACL rules
803 * aclActCtrl - 6 ACL Control Bits
807 * RT_ERR_OK - Success
808 * RT_ERR_SMI - SMI access error
809 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
811 * ACL Action Control Bits Indicate which actions will be take when a rule matches
813 ret_t
rtl8367c_setAsicAclActCtrl(rtk_uint32 index
, rtk_uint32 aclActCtrl
)
817 if(index
> RTL8367C_ACLRULEMAX
)
818 return RT_ERR_OUT_OF_RANGE
;
821 retVal
= rtl8367c_setAsicRegBits(RTL8367C_ACL_ACTION_CTRL2_REG(index
), RTL8367C_ACL_OP_ACTION_MASK(index
), aclActCtrl
);
823 retVal
= rtl8367c_setAsicRegBits(RTL8367C_ACL_ACTION_CTRL_REG(index
), RTL8367C_ACL_OP_ACTION_MASK(index
), aclActCtrl
);
828 * rtl8367c_getAsicAclActCtrl
830 * Get ACL rule matched Action Control Bits
832 * index - ACL rule index (0-95) of 96 ACL rules
833 * pAclActCtrl - 6 ACL Control Bits
837 * RT_ERR_OK - Success
838 * RT_ERR_SMI - SMI access error
839 * RT_ERR_OUT_OF_RANGE - Invalid ACL rule index (0-95)
843 ret_t
rtl8367c_getAsicAclActCtrl(rtk_uint32 index
, rtk_uint32
*pAclActCtrl
)
848 if(index
> RTL8367C_ACLRULEMAX
)
849 return RT_ERR_OUT_OF_RANGE
;
852 retVal
= rtl8367c_getAsicRegBits(RTL8367C_ACL_ACTION_CTRL2_REG(index
), RTL8367C_ACL_OP_ACTION_MASK(index
), ®Data
);
854 retVal
= rtl8367c_getAsicRegBits(RTL8367C_ACL_ACTION_CTRL_REG(index
), RTL8367C_ACL_OP_ACTION_MASK(index
), ®Data
);
856 if(retVal
!= RT_ERR_OK
)
859 *pAclActCtrl
= regData
;
864 * rtl8367c_setAsicAclPortRange
866 * Set ACL TCP/UDP range check
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
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
881 ret_t
rtl8367c_setAsicAclPortRange(rtk_uint32 index
, rtk_uint32 type
, rtk_uint32 upperPort
, rtk_uint32 lowerPort
)
885 if(index
> RTL8367C_ACLRANGEMAX
)
886 return RT_ERR_OUT_OF_RANGE
;
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
)
892 retVal
= rtl8367c_setAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL1
+ index
*3, upperPort
);
893 if(retVal
!= RT_ERR_OK
)
896 retVal
= rtl8367c_setAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL0
+ index
*3, lowerPort
);
897 if(retVal
!= RT_ERR_OK
)
903 * rtl8367c_getAsicAclPortRange
905 * Get ACL TCP/UDP range check
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
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
920 ret_t
rtl8367c_getAsicAclPortRange(rtk_uint32 index
, rtk_uint32
* pType
, rtk_uint32
* pUpperPort
, rtk_uint32
* pLowerPort
)
924 if(index
> RTL8367C_ACLRANGEMAX
)
925 return RT_ERR_OUT_OF_RANGE
;
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
)
931 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL1
+ index
*3, pUpperPort
);
932 if(retVal
!= RT_ERR_OK
)
935 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_SDPORT_RANGE_ENTRY0_CTRL0
+ index
*3, pLowerPort
);
936 if(retVal
!= RT_ERR_OK
)
942 * rtl8367c_setAsicAclVidRange
944 * Set ACL VID range check
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
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)
959 ret_t
rtl8367c_setAsicAclVidRange(rtk_uint32 index
, rtk_uint32 type
, rtk_uint32 upperVid
, rtk_uint32 lowerVid
)
964 if(index
> RTL8367C_ACLRANGEMAX
)
965 return RT_ERR_OUT_OF_RANGE
;
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
);
970 retVal
= rtl8367c_setAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL1
+ index
*2, regData
);
971 if(retVal
!= RT_ERR_OK
)
974 retVal
= rtl8367c_setAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL0
+ index
*2, lowerVid
);
975 if(retVal
!= RT_ERR_OK
)
981 * rtl8367c_getAsicAclVidRange
983 * Get ACL VID range check
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
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)
998 ret_t
rtl8367c_getAsicAclVidRange(rtk_uint32 index
, rtk_uint32
* pType
, rtk_uint32
* pUpperVid
, rtk_uint32
* pLowerVid
)
1003 if(index
> RTL8367C_ACLRANGEMAX
)
1004 return RT_ERR_OUT_OF_RANGE
;
1006 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL1
+ index
*2, ®Data
);
1007 if(retVal
!= RT_ERR_OK
)
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
;
1013 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_VID_RANGE_ENTRY0_CTRL0
+ index
*2, pLowerVid
);
1014 if(retVal
!= RT_ERR_OK
)
1020 * rtl8367c_setAsicAclIpRange
1022 * Set ACL IP range check
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
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)
1037 ret_t
rtl8367c_setAsicAclIpRange(rtk_uint32 index
, rtk_uint32 type
, ipaddr_t upperIp
, ipaddr_t lowerIp
)
1043 if(index
> RTL8367C_ACLRANGEMAX
)
1044 return RT_ERR_OUT_OF_RANGE
;
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
)
1052 regData
= ipData
& 0xFFFF;
1053 retVal
= rtl8367c_setAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL2
+ index
*5, regData
);
1054 if(retVal
!= RT_ERR_OK
)
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
)
1064 regData
= ipData
& 0xFFFF;
1065 retVal
= rtl8367c_setAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL0
+ index
*5, regData
);
1066 if(retVal
!= RT_ERR_OK
)
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
)
1077 * rtl8367c_getAsicAclIpRange
1079 * Get ACL IP range check
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
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)
1094 ret_t
rtl8367c_getAsicAclIpRange(rtk_uint32 index
, rtk_uint32
* pType
, ipaddr_t
* pUpperIp
, ipaddr_t
* pLowerIp
)
1100 if(index
> RTL8367C_ACLRANGEMAX
)
1101 return RT_ERR_OUT_OF_RANGE
;
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
)
1107 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL2
+ index
*5, ®Data
);
1108 if(retVal
!= RT_ERR_OK
)
1113 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL3
+ index
*5, ®Data
);
1114 if(retVal
!= RT_ERR_OK
)
1117 ipData
= (regData
<<16) | ipData
;
1121 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL0
+ index
*5, ®Data
);
1122 if(retVal
!= RT_ERR_OK
)
1127 retVal
= rtl8367c_getAsicReg(RTL8367C_REG_ACL_IP_RANGE_ENTRY0_CTRL1
+ index
*5, ®Data
);
1128 if(retVal
!= RT_ERR_OK
)
1131 ipData
= (regData
<< 16) | ipData
;
1138 * rtl8367c_setAsicAclGpioPolarity
1140 * Set ACL Goip control palarity
1142 * polarity - 1: High, 0: Low
1146 * RT_ERR_OK - Success
1147 * RT_ERR_SMI - SMI access error
1151 ret_t
rtl8367c_setAsicAclGpioPolarity(rtk_uint32 polarity
)
1153 return rtl8367c_setAsicRegBit(RTL8367C_REG_ACL_GPIO_POLARITY
, RTL8367C_ACL_GPIO_POLARITY_OFFSET
, polarity
);
1156 * rtl8367c_getAsicAclGpioPolarity
1158 * Get ACL Goip control palarity
1160 * pPolarity - 1: High, 0: Low
1164 * RT_ERR_OK - Success
1165 * RT_ERR_SMI - SMI access error
1169 ret_t
rtl8367c_getAsicAclGpioPolarity(rtk_uint32
* pPolarity
)
1171 return rtl8367c_getAsicRegBit(RTL8367C_REG_ACL_GPIO_POLARITY
, RTL8367C_ACL_GPIO_POLARITY_OFFSET
, pPolarity
);