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 : RTK switch high-level API for RTL8367/RTL8367C
14 * Feature : Here is a list of all functions and variables in ACL module.
18 #include <rtk_switch.h>
19 #include <rtk_error.h>
26 #include <rtl8367c_asicdrv.h>
27 #include <rtl8367c_asicdrv_acl.h>
28 #include <rtl8367c_asicdrv_hsb.h>
29 #include <rtl8367c_asicdrv_vlan.h>
30 #include <rtl8367c_asicdrv_svlan.h>
31 #include <rtl8367c_asicdrv_cputag.h>
32 #include <rtl8367c_asicdrv_mib.h>
34 CONST_T rtk_uint8 filter_templateField
[RTL8367C_ACLTEMPLATENO
][RTL8367C_ACLRULEFIELDNO
] = {
35 {ACL_DMAC0
, ACL_DMAC1
, ACL_DMAC2
, ACL_SMAC0
, ACL_SMAC1
, ACL_SMAC2
, ACL_ETHERTYPE
, ACL_FIELD_SELECT15
},
36 {ACL_IP4SIP0
, ACL_IP4SIP1
, ACL_IP4DIP0
, ACL_IP4DIP1
, ACL_FIELD_SELECT13
, ACL_FIELD_SELECT14
, ACL_FIELD_SELECT02
, ACL_FIELD_SELECT15
},
37 {ACL_IP6SIP0WITHIPV4
, ACL_IP6SIP1WITHIPV4
,ACL_FIELD_SELECT03
, ACL_FIELD_SELECT04
, ACL_FIELD_SELECT05
, ACL_FIELD_SELECT06
, ACL_FIELD_SELECT07
, ACL_FIELD_SELECT08
},
38 {ACL_IP6DIP0WITHIPV4
, ACL_IP6DIP1WITHIPV4
,ACL_FIELD_SELECT09
, ACL_FIELD_SELECT10
, ACL_FIELD_SELECT11
, ACL_FIELD_SELECT12
, ACL_FIELD_SELECT13
, ACL_FIELD_SELECT14
},
39 {ACL_VIDRANGE
, ACL_IPRANGE
, ACL_PORTRANGE
, ACL_CTAG
, ACL_STAG
, ACL_FIELD_SELECT13
, ACL_FIELD_SELECT14
, ACL_FIELD_SELECT15
}
42 CONST_T rtk_uint8 filter_advanceCaretagField
[RTL8367C_ACLTEMPLATENO
][2] = {
51 CONST_T rtk_uint8 filter_fieldTemplateIndex
[FILTER_FIELD_END
][RTK_FILTER_FIELD_USED_MAX
] = {
63 {0x20, 0x21,0x22,0x23},
64 {0x30, 0x31,0x32,0x33},
97 {0xFF} /* Pattern Match */
100 CONST_T rtk_uint8 filter_fieldSize
[FILTER_FIELD_END
] = {
102 2, 2, 1, 1, 1, 1, 4, 4, 1, 1,
103 1, 1, 1, 1, 1, 1, 1, 1,
105 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
109 CONST_T rtk_uint16 field_selector
[RTL8367C_FIELDSEL_FORMAT_NUMBER
][2] =
111 {FIELDSEL_FORMAT_DEFAULT
, 0}, /* Field Selector 0 */
112 {FIELDSEL_FORMAT_DEFAULT
, 0}, /* Field Selector 1 */
113 {FIELDSEL_FORMAT_IPPAYLOAD
, 12}, /* Field Selector 2 */
114 {FIELDSEL_FORMAT_IPV6
, 10}, /* Field Selector 3 */
115 {FIELDSEL_FORMAT_IPV6
, 8}, /* Field Selector 4 */
116 {FIELDSEL_FORMAT_IPV4
, 0}, /* Field Selector 5 */
117 {FIELDSEL_FORMAT_IPV4
, 8}, /* Field Selector 6 */
118 {FIELDSEL_FORMAT_IPV6
, 0}, /* Field Selector 7 */
119 {FIELDSEL_FORMAT_IPV6
, 6}, /* Field Selector 8 */
120 {FIELDSEL_FORMAT_IPV6
, 26}, /* Field Selector 9 */
121 {FIELDSEL_FORMAT_IPV6
, 24}, /* Field Selector 10 */
122 {FIELDSEL_FORMAT_DEFAULT
, 0}, /* Field Selector 11 */
123 {FIELDSEL_FORMAT_IPV4
, 6}, /* Field Selector 12 */
124 {FIELDSEL_FORMAT_IPPAYLOAD
, 0}, /* Field Selector 13 */
125 {FIELDSEL_FORMAT_IPPAYLOAD
, 2}, /* Field Selector 14 */
126 {FIELDSEL_FORMAT_DEFAULT
, 0} /* Field Selector 15 */
130 static rtk_api_ret_t
_rtk_filter_igrAcl_writeDataField(rtl8367c_aclrule
*aclRule
, rtk_filter_field_t
*fieldPtr
);
134 * rtk_filter_igrAcl_init
136 * ACL initialization function
143 * RT_ERR_FAILED - Failed
144 * RT_ERR_SMI - SMI access error
145 * RT_ERR_NULL_POINTER - Pointer pFilter_field or pFilter_cfg point to NULL.
147 * This function enable and initialize ACL function
149 rtk_api_ret_t
rtk_filter_igrAcl_init(void)
151 rtl8367c_acltemplate_t aclTemp
;
155 /* Check initialization state */
156 RTK_CHK_INIT_STATE();
158 if ((ret
= rtk_filter_igrAcl_cfg_delAll()) != RT_ERR_OK
)
161 for(i
= 0; i
< RTL8367C_ACLTEMPLATENO
; i
++)
163 for(j
= 0; j
< RTL8367C_ACLRULEFIELDNO
;j
++)
164 aclTemp
.field
[j
] = filter_templateField
[i
][j
];
166 if ((ret
= rtl8367c_setAsicAclTemplate(i
, &aclTemp
)) != RT_ERR_OK
)
170 for(i
= 0; i
< RTL8367C_FIELDSEL_FORMAT_NUMBER
; i
++)
172 if ((ret
= rtl8367c_setAsicFieldSelector(i
, field_selector
[i
][0], field_selector
[i
][1])) != RT_ERR_OK
)
176 RTK_SCAN_ALL_PHY_PORTMASK(i
)
178 if ((ret
= rtl8367c_setAsicAcl(i
, TRUE
)) != RT_ERR_OK
)
181 if ((ret
= rtl8367c_setAsicAclUnmatchedPermit(i
, TRUE
)) != RT_ERR_OK
)
189 * rtk_filter_igrAcl_field_add
191 * Add comparison rule to an ACL configuration
193 * pFilter_cfg - The ACL configuration that this function will add comparison rule
194 * pFilter_field - The comparison rule that will be added.
199 * RT_ERR_FAILED - Failed
200 * RT_ERR_SMI - SMI access error
201 * RT_ERR_NULL_POINTER - Pointer pFilter_field or pFilter_cfg point to NULL.
202 * RT_ERR_INPUT - Invalid input parameters.
204 * This function add a comparison rule (*pFilter_field) to an ACL configuration (*pFilter_cfg).
205 * Pointer pFilter_cfg points to an ACL configuration structure, this structure keeps multiple ACL
206 * comparison rules by means of linked list. Pointer pFilter_field will be added to linked
207 * list kept by structure that pFilter_cfg points to.
209 rtk_api_ret_t
rtk_filter_igrAcl_field_add(rtk_filter_cfg_t
* pFilter_cfg
, rtk_filter_field_t
* pFilter_field
)
212 rtk_filter_field_t
*tailPtr
;
214 /* Check initialization state */
215 RTK_CHK_INIT_STATE();
217 if(NULL
== pFilter_cfg
|| NULL
== pFilter_field
)
218 return RT_ERR_NULL_POINTER
;
220 if(pFilter_field
->fieldType
>= FILTER_FIELD_END
)
221 return RT_ERR_ENTRY_INDEX
;
224 if(0 == pFilter_field
->fieldTemplateNo
)
226 pFilter_field
->fieldTemplateNo
= filter_fieldSize
[pFilter_field
->fieldType
];
228 for(i
= 0; i
< pFilter_field
->fieldTemplateNo
; i
++)
230 pFilter_field
->fieldTemplateIdx
[i
] = filter_fieldTemplateIndex
[pFilter_field
->fieldType
][i
];
234 if(NULL
== pFilter_cfg
->fieldHead
)
236 pFilter_cfg
->fieldHead
= pFilter_field
;
240 if (pFilter_cfg
->fieldHead
->next
== NULL
)
242 pFilter_cfg
->fieldHead
->next
= pFilter_field
;
246 tailPtr
= pFilter_cfg
->fieldHead
->next
;
247 while( tailPtr
->next
!= NULL
)
249 tailPtr
= tailPtr
->next
;
251 tailPtr
->next
= pFilter_field
;
258 static rtk_api_ret_t
_rtk_filter_igrAcl_writeDataField(rtl8367c_aclrule
*aclRule
, rtk_filter_field_t
*fieldPtr
)
260 rtk_uint32 i
, tempIdx
,fieldIdx
, ipValue
, ipMask
;
261 rtk_uint32 ip6addr
[RTK_IPV6_ADDR_WORD_LENGTH
];
262 rtk_uint32 ip6mask
[RTK_IPV6_ADDR_WORD_LENGTH
];
264 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
266 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
268 aclRule
[tempIdx
].valid
= TRUE
;
271 switch (fieldPtr
->fieldType
)
273 /* use DMAC structure as representative for mac structure */
274 case FILTER_FIELD_DMAC
:
275 case FILTER_FIELD_SMAC
:
277 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
279 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
280 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
282 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.mac
.value
.octet
[5 - i
*2] | (fieldPtr
->filter_pattern_union
.mac
.value
.octet
[5 - (i
*2 + 1)] << 8);
283 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.mac
.mask
.octet
[5 - i
*2] | (fieldPtr
->filter_pattern_union
.mac
.mask
.octet
[5 - (i
*2 + 1)] << 8);
286 case FILTER_FIELD_ETHERTYPE
:
287 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
289 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
290 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
292 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.etherType
.value
;
293 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.etherType
.mask
;
296 case FILTER_FIELD_IPV4_SIP
:
297 case FILTER_FIELD_IPV4_DIP
:
299 ipValue
= fieldPtr
->filter_pattern_union
.sip
.value
;
300 ipMask
= fieldPtr
->filter_pattern_union
.sip
.mask
;
302 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
304 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
305 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
307 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = (0xFFFF & (ipValue
>> (i
*16)));
308 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = (0xFFFF & (ipMask
>> (i
*16)));
311 case FILTER_FIELD_IPV4_TOS
:
312 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
314 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
315 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
317 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.ipTos
.value
& 0xFF;
318 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.ipTos
.mask
& 0xFF;
321 case FILTER_FIELD_IPV4_PROTOCOL
:
322 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
324 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
325 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
327 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.protocol
.value
& 0xFF;
328 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.protocol
.mask
& 0xFF;
331 case FILTER_FIELD_IPV6_SIPV6
:
332 case FILTER_FIELD_IPV6_DIPV6
:
333 for(i
= 0; i
< RTK_IPV6_ADDR_WORD_LENGTH
; i
++)
335 ip6addr
[i
] = fieldPtr
->filter_pattern_union
.sipv6
.value
.addr
[i
];
336 ip6mask
[i
] = fieldPtr
->filter_pattern_union
.sipv6
.mask
.addr
[i
];
339 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
341 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
342 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
346 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = ((ip6addr
[0] & (0xFFFF << (i
* 16))) >> (i
* 16));
347 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = ((ip6mask
[0] & (0xFFFF << (i
* 16))) >> (i
* 16));
351 /*default ACL template for ipv6 address supports MSB 32-bits and LSB 32-bits only*/
352 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = ((ip6addr
[3] & (0xFFFF << ((i
&1) * 16))) >> ((i
&1) * 16));
353 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = ((ip6mask
[3] & (0xFFFF << ((i
&1) * 16))) >> ((i
&1) * 16));
358 case FILTER_FIELD_CTAG
:
359 case FILTER_FIELD_STAG
:
361 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
363 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
364 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
366 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = (fieldPtr
->filter_pattern_union
.l2tag
.pri
.value
<< 13) | (fieldPtr
->filter_pattern_union
.l2tag
.cfi
.value
<< 12) | fieldPtr
->filter_pattern_union
.l2tag
.vid
.value
;
367 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = (fieldPtr
->filter_pattern_union
.l2tag
.pri
.mask
<< 13) | (fieldPtr
->filter_pattern_union
.l2tag
.cfi
.mask
<< 12) | fieldPtr
->filter_pattern_union
.l2tag
.vid
.mask
;
370 case FILTER_FIELD_IPV4_FLAG
:
372 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
374 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
375 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
377 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] &= 0x1FFF;
378 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.ipFlag
.xf
.value
<< 15);
379 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.ipFlag
.df
.value
<< 14);
380 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.ipFlag
.mf
.value
<< 13);
382 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] &= 0x1FFF;
383 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.ipFlag
.xf
.mask
<< 15);
384 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.ipFlag
.df
.mask
<< 14);
385 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.ipFlag
.mf
.mask
<< 13);
389 case FILTER_FIELD_IPV4_OFFSET
:
391 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
393 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
394 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
396 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] &= 0xE000;
397 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= fieldPtr
->filter_pattern_union
.inData
.value
;
399 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] &= 0xE000;
400 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= fieldPtr
->filter_pattern_union
.inData
.mask
;
405 case FILTER_FIELD_IPV6_TRAFFIC_CLASS
:
406 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
408 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
409 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
412 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = (fieldPtr
->filter_pattern_union
.inData
.value
<< 4)&0x0FF0;
413 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = (fieldPtr
->filter_pattern_union
.inData
.mask
<< 4)&0x0FF0;
416 case FILTER_FIELD_IPV6_NEXT_HEADER
:
417 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
419 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
420 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
422 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.inData
.value
<< 8;
423 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.inData
.mask
<< 8;
426 case FILTER_FIELD_TCP_SPORT
:
427 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
429 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
430 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
432 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.tcpSrcPort
.value
;
433 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.tcpSrcPort
.mask
;
436 case FILTER_FIELD_TCP_DPORT
:
437 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
439 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
440 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
442 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.tcpDstPort
.value
;
443 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.tcpDstPort
.mask
;
446 case FILTER_FIELD_TCP_FLAG
:
448 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
450 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
451 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
453 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.cwr
.value
<< 7);
454 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.ece
.value
<< 6);
455 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.urg
.value
<< 5);
456 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.ack
.value
<< 4);
457 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.psh
.value
<< 3);
458 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.rst
.value
<< 2);
459 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.syn
.value
<< 1);
460 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= fieldPtr
->filter_pattern_union
.tcpFlag
.fin
.value
;
462 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.cwr
.mask
<< 7);
463 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.ece
.mask
<< 6);
464 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.urg
.mask
<< 5);
465 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.ack
.mask
<< 4);
466 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.psh
.mask
<< 3);
467 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.rst
.mask
<< 2);
468 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.tcpFlag
.syn
.mask
<< 1);
469 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= fieldPtr
->filter_pattern_union
.tcpFlag
.fin
.mask
;
472 case FILTER_FIELD_UDP_SPORT
:
473 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
475 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
476 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
478 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.udpSrcPort
.value
;
479 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.udpSrcPort
.mask
;
482 case FILTER_FIELD_UDP_DPORT
:
483 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
485 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
486 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
488 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.udpDstPort
.value
;
489 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.udpDstPort
.mask
;
492 case FILTER_FIELD_ICMP_CODE
:
493 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
495 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
496 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
498 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] &= 0xFF00;
499 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= fieldPtr
->filter_pattern_union
.icmpCode
.value
;
500 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] &= 0xFF00;
501 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= fieldPtr
->filter_pattern_union
.icmpCode
.mask
;
504 case FILTER_FIELD_ICMP_TYPE
:
505 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
507 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
508 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
510 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] &= 0x00FF;
511 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.icmpType
.value
<< 8);
512 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] &= 0x00FF;
513 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] |= (fieldPtr
->filter_pattern_union
.icmpType
.mask
<< 8);
516 case FILTER_FIELD_IGMP_TYPE
:
517 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
519 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
520 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
522 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = (fieldPtr
->filter_pattern_union
.igmpType
.value
<< 8);
523 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = (fieldPtr
->filter_pattern_union
.igmpType
.mask
<< 8);
526 case FILTER_FIELD_PATTERN_MATCH
:
527 for(i
= 0; i
< fieldPtr
->fieldTemplateNo
; i
++)
529 tempIdx
= (fieldPtr
->fieldTemplateIdx
[i
] & 0xF0) >> 4;
530 fieldIdx
= fieldPtr
->fieldTemplateIdx
[i
] & 0x0F;
532 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = ((fieldPtr
->filter_pattern_union
.pattern
.value
[i
/2] >> (16 * (i
%2))) & 0x0000FFFF );
533 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = ((fieldPtr
->filter_pattern_union
.pattern
.mask
[i
/2] >> (16 * (i
%2))) & 0x0000FFFF );
536 case FILTER_FIELD_VID_RANGE
:
537 case FILTER_FIELD_IP_RANGE
:
538 case FILTER_FIELD_PORT_RANGE
:
540 tempIdx
= (fieldPtr
->fieldTemplateIdx
[0] & 0xF0) >> 4;
541 fieldIdx
= fieldPtr
->fieldTemplateIdx
[0] & 0x0F;
543 aclRule
[tempIdx
].data_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.inData
.value
;
544 aclRule
[tempIdx
].care_bits
.field
[fieldIdx
] = fieldPtr
->filter_pattern_union
.inData
.mask
;
552 * rtk_filter_igrAcl_cfg_add
554 * Add an ACL configuration to ASIC
556 * filter_id - Start index of ACL configuration.
557 * pFilter_cfg - The ACL configuration that this function will add comparison rule
558 * pFilter_action - Action(s) of ACL configuration.
560 * ruleNum - number of rules written in ACL table
563 * RT_ERR_FAILED - Failed
564 * RT_ERR_SMI - SMI access error
565 * RT_ERR_NULL_POINTER - Pointer pFilter_field or pFilter_cfg point to NULL.
566 * RT_ERR_INPUT - Invalid input parameters.
567 * RT_ERR_ENTRY_INDEX - Invalid filter_id .
568 * RT_ERR_NULL_POINTER - Pointer pFilter_action or pFilter_cfg point to NULL.
569 * RT_ERR_FILTER_INACL_ACT_NOT_SUPPORT - Action is not supported in this chip.
570 * RT_ERR_FILTER_INACL_RULE_NOT_SUPPORT - Rule is not supported.
572 * This function store pFilter_cfg, pFilter_action into ASIC. The starting
573 * index(es) is filter_id.
575 rtk_api_ret_t
rtk_filter_igrAcl_cfg_add(rtk_filter_id_t filter_id
, rtk_filter_cfg_t
* pFilter_cfg
, rtk_filter_action_t
* pFilter_action
, rtk_filter_number_t
*ruleNum
)
577 rtk_api_ret_t retVal
;
578 rtk_uint32 careTagData
, careTagMask
;
579 rtk_uint32 i
,vidx
, svidx
, actType
, ruleId
;
580 rtk_uint32 aclActCtrl
;
582 rtk_filter_field_t
* fieldPtr
;
583 rtl8367c_aclrule aclRule
[RTL8367C_ACLTEMPLATENO
];
584 rtl8367c_aclrule tempRule
;
585 rtl8367c_acl_act_t aclAct
;
586 rtk_uint32 noRulesAdd
;
588 /* Check initialization state */
589 RTK_CHK_INIT_STATE();
591 if(filter_id
> RTL8367C_ACLRULEMAX
)
592 return RT_ERR_ENTRY_INDEX
;
594 if((NULL
== pFilter_cfg
) || (NULL
== pFilter_action
) || (NULL
== ruleNum
))
595 return RT_ERR_NULL_POINTER
;
597 fieldPtr
= pFilter_cfg
->fieldHead
;
600 for(i
= 0; i
< RTL8367C_ACLTEMPLATENO
; i
++)
602 memset(&aclRule
[i
], 0, sizeof(rtl8367c_aclrule
));
604 aclRule
[i
].data_bits
.type
= i
;
605 aclRule
[i
].care_bits
.type
= 0x7;
608 while(NULL
!= fieldPtr
)
610 _rtk_filter_igrAcl_writeDataField(aclRule
, fieldPtr
);
612 fieldPtr
= fieldPtr
->next
;
615 /*set care tag mask in User Defined Field 15*/
616 /*Follow care tag should not be used while ACL template and User defined fields are fully control by system designer*/
617 /*those advanced packet type care tag is used in default template design structure only*/
621 for(i
= CARE_TAG_TCP
; i
< CARE_TAG_END
; i
++)
623 if(pFilter_cfg
->careTag
.tagType
[i
].mask
)
624 careTagMask
= careTagMask
| (1 << (i
-CARE_TAG_TCP
));
626 if(pFilter_cfg
->careTag
.tagType
[i
].value
)
627 careTagData
= careTagData
| (1 << (i
-CARE_TAG_TCP
));
630 if(careTagData
|| careTagMask
)
633 while(i
< RTL8367C_ACLTEMPLATENO
)
635 if(aclRule
[i
].valid
== 1 && filter_advanceCaretagField
[i
][0] == TRUE
)
638 aclRule
[i
].data_bits
.field
[filter_advanceCaretagField
[i
][1]] = careTagData
& 0xFFFF;
639 aclRule
[i
].care_bits
.field
[filter_advanceCaretagField
[i
][1]] = careTagMask
& 0xFFFF;
644 /*none of previous used template containing field 15*/
645 if(i
== RTL8367C_ACLTEMPLATENO
)
648 while(i
< RTL8367C_ACLTEMPLATENO
)
650 if(filter_advanceCaretagField
[i
][0] == TRUE
)
652 aclRule
[i
].data_bits
.field
[filter_advanceCaretagField
[i
][1]] = careTagData
& 0xFFFF;
653 aclRule
[i
].care_bits
.field
[filter_advanceCaretagField
[i
][1]] = careTagMask
& 0xFFFF;
654 aclRule
[i
].valid
= 1;
662 /*Check rule number*/
664 for(i
= 0; i
< RTL8367C_ACLTEMPLATENO
; i
++)
666 if(1 == aclRule
[i
].valid
)
672 *ruleNum
= noRulesAdd
;
674 if((filter_id
+ noRulesAdd
- 1) > RTL8367C_ACLRULEMAX
)
676 return RT_ERR_ENTRY_INDEX
;
679 /*set care tag mask in TAG Indicator*/
683 for(i
= 0; i
<= CARE_TAG_IPV6
;i
++)
685 if(0 == pFilter_cfg
->careTag
.tagType
[i
].mask
)
687 careTagMask
&= ~(1 << i
);
691 careTagMask
|= (1 << i
);
692 if(0 == pFilter_cfg
->careTag
.tagType
[i
].value
)
693 careTagData
&= ~(1 << i
);
695 careTagData
|= (1 << i
);
699 for(i
= 0; i
< RTL8367C_ACLTEMPLATENO
; i
++)
701 aclRule
[i
].data_bits
.tag_exist
= (careTagData
) & ACL_RULE_CARETAG_MASK
;
702 aclRule
[i
].care_bits
.tag_exist
= (careTagMask
) & ACL_RULE_CARETAG_MASK
;
705 RTK_CHK_PORTMASK_VALID(&pFilter_cfg
->activeport
.value
);
706 RTK_CHK_PORTMASK_VALID(&pFilter_cfg
->activeport
.mask
);
708 for(i
= 0; i
< RTL8367C_ACLTEMPLATENO
; i
++)
710 if(TRUE
== aclRule
[i
].valid
)
712 if(rtk_switch_portmask_L2P_get(&pFilter_cfg
->activeport
.value
, &portmask
) != RT_ERR_OK
)
713 return RT_ERR_PORT_MASK
;
715 aclRule
[i
].data_bits
.active_portmsk
= portmask
;
717 if(rtk_switch_portmask_L2P_get(&pFilter_cfg
->activeport
.mask
, &portmask
) != RT_ERR_OK
)
718 return RT_ERR_PORT_MASK
;
720 aclRule
[i
].care_bits
.active_portmsk
= portmask
;
724 if(pFilter_cfg
->invert
>= FILTER_INVERT_END
)
728 /*Last action gets high priority if actions are the same*/
729 memset(&aclAct
, 0, sizeof(rtl8367c_acl_act_t
));
731 for(actType
= 0; actType
< FILTER_ENACT_END
; actType
++)
733 if(pFilter_action
->actEnable
[actType
])
737 case FILTER_ENACT_CVLAN_INGRESS
:
738 if(pFilter_action
->filterCvlanVid
> RTL8367C_EVIDMAX
)
741 if((retVal
= rtk_vlan_checkAndCreateMbr(pFilter_action
->filterCvlanVid
, &vidx
)) != RT_ERR_OK
)
745 aclAct
.cact
= FILTER_ENACT_CVLAN_TYPE(actType
);
746 aclAct
.cvidx_cact
= vidx
;
748 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
750 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_TAGONLY
)
751 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
755 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_VLANONLY
;
758 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
760 case FILTER_ENACT_CVLAN_EGRESS
:
761 if(pFilter_action
->filterCvlanVid
> RTL8367C_EVIDMAX
)
764 if((retVal
= rtk_vlan_checkAndCreateMbr(pFilter_action
->filterCvlanVid
, &vidx
)) != RT_ERR_OK
)
767 aclAct
.cact
= FILTER_ENACT_CVLAN_TYPE(actType
);
768 aclAct
.cvidx_cact
= vidx
;
770 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
772 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_TAGONLY
)
773 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
777 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_VLANONLY
;
780 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
782 case FILTER_ENACT_CVLAN_SVID
:
784 aclAct
.cact
= FILTER_ENACT_CVLAN_TYPE(actType
);
786 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
788 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_TAGONLY
)
789 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
793 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_VLANONLY
;
796 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
798 case FILTER_ENACT_POLICING_1
:
799 if(pFilter_action
->filterPolicingIdx
[1] >= (RTK_METER_NUM
+ RTL8367C_MAX_LOG_CNT_NUM
))
802 aclAct
.cact
= FILTER_ENACT_CVLAN_TYPE(actType
);
803 aclAct
.cvidx_cact
= pFilter_action
->filterPolicingIdx
[1];
805 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
807 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_TAGONLY
)
808 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
812 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_VLANONLY
;
815 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
818 case FILTER_ENACT_SVLAN_INGRESS
:
819 case FILTER_ENACT_SVLAN_EGRESS
:
821 if((retVal
= rtk_svlan_checkAndCreateMbr(pFilter_action
->filterSvlanVid
, &svidx
)) != RT_ERR_OK
)
824 aclAct
.sact
= FILTER_ENACT_SVLAN_TYPE(actType
);
825 aclAct
.svidx_sact
= svidx
;
826 aclActCtrl
|= FILTER_ENACT_SVLAN_MASK
;
828 case FILTER_ENACT_SVLAN_CVID
:
830 aclAct
.sact
= FILTER_ENACT_SVLAN_TYPE(actType
);
831 aclActCtrl
|= FILTER_ENACT_SVLAN_MASK
;
833 case FILTER_ENACT_POLICING_2
:
834 if(pFilter_action
->filterPolicingIdx
[2] >= (RTK_METER_NUM
+ RTL8367C_MAX_LOG_CNT_NUM
))
837 aclAct
.sact
= FILTER_ENACT_SVLAN_TYPE(actType
);
838 aclAct
.svidx_sact
= pFilter_action
->filterPolicingIdx
[2];
839 aclActCtrl
|= FILTER_ENACT_SVLAN_MASK
;
841 case FILTER_ENACT_POLICING_0
:
842 if(pFilter_action
->filterPolicingIdx
[0] >= (RTK_METER_NUM
+ RTL8367C_MAX_LOG_CNT_NUM
))
845 aclAct
.aclmeteridx
= pFilter_action
->filterPolicingIdx
[0];
846 aclActCtrl
|= FILTER_ENACT_POLICING_MASK
;
848 case FILTER_ENACT_PRIORITY
:
849 case FILTER_ENACT_1P_REMARK
:
850 if(pFilter_action
->filterPriority
> RTL8367C_PRIMAX
)
853 aclAct
.priact
= FILTER_ENACT_PRI_TYPE(actType
);
854 aclAct
.pridx
= pFilter_action
->filterPriority
;
855 aclActCtrl
|= FILTER_ENACT_PRIORITY_MASK
;
857 case FILTER_ENACT_DSCP_REMARK
:
858 if(pFilter_action
->filterPriority
> RTL8367C_DSCPMAX
)
861 aclAct
.priact
= FILTER_ENACT_PRI_TYPE(actType
);
862 aclAct
.pridx
= pFilter_action
->filterPriority
;
863 aclActCtrl
|= FILTER_ENACT_PRIORITY_MASK
;
865 case FILTER_ENACT_POLICING_3
:
866 if(pFilter_action
->filterPriority
>= (RTK_METER_NUM
+ RTL8367C_MAX_LOG_CNT_NUM
))
869 aclAct
.priact
= FILTER_ENACT_PRI_TYPE(actType
);
870 aclAct
.pridx
= pFilter_action
->filterPolicingIdx
[3];
871 aclActCtrl
|= FILTER_ENACT_PRIORITY_MASK
;
873 case FILTER_ENACT_DROP
:
875 aclAct
.fwdact
= FILTER_ENACT_FWD_TYPE(FILTER_ENACT_REDIRECT
);
876 aclAct
.fwdact_ext
= FALSE
;
879 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
881 case FILTER_ENACT_REDIRECT
:
882 RTK_CHK_PORTMASK_VALID(&pFilter_action
->filterPortmask
);
884 aclAct
.fwdact
= FILTER_ENACT_FWD_TYPE(actType
);
885 aclAct
.fwdact_ext
= FALSE
;
887 if(rtk_switch_portmask_L2P_get(&pFilter_action
->filterPortmask
, &portmask
) != RT_ERR_OK
)
888 return RT_ERR_PORT_MASK
;
889 aclAct
.fwdpmask
= portmask
;
891 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
894 case FILTER_ENACT_ADD_DSTPORT
:
895 RTK_CHK_PORTMASK_VALID(&pFilter_action
->filterPortmask
);
897 aclAct
.fwdact
= FILTER_ENACT_FWD_TYPE(actType
);
898 aclAct
.fwdact_ext
= FALSE
;
900 if(rtk_switch_portmask_L2P_get(&pFilter_action
->filterPortmask
, &portmask
) != RT_ERR_OK
)
901 return RT_ERR_PORT_MASK
;
902 aclAct
.fwdpmask
= portmask
;
904 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
906 case FILTER_ENACT_MIRROR
:
907 RTK_CHK_PORTMASK_VALID(&pFilter_action
->filterPortmask
);
909 aclAct
.fwdact
= FILTER_ENACT_FWD_TYPE(actType
);
910 aclAct
.cact_ext
= FALSE
;
912 if(rtk_switch_portmask_L2P_get(&pFilter_action
->filterPortmask
, &portmask
) != RT_ERR_OK
)
913 return RT_ERR_PORT_MASK
;
914 aclAct
.fwdpmask
= portmask
;
916 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
918 case FILTER_ENACT_TRAP_CPU
:
920 aclAct
.fwdact
= FILTER_ENACT_FWD_TYPE(actType
);
921 aclAct
.fwdact_ext
= FALSE
;
923 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
925 case FILTER_ENACT_COPY_CPU
:
926 if((retVal
= rtl8367c_getAsicCputagTrapPort(&cpuPort
)) != RT_ERR_OK
)
929 aclAct
.fwdact
= FILTER_ENACT_FWD_TYPE(FILTER_ENACT_MIRROR
);
930 aclAct
.fwdact_ext
= FALSE
;
932 aclAct
.fwdpmask
= 1 << cpuPort
;
933 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
935 case FILTER_ENACT_ISOLATION
:
936 RTK_CHK_PORTMASK_VALID(&pFilter_action
->filterPortmask
);
938 aclAct
.fwdact_ext
= TRUE
;
940 if(rtk_switch_portmask_L2P_get(&pFilter_action
->filterPortmask
, &portmask
) != RT_ERR_OK
)
941 return RT_ERR_PORT_MASK
;
942 aclAct
.fwdpmask
= portmask
;
944 aclActCtrl
|= FILTER_ENACT_FWD_MASK
;
947 case FILTER_ENACT_INTERRUPT
:
949 aclAct
.aclint
= TRUE
;
950 aclActCtrl
|= FILTER_ENACT_INTGPIO_MASK
;
952 case FILTER_ENACT_GPO
:
954 aclAct
.gpio_en
= TRUE
;
955 aclAct
.gpio_pin
= pFilter_action
->filterPin
;
956 aclActCtrl
|= FILTER_ENACT_INTGPIO_MASK
;
958 case FILTER_ENACT_EGRESSCTAG_TAG
:
960 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
962 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_VLANONLY
)
963 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
967 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_TAGONLY
;
969 aclAct
.tag_fmt
= FILTER_CTAGFMT_TAG
;
970 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
972 case FILTER_ENACT_EGRESSCTAG_UNTAG
:
974 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
976 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_VLANONLY
)
977 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
981 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_TAGONLY
;
983 aclAct
.tag_fmt
= FILTER_CTAGFMT_UNTAG
;
984 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
986 case FILTER_ENACT_EGRESSCTAG_KEEP
:
988 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
990 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_VLANONLY
)
991 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
995 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_TAGONLY
;
997 aclAct
.tag_fmt
= FILTER_CTAGFMT_KEEP
;
998 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
1000 case FILTER_ENACT_EGRESSCTAG_KEEPAND1PRMK
:
1002 if(aclActCtrl
&(FILTER_ENACT_CVLAN_MASK
))
1004 if(aclAct
.cact_ext
== FILTER_ENACT_CACTEXT_VLANONLY
)
1005 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_BOTHVLANTAG
;
1009 aclAct
.cact_ext
= FILTER_ENACT_CACTEXT_TAGONLY
;
1011 aclAct
.tag_fmt
= FILTER_CTAGFMT_KEEP1PRMK
;
1012 aclActCtrl
|= FILTER_ENACT_CVLAN_MASK
;
1015 return RT_ERR_FILTER_INACL_ACT_NOT_SUPPORT
;
1021 /*check if free ACL rules are enough*/
1022 for(i
= filter_id
; i
< (filter_id
+ noRulesAdd
); i
++)
1024 if((retVal
= rtl8367c_getAsicAclRule(i
, &tempRule
)) != RT_ERR_OK
)
1027 if(tempRule
.valid
== TRUE
)
1029 return RT_ERR_TBL_FULL
;
1034 for(i
= 0; i
< RTL8367C_ACLTEMPLATENO
; i
++)
1036 if(aclRule
[i
].valid
== TRUE
)
1038 /* write ACL action control */
1039 if((retVal
= rtl8367c_setAsicAclActCtrl(filter_id
+ ruleId
, aclActCtrl
)) != RT_ERR_OK
)
1041 /* write ACL action */
1042 if((retVal
= rtl8367c_setAsicAclAct(filter_id
+ ruleId
, &aclAct
)) != RT_ERR_OK
)
1046 if((retVal
= rtl8367c_setAsicAclNot(filter_id
+ ruleId
, pFilter_cfg
->invert
)) != RT_ERR_OK
)
1048 /* write ACL rule */
1049 if((retVal
= rtl8367c_setAsicAclRule(filter_id
+ ruleId
, &aclRule
[i
])) != RT_ERR_OK
)
1052 /* only the first rule will be written with input action control, aclActCtrl of other rules will be zero */
1054 memset(&aclAct
, 0, sizeof(rtl8367c_acl_act_t
));
1064 * rtk_filter_igrAcl_cfg_del
1066 * Delete an ACL configuration from ASIC
1068 * filter_id - Start index of ACL configuration.
1073 * RT_ERR_FAILED - Failed
1074 * RT_ERR_SMI - SMI access error
1075 * RT_ERR_FILTER_ENTRYIDX - Invalid filter_id.
1077 * This function delete a group of ACL rules starting from filter_id.
1079 rtk_api_ret_t
rtk_filter_igrAcl_cfg_del(rtk_filter_id_t filter_id
)
1081 rtl8367c_aclrule initRule
;
1082 rtl8367c_acl_act_t initAct
;
1085 /* Check initialization state */
1086 RTK_CHK_INIT_STATE();
1088 if(filter_id
> RTL8367C_ACLRULEMAX
)
1089 return RT_ERR_FILTER_ENTRYIDX
;
1091 memset(&initRule
, 0, sizeof(rtl8367c_aclrule
));
1092 memset(&initAct
, 0, sizeof(rtl8367c_acl_act_t
));
1094 if((ret
= rtl8367c_setAsicAclRule(filter_id
, &initRule
)) != RT_ERR_OK
)
1096 if((ret
= rtl8367c_setAsicAclActCtrl(filter_id
, FILTER_ENACT_INIT_MASK
))!= RT_ERR_OK
)
1098 if((ret
= rtl8367c_setAsicAclAct(filter_id
, &initAct
)) != RT_ERR_OK
)
1100 if((ret
= rtl8367c_setAsicAclNot(filter_id
, DISABLED
)) != RT_ERR_OK
)
1107 * rtk_filter_igrAcl_cfg_delAll
1109 * Delete all ACL entries from ASIC
1116 * RT_ERR_FAILED - Failed
1117 * RT_ERR_SMI - SMI access error
1119 * This function delete all ACL configuration from ASIC.
1121 rtk_api_ret_t
rtk_filter_igrAcl_cfg_delAll(void)
1126 /* Check initialization state */
1127 RTK_CHK_INIT_STATE();
1129 for(i
= 0; i
< RTL8367C_ACLRULENO
; i
++)
1131 if((ret
= rtl8367c_setAsicAclActCtrl(i
, FILTER_ENACT_INIT_MASK
))!= RT_ERR_OK
)
1133 if((ret
= rtl8367c_setAsicAclNot(i
, DISABLED
)) != RT_ERR_OK
)
1137 return rtl8367c_setAsicRegBit(RTL8367C_REG_ACL_RESET_CFG
, RTL8367C_ACL_RESET_CFG_OFFSET
, TRUE
);;
1141 * rtk_filter_igrAcl_cfg_get
1143 * Get one ingress ACL configuration from ASIC.
1145 * filter_id - Start index of ACL configuration.
1147 * pFilter_cfg - buffer pointer of ingress ACL data
1148 * pFilter_action - buffer pointer of ingress ACL action
1151 * RT_ERR_FAILED - Failed
1152 * RT_ERR_SMI - SMI access error
1153 * RT_ERR_NULL_POINTER - Pointer pFilter_action or pFilter_cfg point to NULL.
1154 * RT_ERR_FILTER_ENTRYIDX - Invalid entry index.
1156 * This function get configuration from ASIC.
1158 rtk_api_ret_t
rtk_filter_igrAcl_cfg_get(rtk_filter_id_t filter_id
, rtk_filter_cfg_raw_t
*pFilter_cfg
, rtk_filter_action_t
*pAction
)
1160 rtk_api_ret_t retVal
;
1162 rtl8367c_aclrule aclRule
;
1163 rtl8367c_acl_act_t aclAct
;
1165 rtl8367c_acltemplate_t type
;
1166 rtl8367c_svlan_memconf_t svlan_cfg
;
1167 rtl8367c_vlanconfiguser vlanMC
;
1168 rtk_uint32 phyPmask
;
1170 /* Check initialization state */
1171 RTK_CHK_INIT_STATE();
1173 if(NULL
== pFilter_cfg
|| NULL
== pAction
)
1174 return RT_ERR_NULL_POINTER
;
1176 if(filter_id
> RTL8367C_ACLRULEMAX
)
1177 return RT_ERR_ENTRY_INDEX
;
1179 if ((retVal
= rtl8367c_getAsicAclRule(filter_id
, &aclRule
)) != RT_ERR_OK
)
1183 if(aclRule
.valid
== 0)
1185 pFilter_cfg
->valid
= DISABLED
;
1189 phyPmask
= aclRule
.data_bits
.active_portmsk
;
1190 if(rtk_switch_portmask_P2L_get(phyPmask
,&(pFilter_cfg
->activeport
.value
)) != RT_ERR_OK
)
1191 return RT_ERR_FAILED
;
1193 phyPmask
= aclRule
.care_bits
.active_portmsk
;
1194 if(rtk_switch_portmask_P2L_get(phyPmask
,&(pFilter_cfg
->activeport
.mask
)) != RT_ERR_OK
)
1195 return RT_ERR_FAILED
;
1197 for(i
= 0; i
<= CARE_TAG_IPV6
; i
++)
1199 if(aclRule
.data_bits
.tag_exist
& (1 << i
))
1200 pFilter_cfg
->careTag
.tagType
[i
].value
= 1;
1202 pFilter_cfg
->careTag
.tagType
[i
].value
= 0;
1204 if (aclRule
.care_bits
.tag_exist
& (1 << i
))
1205 pFilter_cfg
->careTag
.tagType
[i
].mask
= 1;
1207 pFilter_cfg
->careTag
.tagType
[i
].mask
= 0;
1210 if(filter_advanceCaretagField
[aclRule
.data_bits
.type
][0] == TRUE
)
1212 /* Advanced Care tag setting */
1213 for(i
= CARE_TAG_TCP
; i
< CARE_TAG_END
; i
++)
1215 if(aclRule
.data_bits
.field
[filter_advanceCaretagField
[aclRule
.data_bits
.type
][1]] & (0x0001 << (i
-CARE_TAG_TCP
)) )
1216 pFilter_cfg
->careTag
.tagType
[i
].value
= 1;
1218 pFilter_cfg
->careTag
.tagType
[i
].value
= 0;
1220 if(aclRule
.care_bits
.field
[filter_advanceCaretagField
[aclRule
.care_bits
.type
][1]] & (0x0001 << (i
-CARE_TAG_TCP
)) )
1221 pFilter_cfg
->careTag
.tagType
[i
].mask
= 1;
1223 pFilter_cfg
->careTag
.tagType
[i
].mask
= 0;
1227 for(i
= 0; i
< RTL8367C_ACLRULEFIELDNO
; i
++)
1229 pFilter_cfg
->careFieldRaw
[i
] = aclRule
.care_bits
.field
[i
];
1230 pFilter_cfg
->dataFieldRaw
[i
] = aclRule
.data_bits
.field
[i
];
1233 if ((retVal
= rtl8367c_getAsicAclNot(filter_id
, &tmp
))!= RT_ERR_OK
)
1236 pFilter_cfg
->invert
= tmp
;
1238 pFilter_cfg
->valid
= aclRule
.valid
;
1240 memset(pAction
, 0, sizeof(rtk_filter_action_t
));
1242 if ((retVal
= rtl8367c_getAsicAclActCtrl(filter_id
, &tmp
))!= RT_ERR_OK
)
1245 if ((retVal
= rtl8367c_getAsicAclAct(filter_id
, &aclAct
)) != RT_ERR_OK
)
1248 if(tmp
& FILTER_ENACT_FWD_MASK
)
1250 if(TRUE
== aclAct
.fwdact_ext
)
1252 pAction
->actEnable
[FILTER_ENACT_ISOLATION
] = TRUE
;
1254 phyPmask
= aclAct
.fwdpmask
;
1255 if(rtk_switch_portmask_P2L_get(phyPmask
,&(pAction
->filterPortmask
)) != RT_ERR_OK
)
1256 return RT_ERR_FAILED
;
1258 else if(aclAct
.fwdact
== RTL8367C_ACL_FWD_TRAP
)
1260 pAction
->actEnable
[FILTER_ENACT_TRAP_CPU
] = TRUE
;
1262 else if (aclAct
.fwdact
== RTL8367C_ACL_FWD_MIRRORFUNTION
)
1264 pAction
->actEnable
[FILTER_ENACT_MIRROR
] = TRUE
;
1266 phyPmask
= aclAct
.fwdpmask
;
1267 if(rtk_switch_portmask_P2L_get(phyPmask
,&(pAction
->filterPortmask
)) != RT_ERR_OK
)
1268 return RT_ERR_FAILED
;
1270 else if (aclAct
.fwdact
== RTL8367C_ACL_FWD_REDIRECT
)
1272 if(aclAct
.fwdpmask
== 0 )
1273 pAction
->actEnable
[FILTER_ENACT_DROP
] = TRUE
;
1276 pAction
->actEnable
[FILTER_ENACT_REDIRECT
] = TRUE
;
1278 phyPmask
= aclAct
.fwdpmask
;
1279 if(rtk_switch_portmask_P2L_get(phyPmask
,&(pAction
->filterPortmask
)) != RT_ERR_OK
)
1280 return RT_ERR_FAILED
;
1283 else if (aclAct
.fwdact
== RTL8367C_ACL_FWD_MIRROR
)
1285 if((retVal
= rtl8367c_getAsicCputagTrapPort(&cpuPort
)) != RT_ERR_OK
)
1287 if (aclAct
.fwdpmask
== (1 << cpuPort
))
1289 pAction
->actEnable
[FILTER_ENACT_COPY_CPU
] = TRUE
;
1293 pAction
->actEnable
[FILTER_ENACT_ADD_DSTPORT
] = TRUE
;
1295 phyPmask
= aclAct
.fwdpmask
;
1296 if(rtk_switch_portmask_P2L_get(phyPmask
,&(pAction
->filterPortmask
)) != RT_ERR_OK
)
1297 return RT_ERR_FAILED
;
1302 return RT_ERR_FAILED
;
1306 if(tmp
& FILTER_ENACT_POLICING_MASK
)
1308 pAction
->actEnable
[FILTER_ENACT_POLICING_0
] = TRUE
;
1309 pAction
->filterPolicingIdx
[0] = aclAct
.aclmeteridx
;
1312 if(tmp
& FILTER_ENACT_PRIORITY_MASK
)
1314 if(aclAct
.priact
== FILTER_ENACT_PRI_TYPE(FILTER_ENACT_PRIORITY
))
1316 pAction
->actEnable
[FILTER_ENACT_PRIORITY
] = TRUE
;
1317 pAction
->filterPriority
= aclAct
.pridx
;
1319 else if(aclAct
.priact
== FILTER_ENACT_PRI_TYPE(FILTER_ENACT_1P_REMARK
))
1321 pAction
->actEnable
[FILTER_ENACT_1P_REMARK
] = TRUE
;
1322 pAction
->filterPriority
= aclAct
.pridx
;
1324 else if(aclAct
.priact
== FILTER_ENACT_PRI_TYPE(FILTER_ENACT_DSCP_REMARK
))
1326 pAction
->actEnable
[FILTER_ENACT_DSCP_REMARK
] = TRUE
;
1327 pAction
->filterPriority
= aclAct
.pridx
;
1329 else if(aclAct
.priact
== FILTER_ENACT_PRI_TYPE(FILTER_ENACT_POLICING_3
))
1331 pAction
->actEnable
[FILTER_ENACT_POLICING_3
] = TRUE
;
1332 pAction
->filterPolicingIdx
[3] = aclAct
.pridx
;
1336 if(tmp
& FILTER_ENACT_SVLAN_MASK
)
1338 if(aclAct
.sact
== FILTER_ENACT_SVLAN_TYPE(FILTER_ENACT_SVLAN_INGRESS
))
1340 if((retVal
= rtl8367c_getAsicSvlanMemberConfiguration(aclAct
.svidx_sact
, &svlan_cfg
)) != RT_ERR_OK
)
1343 pAction
->actEnable
[FILTER_ENACT_SVLAN_INGRESS
] = TRUE
;
1344 pAction
->filterSvlanIdx
= aclAct
.svidx_sact
;
1345 pAction
->filterSvlanVid
= svlan_cfg
.vs_svid
;
1347 else if(aclAct
.sact
== FILTER_ENACT_SVLAN_TYPE(FILTER_ENACT_SVLAN_EGRESS
))
1349 if((retVal
= rtl8367c_getAsicSvlanMemberConfiguration(aclAct
.svidx_sact
, &svlan_cfg
)) != RT_ERR_OK
)
1352 pAction
->actEnable
[FILTER_ENACT_SVLAN_EGRESS
] = TRUE
;
1353 pAction
->filterSvlanIdx
= aclAct
.svidx_sact
;
1354 pAction
->filterSvlanVid
= svlan_cfg
.vs_svid
;
1356 else if(aclAct
.sact
== FILTER_ENACT_SVLAN_TYPE(FILTER_ENACT_SVLAN_CVID
))
1357 pAction
->actEnable
[FILTER_ENACT_SVLAN_CVID
] = TRUE
;
1358 else if(aclAct
.sact
== FILTER_ENACT_SVLAN_TYPE(FILTER_ENACT_POLICING_2
))
1360 pAction
->actEnable
[FILTER_ENACT_POLICING_2
] = TRUE
;
1361 pAction
->filterPolicingIdx
[2] = aclAct
.svidx_sact
;
1366 if(tmp
& FILTER_ENACT_CVLAN_MASK
)
1368 if(FILTER_ENACT_CACTEXT_TAGONLY
== aclAct
.cact_ext
||
1369 FILTER_ENACT_CACTEXT_BOTHVLANTAG
== aclAct
.cact_ext
)
1371 if(FILTER_CTAGFMT_UNTAG
== aclAct
.tag_fmt
)
1373 pAction
->actEnable
[FILTER_ENACT_EGRESSCTAG_UNTAG
] = TRUE
;
1375 else if(FILTER_CTAGFMT_TAG
== aclAct
.tag_fmt
)
1377 pAction
->actEnable
[FILTER_ENACT_EGRESSCTAG_TAG
] = TRUE
;
1379 else if(FILTER_CTAGFMT_KEEP
== aclAct
.tag_fmt
)
1381 pAction
->actEnable
[FILTER_ENACT_EGRESSCTAG_KEEP
] = TRUE
;
1383 else if(FILTER_CTAGFMT_KEEP1PRMK
== aclAct
.tag_fmt
)
1385 pAction
->actEnable
[FILTER_ENACT_EGRESSCTAG_KEEPAND1PRMK
] = TRUE
;
1390 if(FILTER_ENACT_CACTEXT_VLANONLY
== aclAct
.cact_ext
||
1391 FILTER_ENACT_CACTEXT_BOTHVLANTAG
== aclAct
.cact_ext
)
1393 if(aclAct
.cact
== FILTER_ENACT_CVLAN_TYPE(FILTER_ENACT_CVLAN_INGRESS
))
1395 if((retVal
= rtl8367c_getAsicVlanMemberConfig(aclAct
.cvidx_cact
, &vlanMC
)) != RT_ERR_OK
)
1398 pAction
->actEnable
[FILTER_ENACT_CVLAN_INGRESS
] = TRUE
;
1399 pAction
->filterCvlanIdx
= aclAct
.cvidx_cact
;
1400 pAction
->filterCvlanVid
= vlanMC
.evid
;
1402 else if(aclAct
.cact
== FILTER_ENACT_CVLAN_TYPE(FILTER_ENACT_CVLAN_EGRESS
))
1404 if((retVal
= rtl8367c_getAsicVlanMemberConfig(aclAct
.cvidx_cact
, &vlanMC
)) != RT_ERR_OK
)
1407 pAction
->actEnable
[FILTER_ENACT_CVLAN_EGRESS
] = TRUE
;
1408 pAction
->filterCvlanIdx
= aclAct
.cvidx_cact
;
1409 pAction
->filterCvlanVid
= vlanMC
.evid
;
1411 else if(aclAct
.cact
== FILTER_ENACT_CVLAN_TYPE(FILTER_ENACT_CVLAN_SVID
))
1413 pAction
->actEnable
[FILTER_ENACT_CVLAN_SVID
] = TRUE
;
1415 else if(aclAct
.cact
== FILTER_ENACT_CVLAN_TYPE(FILTER_ENACT_POLICING_1
))
1417 pAction
->actEnable
[FILTER_ENACT_POLICING_1
] = TRUE
;
1418 pAction
->filterPolicingIdx
[1] = aclAct
.cvidx_cact
;
1423 if(tmp
& FILTER_ENACT_INTGPIO_MASK
)
1425 if(TRUE
== aclAct
.aclint
)
1427 pAction
->actEnable
[FILTER_ENACT_INTERRUPT
] = TRUE
;
1430 if(TRUE
== aclAct
.gpio_en
)
1432 pAction
->actEnable
[FILTER_ENACT_GPO
] = TRUE
;
1433 pAction
->filterPin
= aclAct
.gpio_pin
;
1437 /* Get field type of RAW data */
1438 if ((retVal
= rtl8367c_getAsicAclTemplate(aclRule
.data_bits
.type
, &type
))!= RT_ERR_OK
)
1441 for(i
= 0; i
< RTL8367C_ACLRULEFIELDNO
; i
++)
1443 pFilter_cfg
->fieldRawType
[i
] = type
.field
[i
];
1444 }/* end of for(i...) */
1450 * rtk_filter_igrAcl_unmatchAction_set
1452 * Set action to packets when no ACL configuration match
1460 * RT_ERR_FAILED - Failed
1461 * RT_ERR_SMI - SMI access error
1462 * RT_ERR_PORT_ID - Invalid port id.
1463 * RT_ERR_INPUT - Invalid input parameters.
1465 * This function sets action of packets when no ACL configuration matches.
1467 rtk_api_ret_t
rtk_filter_igrAcl_unmatchAction_set(rtk_port_t port
, rtk_filter_unmatch_action_t action
)
1471 /* Check initialization state */
1472 RTK_CHK_INIT_STATE();
1474 /* Check port valid */
1475 RTK_CHK_PORT_VALID(port
);
1477 if(action
>= FILTER_UNMATCH_END
)
1478 return RT_ERR_INPUT
;
1480 if((ret
= rtl8367c_setAsicAclUnmatchedPermit(rtk_switch_port_L2P_get(port
), action
)) != RT_ERR_OK
)
1487 * rtk_filter_igrAcl_unmatchAction_get
1489 * Get action to packets when no ACL configuration match
1496 * RT_ERR_FAILED - Failed
1497 * RT_ERR_SMI - SMI access error
1498 * RT_ERR_PORT_ID - Invalid port id.
1499 * RT_ERR_INPUT - Invalid input parameters.
1501 * This function gets action of packets when no ACL configruation matches.
1503 rtk_api_ret_t
rtk_filter_igrAcl_unmatchAction_get(rtk_port_t port
, rtk_filter_unmatch_action_t
* pAction
)
1507 /* Check initialization state */
1508 RTK_CHK_INIT_STATE();
1511 return RT_ERR_NULL_POINTER
;
1513 /* Check port valid */
1514 RTK_CHK_PORT_VALID(port
);
1516 if((ret
= rtl8367c_getAsicAclUnmatchedPermit(rtk_switch_port_L2P_get(port
), pAction
)) != RT_ERR_OK
)
1523 * rtk_filter_igrAcl_state_set
1525 * Set state of ingress ACL.
1528 * state - Ingress ACL state.
1533 * RT_ERR_FAILED - Failed
1534 * RT_ERR_SMI - SMI access error
1535 * RT_ERR_PORT_ID - Invalid port id.
1536 * RT_ERR_INPUT - Invalid input parameters.
1538 * This function gets action of packets when no ACL configuration matches.
1540 rtk_api_ret_t
rtk_filter_igrAcl_state_set(rtk_port_t port
, rtk_filter_state_t state
)
1544 /* Check initialization state */
1545 RTK_CHK_INIT_STATE();
1547 /* Check port valid */
1548 RTK_CHK_PORT_VALID(port
);
1550 if(state
>= RTK_ENABLE_END
)
1551 return RT_ERR_INPUT
;
1553 if((ret
= rtl8367c_setAsicAcl(rtk_switch_port_L2P_get(port
), state
)) != RT_ERR_OK
)
1560 * rtk_filter_igrAcl_state_get
1562 * Get state of ingress ACL.
1566 * pState - Ingress ACL state.
1569 * RT_ERR_FAILED - Failed
1570 * RT_ERR_SMI - SMI access error
1571 * RT_ERR_PORT_ID - Invalid port id.
1572 * RT_ERR_INPUT - Invalid input parameters.
1574 * This function gets action of packets when no ACL configuration matches.
1576 rtk_api_ret_t
rtk_filter_igrAcl_state_get(rtk_port_t port
, rtk_filter_state_t
* pState
)
1580 /* Check initialization state */
1581 RTK_CHK_INIT_STATE();
1584 return RT_ERR_NULL_POINTER
;
1586 /* Check port valid */
1587 RTK_CHK_PORT_VALID(port
);
1589 if((ret
= rtl8367c_getAsicAcl(rtk_switch_port_L2P_get(port
), pState
)) != RT_ERR_OK
)
1595 * rtk_filter_igrAcl_template_set
1597 * Set template of ingress ACL.
1599 * template - Ingress ACL template
1604 * RT_ERR_FAILED - Failed
1605 * RT_ERR_SMI - SMI access error
1606 * RT_ERR_INPUT - Invalid input parameters.
1608 * This function set ACL template.
1610 rtk_api_ret_t
rtk_filter_igrAcl_template_set(rtk_filter_template_t
*aclTemplate
)
1612 rtk_api_ret_t retVal
;
1613 rtk_uint32 idxField
;
1614 rtl8367c_acltemplate_t aclType
;
1616 /* Check initialization state */
1617 RTK_CHK_INIT_STATE();
1619 if(aclTemplate
->index
>= RTK_MAX_NUM_OF_FILTER_TYPE
)
1620 return RT_ERR_INPUT
;
1622 for(idxField
= 0; idxField
< RTK_MAX_NUM_OF_FILTER_FIELD
; idxField
++)
1624 if(aclTemplate
->fieldType
[idxField
] < FILTER_FIELD_RAW_DMAC_15_0
||
1625 (aclTemplate
->fieldType
[idxField
] > FILTER_FIELD_RAW_CTAG
&& aclTemplate
->fieldType
[idxField
] < FILTER_FIELD_RAW_IPV4_SIP_15_0
) ||
1626 (aclTemplate
->fieldType
[idxField
] > FILTER_FIELD_RAW_IPV4_DIP_31_16
&& aclTemplate
->fieldType
[idxField
] < FILTER_FIELD_RAW_IPV6_SIP_15_0
) ||
1627 (aclTemplate
->fieldType
[idxField
] > FILTER_FIELD_RAW_IPV6_DIP_31_16
&& aclTemplate
->fieldType
[idxField
] < FILTER_FIELD_RAW_VIDRANGE
) ||
1628 (aclTemplate
->fieldType
[idxField
] > FILTER_FIELD_RAW_FIELD_VALID
&& aclTemplate
->fieldType
[idxField
] < FILTER_FIELD_RAW_FIELD_SELECT00
) ||
1629 aclTemplate
->fieldType
[idxField
] >= FILTER_FIELD_RAW_END
)
1631 return RT_ERR_INPUT
;
1635 for(idxField
= 0; idxField
< RTK_MAX_NUM_OF_FILTER_FIELD
; idxField
++)
1637 aclType
.field
[idxField
] = aclTemplate
->fieldType
[idxField
];
1640 if((retVal
= rtl8367c_setAsicAclTemplate(aclTemplate
->index
, &aclType
)) != RT_ERR_OK
)
1647 * rtk_filter_igrAcl_template_get
1649 * Get template of ingress ACL.
1651 * template - Ingress ACL template
1656 * RT_ERR_FAILED - Failed
1657 * RT_ERR_SMI - SMI access error
1659 * This function gets template of ACL.
1661 rtk_api_ret_t
rtk_filter_igrAcl_template_get(rtk_filter_template_t
*aclTemplate
)
1664 rtk_uint32 idxField
;
1665 rtl8367c_acltemplate_t aclType
;
1667 /* Check initialization state */
1668 RTK_CHK_INIT_STATE();
1670 if(NULL
== aclTemplate
)
1671 return RT_ERR_NULL_POINTER
;
1673 if(aclTemplate
->index
>= RTK_MAX_NUM_OF_FILTER_TYPE
)
1674 return RT_ERR_INPUT
;
1676 if((ret
= rtl8367c_getAsicAclTemplate(aclTemplate
->index
, &aclType
)) != RT_ERR_OK
)
1679 for(idxField
= 0; idxField
< RTK_MAX_NUM_OF_FILTER_FIELD
; idxField
++)
1681 aclTemplate
->fieldType
[idxField
] = aclType
.field
[idxField
];
1688 * rtk_filter_igrAcl_field_sel_set
1690 * Set user defined field selectors in HSB
1692 * index - index of field selector 0-15
1693 * format - Format of field selector
1694 * offset - Retrieving data offset
1699 * RT_ERR_FAILED - Failed
1700 * RT_ERR_SMI - SMI access error
1702 * System support 16 user defined field selectors.
1703 * Each selector can be enabled or disable.
1704 * User can defined retrieving 16-bits in many predefiend
1705 * standard l2/l3/l4 payload.
1707 rtk_api_ret_t
rtk_filter_igrAcl_field_sel_set(rtk_uint32 index
, rtk_field_sel_t format
, rtk_uint32 offset
)
1711 /* Check initialization state */
1712 RTK_CHK_INIT_STATE();
1714 if(index
>= RTL8367C_FIELDSEL_FORMAT_NUMBER
)
1715 return RT_ERR_OUT_OF_RANGE
;
1717 if(format
>= FORMAT_END
)
1718 return RT_ERR_OUT_OF_RANGE
;
1720 if(offset
> RTL8367C_FIELDSEL_MAX_OFFSET
)
1721 return RT_ERR_OUT_OF_RANGE
;
1723 if((ret
= rtl8367c_setAsicFieldSelector(index
, (rtk_uint32
)format
, offset
)) != RT_ERR_OK
)
1730 * rtk_filter_igrAcl_field_sel_get
1732 * Get user defined field selectors in HSB
1734 * index - index of field selector 0-15
1736 * pFormat - Format of field selector
1737 * pOffset - Retrieving data offset
1740 * RT_ERR_FAILED - Failed
1741 * RT_ERR_SMI - SMI access error
1745 rtk_api_ret_t
rtk_filter_igrAcl_field_sel_get(rtk_uint32 index
, rtk_field_sel_t
*pFormat
, rtk_uint32
*pOffset
)
1749 /* Check initialization state */
1750 RTK_CHK_INIT_STATE();
1752 if(NULL
== pFormat
|| NULL
== pOffset
)
1753 return RT_ERR_NULL_POINTER
;
1755 if(index
>= RTL8367C_FIELDSEL_FORMAT_NUMBER
)
1756 return RT_ERR_OUT_OF_RANGE
;
1758 if((ret
= rtl8367c_getAsicFieldSelector(index
, pFormat
, pOffset
)) != RT_ERR_OK
)
1765 * rtk_filter_iprange_set
1767 * Set IP Range check
1769 * index - index of IP Range 0-15
1770 * type - IP Range check type, 0:Delete a entry, 1: IPv4_SIP, 2: IPv4_DIP, 3:IPv6_SIP, 4:IPv6_DIP
1771 * upperIp - The upper bound of IP range
1772 * lowerIp - The lower Bound of IP range
1777 * RT_ERR_FAILED - Failed
1778 * RT_ERR_SMI - SMI access error
1779 * RT_ERR_OUT_OF_RANGE - The parameter is out of range
1780 * RT_ERR_INPUT - Input error
1782 * upperIp must be larger or equal than lowerIp.
1784 rtk_api_ret_t
rtk_filter_iprange_set(rtk_uint32 index
, rtk_filter_iprange_t type
, ipaddr_t upperIp
, ipaddr_t lowerIp
)
1788 /* Check initialization state */
1789 RTK_CHK_INIT_STATE();
1791 if(index
> RTL8367C_ACLRANGEMAX
)
1792 return RT_ERR_OUT_OF_RANGE
;
1794 if(type
>= IPRANGE_END
)
1795 return RT_ERR_OUT_OF_RANGE
;
1797 if(lowerIp
> upperIp
)
1798 return RT_ERR_INPUT
;
1800 if((ret
= rtl8367c_setAsicAclIpRange(index
, type
, upperIp
, lowerIp
)) != RT_ERR_OK
)
1807 * rtk_filter_iprange_get
1809 * Set IP Range check
1811 * index - index of IP Range 0-15
1813 * pType - IP Range check type, 0:Delete a entry, 1: IPv4_SIP, 2: IPv4_DIP, 3:IPv6_SIP, 4:IPv6_DIP
1814 * pUpperIp - The upper bound of IP range
1815 * pLowerIp - The lower Bound of IP range
1818 * RT_ERR_FAILED - Failed
1819 * RT_ERR_SMI - SMI access error
1820 * RT_ERR_OUT_OF_RANGE - The parameter is out of range
1824 rtk_api_ret_t
rtk_filter_iprange_get(rtk_uint32 index
, rtk_filter_iprange_t
*pType
, ipaddr_t
*pUpperIp
, ipaddr_t
*pLowerIp
)
1828 /* Check initialization state */
1829 RTK_CHK_INIT_STATE();
1831 if((NULL
== pType
) || (NULL
== pUpperIp
) || (NULL
== pLowerIp
))
1832 return RT_ERR_NULL_POINTER
;
1834 if(index
> RTL8367C_ACLRANGEMAX
)
1835 return RT_ERR_OUT_OF_RANGE
;
1837 if((ret
= rtl8367c_getAsicAclIpRange(index
, pType
, pUpperIp
, pLowerIp
)) != RT_ERR_OK
)
1844 * rtk_filter_vidrange_set
1846 * Set VID Range check
1848 * index - index of VID Range 0-15
1849 * type - IP Range check type, 0:Delete a entry, 1: CVID, 2: SVID
1850 * upperVid - The upper bound of VID range
1851 * lowerVid - The lower Bound of VID range
1856 * RT_ERR_FAILED - Failed
1857 * RT_ERR_SMI - SMI access error
1858 * RT_ERR_OUT_OF_RANGE - The parameter is out of range
1859 * RT_ERR_INPUT - Input error
1861 * upperVid must be larger or equal than lowerVid.
1863 rtk_api_ret_t
rtk_filter_vidrange_set(rtk_uint32 index
, rtk_filter_vidrange_t type
, rtk_uint32 upperVid
, rtk_uint32 lowerVid
)
1867 /* Check initialization state */
1868 RTK_CHK_INIT_STATE();
1870 if(index
> RTL8367C_ACLRANGEMAX
)
1871 return RT_ERR_OUT_OF_RANGE
;
1873 if(type
>= VIDRANGE_END
)
1874 return RT_ERR_OUT_OF_RANGE
;
1876 if(lowerVid
> upperVid
)
1877 return RT_ERR_INPUT
;
1879 if( (upperVid
> RTL8367C_VIDMAX
) || (lowerVid
> RTL8367C_VIDMAX
))
1880 return RT_ERR_OUT_OF_RANGE
;
1882 if((ret
= rtl8367c_setAsicAclVidRange(index
, type
, upperVid
, lowerVid
)) != RT_ERR_OK
)
1889 * rtk_filter_vidrange_get
1891 * Get VID Range check
1893 * index - index of VID Range 0-15
1895 * pType - IP Range check type, 0:Unused, 1: CVID, 2: SVID
1896 * pUpperVid - The upper bound of VID range
1897 * pLowerVid - The lower Bound of VID range
1900 * RT_ERR_FAILED - Failed
1901 * RT_ERR_SMI - SMI access error
1902 * RT_ERR_OUT_OF_RANGE - The parameter is out of range
1906 rtk_api_ret_t
rtk_filter_vidrange_get(rtk_uint32 index
, rtk_filter_vidrange_t
*pType
, rtk_uint32
*pUpperVid
, rtk_uint32
*pLowerVid
)
1910 /* Check initialization state */
1911 RTK_CHK_INIT_STATE();
1913 if((NULL
== pType
) || (NULL
== pUpperVid
) || (NULL
== pLowerVid
))
1914 return RT_ERR_NULL_POINTER
;
1916 if(index
> RTL8367C_ACLRANGEMAX
)
1917 return RT_ERR_OUT_OF_RANGE
;
1919 if((ret
= rtl8367c_getAsicAclVidRange(index
, pType
, pUpperVid
, pLowerVid
)) != RT_ERR_OK
)
1926 * rtk_filter_portrange_set
1928 * Set Port Range check
1930 * index - index of Port Range 0-15
1931 * type - IP Range check type, 0:Delete a entry, 1: Source Port, 2: Destination Port
1932 * upperPort - The upper bound of Port range
1933 * lowerPort - The lower Bound of Port range
1938 * RT_ERR_FAILED - Failed
1939 * RT_ERR_SMI - SMI access error
1940 * RT_ERR_OUT_OF_RANGE - The parameter is out of range
1941 * RT_ERR_INPUT - Input error
1943 * upperPort must be larger or equal than lowerPort.
1945 rtk_api_ret_t
rtk_filter_portrange_set(rtk_uint32 index
, rtk_filter_portrange_t type
, rtk_uint32 upperPort
, rtk_uint32 lowerPort
)
1949 /* Check initialization state */
1950 RTK_CHK_INIT_STATE();
1952 if(index
> RTL8367C_ACLRANGEMAX
)
1953 return RT_ERR_OUT_OF_RANGE
;
1955 if(type
>= PORTRANGE_END
)
1956 return RT_ERR_OUT_OF_RANGE
;
1958 if(lowerPort
> upperPort
)
1959 return RT_ERR_INPUT
;
1961 if(upperPort
> RTL8367C_ACL_PORTRANGEMAX
)
1962 return RT_ERR_INPUT
;
1964 if(lowerPort
> RTL8367C_ACL_PORTRANGEMAX
)
1965 return RT_ERR_INPUT
;
1967 if((ret
= rtl8367c_setAsicAclPortRange(index
, type
, upperPort
, lowerPort
)) != RT_ERR_OK
)
1974 * rtk_filter_portrange_get
1976 * Set Port Range check
1978 * index - index of Port Range 0-15
1980 * pType - IP Range check type, 0:Delete a entry, 1: Source Port, 2: Destination Port
1981 * pUpperPort - The upper bound of Port range
1982 * pLowerPort - The lower Bound of Port range
1985 * RT_ERR_FAILED - Failed
1986 * RT_ERR_SMI - SMI access error
1987 * RT_ERR_OUT_OF_RANGE - The parameter is out of range
1988 * RT_ERR_INPUT - Input error
1992 rtk_api_ret_t
rtk_filter_portrange_get(rtk_uint32 index
, rtk_filter_portrange_t
*pType
, rtk_uint32
*pUpperPort
, rtk_uint32
*pLowerPort
)
1996 /* Check initialization state */
1997 RTK_CHK_INIT_STATE();
1999 if((NULL
== pType
) || (NULL
== pUpperPort
) || (NULL
== pLowerPort
))
2000 return RT_ERR_NULL_POINTER
;
2002 if(index
> RTL8367C_ACLRANGEMAX
)
2003 return RT_ERR_OUT_OF_RANGE
;
2005 if((ret
= rtl8367c_getAsicAclPortRange(index
, pType
, pUpperPort
, pLowerPort
)) != RT_ERR_OK
)
2012 * rtk_filter_igrAclPolarity_set
2014 * Set ACL Goip control polarity
2016 * polarity - 1: High, 0: Low
2020 * RT_ERR_OK - Success
2021 * RT_ERR_SMI - SMI access error
2025 rtk_api_ret_t
rtk_filter_igrAclPolarity_set(rtk_uint32 polarity
)
2027 /* Check initialization state */
2028 RTK_CHK_INIT_STATE();
2031 return RT_ERR_OUT_OF_RANGE
;
2032 return rtl8367c_setAsicAclGpioPolarity(polarity
);
2035 * rtk_filter_igrAclPolarity_get
2037 * Get ACL Goip control polarity
2039 * pPolarity - 1: High, 0: Low
2043 * RT_ERR_OK - Success
2044 * RT_ERR_SMI - SMI access error
2048 rtk_api_ret_t
rtk_filter_igrAclPolarity_get(rtk_uint32
* pPolarity
)
2050 /* Check initialization state */
2051 RTK_CHK_INIT_STATE();
2053 if(NULL
== pPolarity
)
2054 return RT_ERR_NULL_POINTER
;
2056 return rtl8367c_getAsicAclGpioPolarity(pPolarity
);