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 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 	/* as only PORT_PARENT_ID is supported currently use common code
231 	 * between PF and VF-rep for now.
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 /* Called when the parent PF interface is closed:
256  * As the mode transition from SWITCHDEV to LEGACY
257  * happens under the rtnl_lock() this routine is safe
258  * under the rtnl_lock()
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 /* Called when the parent PF interface is opened (re-opened):
277  * As the mode transition from SWITCHDEV to LEGACY
278  * happen under the rtnl_lock() this routine is safe
279  * under the rtnl_lock()
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 				/* if register_netdev failed, then netdev_ops
308 				 * would have been set to NULL
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 	/* Ensure that parent PF's and VF-reps' RX/TX has been quiesced
332 	 * before proceeding with VF-rep cleanup.
333 	 */
334 	rtnl_lock();
335 	if (netif_running(bp->dev)) {
336 		bnxt_close_nic(bp, false, false);
337 		closed = true;
338 	}
339 	/* un-publish cfa_code_map so that RX path can't see it anymore */
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 	/* Need to call vf_reps_destroy() outside of rntl_lock
349 	 * as unregister_netdev takes rtnl_lock
350 	 */
351 	__bnxt_vf_reps_destroy(bp);
352 }
353 
354 /* Use the OUI of the PF's perm addr and report the same mac addr
355  * for the same VF-rep each time
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 	/* Just inherit all the featues of the parent PF as the VF-R
378 	 * uses the RX/TX rings of the parent PF
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 	/* Set VF-Rep's max-mtu to the corresponding VF's max-mtu */
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 	bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
402 	if (!bp->vf_reps)
403 		return -ENOMEM;
404 
405 	/* storage for cfa_code to vf-idx mapping */
406 	cfa_code_map = kmalloc_array(MAX_CFA_CODE, sizeof(*bp->cfa_code_map),
407 				     GFP_KERNEL);
408 	if (!cfa_code_map) {
409 		rc = -ENOMEM;
410 		goto err;
411 	}
412 	for (i = 0; i < MAX_CFA_CODE; i++)
413 		cfa_code_map[i] = VF_IDX_INVALID;
414 
415 	for (i = 0; i < num_vfs; i++) {
416 		dev = alloc_etherdev(sizeof(*vf_rep));
417 		if (!dev) {
418 			rc = -ENOMEM;
419 			goto err;
420 		}
421 
422 		vf_rep = netdev_priv(dev);
423 		bp->vf_reps[i] = vf_rep;
424 		vf_rep->dev = dev;
425 		vf_rep->bp = bp;
426 		vf_rep->vf_idx = i;
427 		vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
428 
429 		/* get cfa handles from FW */
430 		rc = hwrm_cfa_vfr_alloc(bp, vf_rep->vf_idx,
431 					&vf_rep->tx_cfa_action,
432 					&vf_rep->rx_cfa_code);
433 		if (rc) {
434 			rc = -ENOLINK;
435 			goto err;
436 		}
437 		cfa_code_map[vf_rep->rx_cfa_code] = vf_rep->vf_idx;
438 
439 		vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
440 						 GFP_KERNEL);
441 		if (!vf_rep->dst) {
442 			rc = -ENOMEM;
443 			goto err;
444 		}
445 		/* only cfa_action is needed to mux a packet while TXing */
446 		vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;
447 		vf_rep->dst->u.port_info.lower_dev = bp->dev;
448 
449 		bnxt_vf_rep_netdev_init(bp, vf_rep, dev);
450 		rc = register_netdev(dev);
451 		if (rc) {
452 			/* no need for unregister_netdev in cleanup */
453 			dev->netdev_ops = NULL;
454 			goto err;
455 		}
456 	}
457 
458 	/* publish cfa_code_map only after all VF-reps have been initialized */
459 	bp->cfa_code_map = cfa_code_map;
460 	bp->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
461 	netif_keep_dst(bp->dev);
462 	return 0;
463 
464 err:
465 	netdev_info(bp->dev, "%s error=%d", __func__, rc);
466 	kfree(cfa_code_map);
467 	__bnxt_vf_reps_destroy(bp);
468 	return rc;
469 }
470 
471 /* Devlink related routines */
472 int bnxt_dl_eswitch_mode_get(struct devlink *devlink, u16 *mode)
473 {
474 	struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
475 
476 	*mode = bp->eswitch_mode;
477 	return 0;
478 }
479 
480 int bnxt_dl_eswitch_mode_set(struct devlink *devlink, u16 mode,
481 			     struct netlink_ext_ack *extack)
482 {
483 	struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
484 	int rc = 0;
485 
486 	mutex_lock(&bp->sriov_lock);
487 	if (bp->eswitch_mode == mode) {
488 		netdev_info(bp->dev, "already in %s eswitch mode",
489 			    mode == DEVLINK_ESWITCH_MODE_LEGACY ?
490 			    "legacy" : "switchdev");
491 		rc = -EINVAL;
492 		goto done;
493 	}
494 
495 	switch (mode) {
496 	case DEVLINK_ESWITCH_MODE_LEGACY:
497 		bnxt_vf_reps_destroy(bp);
498 		break;
499 
500 	case DEVLINK_ESWITCH_MODE_SWITCHDEV:
501 		if (bp->hwrm_spec_code < 0x10803) {
502 			netdev_warn(bp->dev, "FW does not support SRIOV E-Switch SWITCHDEV mode\n");
503 			rc = -ENOTSUPP;
504 			goto done;
505 		}
506 
507 		if (pci_num_vf(bp->pdev) == 0) {
508 			netdev_info(bp->dev, "Enable VFs before setting switchdev mode");
509 			rc = -EPERM;
510 			goto done;
511 		}
512 		rc = bnxt_vf_reps_create(bp);
513 		break;
514 
515 	default:
516 		rc = -EINVAL;
517 		goto done;
518 	}
519 done:
520 	mutex_unlock(&bp->sriov_lock);
521 	return rc;
522 }
523 
524 #endif
525