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_rule *
  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 = { 0 };
  52         struct mlx5_fc *counter = NULL;
  53         struct mlx5_flow_rule *rule;
  54         void *misc;
  55         int action;
  56
  57         if (esw->mode != SRIOV_OFFLOADS)
  58                 return ERR_PTR(-EOPNOTSUPP);
  59
  60         /* per flow vlan pop/push is emulated, don't set that into the firmware */
  61         action = attr->action & ~(MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH | MLX5_FLOW_CONTEXT_ACTION_VLAN_POP);
  62
  63         if (action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {
  64                 dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
  65                 dest.vport_num = attr->out_rep->vport;
  66                 action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
  67         } else if (action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {
  68                 counter = mlx5_fc_create(esw->dev, true);
  69                 if (IS_ERR(counter))
  70                         return ERR_CAST(counter);
  71                 dest.type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;
  72                 dest.counter = counter;
  73         }
  74
  75         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
  76         MLX5_SET(fte_match_set_misc, misc, source_port, attr->in_rep->vport);
  77
  78         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
  79         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
  80
  81         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS |
  82                                       MLX5_MATCH_MISC_PARAMETERS;
  83
  84         rule = mlx5_add_flow_rule((struct mlx5_flow_table *)esw->fdb_table.fdb,
  85                                   spec, action, 0, &dest);
  86
  87         if (IS_ERR(rule))
  88                 mlx5_fc_destroy(esw->dev, counter);
  89
  90         return rule;
  91 }
  92
  93 static int esw_set_global_vlan_pop(struct mlx5_eswitch *esw, u8 val)
  94 {
  95         struct mlx5_eswitch_rep *rep;
  96         int vf_vport, err = 0;
  97
  98         esw_debug(esw->dev, "%s applying global %s policy\n", __func__, val ? "pop" : "none");
  99         for (vf_vport = 1; vf_vport < esw->enabled_vports; vf_vport++) {
 100                 rep = &esw->offloads.vport_reps[vf_vport];
 101                 if (!rep->valid)
 102                         continue;
 103
 104                 err = __mlx5_eswitch_set_vport_vlan(esw, rep->vport, 0, 0, val);
 105                 if (err)
 106                         goto out;
 107         }
 108
 109 out:
 110         return err;
 111 }
 112
 113 static struct mlx5_eswitch_rep *
 114 esw_vlan_action_get_vport(struct mlx5_esw_flow_attr *attr, bool push, bool pop)
 115 {
 116         struct mlx5_eswitch_rep *in_rep, *out_rep, *vport = NULL;
 117
 118         in_rep  = attr->in_rep;
 119         out_rep = attr->out_rep;
 120
 121         if (push)
 122                 vport = in_rep;
 123         else if (pop)
 124                 vport = out_rep;
 125         else
 126                 vport = in_rep;
 127
 128         return vport;
 129 }
 130
 131 static int esw_add_vlan_action_check(struct mlx5_esw_flow_attr *attr,
 132                                      bool push, bool pop, bool fwd)
 133 {
 134         struct mlx5_eswitch_rep *in_rep, *out_rep;
 135
 136         if ((push || pop) && !fwd)
 137                 goto out_notsupp;
 138
 139         in_rep  = attr->in_rep;
 140         out_rep = attr->out_rep;
 141
 142         if (push && in_rep->vport == FDB_UPLINK_VPORT)
 143                 goto out_notsupp;
 144
 145         if (pop && out_rep->vport == FDB_UPLINK_VPORT)
 146                 goto out_notsupp;
 147
 148         /* vport has vlan push configured, can't offload VF --> wire rules w.o it */
 149         if (!push && !pop && fwd)
 150                 if (in_rep->vlan && out_rep->vport == FDB_UPLINK_VPORT)
 151                         goto out_notsupp;
 152
 153         /* protects against (1) setting rules with different vlans to push and
 154          * (2) setting rules w.o vlans (attr->vlan = 0) && w. vlans to push (!= 0)
 155          */
 156         if (push && in_rep->vlan_refcount && (in_rep->vlan != attr->vlan))
 157                 goto out_notsupp;
 158
 159         return 0;
 160
 161 out_notsupp:
 162         return -ENOTSUPP;
 163 }
 164
 165 int mlx5_eswitch_add_vlan_action(struct mlx5_eswitch *esw,
 166                                  struct mlx5_esw_flow_attr *attr)
 167 {
 168         struct offloads_fdb *offloads = &esw->fdb_table.offloads;
 169         struct mlx5_eswitch_rep *vport = NULL;
 170         bool push, pop, fwd;
 171         int err = 0;
 172
 173         push = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH);
 174         pop  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP);
 175         fwd  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST);
 176
 177         err = esw_add_vlan_action_check(attr, push, pop, fwd);
 178         if (err)
 179                 return err;
 180
 181         attr->vlan_handled = false;
 182
 183         vport = esw_vlan_action_get_vport(attr, push, pop);
 184
 185         if (!push && !pop && fwd) {
 186                 /* tracks VF --> wire rules without vlan push action */
 187                 if (attr->out_rep->vport == FDB_UPLINK_VPORT) {
 188                         vport->vlan_refcount++;
 189                         attr->vlan_handled = true;
 190                 }
 191
 192                 return 0;
 193         }
 194
 195         if (!push && !pop)
 196                 return 0;
 197
 198         if (!(offloads->vlan_push_pop_refcount)) {
 199                 /* it's the 1st vlan rule, apply global vlan pop policy */
 200                 err = esw_set_global_vlan_pop(esw, SET_VLAN_STRIP);
 201                 if (err)
 202                         goto out;
 203         }
 204         offloads->vlan_push_pop_refcount++;
 205
 206         if (push) {
 207                 if (vport->vlan_refcount)
 208                         goto skip_set_push;
 209
 210                 err = __mlx5_eswitch_set_vport_vlan(esw, vport->vport, attr->vlan, 0,
 211                                                     SET_VLAN_INSERT | SET_VLAN_STRIP);
 212                 if (err)
 213                         goto out;
 214                 vport->vlan = attr->vlan;
 215 skip_set_push:
 216                 vport->vlan_refcount++;
 217         }
 218 out:
 219         if (!err)
 220                 attr->vlan_handled = true;
 221         return err;
 222 }
 223
 224 int mlx5_eswitch_del_vlan_action(struct mlx5_eswitch *esw,
 225                                  struct mlx5_esw_flow_attr *attr)
 226 {
 227         struct offloads_fdb *offloads = &esw->fdb_table.offloads;
 228         struct mlx5_eswitch_rep *vport = NULL;
 229         bool push, pop, fwd;
 230         int err = 0;
 231
 232         if (!attr->vlan_handled)
 233                 return 0;
 234
 235         push = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH);
 236         pop  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_VLAN_POP);
 237         fwd  = !!(attr->action & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST);
 238
 239         vport = esw_vlan_action_get_vport(attr, push, pop);
 240
 241         if (!push && !pop && fwd) {
 242                 /* tracks VF --> wire rules without vlan push action */
 243                 if (attr->out_rep->vport == FDB_UPLINK_VPORT)
 244                         vport->vlan_refcount--;
 245
 246                 return 0;
 247         }
 248
 249         if (push) {
 250                 vport->vlan_refcount--;
 251                 if (vport->vlan_refcount)
 252                         goto skip_unset_push;
 253
 254                 vport->vlan = 0;
 255                 err = __mlx5_eswitch_set_vport_vlan(esw, vport->vport,
 256                                                     0, 0, SET_VLAN_STRIP);
 257                 if (err)
 258                         goto out;
 259         }
 260
 261 skip_unset_push:
 262         offloads->vlan_push_pop_refcount--;
 263         if (offloads->vlan_push_pop_refcount)
 264                 return 0;
 265
 266         /* no more vlan rules, stop global vlan pop policy */
 267         err = esw_set_global_vlan_pop(esw, 0);
 268
 269 out:
 270         return err;
 271 }
 272
 273 static struct mlx5_flow_rule *
 274 mlx5_eswitch_add_send_to_vport_rule(struct mlx5_eswitch *esw, int vport, u32 sqn)
 275 {
 276         struct mlx5_flow_destination dest;
 277         struct mlx5_flow_rule *flow_rule;
 278         struct mlx5_flow_spec *spec;
 279         void *misc;
 280
 281         spec = mlx5_vzalloc(sizeof(*spec));
 282         if (!spec) {
 283                 esw_warn(esw->dev, "FDB: Failed to alloc match parameters\n");
 284                 flow_rule = ERR_PTR(-ENOMEM);
 285                 goto out;
 286         }
 287
 288         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
 289         MLX5_SET(fte_match_set_misc, misc, source_sqn, sqn);
 290         MLX5_SET(fte_match_set_misc, misc, source_port, 0x0); /* source vport is 0 */
 291
 292         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
 293         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_sqn);
 294         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
 295
 296         spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS;
 297         dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
 298         dest.vport_num = vport;
 299
 300         flow_rule = mlx5_add_flow_rule(esw->fdb_table.offloads.fdb, spec,
 301                                        MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
 302                                        0, &dest);
 303         if (IS_ERR(flow_rule))
 304                 esw_warn(esw->dev, "FDB: Failed to add send to vport rule err %ld\n", PTR_ERR(flow_rule));
 305 out:
 306         kvfree(spec);
 307         return flow_rule;
 308 }
 309
 310 void mlx5_eswitch_sqs2vport_stop(struct mlx5_eswitch *esw,
 311                                  struct mlx5_eswitch_rep *rep)
 312 {
 313         struct mlx5_esw_sq *esw_sq, *tmp;
 314
 315         if (esw->mode != SRIOV_OFFLOADS)
 316                 return;
 317
 318         list_for_each_entry_safe(esw_sq, tmp, &rep->vport_sqs_list, list) {
 319                 mlx5_del_flow_rule(esw_sq->send_to_vport_rule);
 320                 list_del(&esw_sq->list);
 321                 kfree(esw_sq);
 322         }
 323 }
 324
 325 int mlx5_eswitch_sqs2vport_start(struct mlx5_eswitch *esw,
 326                                  struct mlx5_eswitch_rep *rep,
 327                                  u16 *sqns_array, int sqns_num)
 328 {
 329         struct mlx5_flow_rule *flow_rule;
 330         struct mlx5_esw_sq *esw_sq;
 331         int err;
 332         int i;
 333
 334         if (esw->mode != SRIOV_OFFLOADS)
 335                 return 0;
 336
 337         for (i = 0; i < sqns_num; i++) {
 338                 esw_sq = kzalloc(sizeof(*esw_sq), GFP_KERNEL);
 339                 if (!esw_sq) {
 340                         err = -ENOMEM;
 341                         goto out_err;
 342                 }
 343
 344                 /* Add re-inject rule to the PF/representor sqs */
 345                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw,
 346                                                                 rep->vport,
 347                                                                 sqns_array[i]);
 348                 if (IS_ERR(flow_rule)) {
 349                         err = PTR_ERR(flow_rule);
 350                         kfree(esw_sq);
 351                         goto out_err;
 352                 }
 353                 esw_sq->send_to_vport_rule = flow_rule;
 354                 list_add(&esw_sq->list, &rep->vport_sqs_list);
 355         }
 356         return 0;
 357
 358 out_err:
 359         mlx5_eswitch_sqs2vport_stop(esw, rep);
 360         return err;
 361 }
 362
 363 static int esw_add_fdb_miss_rule(struct mlx5_eswitch *esw)
 364 {
 365         struct mlx5_flow_destination dest;
 366         struct mlx5_flow_rule *flow_rule = NULL;
 367         struct mlx5_flow_spec *spec;
 368         int err = 0;
 369
 370         spec = mlx5_vzalloc(sizeof(*spec));
 371         if (!spec) {
 372                 esw_warn(esw->dev, "FDB: Failed to alloc match parameters\n");
 373                 err = -ENOMEM;
 374                 goto out;
 375         }
 376
 377         dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
 378         dest.vport_num = 0;
 379
 380         flow_rule = mlx5_add_flow_rule(esw->fdb_table.offloads.fdb, spec,
 381                                        MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
 382                                        0, &dest);
 383         if (IS_ERR(flow_rule)) {
 384                 err = PTR_ERR(flow_rule);
 385                 esw_warn(esw->dev,  "FDB: Failed to add miss flow rule err %d\n", err);
 386                 goto out;
 387         }
 388
 389         esw->fdb_table.offloads.miss_rule = flow_rule;
 390 out:
 391         kvfree(spec);
 392         return err;
 393 }
 394
 395 #define MAX_PF_SQ 256
 396 #define ESW_OFFLOADS_NUM_ENTRIES (1 << 13) /* 8K */
 397 #define ESW_OFFLOADS_NUM_GROUPS  4
 398
 399 static int esw_create_offloads_fdb_table(struct mlx5_eswitch *esw, int nvports)
 400 {
 401         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 402         struct mlx5_core_dev *dev = esw->dev;
 403         struct mlx5_flow_namespace *root_ns;
 404         struct mlx5_flow_table *fdb = NULL;
 405         struct mlx5_flow_group *g;
 406         u32 *flow_group_in;
 407         void *match_criteria;
 408         int table_size, ix, err = 0;
 409
 410         flow_group_in = mlx5_vzalloc(inlen);
 411         if (!flow_group_in)
 412                 return -ENOMEM;
 413
 414         root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
 415         if (!root_ns) {
 416                 esw_warn(dev, "Failed to get FDB flow namespace\n");
 417                 goto ns_err;
 418         }
 419
 420         esw_debug(dev, "Create offloads FDB table, log_max_size(%d)\n",
 421                   MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size));
 422
 423         fdb = mlx5_create_auto_grouped_flow_table(root_ns, FDB_FAST_PATH,
 424                                                   ESW_OFFLOADS_NUM_ENTRIES,
 425                                                   ESW_OFFLOADS_NUM_GROUPS, 0);
 426         if (IS_ERR(fdb)) {
 427                 err = PTR_ERR(fdb);
 428                 esw_warn(dev, "Failed to create Fast path FDB Table err %d\n", err);
 429                 goto fast_fdb_err;
 430         }
 431         esw->fdb_table.fdb = fdb;
 432
 433         table_size = nvports + MAX_PF_SQ + 1;
 434         fdb = mlx5_create_flow_table(root_ns, FDB_SLOW_PATH, table_size, 0);
 435         if (IS_ERR(fdb)) {
 436                 err = PTR_ERR(fdb);
 437                 esw_warn(dev, "Failed to create slow path FDB Table err %d\n", err);
 438                 goto slow_fdb_err;
 439         }
 440         esw->fdb_table.offloads.fdb = fdb;
 441
 442         /* create send-to-vport group */
 443         memset(flow_group_in, 0, inlen);
 444         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
 445                  MLX5_MATCH_MISC_PARAMETERS);
 446
 447         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
 448
 449         MLX5_SET_TO_ONES(fte_match_param, match_criteria, misc_parameters.source_sqn);
 450         MLX5_SET_TO_ONES(fte_match_param, match_criteria, misc_parameters.source_port);
 451
 452         ix = nvports + MAX_PF_SQ;
 453         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
 454         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, ix - 1);
 455
 456         g = mlx5_create_flow_group(fdb, flow_group_in);
 457         if (IS_ERR(g)) {
 458                 err = PTR_ERR(g);
 459                 esw_warn(dev, "Failed to create send-to-vport flow group err(%d)\n", err);
 460                 goto send_vport_err;
 461         }
 462         esw->fdb_table.offloads.send_to_vport_grp = g;
 463
 464         /* create miss group */
 465         memset(flow_group_in, 0, inlen);
 466         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, 0);
 467
 468         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, ix);
 469         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, ix + 1);
 470
 471         g = mlx5_create_flow_group(fdb, flow_group_in);
 472         if (IS_ERR(g)) {
 473                 err = PTR_ERR(g);
 474                 esw_warn(dev, "Failed to create miss flow group err(%d)\n", err);
 475                 goto miss_err;
 476         }
 477         esw->fdb_table.offloads.miss_grp = g;
 478
 479         err = esw_add_fdb_miss_rule(esw);
 480         if (err)
 481                 goto miss_rule_err;
 482
 483         return 0;
 484
 485 miss_rule_err:
 486         mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);
 487 miss_err:
 488         mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);
 489 send_vport_err:
 490         mlx5_destroy_flow_table(esw->fdb_table.offloads.fdb);
 491 slow_fdb_err:
 492         mlx5_destroy_flow_table(esw->fdb_table.fdb);
 493 fast_fdb_err:
 494 ns_err:
 495         kvfree(flow_group_in);
 496         return err;
 497 }
 498
 499 static void esw_destroy_offloads_fdb_table(struct mlx5_eswitch *esw)
 500 {
 501         if (!esw->fdb_table.fdb)
 502                 return;
 503
 504         esw_debug(esw->dev, "Destroy offloads FDB Table\n");
 505         mlx5_del_flow_rule(esw->fdb_table.offloads.miss_rule);
 506         mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);
 507         mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);
 508
 509         mlx5_destroy_flow_table(esw->fdb_table.offloads.fdb);
 510         mlx5_destroy_flow_table(esw->fdb_table.fdb);
 511 }
 512
 513 static int esw_create_offloads_table(struct mlx5_eswitch *esw)
 514 {
 515         struct mlx5_flow_namespace *ns;
 516         struct mlx5_flow_table *ft_offloads;
 517         struct mlx5_core_dev *dev = esw->dev;
 518         int err = 0;
 519
 520         ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_OFFLOADS);
 521         if (!ns) {
 522                 esw_warn(esw->dev, "Failed to get offloads flow namespace\n");
 523                 return -ENOMEM;
 524         }
 525
 526         ft_offloads = mlx5_create_flow_table(ns, 0, dev->priv.sriov.num_vfs + 2, 0);
 527         if (IS_ERR(ft_offloads)) {
 528                 err = PTR_ERR(ft_offloads);
 529                 esw_warn(esw->dev, "Failed to create offloads table, err %d\n", err);
 530                 return err;
 531         }
 532
 533         esw->offloads.ft_offloads = ft_offloads;
 534         return 0;
 535 }
 536
 537 static void esw_destroy_offloads_table(struct mlx5_eswitch *esw)
 538 {
 539         struct mlx5_esw_offload *offloads = &esw->offloads;
 540
 541         mlx5_destroy_flow_table(offloads->ft_offloads);
 542 }
 543
 544 static int esw_create_vport_rx_group(struct mlx5_eswitch *esw)
 545 {
 546         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 547         struct mlx5_flow_group *g;
 548         struct mlx5_priv *priv = &esw->dev->priv;
 549         u32 *flow_group_in;
 550         void *match_criteria, *misc;
 551         int err = 0;
 552         int nvports = priv->sriov.num_vfs + 2;
 553
 554         flow_group_in = mlx5_vzalloc(inlen);
 555         if (!flow_group_in)
 556                 return -ENOMEM;
 557
 558         /* create vport rx group */
 559         memset(flow_group_in, 0, inlen);
 560         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
 561                  MLX5_MATCH_MISC_PARAMETERS);
 562
 563         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
 564         misc = MLX5_ADDR_OF(fte_match_param, match_criteria, misc_parameters);
 565         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
 566
 567         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
 568         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, nvports - 1);
 569
 570         g = mlx5_create_flow_group(esw->offloads.ft_offloads, flow_group_in);
 571
 572         if (IS_ERR(g)) {
 573                 err = PTR_ERR(g);
 574                 mlx5_core_warn(esw->dev, "Failed to create vport rx group err %d\n", err);
 575                 goto out;
 576         }
 577
 578         esw->offloads.vport_rx_group = g;
 579 out:
 580         kfree(flow_group_in);
 581         return err;
 582 }
 583
 584 static void esw_destroy_vport_rx_group(struct mlx5_eswitch *esw)
 585 {
 586         mlx5_destroy_flow_group(esw->offloads.vport_rx_group);
 587 }
 588
 589 struct mlx5_flow_rule *
 590 mlx5_eswitch_create_vport_rx_rule(struct mlx5_eswitch *esw, int vport, u32 tirn)
 591 {
 592         struct mlx5_flow_destination dest;
 593         struct mlx5_flow_rule *flow_rule;
 594         struct mlx5_flow_spec *spec;
 595         void *misc;
 596
 597         spec = mlx5_vzalloc(sizeof(*spec));
 598         if (!spec) {
 599                 esw_warn(esw->dev, "Failed to alloc match parameters\n");
 600                 flow_rule = ERR_PTR(-ENOMEM);
 601                 goto out;
 602         }
 603
 604         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
 605         MLX5_SET(fte_match_set_misc, misc, source_port, vport);
 606
 607         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
 608         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
 609
 610         spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS;
 611         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 612         dest.tir_num = tirn;
 613
 614         flow_rule = mlx5_add_flow_rule(esw->offloads.ft_offloads, spec,
 615                                        MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
 616                                        0, &dest);
 617         if (IS_ERR(flow_rule)) {
 618                 esw_warn(esw->dev, "fs offloads: Failed to add vport rx rule err %ld\n", PTR_ERR(flow_rule));
 619                 goto out;
 620         }
 621
 622 out:
 623         kvfree(spec);
 624         return flow_rule;
 625 }
 626
 627 static int esw_offloads_start(struct mlx5_eswitch *esw)
 628 {
 629         int err, err1, num_vfs = esw->dev->priv.sriov.num_vfs;
 630
 631         if (esw->mode != SRIOV_LEGACY) {
 632                 esw_warn(esw->dev, "Can't set offloads mode, SRIOV legacy not enabled\n");
 633                 return -EINVAL;
 634         }
 635
 636         mlx5_eswitch_disable_sriov(esw);
 637         err = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_OFFLOADS);
 638         if (err) {
 639                 esw_warn(esw->dev, "Failed setting eswitch to offloads, err %d\n", err);
 640                 err1 = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_LEGACY);
 641                 if (err1)
 642                         esw_warn(esw->dev, "Failed setting eswitch back to legacy, err %d\n", err);
 643         }
 644         return err;
 645 }
 646
 647 int esw_offloads_init(struct mlx5_eswitch *esw, int nvports)
 648 {
 649         struct mlx5_eswitch_rep *rep;
 650         int vport;
 651         int err;
 652
 653         err = esw_create_offloads_fdb_table(esw, nvports);
 654         if (err)
 655                 return err;
 656
 657         err = esw_create_offloads_table(esw);
 658         if (err)
 659                 goto create_ft_err;
 660
 661         err = esw_create_vport_rx_group(esw);
 662         if (err)
 663                 goto create_fg_err;
 664
 665         for (vport = 0; vport < nvports; vport++) {
 666                 rep = &esw->offloads.vport_reps[vport];
 667                 if (!rep->valid)
 668                         continue;
 669
 670                 err = rep->load(esw, rep);
 671                 if (err)
 672                         goto err_reps;
 673         }
 674         return 0;
 675
 676 err_reps:
 677         for (vport--; vport >= 0; vport--) {
 678                 rep = &esw->offloads.vport_reps[vport];
 679                 if (!rep->valid)
 680                         continue;
 681                 rep->unload(esw, rep);
 682         }
 683         esw_destroy_vport_rx_group(esw);
 684
 685 create_fg_err:
 686         esw_destroy_offloads_table(esw);
 687
 688 create_ft_err:
 689         esw_destroy_offloads_fdb_table(esw);
 690         return err;
 691 }
 692
 693 static int esw_offloads_stop(struct mlx5_eswitch *esw)
 694 {
 695         int err, err1, num_vfs = esw->dev->priv.sriov.num_vfs;
 696
 697         mlx5_eswitch_disable_sriov(esw);
 698         err = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_LEGACY);
 699         if (err) {
 700                 esw_warn(esw->dev, "Failed setting eswitch to legacy, err %d\n", err);
 701                 err1 = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_OFFLOADS);
 702                 if (err1)
 703                         esw_warn(esw->dev, "Failed setting eswitch back to offloads, err %d\n", err);
 704         }
 705
 706         return err;
 707 }
 708
 709 void esw_offloads_cleanup(struct mlx5_eswitch *esw, int nvports)
 710 {
 711         struct mlx5_eswitch_rep *rep;
 712         int vport;
 713
 714         for (vport = 0; vport < nvports; vport++) {
 715                 rep = &esw->offloads.vport_reps[vport];
 716                 if (!rep->valid)
 717                         continue;
 718                 rep->unload(esw, rep);
 719         }
 720
 721         esw_destroy_vport_rx_group(esw);
 722         esw_destroy_offloads_table(esw);
 723         esw_destroy_offloads_fdb_table(esw);
 724 }
 725
 726 static int esw_mode_from_devlink(u16 mode, u16 *mlx5_mode)
 727 {
 728         switch (mode) {
 729         case DEVLINK_ESWITCH_MODE_LEGACY:
 730                 *mlx5_mode = SRIOV_LEGACY;
 731                 break;
 732         case DEVLINK_ESWITCH_MODE_SWITCHDEV:
 733                 *mlx5_mode = SRIOV_OFFLOADS;
 734                 break;
 735         default:
 736                 return -EINVAL;
 737         }
 738
 739         return 0;
 740 }
 741
 742 static int esw_mode_to_devlink(u16 mlx5_mode, u16 *mode)
 743 {
 744         switch (mlx5_mode) {
 745         case SRIOV_LEGACY:
 746                 *mode = DEVLINK_ESWITCH_MODE_LEGACY;
 747                 break;
 748         case SRIOV_OFFLOADS:
 749                 *mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
 750                 break;
 751         default:
 752                 return -EINVAL;
 753         }
 754
 755         return 0;
 756 }
 757
 758 int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode)
 759 {
 760         struct mlx5_core_dev *dev;
 761         u16 cur_mlx5_mode, mlx5_mode = 0;
 762
 763         dev = devlink_priv(devlink);
 764
 765         if (!MLX5_CAP_GEN(dev, vport_group_manager))
 766                 return -EOPNOTSUPP;
 767
 768         cur_mlx5_mode = dev->priv.eswitch->mode;
 769
 770         if (cur_mlx5_mode == SRIOV_NONE)
 771                 return -EOPNOTSUPP;
 772
 773         if (esw_mode_from_devlink(mode, &mlx5_mode))
 774                 return -EINVAL;
 775
 776         if (cur_mlx5_mode == mlx5_mode)
 777                 return 0;
 778
 779         if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV)
 780                 return esw_offloads_start(dev->priv.eswitch);
 781         else if (mode == DEVLINK_ESWITCH_MODE_LEGACY)
 782                 return esw_offloads_stop(dev->priv.eswitch);
 783         else
 784                 return -EINVAL;
 785 }
 786
 787 int mlx5_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
 788 {
 789         struct mlx5_core_dev *dev;
 790
 791         dev = devlink_priv(devlink);
 792
 793         if (!MLX5_CAP_GEN(dev, vport_group_manager))
 794                 return -EOPNOTSUPP;
 795
 796         if (dev->priv.eswitch->mode == SRIOV_NONE)
 797                 return -EOPNOTSUPP;
 798
 799         return esw_mode_to_devlink(dev->priv.eswitch->mode, mode);
 800 }
 801
 802 void mlx5_eswitch_register_vport_rep(struct mlx5_eswitch *esw,
 803                                      int vport_index,
 804                                      struct mlx5_eswitch_rep *__rep)
 805 {
 806         struct mlx5_esw_offload *offloads = &esw->offloads;
 807         struct mlx5_eswitch_rep *rep;
 808
 809         rep = &offloads->vport_reps[vport_index];
 810
 811         memset(rep, 0, sizeof(*rep));
 812
 813         rep->load   = __rep->load;
 814         rep->unload = __rep->unload;
 815         rep->vport  = __rep->vport;
 816         rep->priv_data = __rep->priv_data;
 817         ether_addr_copy(rep->hw_id, __rep->hw_id);
 818
 819         INIT_LIST_HEAD(&rep->vport_sqs_list);
 820         rep->valid = true;
 821 }
 822
 823 void mlx5_eswitch_unregister_vport_rep(struct mlx5_eswitch *esw,
 824                                        int vport_index)
 825 {
 826         struct mlx5_esw_offload *offloads = &esw->offloads;
 827         struct mlx5_eswitch_rep *rep;
 828
 829         rep = &offloads->vport_reps[vport_index];
 830
 831         if (esw->mode == SRIOV_OFFLOADS && esw->vports[vport_index].enabled)
 832                 rep->unload(esw, rep);
 833
 834         rep->valid = false;
 835 }