This source file includes following definitions.
- hwrm_cfa_vfr_alloc
- hwrm_cfa_vfr_free
- bnxt_hwrm_vfr_qcfg
- bnxt_vf_rep_open
- bnxt_vf_rep_close
- bnxt_vf_rep_xmit
- bnxt_vf_rep_get_stats64
- bnxt_vf_rep_setup_tc_block_cb
- bnxt_vf_rep_setup_tc
- bnxt_get_vf_rep
- bnxt_vf_rep_rx
- bnxt_vf_rep_get_phys_port_name
- bnxt_vf_rep_get_drvinfo
- bnxt_vf_rep_get_port_parent_id
- bnxt_dev_is_vf_rep
- bnxt_vf_reps_close
- bnxt_vf_reps_open
- __bnxt_vf_reps_destroy
- bnxt_vf_reps_destroy
- bnxt_vf_rep_eth_addr_gen
- bnxt_vf_rep_netdev_init
- bnxt_vf_reps_create
- bnxt_dl_eswitch_mode_get
- bnxt_dl_eswitch_mode_set
1
2
3
4
5
6
7
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
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 LIST_HEAD(bnxt_vf_block_cb_list);
165
166 static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
167 void *type_data)
168 {
169 struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
170
171 switch (type) {
172 case TC_SETUP_BLOCK:
173 return flow_block_cb_setup_simple(type_data,
174 &bnxt_vf_block_cb_list,
175 bnxt_vf_rep_setup_tc_block_cb,
176 vf_rep, vf_rep, true);
177 default:
178 return -EOPNOTSUPP;
179 }
180 }
181
182 struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code)
183 {
184 u16 vf_idx;
185
186 if (cfa_code && bp->cfa_code_map && BNXT_PF(bp)) {
187 vf_idx = bp->cfa_code_map[cfa_code];
188 if (vf_idx != VF_IDX_INVALID)
189 return bp->vf_reps[vf_idx]->dev;
190 }
191 return NULL;
192 }
193
194 void bnxt_vf_rep_rx(struct bnxt *bp, struct sk_buff *skb)
195 {
196 struct bnxt_vf_rep *vf_rep = netdev_priv(skb->dev);
197
198 vf_rep->rx_stats.bytes += skb->len;
199 vf_rep->rx_stats.packets++;
200
201 netif_receive_skb(skb);
202 }
203
204 static int bnxt_vf_rep_get_phys_port_name(struct net_device *dev, char *buf,
205 size_t len)
206 {
207 struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
208 struct pci_dev *pf_pdev = vf_rep->bp->pdev;
209 int rc;
210
211 rc = snprintf(buf, len, "pf%dvf%d", PCI_FUNC(pf_pdev->devfn),
212 vf_rep->vf_idx);
213 if (rc >= len)
214 return -EOPNOTSUPP;
215 return 0;
216 }
217
218 static void bnxt_vf_rep_get_drvinfo(struct net_device *dev,
219 struct ethtool_drvinfo *info)
220 {
221 strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
222 strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
223 }
224
225 static int bnxt_vf_rep_get_port_parent_id(struct net_device *dev,
226 struct netdev_phys_item_id *ppid)
227 {
228 struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
229
230
231
232
233 return bnxt_get_port_parent_id(vf_rep->bp->dev, ppid);
234 }
235
236 static const struct ethtool_ops bnxt_vf_rep_ethtool_ops = {
237 .get_drvinfo = bnxt_vf_rep_get_drvinfo
238 };
239
240 static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
241 .ndo_open = bnxt_vf_rep_open,
242 .ndo_stop = bnxt_vf_rep_close,
243 .ndo_start_xmit = bnxt_vf_rep_xmit,
244 .ndo_get_stats64 = bnxt_vf_rep_get_stats64,
245 .ndo_setup_tc = bnxt_vf_rep_setup_tc,
246 .ndo_get_port_parent_id = bnxt_vf_rep_get_port_parent_id,
247 .ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
248 };
249
250 bool bnxt_dev_is_vf_rep(struct net_device *dev)
251 {
252 return dev->netdev_ops == &bnxt_vf_rep_netdev_ops;
253 }
254
255
256
257
258
259
260 void bnxt_vf_reps_close(struct bnxt *bp)
261 {
262 struct bnxt_vf_rep *vf_rep;
263 u16 num_vfs, i;
264
265 if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
266 return;
267
268 num_vfs = pci_num_vf(bp->pdev);
269 for (i = 0; i < num_vfs; i++) {
270 vf_rep = bp->vf_reps[i];
271 if (netif_running(vf_rep->dev))
272 bnxt_vf_rep_close(vf_rep->dev);
273 }
274 }
275
276
277
278
279
280
281 void bnxt_vf_reps_open(struct bnxt *bp)
282 {
283 int i;
284
285 if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
286 return;
287
288 for (i = 0; i < pci_num_vf(bp->pdev); i++)
289 bnxt_vf_rep_open(bp->vf_reps[i]->dev);
290 }
291
292 static void __bnxt_vf_reps_destroy(struct bnxt *bp)
293 {
294 u16 num_vfs = pci_num_vf(bp->pdev);
295 struct bnxt_vf_rep *vf_rep;
296 int i;
297
298 for (i = 0; i < num_vfs; i++) {
299 vf_rep = bp->vf_reps[i];
300 if (vf_rep) {
301 dst_release((struct dst_entry *)vf_rep->dst);
302
303 if (vf_rep->tx_cfa_action != CFA_HANDLE_INVALID)
304 hwrm_cfa_vfr_free(bp, vf_rep->vf_idx);
305
306 if (vf_rep->dev) {
307
308
309
310 if (vf_rep->dev->netdev_ops)
311 unregister_netdev(vf_rep->dev);
312 free_netdev(vf_rep->dev);
313 }
314 }
315 }
316
317 kfree(bp->vf_reps);
318 bp->vf_reps = NULL;
319 }
320
321 void bnxt_vf_reps_destroy(struct bnxt *bp)
322 {
323 bool closed = false;
324
325 if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
326 return;
327
328 if (!bp->vf_reps)
329 return;
330
331
332
333
334 rtnl_lock();
335 if (netif_running(bp->dev)) {
336 bnxt_close_nic(bp, false, false);
337 closed = true;
338 }
339
340 kfree(bp->cfa_code_map);
341 bp->cfa_code_map = NULL;
342 bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
343
344 if (closed)
345 bnxt_open_nic(bp, false, false);
346 rtnl_unlock();
347
348
349
350
351 __bnxt_vf_reps_destroy(bp);
352 }
353
354
355
356
357 static void bnxt_vf_rep_eth_addr_gen(u8 *src_mac, u16 vf_idx, u8 *mac)
358 {
359 u32 addr;
360
361 ether_addr_copy(mac, src_mac);
362
363 addr = jhash(src_mac, ETH_ALEN, 0) + vf_idx;
364 mac[3] = (u8)(addr & 0xFF);
365 mac[4] = (u8)((addr >> 8) & 0xFF);
366 mac[5] = (u8)((addr >> 16) & 0xFF);
367 }
368
369 static void bnxt_vf_rep_netdev_init(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
370 struct net_device *dev)
371 {
372 struct net_device *pf_dev = bp->dev;
373 u16 max_mtu;
374
375 dev->netdev_ops = &bnxt_vf_rep_netdev_ops;
376 dev->ethtool_ops = &bnxt_vf_rep_ethtool_ops;
377
378
379
380 dev->hw_features = pf_dev->hw_features;
381 dev->gso_partial_features = pf_dev->gso_partial_features;
382 dev->vlan_features = pf_dev->vlan_features;
383 dev->hw_enc_features = pf_dev->hw_enc_features;
384 dev->features |= pf_dev->features;
385 bnxt_vf_rep_eth_addr_gen(bp->pf.mac_addr, vf_rep->vf_idx,
386 dev->perm_addr);
387 ether_addr_copy(dev->dev_addr, dev->perm_addr);
388
389 if (!bnxt_hwrm_vfr_qcfg(bp, vf_rep, &max_mtu))
390 dev->max_mtu = max_mtu;
391 dev->min_mtu = ETH_ZLEN;
392 }
393
394 static int bnxt_vf_reps_create(struct bnxt *bp)
395 {
396 u16 *cfa_code_map = NULL, num_vfs = pci_num_vf(bp->pdev);
397 struct bnxt_vf_rep *vf_rep;
398 struct net_device *dev;
399 int rc, i;
400
401 if (!(bp->flags & BNXT_FLAG_DSN_VALID))
402 return -ENODEV;
403
404 bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
405 if (!bp->vf_reps)
406 return -ENOMEM;
407
408
409 cfa_code_map = kmalloc_array(MAX_CFA_CODE, sizeof(*bp->cfa_code_map),
410 GFP_KERNEL);
411 if (!cfa_code_map) {
412 rc = -ENOMEM;
413 goto err;
414 }
415 for (i = 0; i < MAX_CFA_CODE; i++)
416 cfa_code_map[i] = VF_IDX_INVALID;
417
418 for (i = 0; i < num_vfs; i++) {
419 dev = alloc_etherdev(sizeof(*vf_rep));
420 if (!dev) {
421 rc = -ENOMEM;
422 goto err;
423 }
424
425 vf_rep = netdev_priv(dev);
426 bp->vf_reps[i] = vf_rep;
427 vf_rep->dev = dev;
428 vf_rep->bp = bp;
429 vf_rep->vf_idx = i;
430 vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
431
432
433 rc = hwrm_cfa_vfr_alloc(bp, vf_rep->vf_idx,
434 &vf_rep->tx_cfa_action,
435 &vf_rep->rx_cfa_code);
436 if (rc) {
437 rc = -ENOLINK;
438 goto err;
439 }
440 cfa_code_map[vf_rep->rx_cfa_code] = vf_rep->vf_idx;
441
442 vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
443 GFP_KERNEL);
444 if (!vf_rep->dst) {
445 rc = -ENOMEM;
446 goto err;
447 }
448
449 vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;
450 vf_rep->dst->u.port_info.lower_dev = bp->dev;
451
452 bnxt_vf_rep_netdev_init(bp, vf_rep, dev);
453 rc = register_netdev(dev);
454 if (rc) {
455
456 dev->netdev_ops = NULL;
457 goto err;
458 }
459 }
460
461
462 bp->cfa_code_map = cfa_code_map;
463 bp->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
464 netif_keep_dst(bp->dev);
465 return 0;
466
467 err:
468 netdev_info(bp->dev, "%s error=%d", __func__, rc);
469 kfree(cfa_code_map);
470 __bnxt_vf_reps_destroy(bp);
471 return rc;
472 }
473
474
475 int bnxt_dl_eswitch_mode_get(struct devlink *devlink, u16 *mode)
476 {
477 struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
478
479 *mode = bp->eswitch_mode;
480 return 0;
481 }
482
483 int bnxt_dl_eswitch_mode_set(struct devlink *devlink, u16 mode,
484 struct netlink_ext_ack *extack)
485 {
486 struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
487 int rc = 0;
488
489 mutex_lock(&bp->sriov_lock);
490 if (bp->eswitch_mode == mode) {
491 netdev_info(bp->dev, "already in %s eswitch mode",
492 mode == DEVLINK_ESWITCH_MODE_LEGACY ?
493 "legacy" : "switchdev");
494 rc = -EINVAL;
495 goto done;
496 }
497
498 switch (mode) {
499 case DEVLINK_ESWITCH_MODE_LEGACY:
500 bnxt_vf_reps_destroy(bp);
501 break;
502
503 case DEVLINK_ESWITCH_MODE_SWITCHDEV:
504 if (bp->hwrm_spec_code < 0x10803) {
505 netdev_warn(bp->dev, "FW does not support SRIOV E-Switch SWITCHDEV mode\n");
506 rc = -ENOTSUPP;
507 goto done;
508 }
509
510 if (pci_num_vf(bp->pdev) == 0) {
511 netdev_info(bp->dev, "Enable VFs before setting switchdev mode");
512 rc = -EPERM;
513 goto done;
514 }
515 rc = bnxt_vf_reps_create(bp);
516 break;
517
518 default:
519 rc = -EINVAL;
520 goto done;
521 }
522 done:
523 mutex_unlock(&bp->sriov_lock);
524 return rc;
525 }
526
527 #endif