net/mlx5: Add core support for vlan push/pop steering action
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / eswitch_offloads.c
1 /*
2  * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32
33 #include <linux/etherdevice.h>
34 #include <linux/mlx5/driver.h>
35 #include <linux/mlx5/mlx5_ifc.h>
36 #include <linux/mlx5/vport.h>
37 #include <linux/mlx5/fs.h>
38 #include "mlx5_core.h"
39 #include "eswitch.h"
40
41 enum {
42         FDB_FAST_PATH = 0,
43         FDB_SLOW_PATH
44 };
45
46 struct mlx5_flow_handle *
47 mlx5_eswitch_add_offloaded_rule(struct mlx5_eswitch *esw,
48                                 struct mlx5_flow_spec *spec,
49                                 struct mlx5_esw_flow_attr *attr)
50 {
51         struct mlx5_flow_destination dest[2] = {};
52         struct mlx5_flow_act flow_act = {0};
53         struct mlx5_fc *counter = NULL;
54         struct mlx5_flow_handle *rule;
55         void *misc;
56         int i = 0;
57
58         if (esw->mode != SRIOV_OFFLOADS)
59                 return ERR_PTR(-EOPNOTSUPP);
60
61         /* per flow vlan pop/push is emulated, don't set that into the firmware */
62         flow_act.action = attr->action & ~(MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH | MLX5_FLOW_CONTEXT_ACTION_VLAN_POP);
63
64         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {
65                 dest[i].type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
66                 dest[i].vport_num = attr->out_rep->vport;
67                 i++;
68         }
69         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {
70                 counter = mlx5_fc_create(esw->dev, true);
71                 if (IS_ERR(counter)) {
72                         rule = ERR_CAST(counter);
73                         goto err_counter_alloc;
74                 }
75                 dest[i].type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;
76                 dest[i].counter = counter;
77                 i++;
78         }
79
80         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
81         MLX5_SET(fte_match_set_misc, misc, source_port, attr->in_rep->vport);
82
83         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
84         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
85
86         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS |
87                                       MLX5_MATCH_MISC_PARAMETERS;
88         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DECAP)
89                 spec->match_criteria_enable |= MLX5_MATCH_INNER_HEADERS;
90
91         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)
92                 flow_act.modify_id = attr->mod_hdr_id;
93
94         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_ENCAP)
95                 flow_act.encap_id = attr->encap_id;
96
97         rule = mlx5_add_flow_rules((struct mlx5_flow_table *)esw->fdb_table.fdb,
98                                    spec, &flow_act, dest, i);
99         if (IS_ERR(rule))
100                 goto err_add_rule;
101         else
102                 esw->offloads.num_flows++;
103
104         return rule;
105
106 err_add_rule:
107         mlx5_fc_destroy(esw->dev, counter);
108 err_counter_alloc:
109         return rule;
110 }
111
112 void
113 mlx5_eswitch_del_offloaded_rule(struct mlx5_eswitch *esw,
114                                 struct mlx5_flow_handle *rule,
115                                 struct mlx5_esw_flow_attr *attr)
116 {
117         struct mlx5_fc *counter = NULL;
118
119         counter = mlx5_flow_rule_counter(rule);
120         mlx5_del_flow_rules(rule);
121         mlx5_fc_destroy(esw->dev, counter);
122         esw->offloads.num_flows--;
123 }
124
125 static int esw_set_global_vlan_pop(struct mlx5_eswitch *esw, u8 val)
126 {
127         struct mlx5_eswitch_rep *rep;
128         int vf_vport, err = 0;
129
130         esw_debug(esw->dev, "%s applying global %s policy\n", __func__, val ? "pop" : "none");
131         for (vf_vport = 1; vf_vport < esw->enabled_vports; vf_vport++) {
132                 rep = &esw->offloads.vport_reps[vf_vport];
133                 if (!rep->rep_if[REP_ETH].valid)
134                         continue;
135
136                 err = __mlx5_eswitch_set_vport_vlan(esw, rep->vport, 0, 0, val);
137                 if (err)
138                         goto out;
139         }
140
141 out:
142         return err;
143 }
144
145 static struct mlx5_eswitch_rep *
146 esw_vlan_action_get_vport(struct mlx5_esw_flow_attr *attr, bool push, bool pop)
147 {
148         struct mlx5_eswitch_rep *in_rep, *out_rep, *vport = NULL;
149
150         in_rep  = attr->in_rep;
151         out_rep = attr->out_rep;
152
153         if (push)
154                 vport = in_rep;
155         else if (pop)
156                 vport = out_rep;
157         else
158                 vport = in_rep;
159
160         return vport;
161 }
162
163 static int esw_add_vlan_action_check(struct mlx5_esw_flow_attr *attr,
164                                      bool push, bool pop, bool fwd)
165 {
166         struct mlx5_eswitch_rep *in_rep, *out_rep;
167
168         if ((push || pop) && !fwd)
169                 goto out_notsupp;
170
171         in_rep  = attr->in_rep;
172         out_rep = attr->out_rep;
173
174         if (push && in_rep->vport == FDB_UPLINK_VPORT)
175                 goto out_notsupp;
176
177         if (pop && out_rep->vport == FDB_UPLINK_VPORT)
178                 goto out_notsupp;
179
180         /* vport has vlan push configured, can't offload VF --> wire rules w.o it */
181         if (!push && !pop && fwd)
182                 if (in_rep->vlan && out_rep->vport == FDB_UPLINK_VPORT)
183                         goto out_notsupp;
184
185         /* protects against (1) setting rules with different vlans to push and
186          * (2) setting rules w.o vlans (attr->vlan = 0) && w. vlans to push (!= 0)
187          */
188         if (push && in_rep->vlan_refcount && (in_rep->vlan != attr->vlan))
189                 goto out_notsupp;
190
191         return 0;
192
193 out_notsupp:
194         return -EOPNOTSUPP;
195 }
196
197 int mlx5_eswitch_add_vlan_action(struct mlx5_eswitch *esw,
198                                  struct mlx5_esw_flow_attr *attr)
199 {
200         struct offloads_fdb *offloads = &esw->fdb_table.offloads;
201         struct mlx5_eswitch_rep *vport = NULL;
202         bool push, pop, fwd;
203         int err = 0;
204
205         push = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH);
206         pop  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP);
207         fwd  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST);
208
209         err = esw_add_vlan_action_check(attr, push, pop, fwd);
210         if (err)
211                 return err;
212
213         attr->vlan_handled = false;
214
215         vport = esw_vlan_action_get_vport(attr, push, pop);
216
217         if (!push && !pop && fwd) {
218                 /* tracks VF --> wire rules without vlan push action */
219                 if (attr->out_rep->vport == FDB_UPLINK_VPORT) {
220                         vport->vlan_refcount++;
221                         attr->vlan_handled = true;
222                 }
223
224                 return 0;
225         }
226
227         if (!push && !pop)
228                 return 0;
229
230         if (!(offloads->vlan_push_pop_refcount)) {
231                 /* it's the 1st vlan rule, apply global vlan pop policy */
232                 err = esw_set_global_vlan_pop(esw, SET_VLAN_STRIP);
233                 if (err)
234                         goto out;
235         }
236         offloads->vlan_push_pop_refcount++;
237
238         if (push) {
239                 if (vport->vlan_refcount)
240                         goto skip_set_push;
241
242                 err = __mlx5_eswitch_set_vport_vlan(esw, vport->vport, attr->vlan, 0,
243                                                     SET_VLAN_INSERT | SET_VLAN_STRIP);
244                 if (err)
245                         goto out;
246                 vport->vlan = attr->vlan;
247 skip_set_push:
248                 vport->vlan_refcount++;
249         }
250 out:
251         if (!err)
252                 attr->vlan_handled = true;
253         return err;
254 }
255
256 int mlx5_eswitch_del_vlan_action(struct mlx5_eswitch *esw,
257                                  struct mlx5_esw_flow_attr *attr)
258 {
259         struct offloads_fdb *offloads = &esw->fdb_table.offloads;
260         struct mlx5_eswitch_rep *vport = NULL;
261         bool push, pop, fwd;
262         int err = 0;
263
264         if (!attr->vlan_handled)
265                 return 0;
266
267         push = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH);
268         pop  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP);
269         fwd  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST);
270
271         vport = esw_vlan_action_get_vport(attr, push, pop);
272
273         if (!push && !pop && fwd) {
274                 /* tracks VF --> wire rules without vlan push action */
275                 if (attr->out_rep->vport == FDB_UPLINK_VPORT)
276                         vport->vlan_refcount--;
277
278                 return 0;
279         }
280
281         if (push) {
282                 vport->vlan_refcount--;
283                 if (vport->vlan_refcount)
284                         goto skip_unset_push;
285
286                 vport->vlan = 0;
287                 err = __mlx5_eswitch_set_vport_vlan(esw, vport->vport,
288                                                     0, 0, SET_VLAN_STRIP);
289                 if (err)
290                         goto out;
291         }
292
293 skip_unset_push:
294         offloads->vlan_push_pop_refcount--;
295         if (offloads->vlan_push_pop_refcount)
296                 return 0;
297
298         /* no more vlan rules, stop global vlan pop policy */
299         err = esw_set_global_vlan_pop(esw, 0);
300
301 out:
302         return err;
303 }
304
305 struct mlx5_flow_handle *
306 mlx5_eswitch_add_send_to_vport_rule(struct mlx5_eswitch *esw, int vport, u32 sqn)
307 {
308         struct mlx5_flow_act flow_act = {0};
309         struct mlx5_flow_destination dest = {};
310         struct mlx5_flow_handle *flow_rule;
311         struct mlx5_flow_spec *spec;
312         void *misc;
313
314         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
315         if (!spec) {
316                 flow_rule = ERR_PTR(-ENOMEM);
317                 goto out;
318         }
319
320         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
321         MLX5_SET(fte_match_set_misc, misc, source_sqn, sqn);
322         MLX5_SET(fte_match_set_misc, misc, source_port, 0x0); /* source vport is 0 */
323
324         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
325         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_sqn);
326         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
327
328         spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS;
329         dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
330         dest.vport_num = vport;
331         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
332
333         flow_rule = mlx5_add_flow_rules(esw->fdb_table.offloads.fdb, spec,
334                                         &flow_act, &dest, 1);
335         if (IS_ERR(flow_rule))
336                 esw_warn(esw->dev, "FDB: Failed to add send to vport rule err %ld\n", PTR_ERR(flow_rule));
337 out:
338         kvfree(spec);
339         return flow_rule;
340 }
341 EXPORT_SYMBOL(mlx5_eswitch_add_send_to_vport_rule);
342
343 void mlx5_eswitch_del_send_to_vport_rule(struct mlx5_flow_handle *rule)
344 {
345         mlx5_del_flow_rules(rule);
346 }
347
348 static int esw_add_fdb_miss_rule(struct mlx5_eswitch *esw)
349 {
350         struct mlx5_flow_act flow_act = {0};
351         struct mlx5_flow_destination dest = {};
352         struct mlx5_flow_handle *flow_rule = NULL;
353         struct mlx5_flow_spec *spec;
354         void *headers_c;
355         void *headers_v;
356         int err = 0;
357         u8 *dmac_c;
358         u8 *dmac_v;
359
360         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
361         if (!spec) {
362                 err = -ENOMEM;
363                 goto out;
364         }
365
366         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
367         headers_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
368                                  outer_headers);
369         dmac_c = MLX5_ADDR_OF(fte_match_param, headers_c,
370                               outer_headers.dmac_47_16);
371         dmac_c[0] = 0x01;
372
373         dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
374         dest.vport_num = 0;
375         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
376
377         flow_rule = mlx5_add_flow_rules(esw->fdb_table.offloads.fdb, spec,
378                                         &flow_act, &dest, 1);
379         if (IS_ERR(flow_rule)) {
380                 err = PTR_ERR(flow_rule);
381                 esw_warn(esw->dev,  "FDB: Failed to add unicast miss flow rule err %d\n", err);
382                 goto out;
383         }
384
385         esw->fdb_table.offloads.miss_rule_uni = flow_rule;
386
387         headers_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
388                                  outer_headers);
389         dmac_v = MLX5_ADDR_OF(fte_match_param, headers_v,
390                               outer_headers.dmac_47_16);
391         dmac_v[0] = 0x01;
392         flow_rule = mlx5_add_flow_rules(esw->fdb_table.offloads.fdb, spec,
393                                         &flow_act, &dest, 1);
394         if (IS_ERR(flow_rule)) {
395                 err = PTR_ERR(flow_rule);
396                 esw_warn(esw->dev, "FDB: Failed to add multicast miss flow rule err %d\n", err);
397                 mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_uni);
398                 goto out;
399         }
400
401         esw->fdb_table.offloads.miss_rule_multi = flow_rule;
402
403 out:
404         kvfree(spec);
405         return err;
406 }
407
408 #define ESW_OFFLOADS_NUM_GROUPS  4
409
410 static int esw_create_offloads_fast_fdb_table(struct mlx5_eswitch *esw)
411 {
412         struct mlx5_core_dev *dev = esw->dev;
413         struct mlx5_flow_namespace *root_ns;
414         struct mlx5_flow_table *fdb = NULL;
415         int esw_size, err = 0;
416         u32 flags = 0;
417         u32 max_flow_counter = (MLX5_CAP_GEN(dev, max_flow_counter_31_16) << 16) |
418                                 MLX5_CAP_GEN(dev, max_flow_counter_15_0);
419
420         root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
421         if (!root_ns) {
422                 esw_warn(dev, "Failed to get FDB flow namespace\n");
423                 err = -EOPNOTSUPP;
424                 goto out;
425         }
426
427         esw_debug(dev, "Create offloads FDB table, min (max esw size(2^%d), max counters(%d)*groups(%d))\n",
428                   MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size),
429                   max_flow_counter, ESW_OFFLOADS_NUM_GROUPS);
430
431         esw_size = min_t(int, max_flow_counter * ESW_OFFLOADS_NUM_GROUPS,
432                          1 << MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size));
433
434         if (esw->offloads.encap != DEVLINK_ESWITCH_ENCAP_MODE_NONE)
435                 flags |= MLX5_FLOW_TABLE_TUNNEL_EN;
436
437         fdb = mlx5_create_auto_grouped_flow_table(root_ns, FDB_FAST_PATH,
438                                                   esw_size,
439                                                   ESW_OFFLOADS_NUM_GROUPS, 0,
440                                                   flags);
441         if (IS_ERR(fdb)) {
442                 err = PTR_ERR(fdb);
443                 esw_warn(dev, "Failed to create Fast path FDB Table err %d\n", err);
444                 goto out;
445         }
446         esw->fdb_table.fdb = fdb;
447
448 out:
449         return err;
450 }
451
452 static void esw_destroy_offloads_fast_fdb_table(struct mlx5_eswitch *esw)
453 {
454         mlx5_destroy_flow_table(esw->fdb_table.fdb);
455 }
456
457 #define MAX_PF_SQ 256
458 #define MAX_SQ_NVPORTS 32
459
460 static int esw_create_offloads_fdb_tables(struct mlx5_eswitch *esw, int nvports)
461 {
462         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
463         struct mlx5_flow_table_attr ft_attr = {};
464         struct mlx5_core_dev *dev = esw->dev;
465         struct mlx5_flow_namespace *root_ns;
466         struct mlx5_flow_table *fdb = NULL;
467         int table_size, ix, err = 0;
468         struct mlx5_flow_group *g;
469         void *match_criteria;
470         u32 *flow_group_in;
471         u8 *dmac;
472
473         esw_debug(esw->dev, "Create offloads FDB Tables\n");
474         flow_group_in = kvzalloc(inlen, GFP_KERNEL);
475         if (!flow_group_in)
476                 return -ENOMEM;
477
478         root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
479         if (!root_ns) {
480                 esw_warn(dev, "Failed to get FDB flow namespace\n");
481                 err = -EOPNOTSUPP;
482                 goto ns_err;
483         }
484
485         err = esw_create_offloads_fast_fdb_table(esw);
486         if (err)
487                 goto fast_fdb_err;
488
489         table_size = nvports * MAX_SQ_NVPORTS + MAX_PF_SQ + 2;
490
491         ft_attr.max_fte = table_size;
492         ft_attr.prio = FDB_SLOW_PATH;
493
494         fdb = mlx5_create_flow_table(root_ns, &ft_attr);
495         if (IS_ERR(fdb)) {
496                 err = PTR_ERR(fdb);
497                 esw_warn(dev, "Failed to create slow path FDB Table err %d\n", err);
498                 goto slow_fdb_err;
499         }
500         esw->fdb_table.offloads.fdb = fdb;
501
502         /* create send-to-vport group */
503         memset(flow_group_in, 0, inlen);
504         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
505                  MLX5_MATCH_MISC_PARAMETERS);
506
507         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
508
509         MLX5_SET_TO_ONES(fte_match_param, match_criteria, misc_parameters.source_sqn);
510         MLX5_SET_TO_ONES(fte_match_param, match_criteria, misc_parameters.source_port);
511
512         ix = nvports * MAX_SQ_NVPORTS + MAX_PF_SQ;
513         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
514         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, ix - 1);
515
516         g = mlx5_create_flow_group(fdb, flow_group_in);
517         if (IS_ERR(g)) {
518                 err = PTR_ERR(g);
519                 esw_warn(dev, "Failed to create send-to-vport flow group err(%d)\n", err);
520                 goto send_vport_err;
521         }
522         esw->fdb_table.offloads.send_to_vport_grp = g;
523
524         /* create miss group */
525         memset(flow_group_in, 0, inlen);
526         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
527                  MLX5_MATCH_OUTER_HEADERS);
528         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in,
529                                       match_criteria);
530         dmac = MLX5_ADDR_OF(fte_match_param, match_criteria,
531                             outer_headers.dmac_47_16);
532         dmac[0] = 0x01;
533
534         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, ix);
535         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, ix + 2);
536
537         g = mlx5_create_flow_group(fdb, flow_group_in);
538         if (IS_ERR(g)) {
539                 err = PTR_ERR(g);
540                 esw_warn(dev, "Failed to create miss flow group err(%d)\n", err);
541                 goto miss_err;
542         }
543         esw->fdb_table.offloads.miss_grp = g;
544
545         err = esw_add_fdb_miss_rule(esw);
546         if (err)
547                 goto miss_rule_err;
548
549         return 0;
550
551 miss_rule_err:
552         mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);
553 miss_err:
554         mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);
555 send_vport_err:
556         mlx5_destroy_flow_table(esw->fdb_table.offloads.fdb);
557 slow_fdb_err:
558         mlx5_destroy_flow_table(esw->fdb_table.fdb);
559 fast_fdb_err:
560 ns_err:
561         kvfree(flow_group_in);
562         return err;
563 }
564
565 static void esw_destroy_offloads_fdb_tables(struct mlx5_eswitch *esw)
566 {
567         if (!esw->fdb_table.fdb)
568                 return;
569
570         esw_debug(esw->dev, "Destroy offloads FDB Tables\n");
571         mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_multi);
572         mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_uni);
573         mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);
574         mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);
575
576         mlx5_destroy_flow_table(esw->fdb_table.offloads.fdb);
577         esw_destroy_offloads_fast_fdb_table(esw);
578 }
579
580 static int esw_create_offloads_table(struct mlx5_eswitch *esw)
581 {
582         struct mlx5_flow_table_attr ft_attr = {};
583         struct mlx5_core_dev *dev = esw->dev;
584         struct mlx5_flow_table *ft_offloads;
585         struct mlx5_flow_namespace *ns;
586         int err = 0;
587
588         ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_OFFLOADS);
589         if (!ns) {
590                 esw_warn(esw->dev, "Failed to get offloads flow namespace\n");
591                 return -EOPNOTSUPP;
592         }
593
594         ft_attr.max_fte = dev->priv.sriov.num_vfs + 2;
595
596         ft_offloads = mlx5_create_flow_table(ns, &ft_attr);
597         if (IS_ERR(ft_offloads)) {
598                 err = PTR_ERR(ft_offloads);
599                 esw_warn(esw->dev, "Failed to create offloads table, err %d\n", err);
600                 return err;
601         }
602
603         esw->offloads.ft_offloads = ft_offloads;
604         return 0;
605 }
606
607 static void esw_destroy_offloads_table(struct mlx5_eswitch *esw)
608 {
609         struct mlx5_esw_offload *offloads = &esw->offloads;
610
611         mlx5_destroy_flow_table(offloads->ft_offloads);
612 }
613
614 static int esw_create_vport_rx_group(struct mlx5_eswitch *esw)
615 {
616         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
617         struct mlx5_flow_group *g;
618         struct mlx5_priv *priv = &esw->dev->priv;
619         u32 *flow_group_in;
620         void *match_criteria, *misc;
621         int err = 0;
622         int nvports = priv->sriov.num_vfs + 2;
623
624         flow_group_in = kvzalloc(inlen, GFP_KERNEL);
625         if (!flow_group_in)
626                 return -ENOMEM;
627
628         /* create vport rx group */
629         memset(flow_group_in, 0, inlen);
630         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
631                  MLX5_MATCH_MISC_PARAMETERS);
632
633         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
634         misc = MLX5_ADDR_OF(fte_match_param, match_criteria, misc_parameters);
635         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
636
637         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
638         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, nvports - 1);
639
640         g = mlx5_create_flow_group(esw->offloads.ft_offloads, flow_group_in);
641
642         if (IS_ERR(g)) {
643                 err = PTR_ERR(g);
644                 mlx5_core_warn(esw->dev, "Failed to create vport rx group err %d\n", err);
645                 goto out;
646         }
647
648         esw->offloads.vport_rx_group = g;
649 out:
650         kfree(flow_group_in);
651         return err;
652 }
653
654 static void esw_destroy_vport_rx_group(struct mlx5_eswitch *esw)
655 {
656         mlx5_destroy_flow_group(esw->offloads.vport_rx_group);
657 }
658
659 struct mlx5_flow_handle *
660 mlx5_eswitch_create_vport_rx_rule(struct mlx5_eswitch *esw, int vport, u32 tirn)
661 {
662         struct mlx5_flow_act flow_act = {0};
663         struct mlx5_flow_destination dest = {};
664         struct mlx5_flow_handle *flow_rule;
665         struct mlx5_flow_spec *spec;
666         void *misc;
667
668         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
669         if (!spec) {
670                 flow_rule = ERR_PTR(-ENOMEM);
671                 goto out;
672         }
673
674         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
675         MLX5_SET(fte_match_set_misc, misc, source_port, vport);
676
677         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
678         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
679
680         spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS;
681         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
682         dest.tir_num = tirn;
683
684         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
685         flow_rule = mlx5_add_flow_rules(esw->offloads.ft_offloads, spec,
686                                         &flow_act, &dest, 1);
687         if (IS_ERR(flow_rule)) {
688                 esw_warn(esw->dev, "fs offloads: Failed to add vport rx rule err %ld\n", PTR_ERR(flow_rule));
689                 goto out;
690         }
691
692 out:
693         kvfree(spec);
694         return flow_rule;
695 }
696
697 static int esw_offloads_start(struct mlx5_eswitch *esw)
698 {
699         int err, err1, num_vfs = esw->dev->priv.sriov.num_vfs;
700
701         if (esw->mode != SRIOV_LEGACY) {
702                 esw_warn(esw->dev, "Can't set offloads mode, SRIOV legacy not enabled\n");
703                 return -EINVAL;
704         }
705
706         mlx5_eswitch_disable_sriov(esw);
707         err = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_OFFLOADS);
708         if (err) {
709                 esw_warn(esw->dev, "Failed setting eswitch to offloads, err %d\n", err);
710                 err1 = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_LEGACY);
711                 if (err1)
712                         esw_warn(esw->dev, "Failed setting eswitch back to legacy, err %d\n", err1);
713         }
714         if (esw->offloads.inline_mode == MLX5_INLINE_MODE_NONE) {
715                 if (mlx5_eswitch_inline_mode_get(esw,
716                                                  num_vfs,
717                                                  &esw->offloads.inline_mode)) {
718                         esw->offloads.inline_mode = MLX5_INLINE_MODE_L2;
719                         esw_warn(esw->dev, "Inline mode is different between vports\n");
720                 }
721         }
722         return err;
723 }
724
725 void esw_offloads_cleanup_reps(struct mlx5_eswitch *esw)
726 {
727         kfree(esw->offloads.vport_reps);
728 }
729
730 int esw_offloads_init_reps(struct mlx5_eswitch *esw)
731 {
732         int total_vfs = MLX5_TOTAL_VPORTS(esw->dev);
733         struct mlx5_core_dev *dev = esw->dev;
734         struct mlx5_esw_offload *offloads;
735         struct mlx5_eswitch_rep *rep;
736         u8 hw_id[ETH_ALEN];
737         int vport;
738
739         esw->offloads.vport_reps = kcalloc(total_vfs,
740                                            sizeof(struct mlx5_eswitch_rep),
741                                            GFP_KERNEL);
742         if (!esw->offloads.vport_reps)
743                 return -ENOMEM;
744
745         offloads = &esw->offloads;
746         mlx5_query_nic_vport_mac_address(dev, 0, hw_id);
747
748         for (vport = 0; vport < total_vfs; vport++) {
749                 rep = &offloads->vport_reps[vport];
750
751                 rep->vport = vport;
752                 ether_addr_copy(rep->hw_id, hw_id);
753         }
754
755         offloads->vport_reps[0].vport = FDB_UPLINK_VPORT;
756
757         return 0;
758 }
759
760 static void esw_offloads_unload_reps_type(struct mlx5_eswitch *esw, int nvports,
761                                           u8 rep_type)
762 {
763         struct mlx5_eswitch_rep *rep;
764         int vport;
765
766         for (vport = nvports - 1; vport >= 0; vport--) {
767                 rep = &esw->offloads.vport_reps[vport];
768                 if (!rep->rep_if[rep_type].valid)
769                         continue;
770
771                 rep->rep_if[rep_type].unload(rep);
772         }
773 }
774
775 static void esw_offloads_unload_reps(struct mlx5_eswitch *esw, int nvports)
776 {
777         u8 rep_type = NUM_REP_TYPES;
778
779         while (rep_type-- > 0)
780                 esw_offloads_unload_reps_type(esw, nvports, rep_type);
781 }
782
783 static int esw_offloads_load_reps_type(struct mlx5_eswitch *esw, int nvports,
784                                        u8 rep_type)
785 {
786         struct mlx5_eswitch_rep *rep;
787         int vport;
788         int err;
789
790         for (vport = 0; vport < nvports; vport++) {
791                 rep = &esw->offloads.vport_reps[vport];
792                 if (!rep->rep_if[rep_type].valid)
793                         continue;
794
795                 err = rep->rep_if[rep_type].load(esw->dev, rep);
796                 if (err)
797                         goto err_reps;
798         }
799
800         return 0;
801
802 err_reps:
803         esw_offloads_unload_reps_type(esw, vport, rep_type);
804         return err;
805 }
806
807 static int esw_offloads_load_reps(struct mlx5_eswitch *esw, int nvports)
808 {
809         u8 rep_type = 0;
810         int err;
811
812         for (rep_type = 0; rep_type < NUM_REP_TYPES; rep_type++) {
813                 err = esw_offloads_load_reps_type(esw, nvports, rep_type);
814                 if (err)
815                         goto err_reps;
816         }
817
818         return err;
819
820 err_reps:
821         while (rep_type-- > 0)
822                 esw_offloads_unload_reps_type(esw, nvports, rep_type);
823         return err;
824 }
825
826 int esw_offloads_init(struct mlx5_eswitch *esw, int nvports)
827 {
828         int err;
829
830         err = esw_create_offloads_fdb_tables(esw, nvports);
831         if (err)
832                 return err;
833
834         err = esw_create_offloads_table(esw);
835         if (err)
836                 goto create_ft_err;
837
838         err = esw_create_vport_rx_group(esw);
839         if (err)
840                 goto create_fg_err;
841
842         err = esw_offloads_load_reps(esw, nvports);
843         if (err)
844                 goto err_reps;
845
846         return 0;
847
848 err_reps:
849         esw_destroy_vport_rx_group(esw);
850
851 create_fg_err:
852         esw_destroy_offloads_table(esw);
853
854 create_ft_err:
855         esw_destroy_offloads_fdb_tables(esw);
856
857         return err;
858 }
859
860 static int esw_offloads_stop(struct mlx5_eswitch *esw)
861 {
862         int err, err1, num_vfs = esw->dev->priv.sriov.num_vfs;
863
864         mlx5_eswitch_disable_sriov(esw);
865         err = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_LEGACY);
866         if (err) {
867                 esw_warn(esw->dev, "Failed setting eswitch to legacy, err %d\n", err);
868                 err1 = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_OFFLOADS);
869                 if (err1)
870                         esw_warn(esw->dev, "Failed setting eswitch back to offloads, err %d\n", err);
871         }
872
873         /* enable back PF RoCE */
874         mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
875
876         return err;
877 }
878
879 void esw_offloads_cleanup(struct mlx5_eswitch *esw, int nvports)
880 {
881         esw_offloads_unload_reps(esw, nvports);
882         esw_destroy_vport_rx_group(esw);
883         esw_destroy_offloads_table(esw);
884         esw_destroy_offloads_fdb_tables(esw);
885 }
886
887 static int esw_mode_from_devlink(u16 mode, u16 *mlx5_mode)
888 {
889         switch (mode) {
890         case DEVLINK_ESWITCH_MODE_LEGACY:
891                 *mlx5_mode = SRIOV_LEGACY;
892                 break;
893         case DEVLINK_ESWITCH_MODE_SWITCHDEV:
894                 *mlx5_mode = SRIOV_OFFLOADS;
895                 break;
896         default:
897                 return -EINVAL;
898         }
899
900         return 0;
901 }
902
903 static int esw_mode_to_devlink(u16 mlx5_mode, u16 *mode)
904 {
905         switch (mlx5_mode) {
906         case SRIOV_LEGACY:
907                 *mode = DEVLINK_ESWITCH_MODE_LEGACY;
908                 break;
909         case SRIOV_OFFLOADS:
910                 *mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
911                 break;
912         default:
913                 return -EINVAL;
914         }
915
916         return 0;
917 }
918
919 static int esw_inline_mode_from_devlink(u8 mode, u8 *mlx5_mode)
920 {
921         switch (mode) {
922         case DEVLINK_ESWITCH_INLINE_MODE_NONE:
923                 *mlx5_mode = MLX5_INLINE_MODE_NONE;
924                 break;
925         case DEVLINK_ESWITCH_INLINE_MODE_LINK:
926                 *mlx5_mode = MLX5_INLINE_MODE_L2;
927                 break;
928         case DEVLINK_ESWITCH_INLINE_MODE_NETWORK:
929                 *mlx5_mode = MLX5_INLINE_MODE_IP;
930                 break;
931         case DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT:
932                 *mlx5_mode = MLX5_INLINE_MODE_TCP_UDP;
933                 break;
934         default:
935                 return -EINVAL;
936         }
937
938         return 0;
939 }
940
941 static int esw_inline_mode_to_devlink(u8 mlx5_mode, u8 *mode)
942 {
943         switch (mlx5_mode) {
944         case MLX5_INLINE_MODE_NONE:
945                 *mode = DEVLINK_ESWITCH_INLINE_MODE_NONE;
946                 break;
947         case MLX5_INLINE_MODE_L2:
948                 *mode = DEVLINK_ESWITCH_INLINE_MODE_LINK;
949                 break;
950         case MLX5_INLINE_MODE_IP:
951                 *mode = DEVLINK_ESWITCH_INLINE_MODE_NETWORK;
952                 break;
953         case MLX5_INLINE_MODE_TCP_UDP:
954                 *mode = DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT;
955                 break;
956         default:
957                 return -EINVAL;
958         }
959
960         return 0;
961 }
962
963 static int mlx5_devlink_eswitch_check(struct devlink *devlink)
964 {
965         struct mlx5_core_dev *dev = devlink_priv(devlink);
966
967         if (MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH)
968                 return -EOPNOTSUPP;
969
970         if (!MLX5_CAP_GEN(dev, vport_group_manager))
971                 return -EOPNOTSUPP;
972
973         if (dev->priv.eswitch->mode == SRIOV_NONE)
974                 return -EOPNOTSUPP;
975
976         return 0;
977 }
978
979 int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode)
980 {
981         struct mlx5_core_dev *dev = devlink_priv(devlink);
982         u16 cur_mlx5_mode, mlx5_mode = 0;
983         int err;
984
985         err = mlx5_devlink_eswitch_check(devlink);
986         if (err)
987                 return err;
988
989         cur_mlx5_mode = dev->priv.eswitch->mode;
990
991         if (esw_mode_from_devlink(mode, &mlx5_mode))
992                 return -EINVAL;
993
994         if (cur_mlx5_mode == mlx5_mode)
995                 return 0;
996
997         if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV)
998                 return esw_offloads_start(dev->priv.eswitch);
999         else if (mode == DEVLINK_ESWITCH_MODE_LEGACY)
1000                 return esw_offloads_stop(dev->priv.eswitch);
1001         else
1002                 return -EINVAL;
1003 }
1004
1005 int mlx5_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
1006 {
1007         struct mlx5_core_dev *dev = devlink_priv(devlink);
1008         int err;
1009
1010         err = mlx5_devlink_eswitch_check(devlink);
1011         if (err)
1012                 return err;
1013
1014         return esw_mode_to_devlink(dev->priv.eswitch->mode, mode);
1015 }
1016
1017 int mlx5_devlink_eswitch_inline_mode_set(struct devlink *devlink, u8 mode)
1018 {
1019         struct mlx5_core_dev *dev = devlink_priv(devlink);
1020         struct mlx5_eswitch *esw = dev->priv.eswitch;
1021         int err, vport;
1022         u8 mlx5_mode;
1023
1024         err = mlx5_devlink_eswitch_check(devlink);
1025         if (err)
1026                 return err;
1027
1028         switch (MLX5_CAP_ETH(dev, wqe_inline_mode)) {
1029         case MLX5_CAP_INLINE_MODE_NOT_REQUIRED:
1030                 if (mode == DEVLINK_ESWITCH_INLINE_MODE_NONE)
1031                         return 0;
1032                 /* fall through */
1033         case MLX5_CAP_INLINE_MODE_L2:
1034                 esw_warn(dev, "Inline mode can't be set\n");
1035                 return -EOPNOTSUPP;
1036         case MLX5_CAP_INLINE_MODE_VPORT_CONTEXT:
1037                 break;
1038         }
1039
1040         if (esw->offloads.num_flows > 0) {
1041                 esw_warn(dev, "Can't set inline mode when flows are configured\n");
1042                 return -EOPNOTSUPP;
1043         }
1044
1045         err = esw_inline_mode_from_devlink(mode, &mlx5_mode);
1046         if (err)
1047                 goto out;
1048
1049         for (vport = 1; vport < esw->enabled_vports; vport++) {
1050                 err = mlx5_modify_nic_vport_min_inline(dev, vport, mlx5_mode);
1051                 if (err) {
1052                         esw_warn(dev, "Failed to set min inline on vport %d\n",
1053                                  vport);
1054                         goto revert_inline_mode;
1055                 }
1056         }
1057
1058         esw->offloads.inline_mode = mlx5_mode;
1059         return 0;
1060
1061 revert_inline_mode:
1062         while (--vport > 0)
1063                 mlx5_modify_nic_vport_min_inline(dev,
1064                                                  vport,
1065                                                  esw->offloads.inline_mode);
1066 out:
1067         return err;
1068 }
1069
1070 int mlx5_devlink_eswitch_inline_mode_get(struct devlink *devlink, u8 *mode)
1071 {
1072         struct mlx5_core_dev *dev = devlink_priv(devlink);
1073         struct mlx5_eswitch *esw = dev->priv.eswitch;
1074         int err;
1075
1076         err = mlx5_devlink_eswitch_check(devlink);
1077         if (err)
1078                 return err;
1079
1080         return esw_inline_mode_to_devlink(esw->offloads.inline_mode, mode);
1081 }
1082
1083 int mlx5_eswitch_inline_mode_get(struct mlx5_eswitch *esw, int nvfs, u8 *mode)
1084 {
1085         u8 prev_mlx5_mode, mlx5_mode = MLX5_INLINE_MODE_L2;
1086         struct mlx5_core_dev *dev = esw->dev;
1087         int vport;
1088
1089         if (!MLX5_CAP_GEN(dev, vport_group_manager))
1090                 return -EOPNOTSUPP;
1091
1092         if (esw->mode == SRIOV_NONE)
1093                 return -EOPNOTSUPP;
1094
1095         switch (MLX5_CAP_ETH(dev, wqe_inline_mode)) {
1096         case MLX5_CAP_INLINE_MODE_NOT_REQUIRED:
1097                 mlx5_mode = MLX5_INLINE_MODE_NONE;
1098                 goto out;
1099         case MLX5_CAP_INLINE_MODE_L2:
1100                 mlx5_mode = MLX5_INLINE_MODE_L2;
1101                 goto out;
1102         case MLX5_CAP_INLINE_MODE_VPORT_CONTEXT:
1103                 goto query_vports;
1104         }
1105
1106 query_vports:
1107         for (vport = 1; vport <= nvfs; vport++) {
1108                 mlx5_query_nic_vport_min_inline(dev, vport, &mlx5_mode);
1109                 if (vport > 1 && prev_mlx5_mode != mlx5_mode)
1110                         return -EINVAL;
1111                 prev_mlx5_mode = mlx5_mode;
1112         }
1113
1114 out:
1115         *mode = mlx5_mode;
1116         return 0;
1117 }
1118
1119 int mlx5_devlink_eswitch_encap_mode_set(struct devlink *devlink, u8 encap)
1120 {
1121         struct mlx5_core_dev *dev = devlink_priv(devlink);
1122         struct mlx5_eswitch *esw = dev->priv.eswitch;
1123         int err;
1124
1125         err = mlx5_devlink_eswitch_check(devlink);
1126         if (err)
1127                 return err;
1128
1129         if (encap != DEVLINK_ESWITCH_ENCAP_MODE_NONE &&
1130             (!MLX5_CAP_ESW_FLOWTABLE_FDB(dev, encap) ||
1131              !MLX5_CAP_ESW_FLOWTABLE_FDB(dev, decap)))
1132                 return -EOPNOTSUPP;
1133
1134         if (encap && encap != DEVLINK_ESWITCH_ENCAP_MODE_BASIC)
1135                 return -EOPNOTSUPP;
1136
1137         if (esw->mode == SRIOV_LEGACY) {
1138                 esw->offloads.encap = encap;
1139                 return 0;
1140         }
1141
1142         if (esw->offloads.encap == encap)
1143                 return 0;
1144
1145         if (esw->offloads.num_flows > 0) {
1146                 esw_warn(dev, "Can't set encapsulation when flows are configured\n");
1147                 return -EOPNOTSUPP;
1148         }
1149
1150         esw_destroy_offloads_fast_fdb_table(esw);
1151
1152         esw->offloads.encap = encap;
1153         err = esw_create_offloads_fast_fdb_table(esw);
1154         if (err) {
1155                 esw_warn(esw->dev, "Failed re-creating fast FDB table, err %d\n", err);
1156                 esw->offloads.encap = !encap;
1157                 (void)esw_create_offloads_fast_fdb_table(esw);
1158         }
1159         return err;
1160 }
1161
1162 int mlx5_devlink_eswitch_encap_mode_get(struct devlink *devlink, u8 *encap)
1163 {
1164         struct mlx5_core_dev *dev = devlink_priv(devlink);
1165         struct mlx5_eswitch *esw = dev->priv.eswitch;
1166         int err;
1167
1168         err = mlx5_devlink_eswitch_check(devlink);
1169         if (err)
1170                 return err;
1171
1172         *encap = esw->offloads.encap;
1173         return 0;
1174 }
1175
1176 void mlx5_eswitch_register_vport_rep(struct mlx5_eswitch *esw,
1177                                      int vport_index,
1178                                      struct mlx5_eswitch_rep_if *__rep_if,
1179                                      u8 rep_type)
1180 {
1181         struct mlx5_esw_offload *offloads = &esw->offloads;
1182         struct mlx5_eswitch_rep_if *rep_if;
1183
1184         rep_if = &offloads->vport_reps[vport_index].rep_if[rep_type];
1185
1186         rep_if->load   = __rep_if->load;
1187         rep_if->unload = __rep_if->unload;
1188         rep_if->get_proto_dev = __rep_if->get_proto_dev;
1189         rep_if->priv = __rep_if->priv;
1190
1191         rep_if->valid = true;
1192 }
1193 EXPORT_SYMBOL(mlx5_eswitch_register_vport_rep);
1194
1195 void mlx5_eswitch_unregister_vport_rep(struct mlx5_eswitch *esw,
1196                                        int vport_index, u8 rep_type)
1197 {
1198         struct mlx5_esw_offload *offloads = &esw->offloads;
1199         struct mlx5_eswitch_rep *rep;
1200
1201         rep = &offloads->vport_reps[vport_index];
1202
1203         if (esw->mode == SRIOV_OFFLOADS && esw->vports[vport_index].enabled)
1204                 rep->rep_if[rep_type].unload(rep);
1205
1206         rep->rep_if[rep_type].valid = false;
1207 }
1208 EXPORT_SYMBOL(mlx5_eswitch_unregister_vport_rep);
1209
1210 void *mlx5_eswitch_get_uplink_priv(struct mlx5_eswitch *esw, u8 rep_type)
1211 {
1212 #define UPLINK_REP_INDEX 0
1213         struct mlx5_esw_offload *offloads = &esw->offloads;
1214         struct mlx5_eswitch_rep *rep;
1215
1216         rep = &offloads->vport_reps[UPLINK_REP_INDEX];
1217         return rep->rep_if[rep_type].priv;
1218 }
1219
1220 void *mlx5_eswitch_get_proto_dev(struct mlx5_eswitch *esw,
1221                                  int vport,
1222                                  u8 rep_type)
1223 {
1224         struct mlx5_esw_offload *offloads = &esw->offloads;
1225         struct mlx5_eswitch_rep *rep;
1226
1227         if (vport == FDB_UPLINK_VPORT)
1228                 vport = UPLINK_REP_INDEX;
1229
1230         rep = &offloads->vport_reps[vport];
1231
1232         if (rep->rep_if[rep_type].valid &&
1233             rep->rep_if[rep_type].get_proto_dev)
1234                 return rep->rep_if[rep_type].get_proto_dev(rep);
1235         return NULL;
1236 }
1237 EXPORT_SYMBOL(mlx5_eswitch_get_proto_dev);
1238
1239 void *mlx5_eswitch_uplink_get_proto_dev(struct mlx5_eswitch *esw, u8 rep_type)
1240 {
1241         return mlx5_eswitch_get_proto_dev(esw, UPLINK_REP_INDEX, rep_type);
1242 }
1243 EXPORT_SYMBOL(mlx5_eswitch_uplink_get_proto_dev);
1244
1245 struct mlx5_eswitch_rep *mlx5_eswitch_vport_rep(struct mlx5_eswitch *esw,
1246                                                 int vport)
1247 {
1248         return &esw->offloads.vport_reps[vport];
1249 }
1250 EXPORT_SYMBOL(mlx5_eswitch_vport_rep);