1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
4 #include <linux/kernel.h>
6 #include <linux/errno.h>
8 #include <linux/refcount.h>
9 #include <linux/rhashtable.h>
14 #include "spectrum_acl_tcam.h"
15 #include "core_acl_flex_keys.h"
17 #define MLXSW_SP_ACL_ATCAM_LKEY_ID_BLOCK_CLEAR_START 0
18 #define MLXSW_SP_ACL_ATCAM_LKEY_ID_BLOCK_CLEAR_END 5
20 struct mlxsw_sp_acl_atcam_lkey_id_ht_key {
21 char enc_key[MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN]; /* MSB blocks */
25 struct mlxsw_sp_acl_atcam_lkey_id {
26 struct rhash_head ht_node;
27 struct mlxsw_sp_acl_atcam_lkey_id_ht_key ht_key;
32 struct mlxsw_sp_acl_atcam_region_ops {
33 int (*init)(struct mlxsw_sp_acl_atcam_region *aregion);
34 void (*fini)(struct mlxsw_sp_acl_atcam_region *aregion);
35 struct mlxsw_sp_acl_atcam_lkey_id *
36 (*lkey_id_get)(struct mlxsw_sp_acl_atcam_region *aregion,
37 char *enc_key, u8 erp_id);
38 void (*lkey_id_put)(struct mlxsw_sp_acl_atcam_region *aregion,
39 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id);
42 struct mlxsw_sp_acl_atcam_region_generic {
43 struct mlxsw_sp_acl_atcam_lkey_id dummy_lkey_id;
46 struct mlxsw_sp_acl_atcam_region_12kb {
47 struct rhashtable lkey_ht;
48 unsigned int max_lkey_id;
49 unsigned long *used_lkey_id;
52 static const struct rhashtable_params mlxsw_sp_acl_atcam_lkey_id_ht_params = {
53 .key_len = sizeof(struct mlxsw_sp_acl_atcam_lkey_id_ht_key),
54 .key_offset = offsetof(struct mlxsw_sp_acl_atcam_lkey_id, ht_key),
55 .head_offset = offsetof(struct mlxsw_sp_acl_atcam_lkey_id, ht_node),
58 static const struct rhashtable_params mlxsw_sp_acl_atcam_entries_ht_params = {
59 .key_len = sizeof(struct mlxsw_sp_acl_atcam_entry_ht_key),
60 .key_offset = offsetof(struct mlxsw_sp_acl_atcam_entry, ht_key),
61 .head_offset = offsetof(struct mlxsw_sp_acl_atcam_entry, ht_node),
65 mlxsw_sp_acl_atcam_is_centry(const struct mlxsw_sp_acl_atcam_entry *aentry)
67 return mlxsw_sp_acl_erp_mask_is_ctcam(aentry->erp_mask);
71 mlxsw_sp_acl_atcam_region_generic_init(struct mlxsw_sp_acl_atcam_region *aregion)
73 struct mlxsw_sp_acl_atcam_region_generic *region_generic;
75 region_generic = kzalloc(sizeof(*region_generic), GFP_KERNEL);
79 refcount_set(®ion_generic->dummy_lkey_id.refcnt, 1);
80 aregion->priv = region_generic;
86 mlxsw_sp_acl_atcam_region_generic_fini(struct mlxsw_sp_acl_atcam_region *aregion)
91 static struct mlxsw_sp_acl_atcam_lkey_id *
92 mlxsw_sp_acl_atcam_generic_lkey_id_get(struct mlxsw_sp_acl_atcam_region *aregion,
93 char *enc_key, u8 erp_id)
95 struct mlxsw_sp_acl_atcam_region_generic *region_generic;
97 region_generic = aregion->priv;
98 return ®ion_generic->dummy_lkey_id;
102 mlxsw_sp_acl_atcam_generic_lkey_id_put(struct mlxsw_sp_acl_atcam_region *aregion,
103 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id)
107 static const struct mlxsw_sp_acl_atcam_region_ops
108 mlxsw_sp_acl_atcam_region_generic_ops = {
109 .init = mlxsw_sp_acl_atcam_region_generic_init,
110 .fini = mlxsw_sp_acl_atcam_region_generic_fini,
111 .lkey_id_get = mlxsw_sp_acl_atcam_generic_lkey_id_get,
112 .lkey_id_put = mlxsw_sp_acl_atcam_generic_lkey_id_put,
116 mlxsw_sp_acl_atcam_region_12kb_init(struct mlxsw_sp_acl_atcam_region *aregion)
118 struct mlxsw_sp *mlxsw_sp = aregion->region->mlxsw_sp;
119 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb;
124 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, ACL_MAX_LARGE_KEY_ID))
127 max_lkey_id = MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_LARGE_KEY_ID);
128 region_12kb = kzalloc(sizeof(*region_12kb), GFP_KERNEL);
132 alloc_size = BITS_TO_LONGS(max_lkey_id) * sizeof(unsigned long);
133 region_12kb->used_lkey_id = kzalloc(alloc_size, GFP_KERNEL);
134 if (!region_12kb->used_lkey_id) {
136 goto err_used_lkey_id_alloc;
139 err = rhashtable_init(®ion_12kb->lkey_ht,
140 &mlxsw_sp_acl_atcam_lkey_id_ht_params);
142 goto err_rhashtable_init;
144 region_12kb->max_lkey_id = max_lkey_id;
145 aregion->priv = region_12kb;
150 kfree(region_12kb->used_lkey_id);
151 err_used_lkey_id_alloc:
157 mlxsw_sp_acl_atcam_region_12kb_fini(struct mlxsw_sp_acl_atcam_region *aregion)
159 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv;
161 rhashtable_destroy(®ion_12kb->lkey_ht);
162 kfree(region_12kb->used_lkey_id);
166 static struct mlxsw_sp_acl_atcam_lkey_id *
167 mlxsw_sp_acl_atcam_lkey_id_create(struct mlxsw_sp_acl_atcam_region *aregion,
168 struct mlxsw_sp_acl_atcam_lkey_id_ht_key *ht_key)
170 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv;
171 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id;
175 id = find_first_zero_bit(region_12kb->used_lkey_id,
176 region_12kb->max_lkey_id);
177 if (id < region_12kb->max_lkey_id)
178 __set_bit(id, region_12kb->used_lkey_id);
180 return ERR_PTR(-ENOBUFS);
182 lkey_id = kzalloc(sizeof(*lkey_id), GFP_KERNEL);
185 goto err_lkey_id_alloc;
189 memcpy(&lkey_id->ht_key, ht_key, sizeof(*ht_key));
190 refcount_set(&lkey_id->refcnt, 1);
192 err = rhashtable_insert_fast(®ion_12kb->lkey_ht,
194 mlxsw_sp_acl_atcam_lkey_id_ht_params);
196 goto err_rhashtable_insert;
200 err_rhashtable_insert:
203 __clear_bit(id, region_12kb->used_lkey_id);
208 mlxsw_sp_acl_atcam_lkey_id_destroy(struct mlxsw_sp_acl_atcam_region *aregion,
209 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id)
211 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv;
212 u32 id = lkey_id->id;
214 rhashtable_remove_fast(®ion_12kb->lkey_ht, &lkey_id->ht_node,
215 mlxsw_sp_acl_atcam_lkey_id_ht_params);
217 __clear_bit(id, region_12kb->used_lkey_id);
220 static struct mlxsw_sp_acl_atcam_lkey_id *
221 mlxsw_sp_acl_atcam_12kb_lkey_id_get(struct mlxsw_sp_acl_atcam_region *aregion,
222 char *enc_key, u8 erp_id)
224 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv;
225 struct mlxsw_sp_acl_tcam_region *region = aregion->region;
226 struct mlxsw_sp_acl_atcam_lkey_id_ht_key ht_key = {{ 0 } };
227 struct mlxsw_sp *mlxsw_sp = region->mlxsw_sp;
228 struct mlxsw_afk *afk = mlxsw_sp_acl_afk(mlxsw_sp->acl);
229 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id;
231 memcpy(ht_key.enc_key, enc_key, sizeof(ht_key.enc_key));
232 mlxsw_afk_clear(afk, ht_key.enc_key,
233 MLXSW_SP_ACL_ATCAM_LKEY_ID_BLOCK_CLEAR_START,
234 MLXSW_SP_ACL_ATCAM_LKEY_ID_BLOCK_CLEAR_END);
235 ht_key.erp_id = erp_id;
236 lkey_id = rhashtable_lookup_fast(®ion_12kb->lkey_ht, &ht_key,
237 mlxsw_sp_acl_atcam_lkey_id_ht_params);
239 refcount_inc(&lkey_id->refcnt);
243 return mlxsw_sp_acl_atcam_lkey_id_create(aregion, &ht_key);
247 mlxsw_sp_acl_atcam_12kb_lkey_id_put(struct mlxsw_sp_acl_atcam_region *aregion,
248 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id)
250 if (refcount_dec_and_test(&lkey_id->refcnt))
251 mlxsw_sp_acl_atcam_lkey_id_destroy(aregion, lkey_id);
254 static const struct mlxsw_sp_acl_atcam_region_ops
255 mlxsw_sp_acl_atcam_region_12kb_ops = {
256 .init = mlxsw_sp_acl_atcam_region_12kb_init,
257 .fini = mlxsw_sp_acl_atcam_region_12kb_fini,
258 .lkey_id_get = mlxsw_sp_acl_atcam_12kb_lkey_id_get,
259 .lkey_id_put = mlxsw_sp_acl_atcam_12kb_lkey_id_put,
262 static const struct mlxsw_sp_acl_atcam_region_ops *
263 mlxsw_sp_acl_atcam_region_ops_arr[] = {
264 [MLXSW_SP_ACL_ATCAM_REGION_TYPE_2KB] =
265 &mlxsw_sp_acl_atcam_region_generic_ops,
266 [MLXSW_SP_ACL_ATCAM_REGION_TYPE_4KB] =
267 &mlxsw_sp_acl_atcam_region_generic_ops,
268 [MLXSW_SP_ACL_ATCAM_REGION_TYPE_8KB] =
269 &mlxsw_sp_acl_atcam_region_generic_ops,
270 [MLXSW_SP_ACL_ATCAM_REGION_TYPE_12KB] =
271 &mlxsw_sp_acl_atcam_region_12kb_ops,
274 int mlxsw_sp_acl_atcam_region_associate(struct mlxsw_sp *mlxsw_sp,
277 char perar_pl[MLXSW_REG_PERAR_LEN];
278 /* For now, just assume that every region has 12 key blocks */
279 u16 hw_region = region_id * 3;
282 max_regions = MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_REGIONS);
283 if (hw_region >= max_regions)
286 mlxsw_reg_perar_pack(perar_pl, region_id, hw_region);
287 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(perar), perar_pl);
291 mlxsw_sp_acl_atcam_region_type_init(struct mlxsw_sp_acl_atcam_region *aregion)
293 struct mlxsw_sp_acl_tcam_region *region = aregion->region;
294 enum mlxsw_sp_acl_atcam_region_type region_type;
295 unsigned int blocks_count;
297 /* We already know the blocks count can not exceed the maximum
300 blocks_count = mlxsw_afk_key_info_blocks_count_get(region->key_info);
301 if (blocks_count <= 2)
302 region_type = MLXSW_SP_ACL_ATCAM_REGION_TYPE_2KB;
303 else if (blocks_count <= 4)
304 region_type = MLXSW_SP_ACL_ATCAM_REGION_TYPE_4KB;
305 else if (blocks_count <= 8)
306 region_type = MLXSW_SP_ACL_ATCAM_REGION_TYPE_8KB;
308 region_type = MLXSW_SP_ACL_ATCAM_REGION_TYPE_12KB;
310 aregion->type = region_type;
311 aregion->ops = mlxsw_sp_acl_atcam_region_ops_arr[region_type];
315 mlxsw_sp_acl_atcam_region_init(struct mlxsw_sp *mlxsw_sp,
316 struct mlxsw_sp_acl_atcam *atcam,
317 struct mlxsw_sp_acl_atcam_region *aregion,
318 struct mlxsw_sp_acl_tcam_region *region,
319 const struct mlxsw_sp_acl_ctcam_region_ops *ops)
323 aregion->region = region;
324 aregion->atcam = atcam;
325 mlxsw_sp_acl_atcam_region_type_init(aregion);
326 INIT_LIST_HEAD(&aregion->entries_list);
328 err = rhashtable_init(&aregion->entries_ht,
329 &mlxsw_sp_acl_atcam_entries_ht_params);
332 err = aregion->ops->init(aregion);
335 err = mlxsw_sp_acl_erp_region_init(aregion);
337 goto err_erp_region_init;
338 err = mlxsw_sp_acl_ctcam_region_init(mlxsw_sp, &aregion->cregion,
341 goto err_ctcam_region_init;
345 err_ctcam_region_init:
346 mlxsw_sp_acl_erp_region_fini(aregion);
348 aregion->ops->fini(aregion);
350 rhashtable_destroy(&aregion->entries_ht);
354 void mlxsw_sp_acl_atcam_region_fini(struct mlxsw_sp_acl_atcam_region *aregion)
356 mlxsw_sp_acl_ctcam_region_fini(&aregion->cregion);
357 mlxsw_sp_acl_erp_region_fini(aregion);
358 aregion->ops->fini(aregion);
359 rhashtable_destroy(&aregion->entries_ht);
360 WARN_ON(!list_empty(&aregion->entries_list));
363 void mlxsw_sp_acl_atcam_chunk_init(struct mlxsw_sp_acl_atcam_region *aregion,
364 struct mlxsw_sp_acl_atcam_chunk *achunk,
365 unsigned int priority)
367 mlxsw_sp_acl_ctcam_chunk_init(&aregion->cregion, &achunk->cchunk,
371 void mlxsw_sp_acl_atcam_chunk_fini(struct mlxsw_sp_acl_atcam_chunk *achunk)
373 mlxsw_sp_acl_ctcam_chunk_fini(&achunk->cchunk);
377 mlxsw_sp_acl_atcam_region_entry_insert(struct mlxsw_sp *mlxsw_sp,
378 struct mlxsw_sp_acl_atcam_region *aregion,
379 struct mlxsw_sp_acl_atcam_entry *aentry,
380 struct mlxsw_sp_acl_rule_info *rulei)
382 struct mlxsw_sp_acl_tcam_region *region = aregion->region;
383 u8 erp_id = mlxsw_sp_acl_erp_mask_erp_id(aentry->erp_mask);
384 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id;
385 char ptce3_pl[MLXSW_REG_PTCE3_LEN];
386 u32 kvdl_index, priority;
389 err = mlxsw_sp_acl_tcam_priority_get(mlxsw_sp, rulei, &priority, true);
393 lkey_id = aregion->ops->lkey_id_get(aregion, aentry->ht_key.enc_key,
396 return PTR_ERR(lkey_id);
397 aentry->lkey_id = lkey_id;
399 kvdl_index = mlxsw_afa_block_first_kvdl_index(rulei->act_block);
400 mlxsw_reg_ptce3_pack(ptce3_pl, true, MLXSW_REG_PTCE3_OP_WRITE_WRITE,
401 priority, region->tcam_region_info,
402 aentry->ht_key.enc_key, erp_id,
403 aentry->delta_info.start,
404 aentry->delta_info.mask,
405 aentry->delta_info.value,
406 refcount_read(&lkey_id->refcnt) != 1, lkey_id->id,
408 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce3), ptce3_pl);
410 goto err_ptce3_write;
415 aregion->ops->lkey_id_put(aregion, lkey_id);
420 mlxsw_sp_acl_atcam_region_entry_remove(struct mlxsw_sp *mlxsw_sp,
421 struct mlxsw_sp_acl_atcam_region *aregion,
422 struct mlxsw_sp_acl_atcam_entry *aentry)
424 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id = aentry->lkey_id;
425 struct mlxsw_sp_acl_tcam_region *region = aregion->region;
426 u8 erp_id = mlxsw_sp_acl_erp_mask_erp_id(aentry->erp_mask);
427 char *enc_key = aentry->ht_key.enc_key;
428 char ptce3_pl[MLXSW_REG_PTCE3_LEN];
430 mlxsw_reg_ptce3_pack(ptce3_pl, false, MLXSW_REG_PTCE3_OP_WRITE_WRITE, 0,
431 region->tcam_region_info,
433 aentry->delta_info.start,
434 aentry->delta_info.mask,
435 aentry->delta_info.value,
436 refcount_read(&lkey_id->refcnt) != 1,
438 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce3), ptce3_pl);
439 aregion->ops->lkey_id_put(aregion, lkey_id);
443 mlxsw_sp_acl_atcam_region_entry_action_replace(struct mlxsw_sp *mlxsw_sp,
444 struct mlxsw_sp_acl_atcam_region *aregion,
445 struct mlxsw_sp_acl_atcam_entry *aentry,
446 struct mlxsw_sp_acl_rule_info *rulei)
448 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id = aentry->lkey_id;
449 u8 erp_id = mlxsw_sp_acl_erp_mask_erp_id(aentry->erp_mask);
450 struct mlxsw_sp_acl_tcam_region *region = aregion->region;
451 char ptce3_pl[MLXSW_REG_PTCE3_LEN];
452 u32 kvdl_index, priority;
455 err = mlxsw_sp_acl_tcam_priority_get(mlxsw_sp, rulei, &priority, true);
458 kvdl_index = mlxsw_afa_block_first_kvdl_index(rulei->act_block);
459 mlxsw_reg_ptce3_pack(ptce3_pl, true, MLXSW_REG_PTCE3_OP_WRITE_UPDATE,
460 priority, region->tcam_region_info,
461 aentry->ht_key.enc_key, erp_id,
462 aentry->delta_info.start,
463 aentry->delta_info.mask,
464 aentry->delta_info.value,
465 refcount_read(&lkey_id->refcnt) != 1, lkey_id->id,
467 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce3), ptce3_pl);
471 __mlxsw_sp_acl_atcam_entry_add(struct mlxsw_sp *mlxsw_sp,
472 struct mlxsw_sp_acl_atcam_region *aregion,
473 struct mlxsw_sp_acl_atcam_entry *aentry,
474 struct mlxsw_sp_acl_rule_info *rulei)
476 struct mlxsw_sp_acl_tcam_region *region = aregion->region;
477 char mask[MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN] = { 0 };
478 struct mlxsw_afk *afk = mlxsw_sp_acl_afk(mlxsw_sp->acl);
479 const struct mlxsw_sp_acl_erp_delta *delta;
480 struct mlxsw_sp_acl_erp_mask *erp_mask;
483 mlxsw_afk_encode(afk, region->key_info, &rulei->values,
484 aentry->full_enc_key, mask);
486 erp_mask = mlxsw_sp_acl_erp_mask_get(aregion, mask, false);
487 if (IS_ERR(erp_mask))
488 return PTR_ERR(erp_mask);
489 aentry->erp_mask = erp_mask;
490 aentry->ht_key.erp_id = mlxsw_sp_acl_erp_mask_erp_id(erp_mask);
491 memcpy(aentry->ht_key.enc_key, aentry->full_enc_key,
492 sizeof(aentry->ht_key.enc_key));
494 /* Compute all needed delta information and clear the delta bits
495 * from the encrypted key.
497 delta = mlxsw_sp_acl_erp_delta(aentry->erp_mask);
498 aentry->delta_info.start = mlxsw_sp_acl_erp_delta_start(delta);
499 aentry->delta_info.mask = mlxsw_sp_acl_erp_delta_mask(delta);
500 aentry->delta_info.value =
501 mlxsw_sp_acl_erp_delta_value(delta, aentry->full_enc_key);
502 mlxsw_sp_acl_erp_delta_clear(delta, aentry->ht_key.enc_key);
504 /* Add rule to the list of A-TCAM rules, assuming this
505 * rule is intended to A-TCAM. In case this rule does
506 * not fit into A-TCAM it will be removed from the list.
508 list_add(&aentry->list, &aregion->entries_list);
510 /* We can't insert identical rules into the A-TCAM, so fail and
511 * let the rule spill into C-TCAM
513 err = rhashtable_lookup_insert_fast(&aregion->entries_ht,
515 mlxsw_sp_acl_atcam_entries_ht_params);
517 goto err_rhashtable_insert;
519 /* Bloom filter must be updated here, before inserting the rule into
522 err = mlxsw_sp_acl_erp_bf_insert(mlxsw_sp, aregion, erp_mask, aentry);
526 err = mlxsw_sp_acl_atcam_region_entry_insert(mlxsw_sp, aregion, aentry,
529 goto err_rule_insert;
534 mlxsw_sp_acl_erp_bf_remove(mlxsw_sp, aregion, erp_mask, aentry);
536 rhashtable_remove_fast(&aregion->entries_ht, &aentry->ht_node,
537 mlxsw_sp_acl_atcam_entries_ht_params);
538 err_rhashtable_insert:
539 list_del(&aentry->list);
540 mlxsw_sp_acl_erp_mask_put(aregion, erp_mask);
545 __mlxsw_sp_acl_atcam_entry_del(struct mlxsw_sp *mlxsw_sp,
546 struct mlxsw_sp_acl_atcam_region *aregion,
547 struct mlxsw_sp_acl_atcam_entry *aentry)
549 mlxsw_sp_acl_atcam_region_entry_remove(mlxsw_sp, aregion, aentry);
550 mlxsw_sp_acl_erp_bf_remove(mlxsw_sp, aregion, aentry->erp_mask, aentry);
551 rhashtable_remove_fast(&aregion->entries_ht, &aentry->ht_node,
552 mlxsw_sp_acl_atcam_entries_ht_params);
553 list_del(&aentry->list);
554 mlxsw_sp_acl_erp_mask_put(aregion, aentry->erp_mask);
558 __mlxsw_sp_acl_atcam_entry_action_replace(struct mlxsw_sp *mlxsw_sp,
559 struct mlxsw_sp_acl_atcam_region *aregion,
560 struct mlxsw_sp_acl_atcam_entry *aentry,
561 struct mlxsw_sp_acl_rule_info *rulei)
563 return mlxsw_sp_acl_atcam_region_entry_action_replace(mlxsw_sp, aregion,
567 int mlxsw_sp_acl_atcam_entry_add(struct mlxsw_sp *mlxsw_sp,
568 struct mlxsw_sp_acl_atcam_region *aregion,
569 struct mlxsw_sp_acl_atcam_chunk *achunk,
570 struct mlxsw_sp_acl_atcam_entry *aentry,
571 struct mlxsw_sp_acl_rule_info *rulei)
575 err = __mlxsw_sp_acl_atcam_entry_add(mlxsw_sp, aregion, aentry, rulei);
579 /* It is possible we failed to add the rule to the A-TCAM due to
580 * exceeded number of masks. Try to spill into C-TCAM.
582 err = mlxsw_sp_acl_ctcam_entry_add(mlxsw_sp, &aregion->cregion,
583 &achunk->cchunk, &aentry->centry,
591 void mlxsw_sp_acl_atcam_entry_del(struct mlxsw_sp *mlxsw_sp,
592 struct mlxsw_sp_acl_atcam_region *aregion,
593 struct mlxsw_sp_acl_atcam_chunk *achunk,
594 struct mlxsw_sp_acl_atcam_entry *aentry)
596 if (mlxsw_sp_acl_atcam_is_centry(aentry))
597 mlxsw_sp_acl_ctcam_entry_del(mlxsw_sp, &aregion->cregion,
598 &achunk->cchunk, &aentry->centry);
600 __mlxsw_sp_acl_atcam_entry_del(mlxsw_sp, aregion, aentry);
604 mlxsw_sp_acl_atcam_entry_action_replace(struct mlxsw_sp *mlxsw_sp,
605 struct mlxsw_sp_acl_atcam_region *aregion,
606 struct mlxsw_sp_acl_atcam_chunk *achunk,
607 struct mlxsw_sp_acl_atcam_entry *aentry,
608 struct mlxsw_sp_acl_rule_info *rulei)
612 if (mlxsw_sp_acl_atcam_is_centry(aentry))
613 err = mlxsw_sp_acl_ctcam_entry_action_replace(mlxsw_sp,
619 err = __mlxsw_sp_acl_atcam_entry_action_replace(mlxsw_sp,
626 int mlxsw_sp_acl_atcam_init(struct mlxsw_sp *mlxsw_sp,
627 struct mlxsw_sp_acl_atcam *atcam)
629 return mlxsw_sp_acl_erps_init(mlxsw_sp, atcam);
632 void mlxsw_sp_acl_atcam_fini(struct mlxsw_sp *mlxsw_sp,
633 struct mlxsw_sp_acl_atcam *atcam)
635 mlxsw_sp_acl_erps_fini(mlxsw_sp, atcam);