bd8caac2e572a950f7e30b3c22e407c828ad8bfb
[sfrench/cifs-2.6.git] / 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 int 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         int err;
1088
1089         priv->mdev                         = mdev;
1090         priv->netdev                       = netdev;
1091         priv->profile                      = profile;
1092         priv->ppriv                        = ppriv;
1093
1094         err = mlx5e_netdev_init(netdev, priv);
1095         if (err)
1096                 return err;
1097
1098         mutex_init(&priv->state_lock);
1099
1100         priv->channels.params.num_channels = profile->max_nch(mdev);
1101
1102         mlx5e_build_rep_params(mdev, &priv->channels.params, netdev->mtu);
1103         mlx5e_build_rep_netdev(netdev);
1104
1105         mlx5e_timestamp_init(priv);
1106
1107         return 0;
1108 }
1109
1110 static void mlx5e_cleanup_rep(struct mlx5e_priv *priv)
1111 {
1112         mlx5e_netdev_cleanup(priv->netdev, priv);
1113 }
1114
1115 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv)
1116 {
1117         struct ttc_params ttc_params = {};
1118         int tt, err;
1119
1120         priv->fs.ns = mlx5_get_flow_namespace(priv->mdev,
1121                                               MLX5_FLOW_NAMESPACE_KERNEL);
1122
1123         /* The inner_ttc in the ttc params is intentionally not set */
1124         ttc_params.any_tt_tirn = priv->direct_tir[0].tirn;
1125         mlx5e_set_ttc_ft_params(&ttc_params);
1126         for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++)
1127                 ttc_params.indir_tirn[tt] = priv->indir_tir[tt].tirn;
1128
1129         err = mlx5e_create_ttc_table(priv, &ttc_params, &priv->fs.ttc);
1130         if (err) {
1131                 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n", err);
1132                 return err;
1133         }
1134         return 0;
1135 }
1136
1137 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv)
1138 {
1139         struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
1140         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1141         struct mlx5_eswitch_rep *rep = rpriv->rep;
1142         struct mlx5_flow_handle *flow_rule;
1143         struct mlx5_flow_destination dest;
1144
1145         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
1146         dest.tir_num = priv->direct_tir[0].tirn;
1147         flow_rule = mlx5_eswitch_create_vport_rx_rule(esw,
1148                                                       rep->vport,
1149                                                       &dest);
1150         if (IS_ERR(flow_rule))
1151                 return PTR_ERR(flow_rule);
1152         rpriv->vport_rx_rule = flow_rule;
1153         return 0;
1154 }
1155
1156 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv)
1157 {
1158         struct mlx5_core_dev *mdev = priv->mdev;
1159         int err;
1160
1161         mlx5e_init_l2_addr(priv);
1162
1163         err = mlx5e_open_drop_rq(priv, &priv->drop_rq);
1164         if (err) {
1165                 mlx5_core_err(mdev, "open drop rq failed, %d\n", err);
1166                 return err;
1167         }
1168
1169         err = mlx5e_create_indirect_rqt(priv);
1170         if (err)
1171                 goto err_close_drop_rq;
1172
1173         err = mlx5e_create_direct_rqts(priv);
1174         if (err)
1175                 goto err_destroy_indirect_rqts;
1176
1177         err = mlx5e_create_indirect_tirs(priv, false);
1178         if (err)
1179                 goto err_destroy_direct_rqts;
1180
1181         err = mlx5e_create_direct_tirs(priv);
1182         if (err)
1183                 goto err_destroy_indirect_tirs;
1184
1185         err = mlx5e_create_rep_ttc_table(priv);
1186         if (err)
1187                 goto err_destroy_direct_tirs;
1188
1189         err = mlx5e_create_rep_vport_rx_rule(priv);
1190         if (err)
1191                 goto err_destroy_ttc_table;
1192
1193         return 0;
1194
1195 err_destroy_ttc_table:
1196         mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
1197 err_destroy_direct_tirs:
1198         mlx5e_destroy_direct_tirs(priv);
1199 err_destroy_indirect_tirs:
1200         mlx5e_destroy_indirect_tirs(priv, false);
1201 err_destroy_direct_rqts:
1202         mlx5e_destroy_direct_rqts(priv);
1203 err_destroy_indirect_rqts:
1204         mlx5e_destroy_rqt(priv, &priv->indir_rqt);
1205 err_close_drop_rq:
1206         mlx5e_close_drop_rq(&priv->drop_rq);
1207         return err;
1208 }
1209
1210 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv)
1211 {
1212         struct mlx5e_rep_priv *rpriv = priv->ppriv;
1213
1214         mlx5_del_flow_rules(rpriv->vport_rx_rule);
1215         mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
1216         mlx5e_destroy_direct_tirs(priv);
1217         mlx5e_destroy_indirect_tirs(priv, false);
1218         mlx5e_destroy_direct_rqts(priv);
1219         mlx5e_destroy_rqt(priv, &priv->indir_rqt);
1220         mlx5e_close_drop_rq(&priv->drop_rq);
1221 }
1222
1223 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv)
1224 {
1225         int err;
1226
1227         err = mlx5e_create_tises(priv);
1228         if (err) {
1229                 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err);
1230                 return err;
1231         }
1232         return 0;
1233 }
1234
1235 static const struct mlx5e_profile mlx5e_rep_profile = {
1236         .init                   = mlx5e_init_rep,
1237         .cleanup                = mlx5e_cleanup_rep,
1238         .init_rx                = mlx5e_init_rep_rx,
1239         .cleanup_rx             = mlx5e_cleanup_rep_rx,
1240         .init_tx                = mlx5e_init_rep_tx,
1241         .cleanup_tx             = mlx5e_cleanup_nic_tx,
1242         .update_stats           = mlx5e_rep_update_hw_counters,
1243         .max_nch                = mlx5e_get_max_num_channels,
1244         .update_carrier         = NULL,
1245         .rx_handlers.handle_rx_cqe       = mlx5e_handle_rx_cqe_rep,
1246         .rx_handlers.handle_rx_cqe_mpwqe = mlx5e_handle_rx_cqe_mpwrq,
1247         .max_tc                 = 1,
1248 };
1249
1250 /* e-Switch vport representors */
1251
1252 static int
1253 mlx5e_nic_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1254 {
1255         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1256         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
1257
1258         int err;
1259
1260         if (test_bit(MLX5E_STATE_OPENED, &priv->state)) {
1261                 err = mlx5e_add_sqs_fwd_rules(priv);
1262                 if (err)
1263                         return err;
1264         }
1265
1266         err = mlx5e_rep_neigh_init(rpriv);
1267         if (err)
1268                 goto err_remove_sqs;
1269
1270         /* init shared tc flow table */
1271         err = mlx5e_tc_esw_init(&rpriv->tc_ht);
1272         if (err)
1273                 goto  err_neigh_cleanup;
1274
1275         return 0;
1276
1277 err_neigh_cleanup:
1278         mlx5e_rep_neigh_cleanup(rpriv);
1279 err_remove_sqs:
1280         mlx5e_remove_sqs_fwd_rules(priv);
1281         return err;
1282 }
1283
1284 static void
1285 mlx5e_nic_rep_unload(struct mlx5_eswitch_rep *rep)
1286 {
1287         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1288         struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
1289
1290         if (test_bit(MLX5E_STATE_OPENED, &priv->state))
1291                 mlx5e_remove_sqs_fwd_rules(priv);
1292
1293         /* clean uplink offloaded TC rules, delete shared tc flow table */
1294         mlx5e_tc_esw_cleanup(&rpriv->tc_ht);
1295
1296         mlx5e_rep_neigh_cleanup(rpriv);
1297 }
1298
1299 static int
1300 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep)
1301 {
1302         struct mlx5e_rep_priv *uplink_rpriv;
1303         struct mlx5e_rep_priv *rpriv;
1304         struct net_device *netdev;
1305         struct mlx5e_priv *upriv;
1306         int err;
1307
1308         rpriv = kzalloc(sizeof(*rpriv), GFP_KERNEL);
1309         if (!rpriv)
1310                 return -ENOMEM;
1311
1312         netdev = mlx5e_create_netdev(dev, &mlx5e_rep_profile, rpriv);
1313         if (!netdev) {
1314                 pr_warn("Failed to create representor netdev for vport %d\n",
1315                         rep->vport);
1316                 kfree(rpriv);
1317                 return -EINVAL;
1318         }
1319
1320         rpriv->netdev = netdev;
1321         rpriv->rep = rep;
1322         rep->rep_if[REP_ETH].priv = rpriv;
1323         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1324
1325         err = mlx5e_attach_netdev(netdev_priv(netdev));
1326         if (err) {
1327                 pr_warn("Failed to attach representor netdev for vport %d\n",
1328                         rep->vport);
1329                 goto err_destroy_netdev;
1330         }
1331
1332         err = mlx5e_rep_neigh_init(rpriv);
1333         if (err) {
1334                 pr_warn("Failed to initialized neighbours handling for vport %d\n",
1335                         rep->vport);
1336                 goto err_detach_netdev;
1337         }
1338
1339         uplink_rpriv = mlx5_eswitch_get_uplink_priv(dev->priv.eswitch, REP_ETH);
1340         upriv = netdev_priv(uplink_rpriv->netdev);
1341         err = tc_setup_cb_egdev_register(netdev, mlx5e_rep_setup_tc_cb_egdev,
1342                                          upriv);
1343         if (err)
1344                 goto err_neigh_cleanup;
1345
1346         err = register_netdev(netdev);
1347         if (err) {
1348                 pr_warn("Failed to register representor netdev for vport %d\n",
1349                         rep->vport);
1350                 goto err_egdev_cleanup;
1351         }
1352
1353         return 0;
1354
1355 err_egdev_cleanup:
1356         tc_setup_cb_egdev_unregister(netdev, mlx5e_rep_setup_tc_cb_egdev,
1357                                      upriv);
1358
1359 err_neigh_cleanup:
1360         mlx5e_rep_neigh_cleanup(rpriv);
1361
1362 err_detach_netdev:
1363         mlx5e_detach_netdev(netdev_priv(netdev));
1364
1365 err_destroy_netdev:
1366         mlx5e_destroy_netdev(netdev_priv(netdev));
1367         kfree(rpriv);
1368         return err;
1369 }
1370
1371 static void
1372 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep)
1373 {
1374         struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep);
1375         struct net_device *netdev = rpriv->netdev;
1376         struct mlx5e_priv *priv = netdev_priv(netdev);
1377         struct mlx5e_rep_priv *uplink_rpriv;
1378         void *ppriv = priv->ppriv;
1379         struct mlx5e_priv *upriv;
1380
1381         unregister_netdev(netdev);
1382         uplink_rpriv = mlx5_eswitch_get_uplink_priv(priv->mdev->priv.eswitch,
1383                                                     REP_ETH);
1384         upriv = netdev_priv(uplink_rpriv->netdev);
1385         tc_setup_cb_egdev_unregister(netdev, mlx5e_rep_setup_tc_cb_egdev,
1386                                      upriv);
1387         mlx5e_rep_neigh_cleanup(rpriv);
1388         mlx5e_detach_netdev(priv);
1389         mlx5e_destroy_netdev(priv);
1390         kfree(ppriv); /* mlx5e_rep_priv */
1391 }
1392
1393 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep)
1394 {
1395         struct mlx5e_rep_priv *rpriv;
1396
1397         rpriv = mlx5e_rep_to_rep_priv(rep);
1398
1399         return rpriv->netdev;
1400 }
1401
1402 static void mlx5e_rep_register_vf_vports(struct mlx5e_priv *priv)
1403 {
1404         struct mlx5_core_dev *mdev = priv->mdev;
1405         struct mlx5_eswitch *esw   = mdev->priv.eswitch;
1406         int total_vfs = MLX5_TOTAL_VPORTS(mdev);
1407         int vport;
1408
1409         for (vport = 1; vport < total_vfs; vport++) {
1410                 struct mlx5_eswitch_rep_if rep_if = {};
1411
1412                 rep_if.load = mlx5e_vport_rep_load;
1413                 rep_if.unload = mlx5e_vport_rep_unload;
1414                 rep_if.get_proto_dev = mlx5e_vport_rep_get_proto_dev;
1415                 mlx5_eswitch_register_vport_rep(esw, vport, &rep_if, REP_ETH);
1416         }
1417 }
1418
1419 static void mlx5e_rep_unregister_vf_vports(struct mlx5e_priv *priv)
1420 {
1421         struct mlx5_core_dev *mdev = priv->mdev;
1422         struct mlx5_eswitch *esw = mdev->priv.eswitch;
1423         int total_vfs = MLX5_TOTAL_VPORTS(mdev);
1424         int vport;
1425
1426         for (vport = 1; vport < total_vfs; vport++)
1427                 mlx5_eswitch_unregister_vport_rep(esw, vport, REP_ETH);
1428 }
1429
1430 void mlx5e_register_vport_reps(struct mlx5e_priv *priv)
1431 {
1432         struct mlx5_core_dev *mdev = priv->mdev;
1433         struct mlx5_eswitch *esw   = mdev->priv.eswitch;
1434         struct mlx5_eswitch_rep_if rep_if;
1435         struct mlx5e_rep_priv *rpriv;
1436
1437         rpriv = priv->ppriv;
1438         rpriv->netdev = priv->netdev;
1439
1440         rep_if.load = mlx5e_nic_rep_load;
1441         rep_if.unload = mlx5e_nic_rep_unload;
1442         rep_if.get_proto_dev = mlx5e_vport_rep_get_proto_dev;
1443         rep_if.priv = rpriv;
1444         INIT_LIST_HEAD(&rpriv->vport_sqs_list);
1445         mlx5_eswitch_register_vport_rep(esw, 0, &rep_if, REP_ETH); /* UPLINK PF vport*/
1446
1447         mlx5e_rep_register_vf_vports(priv); /* VFs vports */
1448 }
1449
1450 void mlx5e_unregister_vport_reps(struct mlx5e_priv *priv)
1451 {
1452         struct mlx5_core_dev *mdev = priv->mdev;
1453         struct mlx5_eswitch *esw   = mdev->priv.eswitch;
1454
1455         mlx5e_rep_unregister_vf_vports(priv); /* VFs vports */
1456         mlx5_eswitch_unregister_vport_rep(esw, 0, REP_ETH); /* UPLINK PF*/
1457 }
1458
1459 void *mlx5e_alloc_nic_rep_priv(struct mlx5_core_dev *mdev)
1460 {
1461         struct mlx5_eswitch *esw = mdev->priv.eswitch;
1462         struct mlx5e_rep_priv *rpriv;
1463
1464         rpriv = kzalloc(sizeof(*rpriv), GFP_KERNEL);
1465         if (!rpriv)
1466                 return NULL;
1467
1468         rpriv->rep = &esw->offloads.vport_reps[0];
1469         return rpriv;
1470 }