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_sq_peer *sq_peer;
 378         struct mlx5e_rep_priv *rpriv;
 379         unsigned long i;
 380
 381         if (esw->mode != MLX5_ESWITCH_OFFLOADS)
 382                 return;
 383
 384         rpriv = mlx5e_rep_to_rep_priv(rep);
 385         list_for_each_entry_safe(rep_sq, tmp, &rpriv->vport_sqs_list, list) {
 386                 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule);
 387                 xa_for_each(&rep_sq->sq_peer, i, sq_peer) {
 388                         if (sq_peer->rule)
 389                                 mlx5_eswitch_del_send_to_vport_rule(sq_peer->rule);
 390
 391                         xa_erase(&rep_sq->sq_peer, i);
 392                         kfree(sq_peer);
 393                 }
 394
 395                 xa_destroy(&rep_sq->sq_peer);
 396                 list_del(&rep_sq->list);
 397                 kfree(rep_sq);
 398         }
 399 }
 400
 401 static int mlx5e_sqs2vport_start(struct mlx5_eswitch *esw,
 402                                  struct mlx5_eswitch_rep *rep,
 403                                  u32 *sqns_array, int sqns_num)
 404 {
 405         struct mlx5_eswitch *peer_esw = NULL;
 406         struct mlx5_flow_handle *flow_rule;
 407         struct mlx5e_rep_sq_peer *sq_peer;
 408         struct mlx5e_rep_priv *rpriv;
 409         struct mlx5e_rep_sq *rep_sq;
 410         int err;
 411         int i;
 412
 413         if (esw->mode != MLX5_ESWITCH_OFFLOADS)
 414                 return 0;
 415
 416         rpriv = mlx5e_rep_to_rep_priv(rep);
 417         if (mlx5_devcom_is_paired(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS))
 418                 peer_esw = mlx5_devcom_get_peer_data(esw->dev->priv.devcom,
 419                                                      MLX5_DEVCOM_ESW_OFFLOADS);
 420
 421         for (i = 0; i < sqns_num; i++) {
 422                 rep_sq = kzalloc(sizeof(*rep_sq), GFP_KERNEL);
 423                 if (!rep_sq) {
 424                         err = -ENOMEM;
 425                         goto out_err;
 426                 }
 427                 xa_init(&rep_sq->sq_peer);
 428
 429                 /* Add re-inject rule to the PF/representor sqs */
 430                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw, esw, rep,
 431                                                                 sqns_array[i]);
 432                 if (IS_ERR(flow_rule)) {
 433                         err = PTR_ERR(flow_rule);
 434                         kfree(rep_sq);
 435                         goto out_err;
 436                 }
 437                 rep_sq->send_to_vport_rule = flow_rule;
 438                 rep_sq->sqn = sqns_array[i];
 439
 440                 if (peer_esw) {
 441                         int peer_rule_idx = mlx5_get_dev_index(peer_esw->dev);
 442
 443                         sq_peer = kzalloc(sizeof(*sq_peer), GFP_KERNEL);
 444                         if (!sq_peer) {
 445                                 err = -ENOMEM;
 446                                 goto out_sq_peer_err;
 447                         }
 448
 449                         flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw,
 450                                                                         rep, sqns_array[i]);
 451                         if (IS_ERR(flow_rule)) {
 452                                 err = PTR_ERR(flow_rule);
 453                                 goto out_flow_rule_err;
 454                         }
 455
 456                         sq_peer->rule = flow_rule;
 457                         sq_peer->peer = peer_esw;
 458                         err = xa_insert(&rep_sq->sq_peer, peer_rule_idx, sq_peer, GFP_KERNEL);
 459                         if (err)
 460                                 goto out_xa_err;
 461                 }
 462
 463                 list_add(&rep_sq->list, &rpriv->vport_sqs_list);
 464         }
 465
 466         if (peer_esw)
 467                 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS);
 468
 469         return 0;
 470
 471 out_xa_err:
 472         mlx5_eswitch_del_send_to_vport_rule(flow_rule);
 473 out_flow_rule_err:
 474         kfree(sq_peer);
 475 out_sq_peer_err:
 476         mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule);
 477         xa_destroy(&rep_sq->sq_peer);
 478         kfree(rep_sq);
 479 out_err:
 480         mlx5e_sqs2vport_stop(esw, rep);
 481
 482         if (peer_esw)
 483                 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS);
 484
 485         return err;
 486 }
 487
 488 static int
 489 mlx5e_add_sqs_fwd_rules(struct mlx5e_priv *priv)
 490 {
 491         int sqs_per_channel = mlx5e_get_dcb_num_tc(&priv->channels.params);
 492         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 493         bool is_uplink_rep = mlx5e_is_uplink_rep(priv);
 494         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 495         struct mlx5_eswitch_rep *rep = rpriv->rep;
 496         int n, tc, nch, num_sqs = 0;
 497         struct mlx5e_channel *c;
 498         int err = -ENOMEM;
 499         bool ptp_sq;
 500         u32 *sqs;
 501
 502         ptp_sq = !!(priv->channels.ptp &&
 503                     MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_TX_PORT_TS));
 504         nch = priv->channels.num + ptp_sq;
 505         /* +2 for xdpsqs, they don't exist on the ptp channel but will not be
 506          * counted for by num_sqs.
 507          */
 508         if (is_uplink_rep)
 509                 sqs_per_channel += 2;
 510
 511         sqs = kvcalloc(nch * sqs_per_channel, sizeof(*sqs), GFP_KERNEL);
 512         if (!sqs)
 513                 goto out;
 514
 515         for (n = 0; n < priv->channels.num; n++) {
 516                 c = priv->channels.c[n];
 517                 for (tc = 0; tc < c->num_tc; tc++)
 518                         sqs[num_sqs++] = c->sq[tc].sqn;
 519
 520                 if (is_uplink_rep) {
 521                         if (c->xdp)
 522                                 sqs[num_sqs++] = c->rq_xdpsq.sqn;
 523
 524                         sqs[num_sqs++] = c->xdpsq.sqn;
 525                 }
 526         }
 527         if (ptp_sq) {
 528                 struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
 529
 530                 for (tc = 0; tc < ptp_ch->num_tc; tc++)
 531                         sqs[num_sqs++] = ptp_ch->ptpsq[tc].txqsq.sqn;
 532         }
 533
 534         err = mlx5e_sqs2vport_start(esw, rep, sqs, num_sqs);
 535         kvfree(sqs);
 536
 537 out:
 538         if (err)
 539                 netdev_warn(priv->netdev, "Failed to add SQs FWD rules %d\n", err);
 540         return err;
 541 }
 542
 543 static void
 544 mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv)
 545 {
 546         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 547         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 548         struct mlx5_eswitch_rep *rep = rpriv->rep;
 549
 550         mlx5e_sqs2vport_stop(esw, rep);
 551 }
 552
 553 static int
 554 mlx5e_rep_add_meta_tunnel_rule(struct mlx5e_priv *priv)
 555 {
 556         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 557         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 558         struct mlx5_eswitch_rep *rep = rpriv->rep;
 559         struct mlx5_flow_handle *flow_rule;
 560         struct mlx5_flow_group *g;
 561
 562         g = esw->fdb_table.offloads.send_to_vport_meta_grp;
 563         if (!g)
 564                 return 0;
 565
 566         flow_rule = mlx5_eswitch_add_send_to_vport_meta_rule(esw, rep->vport);
 567         if (IS_ERR(flow_rule))
 568                 return PTR_ERR(flow_rule);
 569
 570         rpriv->send_to_vport_meta_rule = flow_rule;
 571
 572         return 0;
 573 }
 574
 575 static void
 576 mlx5e_rep_del_meta_tunnel_rule(struct mlx5e_priv *priv)
 577 {
 578         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 579
 580         if (rpriv->send_to_vport_meta_rule)
 581                 mlx5_eswitch_del_send_to_vport_meta_rule(rpriv->send_to_vport_meta_rule);
 582 }
 583
 584 void mlx5e_rep_activate_channels(struct mlx5e_priv *priv)
 585 {
 586         mlx5e_add_sqs_fwd_rules(priv);
 587         mlx5e_rep_add_meta_tunnel_rule(priv);
 588 }
 589
 590 void mlx5e_rep_deactivate_channels(struct mlx5e_priv *priv)
 591 {
 592         mlx5e_rep_del_meta_tunnel_rule(priv);
 593         mlx5e_remove_sqs_fwd_rules(priv);
 594 }
 595
 596 static int mlx5e_rep_open(struct net_device *dev)
 597 {
 598         struct mlx5e_priv *priv = netdev_priv(dev);
 599         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 600         struct mlx5_eswitch_rep *rep = rpriv->rep;
 601         int err;
 602
 603         mutex_lock(&priv->state_lock);
 604         err = mlx5e_open_locked(dev);
 605         if (err)
 606                 goto unlock;
 607
 608         if (!mlx5_modify_vport_admin_state(priv->mdev,
 609                                            MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 610                                            rep->vport, 1,
 611                                            MLX5_VPORT_ADMIN_STATE_UP))
 612                 netif_carrier_on(dev);
 613
 614 unlock:
 615         mutex_unlock(&priv->state_lock);
 616         return err;
 617 }
 618
 619 static int mlx5e_rep_close(struct net_device *dev)
 620 {
 621         struct mlx5e_priv *priv = netdev_priv(dev);
 622         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 623         struct mlx5_eswitch_rep *rep = rpriv->rep;
 624         int ret;
 625
 626         mutex_lock(&priv->state_lock);
 627         mlx5_modify_vport_admin_state(priv->mdev,
 628                                       MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 629                                       rep->vport, 1,
 630                                       MLX5_VPORT_ADMIN_STATE_DOWN);
 631         ret = mlx5e_close_locked(dev);
 632         mutex_unlock(&priv->state_lock);
 633         return ret;
 634 }
 635
 636 bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv)
 637 {
 638         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 639         struct mlx5_eswitch_rep *rep;
 640
 641         if (!MLX5_ESWITCH_MANAGER(priv->mdev))
 642                 return false;
 643
 644         if (!rpriv) /* non vport rep mlx5e instances don't use this field */
 645                 return false;
 646
 647         rep = rpriv->rep;
 648         return (rep->vport == MLX5_VPORT_UPLINK);
 649 }
 650
 651 bool mlx5e_rep_has_offload_stats(const struct net_device *dev, int attr_id)
 652 {
 653         switch (attr_id) {
 654         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 655                         return true;
 656         }
 657
 658         return false;
 659 }
 660
 661 static int
 662 mlx5e_get_sw_stats64(const struct net_device *dev,
 663                      struct rtnl_link_stats64 *stats)
 664 {
 665         struct mlx5e_priv *priv = netdev_priv(dev);
 666
 667         mlx5e_fold_sw_stats64(priv, stats);
 668         return 0;
 669 }
 670
 671 int mlx5e_rep_get_offload_stats(int attr_id, const struct net_device *dev,
 672                                 void *sp)
 673 {
 674         switch (attr_id) {
 675         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 676                 return mlx5e_get_sw_stats64(dev, sp);
 677         }
 678
 679         return -EINVAL;
 680 }
 681
 682 static void
 683 mlx5e_rep_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats)
 684 {
 685         struct mlx5e_priv *priv = netdev_priv(dev);
 686
 687         /* update HW stats in background for next time */
 688         mlx5e_queue_update_stats(priv);
 689         memcpy(stats, &priv->stats.vf_vport, sizeof(*stats));
 690 }
 691
 692 static int mlx5e_rep_change_mtu(struct net_device *netdev, int new_mtu)
 693 {
 694         return mlx5e_change_mtu(netdev, new_mtu, NULL);
 695 }
 696
 697 static int mlx5e_rep_change_carrier(struct net_device *dev, bool new_carrier)
 698 {
 699         struct mlx5e_priv *priv = netdev_priv(dev);
 700         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 701         struct mlx5_eswitch_rep *rep = rpriv->rep;
 702         int err;
 703
 704         if (new_carrier) {
 705                 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 706                                                     rep->vport, 1, MLX5_VPORT_ADMIN_STATE_UP);
 707                 if (err)
 708                         return err;
 709                 netif_carrier_on(dev);
 710         } else {
 711                 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 712                                                     rep->vport, 1, MLX5_VPORT_ADMIN_STATE_DOWN);
 713                 if (err)
 714                         return err;
 715                 netif_carrier_off(dev);
 716         }
 717         return 0;
 718 }
 719
 720 static const struct net_device_ops mlx5e_netdev_ops_rep = {
 721         .ndo_open                = mlx5e_rep_open,
 722         .ndo_stop                = mlx5e_rep_close,
 723         .ndo_start_xmit          = mlx5e_xmit,
 724         .ndo_setup_tc            = mlx5e_rep_setup_tc,
 725         .ndo_get_stats64         = mlx5e_rep_get_stats,
 726         .ndo_has_offload_stats   = mlx5e_rep_has_offload_stats,
 727         .ndo_get_offload_stats   = mlx5e_rep_get_offload_stats,
 728         .ndo_change_mtu          = mlx5e_rep_change_mtu,
 729         .ndo_change_carrier      = mlx5e_rep_change_carrier,
 730 };
 731
 732 bool mlx5e_eswitch_uplink_rep(const struct net_device *netdev)
 733 {
 734         return netdev->netdev_ops == &mlx5e_netdev_ops &&
 735                mlx5e_is_uplink_rep(netdev_priv(netdev));
 736 }
 737
 738 bool mlx5e_eswitch_vf_rep(const struct net_device *netdev)
 739 {
 740         return netdev->netdev_ops == &mlx5e_netdev_ops_rep;
 741 }
 742
 743 /* One indirect TIR set for outer. Inner not supported in reps. */
 744 #define REP_NUM_INDIR_TIRS MLX5E_NUM_INDIR_TIRS
 745
 746 static int mlx5e_rep_max_nch_limit(struct mlx5_core_dev *mdev)
 747 {
 748         int max_tir_num = 1 << MLX5_CAP_GEN(mdev, log_max_tir);
 749         int num_vports = mlx5_eswitch_get_total_vports(mdev);
 750
 751         return (max_tir_num - mlx5e_get_pf_num_tirs(mdev)
 752                 - (num_vports * REP_NUM_INDIR_TIRS)) / num_vports;
 753 }
 754
 755 static void mlx5e_build_rep_params(struct net_device *netdev)
 756 {
 757         struct mlx5e_priv *priv = netdev_priv(netdev);
 758         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 759         struct mlx5_eswitch_rep *rep = rpriv->rep;
 760         struct mlx5_core_dev *mdev = priv->mdev;
 761         struct mlx5e_params *params;
 762
 763         u8 cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ?
 764                                          MLX5_CQ_PERIOD_MODE_START_FROM_CQE :
 765                                          MLX5_CQ_PERIOD_MODE_START_FROM_EQE;
 766
 767         params = &priv->channels.params;
 768
 769         params->num_channels = MLX5E_REP_PARAMS_DEF_NUM_CHANNELS;
 770         params->hard_mtu    = MLX5E_ETH_HARD_MTU;
 771         params->sw_mtu      = netdev->mtu;
 772
 773         /* SQ */
 774         if (rep->vport == MLX5_VPORT_UPLINK)
 775                 params->log_sq_size = MLX5E_PARAMS_DEFAULT_LOG_SQ_SIZE;
 776         else
 777                 params->log_sq_size = MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE;
 778
 779         /* RQ */
 780         mlx5e_build_rq_params(mdev, params);
 781
 782         /* update XDP supported features */
 783         mlx5e_set_xdp_feature(netdev);
 784
 785         /* CQ moderation params */
 786         params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation);
 787         mlx5e_set_rx_cq_mode_params(params, cq_period_mode);
 788
 789         params->mqprio.num_tc       = 1;
 790         if (rep->vport != MLX5_VPORT_UPLINK)
 791                 params->vlan_strip_disable = true;
 792
 793         mlx5_query_min_inline(mdev, &params->tx_min_inline_mode);
 794 }
 795
 796 static void mlx5e_build_rep_netdev(struct net_device *netdev,
 797                                    struct mlx5_core_dev *mdev)
 798 {
 799         SET_NETDEV_DEV(netdev, mdev->device);
 800         netdev->netdev_ops = &mlx5e_netdev_ops_rep;
 801         eth_hw_addr_random(netdev);
 802         netdev->ethtool_ops = &mlx5e_rep_ethtool_ops;
 803
 804         netdev->watchdog_timeo    = 15 * HZ;
 805
 806 #if IS_ENABLED(CONFIG_MLX5_CLS_ACT)
 807         netdev->hw_features    |= NETIF_F_HW_TC;
 808 #endif
 809         netdev->hw_features    |= NETIF_F_SG;
 810         netdev->hw_features    |= NETIF_F_IP_CSUM;
 811         netdev->hw_features    |= NETIF_F_IPV6_CSUM;
 812         netdev->hw_features    |= NETIF_F_GRO;
 813         netdev->hw_features    |= NETIF_F_TSO;
 814         netdev->hw_features    |= NETIF_F_TSO6;
 815         netdev->hw_features    |= NETIF_F_RXCSUM;
 816
 817         netdev->features |= netdev->hw_features;
 818         netdev->features |= NETIF_F_NETNS_LOCAL;
 819 }
 820
 821 static int mlx5e_init_rep(struct mlx5_core_dev *mdev,
 822                           struct net_device *netdev)
 823 {
 824         struct mlx5e_priv *priv = netdev_priv(netdev);
 825
 826         priv->fs =
 827                 mlx5e_fs_init(priv->profile, mdev,
 828                               !test_bit(MLX5E_STATE_DESTROYING, &priv->state),
 829                               priv->dfs_root);
 830         if (!priv->fs) {
 831                 netdev_err(priv->netdev, "FS allocation failed\n");
 832                 return -ENOMEM;
 833         }
 834
 835         mlx5e_build_rep_params(netdev);
 836         mlx5e_timestamp_init(priv);
 837
 838         return 0;
 839 }
 840
 841 static int mlx5e_init_ul_rep(struct mlx5_core_dev *mdev,
 842                              struct net_device *netdev)
 843 {
 844         struct mlx5e_priv *priv = netdev_priv(netdev);
 845
 846         priv->dfs_root = debugfs_create_dir("nic",
 847                                             mlx5_debugfs_get_dev_root(mdev));
 848
 849         priv->fs = mlx5e_fs_init(priv->profile, mdev,
 850                                  !test_bit(MLX5E_STATE_DESTROYING, &priv->state),
 851                                  priv->dfs_root);
 852         if (!priv->fs) {
 853                 netdev_err(priv->netdev, "FS allocation failed\n");
 854                 debugfs_remove_recursive(priv->dfs_root);
 855                 return -ENOMEM;
 856         }
 857
 858         mlx5e_vxlan_set_netdev_info(priv);
 859         mlx5e_build_rep_params(netdev);
 860         mlx5e_timestamp_init(priv);
 861         return 0;
 862 }
 863
 864 static void mlx5e_cleanup_rep(struct mlx5e_priv *priv)
 865 {
 866         mlx5e_fs_cleanup(priv->fs);
 867         debugfs_remove_recursive(priv->dfs_root);
 868         priv->fs = NULL;
 869 }
 870
 871 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv)
 872 {
 873         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 874         struct mlx5_eswitch_rep *rep = rpriv->rep;
 875         struct ttc_params ttc_params = {};
 876         int err;
 877
 878         mlx5e_fs_set_ns(priv->fs,
 879                         mlx5_get_flow_namespace(priv->mdev,
 880                                                 MLX5_FLOW_NAMESPACE_KERNEL), false);
 881
 882         /* The inner_ttc in the ttc params is intentionally not set */
 883         mlx5e_set_ttc_params(priv->fs, priv->rx_res, &ttc_params, false);
 884
 885         if (rep->vport != MLX5_VPORT_UPLINK)
 886                 /* To give uplik rep TTC a lower level for chaining from root ft */
 887                 ttc_params.ft_attr.level = MLX5E_TTC_FT_LEVEL + 1;
 888
 889         mlx5e_fs_set_ttc(priv->fs, mlx5_create_ttc_table(priv->mdev, &ttc_params), false);
 890         if (IS_ERR(mlx5e_fs_get_ttc(priv->fs, false))) {
 891                 err = PTR_ERR(mlx5e_fs_get_ttc(priv->fs, false));
 892                 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n",
 893                            err);
 894                 return err;
 895         }
 896         return 0;
 897 }
 898
 899 static int mlx5e_create_rep_root_ft(struct mlx5e_priv *priv)
 900 {
 901         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 902         struct mlx5_eswitch_rep *rep = rpriv->rep;
 903         struct mlx5_flow_table_attr ft_attr = {};
 904         struct mlx5_flow_namespace *ns;
 905         int err = 0;
 906
 907         if (rep->vport != MLX5_VPORT_UPLINK) {
 908                 /* non uplik reps will skip any bypass tables and go directly to
 909                  * their own ttc
 910                  */
 911                 rpriv->root_ft = mlx5_get_ttc_flow_table(mlx5e_fs_get_ttc(priv->fs, false));
 912                 return 0;
 913         }
 914
 915         /* uplink root ft will be used to auto chain, to ethtool or ttc tables */
 916         ns = mlx5_get_flow_namespace(priv->mdev, MLX5_FLOW_NAMESPACE_OFFLOADS);
 917         if (!ns) {
 918                 netdev_err(priv->netdev, "Failed to get reps offloads namespace\n");
 919                 return -EOPNOTSUPP;
 920         }
 921
 922         ft_attr.max_fte = 0; /* Empty table, miss rule will always point to next table */
 923         ft_attr.prio = 1;
 924         ft_attr.level = 1;
 925
 926         rpriv->root_ft = mlx5_create_flow_table(ns, &ft_attr);
 927         if (IS_ERR(rpriv->root_ft)) {
 928                 err = PTR_ERR(rpriv->root_ft);
 929                 rpriv->root_ft = NULL;
 930         }
 931
 932         return err;
 933 }
 934
 935 static void mlx5e_destroy_rep_root_ft(struct mlx5e_priv *priv)
 936 {
 937         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 938         struct mlx5_eswitch_rep *rep = rpriv->rep;
 939
 940         if (rep->vport != MLX5_VPORT_UPLINK)
 941                 return;
 942         mlx5_destroy_flow_table(rpriv->root_ft);
 943 }
 944
 945 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv)
 946 {
 947         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 948         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 949         struct mlx5_eswitch_rep *rep = rpriv->rep;
 950         struct mlx5_flow_handle *flow_rule;
 951         struct mlx5_flow_destination dest;
 952
 953         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 954         dest.ft = rpriv->root_ft;
 955
 956         flow_rule = mlx5_eswitch_create_vport_rx_rule(esw, rep->vport, &dest);
 957         if (IS_ERR(flow_rule))
 958                 return PTR_ERR(flow_rule);
 959         rpriv->vport_rx_rule = flow_rule;
 960         return 0;
 961 }
 962
 963 static void rep_vport_rx_rule_destroy(struct mlx5e_priv *priv)
 964 {
 965         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 966
 967         if (!rpriv->vport_rx_rule)
 968                 return;
 969
 970         mlx5_del_flow_rules(rpriv->vport_rx_rule);
 971         rpriv->vport_rx_rule = NULL;
 972 }
 973
 974 int mlx5e_rep_bond_update(struct mlx5e_priv *priv, bool cleanup)
 975 {
 976         rep_vport_rx_rule_destroy(priv);
 977
 978         return cleanup ? 0 : mlx5e_create_rep_vport_rx_rule(priv);
 979 }
 980
 981 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv)
 982 {
 983         struct mlx5_core_dev *mdev = priv->mdev;
 984         int err;
 985
 986         priv->rx_res = mlx5e_rx_res_alloc();
 987         if (!priv->rx_res) {
 988                 err = -ENOMEM;
 989                 goto err_free_fs;
 990         }
 991
 992         mlx5e_fs_init_l2_addr(priv->fs, priv->netdev);
 993
 994         err = mlx5e_open_drop_rq(priv, &priv->drop_rq);
 995         if (err) {
 996                 mlx5_core_err(mdev, "open drop rq failed, %d\n", err);
 997                 return err;
 998         }
 999
1000         err = mlx5e_rx_res_init(priv->rx_res, priv->mdev, 0,
1001                                 priv->max_nch, priv->drop_rq.rqn,
1002                                 &priv->channels.params.packet_merge,
1003                                 priv->channels.params.num_channels);
1004         if (err)
1005                 goto err_close_drop_rq;
1006
1007         err = mlx5e_create_rep_ttc_table(priv);
1008         if (err)
1009                 goto err_destroy_rx_res;
1010
1011         err = mlx5e_create_rep_root_ft(priv);
1012         if (err)
1013                 goto err_destroy_ttc_table;
1014
1015         err = mlx5e_create_rep_vport_rx_rule(priv);
1016         if (err)
1017                 goto err_destroy_root_ft;
1018
1019         mlx5e_ethtool_init_steering(priv->fs);
1020
1021         return 0;
1022
1023 err_destroy_root_ft:
1024         mlx5e_destroy_rep_root_ft(priv);
1025 err_destroy_ttc_table:
1026         mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false));
1027 err_destroy_rx_res:
1028         mlx5e_rx_res_destroy(priv->rx_res);
1029 err_close_drop_rq:
1030         mlx5e_close_drop_rq(&priv->drop_rq);
1031         mlx5e_rx_res_free(priv->rx_res);
1032         priv->rx_res = NULL;
1033 err_free_fs:
1034         mlx5e_fs_cleanup(priv->fs);
1035         priv->fs = NULL;
1036         return err;
1037 }
1038
1039 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv)
1040 {
1041         mlx5e_ethtool_cleanup_steering(priv->fs);
1042         rep_vport_rx_rule_destroy(priv);
1043         mlx5e_destroy_rep_root_ft(priv);
1044         mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false));
1045         mlx5e_rx_res_destroy(priv->rx_res);
1046         mlx5e_close_drop_rq(&priv->drop_rq);
1047         mlx5e_rx_res_free(priv->rx_res);
1048         priv->rx_res = NULL;
1049 }
1050
1051 static void mlx5e_rep_mpesw_work(struct work_struct *work)
1052 {
1053         struct mlx5_rep_uplink_priv *uplink_priv =
1054                 container_of(work, struct mlx5_rep_uplink_priv,
1055                              mpesw_work);
1056         struct mlx5e_rep_priv *rpriv =
1057                 container_of(uplink_priv, struct mlx5e_rep_priv,
1058                              uplink_priv);
1059         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
1060
1061         rep_vport_rx_rule_destroy(priv);
1062         mlx5e_create_rep_vport_rx_rule(priv);
1063 }
1064
1065 static int mlx5e_init_ul_rep_rx(struct mlx5e_priv *priv)
1066 {
1067         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1068         int err;
1069
1070         mlx5e_create_q_counters(priv);
1071         err = mlx5e_init_rep_rx(priv);
1072         if (err)
1073                 goto out;
1074
1075         mlx5e_tc_int_port_init_rep_rx(priv);
1076
1077         INIT_WORK(&rpriv->uplink_priv.mpesw_work, mlx5e_rep_mpesw_work);
1078
1079 out:
1080         return err;
1081 }
1082
1083 static void mlx5e_cleanup_ul_rep_rx(struct mlx5e_priv *priv)
1084 {
1085         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1086
1087         cancel_work_sync(&rpriv->uplink_priv.mpesw_work);
1088         mlx5e_tc_int_port_cleanup_rep_rx(priv);
1089         mlx5e_cleanup_rep_rx(priv);
1090         mlx5e_destroy_q_counters(priv);
1091 }
1092
1093 static int mlx5e_init_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)
1094 {
1095         struct mlx5_rep_uplink_priv *uplink_priv;
1096         struct net_device *netdev;
1097         struct mlx5e_priv *priv;
1098         int err;
1099
1100         netdev = rpriv->netdev;
1101         priv = netdev_priv(netdev);
1102         uplink_priv = &rpriv->uplink_priv;
1103
1104         err = mlx5e_rep_tc_init(rpriv);
1105         if (err)
1106                 return err;
1107
1108         mlx5_init_port_tun_entropy(&uplink_priv->tun_entropy, priv->mdev);
1109
1110         mlx5e_rep_bond_init(rpriv);
1111         err = mlx5e_rep_tc_netdevice_event_register(rpriv);
1112         if (err) {
1113                 mlx5_core_err(priv->mdev, "Failed to register netdev notifier, err: %d\n",
1114                               err);
1115                 goto err_event_reg;
1116         }
1117
1118         return 0;
1119
1120 err_event_reg:
1121         mlx5e_rep_bond_cleanup(rpriv);
1122         mlx5e_rep_tc_cleanup(rpriv);
1123         return err;
1124 }
1125
1126 static void mlx5e_cleanup_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)
1127 {
1128         mlx5e_rep_tc_netdevice_event_unregister(rpriv);
1129         mlx5e_rep_bond_cleanup(rpriv);
1130         mlx5e_rep_tc_cleanup(rpriv);
1131 }
1132
1133 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv)
1134 {
1135         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1136         int err;
1137
1138         err = mlx5e_create_tises(priv);
1139         if (err) {
1140                 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err);
1141                 return err;
1142         }
1143
1144         if (rpriv->rep->vport == MLX5_VPORT_UPLINK) {
1145                 err = mlx5e_init_uplink_rep_tx(rpriv);
1146                 if (err)
1147                         goto err_init_tx;
1148         }
1149
1150         err = mlx5e_tc_ht_init(&rpriv->tc_ht);
1151         if (err)
1152                 goto err_ht_init;
1153
1154         return 0;
1155
1156 err_ht_init:
1157         if (rpriv->rep->vport == MLX5_VPORT_UPLINK)
1158                 mlx5e_cleanup_uplink_rep_tx(rpriv);
1159 err_init_tx:
1160         mlx5e_destroy_tises(priv);
1161         return err;
1162 }
1163
1164 static void mlx5e_cleanup_rep_tx(struct mlx5e_priv *priv)
1165 {
1166         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1167
1168         mlx5e_tc_ht_cleanup(&rpriv->tc_ht);
1169
1170         if (rpriv->rep->vport == MLX5_VPORT_UPLINK)
1171                 mlx5e_cleanup_uplink_rep_tx(rpriv);
1172
1173         mlx5e_destroy_tises(priv);
1174 }
1175
1176 static void mlx5e_rep_enable(struct mlx5e_priv *priv)
1177 {
1178         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1179
1180         mlx5e_set_netdev_mtu_boundaries(priv);
1181         mlx5e_rep_neigh_init(rpriv);
1182 }
1183
1184 static void mlx5e_rep_disable(struct mlx5e_priv *priv)
1185 {
1186         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1187
1188         mlx5e_rep_neigh_cleanup(rpriv);
1189 }
1190
1191 static int mlx5e_update_rep_rx(struct mlx5e_priv *priv)
1192 {
1193         return 0;
1194 }
1195
1196 static int mlx5e_rep_event_mpesw(struct mlx5e_priv *priv)
1197 {
1198         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1199         struct mlx5_eswitch_rep *rep = rpriv->rep;
1200
1201         if (rep->vport != MLX5_VPORT_UPLINK)
1202                 return NOTIFY_DONE;
1203
1204         queue_work(priv->wq, &rpriv->uplink_priv.mpesw_work);
1205
1206         return NOTIFY_OK;
1207 }
1208
1209 static int uplink_rep_async_event(struct notifier_block *nb, unsigned long event, void *data)
1210 {
1211         struct mlx5e_priv *priv = container_of(nb, struct mlx5e_priv, events_nb);
1212
1213         if (event == MLX5_EVENT_TYPE_PORT_CHANGE) {
1214                 struct mlx5_eqe *eqe = data;
1215
1216                 switch (eqe->sub_type) {
1217                 case MLX5_PORT_CHANGE_SUBTYPE_DOWN:
1218                 case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE:
1219                         queue_work(priv->wq, &priv->update_carrier_work);
1220                         break;
1221                 default:
1222                         return NOTIFY_DONE;
1223                 }
1224
1225                 return NOTIFY_OK;
1226         }
1227
1228         if (event == MLX5_DEV_EVENT_PORT_AFFINITY)
1229                 return mlx5e_rep_tc_event_port_affinity(priv);
1230         else if (event == MLX5_DEV_EVENT_MULTIPORT_ESW)
1231                 return mlx5e_rep_event_mpesw(priv);
1232
1233         return NOTIFY_DONE;
1234 }
1235
1236 static void mlx5e_uplink_rep_enable(struct mlx5e_priv *priv)
1237 {
1238         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1239         struct net_device *netdev = priv->netdev;
1240         struct mlx5_core_dev *mdev = priv->mdev;
1241         u16 max_mtu;
1242
1243         mlx5e_ipsec_init(priv);
1244
1245         netdev->min_mtu = ETH_MIN_MTU;
1246         mlx5_query_port_max_mtu(priv->mdev, &max_mtu, 1);
1247         netdev->max_mtu = MLX5E_HW2SW_MTU(&priv->channels.params, max_mtu);
1248         mlx5e_set_dev_port_mtu(priv);
1249
1250         mlx5e_rep_tc_enable(priv);
1251
1252         if (MLX5_CAP_GEN(mdev, uplink_follow))
1253                 mlx5_modify_vport_admin_state(mdev, MLX5_VPORT_STATE_OP_MOD_UPLINK,
1254                                               0, 0, MLX5_VPORT_ADMIN_STATE_AUTO);
1255         mlx5_lag_add_netdev(mdev, netdev);
1256         priv->events_nb.notifier_call = uplink_rep_async_event;
1257         mlx5_notifier_register(mdev, &priv->events_nb);
1258         mlx5e_dcbnl_initialize(priv);
1259         mlx5e_dcbnl_init_app(priv);
1260         mlx5e_rep_neigh_init(rpriv);
1261         mlx5e_rep_bridge_init(priv);
1262
1263         netdev->wanted_features |= NETIF_F_HW_TC;
1264
1265         rtnl_lock();
1266         if (netif_running(netdev))
1267                 mlx5e_open(netdev);
1268         udp_tunnel_nic_reset_ntf(priv->netdev);
1269         netif_device_attach(netdev);
1270         rtnl_unlock();
1271 }
1272
1273 static void mlx5e_uplink_rep_disable(struct mlx5e_priv *priv)
1274 {
1275         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1276         struct mlx5_core_dev *mdev = priv->mdev;
1277
1278         rtnl_lock();
1279         if (netif_running(priv->netdev))
1280                 mlx5e_close(priv->netdev);
1281         netif_device_detach(priv->netdev);
1282         rtnl_unlock();
1283
1284         mlx5e_rep_bridge_cleanup(priv);
1285         mlx5e_rep_neigh_cleanup(rpriv);
1286         mlx5e_dcbnl_delete_app(priv);
1287         mlx5_notifier_unregister(mdev, &priv->events_nb);
1288         mlx5e_rep_tc_disable(priv);
1289         mlx5_lag_remove_netdev(mdev, priv->netdev);
1290         mlx5_vxlan_reset_to_default(mdev->vxlan);
1291
1292         mlx5e_ipsec_cleanup(priv);
1293 }
1294
1295 static MLX5E_DEFINE_STATS_GRP(sw_rep, 0);
1296 static MLX5E_DEFINE_STATS_GRP(vport_rep, MLX5E_NDO_UPDATE_STATS);
1297
1298 /* The stats groups order is opposite to the update_stats() order calls */
1299 static mlx5e_stats_grp_t mlx5e_rep_stats_grps[] = {
1300         &MLX5E_STATS_GRP(sw_rep),
1301         &MLX5E_STATS_GRP(vport_rep),
1302 };
1303
1304 static unsigned int mlx5e_rep_stats_grps_num(struct mlx5e_priv *priv)
1305 {
1306         return ARRAY_SIZE(mlx5e_rep_stats_grps);
1307 }
1308
1309 /* The stats groups order is opposite to the update_stats() order calls */
1310 static mlx5e_stats_grp_t mlx5e_ul_rep_stats_grps[] = {
1311         &MLX5E_STATS_GRP(sw),
1312         &MLX5E_STATS_GRP(qcnt),
1313         &MLX5E_STATS_GRP(vnic_env),
1314         &MLX5E_STATS_GRP(vport),
1315         &MLX5E_STATS_GRP(802_3),
1316         &MLX5E_STATS_GRP(2863),
1317         &MLX5E_STATS_GRP(2819),
1318         &MLX5E_STATS_GRP(phy),
1319         &MLX5E_STATS_GRP(eth_ext),
1320         &MLX5E_STATS_GRP(pcie),
1321         &MLX5E_STATS_GRP(per_prio),
1322         &MLX5E_STATS_GRP(pme),
1323         &MLX5E_STATS_GRP(channels),
1324         &MLX5E_STATS_GRP(per_port_buff_congest),
1325 #ifdef CONFIG_MLX5_EN_IPSEC
1326         &MLX5E_STATS_GRP(ipsec_sw),
1327 #endif
1328         &MLX5E_STATS_GRP(ptp),
1329 };
1330
1331 static unsigned int mlx5e_ul_rep_stats_grps_num(struct mlx5e_priv *priv)
1332 {
1333         return ARRAY_SIZE(mlx5e_ul_rep_stats_grps);
1334 }
1335
1336 static int
1337 mlx5e_rep_vnic_reporter_diagnose(struct devlink_health_reporter *reporter,
1338                                  struct devlink_fmsg *fmsg,
1339                                  struct netlink_ext_ack *extack)
1340 {
1341         struct mlx5e_rep_priv *rpriv = devlink_health_reporter_priv(reporter);
1342         struct mlx5_eswitch_rep *rep = rpriv->rep;
1343
1344         return mlx5_reporter_vnic_diagnose_counters(rep->esw->dev, fmsg,
1345                                                     rep->vport, true);
1346 }
1347
1348 static const struct devlink_health_reporter_ops mlx5_rep_vnic_reporter_ops = {
1349         .name = "vnic",
1350         .diagnose = mlx5e_rep_vnic_reporter_diagnose,
1351 };
1352
1353 static void mlx5e_rep_vnic_reporter_create(struct mlx5e_priv *priv,
1354                                            struct devlink_port *dl_port)
1355 {
1356         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1357         struct devlink_health_reporter *reporter;
1358
1359         reporter = devl_port_health_reporter_create(dl_port,
1360                                                     &mlx5_rep_vnic_reporter_ops,
1361                                                     0, rpriv);
1362         if (IS_ERR(reporter)) {
1363                 mlx5_core_err(priv->mdev,
1364                               "Failed to create representor vnic reporter, err = %ld\n",
1365                               PTR_ERR(reporter));
1366                 return;
1367         }
1368
1369         rpriv->rep_vnic_reporter = reporter;
1370 }
1371
1372 static void mlx5e_rep_vnic_reporter_destroy(struct mlx5e_priv *priv)
1373 {
1374         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1375
1376         if (!IS_ERR_OR_NULL(rpriv->rep_vnic_reporter))
1377                 devl_health_reporter_destroy(rpriv->rep_vnic_reporter);
1378 }
1379
1380 static const struct mlx5e_profile mlx5e_rep_profile = {
1381         .init                   = mlx5e_init_rep,
1382         .cleanup                = mlx5e_cleanup_rep,
1383         .init_rx                = mlx5e_init_rep_rx,
1384         .cleanup_rx             = mlx5e_cleanup_rep_rx,
1385         .init_tx                = mlx5e_init_rep_tx,
1386         .cleanup_tx             = mlx5e_cleanup_rep_tx,
1387         .enable                 = mlx5e_rep_enable,
1388         .disable                = mlx5e_rep_disable,
1389         .update_rx              = mlx5e_update_rep_rx,
1390         .update_stats           = mlx5e_stats_update_ndo_stats,
1391         .rx_handlers            = &mlx5e_rx_handlers_rep,
1392         .max_tc                 = 1,
1393         .stats_grps             = mlx5e_rep_stats_grps,
1394         .stats_grps_num         = mlx5e_rep_stats_grps_num,
1395         .max_nch_limit          = mlx5e_rep_max_nch_limit,
1396 };
1397
1398 static const struct mlx5e_profile mlx5e_uplink_rep_profile = {
1399         .init                   = mlx5e_init_ul_rep,
1400         .cleanup                = mlx5e_cleanup_rep,
1401         .init_rx                = mlx5e_init_ul_rep_rx,
1402         .cleanup_rx             = mlx5e_cleanup_ul_rep_rx,
1403         .init_tx                = mlx5e_init_rep_tx,
1404         .cleanup_tx             = mlx5e_cleanup_rep_tx,
1405         .enable                 = mlx5e_uplink_rep_enable,
1406         .disable                = mlx5e_uplink_rep_disable,
1407         .update_rx              = mlx5e_update_rep_rx,
1408         .update_stats           = mlx5e_stats_update_ndo_stats,
1409         .update_carrier         = mlx5e_update_carrier,
1410         .rx_handlers            = &mlx5e_rx_handlers_rep,
1411         .max_tc                 = MLX5E_MAX_NUM_TC,
1412         .stats_grps             = mlx5e_ul_rep_stats_grps,
1413         .stats_grps_num         = mlx5e_ul_rep_stats_grps_num,
1414 };
1415
1416 /* e-Switch vport representors */
1417 static int
1418 mlx5e_vport_uplink_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1419 {
1420         struct mlx5e_priv *priv = netdev_priv(mlx5_uplink_netdev_get(dev));
1421         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1422
1423         rpriv->netdev = priv->netdev;
1424         return mlx5e_netdev_change_profile(priv, &mlx5e_uplink_rep_profile,
1425                                            rpriv);
1426 }
1427
1428 static void
1429 mlx5e_vport_uplink_rep_unload(struct mlx5e_rep_priv *rpriv)
1430 {
1431         struct net_device *netdev = rpriv->netdev;
1432         struct mlx5e_priv *priv;
1433
1434         priv = netdev_priv(netdev);
1435
1436         mlx5e_netdev_attach_nic_profile(priv);
1437 }
1438
1439 static int
1440 mlx5e_vport_vf_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1441 {
1442         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1443         const struct mlx5e_profile *profile;
1444         struct devlink_port *dl_port;
1445         struct net_device *netdev;
1446         struct mlx5e_priv *priv;
1447         int err;
1448
1449         profile = &mlx5e_rep_profile;
1450         netdev = mlx5e_create_netdev(dev, profile);
1451         if (!netdev) {
1452                 mlx5_core_warn(dev,
1453                                "Failed to create representor netdev for vport %d\n",
1454                                rep->vport);
1455                 return -EINVAL;
1456         }
1457
1458         mlx5e_build_rep_netdev(netdev, dev);
1459         rpriv->netdev = netdev;
1460
1461         priv = netdev_priv(netdev);
1462         priv->profile = profile;
1463         priv->ppriv = rpriv;
1464         err = profile->init(dev, netdev);
1465         if (err) {
1466                 netdev_warn(netdev, "rep profile init failed, %d\n", err);
1467                 goto err_destroy_netdev;
1468         }
1469
1470         err = mlx5e_attach_netdev(netdev_priv(netdev));
1471         if (err) {
1472                 netdev_warn(netdev,
1473                             "Failed to attach representor netdev for vport %d\n",
1474                             rep->vport);
1475                 goto err_cleanup_profile;
1476         }
1477
1478         dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch,
1479                                                  rpriv->rep->vport);
1480         if (dl_port) {
1481                 SET_NETDEV_DEVLINK_PORT(netdev, dl_port);
1482                 mlx5e_rep_vnic_reporter_create(priv, dl_port);
1483         }
1484
1485         err = register_netdev(netdev);
1486         if (err) {
1487                 netdev_warn(netdev,
1488                             "Failed to register representor netdev for vport %d\n",
1489                             rep->vport);
1490                 goto err_detach_netdev;
1491         }
1492
1493         return 0;
1494
1495 err_detach_netdev:
1496         mlx5e_rep_vnic_reporter_destroy(priv);
1497         mlx5e_detach_netdev(netdev_priv(netdev));
1498 err_cleanup_profile:
1499         priv->profile->cleanup(priv);
1500
1501 err_destroy_netdev:
1502         mlx5e_destroy_netdev(netdev_priv(netdev));
1503         return err;
1504 }
1505
1506 static int
1507 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1508 {
1509         struct mlx5e_rep_priv *rpriv;
1510         int err;
1511
1512         rpriv = kvzalloc(sizeof(*rpriv), GFP_KERNEL);
1513         if (!rpriv)
1514                 return -ENOMEM;
1515
1516         /* rpriv->rep to be looked up when profile->init() is called */
1517         rpriv->rep = rep;
1518         rep->rep_data[REP_ETH].priv = rpriv;
1519         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1520
1521         if (rep->vport == MLX5_VPORT_UPLINK)
1522                 err = mlx5e_vport_uplink_rep_load(dev, rep);
1523         else
1524                 err = mlx5e_vport_vf_rep_load(dev, rep);
1525
1526         if (err)
1527                 kvfree(rpriv);
1528
1529         return err;
1530 }
1531
1532 static void
1533 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep)
1534 {
1535         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1536         struct net_device *netdev = rpriv->netdev;
1537         struct mlx5e_priv *priv = netdev_priv(netdev);
1538         void *ppriv = priv->ppriv;
1539
1540         if (rep->vport == MLX5_VPORT_UPLINK) {
1541                 mlx5e_vport_uplink_rep_unload(rpriv);
1542                 goto free_ppriv;
1543         }
1544
1545         unregister_netdev(netdev);
1546         mlx5e_rep_vnic_reporter_destroy(priv);
1547         mlx5e_detach_netdev(priv);
1548         priv->profile->cleanup(priv);
1549         mlx5e_destroy_netdev(priv);
1550 free_ppriv:
1551         kvfree(ppriv); /* mlx5e_rep_priv */
1552 }
1553
1554 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep)
1555 {
1556         struct mlx5e_rep_priv *rpriv;
1557
1558         rpriv = mlx5e_rep_to_rep_priv(rep);
1559
1560         return rpriv->netdev;
1561 }
1562
1563 static void mlx5e_vport_rep_event_unpair(struct mlx5_eswitch_rep *rep,
1564                                          struct mlx5_eswitch *peer_esw)
1565 {
1566         int i = mlx5_get_dev_index(peer_esw->dev);
1567         struct mlx5e_rep_priv *rpriv;
1568         struct mlx5e_rep_sq *rep_sq;
1569
1570         WARN_ON_ONCE(!peer_esw);
1571         rpriv = mlx5e_rep_to_rep_priv(rep);
1572         list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) {
1573                 struct mlx5e_rep_sq_peer *sq_peer = xa_load(&rep_sq->sq_peer, i);
1574
1575                 if (!sq_peer || sq_peer->peer != peer_esw)
1576                         continue;
1577
1578                 mlx5_eswitch_del_send_to_vport_rule(sq_peer->rule);
1579                 xa_erase(&rep_sq->sq_peer, i);
1580                 kfree(sq_peer);
1581         }
1582 }
1583
1584 static int mlx5e_vport_rep_event_pair(struct mlx5_eswitch *esw,
1585                                       struct mlx5_eswitch_rep *rep,
1586                                       struct mlx5_eswitch *peer_esw)
1587 {
1588         int i = mlx5_get_dev_index(peer_esw->dev);
1589         struct mlx5_flow_handle *flow_rule;
1590         struct mlx5e_rep_sq_peer *sq_peer;
1591         struct mlx5e_rep_priv *rpriv;
1592         struct mlx5e_rep_sq *rep_sq;
1593         int err;
1594
1595         rpriv = mlx5e_rep_to_rep_priv(rep);
1596         list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) {
1597                 sq_peer = xa_load(&rep_sq->sq_peer, i);
1598
1599                 if (sq_peer && sq_peer->peer)
1600                         continue;
1601
1602                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw, rep,
1603                                                                 rep_sq->sqn);
1604                 if (IS_ERR(flow_rule)) {
1605                         err = PTR_ERR(flow_rule);
1606                         goto err_out;
1607                 }
1608
1609                 if (sq_peer) {
1610                         sq_peer->rule = flow_rule;
1611                         sq_peer->peer = peer_esw;
1612                         continue;
1613                 }
1614                 sq_peer = kzalloc(sizeof(*sq_peer), GFP_KERNEL);
1615                 if (!sq_peer) {
1616                         err = -ENOMEM;
1617                         goto err_sq_alloc;
1618                 }
1619                 err = xa_insert(&rep_sq->sq_peer, i, sq_peer, GFP_KERNEL);
1620                 if (err)
1621                         goto err_xa;
1622                 sq_peer->rule = flow_rule;
1623                 sq_peer->peer = peer_esw;
1624         }
1625
1626         return 0;
1627 err_xa:
1628         kfree(sq_peer);
1629 err_sq_alloc:
1630         mlx5_eswitch_del_send_to_vport_rule(flow_rule);
1631 err_out:
1632         mlx5e_vport_rep_event_unpair(rep, peer_esw);
1633         return err;
1634 }
1635
1636 static int mlx5e_vport_rep_event(struct mlx5_eswitch *esw,
1637                                  struct mlx5_eswitch_rep *rep,
1638                                  enum mlx5_switchdev_event event,
1639                                  void *data)
1640 {
1641         int err = 0;
1642
1643         if (event == MLX5_SWITCHDEV_EVENT_PAIR)
1644                 err = mlx5e_vport_rep_event_pair(esw, rep, data);
1645         else if (event == MLX5_SWITCHDEV_EVENT_UNPAIR)
1646                 mlx5e_vport_rep_event_unpair(rep, data);
1647
1648         return err;
1649 }
1650
1651 static const struct mlx5_eswitch_rep_ops rep_ops = {
1652         .load = mlx5e_vport_rep_load,
1653         .unload = mlx5e_vport_rep_unload,
1654         .get_proto_dev = mlx5e_vport_rep_get_proto_dev,
1655         .event = mlx5e_vport_rep_event,
1656 };
1657
1658 static int mlx5e_rep_probe(struct auxiliary_device *adev,
1659                            const struct auxiliary_device_id *id)
1660 {
1661         struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
1662         struct mlx5_core_dev *mdev = edev->mdev;
1663         struct mlx5_eswitch *esw;
1664
1665         esw = mdev->priv.eswitch;
1666         mlx5_eswitch_register_vport_reps(esw, &rep_ops, REP_ETH);
1667         return 0;
1668 }
1669
1670 static void mlx5e_rep_remove(struct auxiliary_device *adev)
1671 {
1672         struct mlx5_adev *vdev = container_of(adev, struct mlx5_adev, adev);
1673         struct mlx5_core_dev *mdev = vdev->mdev;
1674         struct mlx5_eswitch *esw;
1675
1676         esw = mdev->priv.eswitch;
1677         mlx5_eswitch_unregister_vport_reps(esw, REP_ETH);
1678 }
1679
1680 static const struct auxiliary_device_id mlx5e_rep_id_table[] = {
1681         { .name = MLX5_ADEV_NAME ".eth-rep", },
1682         {},
1683 };
1684
1685 MODULE_DEVICE_TABLE(auxiliary, mlx5e_rep_id_table);
1686
1687 static struct auxiliary_driver mlx5e_rep_driver = {
1688         .name = "eth-rep",
1689         .probe = mlx5e_rep_probe,
1690         .remove = mlx5e_rep_remove,
1691         .id_table = mlx5e_rep_id_table,
1692 };
1693
1694 int mlx5e_rep_init(void)
1695 {
1696         return auxiliary_driver_register(&mlx5e_rep_driver);
1697 }
1698
1699 void mlx5e_rep_cleanup(void)
1700 {
1701         auxiliary_driver_unregister(&mlx5e_rep_driver);
1702 }