1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
3 
4 #include <linux/etherdevice.h>
5 #include <linux/io-64-nonatomic-hi-lo.h>
6 #include <linux/lockdep.h>
7 #include <net/dst_metadata.h>
8 
9 #include "nfpcore/nfp_cpp.h"
10 #include "nfpcore/nfp_nsp.h"
11 #include "nfp_app.h"
12 #include "nfp_main.h"
13 #include "nfp_net.h"
14 #include "nfp_net_ctrl.h"
15 #include "nfp_net_repr.h"
16 #include "nfp_net_sriov.h"
17 #include "nfp_port.h"
18 
19 struct net_device *
nfp_repr_get_locked(struct nfp_app * app,struct nfp_reprs * set,unsigned int id)20 nfp_repr_get_locked(struct nfp_app *app, struct nfp_reprs *set, unsigned int id)
21 {
22 	return rcu_dereference_protected(set->reprs[id],
23 					 nfp_app_is_locked(app));
24 }
25 
26 static void
nfp_repr_inc_tx_stats(struct net_device * netdev,unsigned int len,int tx_status)27 nfp_repr_inc_tx_stats(struct net_device *netdev, unsigned int len,
28 		      int tx_status)
29 {
30 	struct nfp_repr *repr = netdev_priv(netdev);
31 	struct nfp_repr_pcpu_stats *stats;
32 
33 	if (unlikely(tx_status != NET_XMIT_SUCCESS &&
34 		     tx_status != NET_XMIT_CN)) {
35 		this_cpu_inc(repr->stats->tx_drops);
36 		return;
37 	}
38 
39 	stats = this_cpu_ptr(repr->stats);
40 	u64_stats_update_begin(&stats->syncp);
41 	stats->tx_packets++;
42 	stats->tx_bytes += len;
43 	u64_stats_update_end(&stats->syncp);
44 }
45 
nfp_repr_inc_rx_stats(struct net_device * netdev,unsigned int len)46 void nfp_repr_inc_rx_stats(struct net_device *netdev, unsigned int len)
47 {
48 	struct nfp_repr *repr = netdev_priv(netdev);
49 	struct nfp_repr_pcpu_stats *stats;
50 
51 	stats = this_cpu_ptr(repr->stats);
52 	u64_stats_update_begin(&stats->syncp);
53 	stats->rx_packets++;
54 	stats->rx_bytes += len;
55 	u64_stats_update_end(&stats->syncp);
56 }
57 
58 static void
nfp_repr_phy_port_get_stats64(struct nfp_port * port,struct rtnl_link_stats64 * stats)59 nfp_repr_phy_port_get_stats64(struct nfp_port *port,
60 			      struct rtnl_link_stats64 *stats)
61 {
62 	u8 __iomem *mem = port->eth_stats;
63 
64 	stats->tx_packets = readq(mem + NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK);
65 	stats->tx_bytes = readq(mem + NFP_MAC_STATS_TX_OUT_OCTETS);
66 	stats->tx_dropped = readq(mem + NFP_MAC_STATS_TX_OUT_ERRORS);
67 
68 	stats->rx_packets = readq(mem + NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK);
69 	stats->rx_bytes = readq(mem + NFP_MAC_STATS_RX_IN_OCTETS);
70 	stats->rx_dropped = readq(mem + NFP_MAC_STATS_RX_IN_ERRORS);
71 }
72 
73 static void
nfp_repr_vnic_get_stats64(struct nfp_port * port,struct rtnl_link_stats64 * stats)74 nfp_repr_vnic_get_stats64(struct nfp_port *port,
75 			  struct rtnl_link_stats64 *stats)
76 {
77 	/* TX and RX stats are flipped as we are returning the stats as seen
78 	 * at the switch port corresponding to the VF.
79 	 */
80 	stats->tx_packets = readq(port->vnic + NFP_NET_CFG_STATS_RX_FRAMES);
81 	stats->tx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_RX_OCTETS);
82 	stats->tx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_RX_DISCARDS);
83 
84 	stats->rx_packets = readq(port->vnic + NFP_NET_CFG_STATS_TX_FRAMES);
85 	stats->rx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_TX_OCTETS);
86 	stats->rx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_TX_DISCARDS);
87 }
88 
89 static void
nfp_repr_get_stats64(struct net_device * netdev,struct rtnl_link_stats64 * stats)90 nfp_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
91 {
92 	struct nfp_repr *repr = netdev_priv(netdev);
93 
94 	if (WARN_ON(!repr->port))
95 		return;
96 
97 	switch (repr->port->type) {
98 	case NFP_PORT_PHYS_PORT:
99 		if (!__nfp_port_get_eth_port(repr->port))
100 			break;
101 		nfp_repr_phy_port_get_stats64(repr->port, stats);
102 		break;
103 	case NFP_PORT_PF_PORT:
104 	case NFP_PORT_VF_PORT:
105 		nfp_repr_vnic_get_stats64(repr->port, stats);
106 		break;
107 	default:
108 		break;
109 	}
110 }
111 
112 static bool
nfp_repr_has_offload_stats(const struct net_device * dev,int attr_id)113 nfp_repr_has_offload_stats(const struct net_device *dev, int attr_id)
114 {
115 	switch (attr_id) {
116 	case IFLA_OFFLOAD_XSTATS_CPU_HIT:
117 		return true;
118 	}
119 
120 	return false;
121 }
122 
123 static int
nfp_repr_get_host_stats64(const struct net_device * netdev,struct rtnl_link_stats64 * stats)124 nfp_repr_get_host_stats64(const struct net_device *netdev,
125 			  struct rtnl_link_stats64 *stats)
126 {
127 	struct nfp_repr *repr = netdev_priv(netdev);
128 	int i;
129 
130 	for_each_possible_cpu(i) {
131 		u64 tbytes, tpkts, tdrops, rbytes, rpkts;
132 		struct nfp_repr_pcpu_stats *repr_stats;
133 		unsigned int start;
134 
135 		repr_stats = per_cpu_ptr(repr->stats, i);
136 		do {
137 			start = u64_stats_fetch_begin_irq(&repr_stats->syncp);
138 			tbytes = repr_stats->tx_bytes;
139 			tpkts = repr_stats->tx_packets;
140 			tdrops = repr_stats->tx_drops;
141 			rbytes = repr_stats->rx_bytes;
142 			rpkts = repr_stats->rx_packets;
143 		} while (u64_stats_fetch_retry_irq(&repr_stats->syncp, start));
144 
145 		stats->tx_bytes += tbytes;
146 		stats->tx_packets += tpkts;
147 		stats->tx_dropped += tdrops;
148 		stats->rx_bytes += rbytes;
149 		stats->rx_packets += rpkts;
150 	}
151 
152 	return 0;
153 }
154 
155 static int
nfp_repr_get_offload_stats(int attr_id,const struct net_device * dev,void * stats)156 nfp_repr_get_offload_stats(int attr_id, const struct net_device *dev,
157 			   void *stats)
158 {
159 	switch (attr_id) {
160 	case IFLA_OFFLOAD_XSTATS_CPU_HIT:
161 		return nfp_repr_get_host_stats64(dev, stats);
162 	}
163 
164 	return -EINVAL;
165 }
166 
nfp_repr_change_mtu(struct net_device * netdev,int new_mtu)167 static int nfp_repr_change_mtu(struct net_device *netdev, int new_mtu)
168 {
169 	struct nfp_repr *repr = netdev_priv(netdev);
170 	int err;
171 
172 	err = nfp_app_check_mtu(repr->app, netdev, new_mtu);
173 	if (err)
174 		return err;
175 
176 	err = nfp_app_repr_change_mtu(repr->app, netdev, new_mtu);
177 	if (err)
178 		return err;
179 
180 	netdev->mtu = new_mtu;
181 
182 	return 0;
183 }
184 
nfp_repr_xmit(struct sk_buff * skb,struct net_device * netdev)185 static netdev_tx_t nfp_repr_xmit(struct sk_buff *skb, struct net_device *netdev)
186 {
187 	struct nfp_repr *repr = netdev_priv(netdev);
188 	unsigned int len = skb->len;
189 	int ret;
190 
191 	skb_dst_drop(skb);
192 	dst_hold((struct dst_entry *)repr->dst);
193 	skb_dst_set(skb, (struct dst_entry *)repr->dst);
194 	skb->dev = repr->dst->u.port_info.lower_dev;
195 
196 	ret = dev_queue_xmit(skb);
197 	nfp_repr_inc_tx_stats(netdev, len, ret);
198 
199 	return NETDEV_TX_OK;
200 }
201 
nfp_repr_stop(struct net_device * netdev)202 static int nfp_repr_stop(struct net_device *netdev)
203 {
204 	struct nfp_repr *repr = netdev_priv(netdev);
205 	int err;
206 
207 	err = nfp_app_repr_stop(repr->app, repr);
208 	if (err)
209 		return err;
210 
211 	nfp_port_configure(netdev, false);
212 	return 0;
213 }
214 
nfp_repr_open(struct net_device * netdev)215 static int nfp_repr_open(struct net_device *netdev)
216 {
217 	struct nfp_repr *repr = netdev_priv(netdev);
218 	int err;
219 
220 	err = nfp_port_configure(netdev, true);
221 	if (err)
222 		return err;
223 
224 	err = nfp_app_repr_open(repr->app, repr);
225 	if (err)
226 		goto err_port_disable;
227 
228 	return 0;
229 
230 err_port_disable:
231 	nfp_port_configure(netdev, false);
232 	return err;
233 }
234 
235 static netdev_features_t
nfp_repr_fix_features(struct net_device * netdev,netdev_features_t features)236 nfp_repr_fix_features(struct net_device *netdev, netdev_features_t features)
237 {
238 	struct nfp_repr *repr = netdev_priv(netdev);
239 	netdev_features_t old_features = features;
240 	netdev_features_t lower_features;
241 	struct net_device *lower_dev;
242 
243 	lower_dev = repr->dst->u.port_info.lower_dev;
244 
245 	lower_features = lower_dev->features;
246 	if (lower_features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM))
247 		lower_features |= NETIF_F_HW_CSUM;
248 
249 	features = netdev_intersect_features(features, lower_features);
250 	features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_HW_TC);
251 	features |= NETIF_F_LLTX;
252 
253 	return features;
254 }
255 
256 const struct net_device_ops nfp_repr_netdev_ops = {
257 	.ndo_init		= nfp_app_ndo_init,
258 	.ndo_uninit		= nfp_app_ndo_uninit,
259 	.ndo_open		= nfp_repr_open,
260 	.ndo_stop		= nfp_repr_stop,
261 	.ndo_start_xmit		= nfp_repr_xmit,
262 	.ndo_change_mtu		= nfp_repr_change_mtu,
263 	.ndo_get_stats64	= nfp_repr_get_stats64,
264 	.ndo_has_offload_stats	= nfp_repr_has_offload_stats,
265 	.ndo_get_offload_stats	= nfp_repr_get_offload_stats,
266 	.ndo_get_phys_port_name	= nfp_port_get_phys_port_name,
267 	.ndo_setup_tc		= nfp_port_setup_tc,
268 	.ndo_set_vf_mac		= nfp_app_set_vf_mac,
269 	.ndo_set_vf_vlan	= nfp_app_set_vf_vlan,
270 	.ndo_set_vf_spoofchk	= nfp_app_set_vf_spoofchk,
271 	.ndo_set_vf_trust	= nfp_app_set_vf_trust,
272 	.ndo_get_vf_config	= nfp_app_get_vf_config,
273 	.ndo_set_vf_link_state	= nfp_app_set_vf_link_state,
274 	.ndo_fix_features	= nfp_repr_fix_features,
275 	.ndo_set_features	= nfp_port_set_features,
276 	.ndo_set_mac_address    = eth_mac_addr,
277 	.ndo_get_port_parent_id	= nfp_port_get_port_parent_id,
278 	.ndo_get_devlink_port	= nfp_devlink_get_devlink_port,
279 };
280 
281 void
nfp_repr_transfer_features(struct net_device * netdev,struct net_device * lower)282 nfp_repr_transfer_features(struct net_device *netdev, struct net_device *lower)
283 {
284 	struct nfp_repr *repr = netdev_priv(netdev);
285 
286 	if (repr->dst->u.port_info.lower_dev != lower)
287 		return;
288 
289 	netif_inherit_tso_max(netdev, lower);
290 
291 	netdev_update_features(netdev);
292 }
293 
nfp_repr_clean(struct nfp_repr * repr)294 static void nfp_repr_clean(struct nfp_repr *repr)
295 {
296 	unregister_netdev(repr->netdev);
297 	nfp_app_repr_clean(repr->app, repr->netdev);
298 	dst_release((struct dst_entry *)repr->dst);
299 	nfp_port_free(repr->port);
300 }
301 
302 static struct lock_class_key nfp_repr_netdev_xmit_lock_key;
303 
nfp_repr_set_lockdep_class_one(struct net_device * dev,struct netdev_queue * txq,void * _unused)304 static void nfp_repr_set_lockdep_class_one(struct net_device *dev,
305 					   struct netdev_queue *txq,
306 					   void *_unused)
307 {
308 	lockdep_set_class(&txq->_xmit_lock, &nfp_repr_netdev_xmit_lock_key);
309 }
310 
nfp_repr_set_lockdep_class(struct net_device * dev)311 static void nfp_repr_set_lockdep_class(struct net_device *dev)
312 {
313 	netdev_for_each_tx_queue(dev, nfp_repr_set_lockdep_class_one, NULL);
314 }
315 
nfp_repr_init(struct nfp_app * app,struct net_device * netdev,u32 cmsg_port_id,struct nfp_port * port,struct net_device * pf_netdev)316 int nfp_repr_init(struct nfp_app *app, struct net_device *netdev,
317 		  u32 cmsg_port_id, struct nfp_port *port,
318 		  struct net_device *pf_netdev)
319 {
320 	struct nfp_repr *repr = netdev_priv(netdev);
321 	struct nfp_net *nn = netdev_priv(pf_netdev);
322 	u32 repr_cap = nn->tlv_caps.repr_cap;
323 	int err;
324 
325 	nfp_repr_set_lockdep_class(netdev);
326 
327 	repr->port = port;
328 	repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL);
329 	if (!repr->dst)
330 		return -ENOMEM;
331 	repr->dst->u.port_info.port_id = cmsg_port_id;
332 	repr->dst->u.port_info.lower_dev = pf_netdev;
333 
334 	netdev->netdev_ops = &nfp_repr_netdev_ops;
335 	netdev->ethtool_ops = &nfp_port_ethtool_ops;
336 
337 	netdev->max_mtu = pf_netdev->max_mtu;
338 
339 	/* Set features the lower device can support with representors */
340 	if (repr_cap & NFP_NET_CFG_CTRL_LIVE_ADDR)
341 		netdev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
342 
343 	netdev->hw_features = NETIF_F_HIGHDMA;
344 	if (repr_cap & NFP_NET_CFG_CTRL_RXCSUM_ANY)
345 		netdev->hw_features |= NETIF_F_RXCSUM;
346 	if (repr_cap & NFP_NET_CFG_CTRL_TXCSUM)
347 		netdev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
348 	if (repr_cap & NFP_NET_CFG_CTRL_GATHER)
349 		netdev->hw_features |= NETIF_F_SG;
350 	if ((repr_cap & NFP_NET_CFG_CTRL_LSO && nn->fw_ver.major > 2) ||
351 	    repr_cap & NFP_NET_CFG_CTRL_LSO2)
352 		netdev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6;
353 	if (repr_cap & NFP_NET_CFG_CTRL_RSS_ANY)
354 		netdev->hw_features |= NETIF_F_RXHASH;
355 	if (repr_cap & NFP_NET_CFG_CTRL_VXLAN) {
356 		if (repr_cap & NFP_NET_CFG_CTRL_LSO)
357 			netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
358 	}
359 	if (repr_cap & NFP_NET_CFG_CTRL_NVGRE) {
360 		if (repr_cap & NFP_NET_CFG_CTRL_LSO)
361 			netdev->hw_features |= NETIF_F_GSO_GRE;
362 	}
363 	if (repr_cap & (NFP_NET_CFG_CTRL_VXLAN | NFP_NET_CFG_CTRL_NVGRE))
364 		netdev->hw_enc_features = netdev->hw_features;
365 
366 	netdev->vlan_features = netdev->hw_features;
367 
368 	if (repr_cap & NFP_NET_CFG_CTRL_RXVLAN_ANY)
369 		netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX;
370 	if (repr_cap & NFP_NET_CFG_CTRL_TXVLAN_ANY) {
371 		if (repr_cap & NFP_NET_CFG_CTRL_LSO2)
372 			netdev_warn(netdev, "Device advertises both TSO2 and TXVLAN. Refusing to enable TXVLAN.\n");
373 		else
374 			netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX;
375 	}
376 	if (repr_cap & NFP_NET_CFG_CTRL_CTAG_FILTER)
377 		netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
378 	if (repr_cap & NFP_NET_CFG_CTRL_RXQINQ)
379 		netdev->hw_features |= NETIF_F_HW_VLAN_STAG_RX;
380 
381 	netdev->features = netdev->hw_features;
382 
383 	/* C-Tag strip and S-Tag strip can't be supported simultaneously,
384 	 * so enable C-Tag strip and disable S-Tag strip by default.
385 	 */
386 	netdev->features &= ~NETIF_F_HW_VLAN_STAG_RX;
387 	netif_set_tso_max_segs(netdev, NFP_NET_LSO_MAX_SEGS);
388 
389 	netdev->priv_flags |= IFF_NO_QUEUE | IFF_DISABLE_NETPOLL;
390 	netdev->features |= NETIF_F_LLTX;
391 
392 	if (nfp_app_has_tc(app)) {
393 		netdev->features |= NETIF_F_HW_TC;
394 		netdev->hw_features |= NETIF_F_HW_TC;
395 	}
396 
397 	err = nfp_app_repr_init(app, netdev);
398 	if (err)
399 		goto err_clean;
400 
401 	err = register_netdev(netdev);
402 	if (err)
403 		goto err_repr_clean;
404 
405 	return 0;
406 
407 err_repr_clean:
408 	nfp_app_repr_clean(app, netdev);
409 err_clean:
410 	dst_release((struct dst_entry *)repr->dst);
411 	return err;
412 }
413 
__nfp_repr_free(struct nfp_repr * repr)414 static void __nfp_repr_free(struct nfp_repr *repr)
415 {
416 	free_percpu(repr->stats);
417 	free_netdev(repr->netdev);
418 }
419 
nfp_repr_free(struct net_device * netdev)420 void nfp_repr_free(struct net_device *netdev)
421 {
422 	__nfp_repr_free(netdev_priv(netdev));
423 }
424 
425 struct net_device *
nfp_repr_alloc_mqs(struct nfp_app * app,unsigned int txqs,unsigned int rxqs)426 nfp_repr_alloc_mqs(struct nfp_app *app, unsigned int txqs, unsigned int rxqs)
427 {
428 	struct net_device *netdev;
429 	struct nfp_repr *repr;
430 
431 	netdev = alloc_etherdev_mqs(sizeof(*repr), txqs, rxqs);
432 	if (!netdev)
433 		return NULL;
434 
435 	netif_carrier_off(netdev);
436 
437 	repr = netdev_priv(netdev);
438 	repr->netdev = netdev;
439 	repr->app = app;
440 
441 	repr->stats = netdev_alloc_pcpu_stats(struct nfp_repr_pcpu_stats);
442 	if (!repr->stats)
443 		goto err_free_netdev;
444 
445 	return netdev;
446 
447 err_free_netdev:
448 	free_netdev(netdev);
449 	return NULL;
450 }
451 
nfp_repr_clean_and_free(struct nfp_repr * repr)452 void nfp_repr_clean_and_free(struct nfp_repr *repr)
453 {
454 	nfp_info(repr->app->cpp, "Destroying Representor(%s)\n",
455 		 repr->netdev->name);
456 	nfp_repr_clean(repr);
457 	__nfp_repr_free(repr);
458 }
459 
nfp_reprs_clean_and_free(struct nfp_app * app,struct nfp_reprs * reprs)460 void nfp_reprs_clean_and_free(struct nfp_app *app, struct nfp_reprs *reprs)
461 {
462 	struct net_device *netdev;
463 	unsigned int i;
464 
465 	for (i = 0; i < reprs->num_reprs; i++) {
466 		netdev = nfp_repr_get_locked(app, reprs, i);
467 		if (netdev)
468 			nfp_repr_clean_and_free(netdev_priv(netdev));
469 	}
470 
471 	kfree(reprs);
472 }
473 
474 void
nfp_reprs_clean_and_free_by_type(struct nfp_app * app,enum nfp_repr_type type)475 nfp_reprs_clean_and_free_by_type(struct nfp_app *app, enum nfp_repr_type type)
476 {
477 	struct net_device *netdev;
478 	struct nfp_reprs *reprs;
479 	int i;
480 
481 	reprs = rcu_dereference_protected(app->reprs[type],
482 					  nfp_app_is_locked(app));
483 	if (!reprs)
484 		return;
485 
486 	/* Preclean must happen before we remove the reprs reference from the
487 	 * app below.
488 	 */
489 	for (i = 0; i < reprs->num_reprs; i++) {
490 		netdev = nfp_repr_get_locked(app, reprs, i);
491 		if (netdev)
492 			nfp_app_repr_preclean(app, netdev);
493 	}
494 
495 	reprs = nfp_app_reprs_set(app, type, NULL);
496 
497 	synchronize_rcu();
498 	nfp_reprs_clean_and_free(app, reprs);
499 }
500 
nfp_reprs_alloc(unsigned int num_reprs)501 struct nfp_reprs *nfp_reprs_alloc(unsigned int num_reprs)
502 {
503 	struct nfp_reprs *reprs;
504 
505 	reprs = kzalloc(struct_size(reprs, reprs, num_reprs), GFP_KERNEL);
506 	if (!reprs)
507 		return NULL;
508 	reprs->num_reprs = num_reprs;
509 
510 	return reprs;
511 }
512 
nfp_reprs_resync_phys_ports(struct nfp_app * app)513 int nfp_reprs_resync_phys_ports(struct nfp_app *app)
514 {
515 	struct net_device *netdev;
516 	struct nfp_reprs *reprs;
517 	struct nfp_repr *repr;
518 	int i;
519 
520 	reprs = nfp_reprs_get_locked(app, NFP_REPR_TYPE_PHYS_PORT);
521 	if (!reprs)
522 		return 0;
523 
524 	for (i = 0; i < reprs->num_reprs; i++) {
525 		netdev = nfp_repr_get_locked(app, reprs, i);
526 		if (!netdev)
527 			continue;
528 
529 		repr = netdev_priv(netdev);
530 		if (repr->port->type != NFP_PORT_INVALID)
531 			continue;
532 
533 		nfp_app_repr_preclean(app, netdev);
534 		rtnl_lock();
535 		rcu_assign_pointer(reprs->reprs[i], NULL);
536 		rtnl_unlock();
537 		synchronize_rcu();
538 		nfp_repr_clean(repr);
539 	}
540 
541 	return 0;
542 }
543