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_get_port_parent_id(struct net_device *dev,
241 					  struct netdev_phys_item_id *ppid)
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_get_port_parent_id(vf_rep->bp->dev, ppid);
249 }
250 
251 static const struct ethtool_ops bnxt_vf_rep_ethtool_ops = {
252 	.get_drvinfo		= bnxt_vf_rep_get_drvinfo
253 };
254 
255 static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
256 	.ndo_open		= bnxt_vf_rep_open,
257 	.ndo_stop		= bnxt_vf_rep_close,
258 	.ndo_start_xmit		= bnxt_vf_rep_xmit,
259 	.ndo_get_stats64	= bnxt_vf_rep_get_stats64,
260 	.ndo_setup_tc		= bnxt_vf_rep_setup_tc,
261 	.ndo_get_port_parent_id	= bnxt_vf_rep_get_port_parent_id,
262 	.ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
263 };
264 
265 bool bnxt_dev_is_vf_rep(struct net_device *dev)
266 {
267 	return dev->netdev_ops == &bnxt_vf_rep_netdev_ops;
268 }
269 
270 /* Called when the parent PF interface is closed:
271  * As the mode transition from SWITCHDEV to LEGACY
272  * happens under the rtnl_lock() this routine is safe
273  * under the rtnl_lock()
274  */
275 void bnxt_vf_reps_close(struct bnxt *bp)
276 {
277 	struct bnxt_vf_rep *vf_rep;
278 	u16 num_vfs, i;
279 
280 	if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
281 		return;
282 
283 	num_vfs = pci_num_vf(bp->pdev);
284 	for (i = 0; i < num_vfs; i++) {
285 		vf_rep = bp->vf_reps[i];
286 		if (netif_running(vf_rep->dev))
287 			bnxt_vf_rep_close(vf_rep->dev);
288 	}
289 }
290 
291 /* Called when the parent PF interface is opened (re-opened):
292  * As the mode transition from SWITCHDEV to LEGACY
293  * happen under the rtnl_lock() this routine is safe
294  * under the rtnl_lock()
295  */
296 void bnxt_vf_reps_open(struct bnxt *bp)
297 {
298 	int i;
299 
300 	if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
301 		return;
302 
303 	for (i = 0; i < pci_num_vf(bp->pdev); i++)
304 		bnxt_vf_rep_open(bp->vf_reps[i]->dev);
305 }
306 
307 static void __bnxt_vf_reps_destroy(struct bnxt *bp)
308 {
309 	u16 num_vfs = pci_num_vf(bp->pdev);
310 	struct bnxt_vf_rep *vf_rep;
311 	int i;
312 
313 	for (i = 0; i < num_vfs; i++) {
314 		vf_rep = bp->vf_reps[i];
315 		if (vf_rep) {
316 			dst_release((struct dst_entry *)vf_rep->dst);
317 
318 			if (vf_rep->tx_cfa_action != CFA_HANDLE_INVALID)
319 				hwrm_cfa_vfr_free(bp, vf_rep->vf_idx);
320 
321 			if (vf_rep->dev) {
322 				/* if register_netdev failed, then netdev_ops
323 				 * would have been set to NULL
324 				 */
325 				if (vf_rep->dev->netdev_ops)
326 					unregister_netdev(vf_rep->dev);
327 				free_netdev(vf_rep->dev);
328 			}
329 		}
330 	}
331 
332 	kfree(bp->vf_reps);
333 	bp->vf_reps = NULL;
334 }
335 
336 void bnxt_vf_reps_destroy(struct bnxt *bp)
337 {
338 	bool closed = false;
339 
340 	if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
341 		return;
342 
343 	if (!bp->vf_reps)
344 		return;
345 
346 	/* Ensure that parent PF's and VF-reps' RX/TX has been quiesced
347 	 * before proceeding with VF-rep cleanup.
348 	 */
349 	rtnl_lock();
350 	if (netif_running(bp->dev)) {
351 		bnxt_close_nic(bp, false, false);
352 		closed = true;
353 	}
354 	/* un-publish cfa_code_map so that RX path can't see it anymore */
355 	kfree(bp->cfa_code_map);
356 	bp->cfa_code_map = NULL;
357 	bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
358 
359 	if (closed)
360 		bnxt_open_nic(bp, false, false);
361 	rtnl_unlock();
362 
363 	/* Need to call vf_reps_destroy() outside of rntl_lock
364 	 * as unregister_netdev takes rtnl_lock
365 	 */
366 	__bnxt_vf_reps_destroy(bp);
367 }
368 
369 /* Use the OUI of the PF's perm addr and report the same mac addr
370  * for the same VF-rep each time
371  */
372 static void bnxt_vf_rep_eth_addr_gen(u8 *src_mac, u16 vf_idx, u8 *mac)
373 {
374 	u32 addr;
375 
376 	ether_addr_copy(mac, src_mac);
377 
378 	addr = jhash(src_mac, ETH_ALEN, 0) + vf_idx;
379 	mac[3] = (u8)(addr & 0xFF);
380 	mac[4] = (u8)((addr >> 8) & 0xFF);
381 	mac[5] = (u8)((addr >> 16) & 0xFF);
382 }
383 
384 static void bnxt_vf_rep_netdev_init(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
385 				    struct net_device *dev)
386 {
387 	struct net_device *pf_dev = bp->dev;
388 	u16 max_mtu;
389 
390 	dev->netdev_ops = &bnxt_vf_rep_netdev_ops;
391 	dev->ethtool_ops = &bnxt_vf_rep_ethtool_ops;
392 	/* Just inherit all the featues of the parent PF as the VF-R
393 	 * uses the RX/TX rings of the parent PF
394 	 */
395 	dev->hw_features = pf_dev->hw_features;
396 	dev->gso_partial_features = pf_dev->gso_partial_features;
397 	dev->vlan_features = pf_dev->vlan_features;
398 	dev->hw_enc_features = pf_dev->hw_enc_features;
399 	dev->features |= pf_dev->features;
400 	bnxt_vf_rep_eth_addr_gen(bp->pf.mac_addr, vf_rep->vf_idx,
401 				 dev->perm_addr);
402 	ether_addr_copy(dev->dev_addr, dev->perm_addr);
403 	/* Set VF-Rep's max-mtu to the corresponding VF's max-mtu */
404 	if (!bnxt_hwrm_vfr_qcfg(bp, vf_rep, &max_mtu))
405 		dev->max_mtu = max_mtu;
406 	dev->min_mtu = ETH_ZLEN;
407 }
408 
409 static int bnxt_pcie_dsn_get(struct bnxt *bp, u8 dsn[])
410 {
411 	struct pci_dev *pdev = bp->pdev;
412 	int pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_DSN);
413 	u32 dw;
414 
415 	if (!pos) {
416 		netdev_info(bp->dev, "Unable do read adapter's DSN");
417 		return -EOPNOTSUPP;
418 	}
419 
420 	/* DSN (two dw) is at an offset of 4 from the cap pos */
421 	pos += 4;
422 	pci_read_config_dword(pdev, pos, &dw);
423 	put_unaligned_le32(dw, &dsn[0]);
424 	pci_read_config_dword(pdev, pos + 4, &dw);
425 	put_unaligned_le32(dw, &dsn[4]);
426 	return 0;
427 }
428 
429 static int bnxt_vf_reps_create(struct bnxt *bp)
430 {
431 	u16 *cfa_code_map = NULL, num_vfs = pci_num_vf(bp->pdev);
432 	struct bnxt_vf_rep *vf_rep;
433 	struct net_device *dev;
434 	int rc, i;
435 
436 	bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
437 	if (!bp->vf_reps)
438 		return -ENOMEM;
439 
440 	/* storage for cfa_code to vf-idx mapping */
441 	cfa_code_map = kmalloc_array(MAX_CFA_CODE, sizeof(*bp->cfa_code_map),
442 				     GFP_KERNEL);
443 	if (!cfa_code_map) {
444 		rc = -ENOMEM;
445 		goto err;
446 	}
447 	for (i = 0; i < MAX_CFA_CODE; i++)
448 		cfa_code_map[i] = VF_IDX_INVALID;
449 
450 	for (i = 0; i < num_vfs; i++) {
451 		dev = alloc_etherdev(sizeof(*vf_rep));
452 		if (!dev) {
453 			rc = -ENOMEM;
454 			goto err;
455 		}
456 
457 		vf_rep = netdev_priv(dev);
458 		bp->vf_reps[i] = vf_rep;
459 		vf_rep->dev = dev;
460 		vf_rep->bp = bp;
461 		vf_rep->vf_idx = i;
462 		vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
463 
464 		/* get cfa handles from FW */
465 		rc = hwrm_cfa_vfr_alloc(bp, vf_rep->vf_idx,
466 					&vf_rep->tx_cfa_action,
467 					&vf_rep->rx_cfa_code);
468 		if (rc) {
469 			rc = -ENOLINK;
470 			goto err;
471 		}
472 		cfa_code_map[vf_rep->rx_cfa_code] = vf_rep->vf_idx;
473 
474 		vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
475 						 GFP_KERNEL);
476 		if (!vf_rep->dst) {
477 			rc = -ENOMEM;
478 			goto err;
479 		}
480 		/* only cfa_action is needed to mux a packet while TXing */
481 		vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;
482 		vf_rep->dst->u.port_info.lower_dev = bp->dev;
483 
484 		bnxt_vf_rep_netdev_init(bp, vf_rep, dev);
485 		rc = register_netdev(dev);
486 		if (rc) {
487 			/* no need for unregister_netdev in cleanup */
488 			dev->netdev_ops = NULL;
489 			goto err;
490 		}
491 	}
492 
493 	/* Read the adapter's DSN to use as the eswitch switch_id */
494 	rc = bnxt_pcie_dsn_get(bp, bp->switch_id);
495 	if (rc)
496 		goto err;
497 
498 	/* publish cfa_code_map only after all VF-reps have been initialized */
499 	bp->cfa_code_map = cfa_code_map;
500 	bp->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
501 	netif_keep_dst(bp->dev);
502 	return 0;
503 
504 err:
505 	netdev_info(bp->dev, "%s error=%d", __func__, rc);
506 	kfree(cfa_code_map);
507 	__bnxt_vf_reps_destroy(bp);
508 	return rc;
509 }
510 
511 /* Devlink related routines */
512 int bnxt_dl_eswitch_mode_get(struct devlink *devlink, u16 *mode)
513 {
514 	struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
515 
516 	*mode = bp->eswitch_mode;
517 	return 0;
518 }
519 
520 int bnxt_dl_eswitch_mode_set(struct devlink *devlink, u16 mode,
521 			     struct netlink_ext_ack *extack)
522 {
523 	struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
524 	int rc = 0;
525 
526 	mutex_lock(&bp->sriov_lock);
527 	if (bp->eswitch_mode == mode) {
528 		netdev_info(bp->dev, "already in %s eswitch mode",
529 			    mode == DEVLINK_ESWITCH_MODE_LEGACY ?
530 			    "legacy" : "switchdev");
531 		rc = -EINVAL;
532 		goto done;
533 	}
534 
535 	switch (mode) {
536 	case DEVLINK_ESWITCH_MODE_LEGACY:
537 		bnxt_vf_reps_destroy(bp);
538 		break;
539 
540 	case DEVLINK_ESWITCH_MODE_SWITCHDEV:
541 		if (bp->hwrm_spec_code < 0x10803) {
542 			netdev_warn(bp->dev, "FW does not support SRIOV E-Switch SWITCHDEV mode\n");
543 			rc = -ENOTSUPP;
544 			goto done;
545 		}
546 
547 		if (pci_num_vf(bp->pdev) == 0) {
548 			netdev_info(bp->dev, "Enable VFs before setting switchdev mode");
549 			rc = -EPERM;
550 			goto done;
551 		}
552 		rc = bnxt_vf_reps_create(bp);
553 		break;
554 
555 	default:
556 		rc = -EINVAL;
557 		goto done;
558 	}
559 done:
560 	mutex_unlock(&bp->sriov_lock);
561 	return rc;
562 }
563 
564 #endif
565