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

   1 /*
   2  * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/debugfs.h>
  34 #include <linux/mlx5/fs.h>
  35 #include <net/switchdev.h>
  36 #include <net/pkt_cls.h>
  37 #include <net/act_api.h>
  38 #include <net/devlink.h>
  39 #include <net/ipv6_stubs.h>
  40
  41 #include "eswitch.h"
  42 #include "en.h"
  43 #include "en_rep.h"
  44 #include "en/params.h"
  45 #include "en/txrx.h"
  46 #include "en_tc.h"
  47 #include "en/rep/tc.h"
  48 #include "en/rep/neigh.h"
  49 #include "en/rep/bridge.h"
  50 #include "en/devlink.h"
  51 #include "fs_core.h"
  52 #include "lib/mlx5.h"
  53 #include "lib/devcom.h"
  54 #include "lib/vxlan.h"
  55 #define CREATE_TRACE_POINTS
  56 #include "diag/en_rep_tracepoint.h"
  57 #include "diag/reporter_vnic.h"
  58 #include "en_accel/ipsec.h"
  59 #include "en/tc/int_port.h"
  60 #include "en/ptp.h"
  61 #include "en/fs_ethtool.h"
  62
  63 #define MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE \
  64         max(0x7, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)
  65 #define MLX5E_REP_PARAMS_DEF_NUM_CHANNELS 1
  66
  67 static const char mlx5e_rep_driver_name[] = "mlx5e_rep";
  68
  69 static void mlx5e_rep_get_drvinfo(struct net_device *dev,
  70                                   struct ethtool_drvinfo *drvinfo)
  71 {
  72         struct mlx5e_priv *priv = netdev_priv(dev);
  73         struct mlx5_core_dev *mdev = priv->mdev;
  74
  75         strscpy(drvinfo->driver, mlx5e_rep_driver_name,
  76                 sizeof(drvinfo->driver));
  77         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  78                  "%d.%d.%04d (%.16s)",
  79                  fw_rev_maj(mdev), fw_rev_min(mdev),
  80                  fw_rev_sub(mdev), mdev->board_id);
  81 }
  82
  83 static const struct counter_desc sw_rep_stats_desc[] = {
  84         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_packets) },
  85         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) },
  86         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) },
  87         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) },
  88 };
  89
  90 static const struct counter_desc vport_rep_stats_desc[] = {
  91         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_rx_packets) },
  92         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_rx_bytes) },
  93         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_tx_packets) },
  94         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_tx_bytes) },
  95         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats,
  96                              rx_vport_rdma_unicast_packets) },
  97         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, rx_vport_rdma_unicast_bytes) },
  98         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats,
  99                              tx_vport_rdma_unicast_packets) },
 100         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, tx_vport_rdma_unicast_bytes) },
 101         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats,
 102                              rx_vport_rdma_multicast_packets) },
 103         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats,
 104                              rx_vport_rdma_multicast_bytes) },
 105         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats,
 106                              tx_vport_rdma_multicast_packets) },
 107         { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats,
 108                              tx_vport_rdma_multicast_bytes) },
 109 };
 110
 111 #define NUM_VPORT_REP_SW_COUNTERS ARRAY_SIZE(sw_rep_stats_desc)
 112 #define NUM_VPORT_REP_HW_COUNTERS ARRAY_SIZE(vport_rep_stats_desc)
 113
 114 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(sw_rep)
 115 {
 116         return NUM_VPORT_REP_SW_COUNTERS;
 117 }
 118
 119 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(sw_rep)
 120 {
 121         int i;
 122
 123         for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++)
 124                 strcpy(data + (idx++) * ETH_GSTRING_LEN,
 125                        sw_rep_stats_desc[i].format);
 126         return idx;
 127 }
 128
 129 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(sw_rep)
 130 {
 131         int i;
 132
 133         for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++)
 134                 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.sw,
 135                                                    sw_rep_stats_desc, i);
 136         return idx;
 137 }
 138
 139 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(sw_rep)
 140 {
 141         struct mlx5e_sw_stats *s = &priv->stats.sw;
 142         struct rtnl_link_stats64 stats64 = {};
 143
 144         memset(s, 0, sizeof(*s));
 145         mlx5e_fold_sw_stats64(priv, &stats64);
 146
 147         s->rx_packets = stats64.rx_packets;
 148         s->rx_bytes   = stats64.rx_bytes;
 149         s->tx_packets = stats64.tx_packets;
 150         s->tx_bytes   = stats64.tx_bytes;
 151         s->tx_queue_dropped = stats64.tx_dropped;
 152 }
 153
 154 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(vport_rep)
 155 {
 156         return NUM_VPORT_REP_HW_COUNTERS;
 157 }
 158
 159 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(vport_rep)
 160 {
 161         int i;
 162
 163         for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++)
 164                 strcpy(data + (idx++) * ETH_GSTRING_LEN, vport_rep_stats_desc[i].format);
 165         return idx;
 166 }
 167
 168 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(vport_rep)
 169 {
 170         int i;
 171
 172         for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++)
 173                 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.rep_stats,
 174                                                    vport_rep_stats_desc, i);
 175         return idx;
 176 }
 177
 178 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(vport_rep)
 179 {
 180         struct mlx5e_rep_stats *rep_stats = &priv->stats.rep_stats;
 181         int outlen = MLX5_ST_SZ_BYTES(query_vport_counter_out);
 182         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 183         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 184         struct mlx5_eswitch_rep *rep = rpriv->rep;
 185         u32 *out;
 186         int err;
 187
 188         out = kvzalloc(outlen, GFP_KERNEL);
 189         if (!out)
 190                 return;
 191
 192         err = mlx5_core_query_vport_counter(esw->dev, 1, rep->vport - 1, 0, out);
 193         if (err) {
 194                 netdev_warn(priv->netdev, "vport %d error %d reading stats\n",
 195                             rep->vport, err);
 196                 goto out;
 197         }
 198
 199         #define MLX5_GET_CTR(p, x) \
 200                 MLX5_GET64(query_vport_counter_out, p, x)
 201         /* flip tx/rx as we are reporting the counters for the switch vport */
 202         rep_stats->vport_rx_packets =
 203                 MLX5_GET_CTR(out, transmitted_ib_unicast.packets) +
 204                 MLX5_GET_CTR(out, transmitted_eth_unicast.packets) +
 205                 MLX5_GET_CTR(out, transmitted_ib_multicast.packets) +
 206                 MLX5_GET_CTR(out, transmitted_eth_multicast.packets) +
 207                 MLX5_GET_CTR(out, transmitted_eth_broadcast.packets);
 208
 209         rep_stats->vport_tx_packets =
 210                 MLX5_GET_CTR(out, received_ib_unicast.packets) +
 211                 MLX5_GET_CTR(out, received_eth_unicast.packets) +
 212                 MLX5_GET_CTR(out, received_ib_multicast.packets) +
 213                 MLX5_GET_CTR(out, received_eth_multicast.packets) +
 214                 MLX5_GET_CTR(out, received_eth_broadcast.packets);
 215
 216         rep_stats->vport_rx_bytes =
 217                 MLX5_GET_CTR(out, transmitted_ib_unicast.octets) +
 218                 MLX5_GET_CTR(out, transmitted_eth_unicast.octets) +
 219                 MLX5_GET_CTR(out, transmitted_ib_multicast.octets) +
 220                 MLX5_GET_CTR(out, transmitted_eth_broadcast.octets);
 221
 222         rep_stats->vport_tx_bytes =
 223                 MLX5_GET_CTR(out, received_ib_unicast.octets) +
 224                 MLX5_GET_CTR(out, received_eth_unicast.octets) +
 225                 MLX5_GET_CTR(out, received_ib_multicast.octets) +
 226                 MLX5_GET_CTR(out, received_eth_multicast.octets) +
 227                 MLX5_GET_CTR(out, received_eth_broadcast.octets);
 228
 229         rep_stats->rx_vport_rdma_unicast_packets =
 230                 MLX5_GET_CTR(out, transmitted_ib_unicast.packets);
 231         rep_stats->tx_vport_rdma_unicast_packets =
 232                 MLX5_GET_CTR(out, received_ib_unicast.packets);
 233         rep_stats->rx_vport_rdma_unicast_bytes =
 234                 MLX5_GET_CTR(out, transmitted_ib_unicast.octets);
 235         rep_stats->tx_vport_rdma_unicast_bytes =
 236                 MLX5_GET_CTR(out, received_ib_unicast.octets);
 237         rep_stats->rx_vport_rdma_multicast_packets =
 238                 MLX5_GET_CTR(out, transmitted_ib_multicast.packets);
 239         rep_stats->tx_vport_rdma_multicast_packets =
 240                 MLX5_GET_CTR(out, received_ib_multicast.packets);
 241         rep_stats->rx_vport_rdma_multicast_bytes =
 242                 MLX5_GET_CTR(out, transmitted_ib_multicast.octets);
 243         rep_stats->tx_vport_rdma_multicast_bytes =
 244                 MLX5_GET_CTR(out, received_ib_multicast.octets);
 245
 246 out:
 247         kvfree(out);
 248 }
 249
 250 static void mlx5e_rep_get_strings(struct net_device *dev,
 251                                   u32 stringset, uint8_t *data)
 252 {
 253         struct mlx5e_priv *priv = netdev_priv(dev);
 254
 255         switch (stringset) {
 256         case ETH_SS_STATS:
 257                 mlx5e_stats_fill_strings(priv, data);
 258                 break;
 259         }
 260 }
 261
 262 static void mlx5e_rep_get_ethtool_stats(struct net_device *dev,
 263                                         struct ethtool_stats *stats, u64 *data)
 264 {
 265         struct mlx5e_priv *priv = netdev_priv(dev);
 266
 267         mlx5e_ethtool_get_ethtool_stats(priv, stats, data);
 268 }
 269
 270 static int mlx5e_rep_get_sset_count(struct net_device *dev, int sset)
 271 {
 272         struct mlx5e_priv *priv = netdev_priv(dev);
 273
 274         switch (sset) {
 275         case ETH_SS_STATS:
 276                 return mlx5e_stats_total_num(priv);
 277         default:
 278                 return -EOPNOTSUPP;
 279         }
 280 }
 281
 282 static void
 283 mlx5e_rep_get_ringparam(struct net_device *dev,
 284                         struct ethtool_ringparam *param,
 285                         struct kernel_ethtool_ringparam *kernel_param,
 286                         struct netlink_ext_ack *extack)
 287 {
 288         struct mlx5e_priv *priv = netdev_priv(dev);
 289
 290         mlx5e_ethtool_get_ringparam(priv, param, kernel_param);
 291 }
 292
 293 static int
 294 mlx5e_rep_set_ringparam(struct net_device *dev,
 295                         struct ethtool_ringparam *param,
 296                         struct kernel_ethtool_ringparam *kernel_param,
 297                         struct netlink_ext_ack *extack)
 298 {
 299         struct mlx5e_priv *priv = netdev_priv(dev);
 300
 301         return mlx5e_ethtool_set_ringparam(priv, param);
 302 }
 303
 304 static void mlx5e_rep_get_channels(struct net_device *dev,
 305                                    struct ethtool_channels *ch)
 306 {
 307         struct mlx5e_priv *priv = netdev_priv(dev);
 308
 309         mlx5e_ethtool_get_channels(priv, ch);
 310 }
 311
 312 static int mlx5e_rep_set_channels(struct net_device *dev,
 313                                   struct ethtool_channels *ch)
 314 {
 315         struct mlx5e_priv *priv = netdev_priv(dev);
 316
 317         return mlx5e_ethtool_set_channels(priv, ch);
 318 }
 319
 320 static int mlx5e_rep_get_coalesce(struct net_device *netdev,
 321                                   struct ethtool_coalesce *coal,
 322                                   struct kernel_ethtool_coalesce *kernel_coal,
 323                                   struct netlink_ext_ack *extack)
 324 {
 325         struct mlx5e_priv *priv = netdev_priv(netdev);
 326
 327         return mlx5e_ethtool_get_coalesce(priv, coal, kernel_coal);
 328 }
 329
 330 static int mlx5e_rep_set_coalesce(struct net_device *netdev,
 331                                   struct ethtool_coalesce *coal,
 332                                   struct kernel_ethtool_coalesce *kernel_coal,
 333                                   struct netlink_ext_ack *extack)
 334 {
 335         struct mlx5e_priv *priv = netdev_priv(netdev);
 336
 337         return mlx5e_ethtool_set_coalesce(priv, coal, kernel_coal, extack);
 338 }
 339
 340 static u32 mlx5e_rep_get_rxfh_key_size(struct net_device *netdev)
 341 {
 342         struct mlx5e_priv *priv = netdev_priv(netdev);
 343
 344         return mlx5e_ethtool_get_rxfh_key_size(priv);
 345 }
 346
 347 static u32 mlx5e_rep_get_rxfh_indir_size(struct net_device *netdev)
 348 {
 349         struct mlx5e_priv *priv = netdev_priv(netdev);
 350
 351         return mlx5e_ethtool_get_rxfh_indir_size(priv);
 352 }
 353
 354 static const struct ethtool_ops mlx5e_rep_ethtool_ops = {
 355         .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
 356                                      ETHTOOL_COALESCE_MAX_FRAMES |
 357                                      ETHTOOL_COALESCE_USE_ADAPTIVE,
 358         .get_drvinfo       = mlx5e_rep_get_drvinfo,
 359         .get_link          = ethtool_op_get_link,
 360         .get_strings       = mlx5e_rep_get_strings,
 361         .get_sset_count    = mlx5e_rep_get_sset_count,
 362         .get_ethtool_stats = mlx5e_rep_get_ethtool_stats,
 363         .get_ringparam     = mlx5e_rep_get_ringparam,
 364         .set_ringparam     = mlx5e_rep_set_ringparam,
 365         .get_channels      = mlx5e_rep_get_channels,
 366         .set_channels      = mlx5e_rep_set_channels,
 367         .get_coalesce      = mlx5e_rep_get_coalesce,
 368         .set_coalesce      = mlx5e_rep_set_coalesce,
 369         .get_rxfh_key_size   = mlx5e_rep_get_rxfh_key_size,
 370         .get_rxfh_indir_size = mlx5e_rep_get_rxfh_indir_size,
 371 };
 372
 373 static void mlx5e_sqs2vport_stop(struct mlx5_eswitch *esw,
 374                                  struct mlx5_eswitch_rep *rep)
 375 {
 376         struct mlx5e_rep_sq *rep_sq, *tmp;
 377         struct mlx5e_rep_priv *rpriv;
 378
 379         if (esw->mode != MLX5_ESWITCH_OFFLOADS)
 380                 return;
 381
 382         rpriv = mlx5e_rep_to_rep_priv(rep);
 383         list_for_each_entry_safe(rep_sq, tmp, &rpriv->vport_sqs_list, list) {
 384                 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule);
 385                 if (rep_sq->send_to_vport_rule_peer)
 386                         mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule_peer);
 387                 list_del(&rep_sq->list);
 388                 kfree(rep_sq);
 389         }
 390 }
 391
 392 static int mlx5e_sqs2vport_start(struct mlx5_eswitch *esw,
 393                                  struct mlx5_eswitch_rep *rep,
 394                                  u32 *sqns_array, int sqns_num)
 395 {
 396         struct mlx5_eswitch *peer_esw = NULL;
 397         struct mlx5_flow_handle *flow_rule;
 398         struct mlx5e_rep_priv *rpriv;
 399         struct mlx5e_rep_sq *rep_sq;
 400         int err;
 401         int i;
 402
 403         if (esw->mode != MLX5_ESWITCH_OFFLOADS)
 404                 return 0;
 405
 406         rpriv = mlx5e_rep_to_rep_priv(rep);
 407         if (mlx5_devcom_is_paired(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS))
 408                 peer_esw = mlx5_devcom_get_peer_data(esw->dev->priv.devcom,
 409                                                      MLX5_DEVCOM_ESW_OFFLOADS);
 410
 411         for (i = 0; i < sqns_num; i++) {
 412                 rep_sq = kzalloc(sizeof(*rep_sq), GFP_KERNEL);
 413                 if (!rep_sq) {
 414                         err = -ENOMEM;
 415                         goto out_err;
 416                 }
 417
 418                 /* Add re-inject rule to the PF/representor sqs */
 419                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw, esw, rep,
 420                                                                 sqns_array[i]);
 421                 if (IS_ERR(flow_rule)) {
 422                         err = PTR_ERR(flow_rule);
 423                         kfree(rep_sq);
 424                         goto out_err;
 425                 }
 426                 rep_sq->send_to_vport_rule = flow_rule;
 427                 rep_sq->sqn = sqns_array[i];
 428
 429                 if (peer_esw) {
 430                         flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw,
 431                                                                         rep, sqns_array[i]);
 432                         if (IS_ERR(flow_rule)) {
 433                                 err = PTR_ERR(flow_rule);
 434                                 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule);
 435                                 kfree(rep_sq);
 436                                 goto out_err;
 437                         }
 438                         rep_sq->send_to_vport_rule_peer = flow_rule;
 439                 }
 440
 441                 list_add(&rep_sq->list, &rpriv->vport_sqs_list);
 442         }
 443
 444         if (peer_esw)
 445                 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS);
 446
 447         return 0;
 448
 449 out_err:
 450         mlx5e_sqs2vport_stop(esw, rep);
 451
 452         if (peer_esw)
 453                 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS);
 454
 455         return err;
 456 }
 457
 458 static int
 459 mlx5e_add_sqs_fwd_rules(struct mlx5e_priv *priv)
 460 {
 461         int sqs_per_channel = mlx5e_get_dcb_num_tc(&priv->channels.params);
 462         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 463         bool is_uplink_rep = mlx5e_is_uplink_rep(priv);
 464         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 465         struct mlx5_eswitch_rep *rep = rpriv->rep;
 466         int n, tc, nch, num_sqs = 0;
 467         struct mlx5e_channel *c;
 468         int err = -ENOMEM;
 469         bool ptp_sq;
 470         u32 *sqs;
 471
 472         ptp_sq = !!(priv->channels.ptp &&
 473                     MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_TX_PORT_TS));
 474         nch = priv->channels.num + ptp_sq;
 475         /* +2 for xdpsqs, they don't exist on the ptp channel but will not be
 476          * counted for by num_sqs.
 477          */
 478         if (is_uplink_rep)
 479                 sqs_per_channel += 2;
 480
 481         sqs = kvcalloc(nch * sqs_per_channel, sizeof(*sqs), GFP_KERNEL);
 482         if (!sqs)
 483                 goto out;
 484
 485         for (n = 0; n < priv->channels.num; n++) {
 486                 c = priv->channels.c[n];
 487                 for (tc = 0; tc < c->num_tc; tc++)
 488                         sqs[num_sqs++] = c->sq[tc].sqn;
 489
 490                 if (is_uplink_rep) {
 491                         if (c->xdp)
 492                                 sqs[num_sqs++] = c->rq_xdpsq.sqn;
 493
 494                         sqs[num_sqs++] = c->xdpsq.sqn;
 495                 }
 496         }
 497         if (ptp_sq) {
 498                 struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
 499
 500                 for (tc = 0; tc < ptp_ch->num_tc; tc++)
 501                         sqs[num_sqs++] = ptp_ch->ptpsq[tc].txqsq.sqn;
 502         }
 503
 504         err = mlx5e_sqs2vport_start(esw, rep, sqs, num_sqs);
 505         kvfree(sqs);
 506
 507 out:
 508         if (err)
 509                 netdev_warn(priv->netdev, "Failed to add SQs FWD rules %d\n", err);
 510         return err;
 511 }
 512
 513 static void
 514 mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv)
 515 {
 516         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 517         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 518         struct mlx5_eswitch_rep *rep = rpriv->rep;
 519
 520         mlx5e_sqs2vport_stop(esw, rep);
 521 }
 522
 523 static int
 524 mlx5e_rep_add_meta_tunnel_rule(struct mlx5e_priv *priv)
 525 {
 526         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 527         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 528         struct mlx5_eswitch_rep *rep = rpriv->rep;
 529         struct mlx5_flow_handle *flow_rule;
 530         struct mlx5_flow_group *g;
 531
 532         g = esw->fdb_table.offloads.send_to_vport_meta_grp;
 533         if (!g)
 534                 return 0;
 535
 536         flow_rule = mlx5_eswitch_add_send_to_vport_meta_rule(esw, rep->vport);
 537         if (IS_ERR(flow_rule))
 538                 return PTR_ERR(flow_rule);
 539
 540         rpriv->send_to_vport_meta_rule = flow_rule;
 541
 542         return 0;
 543 }
 544
 545 static void
 546 mlx5e_rep_del_meta_tunnel_rule(struct mlx5e_priv *priv)
 547 {
 548         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 549
 550         if (rpriv->send_to_vport_meta_rule)
 551                 mlx5_eswitch_del_send_to_vport_meta_rule(rpriv->send_to_vport_meta_rule);
 552 }
 553
 554 void mlx5e_rep_activate_channels(struct mlx5e_priv *priv)
 555 {
 556         mlx5e_add_sqs_fwd_rules(priv);
 557         mlx5e_rep_add_meta_tunnel_rule(priv);
 558 }
 559
 560 void mlx5e_rep_deactivate_channels(struct mlx5e_priv *priv)
 561 {
 562         mlx5e_rep_del_meta_tunnel_rule(priv);
 563         mlx5e_remove_sqs_fwd_rules(priv);
 564 }
 565
 566 static int mlx5e_rep_open(struct net_device *dev)
 567 {
 568         struct mlx5e_priv *priv = netdev_priv(dev);
 569         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 570         struct mlx5_eswitch_rep *rep = rpriv->rep;
 571         int err;
 572
 573         mutex_lock(&priv->state_lock);
 574         err = mlx5e_open_locked(dev);
 575         if (err)
 576                 goto unlock;
 577
 578         if (!mlx5_modify_vport_admin_state(priv->mdev,
 579                                            MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 580                                            rep->vport, 1,
 581                                            MLX5_VPORT_ADMIN_STATE_UP))
 582                 netif_carrier_on(dev);
 583
 584 unlock:
 585         mutex_unlock(&priv->state_lock);
 586         return err;
 587 }
 588
 589 static int mlx5e_rep_close(struct net_device *dev)
 590 {
 591         struct mlx5e_priv *priv = netdev_priv(dev);
 592         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 593         struct mlx5_eswitch_rep *rep = rpriv->rep;
 594         int ret;
 595
 596         mutex_lock(&priv->state_lock);
 597         mlx5_modify_vport_admin_state(priv->mdev,
 598                                       MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 599                                       rep->vport, 1,
 600                                       MLX5_VPORT_ADMIN_STATE_DOWN);
 601         ret = mlx5e_close_locked(dev);
 602         mutex_unlock(&priv->state_lock);
 603         return ret;
 604 }
 605
 606 bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv)
 607 {
 608         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 609         struct mlx5_eswitch_rep *rep;
 610
 611         if (!MLX5_ESWITCH_MANAGER(priv->mdev))
 612                 return false;
 613
 614         if (!rpriv) /* non vport rep mlx5e instances don't use this field */
 615                 return false;
 616
 617         rep = rpriv->rep;
 618         return (rep->vport == MLX5_VPORT_UPLINK);
 619 }
 620
 621 bool mlx5e_rep_has_offload_stats(const struct net_device *dev, int attr_id)
 622 {
 623         switch (attr_id) {
 624         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 625                         return true;
 626         }
 627
 628         return false;
 629 }
 630
 631 static int
 632 mlx5e_get_sw_stats64(const struct net_device *dev,
 633                      struct rtnl_link_stats64 *stats)
 634 {
 635         struct mlx5e_priv *priv = netdev_priv(dev);
 636
 637         mlx5e_fold_sw_stats64(priv, stats);
 638         return 0;
 639 }
 640
 641 int mlx5e_rep_get_offload_stats(int attr_id, const struct net_device *dev,
 642                                 void *sp)
 643 {
 644         switch (attr_id) {
 645         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 646                 return mlx5e_get_sw_stats64(dev, sp);
 647         }
 648
 649         return -EINVAL;
 650 }
 651
 652 static void
 653 mlx5e_rep_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats)
 654 {
 655         struct mlx5e_priv *priv = netdev_priv(dev);
 656
 657         /* update HW stats in background for next time */
 658         mlx5e_queue_update_stats(priv);
 659         memcpy(stats, &priv->stats.vf_vport, sizeof(*stats));
 660 }
 661
 662 static int mlx5e_rep_change_mtu(struct net_device *netdev, int new_mtu)
 663 {
 664         return mlx5e_change_mtu(netdev, new_mtu, NULL);
 665 }
 666
 667 static int mlx5e_rep_change_carrier(struct net_device *dev, bool new_carrier)
 668 {
 669         struct mlx5e_priv *priv = netdev_priv(dev);
 670         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 671         struct mlx5_eswitch_rep *rep = rpriv->rep;
 672         int err;
 673
 674         if (new_carrier) {
 675                 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 676                                                     rep->vport, 1, MLX5_VPORT_ADMIN_STATE_UP);
 677                 if (err)
 678                         return err;
 679                 netif_carrier_on(dev);
 680         } else {
 681                 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 682                                                     rep->vport, 1, MLX5_VPORT_ADMIN_STATE_DOWN);
 683                 if (err)
 684                         return err;
 685                 netif_carrier_off(dev);
 686         }
 687         return 0;
 688 }
 689
 690 static const struct net_device_ops mlx5e_netdev_ops_rep = {
 691         .ndo_open                = mlx5e_rep_open,
 692         .ndo_stop                = mlx5e_rep_close,
 693         .ndo_start_xmit          = mlx5e_xmit,
 694         .ndo_setup_tc            = mlx5e_rep_setup_tc,
 695         .ndo_get_stats64         = mlx5e_rep_get_stats,
 696         .ndo_has_offload_stats   = mlx5e_rep_has_offload_stats,
 697         .ndo_get_offload_stats   = mlx5e_rep_get_offload_stats,
 698         .ndo_change_mtu          = mlx5e_rep_change_mtu,
 699         .ndo_change_carrier      = mlx5e_rep_change_carrier,
 700 };
 701
 702 bool mlx5e_eswitch_uplink_rep(const struct net_device *netdev)
 703 {
 704         return netdev->netdev_ops == &mlx5e_netdev_ops &&
 705                mlx5e_is_uplink_rep(netdev_priv(netdev));
 706 }
 707
 708 bool mlx5e_eswitch_vf_rep(const struct net_device *netdev)
 709 {
 710         return netdev->netdev_ops == &mlx5e_netdev_ops_rep;
 711 }
 712
 713 /* One indirect TIR set for outer. Inner not supported in reps. */
 714 #define REP_NUM_INDIR_TIRS MLX5E_NUM_INDIR_TIRS
 715
 716 static int mlx5e_rep_max_nch_limit(struct mlx5_core_dev *mdev)
 717 {
 718         int max_tir_num = 1 << MLX5_CAP_GEN(mdev, log_max_tir);
 719         int num_vports = mlx5_eswitch_get_total_vports(mdev);
 720
 721         return (max_tir_num - mlx5e_get_pf_num_tirs(mdev)
 722                 - (num_vports * REP_NUM_INDIR_TIRS)) / num_vports;
 723 }
 724
 725 static void mlx5e_build_rep_params(struct net_device *netdev)
 726 {
 727         struct mlx5e_priv *priv = netdev_priv(netdev);
 728         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 729         struct mlx5_eswitch_rep *rep = rpriv->rep;
 730         struct mlx5_core_dev *mdev = priv->mdev;
 731         struct mlx5e_params *params;
 732
 733         u8 cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ?
 734                                          MLX5_CQ_PERIOD_MODE_START_FROM_CQE :
 735                                          MLX5_CQ_PERIOD_MODE_START_FROM_EQE;
 736
 737         params = &priv->channels.params;
 738
 739         params->num_channels = MLX5E_REP_PARAMS_DEF_NUM_CHANNELS;
 740         params->hard_mtu    = MLX5E_ETH_HARD_MTU;
 741         params->sw_mtu      = netdev->mtu;
 742
 743         /* SQ */
 744         if (rep->vport == MLX5_VPORT_UPLINK)
 745                 params->log_sq_size = MLX5E_PARAMS_DEFAULT_LOG_SQ_SIZE;
 746         else
 747                 params->log_sq_size = MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE;
 748
 749         /* RQ */
 750         mlx5e_build_rq_params(mdev, params);
 751
 752         /* update XDP supported features */
 753         mlx5e_set_xdp_feature(netdev);
 754
 755         /* CQ moderation params */
 756         params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation);
 757         mlx5e_set_rx_cq_mode_params(params, cq_period_mode);
 758
 759         params->mqprio.num_tc       = 1;
 760         if (rep->vport != MLX5_VPORT_UPLINK)
 761                 params->vlan_strip_disable = true;
 762
 763         mlx5_query_min_inline(mdev, &params->tx_min_inline_mode);
 764 }
 765
 766 static void mlx5e_build_rep_netdev(struct net_device *netdev,
 767                                    struct mlx5_core_dev *mdev)
 768 {
 769         SET_NETDEV_DEV(netdev, mdev->device);
 770         netdev->netdev_ops = &mlx5e_netdev_ops_rep;
 771         eth_hw_addr_random(netdev);
 772         netdev->ethtool_ops = &mlx5e_rep_ethtool_ops;
 773
 774         netdev->watchdog_timeo    = 15 * HZ;
 775
 776 #if IS_ENABLED(CONFIG_MLX5_CLS_ACT)
 777         netdev->hw_features    |= NETIF_F_HW_TC;
 778 #endif
 779         netdev->hw_features    |= NETIF_F_SG;
 780         netdev->hw_features    |= NETIF_F_IP_CSUM;
 781         netdev->hw_features    |= NETIF_F_IPV6_CSUM;
 782         netdev->hw_features    |= NETIF_F_GRO;
 783         netdev->hw_features    |= NETIF_F_TSO;
 784         netdev->hw_features    |= NETIF_F_TSO6;
 785         netdev->hw_features    |= NETIF_F_RXCSUM;
 786
 787         netdev->features |= netdev->hw_features;
 788         netdev->features |= NETIF_F_NETNS_LOCAL;
 789 }
 790
 791 static int mlx5e_init_rep(struct mlx5_core_dev *mdev,
 792                           struct net_device *netdev)
 793 {
 794         struct mlx5e_priv *priv = netdev_priv(netdev);
 795
 796         priv->fs =
 797                 mlx5e_fs_init(priv->profile, mdev,
 798                               !test_bit(MLX5E_STATE_DESTROYING, &priv->state),
 799                               priv->dfs_root);
 800         if (!priv->fs) {
 801                 netdev_err(priv->netdev, "FS allocation failed\n");
 802                 return -ENOMEM;
 803         }
 804
 805         mlx5e_build_rep_params(netdev);
 806         mlx5e_timestamp_init(priv);
 807
 808         return 0;
 809 }
 810
 811 static int mlx5e_init_ul_rep(struct mlx5_core_dev *mdev,
 812                              struct net_device *netdev)
 813 {
 814         struct mlx5e_priv *priv = netdev_priv(netdev);
 815
 816         priv->dfs_root = debugfs_create_dir("nic",
 817                                             mlx5_debugfs_get_dev_root(mdev));
 818
 819         priv->fs = mlx5e_fs_init(priv->profile, mdev,
 820                                  !test_bit(MLX5E_STATE_DESTROYING, &priv->state),
 821                                  priv->dfs_root);
 822         if (!priv->fs) {
 823                 netdev_err(priv->netdev, "FS allocation failed\n");
 824                 debugfs_remove_recursive(priv->dfs_root);
 825                 return -ENOMEM;
 826         }
 827
 828         mlx5e_vxlan_set_netdev_info(priv);
 829         mlx5e_build_rep_params(netdev);
 830         mlx5e_timestamp_init(priv);
 831         return 0;
 832 }
 833
 834 static void mlx5e_cleanup_rep(struct mlx5e_priv *priv)
 835 {
 836         mlx5e_fs_cleanup(priv->fs);
 837         debugfs_remove_recursive(priv->dfs_root);
 838         priv->fs = NULL;
 839 }
 840
 841 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv)
 842 {
 843         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 844         struct mlx5_eswitch_rep *rep = rpriv->rep;
 845         struct ttc_params ttc_params = {};
 846         int err;
 847
 848         mlx5e_fs_set_ns(priv->fs,
 849                         mlx5_get_flow_namespace(priv->mdev,
 850                                                 MLX5_FLOW_NAMESPACE_KERNEL), false);
 851
 852         /* The inner_ttc in the ttc params is intentionally not set */
 853         mlx5e_set_ttc_params(priv->fs, priv->rx_res, &ttc_params, false);
 854
 855         if (rep->vport != MLX5_VPORT_UPLINK)
 856                 /* To give uplik rep TTC a lower level for chaining from root ft */
 857                 ttc_params.ft_attr.level = MLX5E_TTC_FT_LEVEL + 1;
 858
 859         mlx5e_fs_set_ttc(priv->fs, mlx5_create_ttc_table(priv->mdev, &ttc_params), false);
 860         if (IS_ERR(mlx5e_fs_get_ttc(priv->fs, false))) {
 861                 err = PTR_ERR(mlx5e_fs_get_ttc(priv->fs, false));
 862                 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n",
 863                            err);
 864                 return err;
 865         }
 866         return 0;
 867 }
 868
 869 static int mlx5e_create_rep_root_ft(struct mlx5e_priv *priv)
 870 {
 871         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 872         struct mlx5_eswitch_rep *rep = rpriv->rep;
 873         struct mlx5_flow_table_attr ft_attr = {};
 874         struct mlx5_flow_namespace *ns;
 875         int err = 0;
 876
 877         if (rep->vport != MLX5_VPORT_UPLINK) {
 878                 /* non uplik reps will skip any bypass tables and go directly to
 879                  * their own ttc
 880                  */
 881                 rpriv->root_ft = mlx5_get_ttc_flow_table(mlx5e_fs_get_ttc(priv->fs, false));
 882                 return 0;
 883         }
 884
 885         /* uplink root ft will be used to auto chain, to ethtool or ttc tables */
 886         ns = mlx5_get_flow_namespace(priv->mdev, MLX5_FLOW_NAMESPACE_OFFLOADS);
 887         if (!ns) {
 888                 netdev_err(priv->netdev, "Failed to get reps offloads namespace\n");
 889                 return -EOPNOTSUPP;
 890         }
 891
 892         ft_attr.max_fte = 0; /* Empty table, miss rule will always point to next table */
 893         ft_attr.prio = 1;
 894         ft_attr.level = 1;
 895
 896         rpriv->root_ft = mlx5_create_flow_table(ns, &ft_attr);
 897         if (IS_ERR(rpriv->root_ft)) {
 898                 err = PTR_ERR(rpriv->root_ft);
 899                 rpriv->root_ft = NULL;
 900         }
 901
 902         return err;
 903 }
 904
 905 static void mlx5e_destroy_rep_root_ft(struct mlx5e_priv *priv)
 906 {
 907         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 908         struct mlx5_eswitch_rep *rep = rpriv->rep;
 909
 910         if (rep->vport != MLX5_VPORT_UPLINK)
 911                 return;
 912         mlx5_destroy_flow_table(rpriv->root_ft);
 913 }
 914
 915 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv)
 916 {
 917         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 918         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 919         struct mlx5_eswitch_rep *rep = rpriv->rep;
 920         struct mlx5_flow_handle *flow_rule;
 921         struct mlx5_flow_destination dest;
 922
 923         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 924         dest.ft = rpriv->root_ft;
 925
 926         flow_rule = mlx5_eswitch_create_vport_rx_rule(esw, rep->vport, &dest);
 927         if (IS_ERR(flow_rule))
 928                 return PTR_ERR(flow_rule);
 929         rpriv->vport_rx_rule = flow_rule;
 930         return 0;
 931 }
 932
 933 static void rep_vport_rx_rule_destroy(struct mlx5e_priv *priv)
 934 {
 935         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 936
 937         if (!rpriv->vport_rx_rule)
 938                 return;
 939
 940         mlx5_del_flow_rules(rpriv->vport_rx_rule);
 941         rpriv->vport_rx_rule = NULL;
 942 }
 943
 944 int mlx5e_rep_bond_update(struct mlx5e_priv *priv, bool cleanup)
 945 {
 946         rep_vport_rx_rule_destroy(priv);
 947
 948         return cleanup ? 0 : mlx5e_create_rep_vport_rx_rule(priv);
 949 }
 950
 951 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv)
 952 {
 953         struct mlx5_core_dev *mdev = priv->mdev;
 954         int err;
 955
 956         priv->rx_res = mlx5e_rx_res_alloc();
 957         if (!priv->rx_res) {
 958                 err = -ENOMEM;
 959                 goto err_free_fs;
 960         }
 961
 962         mlx5e_fs_init_l2_addr(priv->fs, priv->netdev);
 963
 964         err = mlx5e_open_drop_rq(priv, &priv->drop_rq);
 965         if (err) {
 966                 mlx5_core_err(mdev, "open drop rq failed, %d\n", err);
 967                 return err;
 968         }
 969
 970         err = mlx5e_rx_res_init(priv->rx_res, priv->mdev, 0,
 971                                 priv->max_nch, priv->drop_rq.rqn,
 972                                 &priv->channels.params.packet_merge,
 973                                 priv->channels.params.num_channels);
 974         if (err)
 975                 goto err_close_drop_rq;
 976
 977         err = mlx5e_create_rep_ttc_table(priv);
 978         if (err)
 979                 goto err_destroy_rx_res;
 980
 981         err = mlx5e_create_rep_root_ft(priv);
 982         if (err)
 983                 goto err_destroy_ttc_table;
 984
 985         err = mlx5e_create_rep_vport_rx_rule(priv);
 986         if (err)
 987                 goto err_destroy_root_ft;
 988
 989         mlx5e_ethtool_init_steering(priv->fs);
 990
 991         return 0;
 992
 993 err_destroy_root_ft:
 994         mlx5e_destroy_rep_root_ft(priv);
 995 err_destroy_ttc_table:
 996         mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false));
 997 err_destroy_rx_res:
 998         mlx5e_rx_res_destroy(priv->rx_res);
 999 err_close_drop_rq:
