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