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 #include "lib/mpfs.h"
  40
  41 static int mlx5e_add_l2_flow_rule(struct mlx5e_priv *priv,
  42                                   struct mlx5e_l2_rule *ai, int type);
  43 static void mlx5e_del_l2_flow_rule(struct mlx5e_priv *priv,
  44                                    struct mlx5e_l2_rule *ai);
  45
  46 enum {
  47         MLX5E_FULLMATCH = 0,
  48         MLX5E_ALLMULTI  = 1,
  49         MLX5E_PROMISC   = 2,
  50 };
  51
  52 enum {
  53         MLX5E_UC        = 0,
  54         MLX5E_MC_IPV4   = 1,
  55         MLX5E_MC_IPV6   = 2,
  56         MLX5E_MC_OTHER  = 3,
  57 };
  58
  59 enum {
  60         MLX5E_ACTION_NONE = 0,
  61         MLX5E_ACTION_ADD  = 1,
  62         MLX5E_ACTION_DEL  = 2,
  63 };
  64
  65 struct mlx5e_l2_hash_node {
  66         struct hlist_node          hlist;
  67         u8                         action;
  68         struct mlx5e_l2_rule ai;
  69         bool   mpfs;
  70 };
  71
  72 static inline int mlx5e_hash_l2(u8 *addr)
  73 {
  74         return addr[5];
  75 }
  76
  77 static void mlx5e_add_l2_to_hash(struct hlist_head *hash, u8 *addr)
  78 {
  79         struct mlx5e_l2_hash_node *hn;
  80         int ix = mlx5e_hash_l2(addr);
  81         int found = 0;
  82
  83         hlist_for_each_entry(hn, &hash[ix], hlist)
  84                 if (ether_addr_equal_64bits(hn->ai.addr, addr)) {
  85                         found = 1;
  86                         break;
  87                 }
  88
  89         if (found) {
  90                 hn->action = MLX5E_ACTION_NONE;
  91                 return;
  92         }
  93
  94         hn = kzalloc(sizeof(*hn), GFP_ATOMIC);
  95         if (!hn)
  96                 return;
  97
  98         ether_addr_copy(hn->ai.addr, addr);
  99         hn->action = MLX5E_ACTION_ADD;
 100
 101         hlist_add_head(&hn->hlist, &hash[ix]);
 102 }
 103
 104 static void mlx5e_del_l2_from_hash(struct mlx5e_l2_hash_node *hn)
 105 {
 106         hlist_del(&hn->hlist);
 107         kfree(hn);
 108 }
 109
 110 static int mlx5e_vport_context_update_vlans(struct mlx5e_priv *priv)
 111 {
 112         struct net_device *ndev = priv->netdev;
 113         int max_list_size;
 114         int list_size;
 115         u16 *vlans;
 116         int vlan;
 117         int err;
 118         int i;
 119
 120         list_size = 0;
 121         for_each_set_bit(vlan, priv->fs.vlan.active_cvlans, VLAN_N_VID)
 122                 list_size++;
 123
 124         max_list_size = 1 << MLX5_CAP_GEN(priv->mdev, log_max_vlan_list);
 125
 126         if (list_size > max_list_size) {
 127                 netdev_warn(ndev,
 128                             "netdev vlans list size (%d) > (%d) max vport list size, some vlans will be dropped\n",
 129                             list_size, max_list_size);
 130                 list_size = max_list_size;
 131         }
 132
 133         vlans = kcalloc(list_size, sizeof(*vlans), GFP_KERNEL);
 134         if (!vlans)
 135                 return -ENOMEM;
 136
 137         i = 0;
 138         for_each_set_bit(vlan, priv->fs.vlan.active_cvlans, VLAN_N_VID) {
 139                 if (i >= list_size)
 140                         break;
 141                 vlans[i++] = vlan;
 142         }
 143
 144         err = mlx5_modify_nic_vport_vlans(priv->mdev, vlans, list_size);
 145         if (err)
 146                 netdev_err(ndev, "Failed to modify vport vlans list err(%d)\n",
 147                            err);
 148
 149         kfree(vlans);
 150         return err;
 151 }
 152
 153 enum mlx5e_vlan_rule_type {
 154         MLX5E_VLAN_RULE_TYPE_UNTAGGED,
 155         MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID,
 156         MLX5E_VLAN_RULE_TYPE_ANY_STAG_VID,
 157         MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID,
 158         MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID,
 159 };
 160
 161 static int __mlx5e_add_vlan_rule(struct mlx5e_priv *priv,
 162                                  enum mlx5e_vlan_rule_type rule_type,
 163                                  u16 vid, struct mlx5_flow_spec *spec)
 164 {
 165         struct mlx5_flow_table *ft = priv->fs.vlan.ft.t;
 166         struct mlx5_flow_destination dest = {};
 167         struct mlx5_flow_handle **rule_p;
 168         MLX5_DECLARE_FLOW_ACT(flow_act);
 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
 176         switch (rule_type) {
 177         case MLX5E_VLAN_RULE_TYPE_UNTAGGED:
 178                 /* cvlan_tag enabled in match criteria and
 179                  * disabled in match value means both S & C tags
 180                  * don't exist (untagged of both)
 181                  */
 182                 rule_p = &priv->fs.vlan.untagged_rule;
 183                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 184                                  outer_headers.cvlan_tag);
 185                 break;
 186         case MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID:
 187                 rule_p = &priv->fs.vlan.any_cvlan_rule;
 188                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 189                                  outer_headers.cvlan_tag);
 190                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.cvlan_tag, 1);
 191                 break;
 192         case MLX5E_VLAN_RULE_TYPE_ANY_STAG_VID:
 193                 rule_p = &priv->fs.vlan.any_svlan_rule;
 194                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 195                                  outer_headers.svlan_tag);
 196                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.svlan_tag, 1);
 197                 break;
 198         case MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID:
 199                 rule_p = &priv->fs.vlan.active_svlans_rule[vid];
 200                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 201                                  outer_headers.svlan_tag);
 202                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.svlan_tag, 1);
 203                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 204                                  outer_headers.first_vid);
 205                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.first_vid,
 206                          vid);
 207                 break;
 208         default: /* MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID */
 209                 rule_p = &priv->fs.vlan.active_cvlans_rule[vid];
 210                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 211                                  outer_headers.cvlan_tag);
 212                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.cvlan_tag, 1);
 213                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 214                                  outer_headers.first_vid);
 215                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.first_vid,
 216                          vid);
 217                 break;
 218         }
 219
 220         *rule_p = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
 221
 222         if (IS_ERR(*rule_p)) {
 223                 err = PTR_ERR(*rule_p);
 224                 *rule_p = NULL;
 225                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
 226         }
 227
 228         return err;
 229 }
 230
 231 static int mlx5e_add_vlan_rule(struct mlx5e_priv *priv,
 232                                enum mlx5e_vlan_rule_type rule_type, u16 vid)
 233 {
 234         struct mlx5_flow_spec *spec;
 235         int err = 0;
 236
 237         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
 238         if (!spec)
 239                 return -ENOMEM;
 240
 241         if (rule_type == MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID)
 242                 mlx5e_vport_context_update_vlans(priv);
 243
 244         err = __mlx5e_add_vlan_rule(priv, rule_type, vid, spec);
 245
 246         kvfree(spec);
 247
 248         return err;
 249 }
 250
 251 static void mlx5e_del_vlan_rule(struct mlx5e_priv *priv,
 252                                 enum mlx5e_vlan_rule_type rule_type, u16 vid)
 253 {
 254         switch (rule_type) {
 255         case MLX5E_VLAN_RULE_TYPE_UNTAGGED:
 256                 if (priv->fs.vlan.untagged_rule) {
 257                         mlx5_del_flow_rules(priv->fs.vlan.untagged_rule);
 258                         priv->fs.vlan.untagged_rule = NULL;
 259                 }
 260                 break;
 261         case MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID:
 262                 if (priv->fs.vlan.any_cvlan_rule) {
 263                         mlx5_del_flow_rules(priv->fs.vlan.any_cvlan_rule);
 264                         priv->fs.vlan.any_cvlan_rule = NULL;
 265                 }
 266                 break;
 267         case MLX5E_VLAN_RULE_TYPE_ANY_STAG_VID:
 268                 if (priv->fs.vlan.any_svlan_rule) {
 269                         mlx5_del_flow_rules(priv->fs.vlan.any_svlan_rule);
 270                         priv->fs.vlan.any_svlan_rule = NULL;
 271                 }
 272                 break;
 273         case MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID:
 274                 if (priv->fs.vlan.active_svlans_rule[vid]) {
 275                         mlx5_del_flow_rules(priv->fs.vlan.active_svlans_rule[vid]);
 276                         priv->fs.vlan.active_svlans_rule[vid] = NULL;
 277                 }
 278                 break;
 279         case MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID:
 280                 mlx5e_vport_context_update_vlans(priv);
 281                 if (priv->fs.vlan.active_cvlans_rule[vid]) {
 282                         mlx5_del_flow_rules(priv->fs.vlan.active_cvlans_rule[vid]);
 283                         priv->fs.vlan.active_cvlans_rule[vid] = NULL;
 284                 }
 285                 mlx5e_vport_context_update_vlans(priv);
 286                 break;
 287         }
 288 }
 289
 290 static void mlx5e_del_any_vid_rules(struct mlx5e_priv *priv)
 291 {
 292         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID, 0);
 293         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_STAG_VID, 0);
 294 }
 295
 296 static int mlx5e_add_any_vid_rules(struct mlx5e_priv *priv)
 297 {
 298         int err;
 299
 300         err = mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID, 0);
 301         if (err)
 302                 return err;
 303
 304         return mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_STAG_VID, 0);
 305 }
 306
 307 void mlx5e_enable_cvlan_filter(struct mlx5e_priv *priv)
 308 {
 309         if (!priv->fs.vlan.cvlan_filter_disabled)
 310                 return;
 311
 312         priv->fs.vlan.cvlan_filter_disabled = false;
 313         if (priv->netdev->flags & IFF_PROMISC)
 314                 return;
 315         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID, 0);
 316 }
 317
 318 void mlx5e_disable_cvlan_filter(struct mlx5e_priv *priv)
 319 {
 320         if (priv->fs.vlan.cvlan_filter_disabled)
 321                 return;
 322
 323         priv->fs.vlan.cvlan_filter_disabled = true;
 324         if (priv->netdev->flags & IFF_PROMISC)
 325                 return;
 326         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_CTAG_VID, 0);
 327 }
 328
 329 static int mlx5e_vlan_rx_add_cvid(struct mlx5e_priv *priv, u16 vid)
 330 {
 331         int err;
 332
 333         set_bit(vid, priv->fs.vlan.active_cvlans);
 334
 335         err = mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID, vid);
 336         if (err)
 337                 clear_bit(vid, priv->fs.vlan.active_cvlans);
 338
 339         return err;
 340 }
 341
 342 static int mlx5e_vlan_rx_add_svid(struct mlx5e_priv *priv, u16 vid)
 343 {
 344         struct net_device *netdev = priv->netdev;
 345         int err;
 346
 347         set_bit(vid, priv->fs.vlan.active_svlans);
 348
 349         err = mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID, vid);
 350         if (err) {
 351                 clear_bit(vid, priv->fs.vlan.active_svlans);
 352                 return err;
 353         }
 354
 355         /* Need to fix some features.. */
 356         netdev_update_features(netdev);
 357         return err;
 358 }
 359
 360 int mlx5e_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
 361 {
 362         struct mlx5e_priv *priv = netdev_priv(dev);
 363
 364         if (be16_to_cpu(proto) == ETH_P_8021Q)
 365                 return mlx5e_vlan_rx_add_cvid(priv, vid);
 366         else if (be16_to_cpu(proto) == ETH_P_8021AD)
 367                 return mlx5e_vlan_rx_add_svid(priv, vid);
 368
 369         return -EOPNOTSUPP;
 370 }
 371
 372 int mlx5e_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid)
 373 {
 374         struct mlx5e_priv *priv = netdev_priv(dev);
 375
 376         if (be16_to_cpu(proto) == ETH_P_8021Q) {
 377                 clear_bit(vid, priv->fs.vlan.active_cvlans);
 378                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID, vid);
 379         } else if (be16_to_cpu(proto) == ETH_P_8021AD) {
 380                 clear_bit(vid, priv->fs.vlan.active_svlans);
 381                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID, vid);
 382                 netdev_update_features(dev);
 383         }
 384
 385         return 0;
 386 }
 387
 388 static void mlx5e_add_vlan_rules(struct mlx5e_priv *priv)
 389 {
 390         int i;
 391
 392         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_UNTAGGED, 0);
 393
 394         for_each_set_bit(i, priv->fs.vlan.active_cvlans, VLAN_N_VID) {
 395                 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID, i);
 396         }
 397
 398         for_each_set_bit(i, priv->fs.vlan.active_svlans, VLAN_N_VID)
 399                 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID, i);
 400
 401         if (priv->fs.vlan.cvlan_filter_disabled &&
 402             !(priv->netdev->flags & IFF_PROMISC))
 403                 mlx5e_add_any_vid_rules(priv);
 404 }
 405
 406 static void mlx5e_del_vlan_rules(struct mlx5e_priv *priv)
 407 {
 408         int i;
 409
 410         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_UNTAGGED, 0);
 411
 412         for_each_set_bit(i, priv->fs.vlan.active_cvlans, VLAN_N_VID) {
 413                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_CTAG_VID, i);
 414         }
 415
 416         for_each_set_bit(i, priv->fs.vlan.active_svlans, VLAN_N_VID)
 417                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID, i);
 418
 419         if (priv->fs.vlan.cvlan_filter_disabled &&
 420             !(priv->netdev->flags & IFF_PROMISC))
 421                 mlx5e_del_any_vid_rules(priv);
 422 }
 423
 424 #define mlx5e_for_each_hash_node(hn, tmp, hash, i) \
 425         for (i = 0; i < MLX5E_L2_ADDR_HASH_SIZE; i++) \
 426                 hlist_for_each_entry_safe(hn, tmp, &hash[i], hlist)
 427
 428 static void mlx5e_execute_l2_action(struct mlx5e_priv *priv,
 429                                     struct mlx5e_l2_hash_node *hn)
 430 {
 431         u8 action = hn->action;
 432         u8 mac_addr[ETH_ALEN];
 433         int l2_err = 0;
 434
 435         ether_addr_copy(mac_addr, hn->ai.addr);
 436
 437         switch (action) {
 438         case MLX5E_ACTION_ADD:
 439                 mlx5e_add_l2_flow_rule(priv, &hn->ai, MLX5E_FULLMATCH);
 440                 if (!is_multicast_ether_addr(mac_addr)) {
 441                         l2_err = mlx5_mpfs_add_mac(priv->mdev, mac_addr);
 442                         hn->mpfs = !l2_err;
 443                 }
 444                 hn->action = MLX5E_ACTION_NONE;
 445                 break;
 446
 447         case MLX5E_ACTION_DEL:
 448                 if (!is_multicast_ether_addr(mac_addr) && hn->mpfs)
 449                         l2_err = mlx5_mpfs_del_mac(priv->mdev, mac_addr);
 450                 mlx5e_del_l2_flow_rule(priv, &hn->ai);
 451                 mlx5e_del_l2_from_hash(hn);
 452                 break;
 453         }
 454
 455         if (l2_err)
 456                 netdev_warn(priv->netdev, "MPFS, failed to %s mac %pM, err(%d)\n",
 457                             action == MLX5E_ACTION_ADD ? "add" : "del", mac_addr, l2_err);
 458 }
 459
 460 static void mlx5e_sync_netdev_addr(struct mlx5e_priv *priv)
 461 {
 462         struct net_device *netdev = priv->netdev;
 463         struct netdev_hw_addr *ha;
 464
 465         netif_addr_lock_bh(netdev);
 466
 467         mlx5e_add_l2_to_hash(priv->fs.l2.netdev_uc,
 468                              priv->netdev->dev_addr);
 469
 470         netdev_for_each_uc_addr(ha, netdev)
 471                 mlx5e_add_l2_to_hash(priv->fs.l2.netdev_uc, ha->addr);
 472
 473         netdev_for_each_mc_addr(ha, netdev)
 474                 mlx5e_add_l2_to_hash(priv->fs.l2.netdev_mc, ha->addr);
 475
 476         netif_addr_unlock_bh(netdev);
 477 }
 478
 479 static void mlx5e_fill_addr_array(struct mlx5e_priv *priv, int list_type,
 480                                   u8 addr_array[][ETH_ALEN], int size)
 481 {
 482         bool is_uc = (list_type == MLX5_NVPRT_LIST_TYPE_UC);
 483         struct net_device *ndev = priv->netdev;
 484         struct mlx5e_l2_hash_node *hn;
 485         struct hlist_head *addr_list;
 486         struct hlist_node *tmp;
 487         int i = 0;
 488         int hi;
 489
 490         addr_list = is_uc ? priv->fs.l2.netdev_uc : priv->fs.l2.netdev_mc;
 491
 492         if (is_uc) /* Make sure our own address is pushed first */
 493                 ether_addr_copy(addr_array[i++], ndev->dev_addr);
 494         else if (priv->fs.l2.broadcast_enabled)
 495                 ether_addr_copy(addr_array[i++], ndev->broadcast);
 496
 497         mlx5e_for_each_hash_node(hn, tmp, addr_list, hi) {
 498                 if (ether_addr_equal(ndev->dev_addr, hn->ai.addr))
 499                         continue;
 500                 if (i >= size)
 501                         break;
 502                 ether_addr_copy(addr_array[i++], hn->ai.addr);
 503         }
 504 }
 505
 506 static void mlx5e_vport_context_update_addr_list(struct mlx5e_priv *priv,
 507                                                  int list_type)
 508 {
 509         bool is_uc = (list_type == MLX5_NVPRT_LIST_TYPE_UC);
 510         struct mlx5e_l2_hash_node *hn;
 511         u8 (*addr_array)[ETH_ALEN] = NULL;
 512         struct hlist_head *addr_list;
 513         struct hlist_node *tmp;
 514         int max_size;
 515         int size;
 516         int err;
 517         int hi;
 518
 519         size = is_uc ? 0 : (priv->fs.l2.broadcast_enabled ? 1 : 0);
 520         max_size = is_uc ?
 521                 1 << MLX5_CAP_GEN(priv->mdev, log_max_current_uc_list) :
 522                 1 << MLX5_CAP_GEN(priv->mdev, log_max_current_mc_list);
 523
 524         addr_list = is_uc ? priv->fs.l2.netdev_uc : priv->fs.l2.netdev_mc;
 525         mlx5e_for_each_hash_node(hn, tmp, addr_list, hi)
 526                 size++;
 527
 528         if (size > max_size) {
 529                 netdev_warn(priv->netdev,
 530                             "netdev %s list size (%d) > (%d) max vport list size, some addresses will be dropped\n",
 531                             is_uc ? "UC" : "MC", size, max_size);
 532                 size = max_size;
 533         }
 534
 535         if (size) {
 536                 addr_array = kcalloc(size, ETH_ALEN, GFP_KERNEL);
 537                 if (!addr_array) {
 538                         err = -ENOMEM;
 539                         goto out;
 540                 }
 541                 mlx5e_fill_addr_array(priv, list_type, addr_array, size);
 542         }
 543
 544         err = mlx5_modify_nic_vport_mac_list(priv->mdev, list_type, addr_array, size);
 545 out:
 546         if (err)
 547                 netdev_err(priv->netdev,
 548                            "Failed to modify vport %s list err(%d)\n",
 549                            is_uc ? "UC" : "MC", err);
 550         kfree(addr_array);
 551 }
 552
 553 static void mlx5e_vport_context_update(struct mlx5e_priv *priv)
 554 {
 555         struct mlx5e_l2_table *ea = &priv->fs.l2;
 556
 557         mlx5e_vport_context_update_addr_list(priv, MLX5_NVPRT_LIST_TYPE_UC);
 558         mlx5e_vport_context_update_addr_list(priv, MLX5_NVPRT_LIST_TYPE_MC);
 559         mlx5_modify_nic_vport_promisc(priv->mdev, 0,
 560                                       ea->allmulti_enabled,
 561                                       ea->promisc_enabled);
 562 }
 563
 564 static void mlx5e_apply_netdev_addr(struct mlx5e_priv *priv)
 565 {
 566         struct mlx5e_l2_hash_node *hn;
 567         struct hlist_node *tmp;
 568         int i;
 569
 570         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_uc, i)
 571                 mlx5e_execute_l2_action(priv, hn);
 572
 573         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_mc, i)
 574                 mlx5e_execute_l2_action(priv, hn);
 575 }
 576
 577 static void mlx5e_handle_netdev_addr(struct mlx5e_priv *priv)
 578 {
 579         struct mlx5e_l2_hash_node *hn;
 580         struct hlist_node *tmp;
 581         int i;
 582
 583         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_uc, i)
 584                 hn->action = MLX5E_ACTION_DEL;
 585         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_mc, i)
 586                 hn->action = MLX5E_ACTION_DEL;
 587
 588         if (!test_bit(MLX5E_STATE_DESTROYING, &priv->state))
 589                 mlx5e_sync_netdev_addr(priv);
 590
 591         mlx5e_apply_netdev_addr(priv);
 592 }
 593
 594 void mlx5e_set_rx_mode_work(struct work_struct *work)
 595 {
 596         struct mlx5e_priv *priv = container_of(work, struct mlx5e_priv,
 597                                                set_rx_mode_work);
 598
 599         struct mlx5e_l2_table *ea = &priv->fs.l2;
 600         struct net_device *ndev = priv->netdev;
 601
 602         bool rx_mode_enable   = !test_bit(MLX5E_STATE_DESTROYING, &priv->state);
 603         bool promisc_enabled   = rx_mode_enable && (ndev->flags & IFF_PROMISC);
 604         bool allmulti_enabled  = rx_mode_enable && (ndev->flags & IFF_ALLMULTI);
 605         bool broadcast_enabled = rx_mode_enable;
 606
 607         bool enable_promisc    = !ea->promisc_enabled   &&  promisc_enabled;
 608         bool disable_promisc   =  ea->promisc_enabled   && !promisc_enabled;
 609         bool enable_allmulti   = !ea->allmulti_enabled  &&  allmulti_enabled;
 610         bool disable_allmulti  =  ea->allmulti_enabled  && !allmulti_enabled;
 611         bool enable_broadcast  = !ea->broadcast_enabled &&  broadcast_enabled;
 612         bool disable_broadcast =  ea->broadcast_enabled && !broadcast_enabled;
 613
 614         if (enable_promisc) {
 615                 if (!priv->channels.params.vlan_strip_disable)
 616                         netdev_warn_once(ndev,
 617                                          "S-tagged traffic will be dropped while C-tag vlan stripping is enabled\n");
 618                 mlx5e_add_l2_flow_rule(priv, &ea->promisc, MLX5E_PROMISC);
 619                 if (!priv->fs.vlan.cvlan_filter_disabled)
 620                         mlx5e_add_any_vid_rules(priv);
 621         }
 622         if (enable_allmulti)
 623                 mlx5e_add_l2_flow_rule(priv, &ea->allmulti, MLX5E_ALLMULTI);
 624         if (enable_broadcast)
 625                 mlx5e_add_l2_flow_rule(priv, &ea->broadcast, MLX5E_FULLMATCH);
 626
 627         mlx5e_handle_netdev_addr(priv);
 628
 629         if (disable_broadcast)
 630                 mlx5e_del_l2_flow_rule(priv, &ea->broadcast);
 631         if (disable_allmulti)
 632                 mlx5e_del_l2_flow_rule(priv, &ea->allmulti);
 633         if (disable_promisc) {
 634                 if (!priv->fs.vlan.cvlan_filter_disabled)
 635                         mlx5e_del_any_vid_rules(priv);
 636                 mlx5e_del_l2_flow_rule(priv, &ea->promisc);
 637         }
 638
 639         ea->promisc_enabled   = promisc_enabled;
 640         ea->allmulti_enabled  = allmulti_enabled;
 641         ea->broadcast_enabled = broadcast_enabled;
 642
 643         mlx5e_vport_context_update(priv);
 644 }
 645
 646 static void mlx5e_destroy_groups(struct mlx5e_flow_table *ft)
 647 {
 648         int i;
 649
 650         for (i = ft->num_groups - 1; i >= 0; i--) {
 651                 if (!IS_ERR_OR_NULL(ft->g[i]))
 652                         mlx5_destroy_flow_group(ft->g[i]);
 653                 ft->g[i] = NULL;
 654         }
 655         ft->num_groups = 0;
 656 }
 657
 658 void mlx5e_init_l2_addr(struct mlx5e_priv *priv)
 659 {
 660         ether_addr_copy(priv->fs.l2.broadcast.addr, priv->netdev->broadcast);
 661 }
 662
 663 void mlx5e_destroy_flow_table(struct mlx5e_flow_table *ft)
 664 {
 665         mlx5e_destroy_groups(ft);
 666         kfree(ft->g);
 667         mlx5_destroy_flow_table(ft->t);
 668         ft->t = NULL;
 669 }
 670
 671 static void mlx5e_cleanup_ttc_rules(struct mlx5e_ttc_table *ttc)
 672 {
 673         int i;
 674
 675         for (i = 0; i < MLX5E_NUM_TT; i++) {
 676                 if (!IS_ERR_OR_NULL(ttc->rules[i])) {
 677                         mlx5_del_flow_rules(ttc->rules[i]);
 678                         ttc->rules[i] = NULL;
 679                 }
 680         }
 681
 682         for (i = 0; i < MLX5E_NUM_TUNNEL_TT; i++) {
 683                 if (!IS_ERR_OR_NULL(ttc->tunnel_rules[i])) {
 684                         mlx5_del_flow_rules(ttc->tunnel_rules[i]);
 685                         ttc->tunnel_rules[i] = NULL;
 686                 }
 687         }
 688 }
 689
 690 struct mlx5e_etype_proto {
 691         u16 etype;
 692         u8 proto;
 693 };
 694
 695 static struct mlx5e_etype_proto ttc_rules[] = {
 696         [MLX5E_TT_IPV4_TCP] = {
 697                 .etype = ETH_P_IP,
 698                 .proto = IPPROTO_TCP,
 699         },
 700         [MLX5E_TT_IPV6_TCP] = {
 701                 .etype = ETH_P_IPV6,
 702                 .proto = IPPROTO_TCP,
 703         },
 704         [MLX5E_TT_IPV4_UDP] = {
 705                 .etype = ETH_P_IP,
 706                 .proto = IPPROTO_UDP,
 707         },
 708         [MLX5E_TT_IPV6_UDP] = {
 709                 .etype = ETH_P_IPV6,
 710                 .proto = IPPROTO_UDP,
 711         },
 712         [MLX5E_TT_IPV4_IPSEC_AH] = {
 713                 .etype = ETH_P_IP,
 714                 .proto = IPPROTO_AH,
 715         },
 716         [MLX5E_TT_IPV6_IPSEC_AH] = {
 717                 .etype = ETH_P_IPV6,
 718                 .proto = IPPROTO_AH,
 719         },
 720         [MLX5E_TT_IPV4_IPSEC_ESP] = {
 721                 .etype = ETH_P_IP,
 722                 .proto = IPPROTO_ESP,
 723         },
 724         [MLX5E_TT_IPV6_IPSEC_ESP] = {
 725                 .etype = ETH_P_IPV6,
 726                 .proto = IPPROTO_ESP,
 727         },
 728         [MLX5E_TT_IPV4] = {
 729                 .etype = ETH_P_IP,
 730                 .proto = 0,
 731         },
 732         [MLX5E_TT_IPV6] = {
 733                 .etype = ETH_P_IPV6,
 734                 .proto = 0,
 735         },
 736         [MLX5E_TT_ANY] = {
 737                 .etype = 0,
 738                 .proto = 0,
 739         },
 740 };
 741
 742 static struct mlx5e_etype_proto ttc_tunnel_rules[] = {
 743         [MLX5E_TT_IPV4_GRE] = {
 744                 .etype = ETH_P_IP,
 745                 .proto = IPPROTO_GRE,
 746         },
 747         [MLX5E_TT_IPV6_GRE] = {
 748                 .etype = ETH_P_IPV6,
 749                 .proto = IPPROTO_GRE,
 750         },
 751 };
 752
 753 static u8 mlx5e_etype_to_ipv(u16 ethertype)
 754 {
 755         if (ethertype == ETH_P_IP)
 756                 return 4;
 757
 758         if (ethertype == ETH_P_IPV6)
 759                 return 6;
 760
 761         return 0;
 762 }
 763
 764 static struct mlx5_flow_handle *
 765 mlx5e_generate_ttc_rule(struct mlx5e_priv *priv,
 766                         struct mlx5_flow_table *ft,
 767                         struct mlx5_flow_destination *dest,
 768                         u16 etype,
 769                         u8 proto)
 770 {
 771         int match_ipv_outer = MLX5_CAP_FLOWTABLE_NIC_RX(priv->mdev, ft_field_support.outer_ip_version);
 772         MLX5_DECLARE_FLOW_ACT(flow_act);
 773         struct mlx5_flow_handle *rule;
 774         struct mlx5_flow_spec *spec;
 775         int err = 0;
 776         u8 ipv;
 777
 778         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
 779         if (!spec)
 780                 return ERR_PTR(-ENOMEM);
 781
 782         if (proto) {
 783                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 784                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ip_protocol);
 785                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ip_protocol, proto);
 786         }
 787
 788         ipv = mlx5e_etype_to_ipv(etype);
 789         if (match_ipv_outer && ipv) {
 790                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 791                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ip_version);
 792                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ip_version, ipv);
 793         } else if (etype) {
 794                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 795                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ethertype);
 796                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ethertype, etype);
 797         }
 798
 799         rule = mlx5_add_flow_rules(ft, spec, &flow_act, dest, 1);
 800         if (IS_ERR(rule)) {
 801                 err = PTR_ERR(rule);
 802                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
 803         }
 804
 805         kvfree(spec);
 806         return err ? ERR_PTR(err) : rule;
 807 }
 808
 809 static int mlx5e_generate_ttc_table_rules(struct mlx5e_priv *priv)
 810 {
 811         struct mlx5_flow_destination dest = {};
 812         struct mlx5e_ttc_table *ttc;
 813         struct mlx5_flow_handle **rules;
 814         struct mlx5_flow_table *ft;
 815         int tt;
 816         int err;
 817
 818         ttc = &priv->fs.ttc;
 819         ft = ttc->ft.t;
 820         rules = ttc->rules;
 821
 822         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 823         for (tt = 0; tt < MLX5E_NUM_TT; tt++) {
 824                 if (tt == MLX5E_TT_ANY)
 825                         dest.tir_num = priv->direct_tir[0].tirn;
 826                 else
 827                         dest.tir_num = priv->indir_tir[tt].tirn;
 828                 rules[tt] = mlx5e_generate_ttc_rule(priv, ft, &dest,
 829                                                     ttc_rules[tt].etype,
 830                                                     ttc_rules[tt].proto);
 831                 if (IS_ERR(rules[tt]))
 832                         goto del_rules;
 833         }
 834
 835         if (!mlx5e_tunnel_inner_ft_supported(priv->mdev))
 836                 return 0;
 837
 838         rules     = ttc->tunnel_rules;
 839         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 840         dest.ft   = priv->fs.inner_ttc.ft.t;
 841         for (tt = 0; tt < MLX5E_NUM_TUNNEL_TT; tt++) {
 842                 rules[tt] = mlx5e_generate_ttc_rule(priv, ft, &dest,
 843                                                     ttc_tunnel_rules[tt].etype,
 844                                                     ttc_tunnel_rules[tt].proto);
 845                 if (IS_ERR(rules[tt]))
 846                         goto del_rules;
 847         }
 848
 849         return 0;
 850
 851 del_rules:
 852         err = PTR_ERR(rules[tt]);
 853         rules[tt] = NULL;
 854         mlx5e_cleanup_ttc_rules(ttc);
 855         return err;
 856 }
 857
 858 #define MLX5E_TTC_NUM_GROUPS    3
 859 #define MLX5E_TTC_GROUP1_SIZE   (BIT(3) + MLX5E_NUM_TUNNEL_TT)
 860 #define MLX5E_TTC_GROUP2_SIZE    BIT(1)
 861 #define MLX5E_TTC_GROUP3_SIZE    BIT(0)
 862 #define MLX5E_TTC_TABLE_SIZE    (MLX5E_TTC_GROUP1_SIZE +\
 863                                  MLX5E_TTC_GROUP2_SIZE +\
 864                                  MLX5E_TTC_GROUP3_SIZE)
 865
 866 #define MLX5E_INNER_TTC_NUM_GROUPS      3
 867 #define MLX5E_INNER_TTC_GROUP1_SIZE     BIT(3)
 868 #define MLX5E_INNER_TTC_GROUP2_SIZE     BIT(1)
 869 #define MLX5E_INNER_TTC_GROUP3_SIZE     BIT(0)
 870 #define MLX5E_INNER_TTC_TABLE_SIZE      (MLX5E_INNER_TTC_GROUP1_SIZE +\
 871                                          MLX5E_INNER_TTC_GROUP2_SIZE +\
 872                                          MLX5E_INNER_TTC_GROUP3_SIZE)
 873
 874 static int mlx5e_create_ttc_table_groups(struct mlx5e_ttc_table *ttc,
 875                                          bool use_ipv)
 876 {
 877         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 878         struct mlx5e_flow_table *ft = &ttc->ft;
 879         int ix = 0;
 880         u32 *in;
 881         int err;
 882         u8 *mc;
 883
 884         ft->g = kcalloc(MLX5E_TTC_NUM_GROUPS,
 885                         sizeof(*ft->g), GFP_KERNEL);
 886         if (!ft->g)
 887                 return -ENOMEM;
 888         in = kvzalloc(inlen, GFP_KERNEL);
 889         if (!in) {
 890                 kfree(ft->g);
 891                 return -ENOMEM;
 892         }
 893
 894         /* L4 Group */
 895         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
 896         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ip_protocol);
 897         if (use_ipv)
 898                 MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ip_version);
 899         else
 900                 MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ethertype);
 901         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
 902         MLX5_SET_CFG(in, start_flow_index, ix);
 903         ix += MLX5E_TTC_GROUP1_SIZE;
 904         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 905         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 906         if (IS_ERR(ft->g[ft->num_groups]))
 907                 goto err;
 908         ft->num_groups++;
 909
 910         /* L3 Group */
 911         MLX5_SET(fte_match_param, mc, outer_headers.ip_protocol, 0);
 912         MLX5_SET_CFG(in, start_flow_index, ix);
 913         ix += MLX5E_TTC_GROUP2_SIZE;
 914         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 915         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 916         if (IS_ERR(ft->g[ft->num_groups]))
 917                 goto err;
 918         ft->num_groups++;
 919
 920         /* Any Group */
 921         memset(in, 0, inlen);
 922         MLX5_SET_CFG(in, start_flow_index, ix);
 923         ix += MLX5E_TTC_GROUP3_SIZE;
 924         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 925         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 926         if (IS_ERR(ft->g[ft->num_groups]))
 927                 goto err;
 928         ft->num_groups++;
 929
 930         kvfree(in);
 931         return 0;
 932
 933 err:
 934         err = PTR_ERR(ft->g[ft->num_groups]);
 935         ft->g[ft->num_groups] = NULL;
 936         kvfree(in);
 937
 938         return err;
 939 }
 940
 941 static struct mlx5_flow_handle *
 942 mlx5e_generate_inner_ttc_rule(struct mlx5e_priv *priv,
 943                               struct mlx5_flow_table *ft,
 944                               struct mlx5_flow_destination *dest,
 945                               u16 etype, u8 proto)
 946 {
 947         MLX5_DECLARE_FLOW_ACT(flow_act);
 948         struct mlx5_flow_handle *rule;
 949         struct mlx5_flow_spec *spec;
 950         int err = 0;
 951         u8 ipv;
 952
 953         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
 954         if (!spec)
 955                 return ERR_PTR(-ENOMEM);
 956
 957         ipv = mlx5e_etype_to_ipv(etype);
 958         if (etype && ipv) {
 959                 spec->match_criteria_enable = MLX5_MATCH_INNER_HEADERS;
 960                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, inner_headers.ip_version);
 961                 MLX5_SET(fte_match_param, spec->match_value, inner_headers.ip_version, ipv);
 962         }
 963
 964         if (proto) {
 965                 spec->match_criteria_enable = MLX5_MATCH_INNER_HEADERS;
 966                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, inner_headers.ip_protocol);
 967                 MLX5_SET(fte_match_param, spec->match_value, inner_headers.ip_protocol, proto);
 968         }
 969
 970         rule = mlx5_add_flow_rules(ft, spec, &flow_act, dest, 1);
 971         if (IS_ERR(rule)) {
 972                 err = PTR_ERR(rule);
 973                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
 974         }
 975
 976         kvfree(spec);
 977         return err ? ERR_PTR(err) : rule;
 978 }
 979
 980 static int mlx5e_generate_inner_ttc_table_rules(struct mlx5e_priv *priv)
 981 {
 982         struct mlx5_flow_destination dest = {};
 983         struct mlx5_flow_handle **rules;
 984         struct mlx5e_ttc_table *ttc;
 985         struct mlx5_flow_table *ft;
 986         int err;
 987         int tt;
 988
 989         ttc =  &priv->fs.inner_ttc;
 990         ft = ttc->ft.t;
 991         rules = ttc->rules;
 992
 993         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 994         for (tt = 0; tt < MLX5E_NUM_TT; tt++) {
 995                 if (tt == MLX5E_TT_ANY)
 996                         dest.tir_num = priv->direct_tir[0].tirn;
 997                 else
 998                         dest.tir_num = priv->inner_indir_tir[tt].tirn;
 999
1000                 rules[tt] = mlx5e_generate_inner_ttc_rule(priv, ft, &dest,
1001                                                           ttc_rules[tt].etype,
1002                                                           ttc_rules[tt].proto);
1003                 if (IS_ERR(rules[tt]))
1004                         goto del_rules;
1005         }
1006
1007         return 0;
1008
1009 del_rules:
1010         err = PTR_ERR(rules[tt]);
1011         rules[tt] = NULL;
1012         mlx5e_cleanup_ttc_rules(ttc);
1013         return err;
1014 }
1015
1016 static int mlx5e_create_inner_ttc_table_groups(struct mlx5e_ttc_table *ttc)
1017 {
1018         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
1019         struct mlx5e_flow_table *ft = &ttc->ft;
1020         int ix = 0;
1021         u32 *in;
1022         int err;
1023         u8 *mc;
1024
1025         ft->g = kcalloc(MLX5E_INNER_TTC_NUM_GROUPS, sizeof(*ft->g), GFP_KERNEL);
1026         if (!ft->g)
1027                 return -ENOMEM;
1028         in = kvzalloc(inlen, GFP_KERNEL);
1029         if (!in) {
1030                 kfree(ft->g);
1031                 return -ENOMEM;
1032         }
1033
1034         /* L4 Group */
1035         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
1036         MLX5_SET_TO_ONES(fte_match_param, mc, inner_headers.ip_protocol);
1037         MLX5_SET_TO_ONES(fte_match_param, mc, inner_headers.ip_version);
1038         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_INNER_HEADERS);
1039         MLX5_SET_CFG(in, start_flow_index, ix);
1040         ix += MLX5E_INNER_TTC_GROUP1_SIZE;
1041         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1042         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1043         if (IS_ERR(ft->g[ft->num_groups]))
1044                 goto err;
1045         ft->num_groups++;
1046
1047         /* L3 Group */
1048         MLX5_SET(fte_match_param, mc, inner_headers.ip_protocol, 0);
1049         MLX5_SET_CFG(in, start_flow_index, ix);
1050         ix += MLX5E_INNER_TTC_GROUP2_SIZE;
1051         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1052         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1053         if (IS_ERR(ft->g[ft->num_groups]))
1054                 goto err;
1055         ft->num_groups++;
1056
1057         /* Any Group */
1058         memset(in, 0, inlen);
1059         MLX5_SET_CFG(in, start_flow_index, ix);
1060         ix += MLX5E_INNER_TTC_GROUP3_SIZE;
1061         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1062         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1063         if (IS_ERR(ft->g[ft->num_groups]))
1064                 goto err;
1065         ft->num_groups++;
1066
1067         kvfree(in);
1068         return 0;
1069
1070 err:
1071         err = PTR_ERR(ft->g[ft->num_groups]);
1072         ft->g[ft->num_groups] = NULL;
1073         kvfree(in);
1074
1075         return err;
1076 }
1077
1078 int mlx5e_create_inner_ttc_table(struct mlx5e_priv *priv)
1079 {
1080         struct mlx5e_ttc_table *ttc = &priv->fs.inner_ttc;
1081         struct mlx5_flow_table_attr ft_attr = {};
1082         struct mlx5e_flow_table *ft = &ttc->ft;
1083         int err;
1084
1085         if (!mlx5e_tunnel_inner_ft_supported(priv->mdev))
1086                 return 0;
1087
1088         ft_attr.max_fte = MLX5E_INNER_TTC_TABLE_SIZE;
1089         ft_attr.level   = MLX5E_INNER_TTC_FT_LEVEL;
1090         ft_attr.prio    = MLX5E_NIC_PRIO;
1091
1092         ft->t = mlx5_create_flow_table(priv->fs.ns, &ft_attr);
1093         if (IS_ERR(ft->t)) {
1094                 err = PTR_ERR(ft->t);
1095                 ft->t = NULL;
1096                 return err;
1097         }
1098
1099         err = mlx5e_create_inner_ttc_table_groups(ttc);
1100         if (err)
1101                 goto err;
1102
1103         err = mlx5e_generate_inner_ttc_table_rules(priv);
1104         if (err)
1105                 goto err;
1106
1107         return 0;
1108
1109 err:
1110         mlx5e_destroy_flow_table(ft);
1111         return err;
1112 }
1113
1114 void mlx5e_destroy_inner_ttc_table(struct mlx5e_priv *priv)
1115 {
1116         struct mlx5e_ttc_table *ttc = &priv->fs.inner_ttc;
1117
1118         if (!mlx5e_tunnel_inner_ft_supported(priv->mdev))
1119                 return;
1120
1121         mlx5e_cleanup_ttc_rules(ttc);
1122         mlx5e_destroy_flow_table(&ttc->ft);
1123 }
1124
1125 void mlx5e_destroy_ttc_table(struct mlx5e_priv *priv)
1126 {
1127         struct mlx5e_ttc_table *ttc = &priv->fs.ttc;
1128
1129         mlx5e_cleanup_ttc_rules(ttc);
1130         mlx5e_destroy_flow_table(&ttc->ft);
1131 }
1132
1133 int mlx5e_create_ttc_table(struct mlx5e_priv *priv)
1134 {
1135         bool match_ipv_outer = MLX5_CAP_FLOWTABLE_NIC_RX(priv->mdev, ft_field_support.outer_ip_version);
1136         struct mlx5e_ttc_table *ttc = &priv->fs.ttc;
1137         struct mlx5_flow_table_attr ft_attr = {};
1138         struct mlx5e_flow_table *ft = &ttc->ft;
1139         int err;
1140
1141         ft_attr.max_fte = MLX5E_TTC_TABLE_SIZE;
1142         ft_attr.level = MLX5E_TTC_FT_LEVEL;
1143         ft_attr.prio = MLX5E_NIC_PRIO;
1144
1145         ft->t = mlx5_create_flow_table(priv->fs.ns, &ft_attr);
1146         if (IS_ERR(ft->t)) {
1147                 err = PTR_ERR(ft->t);
1148                 ft->t = NULL;
1149                 return err;
1150         }
1151
1152         err = mlx5e_create_ttc_table_groups(ttc, match_ipv_outer);
1153         if (err)
1154                 goto err;
1155
1156         err = mlx5e_generate_ttc_table_rules(priv);
1157         if (err)
1158                 goto err;
1159
1160         return 0;
1161 err:
1162         mlx5e_destroy_flow_table(ft);
1163         return err;
1164 }
1165
1166 static void mlx5e_del_l2_flow_rule(struct mlx5e_priv *priv,
1167                                    struct mlx5e_l2_rule *ai)
1168 {
1169         if (!IS_ERR_OR_NULL(ai->rule)) {
1170                 mlx5_del_flow_rules(ai->rule);
1171                 ai->rule = NULL;
1172         }
1173 }
1174
1175 static int mlx5e_add_l2_flow_rule(struct mlx5e_priv *priv,
1176                                   struct mlx5e_l2_rule *ai, int type)
1177 {
1178         struct mlx5_flow_table *ft = priv->fs.l2.ft.t;
1179         struct mlx5_flow_destination dest = {};
1180         MLX5_DECLARE_FLOW_ACT(flow_act);
1181         struct mlx5_flow_spec *spec;
1182         int err = 0;
1183         u8 *mc_dmac;
1184         u8 *mv_dmac;
1185
1186         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
1187         if (!spec)
1188                 return -ENOMEM;
1189
1190         mc_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
1191                                outer_headers.dmac_47_16);
1192         mv_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_value,
1193                                outer_headers.dmac_47_16);
1194
1195         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
1196         dest.ft = priv->fs.ttc.ft.t;
1197
1198         switch (type) {
1199         case MLX5E_FULLMATCH:
1200                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
1201                 eth_broadcast_addr(mc_dmac);
1202                 ether_addr_copy(mv_dmac, ai->addr);
1203                 break;
1204
1205         case MLX5E_ALLMULTI:
1206                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
1207                 mc_dmac[0] = 0x01;
1208                 mv_dmac[0] = 0x01;
1209                 break;
1210
1211         case MLX5E_PROMISC:
1212                 break;
1213         }
1214
1215         ai->rule = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
1216         if (IS_ERR(ai->rule)) {
1217                 netdev_err(priv->netdev, "%s: add l2 rule(mac:%pM) failed\n",
1218                            __func__, mv_dmac);
1219                 err = PTR_ERR(ai->rule);
1220                 ai->rule = NULL;
1221         }
1222
1223         kvfree(spec);
1224
1225         return err;
1226 }
1227
1228 #define MLX5E_NUM_L2_GROUPS        3
1229 #define MLX5E_L2_GROUP1_SIZE       BIT(0)
1230 #define MLX5E_L2_GROUP2_SIZE       BIT(15)
1231 #define MLX5E_L2_GROUP3_SIZE       BIT(0)
1232 #define MLX5E_L2_TABLE_SIZE        (MLX5E_L2_GROUP1_SIZE +\
1233                                     MLX5E_L2_GROUP2_SIZE +\
1234                                     MLX5E_L2_GROUP3_SIZE)
1235 static int mlx5e_create_l2_table_groups(struct mlx5e_l2_table *l2_table)
1236 {
1237         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
1238         struct mlx5e_flow_table *ft = &l2_table->ft;
1239         int ix = 0;
1240         u8 *mc_dmac;
1241         u32 *in;
1242         int err;
1243         u8 *mc;
1244
1245         ft->g = kcalloc(MLX5E_NUM_L2_GROUPS, sizeof(*ft->g), GFP_KERNEL);
1246         if (!ft->g)
1247                 return -ENOMEM;
1248         in = kvzalloc(inlen, GFP_KERNEL);
1249         if (!in) {
1250                 kfree(ft->g);
1251                 return -ENOMEM;
1252         }
1253
1254         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
1255         mc_dmac = MLX5_ADDR_OF(fte_match_param, mc,
1256                                outer_headers.dmac_47_16);
1257         /* Flow Group for promiscuous */
1258         MLX5_SET_CFG(in, start_flow_index, ix);
1259         ix += MLX5E_L2_GROUP1_SIZE;
1260         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1261         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1262         if (IS_ERR(ft->g[ft->num_groups]))
1263                 goto err_destroy_groups;
1264         ft->num_groups++;
1265
1266         /* Flow Group for full match */
1267         eth_broadcast_addr(mc_dmac);
1268         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1269         MLX5_SET_CFG(in, start_flow_index, ix);
1270         ix += MLX5E_L2_GROUP2_SIZE;
1271         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1272         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1273         if (IS_ERR(ft->g[ft->num_groups]))
1274                 goto err_destroy_groups;
1275         ft->num_groups++;
1276
1277         /* Flow Group for allmulti */
1278         eth_zero_addr(mc_dmac);
1279         mc_dmac[0] = 0x01;
1280         MLX5_SET_CFG(in, start_flow_index, ix);
1281         ix += MLX5E_L2_GROUP3_SIZE;
1282         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1283         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1284         if (IS_ERR(ft->g[ft->num_groups]))
1285                 goto err_destroy_groups;
1286         ft->num_groups++;
1287
1288         kvfree(in);
1289         return 0;
1290
1291 err_destroy_groups:
1292         err = PTR_ERR(ft->g[ft->num_groups]);
1293         ft->g[ft->num_groups] = NULL;
1294         mlx5e_destroy_groups(ft);
1295         kvfree(in);
1296
1297         return err;
1298 }
1299
1300 static void mlx5e_destroy_l2_table(struct mlx5e_priv *priv)
1301 {
1302         mlx5e_destroy_flow_table(&priv->fs.l2.ft);
1303 }
1304
1305 static int mlx5e_create_l2_table(struct mlx5e_priv *priv)
1306 {
1307         struct mlx5e_l2_table *l2_table = &priv->fs.l2;
1308         struct mlx5e_flow_table *ft = &l2_table->ft;
1309         struct mlx5_flow_table_attr ft_attr = {};
1310         int err;
1311
1312         ft->num_groups = 0;
1313
1314         ft_attr.max_fte = MLX5E_L2_TABLE_SIZE;
1315         ft_attr.level = MLX5E_L2_FT_LEVEL;
1316         ft_attr.prio = MLX5E_NIC_PRIO;
1317
1318         ft->t = mlx5_create_flow_table(priv->fs.ns, &ft_attr);
1319         if (IS_ERR(ft->t)) {
1320                 err = PTR_ERR(ft->t);
1321                 ft->t = NULL;
1322                 return err;
1323         }
1324
1325         err = mlx5e_create_l2_table_groups(l2_table);
1326         if (err)
1327                 goto err_destroy_flow_table;
1328
1329         return 0;
1330
1331 err_destroy_flow_table:
1332         mlx5_destroy_flow_table(ft->t);
1333         ft->t = NULL;
1334
1335         return err;
1336 }
1337
1338 #define MLX5E_NUM_VLAN_GROUPS   4
1339 #define MLX5E_VLAN_GROUP0_SIZE  BIT(12)
1340 #define MLX5E_VLAN_GROUP1_SIZE  BIT(12)
1341 #define MLX5E_VLAN_GROUP2_SIZE  BIT(1)
1342 #define MLX5E_VLAN_GROUP3_SIZE  BIT(0)
1343 #define MLX5E_VLAN_TABLE_SIZE   (MLX5E_VLAN_GROUP0_SIZE +\
1344                                  MLX5E_VLAN_GROUP1_SIZE +\
1345                                  MLX5E_VLAN_GROUP2_SIZE +\
1346                                  MLX5E_VLAN_GROUP3_SIZE)
1347
1348 static int __mlx5e_create_vlan_table_groups(struct mlx5e_flow_table *ft, u32 *in,
1349                                             int inlen)
1350 {
1351         int err;
1352         int ix = 0;
1353         u8 *mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
1354
1355         memset(in, 0, inlen);
1356         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1357         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.cvlan_tag);
1358         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.first_vid);
1359         MLX5_SET_CFG(in, start_flow_index, ix);
1360         ix += MLX5E_VLAN_GROUP0_SIZE;
1361         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1362         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1363         if (IS_ERR(ft->g[ft->num_groups]))
1364                 goto err_destroy_groups;
1365         ft->num_groups++;
1366
1367         memset(in, 0, inlen);
1368         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1369         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.svlan_tag);
1370         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.first_vid);
1371         MLX5_SET_CFG(in, start_flow_index, ix);
1372         ix += MLX5E_VLAN_GROUP1_SIZE;
1373         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1374         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1375         if (IS_ERR(ft->g[ft->num_groups]))
1376                 goto err_destroy_groups;
1377         ft->num_groups++;
1378
1379         memset(in, 0, inlen);
1380         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1381         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.cvlan_tag);
1382         MLX5_SET_CFG(in, start_flow_index, ix);
1383         ix += MLX5E_VLAN_GROUP2_SIZE;
1384         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1385         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1386         if (IS_ERR(ft->g[ft->num_groups]))
1387                 goto err_destroy_groups;
1388         ft->num_groups++;
1389
1390         memset(in, 0, inlen);
1391         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1392         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.svlan_tag);
1393         MLX5_SET_CFG(in, start_flow_index, ix);
1394         ix += MLX5E_VLAN_GROUP3_SIZE;
1395         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1396         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1397         if (IS_ERR(ft->g[ft->num_groups]))
1398                 goto err_destroy_groups;
1399         ft->num_groups++;
1400
1401         return 0;
1402
1403 err_destroy_groups:
1404         err = PTR_ERR(ft->g[ft->num_groups]);
1405         ft->g[ft->num_groups] = NULL;
1406         mlx5e_destroy_groups(ft);
1407
1408         return err;
1409 }
1410
1411 static int mlx5e_create_vlan_table_groups(struct mlx5e_flow_table *ft)
1412 {
1413         u32 *in;
1414         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
1415         int err;
1416
1417         in = kvzalloc(inlen, GFP_KERNEL);
1418         if (!in)
1419                 return -ENOMEM;
1420
1421         err = __mlx5e_create_vlan_table_groups(ft, in, inlen);
1422
1423         kvfree(in);
1424         return err;
1425 }
1426
1427 static int mlx5e_create_vlan_table(struct mlx5e_priv *priv)
1428 {
1429         struct mlx5e_flow_table *ft = &priv->fs.vlan.ft;
1430         struct mlx5_flow_table_attr ft_attr = {};
1431         int err;
1432
1433         ft->num_groups = 0;
1434
1435         ft_attr.max_fte = MLX5E_VLAN_TABLE_SIZE;
1436         ft_attr.level = MLX5E_VLAN_FT_LEVEL;
1437         ft_attr.prio = MLX5E_NIC_PRIO;
1438
1439         ft->t = mlx5_create_flow_table(priv->fs.ns, &ft_attr);
1440
1441         if (IS_ERR(ft->t)) {
1442                 err = PTR_ERR(ft->t);
1443                 ft->t = NULL;
1444                 return err;
1445         }
1446         ft->g = kcalloc(MLX5E_NUM_VLAN_GROUPS, sizeof(*ft->g), GFP_KERNEL);
1447         if (!ft->g) {
1448                 err = -ENOMEM;
1449                 goto err_destroy_vlan_table;
1450         }
1451
1452         err = mlx5e_create_vlan_table_groups(ft);
1453         if (err)
1454                 goto err_free_g;
1455
1456         mlx5e_add_vlan_rules(priv);
1457
1458         return 0;
1459
1460 err_free_g:
1461         kfree(ft->g);
1462 err_destroy_vlan_table:
1463         mlx5_destroy_flow_table(ft->t);
1464         ft->t = NULL;
1465
1466         return err;
1467 }
1468
1469 static void mlx5e_destroy_vlan_table(struct mlx5e_priv *priv)
1470 {
1471         mlx5e_del_vlan_rules(priv);
1472         mlx5e_destroy_flow_table(&priv->fs.vlan.ft);
1473 }
1474
1475 int mlx5e_create_flow_steering(struct mlx5e_priv *priv)
1476 {
1477         int err;
1478
1479         priv->fs.ns = mlx5_get_flow_namespace(priv->mdev,
1480                                                MLX5_FLOW_NAMESPACE_KERNEL);
1481
1482         if (!priv->fs.ns)
1483                 return -EOPNOTSUPP;
1484
1485         err = mlx5e_arfs_create_tables(priv);
1486         if (err) {
1487                 netdev_err(priv->netdev, "Failed to create arfs tables, err=%d\n",
1488                            err);
1489                 priv->netdev->hw_features &= ~NETIF_F_NTUPLE;
1490         }
1491
1492         err = mlx5e_create_inner_ttc_table(priv);
1493         if (err) {
1494                 netdev_err(priv->netdev, "Failed to create inner ttc table, err=%d\n",
1495                            err);
1496                 goto err_destroy_arfs_tables;
1497         }
1498
1499         err = mlx5e_create_ttc_table(priv);
1500         if (err) {
1501                 netdev_err(priv->netdev, "Failed to create ttc table, err=%d\n",
1502                            err);
1503                 goto err_destroy_inner_ttc_table;
1504         }
1505
1506         err = mlx5e_create_l2_table(priv);
1507         if (err) {
1508                 netdev_err(priv->netdev, "Failed to create l2 table, err=%d\n",
1509                            err);
1510                 goto err_destroy_ttc_table;
1511         }
1512
1513         err = mlx5e_create_vlan_table(priv);
1514         if (err) {
1515                 netdev_err(priv->netdev, "Failed to create vlan table, err=%d\n",
1516                            err);
1517                 goto err_destroy_l2_table;
1518         }
1519
1520         mlx5e_ethtool_init_steering(priv);
1521
1522         return 0;
1523
1524 err_destroy_l2_table:
1525         mlx5e_destroy_l2_table(priv);
1526 err_destroy_ttc_table:
1527         mlx5e_destroy_ttc_table(priv);
1528 err_destroy_inner_ttc_table:
1529         mlx5e_destroy_inner_ttc_table(priv);
1530 err_destroy_arfs_tables:
1531         mlx5e_arfs_destroy_tables(priv);
1532
1533         return err;
1534 }
1535
1536 void mlx5e_destroy_flow_steering(struct mlx5e_priv *priv)
1537 {
1538         mlx5e_destroy_vlan_table(priv);
1539         mlx5e_destroy_l2_table(priv);
1540         mlx5e_destroy_ttc_table(priv);
1541         mlx5e_destroy_inner_ttc_table(priv);
1542         mlx5e_arfs_destroy_tables(priv);
1543         mlx5e_ethtool_cleanup_steering(priv);
1544 }