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