drivers/net/ethernet/mellanox/mlx5/core/en_fs.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/list.h>
  34 #include <linux/ip.h>
  35 #include <linux/ipv6.h>
  36 #include <linux/tcp.h>
  37 #include <linux/mlx5/fs.h>
  38 #include "en.h"
  39
  40 static int mlx5e_add_l2_flow_rule(struct mlx5e_priv *priv,
  41                                   struct mlx5e_l2_rule *ai, int type);
  42 static void mlx5e_del_l2_flow_rule(struct mlx5e_priv *priv,
  43                                    struct mlx5e_l2_rule *ai);
  44
  45 enum {
  46         MLX5E_FULLMATCH = 0,
  47         MLX5E_ALLMULTI  = 1,
  48         MLX5E_PROMISC   = 2,
  49 };
  50
  51 enum {
  52         MLX5E_UC        = 0,
  53         MLX5E_MC_IPV4   = 1,
  54         MLX5E_MC_IPV6   = 2,
  55         MLX5E_MC_OTHER  = 3,
  56 };
  57
  58 enum {
  59         MLX5E_ACTION_NONE = 0,
  60         MLX5E_ACTION_ADD  = 1,
  61         MLX5E_ACTION_DEL  = 2,
  62 };
  63
  64 struct mlx5e_l2_hash_node {
  65         struct hlist_node          hlist;
  66         u8                         action;
  67         struct mlx5e_l2_rule ai;
  68 };
  69
  70 static inline int mlx5e_hash_l2(u8 *addr)
  71 {
  72         return addr[5];
  73 }
  74
  75 static void mlx5e_add_l2_to_hash(struct hlist_head *hash, u8 *addr)
  76 {
  77         struct mlx5e_l2_hash_node *hn;
  78         int ix = mlx5e_hash_l2(addr);
  79         int found = 0;
  80
  81         hlist_for_each_entry(hn, &hash[ix], hlist)
  82                 if (ether_addr_equal_64bits(hn->ai.addr, addr)) {
  83                         found = 1;
  84                         break;
  85                 }
  86
  87         if (found) {
  88                 hn->action = MLX5E_ACTION_NONE;
  89                 return;
  90         }
  91
  92         hn = kzalloc(sizeof(*hn), GFP_ATOMIC);
  93         if (!hn)
  94                 return;
  95
  96         ether_addr_copy(hn->ai.addr, addr);
  97         hn->action = MLX5E_ACTION_ADD;
  98
  99         hlist_add_head(&hn->hlist, &hash[ix]);
 100 }
 101
 102 static void mlx5e_del_l2_from_hash(struct mlx5e_l2_hash_node *hn)
 103 {
 104         hlist_del(&hn->hlist);
 105         kfree(hn);
 106 }
 107
 108 static int mlx5e_vport_context_update_vlans(struct mlx5e_priv *priv)
 109 {
 110         struct net_device *ndev = priv->netdev;
 111         int max_list_size;
 112         int list_size;
 113         u16 *vlans;
 114         int vlan;
 115         int err;
 116         int i;
 117
 118         list_size = 0;
 119         for_each_set_bit(vlan, priv->fs.vlan.active_vlans, VLAN_N_VID)
 120                 list_size++;
 121
 122         max_list_size = 1 << MLX5_CAP_GEN(priv->mdev, log_max_vlan_list);
 123
 124         if (list_size > max_list_size) {
 125                 netdev_warn(ndev,
 126                             "netdev vlans list size (%d) > (%d) max vport list size, some vlans will be dropped\n",
 127                             list_size, max_list_size);
 128                 list_size = max_list_size;
 129         }
 130
 131         vlans = kcalloc(list_size, sizeof(*vlans), GFP_KERNEL);
 132         if (!vlans)
 133                 return -ENOMEM;
 134
 135         i = 0;
 136         for_each_set_bit(vlan, priv->fs.vlan.active_vlans, VLAN_N_VID) {
 137                 if (i >= list_size)
 138                         break;
 139                 vlans[i++] = vlan;
 140         }
 141
 142         err = mlx5_modify_nic_vport_vlans(priv->mdev, vlans, list_size);
 143         if (err)
 144                 netdev_err(ndev, "Failed to modify vport vlans list err(%d)\n",
 145                            err);
 146
 147         kfree(vlans);
 148         return err;
 149 }
 150
 151 enum mlx5e_vlan_rule_type {
 152         MLX5E_VLAN_RULE_TYPE_UNTAGGED,
 153         MLX5E_VLAN_RULE_TYPE_ANY_VID,
 154         MLX5E_VLAN_RULE_TYPE_MATCH_VID,
 155 };
 156
 157 static int __mlx5e_add_vlan_rule(struct mlx5e_priv *priv,
 158                                  enum mlx5e_vlan_rule_type rule_type,
 159                                  u16 vid, struct mlx5_flow_spec *spec)
 160 {
 161         struct mlx5_flow_act flow_act = {
 162                 .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
 163                 .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG,
 164                 .encap_id = 0,
 165         };
 166         struct mlx5_flow_table *ft = priv->fs.vlan.ft.t;
 167         struct mlx5_flow_destination dest;
 168         struct mlx5_flow_handle **rule_p;
 169         int err = 0;
 170
 171         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 172         dest.ft = priv->fs.l2.ft.t;
 173
 174         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 175         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.vlan_tag);
 176
 177         switch (rule_type) {
 178         case MLX5E_VLAN_RULE_TYPE_UNTAGGED:
 179                 rule_p = &priv->fs.vlan.untagged_rule;
 180                 break;
 181         case MLX5E_VLAN_RULE_TYPE_ANY_VID:
 182                 rule_p = &priv->fs.vlan.any_vlan_rule;
 183                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.vlan_tag, 1);
 184                 break;
 185         default: /* MLX5E_VLAN_RULE_TYPE_MATCH_VID */
 186                 rule_p = &priv->fs.vlan.active_vlans_rule[vid];
 187                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.vlan_tag, 1);
 188                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 189                                  outer_headers.first_vid);
 190                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.first_vid,
 191                          vid);
 192                 break;
 193         }
 194
 195         *rule_p = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
 196
 197         if (IS_ERR(*rule_p)) {
 198                 err = PTR_ERR(*rule_p);
 199                 *rule_p = NULL;
 200                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
 201         }
 202
 203         return err;
 204 }
 205
 206 static int mlx5e_add_vlan_rule(struct mlx5e_priv *priv,
 207                                enum mlx5e_vlan_rule_type rule_type, u16 vid)
 208 {
 209         struct mlx5_flow_spec *spec;
 210         int err = 0;
 211
 212         spec = mlx5_vzalloc(sizeof(*spec));
 213         if (!spec) {
 214                 netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
 215                 return -ENOMEM;
 216         }
 217
 218         if (rule_type == MLX5E_VLAN_RULE_TYPE_MATCH_VID)
 219                 mlx5e_vport_context_update_vlans(priv);
 220
 221         err = __mlx5e_add_vlan_rule(priv, rule_type, vid, spec);
 222
 223         kvfree(spec);
 224
 225         return err;
 226 }
 227
 228 static void mlx5e_del_vlan_rule(struct mlx5e_priv *priv,
 229                                 enum mlx5e_vlan_rule_type rule_type, u16 vid)
 230 {
 231         switch (rule_type) {
 232         case MLX5E_VLAN_RULE_TYPE_UNTAGGED:
 233                 if (priv->fs.vlan.untagged_rule) {
 234                         mlx5_del_flow_rules(priv->fs.vlan.untagged_rule);
 235                         priv->fs.vlan.untagged_rule = NULL;
 236                 }
 237                 break;
 238         case MLX5E_VLAN_RULE_TYPE_ANY_VID:
 239                 if (priv->fs.vlan.any_vlan_rule) {
 240                         mlx5_del_flow_rules(priv->fs.vlan.any_vlan_rule);
 241                         priv->fs.vlan.any_vlan_rule = NULL;
 242                 }
 243                 break;
 244         case MLX5E_VLAN_RULE_TYPE_MATCH_VID:
 245                 mlx5e_vport_context_update_vlans(priv);
 246                 if (priv->fs.vlan.active_vlans_rule[vid]) {
 247                         mlx5_del_flow_rules(priv->fs.vlan.active_vlans_rule[vid]);
 248                         priv->fs.vlan.active_vlans_rule[vid] = NULL;
 249                 }
 250                 mlx5e_vport_context_update_vlans(priv);
 251                 break;
 252         }
 253 }
 254
 255 void mlx5e_enable_vlan_filter(struct mlx5e_priv *priv)
 256 {
 257         if (!priv->fs.vlan.filter_disabled)
 258                 return;
 259
 260         priv->fs.vlan.filter_disabled = false;
 261         if (priv->netdev->flags & IFF_PROMISC)
 262                 return;
 263         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
 264 }
 265
 266 void mlx5e_disable_vlan_filter(struct mlx5e_priv *priv)
 267 {
 268         if (priv->fs.vlan.filter_disabled)
 269                 return;
 270
 271         priv->fs.vlan.filter_disabled = true;
 272         if (priv->netdev->flags & IFF_PROMISC)
 273                 return;
 274         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
 275 }
 276
 277 int mlx5e_vlan_rx_add_vid(struct net_device *dev, __always_unused __be16 proto,
 278                           u16 vid)
 279 {
 280         struct mlx5e_priv *priv = netdev_priv(dev);
 281
 282         set_bit(vid, priv->fs.vlan.active_vlans);
 283
 284         return mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, vid);
 285 }
 286
 287 int mlx5e_vlan_rx_kill_vid(struct net_device *dev, __always_unused __be16 proto,
 288                            u16 vid)
 289 {
 290         struct mlx5e_priv *priv = netdev_priv(dev);
 291
 292         clear_bit(vid, priv->fs.vlan.active_vlans);
 293
 294         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, vid);
 295
 296         return 0;
 297 }
 298
 299 static void mlx5e_add_vlan_rules(struct mlx5e_priv *priv)
 300 {
 301         int i;
 302
 303         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_UNTAGGED, 0);
 304
 305         for_each_set_bit(i, priv->fs.vlan.active_vlans, VLAN_N_VID) {
 306                 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, i);
 307         }
 308
 309         if (priv->fs.vlan.filter_disabled &&
 310             !(priv->netdev->flags & IFF_PROMISC))
 311                 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
 312 }
 313
 314 static void mlx5e_del_vlan_rules(struct mlx5e_priv *priv)
 315 {
 316         int i;
 317
 318         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_UNTAGGED, 0);
 319
 320         for_each_set_bit(i, priv->fs.vlan.active_vlans, VLAN_N_VID) {
 321                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, i);
 322         }
 323
 324         if (priv->fs.vlan.filter_disabled &&
 325             !(priv->netdev->flags & IFF_PROMISC))
 326                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
 327 }
 328
 329 #define mlx5e_for_each_hash_node(hn, tmp, hash, i) \
 330         for (i = 0; i < MLX5E_L2_ADDR_HASH_SIZE; i++) \
 331                 hlist_for_each_entry_safe(hn, tmp, &hash[i], hlist)
 332
 333 static void mlx5e_execute_l2_action(struct mlx5e_priv *priv,
 334                                     struct mlx5e_l2_hash_node *hn)
 335 {
 336         switch (hn->action) {
 337         case MLX5E_ACTION_ADD:
 338                 mlx5e_add_l2_flow_rule(priv, &hn->ai, MLX5E_FULLMATCH);
 339                 hn->action = MLX5E_ACTION_NONE;
 340                 break;
 341
 342         case MLX5E_ACTION_DEL:
 343                 mlx5e_del_l2_flow_rule(priv, &hn->ai);
 344                 mlx5e_del_l2_from_hash(hn);
 345                 break;
 346         }
 347 }
 348
 349 static void mlx5e_sync_netdev_addr(struct mlx5e_priv *priv)
 350 {
 351         struct net_device *netdev = priv->netdev;
 352         struct netdev_hw_addr *ha;
 353
 354         netif_addr_lock_bh(netdev);
 355
 356         mlx5e_add_l2_to_hash(priv->fs.l2.netdev_uc,
 357                              priv->netdev->dev_addr);
 358
 359         netdev_for_each_uc_addr(ha, netdev)
 360                 mlx5e_add_l2_to_hash(priv->fs.l2.netdev_uc, ha->addr);
 361
 362         netdev_for_each_mc_addr(ha, netdev)
 363                 mlx5e_add_l2_to_hash(priv->fs.l2.netdev_mc, ha->addr);
 364
 365         netif_addr_unlock_bh(netdev);
 366 }
 367
 368 static void mlx5e_fill_addr_array(struct mlx5e_priv *priv, int list_type,
 369                                   u8 addr_array[][ETH_ALEN], int size)
 370 {
 371         bool is_uc = (list_type == MLX5_NVPRT_LIST_TYPE_UC);
 372         struct net_device *ndev = priv->netdev;
 373         struct mlx5e_l2_hash_node *hn;
 374         struct hlist_head *addr_list;
 375         struct hlist_node *tmp;
 376         int i = 0;
 377         int hi;
 378
 379         addr_list = is_uc ? priv->fs.l2.netdev_uc : priv->fs.l2.netdev_mc;
 380
 381         if (is_uc) /* Make sure our own address is pushed first */
 382                 ether_addr_copy(addr_array[i++], ndev->dev_addr);
 383         else if (priv->fs.l2.broadcast_enabled)
 384                 ether_addr_copy(addr_array[i++], ndev->broadcast);
 385
 386         mlx5e_for_each_hash_node(hn, tmp, addr_list, hi) {
 387                 if (ether_addr_equal(ndev->dev_addr, hn->ai.addr))
 388                         continue;
 389                 if (i >= size)
 390                         break;
 391                 ether_addr_copy(addr_array[i++], hn->ai.addr);
 392         }
 393 }
 394
 395 static void mlx5e_vport_context_update_addr_list(struct mlx5e_priv *priv,
 396                                                  int list_type)
 397 {
 398         bool is_uc = (list_type == MLX5_NVPRT_LIST_TYPE_UC);
 399         struct mlx5e_l2_hash_node *hn;
 400         u8 (*addr_array)[ETH_ALEN] = NULL;
 401         struct hlist_head *addr_list;
 402         struct hlist_node *tmp;
 403         int max_size;
 404         int size;
 405         int err;
 406         int hi;
 407
 408         size = is_uc ? 0 : (priv->fs.l2.broadcast_enabled ? 1 : 0);
 409         max_size = is_uc ?
 410                 1 << MLX5_CAP_GEN(priv->mdev, log_max_current_uc_list) :
 411                 1 << MLX5_CAP_GEN(priv->mdev, log_max_current_mc_list);
 412
 413         addr_list = is_uc ? priv->fs.l2.netdev_uc : priv->fs.l2.netdev_mc;
 414         mlx5e_for_each_hash_node(hn, tmp, addr_list, hi)
 415                 size++;
 416
 417         if (size > max_size) {
 418                 netdev_warn(priv->netdev,
 419                             "netdev %s list size (%d) > (%d) max vport list size, some addresses will be dropped\n",
 420                             is_uc ? "UC" : "MC", size, max_size);
 421                 size = max_size;
 422         }
 423
 424         if (size) {
 425                 addr_array = kcalloc(size, ETH_ALEN, GFP_KERNEL);
 426                 if (!addr_array) {
 427                         err = -ENOMEM;
 428                         goto out;
 429                 }
 430                 mlx5e_fill_addr_array(priv, list_type, addr_array, size);
 431         }
 432
 433         err = mlx5_modify_nic_vport_mac_list(priv->mdev, list_type, addr_array, size);
 434 out:
 435         if (err)
 436                 netdev_err(priv->netdev,
 437                            "Failed to modify vport %s list err(%d)\n",
 438                            is_uc ? "UC" : "MC", err);
 439         kfree(addr_array);
 440 }
 441
 442 static void mlx5e_vport_context_update(struct mlx5e_priv *priv)
 443 {
 444         struct mlx5e_l2_table *ea = &priv->fs.l2;
 445
 446         mlx5e_vport_context_update_addr_list(priv, MLX5_NVPRT_LIST_TYPE_UC);
 447         mlx5e_vport_context_update_addr_list(priv, MLX5_NVPRT_LIST_TYPE_MC);
 448         mlx5_modify_nic_vport_promisc(priv->mdev, 0,
 449                                       ea->allmulti_enabled,
 450                                       ea->promisc_enabled);
 451 }
 452
 453 static void mlx5e_apply_netdev_addr(struct mlx5e_priv *priv)
 454 {
 455         struct mlx5e_l2_hash_node *hn;
 456         struct hlist_node *tmp;
 457         int i;
 458
 459         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_uc, i)
 460                 mlx5e_execute_l2_action(priv, hn);
 461
 462         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_mc, i)
 463                 mlx5e_execute_l2_action(priv, hn);
 464 }
 465
 466 static void mlx5e_handle_netdev_addr(struct mlx5e_priv *priv)
 467 {
 468         struct mlx5e_l2_hash_node *hn;
 469         struct hlist_node *tmp;
 470         int i;
 471
 472         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_uc, i)
 473                 hn->action = MLX5E_ACTION_DEL;
 474         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_mc, i)
 475                 hn->action = MLX5E_ACTION_DEL;
 476
 477         if (!test_bit(MLX5E_STATE_DESTROYING, &priv->state))
 478                 mlx5e_sync_netdev_addr(priv);
 479
 480         mlx5e_apply_netdev_addr(priv);
 481 }
 482
 483 void mlx5e_set_rx_mode_work(struct work_struct *work)
 484 {
 485         struct mlx5e_priv *priv = container_of(work, struct mlx5e_priv,
 486                                                set_rx_mode_work);
 487
 488         struct mlx5e_l2_table *ea = &priv->fs.l2;
 489         struct net_device *ndev = priv->netdev;
 490
 491         bool rx_mode_enable   = !test_bit(MLX5E_STATE_DESTROYING, &priv->state);
 492         bool promisc_enabled   = rx_mode_enable && (ndev->flags & IFF_PROMISC);
 493         bool allmulti_enabled  = rx_mode_enable && (ndev->flags & IFF_ALLMULTI);
 494         bool broadcast_enabled = rx_mode_enable;
 495
 496         bool enable_promisc    = !ea->promisc_enabled   &&  promisc_enabled;
 497         bool disable_promisc   =  ea->promisc_enabled   && !promisc_enabled;
 498         bool enable_allmulti   = !ea->allmulti_enabled  &&  allmulti_enabled;
 499         bool disable_allmulti  =  ea->allmulti_enabled  && !allmulti_enabled;
 500         bool enable_broadcast  = !ea->broadcast_enabled &&  broadcast_enabled;
 501         bool disable_broadcast =  ea->broadcast_enabled && !broadcast_enabled;
 502
 503         if (enable_promisc) {
 504                 mlx5e_add_l2_flow_rule(priv, &ea->promisc, MLX5E_PROMISC);
 505                 if (!priv->fs.vlan.filter_disabled)
 506                         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID,
 507                                             0);
 508         }
 509         if (enable_allmulti)
 510                 mlx5e_add_l2_flow_rule(priv, &ea->allmulti, MLX5E_ALLMULTI);
 511         if (enable_broadcast)
 512                 mlx5e_add_l2_flow_rule(priv, &ea->broadcast, MLX5E_FULLMATCH);
 513
 514         mlx5e_handle_netdev_addr(priv);
 515
 516         if (disable_broadcast)
 517                 mlx5e_del_l2_flow_rule(priv, &ea->broadcast);
 518         if (disable_allmulti)
 519                 mlx5e_del_l2_flow_rule(priv, &ea->allmulti);
 520         if (disable_promisc) {
 521                 if (!priv->fs.vlan.filter_disabled)
 522                         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID,
 523                                             0);
 524                 mlx5e_del_l2_flow_rule(priv, &ea->promisc);
 525         }
 526
 527         ea->promisc_enabled   = promisc_enabled;
 528         ea->allmulti_enabled  = allmulti_enabled;
 529         ea->broadcast_enabled = broadcast_enabled;
 530
 531         mlx5e_vport_context_update(priv);
 532 }
 533
 534 static void mlx5e_destroy_groups(struct mlx5e_flow_table *ft)
 535 {
 536         int i;
 537
 538         for (i = ft->num_groups - 1; i >= 0; i--) {
 539                 if (!IS_ERR_OR_NULL(ft->g[i]))
 540                         mlx5_destroy_flow_group(ft->g[i]);
 541                 ft->g[i] = NULL;
 542         }
 543         ft->num_groups = 0;
 544 }
 545
 546 void mlx5e_init_l2_addr(struct mlx5e_priv *priv)
 547 {
 548         ether_addr_copy(priv->fs.l2.broadcast.addr, priv->netdev->broadcast);
 549 }
 550
 551 void mlx5e_destroy_flow_table(struct mlx5e_flow_table *ft)
 552 {
 553         mlx5e_destroy_groups(ft);
 554         kfree(ft->g);
 555         mlx5_destroy_flow_table(ft->t);
 556         ft->t = NULL;
 557 }
 558
 559 static void mlx5e_cleanup_ttc_rules(struct mlx5e_ttc_table *ttc)
 560 {
 561         int i;
 562
 563         for (i = 0; i < MLX5E_NUM_TT; i++) {
 564                 if (!IS_ERR_OR_NULL(ttc->rules[i])) {
 565                         mlx5_del_flow_rules(ttc->rules[i]);
 566                         ttc->rules[i] = NULL;
 567                 }
 568         }
 569 }
 570
 571 static struct {
 572         u16 etype;
 573         u8 proto;
 574 } ttc_rules[] = {
 575         [MLX5E_TT_IPV4_TCP] = {
 576                 .etype = ETH_P_IP,
 577                 .proto = IPPROTO_TCP,
 578         },
 579         [MLX5E_TT_IPV6_TCP] = {
 580                 .etype = ETH_P_IPV6,
 581                 .proto = IPPROTO_TCP,
 582         },
 583         [MLX5E_TT_IPV4_UDP] = {
 584                 .etype = ETH_P_IP,
 585                 .proto = IPPROTO_UDP,
 586         },
 587         [MLX5E_TT_IPV6_UDP] = {
 588                 .etype = ETH_P_IPV6,
 589                 .proto = IPPROTO_UDP,
 590         },
 591         [MLX5E_TT_IPV4_IPSEC_AH] = {
 592                 .etype = ETH_P_IP,
 593                 .proto = IPPROTO_AH,
 594         },
 595         [MLX5E_TT_IPV6_IPSEC_AH] = {
 596                 .etype = ETH_P_IPV6,
 597                 .proto = IPPROTO_AH,
 598         },
 599         [MLX5E_TT_IPV4_IPSEC_ESP] = {
 600                 .etype = ETH_P_IP,
 601                 .proto = IPPROTO_ESP,
 602         },
 603         [MLX5E_TT_IPV6_IPSEC_ESP] = {
 604                 .etype = ETH_P_IPV6,
 605                 .proto = IPPROTO_ESP,
 606         },
 607         [MLX5E_TT_IPV4] = {
 608                 .etype = ETH_P_IP,
 609                 .proto = 0,
 610         },
 611         [MLX5E_TT_IPV6] = {
 612                 .etype = ETH_P_IPV6,
 613                 .proto = 0,
 614         },
 615         [MLX5E_TT_ANY] = {
 616                 .etype = 0,
 617                 .proto = 0,
 618         },
 619 };
 620
 621 static struct mlx5_flow_handle *
 622 mlx5e_generate_ttc_rule(struct mlx5e_priv *priv,
 623                         struct mlx5_flow_table *ft,
 624                         struct mlx5_flow_destination *dest,
 625                         u16 etype,
 626                         u8 proto)
 627 {
 628         struct mlx5_flow_act flow_act = {
 629                 .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
 630                 .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG,
 631                 .encap_id = 0,
 632         };
 633         struct mlx5_flow_handle *rule;
 634         struct mlx5_flow_spec *spec;
 635         int err = 0;
 636
 637         spec = mlx5_vzalloc(sizeof(*spec));
 638         if (!spec) {
 639                 netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
 640                 return ERR_PTR(-ENOMEM);
 641         }
 642
 643         if (proto) {
 644                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 645                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ip_protocol);
 646                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ip_protocol, proto);
 647         }
 648         if (etype) {
 649                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 650                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ethertype);
 651                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ethertype, etype);
 652         }
 653
 654         rule = mlx5_add_flow_rules(ft, spec, &flow_act, dest, 1);
 655         if (IS_ERR(rule)) {
 656                 err = PTR_ERR(rule);
 657                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
 658         }
 659
 660         kvfree(spec);
 661         return err ? ERR_PTR(err) : rule;
 662 }
 663
 664 static int mlx5e_generate_ttc_table_rules(struct mlx5e_priv *priv)
 665 {
 666         struct mlx5_flow_destination dest;
 667         struct mlx5e_ttc_table *ttc;
 668         struct mlx5_flow_handle **rules;
 669         struct mlx5_flow_table *ft;
 670         int tt;
 671         int err;
 672
 673         ttc = &priv->fs.ttc;
 674         ft = ttc->ft.t;
 675         rules = ttc->rules;
 676
 677         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 678         for (tt = 0; tt < MLX5E_NUM_TT; tt++) {
 679                 if (tt == MLX5E_TT_ANY)
 680                         dest.tir_num = priv->direct_tir[0].tirn;
 681                 else
 682                         dest.tir_num = priv->indir_tir[tt].tirn;
 683                 rules[tt] = mlx5e_generate_ttc_rule(priv, ft, &dest,
 684                                                     ttc_rules[tt].etype,
 685                                                     ttc_rules[tt].proto);
 686                 if (IS_ERR(rules[tt]))
 687                         goto del_rules;
 688         }
 689
 690         return 0;
 691
 692 del_rules:
 693         err = PTR_ERR(rules[tt]);
 694         rules[tt] = NULL;
 695         mlx5e_cleanup_ttc_rules(ttc);
 696         return err;
 697 }
 698
 699 #define MLX5E_TTC_NUM_GROUPS    3
 700 #define MLX5E_TTC_GROUP1_SIZE   BIT(3)
 701 #define MLX5E_TTC_GROUP2_SIZE   BIT(1)
 702 #define MLX5E_TTC_GROUP3_SIZE   BIT(0)
 703 #define MLX5E_TTC_TABLE_SIZE    (MLX5E_TTC_GROUP1_SIZE +\
 704                                  MLX5E_TTC_GROUP2_SIZE +\
 705                                  MLX5E_TTC_GROUP3_SIZE)
 706 static int mlx5e_create_ttc_table_groups(struct mlx5e_ttc_table *ttc)
 707 {
 708         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 709         struct mlx5e_flow_table *ft = &ttc->ft;
 710         int ix = 0;
 711         u32 *in;
 712         int err;
 713         u8 *mc;
 714
 715         ft->g = kcalloc(MLX5E_TTC_NUM_GROUPS,
 716                         sizeof(*ft->g), GFP_KERNEL);
 717         if (!ft->g)
 718                 return -ENOMEM;
 719         in = mlx5_vzalloc(inlen);
 720         if (!in) {
 721                 kfree(ft->g);
 722                 return -ENOMEM;
 723         }
 724
 725         /* L4 Group */
 726         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
 727         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ip_protocol);
 728         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ethertype);
 729         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
 730         MLX5_SET_CFG(in, start_flow_index, ix);
 731         ix += MLX5E_TTC_GROUP1_SIZE;
 732         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 733         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 734         if (IS_ERR(ft->g[ft->num_groups]))
 735                 goto err;
 736         ft->num_groups++;
 737
 738         /* L3 Group */
 739         MLX5_SET(fte_match_param, mc, outer_headers.ip_protocol, 0);
 740         MLX5_SET_CFG(in, start_flow_index, ix);
 741         ix += MLX5E_TTC_GROUP2_SIZE;
 742         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 743         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 744         if (IS_ERR(ft->g[ft->num_groups]))
 745                 goto err;
 746         ft->num_groups++;
 747
 748         /* Any Group */
 749         memset(in, 0, inlen);
 750         MLX5_SET_CFG(in, start_flow_index, ix);
 751         ix += MLX5E_TTC_GROUP3_SIZE;
 752         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 753         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 754         if (IS_ERR(ft->g[ft->num_groups]))
 755                 goto err;
 756         ft->num_groups++;
 757
 758         kvfree(in);
 759         return 0;
 760
 761 err:
 762         err = PTR_ERR(ft->g[ft->num_groups]);
 763         ft->g[ft->num_groups] = NULL;
 764         kvfree(in);
 765
 766         return err;
 767 }
 768
 769 static void mlx5e_destroy_ttc_table(struct mlx5e_priv *priv)
 770 {
 771         struct mlx5e_ttc_table *ttc = &priv->fs.ttc;
 772
 773         mlx5e_cleanup_ttc_rules(ttc);
 774         mlx5e_destroy_flow_table(&ttc->ft);
 775 }
 776
 777 static int mlx5e_create_ttc_table(struct mlx5e_priv *priv)
 778 {
 779         struct mlx5e_ttc_table *ttc = &priv->fs.ttc;
 780         struct mlx5e_flow_table *ft = &ttc->ft;
 781         int err;
 782
 783         ft->t = mlx5_create_flow_table(priv->fs.ns, MLX5E_NIC_PRIO,
 784                                        MLX5E_TTC_TABLE_SIZE, MLX5E_TTC_FT_LEVEL, 0);
 785         if (IS_ERR(ft->t)) {
 786                 err = PTR_ERR(ft->t);
 787                 ft->t = NULL;
 788                 return err;
 789         }
 790
 791         err = mlx5e_create_ttc_table_groups(ttc);
 792         if (err)
 793                 goto err;
 794
 795         err = mlx5e_generate_ttc_table_rules(priv);
 796         if (err)
 797                 goto err;
 798
 799         return 0;
 800 err:
 801         mlx5e_destroy_flow_table(ft);
 802         return err;
 803 }
 804
 805 static void mlx5e_del_l2_flow_rule(struct mlx5e_priv *priv,
 806                                    struct mlx5e_l2_rule *ai)
 807 {
 808         if (!IS_ERR_OR_NULL(ai->rule)) {
 809                 mlx5_del_flow_rules(ai->rule);
 810                 ai->rule = NULL;
 811         }
 812 }
 813
 814 static int mlx5e_add_l2_flow_rule(struct mlx5e_priv *priv,
 815                                   struct mlx5e_l2_rule *ai, int type)
 816 {
 817         struct mlx5_flow_act flow_act = {
 818                 .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
 819                 .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG,
 820                 .encap_id = 0,
 821         };
 822         struct mlx5_flow_table *ft = priv->fs.l2.ft.t;
 823         struct mlx5_flow_destination dest;
 824         struct mlx5_flow_spec *spec;
 825         int err = 0;
 826         u8 *mc_dmac;
 827         u8 *mv_dmac;
 828
 829         spec = mlx5_vzalloc(sizeof(*spec));
 830         if (!spec) {
 831                 netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
 832                 return -ENOMEM;
 833         }
 834
 835         mc_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 836                                outer_headers.dmac_47_16);
 837         mv_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_value,
 838                                outer_headers.dmac_47_16);
 839
 840         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 841         dest.ft = priv->fs.ttc.ft.t;
 842
 843         switch (type) {
 844         case MLX5E_FULLMATCH:
 845                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 846                 eth_broadcast_addr(mc_dmac);
 847                 ether_addr_copy(mv_dmac, ai->addr);
 848                 break;
 849
 850         case MLX5E_ALLMULTI:
 851                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 852                 mc_dmac[0] = 0x01;
 853                 mv_dmac[0] = 0x01;
 854                 break;
 855
 856         case MLX5E_PROMISC:
 857                 break;
 858         }
 859
 860         ai->rule = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
 861         if (IS_ERR(ai->rule)) {
 862                 netdev_err(priv->netdev, "%s: add l2 rule(mac:%pM) failed\n",
 863                            __func__, mv_dmac);
 864                 err = PTR_ERR(ai->rule);
 865                 ai->rule = NULL;
 866         }
 867
 868         kvfree(spec);
 869
 870         return err;
 871 }
 872
 873 #define MLX5E_NUM_L2_GROUPS        3
 874 #define MLX5E_L2_GROUP1_SIZE       BIT(0)
 875 #define MLX5E_L2_GROUP2_SIZE       BIT(15)
 876 #define MLX5E_L2_GROUP3_SIZE       BIT(0)
 877 #define MLX5E_L2_TABLE_SIZE        (MLX5E_L2_GROUP1_SIZE +\
 878                                     MLX5E_L2_GROUP2_SIZE +\
 879                                     MLX5E_L2_GROUP3_SIZE)
 880 static int mlx5e_create_l2_table_groups(struct mlx5e_l2_table *l2_table)
 881 {
 882         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 883         struct mlx5e_flow_table *ft = &l2_table->ft;
 884         int ix = 0;
 885         u8 *mc_dmac;
 886         u32 *in;
 887         int err;
 888         u8 *mc;
 889
 890         ft->g = kcalloc(MLX5E_NUM_L2_GROUPS, sizeof(*ft->g), GFP_KERNEL);
 891         if (!ft->g)
 892                 return -ENOMEM;
 893         in = mlx5_vzalloc(inlen);
 894         if (!in) {
 895                 kfree(ft->g);
 896                 return -ENOMEM;
 897         }
 898
 899         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
 900         mc_dmac = MLX5_ADDR_OF(fte_match_param, mc,
 901                                outer_headers.dmac_47_16);
 902         /* Flow Group for promiscuous */
 903         MLX5_SET_CFG(in, start_flow_index, ix);
 904         ix += MLX5E_L2_GROUP1_SIZE;
 905         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 906         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 907         if (IS_ERR(ft->g[ft->num_groups]))
 908                 goto err_destroy_groups;
 909         ft->num_groups++;
 910
 911         /* Flow Group for full match */
 912         eth_broadcast_addr(mc_dmac);
 913         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
 914         MLX5_SET_CFG(in, start_flow_index, ix);
 915         ix += MLX5E_L2_GROUP2_SIZE;
 916         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 917         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 918         if (IS_ERR(ft->g[ft->num_groups]))
 919                 goto err_destroy_groups;
 920         ft->num_groups++;
 921
 922         /* Flow Group for allmulti */
 923         eth_zero_addr(mc_dmac);
 924         mc_dmac[0] = 0x01;
 925         MLX5_SET_CFG(in, start_flow_index, ix);
 926         ix += MLX5E_L2_GROUP3_SIZE;
 927         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 928         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 929         if (IS_ERR(ft->g[ft->num_groups]))
 930                 goto err_destroy_groups;
 931         ft->num_groups++;
 932
 933         kvfree(in);
 934         return 0;
 935
 936 err_destroy_groups:
 937         err = PTR_ERR(ft->g[ft->num_groups]);
 938         ft->g[ft->num_groups] = NULL;
 939         mlx5e_destroy_groups(ft);
 940         kvfree(in);
 941
 942         return err;
 943 }
 944
 945 static void mlx5e_destroy_l2_table(struct mlx5e_priv *priv)
 946 {
 947         mlx5e_destroy_flow_table(&priv->fs.l2.ft);
 948 }
 949
 950 static int mlx5e_create_l2_table(struct mlx5e_priv *priv)
 951 {
 952         struct mlx5e_l2_table *l2_table = &priv->fs.l2;
 953         struct mlx5e_flow_table *ft = &l2_table->ft;
 954         int err;
 955
 956         ft->num_groups = 0;
 957         ft->t = mlx5_create_flow_table(priv->fs.ns, MLX5E_NIC_PRIO,
 958                                        MLX5E_L2_TABLE_SIZE, MLX5E_L2_FT_LEVEL, 0);
 959
 960         if (IS_ERR(ft->t)) {
 961                 err = PTR_ERR(ft->t);
 962                 ft->t = NULL;
 963                 return err;
 964         }
 965
 966         err = mlx5e_create_l2_table_groups(l2_table);
 967         if (err)
 968                 goto err_destroy_flow_table;
 969
 970         return 0;
 971
 972 err_destroy_flow_table:
 973         mlx5_destroy_flow_table(ft->t);
 974         ft->t = NULL;
 975
 976         return err;
 977 }
 978
 979 #define MLX5E_NUM_VLAN_GROUPS   2
 980 #define MLX5E_VLAN_GROUP0_SIZE  BIT(12)
 981 #define MLX5E_VLAN_GROUP1_SIZE  BIT(1)
 982 #define MLX5E_VLAN_TABLE_SIZE   (MLX5E_VLAN_GROUP0_SIZE +\
 983                                  MLX5E_VLAN_GROUP1_SIZE)
 984
 985 static int __mlx5e_create_vlan_table_groups(struct mlx5e_flow_table *ft, u32 *in,
 986                                             int inlen)
 987 {
 988         int err;
 989         int ix = 0;
 990         u8 *mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
 991
 992         memset(in, 0, inlen);
 993         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
 994         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.vlan_tag);
 995         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.first_vid);
 996         MLX5_SET_CFG(in, start_flow_index, ix);
 997         ix += MLX5E_VLAN_GROUP0_SIZE;
 998         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 999         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1000         if (IS_ERR(ft->g[ft->num_groups]))
