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 <generated/utsrelease.h>
  34 #include <linux/mlx5/fs.h>
  35 #include <net/switchdev.h>
  36 #include <net/pkt_cls.h>
  37 #include <net/act_api.h>
  38 #include <net/netevent.h>
  39 #include <net/arp.h>
  40
  41 #include "eswitch.h"
  42 #include "en.h"
  43 #include "en_rep.h"
  44 #include "en_tc.h"
  45 #include "fs_core.h"
  46
  47 #define MLX5E_REP_PARAMS_LOG_SQ_SIZE \
  48         max(0x6, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)
  49
  50 static const char mlx5e_rep_driver_name[] = "mlx5e_rep";
  51
  52 static void mlx5e_rep_get_drvinfo(struct net_device *dev,
  53                                   struct ethtool_drvinfo *drvinfo)
  54 {
  55         strlcpy(drvinfo->driver, mlx5e_rep_driver_name,
  56                 sizeof(drvinfo->driver));
  57         strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version));
  58 }
  59
  60 static const struct counter_desc sw_rep_stats_desc[] = {
  61         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_packets) },
  62         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) },
  63         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) },
  64         { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) },
  65 };
  66
  67 struct vport_stats {
  68         u64 vport_rx_packets;
  69         u64 vport_tx_packets;
  70         u64 vport_rx_bytes;
  71         u64 vport_tx_bytes;
  72 };
  73
  74 static const struct counter_desc vport_rep_stats_desc[] = {
  75         { MLX5E_DECLARE_STAT(struct vport_stats, vport_rx_packets) },
  76         { MLX5E_DECLARE_STAT(struct vport_stats, vport_rx_bytes) },
  77         { MLX5E_DECLARE_STAT(struct vport_stats, vport_tx_packets) },
  78         { MLX5E_DECLARE_STAT(struct vport_stats, vport_tx_bytes) },
  79 };
  80
  81 #define NUM_VPORT_REP_SW_COUNTERS ARRAY_SIZE(sw_rep_stats_desc)
  82 #define NUM_VPORT_REP_HW_COUNTERS ARRAY_SIZE(vport_rep_stats_desc)
  83
  84 static void mlx5e_rep_get_strings(struct net_device *dev,
  85                                   u32 stringset, uint8_t *data)
  86 {
  87         int i, j;
  88
  89         switch (stringset) {
  90         case ETH_SS_STATS:
  91                 for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++)
  92                         strcpy(data + (i * ETH_GSTRING_LEN),
  93                                sw_rep_stats_desc[i].format);
  94                 for (j = 0; j < NUM_VPORT_REP_HW_COUNTERS; j++, i++)
  95                         strcpy(data + (i * ETH_GSTRING_LEN),
  96                                vport_rep_stats_desc[j].format);
  97                 break;
  98         }
  99 }
 100
 101 static void mlx5e_rep_update_hw_counters(struct mlx5e_priv *priv)
 102 {
 103         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 104         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 105         struct mlx5_eswitch_rep *rep = rpriv->rep;
 106         struct rtnl_link_stats64 *vport_stats;
 107         struct ifla_vf_stats vf_stats;
 108         int err;
 109
 110         err = mlx5_eswitch_get_vport_stats(esw, rep->vport, &vf_stats);
 111         if (err) {
 112                 pr_warn("vport %d error %d reading stats\n", rep->vport, err);
 113                 return;
 114         }
 115
 116         vport_stats = &priv->stats.vf_vport;
 117         /* flip tx/rx as we are reporting the counters for the switch vport */
 118         vport_stats->rx_packets = vf_stats.tx_packets;
 119         vport_stats->rx_bytes   = vf_stats.tx_bytes;
 120         vport_stats->tx_packets = vf_stats.rx_packets;
 121         vport_stats->tx_bytes   = vf_stats.rx_bytes;
 122 }
 123
 124 static void mlx5e_rep_update_sw_counters(struct mlx5e_priv *priv)
 125 {
 126         struct mlx5e_sw_stats *s = &priv->stats.sw;
 127         struct mlx5e_rq_stats *rq_stats;
 128         struct mlx5e_sq_stats *sq_stats;
 129         int i, j;
 130
 131         memset(s, 0, sizeof(*s));
 132         for (i = 0; i < priv->channels.num; i++) {
 133                 struct mlx5e_channel *c = priv->channels.c[i];
 134
 135                 rq_stats = c->rq.stats;
 136
 137                 s->rx_packets   += rq_stats->packets;
 138                 s->rx_bytes     += rq_stats->bytes;
 139
 140                 for (j = 0; j < priv->channels.params.num_tc; j++) {
 141                         sq_stats = c->sq[j].stats;
 142
 143                         s->tx_packets           += sq_stats->packets;
 144                         s->tx_bytes             += sq_stats->bytes;
 145                 }
 146         }
 147 }
 148
 149 static void mlx5e_rep_get_ethtool_stats(struct net_device *dev,
 150                                         struct ethtool_stats *stats, u64 *data)
 151 {
 152         struct mlx5e_priv *priv = netdev_priv(dev);
 153         int i, j;
 154
 155         if (!data)
 156                 return;
 157
 158         mutex_lock(&priv->state_lock);
 159         if (test_bit(MLX5E_STATE_OPENED, &priv->state))
 160                 mlx5e_rep_update_sw_counters(priv);
 161         mlx5e_rep_update_hw_counters(priv);
 162         mutex_unlock(&priv->state_lock);
 163
 164         for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++)
 165                 data[i] = MLX5E_READ_CTR64_CPU(&priv->stats.sw,
 166                                                sw_rep_stats_desc, i);
 167
 168         for (j = 0; j < NUM_VPORT_REP_HW_COUNTERS; j++, i++)
 169                 data[i] = MLX5E_READ_CTR64_CPU(&priv->stats.vf_vport,
 170                                                vport_rep_stats_desc, j);
 171 }
 172
 173 static int mlx5e_rep_get_sset_count(struct net_device *dev, int sset)
 174 {
 175         switch (sset) {
 176         case ETH_SS_STATS:
 177                 return NUM_VPORT_REP_SW_COUNTERS + NUM_VPORT_REP_HW_COUNTERS;
 178         default:
 179                 return -EOPNOTSUPP;
 180         }
 181 }
 182
 183 static void mlx5e_rep_get_ringparam(struct net_device *dev,
 184                                 struct ethtool_ringparam *param)
 185 {
 186         struct mlx5e_priv *priv = netdev_priv(dev);
 187
 188         mlx5e_ethtool_get_ringparam(priv, param);
 189 }
 190
 191 static int mlx5e_rep_set_ringparam(struct net_device *dev,
 192                                struct ethtool_ringparam *param)
 193 {
 194         struct mlx5e_priv *priv = netdev_priv(dev);
 195
 196         return mlx5e_ethtool_set_ringparam(priv, param);
 197 }
 198
 199 static int mlx5e_replace_rep_vport_rx_rule(struct mlx5e_priv *priv,
 200                                            struct mlx5_flow_destination *dest)
 201 {
 202         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 203         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 204         struct mlx5_eswitch_rep *rep = rpriv->rep;
 205         struct mlx5_flow_handle *flow_rule;
 206
 207         flow_rule = mlx5_eswitch_create_vport_rx_rule(esw,
 208                                                       rep->vport,
 209                                                       dest);
 210         if (IS_ERR(flow_rule))
 211                 return PTR_ERR(flow_rule);
 212
 213         mlx5_del_flow_rules(rpriv->vport_rx_rule);
 214         rpriv->vport_rx_rule = flow_rule;
 215         return 0;
 216 }
 217
 218 static void mlx5e_rep_get_channels(struct net_device *dev,
 219                                    struct ethtool_channels *ch)
 220 {
 221         struct mlx5e_priv *priv = netdev_priv(dev);
 222
 223         mlx5e_ethtool_get_channels(priv, ch);
 224 }
 225
 226 static int mlx5e_rep_set_channels(struct net_device *dev,
 227                                   struct ethtool_channels *ch)
 228 {
 229         struct mlx5e_priv *priv = netdev_priv(dev);
 230         u16 curr_channels_amount = priv->channels.params.num_channels;
 231         u32 new_channels_amount = ch->combined_count;
 232         struct mlx5_flow_destination new_dest;
 233         int err = 0;
 234
 235         err = mlx5e_ethtool_set_channels(priv, ch);
 236         if (err)
 237                 return err;
 238
 239         if (curr_channels_amount == 1 && new_channels_amount > 1) {
 240                 new_dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 241                 new_dest.ft = priv->fs.ttc.ft.t;
 242         } else if (new_channels_amount == 1 && curr_channels_amount > 1) {
 243                 new_dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 244                 new_dest.tir_num = priv->direct_tir[0].tirn;
 245         } else {
 246                 return 0;
 247         }
 248
 249         err = mlx5e_replace_rep_vport_rx_rule(priv, &new_dest);
 250         if (err) {
 251                 netdev_warn(priv->netdev, "Failed to update vport rx rule, when going from (%d) channels to (%d) channels\n",
 252                             curr_channels_amount, new_channels_amount);
 253                 return err;
 254         }
 255
 256         return 0;
 257 }
 258
 259 static u32 mlx5e_rep_get_rxfh_key_size(struct net_device *netdev)
 260 {
 261         struct mlx5e_priv *priv = netdev_priv(netdev);
 262
 263         return mlx5e_ethtool_get_rxfh_key_size(priv);
 264 }
 265
 266 static u32 mlx5e_rep_get_rxfh_indir_size(struct net_device *netdev)
 267 {
 268         struct mlx5e_priv *priv = netdev_priv(netdev);
 269
 270         return mlx5e_ethtool_get_rxfh_indir_size(priv);
 271 }
 272
 273 static const struct ethtool_ops mlx5e_rep_ethtool_ops = {
 274         .get_drvinfo       = mlx5e_rep_get_drvinfo,
 275         .get_link          = ethtool_op_get_link,
 276         .get_strings       = mlx5e_rep_get_strings,
 277         .get_sset_count    = mlx5e_rep_get_sset_count,
 278         .get_ethtool_stats = mlx5e_rep_get_ethtool_stats,
 279         .get_ringparam     = mlx5e_rep_get_ringparam,
 280         .set_ringparam     = mlx5e_rep_set_ringparam,
 281         .get_channels      = mlx5e_rep_get_channels,
 282         .set_channels      = mlx5e_rep_set_channels,
 283         .get_rxfh_key_size   = mlx5e_rep_get_rxfh_key_size,
 284         .get_rxfh_indir_size = mlx5e_rep_get_rxfh_indir_size,
 285 };
 286
 287 int mlx5e_attr_get(struct net_device *dev, struct switchdev_attr *attr)
 288 {
 289         struct mlx5e_priv *priv = netdev_priv(dev);
 290         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 291         struct mlx5_eswitch_rep *rep = rpriv->rep;
 292         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 293
 294         if (esw->mode == SRIOV_NONE)
 295                 return -EOPNOTSUPP;
 296
 297         switch (attr->id) {
 298         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
 299                 attr->u.ppid.id_len = ETH_ALEN;
 300                 ether_addr_copy(attr->u.ppid.id, rep->hw_id);
 301                 break;
 302         default:
 303                 return -EOPNOTSUPP;
 304         }
 305
 306         return 0;
 307 }
 308
 309 static void mlx5e_sqs2vport_stop(struct mlx5_eswitch *esw,
 310                                  struct mlx5_eswitch_rep *rep)
 311 {
 312         struct mlx5e_rep_sq *rep_sq, *tmp;
 313         struct mlx5e_rep_priv *rpriv;
 314
 315         if (esw->mode != SRIOV_OFFLOADS)
 316                 return;
 317
 318         rpriv = mlx5e_rep_to_rep_priv(rep);
 319         list_for_each_entry_safe(rep_sq, tmp, &rpriv->vport_sqs_list, list) {
 320                 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule);
 321                 list_del(&rep_sq->list);
 322                 kfree(rep_sq);
 323         }
 324 }
 325
 326 static int mlx5e_sqs2vport_start(struct mlx5_eswitch *esw,
 327                                  struct mlx5_eswitch_rep *rep,
 328                                  u32 *sqns_array, int sqns_num)
 329 {
 330         struct mlx5_flow_handle *flow_rule;
 331         struct mlx5e_rep_priv *rpriv;
 332         struct mlx5e_rep_sq *rep_sq;
 333         int err;
 334         int i;
 335
 336         if (esw->mode != SRIOV_OFFLOADS)
 337                 return 0;
 338
 339         rpriv = mlx5e_rep_to_rep_priv(rep);
 340         for (i = 0; i < sqns_num; i++) {
 341                 rep_sq = kzalloc(sizeof(*rep_sq), GFP_KERNEL);
 342                 if (!rep_sq) {
 343                         err = -ENOMEM;
 344                         goto out_err;
 345                 }
 346
 347                 /* Add re-inject rule to the PF/representor sqs */
 348                 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw,
 349                                                                 rep->vport,
 350                                                                 sqns_array[i]);
 351                 if (IS_ERR(flow_rule)) {
 352                         err = PTR_ERR(flow_rule);
 353                         kfree(rep_sq);
 354                         goto out_err;
 355                 }
 356                 rep_sq->send_to_vport_rule = flow_rule;
 357                 list_add(&rep_sq->list, &rpriv->vport_sqs_list);
 358         }
 359         return 0;
 360
 361 out_err:
 362         mlx5e_sqs2vport_stop(esw, rep);
 363         return err;
 364 }
 365
 366 int mlx5e_add_sqs_fwd_rules(struct mlx5e_priv *priv)
 367 {
 368         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 369         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 370         struct mlx5_eswitch_rep *rep = rpriv->rep;
 371         struct mlx5e_channel *c;
 372         int n, tc, num_sqs = 0;
 373         int err = -ENOMEM;
 374         u32 *sqs;
 375
 376         sqs = kcalloc(priv->channels.num * priv->channels.params.num_tc, sizeof(*sqs), GFP_KERNEL);
 377         if (!sqs)
 378                 goto out;
 379
 380         for (n = 0; n < priv->channels.num; n++) {
 381                 c = priv->channels.c[n];
 382                 for (tc = 0; tc < c->num_tc; tc++)
 383                         sqs[num_sqs++] = c->sq[tc].sqn;
 384         }
 385
 386         err = mlx5e_sqs2vport_start(esw, rep, sqs, num_sqs);
 387         kfree(sqs);
 388
 389 out:
 390         if (err)
 391                 netdev_warn(priv->netdev, "Failed to add SQs FWD rules %d\n", err);
 392         return err;
 393 }
 394
 395 void mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv)
 396 {
 397         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 398         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 399         struct mlx5_eswitch_rep *rep = rpriv->rep;
 400
 401         mlx5e_sqs2vport_stop(esw, rep);
 402 }
 403
 404 static void mlx5e_rep_neigh_update_init_interval(struct mlx5e_rep_priv *rpriv)
 405 {
 406 #if IS_ENABLED(CONFIG_IPV6)
 407         unsigned long ipv6_interval = NEIGH_VAR(&nd_tbl.parms,
 408                                                 DELAY_PROBE_TIME);
 409 #else
 410         unsigned long ipv6_interval = ~0UL;
 411 #endif
 412         unsigned long ipv4_interval = NEIGH_VAR(&arp_tbl.parms,
 413                                                 DELAY_PROBE_TIME);
 414         struct net_device *netdev = rpriv->netdev;
 415         struct mlx5e_priv *priv = netdev_priv(netdev);
 416
 417         rpriv->neigh_update.min_interval = min_t(unsigned long, ipv6_interval, ipv4_interval);
 418         mlx5_fc_update_sampling_interval(priv->mdev, rpriv->neigh_update.min_interval);
 419 }
 420
 421 void mlx5e_rep_queue_neigh_stats_work(struct mlx5e_priv *priv)
 422 {
 423         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 424         struct mlx5e_neigh_update_table *neigh_update = &rpriv->neigh_update;
 425
 426         mlx5_fc_queue_stats_work(priv->mdev,
 427                                  &neigh_update->neigh_stats_work,
 428                                  neigh_update->min_interval);
 429 }
 430
 431 static void mlx5e_rep_neigh_stats_work(struct work_struct *work)
 432 {
 433         struct mlx5e_rep_priv *rpriv = container_of(work, struct mlx5e_rep_priv,
 434                                                     neigh_update.neigh_stats_work.work);
 435         struct net_device *netdev = rpriv->netdev;
 436         struct mlx5e_priv *priv = netdev_priv(netdev);
 437         struct mlx5e_neigh_hash_entry *nhe;
 438
 439         rtnl_lock();
 440         if (!list_empty(&rpriv->neigh_update.neigh_list))
 441                 mlx5e_rep_queue_neigh_stats_work(priv);
 442
 443         list_for_each_entry(nhe, &rpriv->neigh_update.neigh_list, neigh_list)
 444                 mlx5e_tc_update_neigh_used_value(nhe);
 445
 446         rtnl_unlock();
 447 }
 448
 449 static void mlx5e_rep_neigh_entry_hold(struct mlx5e_neigh_hash_entry *nhe)
 450 {
 451         refcount_inc(&nhe->refcnt);
 452 }
 453
 454 static void mlx5e_rep_neigh_entry_release(struct mlx5e_neigh_hash_entry *nhe)
 455 {
 456         if (refcount_dec_and_test(&nhe->refcnt))
 457                 kfree(nhe);
 458 }
 459
 460 static void mlx5e_rep_update_flows(struct mlx5e_priv *priv,
 461                                    struct mlx5e_encap_entry *e,
 462                                    bool neigh_connected,
 463                                    unsigned char ha[ETH_ALEN])
 464 {
 465         struct ethhdr *eth = (struct ethhdr *)e->encap_header;
 466
 467         ASSERT_RTNL();
 468
 469         if ((!neigh_connected && (e->flags & MLX5_ENCAP_ENTRY_VALID)) ||
 470             !ether_addr_equal(e->h_dest, ha))
 471                 mlx5e_tc_encap_flows_del(priv, e);
 472
 473         if (neigh_connected && !(e->flags & MLX5_ENCAP_ENTRY_VALID)) {
 474                 ether_addr_copy(e->h_dest, ha);
 475                 ether_addr_copy(eth->h_dest, ha);
 476
 477                 mlx5e_tc_encap_flows_add(priv, e);
 478         }
 479 }
 480
 481 static void mlx5e_rep_neigh_update(struct work_struct *work)
 482 {
 483         struct mlx5e_neigh_hash_entry *nhe =
 484                 container_of(work, struct mlx5e_neigh_hash_entry, neigh_update_work);
 485         struct neighbour *n = nhe->n;
 486         struct mlx5e_encap_entry *e;
 487         unsigned char ha[ETH_ALEN];
 488         struct mlx5e_priv *priv;
 489         bool neigh_connected;
 490         bool encap_connected;
 491         u8 nud_state, dead;
 492
 493         rtnl_lock();
 494
 495         /* If these parameters are changed after we release the lock,
 496          * we'll receive another event letting us know about it.
 497          * We use this lock to avoid inconsistency between the neigh validity
 498          * and it's hw address.
 499          */
 500         read_lock_bh(&n->lock);
 501         memcpy(ha, n->ha, ETH_ALEN);
 502         nud_state = n->nud_state;
 503         dead = n->dead;
 504         read_unlock_bh(&n->lock);
 505
 506         neigh_connected = (nud_state & NUD_VALID) && !dead;
 507
 508         list_for_each_entry(e, &nhe->encap_list, encap_list) {
 509                 encap_connected = !!(e->flags & MLX5_ENCAP_ENTRY_VALID);
 510                 priv = netdev_priv(e->out_dev);
 511
 512                 if (encap_connected != neigh_connected ||
 513                     !ether_addr_equal(e->h_dest, ha))
 514                         mlx5e_rep_update_flows(priv, e, neigh_connected, ha);
 515         }
 516         mlx5e_rep_neigh_entry_release(nhe);
 517         rtnl_unlock();
 518         neigh_release(n);
 519 }
 520
 521 static struct mlx5e_neigh_hash_entry *
 522 mlx5e_rep_neigh_entry_lookup(struct mlx5e_priv *priv,
 523                              struct mlx5e_neigh *m_neigh);
 524
 525 static int mlx5e_rep_netevent_event(struct notifier_block *nb,
 526                                     unsigned long event, void *ptr)
 527 {
 528         struct mlx5e_rep_priv *rpriv = container_of(nb, struct mlx5e_rep_priv,
 529                                                     neigh_update.netevent_nb);
 530         struct mlx5e_neigh_update_table *neigh_update = &rpriv->neigh_update;
 531         struct net_device *netdev = rpriv->netdev;
 532         struct mlx5e_priv *priv = netdev_priv(netdev);
 533         struct mlx5e_neigh_hash_entry *nhe = NULL;
 534         struct mlx5e_neigh m_neigh = {};
 535         struct neigh_parms *p;
 536         struct neighbour *n;
 537         bool found = false;
 538
 539         switch (event) {
 540         case NETEVENT_NEIGH_UPDATE:
 541                 n = ptr;
 542 #if IS_ENABLED(CONFIG_IPV6)
 543                 if (n->tbl != &nd_tbl && n->tbl != &arp_tbl)
 544 #else
 545                 if (n->tbl != &arp_tbl)
 546 #endif
 547                         return NOTIFY_DONE;
 548
 549                 m_neigh.dev = n->dev;
 550                 m_neigh.family = n->ops->family;
 551                 memcpy(&m_neigh.dst_ip, n->primary_key, n->tbl->key_len);
 552
 553                 /* We are in atomic context and can't take RTNL mutex, so use
 554                  * spin_lock_bh to lookup the neigh table. bh is used since
 555                  * netevent can be called from a softirq context.
 556                  */
 557                 spin_lock_bh(&neigh_update->encap_lock);
 558                 nhe = mlx5e_rep_neigh_entry_lookup(priv, &m_neigh);
 559                 if (!nhe) {
 560                         spin_unlock_bh(&neigh_update->encap_lock);
 561                         return NOTIFY_DONE;
 562                 }
 563
 564                 /* This assignment is valid as long as the the neigh reference
 565                  * is taken
 566                  */
 567                 nhe->n = n;
 568
 569                 /* Take a reference to ensure the neighbour and mlx5 encap
 570                  * entry won't be destructed until we drop the reference in
 571                  * delayed work.
 572                  */
 573                 neigh_hold(n);
 574                 mlx5e_rep_neigh_entry_hold(nhe);
 575
 576                 if (!queue_work(priv->wq, &nhe->neigh_update_work)) {
 577                         mlx5e_rep_neigh_entry_release(nhe);
 578                         neigh_release(n);
 579                 }
 580                 spin_unlock_bh(&neigh_update->encap_lock);
 581                 break;
 582
 583         case NETEVENT_DELAY_PROBE_TIME_UPDATE:
 584                 p = ptr;
 585
 586                 /* We check the device is present since we don't care about
 587                  * changes in the default table, we only care about changes
 588                  * done per device delay prob time parameter.
 589                  */
 590 #if IS_ENABLED(CONFIG_IPV6)
 591                 if (!p->dev || (p->tbl != &nd_tbl && p->tbl != &arp_tbl))
 592 #else
 593                 if (!p->dev || p->tbl != &arp_tbl)
 594 #endif
 595                         return NOTIFY_DONE;
 596
 597                 /* We are in atomic context and can't take RTNL mutex,
 598                  * so use spin_lock_bh to walk the neigh list and look for
 599                  * the relevant device. bh is used since netevent can be
 600                  * called from a softirq context.
 601                  */
 602                 spin_lock_bh(&neigh_update->encap_lock);
 603                 list_for_each_entry(nhe, &neigh_update->neigh_list, neigh_list) {
 604                         if (p->dev == nhe->m_neigh.dev) {
 605                                 found = true;
 606                                 break;
 607                         }
 608                 }
 609                 spin_unlock_bh(&neigh_update->encap_lock);
 610                 if (!found)
 611                         return NOTIFY_DONE;
 612
 613                 neigh_update->min_interval = min_t(unsigned long,
 614                                                    NEIGH_VAR(p, DELAY_PROBE_TIME),
 615                                                    neigh_update->min_interval);
 616                 mlx5_fc_update_sampling_interval(priv->mdev,
 617                                                  neigh_update->min_interval);
 618                 break;
 619         }
 620         return NOTIFY_DONE;
 621 }
 622
 623 static const struct rhashtable_params mlx5e_neigh_ht_params = {
 624         .head_offset = offsetof(struct mlx5e_neigh_hash_entry, rhash_node),
 625         .key_offset = offsetof(struct mlx5e_neigh_hash_entry, m_neigh),
 626         .key_len = sizeof(struct mlx5e_neigh),
 627         .automatic_shrinking = true,
 628 };
 629
 630 static int mlx5e_rep_neigh_init(struct mlx5e_rep_priv *rpriv)
 631 {
 632         struct mlx5e_neigh_update_table *neigh_update = &rpriv->neigh_update;
 633         int err;
 634
 635         err = rhashtable_init(&neigh_update->neigh_ht, &mlx5e_neigh_ht_params);
 636         if (err)
 637                 return err;
 638
 639         INIT_LIST_HEAD(&neigh_update->neigh_list);
 640         spin_lock_init(&neigh_update->encap_lock);
 641         INIT_DELAYED_WORK(&neigh_update->neigh_stats_work,
 642                           mlx5e_rep_neigh_stats_work);
 643         mlx5e_rep_neigh_update_init_interval(rpriv);
 644
 645         rpriv->neigh_update.netevent_nb.notifier_call = mlx5e_rep_netevent_event;
 646         err = register_netevent_notifier(&rpriv->neigh_update.netevent_nb);
 647         if (err)
 648                 goto out_err;
 649         return 0;
 650
 651 out_err:
 652         rhashtable_destroy(&neigh_update->neigh_ht);
 653         return err;
 654 }
 655
 656 static void mlx5e_rep_neigh_cleanup(struct mlx5e_rep_priv *rpriv)
 657 {
 658         struct mlx5e_neigh_update_table *neigh_update = &rpriv->neigh_update;
 659         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
 660
 661         unregister_netevent_notifier(&neigh_update->netevent_nb);
 662
 663         flush_workqueue(priv->wq); /* flush neigh update works */
 664
 665         cancel_delayed_work_sync(&rpriv->neigh_update.neigh_stats_work);
 666
 667         rhashtable_destroy(&neigh_update->neigh_ht);
 668 }
 669
 670 static int mlx5e_rep_neigh_entry_insert(struct mlx5e_priv *priv,
 671                                         struct mlx5e_neigh_hash_entry *nhe)
 672 {
 673         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 674         int err;
 675
 676         err = rhashtable_insert_fast(&rpriv->neigh_update.neigh_ht,
 677                                      &nhe->rhash_node,
 678                                      mlx5e_neigh_ht_params);
 679         if (err)
 680                 return err;
 681
 682         list_add(&nhe->neigh_list, &rpriv->neigh_update.neigh_list);
 683
 684         return err;
 685 }
 686
 687 static void mlx5e_rep_neigh_entry_remove(struct mlx5e_priv *priv,
 688                                          struct mlx5e_neigh_hash_entry *nhe)
 689 {
 690         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 691
 692         spin_lock_bh(&rpriv->neigh_update.encap_lock);
 693
 694         list_del(&nhe->neigh_list);
 695
 696         rhashtable_remove_fast(&rpriv->neigh_update.neigh_ht,
 697                                &nhe->rhash_node,
 698                                mlx5e_neigh_ht_params);
 699         spin_unlock_bh(&rpriv->neigh_update.encap_lock);
 700 }
 701
 702 /* This function must only be called under RTNL lock or under the
 703  * representor's encap_lock in case RTNL mutex can't be held.
 704  */
 705 static struct mlx5e_neigh_hash_entry *
 706 mlx5e_rep_neigh_entry_lookup(struct mlx5e_priv *priv,
 707                              struct mlx5e_neigh *m_neigh)
 708 {
 709         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 710         struct mlx5e_neigh_update_table *neigh_update = &rpriv->neigh_update;
 711
 712         return rhashtable_lookup_fast(&neigh_update->neigh_ht, m_neigh,
 713                                       mlx5e_neigh_ht_params);
 714 }
 715
 716 static int mlx5e_rep_neigh_entry_create(struct mlx5e_priv *priv,
 717                                         struct mlx5e_encap_entry *e,
 718                                         struct mlx5e_neigh_hash_entry **nhe)
 719 {
 720         int err;
 721
 722         *nhe = kzalloc(sizeof(**nhe), GFP_KERNEL);
 723         if (!*nhe)
 724                 return -ENOMEM;
 725
 726         memcpy(&(*nhe)->m_neigh, &e->m_neigh, sizeof(e->m_neigh));
 727         INIT_WORK(&(*nhe)->neigh_update_work, mlx5e_rep_neigh_update);
 728         INIT_LIST_HEAD(&(*nhe)->encap_list);
 729         refcount_set(&(*nhe)->refcnt, 1);
 730
 731         err = mlx5e_rep_neigh_entry_insert(priv, *nhe);
 732         if (err)
 733                 goto out_free;
 734         return 0;
 735
 736 out_free:
 737         kfree(*nhe);
 738         return err;
 739 }
 740
 741 static void mlx5e_rep_neigh_entry_destroy(struct mlx5e_priv *priv,
 742                                           struct mlx5e_neigh_hash_entry *nhe)
 743 {
 744         /* The neigh hash entry must be removed from the hash table regardless
 745          * of the reference count value, so it won't be found by the next
 746          * neigh notification call. The neigh hash entry reference count is
 747          * incremented only during creation and neigh notification calls and
 748          * protects from freeing the nhe struct.
 749          */
 750         mlx5e_rep_neigh_entry_remove(priv, nhe);
 751         mlx5e_rep_neigh_entry_release(nhe);
 752 }
 753
 754 int mlx5e_rep_encap_entry_attach(struct mlx5e_priv *priv,
 755                                  struct mlx5e_encap_entry *e)
 756 {
 757         struct mlx5e_neigh_hash_entry *nhe;
 758         int err;
 759
 760         nhe = mlx5e_rep_neigh_entry_lookup(priv, &e->m_neigh);
 761         if (!nhe) {
 762                 err = mlx5e_rep_neigh_entry_create(priv, e, &nhe);
 763                 if (err)
 764                         return err;
 765         }
 766         list_add(&e->encap_list, &nhe->encap_list);
 767         return 0;
 768 }
 769
 770 void mlx5e_rep_encap_entry_detach(struct mlx5e_priv *priv,
 771                                   struct mlx5e_encap_entry *e)
 772 {
 773         struct mlx5e_neigh_hash_entry *nhe;
 774
 775         list_del(&e->encap_list);
 776         nhe = mlx5e_rep_neigh_entry_lookup(priv, &e->m_neigh);
 777
 778         if (list_empty(&nhe->encap_list))
 779                 mlx5e_rep_neigh_entry_destroy(priv, nhe);
 780 }
 781
 782 static int mlx5e_rep_open(struct net_device *dev)
 783 {
 784         struct mlx5e_priv *priv = netdev_priv(dev);
 785         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 786         struct mlx5_eswitch_rep *rep = rpriv->rep;
 787         int err;
 788
 789         mutex_lock(&priv->state_lock);
 790         err = mlx5e_open_locked(dev);
 791         if (err)
 792                 goto unlock;
 793
 794         if (!mlx5_modify_vport_admin_state(priv->mdev,
 795                                            MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 796                                            rep->vport, MLX5_VPORT_ADMIN_STATE_UP))
 797                 netif_carrier_on(dev);
 798
 799 unlock:
 800         mutex_unlock(&priv->state_lock);
 801         return err;
 802 }
 803
 804 static int mlx5e_rep_close(struct net_device *dev)
 805 {
 806         struct mlx5e_priv *priv = netdev_priv(dev);
 807         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 808         struct mlx5_eswitch_rep *rep = rpriv->rep;
 809         int ret;
 810
 811         mutex_lock(&priv->state_lock);
 812         mlx5_modify_vport_admin_state(priv->mdev,
 813                                       MLX5_VPORT_STATE_OP_MOD_ESW_VPORT,
 814                                       rep->vport, MLX5_VPORT_ADMIN_STATE_DOWN);
 815         ret = mlx5e_close_locked(dev);
 816         mutex_unlock(&priv->state_lock);
 817         return ret;
 818 }
 819
 820 static int mlx5e_rep_get_phys_port_name(struct net_device *dev,
 821                                         char *buf, size_t len)
 822 {
 823         struct mlx5e_priv *priv = netdev_priv(dev);
 824         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 825         struct mlx5_eswitch_rep *rep = rpriv->rep;
 826         int ret;
 827
 828         ret = snprintf(buf, len, "%d", rep->vport - 1);
 829         if (ret >= len)
 830                 return -EOPNOTSUPP;
 831
 832         return 0;
 833 }
 834
 835 static int
 836 mlx5e_rep_setup_tc_cls_flower(struct mlx5e_priv *priv,
 837                               struct tc_cls_flower_offload *cls_flower, int flags)
 838 {
 839         switch (cls_flower->command) {
 840         case TC_CLSFLOWER_REPLACE:
 841                 return mlx5e_configure_flower(priv, cls_flower, flags);
 842         case TC_CLSFLOWER_DESTROY:
 843                 return mlx5e_delete_flower(priv, cls_flower, flags);
 844         case TC_CLSFLOWER_STATS:
 845                 return mlx5e_stats_flower(priv, cls_flower, flags);
 846         default:
 847                 return -EOPNOTSUPP;
 848         }
 849 }
 850
 851 static int mlx5e_rep_setup_tc_cb_egdev(enum tc_setup_type type, void *type_data,
 852                                        void *cb_priv)
 853 {
 854         struct mlx5e_priv *priv = cb_priv;
 855
 856         if (!tc_cls_can_offload_and_chain0(priv->netdev, type_data))
 857                 return -EOPNOTSUPP;
 858
 859         switch (type) {
 860         case TC_SETUP_CLSFLOWER:
 861                 return mlx5e_rep_setup_tc_cls_flower(priv, type_data, MLX5E_TC_EGRESS);
 862         default:
 863                 return -EOPNOTSUPP;
 864         }
 865 }
 866
 867 static int mlx5e_rep_setup_tc_cb(enum tc_setup_type type, void *type_data,
 868                                  void *cb_priv)
 869 {
 870         struct mlx5e_priv *priv = cb_priv;
 871
 872         if (!tc_cls_can_offload_and_chain0(priv->netdev, type_data))
 873                 return -EOPNOTSUPP;
 874
 875         switch (type) {
 876         case TC_SETUP_CLSFLOWER:
 877                 return mlx5e_rep_setup_tc_cls_flower(priv, type_data, MLX5E_TC_INGRESS);
 878         default:
 879                 return -EOPNOTSUPP;
 880         }
 881 }
 882
 883 static int mlx5e_rep_setup_tc_block(struct net_device *dev,
 884                                     struct tc_block_offload *f)
 885 {
 886         struct mlx5e_priv *priv = netdev_priv(dev);
 887
 888         if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
 889                 return -EOPNOTSUPP;
 890
 891         switch (f->command) {
 892         case TC_BLOCK_BIND:
 893                 return tcf_block_cb_register(f->block, mlx5e_rep_setup_tc_cb,
 894                                              priv, priv, f->extack);
 895         case TC_BLOCK_UNBIND:
 896                 tcf_block_cb_unregister(f->block, mlx5e_rep_setup_tc_cb, priv);
 897                 return 0;
 898         default:
 899                 return -EOPNOTSUPP;
 900         }
 901 }
 902
 903 static int mlx5e_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
 904                               void *type_data)
 905 {
 906         switch (type) {
 907         case TC_SETUP_BLOCK:
 908                 return mlx5e_rep_setup_tc_block(dev, type_data);
 909         default:
 910                 return -EOPNOTSUPP;
 911         }
 912 }
 913
 914 bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv)
 915 {
 916         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
 917         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 918         struct mlx5_eswitch_rep *rep;
 919
 920         if (!MLX5_ESWITCH_MANAGER(priv->mdev))
 921                 return false;
 922
 923         rep = rpriv->rep;
 924         if (esw->mode == SRIOV_OFFLOADS &&
 925             rep && rep->vport == FDB_UPLINK_VPORT)
 926                 return true;
 927
 928         return false;
 929 }
 930
 931 static bool mlx5e_is_vf_vport_rep(struct mlx5e_priv *priv)
 932 {
 933         struct mlx5e_rep_priv *rpriv = priv->ppriv;
 934         struct mlx5_eswitch_rep *rep;
 935
 936         if (!MLX5_ESWITCH_MANAGER(priv->mdev))
 937                 return false;
 938
 939         rep = rpriv->rep;
 940         if (rep && rep->vport != FDB_UPLINK_VPORT)
 941                 return true;
 942
 943         return false;
 944 }
 945
 946 bool mlx5e_has_offload_stats(const struct net_device *dev, int attr_id)
 947 {
 948         struct mlx5e_priv *priv = netdev_priv(dev);
 949
 950         switch (attr_id) {
 951         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 952                 if (mlx5e_is_vf_vport_rep(priv) || mlx5e_is_uplink_rep(priv))
 953                         return true;
 954         }
 955
 956         return false;
 957 }
 958
 959 static int
 960 mlx5e_get_sw_stats64(const struct net_device *dev,
 961                      struct rtnl_link_stats64 *stats)
 962 {
 963         struct mlx5e_priv *priv = netdev_priv(dev);
 964         struct mlx5e_sw_stats *sstats = &priv->stats.sw;
 965
 966         mlx5e_rep_update_sw_counters(priv);
 967
 968         stats->rx_packets = sstats->rx_packets;
 969         stats->rx_bytes   = sstats->rx_bytes;
 970         stats->tx_packets = sstats->tx_packets;
 971         stats->tx_bytes   = sstats->tx_bytes;
 972
 973         stats->tx_dropped = sstats->tx_queue_dropped;
 974
 975         return 0;
 976 }
 977
 978 int mlx5e_get_offload_stats(int attr_id, const struct net_device *dev,
 979                             void *sp)
 980 {
 981         switch (attr_id) {
 982         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 983                 return mlx5e_get_sw_stats64(dev, sp);
 984         }
 985
 986         return -EINVAL;
 987 }
 988
 989 static void
 990 mlx5e_rep_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats)
 991 {
 992         struct mlx5e_priv *priv = netdev_priv(dev);
 993
 994         /* update HW stats in background for next time */
 995         queue_delayed_work(priv->wq, &priv->update_stats_work, 0);
 996
 997         memcpy(stats, &priv->stats.vf_vport, sizeof(*stats));
 998 }
 999
