1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Atlantic Network Driver
3  *
4  * Copyright (C) 2014-2019 aQuantia Corporation
5  * Copyright (C) 2019-2020 Marvell International Ltd.
6  */
7 
8 /* File aq_main.c: Main file for aQuantia Linux driver. */
9 
10 #include "aq_main.h"
11 #include "aq_nic.h"
12 #include "aq_pci_func.h"
13 #include "aq_ethtool.h"
14 #include "aq_ptp.h"
15 #include "aq_filters.h"
16 #include "aq_hw_utils.h"
17 
18 #include <linux/netdevice.h>
19 #include <linux/module.h>
20 #include <linux/ip.h>
21 #include <linux/udp.h>
22 #include <net/pkt_cls.h>
23 
24 MODULE_LICENSE("GPL v2");
25 MODULE_AUTHOR(AQ_CFG_DRV_AUTHOR);
26 MODULE_DESCRIPTION(AQ_CFG_DRV_DESC);
27 
28 static const char aq_ndev_driver_name[] = AQ_CFG_DRV_NAME;
29 
30 static const struct net_device_ops aq_ndev_ops;
31 
32 static struct workqueue_struct *aq_ndev_wq;
33 
aq_ndev_schedule_work(struct work_struct * work)34 void aq_ndev_schedule_work(struct work_struct *work)
35 {
36 	queue_work(aq_ndev_wq, work);
37 }
38 
aq_ndev_alloc(void)39 struct net_device *aq_ndev_alloc(void)
40 {
41 	struct net_device *ndev = NULL;
42 	struct aq_nic_s *aq_nic = NULL;
43 
44 	ndev = alloc_etherdev_mq(sizeof(struct aq_nic_s), AQ_HW_QUEUES_MAX);
45 	if (!ndev)
46 		return NULL;
47 
48 	aq_nic = netdev_priv(ndev);
49 	aq_nic->ndev = ndev;
50 	ndev->netdev_ops = &aq_ndev_ops;
51 	ndev->ethtool_ops = &aq_ethtool_ops;
52 
53 	return ndev;
54 }
55 
aq_ndev_open(struct net_device * ndev)56 static int aq_ndev_open(struct net_device *ndev)
57 {
58 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
59 	int err = 0;
60 
61 	err = aq_nic_init(aq_nic);
62 	if (err < 0)
63 		goto err_exit;
64 
65 	err = aq_reapply_rxnfc_all_rules(aq_nic);
66 	if (err < 0)
67 		goto err_exit;
68 
69 	err = aq_filters_vlans_update(aq_nic);
70 	if (err < 0)
71 		goto err_exit;
72 
73 	err = aq_nic_start(aq_nic);
74 	if (err < 0) {
75 		aq_nic_stop(aq_nic);
76 		goto err_exit;
77 	}
78 
79 err_exit:
80 	if (err < 0)
81 		aq_nic_deinit(aq_nic, true);
82 
83 	return err;
84 }
85 
aq_ndev_close(struct net_device * ndev)86 static int aq_ndev_close(struct net_device *ndev)
87 {
88 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
89 	int err = 0;
90 
91 	err = aq_nic_stop(aq_nic);
92 	if (err < 0)
93 		goto err_exit;
94 	aq_nic_deinit(aq_nic, true);
95 
96 err_exit:
97 	return err;
98 }
99 
aq_ndev_start_xmit(struct sk_buff * skb,struct net_device * ndev)100 static netdev_tx_t aq_ndev_start_xmit(struct sk_buff *skb, struct net_device *ndev)
101 {
102 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
103 
104 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
105 	if (unlikely(aq_utils_obj_test(&aq_nic->flags, AQ_NIC_PTP_DPATH_UP))) {
106 		/* Hardware adds the Timestamp for PTPv2 802.AS1
107 		 * and PTPv2 IPv4 UDP.
108 		 * We have to push even general 320 port messages to the ptp
109 		 * queue explicitly. This is a limitation of current firmware
110 		 * and hardware PTP design of the chip. Otherwise ptp stream
111 		 * will fail to sync
112 		 */
113 		if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) ||
114 		    unlikely((ip_hdr(skb)->version == 4) &&
115 			     (ip_hdr(skb)->protocol == IPPROTO_UDP) &&
116 			     ((udp_hdr(skb)->dest == htons(319)) ||
117 			      (udp_hdr(skb)->dest == htons(320)))) ||
118 		    unlikely(eth_hdr(skb)->h_proto == htons(ETH_P_1588)))
119 			return aq_ptp_xmit(aq_nic, skb);
120 	}
121 #endif
122 
123 	skb_tx_timestamp(skb);
124 	return aq_nic_xmit(aq_nic, skb);
125 }
126 
aq_ndev_change_mtu(struct net_device * ndev,int new_mtu)127 static int aq_ndev_change_mtu(struct net_device *ndev, int new_mtu)
128 {
129 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
130 	int err;
131 
132 	err = aq_nic_set_mtu(aq_nic, new_mtu + ETH_HLEN);
133 
134 	if (err < 0)
135 		goto err_exit;
136 	ndev->mtu = new_mtu;
137 
138 err_exit:
139 	return err;
140 }
141 
aq_ndev_set_features(struct net_device * ndev,netdev_features_t features)142 static int aq_ndev_set_features(struct net_device *ndev,
143 				netdev_features_t features)
144 {
145 	bool is_vlan_tx_insert = !!(features & NETIF_F_HW_VLAN_CTAG_TX);
146 	bool is_vlan_rx_strip = !!(features & NETIF_F_HW_VLAN_CTAG_RX);
147 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
148 	bool need_ndev_restart = false;
149 	struct aq_nic_cfg_s *aq_cfg;
150 	bool is_lro = false;
151 	int err = 0;
152 
153 	aq_cfg = aq_nic_get_cfg(aq_nic);
154 
155 	if (!(features & NETIF_F_NTUPLE)) {
156 		if (aq_nic->ndev->features & NETIF_F_NTUPLE) {
157 			err = aq_clear_rxnfc_all_rules(aq_nic);
158 			if (unlikely(err))
159 				goto err_exit;
160 		}
161 	}
162 	if (!(features & NETIF_F_HW_VLAN_CTAG_FILTER)) {
163 		if (aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) {
164 			err = aq_filters_vlan_offload_off(aq_nic);
165 			if (unlikely(err))
166 				goto err_exit;
167 		}
168 	}
169 
170 	aq_cfg->features = features;
171 
172 	if (aq_cfg->aq_hw_caps->hw_features & NETIF_F_LRO) {
173 		is_lro = features & NETIF_F_LRO;
174 
175 		if (aq_cfg->is_lro != is_lro) {
176 			aq_cfg->is_lro = is_lro;
177 			need_ndev_restart = true;
178 		}
179 	}
180 
181 	if ((aq_nic->ndev->features ^ features) & NETIF_F_RXCSUM) {
182 		err = aq_nic->aq_hw_ops->hw_set_offload(aq_nic->aq_hw,
183 							aq_cfg);
184 
185 		if (unlikely(err))
186 			goto err_exit;
187 	}
188 
189 	if (aq_cfg->is_vlan_rx_strip != is_vlan_rx_strip) {
190 		aq_cfg->is_vlan_rx_strip = is_vlan_rx_strip;
191 		need_ndev_restart = true;
192 	}
193 	if (aq_cfg->is_vlan_tx_insert != is_vlan_tx_insert) {
194 		aq_cfg->is_vlan_tx_insert = is_vlan_tx_insert;
195 		need_ndev_restart = true;
196 	}
197 
198 	if (need_ndev_restart && netif_running(ndev)) {
199 		aq_ndev_close(ndev);
200 		aq_ndev_open(ndev);
201 	}
202 
203 err_exit:
204 	return err;
205 }
206 
aq_ndev_set_mac_address(struct net_device * ndev,void * addr)207 static int aq_ndev_set_mac_address(struct net_device *ndev, void *addr)
208 {
209 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
210 	int err = 0;
211 
212 	err = eth_mac_addr(ndev, addr);
213 	if (err < 0)
214 		goto err_exit;
215 	err = aq_nic_set_mac(aq_nic, ndev);
216 	if (err < 0)
217 		goto err_exit;
218 
219 err_exit:
220 	return err;
221 }
222 
aq_ndev_set_multicast_settings(struct net_device * ndev)223 static void aq_ndev_set_multicast_settings(struct net_device *ndev)
224 {
225 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
226 
227 	(void)aq_nic_set_multicast_list(aq_nic, ndev);
228 }
229 
230 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
aq_ndev_config_hwtstamp(struct aq_nic_s * aq_nic,struct hwtstamp_config * config)231 static int aq_ndev_config_hwtstamp(struct aq_nic_s *aq_nic,
232 				   struct hwtstamp_config *config)
233 {
234 	if (config->flags)
235 		return -EINVAL;
236 
237 	switch (config->tx_type) {
238 	case HWTSTAMP_TX_OFF:
239 	case HWTSTAMP_TX_ON:
240 		break;
241 	default:
242 		return -ERANGE;
243 	}
244 
245 	switch (config->rx_filter) {
246 	case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
247 	case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
248 	case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
249 	case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
250 	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
251 	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
252 	case HWTSTAMP_FILTER_PTP_V2_SYNC:
253 	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
254 		config->rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
255 		break;
256 	case HWTSTAMP_FILTER_PTP_V2_EVENT:
257 	case HWTSTAMP_FILTER_NONE:
258 		break;
259 	default:
260 		return -ERANGE;
261 	}
262 
263 	return aq_ptp_hwtstamp_config_set(aq_nic->aq_ptp, config);
264 }
265 #endif
266 
aq_ndev_hwtstamp_set(struct aq_nic_s * aq_nic,struct ifreq * ifr)267 static int aq_ndev_hwtstamp_set(struct aq_nic_s *aq_nic, struct ifreq *ifr)
268 {
269 	struct hwtstamp_config config;
270 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
271 	int ret_val;
272 #endif
273 
274 	if (!aq_nic->aq_ptp)
275 		return -EOPNOTSUPP;
276 
277 	if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
278 		return -EFAULT;
279 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
280 	ret_val = aq_ndev_config_hwtstamp(aq_nic, &config);
281 	if (ret_val)
282 		return ret_val;
283 #endif
284 
285 	return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
286 	       -EFAULT : 0;
287 }
288 
289 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
aq_ndev_hwtstamp_get(struct aq_nic_s * aq_nic,struct ifreq * ifr)290 static int aq_ndev_hwtstamp_get(struct aq_nic_s *aq_nic, struct ifreq *ifr)
291 {
292 	struct hwtstamp_config config;
293 
294 	if (!aq_nic->aq_ptp)
295 		return -EOPNOTSUPP;
296 
297 	aq_ptp_hwtstamp_config_get(aq_nic->aq_ptp, &config);
298 	return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
299 	       -EFAULT : 0;
300 }
301 #endif
302 
aq_ndev_ioctl(struct net_device * netdev,struct ifreq * ifr,int cmd)303 static int aq_ndev_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
304 {
305 	struct aq_nic_s *aq_nic = netdev_priv(netdev);
306 
307 	switch (cmd) {
308 	case SIOCSHWTSTAMP:
309 		return aq_ndev_hwtstamp_set(aq_nic, ifr);
310 
311 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
312 	case SIOCGHWTSTAMP:
313 		return aq_ndev_hwtstamp_get(aq_nic, ifr);
314 #endif
315 	}
316 
317 	return -EOPNOTSUPP;
318 }
319 
aq_ndo_vlan_rx_add_vid(struct net_device * ndev,__be16 proto,u16 vid)320 static int aq_ndo_vlan_rx_add_vid(struct net_device *ndev, __be16 proto,
321 				  u16 vid)
322 {
323 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
324 
325 	if (!aq_nic->aq_hw_ops->hw_filter_vlan_set)
326 		return -EOPNOTSUPP;
327 
328 	set_bit(vid, aq_nic->active_vlans);
329 
330 	return aq_filters_vlans_update(aq_nic);
331 }
332 
aq_ndo_vlan_rx_kill_vid(struct net_device * ndev,__be16 proto,u16 vid)333 static int aq_ndo_vlan_rx_kill_vid(struct net_device *ndev, __be16 proto,
334 				   u16 vid)
335 {
336 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
337 
338 	if (!aq_nic->aq_hw_ops->hw_filter_vlan_set)
339 		return -EOPNOTSUPP;
340 
341 	clear_bit(vid, aq_nic->active_vlans);
342 
343 	if (-ENOENT == aq_del_fvlan_by_vlan(aq_nic, vid))
344 		return aq_filters_vlans_update(aq_nic);
345 
346 	return 0;
347 }
348 
aq_validate_mqprio_opt(struct aq_nic_s * self,struct tc_mqprio_qopt_offload * mqprio,const unsigned int num_tc)349 static int aq_validate_mqprio_opt(struct aq_nic_s *self,
350 				  struct tc_mqprio_qopt_offload *mqprio,
351 				  const unsigned int num_tc)
352 {
353 	const bool has_min_rate = !!(mqprio->flags & TC_MQPRIO_F_MIN_RATE);
354 	struct aq_nic_cfg_s *aq_nic_cfg = aq_nic_get_cfg(self);
355 	const unsigned int tcs_max = min_t(u8, aq_nic_cfg->aq_hw_caps->tcs_max,
356 					   AQ_CFG_TCS_MAX);
357 
358 	if (num_tc > tcs_max) {
359 		netdev_err(self->ndev, "Too many TCs requested\n");
360 		return -EOPNOTSUPP;
361 	}
362 
363 	if (num_tc != 0 && !is_power_of_2(num_tc)) {
364 		netdev_err(self->ndev, "TC count should be power of 2\n");
365 		return -EOPNOTSUPP;
366 	}
367 
368 	if (has_min_rate && !ATL_HW_IS_CHIP_FEATURE(self->aq_hw, ANTIGUA)) {
369 		netdev_err(self->ndev, "Min tx rate is not supported\n");
370 		return -EOPNOTSUPP;
371 	}
372 
373 	return 0;
374 }
375 
aq_ndo_setup_tc(struct net_device * dev,enum tc_setup_type type,void * type_data)376 static int aq_ndo_setup_tc(struct net_device *dev, enum tc_setup_type type,
377 			   void *type_data)
378 {
379 	struct tc_mqprio_qopt_offload *mqprio = type_data;
380 	struct aq_nic_s *aq_nic = netdev_priv(dev);
381 	bool has_min_rate;
382 	bool has_max_rate;
383 	int err;
384 	int i;
385 
386 	if (type != TC_SETUP_QDISC_MQPRIO)
387 		return -EOPNOTSUPP;
388 
389 	has_min_rate = !!(mqprio->flags & TC_MQPRIO_F_MIN_RATE);
390 	has_max_rate = !!(mqprio->flags & TC_MQPRIO_F_MAX_RATE);
391 
392 	err = aq_validate_mqprio_opt(aq_nic, mqprio, mqprio->qopt.num_tc);
393 	if (err)
394 		return err;
395 
396 	for (i = 0; i < mqprio->qopt.num_tc; i++) {
397 		if (has_max_rate) {
398 			u64 max_rate = mqprio->max_rate[i];
399 
400 			do_div(max_rate, AQ_MBPS_DIVISOR);
401 			aq_nic_setup_tc_max_rate(aq_nic, i, (u32)max_rate);
402 		}
403 
404 		if (has_min_rate) {
405 			u64 min_rate = mqprio->min_rate[i];
406 
407 			do_div(min_rate, AQ_MBPS_DIVISOR);
408 			aq_nic_setup_tc_min_rate(aq_nic, i, (u32)min_rate);
409 		}
410 	}
411 
412 	return aq_nic_setup_tc_mqprio(aq_nic, mqprio->qopt.num_tc,
413 				      mqprio->qopt.prio_tc_map);
414 }
415 
416 static const struct net_device_ops aq_ndev_ops = {
417 	.ndo_open = aq_ndev_open,
418 	.ndo_stop = aq_ndev_close,
419 	.ndo_start_xmit = aq_ndev_start_xmit,
420 	.ndo_set_rx_mode = aq_ndev_set_multicast_settings,
421 	.ndo_change_mtu = aq_ndev_change_mtu,
422 	.ndo_set_mac_address = aq_ndev_set_mac_address,
423 	.ndo_set_features = aq_ndev_set_features,
424 	.ndo_eth_ioctl = aq_ndev_ioctl,
425 	.ndo_vlan_rx_add_vid = aq_ndo_vlan_rx_add_vid,
426 	.ndo_vlan_rx_kill_vid = aq_ndo_vlan_rx_kill_vid,
427 	.ndo_setup_tc = aq_ndo_setup_tc,
428 };
429 
aq_ndev_init_module(void)430 static int __init aq_ndev_init_module(void)
431 {
432 	int ret;
433 
434 	aq_ndev_wq = create_singlethread_workqueue(aq_ndev_driver_name);
435 	if (!aq_ndev_wq) {
436 		pr_err("Failed to create workqueue\n");
437 		return -ENOMEM;
438 	}
439 
440 	ret = aq_pci_func_register_driver();
441 	if (ret) {
442 		destroy_workqueue(aq_ndev_wq);
443 		return ret;
444 	}
445 
446 	return 0;
447 }
448 
aq_ndev_exit_module(void)449 static void __exit aq_ndev_exit_module(void)
450 {
451 	aq_pci_func_unregister_driver();
452 
453 	if (aq_ndev_wq) {
454 		destroy_workqueue(aq_ndev_wq);
455 		aq_ndev_wq = NULL;
456 	}
457 }
458 
459 module_init(aq_ndev_init_module);
460 module_exit(aq_ndev_exit_module);
461