1001                 goto err_destroy_groups;
1002         ft->num_groups++;
1003
1004         memset(in, 0, inlen);
1005         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1006         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.vlan_tag);
1007         MLX5_SET_CFG(in, start_flow_index, ix);
1008         ix += MLX5E_VLAN_GROUP1_SIZE;
1009         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1010         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1011         if (IS_ERR(ft->g[ft->num_groups]))
1012                 goto err_destroy_groups;
1013         ft->num_groups++;
1014
1015         return 0;
1016
1017 err_destroy_groups:
1018         err = PTR_ERR(ft->g[ft->num_groups]);
1019         ft->g[ft->num_groups] = NULL;
1020         mlx5e_destroy_groups(ft);
1021
1022         return err;
1023 }
1024
1025 static int mlx5e_create_vlan_table_groups(struct mlx5e_flow_table *ft)
1026 {
1027         u32 *in;
1028         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
1029         int err;
1030
1031         in = mlx5_vzalloc(inlen);
1032         if (!in)
1033                 return -ENOMEM;
1034
1035         err = __mlx5e_create_vlan_table_groups(ft, in, inlen);
1036
1037         kvfree(in);
1038         return err;
1039 }
1040
1041 static int mlx5e_create_vlan_table(struct mlx5e_priv *priv)
1042 {
1043         struct mlx5e_flow_table *ft = &priv->fs.vlan.ft;
1044         int err;
1045
1046         ft->num_groups = 0;
1047         ft->t = mlx5_create_flow_table(priv->fs.ns, MLX5E_NIC_PRIO,
1048                                        MLX5E_VLAN_TABLE_SIZE, MLX5E_VLAN_FT_LEVEL, 0);
1049
1050         if (IS_ERR(ft->t)) {
1051                 err = PTR_ERR(ft->t);
1052                 ft->t = NULL;
1053                 return err;
1054         }
1055         ft->g = kcalloc(MLX5E_NUM_VLAN_GROUPS, sizeof(*ft->g), GFP_KERNEL);
1056         if (!ft->g) {
1057                 err = -ENOMEM;
1058                 goto err_destroy_vlan_table;
1059         }
1060
1061         err = mlx5e_create_vlan_table_groups(ft);
1062         if (err)
1063                 goto err_free_g;
1064
1065         mlx5e_add_vlan_rules(priv);
1066
1067         return 0;
1068
1069 err_free_g:
1070         kfree(ft->g);
1071 err_destroy_vlan_table:
1072         mlx5_destroy_flow_table(ft->t);
1073         ft->t = NULL;
1074
1075         return err;
1076 }
1077
1078 static void mlx5e_destroy_vlan_table(struct mlx5e_priv *priv)
1079 {
1080         mlx5e_del_vlan_rules(priv);
1081         mlx5e_destroy_flow_table(&priv->fs.vlan.ft);
1082 }
1083
1084 int mlx5e_create_flow_steering(struct mlx5e_priv *priv)
1085 {
1086         int err;
1087
1088         priv->fs.ns = mlx5_get_flow_namespace(priv->mdev,
1089                                                MLX5_FLOW_NAMESPACE_KERNEL);
1090
1091         if (!priv->fs.ns)
1092                 return -EINVAL;
1093
1094         err = mlx5e_arfs_create_tables(priv);
1095         if (err) {
1096                 netdev_err(priv->netdev, "Failed to create arfs tables, err=%d\n",
1097                            err);
1098                 priv->netdev->hw_features &= ~NETIF_F_NTUPLE;
1099         }
1100
1101         err = mlx5e_create_ttc_table(priv);
1102         if (err) {
1103                 netdev_err(priv->netdev, "Failed to create ttc table, err=%d\n",
1104                            err);
1105                 goto err_destroy_arfs_tables;
1106         }
1107
1108         err = mlx5e_create_l2_table(priv);
1109         if (err) {
1110                 netdev_err(priv->netdev, "Failed to create l2 table, err=%d\n",
1111                            err);
1112                 goto err_destroy_ttc_table;
1113         }
1114
1115         err = mlx5e_create_vlan_table(priv);
1116         if (err) {
1117                 netdev_err(priv->netdev, "Failed to create vlan table, err=%d\n",
1118                            err);
1119                 goto err_destroy_l2_table;
1120         }
1121
1122         mlx5e_ethtool_init_steering(priv);
1123
1124         return 0;
1125
1126 err_destroy_l2_table:
1127         mlx5e_destroy_l2_table(priv);
1128 err_destroy_ttc_table:
1129         mlx5e_destroy_ttc_table(priv);
1130 err_destroy_arfs_tables:
1131         mlx5e_arfs_destroy_tables(priv);
1132
1133         return err;
1134 }
1135
1136 void mlx5e_destroy_flow_steering(struct mlx5e_priv *priv)
1137 {
1138         mlx5e_destroy_vlan_table(priv);
1139         mlx5e_destroy_l2_table(priv);
1140         mlx5e_destroy_ttc_table(priv);
1141         mlx5e_arfs_destroy_tables(priv);
1142         mlx5e_ethtool_cleanup_steering(priv);
1143 }