1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */ 3 4 #include <linux/kernel.h> 5 #include <linux/err.h> 6 #include <linux/errno.h> 7 #include <linux/gfp.h> 8 #include <linux/refcount.h> 9 #include <linux/rhashtable.h> 10 11 #include "reg.h" 12 #include "core.h" 13 #include "spectrum.h" 14 #include "spectrum_acl_tcam.h" 15 #include "core_acl_flex_keys.h" 16 17 #define MLXSW_SP_ACL_ATCAM_LKEY_ID_BLOCK_CLEAR_START 0 18 #define MLXSW_SP_ACL_ATCAM_LKEY_ID_BLOCK_CLEAR_END 5 19 20 struct mlxsw_sp_acl_atcam_lkey_id_ht_key { 21 char enc_key[MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN]; /* MSB blocks */ 22 u8 erp_id; 23 }; 24 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; 28 refcount_t refcnt; 29 u32 id; 30 }; 31 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); 40 }; 41 42 struct mlxsw_sp_acl_atcam_region_generic { 43 struct mlxsw_sp_acl_atcam_lkey_id dummy_lkey_id; 44 }; 45 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; 50 }; 51 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), 56 }; 57 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), 62 }; 63 64 static bool 65 mlxsw_sp_acl_atcam_is_centry(const struct mlxsw_sp_acl_atcam_entry *aentry) 66 { 67 return mlxsw_sp_acl_erp_mask_is_ctcam(aentry->erp_mask); 68 } 69 70 static int 71 mlxsw_sp_acl_atcam_region_generic_init(struct mlxsw_sp_acl_atcam_region *aregion) 72 { 73 struct mlxsw_sp_acl_atcam_region_generic *region_generic; 74 75 region_generic = kzalloc(sizeof(*region_generic), GFP_KERNEL); 76 if (!region_generic) 77 return -ENOMEM; 78 79 refcount_set(®ion_generic->dummy_lkey_id.refcnt, 1); 80 aregion->priv = region_generic; 81 82 return 0; 83 } 84 85 static void 86 mlxsw_sp_acl_atcam_region_generic_fini(struct mlxsw_sp_acl_atcam_region *aregion) 87 { 88 kfree(aregion->priv); 89 } 90 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) 94 { 95 struct mlxsw_sp_acl_atcam_region_generic *region_generic; 96 97 region_generic = aregion->priv; 98 return ®ion_generic->dummy_lkey_id; 99 } 100 101 static void 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) 104 { 105 } 106 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, 113 }; 114 115 static int 116 mlxsw_sp_acl_atcam_region_12kb_init(struct mlxsw_sp_acl_atcam_region *aregion) 117 { 118 struct mlxsw_sp *mlxsw_sp = aregion->region->mlxsw_sp; 119 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb; 120 size_t alloc_size; 121 u64 max_lkey_id; 122 int err; 123 124 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, ACL_MAX_LARGE_KEY_ID)) 125 return -EIO; 126 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); 129 if (!region_12kb) 130 return -ENOMEM; 131 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) { 135 err = -ENOMEM; 136 goto err_used_lkey_id_alloc; 137 } 138 139 err = rhashtable_init(®ion_12kb->lkey_ht, 140 &mlxsw_sp_acl_atcam_lkey_id_ht_params); 141 if (err) 142 goto err_rhashtable_init; 143 144 region_12kb->max_lkey_id = max_lkey_id; 145 aregion->priv = region_12kb; 146 147 return 0; 148 149 err_rhashtable_init: 150 kfree(region_12kb->used_lkey_id); 151 err_used_lkey_id_alloc: 152 kfree(region_12kb); 153 return err; 154 } 155 156 static void 157 mlxsw_sp_acl_atcam_region_12kb_fini(struct mlxsw_sp_acl_atcam_region *aregion) 158 { 159 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv; 160 161 rhashtable_destroy(®ion_12kb->lkey_ht); 162 kfree(region_12kb->used_lkey_id); 163 kfree(region_12kb); 164 } 165 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) 169 { 170 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv; 171 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id; 172 u32 id; 173 int err; 174 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); 179 else 180 return ERR_PTR(-ENOBUFS); 181 182 lkey_id = kzalloc(sizeof(*lkey_id), GFP_KERNEL); 183 if (!lkey_id) { 184 err = -ENOMEM; 185 goto err_lkey_id_alloc; 186 } 187 188 lkey_id->id = id; 189 memcpy(&lkey_id->ht_key, ht_key, sizeof(*ht_key)); 190 refcount_set(&lkey_id->refcnt, 1); 191 192 err = rhashtable_insert_fast(®ion_12kb->lkey_ht, 193 &lkey_id->ht_node, 194 mlxsw_sp_acl_atcam_lkey_id_ht_params); 195 if (err) 196 goto err_rhashtable_insert; 197 198 return lkey_id; 199 200 err_rhashtable_insert: 201 kfree(lkey_id); 202 err_lkey_id_alloc: 203 __clear_bit(id, region_12kb->used_lkey_id); 204 return ERR_PTR(err); 205 } 206 207 static void 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) 210 { 211 struct mlxsw_sp_acl_atcam_region_12kb *region_12kb = aregion->priv; 212 u32 id = lkey_id->id; 213 214 rhashtable_remove_fast(®ion_12kb->lkey_ht, &lkey_id->ht_node, 215 mlxsw_sp_acl_atcam_lkey_id_ht_params); 216 kfree(lkey_id); 217 __clear_bit(id, region_12kb->used_lkey_id); 218 } 219 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) 223 { 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; 230 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); 238 if (lkey_id) { 239 refcount_inc(&lkey_id->refcnt); 240 return lkey_id; 241 } 242 243 return mlxsw_sp_acl_atcam_lkey_id_create(aregion, &ht_key); 244 } 245 246 static void 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) 249 { 250 if (refcount_dec_and_test(&lkey_id->refcnt)) 251 mlxsw_sp_acl_atcam_lkey_id_destroy(aregion, lkey_id); 252 } 253 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, 260 }; 261 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, 272 }; 273 274 int mlxsw_sp_acl_atcam_region_associate(struct mlxsw_sp *mlxsw_sp, 275 u16 region_id) 276 { 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; 280 u64 max_regions; 281 282 max_regions = MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_REGIONS); 283 if (hw_region >= max_regions) 284 return -ENOBUFS; 285 286 mlxsw_reg_perar_pack(perar_pl, region_id, hw_region); 287 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(perar), perar_pl); 288 } 289 290 static void 291 mlxsw_sp_acl_atcam_region_type_init(struct mlxsw_sp_acl_atcam_region *aregion) 292 { 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; 296 297 /* We already know the blocks count can not exceed the maximum 298 * blocks count. 299 */ 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; 307 else 308 region_type = MLXSW_SP_ACL_ATCAM_REGION_TYPE_12KB; 309 310 aregion->type = region_type; 311 aregion->ops = mlxsw_sp_acl_atcam_region_ops_arr[region_type]; 312 } 313 314 int 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) 320 { 321 int err; 322 323 aregion->region = region; 324 aregion->atcam = atcam; 325 mlxsw_sp_acl_atcam_region_type_init(aregion); 326 327 err = rhashtable_init(&aregion->entries_ht, 328 &mlxsw_sp_acl_atcam_entries_ht_params); 329 if (err) 330 return err; 331 err = aregion->ops->init(aregion); 332 if (err) 333 goto err_ops_init; 334 err = mlxsw_sp_acl_erp_region_init(aregion); 335 if (err) 336 goto err_erp_region_init; 337 err = mlxsw_sp_acl_ctcam_region_init(mlxsw_sp, &aregion->cregion, 338 region, ops); 339 if (err) 340 goto err_ctcam_region_init; 341 342 return 0; 343 344 err_ctcam_region_init: 345 mlxsw_sp_acl_erp_region_fini(aregion); 346 err_erp_region_init: 347 aregion->ops->fini(aregion); 348 err_ops_init: 349 rhashtable_destroy(&aregion->entries_ht); 350 return err; 351 } 352 353 void mlxsw_sp_acl_atcam_region_fini(struct mlxsw_sp_acl_atcam_region *aregion) 354 { 355 mlxsw_sp_acl_ctcam_region_fini(&aregion->cregion); 356 mlxsw_sp_acl_erp_region_fini(aregion); 357 aregion->ops->fini(aregion); 358 rhashtable_destroy(&aregion->entries_ht); 359 } 360 361 void mlxsw_sp_acl_atcam_chunk_init(struct mlxsw_sp_acl_atcam_region *aregion, 362 struct mlxsw_sp_acl_atcam_chunk *achunk, 363 unsigned int priority) 364 { 365 mlxsw_sp_acl_ctcam_chunk_init(&aregion->cregion, &achunk->cchunk, 366 priority); 367 } 368 369 void mlxsw_sp_acl_atcam_chunk_fini(struct mlxsw_sp_acl_atcam_chunk *achunk) 370 { 371 mlxsw_sp_acl_ctcam_chunk_fini(&achunk->cchunk); 372 } 373 374 static int 375 mlxsw_sp_acl_atcam_region_entry_insert(struct mlxsw_sp *mlxsw_sp, 376 struct mlxsw_sp_acl_atcam_region *aregion, 377 struct mlxsw_sp_acl_atcam_entry *aentry, 378 struct mlxsw_sp_acl_rule_info *rulei) 379 { 380 struct mlxsw_sp_acl_tcam_region *region = aregion->region; 381 u8 erp_id = mlxsw_sp_acl_erp_mask_erp_id(aentry->erp_mask); 382 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id; 383 char ptce3_pl[MLXSW_REG_PTCE3_LEN]; 384 u32 kvdl_index, priority; 385 int err; 386 387 err = mlxsw_sp_acl_tcam_priority_get(mlxsw_sp, rulei, &priority, true); 388 if (err) 389 return err; 390 391 lkey_id = aregion->ops->lkey_id_get(aregion, aentry->ht_key.enc_key, 392 erp_id); 393 if (IS_ERR(lkey_id)) 394 return PTR_ERR(lkey_id); 395 aentry->lkey_id = lkey_id; 396 397 kvdl_index = mlxsw_afa_block_first_kvdl_index(rulei->act_block); 398 mlxsw_reg_ptce3_pack(ptce3_pl, true, MLXSW_REG_PTCE3_OP_WRITE_WRITE, 399 priority, region->tcam_region_info, 400 aentry->ht_key.enc_key, erp_id, 401 aentry->delta_info.start, 402 aentry->delta_info.mask, 403 aentry->delta_info.value, 404 refcount_read(&lkey_id->refcnt) != 1, lkey_id->id, 405 kvdl_index); 406 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce3), ptce3_pl); 407 if (err) 408 goto err_ptce3_write; 409 410 return 0; 411 412 err_ptce3_write: 413 aregion->ops->lkey_id_put(aregion, lkey_id); 414 return err; 415 } 416 417 static void 418 mlxsw_sp_acl_atcam_region_entry_remove(struct mlxsw_sp *mlxsw_sp, 419 struct mlxsw_sp_acl_atcam_region *aregion, 420 struct mlxsw_sp_acl_atcam_entry *aentry) 421 { 422 struct mlxsw_sp_acl_atcam_lkey_id *lkey_id = aentry->lkey_id; 423 struct mlxsw_sp_acl_tcam_region *region = aregion->region; 424 u8 erp_id = mlxsw_sp_acl_erp_mask_erp_id(aentry->erp_mask); 425 char *enc_key = aentry->ht_key.enc_key; 426 char ptce3_pl[MLXSW_REG_PTCE3_LEN]; 427 428 mlxsw_reg_ptce3_pack(ptce3_pl, false, MLXSW_REG_PTCE3_OP_WRITE_WRITE, 0, 429 region->tcam_region_info, 430 enc_key, erp_id, 431 aentry->delta_info.start, 432 aentry->delta_info.mask, 433 aentry->delta_info.value, 434 refcount_read(&lkey_id->refcnt) != 1, 435 lkey_id->id, 0); 436 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce3), ptce3_pl); 437 aregion->ops->lkey_id_put(aregion, lkey_id); 438 } 439 440 static int 441 __mlxsw_sp_acl_atcam_entry_add(struct mlxsw_sp *mlxsw_sp, 442 struct mlxsw_sp_acl_atcam_region *aregion, 443 struct mlxsw_sp_acl_atcam_entry *aentry, 444 struct mlxsw_sp_acl_rule_info *rulei) 445 { 446 struct mlxsw_sp_acl_tcam_region *region = aregion->region; 447 char mask[MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN] = { 0 }; 448 struct mlxsw_afk *afk = mlxsw_sp_acl_afk(mlxsw_sp->acl); 449 const struct mlxsw_sp_acl_erp_delta *delta; 450 struct mlxsw_sp_acl_erp_mask *erp_mask; 451 int err; 452 453 mlxsw_afk_encode(afk, region->key_info, &rulei->values, 454 aentry->full_enc_key, mask); 455 456 erp_mask = mlxsw_sp_acl_erp_mask_get(aregion, mask, false); 457 if (IS_ERR(erp_mask)) 458 return PTR_ERR(erp_mask); 459 aentry->erp_mask = erp_mask; 460 aentry->ht_key.erp_id = mlxsw_sp_acl_erp_mask_erp_id(erp_mask); 461 memcpy(aentry->ht_key.enc_key, aentry->full_enc_key, 462 sizeof(aentry->ht_key.enc_key)); 463 464 /* Compute all needed delta information and clear the delta bits 465 * from the encrypted key. 466 */ 467 delta = mlxsw_sp_acl_erp_delta(aentry->erp_mask); 468 aentry->delta_info.start = mlxsw_sp_acl_erp_delta_start(delta); 469 aentry->delta_info.mask = mlxsw_sp_acl_erp_delta_mask(delta); 470 aentry->delta_info.value = 471 mlxsw_sp_acl_erp_delta_value(delta, aentry->full_enc_key); 472 mlxsw_sp_acl_erp_delta_clear(delta, aentry->ht_key.enc_key); 473 474 /* We can't insert identical rules into the A-TCAM, so fail and 475 * let the rule spill into C-TCAM 476 */ 477 err = rhashtable_lookup_insert_fast(&aregion->entries_ht, 478 &aentry->ht_node, 479 mlxsw_sp_acl_atcam_entries_ht_params); 480 if (err) 481 goto err_rhashtable_insert; 482 483 err = mlxsw_sp_acl_atcam_region_entry_insert(mlxsw_sp, aregion, aentry, 484 rulei); 485 if (err) 486 goto err_rule_insert; 487 488 return 0; 489 490 err_rule_insert: 491 rhashtable_remove_fast(&aregion->entries_ht, &aentry->ht_node, 492 mlxsw_sp_acl_atcam_entries_ht_params); 493 err_rhashtable_insert: 494 mlxsw_sp_acl_erp_mask_put(aregion, erp_mask); 495 return err; 496 } 497 498 static void 499 __mlxsw_sp_acl_atcam_entry_del(struct mlxsw_sp *mlxsw_sp, 500 struct mlxsw_sp_acl_atcam_region *aregion, 501 struct mlxsw_sp_acl_atcam_entry *aentry) 502 { 503 mlxsw_sp_acl_atcam_region_entry_remove(mlxsw_sp, aregion, aentry); 504 rhashtable_remove_fast(&aregion->entries_ht, &aentry->ht_node, 505 mlxsw_sp_acl_atcam_entries_ht_params); 506 mlxsw_sp_acl_erp_mask_put(aregion, aentry->erp_mask); 507 } 508 509 int mlxsw_sp_acl_atcam_entry_add(struct mlxsw_sp *mlxsw_sp, 510 struct mlxsw_sp_acl_atcam_region *aregion, 511 struct mlxsw_sp_acl_atcam_chunk *achunk, 512 struct mlxsw_sp_acl_atcam_entry *aentry, 513 struct mlxsw_sp_acl_rule_info *rulei) 514 { 515 int err; 516 517 err = __mlxsw_sp_acl_atcam_entry_add(mlxsw_sp, aregion, aentry, rulei); 518 if (!err) 519 return 0; 520 521 /* It is possible we failed to add the rule to the A-TCAM due to 522 * exceeded number of masks. Try to spill into C-TCAM. 523 */ 524 err = mlxsw_sp_acl_ctcam_entry_add(mlxsw_sp, &aregion->cregion, 525 &achunk->cchunk, &aentry->centry, 526 rulei, true); 527 if (!err) 528 return 0; 529 530 return err; 531 } 532 533 void mlxsw_sp_acl_atcam_entry_del(struct mlxsw_sp *mlxsw_sp, 534 struct mlxsw_sp_acl_atcam_region *aregion, 535 struct mlxsw_sp_acl_atcam_chunk *achunk, 536 struct mlxsw_sp_acl_atcam_entry *aentry) 537 { 538 if (mlxsw_sp_acl_atcam_is_centry(aentry)) 539 mlxsw_sp_acl_ctcam_entry_del(mlxsw_sp, &aregion->cregion, 540 &achunk->cchunk, &aentry->centry); 541 else 542 __mlxsw_sp_acl_atcam_entry_del(mlxsw_sp, aregion, aentry); 543 } 544 545 int mlxsw_sp_acl_atcam_init(struct mlxsw_sp *mlxsw_sp, 546 struct mlxsw_sp_acl_atcam *atcam) 547 { 548 return mlxsw_sp_acl_erps_init(mlxsw_sp, atcam); 549 } 550 551 void mlxsw_sp_acl_atcam_fini(struct mlxsw_sp *mlxsw_sp, 552 struct mlxsw_sp_acl_atcam *atcam) 553 { 554 mlxsw_sp_acl_erps_fini(mlxsw_sp, atcam); 555 } 556