This source file includes following definitions.
- mlxsw_sp_acl_tcam_priv_size
- mlxsw_sp_acl_tcam_init
- mlxsw_sp_acl_tcam_fini
- mlxsw_sp_acl_tcam_priority_get
- mlxsw_sp_acl_tcam_region_id_get
- mlxsw_sp_acl_tcam_region_id_put
- mlxsw_sp_acl_tcam_group_id_get
- mlxsw_sp_acl_tcam_group_id_put
- mlxsw_sp_acl_tcam_group_update
- mlxsw_sp_acl_tcam_group_add
- mlxsw_sp_acl_tcam_group_del
- mlxsw_sp_acl_tcam_vgroup_add
- mlxsw_sp_acl_tcam_vgroup_del
- mlxsw_sp_acl_tcam_group_bind
- mlxsw_sp_acl_tcam_group_unbind
- mlxsw_sp_acl_tcam_group_id
- mlxsw_sp_acl_tcam_vregion_prio
- mlxsw_sp_acl_tcam_vregion_max_prio
- mlxsw_sp_acl_tcam_group_region_attach
- mlxsw_sp_acl_tcam_group_region_detach
- mlxsw_sp_acl_tcam_vgroup_vregion_attach
- mlxsw_sp_acl_tcam_vgroup_vregion_detach
- mlxsw_sp_acl_tcam_vgroup_vregion_find
- mlxsw_sp_acl_tcam_vgroup_use_patterns
- mlxsw_sp_acl_tcam_region_alloc
- mlxsw_sp_acl_tcam_region_free
- mlxsw_sp_acl_tcam_region_enable
- mlxsw_sp_acl_tcam_region_disable
- mlxsw_sp_acl_tcam_region_create
- mlxsw_sp_acl_tcam_region_destroy
- mlxsw_sp_acl_tcam_vregion_rehash_work_schedule
- mlxsw_sp_acl_tcam_vregion_rehash_work
- mlxsw_sp_acl_tcam_rehash_ctx_vchunk_changed
- mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed
- mlxsw_sp_acl_tcam_vregion_create
- mlxsw_sp_acl_tcam_vregion_destroy
- mlxsw_sp_acl_tcam_vregion_rehash_intrvl_get
- mlxsw_sp_acl_tcam_vregion_rehash_intrvl_set
- mlxsw_sp_acl_tcam_vregion_get
- mlxsw_sp_acl_tcam_vregion_put
- mlxsw_sp_acl_tcam_chunk_create
- mlxsw_sp_acl_tcam_chunk_destroy
- mlxsw_sp_acl_tcam_vchunk_create
- mlxsw_sp_acl_tcam_vchunk_destroy
- mlxsw_sp_acl_tcam_vchunk_get
- mlxsw_sp_acl_tcam_vchunk_put
- mlxsw_sp_acl_tcam_entry_create
- mlxsw_sp_acl_tcam_entry_destroy
- mlxsw_sp_acl_tcam_entry_action_replace
- mlxsw_sp_acl_tcam_entry_activity_get
- mlxsw_sp_acl_tcam_ventry_add
- mlxsw_sp_acl_tcam_ventry_del
- mlxsw_sp_acl_tcam_ventry_action_replace
- mlxsw_sp_acl_tcam_ventry_activity_get
- mlxsw_sp_acl_tcam_ventry_migrate
- mlxsw_sp_acl_tcam_vchunk_migrate_start
- mlxsw_sp_acl_tcam_vchunk_migrate_end
- mlxsw_sp_acl_tcam_vchunk_migrate_one
- mlxsw_sp_acl_tcam_vchunk_migrate_all
- mlxsw_sp_acl_tcam_vregion_migrate
- mlxsw_sp_acl_tcam_vregion_rehash_in_progress
- mlxsw_sp_acl_tcam_vregion_rehash_start
- mlxsw_sp_acl_tcam_vregion_rehash_end
- mlxsw_sp_acl_tcam_vregion_rehash
- mlxsw_sp_acl_tcam_flower_ruleset_add
- mlxsw_sp_acl_tcam_flower_ruleset_del
- mlxsw_sp_acl_tcam_flower_ruleset_bind
- mlxsw_sp_acl_tcam_flower_ruleset_unbind
- mlxsw_sp_acl_tcam_flower_ruleset_group_id
- mlxsw_sp_acl_tcam_flower_rule_add
- mlxsw_sp_acl_tcam_flower_rule_del
- mlxsw_sp_acl_tcam_flower_rule_action_replace
- mlxsw_sp_acl_tcam_flower_rule_activity_get
- mlxsw_sp_acl_tcam_mr_ruleset_add
- mlxsw_sp_acl_tcam_mr_ruleset_del
- mlxsw_sp_acl_tcam_mr_ruleset_bind
- mlxsw_sp_acl_tcam_mr_ruleset_unbind
- mlxsw_sp_acl_tcam_mr_ruleset_group_id
- mlxsw_sp_acl_tcam_mr_rule_add
- mlxsw_sp_acl_tcam_mr_rule_del
- mlxsw_sp_acl_tcam_mr_rule_action_replace
- mlxsw_sp_acl_tcam_mr_rule_activity_get
- mlxsw_sp_acl_tcam_profile_ops
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
21 size_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
32 int 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
78 err_tcam_init:
79 kfree(tcam->used_groups);
80 err_alloc_used_groups:
81 kfree(tcam->used_regions);
82 return err;
83 }
84
85 void 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
96 int 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
120 static 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
134 static 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
140 static 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
154 static 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
160 struct mlxsw_sp_acl_tcam_pattern {
161 const enum mlxsw_afk_element *elements;
162 unsigned int elements_count;
163 };
164
165 struct 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
173 struct 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
184 struct 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
202 struct 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
222 struct mlxsw_sp_acl_tcam_vchunk;
223
224 struct 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
231 struct 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
243 struct 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
250 struct 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
257 static 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
264 static 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
286 static int
287 mlxsw_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
303 static 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
312 static int
313 mlxsw_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
345 err_rhashtable_init:
346 mlxsw_sp_acl_tcam_group_del(&vgroup->group);
347 return err;
348 }
349
350 static void
351 mlxsw_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
358 static int
359 mlxsw_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
373 static void
374 mlxsw_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
388 static u16
389 mlxsw_sp_acl_tcam_group_id(struct mlxsw_sp_acl_tcam_group *group)
390 {
391 return group->id;
392 }
393
394 static unsigned int
395 mlxsw_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
407 static unsigned int
408 mlxsw_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
419 static int
420 mlxsw_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
461 err_group_update:
462 list_del(®ion->list);
463 err_region_count_check:
464 mutex_unlock(&group->lock);
465 return err;
466 }
467
468 static void
469 mlxsw_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
481 static int
482 mlxsw_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
507 err_region_attach:
508 list_del(&vregion->list);
509 return err;
510 }
511
512 static void
513 mlxsw_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
523 static struct mlxsw_sp_acl_tcam_vregion *
524 mlxsw_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
579 static void
580 mlxsw_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
606 static int
607 mlxsw_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
634 static void
635 mlxsw_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
646 static int
647 mlxsw_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
657 static void
658 mlxsw_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
668 static struct mlxsw_sp_acl_tcam_region *
669 mlxsw_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
709 err_tcam_region_init:
710 mlxsw_sp_acl_tcam_region_disable(mlxsw_sp, region);
711 err_tcam_region_enable:
712 mlxsw_sp_acl_tcam_region_free(mlxsw_sp, region);
713 err_tcam_region_alloc:
714 err_tcam_region_associate:
715 mlxsw_sp_acl_tcam_region_id_put(tcam, region->id);
716 err_region_id_get:
717 kfree(region);
718 return ERR_PTR(err);
719 }
720
721 static void
722 mlxsw_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
735 static void
736 mlxsw_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
746 static void
747 mlxsw_sp_acl_tcam_vregion_rehash(struct mlxsw_sp *mlxsw_sp,
748 struct mlxsw_sp_acl_tcam_vregion *vregion,
749 int *credits);
750
751 static 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
768 static void
769 mlxsw_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
783 static void
784 mlxsw_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
793 static struct mlxsw_sp_acl_tcam_vregion *
794 mlxsw_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
845 err_vgroup_vregion_attach:
846 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, vregion->region);
847 err_region_create:
848 mlxsw_afk_key_info_put(vregion->key_info);
849 err_key_info_get:
850 kfree(vregion);
851 return ERR_PTR(err);
852 }
853
854 static void
855 mlxsw_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
877 u32 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
889 int 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
912 static struct mlxsw_sp_acl_tcam_vregion *
913 mlxsw_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
946 static void
947 mlxsw_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
955 static struct mlxsw_sp_acl_tcam_chunk *
956 mlxsw_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
973 static void
974 mlxsw_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
983 static struct mlxsw_sp_acl_tcam_vchunk *
984 mlxsw_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_vchunk *vchunk, *vchunk2;
990 struct mlxsw_sp_acl_tcam_vregion *vregion;
991 struct list_head *pos;
992 int err;
993
994 if (priority == MLXSW_SP_ACL_TCAM_CATCHALL_PRIO)
995 return ERR_PTR(-EINVAL);
996
997 vchunk = kzalloc(sizeof(*vchunk), GFP_KERNEL);
998 if (!vchunk)
999 return ERR_PTR(-ENOMEM);
1000 INIT_LIST_HEAD(&vchunk->ventry_list);
1001 vchunk->priority = priority;
1002 vchunk->vgroup = vgroup;
1003 vchunk->ref_count = 1;
1004
1005 vregion = mlxsw_sp_acl_tcam_vregion_get(mlxsw_sp, vgroup,
1006 priority, elusage);
1007 if (IS_ERR(vregion)) {
1008 err = PTR_ERR(vregion);
1009 goto err_vregion_get;
1010 }
1011
1012 vchunk->vregion = vregion;
1013
1014 err = rhashtable_insert_fast(&vgroup->vchunk_ht, &vchunk->ht_node,
1015 mlxsw_sp_acl_tcam_vchunk_ht_params);
1016 if (err)
1017 goto err_rhashtable_insert;
1018
1019 mutex_lock(&vregion->lock);
1020 vchunk->chunk = mlxsw_sp_acl_tcam_chunk_create(mlxsw_sp, vchunk,
1021 vchunk->vregion->region);
1022 if (IS_ERR(vchunk->chunk)) {
1023 mutex_unlock(&vregion->lock);
1024 err = PTR_ERR(vchunk->chunk);
1025 goto err_chunk_create;
1026 }
1027
1028 mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(vregion);
1029
1030
1031 list_for_each(pos, &vregion->vchunk_list) {
1032 vchunk2 = list_entry(pos, typeof(*vchunk2), list);
1033 if (vchunk2->priority > priority)
1034 break;
1035 }
1036 list_add_tail(&vchunk->list, pos);
1037 mutex_unlock(&vregion->lock);
1038
1039 return vchunk;
1040
1041 err_chunk_create:
1042 rhashtable_remove_fast(&vgroup->vchunk_ht, &vchunk->ht_node,
1043 mlxsw_sp_acl_tcam_vchunk_ht_params);
1044 err_rhashtable_insert:
1045 mlxsw_sp_acl_tcam_vregion_put(mlxsw_sp, vregion);
1046 err_vregion_get:
1047 kfree(vchunk);
1048 return ERR_PTR(err);
1049 }
1050
1051 static void
1052 mlxsw_sp_acl_tcam_vchunk_destroy(struct mlxsw_sp *mlxsw_sp,
1053 struct mlxsw_sp_acl_tcam_vchunk *vchunk)
1054 {
1055 struct mlxsw_sp_acl_tcam_vregion *vregion = vchunk->vregion;
1056 struct mlxsw_sp_acl_tcam_vgroup *vgroup = vchunk->vgroup;
1057
1058 mutex_lock(&vregion->lock);
1059 mlxsw_sp_acl_tcam_rehash_ctx_vregion_changed(vregion);
1060 list_del(&vchunk->list);
1061 if (vchunk->chunk2)
1062 mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk2);
1063 mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk);
1064 mutex_unlock(&vregion->lock);
1065 rhashtable_remove_fast(&vgroup->vchunk_ht, &vchunk->ht_node,
1066 mlxsw_sp_acl_tcam_vchunk_ht_params);
1067 mlxsw_sp_acl_tcam_vregion_put(mlxsw_sp, vchunk->vregion);
1068 kfree(vchunk);
1069 }
1070
1071 static struct mlxsw_sp_acl_tcam_vchunk *
1072 mlxsw_sp_acl_tcam_vchunk_get(struct mlxsw_sp *mlxsw_sp,
1073 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
1074 unsigned int priority,
1075 struct mlxsw_afk_element_usage *elusage)
1076 {
1077 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1078
1079 vchunk = rhashtable_lookup_fast(&vgroup->vchunk_ht, &priority,
1080 mlxsw_sp_acl_tcam_vchunk_ht_params);
1081 if (vchunk) {
1082 if (WARN_ON(!mlxsw_afk_key_info_subset(vchunk->vregion->key_info,
1083 elusage)))
1084 return ERR_PTR(-EINVAL);
1085 vchunk->ref_count++;
1086 return vchunk;
1087 }
1088 return mlxsw_sp_acl_tcam_vchunk_create(mlxsw_sp, vgroup,
1089 priority, elusage);
1090 }
1091
1092 static void
1093 mlxsw_sp_acl_tcam_vchunk_put(struct mlxsw_sp *mlxsw_sp,
1094 struct mlxsw_sp_acl_tcam_vchunk *vchunk)
1095 {
1096 if (--vchunk->ref_count)
1097 return;
1098 mlxsw_sp_acl_tcam_vchunk_destroy(mlxsw_sp, vchunk);
1099 }
1100
1101 static struct mlxsw_sp_acl_tcam_entry *
1102 mlxsw_sp_acl_tcam_entry_create(struct mlxsw_sp *mlxsw_sp,
1103 struct mlxsw_sp_acl_tcam_ventry *ventry,
1104 struct mlxsw_sp_acl_tcam_chunk *chunk)
1105 {
1106 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1107 struct mlxsw_sp_acl_tcam_entry *entry;
1108 int err;
1109
1110 entry = kzalloc(sizeof(*entry) + ops->entry_priv_size, GFP_KERNEL);
1111 if (!entry)
1112 return ERR_PTR(-ENOMEM);
1113 entry->ventry = ventry;
1114 entry->chunk = chunk;
1115
1116 err = ops->entry_add(mlxsw_sp, chunk->region->priv, chunk->priv,
1117 entry->priv, ventry->rulei);
1118 if (err)
1119 goto err_entry_add;
1120
1121 return entry;
1122
1123 err_entry_add:
1124 kfree(entry);
1125 return ERR_PTR(err);
1126 }
1127
1128 static void mlxsw_sp_acl_tcam_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1129 struct mlxsw_sp_acl_tcam_entry *entry)
1130 {
1131 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1132
1133 ops->entry_del(mlxsw_sp, entry->chunk->region->priv,
1134 entry->chunk->priv, entry->priv);
1135 kfree(entry);
1136 }
1137
1138 static int
1139 mlxsw_sp_acl_tcam_entry_action_replace(struct mlxsw_sp *mlxsw_sp,
1140 struct mlxsw_sp_acl_tcam_region *region,
1141 struct mlxsw_sp_acl_tcam_entry *entry,
1142 struct mlxsw_sp_acl_rule_info *rulei)
1143 {
1144 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1145
1146 return ops->entry_action_replace(mlxsw_sp, region->priv,
1147 entry->priv, rulei);
1148 }
1149
1150 static int
1151 mlxsw_sp_acl_tcam_entry_activity_get(struct mlxsw_sp *mlxsw_sp,
1152 struct mlxsw_sp_acl_tcam_entry *entry,
1153 bool *activity)
1154 {
1155 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1156
1157 return ops->entry_activity_get(mlxsw_sp, entry->chunk->region->priv,
1158 entry->priv, activity);
1159 }
1160
1161 static int mlxsw_sp_acl_tcam_ventry_add(struct mlxsw_sp *mlxsw_sp,
1162 struct mlxsw_sp_acl_tcam_vgroup *vgroup,
1163 struct mlxsw_sp_acl_tcam_ventry *ventry,
1164 struct mlxsw_sp_acl_rule_info *rulei)
1165 {
1166 struct mlxsw_sp_acl_tcam_vregion *vregion;
1167 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1168 int err;
1169
1170 vchunk = mlxsw_sp_acl_tcam_vchunk_get(mlxsw_sp, vgroup, rulei->priority,
1171 &rulei->values.elusage);
1172 if (IS_ERR(vchunk))
1173 return PTR_ERR(vchunk);
1174
1175 ventry->vchunk = vchunk;
1176 ventry->rulei = rulei;
1177 vregion = vchunk->vregion;
1178
1179 mutex_lock(&vregion->lock);
1180 ventry->entry = mlxsw_sp_acl_tcam_entry_create(mlxsw_sp, ventry,
1181 vchunk->chunk);
1182 if (IS_ERR(ventry->entry)) {
1183 mutex_unlock(&vregion->lock);
1184 err = PTR_ERR(ventry->entry);
1185 goto err_entry_create;
1186 }
1187
1188 list_add_tail(&ventry->list, &vchunk->ventry_list);
1189 mlxsw_sp_acl_tcam_rehash_ctx_vchunk_changed(vchunk);
1190 mutex_unlock(&vregion->lock);
1191
1192 return 0;
1193
1194 err_entry_create:
1195 mlxsw_sp_acl_tcam_vchunk_put(mlxsw_sp, vchunk);
1196 return err;
1197 }
1198
1199 static void mlxsw_sp_acl_tcam_ventry_del(struct mlxsw_sp *mlxsw_sp,
1200 struct mlxsw_sp_acl_tcam_ventry *ventry)
1201 {
1202 struct mlxsw_sp_acl_tcam_vchunk *vchunk = ventry->vchunk;
1203 struct mlxsw_sp_acl_tcam_vregion *vregion = vchunk->vregion;
1204
1205 mutex_lock(&vregion->lock);
1206 mlxsw_sp_acl_tcam_rehash_ctx_vchunk_changed(vchunk);
1207 list_del(&ventry->list);
1208 mlxsw_sp_acl_tcam_entry_destroy(mlxsw_sp, ventry->entry);
1209 mutex_unlock(&vregion->lock);
1210 mlxsw_sp_acl_tcam_vchunk_put(mlxsw_sp, vchunk);
1211 }
1212
1213 static int
1214 mlxsw_sp_acl_tcam_ventry_action_replace(struct mlxsw_sp *mlxsw_sp,
1215 struct mlxsw_sp_acl_tcam_ventry *ventry,
1216 struct mlxsw_sp_acl_rule_info *rulei)
1217 {
1218 struct mlxsw_sp_acl_tcam_vchunk *vchunk = ventry->vchunk;
1219
1220 return mlxsw_sp_acl_tcam_entry_action_replace(mlxsw_sp,
1221 vchunk->vregion->region,
1222 ventry->entry, rulei);
1223 }
1224
1225 static int
1226 mlxsw_sp_acl_tcam_ventry_activity_get(struct mlxsw_sp *mlxsw_sp,
1227 struct mlxsw_sp_acl_tcam_ventry *ventry,
1228 bool *activity)
1229 {
1230 return mlxsw_sp_acl_tcam_entry_activity_get(mlxsw_sp,
1231 ventry->entry, activity);
1232 }
1233
1234 static int
1235 mlxsw_sp_acl_tcam_ventry_migrate(struct mlxsw_sp *mlxsw_sp,
1236 struct mlxsw_sp_acl_tcam_ventry *ventry,
1237 struct mlxsw_sp_acl_tcam_chunk *chunk,
1238 int *credits)
1239 {
1240 struct mlxsw_sp_acl_tcam_entry *new_entry;
1241
1242
1243 if (ventry->entry->chunk == chunk)
1244 return 0;
1245
1246 if (--(*credits) < 0)
1247 return 0;
1248
1249 new_entry = mlxsw_sp_acl_tcam_entry_create(mlxsw_sp, ventry, chunk);
1250 if (IS_ERR(new_entry))
1251 return PTR_ERR(new_entry);
1252 mlxsw_sp_acl_tcam_entry_destroy(mlxsw_sp, ventry->entry);
1253 ventry->entry = new_entry;
1254 return 0;
1255 }
1256
1257 static int
1258 mlxsw_sp_acl_tcam_vchunk_migrate_start(struct mlxsw_sp *mlxsw_sp,
1259 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
1260 struct mlxsw_sp_acl_tcam_region *region,
1261 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1262 {
1263 struct mlxsw_sp_acl_tcam_chunk *new_chunk;
1264
1265 new_chunk = mlxsw_sp_acl_tcam_chunk_create(mlxsw_sp, vchunk, region);
1266 if (IS_ERR(new_chunk))
1267 return PTR_ERR(new_chunk);
1268 vchunk->chunk2 = vchunk->chunk;
1269 vchunk->chunk = new_chunk;
1270 ctx->current_vchunk = vchunk;
1271 ctx->start_ventry = NULL;
1272 ctx->stop_ventry = NULL;
1273 return 0;
1274 }
1275
1276 static void
1277 mlxsw_sp_acl_tcam_vchunk_migrate_end(struct mlxsw_sp *mlxsw_sp,
1278 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
1279 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1280 {
1281 mlxsw_sp_acl_tcam_chunk_destroy(mlxsw_sp, vchunk->chunk2);
1282 vchunk->chunk2 = NULL;
1283 ctx->current_vchunk = NULL;
1284 }
1285
1286 static int
1287 mlxsw_sp_acl_tcam_vchunk_migrate_one(struct mlxsw_sp *mlxsw_sp,
1288 struct mlxsw_sp_acl_tcam_vchunk *vchunk,
1289 struct mlxsw_sp_acl_tcam_region *region,
1290 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx,
1291 int *credits)
1292 {
1293 struct mlxsw_sp_acl_tcam_ventry *ventry;
1294 int err;
1295
1296 if (vchunk->chunk->region != region) {
1297 err = mlxsw_sp_acl_tcam_vchunk_migrate_start(mlxsw_sp, vchunk,
1298 region, ctx);
1299 if (err)
1300 return err;
1301 } else if (!vchunk->chunk2) {
1302
1303 return 0;
1304 }
1305
1306
1307
1308
1309 if (ctx->start_ventry)
1310 ventry = ctx->start_ventry;
1311 else
1312 ventry = list_first_entry(&vchunk->ventry_list,
1313 typeof(*ventry), list);
1314
1315 list_for_each_entry_from(ventry, &vchunk->ventry_list, list) {
1316
1317
1318
1319 if (ventry == ctx->stop_ventry)
1320 break;
1321
1322 err = mlxsw_sp_acl_tcam_ventry_migrate(mlxsw_sp, ventry,
1323 vchunk->chunk, credits);
1324 if (err) {
1325 if (ctx->this_is_rollback) {
1326
1327
1328
1329 ctx->start_ventry = ventry;
1330 return err;
1331 }
1332
1333
1334
1335
1336 swap(vchunk->chunk, vchunk->chunk2);
1337
1338
1339
1340
1341
1342 ctx->start_ventry = NULL;
1343 ctx->stop_ventry = ventry;
1344 return err;
1345 } else if (*credits < 0) {
1346
1347
1348
1349
1350 ctx->start_ventry = ventry;
1351 return 0;
1352 }
1353 }
1354
1355 mlxsw_sp_acl_tcam_vchunk_migrate_end(mlxsw_sp, vchunk, ctx);
1356 return 0;
1357 }
1358
1359 static int
1360 mlxsw_sp_acl_tcam_vchunk_migrate_all(struct mlxsw_sp *mlxsw_sp,
1361 struct mlxsw_sp_acl_tcam_vregion *vregion,
1362 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx,
1363 int *credits)
1364 {
1365 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1366 int err;
1367
1368
1369
1370
1371 if (ctx->current_vchunk)
1372 vchunk = ctx->current_vchunk;
1373 else
1374 vchunk = list_first_entry(&vregion->vchunk_list,
1375 typeof(*vchunk), list);
1376
1377 list_for_each_entry_from(vchunk, &vregion->vchunk_list, list) {
1378 err = mlxsw_sp_acl_tcam_vchunk_migrate_one(mlxsw_sp, vchunk,
1379 vregion->region,
1380 ctx, credits);
1381 if (err || *credits < 0)
1382 return err;
1383 }
1384 return 0;
1385 }
1386
1387 static int
1388 mlxsw_sp_acl_tcam_vregion_migrate(struct mlxsw_sp *mlxsw_sp,
1389 struct mlxsw_sp_acl_tcam_vregion *vregion,
1390 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx,
1391 int *credits)
1392 {
1393 int err, err2;
1394
1395 trace_mlxsw_sp_acl_tcam_vregion_migrate(mlxsw_sp, vregion);
1396 mutex_lock(&vregion->lock);
1397 err = mlxsw_sp_acl_tcam_vchunk_migrate_all(mlxsw_sp, vregion,
1398 ctx, credits);
1399 if (err) {
1400
1401
1402
1403
1404 swap(vregion->region, vregion->region2);
1405 ctx->current_vchunk = NULL;
1406 ctx->this_is_rollback = true;
1407 err2 = mlxsw_sp_acl_tcam_vchunk_migrate_all(mlxsw_sp, vregion,
1408 ctx, credits);
1409 if (err2) {
1410 trace_mlxsw_sp_acl_tcam_vregion_rehash_rollback_failed(mlxsw_sp,
1411 vregion);
1412 dev_err(mlxsw_sp->bus_info->dev, "Failed to rollback during vregion migration fail\n");
1413
1414 }
1415 }
1416 mutex_unlock(&vregion->lock);
1417 trace_mlxsw_sp_acl_tcam_vregion_migrate_end(mlxsw_sp, vregion);
1418 return err;
1419 }
1420
1421 static bool
1422 mlxsw_sp_acl_tcam_vregion_rehash_in_progress(const struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1423 {
1424 return ctx->hints_priv;
1425 }
1426
1427 static int
1428 mlxsw_sp_acl_tcam_vregion_rehash_start(struct mlxsw_sp *mlxsw_sp,
1429 struct mlxsw_sp_acl_tcam_vregion *vregion,
1430 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1431 {
1432 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1433 unsigned int priority = mlxsw_sp_acl_tcam_vregion_prio(vregion);
1434 struct mlxsw_sp_acl_tcam_region *new_region;
1435 void *hints_priv;
1436 int err;
1437
1438 trace_mlxsw_sp_acl_tcam_vregion_rehash(mlxsw_sp, vregion);
1439
1440 hints_priv = ops->region_rehash_hints_get(vregion->region->priv);
1441 if (IS_ERR(hints_priv))
1442 return PTR_ERR(hints_priv);
1443
1444 new_region = mlxsw_sp_acl_tcam_region_create(mlxsw_sp, vregion->tcam,
1445 vregion, hints_priv);
1446 if (IS_ERR(new_region)) {
1447 err = PTR_ERR(new_region);
1448 goto err_region_create;
1449 }
1450
1451
1452
1453
1454 vregion->region2 = vregion->region;
1455 vregion->region = new_region;
1456 err = mlxsw_sp_acl_tcam_group_region_attach(mlxsw_sp,
1457 vregion->region2->group,
1458 new_region, priority,
1459 vregion->region2);
1460 if (err)
1461 goto err_group_region_attach;
1462
1463 ctx->hints_priv = hints_priv;
1464 ctx->this_is_rollback = false;
1465
1466 return 0;
1467
1468 err_group_region_attach:
1469 vregion->region = vregion->region2;
1470 vregion->region2 = NULL;
1471 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, new_region);
1472 err_region_create:
1473 ops->region_rehash_hints_put(hints_priv);
1474 return err;
1475 }
1476
1477 static void
1478 mlxsw_sp_acl_tcam_vregion_rehash_end(struct mlxsw_sp *mlxsw_sp,
1479 struct mlxsw_sp_acl_tcam_vregion *vregion,
1480 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx)
1481 {
1482 struct mlxsw_sp_acl_tcam_region *unused_region = vregion->region2;
1483 const struct mlxsw_sp_acl_tcam_ops *ops = mlxsw_sp->acl_tcam_ops;
1484
1485 vregion->region2 = NULL;
1486 mlxsw_sp_acl_tcam_group_region_detach(mlxsw_sp, unused_region);
1487 mlxsw_sp_acl_tcam_region_destroy(mlxsw_sp, unused_region);
1488 ops->region_rehash_hints_put(ctx->hints_priv);
1489 ctx->hints_priv = NULL;
1490 }
1491
1492 static void
1493 mlxsw_sp_acl_tcam_vregion_rehash(struct mlxsw_sp *mlxsw_sp,
1494 struct mlxsw_sp_acl_tcam_vregion *vregion,
1495 int *credits)
1496 {
1497 struct mlxsw_sp_acl_tcam_rehash_ctx *ctx = &vregion->rehash.ctx;
1498 int err;
1499
1500
1501
1502
1503
1504 if (!mlxsw_sp_acl_tcam_vregion_rehash_in_progress(ctx)) {
1505 err = mlxsw_sp_acl_tcam_vregion_rehash_start(mlxsw_sp,
1506 vregion, ctx);
1507 if (err) {
1508 if (err != -EAGAIN)
1509 dev_err(mlxsw_sp->bus_info->dev, "Failed get rehash hints\n");
1510 return;
1511 }
1512 }
1513
1514 err = mlxsw_sp_acl_tcam_vregion_migrate(mlxsw_sp, vregion,
1515 ctx, credits);
1516 if (err) {
1517 dev_err(mlxsw_sp->bus_info->dev, "Failed to migrate vregion\n");
1518 }
1519
1520 if (*credits >= 0)
1521 mlxsw_sp_acl_tcam_vregion_rehash_end(mlxsw_sp, vregion, ctx);
1522 }
1523
1524 static const enum mlxsw_afk_element mlxsw_sp_acl_tcam_pattern_ipv4[] = {
1525 MLXSW_AFK_ELEMENT_SRC_SYS_PORT,
1526 MLXSW_AFK_ELEMENT_DMAC_32_47,
1527 MLXSW_AFK_ELEMENT_DMAC_0_31,
1528 MLXSW_AFK_ELEMENT_SMAC_32_47,
1529 MLXSW_AFK_ELEMENT_SMAC_0_31,
1530 MLXSW_AFK_ELEMENT_ETHERTYPE,
1531 MLXSW_AFK_ELEMENT_IP_PROTO,
1532 MLXSW_AFK_ELEMENT_SRC_IP_0_31,
1533 MLXSW_AFK_ELEMENT_DST_IP_0_31,
1534 MLXSW_AFK_ELEMENT_DST_L4_PORT,
1535 MLXSW_AFK_ELEMENT_SRC_L4_PORT,
1536 MLXSW_AFK_ELEMENT_VID,
1537 MLXSW_AFK_ELEMENT_PCP,
1538 MLXSW_AFK_ELEMENT_TCP_FLAGS,
1539 MLXSW_AFK_ELEMENT_IP_TTL_,
1540 MLXSW_AFK_ELEMENT_IP_ECN,
1541 MLXSW_AFK_ELEMENT_IP_DSCP,
1542 };
1543
1544 static const enum mlxsw_afk_element mlxsw_sp_acl_tcam_pattern_ipv6[] = {
1545 MLXSW_AFK_ELEMENT_ETHERTYPE,
1546 MLXSW_AFK_ELEMENT_IP_PROTO,
1547 MLXSW_AFK_ELEMENT_SRC_IP_96_127,
1548 MLXSW_AFK_ELEMENT_SRC_IP_64_95,
1549 MLXSW_AFK_ELEMENT_SRC_IP_32_63,
1550 MLXSW_AFK_ELEMENT_SRC_IP_0_31,
1551 MLXSW_AFK_ELEMENT_DST_IP_96_127,
1552 MLXSW_AFK_ELEMENT_DST_IP_64_95,
1553 MLXSW_AFK_ELEMENT_DST_IP_32_63,
1554 MLXSW_AFK_ELEMENT_DST_IP_0_31,
1555 MLXSW_AFK_ELEMENT_DST_L4_PORT,
1556 MLXSW_AFK_ELEMENT_SRC_L4_PORT,
1557 };
1558
1559 static const struct mlxsw_sp_acl_tcam_pattern mlxsw_sp_acl_tcam_patterns[] = {
1560 {
1561 .elements = mlxsw_sp_acl_tcam_pattern_ipv4,
1562 .elements_count = ARRAY_SIZE(mlxsw_sp_acl_tcam_pattern_ipv4),
1563 },
1564 {
1565 .elements = mlxsw_sp_acl_tcam_pattern_ipv6,
1566 .elements_count = ARRAY_SIZE(mlxsw_sp_acl_tcam_pattern_ipv6),
1567 },
1568 };
1569
1570 #define MLXSW_SP_ACL_TCAM_PATTERNS_COUNT \
1571 ARRAY_SIZE(mlxsw_sp_acl_tcam_patterns)
1572
1573 struct mlxsw_sp_acl_tcam_flower_ruleset {
1574 struct mlxsw_sp_acl_tcam_vgroup vgroup;
1575 };
1576
1577 struct mlxsw_sp_acl_tcam_flower_rule {
1578 struct mlxsw_sp_acl_tcam_ventry ventry;
1579 };
1580
1581 static int
1582 mlxsw_sp_acl_tcam_flower_ruleset_add(struct mlxsw_sp *mlxsw_sp,
1583 struct mlxsw_sp_acl_tcam *tcam,
1584 void *ruleset_priv,
1585 struct mlxsw_afk_element_usage *tmplt_elusage)
1586 {
1587 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1588
1589 return mlxsw_sp_acl_tcam_vgroup_add(mlxsw_sp, tcam, &ruleset->vgroup,
1590 mlxsw_sp_acl_tcam_patterns,
1591 MLXSW_SP_ACL_TCAM_PATTERNS_COUNT,
1592 tmplt_elusage, true);
1593 }
1594
1595 static void
1596 mlxsw_sp_acl_tcam_flower_ruleset_del(struct mlxsw_sp *mlxsw_sp,
1597 void *ruleset_priv)
1598 {
1599 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1600
1601 mlxsw_sp_acl_tcam_vgroup_del(&ruleset->vgroup);
1602 }
1603
1604 static int
1605 mlxsw_sp_acl_tcam_flower_ruleset_bind(struct mlxsw_sp *mlxsw_sp,
1606 void *ruleset_priv,
1607 struct mlxsw_sp_port *mlxsw_sp_port,
1608 bool ingress)
1609 {
1610 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1611
1612 return mlxsw_sp_acl_tcam_group_bind(mlxsw_sp, &ruleset->vgroup.group,
1613 mlxsw_sp_port, ingress);
1614 }
1615
1616 static void
1617 mlxsw_sp_acl_tcam_flower_ruleset_unbind(struct mlxsw_sp *mlxsw_sp,
1618 void *ruleset_priv,
1619 struct mlxsw_sp_port *mlxsw_sp_port,
1620 bool ingress)
1621 {
1622 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1623
1624 mlxsw_sp_acl_tcam_group_unbind(mlxsw_sp, &ruleset->vgroup.group,
1625 mlxsw_sp_port, ingress);
1626 }
1627
1628 static u16
1629 mlxsw_sp_acl_tcam_flower_ruleset_group_id(void *ruleset_priv)
1630 {
1631 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1632
1633 return mlxsw_sp_acl_tcam_group_id(&ruleset->vgroup.group);
1634 }
1635
1636 static int
1637 mlxsw_sp_acl_tcam_flower_rule_add(struct mlxsw_sp *mlxsw_sp,
1638 void *ruleset_priv, void *rule_priv,
1639 struct mlxsw_sp_acl_rule_info *rulei)
1640 {
1641 struct mlxsw_sp_acl_tcam_flower_ruleset *ruleset = ruleset_priv;
1642 struct mlxsw_sp_acl_tcam_flower_rule *rule = rule_priv;
1643
1644 return mlxsw_sp_acl_tcam_ventry_add(mlxsw_sp, &ruleset->vgroup,
1645 &rule->ventry, rulei);
1646 }
1647
1648 static void
1649 mlxsw_sp_acl_tcam_flower_rule_del(struct mlxsw_sp *mlxsw_sp, void *rule_priv)
1650 {
1651 struct mlxsw_sp_acl_tcam_flower_rule *rule = rule_priv;
1652
1653 mlxsw_sp_acl_tcam_ventry_del(mlxsw_sp, &rule->ventry);
1654 }
1655
1656 static int
1657 mlxsw_sp_acl_tcam_flower_rule_action_replace(struct mlxsw_sp *mlxsw_sp,
1658 void *rule_priv,
1659 struct mlxsw_sp_acl_rule_info *rulei)
1660 {
1661 return -EOPNOTSUPP;
1662 }
1663
1664 static int
1665 mlxsw_sp_acl_tcam_flower_rule_activity_get(struct mlxsw_sp *mlxsw_sp,
1666 void *rule_priv, bool *activity)
1667 {
1668 struct mlxsw_sp_acl_tcam_flower_rule *rule = rule_priv;
1669
1670 return mlxsw_sp_acl_tcam_ventry_activity_get(mlxsw_sp, &rule->ventry,
1671 activity);
1672 }
1673
1674 static const struct mlxsw_sp_acl_profile_ops mlxsw_sp_acl_tcam_flower_ops = {
1675 .ruleset_priv_size = sizeof(struct mlxsw_sp_acl_tcam_flower_ruleset),
1676 .ruleset_add = mlxsw_sp_acl_tcam_flower_ruleset_add,
1677 .ruleset_del = mlxsw_sp_acl_tcam_flower_ruleset_del,
1678 .ruleset_bind = mlxsw_sp_acl_tcam_flower_ruleset_bind,
1679 .ruleset_unbind = mlxsw_sp_acl_tcam_flower_ruleset_unbind,
1680 .ruleset_group_id = mlxsw_sp_acl_tcam_flower_ruleset_group_id,
1681 .rule_priv_size = sizeof(struct mlxsw_sp_acl_tcam_flower_rule),
1682 .rule_add = mlxsw_sp_acl_tcam_flower_rule_add,
1683 .rule_del = mlxsw_sp_acl_tcam_flower_rule_del,
1684 .rule_action_replace = mlxsw_sp_acl_tcam_flower_rule_action_replace,
1685 .rule_activity_get = mlxsw_sp_acl_tcam_flower_rule_activity_get,
1686 };
1687
1688 struct mlxsw_sp_acl_tcam_mr_ruleset {
1689 struct mlxsw_sp_acl_tcam_vchunk *vchunk;
1690 struct mlxsw_sp_acl_tcam_vgroup vgroup;
1691 };
1692
1693 struct mlxsw_sp_acl_tcam_mr_rule {
1694 struct mlxsw_sp_acl_tcam_ventry ventry;
1695 };
1696
1697 static int
1698 mlxsw_sp_acl_tcam_mr_ruleset_add(struct mlxsw_sp *mlxsw_sp,
1699 struct mlxsw_sp_acl_tcam *tcam,
1700 void *ruleset_priv,
1701 struct mlxsw_afk_element_usage *tmplt_elusage)
1702 {
1703 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1704 int err;
1705
1706 err = mlxsw_sp_acl_tcam_vgroup_add(mlxsw_sp, tcam, &ruleset->vgroup,
1707 mlxsw_sp_acl_tcam_patterns,
1708 MLXSW_SP_ACL_TCAM_PATTERNS_COUNT,
1709 tmplt_elusage, false);
1710 if (err)
1711 return err;
1712
1713
1714
1715
1716
1717
1718
1719 ruleset->vchunk = mlxsw_sp_acl_tcam_vchunk_get(mlxsw_sp,
1720 &ruleset->vgroup, 1,
1721 tmplt_elusage);
1722 if (IS_ERR(ruleset->vchunk)) {
1723 err = PTR_ERR(ruleset->vchunk);
1724 goto err_chunk_get;
1725 }
1726
1727 return 0;
1728
1729 err_chunk_get:
1730 mlxsw_sp_acl_tcam_vgroup_del(&ruleset->vgroup);
1731 return err;
1732 }
1733
1734 static void
1735 mlxsw_sp_acl_tcam_mr_ruleset_del(struct mlxsw_sp *mlxsw_sp, void *ruleset_priv)
1736 {
1737 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1738
1739 mlxsw_sp_acl_tcam_vchunk_put(mlxsw_sp, ruleset->vchunk);
1740 mlxsw_sp_acl_tcam_vgroup_del(&ruleset->vgroup);
1741 }
1742
1743 static int
1744 mlxsw_sp_acl_tcam_mr_ruleset_bind(struct mlxsw_sp *mlxsw_sp, void *ruleset_priv,
1745 struct mlxsw_sp_port *mlxsw_sp_port,
1746 bool ingress)
1747 {
1748
1749 return 0;
1750 }
1751
1752 static void
1753 mlxsw_sp_acl_tcam_mr_ruleset_unbind(struct mlxsw_sp *mlxsw_sp,
1754 void *ruleset_priv,
1755 struct mlxsw_sp_port *mlxsw_sp_port,
1756 bool ingress)
1757 {
1758 }
1759
1760 static u16
1761 mlxsw_sp_acl_tcam_mr_ruleset_group_id(void *ruleset_priv)
1762 {
1763 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1764
1765 return mlxsw_sp_acl_tcam_group_id(&ruleset->vgroup.group);
1766 }
1767
1768 static int
1769 mlxsw_sp_acl_tcam_mr_rule_add(struct mlxsw_sp *mlxsw_sp, void *ruleset_priv,
1770 void *rule_priv,
1771 struct mlxsw_sp_acl_rule_info *rulei)
1772 {
1773 struct mlxsw_sp_acl_tcam_mr_ruleset *ruleset = ruleset_priv;
1774 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1775
1776 return mlxsw_sp_acl_tcam_ventry_add(mlxsw_sp, &ruleset->vgroup,
1777 &rule->ventry, rulei);
1778 }
1779
1780 static void
1781 mlxsw_sp_acl_tcam_mr_rule_del(struct mlxsw_sp *mlxsw_sp, void *rule_priv)
1782 {
1783 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1784
1785 mlxsw_sp_acl_tcam_ventry_del(mlxsw_sp, &rule->ventry);
1786 }
1787
1788 static int
1789 mlxsw_sp_acl_tcam_mr_rule_action_replace(struct mlxsw_sp *mlxsw_sp,
1790 void *rule_priv,
1791 struct mlxsw_sp_acl_rule_info *rulei)
1792 {
1793 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1794
1795 return mlxsw_sp_acl_tcam_ventry_action_replace(mlxsw_sp, &rule->ventry,
1796 rulei);
1797 }
1798
1799 static int
1800 mlxsw_sp_acl_tcam_mr_rule_activity_get(struct mlxsw_sp *mlxsw_sp,
1801 void *rule_priv, bool *activity)
1802 {
1803 struct mlxsw_sp_acl_tcam_mr_rule *rule = rule_priv;
1804
1805 return mlxsw_sp_acl_tcam_ventry_activity_get(mlxsw_sp, &rule->ventry,
1806 activity);
1807 }
1808
1809 static const struct mlxsw_sp_acl_profile_ops mlxsw_sp_acl_tcam_mr_ops = {
1810 .ruleset_priv_size = sizeof(struct mlxsw_sp_acl_tcam_mr_ruleset),
1811 .ruleset_add = mlxsw_sp_acl_tcam_mr_ruleset_add,
1812 .ruleset_del = mlxsw_sp_acl_tcam_mr_ruleset_del,
1813 .ruleset_bind = mlxsw_sp_acl_tcam_mr_ruleset_bind,
1814 .ruleset_unbind = mlxsw_sp_acl_tcam_mr_ruleset_unbind,
1815 .ruleset_group_id = mlxsw_sp_acl_tcam_mr_ruleset_group_id,
1816 .rule_priv_size = sizeof(struct mlxsw_sp_acl_tcam_mr_rule),
1817 .rule_add = mlxsw_sp_acl_tcam_mr_rule_add,
1818 .rule_del = mlxsw_sp_acl_tcam_mr_rule_del,
1819 .rule_action_replace = mlxsw_sp_acl_tcam_mr_rule_action_replace,
1820 .rule_activity_get = mlxsw_sp_acl_tcam_mr_rule_activity_get,
1821 };
1822
1823 static const struct mlxsw_sp_acl_profile_ops *
1824 mlxsw_sp_acl_tcam_profile_ops_arr[] = {
1825 [MLXSW_SP_ACL_PROFILE_FLOWER] = &mlxsw_sp_acl_tcam_flower_ops,
1826 [MLXSW_SP_ACL_PROFILE_MR] = &mlxsw_sp_acl_tcam_mr_ops,
1827 };
1828
1829 const struct mlxsw_sp_acl_profile_ops *
1830 mlxsw_sp_acl_tcam_profile_ops(struct mlxsw_sp *mlxsw_sp,
1831 enum mlxsw_sp_acl_profile profile)
1832 {
1833 const struct mlxsw_sp_acl_profile_ops *ops;
1834
1835 if (WARN_ON(profile >= ARRAY_SIZE(mlxsw_sp_acl_tcam_profile_ops_arr)))
1836 return NULL;
1837 ops = mlxsw_sp_acl_tcam_profile_ops_arr[profile];
1838 if (WARN_ON(!ops))
1839 return NULL;
1840 return ops;
1841 }