drivers/net/ethernet/mellanox/mlx5/core/eswitch.c

   1 /*
   2  * Copyright (c) 2015, 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 "lib/eq.h"
  40 #include "eswitch.h"
  41 #include "fs_core.h"
  42 #include "ecpf.h"
  43
  44 enum {
  45         MLX5_ACTION_NONE = 0,
  46         MLX5_ACTION_ADD  = 1,
  47         MLX5_ACTION_DEL  = 2,
  48 };
  49
  50 /* Vport UC/MC hash node */
  51 struct vport_addr {
  52         struct l2addr_node     node;
  53         u8                     action;
  54         u16                    vport;
  55         struct mlx5_flow_handle *flow_rule;
  56         bool mpfs; /* UC MAC was added to MPFs */
  57         /* A flag indicating that mac was added due to mc promiscuous vport */
  58         bool mc_promisc;
  59 };
  60
  61 enum {
  62         UC_ADDR_CHANGE = BIT(0),
  63         MC_ADDR_CHANGE = BIT(1),
  64         PROMISC_CHANGE = BIT(3),
  65 };
  66
  67 static void esw_destroy_legacy_fdb_table(struct mlx5_eswitch *esw);
  68 static void esw_cleanup_vepa_rules(struct mlx5_eswitch *esw);
  69
  70 /* Vport context events */
  71 #define SRIOV_VPORT_EVENTS (UC_ADDR_CHANGE | \
  72                             MC_ADDR_CHANGE | \
  73                             PROMISC_CHANGE)
  74
  75 struct mlx5_vport *mlx5_eswitch_get_vport(struct mlx5_eswitch *esw,
  76                                           u16 vport_num)
  77 {
  78         u16 idx = mlx5_eswitch_vport_num_to_index(esw, vport_num);
  79
  80         WARN_ON(idx > esw->total_vports - 1);
  81         return &esw->vports[idx];
  82 }
  83
  84 static int arm_vport_context_events_cmd(struct mlx5_core_dev *dev, u16 vport,
  85                                         u32 events_mask)
  86 {
  87         int in[MLX5_ST_SZ_DW(modify_nic_vport_context_in)]   = {0};
  88         int out[MLX5_ST_SZ_DW(modify_nic_vport_context_out)] = {0};
  89         void *nic_vport_ctx;
  90
  91         MLX5_SET(modify_nic_vport_context_in, in,
  92                  opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
  93         MLX5_SET(modify_nic_vport_context_in, in, field_select.change_event, 1);
  94         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
  95         MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
  96         nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in,
  97                                      in, nic_vport_context);
  98
  99         MLX5_SET(nic_vport_context, nic_vport_ctx, arm_change_event, 1);
 100
 101         if (events_mask & UC_ADDR_CHANGE)
 102                 MLX5_SET(nic_vport_context, nic_vport_ctx,
 103                          event_on_uc_address_change, 1);
 104         if (events_mask & MC_ADDR_CHANGE)
 105                 MLX5_SET(nic_vport_context, nic_vport_ctx,
 106                          event_on_mc_address_change, 1);
 107         if (events_mask & PROMISC_CHANGE)
 108                 MLX5_SET(nic_vport_context, nic_vport_ctx,
 109                          event_on_promisc_change, 1);
 110
 111         return mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
 112 }
 113
 114 /* E-Switch vport context HW commands */
 115 static int modify_esw_vport_context_cmd(struct mlx5_core_dev *dev, u16 vport,
 116                                         void *in, int inlen)
 117 {
 118         u32 out[MLX5_ST_SZ_DW(modify_esw_vport_context_out)] = {0};
 119
 120         MLX5_SET(modify_esw_vport_context_in, in, opcode,
 121                  MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT);
 122         MLX5_SET(modify_esw_vport_context_in, in, vport_number, vport);
 123         MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1);
 124         return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out));
 125 }
 126
 127 static int modify_esw_vport_cvlan(struct mlx5_core_dev *dev, u16 vport,
 128                                   u16 vlan, u8 qos, u8 set_flags)
 129 {
 130         u32 in[MLX5_ST_SZ_DW(modify_esw_vport_context_in)] = {0};
 131
 132         if (!MLX5_CAP_ESW(dev, vport_cvlan_strip) ||
 133             !MLX5_CAP_ESW(dev, vport_cvlan_insert_if_not_exist))
 134                 return -EOPNOTSUPP;
 135
 136         esw_debug(dev, "Set Vport[%d] VLAN %d qos %d set=%x\n",
 137                   vport, vlan, qos, set_flags);
 138
 139         if (set_flags & SET_VLAN_STRIP)
 140                 MLX5_SET(modify_esw_vport_context_in, in,
 141                          esw_vport_context.vport_cvlan_strip, 1);
 142
 143         if (set_flags & SET_VLAN_INSERT) {
 144                 /* insert only if no vlan in packet */
 145                 MLX5_SET(modify_esw_vport_context_in, in,
 146                          esw_vport_context.vport_cvlan_insert, 1);
 147
 148                 MLX5_SET(modify_esw_vport_context_in, in,
 149                          esw_vport_context.cvlan_pcp, qos);
 150                 MLX5_SET(modify_esw_vport_context_in, in,
 151                          esw_vport_context.cvlan_id, vlan);
 152         }
 153
 154         MLX5_SET(modify_esw_vport_context_in, in,
 155                  field_select.vport_cvlan_strip, 1);
 156         MLX5_SET(modify_esw_vport_context_in, in,
 157                  field_select.vport_cvlan_insert, 1);
 158
 159         return modify_esw_vport_context_cmd(dev, vport, in, sizeof(in));
 160 }
 161
 162 /* E-Switch FDB */
 163 static struct mlx5_flow_handle *
 164 __esw_fdb_set_vport_rule(struct mlx5_eswitch *esw, u16 vport, bool rx_rule,
 165                          u8 mac_c[ETH_ALEN], u8 mac_v[ETH_ALEN])
 166 {
 167         int match_header = (is_zero_ether_addr(mac_c) ? 0 :
 168                             MLX5_MATCH_OUTER_HEADERS);
 169         struct mlx5_flow_handle *flow_rule = NULL;
 170         struct mlx5_flow_act flow_act = {0};
 171         struct mlx5_flow_destination dest = {};
 172         struct mlx5_flow_spec *spec;
 173         void *mv_misc = NULL;
 174         void *mc_misc = NULL;
 175         u8 *dmac_v = NULL;
 176         u8 *dmac_c = NULL;
 177
 178         if (rx_rule)
 179                 match_header |= MLX5_MATCH_MISC_PARAMETERS;
 180
 181         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
 182         if (!spec)
 183                 return NULL;
 184
 185         dmac_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
 186                               outer_headers.dmac_47_16);
 187         dmac_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 188                               outer_headers.dmac_47_16);
 189
 190         if (match_header & MLX5_MATCH_OUTER_HEADERS) {
 191                 ether_addr_copy(dmac_v, mac_v);
 192                 ether_addr_copy(dmac_c, mac_c);
 193         }
 194
 195         if (match_header & MLX5_MATCH_MISC_PARAMETERS) {
 196                 mv_misc  = MLX5_ADDR_OF(fte_match_param, spec->match_value,
 197                                         misc_parameters);
 198                 mc_misc  = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 199                                         misc_parameters);
 200                 MLX5_SET(fte_match_set_misc, mv_misc, source_port, MLX5_VPORT_UPLINK);
 201                 MLX5_SET_TO_ONES(fte_match_set_misc, mc_misc, source_port);
 202         }
 203
 204         dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
 205         dest.vport.num = vport;
 206
 207         esw_debug(esw->dev,
 208                   "\tFDB add rule dmac_v(%pM) dmac_c(%pM) -> vport(%d)\n",
 209                   dmac_v, dmac_c, vport);
 210         spec->match_criteria_enable = match_header;
 211         flow_act.action =  MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
 212         flow_rule =
 213                 mlx5_add_flow_rules(esw->fdb_table.legacy.fdb, spec,
 214                                     &flow_act, &dest, 1);
 215         if (IS_ERR(flow_rule)) {
 216                 esw_warn(esw->dev,
 217                          "FDB: Failed to add flow rule: dmac_v(%pM) dmac_c(%pM) -> vport(%d), err(%ld)\n",
 218                          dmac_v, dmac_c, vport, PTR_ERR(flow_rule));
 219                 flow_rule = NULL;
 220         }
 221
 222         kvfree(spec);
 223         return flow_rule;
 224 }
 225
 226 static struct mlx5_flow_handle *
 227 esw_fdb_set_vport_rule(struct mlx5_eswitch *esw, u8 mac[ETH_ALEN], u16 vport)
 228 {
 229         u8 mac_c[ETH_ALEN];
 230
 231         eth_broadcast_addr(mac_c);
 232         return __esw_fdb_set_vport_rule(esw, vport, false, mac_c, mac);
 233 }
 234
 235 static struct mlx5_flow_handle *
 236 esw_fdb_set_vport_allmulti_rule(struct mlx5_eswitch *esw, u16 vport)
 237 {
 238         u8 mac_c[ETH_ALEN];
 239         u8 mac_v[ETH_ALEN];
 240
 241         eth_zero_addr(mac_c);
 242         eth_zero_addr(mac_v);
 243         mac_c[0] = 0x01;
 244         mac_v[0] = 0x01;
 245         return __esw_fdb_set_vport_rule(esw, vport, false, mac_c, mac_v);
 246 }
 247
 248 static struct mlx5_flow_handle *
 249 esw_fdb_set_vport_promisc_rule(struct mlx5_eswitch *esw, u16 vport)
 250 {
 251         u8 mac_c[ETH_ALEN];
 252         u8 mac_v[ETH_ALEN];
 253
 254         eth_zero_addr(mac_c);
 255         eth_zero_addr(mac_v);
 256         return __esw_fdb_set_vport_rule(esw, vport, true, mac_c, mac_v);
 257 }
 258
 259 enum {
 260         LEGACY_VEPA_PRIO = 0,
 261         LEGACY_FDB_PRIO,
 262 };
 263
 264 static int esw_create_legacy_vepa_table(struct mlx5_eswitch *esw)
 265 {
 266         struct mlx5_core_dev *dev = esw->dev;
 267         struct mlx5_flow_namespace *root_ns;
 268         struct mlx5_flow_table *fdb;
 269         int err;
 270
 271         root_ns = mlx5_get_fdb_sub_ns(dev, 0);
 272         if (!root_ns) {
 273                 esw_warn(dev, "Failed to get FDB flow namespace\n");
 274                 return -EOPNOTSUPP;
 275         }
 276
 277         /* num FTE 2, num FG 2 */
 278         fdb = mlx5_create_auto_grouped_flow_table(root_ns, LEGACY_VEPA_PRIO,
 279                                                   2, 2, 0, 0);
 280         if (IS_ERR(fdb)) {
 281                 err = PTR_ERR(fdb);
 282                 esw_warn(dev, "Failed to create VEPA FDB err %d\n", err);
 283                 return err;
 284         }
 285         esw->fdb_table.legacy.vepa_fdb = fdb;
 286
 287         return 0;
 288 }
 289
 290 static int esw_create_legacy_fdb_table(struct mlx5_eswitch *esw)
 291 {
 292         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 293         struct mlx5_flow_table_attr ft_attr = {};
 294         struct mlx5_core_dev *dev = esw->dev;
 295         struct mlx5_flow_namespace *root_ns;
 296         struct mlx5_flow_table *fdb;
 297         struct mlx5_flow_group *g;
 298         void *match_criteria;
 299         int table_size;
 300         u32 *flow_group_in;
 301         u8 *dmac;
 302         int err = 0;
 303
 304         esw_debug(dev, "Create FDB log_max_size(%d)\n",
 305                   MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size));
 306
 307         root_ns = mlx5_get_fdb_sub_ns(dev, 0);
 308         if (!root_ns) {
 309                 esw_warn(dev, "Failed to get FDB flow namespace\n");
 310                 return -EOPNOTSUPP;
 311         }
 312
 313         flow_group_in = kvzalloc(inlen, GFP_KERNEL);
 314         if (!flow_group_in)
 315                 return -ENOMEM;
 316
 317         table_size = BIT(MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size));
 318         ft_attr.max_fte = table_size;
 319         ft_attr.prio = LEGACY_FDB_PRIO;
 320         fdb = mlx5_create_flow_table(root_ns, &ft_attr);
 321         if (IS_ERR(fdb)) {
 322                 err = PTR_ERR(fdb);
 323                 esw_warn(dev, "Failed to create FDB Table err %d\n", err);
 324                 goto out;
 325         }
 326         esw->fdb_table.legacy.fdb = fdb;
 327
 328         /* Addresses group : Full match unicast/multicast addresses */
 329         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
 330                  MLX5_MATCH_OUTER_HEADERS);
 331         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
 332         dmac = MLX5_ADDR_OF(fte_match_param, match_criteria, outer_headers.dmac_47_16);
 333         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
 334         /* Preserve 2 entries for allmulti and promisc rules*/
 335         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, table_size - 3);
 336         eth_broadcast_addr(dmac);
 337         g = mlx5_create_flow_group(fdb, flow_group_in);
 338         if (IS_ERR(g)) {
 339                 err = PTR_ERR(g);
 340                 esw_warn(dev, "Failed to create flow group err(%d)\n", err);
 341                 goto out;
 342         }
 343         esw->fdb_table.legacy.addr_grp = g;
 344
 345         /* Allmulti group : One rule that forwards any mcast traffic */
 346         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
 347                  MLX5_MATCH_OUTER_HEADERS);
 348         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, table_size - 2);
 349         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, table_size - 2);
 350         eth_zero_addr(dmac);
 351         dmac[0] = 0x01;
 352         g = mlx5_create_flow_group(fdb, flow_group_in);
 353         if (IS_ERR(g)) {
 354                 err = PTR_ERR(g);
 355                 esw_warn(dev, "Failed to create allmulti flow group err(%d)\n", err);
 356                 goto out;
 357         }
 358         esw->fdb_table.legacy.allmulti_grp = g;
 359
 360         /* Promiscuous group :
 361          * One rule that forward all unmatched traffic from previous groups
 362          */
 363         eth_zero_addr(dmac);
 364         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
 365                  MLX5_MATCH_MISC_PARAMETERS);
 366         MLX5_SET_TO_ONES(fte_match_param, match_criteria, misc_parameters.source_port);
 367         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, table_size - 1);
 368         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, table_size - 1);
 369         g = mlx5_create_flow_group(fdb, flow_group_in);
 370         if (IS_ERR(g)) {
 371                 err = PTR_ERR(g);
 372                 esw_warn(dev, "Failed to create promisc flow group err(%d)\n", err);
 373                 goto out;
 374         }
 375         esw->fdb_table.legacy.promisc_grp = g;
 376
 377 out:
 378         if (err)
 379                 esw_destroy_legacy_fdb_table(esw);
 380
 381         kvfree(flow_group_in);
 382         return err;
 383 }
 384
 385 static void esw_destroy_legacy_vepa_table(struct mlx5_eswitch *esw)
 386 {
 387         esw_debug(esw->dev, "Destroy VEPA Table\n");
 388         if (!esw->fdb_table.legacy.vepa_fdb)
 389                 return;
 390
 391         mlx5_destroy_flow_table(esw->fdb_table.legacy.vepa_fdb);
 392         esw->fdb_table.legacy.vepa_fdb = NULL;
 393 }
 394
 395 static void esw_destroy_legacy_fdb_table(struct mlx5_eswitch *esw)
 396 {
 397         esw_debug(esw->dev, "Destroy FDB Table\n");
 398         if (!esw->fdb_table.legacy.fdb)
 399                 return;
 400
 401         if (esw->fdb_table.legacy.promisc_grp)
 402                 mlx5_destroy_flow_group(esw->fdb_table.legacy.promisc_grp);
 403         if (esw->fdb_table.legacy.allmulti_grp)
 404                 mlx5_destroy_flow_group(esw->fdb_table.legacy.allmulti_grp);
 405         if (esw->fdb_table.legacy.addr_grp)
 406                 mlx5_destroy_flow_group(esw->fdb_table.legacy.addr_grp);
 407         mlx5_destroy_flow_table(esw->fdb_table.legacy.fdb);
 408
 409         esw->fdb_table.legacy.fdb = NULL;
 410         esw->fdb_table.legacy.addr_grp = NULL;
 411         esw->fdb_table.legacy.allmulti_grp = NULL;
 412         esw->fdb_table.legacy.promisc_grp = NULL;
 413 }
 414
 415 static int esw_create_legacy_table(struct mlx5_eswitch *esw)
 416 {
 417         int err;
 418
 419         memset(&esw->fdb_table.legacy, 0, sizeof(struct legacy_fdb));
 420
 421         err = esw_create_legacy_vepa_table(esw);
 422         if (err)
 423                 return err;
 424
 425         err = esw_create_legacy_fdb_table(esw);
 426         if (err)
 427                 esw_destroy_legacy_vepa_table(esw);
 428
 429         return err;
 430 }
 431
 432 static void esw_destroy_legacy_table(struct mlx5_eswitch *esw)
 433 {
 434         esw_cleanup_vepa_rules(esw);
 435         esw_destroy_legacy_fdb_table(esw);
 436         esw_destroy_legacy_vepa_table(esw);
 437 }
 438
 439 /* E-Switch vport UC/MC lists management */
 440 typedef int (*vport_addr_action)(struct mlx5_eswitch *esw,
 441                                  struct vport_addr *vaddr);
 442
 443 static int esw_add_uc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr)
 444 {
 445         u8 *mac = vaddr->node.addr;
 446         u16 vport = vaddr->vport;
 447         int err;
 448
 449         /* Skip mlx5_mpfs_add_mac for eswitch_managers,
 450          * it is already done by its netdev in mlx5e_execute_l2_action
 451          */
 452         if (esw->manager_vport == vport)
 453                 goto fdb_add;
 454
 455         err = mlx5_mpfs_add_mac(esw->dev, mac);
 456         if (err) {
 457                 esw_warn(esw->dev,
 458                          "Failed to add L2 table mac(%pM) for vport(0x%x), err(%d)\n",
 459                          mac, vport, err);
 460                 return err;
 461         }
 462         vaddr->mpfs = true;
 463
 464 fdb_add:
 465         /* SRIOV is enabled: Forward UC MAC to vport */
 466         if (esw->fdb_table.legacy.fdb && esw->mode == SRIOV_LEGACY)
 467                 vaddr->flow_rule = esw_fdb_set_vport_rule(esw, mac, vport);
 468
 469         esw_debug(esw->dev, "\tADDED UC MAC: vport[%d] %pM fr(%p)\n",
 470                   vport, mac, vaddr->flow_rule);
 471
 472         return 0;
 473 }
 474
 475 static int esw_del_uc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr)
 476 {
 477         u8 *mac = vaddr->node.addr;
 478         u16 vport = vaddr->vport;
 479         int err = 0;
 480
 481         /* Skip mlx5_mpfs_del_mac for eswitch managerss,
 482          * it is already done by its netdev in mlx5e_execute_l2_action
 483          */
 484         if (!vaddr->mpfs || esw->manager_vport == vport)
 485                 goto fdb_del;
 486
 487         err = mlx5_mpfs_del_mac(esw->dev, mac);
 488         if (err)
 489                 esw_warn(esw->dev,
 490                          "Failed to del L2 table mac(%pM) for vport(%d), err(%d)\n",
 491                          mac, vport, err);
 492         vaddr->mpfs = false;
 493
 494 fdb_del:
 495         if (vaddr->flow_rule)
 496                 mlx5_del_flow_rules(vaddr->flow_rule);
 497         vaddr->flow_rule = NULL;
 498
 499         return 0;
 500 }
 501
 502 static void update_allmulti_vports(struct mlx5_eswitch *esw,
 503                                    struct vport_addr *vaddr,
 504                                    struct esw_mc_addr *esw_mc)
 505 {
 506         u8 *mac = vaddr->node.addr;
 507         struct mlx5_vport *vport;
 508         u16 i, vport_num;
 509
 510         mlx5_esw_for_all_vports(esw, i, vport) {
 511                 struct hlist_head *vport_hash = vport->mc_list;
 512                 struct vport_addr *iter_vaddr =
 513                                         l2addr_hash_find(vport_hash,
 514                                                          mac,
 515                                                          struct vport_addr);
 516                 vport_num = vport->vport;
 517                 if (IS_ERR_OR_NULL(vport->allmulti_rule) ||
 518                     vaddr->vport == vport_num)
 519                         continue;
 520                 switch (vaddr->action) {
 521                 case MLX5_ACTION_ADD:
 522                         if (iter_vaddr)
 523                                 continue;
 524                         iter_vaddr = l2addr_hash_add(vport_hash, mac,
 525                                                      struct vport_addr,
 526                                                      GFP_KERNEL);
 527                         if (!iter_vaddr) {
 528                                 esw_warn(esw->dev,
 529                                          "ALL-MULTI: Failed to add MAC(%pM) to vport[%d] DB\n",
 530                                          mac, vport_num);
 531                                 continue;
 532                         }
 533                         iter_vaddr->vport = vport_num;
 534                         iter_vaddr->flow_rule =
 535                                         esw_fdb_set_vport_rule(esw,
 536                                                                mac,
 537                                                                vport_num);
 538                         iter_vaddr->mc_promisc = true;
 539                         break;
 540                 case MLX5_ACTION_DEL:
 541                         if (!iter_vaddr)
 542                                 continue;
 543                         mlx5_del_flow_rules(iter_vaddr->flow_rule);
 544                         l2addr_hash_del(iter_vaddr);
 545                         break;
 546                 }
 547         }
 548 }
 549
 550 static int esw_add_mc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr)
 551 {
 552         struct hlist_head *hash = esw->mc_table;
 553         struct esw_mc_addr *esw_mc;
 554         u8 *mac = vaddr->node.addr;
 555         u16 vport = vaddr->vport;
 556
 557         if (!esw->fdb_table.legacy.fdb)
 558                 return 0;
 559
 560         esw_mc = l2addr_hash_find(hash, mac, struct esw_mc_addr);
 561         if (esw_mc)
 562                 goto add;
 563
 564         esw_mc = l2addr_hash_add(hash, mac, struct esw_mc_addr, GFP_KERNEL);
 565         if (!esw_mc)
 566                 return -ENOMEM;
 567
 568         esw_mc->uplink_rule = /* Forward MC MAC to Uplink */
 569                 esw_fdb_set_vport_rule(esw, mac, MLX5_VPORT_UPLINK);
 570
 571         /* Add this multicast mac to all the mc promiscuous vports */
 572         update_allmulti_vports(esw, vaddr, esw_mc);
 573
 574 add:
 575         /* If the multicast mac is added as a result of mc promiscuous vport,
 576          * don't increment the multicast ref count
 577          */
 578         if (!vaddr->mc_promisc)
 579                 esw_mc->refcnt++;
 580
 581         /* Forward MC MAC to vport */
 582         vaddr->flow_rule = esw_fdb_set_vport_rule(esw, mac, vport);
 583         esw_debug(esw->dev,
 584                   "\tADDED MC MAC: vport[%d] %pM fr(%p) refcnt(%d) uplinkfr(%p)\n",
 585                   vport, mac, vaddr->flow_rule,
 586                   esw_mc->refcnt, esw_mc->uplink_rule);
 587         return 0;
 588 }
 589
 590 static int esw_del_mc_addr(struct mlx5_eswitch *esw, struct vport_addr *vaddr)
 591 {
 592         struct hlist_head *hash = esw->mc_table;
 593         struct esw_mc_addr *esw_mc;
 594         u8 *mac = vaddr->node.addr;
 595         u16 vport = vaddr->vport;
 596
 597         if (!esw->fdb_table.legacy.fdb)
 598                 return 0;
 599
 600         esw_mc = l2addr_hash_find(hash, mac, struct esw_mc_addr);
 601         if (!esw_mc) {
 602                 esw_warn(esw->dev,
 603                          "Failed to find eswitch MC addr for MAC(%pM) vport(%d)",
 604                          mac, vport);
 605                 return -EINVAL;
 606         }
 607         esw_debug(esw->dev,
 608                   "\tDELETE MC MAC: vport[%d] %pM fr(%p) refcnt(%d) uplinkfr(%p)\n",
 609                   vport, mac, vaddr->flow_rule, esw_mc->refcnt,
 610                   esw_mc->uplink_rule);
 611
 612         if (vaddr->flow_rule)
 613                 mlx5_del_flow_rules(vaddr->flow_rule);
 614         vaddr->flow_rule = NULL;
 615
 616         /* If the multicast mac is added as a result of mc promiscuous vport,
 617          * don't decrement the multicast ref count.
 618          */
 619         if (vaddr->mc_promisc || (--esw_mc->refcnt > 0))
 620                 return 0;
 621
 622         /* Remove this multicast mac from all the mc promiscuous vports */
 623         update_allmulti_vports(esw, vaddr, esw_mc);
 624
 625         if (esw_mc->uplink_rule)
 626                 mlx5_del_flow_rules(esw_mc->uplink_rule);
 627
 628         l2addr_hash_del(esw_mc);
 629         return 0;
 630 }
 631
 632 /* Apply vport UC/MC list to HW l2 table and FDB table */
 633 static void esw_apply_vport_addr_list(struct mlx5_eswitch *esw,
 634                                       struct mlx5_vport *vport, int list_type)
 635 {
 636         bool is_uc = list_type == MLX5_NVPRT_LIST_TYPE_UC;
 637         vport_addr_action vport_addr_add;
 638         vport_addr_action vport_addr_del;
 639         struct vport_addr *addr;
 640         struct l2addr_node *node;
 641         struct hlist_head *hash;
 642         struct hlist_node *tmp;
 643         int hi;
 644
 645         vport_addr_add = is_uc ? esw_add_uc_addr :
 646                                  esw_add_mc_addr;
 647         vport_addr_del = is_uc ? esw_del_uc_addr :
 648                                  esw_del_mc_addr;
 649
 650         hash = is_uc ? vport->uc_list : vport->mc_list;
 651         for_each_l2hash_node(node, tmp, hash, hi) {
 652                 addr = container_of(node, struct vport_addr, node);
 653                 switch (addr->action) {
 654                 case MLX5_ACTION_ADD:
 655                         vport_addr_add(esw, addr);
 656                         addr->action = MLX5_ACTION_NONE;
 657                         break;
 658                 case MLX5_ACTION_DEL:
 659                         vport_addr_del(esw, addr);
 660                         l2addr_hash_del(addr);
 661                         break;
 662                 }
 663         }
 664 }
 665
 666 /* Sync vport UC/MC list from vport context */
 667 static void esw_update_vport_addr_list(struct mlx5_eswitch *esw,
 668                                        struct mlx5_vport *vport, int list_type)
 669 {
 670         bool is_uc = list_type == MLX5_NVPRT_LIST_TYPE_UC;
 671         u8 (*mac_list)[ETH_ALEN];
 672         struct l2addr_node *node;
 673         struct vport_addr *addr;
 674         struct hlist_head *hash;
 675         struct hlist_node *tmp;
 676         int size;
 677         int err;
 678         int hi;
 679         int i;
 680
 681         size = is_uc ? MLX5_MAX_UC_PER_VPORT(esw->dev) :
 682                        MLX5_MAX_MC_PER_VPORT(esw->dev);
 683
 684         mac_list = kcalloc(size, ETH_ALEN, GFP_KERNEL);
 685         if (!mac_list)
 686                 return;
 687
 688         hash = is_uc ? vport->uc_list : vport->mc_list;
 689
 690         for_each_l2hash_node(node, tmp, hash, hi) {
 691                 addr = container_of(node, struct vport_addr, node);
 692                 addr->action = MLX5_ACTION_DEL;
 693         }
 694
 695         if (!vport->enabled)
 696                 goto out;
 697
 698         err = mlx5_query_nic_vport_mac_list(esw->dev, vport->vport, list_type,
 699                                             mac_list, &size);
 700         if (err)
 701                 goto out;
 702         esw_debug(esw->dev, "vport[%d] context update %s list size (%d)\n",
 703                   vport->vport, is_uc ? "UC" : "MC", size);
 704
 705         for (i = 0; i < size; i++) {
 706                 if (is_uc && !is_valid_ether_addr(mac_list[i]))
 707                         continue;
 708
 709                 if (!is_uc && !is_multicast_ether_addr(mac_list[i]))
 710                         continue;
 711
 712                 addr = l2addr_hash_find(hash, mac_list[i], struct vport_addr);
 713                 if (addr) {
 714                         addr->action = MLX5_ACTION_NONE;
 715                         /* If this mac was previously added because of allmulti
 716                          * promiscuous rx mode, its now converted to be original
 717                          * vport mac.
 718                          */
 719                         if (addr->mc_promisc) {
 720                                 struct esw_mc_addr *esw_mc =
 721                                         l2addr_hash_find(esw->mc_table,
 722                                                          mac_list[i],
 723                                                          struct esw_mc_addr);
 724                                 if (!esw_mc) {
 725                                         esw_warn(esw->dev,
 726                                                  "Failed to MAC(%pM) in mcast DB\n",
 727                                                  mac_list[i]);
 728                                         continue;
 729                                 }
 730                                 esw_mc->refcnt++;
 731                                 addr->mc_promisc = false;
 732                         }
 733                         continue;
 734                 }
 735
 736                 addr = l2addr_hash_add(hash, mac_list[i], struct vport_addr,
 737                                        GFP_KERNEL);
 738                 if (!addr) {
 739                         esw_warn(esw->dev,
 740                                  "Failed to add MAC(%pM) to vport[%d] DB\n",
 741                                  mac_list[i], vport->vport);
 742                         continue;
 743                 }
 744                 addr->vport = vport->vport;
 745                 addr->action = MLX5_ACTION_ADD;
 746         }
 747 out:
 748         kfree(mac_list);
 749 }
 750
 751 /* Sync vport UC/MC list from vport context
 752  * Must be called after esw_update_vport_addr_list
 753  */
 754 static void esw_update_vport_mc_promisc(struct mlx5_eswitch *esw,
 755                                         struct mlx5_vport *vport)
 756 {
 757         struct l2addr_node *node;
 758         struct vport_addr *addr;
 759         struct hlist_head *hash;
 760         struct hlist_node *tmp;
 761         int hi;
 762
 763         hash = vport->mc_list;
 764
 765         for_each_l2hash_node(node, tmp, esw->mc_table, hi) {
 766                 u8 *mac = node->addr;
 767
 768                 addr = l2addr_hash_find(hash, mac, struct vport_addr);
 769                 if (addr) {
 770                         if (addr->action == MLX5_ACTION_DEL)
 771                                 addr->action = MLX5_ACTION_NONE;
 772                         continue;
 773                 }
 774                 addr = l2addr_hash_add(hash, mac, struct vport_addr,
 775                                        GFP_KERNEL);
 776                 if (!addr) {
 777                         esw_warn(esw->dev,
 778                                  "Failed to add allmulti MAC(%pM) to vport[%d] DB\n",
 779                                  mac, vport->vport);
 780                         continue;
 781                 }
 782                 addr->vport = vport->vport;
 783                 addr->action = MLX5_ACTION_ADD;
 784                 addr->mc_promisc = true;
 785         }
 786 }
 787
 788 /* Apply vport rx mode to HW FDB table */
 789 static void esw_apply_vport_rx_mode(struct mlx5_eswitch *esw,
 790                                     struct mlx5_vport *vport,
 791                                     bool promisc, bool mc_promisc)
 792 {
 793         struct esw_mc_addr *allmulti_addr = &esw->mc_promisc;
 794
 795         if (IS_ERR_OR_NULL(vport->allmulti_rule) != mc_promisc)
 796                 goto promisc;
 797
 798         if (mc_promisc) {
 799                 vport->allmulti_rule =
 800                         esw_fdb_set_vport_allmulti_rule(esw, vport->vport);
 801                 if (!allmulti_addr->uplink_rule)
 802                         allmulti_addr->uplink_rule =
 803                                 esw_fdb_set_vport_allmulti_rule(esw,
 804                                                                 MLX5_VPORT_UPLINK);
 805                 allmulti_addr->refcnt++;
 806         } else if (vport->allmulti_rule) {
 807                 mlx5_del_flow_rules(vport->allmulti_rule);
 808                 vport->allmulti_rule = NULL;
 809
 810                 if (--allmulti_addr->refcnt > 0)
 811                         goto promisc;
 812
 813                 if (allmulti_addr->uplink_rule)
 814                         mlx5_del_flow_rules(allmulti_addr->uplink_rule);
 815                 allmulti_addr->uplink_rule = NULL;
 816         }
 817
 818 promisc:
 819         if (IS_ERR_OR_NULL(vport->promisc_rule) != promisc)
 820                 return;
 821
 822         if (promisc) {
 823                 vport->promisc_rule =
 824                         esw_fdb_set_vport_promisc_rule(esw, vport->vport);
 825         } else if (vport->promisc_rule) {
 826                 mlx5_del_flow_rules(vport->promisc_rule);
 827                 vport->promisc_rule = NULL;
 828         }
 829 }
 830
 831 /* Sync vport rx mode from vport context */
 832 static void esw_update_vport_rx_mode(struct mlx5_eswitch *esw,
 833                                      struct mlx5_vport *vport)
 834 {
 835         int promisc_all = 0;
 836         int promisc_uc = 0;
 837         int promisc_mc = 0;
 838         int err;
 839
 840         err = mlx5_query_nic_vport_promisc(esw->dev,
 841                                            vport->vport,
 842                                            &promisc_uc,
 843                                            &promisc_mc,
 844                                            &promisc_all);
 845         if (err)
 846                 return;
 847         esw_debug(esw->dev, "vport[%d] context update rx mode promisc_all=%d, all_multi=%d\n",
 848                   vport->vport, promisc_all, promisc_mc);
 849
 850         if (!vport->info.trusted || !vport->enabled) {
 851                 promisc_uc = 0;
 852                 promisc_mc = 0;
 853                 promisc_all = 0;
 854         }
 855
 856         esw_apply_vport_rx_mode(esw, vport, promisc_all,
 857                                 (promisc_all || promisc_mc));
 858 }
 859
 860 static void esw_vport_change_handle_locked(struct mlx5_vport *vport)
 861 {
 862         struct mlx5_core_dev *dev = vport->dev;
 863         struct mlx5_eswitch *esw = dev->priv.eswitch;
 864         u8 mac[ETH_ALEN];
 865
 866         mlx5_query_nic_vport_mac_address(dev, vport->vport, mac);
 867         esw_debug(dev, "vport[%d] Context Changed: perm mac: %pM\n",
 868                   vport->vport, mac);
 869
 870         if (vport->enabled_events & UC_ADDR_CHANGE) {
 871                 esw_update_vport_addr_list(esw, vport, MLX5_NVPRT_LIST_TYPE_UC);
 872                 esw_apply_vport_addr_list(esw, vport, MLX5_NVPRT_LIST_TYPE_UC);
 873         }
 874
 875         if (vport->enabled_events & MC_ADDR_CHANGE)
 876                 esw_update_vport_addr_list(esw, vport, MLX5_NVPRT_LIST_TYPE_MC);
 877
 878         if (vport->enabled_events & PROMISC_CHANGE) {
 879                 esw_update_vport_rx_mode(esw, vport);
 880                 if (!IS_ERR_OR_NULL(vport->allmulti_rule))
 881                         esw_update_vport_mc_promisc(esw, vport);
 882         }
 883
 884         if (vport->enabled_events & (PROMISC_CHANGE | MC_ADDR_CHANGE))
 885                 esw_apply_vport_addr_list(esw, vport, MLX5_NVPRT_LIST_TYPE_MC);
 886
 887         esw_debug(esw->dev, "vport[%d] Context Changed: Done\n", vport->vport);
 888         if (vport->enabled)
 889                 arm_vport_context_events_cmd(dev, vport->vport,
 890                                              vport->enabled_events);
 891 }
 892
 893 static void esw_vport_change_handler(struct work_struct *work)
 894 {
 895         struct mlx5_vport *vport =
 896                 container_of(work, struct mlx5_vport, vport_change_handler);
 897         struct mlx5_eswitch *esw = vport->dev->priv.eswitch;
 898
 899         mutex_lock(&esw->state_lock);
 900         esw_vport_change_handle_locked(vport);
 901         mutex_unlock(&esw->state_lock);
 902 }
 903
 904 int esw_vport_enable_egress_acl(struct mlx5_eswitch *esw,
 905                                 struct mlx5_vport *vport)
 906 {
 907         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 908         struct mlx5_flow_group *vlan_grp = NULL;
 909         struct mlx5_flow_group *drop_grp = NULL;
 910         struct mlx5_core_dev *dev = esw->dev;
 911         struct mlx5_flow_namespace *root_ns;
 912         struct mlx5_flow_table *acl;
 913         void *match_criteria;
 914         u32 *flow_group_in;
 915         /* The egress acl table contains 2 rules:
 916          * 1)Allow traffic with vlan_tag=vst_vlan_id
 917          * 2)Drop all other traffic.
 918          */
 919         int table_size = 2;
 920         int err = 0;
 921
 922         if (!MLX5_CAP_ESW_EGRESS_ACL(dev, ft_support))
 923                 return -EOPNOTSUPP;
 924
 925         if (!IS_ERR_OR_NULL(vport->egress.acl))
 926                 return 0;
 927
 928         esw_debug(dev, "Create vport[%d] egress ACL log_max_size(%d)\n",
 929                   vport->vport, MLX5_CAP_ESW_EGRESS_ACL(dev, log_max_ft_size));
 930
 931         root_ns = mlx5_get_flow_vport_acl_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_EGRESS,
 932                                                     vport->vport);
 933         if (!root_ns) {
 934                 esw_warn(dev, "Failed to get E-Switch egress flow namespace for vport (%d)\n", vport->vport);
 935                 return -EOPNOTSUPP;
 936         }
 937
 938         flow_group_in = kvzalloc(inlen, GFP_KERNEL);
 939         if (!flow_group_in)
 940                 return -ENOMEM;
 941
 942         acl = mlx5_create_vport_flow_table(root_ns, 0, table_size, 0, vport->vport);
 943         if (IS_ERR(acl)) {
 944                 err = PTR_ERR(acl);
 945                 esw_warn(dev, "Failed to create E-Switch vport[%d] egress flow Table, err(%d)\n",
 946                          vport->vport, err);
 947                 goto out;
 948         }
 949
 950         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
 951         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
 952         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.cvlan_tag);
 953         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.first_vid);
 954         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
 955         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 0);
 956
 957         vlan_grp = mlx5_create_flow_group(acl, flow_group_in);
 958         if (IS_ERR(vlan_grp)) {
 959                 err = PTR_ERR(vlan_grp);
 960                 esw_warn(dev, "Failed to create E-Switch vport[%d] egress allowed vlans flow group, err(%d)\n",
 961                          vport->vport, err);
 962                 goto out;
 963         }
 964
 965         memset(flow_group_in, 0, inlen);
 966         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 1);
 967         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 1);
 968         drop_grp = mlx5_create_flow_group(acl, flow_group_in);
 969         if (IS_ERR(drop_grp)) {
 970                 err = PTR_ERR(drop_grp);
 971                 esw_warn(dev, "Failed to create E-Switch vport[%d] egress drop flow group, err(%d)\n",
 972                          vport->vport, err);
 973                 goto out;
 974         }
 975
 976         vport->egress.acl = acl;
 977         vport->egress.drop_grp = drop_grp;
 978         vport->egress.allowed_vlans_grp = vlan_grp;
 979 out:
 980         kvfree(flow_group_in);
 981         if (err && !IS_ERR_OR_NULL(vlan_grp))
 982                 mlx5_destroy_flow_group(vlan_grp);
 983         if (err && !IS_ERR_OR_NULL(acl))
 984                 mlx5_destroy_flow_table(acl);
 985         return err;
 986 }
 987
 988 void esw_vport_cleanup_egress_rules(struct mlx5_eswitch *esw,
 989                                     struct mlx5_vport *vport)
 990 {
 991         if (!IS_ERR_OR_NULL(vport->egress.allowed_vlan))
 992                 mlx5_del_flow_rules(vport->egress.allowed_vlan);
 993
 994         if (!IS_ERR_OR_NULL(vport->egress.drop_rule))
 995                 mlx5_del_flow_rules(vport->egress.drop_rule);
 996
 997         vport->egress.allowed_vlan = NULL;
 998         vport->egress.drop_rule = NULL;
 999 }