1000         mlx5e_close_drop_rq(&priv->drop_rq);
1001         mlx5e_rx_res_free(priv->rx_res);
1002         priv->rx_res = NULL;
1003 err_free_fs:
1004         mlx5e_fs_cleanup(priv->fs);
1005         priv->fs = NULL;
1006         return err;
1007 }
1008
1009 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv)
1010 {
1011         mlx5e_ethtool_cleanup_steering(priv->fs);
1012         rep_vport_rx_rule_destroy(priv);
1013         mlx5e_destroy_rep_root_ft(priv);
1014         mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false));
1015         mlx5e_rx_res_destroy(priv->rx_res);
1016         mlx5e_close_drop_rq(&priv->drop_rq);
1017         mlx5e_rx_res_free(priv->rx_res);
1018         priv->rx_res = NULL;
1019 }
1020
1021 static void mlx5e_rep_mpesw_work(struct work_struct *work)
1022 {
1023         struct mlx5_rep_uplink_priv *uplink_priv =
1024                 container_of(work, struct mlx5_rep_uplink_priv,
1025                              mpesw_work);
1026         struct mlx5e_rep_priv *rpriv =
1027                 container_of(uplink_priv, struct mlx5e_rep_priv,
1028                              uplink_priv);
1029         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
1030
1031         rep_vport_rx_rule_destroy(priv);
1032         mlx5e_create_rep_vport_rx_rule(priv);
1033 }
1034
1035 static int mlx5e_init_ul_rep_rx(struct mlx5e_priv *priv)
1036 {
1037         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1038         int err;
1039
1040         mlx5e_create_q_counters(priv);
1041         err = mlx5e_init_rep_rx(priv);
1042         if (err)
1043                 goto out;
1044
1045         mlx5e_tc_int_port_init_rep_rx(priv);
1046
1047         INIT_WORK(&rpriv->uplink_priv.mpesw_work, mlx5e_rep_mpesw_work);
1048
1049 out:
1050         return err;
1051 }
1052
1053 static void mlx5e_cleanup_ul_rep_rx(struct mlx5e_priv *priv)
1054 {
1055         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1056
1057         cancel_work_sync(&rpriv->uplink_priv.mpesw_work);
1058         mlx5e_tc_int_port_cleanup_rep_rx(priv);
1059         mlx5e_cleanup_rep_rx(priv);
1060         mlx5e_destroy_q_counters(priv);
1061 }
1062
1063 static int mlx5e_init_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)
1064 {
1065         struct mlx5_rep_uplink_priv *uplink_priv;
1066         struct net_device *netdev;
1067         struct mlx5e_priv *priv;
1068         int err;
1069
1070         netdev = rpriv->netdev;
1071         priv = netdev_priv(netdev);
1072         uplink_priv = &rpriv->uplink_priv;
1073
1074         err = mlx5e_rep_tc_init(rpriv);
1075         if (err)
1076                 return err;
1077
1078         mlx5_init_port_tun_entropy(&uplink_priv->tun_entropy, priv->mdev);
1079
1080         mlx5e_rep_bond_init(rpriv);
1081         err = mlx5e_rep_tc_netdevice_event_register(rpriv);
1082         if (err) {
1083                 mlx5_core_err(priv->mdev, "Failed to register netdev notifier, err: %d\n",
1084                               err);
1085                 goto err_event_reg;
1086         }
1087
1088         return 0;
1089
1090 err_event_reg:
1091         mlx5e_rep_bond_cleanup(rpriv);
1092         mlx5e_rep_tc_cleanup(rpriv);
1093         return err;
1094 }
1095
1096 static void mlx5e_cleanup_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)
1097 {
1098         mlx5e_rep_tc_netdevice_event_unregister(rpriv);
1099         mlx5e_rep_bond_cleanup(rpriv);
1100         mlx5e_rep_tc_cleanup(rpriv);
1101 }
1102
1103 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv)
1104 {
1105         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1106         int err;
1107
1108         err = mlx5e_create_tises(priv);
1109         if (err) {
1110                 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err);
1111                 return err;
1112         }
1113
1114         if (rpriv->rep->vport == MLX5_VPORT_UPLINK) {
1115                 err = mlx5e_init_uplink_rep_tx(rpriv);
1116                 if (err)
1117                         goto err_init_tx;
1118         }
1119
1120         err = mlx5e_tc_ht_init(&rpriv->tc_ht);
1121         if (err)
1122                 goto err_ht_init;
1123
1124         return 0;
1125
1126 err_ht_init:
1127         if (rpriv->rep->vport == MLX5_VPORT_UPLINK)
1128                 mlx5e_cleanup_uplink_rep_tx(rpriv);
1129 err_init_tx:
1130         mlx5e_destroy_tises(priv);
1131         return err;
1132 }
1133
1134 static void mlx5e_cleanup_rep_tx(struct mlx5e_priv *priv)
1135 {
1136         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1137
1138         mlx5e_tc_ht_cleanup(&rpriv->tc_ht);
1139
1140         if (rpriv->rep->vport == MLX5_VPORT_UPLINK)
1141                 mlx5e_cleanup_uplink_rep_tx(rpriv);
1142
1143         mlx5e_destroy_tises(priv);
1144 }
1145
1146 static void mlx5e_rep_enable(struct mlx5e_priv *priv)
1147 {
1148         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1149
1150         mlx5e_set_netdev_mtu_boundaries(priv);
1151         mlx5e_rep_neigh_init(rpriv);
1152 }
1153
1154 static void mlx5e_rep_disable(struct mlx5e_priv *priv)
1155 {
1156         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1157
1158         mlx5e_rep_neigh_cleanup(rpriv);
1159 }
1160
1161 static int mlx5e_update_rep_rx(struct mlx5e_priv *priv)
1162 {
1163         return 0;
1164 }
1165
1166 static int mlx5e_rep_event_mpesw(struct mlx5e_priv *priv)
1167 {
1168         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1169         struct mlx5_eswitch_rep *rep = rpriv->rep;
1170
1171         if (rep->vport != MLX5_VPORT_UPLINK)
1172                 return NOTIFY_DONE;
1173
1174         queue_work(priv->wq, &rpriv->uplink_priv.mpesw_work);
1175
1176         return NOTIFY_OK;
1177 }
1178
1179 static int uplink_rep_async_event(struct notifier_block *nb, unsigned long event, void *data)
1180 {
1181         struct mlx5e_priv *priv = container_of(nb, struct mlx5e_priv, events_nb);
1182
1183         if (event == MLX5_EVENT_TYPE_PORT_CHANGE) {
1184                 struct mlx5_eqe *eqe = data;
1185
1186                 switch (eqe->sub_type) {
1187                 case MLX5_PORT_CHANGE_SUBTYPE_DOWN:
1188                 case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE:
1189                         queue_work(priv->wq, &priv->update_carrier_work);
1190                         break;
1191                 default:
1192                         return NOTIFY_DONE;
1193                 }
1194
1195                 return NOTIFY_OK;
1196         }
1197
1198         if (event == MLX5_DEV_EVENT_PORT_AFFINITY)
1199                 return mlx5e_rep_tc_event_port_affinity(priv);
1200         else if (event == MLX5_DEV_EVENT_MULTIPORT_ESW)
1201                 return mlx5e_rep_event_mpesw(priv);
1202
1203         return NOTIFY_DONE;
1204 }
1205
1206 static void mlx5e_uplink_rep_enable(struct mlx5e_priv *priv)
1207 {
1208         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1209         struct net_device *netdev = priv->netdev;
1210         struct mlx5_core_dev *mdev = priv->mdev;
1211         u16 max_mtu;
1212
1213         mlx5e_ipsec_init(priv);
1214
1215         netdev->min_mtu = ETH_MIN_MTU;
1216         mlx5_query_port_max_mtu(priv->mdev, &max_mtu, 1);
1217         netdev->max_mtu = MLX5E_HW2SW_MTU(&priv->channels.params, max_mtu);
1218         mlx5e_set_dev_port_mtu(priv);
1219
1220         mlx5e_rep_tc_enable(priv);
1221
1222         if (MLX5_CAP_GEN(mdev, uplink_follow))
1223                 mlx5_modify_vport_admin_state(mdev, MLX5_VPORT_STATE_OP_MOD_UPLINK,
1224                                               0, 0, MLX5_VPORT_ADMIN_STATE_AUTO);
1225         mlx5_lag_add_netdev(mdev, netdev);
1226         priv->events_nb.notifier_call = uplink_rep_async_event;
1227         mlx5_notifier_register(mdev, &priv->events_nb);
1228         mlx5e_dcbnl_initialize(priv);
1229         mlx5e_dcbnl_init_app(priv);
1230         mlx5e_rep_neigh_init(rpriv);
1231         mlx5e_rep_bridge_init(priv);
1232
1233         netdev->wanted_features |= NETIF_F_HW_TC;
1234
1235         rtnl_lock();
1236         if (netif_running(netdev))
1237                 mlx5e_open(netdev);
1238         udp_tunnel_nic_reset_ntf(priv->netdev);
1239         netif_device_attach(netdev);
1240         rtnl_unlock();
1241 }
1242
1243 static void mlx5e_uplink_rep_disable(struct mlx5e_priv *priv)
1244 {
1245         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1246         struct mlx5_core_dev *mdev = priv->mdev;
1247
1248         rtnl_lock();
1249         if (netif_running(priv->netdev))
1250                 mlx5e_close(priv->netdev);
1251         netif_device_detach(priv->netdev);
1252         rtnl_unlock();
1253
1254         mlx5e_rep_bridge_cleanup(priv);
1255         mlx5e_rep_neigh_cleanup(rpriv);
1256         mlx5e_dcbnl_delete_app(priv);
1257         mlx5_notifier_unregister(mdev, &priv->events_nb);
1258         mlx5e_rep_tc_disable(priv);
1259         mlx5_lag_remove_netdev(mdev, priv->netdev);
1260         mlx5_vxlan_reset_to_default(mdev->vxlan);
1261
1262         mlx5e_ipsec_cleanup(priv);
1263 }
1264
1265 static MLX5E_DEFINE_STATS_GRP(sw_rep, 0);
1266 static MLX5E_DEFINE_STATS_GRP(vport_rep, MLX5E_NDO_UPDATE_STATS);
1267
1268 /* The stats groups order is opposite to the update_stats() order calls */
1269 static mlx5e_stats_grp_t mlx5e_rep_stats_grps[] = {
1270         &MLX5E_STATS_GRP(sw_rep),
1271         &MLX5E_STATS_GRP(vport_rep),
1272 };
1273
1274 static unsigned int mlx5e_rep_stats_grps_num(struct mlx5e_priv *priv)
1275 {
1276         return ARRAY_SIZE(mlx5e_rep_stats_grps);
1277 }
1278
1279 /* The stats groups order is opposite to the update_stats() order calls */
1280 static mlx5e_stats_grp_t mlx5e_ul_rep_stats_grps[] = {
1281         &MLX5E_STATS_GRP(sw),
1282         &MLX5E_STATS_GRP(qcnt),
1283         &MLX5E_STATS_GRP(vnic_env),
1284         &MLX5E_STATS_GRP(vport),
1285         &MLX5E_STATS_GRP(802_3),
1286         &MLX5E_STATS_GRP(2863),
1287         &MLX5E_STATS_GRP(2819),
1288         &MLX5E_STATS_GRP(phy),
1289         &MLX5E_STATS_GRP(eth_ext),
1290         &MLX5E_STATS_GRP(pcie),
1291         &MLX5E_STATS_GRP(per_prio),
1292         &MLX5E_STATS_GRP(pme),
1293         &MLX5E_STATS_GRP(channels),
1294         &MLX5E_STATS_GRP(per_port_buff_congest),
1295 #ifdef CONFIG_MLX5_EN_IPSEC
1296         &MLX5E_STATS_GRP(ipsec_sw),
1297 #endif
1298         &MLX5E_STATS_GRP(ptp),
1299 };
1300
1301 static unsigned int mlx5e_ul_rep_stats_grps_num(struct mlx5e_priv *priv)
1302 {
1303         return ARRAY_SIZE(mlx5e_ul_rep_stats_grps);
1304 }
1305
1306 static int
1307 mlx5e_rep_vnic_reporter_diagnose(struct devlink_health_reporter *reporter,
1308                                  struct devlink_fmsg *fmsg,
1309                                  struct netlink_ext_ack *extack)
1310 {
1311         struct mlx5e_rep_priv *rpriv = devlink_health_reporter_priv(reporter);
1312         struct mlx5_eswitch_rep *rep = rpriv->rep;
1313
1314         return mlx5_reporter_vnic_diagnose_counters(rep->esw->dev, fmsg,
1315                                                     rep->vport, true);
1316 }
1317
1318 static const struct devlink_health_reporter_ops mlx5_rep_vnic_reporter_ops = {
1319         .name = "vnic",
1320         .diagnose = mlx5e_rep_vnic_reporter_diagnose,
1321 };
1322
1323 static void mlx5e_rep_vnic_reporter_create(struct mlx5e_priv *priv,
1324                                            struct devlink_port *dl_port)
1325 {
1326         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1327         struct devlink_health_reporter *reporter;
1328
1329         reporter = devl_port_health_reporter_create(dl_port,
1330                                                     &mlx5_rep_vnic_reporter_ops,
1331                                                     0, rpriv);
1332         if (IS_ERR(reporter)) {
1333                 mlx5_core_err(priv->mdev,
1334                               "Failed to create representor vnic reporter, err = %ld\n",
1335                               PTR_ERR(reporter));
1336                 return;
1337         }
1338
1339         rpriv->rep_vnic_reporter = reporter;
1340 }
1341
1342 static void mlx5e_rep_vnic_reporter_destroy(struct mlx5e_priv *priv)
1343 {
1344         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1345
1346         if (!IS_ERR_OR_NULL(rpriv->rep_vnic_reporter))
1347                 devl_health_reporter_destroy(rpriv->rep_vnic_reporter);
1348 }
1349
1350 static const struct mlx5e_profile mlx5e_rep_profile = {
1351         .init                   = mlx5e_init_rep,
1352         .cleanup                = mlx5e_cleanup_rep,
1353         .init_rx                = mlx5e_init_rep_rx,
1354         .cleanup_rx             = mlx5e_cleanup_rep_rx,
1355         .init_tx                = mlx5e_init_rep_tx,
1356         .cleanup_tx             = mlx5e_cleanup_rep_tx,
1357         .enable                 = mlx5e_rep_enable,
1358         .disable                = mlx5e_rep_disable,
1359         .update_rx              = mlx5e_update_rep_rx,
1360         .update_stats           = mlx5e_stats_update_ndo_stats,
1361         .rx_handlers            = &mlx5e_rx_handlers_rep,
1362         .max_tc                 = 1,
1363         .stats_grps             = mlx5e_rep_stats_grps,
1364         .stats_grps_num         = mlx5e_rep_stats_grps_num,
1365         .max_nch_limit          = mlx5e_rep_max_nch_limit,
1366 };
1367
1368 static const struct mlx5e_profile mlx5e_uplink_rep_profile = {
1369         .init                   = mlx5e_init_ul_rep,
1370         .cleanup                = mlx5e_cleanup_rep,
1371         .init_rx                = mlx5e_init_ul_rep_rx,
1372         .cleanup_rx             = mlx5e_cleanup_ul_rep_rx,
1373         .init_tx                = mlx5e_init_rep_tx,
1374         .cleanup_tx             = mlx5e_cleanup_rep_tx,
1375         .enable                 = mlx5e_uplink_rep_enable,
1376         .disable                = mlx5e_uplink_rep_disable,
1377         .update_rx              = mlx5e_update_rep_rx,
1378         .update_stats           = mlx5e_stats_update_ndo_stats,
1379         .update_carrier         = mlx5e_update_carrier,
1380         .rx_handlers            = &mlx5e_rx_handlers_rep,
1381         .max_tc                 = MLX5E_MAX_NUM_TC,
1382         .stats_grps             = mlx5e_ul_rep_stats_grps,
1383         .stats_grps_num         = mlx5e_ul_rep_stats_grps_num,
1384 };
1385
1386 /* e-Switch vport representors */
1387 static int
1388 mlx5e_vport_uplink_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1389 {
1390         struct mlx5e_priv *priv = netdev_priv(mlx5_uplink_netdev_get(dev));
1391         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1392
1393         rpriv->netdev = priv->netdev;
1394         return mlx5e_netdev_change_profile(priv, &mlx5e_uplink_rep_profile,
1395                                            rpriv);
1396 }
1397
1398 static void
1399 mlx5e_vport_uplink_rep_unload(struct mlx5e_rep_priv *rpriv)
1400 {
1401         struct net_device *netdev = rpriv->netdev;
1402         struct mlx5e_priv *priv;
1403
1404         priv = netdev_priv(netdev);
1405
1406         mlx5e_netdev_attach_nic_profile(priv);
1407 }
1408
1409 static int
1410 mlx5e_vport_vf_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1411 {
1412         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1413         const struct mlx5e_profile *profile;
1414         struct devlink_port *dl_port;
1415         struct net_device *netdev;
1416         struct mlx5e_priv *priv;
1417         int err;
1418
1419         profile = &mlx5e_rep_profile;
1420         netdev = mlx5e_create_netdev(dev, profile);
1421         if (!netdev) {
1422                 mlx5_core_warn(dev,
1423                                "Failed to create representor netdev for vport %d\n",
1424                                rep->vport);
1425                 return -EINVAL;
1426         }
1427
1428         mlx5e_build_rep_netdev(netdev, dev);
1429         rpriv->netdev = netdev;
1430
1431         priv = netdev_priv(netdev);
1432         priv->profile = profile;
1433         priv->ppriv = rpriv;
1434         err = profile->init(dev, netdev);
1435         if (err) {
1436                 netdev_warn(netdev, "rep profile init failed, %d\n", err);
1437                 goto err_destroy_netdev;
1438         }
1439
1440         err = mlx5e_attach_netdev(netdev_priv(netdev));
1441         if (err) {
1442                 netdev_warn(netdev,
1443                             "Failed to attach representor netdev for vport %d\n",
1444                             rep->vport);
1445                 goto err_cleanup_profile;
1446         }
1447
1448         dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch,
1449                                                  rpriv->rep->vport);
1450         if (dl_port) {
1451                 SET_NETDEV_DEVLINK_PORT(netdev, dl_port);
1452                 mlx5e_rep_vnic_reporter_create(priv, dl_port);
1453         }
1454
1455         err = register_netdev(netdev);
1456         if (err) {
1457                 netdev_warn(netdev,
1458                             "Failed to register representor netdev for vport %d\n",
1459                             rep->vport);
1460                 goto err_detach_netdev;
1461         }
1462
1463         return 0;
1464
1465 err_detach_netdev:
1466         mlx5e_rep_vnic_reporter_destroy(priv);
1467         mlx5e_detach_netdev(netdev_priv(netdev));
1468 err_cleanup_profile:
1469         priv->profile->cleanup(priv);
1470
1471 err_destroy_netdev:
1472         mlx5e_destroy_netdev(netdev_priv(netdev));
1473         return err;
1474 }
1475
1476 static int
1477 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1478 {
1479         struct mlx5e_rep_priv *rpriv;
1480         int err;
1481
1482         rpriv = kvzalloc(sizeof(*rpriv), GFP_KERNEL);
1483         if (!rpriv)
1484                 return -ENOMEM;
1485
1486         /* rpriv->rep to be looked up when profile->init() is called */
1487         rpriv->rep = rep;
1488         rep->rep_data[REP_ETH].priv = rpriv;
1489         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1490
1491         if (rep->vport == MLX5_VPORT_UPLINK)
1492                 err = mlx5e_vport_uplink_rep_load(dev, rep);
1493         else
1494                 err = mlx5e_vport_vf_rep_load(dev, rep);
1495
1496         if (err)
1497                 kvfree(rpriv);
1498
1499         return err;
1500 }
1501
1502 static void
1503 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep)
1504 {
1505         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1506         struct net_device *netdev = rpriv->netdev;
1507         struct mlx5e_priv *priv = netdev_priv(netdev);
1508         void *ppriv = priv->ppriv;
1509
1510         if (rep->vport == MLX5_VPORT_UPLINK) {
1511                 mlx5e_vport_uplink_rep_unload(rpriv);
1512                 goto free_ppriv;
1513         }
1514
1515         unregister_netdev(netdev);
1516         mlx5e_rep_vnic_reporter_destroy(priv);
1517         mlx5e_detach_netdev(priv);
1518         priv->profile->cleanup(priv);
1519         mlx5e_destroy_netdev(priv);
1520 free_ppriv:
1521         kvfree(ppriv); /* mlx5e_rep_priv */
1522 }
1523
1524 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep)
1525 {
1526         struct mlx5e_rep_priv *rpriv;
1527
1528         rpriv = mlx5e_rep_to_rep_priv(rep);
1529
1530         return rpriv->netdev;
1531 }
1532
1533 static void mlx5e_vport_rep_event_unpair(struct mlx5_eswitch_rep *rep)
1534 {
1535         struct mlx5e_rep_priv *rpriv;
1536         struct mlx5e_rep_sq *rep_sq;
1537
1538         rpriv = mlx5e_rep_to_rep_priv(rep);
1539         list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) {
1540                 if (!rep_sq->send_to_vport_rule_peer)
1541                         continue;
1542                 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule_peer);
1543                 rep_sq->send_to_vport_rule_peer = NULL;
1544         }
1545 }
1546
1547 static int mlx5e_vport_rep_event_pair(struct mlx5_eswitch *esw,
1548                                       struct mlx5_eswitch_rep *rep,
1549                                       struct mlx5_eswitch *peer_esw)
1550 {
1551         struct mlx5_flow_handle *flow_rule;
1552         struct mlx5e_rep_priv *rpriv;
1553         struct mlx5e_rep_sq *rep_sq;
1554
1555         rpriv = mlx5e_rep_to_rep_priv(rep);
1556         list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) {
1557                 if (rep_sq->send_to_vport_rule_peer)
1558                         continue;
1559                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw, rep, rep_sq->sqn);
1560                 if (IS_ERR(flow_rule))
1561                         goto err_out;
1562                 rep_sq->send_to_vport_rule_peer = flow_rule;
1563         }
1564
1565         return 0;
1566 err_out:
1567         mlx5e_vport_rep_event_unpair(rep);
1568         return PTR_ERR(flow_rule);
1569 }
1570
1571 static int mlx5e_vport_rep_event(struct mlx5_eswitch *esw,
1572                                  struct mlx5_eswitch_rep *rep,
1573                                  enum mlx5_switchdev_event event,
1574                                  void *data)
1575 {
1576         int err = 0;
1577
1578         if (event == MLX5_SWITCHDEV_EVENT_PAIR)
1579                 err = mlx5e_vport_rep_event_pair(esw, rep, data);
1580         else if (event == MLX5_SWITCHDEV_EVENT_UNPAIR)
1581                 mlx5e_vport_rep_event_unpair(rep);
1582
1583         return err;
1584 }
1585
1586 static const struct mlx5_eswitch_rep_ops rep_ops = {
1587         .load = mlx5e_vport_rep_load,
1588         .unload = mlx5e_vport_rep_unload,
1589         .get_proto_dev = mlx5e_vport_rep_get_proto_dev,
1590         .event = mlx5e_vport_rep_event,
1591 };
1592
1593 static int mlx5e_rep_probe(struct auxiliary_device *adev,
1594                            const struct auxiliary_device_id *id)
1595 {
1596         struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
1597         struct mlx5_core_dev *mdev = edev->mdev;
1598         struct mlx5_eswitch *esw;
1599
1600         esw = mdev->priv.eswitch;
1601         mlx5_eswitch_register_vport_reps(esw, &rep_ops, REP_ETH);
1602         return 0;
1603 }
1604
1605 static void mlx5e_rep_remove(struct auxiliary_device *adev)
1606 {
1607         struct mlx5_adev *vdev = container_of(adev, struct mlx5_adev, adev);
1608         struct mlx5_core_dev *mdev = vdev->mdev;
1609         struct mlx5_eswitch *esw;
1610
1611         esw = mdev->priv.eswitch;
1612         mlx5_eswitch_unregister_vport_reps(esw, REP_ETH);
1613 }
1614
1615 static const struct auxiliary_device_id mlx5e_rep_id_table[] = {
1616         { .name = MLX5_ADEV_NAME ".eth-rep", },
1617         {},
1618 };
1619
1620 MODULE_DEVICE_TABLE(auxiliary, mlx5e_rep_id_table);
1621
1622 static struct auxiliary_driver mlx5e_rep_driver = {
1623         .name = "eth-rep",
1624         .probe = mlx5e_rep_probe,
1625         .remove = mlx5e_rep_remove,
1626         .id_table = mlx5e_rep_id_table,
1627 };
1628
1629 int mlx5e_rep_init(void)
1630 {
1631         return auxiliary_driver_register(&mlx5e_rep_driver);
1632 }
1633
1634 void mlx5e_rep_cleanup(void)
1635 {
1636         auxiliary_driver_unregister(&mlx5e_rep_driver);
1637 }