1 // SPDX-License-Identifier: GPL-2.0-only
2 /****************************************************************************
3  * Driver for Solarflare network controllers and boards
4  * Copyright 2019 Solarflare Communications Inc.
5  * Copyright 2020-2022 Xilinx Inc.
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License version 2 as published
9  * by the Free Software Foundation, incorporated herein by reference.
10  */
11 
12 #include <linux/rhashtable.h>
13 #include "ef100_rep.h"
14 #include "ef100_netdev.h"
15 #include "ef100_nic.h"
16 #include "mae.h"
17 #include "rx_common.h"
18 #include "tc_bindings.h"
19 #include "efx_devlink.h"
20 
21 #define EFX_EF100_REP_DRIVER	"efx_ef100_rep"
22 
23 #define EFX_REP_DEFAULT_PSEUDO_RING_SIZE	64
24 
25 static int efx_ef100_rep_poll(struct napi_struct *napi, int weight);
26 
27 static int efx_ef100_rep_init_struct(struct efx_nic *efx, struct efx_rep *efv,
28 				     unsigned int i)
29 {
30 	efv->parent = efx;
31 	efv->idx = i;
32 	INIT_LIST_HEAD(&efv->list);
33 	efv->dflt.fw_id = MC_CMD_MAE_ACTION_RULE_INSERT_OUT_ACTION_RULE_ID_NULL;
34 	INIT_LIST_HEAD(&efv->dflt.acts.list);
35 	INIT_LIST_HEAD(&efv->rx_list);
36 	spin_lock_init(&efv->rx_lock);
37 	efv->msg_enable = NETIF_MSG_DRV | NETIF_MSG_PROBE |
38 			  NETIF_MSG_LINK | NETIF_MSG_IFDOWN |
39 			  NETIF_MSG_IFUP | NETIF_MSG_RX_ERR |
40 			  NETIF_MSG_TX_ERR | NETIF_MSG_HW;
41 	return 0;
42 }
43 
44 static int efx_ef100_rep_open(struct net_device *net_dev)
45 {
46 	struct efx_rep *efv = netdev_priv(net_dev);
47 
48 	netif_napi_add(net_dev, &efv->napi, efx_ef100_rep_poll);
49 	napi_enable(&efv->napi);
50 	return 0;
51 }
52 
53 static int efx_ef100_rep_close(struct net_device *net_dev)
54 {
55 	struct efx_rep *efv = netdev_priv(net_dev);
56 
57 	napi_disable(&efv->napi);
58 	netif_napi_del(&efv->napi);
59 	return 0;
60 }
61 
62 static netdev_tx_t efx_ef100_rep_xmit(struct sk_buff *skb,
63 				      struct net_device *dev)
64 {
65 	struct efx_rep *efv = netdev_priv(dev);
66 	struct efx_nic *efx = efv->parent;
67 	netdev_tx_t rc;
68 
69 	/* __ef100_hard_start_xmit() will always return success even in the
70 	 * case of TX drops, where it will increment efx's tx_dropped.  The
71 	 * efv stats really only count attempted TX, not success/failure.
72 	 */
73 	atomic64_inc(&efv->stats.tx_packets);
74 	atomic64_add(skb->len, &efv->stats.tx_bytes);
75 	netif_tx_lock(efx->net_dev);
76 	rc = __ef100_hard_start_xmit(skb, efx, dev, efv);
77 	netif_tx_unlock(efx->net_dev);
78 	return rc;
79 }
80 
81 static int efx_ef100_rep_get_port_parent_id(struct net_device *dev,
82 					    struct netdev_phys_item_id *ppid)
83 {
84 	struct efx_rep *efv = netdev_priv(dev);
85 	struct efx_nic *efx = efv->parent;
86 	struct ef100_nic_data *nic_data;
87 
88 	nic_data = efx->nic_data;
89 	/* nic_data->port_id is a u8[] */
90 	ppid->id_len = sizeof(nic_data->port_id);
91 	memcpy(ppid->id, nic_data->port_id, sizeof(nic_data->port_id));
92 	return 0;
93 }
94 
95 static int efx_ef100_rep_get_phys_port_name(struct net_device *dev,
96 					    char *buf, size_t len)
97 {
98 	struct efx_rep *efv = netdev_priv(dev);
99 	struct efx_nic *efx = efv->parent;
100 	struct ef100_nic_data *nic_data;
101 	int ret;
102 
103 	nic_data = efx->nic_data;
104 	ret = snprintf(buf, len, "p%upf%uvf%u", efx->port_num,
105 		       nic_data->pf_index, efv->idx);
106 	if (ret >= len)
107 		return -EOPNOTSUPP;
108 
109 	return 0;
110 }
111 
112 static int efx_ef100_rep_setup_tc(struct net_device *net_dev,
113 				  enum tc_setup_type type, void *type_data)
114 {
115 	struct efx_rep *efv = netdev_priv(net_dev);
116 	struct efx_nic *efx = efv->parent;
117 
118 	if (type == TC_SETUP_CLSFLOWER)
119 		return efx_tc_flower(efx, net_dev, type_data, efv);
120 	if (type == TC_SETUP_BLOCK)
121 		return efx_tc_setup_block(net_dev, efx, type_data, efv);
122 
123 	return -EOPNOTSUPP;
124 }
125 
126 static void efx_ef100_rep_get_stats64(struct net_device *dev,
127 				      struct rtnl_link_stats64 *stats)
128 {
129 	struct efx_rep *efv = netdev_priv(dev);
130 
131 	stats->rx_packets = atomic64_read(&efv->stats.rx_packets);
132 	stats->tx_packets = atomic64_read(&efv->stats.tx_packets);
133 	stats->rx_bytes = atomic64_read(&efv->stats.rx_bytes);
134 	stats->tx_bytes = atomic64_read(&efv->stats.tx_bytes);
135 	stats->rx_dropped = atomic64_read(&efv->stats.rx_dropped);
136 	stats->tx_errors = atomic64_read(&efv->stats.tx_errors);
137 }
138 
139 const struct net_device_ops efx_ef100_rep_netdev_ops = {
140 	.ndo_open		= efx_ef100_rep_open,
141 	.ndo_stop		= efx_ef100_rep_close,
142 	.ndo_start_xmit		= efx_ef100_rep_xmit,
143 	.ndo_get_port_parent_id	= efx_ef100_rep_get_port_parent_id,
144 	.ndo_get_phys_port_name	= efx_ef100_rep_get_phys_port_name,
145 	.ndo_get_stats64	= efx_ef100_rep_get_stats64,
146 	.ndo_setup_tc		= efx_ef100_rep_setup_tc,
147 };
148 
149 static void efx_ef100_rep_get_drvinfo(struct net_device *dev,
150 				      struct ethtool_drvinfo *drvinfo)
151 {
152 	strscpy(drvinfo->driver, EFX_EF100_REP_DRIVER, sizeof(drvinfo->driver));
153 }
154 
155 static u32 efx_ef100_rep_ethtool_get_msglevel(struct net_device *net_dev)
156 {
157 	struct efx_rep *efv = netdev_priv(net_dev);
158 
159 	return efv->msg_enable;
160 }
161 
162 static void efx_ef100_rep_ethtool_set_msglevel(struct net_device *net_dev,
163 					       u32 msg_enable)
164 {
165 	struct efx_rep *efv = netdev_priv(net_dev);
166 
167 	efv->msg_enable = msg_enable;
168 }
169 
170 static void efx_ef100_rep_ethtool_get_ringparam(struct net_device *net_dev,
171 						struct ethtool_ringparam *ring,
172 						struct kernel_ethtool_ringparam *kring,
173 						struct netlink_ext_ack *ext_ack)
174 {
175 	struct efx_rep *efv = netdev_priv(net_dev);
176 
177 	ring->rx_max_pending = U32_MAX;
178 	ring->rx_pending = efv->rx_pring_size;
179 }
180 
181 static int efx_ef100_rep_ethtool_set_ringparam(struct net_device *net_dev,
182 					       struct ethtool_ringparam *ring,
183 					       struct kernel_ethtool_ringparam *kring,
184 					       struct netlink_ext_ack *ext_ack)
185 {
186 	struct efx_rep *efv = netdev_priv(net_dev);
187 
188 	if (ring->rx_mini_pending || ring->rx_jumbo_pending || ring->tx_pending)
189 		return -EINVAL;
190 
191 	efv->rx_pring_size = ring->rx_pending;
192 	return 0;
193 }
194 
195 static const struct ethtool_ops efx_ef100_rep_ethtool_ops = {
196 	.get_drvinfo		= efx_ef100_rep_get_drvinfo,
197 	.get_msglevel		= efx_ef100_rep_ethtool_get_msglevel,
198 	.set_msglevel		= efx_ef100_rep_ethtool_set_msglevel,
199 	.get_ringparam		= efx_ef100_rep_ethtool_get_ringparam,
200 	.set_ringparam		= efx_ef100_rep_ethtool_set_ringparam,
201 };
202 
203 static struct efx_rep *efx_ef100_rep_create_netdev(struct efx_nic *efx,
204 						   unsigned int i)
205 {
206 	struct net_device *net_dev;
207 	struct efx_rep *efv;
208 	int rc;
209 
210 	net_dev = alloc_etherdev_mq(sizeof(*efv), 1);
211 	if (!net_dev)
212 		return ERR_PTR(-ENOMEM);
213 
214 	efv = netdev_priv(net_dev);
215 	rc = efx_ef100_rep_init_struct(efx, efv, i);
216 	if (rc)
217 		goto fail1;
218 	efv->net_dev = net_dev;
219 	rtnl_lock();
220 	spin_lock_bh(&efx->vf_reps_lock);
221 	list_add_tail(&efv->list, &efx->vf_reps);
222 	spin_unlock_bh(&efx->vf_reps_lock);
223 	if (netif_running(efx->net_dev) && efx->state == STATE_NET_UP) {
224 		netif_device_attach(net_dev);
225 		netif_carrier_on(net_dev);
226 	} else {
227 		netif_carrier_off(net_dev);
228 		netif_tx_stop_all_queues(net_dev);
229 	}
230 	rtnl_unlock();
231 
232 	net_dev->netdev_ops = &efx_ef100_rep_netdev_ops;
233 	net_dev->ethtool_ops = &efx_ef100_rep_ethtool_ops;
234 	net_dev->min_mtu = EFX_MIN_MTU;
235 	net_dev->max_mtu = EFX_MAX_MTU;
236 	net_dev->features |= NETIF_F_LLTX;
237 	net_dev->hw_features |= NETIF_F_LLTX;
238 	return efv;
239 fail1:
240 	free_netdev(net_dev);
241 	return ERR_PTR(rc);
242 }
243 
244 static int efx_ef100_configure_rep(struct efx_rep *efv)
245 {
246 	struct efx_nic *efx = efv->parent;
247 	int rc;
248 
249 	efv->rx_pring_size = EFX_REP_DEFAULT_PSEUDO_RING_SIZE;
250 	/* Look up actual mport ID */
251 	rc = efx_mae_lookup_mport(efx, efv->idx, &efv->mport);
252 	if (rc)
253 		return rc;
254 	pci_dbg(efx->pci_dev, "VF %u has mport ID %#x\n", efv->idx, efv->mport);
255 	/* mport label should fit in 16 bits */
256 	WARN_ON(efv->mport >> 16);
257 
258 	return efx_tc_configure_default_rule_rep(efv);
259 }
260 
261 static void efx_ef100_deconfigure_rep(struct efx_rep *efv)
262 {
263 	struct efx_nic *efx = efv->parent;
264 
265 	efx_tc_deconfigure_default_rule(efx, &efv->dflt);
266 }
267 
268 static void efx_ef100_rep_destroy_netdev(struct efx_rep *efv)
269 {
270 	struct efx_nic *efx = efv->parent;
271 
272 	rtnl_lock();
273 	spin_lock_bh(&efx->vf_reps_lock);
274 	list_del(&efv->list);
275 	spin_unlock_bh(&efx->vf_reps_lock);
276 	rtnl_unlock();
277 	synchronize_rcu();
278 	free_netdev(efv->net_dev);
279 }
280 
281 int efx_ef100_vfrep_create(struct efx_nic *efx, unsigned int i)
282 {
283 	struct efx_rep *efv;
284 	int rc;
285 
286 	efv = efx_ef100_rep_create_netdev(efx, i);
287 	if (IS_ERR(efv)) {
288 		rc = PTR_ERR(efv);
289 		pci_err(efx->pci_dev,
290 			"Failed to create representor for VF %d, rc %d\n", i,
291 			rc);
292 		return rc;
293 	}
294 	rc = efx_ef100_configure_rep(efv);
295 	if (rc) {
296 		pci_err(efx->pci_dev,
297 			"Failed to configure representor for VF %d, rc %d\n",
298 			i, rc);
299 		goto fail1;
300 	}
301 	ef100_rep_set_devlink_port(efv);
302 	rc = register_netdev(efv->net_dev);
303 	if (rc) {
304 		pci_err(efx->pci_dev,
305 			"Failed to register representor for VF %d, rc %d\n",
306 			i, rc);
307 		goto fail2;
308 	}
309 	pci_dbg(efx->pci_dev, "Representor for VF %d is %s\n", i,
310 		efv->net_dev->name);
311 	return 0;
312 fail2:
313 	ef100_rep_unset_devlink_port(efv);
314 	efx_ef100_deconfigure_rep(efv);
315 fail1:
316 	efx_ef100_rep_destroy_netdev(efv);
317 	return rc;
318 }
319 
320 void efx_ef100_vfrep_destroy(struct efx_nic *efx, struct efx_rep *efv)
321 {
322 	struct net_device *rep_dev;
323 
324 	rep_dev = efv->net_dev;
325 	if (!rep_dev)
326 		return;
327 	netif_dbg(efx, drv, rep_dev, "Removing VF representor\n");
328 	unregister_netdev(rep_dev);
329 	ef100_rep_unset_devlink_port(efv);
330 	efx_ef100_deconfigure_rep(efv);
331 	efx_ef100_rep_destroy_netdev(efv);
332 }
333 
334 void efx_ef100_fini_vfreps(struct efx_nic *efx)
335 {
336 	struct ef100_nic_data *nic_data = efx->nic_data;
337 	struct efx_rep *efv, *next;
338 
339 	if (!nic_data->grp_mae)
340 		return;
341 
342 	list_for_each_entry_safe(efv, next, &efx->vf_reps, list)
343 		efx_ef100_vfrep_destroy(efx, efv);
344 }
345 
346 static bool ef100_mport_is_pcie_vnic(struct mae_mport_desc *mport_desc)
347 {
348 	return mport_desc->mport_type == MAE_MPORT_DESC_MPORT_TYPE_VNIC &&
349 	       mport_desc->vnic_client_type == MAE_MPORT_DESC_VNIC_CLIENT_TYPE_FUNCTION;
350 }
351 
352 bool ef100_mport_on_local_intf(struct efx_nic *efx,
353 			       struct mae_mport_desc *mport_desc)
354 {
355 	struct ef100_nic_data *nic_data = efx->nic_data;
356 	bool pcie_func;
357 
358 	pcie_func = ef100_mport_is_pcie_vnic(mport_desc);
359 
360 	return nic_data->have_local_intf && pcie_func &&
361 		     mport_desc->interface_idx == nic_data->local_mae_intf;
362 }
363 
364 bool ef100_mport_is_vf(struct mae_mport_desc *mport_desc)
365 {
366 	bool pcie_func;
367 
368 	pcie_func = ef100_mport_is_pcie_vnic(mport_desc);
369 	return pcie_func && (mport_desc->vf_idx != MAE_MPORT_DESC_VF_IDX_NULL);
370 }
371 
372 void efx_ef100_init_reps(struct efx_nic *efx)
373 {
374 	struct ef100_nic_data *nic_data = efx->nic_data;
375 	int rc;
376 
377 	nic_data->have_local_intf = false;
378 	rc = efx_mae_enumerate_mports(efx);
379 	if (rc)
380 		pci_warn(efx->pci_dev,
381 			 "Could not enumerate mports (rc=%d), are we admin?",
382 			 rc);
383 }
384 
385 void efx_ef100_fini_reps(struct efx_nic *efx)
386 {
387 	struct efx_mae *mae = efx->mae;
388 
389 	rhashtable_free_and_destroy(&mae->mports_ht, efx_mae_remove_mport,
390 				    NULL);
391 }
392 
393 static int efx_ef100_rep_poll(struct napi_struct *napi, int weight)
394 {
395 	struct efx_rep *efv = container_of(napi, struct efx_rep, napi);
396 	unsigned int read_index;
397 	struct list_head head;
398 	struct sk_buff *skb;
399 	bool need_resched;
400 	int spent = 0;
401 
402 	INIT_LIST_HEAD(&head);
403 	/* Grab up to 'weight' pending SKBs */
404 	spin_lock_bh(&efv->rx_lock);
405 	read_index = efv->write_index;
406 	while (spent < weight && !list_empty(&efv->rx_list)) {
407 		skb = list_first_entry(&efv->rx_list, struct sk_buff, list);
408 		list_del(&skb->list);
409 		list_add_tail(&skb->list, &head);
410 		spent++;
411 	}
412 	spin_unlock_bh(&efv->rx_lock);
413 	/* Receive them */
414 	netif_receive_skb_list(&head);
415 	if (spent < weight)
416 		if (napi_complete_done(napi, spent)) {
417 			spin_lock_bh(&efv->rx_lock);
418 			efv->read_index = read_index;
419 			/* If write_index advanced while we were doing the
420 			 * RX, then storing our read_index won't re-prime the
421 			 * fake-interrupt.  In that case, we need to schedule
422 			 * NAPI again to consume the additional packet(s).
423 			 */
424 			need_resched = efv->write_index != read_index;
425 			spin_unlock_bh(&efv->rx_lock);
426 			if (need_resched)
427 				napi_schedule(&efv->napi);
428 		}
429 	return spent;
430 }
431 
432 void efx_ef100_rep_rx_packet(struct efx_rep *efv, struct efx_rx_buffer *rx_buf)
433 {
434 	u8 *eh = efx_rx_buf_va(rx_buf);
435 	struct sk_buff *skb;
436 	bool primed;
437 
438 	/* Don't allow too many queued SKBs to build up, as they consume
439 	 * GFP_ATOMIC memory.  If we overrun, just start dropping.
440 	 */
441 	if (efv->write_index - READ_ONCE(efv->read_index) > efv->rx_pring_size) {
442 		atomic64_inc(&efv->stats.rx_dropped);
443 		if (net_ratelimit())
444 			netif_dbg(efv->parent, rx_err, efv->net_dev,
445 				  "nodesc-dropped packet of length %u\n",
446 				  rx_buf->len);
447 		return;
448 	}
449 
450 	skb = netdev_alloc_skb(efv->net_dev, rx_buf->len);
451 	if (!skb) {
452 		atomic64_inc(&efv->stats.rx_dropped);
453 		if (net_ratelimit())
454 			netif_dbg(efv->parent, rx_err, efv->net_dev,
455 				  "noskb-dropped packet of length %u\n",
456 				  rx_buf->len);
457 		return;
458 	}
459 	memcpy(skb->data, eh, rx_buf->len);
460 	__skb_put(skb, rx_buf->len);
461 
462 	skb_record_rx_queue(skb, 0); /* rep is single-queue */
463 
464 	/* Move past the ethernet header */
465 	skb->protocol = eth_type_trans(skb, efv->net_dev);
466 
467 	skb_checksum_none_assert(skb);
468 
469 	atomic64_inc(&efv->stats.rx_packets);
470 	atomic64_add(rx_buf->len, &efv->stats.rx_bytes);
471 
472 	/* Add it to the rx list */
473 	spin_lock_bh(&efv->rx_lock);
474 	primed = efv->read_index == efv->write_index;
475 	list_add_tail(&skb->list, &efv->rx_list);
476 	efv->write_index++;
477 	spin_unlock_bh(&efv->rx_lock);
478 	/* Trigger rx work */
479 	if (primed)
480 		napi_schedule(&efv->napi);
481 }
482 
483 struct efx_rep *efx_ef100_find_rep_by_mport(struct efx_nic *efx, u16 mport)
484 {
485 	struct efx_rep *efv, *out = NULL;
486 
487 	/* spinlock guards against list mutation while we're walking it;
488 	 * but caller must also hold rcu_read_lock() to ensure the netdev
489 	 * isn't freed after we drop the spinlock.
490 	 */
491 	spin_lock_bh(&efx->vf_reps_lock);
492 	list_for_each_entry(efv, &efx->vf_reps, list)
493 		if (efv->mport == mport) {
494 			out = efv;
495 			break;
496 		}
497 	spin_unlock_bh(&efx->vf_reps_lock);
498 	return out;
499 }
500