1000 static const struct switchdev_ops mlx5e_rep_switchdev_ops = {
1001         .switchdev_port_attr_get        = mlx5e_attr_get,
1002 };
1003
1004 static int mlx5e_change_rep_mtu(struct net_device *netdev, int new_mtu)
1005 {
1006         return mlx5e_change_mtu(netdev, new_mtu, NULL);
1007 }
1008
1009 static const struct net_device_ops mlx5e_netdev_ops_rep = {
1010         .ndo_open                = mlx5e_rep_open,
1011         .ndo_stop                = mlx5e_rep_close,
1012         .ndo_start_xmit          = mlx5e_xmit,
1013         .ndo_get_phys_port_name  = mlx5e_rep_get_phys_port_name,
1014         .ndo_setup_tc            = mlx5e_rep_setup_tc,
1015         .ndo_get_stats64         = mlx5e_rep_get_stats,
1016         .ndo_has_offload_stats   = mlx5e_has_offload_stats,
1017         .ndo_get_offload_stats   = mlx5e_get_offload_stats,
1018         .ndo_change_mtu          = mlx5e_change_rep_mtu,
1019 };
1020
1021 static void mlx5e_build_rep_params(struct mlx5_core_dev *mdev,
1022                                    struct mlx5e_params *params, u16 mtu)
1023 {
1024         u8 cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ?
1025                                          MLX5_CQ_PERIOD_MODE_START_FROM_CQE :
1026                                          MLX5_CQ_PERIOD_MODE_START_FROM_EQE;
1027
1028         params->hard_mtu    = MLX5E_ETH_HARD_MTU;
1029         params->sw_mtu      = mtu;
1030         params->log_sq_size = MLX5E_REP_PARAMS_LOG_SQ_SIZE;
1031
1032         /* RQ */
1033         mlx5e_build_rq_params(mdev, params);
1034
1035         /* CQ moderation params */
1036         params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation);
1037         mlx5e_set_rx_cq_mode_params(params, cq_period_mode);
1038
1039         params->num_tc                = 1;
1040
1041         mlx5_query_min_inline(mdev, &params->tx_min_inline_mode);
1042
1043         /* RSS */
1044         mlx5e_build_rss_params(params);
1045 }
1046
1047 static void mlx5e_build_rep_netdev(struct net_device *netdev)
1048 {
1049         struct mlx5e_priv *priv = netdev_priv(netdev);
1050         struct mlx5_core_dev *mdev = priv->mdev;
1051         u16 max_mtu;
1052
1053         netdev->netdev_ops = &mlx5e_netdev_ops_rep;
1054
1055         netdev->watchdog_timeo    = 15 * HZ;
1056
1057         netdev->ethtool_ops       = &mlx5e_rep_ethtool_ops;
1058
1059         netdev->switchdev_ops = &mlx5e_rep_switchdev_ops;
1060
1061         netdev->features         |= NETIF_F_VLAN_CHALLENGED | NETIF_F_HW_TC | NETIF_F_NETNS_LOCAL;
1062         netdev->hw_features      |= NETIF_F_HW_TC;
1063
1064         netdev->hw_features    |= NETIF_F_SG;
1065         netdev->hw_features    |= NETIF_F_IP_CSUM;
1066         netdev->hw_features    |= NETIF_F_IPV6_CSUM;
1067         netdev->hw_features    |= NETIF_F_GRO;
1068         netdev->hw_features    |= NETIF_F_TSO;
1069         netdev->hw_features    |= NETIF_F_TSO6;
1070         netdev->hw_features    |= NETIF_F_RXCSUM;
1071
1072         netdev->features |= netdev->hw_features;
1073
1074         eth_hw_addr_random(netdev);
1075
1076         netdev->min_mtu = ETH_MIN_MTU;
1077         mlx5_query_port_max_mtu(mdev, &max_mtu, 1);
1078         netdev->max_mtu = MLX5E_HW2SW_MTU(&priv->channels.params, max_mtu);
1079 }
1080
1081 static void mlx5e_init_rep(struct mlx5_core_dev *mdev,
1082                            struct net_device *netdev,
1083                            const struct mlx5e_profile *profile,
1084                            void *ppriv)
1085 {
1086         struct mlx5e_priv *priv = netdev_priv(netdev);
1087
1088         priv->mdev                         = mdev;
1089         priv->netdev                       = netdev;
1090         priv->profile                      = profile;
1091         priv->ppriv                        = ppriv;
1092
1093         mutex_init(&priv->state_lock);
1094
1095         INIT_DELAYED_WORK(&priv->update_stats_work, mlx5e_update_stats_work);
1096
1097         priv->channels.params.num_channels = 1;
1098
1099         mlx5e_build_rep_params(mdev, &priv->channels.params, netdev->mtu);
1100         mlx5e_build_rep_netdev(netdev);
1101
1102         mlx5e_timestamp_init(priv);
1103 }
1104
1105 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv)
1106 {
1107         struct ttc_params ttc_params = {};
1108         int tt, err;
1109
1110         priv->fs.ns = mlx5_get_flow_namespace(priv->mdev,
1111                                               MLX5_FLOW_NAMESPACE_KERNEL);
1112
1113         /* The inner_ttc in the ttc params is intentionally not set */
1114         ttc_params.any_tt_tirn = priv->direct_tir[0].tirn;
1115         mlx5e_set_ttc_ft_params(&ttc_params);
1116         for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++)
1117                 ttc_params.indir_tirn[tt] = priv->indir_tir[tt].tirn;
1118
1119         err = mlx5e_create_ttc_table(priv, &ttc_params, &priv->fs.ttc);
1120         if (err) {
1121                 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n", err);
1122                 return err;
1123         }
1124         return 0;
1125 }
1126
1127 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv)
1128 {
1129         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
1130         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1131         struct mlx5_eswitch_rep *rep = rpriv->rep;
1132         struct mlx5_flow_handle *flow_rule;
1133         struct mlx5_flow_destination dest;
1134
1135         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
1136         dest.tir_num = priv->direct_tir[0].tirn;
1137         flow_rule = mlx5_eswitch_create_vport_rx_rule(esw,
1138                                                       rep->vport,
1139                                                       &dest);
1140         if (IS_ERR(flow_rule))
1141                 return PTR_ERR(flow_rule);
1142         rpriv->vport_rx_rule = flow_rule;
1143         return 0;
1144 }
1145
1146 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv)
1147 {
1148         struct mlx5_core_dev *mdev = priv->mdev;
1149         int err;
1150
1151         mlx5e_init_l2_addr(priv);
1152
1153         err = mlx5e_open_drop_rq(priv, &priv->drop_rq);
1154         if (err) {
1155                 mlx5_core_err(mdev, "open drop rq failed, %d\n", err);
1156                 return err;
1157         }
1158
1159         err = mlx5e_create_indirect_rqt(priv);
1160         if (err)
1161                 goto err_close_drop_rq;
1162
1163         err = mlx5e_create_direct_rqts(priv);
1164         if (err)
1165                 goto err_destroy_indirect_rqts;
1166
1167         err = mlx5e_create_indirect_tirs(priv, false);
1168         if (err)
1169                 goto err_destroy_direct_rqts;
1170
1171         err = mlx5e_create_direct_tirs(priv);
1172         if (err)
1173                 goto err_destroy_indirect_tirs;
1174
1175         err = mlx5e_create_rep_ttc_table(priv);
1176         if (err)
1177                 goto err_destroy_direct_tirs;
1178
1179         err = mlx5e_create_rep_vport_rx_rule(priv);
1180         if (err)
1181                 goto err_destroy_ttc_table;
1182
1183         return 0;
1184
1185 err_destroy_ttc_table:
1186         mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
1187 err_destroy_direct_tirs:
1188         mlx5e_destroy_direct_tirs(priv);
1189 err_destroy_indirect_tirs:
1190         mlx5e_destroy_indirect_tirs(priv, false);
1191 err_destroy_direct_rqts:
1192         mlx5e_destroy_direct_rqts(priv);
1193 err_destroy_indirect_rqts:
1194         mlx5e_destroy_rqt(priv, &priv->indir_rqt);
1195 err_close_drop_rq:
1196         mlx5e_close_drop_rq(&priv->drop_rq);
1197         return err;
1198 }
1199
1200 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv)
1201 {
1202         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1203
1204         mlx5_del_flow_rules(rpriv->vport_rx_rule);
1205         mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
1206         mlx5e_destroy_direct_tirs(priv);
1207         mlx5e_destroy_indirect_tirs(priv, false);
1208         mlx5e_destroy_direct_rqts(priv);
1209         mlx5e_destroy_rqt(priv, &priv->indir_rqt);
1210         mlx5e_close_drop_rq(&priv->drop_rq);
1211 }
1212
1213 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv)
1214 {
1215         int err;
1216
1217         err = mlx5e_create_tises(priv);
1218         if (err) {
1219                 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err);
1220                 return err;
1221         }
1222         return 0;
1223 }
1224
1225 static const struct mlx5e_profile mlx5e_rep_profile = {
1226         .init                   = mlx5e_init_rep,
1227         .init_rx                = mlx5e_init_rep_rx,
1228         .cleanup_rx             = mlx5e_cleanup_rep_rx,
1229         .init_tx                = mlx5e_init_rep_tx,
1230         .cleanup_tx             = mlx5e_cleanup_nic_tx,
1231         .update_stats           = mlx5e_rep_update_hw_counters,
1232         .max_nch                = mlx5e_get_max_num_channels,
1233         .update_carrier         = NULL,
1234         .rx_handlers.handle_rx_cqe       = mlx5e_handle_rx_cqe_rep,
1235         .rx_handlers.handle_rx_cqe_mpwqe = mlx5e_handle_rx_cqe_mpwrq,
1236         .max_tc                 = 1,
1237 };
1238
1239 /* e-Switch vport representors */
1240
1241 static int
1242 mlx5e_nic_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1243 {
1244         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1245         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
1246
1247         int err;
1248
1249         if (test_bit(MLX5E_STATE_OPENED, &priv->state)) {
1250                 err = mlx5e_add_sqs_fwd_rules(priv);
1251                 if (err)
1252                         return err;
1253         }
1254
1255         err = mlx5e_rep_neigh_init(rpriv);
1256         if (err)
1257                 goto err_remove_sqs;
1258
1259         /* init shared tc flow table */
1260         err = mlx5e_tc_esw_init(&rpriv->tc_ht);
1261         if (err)
1262                 goto  err_neigh_cleanup;
1263
1264         return 0;
1265
1266 err_neigh_cleanup:
1267         mlx5e_rep_neigh_cleanup(rpriv);
1268 err_remove_sqs:
1269         mlx5e_remove_sqs_fwd_rules(priv);
1270         return err;
1271 }
1272
1273 static void
1274 mlx5e_nic_rep_unload(struct mlx5_eswitch_rep *rep)
1275 {
1276         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1277         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
1278
1279         if (test_bit(MLX5E_STATE_OPENED, &priv->state))
1280                 mlx5e_remove_sqs_fwd_rules(priv);
1281
1282         /* clean uplink offloaded TC rules, delete shared tc flow table */
1283         mlx5e_tc_esw_cleanup(&rpriv->tc_ht);
1284
1285         mlx5e_rep_neigh_cleanup(rpriv);
1286 }
1287
1288 static int
1289 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1290 {
1291         struct mlx5e_rep_priv *uplink_rpriv;
1292         struct mlx5e_rep_priv *rpriv;
1293         struct net_device *netdev;
1294         struct mlx5e_priv *upriv;
1295         int err;
1296
1297         rpriv = kzalloc(sizeof(*rpriv), GFP_KERNEL);
1298         if (!rpriv)
1299                 return -ENOMEM;
1300
1301         netdev = mlx5e_create_netdev(dev, &mlx5e_rep_profile, rpriv);
1302         if (!netdev) {
1303                 pr_warn("Failed to create representor netdev for vport %d\n",
1304                         rep->vport);
1305                 kfree(rpriv);
1306                 return -EINVAL;
1307         }
1308
1309         rpriv->netdev = netdev;
1310         rpriv->rep = rep;
1311         rep->rep_if[REP_ETH].priv = rpriv;
1312         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1313
1314         err = mlx5e_attach_netdev(netdev_priv(netdev));
1315         if (err) {
1316                 pr_warn("Failed to attach representor netdev for vport %d\n",
1317                         rep->vport);
1318                 goto err_destroy_netdev;
1319         }
1320
1321         err = mlx5e_rep_neigh_init(rpriv);
1322         if (err) {
1323                 pr_warn("Failed to initialized neighbours handling for vport %d\n",
1324                         rep->vport);
1325                 goto err_detach_netdev;
1326         }
1327
1328         uplink_rpriv = mlx5_eswitch_get_uplink_priv(dev->priv.eswitch, REP_ETH);
1329         upriv = netdev_priv(uplink_rpriv->netdev);
1330         err = tc_setup_cb_egdev_register(netdev, mlx5e_rep_setup_tc_cb_egdev,
1331                                          upriv);
1332         if (err)
1333                 goto err_neigh_cleanup;
1334
1335         err = register_netdev(netdev);
1336         if (err) {
1337                 pr_warn("Failed to register representor netdev for vport %d\n",
1338                         rep->vport);
1339                 goto err_egdev_cleanup;
1340         }
1341
1342         return 0;
1343
1344 err_egdev_cleanup:
1345         tc_setup_cb_egdev_unregister(netdev, mlx5e_rep_setup_tc_cb_egdev,
1346                                      upriv);
1347
1348 err_neigh_cleanup:
1349         mlx5e_rep_neigh_cleanup(rpriv);
1350
1351 err_detach_netdev:
1352         mlx5e_detach_netdev(netdev_priv(netdev));
1353
1354 err_destroy_netdev:
1355         mlx5e_destroy_netdev(netdev_priv(netdev));
1356         kfree(rpriv);
1357         return err;
1358 }
1359
1360 static void
1361 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep)
1362 {
1363         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1364         struct net_device *netdev = rpriv->netdev;
1365         struct mlx5e_priv *priv = netdev_priv(netdev);
1366         struct mlx5e_rep_priv *uplink_rpriv;
1367         void *ppriv = priv->ppriv;
1368         struct mlx5e_priv *upriv;
1369
1370         unregister_netdev(netdev);
1371         uplink_rpriv = mlx5_eswitch_get_uplink_priv(priv->mdev->priv.eswitch,
1372                                                     REP_ETH);
1373         upriv = netdev_priv(uplink_rpriv->netdev);
1374         tc_setup_cb_egdev_unregister(netdev, mlx5e_rep_setup_tc_cb_egdev,
1375                                      upriv);
1376         mlx5e_rep_neigh_cleanup(rpriv);
1377         mlx5e_detach_netdev(priv);
1378         mlx5e_destroy_netdev(priv);
1379         kfree(ppriv); /* mlx5e_rep_priv */
1380 }
1381
1382 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep)
1383 {
1384         struct mlx5e_rep_priv *rpriv;
1385
1386         rpriv = mlx5e_rep_to_rep_priv(rep);
1387
1388         return rpriv->netdev;
1389 }
1390
1391 static void mlx5e_rep_register_vf_vports(struct mlx5e_priv *priv)
1392 {
1393         struct mlx5_core_dev *mdev = priv->mdev;
1394         struct mlx5_eswitch *esw   = mdev->priv.eswitch;
1395         int total_vfs = MLX5_TOTAL_VPORTS(mdev);
1396         int vport;
1397
1398         for (vport = 1; vport < total_vfs; vport++) {
1399                 struct mlx5_eswitch_rep_if rep_if = {};
1400
1401                 rep_if.load = mlx5e_vport_rep_load;
1402                 rep_if.unload = mlx5e_vport_rep_unload;
1403                 rep_if.get_proto_dev = mlx5e_vport_rep_get_proto_dev;
1404                 mlx5_eswitch_register_vport_rep(esw, vport, &rep_if, REP_ETH);
1405         }
1406 }
1407
1408 static void mlx5e_rep_unregister_vf_vports(struct mlx5e_priv *priv)
1409 {
1410         struct mlx5_core_dev *mdev = priv->mdev;
1411         struct mlx5_eswitch *esw = mdev->priv.eswitch;
1412         int total_vfs = MLX5_TOTAL_VPORTS(mdev);
1413         int vport;
1414
1415         for (vport = 1; vport < total_vfs; vport++)
1416                 mlx5_eswitch_unregister_vport_rep(esw, vport, REP_ETH);
1417 }
1418
1419 void mlx5e_register_vport_reps(struct mlx5e_priv *priv)
1420 {
1421         struct mlx5_core_dev *mdev = priv->mdev;
1422         struct mlx5_eswitch *esw   = mdev->priv.eswitch;
1423         struct mlx5_eswitch_rep_if rep_if;
1424         struct mlx5e_rep_priv *rpriv;
1425
1426         rpriv = priv->ppriv;
1427         rpriv->netdev = priv->netdev;
1428
1429         rep_if.load = mlx5e_nic_rep_load;
1430         rep_if.unload = mlx5e_nic_rep_unload;
1431         rep_if.get_proto_dev = mlx5e_vport_rep_get_proto_dev;
1432         rep_if.priv = rpriv;
1433         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1434         mlx5_eswitch_register_vport_rep(esw, 0, &rep_if, REP_ETH); /* UPLINK PF vport*/
1435
1436         mlx5e_rep_register_vf_vports(priv); /* VFs vports */
1437 }
1438
1439 void mlx5e_unregister_vport_reps(struct mlx5e_priv *priv)
1440 {
1441         struct mlx5_core_dev *mdev = priv->mdev;
1442         struct mlx5_eswitch *esw   = mdev->priv.eswitch;
1443
1444         mlx5e_rep_unregister_vf_vports(priv); /* VFs vports */
1445         mlx5_eswitch_unregister_vport_rep(esw, 0, REP_ETH); /* UPLINK PF*/
1446 }
1447
1448 void *mlx5e_alloc_nic_rep_priv(struct mlx5_core_dev *mdev)
1449 {
1450         struct mlx5_eswitch *esw = mdev->priv.eswitch;
1451         struct mlx5e_rep_priv *rpriv;
1452
1453         rpriv = kzalloc(sizeof(*rpriv), GFP_KERNEL);
1454         if (!rpriv)
1455                 return NULL;
1456
1457         rpriv->rep = &esw->offloads.vport_reps[0];
1458         return rpriv;
1459 }