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