1000
1001 void esw_vport_disable_egress_acl(struct mlx5_eswitch *esw,
1002                                   struct mlx5_vport *vport)
1003 {
1004         if (IS_ERR_OR_NULL(vport->egress.acl))
1005                 return;
1006
1007         esw_debug(esw->dev, "Destroy vport[%d] E-Switch egress ACL\n", vport->vport);
1008
1009         esw_vport_cleanup_egress_rules(esw, vport);
1010         mlx5_destroy_flow_group(vport->egress.allowed_vlans_grp);
1011         mlx5_destroy_flow_group(vport->egress.drop_grp);
1012         mlx5_destroy_flow_table(vport->egress.acl);
1013         vport->egress.allowed_vlans_grp = NULL;
1014         vport->egress.drop_grp = NULL;
1015         vport->egress.acl = NULL;
1016 }
1017
1018 int esw_vport_enable_ingress_acl(struct mlx5_eswitch *esw,
1019                                  struct mlx5_vport *vport)
1020 {
1021         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
1022         struct mlx5_core_dev *dev = esw->dev;
1023         struct mlx5_flow_namespace *root_ns;
1024         struct mlx5_flow_table *acl;
1025         struct mlx5_flow_group *g;
1026         void *match_criteria;
1027         u32 *flow_group_in;
1028         /* The ingress acl table contains 4 groups
1029          * (2 active rules at the same time -
1030          *      1 allow rule from one of the first 3 groups.
1031          *      1 drop rule from the last group):
1032          * 1)Allow untagged traffic with smac=original mac.
1033          * 2)Allow untagged traffic.
1034          * 3)Allow traffic with smac=original mac.
1035          * 4)Drop all other traffic.
1036          */
1037         int table_size = 4;
1038         int err = 0;
1039
1040         if (!MLX5_CAP_ESW_INGRESS_ACL(dev, ft_support))
1041                 return -EOPNOTSUPP;
1042
1043         if (!IS_ERR_OR_NULL(vport->ingress.acl))
1044                 return 0;
1045
1046         esw_debug(dev, "Create vport[%d] ingress ACL log_max_size(%d)\n",
1047                   vport->vport, MLX5_CAP_ESW_INGRESS_ACL(dev, log_max_ft_size));
1048
1049         root_ns = mlx5_get_flow_vport_acl_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_INGRESS,
1050                                                     vport->vport);
1051         if (!root_ns) {
1052                 esw_warn(dev, "Failed to get E-Switch ingress flow namespace for vport (%d)\n", vport->vport);
1053                 return -EOPNOTSUPP;
1054         }
1055
1056         flow_group_in = kvzalloc(inlen, GFP_KERNEL);
1057         if (!flow_group_in)
1058                 return -ENOMEM;
1059
1060         acl = mlx5_create_vport_flow_table(root_ns, 0, table_size, 0, vport->vport);
1061         if (IS_ERR(acl)) {
1062                 err = PTR_ERR(acl);
1063                 esw_warn(dev, "Failed to create E-Switch vport[%d] ingress flow Table, err(%d)\n",
1064                          vport->vport, err);
1065                 goto out;
1066         }
1067         vport->ingress.acl = acl;
1068
1069         match_criteria = MLX5_ADDR_OF(create_flow_group_in, flow_group_in, match_criteria);
1070
1071         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1072         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.cvlan_tag);
1073         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.smac_47_16);
1074         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.smac_15_0);
1075         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
1076         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 0);
1077
1078         g = mlx5_create_flow_group(acl, flow_group_in);
1079         if (IS_ERR(g)) {
1080                 err = PTR_ERR(g);
1081                 esw_warn(dev, "Failed to create E-Switch vport[%d] ingress untagged spoofchk flow group, err(%d)\n",
1082                          vport->vport, err);
1083                 goto out;
1084         }
1085         vport->ingress.allow_untagged_spoofchk_grp = g;
1086
1087         memset(flow_group_in, 0, inlen);
1088         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1089         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.cvlan_tag);
1090         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 1);
1091         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 1);
1092
1093         g = mlx5_create_flow_group(acl, flow_group_in);
1094         if (IS_ERR(g)) {
1095                 err = PTR_ERR(g);
1096                 esw_warn(dev, "Failed to create E-Switch vport[%d] ingress untagged flow group, err(%d)\n",
1097                          vport->vport, err);
1098                 goto out;
1099         }
1100         vport->ingress.allow_untagged_only_grp = g;
1101
1102         memset(flow_group_in, 0, inlen);
1103         MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1104         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.smac_47_16);
1105         MLX5_SET_TO_ONES(fte_match_param, match_criteria, outer_headers.smac_15_0);
1106         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 2);
1107         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 2);
1108
1109         g = mlx5_create_flow_group(acl, flow_group_in);
1110         if (IS_ERR(g)) {
1111                 err = PTR_ERR(g);
1112                 esw_warn(dev, "Failed to create E-Switch vport[%d] ingress spoofchk flow group, err(%d)\n",
1113                          vport->vport, err);
1114                 goto out;
1115         }
1116         vport->ingress.allow_spoofchk_only_grp = g;
1117
1118         memset(flow_group_in, 0, inlen);
1119         MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 3);
1120         MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index, 3);
1121
1122         g = mlx5_create_flow_group(acl, flow_group_in);
1123         if (IS_ERR(g)) {
1124                 err = PTR_ERR(g);
1125                 esw_warn(dev, "Failed to create E-Switch vport[%d] ingress drop flow group, err(%d)\n",
1126                          vport->vport, err);
1127                 goto out;
1128         }
1129         vport->ingress.drop_grp = g;
1130
1131 out:
1132         if (err) {
1133                 if (!IS_ERR_OR_NULL(vport->ingress.allow_spoofchk_only_grp))
1134                         mlx5_destroy_flow_group(
1135                                         vport->ingress.allow_spoofchk_only_grp);
1136                 if (!IS_ERR_OR_NULL(vport->ingress.allow_untagged_only_grp))
1137                         mlx5_destroy_flow_group(
1138                                         vport->ingress.allow_untagged_only_grp);
1139                 if (!IS_ERR_OR_NULL(vport->ingress.allow_untagged_spoofchk_grp))
1140                         mlx5_destroy_flow_group(
1141                                 vport->ingress.allow_untagged_spoofchk_grp);
1142                 if (!IS_ERR_OR_NULL(vport->ingress.acl))
1143                         mlx5_destroy_flow_table(vport->ingress.acl);
1144         }
1145
1146         kvfree(flow_group_in);
1147         return err;
1148 }
1149
1150 void esw_vport_cleanup_ingress_rules(struct mlx5_eswitch *esw,
1151                                      struct mlx5_vport *vport)
1152 {
1153         if (!IS_ERR_OR_NULL(vport->ingress.drop_rule))
1154                 mlx5_del_flow_rules(vport->ingress.drop_rule);
1155
1156         if (!IS_ERR_OR_NULL(vport->ingress.allow_rule))
1157                 mlx5_del_flow_rules(vport->ingress.allow_rule);
1158
1159         vport->ingress.drop_rule = NULL;
1160         vport->ingress.allow_rule = NULL;
1161 }
1162
1163 void esw_vport_disable_ingress_acl(struct mlx5_eswitch *esw,
1164                                    struct mlx5_vport *vport)
1165 {
1166         if (IS_ERR_OR_NULL(vport->ingress.acl))
1167                 return;
1168
1169         esw_debug(esw->dev, "Destroy vport[%d] E-Switch ingress ACL\n", vport->vport);
1170
1171         esw_vport_cleanup_ingress_rules(esw, vport);
1172         mlx5_destroy_flow_group(vport->ingress.allow_spoofchk_only_grp);
1173         mlx5_destroy_flow_group(vport->ingress.allow_untagged_only_grp);
1174         mlx5_destroy_flow_group(vport->ingress.allow_untagged_spoofchk_grp);
1175         mlx5_destroy_flow_group(vport->ingress.drop_grp);
1176         mlx5_destroy_flow_table(vport->ingress.acl);
1177         vport->ingress.acl = NULL;
1178         vport->ingress.drop_grp = NULL;
1179         vport->ingress.allow_spoofchk_only_grp = NULL;
1180         vport->ingress.allow_untagged_only_grp = NULL;
1181         vport->ingress.allow_untagged_spoofchk_grp = NULL;
1182 }
1183
1184 static int esw_vport_ingress_config(struct mlx5_eswitch *esw,
1185                                     struct mlx5_vport *vport)
1186 {
1187         struct mlx5_fc *counter = vport->ingress.drop_counter;
1188         struct mlx5_flow_destination drop_ctr_dst = {0};
1189         struct mlx5_flow_destination *dst = NULL;
1190         struct mlx5_flow_act flow_act = {0};
1191         struct mlx5_flow_spec *spec;
1192         int dest_num = 0;
1193         int err = 0;
1194         u8 *smac_v;
1195
1196         esw_vport_cleanup_ingress_rules(esw, vport);
1197
1198         if (!vport->info.vlan && !vport->info.qos && !vport->info.spoofchk) {
1199                 esw_vport_disable_ingress_acl(esw, vport);
1200                 return 0;
1201         }
1202
1203         err = esw_vport_enable_ingress_acl(esw, vport);
1204         if (err) {
1205                 mlx5_core_warn(esw->dev,
1206                                "failed to enable ingress acl (%d) on vport[%d]\n",
1207                                err, vport->vport);
1208                 return err;
1209         }
1210
1211         esw_debug(esw->dev,
1212                   "vport[%d] configure ingress rules, vlan(%d) qos(%d)\n",
1213                   vport->vport, vport->info.vlan, vport->info.qos);
1214
1215         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
1216         if (!spec) {
1217                 err = -ENOMEM;
1218                 goto out;
1219         }
1220
1221         if (vport->info.vlan || vport->info.qos)
1222                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.cvlan_tag);
1223
1224         if (vport->info.spoofchk) {
1225                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.smac_47_16);
1226                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.smac_15_0);
1227                 smac_v = MLX5_ADDR_OF(fte_match_param,
1228                                       spec->match_value,
1229                                       outer_headers.smac_47_16);
1230                 ether_addr_copy(smac_v, vport->info.mac);
1231         }
1232
1233         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
1234         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_ALLOW;
1235         vport->ingress.allow_rule =
1236                 mlx5_add_flow_rules(vport->ingress.acl, spec,
1237                                     &flow_act, NULL, 0);
1238         if (IS_ERR(vport->ingress.allow_rule)) {
1239                 err = PTR_ERR(vport->ingress.allow_rule);
1240                 esw_warn(esw->dev,
1241                          "vport[%d] configure ingress allow rule, err(%d)\n",
1242                          vport->vport, err);
1243                 vport->ingress.allow_rule = NULL;
1244                 goto out;
1245         }
1246
1247         memset(spec, 0, sizeof(*spec));
1248         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_DROP;
1249
1250         /* Attach drop flow counter */
1251         if (counter) {
1252                 flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_COUNT;
1253                 drop_ctr_dst.type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;
1254                 drop_ctr_dst.counter_id = mlx5_fc_id(counter);
1255                 dst = &drop_ctr_dst;
1256                 dest_num++;
1257         }
1258         vport->ingress.drop_rule =
1259                 mlx5_add_flow_rules(vport->ingress.acl, spec,
1260                                     &flow_act, dst, dest_num);
1261         if (IS_ERR(vport->ingress.drop_rule)) {
1262                 err = PTR_ERR(vport->ingress.drop_rule);
1263                 esw_warn(esw->dev,
1264                          "vport[%d] configure ingress drop rule, err(%d)\n",
1265                          vport->vport, err);
1266                 vport->ingress.drop_rule = NULL;
1267                 goto out;
1268         }
1269
1270 out:
1271         if (err)
1272                 esw_vport_cleanup_ingress_rules(esw, vport);
1273         kvfree(spec);
1274         return err;
1275 }
1276
1277 static int esw_vport_egress_config(struct mlx5_eswitch *esw,
1278                                    struct mlx5_vport *vport)
1279 {
1280         struct mlx5_fc *counter = vport->egress.drop_counter;
1281         struct mlx5_flow_destination drop_ctr_dst = {0};
1282         struct mlx5_flow_destination *dst = NULL;
1283         struct mlx5_flow_act flow_act = {0};
1284         struct mlx5_flow_spec *spec;
1285         int dest_num = 0;
1286         int err = 0;
1287
1288         esw_vport_cleanup_egress_rules(esw, vport);
1289
1290         if (!vport->info.vlan && !vport->info.qos) {
1291                 esw_vport_disable_egress_acl(esw, vport);
1292                 return 0;
1293         }
1294
1295         err = esw_vport_enable_egress_acl(esw, vport);
1296         if (err) {
1297                 mlx5_core_warn(esw->dev,
1298                                "failed to enable egress acl (%d) on vport[%d]\n",
1299                                err, vport->vport);
1300                 return err;
1301         }
1302
1303         esw_debug(esw->dev,
1304                   "vport[%d] configure egress rules, vlan(%d) qos(%d)\n",
1305                   vport->vport, vport->info.vlan, vport->info.qos);
1306
1307         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
1308         if (!spec) {
1309                 err = -ENOMEM;
1310                 goto out;
1311         }
1312
1313         /* Allowed vlan rule */
1314         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.cvlan_tag);
1315         MLX5_SET_TO_ONES(fte_match_param, spec->match_value, outer_headers.cvlan_tag);
1316         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.first_vid);
1317         MLX5_SET(fte_match_param, spec->match_value, outer_headers.first_vid, vport->info.vlan);
1318
1319         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
1320         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_ALLOW;
1321         vport->egress.allowed_vlan =
1322                 mlx5_add_flow_rules(vport->egress.acl, spec,
1323                                     &flow_act, NULL, 0);
1324         if (IS_ERR(vport->egress.allowed_vlan)) {
1325                 err = PTR_ERR(vport->egress.allowed_vlan);
1326                 esw_warn(esw->dev,
1327                          "vport[%d] configure egress allowed vlan rule failed, err(%d)\n",
1328                          vport->vport, err);
1329                 vport->egress.allowed_vlan = NULL;
1330                 goto out;
1331         }
1332
1333         /* Drop others rule (star rule) */
1334         memset(spec, 0, sizeof(*spec));
1335         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_DROP;
1336
1337         /* Attach egress drop flow counter */
1338         if (counter) {
1339                 flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_COUNT;
1340                 drop_ctr_dst.type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;
1341                 drop_ctr_dst.counter_id = mlx5_fc_id(counter);
1342                 dst = &drop_ctr_dst;
1343                 dest_num++;
1344         }
1345         vport->egress.drop_rule =
1346                 mlx5_add_flow_rules(vport->egress.acl, spec,
1347                                     &flow_act, dst, dest_num);
1348         if (IS_ERR(vport->egress.drop_rule)) {
1349                 err = PTR_ERR(vport->egress.drop_rule);
1350                 esw_warn(esw->dev,
1351                          "vport[%d] configure egress drop rule failed, err(%d)\n",
1352                          vport->vport, err);
1353                 vport->egress.drop_rule = NULL;
1354         }
1355 out:
1356         kvfree(spec);
1357         return err;
1358 }
1359
1360 /* Vport QoS management */
1361 static int esw_create_tsar(struct mlx5_eswitch *esw)
1362 {
1363         u32 tsar_ctx[MLX5_ST_SZ_DW(scheduling_context)] = {0};
1364         struct mlx5_core_dev *dev = esw->dev;
1365         int err;
1366
1367         if (!MLX5_CAP_GEN(dev, qos) || !MLX5_CAP_QOS(dev, esw_scheduling))
1368                 return 0;
1369
1370         if (esw->qos.enabled)
1371                 return -EEXIST;
1372
1373         err = mlx5_create_scheduling_element_cmd(dev,
1374                                                  SCHEDULING_HIERARCHY_E_SWITCH,
1375                                                  tsar_ctx,
1376                                                  &esw->qos.root_tsar_id);
1377         if (err) {
1378                 esw_warn(esw->dev, "E-Switch create TSAR failed (%d)\n", err);
1379                 return err;
1380         }
1381
1382         esw->qos.enabled = true;
1383         return 0;
1384 }
1385
1386 static void esw_destroy_tsar(struct mlx5_eswitch *esw)
1387 {
1388         int err;
1389
1390         if (!esw->qos.enabled)
1391                 return;
1392
1393         err = mlx5_destroy_scheduling_element_cmd(esw->dev,
1394                                                   SCHEDULING_HIERARCHY_E_SWITCH,
1395                                                   esw->qos.root_tsar_id);
1396         if (err)
1397                 esw_warn(esw->dev, "E-Switch destroy TSAR failed (%d)\n", err);
1398
1399         esw->qos.enabled = false;
1400 }
1401
1402 static int esw_vport_enable_qos(struct mlx5_eswitch *esw,
1403                                 struct mlx5_vport *vport,
1404                                 u32 initial_max_rate, u32 initial_bw_share)
1405 {
1406         u32 sched_ctx[MLX5_ST_SZ_DW(scheduling_context)] = {0};
1407         struct mlx5_core_dev *dev = esw->dev;
1408         void *vport_elem;
1409         int err = 0;
1410
1411         if (!esw->qos.enabled || !MLX5_CAP_GEN(dev, qos) ||
1412             !MLX5_CAP_QOS(dev, esw_scheduling))
1413                 return 0;
1414
1415         if (vport->qos.enabled)
1416                 return -EEXIST;
1417
1418         MLX5_SET(scheduling_context, sched_ctx, element_type,
1419                  SCHEDULING_CONTEXT_ELEMENT_TYPE_VPORT);
1420         vport_elem = MLX5_ADDR_OF(scheduling_context, sched_ctx,
1421                                   element_attributes);
1422         MLX5_SET(vport_element, vport_elem, vport_number, vport->vport);
1423         MLX5_SET(scheduling_context, sched_ctx, parent_element_id,
1424                  esw->qos.root_tsar_id);
1425         MLX5_SET(scheduling_context, sched_ctx, max_average_bw,
1426                  initial_max_rate);
1427         MLX5_SET(scheduling_context, sched_ctx, bw_share, initial_bw_share);
1428
1429         err = mlx5_create_scheduling_element_cmd(dev,
1430                                                  SCHEDULING_HIERARCHY_E_SWITCH,
1431                                                  sched_ctx,
1432                                                  &vport->qos.esw_tsar_ix);
1433         if (err) {
1434                 esw_warn(esw->dev, "E-Switch create TSAR vport element failed (vport=%d,err=%d)\n",
1435                          vport->vport, err);
1436                 return err;
1437         }
1438
1439         vport->qos.enabled = true;
1440         return 0;
1441 }
1442
1443 static void esw_vport_disable_qos(struct mlx5_eswitch *esw,
1444                                   struct mlx5_vport *vport)
1445 {
1446         int err;
1447
1448         if (!vport->qos.enabled)
1449                 return;
1450
1451         err = mlx5_destroy_scheduling_element_cmd(esw->dev,
1452                                                   SCHEDULING_HIERARCHY_E_SWITCH,
1453                                                   vport->qos.esw_tsar_ix);
1454         if (err)
1455                 esw_warn(esw->dev, "E-Switch destroy TSAR vport element failed (vport=%d,err=%d)\n",
1456                          vport->vport, err);
1457
1458         vport->qos.enabled = false;
1459 }
1460
1461 static int esw_vport_qos_config(struct mlx5_eswitch *esw,
1462                                 struct mlx5_vport *vport,
1463                                 u32 max_rate, u32 bw_share)
1464 {
1465         u32 sched_ctx[MLX5_ST_SZ_DW(scheduling_context)] = {0};
1466         struct mlx5_core_dev *dev = esw->dev;
1467         void *vport_elem;
1468         u32 bitmask = 0;
1469         int err = 0;
1470
1471         if (!MLX5_CAP_GEN(dev, qos) || !MLX5_CAP_QOS(dev, esw_scheduling))
1472                 return -EOPNOTSUPP;
1473
1474         if (!vport->qos.enabled)
1475                 return -EIO;
1476
1477         MLX5_SET(scheduling_context, sched_ctx, element_type,
1478                  SCHEDULING_CONTEXT_ELEMENT_TYPE_VPORT);
1479         vport_elem = MLX5_ADDR_OF(scheduling_context, sched_ctx,
1480                                   element_attributes);
1481         MLX5_SET(vport_element, vport_elem, vport_number, vport->vport);
1482         MLX5_SET(scheduling_context, sched_ctx, parent_element_id,
1483                  esw->qos.root_tsar_id);
1484         MLX5_SET(scheduling_context, sched_ctx, max_average_bw,
1485                  max_rate);
1486         MLX5_SET(scheduling_context, sched_ctx, bw_share, bw_share);
1487         bitmask |= MODIFY_SCHEDULING_ELEMENT_IN_MODIFY_BITMASK_MAX_AVERAGE_BW;
1488         bitmask |= MODIFY_SCHEDULING_ELEMENT_IN_MODIFY_BITMASK_BW_SHARE;
1489
1490         err = mlx5_modify_scheduling_element_cmd(dev,
1491                                                  SCHEDULING_HIERARCHY_E_SWITCH,
1492                                                  sched_ctx,
1493                                                  vport->qos.esw_tsar_ix,
1494                                                  bitmask);
1495         if (err) {
1496                 esw_warn(esw->dev, "E-Switch modify TSAR vport element failed (vport=%d,err=%d)\n",
1497                          vport->vport, err);
1498                 return err;
1499         }
1500
1501         return 0;
1502 }
1503
1504 static void node_guid_gen_from_mac(u64 *node_guid, u8 mac[ETH_ALEN])
1505 {
1506         ((u8 *)node_guid)[7] = mac[0];
1507         ((u8 *)node_guid)[6] = mac[1];
1508         ((u8 *)node_guid)[5] = mac[2];
1509         ((u8 *)node_guid)[4] = 0xff;
1510         ((u8 *)node_guid)[3] = 0xfe;
1511         ((u8 *)node_guid)[2] = mac[3];
1512         ((u8 *)node_guid)[1] = mac[4];
1513         ((u8 *)node_guid)[0] = mac[5];
1514 }
1515
1516 static void esw_apply_vport_conf(struct mlx5_eswitch *esw,
1517                                  struct mlx5_vport *vport)
1518 {
1519         int vport_num = vport->vport;
1520
1521         if (esw->manager_vport == vport_num)
1522                 return;
1523
1524         mlx5_modify_vport_admin_state(esw->dev,
1525                                       MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
1526                                       vport_num, 1,
1527                                       vport->info.link_state);
1528
1529         /* Host PF has its own mac/guid. */
1530         if (vport_num) {
1531                 mlx5_modify_nic_vport_mac_address(esw->dev, vport_num,
1532                                                   vport->info.mac);
1533                 mlx5_modify_nic_vport_node_guid(esw->dev, vport_num,
1534                                                 vport->info.node_guid);
1535         }
1536
1537         modify_esw_vport_cvlan(esw->dev, vport_num, vport->info.vlan, vport->info.qos,
1538                                (vport->info.vlan || vport->info.qos));
1539
1540         /* Only legacy mode needs ACLs */
1541         if (esw->mode == SRIOV_LEGACY) {
1542                 esw_vport_ingress_config(esw, vport);
1543                 esw_vport_egress_config(esw, vport);
1544         }
1545 }
1546
1547 static void esw_vport_create_drop_counters(struct mlx5_vport *vport)
1548 {
1549         struct mlx5_core_dev *dev = vport->dev;
1550
1551         if (MLX5_CAP_ESW_INGRESS_ACL(dev, flow_counter)) {
1552                 vport->ingress.drop_counter = mlx5_fc_create(dev, false);
1553                 if (IS_ERR(vport->ingress.drop_counter)) {
1554                         esw_warn(dev,
1555                                  "vport[%d] configure ingress drop rule counter failed\n",
1556                                  vport->vport);
1557                         vport->ingress.drop_counter = NULL;
1558                 }
1559         }
1560
1561         if (MLX5_CAP_ESW_EGRESS_ACL(dev, flow_counter)) {
1562                 vport->egress.drop_counter = mlx5_fc_create(dev, false);
1563                 if (IS_ERR(vport->egress.drop_counter)) {
1564                         esw_warn(dev,
1565                                  "vport[%d] configure egress drop rule counter failed\n",
1566                                  vport->vport);
1567                         vport->egress.drop_counter = NULL;
1568                 }
1569         }
1570 }
1571
1572 static void esw_vport_destroy_drop_counters(struct mlx5_vport *vport)
1573 {
1574         struct mlx5_core_dev *dev = vport->dev;
1575
1576         if (vport->ingress.drop_counter)
1577                 mlx5_fc_destroy(dev, vport->ingress.drop_counter);
1578         if (vport->egress.drop_counter)
1579                 mlx5_fc_destroy(dev, vport->egress.drop_counter);
1580 }
1581
1582 static void esw_enable_vport(struct mlx5_eswitch *esw, struct mlx5_vport *vport,
1583                              int enable_events)
1584 {
1585         u16 vport_num = vport->vport;
1586
1587         mutex_lock(&esw->state_lock);
1588         WARN_ON(vport->enabled);
1589
1590         esw_debug(esw->dev, "Enabling VPORT(%d)\n", vport_num);
1591
1592         /* Create steering drop counters for ingress and egress ACLs */
1593         if (vport_num && esw->mode == SRIOV_LEGACY)
1594                 esw_vport_create_drop_counters(vport);
1595
1596         /* Restore old vport configuration */
1597         esw_apply_vport_conf(esw, vport);
1598
1599         /* Attach vport to the eswitch rate limiter */
1600         if (esw_vport_enable_qos(esw, vport, vport->info.max_rate,
1601                                  vport->qos.bw_share))
1602                 esw_warn(esw->dev, "Failed to attach vport %d to eswitch rate limiter", vport_num);
1603
1604         /* Sync with current vport context */
1605         vport->enabled_events = enable_events;
1606         vport->enabled = true;
1607
1608         /* Esw manager is trusted by default. Host PF (vport 0) is trusted as well
1609          * in smartNIC as it's a vport group manager.
1610          */
1611         if (esw->manager_vport == vport_num ||
1612             (!vport_num && mlx5_core_is_ecpf(esw->dev)))
1613                 vport->info.trusted = true;
1614
1615         esw_vport_change_handle_locked(vport);
1616
1617         esw->enabled_vports++;
1618         esw_debug(esw->dev, "Enabled VPORT(%d)\n", vport_num);
1619         mutex_unlock(&esw->state_lock);
1620 }
1621
1622 static void esw_disable_vport(struct mlx5_eswitch *esw,
1623                               struct mlx5_vport *vport)
1624 {
1625         u16 vport_num = vport->vport;
1626
1627         if (!vport->enabled)
1628                 return;
1629
1630         esw_debug(esw->dev, "Disabling vport(%d)\n", vport_num);
1631         /* Mark this vport as disabled to discard new events */
1632         vport->enabled = false;
1633
1634         /* Wait for current already scheduled events to complete */
1635         flush_workqueue(esw->work_queue);
1636         /* Disable events from this vport */
1637         arm_vport_context_events_cmd(esw->dev, vport->vport, 0);
1638         mutex_lock(&esw->state_lock);
1639         /* We don't assume VFs will cleanup after themselves.
1640          * Calling vport change handler while vport is disabled will cleanup
1641          * the vport resources.
1642          */
1643         esw_vport_change_handle_locked(vport);
1644         vport->enabled_events = 0;
1645         esw_vport_disable_qos(esw, vport);
1646         if (esw->manager_vport != vport_num &&
1647             esw->mode == SRIOV_LEGACY) {
1648                 mlx5_modify_vport_admin_state(esw->dev,
1649                                               MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
1650                                               vport_num, 1,
1651                                               MLX5_VPORT_ADMIN_STATE_DOWN);
1652                 esw_vport_disable_egress_acl(esw, vport);
1653                 esw_vport_disable_ingress_acl(esw, vport);
1654                 esw_vport_destroy_drop_counters(vport);
1655         }
1656         esw->enabled_vports--;
1657         mutex_unlock(&esw->state_lock);
1658 }
1659
1660 static int eswitch_vport_event(struct notifier_block *nb,
1661                                unsigned long type, void *data)
1662 {
1663         struct mlx5_eswitch *esw = mlx5_nb_cof(nb, struct mlx5_eswitch, nb);
1664         struct mlx5_eqe *eqe = data;
1665         struct mlx5_vport *vport;
1666         u16 vport_num;
1667
1668         vport_num = be16_to_cpu(eqe->data.vport_change.vport_num);
1669         vport = mlx5_eswitch_get_vport(esw, vport_num);
1670         if (vport->enabled)
1671                 queue_work(esw->work_queue, &vport->vport_change_handler);
1672
1673         return NOTIFY_OK;
1674 }
1675
1676 /* Public E-Switch API */
1677 #define ESW_ALLOWED(esw) ((esw) && MLX5_ESWITCH_MANAGER((esw)->dev))
1678
1679 int mlx5_eswitch_enable_sriov(struct mlx5_eswitch *esw, int nvfs, int mode)
1680 {
1681         int vf_nvports = 0, total_nvports = 0;
1682         struct mlx5_vport *vport;
1683         int err;
1684         int i, enabled_events;
1685
1686         if (!ESW_ALLOWED(esw) ||
1687             !MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ft_support)) {
1688                 esw_warn(esw->dev, "E-Switch FDB is not supported, aborting ...\n");
1689                 return -EOPNOTSUPP;
1690         }
1691
1692         if (!MLX5_CAP_ESW_INGRESS_ACL(esw->dev, ft_support))
1693                 esw_warn(esw->dev, "E-Switch ingress ACL is not supported by FW\n");
1694
1695         if (!MLX5_CAP_ESW_EGRESS_ACL(esw->dev, ft_support))
1696                 esw_warn(esw->dev, "E-Switch engress ACL is not supported by FW\n");
1697
1698         esw_info(esw->dev, "E-Switch enable SRIOV: nvfs(%d) mode (%d)\n", nvfs, mode);
1699
1700         if (mode == SRIOV_OFFLOADS) {
1701                 if (mlx5_core_is_ecpf_esw_manager(esw->dev)) {
1702                         err = mlx5_query_host_params_num_vfs(esw->dev, &vf_nvports);
1703                         if (err)
1704                                 return err;
1705                         total_nvports = esw->total_vports;
1706                 } else {
1707                         vf_nvports = nvfs;
1708                         total_nvports = nvfs + MLX5_SPECIAL_VPORTS(esw->dev);
1709                 }
1710         }
1711
1712         esw->mode = mode;
1713
1714         mlx5_lag_update(esw->dev);
1715
1716         if (mode == SRIOV_LEGACY) {
1717                 err = esw_create_legacy_table(esw);
1718                 if (err)
1719                         goto abort;
1720         } else {
1721                 mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_ETH);
1722                 mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
1723                 err = esw_offloads_init(esw, vf_nvports, total_nvports);
1724         }
1725
1726         if (err)
1727                 goto abort;
1728
1729         err = esw_create_tsar(esw);
1730         if (err)
1731                 esw_warn(esw->dev, "Failed to create eswitch TSAR");
1732
1733         /* Don't enable vport events when in SRIOV_OFFLOADS mode, since:
1734          * 1. L2 table (MPFS) is programmed by PF/VF representors netdevs set_rx_mode
1735          * 2. FDB/Eswitch is programmed by user space tools
1736          */
1737         enabled_events = (mode == SRIOV_LEGACY) ? SRIOV_VPORT_EVENTS : 0;
1738
1739         /* Enable PF vport */
1740         vport = mlx5_eswitch_get_vport(esw, MLX5_VPORT_PF);
1741         esw_enable_vport(esw, vport, enabled_events);
1742
1743         /* Enable ECPF vports */
1744         if (mlx5_ecpf_vport_exists(esw->dev)) {
1745                 vport = mlx5_eswitch_get_vport(esw, MLX5_VPORT_ECPF);
1746                 esw_enable_vport(esw, vport, enabled_events);
1747         }
1748
1749         /* Enable VF vports */
1750         mlx5_esw_for_each_vf_vport(esw, i, vport, nvfs)
1751                 esw_enable_vport(esw, vport, enabled_events);
1752
1753         if (mode == SRIOV_LEGACY) {
1754                 MLX5_NB_INIT(&esw->nb, eswitch_vport_event, NIC_VPORT_CHANGE);
1755                 mlx5_eq_notifier_register(esw->dev, &esw->nb);
1756         }
1757
1758         esw_info(esw->dev, "SRIOV enabled: active vports(%d)\n",
1759                  esw->enabled_vports);
1760         return 0;
1761
1762 abort:
1763         esw->mode = SRIOV_NONE;
1764
1765         if (mode == SRIOV_OFFLOADS) {
1766                 mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
1767                 mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_ETH);
1768         }
1769
1770         return err;
1771 }
1772
1773 void mlx5_eswitch_disable_sriov(struct mlx5_eswitch *esw)
1774 {
1775         struct esw_mc_addr *mc_promisc;
1776         struct mlx5_vport *vport;
1777         int old_mode;
1778         int i;
1779
1780         if (!ESW_ALLOWED(esw) || esw->mode == SRIOV_NONE)
1781                 return;
1782
1783         esw_info(esw->dev, "disable SRIOV: active vports(%d) mode(%d)\n",
1784                  esw->enabled_vports, esw->mode);
1785
1786         mc_promisc = &esw->mc_promisc;
1787
1788         if (esw->mode == SRIOV_LEGACY)
1789                 mlx5_eq_notifier_unregister(esw->dev, &esw->nb);
1790
1791         mlx5_esw_for_all_vports(esw, i, vport)
1792                 esw_disable_vport(esw, vport);
1793
1794         if (mc_promisc && mc_promisc->uplink_rule)
1795                 mlx5_del_flow_rules(mc_promisc->uplink_rule);
1796
1797         esw_destroy_tsar(esw);
1798
1799         if (esw->mode == SRIOV_LEGACY)
1800                 esw_destroy_legacy_table(esw);
1801         else if (esw->mode == SRIOV_OFFLOADS)
1802                 esw_offloads_cleanup(esw);
1803
1804         old_mode = esw->mode;
1805         esw->mode = SRIOV_NONE;
1806
1807         mlx5_lag_update(esw->dev);
1808
1809         if (old_mode == SRIOV_OFFLOADS) {
1810                 mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
1811                 mlx5_reload_interface(esw->dev, MLX5_INTERFACE_PROTOCOL_ETH);
1812         }
1813 }
1814
1815 int mlx5_eswitch_init(struct mlx5_core_dev *dev)
1816 {
1817         int total_vports = MLX5_TOTAL_VPORTS(dev);
1818         struct mlx5_eswitch *esw;
1819         struct mlx5_vport *vport;
1820         int err, i;
1821
1822         if (!MLX5_VPORT_MANAGER(dev))
1823                 return 0;
1824
1825         esw_info(dev,
1826                  "Total vports %d, per vport: max uc(%d) max mc(%d)\n",
1827                  total_vports,
1828                  MLX5_MAX_UC_PER_VPORT(dev),
1829                  MLX5_MAX_MC_PER_VPORT(dev));
1830
1831         esw = kzalloc(sizeof(*esw), GFP_KERNEL);
1832         if (!esw)
1833                 return -ENOMEM;
1834
1835         esw->dev = dev;
1836         esw->manager_vport = mlx5_eswitch_manager_vport(dev);
1837
1838         esw->work_queue = create_singlethread_workqueue("mlx5_esw_wq");
1839         if (!esw->work_queue) {
1840                 err = -ENOMEM;
1841                 goto abort;
1842         }
1843
1844         esw->vports = kcalloc(total_vports, sizeof(struct mlx5_vport),
1845                               GFP_KERNEL);
1846         if (!esw->vports) {
1847                 err = -ENOMEM;
1848                 goto abort;
1849         }
1850
1851         esw->total_vports = total_vports;
1852
1853         err = esw_offloads_init_reps(esw);
1854         if (err)
1855                 goto abort;
1856
1857         hash_init(esw->offloads.encap_tbl);
1858         hash_init(esw->offloads.mod_hdr_tbl);
1859         mutex_init(&esw->state_lock);
1860
1861         mlx5_esw_for_all_vports(esw, i, vport) {
1862                 vport->vport = mlx5_eswitch_index_to_vport_num(esw, i);
1863                 vport->info.link_state = MLX5_VPORT_ADMIN_STATE_AUTO;
1864                 vport->dev = dev;
1865                 INIT_WORK(&vport->vport_change_handler,
1866                           esw_vport_change_handler);
1867         }
1868
1869         esw->enabled_vports = 0;
1870         esw->mode = SRIOV_NONE;
1871         esw->offloads.inline_mode = MLX5_INLINE_MODE_NONE;
1872         if (MLX5_CAP_ESW_FLOWTABLE_FDB(dev, reformat) &&
1873             MLX5_CAP_ESW_FLOWTABLE_FDB(dev, decap))
1874                 esw->offloads.encap = DEVLINK_ESWITCH_ENCAP_MODE_BASIC;
1875         else
1876                 esw->offloads.encap = DEVLINK_ESWITCH_ENCAP_MODE_NONE;
1877
1878         dev->priv.eswitch = esw;
1879         return 0;
1880 abort:
1881         if (esw->work_queue)
1882                 destroy_workqueue(esw->work_queue);
1883         esw_offloads_cleanup_reps(esw);
1884         kfree(esw->vports);
1885         kfree(esw);
1886         return err;
1887 }
1888
1889 void mlx5_eswitch_cleanup(struct mlx5_eswitch *esw)
1890 {
1891         if (!esw || !MLX5_VPORT_MANAGER(esw->dev))
1892                 return;
1893
1894         esw_info(esw->dev, "cleanup\n");
1895
1896         esw->dev->priv.eswitch = NULL;
1897         destroy_workqueue(esw->work_queue);
1898         esw_offloads_cleanup_reps(esw);
1899         kfree(esw->vports);
1900         kfree(esw);
1901 }
1902
1903 /* Vport Administration */
1904 #define LEGAL_VPORT(esw, vport) (vport >= 0 && vport < esw->total_vports)
1905
1906 int mlx5_eswitch_set_vport_mac(struct mlx5_eswitch *esw,
1907                                int vport, u8 mac[ETH_ALEN])
1908 {
1909         struct mlx5_vport *evport;
1910         u64 node_guid;
1911         int err = 0;
1912
1913         if (!esw || !MLX5_CAP_GEN(esw->dev, vport_group_manager))
1914                 return -EPERM;
1915         if (!LEGAL_VPORT(esw, vport) || is_multicast_ether_addr(mac))
1916                 return -EINVAL;
1917
1918         mutex_lock(&esw->state_lock);
1919         evport = mlx5_eswitch_get_vport(esw, vport);
1920
1921         if (evport->info.spoofchk && !is_valid_ether_addr(mac))
1922                 mlx5_core_warn(esw->dev,
1923                                "Set invalid MAC while spoofchk is on, vport(%d)\n",
1924                                vport);
1925
1926         err = mlx5_modify_nic_vport_mac_address(esw->dev, vport, mac);
1927         if (err) {
1928                 mlx5_core_warn(esw->dev,
1929                                "Failed to mlx5_modify_nic_vport_mac vport(%d) err=(%d)\n",
1930                                vport, err);
1931                 goto unlock;
1932         }
1933
1934         node_guid_gen_from_mac(&node_guid, mac);
1935         err = mlx5_modify_nic_vport_node_guid(esw->dev, vport, node_guid);
1936         if (err)
1937                 mlx5_core_warn(esw->dev,
1938                                "Failed to set vport %d node guid, err = %d. RDMA_CM will not function properly for this VF.\n",
1939                                vport, err);
1940
1941         ether_addr_copy(evport->info.mac, mac);
1942         evport->info.node_guid = node_guid;
1943         if (evport->enabled && esw->mode == SRIOV_LEGACY)
1944                 err = esw_vport_ingress_config(esw, evport);
1945
1946 unlock:
1947         mutex_unlock(&esw->state_lock);
1948         return err;
1949 }
1950
1951 int mlx5_eswitch_set_vport_state(struct mlx5_eswitch *esw,
1952                                  int vport, int link_state)
1953 {
1954         struct mlx5_vport *evport;
1955         int err = 0;
1956
1957         if (!ESW_ALLOWED(esw))
1958                 return -EPERM;
1959         if (!LEGAL_VPORT(esw, vport))
1960                 return -EINVAL;
1961
1962         mutex_lock(&esw->state_lock);
1963         evport = mlx5_eswitch_get_vport(esw, vport);
1964
1965         err = mlx5_modify_vport_admin_state(esw->dev,
1966                                             MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
1967                                             vport, 1, link_state);
1968         if (err) {
1969                 mlx5_core_warn(esw->dev,
1970                                "Failed to set vport %d link state, err = %d",
1971                                vport, err);
1972                 goto unlock;
1973         }
1974
1975         evport->info.link_state = link_state;
1976
1977 unlock:
1978         mutex_unlock(&esw->state_lock);
1979         return 0;
1980 }
1981
1982 int mlx5_eswitch_get_vport_config(struct mlx5_eswitch *esw,
1983                                   int vport, struct ifla_vf_info *ivi)
1984 {
1985         struct mlx5_vport *evport;
1986
1987         if (!esw || !MLX5_CAP_GEN(esw->dev, vport_group_manager))
1988                 return -EPERM;
1989         if (!LEGAL_VPORT(esw, vport))
1990                 return -EINVAL;
1991
1992         evport = mlx5_eswitch_get_vport(esw, vport);
1993
1994         memset(ivi, 0, sizeof(*ivi));
1995         ivi->vf = vport - 1;
1996
1997         mutex_lock(&esw->state_lock);
1998         ether_addr_copy(ivi->mac, evport->info.mac);
1999         ivi->linkstate = evport->info.link_state;
2000         ivi->vlan = evport->info.vlan;
2001         ivi->qos = evport->info.qos;
2002         ivi->spoofchk = evport->info.spoofchk;
2003         ivi->trusted = evport->info.trusted;
2004         ivi->min_tx_rate = evport->info.min_rate;
2005         ivi->max_tx_rate = evport->info.max_rate;
2006         mutex_unlock(&esw->state_lock);
2007
2008         return 0;
2009 }
2010
2011 int __mlx5_eswitch_set_vport_vlan(struct mlx5_eswitch *esw,
2012                                   int vport, u16 vlan, u8 qos, u8 set_flags)
2013 {
2014         struct mlx5_vport *evport;
2015         int err = 0;
2016
2017         if (!ESW_ALLOWED(esw))
2018                 return -EPERM;
2019         if (!LEGAL_VPORT(esw, vport) || (vlan > 4095) || (qos > 7))
2020                 return -EINVAL;
2021
2022         mutex_lock(&esw->state_lock);
2023         evport = mlx5_eswitch_get_vport(esw, vport);
2024
2025         err = modify_esw_vport_cvlan(esw->dev, vport, vlan, qos, set_flags);
2026         if (err)
2027                 goto unlock;
2028
2029         evport->info.vlan = vlan;
2030         evport->info.qos = qos;
2031         if (evport->enabled && esw->mode == SRIOV_LEGACY) {
2032                 err = esw_vport_ingress_config(esw, evport);
2033                 if (err)
2034                         goto unlock;
2035                 err = esw_vport_egress_config(esw, evport);
2036         }
2037
2038 unlock:
2039         mutex_unlock(&esw->state_lock);
2040         return err;
2041 }
2042
2043 int mlx5_eswitch_set_vport_vlan(struct mlx5_eswitch *esw,
2044                                 int vport, u16 vlan, u8 qos)
2045 {
2046         u8 set_flags = 0;
2047
2048         if (vlan || qos)
2049                 set_flags = SET_VLAN_STRIP | SET_VLAN_INSERT;
2050
2051         return __mlx5_eswitch_set_vport_vlan(esw, vport, vlan, qos, set_flags);
2052 }
2053
2054 int mlx5_eswitch_set_vport_spoofchk(struct mlx5_eswitch *esw,
2055                                     int vport, bool spoofchk)
2056 {
2057         struct mlx5_vport *evport;
2058         bool pschk;
2059         int err = 0;
2060
2061         if (!ESW_ALLOWED(esw))
2062                 return -EPERM;
2063         if (!LEGAL_VPORT(esw, vport))
2064                 return -EINVAL;
2065
2066         mutex_lock(&esw->state_lock);
2067         evport = mlx5_eswitch_get_vport(esw, vport);
2068         pschk = evport->info.spoofchk;
2069         evport->info.spoofchk = spoofchk;
2070         if (pschk && !is_valid_ether_addr(evport->info.mac))
2071                 mlx5_core_warn(esw->dev,
2072                                "Spoofchk in set while MAC is invalid, vport(%d)\n",
2073                                evport->vport);
2074         if (evport->enabled && esw->mode == SRIOV_LEGACY)
2075                 err = esw_vport_ingress_config(esw, evport);
2076         if (err)
2077                 evport->info.spoofchk = pschk;
2078         mutex_unlock(&esw->state_lock);
2079
2080         return err;
2081 }
2082
2083 static void esw_cleanup_vepa_rules(struct mlx5_eswitch *esw)
2084 {
2085         if (esw->fdb_table.legacy.vepa_uplink_rule)
2086                 mlx5_del_flow_rules(esw->fdb_table.legacy.vepa_uplink_rule);
2087
2088         if (esw->fdb_table.legacy.vepa_star_rule)
2089                 mlx5_del_flow_rules(esw->fdb_table.legacy.vepa_star_rule);
2090
2091         esw->fdb_table.legacy.vepa_uplink_rule = NULL;
2092         esw->fdb_table.legacy.vepa_star_rule = NULL;
2093 }
2094
2095 static int _mlx5_eswitch_set_vepa_locked(struct mlx5_eswitch *esw,
2096                                          u8 setting)
2097 {
2098         struct mlx5_flow_destination dest = {};
2099         struct mlx5_flow_act flow_act = {};
2100         struct mlx5_flow_handle *flow_rule;
2101         struct mlx5_flow_spec *spec;
2102         int err = 0;
2103         void *misc;
2104
2105         if (!setting) {
2106                 esw_cleanup_vepa_rules(esw);
2107                 return 0;
2108         }
2109
2110         if (esw->fdb_table.legacy.vepa_uplink_rule)
2111                 return 0;
2112
2113         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
2114         if (!spec)
2115                 return -ENOMEM;
2116
2117         /* Uplink rule forward uplink traffic to FDB */
2118         misc = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
2119         MLX5_SET(fte_match_set_misc, misc, source_port, MLX5_VPORT_UPLINK);
2120
2121         misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
2122         MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
2123
2124         spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS;
2125         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
2126         dest.ft = esw->fdb_table.legacy.fdb;
2127         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
2128         flow_rule = mlx5_add_flow_rules(esw->fdb_table.legacy.vepa_fdb, spec,
2129                                         &flow_act, &dest, 1);
2130         if (IS_ERR(flow_rule)) {
2131                 err = PTR_ERR(flow_rule);
2132                 goto out;
2133         } else {
2134                 esw->fdb_table.legacy.vepa_uplink_rule = flow_rule;
2135         }
2136
2137         /* Star rule to forward all traffic to uplink vport */
2138         memset(spec, 0, sizeof(*spec));
2139         memset(&dest, 0, sizeof(dest));
2140         dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
2141         dest.vport.num = MLX5_VPORT_UPLINK;
2142         flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
2143         flow_rule = mlx5_add_flow_rules(esw->fdb_table.legacy.vepa_fdb, spec,
2144                                         &flow_act, &dest, 1);
2145         if (IS_ERR(flow_rule)) {
2146                 err = PTR_ERR(flow_rule);
2147                 goto out;
2148         } else {
2149                 esw->fdb_table.legacy.vepa_star_rule = flow_rule;
2150         }
2151
2152 out:
2153         kvfree(spec);
2154         if (err)
2155                 esw_cleanup_vepa_rules(esw);
2156         return err;
2157 }
2158
2159 int mlx5_eswitch_set_vepa(struct mlx5_eswitch *esw, u8 setting)
2160 {
2161         int err = 0;
2162
2163         if (!esw)
2164                 return -EOPNOTSUPP;
2165
2166         if (!ESW_ALLOWED(esw))
2167                 return -EPERM;
2168
2169         mutex_lock(&esw->state_lock);
2170         if (esw->mode != SRIOV_LEGACY) {
2171                 err = -EOPNOTSUPP;
2172                 goto out;
2173         }
2174
2175         err = _mlx5_eswitch_set_vepa_locked(esw, setting);
2176
2177 out:
2178         mutex_unlock(&esw->state_lock);
2179         return err;
2180 }
2181
2182 int mlx5_eswitch_get_vepa(struct mlx5_eswitch *esw, u8 *setting)
2183 {
2184         int err = 0;
2185
2186         if (!esw)
2187                 return -EOPNOTSUPP;
2188
2189         if (!ESW_ALLOWED(esw))
2190                 return -EPERM;
2191
2192         mutex_lock(&esw->state_lock);
2193         if (esw->mode != SRIOV_LEGACY) {
2194                 err = -EOPNOTSUPP;
2195                 goto out;
2196         }
2197
2198         *setting = esw->fdb_table.legacy.vepa_uplink_rule ? 1 : 0;
2199
2200 out:
2201         mutex_unlock(&esw->state_lock);
2202         return err;
2203 }
2204
2205 int mlx5_eswitch_set_vport_trust(struct mlx5_eswitch *esw,
2206                                  int vport, bool setting)
2207 {
2208         struct mlx5_vport *evport;
2209
2210         if (!ESW_ALLOWED(esw))
2211                 return -EPERM;
2212         if (!LEGAL_VPORT(esw, vport))
2213                 return -EINVAL;
2214
2215         mutex_lock(&esw->state_lock);
2216         evport = mlx5_eswitch_get_vport(esw, vport);
2217         evport->info.trusted = setting;
2218         if (evport->enabled)
2219                 esw_vport_change_handle_locked(evport);
2220         mutex_unlock(&esw->state_lock);
2221
2222         return 0;
2223 }
2224
2225 static u32 calculate_vports_min_rate_divider(struct mlx5_eswitch *esw)
2226 {
2227         u32 fw_max_bw_share = MLX5_CAP_QOS(esw->dev, max_tsar_bw_share);
2228         struct mlx5_vport *evport;
2229         u32 max_guarantee = 0;
2230         int i;
2231
2232         mlx5_esw_for_all_vports(esw, i, evport) {
2233                 if (!evport->enabled || evport->info.min_rate < max_guarantee)
2234                         continue;
2235                 max_guarantee = evport->info.min_rate;
2236         }
2237
2238         return max_t(u32, max_guarantee / fw_max_bw_share, 1);
2239 }
2240
2241 static int normalize_vports_min_rate(struct mlx5_eswitch *esw, u32 divider)
2242 {
2243         u32 fw_max_bw_share = MLX5_CAP_QOS(esw->dev, max_tsar_bw_share);
2244         struct mlx5_vport *evport;
2245         u32 vport_max_rate;
2246         u32 vport_min_rate;
2247         u32 bw_share;
2248         int err;
2249         int i;
2250
2251         mlx5_esw_for_all_vports(esw, i, evport) {
2252                 if (!evport->enabled)
2253                         continue;
2254                 vport_min_rate = evport->info.min_rate;
2255                 vport_max_rate = evport->info.max_rate;
2256                 bw_share = MLX5_MIN_BW_SHARE;
2257
2258                 if (vport_min_rate)
2259                         bw_share = MLX5_RATE_TO_BW_SHARE(vport_min_rate,
2260                                                          divider,
2261                                                          fw_max_bw_share);
2262
2263                 if (bw_share == evport->qos.bw_share)
2264                         continue;
2265
2266                 err = esw_vport_qos_config(esw, evport, vport_max_rate,
2267                                            bw_share);
2268                 if (!err)
2269                         evport->qos.bw_share = bw_share;
2270                 else
2271                         return err;
2272         }
2273
2274         return 0;
2275 }
2276
2277 int mlx5_eswitch_set_vport_rate(struct mlx5_eswitch *esw, int vport,
2278                                 u32 max_rate, u32 min_rate)
2279 {
2280         struct mlx5_vport *evport;
2281         u32 fw_max_bw_share;
2282         u32 previous_min_rate;
2283         u32 divider;
2284         bool min_rate_supported;
2285         bool max_rate_supported;
2286         int err = 0;
2287
2288         if (!ESW_ALLOWED(esw))
2289                 return -EPERM;
2290         if (!LEGAL_VPORT(esw, vport))
2291                 return -EINVAL;
2292
2293         fw_max_bw_share = MLX5_CAP_QOS(esw->dev, max_tsar_bw_share);
2294         min_rate_supported = MLX5_CAP_QOS(esw->dev, esw_bw_share) &&
2295                                 fw_max_bw_share >= MLX5_MIN_BW_SHARE;
2296         max_rate_supported = MLX5_CAP_QOS(esw->dev, esw_rate_limit);
2297
2298         if ((min_rate && !min_rate_supported) || (max_rate && !max_rate_supported))
2299                 return -EOPNOTSUPP;
2300
2301         mutex_lock(&esw->state_lock);
2302         evport = mlx5_eswitch_get_vport(esw, vport);
2303
2304         if (min_rate == evport->info.min_rate)
2305                 goto set_max_rate;
2306
2307         previous_min_rate = evport->info.min_rate;
2308         evport->info.min_rate = min_rate;
2309         divider = calculate_vports_min_rate_divider(esw);
2310         err = normalize_vports_min_rate(esw, divider);
2311         if (err) {
2312                 evport->info.min_rate = previous_min_rate;
2313                 goto unlock;
2314         }
2315
2316 set_max_rate:
2317         if (max_rate == evport->info.max_rate)
2318                 goto unlock;
2319
2320         err = esw_vport_qos_config(esw, evport, max_rate, evport->qos.bw_share);
2321         if (!err)
2322                 evport->info.max_rate = max_rate;
2323
2324 unlock:
2325         mutex_unlock(&esw->state_lock);
2326         return err;
2327 }
2328
2329 static int mlx5_eswitch_query_vport_drop_stats(struct mlx5_core_dev *dev,
2330                                                struct mlx5_vport *vport,
2331                                                struct mlx5_vport_drop_stats *stats)
2332 {
2333         struct mlx5_eswitch *esw = dev->priv.eswitch;
2334         u64 rx_discard_vport_down, tx_discard_vport_down;
2335         u64 bytes = 0;
2336         int err = 0;
2337
2338         if (!vport->enabled || esw->mode != SRIOV_LEGACY)
2339                 return 0;
2340
2341         if (vport->egress.drop_counter)
2342                 mlx5_fc_query(dev, vport->egress.drop_counter,
2343                               &stats->rx_dropped, &bytes);
2344
2345         if (vport->ingress.drop_counter)
2346                 mlx5_fc_query(dev, vport->ingress.drop_counter,
2347                               &stats->tx_dropped, &bytes);
2348
2349         if (!MLX5_CAP_GEN(dev, receive_discard_vport_down) &&
2350             !MLX5_CAP_GEN(dev, transmit_discard_vport_down))
2351                 return 0;
2352
2353         err = mlx5_query_vport_down_stats(dev, vport->vport, 1,
2354                                           &rx_discard_vport_down,
2355                                           &tx_discard_vport_down);
2356         if (err)
2357                 return err;
2358
2359         if (MLX5_CAP_GEN(dev, receive_discard_vport_down))
2360                 stats->rx_dropped += rx_discard_vport_down;
2361         if (MLX5_CAP_GEN(dev, transmit_discard_vport_down))
2362                 stats->tx_dropped += tx_discard_vport_down;
2363
2364         return 0;
2365 }
2366
2367 int mlx5_eswitch_get_vport_stats(struct mlx5_eswitch *esw,
2368                                  int vport_num,
2369                                  struct ifla_vf_stats *vf_stats)
2370 {
2371         struct mlx5_vport *vport;
2372         int outlen = MLX5_ST_SZ_BYTES(query_vport_counter_out);
2373         u32 in[MLX5_ST_SZ_DW(query_vport_counter_in)] = {0};
2374         struct mlx5_vport_drop_stats stats = {0};
2375         int err = 0;
2376         u32 *out;
2377
2378         if (!ESW_ALLOWED(esw))
2379                 return -EPERM;
2380         if (!LEGAL_VPORT(esw, vport_num))
2381                 return -EINVAL;
2382
2383         vport = mlx5_eswitch_get_vport(esw, vport_num);
2384         out = kvzalloc(outlen, GFP_KERNEL);
2385         if (!out)
2386                 return -ENOMEM;
2387
2388         MLX5_SET(query_vport_counter_in, in, opcode,
2389                  MLX5_CMD_OP_QUERY_VPORT_COUNTER);
2390         MLX5_SET(query_vport_counter_in, in, op_mod, 0);
2391         MLX5_SET(query_vport_counter_in, in, vport_number, vport->vport);
2392         MLX5_SET(query_vport_counter_in, in, other_vport, 1);
2393
2394         memset(out, 0, outlen);
2395         err = mlx5_cmd_exec(esw->dev, in, sizeof(in), out, outlen);
2396         if (err)
2397                 goto free_out;
2398
2399         #define MLX5_GET_CTR(p, x) \
2400                 MLX5_GET64(query_vport_counter_out, p, x)
2401
2402         memset(vf_stats, 0, sizeof(*vf_stats));
2403         vf_stats->rx_packets =
2404                 MLX5_GET_CTR(out, received_eth_unicast.packets) +
2405                 MLX5_GET_CTR(out, received_ib_unicast.packets) +
2406                 MLX5_GET_CTR(out, received_eth_multicast.packets) +
2407                 MLX5_GET_CTR(out, received_ib_multicast.packets) +
2408                 MLX5_GET_CTR(out, received_eth_broadcast.packets);
2409
2410         vf_stats->rx_bytes =
2411                 MLX5_GET_CTR(out, received_eth_unicast.octets) +
2412                 MLX5_GET_CTR(out, received_ib_unicast.octets) +
2413                 MLX5_GET_CTR(out, received_eth_multicast.octets) +
2414                 MLX5_GET_CTR(out, received_ib_multicast.octets) +
2415                 MLX5_GET_CTR(out, received_eth_broadcast.octets);
2416
2417         vf_stats->tx_packets =
2418                 MLX5_GET_CTR(out, transmitted_eth_unicast.packets) +
2419                 MLX5_GET_CTR(out, transmitted_ib_unicast.packets) +
2420                 MLX5_GET_CTR(out, transmitted_eth_multicast.packets) +
2421                 MLX5_GET_CTR(out, transmitted_ib_multicast.packets) +
2422                 MLX5_GET_CTR(out, transmitted_eth_broadcast.packets);
2423
2424         vf_stats->tx_bytes =
2425                 MLX5_GET_CTR(out, transmitted_eth_unicast.octets) +
2426                 MLX5_GET_CTR(out, transmitted_ib_unicast.octets) +
2427                 MLX5_GET_CTR(out, transmitted_eth_multicast.octets) +
2428                 MLX5_GET_CTR(out, transmitted_ib_multicast.octets) +
2429                 MLX5_GET_CTR(out, transmitted_eth_broadcast.octets);
2430
2431         vf_stats->multicast =
2432                 MLX5_GET_CTR(out, received_eth_multicast.packets) +
2433                 MLX5_GET_CTR(out, received_ib_multicast.packets);
2434
2435         vf_stats->broadcast =
2436                 MLX5_GET_CTR(out, received_eth_broadcast.packets);
2437
2438         err = mlx5_eswitch_query_vport_drop_stats(esw->dev, vport, &stats);
2439         if (err)
2440                 goto free_out;
2441         vf_stats->rx_dropped = stats.rx_dropped;
2442         vf_stats->tx_dropped = stats.tx_dropped;
2443
2444 free_out:
2445         kvfree(out);
2446         return err;
2447 }
2448
2449 u8 mlx5_eswitch_mode(struct mlx5_eswitch *esw)
2450 {
2451         return ESW_ALLOWED(esw) ? esw->mode : SRIOV_NONE;
2452 }
2453 EXPORT_SYMBOL_GPL(mlx5_eswitch_mode);
2454
2455 bool mlx5_esw_lag_prereq(struct mlx5_core_dev *dev0, struct mlx5_core_dev *dev1)
2456 {
2457         if ((dev0->priv.eswitch->mode == SRIOV_NONE &&
2458              dev1->priv.eswitch->mode == SRIOV_NONE) ||
2459             (dev0->priv.eswitch->mode == SRIOV_OFFLOADS &&
2460              dev1->priv.eswitch->mode == SRIOV_OFFLOADS))
2461                 return true;
2462
2463         return false;
2464 }
2465
2466 bool mlx5_esw_multipath_prereq(struct mlx5_core_dev *dev0,
2467                                struct mlx5_core_dev *dev1)
2468 {
2469         return (dev0->priv.eswitch->mode == SRIOV_OFFLOADS &&
2470                 dev1->priv.eswitch->mode == SRIOV_OFFLOADS);
2471 }