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/mlx5/fs.h>
  34 #include <net/switchdev.h>
  35 #include <net/pkt_cls.h>
  36 #include <net/act_api.h>
  37 #include <net/devlink.h>
  38 #include <net/ipv6_stubs.h>
  39
  40 #include "eswitch.h"
  41 #include "en.h"
  42 #include "en_rep.h"
  43 #include "en/params.h"
  44 #include "en/txrx.h"
  45 #include "en_tc.h"
  46 #include "en/rep/tc.h"
  47 #include "en/rep/neigh.h"
  48 #include "en/rep/bridge.h"
  49 #include "en/devlink.h"
  50 #include "fs_core.h"
  51 #include "lib/mlx5.h"
  52 #define CREATE_TRACE_POINTS
  53 #include "diag/en_rep_tracepoint.h"
  54 #include "en_accel/ipsec.h"
  55
  56 #define MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE \
  57         max(0x7, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)
  58 #define MLX5E_REP_PARAMS_DEF_NUM_CHANNELS 1
  59
  60 static const char mlx5e_rep_driver_name[] = "mlx5e_rep";
  61
  62 static void mlx5e_rep_get_drvinfo(struct net_device *dev,
  63                                   struct ethtool_drvinfo *drvinfo)
  64 {
  65         struct mlx5e_priv *priv = netdev_priv(dev);
  66         struct mlx5_core_dev *mdev = priv->mdev;
  67
  68         strlcpy(drvinfo->driver, mlx5e_rep_driver_name,
  69                 sizeof(drvinfo->driver));
  70         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  71                  "%d.%d.%04d (%.16s)",
  72                  fw_rev_maj(mdev), fw_rev_min(mdev),
  73                  fw_rev_sub(mdev), mdev->board_id);
  74 }
  75
  76 static const struct counter_desc sw_rep_stats_desc[] = {
  77         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_packets) },
  78         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) },
  79         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) },
  80         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) },
  81 };
  82
  83 struct vport_stats {
  84         u64 vport_rx_packets;
  85         u64 vport_tx_packets;
  86         u64 vport_rx_bytes;
  87         u64 vport_tx_bytes;
  88 };
  89
  90 static const struct counter_desc vport_rep_stats_desc[] = {
  91         { MLX5E_DECLARE_STAT(struct vport_stats, vport_rx_packets) },
  92         { MLX5E_DECLARE_STAT(struct vport_stats, vport_rx_bytes) },
  93         { MLX5E_DECLARE_STAT(struct vport_stats, vport_tx_packets) },
  94         { MLX5E_DECLARE_STAT(struct vport_stats, vport_tx_bytes) },
  95 };
  96
  97 #define NUM_VPORT_REP_SW_COUNTERS ARRAY_SIZE(sw_rep_stats_desc)
  98 #define NUM_VPORT_REP_HW_COUNTERS ARRAY_SIZE(vport_rep_stats_desc)
  99
 100 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(sw_rep)
 101 {
 102         return NUM_VPORT_REP_SW_COUNTERS;
 103 }
 104
 105 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(sw_rep)
 106 {
 107         int i;
 108
 109         for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++)
 110                 strcpy(data + (idx++) * ETH_GSTRING_LEN,
 111                        sw_rep_stats_desc[i].format);
 112         return idx;
 113 }
 114
 115 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(sw_rep)
 116 {
 117         int i;
 118
 119         for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++)
 120                 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.sw,
 121                                                    sw_rep_stats_desc, i);
 122         return idx;
 123 }
 124
 125 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(sw_rep)
 126 {
 127         struct mlx5e_sw_stats *s = &priv->stats.sw;
 128         struct rtnl_link_stats64 stats64 = {};
 129
 130         memset(s, 0, sizeof(*s));
 131         mlx5e_fold_sw_stats64(priv, &stats64);
 132
 133         s->rx_packets = stats64.rx_packets;
 134         s->rx_bytes   = stats64.rx_bytes;
 135         s->tx_packets = stats64.tx_packets;
 136         s->tx_bytes   = stats64.tx_bytes;
 137         s->tx_queue_dropped = stats64.tx_dropped;
 138 }
 139
 140 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(vport_rep)
 141 {
 142         return NUM_VPORT_REP_HW_COUNTERS;
 143 }
 144
 145 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(vport_rep)
 146 {
 147         int i;
 148
 149         for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++)
 150                 strcpy(data + (idx++) * ETH_GSTRING_LEN, vport_rep_stats_desc[i].format);
 151         return idx;
 152 }
 153
 154 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(vport_rep)
 155 {
 156         int i;
 157
 158         for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++)
 159                 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.vf_vport,
 160                                                    vport_rep_stats_desc, i);
 161         return idx;
 162 }
 163
 164 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(vport_rep)
 165 {
 166         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 167         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 168         struct mlx5_eswitch_rep *rep = rpriv->rep;
 169         struct rtnl_link_stats64 *vport_stats;
 170         struct ifla_vf_stats vf_stats;
 171         int err;
 172
 173         err = mlx5_eswitch_get_vport_stats(esw, rep->vport, &vf_stats);
 174         if (err) {
 175                 netdev_warn(priv->netdev, "vport %d error %d reading stats\n",
 176                             rep->vport, err);
 177                 return;
 178         }
 179
 180         vport_stats = &priv->stats.vf_vport;
 181         /* flip tx/rx as we are reporting the counters for the switch vport */
 182         vport_stats->rx_packets = vf_stats.tx_packets;
 183         vport_stats->rx_bytes   = vf_stats.tx_bytes;
 184         vport_stats->tx_packets = vf_stats.rx_packets;
 185         vport_stats->tx_bytes   = vf_stats.rx_bytes;
 186 }
 187
 188 static void mlx5e_rep_get_strings(struct net_device *dev,
 189                                   u32 stringset, uint8_t *data)
 190 {
 191         struct mlx5e_priv *priv = netdev_priv(dev);
 192
 193         switch (stringset) {
 194         case ETH_SS_STATS:
 195                 mlx5e_stats_fill_strings(priv, data);
 196                 break;
 197         }
 198 }
 199
 200 static void mlx5e_rep_get_ethtool_stats(struct net_device *dev,
 201                                         struct ethtool_stats *stats, u64 *data)
 202 {
 203         struct mlx5e_priv *priv = netdev_priv(dev);
 204
 205         mlx5e_ethtool_get_ethtool_stats(priv, stats, data);
 206 }
 207
 208 static int mlx5e_rep_get_sset_count(struct net_device *dev, int sset)
 209 {
 210         struct mlx5e_priv *priv = netdev_priv(dev);
 211
 212         switch (sset) {
 213         case ETH_SS_STATS:
 214                 return mlx5e_stats_total_num(priv);
 215         default:
 216                 return -EOPNOTSUPP;
 217         }
 218 }
 219
 220 static void mlx5e_rep_get_ringparam(struct net_device *dev,
 221                                 struct ethtool_ringparam *param)
 222 {
 223         struct mlx5e_priv *priv = netdev_priv(dev);
 224
 225         mlx5e_ethtool_get_ringparam(priv, param);
 226 }
 227
 228 static int mlx5e_rep_set_ringparam(struct net_device *dev,
 229                                struct ethtool_ringparam *param)
 230 {
 231         struct mlx5e_priv *priv = netdev_priv(dev);
 232
 233         return mlx5e_ethtool_set_ringparam(priv, param);
 234 }
 235
 236 static void mlx5e_rep_get_channels(struct net_device *dev,
 237                                    struct ethtool_channels *ch)
 238 {
 239         struct mlx5e_priv *priv = netdev_priv(dev);
 240
 241         mlx5e_ethtool_get_channels(priv, ch);
 242 }
 243
 244 static int mlx5e_rep_set_channels(struct net_device *dev,
 245                                   struct ethtool_channels *ch)
 246 {
 247         struct mlx5e_priv *priv = netdev_priv(dev);
 248
 249         return mlx5e_ethtool_set_channels(priv, ch);
 250 }
 251
 252 static int mlx5e_rep_get_coalesce(struct net_device *netdev,
 253                                   struct ethtool_coalesce *coal)
 254 {
 255         struct mlx5e_priv *priv = netdev_priv(netdev);
 256
 257         return mlx5e_ethtool_get_coalesce(priv, coal);
 258 }
 259
 260 static int mlx5e_rep_set_coalesce(struct net_device *netdev,
 261                                   struct ethtool_coalesce *coal)
 262 {
 263         struct mlx5e_priv *priv = netdev_priv(netdev);
 264
 265         return mlx5e_ethtool_set_coalesce(priv, coal);
 266 }
 267
 268 static u32 mlx5e_rep_get_rxfh_key_size(struct net_device *netdev)
 269 {
 270         struct mlx5e_priv *priv = netdev_priv(netdev);
 271
 272         return mlx5e_ethtool_get_rxfh_key_size(priv);
 273 }
 274
 275 static u32 mlx5e_rep_get_rxfh_indir_size(struct net_device *netdev)
 276 {
 277         struct mlx5e_priv *priv = netdev_priv(netdev);
 278
 279         return mlx5e_ethtool_get_rxfh_indir_size(priv);
 280 }
 281
 282 static const struct ethtool_ops mlx5e_rep_ethtool_ops = {
 283         .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
 284                                      ETHTOOL_COALESCE_MAX_FRAMES |
 285                                      ETHTOOL_COALESCE_USE_ADAPTIVE,
 286         .get_drvinfo       = mlx5e_rep_get_drvinfo,
 287         .get_link          = ethtool_op_get_link,
 288         .get_strings       = mlx5e_rep_get_strings,
 289         .get_sset_count    = mlx5e_rep_get_sset_count,
 290         .get_ethtool_stats = mlx5e_rep_get_ethtool_stats,
 291         .get_ringparam     = mlx5e_rep_get_ringparam,
 292         .set_ringparam     = mlx5e_rep_set_ringparam,
 293         .get_channels      = mlx5e_rep_get_channels,
 294         .set_channels      = mlx5e_rep_set_channels,
 295         .get_coalesce      = mlx5e_rep_get_coalesce,
 296         .set_coalesce      = mlx5e_rep_set_coalesce,
 297         .get_rxfh_key_size   = mlx5e_rep_get_rxfh_key_size,
 298         .get_rxfh_indir_size = mlx5e_rep_get_rxfh_indir_size,
 299 };
 300
 301 static void mlx5e_sqs2vport_stop(struct mlx5_eswitch *esw,
 302                                  struct mlx5_eswitch_rep *rep)
 303 {
 304         struct mlx5e_rep_sq *rep_sq, *tmp;
 305         struct mlx5e_rep_priv *rpriv;
 306
 307         if (esw->mode != MLX5_ESWITCH_OFFLOADS)
 308                 return;
 309
 310         rpriv = mlx5e_rep_to_rep_priv(rep);
 311         list_for_each_entry_safe(rep_sq, tmp, &rpriv->vport_sqs_list, list) {
 312                 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule);
 313                 list_del(&rep_sq->list);
 314                 kfree(rep_sq);
 315         }
 316 }
 317
 318 static int mlx5e_sqs2vport_start(struct mlx5_eswitch *esw,
 319                                  struct mlx5_eswitch_rep *rep,
 320                                  u32 *sqns_array, int sqns_num)
 321 {
 322         struct mlx5_flow_handle *flow_rule;
 323         struct mlx5e_rep_priv *rpriv;
 324         struct mlx5e_rep_sq *rep_sq;
 325         int err;
 326         int i;
 327
 328         if (esw->mode != MLX5_ESWITCH_OFFLOADS)
 329                 return 0;
 330
 331         rpriv = mlx5e_rep_to_rep_priv(rep);
 332         for (i = 0; i < sqns_num; i++) {
 333                 rep_sq = kzalloc(sizeof(*rep_sq), GFP_KERNEL);
 334                 if (!rep_sq) {
 335                         err = -ENOMEM;
 336                         goto out_err;
 337                 }
 338
 339                 /* Add re-inject rule to the PF/representor sqs */
 340                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw, rep,
 341                                                                 sqns_array[i]);
 342                 if (IS_ERR(flow_rule)) {
 343                         err = PTR_ERR(flow_rule);
 344                         kfree(rep_sq);
 345                         goto out_err;
 346                 }
 347                 rep_sq->send_to_vport_rule = flow_rule;
 348                 list_add(&rep_sq->list, &rpriv->vport_sqs_list);
 349         }
 350         return 0;
 351
 352 out_err:
 353         mlx5e_sqs2vport_stop(esw, rep);
 354         return err;
 355 }
 356
 357 int mlx5e_add_sqs_fwd_rules(struct mlx5e_priv *priv)
 358 {
 359         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 360         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 361         struct mlx5_eswitch_rep *rep = rpriv->rep;
 362         struct mlx5e_channel *c;
 363         int n, tc, num_sqs = 0;
 364         int err = -ENOMEM;
 365         u32 *sqs;
 366
 367         sqs = kcalloc(priv->channels.num * priv->channels.params.num_tc, sizeof(*sqs), GFP_KERNEL);
 368         if (!sqs)
 369                 goto out;
 370
 371         for (n = 0; n < priv->channels.num; n++) {
 372                 c = priv->channels.c[n];
 373                 for (tc = 0; tc < c->num_tc; tc++)
 374                         sqs[num_sqs++] = c->sq[tc].sqn;
 375         }
 376
 377         err = mlx5e_sqs2vport_start(esw, rep, sqs, num_sqs);
 378         kfree(sqs);
 379
 380 out:
 381         if (err)
 382                 netdev_warn(priv->netdev, "Failed to add SQs FWD rules %d\n", err);
 383         return err;
 384 }
 385
 386 void mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv)
 387 {
 388         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 389         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 390         struct mlx5_eswitch_rep *rep = rpriv->rep;
 391
 392         mlx5e_sqs2vport_stop(esw, rep);
 393 }
 394
 395 static int mlx5e_rep_open(struct net_device *dev)
 396 {
 397         struct mlx5e_priv *priv = netdev_priv(dev);
 398         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 399         struct mlx5_eswitch_rep *rep = rpriv->rep;
 400         int err;
 401
 402         mutex_lock(&priv->state_lock);
 403         err = mlx5e_open_locked(dev);
 404         if (err)
 405                 goto unlock;
 406
 407         if (!mlx5_modify_vport_admin_state(priv->mdev,
 408                                            MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 409                                            rep->vport, 1,
 410                                            MLX5_VPORT_ADMIN_STATE_UP))
 411                 netif_carrier_on(dev);
 412
 413 unlock:
 414         mutex_unlock(&priv->state_lock);
 415         return err;
 416 }
 417
 418 static int mlx5e_rep_close(struct net_device *dev)
 419 {
 420         struct mlx5e_priv *priv = netdev_priv(dev);
 421         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 422         struct mlx5_eswitch_rep *rep = rpriv->rep;
 423         int ret;
 424
 425         mutex_lock(&priv->state_lock);
 426         mlx5_modify_vport_admin_state(priv->mdev,
 427                                       MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 428                                       rep->vport, 1,
 429                                       MLX5_VPORT_ADMIN_STATE_DOWN);
 430         ret = mlx5e_close_locked(dev);
 431         mutex_unlock(&priv->state_lock);
 432         return ret;
 433 }
 434
 435 bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv)
 436 {
 437         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 438         struct mlx5_eswitch_rep *rep;
 439
 440         if (!MLX5_ESWITCH_MANAGER(priv->mdev))
 441                 return false;
 442
 443         if (!rpriv) /* non vport rep mlx5e instances don't use this field */
 444                 return false;
 445
 446         rep = rpriv->rep;
 447         return (rep->vport == MLX5_VPORT_UPLINK);
 448 }
 449
 450 bool mlx5e_rep_has_offload_stats(const struct net_device *dev, int attr_id)
 451 {
 452         switch (attr_id) {
 453         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 454                         return true;
 455         }
 456
 457         return false;
 458 }
 459
 460 static int
 461 mlx5e_get_sw_stats64(const struct net_device *dev,
 462                      struct rtnl_link_stats64 *stats)
 463 {
 464         struct mlx5e_priv *priv = netdev_priv(dev);
 465
 466         mlx5e_fold_sw_stats64(priv, stats);
 467         return 0;
 468 }
 469
 470 int mlx5e_rep_get_offload_stats(int attr_id, const struct net_device *dev,
 471                                 void *sp)
 472 {
 473         switch (attr_id) {
 474         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 475                 return mlx5e_get_sw_stats64(dev, sp);
 476         }
 477
 478         return -EINVAL;
 479 }
 480
 481 static void
 482 mlx5e_rep_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats)
 483 {
 484         struct mlx5e_priv *priv = netdev_priv(dev);
 485
 486         /* update HW stats in background for next time */
 487         mlx5e_queue_update_stats(priv);
 488         memcpy(stats, &priv->stats.vf_vport, sizeof(*stats));
 489 }
 490
 491 static int mlx5e_rep_change_mtu(struct net_device *netdev, int new_mtu)
 492 {
 493         return mlx5e_change_mtu(netdev, new_mtu, NULL);
 494 }
 495
 496 static struct devlink_port *mlx5e_rep_get_devlink_port(struct net_device *netdev)
 497 {
 498         struct mlx5e_priv *priv = netdev_priv(netdev);
 499         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 500         struct mlx5_core_dev *dev = priv->mdev;
 501
 502         return mlx5_esw_offloads_devlink_port(dev->priv.eswitch, rpriv->rep->vport);
 503 }
 504
 505 static int mlx5e_rep_change_carrier(struct net_device *dev, bool new_carrier)
 506 {
 507         struct mlx5e_priv *priv = netdev_priv(dev);
 508         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 509         struct mlx5_eswitch_rep *rep = rpriv->rep;
 510         int err;
 511
 512         if (new_carrier) {
 513                 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 514                                                     rep->vport, 1, MLX5_VPORT_ADMIN_STATE_UP);
 515                 if (err)
 516                         return err;
 517                 netif_carrier_on(dev);
 518         } else {
 519                 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 520                                                     rep->vport, 1, MLX5_VPORT_ADMIN_STATE_DOWN);
 521                 if (err)
 522                         return err;
 523                 netif_carrier_off(dev);
 524         }
 525         return 0;
 526 }
 527
 528 static const struct net_device_ops mlx5e_netdev_ops_rep = {
 529         .ndo_open                = mlx5e_rep_open,
 530         .ndo_stop                = mlx5e_rep_close,
 531         .ndo_start_xmit          = mlx5e_xmit,
 532         .ndo_setup_tc            = mlx5e_rep_setup_tc,
 533         .ndo_get_devlink_port    = mlx5e_rep_get_devlink_port,
 534         .ndo_get_stats64         = mlx5e_rep_get_stats,
 535         .ndo_has_offload_stats   = mlx5e_rep_has_offload_stats,
 536         .ndo_get_offload_stats   = mlx5e_rep_get_offload_stats,
 537         .ndo_change_mtu          = mlx5e_rep_change_mtu,
 538         .ndo_change_carrier      = mlx5e_rep_change_carrier,
 539 };
 540
 541 bool mlx5e_eswitch_uplink_rep(const struct net_device *netdev)
 542 {
 543         return netdev->netdev_ops == &mlx5e_netdev_ops &&
 544                mlx5e_is_uplink_rep(netdev_priv(netdev));
 545 }
 546
 547 bool mlx5e_eswitch_vf_rep(const struct net_device *netdev)
 548 {
 549         return netdev->netdev_ops == &mlx5e_netdev_ops_rep;
 550 }
 551
 552 static void mlx5e_build_rep_params(struct net_device *netdev)
 553 {
 554         struct mlx5e_priv *priv = netdev_priv(netdev);
 555         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 556         struct mlx5_eswitch_rep *rep = rpriv->rep;
 557         struct mlx5_core_dev *mdev = priv->mdev;
 558         struct mlx5e_params *params;
 559
 560         u8 cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ?
 561                                          MLX5_CQ_PERIOD_MODE_START_FROM_CQE :
 562                                          MLX5_CQ_PERIOD_MODE_START_FROM_EQE;
 563
 564         priv->max_nch = mlx5e_calc_max_nch(priv, priv->profile);
 565         params = &priv->channels.params;
 566
 567         params->num_channels = MLX5E_REP_PARAMS_DEF_NUM_CHANNELS;
 568         params->hard_mtu    = MLX5E_ETH_HARD_MTU;
 569         params->sw_mtu      = netdev->mtu;
 570
 571         /* SQ */
 572         if (rep->vport == MLX5_VPORT_UPLINK)
 573                 params->log_sq_size = MLX5E_PARAMS_DEFAULT_LOG_SQ_SIZE;
 574         else
 575                 params->log_sq_size = MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE;
 576
 577         /* RQ */
 578         mlx5e_build_rq_params(mdev, params);
 579
 580         /* CQ moderation params */
 581         params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation);
 582         mlx5e_set_rx_cq_mode_params(params, cq_period_mode);
 583
 584         params->num_tc                = 1;
 585         params->tunneled_offload_en = false;
 586
 587         mlx5_query_min_inline(mdev, &params->tx_min_inline_mode);
 588 }
 589
 590 static void mlx5e_build_rep_netdev(struct net_device *netdev,
 591                                    struct mlx5_core_dev *mdev)
 592 {
 593         SET_NETDEV_DEV(netdev, mdev->device);
 594         netdev->netdev_ops = &mlx5e_netdev_ops_rep;
 595         eth_hw_addr_random(netdev);
 596         netdev->ethtool_ops = &mlx5e_rep_ethtool_ops;
 597
 598         netdev->watchdog_timeo    = 15 * HZ;
 599
 600 #if IS_ENABLED(CONFIG_MLX5_CLS_ACT)
 601         netdev->hw_features    |= NETIF_F_HW_TC;
 602 #endif
 603         netdev->hw_features    |= NETIF_F_SG;
 604         netdev->hw_features    |= NETIF_F_IP_CSUM;
 605         netdev->hw_features    |= NETIF_F_IPV6_CSUM;
 606         netdev->hw_features    |= NETIF_F_GRO;
 607         netdev->hw_features    |= NETIF_F_TSO;
 608         netdev->hw_features    |= NETIF_F_TSO6;
 609         netdev->hw_features    |= NETIF_F_RXCSUM;
 610
 611         netdev->features |= netdev->hw_features;
 612         netdev->features |= NETIF_F_VLAN_CHALLENGED;
 613         netdev->features |= NETIF_F_NETNS_LOCAL;
 614 }
 615
 616 static int mlx5e_init_rep(struct mlx5_core_dev *mdev,
 617                           struct net_device *netdev)
 618 {
 619         struct mlx5e_priv *priv = netdev_priv(netdev);
 620
 621         mlx5e_build_rep_params(netdev);
 622         mlx5e_timestamp_init(priv);
 623
 624         return 0;
 625 }
 626
 627 static int mlx5e_init_ul_rep(struct mlx5_core_dev *mdev,
 628                              struct net_device *netdev)
 629 {
 630         struct mlx5e_priv *priv = netdev_priv(netdev);
 631         int err;
 632
 633         err = mlx5e_ipsec_init(priv);
 634         if (err)
 635                 mlx5_core_err(mdev, "Uplink rep IPsec initialization failed, %d\n", err);
 636
 637         mlx5e_vxlan_set_netdev_info(priv);
 638         return mlx5e_init_rep(mdev, netdev);
 639 }
 640
 641 static void mlx5e_cleanup_rep(struct mlx5e_priv *priv)
 642 {
 643         mlx5e_ipsec_cleanup(priv);
 644 }
 645
 646 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv)
 647 {
 648         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 649         struct mlx5_eswitch_rep *rep = rpriv->rep;
 650         struct ttc_params ttc_params = {};
 651         int tt, err;
 652
 653         priv->fs.ns = mlx5_get_flow_namespace(priv->mdev,
 654                                               MLX5_FLOW_NAMESPACE_KERNEL);
 655
 656         /* The inner_ttc in the ttc params is intentionally not set */
 657         ttc_params.any_tt_tirn = priv->direct_tir[0].tirn;
 658         mlx5e_set_ttc_ft_params(&ttc_params);
 659
 660         if (rep->vport != MLX5_VPORT_UPLINK)
 661                 /* To give uplik rep TTC a lower level for chaining from root ft */
 662                 ttc_params.ft_attr.level = MLX5E_TTC_FT_LEVEL + 1;
 663
 664         for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++)
 665                 ttc_params.indir_tirn[tt] = priv->indir_tir[tt].tirn;
 666
 667         err = mlx5e_create_ttc_table(priv, &ttc_params, &priv->fs.ttc);
 668         if (err) {
 669                 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n", err);
 670                 return err;
 671         }
 672         return 0;
 673 }
 674
 675 static int mlx5e_create_rep_root_ft(struct mlx5e_priv *priv)
 676 {
 677         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 678         struct mlx5_eswitch_rep *rep = rpriv->rep;
 679         struct mlx5_flow_table_attr ft_attr = {};
 680         struct mlx5_flow_namespace *ns;
 681         int err = 0;
 682
 683         if (rep->vport != MLX5_VPORT_UPLINK) {
 684                 /* non uplik reps will skip any bypass tables and go directly to
 685                  * their own ttc
 686                  */
 687                 rpriv->root_ft = priv->fs.ttc.ft.t;
 688                 return 0;
 689         }
 690
 691         /* uplink root ft will be used to auto chain, to ethtool or ttc tables */
 692         ns = mlx5_get_flow_namespace(priv->mdev, MLX5_FLOW_NAMESPACE_OFFLOADS);
 693         if (!ns) {
 694                 netdev_err(priv->netdev, "Failed to get reps offloads namespace\n");
 695                 return -EOPNOTSUPP;
 696         }
 697
 698         ft_attr.max_fte = 0; /* Empty table, miss rule will always point to next table */
 699         ft_attr.prio = 1;
 700         ft_attr.level = 1;
 701
 702         rpriv->root_ft = mlx5_create_flow_table(ns, &ft_attr);
 703         if (IS_ERR(rpriv->root_ft)) {
 704                 err = PTR_ERR(rpriv->root_ft);
 705                 rpriv->root_ft = NULL;
 706         }
 707
 708         return err;
 709 }
 710
 711 static void mlx5e_destroy_rep_root_ft(struct mlx5e_priv *priv)
 712 {
 713         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 714         struct mlx5_eswitch_rep *rep = rpriv->rep;
 715
 716         if (rep->vport != MLX5_VPORT_UPLINK)
 717                 return;
 718         mlx5_destroy_flow_table(rpriv->root_ft);
 719 }
 720
 721 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv)
 722 {
 723         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 724         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 725         struct mlx5_eswitch_rep *rep = rpriv->rep;
 726         struct mlx5_flow_handle *flow_rule;
 727         struct mlx5_flow_destination dest;
 728
 729         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 730         dest.ft = rpriv->root_ft;
 731
 732         flow_rule = mlx5_eswitch_create_vport_rx_rule(esw, rep->vport, &dest);
 733         if (IS_ERR(flow_rule))
 734                 return PTR_ERR(flow_rule);
 735         rpriv->vport_rx_rule = flow_rule;
 736         return 0;
 737 }
 738
 739 static void rep_vport_rx_rule_destroy(struct mlx5e_priv *priv)
 740 {
 741         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 742
 743         if (!rpriv->vport_rx_rule)
 744                 return;
 745
 746         mlx5_del_flow_rules(rpriv->vport_rx_rule);
 747         rpriv->vport_rx_rule = NULL;
 748 }
 749
 750 int mlx5e_rep_bond_update(struct mlx5e_priv *priv, bool cleanup)
 751 {
 752         rep_vport_rx_rule_destroy(priv);
 753
 754         return cleanup ? 0 : mlx5e_create_rep_vport_rx_rule(priv);
 755 }
 756
 757 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv)
 758 {
 759         struct mlx5_core_dev *mdev = priv->mdev;
 760         u16 max_nch = priv->max_nch;
 761         int err;
 762
 763         mlx5e_build_rss_params(&priv->rss_params, priv->channels.params.num_channels);
 764
 765         mlx5e_init_l2_addr(priv);
 766
 767         err = mlx5e_open_drop_rq(priv, &priv->drop_rq);
 768         if (err) {
 769                 mlx5_core_err(mdev, "open drop rq failed, %d\n", err);
 770                 return err;
 771         }
 772
 773         err = mlx5e_create_indirect_rqt(priv);
 774         if (err)
 775                 goto err_close_drop_rq;
 776
 777         err = mlx5e_create_direct_rqts(priv, priv->direct_tir, max_nch);
 778         if (err)
 779                 goto err_destroy_indirect_rqts;
 780
 781         err = mlx5e_create_indirect_tirs(priv, false);
 782         if (err)
 783                 goto err_destroy_direct_rqts;
 784
 785         err = mlx5e_create_direct_tirs(priv, priv->direct_tir, max_nch);
 786         if (err)
 787                 goto err_destroy_indirect_tirs;
 788
 789         err = mlx5e_create_rep_ttc_table(priv);
 790         if (err)
 791                 goto err_destroy_direct_tirs;
 792
 793         err = mlx5e_create_rep_root_ft(priv);
 794         if (err)
 795                 goto err_destroy_ttc_table;
 796
 797         err = mlx5e_create_rep_vport_rx_rule(priv);
 798         if (err)
 799                 goto err_destroy_root_ft;
 800
 801         mlx5e_ethtool_init_steering(priv);
 802
 803         return 0;
 804
 805 err_destroy_root_ft:
 806         mlx5e_destroy_rep_root_ft(priv);
 807 err_destroy_ttc_table:
 808         mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
 809 err_destroy_direct_tirs:
 810         mlx5e_destroy_direct_tirs(priv, priv->direct_tir, max_nch);
 811 err_destroy_indirect_tirs:
 812         mlx5e_destroy_indirect_tirs(priv);
 813 err_destroy_direct_rqts:
 814         mlx5e_destroy_direct_rqts(priv, priv->direct_tir, max_nch);
 815 err_destroy_indirect_rqts:
 816         priv->indir_rqt_enabled = false;
 817         mlx5e_rqt_destroy(&priv->indir_rqt);
 818 err_close_drop_rq:
 819         mlx5e_close_drop_rq(&priv->drop_rq);
 820         return err;
 821 }
 822
 823 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv)
 824 {
 825         u16 max_nch = priv->max_nch;
 826
 827         mlx5e_ethtool_cleanup_steering(priv);
 828         rep_vport_rx_rule_destroy(priv);
 829         mlx5e_destroy_rep_root_ft(priv);
 830         mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
 831         mlx5e_destroy_direct_tirs(priv, priv->direct_tir, max_nch);
 832         mlx5e_destroy_indirect_tirs(priv);
 833         mlx5e_destroy_direct_rqts(priv, priv->direct_tir, max_nch);
 834         priv->indir_rqt_enabled = false;
 835         mlx5e_rqt_destroy(&priv->indir_rqt);
 836         mlx5e_close_drop_rq(&priv->drop_rq);
 837 }
 838
 839 static int mlx5e_init_ul_rep_rx(struct mlx5e_priv *priv)
 840 {
 841         mlx5e_create_q_counters(priv);
 842         return mlx5e_init_rep_rx(priv);
 843 }
 844
 845 static void mlx5e_cleanup_ul_rep_rx(struct mlx5e_priv *priv)
 846 {
 847         mlx5e_cleanup_rep_rx(priv);
 848         mlx5e_destroy_q_counters(priv);
 849 }
 850
 851 static int mlx5e_init_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)
 852 {
 853         struct mlx5_rep_uplink_priv *uplink_priv;
 854         struct net_device *netdev;
 855         struct mlx5e_priv *priv;
 856         int err;
 857
 858         netdev = rpriv->netdev;
 859         priv = netdev_priv(netdev);
 860         uplink_priv = &rpriv->uplink_priv;
 861
 862         err = mlx5e_rep_tc_init(rpriv);
 863         if (err)
 864                 return err;
 865
 866         mlx5_init_port_tun_entropy(&uplink_priv->tun_entropy, priv->mdev);
 867
 868         mlx5e_rep_bond_init(rpriv);
 869         err = mlx5e_rep_tc_netdevice_event_register(rpriv);
 870         if (err) {
 871                 mlx5_core_err(priv->mdev, "Failed to register netdev notifier, err: %d\n",
 872                               err);
 873                 goto err_event_reg;
 874         }
 875
 876         return 0;
 877
 878 err_event_reg:
 879         mlx5e_rep_bond_cleanup(rpriv);
 880         mlx5e_rep_tc_cleanup(rpriv);
 881         return err;
 882 }
 883
 884 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv)
 885 {
 886         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 887         int err;
 888
 889         err = mlx5e_create_tises(priv);
 890         if (err) {
 891                 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err);
 892                 return err;
 893         }
 894
 895         if (rpriv->rep->vport == MLX5_VPORT_UPLINK) {
 896                 err = mlx5e_init_uplink_rep_tx(rpriv);
 897                 if (err)
 898                         goto destroy_tises;
 899         }
 900
 901         return 0;
 902
 903 destroy_tises:
 904         mlx5e_destroy_tises(priv);
 905         return err;
 906 }
 907
 908 static void mlx5e_cleanup_uplink_rep_tx(struct mlx5e_rep_priv *rpriv)
 909 {
 910         mlx5e_rep_tc_netdevice_event_unregister(rpriv);
 911         mlx5e_rep_bond_cleanup(rpriv);
 912         mlx5e_rep_tc_cleanup(rpriv);
 913 }
 914
 915 static void mlx5e_cleanup_rep_tx(struct mlx5e_priv *priv)
 916 {
 917         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 918
 919         mlx5e_destroy_tises(priv);
 920
 921         if (rpriv->rep->vport == MLX5_VPORT_UPLINK)
 922                 mlx5e_cleanup_uplink_rep_tx(rpriv);
 923 }
 924
 925 static void mlx5e_rep_enable(struct mlx5e_priv *priv)
 926 {
 927         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 928
 929         mlx5e_set_netdev_mtu_boundaries(priv);
 930         mlx5e_rep_neigh_init(rpriv);
 931 }
 932
 933 static void mlx5e_rep_disable(struct mlx5e_priv *priv)
 934 {
 935         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 936
 937         mlx5e_rep_neigh_cleanup(rpriv);
 938 }
 939
 940 static int mlx5e_update_rep_rx(struct mlx5e_priv *priv)
 941 {
 942         return 0;
 943 }
 944
 945 static int uplink_rep_async_event(struct notifier_block *nb, unsigned long event, void *data)
 946 {
 947         struct mlx5e_priv *priv = container_of(nb, struct mlx5e_priv, events_nb);
 948
 949         if (event == MLX5_EVENT_TYPE_PORT_CHANGE) {
 950                 struct mlx5_eqe *eqe = data;
 951
 952                 switch (eqe->sub_type) {
 953                 case MLX5_PORT_CHANGE_SUBTYPE_DOWN:
 954                 case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE:
 955                         queue_work(priv->wq, &priv->update_carrier_work);
 956                         break;
 957                 default:
 958                         return NOTIFY_DONE;
 959                 }
 960
 961                 return NOTIFY_OK;
 962         }
 963
 964         if (event == MLX5_DEV_EVENT_PORT_AFFINITY)
 965                 return mlx5e_rep_tc_event_port_affinity(priv);
 966
 967         return NOTIFY_DONE;
 968 }
 969
 970 static void mlx5e_uplink_rep_enable(struct mlx5e_priv *priv)
 971 {
 972         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 973         struct net_device *netdev = priv->netdev;
 974         struct mlx5_core_dev *mdev = priv->mdev;
 975         u16 max_mtu;
 976
 977         netdev->min_mtu = ETH_MIN_MTU;
 978         mlx5_query_port_max_mtu(priv->mdev, &max_mtu, 1);
 979         netdev->max_mtu = MLX5E_HW2SW_MTU(&priv->channels.params, max_mtu);
 980         mlx5e_set_dev_port_mtu(priv);
 981
 982         mlx5e_rep_tc_enable(priv);
 983
 984         if (MLX5_CAP_GEN(mdev, uplink_follow))
 985                 mlx5_modify_vport_admin_state(mdev, MLX5_VPORT_STATE_OP_MOD_UPLINK,
 986                                               0, 0, MLX5_VPORT_ADMIN_STATE_AUTO);
 987         mlx5_lag_add_netdev(mdev, netdev);
 988         priv->events_nb.notifier_call = uplink_rep_async_event;
 989         mlx5_notifier_register(mdev, &priv->events_nb);
 990         mlx5e_dcbnl_initialize(priv);
 991         mlx5e_dcbnl_init_app(priv);
 992         mlx5e_rep_neigh_init(rpriv);
 993         mlx5e_rep_bridge_init(priv);
 994
 995         netdev->wanted_features |= NETIF_F_HW_TC;
 996
 997         rtnl_lock();
 998         if (netif_running(netdev))
 999                 mlx5e_open(netdev);
1000         netif_device_attach(netdev);
1001         rtnl_unlock();
1002 }
1003
1004 static void mlx5e_uplink_rep_disable(struct mlx5e_priv *priv)
1005 {
1006         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1007         struct mlx5_core_dev *mdev = priv->mdev;
1008
1009         rtnl_lock();
1010         if (netif_running(priv->netdev))
1011                 mlx5e_close(priv->netdev);
1012         netif_device_detach(priv->netdev);
1013         rtnl_unlock();
1014
1015         mlx5e_rep_bridge_cleanup(priv);
1016         mlx5e_rep_neigh_cleanup(rpriv);
1017         mlx5e_dcbnl_delete_app(priv);
1018         mlx5_notifier_unregister(mdev, &priv->events_nb);
1019         mlx5e_rep_tc_disable(priv);
1020         mlx5_lag_remove_netdev(mdev, priv->netdev);
1021 }
1022
1023 static MLX5E_DEFINE_STATS_GRP(sw_rep, 0);
1024 static MLX5E_DEFINE_STATS_GRP(vport_rep, MLX5E_NDO_UPDATE_STATS);
1025
1026 /* The stats groups order is opposite to the update_stats() order calls */
1027 static mlx5e_stats_grp_t mlx5e_rep_stats_grps[] = {
1028         &MLX5E_STATS_GRP(sw_rep),
1029         &MLX5E_STATS_GRP(vport_rep),
1030 };
1031
1032 static unsigned int mlx5e_rep_stats_grps_num(struct mlx5e_priv *priv)
1033 {
1034         return ARRAY_SIZE(mlx5e_rep_stats_grps);
1035 }
1036
1037 /* The stats groups order is opposite to the update_stats() order calls */
1038 static mlx5e_stats_grp_t mlx5e_ul_rep_stats_grps[] = {
1039         &MLX5E_STATS_GRP(sw),
1040         &MLX5E_STATS_GRP(qcnt),
1041         &MLX5E_STATS_GRP(vnic_env),
1042         &MLX5E_STATS_GRP(vport),
1043         &MLX5E_STATS_GRP(802_3),
1044         &MLX5E_STATS_GRP(2863),
1045         &MLX5E_STATS_GRP(2819),
1046         &MLX5E_STATS_GRP(phy),
1047         &MLX5E_STATS_GRP(eth_ext),
1048         &MLX5E_STATS_GRP(pcie),
1049         &MLX5E_STATS_GRP(per_prio),
1050         &MLX5E_STATS_GRP(pme),
1051         &MLX5E_STATS_GRP(channels),
1052         &MLX5E_STATS_GRP(per_port_buff_congest),
1053 };
1054
1055 static unsigned int mlx5e_ul_rep_stats_grps_num(struct mlx5e_priv *priv)
1056 {
1057         return ARRAY_SIZE(mlx5e_ul_rep_stats_grps);
1058 }
1059
1060 static const struct mlx5e_profile mlx5e_rep_profile = {
1061         .init                   = mlx5e_init_rep,
1062         .cleanup                = mlx5e_cleanup_rep,
1063         .init_rx                = mlx5e_init_rep_rx,
1064         .cleanup_rx             = mlx5e_cleanup_rep_rx,
1065         .init_tx                = mlx5e_init_rep_tx,
1066         .cleanup_tx             = mlx5e_cleanup_rep_tx,
1067         .enable                 = mlx5e_rep_enable,
1068         .disable                = mlx5e_rep_disable,
1069         .update_rx              = mlx5e_update_rep_rx,
1070         .update_stats           = mlx5e_stats_update_ndo_stats,
1071         .rx_handlers            = &mlx5e_rx_handlers_rep,
1072         .max_tc                 = 1,
1073         .rq_groups              = MLX5E_NUM_RQ_GROUPS(REGULAR),
1074         .stats_grps             = mlx5e_rep_stats_grps,
1075         .stats_grps_num         = mlx5e_rep_stats_grps_num,
1076         .rx_ptp_support         = false,
1077 };
1078
1079 static const struct mlx5e_profile mlx5e_uplink_rep_profile = {
1080         .init                   = mlx5e_init_ul_rep,
1081         .cleanup                = mlx5e_cleanup_rep,
1082         .init_rx                = mlx5e_init_ul_rep_rx,
1083         .cleanup_rx             = mlx5e_cleanup_ul_rep_rx,
1084         .init_tx                = mlx5e_init_rep_tx,
1085         .cleanup_tx             = mlx5e_cleanup_rep_tx,
1086         .enable                 = mlx5e_uplink_rep_enable,
1087         .disable                = mlx5e_uplink_rep_disable,
1088         .update_rx              = mlx5e_update_rep_rx,
1089         .update_stats           = mlx5e_stats_update_ndo_stats,
1090         .update_carrier         = mlx5e_update_carrier,
1091         .rx_handlers            = &mlx5e_rx_handlers_rep,
1092         .max_tc                 = MLX5E_MAX_NUM_TC,
1093         /* XSK is needed so we can replace profile with NIC netdev */
1094         .rq_groups              = MLX5E_NUM_RQ_GROUPS(XSK),
1095         .stats_grps             = mlx5e_ul_rep_stats_grps,
1096         .stats_grps_num         = mlx5e_ul_rep_stats_grps_num,
1097         .rx_ptp_support         = false,
1098 };
1099
1100 /* e-Switch vport representors */
1101 static int
1102 mlx5e_vport_uplink_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1103 {
1104         struct mlx5e_priv *priv = netdev_priv(mlx5_uplink_netdev_get(dev));
1105         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1106         struct devlink_port *dl_port;
1107         int err;
1108
1109         rpriv->netdev = priv->netdev;
1110
1111         err = mlx5e_netdev_change_profile(priv, &mlx5e_uplink_rep_profile,
1112                                           rpriv);
1113         if (err)
1114                 return err;
1115
1116         dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch, rpriv->rep->vport);
1117         if (dl_port)
1118                 devlink_port_type_eth_set(dl_port, rpriv->netdev);
1119
1120         return 0;
1121 }
1122
1123 static void
1124 mlx5e_vport_uplink_rep_unload(struct mlx5e_rep_priv *rpriv)
1125 {
1126         struct net_device *netdev = rpriv->netdev;
1127         struct devlink_port *dl_port;
1128         struct mlx5_core_dev *dev;
1129         struct mlx5e_priv *priv;
1130
1131         priv = netdev_priv(netdev);
1132         dev = priv->mdev;
1133
1134         dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch, rpriv->rep->vport);
1135         if (dl_port)
1136                 devlink_port_type_clear(dl_port);
1137         mlx5e_netdev_attach_nic_profile(priv);
1138 }
1139
1140 static int
1141 mlx5e_vport_vf_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1142 {
1143         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1144         const struct mlx5e_profile *profile;
1145         struct devlink_port *dl_port;
1146         struct net_device *netdev;
1147         struct mlx5e_priv *priv;
1148         unsigned int txqs, rxqs;
1149         int nch, err;
1150
1151         profile = &mlx5e_rep_profile;
1152         nch = mlx5e_get_max_num_channels(dev);
1153         txqs = nch * profile->max_tc;
1154         rxqs = nch * profile->rq_groups;
1155         netdev = mlx5e_create_netdev(dev, txqs, rxqs);
1156         if (!netdev) {
1157                 mlx5_core_warn(dev,
1158                                "Failed to create representor netdev for vport %d\n",
1159                                rep->vport);
1160                 return -EINVAL;
1161         }
1162
1163         mlx5e_build_rep_netdev(netdev, dev);
1164         rpriv->netdev = netdev;
1165
1166         priv = netdev_priv(netdev);
1167         priv->profile = profile;
1168         priv->ppriv = rpriv;
1169         err = profile->init(dev, netdev);
1170         if (err) {
1171                 netdev_warn(netdev, "rep profile init failed, %d\n", err);
1172                 goto err_destroy_netdev;
1173         }
1174
1175         err = mlx5e_attach_netdev(netdev_priv(netdev));
1176         if (err) {
1177                 netdev_warn(netdev,
1178                             "Failed to attach representor netdev for vport %d\n",
1179                             rep->vport);
1180                 goto err_cleanup_profile;
1181         }
1182
1183         err = register_netdev(netdev);
1184         if (err) {
1185                 netdev_warn(netdev,
1186                             "Failed to register representor netdev for vport %d\n",
1187                             rep->vport);
1188                 goto err_detach_netdev;
1189         }
1190
1191         dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch, rpriv->rep->vport);
1192         if (dl_port)
1193                 devlink_port_type_eth_set(dl_port, netdev);
1194         return 0;
1195
1196 err_detach_netdev:
1197         mlx5e_detach_netdev(netdev_priv(netdev));
1198
1199 err_cleanup_profile:
1200         priv->profile->cleanup(priv);
1201
1202 err_destroy_netdev:
1203         mlx5e_destroy_netdev(netdev_priv(netdev));
1204         return err;
1205 }
1206
1207 static int
1208 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1209 {
1210         struct mlx5e_rep_priv *rpriv;
1211         int err;
1212
1213         rpriv = kzalloc(sizeof(*rpriv), GFP_KERNEL);
1214         if (!rpriv)
1215                 return -ENOMEM;
1216
1217         /* rpriv->rep to be looked up when profile->init() is called */
1218         rpriv->rep = rep;
1219         rep->rep_data[REP_ETH].priv = rpriv;
1220         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1221
1222         if (rep->vport == MLX5_VPORT_UPLINK)
1223                 err = mlx5e_vport_uplink_rep_load(dev, rep);
1224         else
1225                 err = mlx5e_vport_vf_rep_load(dev, rep);
1226
1227         if (err)
1228                 kfree(rpriv);
1229
1230         return err;
1231 }
1232
1233 static void
1234 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep)
1235 {
1236         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1237         struct net_device *netdev = rpriv->netdev;
1238         struct mlx5e_priv *priv = netdev_priv(netdev);
1239         struct mlx5_core_dev *dev = priv->mdev;
1240         struct devlink_port *dl_port;
1241         void *ppriv = priv->ppriv;
1242
1243         if (rep->vport == MLX5_VPORT_UPLINK) {
1244                 mlx5e_vport_uplink_rep_unload(rpriv);
1245                 goto free_ppriv;
1246         }
1247
1248         dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch, rpriv->rep->vport);
1249         if (dl_port)
1250                 devlink_port_type_clear(dl_port);
1251         unregister_netdev(netdev);
1252         mlx5e_detach_netdev(priv);
1253         priv->profile->cleanup(priv);
1254         mlx5e_destroy_netdev(priv);
1255 free_ppriv:
1256         kfree(ppriv); /* mlx5e_rep_priv */
1257 }
1258
1259 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep)
1260 {
1261         struct mlx5e_rep_priv *rpriv;
1262
1263         rpriv = mlx5e_rep_to_rep_priv(rep);
1264
1265         return rpriv->netdev;
1266 }
1267
1268 static const struct mlx5_eswitch_rep_ops rep_ops = {
1269         .load = mlx5e_vport_rep_load,
1270         .unload = mlx5e_vport_rep_unload,
1271         .get_proto_dev = mlx5e_vport_rep_get_proto_dev
1272 };
1273
1274 static int mlx5e_rep_probe(struct auxiliary_device *adev,
1275                            const struct auxiliary_device_id *id)
1276 {
1277         struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
1278         struct mlx5_core_dev *mdev = edev->mdev;
1279         struct mlx5_eswitch *esw;
1280
1281         esw = mdev->priv.eswitch;
1282         mlx5_eswitch_register_vport_reps(esw, &rep_ops, REP_ETH);
1283         return 0;
1284 }
1285
1286 static void mlx5e_rep_remove(struct auxiliary_device *adev)
1287 {
1288         struct mlx5_adev *vdev = container_of(adev, struct mlx5_adev, adev);
1289         struct mlx5_core_dev *mdev = vdev->mdev;
1290         struct mlx5_eswitch *esw;
1291
1292         esw = mdev->priv.eswitch;
1293         mlx5_eswitch_unregister_vport_reps(esw, REP_ETH);
1294 }
1295
1296 static const struct auxiliary_device_id mlx5e_rep_id_table[] = {
1297         { .name = MLX5_ADEV_NAME ".eth-rep", },
1298         {},
1299 };
1300
1301 MODULE_DEVICE_TABLE(auxiliary, mlx5e_rep_id_table);
1302
1303 static struct auxiliary_driver mlx5e_rep_driver = {
1304         .name = "eth-rep",
1305         .probe = mlx5e_rep_probe,
1306         .remove = mlx5e_rep_remove,
1307         .id_table = mlx5e_rep_id_table,
1308 };
1309
1310 int mlx5e_rep_init(void)
1311 {
1312         return auxiliary_driver_register(&mlx5e_rep_driver);
1313 }
1314
1315 void mlx5e_rep_cleanup(void)
1316 {
1317         auxiliary_driver_unregister(&mlx5e_rep_driver);
1318 }