1
2
3
4#include <linux/kernel.h>
5#include <linux/slab.h>
6#include <linux/errno.h>
7#include <linux/bitops.h>
8#include <linux/list.h>
9#include <linux/rhashtable.h>
10#include <linux/netdevice.h>
11#include <linux/mutex.h>
12#include <trace/events/mlxsw.h>
13
14#include "reg.h"
15#include "core.h"
16#include "resources.h"
17#include "spectrum.h"
18#include "spectrum_acl_tcam.h"
19#include "core_acl_flex_keys.h"
20
21size_t mlxsw_sp_acl_tcam_priv_size(struct mlxsw_sp *mlxsw_sp)
22{
23 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
24
25 return ops->priv_size;
26}
27
28#define MLXSW_SP_ACL_TCAM_VREGION_REHASH_INTRVL_DFLT 5000
29#define MLXSW_SP_ACL_TCAM_VREGION_REHASH_INTRVL_MIN 3000
30#define MLXSW_SP_ACL_TCAM_VREGION_REHASH_CREDITS 100
31
32int mlxsw_sp_acl_tcam_init(struct mlxsw_sp *mlxsw_sp,
33 struct mlxsw_sp_acl_tcam *tcam)
34{
35 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
36 u64 max_tcam_regions;
37 u64 max_regions;
38 u64 max_groups;
39 size_t alloc_size;
40 int err;
41
42 mutex_init(&tcam->lock);
43 tcam->vregion_rehash_intrvl =
44 MLXSW_SP_ACL_TCAM_VREGION_REHASH_INTRVL_DFLT;
45 INIT_LIST_HEAD(&tcam->vregion_list);
46
47 max_tcam_regions = MLXSW_CORE_RES_GET(mlxsw_sp->core,
48 ACL_MAX_TCAM_REGIONS);
49 max_regions = MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_REGIONS);
50
51
52 if (max_tcam_regions < max_regions)
53 max_regions = max_tcam_regions;
54
55 alloc_size = sizeof(tcam->used_regions[0]) * BITS_TO_LONGS(max_regions);
56 tcam->used_regions = kzalloc(alloc_size, GFP_KERNEL);
57 if (!tcam->used_regions)
58 return -ENOMEM;
59 tcam->max_regions = max_regions;
60
61 max_groups = MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_GROUPS);
62 alloc_size = sizeof(tcam->used_groups[0]) * BITS_TO_LONGS(max_groups);
63 tcam->used_groups = kzalloc(alloc_size, GFP_KERNEL);
64 if (!tcam->used_groups) {
65 err = -ENOMEM;
66 goto err_alloc_used_groups;
67 }
68 tcam->max_groups = max_groups;
69 tcam->max_group_size = MLXSW_CORE_RES_GET(mlxsw_sp->core,
70 ACL_MAX_GROUP_SIZE);
71
72 err = ops->init(mlxsw_sp, tcam->priv, tcam);
73 if (err)
74 goto err_tcam_init;
75
76 return 0;
77
78err_tcam_init:
79 kfree(tcam->used_groups);
80err_alloc_used_groups:
81 kfree(tcam->used_regions);
82 return err;
83}
84
85void mlxsw_sp_acl_tcam_fini(struct mlxsw_sp *mlxsw_sp,
86 struct mlxsw_sp_acl_tcam *tcam)
87{
88 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
89
90 mutex_destroy(&tcam->lock);
91 ops->fini(mlxsw_sp, tcam->priv);
92 kfree(tcam->used_groups);
93 kfree(tcam->used_regions);
94}
95
96int mlxsw_sp_acl_tcam_priority_get(struct mlxsw_sp *mlxsw_sp,
97 struct mlxsw_sp_acl_rule_info *rulei,
98 u32 *priority, bool fillup_priority)
99{
100 u64 max_priority;
101
102 if (!fillup_priority) {
103 *priority = 0;
104 return 0;
105 }
106
107 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, KVD_SIZE))
108 return -EIO;
109
110
111 max_priority = MLXSW_CORE_RES_GET(mlxsw_sp->core, KVD_SIZE) - 1;
112 if (rulei->priority >= max_priority)
113 return -EINVAL;
114
115
116 *priority = max_priority - rulei->priority;
117 return 0;
118}
119
120static int mlxsw_sp_acl_tcam_region_id_get(struct mlxsw_sp_acl_tcam *tcam,
121 u16 *p_id)
122{
123 u16 id;
124
125 id = find_first_zero_bit(tcam->used_regions, tcam->max_regions);
126 if (id < tcam->max_regions) {
127 __set_bit(id, tcam->used_regions);
128 *p_id = id;
129 return 0;
130 }
131 return -ENOBUFS;
132}
133
134static void mlxsw_sp_acl_tcam_region_id_put(struct mlxsw_sp_acl_tcam *tcam,
135 u16 id)
136{
137 __clear_bit(id, tcam->used_regions);
138}
139
140static int mlxsw_sp_acl_tcam_group_id_get(struct mlxsw_sp_acl_tcam *tcam,
141 u16 *p_id)
142{
143 u16 id;
144
145 id = find_first_zero_bit(tcam->used_groups, tcam->max_groups);
146 if (id < tcam->max_groups) {
147 __set_bit(id, tcam->used_groups);
148 *p_id = id;
149 return 0;
150 }
151 return -ENOBUFS;
152}
153
154static void mlxsw_sp_acl_tcam_group_id_put(struct mlxsw_sp_acl_tcam *tcam,
155 u16 id)
156{
157 __clear_bit(id, tcam->used_groups);
158}
159
160struct mlxsw_sp_acl_tcam_pattern {
161 const enum mlxsw_afk_element *elements;
162 unsigned int elements_count;
163};
164
165struct mlxsw_sp_acl_tcam_group {
166 struct mlxsw_sp_acl_tcam *tcam;
167 u16 id;
168 struct mutex lock;
169 struct list_head region_list;
170 unsigned int region_count;
171};
172
173struct mlxsw_sp_acl_tcam_vgroup {
174 struct mlxsw_sp_acl_tcam_group group;
175 struct list_head vregion_list;
176 struct rhashtable vchunk_ht;
177 const struct mlxsw_sp_acl_tcam_pattern *patterns;
178 unsigned int patterns_count;
179 bool tmplt_elusage_set;
180 struct mlxsw_afk_element_usage tmplt_elusage;
181 bool vregion_rehash_enabled;
182};
183
184struct mlxsw_sp_acl_tcam_rehash_ctx {
185 void *hints_priv;
186 bool this_is_rollback;
187 struct mlxsw_sp_acl_tcam_vchunk *current_vchunk;
188
189
190 struct mlxsw_sp_acl_tcam_ventry *start_ventry;
191
192
193
194
195 struct mlxsw_sp_acl_tcam_ventry *stop_ventry;
196
197
198
199
200};
201
202struct mlxsw_sp_acl_tcam_vregion {
203 struct mutex lock;
204
205
206 struct mlxsw_sp_acl_tcam_region *region;
207 struct mlxsw_sp_acl_tcam_region *region2;
208 struct list_head list;
209 struct list_head tlist;
210 struct list_head vchunk_list;
211 struct mlxsw_afk_key_info *key_info;
212 struct mlxsw_sp_acl_tcam *tcam;
213 struct mlxsw_sp_acl_tcam_vgroup *vgroup;
214 struct {
215 struct delayed_work dw;
216 struct mlxsw_sp_acl_tcam_rehash_ctx ctx;
217 } rehash;
218 struct mlxsw_sp *mlxsw_sp;
219 unsigned int ref_count;
220};
221
222struct mlxsw_sp_acl_tcam_vchunk;
223
224struct mlxsw_sp_acl_tcam_chunk {
225 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
226 struct mlxsw_sp_acl_tcam_region *region;
227 unsigned long priv[0];
228
229};
230
231struct mlxsw_sp_acl_tcam_vchunk {
232 struct mlxsw_sp_acl_tcam_chunk *chunk;
233 struct mlxsw_sp_acl_tcam_chunk *chunk2;
234 struct list_head list;
235 struct rhash_head ht_node;
236 struct list_head ventry_list;
237 unsigned int priority;
238 struct mlxsw_sp_acl_tcam_vgroup *vgroup;
239 struct mlxsw_sp_acl_tcam_vregion *vregion;
240 unsigned int ref_count;
241};
242
243struct mlxsw_sp_acl_tcam_entry {
244 struct mlxsw_sp_acl_tcam_ventry *ventry;
245 struct mlxsw_sp_acl_tcam_chunk *chunk;
246 unsigned long priv[0];
247
248};
249
250struct mlxsw_sp_acl_tcam_ventry {
251 struct mlxsw_sp_acl_tcam_entry *entry;
252 struct list_head list;
253 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
254 struct mlxsw_sp_acl_rule_info *rulei;
255};
256
257static const struct rhashtable_params mlxsw_sp_acl_tcam_vchunk_ht_params = {
258 .key_len = sizeof(unsigned int),
259 .key_offset = offsetof(struct mlxsw_sp_acl_tcam_vchunk, priority),
260 .head_offset = offsetof(struct mlxsw_sp_acl_tcam_vchunk, ht_node),
261 .automatic_shrinking = true,
262};
263
264static int mlxsw_sp_acl_tcam_group_update(struct mlxsw_sp *mlxsw_sp,
265 struct mlxsw_sp_acl_tcam_group *group)
266{
267 struct mlxsw_sp_acl_tcam_region *region;
268 char pagt_pl[MLXSW_REG_PAGT_LEN];
269 int acl_index = 0;
270
271 mlxsw_reg_pagt_pack(pagt_pl, group->id);
272 list_for_each_entry(region, &group->region_list, list) {
273 bool multi = false;
274
275
276 if (region->list.next != &group->region_list &&
277 list_next_entry(region, list)->vregion == region->vregion)
278 multi = true;
279 mlxsw_reg_pagt_acl_id_pack(pagt_pl, acl_index++,
280 region->id, multi);
281 }
282 mlxsw_reg_pagt_size_set(pagt_pl, acl_index);
283 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pagt), pagt_pl);
284}
285
286static int
287mlxsw_sp_acl_tcam_group_add(struct mlxsw_sp_acl_tcam *tcam,
288 struct mlxsw_sp_acl_tcam_group *group)
289{
290 int err;
291
292 group->tcam = tcam;
293 mutex_init(&group->lock);
294 INIT_LIST_HEAD(&group->region_list);
295
296 err = mlxsw_sp_acl_tcam_group_id_get(tcam, &group->id);
297 if (err)
298 return err;
299
300 return 0;
301}
302
303static void mlxsw_sp_acl_tcam_group_del(struct mlxsw_sp_acl_tcam_group *group)
304{
305 struct mlxsw_sp_acl_tcam *tcam = group->tcam;
306
307 mutex_destroy(&group->lock);
308 mlxsw_sp_acl_tcam_group_id_put(tcam, group->id);
309 WARN_ON(!list_empty(&group->region_list));
310}
311
312static int
313mlxsw_sp_acl_tcam_vgroup_add(struct mlxsw_sp *mlxsw_sp,
314 struct mlxsw_sp_acl_tcam *tcam,
315 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
316 const struct mlxsw_sp_acl_tcam_pattern *patterns,
317 unsigned int patterns_count,
318 struct mlxsw_afk_element_usage *tmplt_elusage,
319 bool vregion_rehash_enabled)
320{
321 int err;
322
323 vgroup->patterns = patterns;
324 vgroup->patterns_count = patterns_count;
325 vgroup->vregion_rehash_enabled = vregion_rehash_enabled;
326
327 if (tmplt_elusage) {
328 vgroup->tmplt_elusage_set = true;
329 memcpy(&vgroup->tmplt_elusage, tmplt_elusage,
330 sizeof(vgroup->tmplt_elusage));
331 }
332 INIT_LIST_HEAD(&vgroup->vregion_list);
333
334 err = mlxsw_sp_acl_tcam_group_add(tcam, &vgroup->group);
335 if (err)
336 return err;
337
338 err = rhashtable_init(&vgroup->vchunk_ht,
339 &mlxsw_sp_acl_tcam_vchunk_ht_params);
340 if (err)
341 goto err_rhashtable_init;
342
343 return 0;
344
345err_rhashtable_init:
346 mlxsw_sp_acl_tcam_group_del(&vgroup->group);
347 return err;
348}
349
350static void
351mlxsw_sp_acl_tcam_vgroup_del(struct mlxsw_sp_acl_tcam_vgroup *vgroup)
352{
353 rhashtable_destroy(&vgroup->vchunk_ht);
354 mlxsw_sp_acl_tcam_group_del(&vgroup->group);
355 WARN_ON(!list_empty(&vgroup->vregion_list));
356}
357
358static int
359mlxsw_sp_acl_tcam_group_bind(struct mlxsw_sp *mlxsw_sp,
360 struct mlxsw_sp_acl_tcam_group *group,
361 struct mlxsw_sp_port *mlxsw_sp_port,
362 bool ingress)
363{
364 char ppbt_pl[MLXSW_REG_PPBT_LEN];
365
366 mlxsw_reg_ppbt_pack(ppbt_pl, ingress ? MLXSW_REG_PXBT_E_IACL :
367 MLXSW_REG_PXBT_E_EACL,
368 MLXSW_REG_PXBT_OP_BIND, mlxsw_sp_port->local_port,
369 group->id);
370 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ppbt), ppbt_pl);
371}
372
373static void
374mlxsw_sp_acl_tcam_group_unbind(struct mlxsw_sp *mlxsw_sp,
375 struct mlxsw_sp_acl_tcam_group *group,
376 struct mlxsw_sp_port *mlxsw_sp_port,
377 bool ingress)
378{
379 char ppbt_pl[MLXSW_REG_PPBT_LEN];
380
381 mlxsw_reg_ppbt_pack(ppbt_pl, ingress ? MLXSW_REG_PXBT_E_IACL :
382 MLXSW_REG_PXBT_E_EACL,
383 MLXSW_REG_PXBT_OP_UNBIND, mlxsw_sp_port->local_port,
384 group->id);
385 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ppbt), ppbt_pl);
386}
387
388static u16
389mlxsw_sp_acl_tcam_group_id(struct mlxsw_sp_acl_tcam_group *group)
390{
391 return group->id;
392}
393
394static unsigned int
395mlxsw_sp_acl_tcam_vregion_prio(struct mlxsw_sp_acl_tcam_vregion *vregion)
396{
397 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
398
399 if (list_empty(&vregion->vchunk_list))
400 return 0;
401
402 vchunk = list_first_entry(&vregion->vchunk_list,
403 typeof(*vchunk), list);
404 return vchunk->priority;
405}
406
407static unsigned int
408mlxsw_sp_acl_tcam_vregion_max_prio(struct mlxsw_sp_acl_tcam_vregion *vregion)
409{
410 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
411
412 if (list_empty(&vregion->vchunk_list))
413 return 0;
414 vchunk = list_last_entry(&vregion->vchunk_list,
415 typeof(*vchunk), list);
416 return vchunk->priority;
417}
418
419static int
420mlxsw_sp_acl_tcam_group_region_attach(struct mlxsw_sp *mlxsw_sp,
421 struct mlxsw_sp_acl_tcam_group *group,
422 struct mlxsw_sp_acl_tcam_region *region,
423 unsigned int priority,
424 struct mlxsw_sp_acl_tcam_region *next_region)
425{
426 struct mlxsw_sp_acl_tcam_region *region2;
427 struct list_head *pos;
428 int err;
429
430 mutex_lock(&group->lock);
431 if (group->region_count == group->tcam->max_group_size) {
432 err = -ENOBUFS;
433 goto err_region_count_check;
434 }
435
436 if (next_region) {
437
438
439
440 pos = &next_region->list;
441 } else {
442
443 list_for_each(pos, &group->region_list) {
444 region2 = list_entry(pos, typeof(*region2), list);
445 if (mlxsw_sp_acl_tcam_vregion_prio(region2->vregion) >
446 priority)
447 break;
448 }
449 }
450 list_add_tail(®ion->list, pos);
451 region->group = group;
452
453 err = mlxsw_sp_acl_tcam_group_update(mlxsw_sp, group);
454 if (err)
455 goto err_group_update;
456
457 group->region_count++;
458 mutex_unlock(&group->lock);
459 return 0;
460
461err_group_update:
462 list_del(®ion->list);
463err_region_count_check:
464 mutex_unlock(&group->lock);
465 return err;
466}
467
468static void
469mlxsw_sp_acl_tcam_group_region_detach(struct mlxsw_sp *mlxsw_sp,
470 struct mlxsw_sp_acl_tcam_region *region)
471{
472 struct mlxsw_sp_acl_tcam_group *group = region->group;
473
474 mutex_lock(&group->lock);
475 list_del(®ion->list);
476 group->region_count--;
477 mlxsw_sp_acl_tcam_group_update(mlxsw_sp, group);
478 mutex_unlock(&group->lock);
479}
480
481static int
482mlxsw_sp_acl_tcam_vgroup_vregion_attach(struct mlxsw_sp *mlxsw_sp,
483 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
484 struct mlxsw_sp_acl_tcam_vregion *vregion,
485 unsigned int priority)
486{
487 struct mlxsw_sp_acl_tcam_vregion *vregion2;
488 struct list_head *pos;
489 int err;
490
491
492 list_for_each(pos, &vgroup->vregion_list) {
493 vregion2 = list_entry(pos, typeof(*vregion2), list);
494 if (mlxsw_sp_acl_tcam_vregion_prio(vregion2) > priority)
495 break;
496 }
497 list_add_tail(&vregion->list, pos);
498
499 err = mlxsw_sp_acl_tcam_group_region_attach(mlxsw_sp, &vgroup->group,
500 vregion->region,
501 priority, NULL);
502 if (err)
503 goto err_region_attach;
504
505 return 0;
506
507err_region_attach:
508 list_del(&vregion->list);
509 return err;
510}
511
512static void
513mlxsw_sp_acl_tcam_vgroup_vregion_detach(struct mlxsw_sp *mlxsw_sp,
514 struct mlxsw_sp_acl_tcam_vregion *vregion)
515{
516 list_del(&vregion->list);
517 if (vregion->region2)
518 mlxsw_sp_acl_tcam_group_region_detach(mlxsw_sp,
519 vregion->region2);
520 mlxsw_sp_acl_tcam_group_region_detach(mlxsw_sp, vregion->region);
521}
522
523static struct mlxsw_sp_acl_tcam_vregion *
524mlxsw_sp_acl_tcam_vgroup_vregion_find(struct mlxsw_sp_acl_tcam_vgroup *vgroup,
525 unsigned int priority,
526 struct mlxsw_afk_element_usage *elusage,
527 bool *p_need_split)
528{
529 struct mlxsw_sp_acl_tcam_vregion *vregion, *vregion2;
530 struct list_head *pos;
531 bool issubset;
532
533 list_for_each(pos, &vgroup->vregion_list) {
534 vregion = list_entry(pos, typeof(*vregion), list);
535
536
537
538
539 if (pos->next != &vgroup->vregion_list) {
540 vregion2 = list_entry(pos->next, typeof(*vregion2),
541 list);
542 if (priority >=
543 mlxsw_sp_acl_tcam_vregion_prio(vregion2))
544 continue;
545 }
546
547 issubset = mlxsw_afk_key_info_subset(vregion->key_info,
548 elusage);
549
550
551
552
553
554
555 if (!issubset &&
556 priority < mlxsw_sp_acl_tcam_vregion_prio(vregion))
557 return NULL;
558
559
560
561
562
563
564
565 if (!issubset &&
566 priority > mlxsw_sp_acl_tcam_vregion_max_prio(vregion))
567 continue;
568
569
570
571
572
573 *p_need_split = !issubset;
574 return vregion;
575 }
576 return NULL;
577}
578
579static void
580mlxsw_sp_acl_tcam_vgroup_use_patterns(struct mlxsw_sp_acl_tcam_vgroup *vgroup,
581 struct mlxsw_afk_element_usage *elusage,
582 struct mlxsw_afk_element_usage *out)
583{
584 const struct mlxsw_sp_acl_tcam_pattern *pattern;
585 int i;
586
587
588
589
590 if (vgroup->tmplt_elusage_set) {
591 memcpy(out, &vgroup->tmplt_elusage, sizeof(*out));
592 WARN_ON(!mlxsw_afk_element_usage_subset(elusage, out));
593 return;
594 }
595
596 for (i = 0; i < vgroup->patterns_count; i++) {
597 pattern = &vgroup->patterns[i];
598 mlxsw_afk_element_usage_fill(out, pattern->elements,
599 pattern->elements_count);
600 if (mlxsw_afk_element_usage_subset(elusage, out))
601 return;
602 }
603 memcpy(out, elusage, sizeof(*out));
604}
605
606static int
607mlxsw_sp_acl_tcam_region_alloc(struct mlxsw_sp *mlxsw_sp,
608 struct mlxsw_sp_acl_tcam_region *region)
609{
610 struct mlxsw_afk_key_info *key_info = region->key_info;
611 char ptar_pl[MLXSW_REG_PTAR_LEN];
612 unsigned int encodings_count;
613 int i;
614 int err;
615
616 mlxsw_reg_ptar_pack(ptar_pl, MLXSW_REG_PTAR_OP_ALLOC,
617 region->key_type,
618 MLXSW_SP_ACL_TCAM_REGION_BASE_COUNT,
619 region->id, region->tcam_region_info);
620 encodings_count = mlxsw_afk_key_info_blocks_count_get(key_info);
621 for (i = 0; i < encodings_count; i++) {
622 u16 encoding;
623
624 encoding = mlxsw_afk_key_info_block_encoding_get(key_info, i);
625 mlxsw_reg_ptar_key_id_pack(ptar_pl, i, encoding);
626 }
627 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptar), ptar_pl);
628 if (err)
629 return err;
630 mlxsw_reg_ptar_unpack(ptar_pl, region->tcam_region_info);
631 return 0;
632}
633
634static void
635mlxsw_sp_acl_tcam_region_free(struct mlxsw_sp *mlxsw_sp,
636 struct mlxsw_sp_acl_tcam_region *region)
637{
638 char ptar_pl[MLXSW_REG_PTAR_LEN];
639
640 mlxsw_reg_ptar_pack(ptar_pl, MLXSW_REG_PTAR_OP_FREE,
641 region->key_type, 0, region->id,
642 region->tcam_region_info);
643 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptar), ptar_pl);
644}
645
646static int
647mlxsw_sp_acl_tcam_region_enable(struct mlxsw_sp *mlxsw_sp,
648 struct mlxsw_sp_acl_tcam_region *region)
649{
650 char pacl_pl[MLXSW_REG_PACL_LEN];
651
652 mlxsw_reg_pacl_pack(pacl_pl, region->id, true,
653 region->tcam_region_info);
654 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pacl), pacl_pl);
655}
656
657static void
658mlxsw_sp_acl_tcam_region_disable(struct mlxsw_sp *mlxsw_sp,
659 struct mlxsw_sp_acl_tcam_region *region)
660{
661 char pacl_pl[MLXSW_REG_PACL_LEN];
662
663 mlxsw_reg_pacl_pack(pacl_pl, region->id, false,
664 region->tcam_region_info);
665 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pacl), pacl_pl);
666}
667
668static struct mlxsw_sp_acl_tcam_region *
669mlxsw_sp_acl_tcam_region_create(struct mlxsw_sp *mlxsw_sp,
670 struct mlxsw_sp_acl_tcam *tcam,
671 struct mlxsw_sp_acl_tcam_vregion *vregion,
672 void *hints_priv)
673{
674 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
675 struct mlxsw_sp_acl_tcam_region *region;
676 int err;
677
678 region = kzalloc(sizeof(*region) + ops->region_priv_size, GFP_KERNEL);
679 if (!region)
680 return ERR_PTR(-ENOMEM);
681 region->mlxsw_sp = mlxsw_sp;
682 region->vregion = vregion;
683 region->key_info = vregion->key_info;
684
685 err = mlxsw_sp_acl_tcam_region_id_get(tcam, ®ion->id);
686 if (err)
687 goto err_region_id_get;
688
689 err = ops->region_associate(mlxsw_sp, region);
690 if (err)
691 goto err_tcam_region_associate;
692
693 region->key_type = ops->key_type;
694 err = mlxsw_sp_acl_tcam_region_alloc(mlxsw_sp, region);
695 if (err)
696 goto err_tcam_region_alloc;
697
698 err = mlxsw_sp_acl_tcam_region_enable(mlxsw_sp, region);
699 if (err)
700 goto err_tcam_region_enable;
701
702 err = ops->region_init(mlxsw_sp, region->priv, tcam->priv,
703 region, hints_priv);
704 if (err)
705 goto err_tcam_region_init;
706
707 return region;
708
709err_tcam_region_init:
710 mlxsw_sp_acl_tcam_region_disable(mlxsw_sp, region);
711err_tcam_region_enable:
712 mlxsw_sp_acl_tcam_region_free(mlxsw_sp, region);
713err_tcam_region_alloc:
714err_tcam_region_associate:
715 mlxsw_sp_acl_tcam_region_id_put(tcam, region->id);
716err_region_id_get:
717 kfree(region);
718 return ERR_PTR(err);
719}
720
721static void
722mlxsw_sp_acl_tcam_region_destroy(struct mlxsw_sp *mlxsw_sp,
723 struct mlxsw_sp_acl_tcam_region *region)
724{
725 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
726
727 ops->region_fini(mlxsw_sp, region->priv);
728 mlxsw_sp_acl_tcam_region_disable(mlxsw_sp, region);
729 mlxsw_sp_acl_tcam_region_free(mlxsw_sp, region);
730 mlxsw_sp_acl_tcam_region_id_put(region->group->tcam,
731 region->id);
732 kfree(region);
733}
734
735static void
736mlxsw_sp_acl_tcam_vregion_rehash_work_schedule(struct mlxsw_sp_acl_tcam_vregion *vregion)
737{
738 unsigned long interval = vregion->tcam->vregion_rehash_intrvl;
739
740 if (!interval)
741 return;
742 mlxsw_core_schedule_dw(&vregion->rehash.dw,
743 msecs_to_jiffies(interval));
744}
745
746static void
747mlxsw_sp_acl_tcam_vregion_rehash(struct mlxsw_sp *mlxsw_sp,
748 struct mlxsw_sp_acl_tcam_vregion *vregion,
749 int *credits);
750
751static void mlxsw_sp_acl_tcam_vregion_rehash_work(struct work_struct *work)
752{
753 struct mlxsw_sp_acl_tcam_vregion *vregion =
754 container_of(work, struct mlxsw_sp_acl_tcam_vregion,
755 rehash.dw.work);
756 int credits = MLXSW_SP_ACL_TCAM_VREGION_REHASH_CREDITS;
757
758 mlxsw_sp_acl_tcam_vregion_rehash(vregion->mlxsw_sp, vregion, &credits);
759 if (credits < 0)
760
761
762
763 mlxsw_core_schedule_dw(&vregion->rehash.dw, 0);
764 else
765 mlxsw_sp_acl_tcam_vregion_rehash_work_schedule(vregion);
766}
767
768static void
769mlxsw_sp_acl_tcam_rehash_ctx_vchunk_changed(struct mlxsw_sp_acl_tcam_vchunk *vchunk)
770{
771 struct mlxsw_sp_acl_tcam_vregion *vregion = vchunk->vregion;
772
773
774
775
776
777 if (vregion->rehash.ctx.current_vchunk == vchunk) {
778 vregion->rehash.ctx.start_ventry = NULL;
779 vregion->rehash.ctx.stop_ventry = NULL;
780 }
781}
782
783static void
784mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(struct mlxsw_sp_acl_tcam_vregion *vregion)
785{
786
787
788
789
790 vregion->rehash.ctx.current_vchunk = NULL;
791}
792
793static struct mlxsw_sp_acl_tcam_vregion *
794mlxsw_sp_acl_tcam_vregion_create(struct mlxsw_sp *mlxsw_sp,
795 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
796 unsigned int priority,
797 struct mlxsw_afk_element_usage *elusage)
798{
799 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
800 struct mlxsw_afk *afk = mlxsw_sp_acl_afk(mlxsw_sp->acl);
801 struct mlxsw_sp_acl_tcam *tcam = vgroup->group.tcam;
802 struct mlxsw_sp_acl_tcam_vregion *vregion;
803 int err;
804
805 vregion = kzalloc(sizeof(*vregion), GFP_KERNEL);
806 if (!vregion)
807 return ERR_PTR(-ENOMEM);
808 INIT_LIST_HEAD(&vregion->vchunk_list);
809 mutex_init(&vregion->lock);
810 vregion->tcam = tcam;
811 vregion->mlxsw_sp = mlxsw_sp;
812 vregion->vgroup = vgroup;
813 vregion->ref_count = 1;
814
815 vregion->key_info = mlxsw_afk_key_info_get(afk, elusage);
816 if (IS_ERR(vregion->key_info)) {
817 err = PTR_ERR(vregion->key_info);
818 goto err_key_info_get;
819 }
820
821 vregion->region = mlxsw_sp_acl_tcam_region_create(mlxsw_sp, tcam,
822 vregion, NULL);
823 if (IS_ERR(vregion->region)) {
824 err = PTR_ERR(vregion->region);
825 goto err_region_create;
826 }
827
828 err = mlxsw_sp_acl_tcam_vgroup_vregion_attach(mlxsw_sp, vgroup, vregion,
829 priority);
830 if (err)
831 goto err_vgroup_vregion_attach;
832
833 if (vgroup->vregion_rehash_enabled && ops->region_rehash_hints_get) {
834
835 INIT_DELAYED_WORK(&vregion->rehash.dw,
836 mlxsw_sp_acl_tcam_vregion_rehash_work);
837 mlxsw_sp_acl_tcam_vregion_rehash_work_schedule(vregion);
838 mutex_lock(&tcam->lock);
839 list_add_tail(&vregion->tlist, &tcam->vregion_list);
840 mutex_unlock(&tcam->lock);
841 }
842
843 return vregion;
844
845err_vgroup_vregion_attach:
846 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, vregion->region);
847err_region_create:
848 mlxsw_afk_key_info_put(vregion->key_info);
849err_key_info_get:
850 kfree(vregion);
851 return ERR_PTR(err);
852}
853
854static void
855mlxsw_sp_acl_tcam_vregion_destroy(struct mlxsw_sp *mlxsw_sp,
856 struct mlxsw_sp_acl_tcam_vregion *vregion)
857{
858 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
859 struct mlxsw_sp_acl_tcam_vgroup *vgroup = vregion->vgroup;
860 struct mlxsw_sp_acl_tcam *tcam = vregion->tcam;
861
862 if (vgroup->vregion_rehash_enabled && ops->region_rehash_hints_get) {
863 mutex_lock(&tcam->lock);
864 list_del(&vregion->tlist);
865 mutex_unlock(&tcam->lock);
866 cancel_delayed_work_sync(&vregion->rehash.dw);
867 }
868 mlxsw_sp_acl_tcam_vgroup_vregion_detach(mlxsw_sp, vregion);
869 if (vregion->region2)
870 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, vregion->region2);
871 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, vregion->region);
872 mlxsw_afk_key_info_put(vregion->key_info);
873 mutex_destroy(&vregion->lock);
874 kfree(vregion);
875}
876
877u32 mlxsw_sp_acl_tcam_vregion_rehash_intrvl_get(struct mlxsw_sp *mlxsw_sp,
878 struct mlxsw_sp_acl_tcam *tcam)
879{
880 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
881 u32 vregion_rehash_intrvl;
882
883 if (WARN_ON(!ops->region_rehash_hints_get))
884 return 0;
885 vregion_rehash_intrvl = tcam->vregion_rehash_intrvl;
886 return vregion_rehash_intrvl;
887}
888
889int mlxsw_sp_acl_tcam_vregion_rehash_intrvl_set(struct mlxsw_sp *mlxsw_sp,
890 struct mlxsw_sp_acl_tcam *tcam,
891 u32 val)
892{
893 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
894 struct mlxsw_sp_acl_tcam_vregion *vregion;
895
896 if (val < MLXSW_SP_ACL_TCAM_VREGION_REHASH_INTRVL_MIN && val)
897 return -EINVAL;
898 if (WARN_ON(!ops->region_rehash_hints_get))
899 return -EOPNOTSUPP;
900 tcam->vregion_rehash_intrvl = val;
901 mutex_lock(&tcam->lock);
902 list_for_each_entry(vregion, &tcam->vregion_list, tlist) {
903 if (val)
904 mlxsw_core_schedule_dw(&vregion->rehash.dw, 0);
905 else
906 cancel_delayed_work_sync(&vregion->rehash.dw);
907 }
908 mutex_unlock(&tcam->lock);
909 return 0;
910}
911
912static struct mlxsw_sp_acl_tcam_vregion *
913mlxsw_sp_acl_tcam_vregion_get(struct mlxsw_sp *mlxsw_sp,
914 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
915 unsigned int priority,
916 struct mlxsw_afk_element_usage *elusage)
917{
918 struct mlxsw_afk_element_usage vregion_elusage;
919 struct mlxsw_sp_acl_tcam_vregion *vregion;
920 bool need_split;
921
922 vregion = mlxsw_sp_acl_tcam_vgroup_vregion_find(vgroup, priority,
923 elusage, &need_split);
924 if (vregion) {
925 if (need_split) {
926
927
928
929
930
931
932
933 return ERR_PTR(-EOPNOTSUPP);
934 }
935 vregion->ref_count++;
936 return vregion;
937 }
938
939 mlxsw_sp_acl_tcam_vgroup_use_patterns(vgroup, elusage,
940 &vregion_elusage);
941
942 return mlxsw_sp_acl_tcam_vregion_create(mlxsw_sp, vgroup, priority,
943 &vregion_elusage);
944}
945
946static void
947mlxsw_sp_acl_tcam_vregion_put(struct mlxsw_sp *mlxsw_sp,
948 struct mlxsw_sp_acl_tcam_vregion *vregion)
949{
950 if (--vregion->ref_count)
951 return;
952 mlxsw_sp_acl_tcam_vregion_destroy(mlxsw_sp, vregion);
953}
954
955static struct mlxsw_sp_acl_tcam_chunk *
956mlxsw_sp_acl_tcam_chunk_create(struct mlxsw_sp *mlxsw_sp,
957 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
958 struct mlxsw_sp_acl_tcam_region *region)
959{
960 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
961 struct mlxsw_sp_acl_tcam_chunk *chunk;
962
963 chunk = kzalloc(sizeof(*chunk) + ops->chunk_priv_size, GFP_KERNEL);
964 if (!chunk)
965 return ERR_PTR(-ENOMEM);
966 chunk->vchunk = vchunk;
967 chunk->region = region;
968
969 ops->chunk_init(region->priv, chunk->priv, vchunk->priority);
970 return chunk;
971}
972
973static void
974mlxsw_sp_acl_tcam_chunk_destroy(struct mlxsw_sp *mlxsw_sp,
975 struct mlxsw_sp_acl_tcam_chunk *chunk)
976{
977 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
978
979 ops->chunk_fini(chunk->priv);
980 kfree(chunk);
981}
982
983static struct mlxsw_sp_acl_tcam_vchunk *
984mlxsw_sp_acl_tcam_vchunk_create(struct mlxsw_sp *mlxsw_sp,
985 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
986 unsigned int priority,
987 struct mlxsw_afk_element_usage *elusage)
988{
989 struct mlxsw_sp_acl_tcam_vregion *vregion;
990 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
991 int err;
992
993 if (priority == MLXSW_SP_ACL_TCAM_CATCHALL_PRIO)
994 return ERR_PTR(-EINVAL);
995
996 vchunk = kzalloc(sizeof(*vchunk), GFP_KERNEL);
997 if (!vchunk)
998 return ERR_PTR(-ENOMEM);
999 INIT_LIST_HEAD(&vchunk->ventry_list);
1000 vchunk->priority = priority;
1001 vchunk->vgroup = vgroup;
1002 vchunk->ref_count = 1;
1003
1004 vregion = mlxsw_sp_acl_tcam_vregion_get(mlxsw_sp, vgroup,
1005 priority, elusage);
1006 if (IS_ERR(vregion)) {
1007 err = PTR_ERR(vregion);
1008 goto err_vregion_get;
1009 }
1010
1011 vchunk->vregion = vregion;
1012
1013 err = rhashtable_insert_fast(&vgroup->vchunk_ht, &vchunk->ht_node,
1014 mlxsw_sp_acl_tcam_vchunk_ht_params);
1015 if (err)
1016 goto err_rhashtable_insert;
1017
1018 mutex_lock(&vregion->lock);
1019 vchunk->chunk = mlxsw_sp_acl_tcam_chunk_create(mlxsw_sp, vchunk,
1020 vchunk->vregion->region);
1021 if (IS_ERR(vchunk->chunk)) {
1022 mutex_unlock(&vregion->lock);
1023 err = PTR_ERR(vchunk->chunk);
1024 goto err_chunk_create;
1025 }
1026
1027 mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(vregion);
1028 list_add_tail(&vchunk->list, &vregion->vchunk_list);
1029 mutex_unlock(&vregion->lock);
1030
1031 return vchunk;
1032
1033err_chunk_create:
1034 rhashtable_remove_fast(&vgroup->vchunk_ht, &vchunk->ht_node,
1035 mlxsw_sp_acl_tcam_vchunk_ht_params);
1036err_rhashtable_insert:
1037 mlxsw_sp_acl_tcam_vregion_put(mlxsw_sp, vregion);
1038err_vregion_get:
1039 kfree(vchunk);
1040 return ERR_PTR(err);
1041}
1042
1043static void
1044mlxsw_sp_acl_tcam_vchunk_destroy(struct mlxsw_sp *mlxsw_sp,
1045 struct mlxsw_sp_acl_tcam_vchunk *vchunk)
1046{
1047 struct mlxsw_sp_acl_tcam_vregion *vregion = vchunk->vregion;
1048 struct mlxsw_sp_acl_tcam_vgroup *vgroup = vchunk->vgroup;
1049
1050 mutex_lock(&vregion->lock);
1051 mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(vregion);
1052 list_del(&vchunk->list);
1053 if (vchunk->chunk2)
1054 mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk2);
1055 mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk);
1056 mutex_unlock(&vregion->lock);
1057 rhashtable_remove_fast(&vgroup->vchunk_ht, &vchunk->ht_node,
1058 mlxsw_sp_acl_tcam_vchunk_ht_params);
1059 mlxsw_sp_acl_tcam_vregion_put(mlxsw_sp, vchunk->vregion);
1060 kfree(vchunk);
1061}
1062
1063static struct mlxsw_sp_acl_tcam_vchunk *
1064mlxsw_sp_acl_tcam_vchunk_get(struct mlxsw_sp *mlxsw_sp,
1065 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
1066 unsigned int priority,
1067 struct mlxsw_afk_element_usage *elusage)
1068{
1069 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1070
1071 vchunk = rhashtable_lookup_fast(&vgroup->vchunk_ht, &priority,
1072 mlxsw_sp_acl_tcam_vchunk_ht_params);
1073 if (vchunk) {
1074 if (WARN_ON(!mlxsw_afk_key_info_subset(vchunk->vregion->key_info,
1075 elusage)))
1076 return ERR_PTR(-EINVAL);
1077 vchunk->ref_count++;
1078 return vchunk;
1079 }
1080 return mlxsw_sp_acl_tcam_vchunk_create(mlxsw_sp, vgroup,
1081 priority, elusage);
1082}
1083
1084static void
1085mlxsw_sp_acl_tcam_vchunk_put(struct mlxsw_sp *mlxsw_sp,
1086 struct mlxsw_sp_acl_tcam_vchunk *vchunk)
1087{
1088 if (--vchunk->ref_count)
1089 return;
1090 mlxsw_sp_acl_tcam_vchunk_destroy(mlxsw_sp, vchunk);
1091}
1092
1093static struct mlxsw_sp_acl_tcam_entry *
1094mlxsw_sp_acl_tcam_entry_create(struct mlxsw_sp *mlxsw_sp,
1095 struct mlxsw_sp_acl_tcam_ventry *ventry,
1096 struct mlxsw_sp_acl_tcam_chunk *chunk)
1097{
1098 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1099 struct mlxsw_sp_acl_tcam_entry *entry;
1100 int err;
1101
1102 entry = kzalloc(sizeof(*entry) + ops->entry_priv_size, GFP_KERNEL);
1103 if (!entry)
1104 return ERR_PTR(-ENOMEM);
1105 entry->ventry = ventry;
1106 entry->chunk = chunk;
1107
1108 err = ops->entry_add(mlxsw_sp, chunk->region->priv, chunk->priv,
1109 entry->priv, ventry->rulei);
1110 if (err)
1111 goto err_entry_add;
1112
1113 return entry;
1114
1115err_entry_add:
1116 kfree(entry);
1117 return ERR_PTR(err);
1118}
1119
1120static void mlxsw_sp_acl_tcam_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1121 struct mlxsw_sp_acl_tcam_entry *entry)
1122{
1123 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1124
1125 ops->entry_del(mlxsw_sp, entry->chunk->region->priv,
1126 entry->chunk->priv, entry->priv);
1127 kfree(entry);
1128}
1129
1130static int
1131mlxsw_sp_acl_tcam_entry_action_replace(struct mlxsw_sp *mlxsw_sp,
1132 struct mlxsw_sp_acl_tcam_region *region,
1133 struct mlxsw_sp_acl_tcam_entry *entry,
1134 struct mlxsw_sp_acl_rule_info *rulei)
1135{
1136 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1137
1138 return ops->entry_action_replace(mlxsw_sp, region->priv,
1139 entry->priv, rulei);
1140}
1141
1142static int
1143mlxsw_sp_acl_tcam_entry_activity_get(struct mlxsw_sp *mlxsw_sp,
1144 struct mlxsw_sp_acl_tcam_entry *entry,
1145 bool *activity)
1146{
1147 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1148
1149 return ops->entry_activity_get(mlxsw_sp, entry->chunk->region->priv,
1150 entry->priv, activity);
1151}
1152
1153static int mlxsw_sp_acl_tcam_ventry_add(struct mlxsw_sp *mlxsw_sp,
1154 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
1155 struct mlxsw_sp_acl_tcam_ventry *ventry,
1156 struct mlxsw_sp_acl_rule_info *rulei)
1157{
1158 struct mlxsw_sp_acl_tcam_vregion *vregion;
1159 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1160 int err;
1161
1162 vchunk = mlxsw_sp_acl_tcam_vchunk_get(mlxsw_sp, vgroup, rulei->priority,
1163 &rulei->values.elusage);
1164 if (IS_ERR(vchunk))
1165 return PTR_ERR(vchunk);
1166
1167 ventry->vchunk = vchunk;
1168 ventry->rulei = rulei;
1169 vregion = vchunk->vregion;
1170
1171 mutex_lock(&vregion->lock);
1172 ventry->entry = mlxsw_sp_acl_tcam_entry_create(mlxsw_sp, ventry,
1173 vchunk->chunk);
1174 if (IS_ERR(ventry->entry)) {
1175 mutex_unlock(&vregion->lock);
1176 err = PTR_ERR(ventry->entry);
1177 goto err_entry_create;
1178 }
1179
1180 list_add_tail(&ventry->list, &vchunk->ventry_list);
1181 mlxsw_sp_acl_tcam_rehash_ctx_vchunk_changed(vchunk);
1182 mutex_unlock(&vregion->lock);
1183
1184 return 0;
1185
1186err_entry_create:
1187 mlxsw_sp_acl_tcam_vchunk_put(mlxsw_sp, vchunk);
1188 return err;
1189}
1190
1191static void mlxsw_sp_acl_tcam_ventry_del(struct mlxsw_sp *mlxsw_sp,
1192 struct mlxsw_sp_acl_tcam_ventry *ventry)
1193{
1194 struct mlxsw_sp_acl_tcam_vchunk *vchunk = ventry->vchunk;
1195 struct mlxsw_sp_acl_tcam_vregion *vregion = vchunk->vregion;
1196
1197 mutex_lock(&vregion->lock);
1198 mlxsw_sp_acl_tcam_rehash_ctx_vchunk_changed(vchunk);
1199 list_del(&ventry->list);
1200 mlxsw_sp_acl_tcam_entry_destroy(mlxsw_sp, ventry->entry);
1201 mutex_unlock(&vregion->lock);
1202 mlxsw_sp_acl_tcam_vchunk_put(mlxsw_sp, vchunk);
1203}
1204
1205static int
1206mlxsw_sp_acl_tcam_ventry_action_replace(struct mlxsw_sp *mlxsw_sp,
1207 struct mlxsw_sp_acl_tcam_ventry *ventry,
1208 struct mlxsw_sp_acl_rule_info *rulei)
1209{
1210 struct mlxsw_sp_acl_tcam_vchunk *vchunk = ventry->vchunk;
1211
1212 return mlxsw_sp_acl_tcam_entry_action_replace(mlxsw_sp,
1213 vchunk->vregion->region,
1214 ventry->entry, rulei);
1215}
1216
1217static int
1218mlxsw_sp_acl_tcam_ventry_activity_get(struct mlxsw_sp *mlxsw_sp,
1219 struct mlxsw_sp_acl_tcam_ventry *ventry,
1220 bool *activity)
1221{
1222 return mlxsw_sp_acl_tcam_entry_activity_get(mlxsw_sp,
1223 ventry->entry, activity);
1224}
1225
1226static int
1227mlxsw_sp_acl_tcam_ventry_migrate(struct mlxsw_sp *mlxsw_sp,
1228 struct mlxsw_sp_acl_tcam_ventry *ventry,
1229 struct mlxsw_sp_acl_tcam_chunk *chunk,
1230 int *credits)
1231{
1232 struct mlxsw_sp_acl_tcam_entry *new_entry;
1233
1234
1235 if (ventry->entry->chunk == chunk)
1236 return 0;
1237
1238 if (--(*credits) < 0)
1239 return 0;
1240
1241 new_entry = mlxsw_sp_acl_tcam_entry_create(mlxsw_sp, ventry, chunk);
1242 if (IS_ERR(new_entry))
1243 return PTR_ERR(new_entry);
1244 mlxsw_sp_acl_tcam_entry_destroy(mlxsw_sp, ventry->entry);
1245 ventry->entry = new_entry;
1246 return 0;
1247}
1248
1249static int
1250mlxsw_sp_acl_tcam_vchunk_migrate_start(struct mlxsw_sp *mlxsw_sp,
1251 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
1252 struct mlxsw_sp_acl_tcam_region *region,
1253 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1254{
1255 struct mlxsw_sp_acl_tcam_chunk *new_chunk;
1256
1257 new_chunk = mlxsw_sp_acl_tcam_chunk_create(mlxsw_sp, vchunk, region);
1258 if (IS_ERR(new_chunk))
1259 return PTR_ERR(new_chunk);
1260 vchunk->chunk2 = vchunk->chunk;
1261 vchunk->chunk = new_chunk;
1262 ctx->current_vchunk = vchunk;
1263 ctx->start_ventry = NULL;
1264 ctx->stop_ventry = NULL;
1265 return 0;
1266}
1267
1268static void
1269mlxsw_sp_acl_tcam_vchunk_migrate_end(struct mlxsw_sp *mlxsw_sp,
1270 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
1271 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1272{
1273 mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk2);
1274 vchunk->chunk2 = NULL;
1275 ctx->current_vchunk = NULL;
1276}
1277
1278static int
1279mlxsw_sp_acl_tcam_vchunk_migrate_one(struct mlxsw_sp *mlxsw_sp,
1280 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
1281 struct mlxsw_sp_acl_tcam_region *region,
1282 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx,
1283 int *credits)
1284{
1285 struct mlxsw_sp_acl_tcam_ventry *ventry;
1286 int err;
1287
1288 if (vchunk->chunk->region != region) {
1289 err = mlxsw_sp_acl_tcam_vchunk_migrate_start(mlxsw_sp, vchunk,
1290 region, ctx);
1291 if (err)
1292 return err;
1293 } else if (!vchunk->chunk2) {
1294
1295 return 0;
1296 }
1297
1298
1299
1300
1301 if (ctx->start_ventry)
1302 ventry = ctx->start_ventry;
1303 else
1304 ventry = list_first_entry(&vchunk->ventry_list,
1305 typeof(*ventry), list);
1306
1307 list_for_each_entry_from(ventry, &vchunk->ventry_list, list) {
1308
1309
1310
1311 if (ventry == ctx->stop_ventry)
1312 break;
1313
1314 err = mlxsw_sp_acl_tcam_ventry_migrate(mlxsw_sp, ventry,
1315 vchunk->chunk, credits);
1316 if (err) {
1317 if (ctx->this_is_rollback) {
1318
1319
1320
1321 ctx->start_ventry = ventry;
1322 return err;
1323 }
1324
1325
1326
1327
1328 swap(vchunk->chunk, vchunk->chunk2);
1329
1330
1331
1332
1333
1334 ctx->start_ventry = NULL;
1335 ctx->stop_ventry = ventry;
1336 return err;
1337 } else if (*credits < 0) {
1338
1339
1340
1341
1342 ctx->start_ventry = ventry;
1343 return 0;
1344 }
1345 }
1346
1347 mlxsw_sp_acl_tcam_vchunk_migrate_end(mlxsw_sp, vchunk, ctx);
1348 return 0;
1349}
1350
1351static int
1352mlxsw_sp_acl_tcam_vchunk_migrate_all(struct mlxsw_sp *mlxsw_sp,
1353 struct mlxsw_sp_acl_tcam_vregion *vregion,
1354 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx,
1355 int *credits)
1356{
1357 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1358 int err;
1359
1360
1361
1362
1363 if (ctx->current_vchunk)
1364 vchunk = ctx->current_vchunk;
1365 else
1366 vchunk = list_first_entry(&vregion->vchunk_list,
1367 typeof(*vchunk), list);
1368
1369 list_for_each_entry_from(vchunk, &vregion->vchunk_list, list) {
1370 err = mlxsw_sp_acl_tcam_vchunk_migrate_one(mlxsw_sp, vchunk,
1371 vregion->region,
1372 ctx, credits);
1373 if (err || *credits < 0)
1374 return err;
1375 }
1376 return 0;
1377}
1378
1379static int
1380mlxsw_sp_acl_tcam_vregion_migrate(struct mlxsw_sp *mlxsw_sp,
1381 struct mlxsw_sp_acl_tcam_vregion *vregion,
1382 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx,
1383 int *credits)
1384{
1385 int err, err2;
1386
1387 trace_mlxsw_sp_acl_tcam_vregion_migrate(mlxsw_sp, vregion);
1388 mutex_lock(&vregion->lock);
1389 err = mlxsw_sp_acl_tcam_vchunk_migrate_all(mlxsw_sp, vregion,
1390 ctx, credits);
1391 if (err) {
1392
1393
1394
1395
1396 swap(vregion->region, vregion->region2);
1397 ctx->current_vchunk = NULL;
1398 ctx->this_is_rollback = true;
1399 err2 = mlxsw_sp_acl_tcam_vchunk_migrate_all(mlxsw_sp, vregion,
1400 ctx, credits);
1401 if (err2) {
1402 trace_mlxsw_sp_acl_tcam_vregion_rehash_rollback_failed(mlxsw_sp,
1403 vregion);
1404 dev_err(mlxsw_sp->bus_info->dev, "Failed to rollback during vregion migration fail\n");
1405
1406 }
1407 }
1408 mutex_unlock(&vregion->lock);
1409 trace_mlxsw_sp_acl_tcam_vregion_migrate_end(mlxsw_sp, vregion);
1410 return err;
1411}
1412
1413static bool
1414mlxsw_sp_acl_tcam_vregion_rehash_in_progress(const struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1415{
1416 return ctx->hints_priv;
1417}
1418
1419static int
1420mlxsw_sp_acl_tcam_vregion_rehash_start(struct mlxsw_sp *mlxsw_sp,
1421 struct mlxsw_sp_acl_tcam_vregion *vregion,
1422 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1423{
1424 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1425 unsigned int priority = mlxsw_sp_acl_tcam_vregion_prio(vregion);
1426 struct mlxsw_sp_acl_tcam_region *new_region;
1427 void *hints_priv;
1428 int err;
1429
1430 trace_mlxsw_sp_acl_tcam_vregion_rehash(mlxsw_sp, vregion);
1431
1432 hints_priv = ops->region_rehash_hints_get(vregion->region->priv);
1433 if (IS_ERR(hints_priv))
1434 return PTR_ERR(hints_priv);
1435
1436 new_region = mlxsw_sp_acl_tcam_region_create(mlxsw_sp, vregion->tcam,
1437 vregion, hints_priv);
1438 if (IS_ERR(new_region)) {
1439 err = PTR_ERR(new_region);
1440 goto err_region_create;
1441 }
1442
1443
1444
1445
1446 vregion->region2 = vregion->region;
1447 vregion->region = new_region;
1448 err = mlxsw_sp_acl_tcam_group_region_attach(mlxsw_sp,
1449 vregion->region2->group,
1450 new_region, priority,
1451 vregion->region2);
1452 if (err)
1453 goto err_group_region_attach;
1454
1455 ctx->hints_priv = hints_priv;
1456 ctx->this_is_rollback = false;
1457
1458 return 0;
1459
1460err_group_region_attach:
1461 vregion->region = vregion->region2;
1462 vregion->region2 = NULL;
1463 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, new_region);
1464err_region_create:
1465 ops->region_rehash_hints_put(hints_priv);
1466 return err;
1467}
1468
1469static void
1470mlxsw_sp_acl_tcam_vregion_rehash_end(struct mlxsw_sp *mlxsw_sp,
1471 struct mlxsw_sp_acl_tcam_vregion *vregion,
1472 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1473{
1474 struct mlxsw_sp_acl_tcam_region *unused_region = vregion->region2;
1475 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1476
1477 vregion->region2 = NULL;
1478 mlxsw_sp_acl_tcam_group_region_detach(mlxsw_sp, unused_region);
1479 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, unused_region);
1480 ops->region_rehash_hints_put(ctx->hints_priv);
1481 ctx->hints_priv = NULL;
1482}
1483
1484static void
1485mlxsw_sp_acl_tcam_vregion_rehash(struct mlxsw_sp *mlxsw_sp,
1486 struct mlxsw_sp_acl_tcam_vregion *vregion,
1487 int *credits)
1488{
1489 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx = &vregion->rehash.ctx;
1490 int err;
1491
1492
1493
1494
1495
1496 if (!mlxsw_sp_acl_tcam_vregion_rehash_in_progress(ctx)) {
1497 err = mlxsw_sp_acl_tcam_vregion_rehash_start(mlxsw_sp,
1498 vregion, ctx);
1499 if (err) {
1500 if (err != -EAGAIN)
1501 dev_err(mlxsw_sp->bus_info->dev, "Failed get rehash hints\n");
1502 return;
1503 }
1504 }
1505
1506 err = mlxsw_sp_acl_tcam_vregion_migrate(mlxsw_sp, vregion,
1507 ctx, credits);
1508 if (err) {
1509 dev_err(mlxsw_sp->bus_info->dev, "Failed to migrate vregion\n");
1510 }
1511
1512 if (*credits >= 0)
1513 mlxsw_sp_acl_tcam_vregion_rehash_end(mlxsw_sp, vregion, ctx);
1514}
1515
1516static const enum mlxsw_afk_element mlxsw_sp_acl_tcam_pattern_ipv4[] = {
1517 MLXSW_AFK_ELEMENT_SRC_SYS_PORT,
1518 MLXSW_AFK_ELEMENT_DMAC_32_47,
1519 MLXSW_AFK_ELEMENT_DMAC_0_31,
1520 MLXSW_AFK_ELEMENT_SMAC_32_47,
1521 MLXSW_AFK_ELEMENT_SMAC_0_31,
1522 MLXSW_AFK_ELEMENT_ETHERTYPE,
1523 MLXSW_AFK_ELEMENT_IP_PROTO,
1524 MLXSW_AFK_ELEMENT_SRC_IP_0_31,
1525 MLXSW_AFK_ELEMENT_DST_IP_0_31,
1526 MLXSW_AFK_ELEMENT_DST_L4_PORT,
1527 MLXSW_AFK_ELEMENT_SRC_L4_PORT,
1528 MLXSW_AFK_ELEMENT_VID,
1529 MLXSW_AFK_ELEMENT_PCP,
1530 MLXSW_AFK_ELEMENT_TCP_FLAGS,
1531 MLXSW_AFK_ELEMENT_IP_TTL_,
1532 MLXSW_AFK_ELEMENT_IP_ECN,
1533 MLXSW_AFK_ELEMENT_IP_DSCP,
1534};
1535
1536static const enum mlxsw_afk_element mlxsw_sp_acl_tcam_pattern_ipv6[] = {
1537 MLXSW_AFK_ELEMENT_ETHERTYPE,
1538 MLXSW_AFK_ELEMENT_IP_PROTO,
1539 MLXSW_AFK_ELEMENT_SRC_IP_96_127,
1540 MLXSW_AFK_ELEMENT_SRC_IP_64_95,
1541 MLXSW_AFK_ELEMENT_SRC_IP_32_63,
1542 MLXSW_AFK_ELEMENT_SRC_IP_0_31,
1543 MLXSW_AFK_ELEMENT_DST_IP_96_127,
1544 MLXSW_AFK_ELEMENT_DST_IP_64_95,
1545 MLXSW_AFK_ELEMENT_DST_IP_32_63,
1546 MLXSW_AFK_ELEMENT_DST_IP_0_31,
1547 MLXSW_AFK_ELEMENT_DST_L4_PORT,
1548 MLXSW_AFK_ELEMENT_SRC_L4_PORT,
1549};
1550
1551static const struct mlxsw_sp_acl_tcam_pattern mlxsw_sp_acl_tcam_patterns[] = {
1552 {
1553 .elements = mlxsw_sp_acl_tcam_pattern_ipv4,
1554 .elements_count = ARRAY_SIZE(mlxsw_sp_acl_tcam_pattern_ipv4),
1555 },
1556 {
1557 .elements = mlxsw_sp_acl_tcam_pattern_ipv6,
1558 .elements_count = ARRAY_SIZE(mlxsw_sp_acl_tcam_pattern_ipv6),
1559 },
1560};
1561
1562#define MLXSW_SP_ACL_TCAM_PATTERNS_COUNT \
1563 ARRAY_SIZE(mlxsw_sp_acl_tcam_patterns)
1564
1565struct mlxsw_sp_acl_tcam_flower_ruleset {
1566 struct mlxsw_sp_acl_tcam_vgroup vgroup;
1567};
1568
1569struct mlxsw_sp_acl_tcam_flower_rule {
1570 struct mlxsw_sp_acl_tcam_ventry ventry;
1571};
1572
1573static int
1574mlxsw_sp_acl_tcam_flower_ruleset_add(struct mlxsw_sp *mlxsw_sp,
1575 struct mlxsw_sp_acl_tcam *tcam,
1576 void *ruleset_priv,
1577 struct mlxsw_afk_element_usage *tmplt_elusage)
1578{
1579 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1580
1581 return mlxsw_sp_acl_tcam_vgroup_add(mlxsw_sp, tcam, &ruleset->vgroup,
1582 mlxsw_sp_acl_tcam_patterns,
1583 MLXSW_SP_ACL_TCAM_PATTERNS_COUNT,
1584 tmplt_elusage, true);
1585}
1586
1587static void
1588mlxsw_sp_acl_tcam_flower_ruleset_del(struct mlxsw_sp *mlxsw_sp,
1589 void *ruleset_priv)
1590{
1591 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1592
1593 mlxsw_sp_acl_tcam_vgroup_del(&ruleset->vgroup);
1594}
1595
1596static int
1597mlxsw_sp_acl_tcam_flower_ruleset_bind(struct mlxsw_sp *mlxsw_sp,
1598 void *ruleset_priv,
1599 struct mlxsw_sp_port *mlxsw_sp_port,
1600 bool ingress)
1601{
1602 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1603
1604 return mlxsw_sp_acl_tcam_group_bind(mlxsw_sp, &ruleset->vgroup.group,
1605 mlxsw_sp_port, ingress);
1606}
1607
1608static void
1609mlxsw_sp_acl_tcam_flower_ruleset_unbind(struct mlxsw_sp *mlxsw_sp,
1610 void *ruleset_priv,
1611 struct mlxsw_sp_port *mlxsw_sp_port,
1612 bool ingress)
1613{
1614 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1615
1616 mlxsw_sp_acl_tcam_group_unbind(mlxsw_sp, &ruleset->vgroup.group,
1617 mlxsw_sp_port, ingress);
1618}
1619
1620static u16
1621mlxsw_sp_acl_tcam_flower_ruleset_group_id(void *ruleset_priv)
1622{
1623 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1624
1625 return mlxsw_sp_acl_tcam_group_id(&ruleset->vgroup.group);
1626}
1627
1628static int
1629mlxsw_sp_acl_tcam_flower_rule_add(struct mlxsw_sp *mlxsw_sp,
1630 void *ruleset_priv, void *rule_priv,
1631 struct mlxsw_sp_acl_rule_info *rulei)
1632{
1633 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1634 struct mlxsw_sp_acl_tcam_flower_rule *rule = rule_priv;
1635
1636 return mlxsw_sp_acl_tcam_ventry_add(mlxsw_sp, &ruleset->vgroup,
1637 &rule->ventry, rulei);
1638}
1639
1640static void
1641mlxsw_sp_acl_tcam_flower_rule_del(struct mlxsw_sp *mlxsw_sp, void *rule_priv)
1642{
1643 struct mlxsw_sp_acl_tcam_flower_rule *rule = rule_priv;
1644
1645 mlxsw_sp_acl_tcam_ventry_del(mlxsw_sp, &rule->ventry);
1646}
1647
1648static int
1649mlxsw_sp_acl_tcam_flower_rule_action_replace(struct mlxsw_sp *mlxsw_sp,
1650 void *rule_priv,
1651 struct mlxsw_sp_acl_rule_info *rulei)
1652{
1653 return -EOPNOTSUPP;
1654}
1655
1656static int
1657mlxsw_sp_acl_tcam_flower_rule_activity_get(struct mlxsw_sp *mlxsw_sp,
1658 void *rule_priv, bool *activity)
1659{
1660 struct mlxsw_sp_acl_tcam_flower_rule *rule = rule_priv;
1661
1662 return mlxsw_sp_acl_tcam_ventry_activity_get(mlxsw_sp, &rule->ventry,
1663 activity);
1664}
1665
1666static const struct mlxsw_sp_acl_profile_ops mlxsw_sp_acl_tcam_flower_ops = {
1667 .ruleset_priv_size = sizeof(struct mlxsw_sp_acl_tcam_flower_ruleset),
1668 .ruleset_add = mlxsw_sp_acl_tcam_flower_ruleset_add,
1669 .ruleset_del = mlxsw_sp_acl_tcam_flower_ruleset_del,
1670 .ruleset_bind = mlxsw_sp_acl_tcam_flower_ruleset_bind,
1671 .ruleset_unbind = mlxsw_sp_acl_tcam_flower_ruleset_unbind,
1672 .ruleset_group_id = mlxsw_sp_acl_tcam_flower_ruleset_group_id,
1673 .rule_priv_size = sizeof(struct mlxsw_sp_acl_tcam_flower_rule),
1674 .rule_add = mlxsw_sp_acl_tcam_flower_rule_add,
1675 .rule_del = mlxsw_sp_acl_tcam_flower_rule_del,
1676 .rule_action_replace = mlxsw_sp_acl_tcam_flower_rule_action_replace,
1677 .rule_activity_get = mlxsw_sp_acl_tcam_flower_rule_activity_get,
1678};
1679
1680struct mlxsw_sp_acl_tcam_mr_ruleset {
1681 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1682 struct mlxsw_sp_acl_tcam_vgroup vgroup;
1683};
1684
1685struct mlxsw_sp_acl_tcam_mr_rule {
1686 struct mlxsw_sp_acl_tcam_ventry ventry;
1687};
1688
1689static int
1690mlxsw_sp_acl_tcam_mr_ruleset_add(struct mlxsw_sp *mlxsw_sp,
1691 struct mlxsw_sp_acl_tcam *tcam,
1692 void *ruleset_priv,
1693 struct mlxsw_afk_element_usage *tmplt_elusage)
1694{
1695 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1696 int err;
1697
1698 err = mlxsw_sp_acl_tcam_vgroup_add(mlxsw_sp, tcam, &ruleset->vgroup,
1699 mlxsw_sp_acl_tcam_patterns,
1700 MLXSW_SP_ACL_TCAM_PATTERNS_COUNT,
1701 tmplt_elusage, false);
1702 if (err)
1703 return err;
1704
1705
1706
1707
1708
1709
1710
1711 ruleset->vchunk = mlxsw_sp_acl_tcam_vchunk_get(mlxsw_sp,
1712 &ruleset->vgroup, 1,
1713 tmplt_elusage);
1714 if (IS_ERR(ruleset->vchunk)) {
1715 err = PTR_ERR(ruleset->vchunk);
1716 goto err_chunk_get;
1717 }
1718
1719 return 0;
1720
1721err_chunk_get:
1722 mlxsw_sp_acl_tcam_vgroup_del(&ruleset->vgroup);
1723 return err;
1724}
1725
1726static void
1727mlxsw_sp_acl_tcam_mr_ruleset_del(struct mlxsw_sp *mlxsw_sp, void *ruleset_priv)
1728{
1729 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1730
1731 mlxsw_sp_acl_tcam_vchunk_put(mlxsw_sp, ruleset->vchunk);
1732 mlxsw_sp_acl_tcam_vgroup_del(&ruleset->vgroup);
1733}
1734
1735static int
1736mlxsw_sp_acl_tcam_mr_ruleset_bind(struct mlxsw_sp *mlxsw_sp, void *ruleset_priv,
1737 struct mlxsw_sp_port *mlxsw_sp_port,
1738 bool ingress)
1739{
1740
1741 return 0;
1742}
1743
1744static void
1745mlxsw_sp_acl_tcam_mr_ruleset_unbind(struct mlxsw_sp *mlxsw_sp,
1746 void *ruleset_priv,
1747 struct mlxsw_sp_port *mlxsw_sp_port,
1748 bool ingress)
1749{
1750}
1751
1752static u16
1753mlxsw_sp_acl_tcam_mr_ruleset_group_id(void *ruleset_priv)
1754{
1755 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1756
1757 return mlxsw_sp_acl_tcam_group_id(&ruleset->vgroup.group);
1758}
1759
1760static int
1761mlxsw_sp_acl_tcam_mr_rule_add(struct mlxsw_sp *mlxsw_sp, void *ruleset_priv,
1762 void *rule_priv,
1763 struct mlxsw_sp_acl_rule_info *rulei)
1764{
1765 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1766 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1767
1768 return mlxsw_sp_acl_tcam_ventry_add(mlxsw_sp, &ruleset->vgroup,
1769 &rule->ventry, rulei);
1770}
1771
1772static void
1773mlxsw_sp_acl_tcam_mr_rule_del(struct mlxsw_sp *mlxsw_sp, void *rule_priv)
1774{
1775 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1776
1777 mlxsw_sp_acl_tcam_ventry_del(mlxsw_sp, &rule->ventry);
1778}
1779
1780static int
1781mlxsw_sp_acl_tcam_mr_rule_action_replace(struct mlxsw_sp *mlxsw_sp,
1782 void *rule_priv,
1783 struct mlxsw_sp_acl_rule_info *rulei)
1784{
1785 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1786
1787 return mlxsw_sp_acl_tcam_ventry_action_replace(mlxsw_sp, &rule->ventry,
1788 rulei);
1789}
1790
1791static int
1792mlxsw_sp_acl_tcam_mr_rule_activity_get(struct mlxsw_sp *mlxsw_sp,
1793 void *rule_priv, bool *activity)
1794{
1795 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1796
1797 return mlxsw_sp_acl_tcam_ventry_activity_get(mlxsw_sp, &rule->ventry,
1798 activity);
1799}
1800
1801static const struct mlxsw_sp_acl_profile_ops mlxsw_sp_acl_tcam_mr_ops = {
1802 .ruleset_priv_size = sizeof(struct mlxsw_sp_acl_tcam_mr_ruleset),
1803 .ruleset_add = mlxsw_sp_acl_tcam_mr_ruleset_add,
1804 .ruleset_del = mlxsw_sp_acl_tcam_mr_ruleset_del,
1805 .ruleset_bind = mlxsw_sp_acl_tcam_mr_ruleset_bind,
1806 .ruleset_unbind = mlxsw_sp_acl_tcam_mr_ruleset_unbind,
1807 .ruleset_group_id = mlxsw_sp_acl_tcam_mr_ruleset_group_id,
1808 .rule_priv_size = sizeof(struct mlxsw_sp_acl_tcam_mr_rule),
1809 .rule_add = mlxsw_sp_acl_tcam_mr_rule_add,
1810 .rule_del = mlxsw_sp_acl_tcam_mr_rule_del,
1811 .rule_action_replace = mlxsw_sp_acl_tcam_mr_rule_action_replace,
1812 .rule_activity_get = mlxsw_sp_acl_tcam_mr_rule_activity_get,
1813};
1814
1815static const struct mlxsw_sp_acl_profile_ops *
1816mlxsw_sp_acl_tcam_profile_ops_arr[] = {
1817 [MLXSW_SP_ACL_PROFILE_FLOWER] = &mlxsw_sp_acl_tcam_flower_ops,
1818 [MLXSW_SP_ACL_PROFILE_MR] = &mlxsw_sp_acl_tcam_mr_ops,
1819};
1820
1821const struct mlxsw_sp_acl_profile_ops *
1822mlxsw_sp_acl_tcam_profile_ops(struct mlxsw_sp *mlxsw_sp,
1823 enum mlxsw_sp_acl_profile profile)
1824{
1825 const struct mlxsw_sp_acl_profile_ops *ops;
1826
1827 if (WARN_ON(profile >= ARRAY_SIZE(mlxsw_sp_acl_tcam_profile_ops_arr)))
1828 return NULL;
1829 ops = mlxsw_sp_acl_tcam_profile_ops_arr[profile];
1830 if (WARN_ON(!ops))
1831 return NULL;
1832 return ops;
1833}
1834