1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/* Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved */
3
4#include <linux/kernel.h>
5#include <linux/types.h>
6#include <linux/slab.h>
7#include <linux/errno.h>
8#include <linux/rhashtable.h>
9#include <linux/list.h>
10#include <linux/idr.h>
11#include <linux/refcount.h>
12#include <net/flow_offload.h>
13
14#include "item.h"
15#include "trap.h"
16#include "core_acl_flex_actions.h"
17
18enum mlxsw_afa_set_type {
19 MLXSW_AFA_SET_TYPE_NEXT,
20 MLXSW_AFA_SET_TYPE_GOTO,
21};
22
23/* afa_set_type
24 * Type of the record at the end of the action set.
25 */
26MLXSW_ITEM32(afa, set, type, 0xA0, 28, 4);
27
28/* afa_set_next_action_set_ptr
29 * A pointer to the next action set in the KVD Centralized database.
30 */
31MLXSW_ITEM32(afa, set, next_action_set_ptr, 0xA4, 0, 24);
32
33/* afa_set_goto_g
34 * group - When set, the binding is of an ACL group. When cleared,
35 * the binding is of an ACL.
36 * Must be set to 1 for Spectrum.
37 */
38MLXSW_ITEM32(afa, set, goto_g, 0xA4, 29, 1);
39
40enum mlxsw_afa_set_goto_binding_cmd {
41 /* continue go the next binding point */
42 MLXSW_AFA_SET_GOTO_BINDING_CMD_NONE,
43 /* jump to the next binding point no return */
44 MLXSW_AFA_SET_GOTO_BINDING_CMD_JUMP,
45 /* terminate the acl binding */
46 MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM = 4,
47};
48
49/* afa_set_goto_binding_cmd */
50MLXSW_ITEM32(afa, set, goto_binding_cmd, 0xA4, 24, 3);
51
52/* afa_set_goto_next_binding
53 * ACL/ACL group identifier. If the g bit is set, this field should hold
54 * the acl_group_id, else it should hold the acl_id.
55 */
56MLXSW_ITEM32(afa, set, goto_next_binding, 0xA4, 0, 16);
57
58/* afa_all_action_type
59 * Action Type.
60 */
61MLXSW_ITEM32(afa, all, action_type, 0x00, 24, 6);
62
63struct mlxsw_afa {
64 unsigned int max_acts_per_set;
65 const struct mlxsw_afa_ops *ops;
66 void *ops_priv;
67 struct rhashtable set_ht;
68 struct rhashtable fwd_entry_ht;
69 struct rhashtable cookie_ht;
70 struct rhashtable policer_ht;
71 struct idr cookie_idr;
72 struct list_head policer_list;
73};
74
75#define MLXSW_AFA_SET_LEN 0xA8
76
77struct mlxsw_afa_set_ht_key {
78 char enc_actions[MLXSW_AFA_SET_LEN]; /* Encoded set */
79 bool is_first;
80};
81
82/* Set structure holds one action set record. It contains up to three
83 * actions (depends on size of particular actions). The set is either
84 * put directly to a rule, or it is stored in KVD linear area.
85 * To prevent duplicate entries in KVD linear area, a hashtable is
86 * used to track sets that were previously inserted and may be shared.
87 */
88
89struct mlxsw_afa_set {
90 struct rhash_head ht_node;
91 struct mlxsw_afa_set_ht_key ht_key;
92 u32 kvdl_index;
93 u8 shared:1, /* Inserted in hashtable (doesn't mean that
94 * kvdl_index is valid).
95 */
96 has_trap:1,
97 has_police:1;
98 unsigned int ref_count;
99 struct mlxsw_afa_set *next; /* Pointer to the next set. */
100 struct mlxsw_afa_set *prev; /* Pointer to the previous set,
101 * note that set may have multiple
102 * sets from multiple blocks
103 * pointing at it. This is only
104 * usable until commit.
105 */
106};
107
108static const struct rhashtable_params mlxsw_afa_set_ht_params = {
109 .key_len = sizeof(struct mlxsw_afa_set_ht_key),
110 .key_offset = offsetof(struct mlxsw_afa_set, ht_key),
111 .head_offset = offsetof(struct mlxsw_afa_set, ht_node),
112 .automatic_shrinking = true,
113};
114
115struct mlxsw_afa_fwd_entry_ht_key {
116 u16 local_port;
117};
118
119struct mlxsw_afa_fwd_entry {
120 struct rhash_head ht_node;
121 struct mlxsw_afa_fwd_entry_ht_key ht_key;
122 u32 kvdl_index;
123 unsigned int ref_count;
124};
125
126static const struct rhashtable_params mlxsw_afa_fwd_entry_ht_params = {
127 .key_len = sizeof(struct mlxsw_afa_fwd_entry_ht_key),
128 .key_offset = offsetof(struct mlxsw_afa_fwd_entry, ht_key),
129 .head_offset = offsetof(struct mlxsw_afa_fwd_entry, ht_node),
130 .automatic_shrinking = true,
131};
132
133struct mlxsw_afa_cookie {
134 struct rhash_head ht_node;
135 refcount_t ref_count;
136 struct rcu_head rcu;
137 u32 cookie_index;
138 struct flow_action_cookie fa_cookie;
139};
140
141static u32 mlxsw_afa_cookie_hash(const struct flow_action_cookie *fa_cookie,
142 u32 seed)
143{
144 return jhash2(k: (u32 *) fa_cookie->cookie,
145 length: fa_cookie->cookie_len / sizeof(u32), initval: seed);
146}
147
148static u32 mlxsw_afa_cookie_key_hashfn(const void *data, u32 len, u32 seed)
149{
150 const struct flow_action_cookie *fa_cookie = data;
151
152 return mlxsw_afa_cookie_hash(fa_cookie, seed);
153}
154
155static u32 mlxsw_afa_cookie_obj_hashfn(const void *data, u32 len, u32 seed)
156{
157 const struct mlxsw_afa_cookie *cookie = data;
158
159 return mlxsw_afa_cookie_hash(fa_cookie: &cookie->fa_cookie, seed);
160}
161
162static int mlxsw_afa_cookie_obj_cmpfn(struct rhashtable_compare_arg *arg,
163 const void *obj)
164{
165 const struct flow_action_cookie *fa_cookie = arg->key;
166 const struct mlxsw_afa_cookie *cookie = obj;
167
168 if (cookie->fa_cookie.cookie_len == fa_cookie->cookie_len)
169 return memcmp(p: cookie->fa_cookie.cookie, q: fa_cookie->cookie,
170 size: fa_cookie->cookie_len);
171 return 1;
172}
173
174static const struct rhashtable_params mlxsw_afa_cookie_ht_params = {
175 .head_offset = offsetof(struct mlxsw_afa_cookie, ht_node),
176 .hashfn = mlxsw_afa_cookie_key_hashfn,
177 .obj_hashfn = mlxsw_afa_cookie_obj_hashfn,
178 .obj_cmpfn = mlxsw_afa_cookie_obj_cmpfn,
179 .automatic_shrinking = true,
180};
181
182struct mlxsw_afa_policer {
183 struct rhash_head ht_node;
184 struct list_head list; /* Member of policer_list */
185 refcount_t ref_count;
186 u32 fa_index;
187 u16 policer_index;
188};
189
190static const struct rhashtable_params mlxsw_afa_policer_ht_params = {
191 .key_len = sizeof(u32),
192 .key_offset = offsetof(struct mlxsw_afa_policer, fa_index),
193 .head_offset = offsetof(struct mlxsw_afa_policer, ht_node),
194 .automatic_shrinking = true,
195};
196
197struct mlxsw_afa *mlxsw_afa_create(unsigned int max_acts_per_set,
198 const struct mlxsw_afa_ops *ops,
199 void *ops_priv)
200{
201 struct mlxsw_afa *mlxsw_afa;
202 int err;
203
204 mlxsw_afa = kzalloc(size: sizeof(*mlxsw_afa), GFP_KERNEL);
205 if (!mlxsw_afa)
206 return ERR_PTR(error: -ENOMEM);
207 err = rhashtable_init(ht: &mlxsw_afa->set_ht, params: &mlxsw_afa_set_ht_params);
208 if (err)
209 goto err_set_rhashtable_init;
210 err = rhashtable_init(ht: &mlxsw_afa->fwd_entry_ht,
211 params: &mlxsw_afa_fwd_entry_ht_params);
212 if (err)
213 goto err_fwd_entry_rhashtable_init;
214 err = rhashtable_init(ht: &mlxsw_afa->cookie_ht,
215 params: &mlxsw_afa_cookie_ht_params);
216 if (err)
217 goto err_cookie_rhashtable_init;
218 err = rhashtable_init(ht: &mlxsw_afa->policer_ht,
219 params: &mlxsw_afa_policer_ht_params);
220 if (err)
221 goto err_policer_rhashtable_init;
222 idr_init(idr: &mlxsw_afa->cookie_idr);
223 INIT_LIST_HEAD(list: &mlxsw_afa->policer_list);
224 mlxsw_afa->max_acts_per_set = max_acts_per_set;
225 mlxsw_afa->ops = ops;
226 mlxsw_afa->ops_priv = ops_priv;
227 return mlxsw_afa;
228
229err_policer_rhashtable_init:
230 rhashtable_destroy(ht: &mlxsw_afa->cookie_ht);
231err_cookie_rhashtable_init:
232 rhashtable_destroy(ht: &mlxsw_afa->fwd_entry_ht);
233err_fwd_entry_rhashtable_init:
234 rhashtable_destroy(ht: &mlxsw_afa->set_ht);
235err_set_rhashtable_init:
236 kfree(objp: mlxsw_afa);
237 return ERR_PTR(error: err);
238}
239EXPORT_SYMBOL(mlxsw_afa_create);
240
241void mlxsw_afa_destroy(struct mlxsw_afa *mlxsw_afa)
242{
243 WARN_ON(!list_empty(&mlxsw_afa->policer_list));
244 WARN_ON(!idr_is_empty(&mlxsw_afa->cookie_idr));
245 idr_destroy(&mlxsw_afa->cookie_idr);
246 rhashtable_destroy(ht: &mlxsw_afa->policer_ht);
247 rhashtable_destroy(ht: &mlxsw_afa->cookie_ht);
248 rhashtable_destroy(ht: &mlxsw_afa->fwd_entry_ht);
249 rhashtable_destroy(ht: &mlxsw_afa->set_ht);
250 kfree(objp: mlxsw_afa);
251}
252EXPORT_SYMBOL(mlxsw_afa_destroy);
253
254static void mlxsw_afa_set_goto_set(struct mlxsw_afa_set *set,
255 enum mlxsw_afa_set_goto_binding_cmd cmd,
256 u16 group_id)
257{
258 char *actions = set->ht_key.enc_actions;
259
260 mlxsw_afa_set_type_set(buf: actions, val: MLXSW_AFA_SET_TYPE_GOTO);
261 mlxsw_afa_set_goto_g_set(buf: actions, val: true);
262 mlxsw_afa_set_goto_binding_cmd_set(buf: actions, val: cmd);
263 mlxsw_afa_set_goto_next_binding_set(buf: actions, val: group_id);
264}
265
266static void mlxsw_afa_set_next_set(struct mlxsw_afa_set *set,
267 u32 next_set_kvdl_index)
268{
269 char *actions = set->ht_key.enc_actions;
270
271 mlxsw_afa_set_type_set(buf: actions, val: MLXSW_AFA_SET_TYPE_NEXT);
272 mlxsw_afa_set_next_action_set_ptr_set(buf: actions, val: next_set_kvdl_index);
273}
274
275static struct mlxsw_afa_set *mlxsw_afa_set_create(bool is_first)
276{
277 struct mlxsw_afa_set *set;
278
279 set = kzalloc(size: sizeof(*set), GFP_KERNEL);
280 if (!set)
281 return NULL;
282 /* Need to initialize the set to pass by default */
283 mlxsw_afa_set_goto_set(set, cmd: MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM, group_id: 0);
284 set->ht_key.is_first = is_first;
285 set->ref_count = 1;
286 return set;
287}
288
289static void mlxsw_afa_set_destroy(struct mlxsw_afa_set *set)
290{
291 kfree(objp: set);
292}
293
294static int mlxsw_afa_set_share(struct mlxsw_afa *mlxsw_afa,
295 struct mlxsw_afa_set *set)
296{
297 int err;
298
299 err = rhashtable_insert_fast(ht: &mlxsw_afa->set_ht, obj: &set->ht_node,
300 params: mlxsw_afa_set_ht_params);
301 if (err)
302 return err;
303 err = mlxsw_afa->ops->kvdl_set_add(mlxsw_afa->ops_priv,
304 &set->kvdl_index,
305 set->ht_key.enc_actions,
306 set->ht_key.is_first);
307 if (err)
308 goto err_kvdl_set_add;
309 set->shared = true;
310 set->prev = NULL;
311 return 0;
312
313err_kvdl_set_add:
314 rhashtable_remove_fast(ht: &mlxsw_afa->set_ht, obj: &set->ht_node,
315 params: mlxsw_afa_set_ht_params);
316 return err;
317}
318
319static void mlxsw_afa_set_unshare(struct mlxsw_afa *mlxsw_afa,
320 struct mlxsw_afa_set *set)
321{
322 mlxsw_afa->ops->kvdl_set_del(mlxsw_afa->ops_priv,
323 set->kvdl_index,
324 set->ht_key.is_first);
325 rhashtable_remove_fast(ht: &mlxsw_afa->set_ht, obj: &set->ht_node,
326 params: mlxsw_afa_set_ht_params);
327 set->shared = false;
328}
329
330static void mlxsw_afa_set_put(struct mlxsw_afa *mlxsw_afa,
331 struct mlxsw_afa_set *set)
332{
333 if (--set->ref_count)
334 return;
335 if (set->shared)
336 mlxsw_afa_set_unshare(mlxsw_afa, set);
337 mlxsw_afa_set_destroy(set);
338}
339
340static struct mlxsw_afa_set *mlxsw_afa_set_get(struct mlxsw_afa *mlxsw_afa,
341 struct mlxsw_afa_set *orig_set)
342{
343 struct mlxsw_afa_set *set;
344 int err;
345
346 /* There is a hashtable of sets maintained. If a set with the exact
347 * same encoding exists, we reuse it. Otherwise, the current set
348 * is shared by making it available to others using the hash table.
349 */
350 set = rhashtable_lookup_fast(ht: &mlxsw_afa->set_ht, key: &orig_set->ht_key,
351 params: mlxsw_afa_set_ht_params);
352 if (set) {
353 set->ref_count++;
354 mlxsw_afa_set_put(mlxsw_afa, set: orig_set);
355 } else {
356 set = orig_set;
357 err = mlxsw_afa_set_share(mlxsw_afa, set);
358 if (err)
359 return ERR_PTR(error: err);
360 }
361 return set;
362}
363
364/* Block structure holds a list of action sets. One action block
365 * represents one chain of actions executed upon match of a rule.
366 */
367
368struct mlxsw_afa_block {
369 struct mlxsw_afa *afa;
370 bool finished;
371 struct mlxsw_afa_set *first_set;
372 struct mlxsw_afa_set *cur_set;
373 unsigned int cur_act_index; /* In current set. */
374 struct list_head resource_list; /* List of resources held by actions
375 * in this block.
376 */
377};
378
379struct mlxsw_afa_resource {
380 struct list_head list;
381 void (*destructor)(struct mlxsw_afa_block *block,
382 struct mlxsw_afa_resource *resource);
383};
384
385static void mlxsw_afa_resource_add(struct mlxsw_afa_block *block,
386 struct mlxsw_afa_resource *resource)
387{
388 list_add(new: &resource->list, head: &block->resource_list);
389}
390
391static void mlxsw_afa_resource_del(struct mlxsw_afa_resource *resource)
392{
393 list_del(entry: &resource->list);
394}
395
396static void mlxsw_afa_resources_destroy(struct mlxsw_afa_block *block)
397{
398 struct mlxsw_afa_resource *resource, *tmp;
399
400 list_for_each_entry_safe(resource, tmp, &block->resource_list, list) {
401 resource->destructor(block, resource);
402 }
403}
404
405struct mlxsw_afa_block *mlxsw_afa_block_create(struct mlxsw_afa *mlxsw_afa)
406{
407 struct mlxsw_afa_block *block;
408
409 block = kzalloc(size: sizeof(*block), GFP_KERNEL);
410 if (!block)
411 return ERR_PTR(error: -ENOMEM);
412 INIT_LIST_HEAD(list: &block->resource_list);
413 block->afa = mlxsw_afa;
414
415 /* At least one action set is always present, so just create it here */
416 block->first_set = mlxsw_afa_set_create(is_first: true);
417 if (!block->first_set)
418 goto err_first_set_create;
419
420 /* In case user instructs to have dummy first set, we leave it
421 * empty here and create another, real, set right away.
422 */
423 if (mlxsw_afa->ops->dummy_first_set) {
424 block->cur_set = mlxsw_afa_set_create(is_first: false);
425 if (!block->cur_set)
426 goto err_second_set_create;
427 block->cur_set->prev = block->first_set;
428 block->first_set->next = block->cur_set;
429 } else {
430 block->cur_set = block->first_set;
431 }
432
433 return block;
434
435err_second_set_create:
436 mlxsw_afa_set_destroy(set: block->first_set);
437err_first_set_create:
438 kfree(objp: block);
439 return ERR_PTR(error: -ENOMEM);
440}
441EXPORT_SYMBOL(mlxsw_afa_block_create);
442
443void mlxsw_afa_block_destroy(struct mlxsw_afa_block *block)
444{
445 struct mlxsw_afa_set *set = block->first_set;
446 struct mlxsw_afa_set *next_set;
447
448 do {
449 next_set = set->next;
450 mlxsw_afa_set_put(mlxsw_afa: block->afa, set);
451 set = next_set;
452 } while (set);
453 mlxsw_afa_resources_destroy(block);
454 kfree(objp: block);
455}
456EXPORT_SYMBOL(mlxsw_afa_block_destroy);
457
458int mlxsw_afa_block_commit(struct mlxsw_afa_block *block)
459{
460 struct mlxsw_afa_set *set = block->cur_set;
461 struct mlxsw_afa_set *prev_set;
462
463 block->cur_set = NULL;
464 block->finished = true;
465
466 /* Go over all linked sets starting from last
467 * and try to find existing set in the hash table.
468 * In case it is not there, assign a KVD linear index
469 * and insert it.
470 */
471 do {
472 prev_set = set->prev;
473 set = mlxsw_afa_set_get(mlxsw_afa: block->afa, orig_set: set);
474 if (IS_ERR(ptr: set))
475 /* No rollback is needed since the chain is
476 * in consistent state and mlxsw_afa_block_destroy
477 * will take care of putting it away.
478 */
479 return PTR_ERR(ptr: set);
480 if (prev_set) {
481 prev_set->next = set;
482 mlxsw_afa_set_next_set(set: prev_set, next_set_kvdl_index: set->kvdl_index);
483 set = prev_set;
484 }
485 } while (prev_set);
486
487 block->first_set = set;
488 return 0;
489}
490EXPORT_SYMBOL(mlxsw_afa_block_commit);
491
492char *mlxsw_afa_block_first_set(struct mlxsw_afa_block *block)
493{
494 return block->first_set->ht_key.enc_actions;
495}
496EXPORT_SYMBOL(mlxsw_afa_block_first_set);
497
498char *mlxsw_afa_block_cur_set(struct mlxsw_afa_block *block)
499{
500 return block->cur_set->ht_key.enc_actions;
501}
502EXPORT_SYMBOL(mlxsw_afa_block_cur_set);
503
504u32 mlxsw_afa_block_first_kvdl_index(struct mlxsw_afa_block *block)
505{
506 /* First set is never in KVD linear. So the first set
507 * with valid KVD linear index is always the second one.
508 */
509 if (WARN_ON(!block->first_set->next))
510 return 0;
511 return block->first_set->next->kvdl_index;
512}
513EXPORT_SYMBOL(mlxsw_afa_block_first_kvdl_index);
514
515int mlxsw_afa_block_activity_get(struct mlxsw_afa_block *block, bool *activity)
516{
517 u32 kvdl_index = mlxsw_afa_block_first_kvdl_index(block);
518
519 return block->afa->ops->kvdl_set_activity_get(block->afa->ops_priv,
520 kvdl_index, activity);
521}
522EXPORT_SYMBOL(mlxsw_afa_block_activity_get);
523
524int mlxsw_afa_block_continue(struct mlxsw_afa_block *block)
525{
526 if (block->finished)
527 return -EINVAL;
528 mlxsw_afa_set_goto_set(set: block->cur_set,
529 cmd: MLXSW_AFA_SET_GOTO_BINDING_CMD_NONE, group_id: 0);
530 block->finished = true;
531 return 0;
532}
533EXPORT_SYMBOL(mlxsw_afa_block_continue);
534
535int mlxsw_afa_block_jump(struct mlxsw_afa_block *block, u16 group_id)
536{
537 if (block->finished)
538 return -EINVAL;
539 mlxsw_afa_set_goto_set(set: block->cur_set,
540 cmd: MLXSW_AFA_SET_GOTO_BINDING_CMD_JUMP, group_id);
541 block->finished = true;
542 return 0;
543}
544EXPORT_SYMBOL(mlxsw_afa_block_jump);
545
546int mlxsw_afa_block_terminate(struct mlxsw_afa_block *block)
547{
548 if (block->finished)
549 return -EINVAL;
550 mlxsw_afa_set_goto_set(set: block->cur_set,
551 cmd: MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM, group_id: 0);
552 block->finished = true;
553 return 0;
554}
555EXPORT_SYMBOL(mlxsw_afa_block_terminate);
556
557static struct mlxsw_afa_fwd_entry *
558mlxsw_afa_fwd_entry_create(struct mlxsw_afa *mlxsw_afa, u16 local_port)
559{
560 struct mlxsw_afa_fwd_entry *fwd_entry;
561 int err;
562
563 fwd_entry = kzalloc(size: sizeof(*fwd_entry), GFP_KERNEL);
564 if (!fwd_entry)
565 return ERR_PTR(error: -ENOMEM);
566 fwd_entry->ht_key.local_port = local_port;
567 fwd_entry->ref_count = 1;
568
569 err = rhashtable_insert_fast(ht: &mlxsw_afa->fwd_entry_ht,
570 obj: &fwd_entry->ht_node,
571 params: mlxsw_afa_fwd_entry_ht_params);
572 if (err)
573 goto err_rhashtable_insert;
574
575 err = mlxsw_afa->ops->kvdl_fwd_entry_add(mlxsw_afa->ops_priv,
576 &fwd_entry->kvdl_index,
577 local_port);
578 if (err)
579 goto err_kvdl_fwd_entry_add;
580 return fwd_entry;
581
582err_kvdl_fwd_entry_add:
583 rhashtable_remove_fast(ht: &mlxsw_afa->fwd_entry_ht, obj: &fwd_entry->ht_node,
584 params: mlxsw_afa_fwd_entry_ht_params);
585err_rhashtable_insert:
586 kfree(objp: fwd_entry);
587 return ERR_PTR(error: err);
588}
589
590static void mlxsw_afa_fwd_entry_destroy(struct mlxsw_afa *mlxsw_afa,
591 struct mlxsw_afa_fwd_entry *fwd_entry)
592{
593 mlxsw_afa->ops->kvdl_fwd_entry_del(mlxsw_afa->ops_priv,
594 fwd_entry->kvdl_index);
595 rhashtable_remove_fast(ht: &mlxsw_afa->fwd_entry_ht, obj: &fwd_entry->ht_node,
596 params: mlxsw_afa_fwd_entry_ht_params);
597 kfree(objp: fwd_entry);
598}
599
600static struct mlxsw_afa_fwd_entry *
601mlxsw_afa_fwd_entry_get(struct mlxsw_afa *mlxsw_afa, u16 local_port)
602{
603 struct mlxsw_afa_fwd_entry_ht_key ht_key = {0};
604 struct mlxsw_afa_fwd_entry *fwd_entry;
605
606 ht_key.local_port = local_port;
607 fwd_entry = rhashtable_lookup_fast(ht: &mlxsw_afa->fwd_entry_ht, key: &ht_key,
608 params: mlxsw_afa_fwd_entry_ht_params);
609 if (fwd_entry) {
610 fwd_entry->ref_count++;
611 return fwd_entry;
612 }
613 return mlxsw_afa_fwd_entry_create(mlxsw_afa, local_port);
614}
615
616static void mlxsw_afa_fwd_entry_put(struct mlxsw_afa *mlxsw_afa,
617 struct mlxsw_afa_fwd_entry *fwd_entry)
618{
619 if (--fwd_entry->ref_count)
620 return;
621 mlxsw_afa_fwd_entry_destroy(mlxsw_afa, fwd_entry);
622}
623
624struct mlxsw_afa_fwd_entry_ref {
625 struct mlxsw_afa_resource resource;
626 struct mlxsw_afa_fwd_entry *fwd_entry;
627};
628
629static void
630mlxsw_afa_fwd_entry_ref_destroy(struct mlxsw_afa_block *block,
631 struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref)
632{
633 mlxsw_afa_resource_del(resource: &fwd_entry_ref->resource);
634 mlxsw_afa_fwd_entry_put(mlxsw_afa: block->afa, fwd_entry: fwd_entry_ref->fwd_entry);
635 kfree(objp: fwd_entry_ref);
636}
637
638static void
639mlxsw_afa_fwd_entry_ref_destructor(struct mlxsw_afa_block *block,
640 struct mlxsw_afa_resource *resource)
641{
642 struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref;
643
644 fwd_entry_ref = container_of(resource, struct mlxsw_afa_fwd_entry_ref,
645 resource);
646 mlxsw_afa_fwd_entry_ref_destroy(block, fwd_entry_ref);
647}
648
649static struct mlxsw_afa_fwd_entry_ref *
650mlxsw_afa_fwd_entry_ref_create(struct mlxsw_afa_block *block, u16 local_port)
651{
652 struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref;
653 struct mlxsw_afa_fwd_entry *fwd_entry;
654 int err;
655
656 fwd_entry_ref = kzalloc(size: sizeof(*fwd_entry_ref), GFP_KERNEL);
657 if (!fwd_entry_ref)
658 return ERR_PTR(error: -ENOMEM);
659 fwd_entry = mlxsw_afa_fwd_entry_get(mlxsw_afa: block->afa, local_port);
660 if (IS_ERR(ptr: fwd_entry)) {
661 err = PTR_ERR(ptr: fwd_entry);
662 goto err_fwd_entry_get;
663 }
664 fwd_entry_ref->fwd_entry = fwd_entry;
665 fwd_entry_ref->resource.destructor = mlxsw_afa_fwd_entry_ref_destructor;
666 mlxsw_afa_resource_add(block, resource: &fwd_entry_ref->resource);
667 return fwd_entry_ref;
668
669err_fwd_entry_get:
670 kfree(objp: fwd_entry_ref);
671 return ERR_PTR(error: err);
672}
673
674struct mlxsw_afa_counter {
675 struct mlxsw_afa_resource resource;
676 u32 counter_index;
677};
678
679static void
680mlxsw_afa_counter_destroy(struct mlxsw_afa_block *block,
681 struct mlxsw_afa_counter *counter)
682{
683 mlxsw_afa_resource_del(resource: &counter->resource);
684 block->afa->ops->counter_index_put(block->afa->ops_priv,
685 counter->counter_index);
686 kfree(objp: counter);
687}
688
689static void
690mlxsw_afa_counter_destructor(struct mlxsw_afa_block *block,
691 struct mlxsw_afa_resource *resource)
692{
693 struct mlxsw_afa_counter *counter;
694
695 counter = container_of(resource, struct mlxsw_afa_counter, resource);
696 mlxsw_afa_counter_destroy(block, counter);
697}
698
699static struct mlxsw_afa_counter *
700mlxsw_afa_counter_create(struct mlxsw_afa_block *block)
701{
702 struct mlxsw_afa_counter *counter;
703 int err;
704
705 counter = kzalloc(size: sizeof(*counter), GFP_KERNEL);
706 if (!counter)
707 return ERR_PTR(error: -ENOMEM);
708
709 err = block->afa->ops->counter_index_get(block->afa->ops_priv,
710 &counter->counter_index);
711 if (err)
712 goto err_counter_index_get;
713 counter->resource.destructor = mlxsw_afa_counter_destructor;
714 mlxsw_afa_resource_add(block, resource: &counter->resource);
715 return counter;
716
717err_counter_index_get:
718 kfree(objp: counter);
719 return ERR_PTR(error: err);
720}
721
722/* 20 bits is a maximum that hardware can handle in trap with userdef action
723 * and carry along with the trapped packet.
724 */
725#define MLXSW_AFA_COOKIE_INDEX_BITS 20
726#define MLXSW_AFA_COOKIE_INDEX_MAX ((1 << MLXSW_AFA_COOKIE_INDEX_BITS) - 1)
727
728static struct mlxsw_afa_cookie *
729mlxsw_afa_cookie_create(struct mlxsw_afa *mlxsw_afa,
730 const struct flow_action_cookie *fa_cookie)
731{
732 struct mlxsw_afa_cookie *cookie;
733 u32 cookie_index;
734 int err;
735
736 cookie = kzalloc(size: sizeof(*cookie) + fa_cookie->cookie_len, GFP_KERNEL);
737 if (!cookie)
738 return ERR_PTR(error: -ENOMEM);
739 refcount_set(r: &cookie->ref_count, n: 1);
740 cookie->fa_cookie = *fa_cookie;
741 memcpy(cookie->fa_cookie.cookie, fa_cookie->cookie,
742 fa_cookie->cookie_len);
743
744 err = rhashtable_insert_fast(ht: &mlxsw_afa->cookie_ht, obj: &cookie->ht_node,
745 params: mlxsw_afa_cookie_ht_params);
746 if (err)
747 goto err_rhashtable_insert;
748
749 /* Start cookie indexes with 1. Leave the 0 index unused. Packets
750 * that come from the HW which are not dropped by drop-with-cookie
751 * action are going to pass cookie_index 0 to lookup.
752 */
753 cookie_index = 1;
754 err = idr_alloc_u32(&mlxsw_afa->cookie_idr, ptr: cookie, id: &cookie_index,
755 MLXSW_AFA_COOKIE_INDEX_MAX, GFP_KERNEL);
756 if (err)
757 goto err_idr_alloc;
758 cookie->cookie_index = cookie_index;
759 return cookie;
760
761err_idr_alloc:
762 rhashtable_remove_fast(ht: &mlxsw_afa->cookie_ht, obj: &cookie->ht_node,
763 params: mlxsw_afa_cookie_ht_params);
764err_rhashtable_insert:
765 kfree(objp: cookie);
766 return ERR_PTR(error: err);
767}
768
769static void mlxsw_afa_cookie_destroy(struct mlxsw_afa *mlxsw_afa,
770 struct mlxsw_afa_cookie *cookie)
771{
772 idr_remove(&mlxsw_afa->cookie_idr, id: cookie->cookie_index);
773 rhashtable_remove_fast(ht: &mlxsw_afa->cookie_ht, obj: &cookie->ht_node,
774 params: mlxsw_afa_cookie_ht_params);
775 kfree_rcu(cookie, rcu);
776}
777
778static struct mlxsw_afa_cookie *
779mlxsw_afa_cookie_get(struct mlxsw_afa *mlxsw_afa,
780 const struct flow_action_cookie *fa_cookie)
781{
782 struct mlxsw_afa_cookie *cookie;
783
784 cookie = rhashtable_lookup_fast(ht: &mlxsw_afa->cookie_ht, key: fa_cookie,
785 params: mlxsw_afa_cookie_ht_params);
786 if (cookie) {
787 refcount_inc(r: &cookie->ref_count);
788 return cookie;
789 }
790 return mlxsw_afa_cookie_create(mlxsw_afa, fa_cookie);
791}
792
793static void mlxsw_afa_cookie_put(struct mlxsw_afa *mlxsw_afa,
794 struct mlxsw_afa_cookie *cookie)
795{
796 if (!refcount_dec_and_test(r: &cookie->ref_count))
797 return;
798 mlxsw_afa_cookie_destroy(mlxsw_afa, cookie);
799}
800
801/* RCU read lock must be held */
802const struct flow_action_cookie *
803mlxsw_afa_cookie_lookup(struct mlxsw_afa *mlxsw_afa, u32 cookie_index)
804{
805 struct mlxsw_afa_cookie *cookie;
806
807 /* 0 index means no cookie */
808 if (!cookie_index)
809 return NULL;
810 cookie = idr_find(&mlxsw_afa->cookie_idr, id: cookie_index);
811 if (!cookie)
812 return NULL;
813 return &cookie->fa_cookie;
814}
815EXPORT_SYMBOL(mlxsw_afa_cookie_lookup);
816
817struct mlxsw_afa_cookie_ref {
818 struct mlxsw_afa_resource resource;
819 struct mlxsw_afa_cookie *cookie;
820};
821
822static void
823mlxsw_afa_cookie_ref_destroy(struct mlxsw_afa_block *block,
824 struct mlxsw_afa_cookie_ref *cookie_ref)
825{
826 mlxsw_afa_resource_del(resource: &cookie_ref->resource);
827 mlxsw_afa_cookie_put(mlxsw_afa: block->afa, cookie: cookie_ref->cookie);
828 kfree(objp: cookie_ref);
829}
830
831static void
832mlxsw_afa_cookie_ref_destructor(struct mlxsw_afa_block *block,
833 struct mlxsw_afa_resource *resource)
834{
835 struct mlxsw_afa_cookie_ref *cookie_ref;
836
837 cookie_ref = container_of(resource, struct mlxsw_afa_cookie_ref,
838 resource);
839 mlxsw_afa_cookie_ref_destroy(block, cookie_ref);
840}
841
842static struct mlxsw_afa_cookie_ref *
843mlxsw_afa_cookie_ref_create(struct mlxsw_afa_block *block,
844 const struct flow_action_cookie *fa_cookie)
845{
846 struct mlxsw_afa_cookie_ref *cookie_ref;
847 struct mlxsw_afa_cookie *cookie;
848 int err;
849
850 cookie_ref = kzalloc(size: sizeof(*cookie_ref), GFP_KERNEL);
851 if (!cookie_ref)
852 return ERR_PTR(error: -ENOMEM);
853 cookie = mlxsw_afa_cookie_get(mlxsw_afa: block->afa, fa_cookie);
854 if (IS_ERR(ptr: cookie)) {
855 err = PTR_ERR(ptr: cookie);
856 goto err_cookie_get;
857 }
858 cookie_ref->cookie = cookie;
859 cookie_ref->resource.destructor = mlxsw_afa_cookie_ref_destructor;
860 mlxsw_afa_resource_add(block, resource: &cookie_ref->resource);
861 return cookie_ref;
862
863err_cookie_get:
864 kfree(objp: cookie_ref);
865 return ERR_PTR(error: err);
866}
867
868static struct mlxsw_afa_policer *
869mlxsw_afa_policer_create(struct mlxsw_afa *mlxsw_afa, u32 fa_index,
870 u64 rate_bytes_ps, u32 burst,
871 struct netlink_ext_ack *extack)
872{
873 struct mlxsw_afa_policer *policer;
874 int err;
875
876 policer = kzalloc(size: sizeof(*policer), GFP_KERNEL);
877 if (!policer)
878 return ERR_PTR(error: -ENOMEM);
879
880 err = mlxsw_afa->ops->policer_add(mlxsw_afa->ops_priv, rate_bytes_ps,
881 burst, &policer->policer_index,
882 extack);
883 if (err)
884 goto err_policer_add;
885
886 refcount_set(r: &policer->ref_count, n: 1);
887 policer->fa_index = fa_index;
888
889 err = rhashtable_insert_fast(ht: &mlxsw_afa->policer_ht, obj: &policer->ht_node,
890 params: mlxsw_afa_policer_ht_params);
891 if (err)
892 goto err_rhashtable_insert;
893
894 list_add_tail(new: &policer->list, head: &mlxsw_afa->policer_list);
895
896 return policer;
897
898err_rhashtable_insert:
899 mlxsw_afa->ops->policer_del(mlxsw_afa->ops_priv,
900 policer->policer_index);
901err_policer_add:
902 kfree(objp: policer);
903 return ERR_PTR(error: err);
904}
905
906static void mlxsw_afa_policer_destroy(struct mlxsw_afa *mlxsw_afa,
907 struct mlxsw_afa_policer *policer)
908{
909 list_del(entry: &policer->list);
910 rhashtable_remove_fast(ht: &mlxsw_afa->policer_ht, obj: &policer->ht_node,
911 params: mlxsw_afa_policer_ht_params);
912 mlxsw_afa->ops->policer_del(mlxsw_afa->ops_priv,
913 policer->policer_index);
914 kfree(objp: policer);
915}
916
917static struct mlxsw_afa_policer *
918mlxsw_afa_policer_get(struct mlxsw_afa *mlxsw_afa, u32 fa_index,
919 u64 rate_bytes_ps, u32 burst,
920 struct netlink_ext_ack *extack)
921{
922 struct mlxsw_afa_policer *policer;
923
924 policer = rhashtable_lookup_fast(ht: &mlxsw_afa->policer_ht, key: &fa_index,
925 params: mlxsw_afa_policer_ht_params);
926 if (policer) {
927 refcount_inc(r: &policer->ref_count);
928 return policer;
929 }
930
931 return mlxsw_afa_policer_create(mlxsw_afa, fa_index, rate_bytes_ps,
932 burst, extack);
933}
934
935static void mlxsw_afa_policer_put(struct mlxsw_afa *mlxsw_afa,
936 struct mlxsw_afa_policer *policer)
937{
938 if (!refcount_dec_and_test(r: &policer->ref_count))
939 return;
940 mlxsw_afa_policer_destroy(mlxsw_afa, policer);
941}
942
943struct mlxsw_afa_policer_ref {
944 struct mlxsw_afa_resource resource;
945 struct mlxsw_afa_policer *policer;
946};
947
948static void
949mlxsw_afa_policer_ref_destroy(struct mlxsw_afa_block *block,
950 struct mlxsw_afa_policer_ref *policer_ref)
951{
952 mlxsw_afa_resource_del(resource: &policer_ref->resource);
953 mlxsw_afa_policer_put(mlxsw_afa: block->afa, policer: policer_ref->policer);
954 kfree(objp: policer_ref);
955}
956
957static void
958mlxsw_afa_policer_ref_destructor(struct mlxsw_afa_block *block,
959 struct mlxsw_afa_resource *resource)
960{
961 struct mlxsw_afa_policer_ref *policer_ref;
962
963 policer_ref = container_of(resource, struct mlxsw_afa_policer_ref,
964 resource);
965 mlxsw_afa_policer_ref_destroy(block, policer_ref);
966}
967
968static struct mlxsw_afa_policer_ref *
969mlxsw_afa_policer_ref_create(struct mlxsw_afa_block *block, u32 fa_index,
970 u64 rate_bytes_ps, u32 burst,
971 struct netlink_ext_ack *extack)
972{
973 struct mlxsw_afa_policer_ref *policer_ref;
974 struct mlxsw_afa_policer *policer;
975 int err;
976
977 policer_ref = kzalloc(size: sizeof(*policer_ref), GFP_KERNEL);
978 if (!policer_ref)
979 return ERR_PTR(error: -ENOMEM);
980
981 policer = mlxsw_afa_policer_get(mlxsw_afa: block->afa, fa_index, rate_bytes_ps,
982 burst, extack);
983 if (IS_ERR(ptr: policer)) {
984 err = PTR_ERR(ptr: policer);
985 goto err_policer_get;
986 }
987
988 policer_ref->policer = policer;
989 policer_ref->resource.destructor = mlxsw_afa_policer_ref_destructor;
990 mlxsw_afa_resource_add(block, resource: &policer_ref->resource);
991
992 return policer_ref;
993
994err_policer_get:
995 kfree(objp: policer_ref);
996 return ERR_PTR(error: err);
997}
998
999#define MLXSW_AFA_ONE_ACTION_LEN 32
1000#define MLXSW_AFA_PAYLOAD_OFFSET 4
1001
1002enum mlxsw_afa_action_type {
1003 MLXSW_AFA_ACTION_TYPE_TRAP,
1004 MLXSW_AFA_ACTION_TYPE_POLICE,
1005 MLXSW_AFA_ACTION_TYPE_OTHER,
1006};
1007
1008static bool
1009mlxsw_afa_block_need_split(const struct mlxsw_afa_block *block,
1010 enum mlxsw_afa_action_type type)
1011{
1012 struct mlxsw_afa_set *cur_set = block->cur_set;
1013
1014 /* Due to a hardware limitation, police action cannot be in the same
1015 * action set with MLXSW_AFA_TRAP_CODE or MLXSW_AFA_TRAPWU_CODE
1016 * actions. Work around this limitation by creating a new action set
1017 * and place the new action there.
1018 */
1019 return (cur_set->has_trap && type == MLXSW_AFA_ACTION_TYPE_POLICE) ||
1020 (cur_set->has_police && type == MLXSW_AFA_ACTION_TYPE_TRAP);
1021}
1022
1023static char *mlxsw_afa_block_append_action_ext(struct mlxsw_afa_block *block,
1024 u8 action_code, u8 action_size,
1025 enum mlxsw_afa_action_type type)
1026{
1027 char *oneact;
1028 char *actions;
1029
1030 if (block->finished)
1031 return ERR_PTR(error: -EINVAL);
1032 if (block->cur_act_index + action_size > block->afa->max_acts_per_set ||
1033 mlxsw_afa_block_need_split(block, type)) {
1034 struct mlxsw_afa_set *set;
1035
1036 /* The appended action won't fit into the current action set,
1037 * so create a new set.
1038 */
1039 set = mlxsw_afa_set_create(is_first: false);
1040 if (!set)
1041 return ERR_PTR(error: -ENOBUFS);
1042 set->prev = block->cur_set;
1043 block->cur_act_index = 0;
1044 block->cur_set->next = set;
1045 block->cur_set = set;
1046 }
1047
1048 switch (type) {
1049 case MLXSW_AFA_ACTION_TYPE_TRAP:
1050 block->cur_set->has_trap = true;
1051 break;
1052 case MLXSW_AFA_ACTION_TYPE_POLICE:
1053 block->cur_set->has_police = true;
1054 break;
1055 default:
1056 break;
1057 }
1058
1059 actions = block->cur_set->ht_key.enc_actions;
1060 oneact = actions + block->cur_act_index * MLXSW_AFA_ONE_ACTION_LEN;
1061 block->cur_act_index += action_size;
1062 mlxsw_afa_all_action_type_set(buf: oneact, val: action_code);
1063 return oneact + MLXSW_AFA_PAYLOAD_OFFSET;
1064}
1065
1066static char *mlxsw_afa_block_append_action(struct mlxsw_afa_block *block,
1067 u8 action_code, u8 action_size)
1068{
1069 return mlxsw_afa_block_append_action_ext(block, action_code,
1070 action_size,
1071 type: MLXSW_AFA_ACTION_TYPE_OTHER);
1072}
1073
1074/* VLAN Action
1075 * -----------
1076 * VLAN action is used for manipulating VLANs. It can be used to implement QinQ,
1077 * VLAN translation, change of PCP bits of the VLAN tag, push, pop as swap VLANs
1078 * and more.
1079 */
1080
1081#define MLXSW_AFA_VLAN_CODE 0x02
1082#define MLXSW_AFA_VLAN_SIZE 1
1083
1084enum mlxsw_afa_vlan_vlan_tag_cmd {
1085 MLXSW_AFA_VLAN_VLAN_TAG_CMD_NOP,
1086 MLXSW_AFA_VLAN_VLAN_TAG_CMD_PUSH_TAG,
1087 MLXSW_AFA_VLAN_VLAN_TAG_CMD_POP_TAG,
1088};
1089
1090enum mlxsw_afa_vlan_cmd {
1091 MLXSW_AFA_VLAN_CMD_NOP,
1092 MLXSW_AFA_VLAN_CMD_SET_OUTER,
1093 MLXSW_AFA_VLAN_CMD_SET_INNER,
1094 MLXSW_AFA_VLAN_CMD_COPY_OUTER_TO_INNER,
1095 MLXSW_AFA_VLAN_CMD_COPY_INNER_TO_OUTER,
1096 MLXSW_AFA_VLAN_CMD_SWAP,
1097};
1098
1099/* afa_vlan_vlan_tag_cmd
1100 * Tag command: push, pop, nop VLAN header.
1101 */
1102MLXSW_ITEM32(afa, vlan, vlan_tag_cmd, 0x00, 29, 3);
1103
1104/* afa_vlan_vid_cmd */
1105MLXSW_ITEM32(afa, vlan, vid_cmd, 0x04, 29, 3);
1106
1107/* afa_vlan_vid */
1108MLXSW_ITEM32(afa, vlan, vid, 0x04, 0, 12);
1109
1110/* afa_vlan_ethertype_cmd */
1111MLXSW_ITEM32(afa, vlan, ethertype_cmd, 0x08, 29, 3);
1112
1113/* afa_vlan_ethertype
1114 * Index to EtherTypes in Switch VLAN EtherType Register (SVER).
1115 */
1116MLXSW_ITEM32(afa, vlan, ethertype, 0x08, 24, 3);
1117
1118/* afa_vlan_pcp_cmd */
1119MLXSW_ITEM32(afa, vlan, pcp_cmd, 0x08, 13, 3);
1120
1121/* afa_vlan_pcp */
1122MLXSW_ITEM32(afa, vlan, pcp, 0x08, 8, 3);
1123
1124static inline void
1125mlxsw_afa_vlan_pack(char *payload,
1126 enum mlxsw_afa_vlan_vlan_tag_cmd vlan_tag_cmd,
1127 enum mlxsw_afa_vlan_cmd vid_cmd, u16 vid,
1128 enum mlxsw_afa_vlan_cmd pcp_cmd, u8 pcp,
1129 enum mlxsw_afa_vlan_cmd ethertype_cmd, u8 ethertype)
1130{
1131 mlxsw_afa_vlan_vlan_tag_cmd_set(buf: payload, val: vlan_tag_cmd);
1132 mlxsw_afa_vlan_vid_cmd_set(buf: payload, val: vid_cmd);
1133 mlxsw_afa_vlan_vid_set(buf: payload, val: vid);
1134 mlxsw_afa_vlan_pcp_cmd_set(buf: payload, val: pcp_cmd);
1135 mlxsw_afa_vlan_pcp_set(buf: payload, val: pcp);
1136 mlxsw_afa_vlan_ethertype_cmd_set(buf: payload, val: ethertype_cmd);
1137 mlxsw_afa_vlan_ethertype_set(buf: payload, val: ethertype);
1138}
1139
1140int mlxsw_afa_block_append_vlan_modify(struct mlxsw_afa_block *block,
1141 u16 vid, u8 pcp, u8 et,
1142 struct netlink_ext_ack *extack)
1143{
1144 char *act = mlxsw_afa_block_append_action(block,
1145 MLXSW_AFA_VLAN_CODE,
1146 MLXSW_AFA_VLAN_SIZE);
1147
1148 if (IS_ERR(ptr: act)) {
1149 NL_SET_ERR_MSG_MOD(extack, "Cannot append vlan_modify action");
1150 return PTR_ERR(ptr: act);
1151 }
1152 mlxsw_afa_vlan_pack(payload: act, vlan_tag_cmd: MLXSW_AFA_VLAN_VLAN_TAG_CMD_NOP,
1153 vid_cmd: MLXSW_AFA_VLAN_CMD_SET_OUTER, vid,
1154 pcp_cmd: MLXSW_AFA_VLAN_CMD_SET_OUTER, pcp,
1155 ethertype_cmd: MLXSW_AFA_VLAN_CMD_SET_OUTER, ethertype: et);
1156 return 0;
1157}
1158EXPORT_SYMBOL(mlxsw_afa_block_append_vlan_modify);
1159
1160/* Trap Action / Trap With Userdef Action
1161 * --------------------------------------
1162 * The Trap action enables trapping / mirroring packets to the CPU
1163 * as well as discarding packets.
1164 * The ACL Trap / Discard separates the forward/discard control from CPU
1165 * trap control. In addition, the Trap / Discard action enables activating
1166 * SPAN (port mirroring).
1167 *
1168 * The Trap with userdef action has the same functionality as
1169 * the Trap action with addition of user defined value that can be set
1170 * and used by higher layer applications.
1171 */
1172
1173#define MLXSW_AFA_TRAP_CODE 0x03
1174#define MLXSW_AFA_TRAP_SIZE 1
1175
1176#define MLXSW_AFA_TRAPWU_CODE 0x04
1177#define MLXSW_AFA_TRAPWU_SIZE 2
1178
1179enum mlxsw_afa_trap_trap_action {
1180 MLXSW_AFA_TRAP_TRAP_ACTION_NOP = 0,
1181 MLXSW_AFA_TRAP_TRAP_ACTION_TRAP = 2,
1182};
1183
1184/* afa_trap_trap_action
1185 * Trap Action.
1186 */
1187MLXSW_ITEM32(afa, trap, trap_action, 0x00, 24, 4);
1188
1189enum mlxsw_afa_trap_forward_action {
1190 MLXSW_AFA_TRAP_FORWARD_ACTION_FORWARD = 1,
1191 MLXSW_AFA_TRAP_FORWARD_ACTION_DISCARD = 3,
1192};
1193
1194/* afa_trap_forward_action
1195 * Forward Action.
1196 */
1197MLXSW_ITEM32(afa, trap, forward_action, 0x00, 0, 4);
1198
1199/* afa_trap_trap_id
1200 * Trap ID to configure.
1201 */
1202MLXSW_ITEM32(afa, trap, trap_id, 0x04, 0, 9);
1203
1204/* afa_trap_mirror_agent
1205 * Mirror agent.
1206 */
1207MLXSW_ITEM32(afa, trap, mirror_agent, 0x08, 29, 3);
1208
1209/* afa_trap_mirror_enable
1210 * Mirror enable.
1211 */
1212MLXSW_ITEM32(afa, trap, mirror_enable, 0x08, 24, 1);
1213
1214/* user_def_val
1215 * Value for the SW usage. Can be used to pass information of which
1216 * rule has caused a trap. This may be overwritten by later traps.
1217 * This field does a set on the packet's user_def_val only if this
1218 * is the first trap_id or if the trap_id has replaced the previous
1219 * packet's trap_id.
1220 */
1221MLXSW_ITEM32(afa, trap, user_def_val, 0x0C, 0, 20);
1222
1223static inline void
1224mlxsw_afa_trap_pack(char *payload,
1225 enum mlxsw_afa_trap_trap_action trap_action,
1226 enum mlxsw_afa_trap_forward_action forward_action,
1227 u16 trap_id)
1228{
1229 mlxsw_afa_trap_trap_action_set(buf: payload, val: trap_action);
1230 mlxsw_afa_trap_forward_action_set(buf: payload, val: forward_action);
1231 mlxsw_afa_trap_trap_id_set(buf: payload, val: trap_id);
1232}
1233
1234static inline void
1235mlxsw_afa_trapwu_pack(char *payload,
1236 enum mlxsw_afa_trap_trap_action trap_action,
1237 enum mlxsw_afa_trap_forward_action forward_action,
1238 u16 trap_id, u32 user_def_val)
1239{
1240 mlxsw_afa_trap_pack(payload, trap_action, forward_action, trap_id);
1241 mlxsw_afa_trap_user_def_val_set(buf: payload, val: user_def_val);
1242}
1243
1244static inline void
1245mlxsw_afa_trap_mirror_pack(char *payload, bool mirror_enable,
1246 u8 mirror_agent)
1247{
1248 mlxsw_afa_trap_mirror_enable_set(buf: payload, val: mirror_enable);
1249 mlxsw_afa_trap_mirror_agent_set(buf: payload, val: mirror_agent);
1250}
1251
1252static char *mlxsw_afa_block_append_action_trap(struct mlxsw_afa_block *block,
1253 u8 action_code, u8 action_size)
1254{
1255 return mlxsw_afa_block_append_action_ext(block, action_code,
1256 action_size,
1257 type: MLXSW_AFA_ACTION_TYPE_TRAP);
1258}
1259
1260static int mlxsw_afa_block_append_drop_plain(struct mlxsw_afa_block *block,
1261 bool ingress)
1262{
1263 char *act = mlxsw_afa_block_append_action_trap(block,
1264 MLXSW_AFA_TRAP_CODE,
1265 MLXSW_AFA_TRAP_SIZE);
1266
1267 if (IS_ERR(ptr: act))
1268 return PTR_ERR(ptr: act);
1269 mlxsw_afa_trap_pack(payload: act, trap_action: MLXSW_AFA_TRAP_TRAP_ACTION_TRAP,
1270 forward_action: MLXSW_AFA_TRAP_FORWARD_ACTION_DISCARD,
1271 trap_id: ingress ? MLXSW_TRAP_ID_DISCARD_INGRESS_ACL :
1272 MLXSW_TRAP_ID_DISCARD_EGRESS_ACL);
1273 return 0;
1274}
1275
1276static int
1277mlxsw_afa_block_append_drop_with_cookie(struct mlxsw_afa_block *block,
1278 bool ingress,
1279 const struct flow_action_cookie *fa_cookie,
1280 struct netlink_ext_ack *extack)
1281{
1282 struct mlxsw_afa_cookie_ref *cookie_ref;
1283 u32 cookie_index;
1284 char *act;
1285 int err;
1286
1287 cookie_ref = mlxsw_afa_cookie_ref_create(block, fa_cookie);
1288 if (IS_ERR(ptr: cookie_ref)) {
1289 NL_SET_ERR_MSG_MOD(extack, "Cannot create cookie for drop action");
1290 return PTR_ERR(ptr: cookie_ref);
1291 }
1292 cookie_index = cookie_ref->cookie->cookie_index;
1293
1294 act = mlxsw_afa_block_append_action_trap(block, MLXSW_AFA_TRAPWU_CODE,
1295 MLXSW_AFA_TRAPWU_SIZE);
1296 if (IS_ERR(ptr: act)) {
1297 NL_SET_ERR_MSG_MOD(extack, "Cannot append drop with cookie action");
1298 err = PTR_ERR(ptr: act);
1299 goto err_append_action;
1300 }
1301 mlxsw_afa_trapwu_pack(payload: act, trap_action: MLXSW_AFA_TRAP_TRAP_ACTION_TRAP,
1302 forward_action: MLXSW_AFA_TRAP_FORWARD_ACTION_DISCARD,
1303 trap_id: ingress ? MLXSW_TRAP_ID_DISCARD_INGRESS_ACL :
1304 MLXSW_TRAP_ID_DISCARD_EGRESS_ACL,
1305 user_def_val: cookie_index);
1306 return 0;
1307
1308err_append_action:
1309 mlxsw_afa_cookie_ref_destroy(block, cookie_ref);
1310 return err;
1311}
1312
1313int mlxsw_afa_block_append_drop(struct mlxsw_afa_block *block, bool ingress,
1314 const struct flow_action_cookie *fa_cookie,
1315 struct netlink_ext_ack *extack)
1316{
1317 return fa_cookie ?
1318 mlxsw_afa_block_append_drop_with_cookie(block, ingress,
1319 fa_cookie, extack) :
1320 mlxsw_afa_block_append_drop_plain(block, ingress);
1321}
1322EXPORT_SYMBOL(mlxsw_afa_block_append_drop);
1323
1324int mlxsw_afa_block_append_trap(struct mlxsw_afa_block *block, u16 trap_id)
1325{
1326 char *act = mlxsw_afa_block_append_action_trap(block,
1327 MLXSW_AFA_TRAP_CODE,
1328 MLXSW_AFA_TRAP_SIZE);
1329
1330 if (IS_ERR(ptr: act))
1331 return PTR_ERR(ptr: act);
1332 mlxsw_afa_trap_pack(payload: act, trap_action: MLXSW_AFA_TRAP_TRAP_ACTION_TRAP,
1333 forward_action: MLXSW_AFA_TRAP_FORWARD_ACTION_DISCARD, trap_id);
1334 return 0;
1335}
1336EXPORT_SYMBOL(mlxsw_afa_block_append_trap);
1337
1338int mlxsw_afa_block_append_trap_and_forward(struct mlxsw_afa_block *block,
1339 u16 trap_id)
1340{
1341 char *act = mlxsw_afa_block_append_action_trap(block,
1342 MLXSW_AFA_TRAP_CODE,
1343 MLXSW_AFA_TRAP_SIZE);
1344
1345 if (IS_ERR(ptr: act))
1346 return PTR_ERR(ptr: act);
1347 mlxsw_afa_trap_pack(payload: act, trap_action: MLXSW_AFA_TRAP_TRAP_ACTION_TRAP,
1348 forward_action: MLXSW_AFA_TRAP_FORWARD_ACTION_FORWARD, trap_id);
1349 return 0;
1350}
1351EXPORT_SYMBOL(mlxsw_afa_block_append_trap_and_forward);
1352
1353struct mlxsw_afa_mirror {
1354 struct mlxsw_afa_resource resource;
1355 int span_id;
1356 u16 local_in_port;
1357 bool ingress;
1358};
1359
1360static void
1361mlxsw_afa_mirror_destroy(struct mlxsw_afa_block *block,
1362 struct mlxsw_afa_mirror *mirror)
1363{
1364 mlxsw_afa_resource_del(resource: &mirror->resource);
1365 block->afa->ops->mirror_del(block->afa->ops_priv,
1366 mirror->local_in_port,
1367 mirror->span_id,
1368 mirror->ingress);
1369 kfree(objp: mirror);
1370}
1371
1372static void
1373mlxsw_afa_mirror_destructor(struct mlxsw_afa_block *block,
1374 struct mlxsw_afa_resource *resource)
1375{
1376 struct mlxsw_afa_mirror *mirror;
1377
1378 mirror = container_of(resource, struct mlxsw_afa_mirror, resource);
1379 mlxsw_afa_mirror_destroy(block, mirror);
1380}
1381
1382static struct mlxsw_afa_mirror *
1383mlxsw_afa_mirror_create(struct mlxsw_afa_block *block, u16 local_in_port,
1384 const struct net_device *out_dev, bool ingress)
1385{
1386 struct mlxsw_afa_mirror *mirror;
1387 int err;
1388
1389 mirror = kzalloc(size: sizeof(*mirror), GFP_KERNEL);
1390 if (!mirror)
1391 return ERR_PTR(error: -ENOMEM);
1392
1393 err = block->afa->ops->mirror_add(block->afa->ops_priv,
1394 local_in_port, out_dev,
1395 ingress, &mirror->span_id);
1396 if (err)
1397 goto err_mirror_add;
1398
1399 mirror->ingress = ingress;
1400 mirror->local_in_port = local_in_port;
1401 mirror->resource.destructor = mlxsw_afa_mirror_destructor;
1402 mlxsw_afa_resource_add(block, resource: &mirror->resource);
1403 return mirror;
1404
1405err_mirror_add:
1406 kfree(objp: mirror);
1407 return ERR_PTR(error: err);
1408}
1409
1410static int
1411mlxsw_afa_block_append_allocated_mirror(struct mlxsw_afa_block *block,
1412 u8 mirror_agent)
1413{
1414 char *act = mlxsw_afa_block_append_action_trap(block,
1415 MLXSW_AFA_TRAP_CODE,
1416 MLXSW_AFA_TRAP_SIZE);
1417
1418 if (IS_ERR(ptr: act))
1419 return PTR_ERR(ptr: act);
1420 mlxsw_afa_trap_pack(payload: act, trap_action: MLXSW_AFA_TRAP_TRAP_ACTION_NOP,
1421 forward_action: MLXSW_AFA_TRAP_FORWARD_ACTION_FORWARD, trap_id: 0);
1422 mlxsw_afa_trap_mirror_pack(payload: act, mirror_enable: true, mirror_agent);
1423 return 0;
1424}
1425
1426int
1427mlxsw_afa_block_append_mirror(struct mlxsw_afa_block *block, u16 local_in_port,
1428 const struct net_device *out_dev, bool ingress,
1429 struct netlink_ext_ack *extack)
1430{
1431 struct mlxsw_afa_mirror *mirror;
1432 int err;
1433
1434 mirror = mlxsw_afa_mirror_create(block, local_in_port, out_dev,
1435 ingress);
1436 if (IS_ERR(ptr: mirror)) {
1437 NL_SET_ERR_MSG_MOD(extack, "Cannot create mirror action");
1438 return PTR_ERR(ptr: mirror);
1439 }
1440 err = mlxsw_afa_block_append_allocated_mirror(block, mirror_agent: mirror->span_id);
1441 if (err) {
1442 NL_SET_ERR_MSG_MOD(extack, "Cannot append mirror action");
1443 goto err_append_allocated_mirror;
1444 }
1445
1446 return 0;
1447
1448err_append_allocated_mirror:
1449 mlxsw_afa_mirror_destroy(block, mirror);
1450 return err;
1451}
1452EXPORT_SYMBOL(mlxsw_afa_block_append_mirror);
1453
1454/* QoS Action
1455 * ----------
1456 * The QOS_ACTION is used for manipulating the QoS attributes of a packet. It
1457 * can be used to change the DCSP, ECN, Color and Switch Priority of the packet.
1458 * Note that PCP field can be changed using the VLAN action.
1459 */
1460
1461#define MLXSW_AFA_QOS_CODE 0x06
1462#define MLXSW_AFA_QOS_SIZE 1
1463
1464enum mlxsw_afa_qos_ecn_cmd {
1465 /* Do nothing */
1466 MLXSW_AFA_QOS_ECN_CMD_NOP,
1467 /* Set ECN to afa_qos_ecn */
1468 MLXSW_AFA_QOS_ECN_CMD_SET,
1469};
1470
1471/* afa_qos_ecn_cmd
1472 */
1473MLXSW_ITEM32(afa, qos, ecn_cmd, 0x04, 29, 3);
1474
1475/* afa_qos_ecn
1476 * ECN value.
1477 */
1478MLXSW_ITEM32(afa, qos, ecn, 0x04, 24, 2);
1479
1480enum mlxsw_afa_qos_dscp_cmd {
1481 /* Do nothing */
1482 MLXSW_AFA_QOS_DSCP_CMD_NOP,
1483 /* Set DSCP 3 LSB bits according to dscp[2:0] */
1484 MLXSW_AFA_QOS_DSCP_CMD_SET_3LSB,
1485 /* Set DSCP 3 MSB bits according to dscp[5:3] */
1486 MLXSW_AFA_QOS_DSCP_CMD_SET_3MSB,
1487 /* Set DSCP 6 bits according to dscp[5:0] */
1488 MLXSW_AFA_QOS_DSCP_CMD_SET_ALL,
1489};
1490
1491/* afa_qos_dscp_cmd
1492 * DSCP command.
1493 */
1494MLXSW_ITEM32(afa, qos, dscp_cmd, 0x04, 14, 2);
1495
1496/* afa_qos_dscp
1497 * DSCP value.
1498 */
1499MLXSW_ITEM32(afa, qos, dscp, 0x04, 0, 6);
1500
1501enum mlxsw_afa_qos_switch_prio_cmd {
1502 /* Do nothing */
1503 MLXSW_AFA_QOS_SWITCH_PRIO_CMD_NOP,
1504 /* Set Switch Priority to afa_qos_switch_prio */
1505 MLXSW_AFA_QOS_SWITCH_PRIO_CMD_SET,
1506};
1507
1508/* afa_qos_switch_prio_cmd
1509 */
1510MLXSW_ITEM32(afa, qos, switch_prio_cmd, 0x08, 14, 2);
1511
1512/* afa_qos_switch_prio
1513 * Switch Priority.
1514 */
1515MLXSW_ITEM32(afa, qos, switch_prio, 0x08, 0, 4);
1516
1517enum mlxsw_afa_qos_dscp_rw {
1518 MLXSW_AFA_QOS_DSCP_RW_PRESERVE,
1519 MLXSW_AFA_QOS_DSCP_RW_SET,
1520 MLXSW_AFA_QOS_DSCP_RW_CLEAR,
1521};
1522
1523/* afa_qos_dscp_rw
1524 * DSCP Re-write Enable. Controlling the rewrite_enable for DSCP.
1525 */
1526MLXSW_ITEM32(afa, qos, dscp_rw, 0x0C, 30, 2);
1527
1528static inline void
1529mlxsw_afa_qos_ecn_pack(char *payload,
1530 enum mlxsw_afa_qos_ecn_cmd ecn_cmd, u8 ecn)
1531{
1532 mlxsw_afa_qos_ecn_cmd_set(buf: payload, val: ecn_cmd);
1533 mlxsw_afa_qos_ecn_set(buf: payload, val: ecn);
1534}
1535
1536static inline void
1537mlxsw_afa_qos_dscp_pack(char *payload,
1538 enum mlxsw_afa_qos_dscp_cmd dscp_cmd, u8 dscp)
1539{
1540 mlxsw_afa_qos_dscp_cmd_set(buf: payload, val: dscp_cmd);
1541 mlxsw_afa_qos_dscp_set(buf: payload, val: dscp);
1542}
1543
1544static inline void
1545mlxsw_afa_qos_switch_prio_pack(char *payload,
1546 enum mlxsw_afa_qos_switch_prio_cmd prio_cmd,
1547 u8 prio)
1548{
1549 mlxsw_afa_qos_switch_prio_cmd_set(buf: payload, val: prio_cmd);
1550 mlxsw_afa_qos_switch_prio_set(buf: payload, val: prio);
1551}
1552
1553static int __mlxsw_afa_block_append_qos_dsfield(struct mlxsw_afa_block *block,
1554 bool set_dscp, u8 dscp,
1555 bool set_ecn, u8 ecn,
1556 struct netlink_ext_ack *extack)
1557{
1558 char *act = mlxsw_afa_block_append_action(block,
1559 MLXSW_AFA_QOS_CODE,
1560 MLXSW_AFA_QOS_SIZE);
1561
1562 if (IS_ERR(ptr: act)) {
1563 NL_SET_ERR_MSG_MOD(extack, "Cannot append QOS action");
1564 return PTR_ERR(ptr: act);
1565 }
1566
1567 if (set_ecn)
1568 mlxsw_afa_qos_ecn_pack(payload: act, ecn_cmd: MLXSW_AFA_QOS_ECN_CMD_SET, ecn);
1569 if (set_dscp) {
1570 mlxsw_afa_qos_dscp_pack(payload: act, dscp_cmd: MLXSW_AFA_QOS_DSCP_CMD_SET_ALL,
1571 dscp);
1572 mlxsw_afa_qos_dscp_rw_set(buf: act, val: MLXSW_AFA_QOS_DSCP_RW_CLEAR);
1573 }
1574
1575 return 0;
1576}
1577
1578int mlxsw_afa_block_append_qos_dsfield(struct mlxsw_afa_block *block,
1579 u8 dsfield,
1580 struct netlink_ext_ack *extack)
1581{
1582 return __mlxsw_afa_block_append_qos_dsfield(block,
1583 set_dscp: true, dscp: dsfield >> 2,
1584 set_ecn: true, ecn: dsfield & 0x03,
1585 extack);
1586}
1587EXPORT_SYMBOL(mlxsw_afa_block_append_qos_dsfield);
1588
1589int mlxsw_afa_block_append_qos_dscp(struct mlxsw_afa_block *block,
1590 u8 dscp, struct netlink_ext_ack *extack)
1591{
1592 return __mlxsw_afa_block_append_qos_dsfield(block,
1593 set_dscp: true, dscp,
1594 set_ecn: false, ecn: 0,
1595 extack);
1596}
1597EXPORT_SYMBOL(mlxsw_afa_block_append_qos_dscp);
1598
1599int mlxsw_afa_block_append_qos_ecn(struct mlxsw_afa_block *block,
1600 u8 ecn, struct netlink_ext_ack *extack)
1601{
1602 return __mlxsw_afa_block_append_qos_dsfield(block,
1603 set_dscp: false, dscp: 0,
1604 set_ecn: true, ecn,
1605 extack);
1606}
1607EXPORT_SYMBOL(mlxsw_afa_block_append_qos_ecn);
1608
1609int mlxsw_afa_block_append_qos_switch_prio(struct mlxsw_afa_block *block,
1610 u8 prio,
1611 struct netlink_ext_ack *extack)
1612{
1613 char *act = mlxsw_afa_block_append_action(block,
1614 MLXSW_AFA_QOS_CODE,
1615 MLXSW_AFA_QOS_SIZE);
1616
1617 if (IS_ERR(ptr: act)) {
1618 NL_SET_ERR_MSG_MOD(extack, "Cannot append QOS action");
1619 return PTR_ERR(ptr: act);
1620 }
1621 mlxsw_afa_qos_switch_prio_pack(payload: act, prio_cmd: MLXSW_AFA_QOS_SWITCH_PRIO_CMD_SET,
1622 prio);
1623 return 0;
1624}
1625EXPORT_SYMBOL(mlxsw_afa_block_append_qos_switch_prio);
1626
1627/* Forwarding Action
1628 * -----------------
1629 * Forwarding Action can be used to implement Policy Based Switching (PBS)
1630 * as well as OpenFlow related "Output" action.
1631 */
1632
1633#define MLXSW_AFA_FORWARD_CODE 0x07
1634#define MLXSW_AFA_FORWARD_SIZE 1
1635
1636enum mlxsw_afa_forward_type {
1637 /* PBS, Policy Based Switching */
1638 MLXSW_AFA_FORWARD_TYPE_PBS,
1639 /* Output, OpenFlow output type */
1640 MLXSW_AFA_FORWARD_TYPE_OUTPUT,
1641};
1642
1643/* afa_forward_type */
1644MLXSW_ITEM32(afa, forward, type, 0x00, 24, 2);
1645
1646/* afa_forward_pbs_ptr
1647 * A pointer to the PBS entry configured by PPBS register.
1648 * Reserved when in_port is set.
1649 */
1650MLXSW_ITEM32(afa, forward, pbs_ptr, 0x08, 0, 24);
1651
1652/* afa_forward_in_port
1653 * Packet is forwarded back to the ingress port.
1654 */
1655MLXSW_ITEM32(afa, forward, in_port, 0x0C, 0, 1);
1656
1657static inline void
1658mlxsw_afa_forward_pack(char *payload, enum mlxsw_afa_forward_type type,
1659 u32 pbs_ptr, bool in_port)
1660{
1661 mlxsw_afa_forward_type_set(buf: payload, val: type);
1662 mlxsw_afa_forward_pbs_ptr_set(buf: payload, val: pbs_ptr);
1663 mlxsw_afa_forward_in_port_set(buf: payload, val: in_port);
1664}
1665
1666int mlxsw_afa_block_append_fwd(struct mlxsw_afa_block *block,
1667 u16 local_port, bool in_port,
1668 struct netlink_ext_ack *extack)
1669{
1670 struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref;
1671 u32 kvdl_index;
1672 char *act;
1673 int err;
1674
1675 if (in_port) {
1676 NL_SET_ERR_MSG_MOD(extack, "Forwarding to ingress port is not supported");
1677 return -EOPNOTSUPP;
1678 }
1679 fwd_entry_ref = mlxsw_afa_fwd_entry_ref_create(block, local_port);
1680 if (IS_ERR(ptr: fwd_entry_ref)) {
1681 NL_SET_ERR_MSG_MOD(extack, "Cannot create forward action");
1682 return PTR_ERR(ptr: fwd_entry_ref);
1683 }
1684 kvdl_index = fwd_entry_ref->fwd_entry->kvdl_index;
1685
1686 act = mlxsw_afa_block_append_action(block, MLXSW_AFA_FORWARD_CODE,
1687 MLXSW_AFA_FORWARD_SIZE);
1688 if (IS_ERR(ptr: act)) {
1689 NL_SET_ERR_MSG_MOD(extack, "Cannot append forward action");
1690 err = PTR_ERR(ptr: act);
1691 goto err_append_action;
1692 }
1693 mlxsw_afa_forward_pack(payload: act, type: MLXSW_AFA_FORWARD_TYPE_PBS,
1694 pbs_ptr: kvdl_index, in_port);
1695 return 0;
1696
1697err_append_action:
1698 mlxsw_afa_fwd_entry_ref_destroy(block, fwd_entry_ref);
1699 return err;
1700}
1701EXPORT_SYMBOL(mlxsw_afa_block_append_fwd);
1702
1703/* Policing and Counting Action
1704 * ----------------------------
1705 * Policing and Counting action is used for binding policer and counter
1706 * to ACL rules.
1707 */
1708
1709#define MLXSW_AFA_POLCNT_CODE 0x08
1710#define MLXSW_AFA_POLCNT_SIZE 1
1711
1712enum {
1713 MLXSW_AFA_POLCNT_COUNTER,
1714 MLXSW_AFA_POLCNT_POLICER,
1715};
1716
1717/* afa_polcnt_c_p
1718 * Counter or policer.
1719 * Indicates whether the action binds a policer or a counter to the flow.
1720 * 0: Counter
1721 * 1: Policer
1722 */
1723MLXSW_ITEM32(afa, polcnt, c_p, 0x00, 31, 1);
1724
1725enum mlxsw_afa_polcnt_counter_set_type {
1726 /* No count */
1727 MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_NO_COUNT = 0x00,
1728 /* Count packets and bytes */
1729 MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_PACKETS_BYTES = 0x03,
1730 /* Count only packets */
1731 MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_PACKETS = 0x05,
1732};
1733
1734/* afa_polcnt_counter_set_type
1735 * Counter set type for flow counters.
1736 */
1737MLXSW_ITEM32(afa, polcnt, counter_set_type, 0x04, 24, 8);
1738
1739/* afa_polcnt_counter_index
1740 * Counter index for flow counters.
1741 */
1742MLXSW_ITEM32(afa, polcnt, counter_index, 0x04, 0, 24);
1743
1744/* afa_polcnt_pid
1745 * Policer ID.
1746 * Reserved when c_p = 0
1747 */
1748MLXSW_ITEM32(afa, polcnt, pid, 0x08, 0, 14);
1749
1750static inline void
1751mlxsw_afa_polcnt_pack(char *payload,
1752 enum mlxsw_afa_polcnt_counter_set_type set_type,
1753 u32 counter_index)
1754{
1755 mlxsw_afa_polcnt_c_p_set(buf: payload, val: MLXSW_AFA_POLCNT_COUNTER);
1756 mlxsw_afa_polcnt_counter_set_type_set(buf: payload, val: set_type);
1757 mlxsw_afa_polcnt_counter_index_set(buf: payload, val: counter_index);
1758}
1759
1760static void mlxsw_afa_polcnt_policer_pack(char *payload, u16 policer_index)
1761{
1762 mlxsw_afa_polcnt_c_p_set(buf: payload, val: MLXSW_AFA_POLCNT_POLICER);
1763 mlxsw_afa_polcnt_pid_set(buf: payload, val: policer_index);
1764}
1765
1766int mlxsw_afa_block_append_allocated_counter(struct mlxsw_afa_block *block,
1767 u32 counter_index)
1768{
1769 char *act = mlxsw_afa_block_append_action(block, MLXSW_AFA_POLCNT_CODE,
1770 MLXSW_AFA_POLCNT_SIZE);
1771 if (IS_ERR(ptr: act))
1772 return PTR_ERR(ptr: act);
1773 mlxsw_afa_polcnt_pack(payload: act, set_type: MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_PACKETS_BYTES,
1774 counter_index);
1775 return 0;
1776}
1777EXPORT_SYMBOL(mlxsw_afa_block_append_allocated_counter);
1778
1779int mlxsw_afa_block_append_counter(struct mlxsw_afa_block *block,
1780 u32 *p_counter_index,
1781 struct netlink_ext_ack *extack)
1782{
1783 struct mlxsw_afa_counter *counter;
1784 u32 counter_index;
1785 int err;
1786
1787 counter = mlxsw_afa_counter_create(block);
1788 if (IS_ERR(ptr: counter)) {
1789 NL_SET_ERR_MSG_MOD(extack, "Cannot create count action");
1790 return PTR_ERR(ptr: counter);
1791 }
1792 counter_index = counter->counter_index;
1793
1794 err = mlxsw_afa_block_append_allocated_counter(block, counter_index);
1795 if (err) {
1796 NL_SET_ERR_MSG_MOD(extack, "Cannot append count action");
1797 goto err_append_allocated_counter;
1798 }
1799 if (p_counter_index)
1800 *p_counter_index = counter_index;
1801 return 0;
1802
1803err_append_allocated_counter:
1804 mlxsw_afa_counter_destroy(block, counter);
1805 return err;
1806}
1807EXPORT_SYMBOL(mlxsw_afa_block_append_counter);
1808
1809int mlxsw_afa_block_append_police(struct mlxsw_afa_block *block,
1810 u32 fa_index, u64 rate_bytes_ps, u32 burst,
1811 u16 *p_policer_index,
1812 struct netlink_ext_ack *extack)
1813{
1814 struct mlxsw_afa_policer_ref *policer_ref;
1815 char *act;
1816 int err;
1817
1818 policer_ref = mlxsw_afa_policer_ref_create(block, fa_index,
1819 rate_bytes_ps,
1820 burst, extack);
1821 if (IS_ERR(ptr: policer_ref))
1822 return PTR_ERR(ptr: policer_ref);
1823 *p_policer_index = policer_ref->policer->policer_index;
1824
1825 act = mlxsw_afa_block_append_action_ext(block, MLXSW_AFA_POLCNT_CODE,
1826 MLXSW_AFA_POLCNT_SIZE,
1827 type: MLXSW_AFA_ACTION_TYPE_POLICE);
1828 if (IS_ERR(ptr: act)) {
1829 NL_SET_ERR_MSG_MOD(extack, "Cannot append police action");
1830 err = PTR_ERR(ptr: act);
1831 goto err_append_action;
1832 }
1833 mlxsw_afa_polcnt_policer_pack(payload: act, policer_index: *p_policer_index);
1834
1835 return 0;
1836
1837err_append_action:
1838 mlxsw_afa_policer_ref_destroy(block, policer_ref);
1839 return err;
1840}
1841EXPORT_SYMBOL(mlxsw_afa_block_append_police);
1842
1843/* Virtual Router and Forwarding Domain Action
1844 * -------------------------------------------
1845 * Virtual Switch action is used for manipulate the Virtual Router (VR),
1846 * MPLS label space and the Forwarding Identifier (FID).
1847 */
1848
1849#define MLXSW_AFA_VIRFWD_CODE 0x0E
1850#define MLXSW_AFA_VIRFWD_SIZE 1
1851
1852enum mlxsw_afa_virfwd_fid_cmd {
1853 /* Do nothing */
1854 MLXSW_AFA_VIRFWD_FID_CMD_NOOP,
1855 /* Set the Forwarding Identifier (FID) to fid */
1856 MLXSW_AFA_VIRFWD_FID_CMD_SET,
1857};
1858
1859/* afa_virfwd_fid_cmd */
1860MLXSW_ITEM32(afa, virfwd, fid_cmd, 0x08, 29, 3);
1861
1862/* afa_virfwd_fid
1863 * The FID value.
1864 */
1865MLXSW_ITEM32(afa, virfwd, fid, 0x08, 0, 16);
1866
1867static inline void mlxsw_afa_virfwd_pack(char *payload,
1868 enum mlxsw_afa_virfwd_fid_cmd fid_cmd,
1869 u16 fid)
1870{
1871 mlxsw_afa_virfwd_fid_cmd_set(buf: payload, val: fid_cmd);
1872 mlxsw_afa_virfwd_fid_set(buf: payload, val: fid);
1873}
1874
1875int mlxsw_afa_block_append_fid_set(struct mlxsw_afa_block *block, u16 fid,
1876 struct netlink_ext_ack *extack)
1877{
1878 char *act = mlxsw_afa_block_append_action(block,
1879 MLXSW_AFA_VIRFWD_CODE,
1880 MLXSW_AFA_VIRFWD_SIZE);
1881 if (IS_ERR(ptr: act)) {
1882 NL_SET_ERR_MSG_MOD(extack, "Cannot append fid_set action");
1883 return PTR_ERR(ptr: act);
1884 }
1885 mlxsw_afa_virfwd_pack(payload: act, fid_cmd: MLXSW_AFA_VIRFWD_FID_CMD_SET, fid);
1886 return 0;
1887}
1888EXPORT_SYMBOL(mlxsw_afa_block_append_fid_set);
1889
1890/* Ignore Action
1891 * -------------
1892 * The ignore action is used to ignore basic switching functions such as
1893 * learning on a per-packet basis.
1894 */
1895
1896#define MLXSW_AFA_IGNORE_CODE 0x0F
1897#define MLXSW_AFA_IGNORE_SIZE 1
1898
1899/* afa_ignore_disable_learning
1900 * Disable learning on ingress.
1901 */
1902MLXSW_ITEM32(afa, ignore, disable_learning, 0x00, 29, 1);
1903
1904/* afa_ignore_disable_security
1905 * Disable security lookup on ingress.
1906 * Reserved when Spectrum-1.
1907 */
1908MLXSW_ITEM32(afa, ignore, disable_security, 0x00, 28, 1);
1909
1910static void mlxsw_afa_ignore_pack(char *payload, bool disable_learning,
1911 bool disable_security)
1912{
1913 mlxsw_afa_ignore_disable_learning_set(buf: payload, val: disable_learning);
1914 mlxsw_afa_ignore_disable_security_set(buf: payload, val: disable_security);
1915}
1916
1917int mlxsw_afa_block_append_ignore(struct mlxsw_afa_block *block,
1918 bool disable_learning, bool disable_security)
1919{
1920 char *act = mlxsw_afa_block_append_action(block, MLXSW_AFA_IGNORE_CODE,
1921 MLXSW_AFA_IGNORE_SIZE);
1922
1923 if (IS_ERR(ptr: act))
1924 return PTR_ERR(ptr: act);
1925 mlxsw_afa_ignore_pack(payload: act, disable_learning, disable_security);
1926 return 0;
1927}
1928EXPORT_SYMBOL(mlxsw_afa_block_append_ignore);
1929
1930/* MC Routing Action
1931 * -----------------
1932 * The Multicast router action. Can be used by RMFT_V2 - Router Multicast
1933 * Forwarding Table Version 2 Register.
1934 */
1935
1936#define MLXSW_AFA_MCROUTER_CODE 0x10
1937#define MLXSW_AFA_MCROUTER_SIZE 2
1938
1939enum mlxsw_afa_mcrouter_rpf_action {
1940 MLXSW_AFA_MCROUTER_RPF_ACTION_NOP,
1941 MLXSW_AFA_MCROUTER_RPF_ACTION_TRAP,
1942 MLXSW_AFA_MCROUTER_RPF_ACTION_DISCARD_ERROR,
1943};
1944
1945/* afa_mcrouter_rpf_action */
1946MLXSW_ITEM32(afa, mcrouter, rpf_action, 0x00, 28, 3);
1947
1948/* afa_mcrouter_expected_irif */
1949MLXSW_ITEM32(afa, mcrouter, expected_irif, 0x00, 0, 16);
1950
1951/* afa_mcrouter_min_mtu */
1952MLXSW_ITEM32(afa, mcrouter, min_mtu, 0x08, 0, 16);
1953
1954enum mlxsw_afa_mrouter_vrmid {
1955 MLXSW_AFA_MCROUTER_VRMID_INVALID,
1956 MLXSW_AFA_MCROUTER_VRMID_VALID
1957};
1958
1959/* afa_mcrouter_vrmid
1960 * Valid RMID: rigr_rmid_index is used as RMID
1961 */
1962MLXSW_ITEM32(afa, mcrouter, vrmid, 0x0C, 31, 1);
1963
1964/* afa_mcrouter_rigr_rmid_index
1965 * When the vrmid field is set to invalid, the field is used as pointer to
1966 * Router Interface Group (RIGR) Table in the KVD linear.
1967 * When the vrmid is set to valid, the field is used as RMID index, ranged
1968 * from 0 to max_mid - 1. The index is to the Port Group Table.
1969 */
1970MLXSW_ITEM32(afa, mcrouter, rigr_rmid_index, 0x0C, 0, 24);
1971
1972static inline void
1973mlxsw_afa_mcrouter_pack(char *payload,
1974 enum mlxsw_afa_mcrouter_rpf_action rpf_action,
1975 u16 expected_irif, u16 min_mtu,
1976 enum mlxsw_afa_mrouter_vrmid vrmid, u32 rigr_rmid_index)
1977
1978{
1979 mlxsw_afa_mcrouter_rpf_action_set(buf: payload, val: rpf_action);
1980 mlxsw_afa_mcrouter_expected_irif_set(buf: payload, val: expected_irif);
1981 mlxsw_afa_mcrouter_min_mtu_set(buf: payload, val: min_mtu);
1982 mlxsw_afa_mcrouter_vrmid_set(buf: payload, val: vrmid);
1983 mlxsw_afa_mcrouter_rigr_rmid_index_set(buf: payload, val: rigr_rmid_index);
1984}
1985
1986int mlxsw_afa_block_append_mcrouter(struct mlxsw_afa_block *block,
1987 u16 expected_irif, u16 min_mtu,
1988 bool rmid_valid, u32 kvdl_index)
1989{
1990 char *act = mlxsw_afa_block_append_action(block,
1991 MLXSW_AFA_MCROUTER_CODE,
1992 MLXSW_AFA_MCROUTER_SIZE);
1993 if (IS_ERR(ptr: act))
1994 return PTR_ERR(ptr: act);
1995 mlxsw_afa_mcrouter_pack(payload: act, rpf_action: MLXSW_AFA_MCROUTER_RPF_ACTION_TRAP,
1996 expected_irif, min_mtu, vrmid: rmid_valid, rigr_rmid_index: kvdl_index);
1997 return 0;
1998}
1999EXPORT_SYMBOL(mlxsw_afa_block_append_mcrouter);
2000
2001/* SIP DIP Action
2002 * --------------
2003 * The SIP_DIP_ACTION is used for modifying the SIP and DIP fields of the
2004 * packet, e.g. for NAT. The L3 checksum is updated. Also, if the L4 is TCP or
2005 * if the L4 is UDP and the checksum field is not zero, then the L4 checksum is
2006 * updated.
2007 */
2008
2009#define MLXSW_AFA_IP_CODE 0x11
2010#define MLXSW_AFA_IP_SIZE 2
2011
2012enum mlxsw_afa_ip_s_d {
2013 /* ip refers to dip */
2014 MLXSW_AFA_IP_S_D_DIP,
2015 /* ip refers to sip */
2016 MLXSW_AFA_IP_S_D_SIP,
2017};
2018
2019/* afa_ip_s_d
2020 * Source or destination.
2021 */
2022MLXSW_ITEM32(afa, ip, s_d, 0x00, 31, 1);
2023
2024enum mlxsw_afa_ip_m_l {
2025 /* LSB: ip[63:0] refers to ip[63:0] */
2026 MLXSW_AFA_IP_M_L_LSB,
2027 /* MSB: ip[63:0] refers to ip[127:64] */
2028 MLXSW_AFA_IP_M_L_MSB,
2029};
2030
2031/* afa_ip_m_l
2032 * MSB or LSB.
2033 */
2034MLXSW_ITEM32(afa, ip, m_l, 0x00, 30, 1);
2035
2036/* afa_ip_ip_63_32
2037 * Bits [63:32] in the IP address to change to.
2038 */
2039MLXSW_ITEM32(afa, ip, ip_63_32, 0x08, 0, 32);
2040
2041/* afa_ip_ip_31_0
2042 * Bits [31:0] in the IP address to change to.
2043 */
2044MLXSW_ITEM32(afa, ip, ip_31_0, 0x0C, 0, 32);
2045
2046static void mlxsw_afa_ip_pack(char *payload, enum mlxsw_afa_ip_s_d s_d,
2047 enum mlxsw_afa_ip_m_l m_l, u32 ip_31_0,
2048 u32 ip_63_32)
2049{
2050 mlxsw_afa_ip_s_d_set(buf: payload, val: s_d);
2051 mlxsw_afa_ip_m_l_set(buf: payload, val: m_l);
2052 mlxsw_afa_ip_ip_31_0_set(buf: payload, val: ip_31_0);
2053 mlxsw_afa_ip_ip_63_32_set(buf: payload, val: ip_63_32);
2054}
2055
2056int mlxsw_afa_block_append_ip(struct mlxsw_afa_block *block, bool is_dip,
2057 bool is_lsb, u32 val_31_0, u32 val_63_32,
2058 struct netlink_ext_ack *extack)
2059{
2060 enum mlxsw_afa_ip_s_d s_d = is_dip ? MLXSW_AFA_IP_S_D_DIP :
2061 MLXSW_AFA_IP_S_D_SIP;
2062 enum mlxsw_afa_ip_m_l m_l = is_lsb ? MLXSW_AFA_IP_M_L_LSB :
2063 MLXSW_AFA_IP_M_L_MSB;
2064 char *act = mlxsw_afa_block_append_action(block,
2065 MLXSW_AFA_IP_CODE,
2066 MLXSW_AFA_IP_SIZE);
2067
2068 if (IS_ERR(ptr: act)) {
2069 NL_SET_ERR_MSG_MOD(extack, "Cannot append IP action");
2070 return PTR_ERR(ptr: act);
2071 }
2072
2073 mlxsw_afa_ip_pack(payload: act, s_d, m_l, ip_31_0: val_31_0, ip_63_32: val_63_32);
2074 return 0;
2075}
2076EXPORT_SYMBOL(mlxsw_afa_block_append_ip);
2077
2078/* L4 Port Action
2079 * --------------
2080 * The L4_PORT_ACTION is used for modifying the sport and dport fields of the packet, e.g. for NAT.
2081 * If (the L4 is TCP) or if (the L4 is UDP and checksum field!=0) then the L4 checksum is updated.
2082 */
2083
2084#define MLXSW_AFA_L4PORT_CODE 0x12
2085#define MLXSW_AFA_L4PORT_SIZE 1
2086
2087enum mlxsw_afa_l4port_s_d {
2088 /* configure src_l4_port */
2089 MLXSW_AFA_L4PORT_S_D_SRC,
2090 /* configure dst_l4_port */
2091 MLXSW_AFA_L4PORT_S_D_DST,
2092};
2093
2094/* afa_l4port_s_d
2095 * Source or destination.
2096 */
2097MLXSW_ITEM32(afa, l4port, s_d, 0x00, 31, 1);
2098
2099/* afa_l4port_l4_port
2100 * Number of port to change to.
2101 */
2102MLXSW_ITEM32(afa, l4port, l4_port, 0x08, 0, 16);
2103
2104static void mlxsw_afa_l4port_pack(char *payload, enum mlxsw_afa_l4port_s_d s_d, u16 l4_port)
2105{
2106 mlxsw_afa_l4port_s_d_set(buf: payload, val: s_d);
2107 mlxsw_afa_l4port_l4_port_set(buf: payload, val: l4_port);
2108}
2109
2110int mlxsw_afa_block_append_l4port(struct mlxsw_afa_block *block, bool is_dport, u16 l4_port,
2111 struct netlink_ext_ack *extack)
2112{
2113 enum mlxsw_afa_l4port_s_d s_d = is_dport ? MLXSW_AFA_L4PORT_S_D_DST :
2114 MLXSW_AFA_L4PORT_S_D_SRC;
2115 char *act = mlxsw_afa_block_append_action(block,
2116 MLXSW_AFA_L4PORT_CODE,
2117 MLXSW_AFA_L4PORT_SIZE);
2118
2119 if (IS_ERR(ptr: act)) {
2120 NL_SET_ERR_MSG_MOD(extack, "Cannot append L4_PORT action");
2121 return PTR_ERR(ptr: act);
2122 }
2123
2124 mlxsw_afa_l4port_pack(payload: act, s_d, l4_port);
2125 return 0;
2126}
2127EXPORT_SYMBOL(mlxsw_afa_block_append_l4port);
2128
2129/* Mirror Sampler Action
2130 * ---------------------
2131 * The SAMPLER_ACTION is used to mirror packets with a probability (sampling).
2132 */
2133
2134#define MLXSW_AFA_SAMPLER_CODE 0x13
2135#define MLXSW_AFA_SAMPLER_SIZE 1
2136
2137/* afa_sampler_mirror_agent
2138 * Mirror (SPAN) agent.
2139 */
2140MLXSW_ITEM32(afa, sampler, mirror_agent, 0x04, 0, 3);
2141
2142#define MLXSW_AFA_SAMPLER_RATE_MAX (BIT(24) - 1)
2143
2144/* afa_sampler_mirror_probability_rate
2145 * Mirroring probability.
2146 * Valid values are 1 to 2^24 - 1
2147 */
2148MLXSW_ITEM32(afa, sampler, mirror_probability_rate, 0x08, 0, 24);
2149
2150static void mlxsw_afa_sampler_pack(char *payload, u8 mirror_agent, u32 rate)
2151{
2152 mlxsw_afa_sampler_mirror_agent_set(buf: payload, val: mirror_agent);
2153 mlxsw_afa_sampler_mirror_probability_rate_set(buf: payload, val: rate);
2154}
2155
2156struct mlxsw_afa_sampler {
2157 struct mlxsw_afa_resource resource;
2158 int span_id;
2159 u16 local_port;
2160 bool ingress;
2161};
2162
2163static void mlxsw_afa_sampler_destroy(struct mlxsw_afa_block *block,
2164 struct mlxsw_afa_sampler *sampler)
2165{
2166 mlxsw_afa_resource_del(resource: &sampler->resource);
2167 block->afa->ops->sampler_del(block->afa->ops_priv, sampler->local_port,
2168 sampler->span_id, sampler->ingress);
2169 kfree(objp: sampler);
2170}
2171
2172static void mlxsw_afa_sampler_destructor(struct mlxsw_afa_block *block,
2173 struct mlxsw_afa_resource *resource)
2174{
2175 struct mlxsw_afa_sampler *sampler;
2176
2177 sampler = container_of(resource, struct mlxsw_afa_sampler, resource);
2178 mlxsw_afa_sampler_destroy(block, sampler);
2179}
2180
2181static struct mlxsw_afa_sampler *
2182mlxsw_afa_sampler_create(struct mlxsw_afa_block *block, u16 local_port,
2183 struct psample_group *psample_group, u32 rate,
2184 u32 trunc_size, bool truncate, bool ingress,
2185 struct netlink_ext_ack *extack)
2186{
2187 struct mlxsw_afa_sampler *sampler;
2188 int err;
2189
2190 sampler = kzalloc(size: sizeof(*sampler), GFP_KERNEL);
2191 if (!sampler)
2192 return ERR_PTR(error: -ENOMEM);
2193
2194 err = block->afa->ops->sampler_add(block->afa->ops_priv, local_port,
2195 psample_group, rate, trunc_size,
2196 truncate, ingress, &sampler->span_id,
2197 extack);
2198 if (err)
2199 goto err_sampler_add;
2200
2201 sampler->ingress = ingress;
2202 sampler->local_port = local_port;
2203 sampler->resource.destructor = mlxsw_afa_sampler_destructor;
2204 mlxsw_afa_resource_add(block, resource: &sampler->resource);
2205 return sampler;
2206
2207err_sampler_add:
2208 kfree(objp: sampler);
2209 return ERR_PTR(error: err);
2210}
2211
2212static int
2213mlxsw_afa_block_append_allocated_sampler(struct mlxsw_afa_block *block,
2214 u8 mirror_agent, u32 rate)
2215{
2216 char *act = mlxsw_afa_block_append_action(block, MLXSW_AFA_SAMPLER_CODE,
2217 MLXSW_AFA_SAMPLER_SIZE);
2218
2219 if (IS_ERR(ptr: act))
2220 return PTR_ERR(ptr: act);
2221 mlxsw_afa_sampler_pack(payload: act, mirror_agent, rate);
2222 return 0;
2223}
2224
2225int mlxsw_afa_block_append_sampler(struct mlxsw_afa_block *block, u16 local_port,
2226 struct psample_group *psample_group,
2227 u32 rate, u32 trunc_size, bool truncate,
2228 bool ingress,
2229 struct netlink_ext_ack *extack)
2230{
2231 struct mlxsw_afa_sampler *sampler;
2232 int err;
2233
2234 if (rate > MLXSW_AFA_SAMPLER_RATE_MAX) {
2235 NL_SET_ERR_MSG_MOD(extack, "Sampling rate is too high");
2236 return -EINVAL;
2237 }
2238
2239 sampler = mlxsw_afa_sampler_create(block, local_port, psample_group,
2240 rate, trunc_size, truncate, ingress,
2241 extack);
2242 if (IS_ERR(ptr: sampler))
2243 return PTR_ERR(ptr: sampler);
2244
2245 err = mlxsw_afa_block_append_allocated_sampler(block, mirror_agent: sampler->span_id,
2246 rate);
2247 if (err) {
2248 NL_SET_ERR_MSG_MOD(extack, "Cannot append sampler action");
2249 goto err_append_allocated_sampler;
2250 }
2251
2252 return 0;
2253
2254err_append_allocated_sampler:
2255 mlxsw_afa_sampler_destroy(block, sampler);
2256 return err;
2257}
2258EXPORT_SYMBOL(mlxsw_afa_block_append_sampler);
2259

source code of linux/drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c