devlink: Add extack for eswitch operations
[sfrench/cifs-2.6.git] / drivers / net / ethernet / broadcom / bnxt / bnxt_vfr.c
1 /* Broadcom NetXtreme-C/E network driver.
2  *
3  * Copyright (c) 2016-2017 Broadcom Limited
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation.
8  */
9 #include <linux/pci.h>
10 #include <linux/netdevice.h>
11 #include <linux/etherdevice.h>
12 #include <linux/rtnetlink.h>
13 #include <linux/jhash.h>
14 #include <net/pkt_cls.h>
15
16 #include "bnxt_hsi.h"
17 #include "bnxt.h"
18 #include "bnxt_vfr.h"
19 #include "bnxt_devlink.h"
20 #include "bnxt_tc.h"
21
22 #ifdef CONFIG_BNXT_SRIOV
23
24 #define CFA_HANDLE_INVALID              0xffff
25 #define VF_IDX_INVALID                  0xffff
26
27 static int hwrm_cfa_vfr_alloc(struct bnxt *bp, u16 vf_idx,
28                               u16 *tx_cfa_action, u16 *rx_cfa_code)
29 {
30         struct hwrm_cfa_vfr_alloc_output *resp = bp->hwrm_cmd_resp_addr;
31         struct hwrm_cfa_vfr_alloc_input req = { 0 };
32         int rc;
33
34         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_CFA_VFR_ALLOC, -1, -1);
35         req.vf_id = cpu_to_le16(vf_idx);
36         sprintf(req.vfr_name, "vfr%d", vf_idx);
37
38         mutex_lock(&bp->hwrm_cmd_lock);
39         rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
40         if (!rc) {
41                 *tx_cfa_action = le16_to_cpu(resp->tx_cfa_action);
42                 *rx_cfa_code = le16_to_cpu(resp->rx_cfa_code);
43                 netdev_dbg(bp->dev, "tx_cfa_action=0x%x, rx_cfa_code=0x%x",
44                            *tx_cfa_action, *rx_cfa_code);
45         } else {
46                 netdev_info(bp->dev, "%s error rc=%d", __func__, rc);
47         }
48
49         mutex_unlock(&bp->hwrm_cmd_lock);
50         return rc;
51 }
52
53 static int hwrm_cfa_vfr_free(struct bnxt *bp, u16 vf_idx)
54 {
55         struct hwrm_cfa_vfr_free_input req = { 0 };
56         int rc;
57
58         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_CFA_VFR_FREE, -1, -1);
59         sprintf(req.vfr_name, "vfr%d", vf_idx);
60
61         rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
62         if (rc)
63                 netdev_info(bp->dev, "%s error rc=%d", __func__, rc);
64         return rc;
65 }
66
67 static int bnxt_hwrm_vfr_qcfg(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
68                               u16 *max_mtu)
69 {
70         struct hwrm_func_qcfg_output *resp = bp->hwrm_cmd_resp_addr;
71         struct hwrm_func_qcfg_input req = {0};
72         u16 mtu;
73         int rc;
74
75         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_QCFG, -1, -1);
76         req.fid = cpu_to_le16(bp->pf.vf[vf_rep->vf_idx].fw_fid);
77
78         mutex_lock(&bp->hwrm_cmd_lock);
79
80         rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
81         if (!rc) {
82                 mtu = le16_to_cpu(resp->max_mtu_configured);
83                 if (!mtu)
84                         *max_mtu = BNXT_MAX_MTU;
85                 else
86                         *max_mtu = mtu;
87         }
88         mutex_unlock(&bp->hwrm_cmd_lock);
89         return rc;
90 }
91
92 static int bnxt_vf_rep_open(struct net_device *dev)
93 {
94         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
95         struct bnxt *bp = vf_rep->bp;
96
97         /* Enable link and TX only if the parent PF is open. */
98         if (netif_running(bp->dev)) {
99                 netif_carrier_on(dev);
100                 netif_tx_start_all_queues(dev);
101         }
102         return 0;
103 }
104
105 static int bnxt_vf_rep_close(struct net_device *dev)
106 {
107         netif_carrier_off(dev);
108         netif_tx_disable(dev);
109
110         return 0;
111 }
112
113 static netdev_tx_t bnxt_vf_rep_xmit(struct sk_buff *skb,
114                                     struct net_device *dev)
115 {
116         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
117         int rc, len = skb->len;
118
119         skb_dst_drop(skb);
120         dst_hold((struct dst_entry *)vf_rep->dst);
121         skb_dst_set(skb, (struct dst_entry *)vf_rep->dst);
122         skb->dev = vf_rep->dst->u.port_info.lower_dev;
123
124         rc = dev_queue_xmit(skb);
125         if (!rc) {
126                 vf_rep->tx_stats.packets++;
127                 vf_rep->tx_stats.bytes += len;
128         }
129         return rc;
130 }
131
132 static void
133 bnxt_vf_rep_get_stats64(struct net_device *dev,
134                         struct rtnl_link_stats64 *stats)
135 {
136         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
137
138         stats->rx_packets = vf_rep->rx_stats.packets;
139         stats->rx_bytes = vf_rep->rx_stats.bytes;
140         stats->tx_packets = vf_rep->tx_stats.packets;
141         stats->tx_bytes = vf_rep->tx_stats.bytes;
142 }
143
144 static int bnxt_vf_rep_setup_tc_block_cb(enum tc_setup_type type,
145                                          void *type_data,
146                                          void *cb_priv)
147 {
148         struct bnxt_vf_rep *vf_rep = cb_priv;
149         struct bnxt *bp = vf_rep->bp;
150         int vf_fid = bp->pf.vf[vf_rep->vf_idx].fw_fid;
151
152         if (!bnxt_tc_flower_enabled(vf_rep->bp) ||
153             !tc_cls_can_offload_and_chain0(bp->dev, type_data))
154                 return -EOPNOTSUPP;
155
156         switch (type) {
157         case TC_SETUP_CLSFLOWER:
158                 return bnxt_tc_setup_flower(bp, vf_fid, type_data);
159         default:
160                 return -EOPNOTSUPP;
161         }
162 }
163
164 static int bnxt_vf_rep_setup_tc_block(struct net_device *dev,
165                                       struct tc_block_offload *f)
166 {
167         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
168
169         if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
170                 return -EOPNOTSUPP;
171
172         switch (f->command) {
173         case TC_BLOCK_BIND:
174                 return tcf_block_cb_register(f->block,
175                                              bnxt_vf_rep_setup_tc_block_cb,
176                                              vf_rep, vf_rep, f->extack);
177         case TC_BLOCK_UNBIND:
178                 tcf_block_cb_unregister(f->block,
179                                         bnxt_vf_rep_setup_tc_block_cb, vf_rep);
180                 return 0;
181         default:
182                 return -EOPNOTSUPP;
183         }
184 }
185
186 static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
187                                 void *type_data)
188 {
189         switch (type) {
190         case TC_SETUP_BLOCK:
191                 return bnxt_vf_rep_setup_tc_block(dev, type_data);
192         default:
193                 return -EOPNOTSUPP;
194         }
195 }
196
197 struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code)
198 {
199         u16 vf_idx;
200
201         if (cfa_code && bp->cfa_code_map && BNXT_PF(bp)) {
202                 vf_idx = bp->cfa_code_map[cfa_code];
203                 if (vf_idx != VF_IDX_INVALID)
204                         return bp->vf_reps[vf_idx]->dev;
205         }
206         return NULL;
207 }
208
209 void bnxt_vf_rep_rx(struct bnxt *bp, struct sk_buff *skb)
210 {
211         struct bnxt_vf_rep *vf_rep = netdev_priv(skb->dev);
212
213         vf_rep->rx_stats.bytes += skb->len;
214         vf_rep->rx_stats.packets++;
215
216         netif_receive_skb(skb);
217 }
218
219 static int bnxt_vf_rep_get_phys_port_name(struct net_device *dev, char *buf,
220                                           size_t len)
221 {
222         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
223         struct pci_dev *pf_pdev = vf_rep->bp->pdev;
224         int rc;
225
226         rc = snprintf(buf, len, "pf%dvf%d", PCI_FUNC(pf_pdev->devfn),
227                       vf_rep->vf_idx);
228         if (rc >= len)
229                 return -EOPNOTSUPP;
230         return 0;
231 }
232
233 static void bnxt_vf_rep_get_drvinfo(struct net_device *dev,
234                                     struct ethtool_drvinfo *info)
235 {
236         strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
237         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
238 }
239
240 static int bnxt_vf_rep_port_attr_get(struct net_device *dev,
241                                      struct switchdev_attr *attr)
242 {
243         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
244
245         /* as only PORT_PARENT_ID is supported currently use common code
246          * between PF and VF-rep for now.
247          */
248         return bnxt_port_attr_get(vf_rep->bp, attr);
249 }
250
251 static const struct switchdev_ops bnxt_vf_rep_switchdev_ops = {
252         .switchdev_port_attr_get        = bnxt_vf_rep_port_attr_get
253 };
254
255 static const struct ethtool_ops bnxt_vf_rep_ethtool_ops = {
256         .get_drvinfo            = bnxt_vf_rep_get_drvinfo
257 };
258
259 static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
260         .ndo_open               = bnxt_vf_rep_open,
261         .ndo_stop               = bnxt_vf_rep_close,
262         .ndo_start_xmit         = bnxt_vf_rep_xmit,
263         .ndo_get_stats64        = bnxt_vf_rep_get_stats64,
264         .ndo_setup_tc           = bnxt_vf_rep_setup_tc,
265         .ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
266 };
267
268 bool bnxt_dev_is_vf_rep(struct net_device *dev)
269 {
270         return dev->netdev_ops == &bnxt_vf_rep_netdev_ops;
271 }
272
273 /* Called when the parent PF interface is closed:
274  * As the mode transition from SWITCHDEV to LEGACY
275  * happens under the rtnl_lock() this routine is safe
276  * under the rtnl_lock()
277  */
278 void bnxt_vf_reps_close(struct bnxt *bp)
279 {
280         struct bnxt_vf_rep *vf_rep;
281         u16 num_vfs, i;
282
283         if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
284                 return;
285
286         num_vfs = pci_num_vf(bp->pdev);
287         for (i = 0; i < num_vfs; i++) {
288                 vf_rep = bp->vf_reps[i];
289                 if (netif_running(vf_rep->dev))
290                         bnxt_vf_rep_close(vf_rep->dev);
291         }
292 }
293
294 /* Called when the parent PF interface is opened (re-opened):
295  * As the mode transition from SWITCHDEV to LEGACY
296  * happen under the rtnl_lock() this routine is safe
297  * under the rtnl_lock()
298  */
299 void bnxt_vf_reps_open(struct bnxt *bp)
300 {
301         int i;
302
303         if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
304                 return;
305
306         for (i = 0; i < pci_num_vf(bp->pdev); i++)
307                 bnxt_vf_rep_open(bp->vf_reps[i]->dev);
308 }
309
310 static void __bnxt_vf_reps_destroy(struct bnxt *bp)
311 {
312         u16 num_vfs = pci_num_vf(bp->pdev);
313         struct bnxt_vf_rep *vf_rep;
314         int i;
315
316         for (i = 0; i < num_vfs; i++) {
317                 vf_rep = bp->vf_reps[i];
318                 if (vf_rep) {
319                         dst_release((struct dst_entry *)vf_rep->dst);
320
321                         if (vf_rep->tx_cfa_action != CFA_HANDLE_INVALID)
322                                 hwrm_cfa_vfr_free(bp, vf_rep->vf_idx);
323
324                         if (vf_rep->dev) {
325                                 /* if register_netdev failed, then netdev_ops
326                                  * would have been set to NULL
327                                  */
328                                 if (vf_rep->dev->netdev_ops)
329                                         unregister_netdev(vf_rep->dev);
330                                 free_netdev(vf_rep->dev);
331                         }
332                 }
333         }
334
335         kfree(bp->vf_reps);
336         bp->vf_reps = NULL;
337 }
338
339 void bnxt_vf_reps_destroy(struct bnxt *bp)
340 {
341         bool closed = false;
342
343         if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
344                 return;
345
346         if (!bp->vf_reps)
347                 return;
348
349         /* Ensure that parent PF's and VF-reps' RX/TX has been quiesced
350          * before proceeding with VF-rep cleanup.
351          */
352         rtnl_lock();
353         if (netif_running(bp->dev)) {
354                 bnxt_close_nic(bp, false, false);
355                 closed = true;
356         }
357         /* un-publish cfa_code_map so that RX path can't see it anymore */
358         kfree(bp->cfa_code_map);
359         bp->cfa_code_map = NULL;
360         bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
361
362         if (closed)
363                 bnxt_open_nic(bp, false, false);
364         rtnl_unlock();
365
366         /* Need to call vf_reps_destroy() outside of rntl_lock
367          * as unregister_netdev takes rtnl_lock
368          */
369         __bnxt_vf_reps_destroy(bp);
370 }
371
372 /* Use the OUI of the PF's perm addr and report the same mac addr
373  * for the same VF-rep each time
374  */
375 static void bnxt_vf_rep_eth_addr_gen(u8 *src_mac, u16 vf_idx, u8 *mac)
376 {
377         u32 addr;
378
379         ether_addr_copy(mac, src_mac);
380
381         addr = jhash(src_mac, ETH_ALEN, 0) + vf_idx;
382         mac[3] = (u8)(addr & 0xFF);
383         mac[4] = (u8)((addr >> 8) & 0xFF);
384         mac[5] = (u8)((addr >> 16) & 0xFF);
385 }
386
387 static void bnxt_vf_rep_netdev_init(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
388                                     struct net_device *dev)
389 {
390         struct net_device *pf_dev = bp->dev;
391         u16 max_mtu;
392
393         dev->netdev_ops = &bnxt_vf_rep_netdev_ops;
394         dev->ethtool_ops = &bnxt_vf_rep_ethtool_ops;
395         SWITCHDEV_SET_OPS(dev, &bnxt_vf_rep_switchdev_ops);
396         /* Just inherit all the featues of the parent PF as the VF-R
397          * uses the RX/TX rings of the parent PF
398          */
399         dev->hw_features = pf_dev->hw_features;
400         dev->gso_partial_features = pf_dev->gso_partial_features;
401         dev->vlan_features = pf_dev->vlan_features;
402         dev->hw_enc_features = pf_dev->hw_enc_features;
403         dev->features |= pf_dev->features;
404         bnxt_vf_rep_eth_addr_gen(bp->pf.mac_addr, vf_rep->vf_idx,
405                                  dev->perm_addr);
406         ether_addr_copy(dev->dev_addr, dev->perm_addr);
407         /* Set VF-Rep's max-mtu to the corresponding VF's max-mtu */
408         if (!bnxt_hwrm_vfr_qcfg(bp, vf_rep, &max_mtu))
409                 dev->max_mtu = max_mtu;
410         dev->min_mtu = ETH_ZLEN;
411 }
412
413 static int bnxt_pcie_dsn_get(struct bnxt *bp, u8 dsn[])
414 {
415         struct pci_dev *pdev = bp->pdev;
416         int pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_DSN);
417         u32 dw;
418
419         if (!pos) {
420                 netdev_info(bp->dev, "Unable do read adapter's DSN");
421                 return -EOPNOTSUPP;
422         }
423
424         /* DSN (two dw) is at an offset of 4 from the cap pos */
425         pos += 4;
426         pci_read_config_dword(pdev, pos, &dw);
427         put_unaligned_le32(dw, &dsn[0]);
428         pci_read_config_dword(pdev, pos + 4, &dw);
429         put_unaligned_le32(dw, &dsn[4]);
430         return 0;
431 }
432
433 static int bnxt_vf_reps_create(struct bnxt *bp)
434 {
435         u16 *cfa_code_map = NULL, num_vfs = pci_num_vf(bp->pdev);
436         struct bnxt_vf_rep *vf_rep;
437         struct net_device *dev;
438         int rc, i;
439
440         bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
441         if (!bp->vf_reps)
442                 return -ENOMEM;
443
444         /* storage for cfa_code to vf-idx mapping */
445         cfa_code_map = kmalloc_array(MAX_CFA_CODE, sizeof(*bp->cfa_code_map),
446                                      GFP_KERNEL);
447         if (!cfa_code_map) {
448                 rc = -ENOMEM;
449                 goto err;
450         }
451         for (i = 0; i < MAX_CFA_CODE; i++)
452                 cfa_code_map[i] = VF_IDX_INVALID;
453
454         for (i = 0; i < num_vfs; i++) {
455                 dev = alloc_etherdev(sizeof(*vf_rep));
456                 if (!dev) {
457                         rc = -ENOMEM;
458                         goto err;
459                 }
460
461                 vf_rep = netdev_priv(dev);
462                 bp->vf_reps[i] = vf_rep;
463                 vf_rep->dev = dev;
464                 vf_rep->bp = bp;
465                 vf_rep->vf_idx = i;
466                 vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
467
468                 /* get cfa handles from FW */
469                 rc = hwrm_cfa_vfr_alloc(bp, vf_rep->vf_idx,
470                                         &vf_rep->tx_cfa_action,
471                                         &vf_rep->rx_cfa_code);
472                 if (rc) {
473                         rc = -ENOLINK;
474                         goto err;
475                 }
476                 cfa_code_map[vf_rep->rx_cfa_code] = vf_rep->vf_idx;
477
478                 vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
479                                                  GFP_KERNEL);
480                 if (!vf_rep->dst) {
481                         rc = -ENOMEM;
482                         goto err;
483                 }
484                 /* only cfa_action is needed to mux a packet while TXing */
485                 vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;
486                 vf_rep->dst->u.port_info.lower_dev = bp->dev;
487
488                 bnxt_vf_rep_netdev_init(bp, vf_rep, dev);
489                 rc = register_netdev(dev);
490                 if (rc) {
491                         /* no need for unregister_netdev in cleanup */
492                         dev->netdev_ops = NULL;
493                         goto err;
494                 }
495         }
496
497         /* Read the adapter's DSN to use as the eswitch switch_id */
498         rc = bnxt_pcie_dsn_get(bp, bp->switch_id);
499         if (rc)
500                 goto err;
501
502         /* publish cfa_code_map only after all VF-reps have been initialized */
503         bp->cfa_code_map = cfa_code_map;
504         bp->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
505         netif_keep_dst(bp->dev);
506         return 0;
507
508 err:
509         netdev_info(bp->dev, "%s error=%d", __func__, rc);
510         kfree(cfa_code_map);
511         __bnxt_vf_reps_destroy(bp);
512         return rc;
513 }
514
515 /* Devlink related routines */
516 int bnxt_dl_eswitch_mode_get(struct devlink *devlink, u16 *mode)
517 {
518         struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
519
520         *mode = bp->eswitch_mode;
521         return 0;
522 }
523
524 int bnxt_dl_eswitch_mode_set(struct devlink *devlink, u16 mode,
525                              struct netlink_ext_ack *extack)
526 {
527         struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
528         int rc = 0;
529
530         mutex_lock(&bp->sriov_lock);
531         if (bp->eswitch_mode == mode) {
532                 netdev_info(bp->dev, "already in %s eswitch mode",
533                             mode == DEVLINK_ESWITCH_MODE_LEGACY ?
534                             "legacy" : "switchdev");
535                 rc = -EINVAL;
536                 goto done;
537         }
538
539         switch (mode) {
540         case DEVLINK_ESWITCH_MODE_LEGACY:
541                 bnxt_vf_reps_destroy(bp);
542                 break;
543
544         case DEVLINK_ESWITCH_MODE_SWITCHDEV:
545                 if (bp->hwrm_spec_code < 0x10803) {
546                         netdev_warn(bp->dev, "FW does not support SRIOV E-Switch SWITCHDEV mode\n");
547                         rc = -ENOTSUPP;
548                         goto done;
549                 }
550
551                 if (pci_num_vf(bp->pdev) == 0) {
552                         netdev_info(bp->dev, "Enable VFs before setting switchdev mode");
553                         rc = -EPERM;
554                         goto done;
555                 }
556                 rc = bnxt_vf_reps_create(bp);
557                 break;
558
559         default:
560                 rc = -EINVAL;
561                 goto done;
562         }
563 done:
564         mutex_unlock(&bp->sriov_lock);
565         return rc;
566 }
567
568 #endif