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_ethtool.c: Definition of ethertool related functions. */
9 
10 #include "aq_ethtool.h"
11 #include "aq_nic.h"
12 #include "aq_vec.h"
13 #include "aq_ptp.h"
14 #include "aq_filters.h"
15 #include "aq_macsec.h"
16 
17 #include <linux/ptp_clock_kernel.h>
18 
19 static void aq_ethtool_get_regs(struct net_device *ndev,
20 				struct ethtool_regs *regs, void *p)
21 {
22 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
23 	u32 regs_count;
24 
25 	regs_count = aq_nic_get_regs_count(aq_nic);
26 
27 	memset(p, 0, regs_count * sizeof(u32));
28 	aq_nic_get_regs(aq_nic, regs, p);
29 }
30 
31 static int aq_ethtool_get_regs_len(struct net_device *ndev)
32 {
33 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
34 	u32 regs_count;
35 
36 	regs_count = aq_nic_get_regs_count(aq_nic);
37 
38 	return regs_count * sizeof(u32);
39 }
40 
41 static u32 aq_ethtool_get_link(struct net_device *ndev)
42 {
43 	return ethtool_op_get_link(ndev);
44 }
45 
46 static int aq_ethtool_get_link_ksettings(struct net_device *ndev,
47 					 struct ethtool_link_ksettings *cmd)
48 {
49 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
50 
51 	aq_nic_get_link_ksettings(aq_nic, cmd);
52 	cmd->base.speed = netif_carrier_ok(ndev) ?
53 				aq_nic_get_link_speed(aq_nic) : 0U;
54 
55 	return 0;
56 }
57 
58 static int
59 aq_ethtool_set_link_ksettings(struct net_device *ndev,
60 			      const struct ethtool_link_ksettings *cmd)
61 {
62 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
63 
64 	return aq_nic_set_link_ksettings(aq_nic, cmd);
65 }
66 
67 static const char aq_ethtool_stat_names[][ETH_GSTRING_LEN] = {
68 	"InPackets",
69 	"InUCast",
70 	"InMCast",
71 	"InBCast",
72 	"InErrors",
73 	"OutPackets",
74 	"OutUCast",
75 	"OutMCast",
76 	"OutBCast",
77 	"InUCastOctets",
78 	"OutUCastOctets",
79 	"InMCastOctets",
80 	"OutMCastOctets",
81 	"InBCastOctets",
82 	"OutBCastOctets",
83 	"InOctets",
84 	"OutOctets",
85 	"InPacketsDma",
86 	"OutPacketsDma",
87 	"InOctetsDma",
88 	"OutOctetsDma",
89 	"InDroppedDma",
90 };
91 
92 static const char * const aq_ethtool_queue_rx_stat_names[] = {
93 	"%sQueue[%d] InPackets",
94 	"%sQueue[%d] InJumboPackets",
95 	"%sQueue[%d] InLroPackets",
96 	"%sQueue[%d] InErrors",
97 	"%sQueue[%d] AllocFails",
98 	"%sQueue[%d] SkbAllocFails",
99 	"%sQueue[%d] Polls",
100 	"%sQueue[%d] PageFlips",
101 	"%sQueue[%d] PageReuses",
102 	"%sQueue[%d] PageFrees",
103 	"%sQueue[%d] XdpAbort",
104 	"%sQueue[%d] XdpDrop",
105 	"%sQueue[%d] XdpPass",
106 	"%sQueue[%d] XdpTx",
107 	"%sQueue[%d] XdpInvalid",
108 	"%sQueue[%d] XdpRedirect",
109 };
110 
111 static const char * const aq_ethtool_queue_tx_stat_names[] = {
112 	"%sQueue[%d] OutPackets",
113 	"%sQueue[%d] Restarts",
114 };
115 
116 #if IS_ENABLED(CONFIG_MACSEC)
117 static const char aq_macsec_stat_names[][ETH_GSTRING_LEN] = {
118 	"MACSec InCtlPackets",
119 	"MACSec InTaggedMissPackets",
120 	"MACSec InUntaggedMissPackets",
121 	"MACSec InNotagPackets",
122 	"MACSec InUntaggedPackets",
123 	"MACSec InBadTagPackets",
124 	"MACSec InNoSciPackets",
125 	"MACSec InUnknownSciPackets",
126 	"MACSec InCtrlPortPassPackets",
127 	"MACSec InUnctrlPortPassPackets",
128 	"MACSec InCtrlPortFailPackets",
129 	"MACSec InUnctrlPortFailPackets",
130 	"MACSec InTooLongPackets",
131 	"MACSec InIgpocCtlPackets",
132 	"MACSec InEccErrorPackets",
133 	"MACSec InUnctrlHitDropRedir",
134 	"MACSec OutCtlPackets",
135 	"MACSec OutUnknownSaPackets",
136 	"MACSec OutUntaggedPackets",
137 	"MACSec OutTooLong",
138 	"MACSec OutEccErrorPackets",
139 	"MACSec OutUnctrlHitDropRedir",
140 };
141 
142 static const char * const aq_macsec_txsc_stat_names[] = {
143 	"MACSecTXSC%d ProtectedPkts",
144 	"MACSecTXSC%d EncryptedPkts",
145 	"MACSecTXSC%d ProtectedOctets",
146 	"MACSecTXSC%d EncryptedOctets",
147 };
148 
149 static const char * const aq_macsec_txsa_stat_names[] = {
150 	"MACSecTXSC%dSA%d HitDropRedirect",
151 	"MACSecTXSC%dSA%d Protected2Pkts",
152 	"MACSecTXSC%dSA%d ProtectedPkts",
153 	"MACSecTXSC%dSA%d EncryptedPkts",
154 };
155 
156 static const char * const aq_macsec_rxsa_stat_names[] = {
157 	"MACSecRXSC%dSA%d UntaggedHitPkts",
158 	"MACSecRXSC%dSA%d CtrlHitDrpRedir",
159 	"MACSecRXSC%dSA%d NotUsingSa",
160 	"MACSecRXSC%dSA%d UnusedSa",
161 	"MACSecRXSC%dSA%d NotValidPkts",
162 	"MACSecRXSC%dSA%d InvalidPkts",
163 	"MACSecRXSC%dSA%d OkPkts",
164 	"MACSecRXSC%dSA%d LatePkts",
165 	"MACSecRXSC%dSA%d DelayedPkts",
166 	"MACSecRXSC%dSA%d UncheckedPkts",
167 	"MACSecRXSC%dSA%d ValidatedOctets",
168 	"MACSecRXSC%dSA%d DecryptedOctets",
169 };
170 #endif
171 
172 static const char aq_ethtool_priv_flag_names[][ETH_GSTRING_LEN] = {
173 	"DMASystemLoopback",
174 	"PKTSystemLoopback",
175 	"DMANetworkLoopback",
176 	"PHYInternalLoopback",
177 	"PHYExternalLoopback",
178 };
179 
180 static u32 aq_ethtool_n_stats(struct net_device *ndev)
181 {
182 	const int rx_stat_cnt = ARRAY_SIZE(aq_ethtool_queue_rx_stat_names);
183 	const int tx_stat_cnt = ARRAY_SIZE(aq_ethtool_queue_tx_stat_names);
184 	struct aq_nic_s *nic = netdev_priv(ndev);
185 	struct aq_nic_cfg_s *cfg = aq_nic_get_cfg(nic);
186 	u32 n_stats = ARRAY_SIZE(aq_ethtool_stat_names) +
187 		      (rx_stat_cnt + tx_stat_cnt) * cfg->vecs * cfg->tcs;
188 
189 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
190 	n_stats += rx_stat_cnt * aq_ptp_get_ring_cnt(nic, ATL_RING_RX) +
191 		   tx_stat_cnt * aq_ptp_get_ring_cnt(nic, ATL_RING_TX);
192 #endif
193 
194 #if IS_ENABLED(CONFIG_MACSEC)
195 	if (nic->macsec_cfg) {
196 		n_stats += ARRAY_SIZE(aq_macsec_stat_names) +
197 			   ARRAY_SIZE(aq_macsec_txsc_stat_names) *
198 				   aq_macsec_tx_sc_cnt(nic) +
199 			   ARRAY_SIZE(aq_macsec_txsa_stat_names) *
200 				   aq_macsec_tx_sa_cnt(nic) +
201 			   ARRAY_SIZE(aq_macsec_rxsa_stat_names) *
202 				   aq_macsec_rx_sa_cnt(nic);
203 	}
204 #endif
205 
206 	return n_stats;
207 }
208 
209 static void aq_ethtool_stats(struct net_device *ndev,
210 			     struct ethtool_stats *stats, u64 *data)
211 {
212 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
213 
214 	memset(data, 0, aq_ethtool_n_stats(ndev) * sizeof(u64));
215 	data = aq_nic_get_stats(aq_nic, data);
216 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
217 	data = aq_ptp_get_stats(aq_nic, data);
218 #endif
219 #if IS_ENABLED(CONFIG_MACSEC)
220 	data = aq_macsec_get_stats(aq_nic, data);
221 #endif
222 }
223 
224 static void aq_ethtool_get_drvinfo(struct net_device *ndev,
225 				   struct ethtool_drvinfo *drvinfo)
226 {
227 	struct pci_dev *pdev = to_pci_dev(ndev->dev.parent);
228 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
229 	u32 firmware_version;
230 	u32 regs_count;
231 
232 	firmware_version = aq_nic_get_fw_version(aq_nic);
233 	regs_count = aq_nic_get_regs_count(aq_nic);
234 
235 	strlcat(drvinfo->driver, AQ_CFG_DRV_NAME, sizeof(drvinfo->driver));
236 
237 	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
238 		 "%u.%u.%u", firmware_version >> 24,
239 		 (firmware_version >> 16) & 0xFFU, firmware_version & 0xFFFFU);
240 
241 	strlcpy(drvinfo->bus_info, pdev ? pci_name(pdev) : "",
242 		sizeof(drvinfo->bus_info));
243 	drvinfo->n_stats = aq_ethtool_n_stats(ndev);
244 	drvinfo->testinfo_len = 0;
245 	drvinfo->regdump_len = regs_count;
246 	drvinfo->eedump_len = 0;
247 }
248 
249 static void aq_ethtool_get_strings(struct net_device *ndev,
250 				   u32 stringset, u8 *data)
251 {
252 	struct aq_nic_s *nic = netdev_priv(ndev);
253 	struct aq_nic_cfg_s *cfg;
254 	u8 *p = data;
255 	int i, si;
256 #if IS_ENABLED(CONFIG_MACSEC)
257 	int sa;
258 #endif
259 
260 	cfg = aq_nic_get_cfg(nic);
261 
262 	switch (stringset) {
263 	case ETH_SS_STATS: {
264 		const int rx_stat_cnt = ARRAY_SIZE(aq_ethtool_queue_rx_stat_names);
265 		const int tx_stat_cnt = ARRAY_SIZE(aq_ethtool_queue_tx_stat_names);
266 		char tc_string[8];
267 		int tc;
268 
269 		memset(tc_string, 0, sizeof(tc_string));
270 		memcpy(p, aq_ethtool_stat_names,
271 		       sizeof(aq_ethtool_stat_names));
272 		p = p + sizeof(aq_ethtool_stat_names);
273 
274 		for (tc = 0; tc < cfg->tcs; tc++) {
275 			if (cfg->is_qos)
276 				snprintf(tc_string, 8, "TC%d ", tc);
277 
278 			for (i = 0; i < cfg->vecs; i++) {
279 				for (si = 0; si < rx_stat_cnt; si++) {
280 					snprintf(p, ETH_GSTRING_LEN,
281 					     aq_ethtool_queue_rx_stat_names[si],
282 					     tc_string,
283 					     AQ_NIC_CFG_TCVEC2RING(cfg, tc, i));
284 					p += ETH_GSTRING_LEN;
285 				}
286 				for (si = 0; si < tx_stat_cnt; si++) {
287 					snprintf(p, ETH_GSTRING_LEN,
288 					     aq_ethtool_queue_tx_stat_names[si],
289 					     tc_string,
290 					     AQ_NIC_CFG_TCVEC2RING(cfg, tc, i));
291 					p += ETH_GSTRING_LEN;
292 				}
293 			}
294 		}
295 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
296 		if (nic->aq_ptp) {
297 			const int rx_ring_cnt = aq_ptp_get_ring_cnt(nic, ATL_RING_RX);
298 			const int tx_ring_cnt = aq_ptp_get_ring_cnt(nic, ATL_RING_TX);
299 			unsigned int ptp_ring_idx =
300 				aq_ptp_ring_idx(nic->aq_nic_cfg.tc_mode);
301 
302 			snprintf(tc_string, 8, "PTP ");
303 
304 			for (i = 0; i < max(rx_ring_cnt, tx_ring_cnt); i++) {
305 				for (si = 0; si < rx_stat_cnt; si++) {
306 					snprintf(p, ETH_GSTRING_LEN,
307 						 aq_ethtool_queue_rx_stat_names[si],
308 						 tc_string,
309 						 i ? PTP_HWST_RING_IDX : ptp_ring_idx);
310 					p += ETH_GSTRING_LEN;
311 				}
312 				if (i >= tx_ring_cnt)
313 					continue;
314 				for (si = 0; si < tx_stat_cnt; si++) {
315 					snprintf(p, ETH_GSTRING_LEN,
316 						 aq_ethtool_queue_tx_stat_names[si],
317 						 tc_string,
318 						 i ? PTP_HWST_RING_IDX : ptp_ring_idx);
319 					p += ETH_GSTRING_LEN;
320 				}
321 			}
322 		}
323 #endif
324 #if IS_ENABLED(CONFIG_MACSEC)
325 		if (!nic->macsec_cfg)
326 			break;
327 
328 		memcpy(p, aq_macsec_stat_names, sizeof(aq_macsec_stat_names));
329 		p = p + sizeof(aq_macsec_stat_names);
330 		for (i = 0; i < AQ_MACSEC_MAX_SC; i++) {
331 			struct aq_macsec_txsc *aq_txsc;
332 
333 			if (!(test_bit(i, &nic->macsec_cfg->txsc_idx_busy)))
334 				continue;
335 
336 			for (si = 0;
337 				si < ARRAY_SIZE(aq_macsec_txsc_stat_names);
338 				si++) {
339 				snprintf(p, ETH_GSTRING_LEN,
340 					 aq_macsec_txsc_stat_names[si], i);
341 				p += ETH_GSTRING_LEN;
342 			}
343 			aq_txsc = &nic->macsec_cfg->aq_txsc[i];
344 			for (sa = 0; sa < MACSEC_NUM_AN; sa++) {
345 				if (!(test_bit(sa, &aq_txsc->tx_sa_idx_busy)))
346 					continue;
347 				for (si = 0;
348 				     si < ARRAY_SIZE(aq_macsec_txsa_stat_names);
349 				     si++) {
350 					snprintf(p, ETH_GSTRING_LEN,
351 						 aq_macsec_txsa_stat_names[si],
352 						 i, sa);
353 					p += ETH_GSTRING_LEN;
354 				}
355 			}
356 		}
357 		for (i = 0; i < AQ_MACSEC_MAX_SC; i++) {
358 			struct aq_macsec_rxsc *aq_rxsc;
359 
360 			if (!(test_bit(i, &nic->macsec_cfg->rxsc_idx_busy)))
361 				continue;
362 
363 			aq_rxsc = &nic->macsec_cfg->aq_rxsc[i];
364 			for (sa = 0; sa < MACSEC_NUM_AN; sa++) {
365 				if (!(test_bit(sa, &aq_rxsc->rx_sa_idx_busy)))
366 					continue;
367 				for (si = 0;
368 				     si < ARRAY_SIZE(aq_macsec_rxsa_stat_names);
369 				     si++) {
370 					snprintf(p, ETH_GSTRING_LEN,
371 						 aq_macsec_rxsa_stat_names[si],
372 						 i, sa);
373 					p += ETH_GSTRING_LEN;
374 				}
375 			}
376 		}
377 #endif
378 		break;
379 	}
380 	case ETH_SS_PRIV_FLAGS:
381 		memcpy(p, aq_ethtool_priv_flag_names,
382 		       sizeof(aq_ethtool_priv_flag_names));
383 		break;
384 	}
385 }
386 
387 static int aq_ethtool_set_phys_id(struct net_device *ndev,
388 				  enum ethtool_phys_id_state state)
389 {
390 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
391 	struct aq_hw_s *hw = aq_nic->aq_hw;
392 	int ret = 0;
393 
394 	if (!aq_nic->aq_fw_ops->led_control)
395 		return -EOPNOTSUPP;
396 
397 	mutex_lock(&aq_nic->fwreq_mutex);
398 
399 	switch (state) {
400 	case ETHTOOL_ID_ACTIVE:
401 		ret = aq_nic->aq_fw_ops->led_control(hw, AQ_HW_LED_BLINK |
402 				 AQ_HW_LED_BLINK << 2 | AQ_HW_LED_BLINK << 4);
403 		break;
404 	case ETHTOOL_ID_INACTIVE:
405 		ret = aq_nic->aq_fw_ops->led_control(hw, AQ_HW_LED_DEFAULT);
406 		break;
407 	default:
408 		break;
409 	}
410 
411 	mutex_unlock(&aq_nic->fwreq_mutex);
412 
413 	return ret;
414 }
415 
416 static int aq_ethtool_get_sset_count(struct net_device *ndev, int stringset)
417 {
418 	int ret = 0;
419 
420 	switch (stringset) {
421 	case ETH_SS_STATS:
422 		ret = aq_ethtool_n_stats(ndev);
423 		break;
424 	case ETH_SS_PRIV_FLAGS:
425 		ret = ARRAY_SIZE(aq_ethtool_priv_flag_names);
426 		break;
427 	default:
428 		ret = -EOPNOTSUPP;
429 	}
430 
431 	return ret;
432 }
433 
434 static u32 aq_ethtool_get_rss_indir_size(struct net_device *ndev)
435 {
436 	return AQ_CFG_RSS_INDIRECTION_TABLE_MAX;
437 }
438 
439 static u32 aq_ethtool_get_rss_key_size(struct net_device *ndev)
440 {
441 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
442 	struct aq_nic_cfg_s *cfg;
443 
444 	cfg = aq_nic_get_cfg(aq_nic);
445 
446 	return sizeof(cfg->aq_rss.hash_secret_key);
447 }
448 
449 static int aq_ethtool_get_rss(struct net_device *ndev, u32 *indir, u8 *key,
450 			      u8 *hfunc)
451 {
452 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
453 	struct aq_nic_cfg_s *cfg;
454 	unsigned int i = 0U;
455 
456 	cfg = aq_nic_get_cfg(aq_nic);
457 
458 	if (hfunc)
459 		*hfunc = ETH_RSS_HASH_TOP; /* Toeplitz */
460 	if (indir) {
461 		for (i = 0; i < AQ_CFG_RSS_INDIRECTION_TABLE_MAX; i++)
462 			indir[i] = cfg->aq_rss.indirection_table[i];
463 	}
464 	if (key)
465 		memcpy(key, cfg->aq_rss.hash_secret_key,
466 		       sizeof(cfg->aq_rss.hash_secret_key));
467 
468 	return 0;
469 }
470 
471 static int aq_ethtool_set_rss(struct net_device *netdev, const u32 *indir,
472 			      const u8 *key, const u8 hfunc)
473 {
474 	struct aq_nic_s *aq_nic = netdev_priv(netdev);
475 	struct aq_nic_cfg_s *cfg;
476 	unsigned int i = 0U;
477 	u32 rss_entries;
478 	int err = 0;
479 
480 	cfg = aq_nic_get_cfg(aq_nic);
481 	rss_entries = cfg->aq_rss.indirection_table_size;
482 
483 	/* We do not allow change in unsupported parameters */
484 	if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
485 		return -EOPNOTSUPP;
486 	/* Fill out the redirection table */
487 	if (indir)
488 		for (i = 0; i < rss_entries; i++)
489 			cfg->aq_rss.indirection_table[i] = indir[i];
490 
491 	/* Fill out the rss hash key */
492 	if (key) {
493 		memcpy(cfg->aq_rss.hash_secret_key, key,
494 		       sizeof(cfg->aq_rss.hash_secret_key));
495 		err = aq_nic->aq_hw_ops->hw_rss_hash_set(aq_nic->aq_hw,
496 			&cfg->aq_rss);
497 		if (err)
498 			return err;
499 	}
500 
501 	err = aq_nic->aq_hw_ops->hw_rss_set(aq_nic->aq_hw, &cfg->aq_rss);
502 
503 	return err;
504 }
505 
506 static int aq_ethtool_get_rxnfc(struct net_device *ndev,
507 				struct ethtool_rxnfc *cmd,
508 				u32 *rule_locs)
509 {
510 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
511 	struct aq_nic_cfg_s *cfg;
512 	int err = 0;
513 
514 	cfg = aq_nic_get_cfg(aq_nic);
515 
516 	switch (cmd->cmd) {
517 	case ETHTOOL_GRXRINGS:
518 		cmd->data = cfg->vecs;
519 		break;
520 	case ETHTOOL_GRXCLSRLCNT:
521 		cmd->rule_cnt = aq_get_rxnfc_count_all_rules(aq_nic);
522 		break;
523 	case ETHTOOL_GRXCLSRULE:
524 		err = aq_get_rxnfc_rule(aq_nic, cmd);
525 		break;
526 	case ETHTOOL_GRXCLSRLALL:
527 		err = aq_get_rxnfc_all_rules(aq_nic, cmd, rule_locs);
528 		break;
529 	default:
530 		err = -EOPNOTSUPP;
531 		break;
532 	}
533 
534 	return err;
535 }
536 
537 static int aq_ethtool_set_rxnfc(struct net_device *ndev,
538 				struct ethtool_rxnfc *cmd)
539 {
540 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
541 	int err = 0;
542 
543 	switch (cmd->cmd) {
544 	case ETHTOOL_SRXCLSRLINS:
545 		err = aq_add_rxnfc_rule(aq_nic, cmd);
546 		break;
547 	case ETHTOOL_SRXCLSRLDEL:
548 		err = aq_del_rxnfc_rule(aq_nic, cmd);
549 		break;
550 	default:
551 		err = -EOPNOTSUPP;
552 		break;
553 	}
554 
555 	return err;
556 }
557 
558 static int aq_ethtool_get_coalesce(struct net_device *ndev,
559 				   struct ethtool_coalesce *coal,
560 				   struct kernel_ethtool_coalesce *kernel_coal,
561 				   struct netlink_ext_ack *extack)
562 {
563 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
564 	struct aq_nic_cfg_s *cfg;
565 
566 	cfg = aq_nic_get_cfg(aq_nic);
567 
568 	if (cfg->itr == AQ_CFG_INTERRUPT_MODERATION_ON ||
569 	    cfg->itr == AQ_CFG_INTERRUPT_MODERATION_AUTO) {
570 		coal->rx_coalesce_usecs = cfg->rx_itr;
571 		coal->tx_coalesce_usecs = cfg->tx_itr;
572 		coal->rx_max_coalesced_frames = 0;
573 		coal->tx_max_coalesced_frames = 0;
574 	} else {
575 		coal->rx_coalesce_usecs = 0;
576 		coal->tx_coalesce_usecs = 0;
577 		coal->rx_max_coalesced_frames = 1;
578 		coal->tx_max_coalesced_frames = 1;
579 	}
580 
581 	return 0;
582 }
583 
584 static int aq_ethtool_set_coalesce(struct net_device *ndev,
585 				   struct ethtool_coalesce *coal,
586 				   struct kernel_ethtool_coalesce *kernel_coal,
587 				   struct netlink_ext_ack *extack)
588 {
589 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
590 	struct aq_nic_cfg_s *cfg;
591 
592 	cfg = aq_nic_get_cfg(aq_nic);
593 
594 	/* Atlantic only supports timing based coalescing
595 	 */
596 	if (coal->rx_max_coalesced_frames > 1 ||
597 	    coal->tx_max_coalesced_frames > 1)
598 		return -EOPNOTSUPP;
599 
600 	/* We do not support frame counting. Check this
601 	 */
602 	if (!(coal->rx_max_coalesced_frames == !coal->rx_coalesce_usecs))
603 		return -EOPNOTSUPP;
604 	if (!(coal->tx_max_coalesced_frames == !coal->tx_coalesce_usecs))
605 		return -EOPNOTSUPP;
606 
607 	if (coal->rx_coalesce_usecs > AQ_CFG_INTERRUPT_MODERATION_USEC_MAX ||
608 	    coal->tx_coalesce_usecs > AQ_CFG_INTERRUPT_MODERATION_USEC_MAX)
609 		return -EINVAL;
610 
611 	cfg->itr = AQ_CFG_INTERRUPT_MODERATION_ON;
612 
613 	cfg->rx_itr = coal->rx_coalesce_usecs;
614 	cfg->tx_itr = coal->tx_coalesce_usecs;
615 
616 	return aq_nic_update_interrupt_moderation_settings(aq_nic);
617 }
618 
619 static void aq_ethtool_get_wol(struct net_device *ndev,
620 			       struct ethtool_wolinfo *wol)
621 {
622 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
623 	struct aq_nic_cfg_s *cfg;
624 
625 	cfg = aq_nic_get_cfg(aq_nic);
626 
627 	wol->supported = AQ_NIC_WOL_MODES;
628 	wol->wolopts = cfg->wol;
629 }
630 
631 static int aq_ethtool_set_wol(struct net_device *ndev,
632 			      struct ethtool_wolinfo *wol)
633 {
634 	struct pci_dev *pdev = to_pci_dev(ndev->dev.parent);
635 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
636 	struct aq_nic_cfg_s *cfg;
637 	int err = 0;
638 
639 	cfg = aq_nic_get_cfg(aq_nic);
640 
641 	if (wol->wolopts & ~AQ_NIC_WOL_MODES)
642 		return -EOPNOTSUPP;
643 
644 	cfg->wol = wol->wolopts;
645 
646 	err = device_set_wakeup_enable(&pdev->dev, !!cfg->wol);
647 
648 	return err;
649 }
650 
651 static int aq_ethtool_get_ts_info(struct net_device *ndev,
652 				  struct ethtool_ts_info *info)
653 {
654 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
655 
656 	ethtool_op_get_ts_info(ndev, info);
657 
658 	if (!aq_nic->aq_ptp)
659 		return 0;
660 
661 	info->so_timestamping |=
662 		SOF_TIMESTAMPING_TX_HARDWARE |
663 		SOF_TIMESTAMPING_RX_HARDWARE |
664 		SOF_TIMESTAMPING_RAW_HARDWARE;
665 
666 	info->tx_types = BIT(HWTSTAMP_TX_OFF) |
667 			 BIT(HWTSTAMP_TX_ON);
668 
669 	info->rx_filters = BIT(HWTSTAMP_FILTER_NONE);
670 
671 	info->rx_filters |= BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
672 			    BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
673 			    BIT(HWTSTAMP_FILTER_PTP_V2_EVENT);
674 
675 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK)
676 	info->phc_index = ptp_clock_index(aq_ptp_get_ptp_clock(aq_nic->aq_ptp));
677 #endif
678 
679 	return 0;
680 }
681 
682 static u32 eee_mask_to_ethtool_mask(u32 speed)
683 {
684 	u32 rate = 0;
685 
686 	if (speed & AQ_NIC_RATE_EEE_10G)
687 		rate |= SUPPORTED_10000baseT_Full;
688 
689 	if (speed & AQ_NIC_RATE_EEE_1G)
690 		rate |= SUPPORTED_1000baseT_Full;
691 
692 	if (speed & AQ_NIC_RATE_EEE_100M)
693 		rate |= SUPPORTED_100baseT_Full;
694 
695 	return rate;
696 }
697 
698 static int aq_ethtool_get_eee(struct net_device *ndev, struct ethtool_eee *eee)
699 {
700 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
701 	u32 rate, supported_rates;
702 	int err = 0;
703 
704 	if (!aq_nic->aq_fw_ops->get_eee_rate)
705 		return -EOPNOTSUPP;
706 
707 	mutex_lock(&aq_nic->fwreq_mutex);
708 	err = aq_nic->aq_fw_ops->get_eee_rate(aq_nic->aq_hw, &rate,
709 					      &supported_rates);
710 	mutex_unlock(&aq_nic->fwreq_mutex);
711 	if (err < 0)
712 		return err;
713 
714 	eee->supported = eee_mask_to_ethtool_mask(supported_rates);
715 
716 	if (aq_nic->aq_nic_cfg.eee_speeds)
717 		eee->advertised = eee->supported;
718 
719 	eee->lp_advertised = eee_mask_to_ethtool_mask(rate);
720 
721 	eee->eee_enabled = !!eee->advertised;
722 
723 	eee->tx_lpi_enabled = eee->eee_enabled;
724 	if ((supported_rates & rate) & AQ_NIC_RATE_EEE_MSK)
725 		eee->eee_active = true;
726 
727 	return 0;
728 }
729 
730 static int aq_ethtool_set_eee(struct net_device *ndev, struct ethtool_eee *eee)
731 {
732 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
733 	u32 rate, supported_rates;
734 	struct aq_nic_cfg_s *cfg;
735 	int err = 0;
736 
737 	cfg = aq_nic_get_cfg(aq_nic);
738 
739 	if (unlikely(!aq_nic->aq_fw_ops->get_eee_rate ||
740 		     !aq_nic->aq_fw_ops->set_eee_rate))
741 		return -EOPNOTSUPP;
742 
743 	mutex_lock(&aq_nic->fwreq_mutex);
744 	err = aq_nic->aq_fw_ops->get_eee_rate(aq_nic->aq_hw, &rate,
745 					      &supported_rates);
746 	mutex_unlock(&aq_nic->fwreq_mutex);
747 	if (err < 0)
748 		return err;
749 
750 	if (eee->eee_enabled) {
751 		rate = supported_rates;
752 		cfg->eee_speeds = rate;
753 	} else {
754 		rate = 0;
755 		cfg->eee_speeds = 0;
756 	}
757 
758 	mutex_lock(&aq_nic->fwreq_mutex);
759 	err = aq_nic->aq_fw_ops->set_eee_rate(aq_nic->aq_hw, rate);
760 	mutex_unlock(&aq_nic->fwreq_mutex);
761 
762 	return err;
763 }
764 
765 static int aq_ethtool_nway_reset(struct net_device *ndev)
766 {
767 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
768 	int err = 0;
769 
770 	if (unlikely(!aq_nic->aq_fw_ops->renegotiate))
771 		return -EOPNOTSUPP;
772 
773 	if (netif_running(ndev)) {
774 		mutex_lock(&aq_nic->fwreq_mutex);
775 		err = aq_nic->aq_fw_ops->renegotiate(aq_nic->aq_hw);
776 		mutex_unlock(&aq_nic->fwreq_mutex);
777 	}
778 
779 	return err;
780 }
781 
782 static void aq_ethtool_get_pauseparam(struct net_device *ndev,
783 				      struct ethtool_pauseparam *pause)
784 {
785 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
786 	int fc = aq_nic->aq_nic_cfg.fc.req;
787 
788 	pause->autoneg = 0;
789 
790 	pause->rx_pause = !!(fc & AQ_NIC_FC_RX);
791 	pause->tx_pause = !!(fc & AQ_NIC_FC_TX);
792 }
793 
794 static int aq_ethtool_set_pauseparam(struct net_device *ndev,
795 				     struct ethtool_pauseparam *pause)
796 {
797 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
798 	int err = 0;
799 
800 	if (!aq_nic->aq_fw_ops->set_flow_control)
801 		return -EOPNOTSUPP;
802 
803 	if (pause->autoneg == AUTONEG_ENABLE)
804 		return -EOPNOTSUPP;
805 
806 	if (pause->rx_pause)
807 		aq_nic->aq_hw->aq_nic_cfg->fc.req |= AQ_NIC_FC_RX;
808 	else
809 		aq_nic->aq_hw->aq_nic_cfg->fc.req &= ~AQ_NIC_FC_RX;
810 
811 	if (pause->tx_pause)
812 		aq_nic->aq_hw->aq_nic_cfg->fc.req |= AQ_NIC_FC_TX;
813 	else
814 		aq_nic->aq_hw->aq_nic_cfg->fc.req &= ~AQ_NIC_FC_TX;
815 
816 	mutex_lock(&aq_nic->fwreq_mutex);
817 	err = aq_nic->aq_fw_ops->set_flow_control(aq_nic->aq_hw);
818 	mutex_unlock(&aq_nic->fwreq_mutex);
819 
820 	return err;
821 }
822 
823 static void aq_get_ringparam(struct net_device *ndev,
824 			     struct ethtool_ringparam *ring,
825 			     struct kernel_ethtool_ringparam *kernel_ring,
826 			     struct netlink_ext_ack *extack)
827 {
828 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
829 	struct aq_nic_cfg_s *cfg;
830 
831 	cfg = aq_nic_get_cfg(aq_nic);
832 
833 	ring->rx_pending = cfg->rxds;
834 	ring->tx_pending = cfg->txds;
835 
836 	ring->rx_max_pending = cfg->aq_hw_caps->rxds_max;
837 	ring->tx_max_pending = cfg->aq_hw_caps->txds_max;
838 }
839 
840 static int aq_set_ringparam(struct net_device *ndev,
841 			    struct ethtool_ringparam *ring,
842 			    struct kernel_ethtool_ringparam *kernel_ring,
843 			    struct netlink_ext_ack *extack)
844 {
845 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
846 	const struct aq_hw_caps_s *hw_caps;
847 	bool ndev_running = false;
848 	struct aq_nic_cfg_s *cfg;
849 	int err = 0;
850 
851 	cfg = aq_nic_get_cfg(aq_nic);
852 	hw_caps = cfg->aq_hw_caps;
853 
854 	if (ring->rx_mini_pending || ring->rx_jumbo_pending) {
855 		err = -EOPNOTSUPP;
856 		goto err_exit;
857 	}
858 
859 	if (netif_running(ndev)) {
860 		ndev_running = true;
861 		dev_close(ndev);
862 	}
863 
864 	cfg->rxds = max(ring->rx_pending, hw_caps->rxds_min);
865 	cfg->rxds = min(cfg->rxds, hw_caps->rxds_max);
866 	cfg->rxds = ALIGN(cfg->rxds, AQ_HW_RXD_MULTIPLE);
867 
868 	cfg->txds = max(ring->tx_pending, hw_caps->txds_min);
869 	cfg->txds = min(cfg->txds, hw_caps->txds_max);
870 	cfg->txds = ALIGN(cfg->txds, AQ_HW_TXD_MULTIPLE);
871 
872 	err = aq_nic_realloc_vectors(aq_nic);
873 	if (err)
874 		goto err_exit;
875 
876 	if (ndev_running)
877 		err = dev_open(ndev, NULL);
878 
879 err_exit:
880 	return err;
881 }
882 
883 static u32 aq_get_msg_level(struct net_device *ndev)
884 {
885 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
886 
887 	return aq_nic->msg_enable;
888 }
889 
890 static void aq_set_msg_level(struct net_device *ndev, u32 data)
891 {
892 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
893 
894 	aq_nic->msg_enable = data;
895 }
896 
897 static u32 aq_ethtool_get_priv_flags(struct net_device *ndev)
898 {
899 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
900 
901 	return aq_nic->aq_nic_cfg.priv_flags;
902 }
903 
904 static int aq_ethtool_set_priv_flags(struct net_device *ndev, u32 flags)
905 {
906 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
907 	struct aq_nic_cfg_s *cfg;
908 	u32 priv_flags;
909 	int ret = 0;
910 
911 	cfg = aq_nic_get_cfg(aq_nic);
912 	priv_flags = cfg->priv_flags;
913 
914 	if (flags & ~AQ_PRIV_FLAGS_MASK)
915 		return -EOPNOTSUPP;
916 
917 	if (hweight32((flags | priv_flags) & AQ_HW_LOOPBACK_MASK) > 1) {
918 		netdev_info(ndev, "Can't enable more than one loopback simultaneously\n");
919 		return -EINVAL;
920 	}
921 
922 	cfg->priv_flags = flags;
923 
924 	if ((priv_flags ^ flags) & BIT(AQ_HW_LOOPBACK_DMA_NET)) {
925 		if (netif_running(ndev)) {
926 			dev_close(ndev);
927 
928 			dev_open(ndev, NULL);
929 		}
930 	} else if ((priv_flags ^ flags) & AQ_HW_LOOPBACK_MASK) {
931 		ret = aq_nic_set_loopback(aq_nic);
932 	}
933 
934 	return ret;
935 }
936 
937 static int aq_ethtool_get_phy_tunable(struct net_device *ndev,
938 				      const struct ethtool_tunable *tuna, void *data)
939 {
940 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
941 
942 	switch (tuna->id) {
943 	case ETHTOOL_PHY_EDPD: {
944 		u16 *val = data;
945 
946 		*val = aq_nic->aq_nic_cfg.is_media_detect ? AQ_HW_MEDIA_DETECT_CNT : 0;
947 		break;
948 	}
949 	case ETHTOOL_PHY_DOWNSHIFT: {
950 		u8 *val = data;
951 
952 		*val = (u8)aq_nic->aq_nic_cfg.downshift_counter;
953 		break;
954 	}
955 	default:
956 		return -EOPNOTSUPP;
957 	}
958 
959 	return 0;
960 }
961 
962 static int aq_ethtool_set_phy_tunable(struct net_device *ndev,
963 				      const struct ethtool_tunable *tuna, const void *data)
964 {
965 	int err = -EOPNOTSUPP;
966 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
967 
968 	switch (tuna->id) {
969 	case ETHTOOL_PHY_EDPD: {
970 		const u16 *val = data;
971 
972 		err = aq_nic_set_media_detect(aq_nic, *val);
973 		break;
974 	}
975 	case ETHTOOL_PHY_DOWNSHIFT: {
976 		const u8 *val = data;
977 
978 		err = aq_nic_set_downshift(aq_nic, *val);
979 		break;
980 	}
981 	default:
982 		break;
983 	}
984 
985 	return err;
986 }
987 
988 const struct ethtool_ops aq_ethtool_ops = {
989 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
990 				     ETHTOOL_COALESCE_MAX_FRAMES,
991 	.get_link            = aq_ethtool_get_link,
992 	.get_regs_len        = aq_ethtool_get_regs_len,
993 	.get_regs            = aq_ethtool_get_regs,
994 	.get_drvinfo         = aq_ethtool_get_drvinfo,
995 	.get_strings         = aq_ethtool_get_strings,
996 	.set_phys_id         = aq_ethtool_set_phys_id,
997 	.get_rxfh_indir_size = aq_ethtool_get_rss_indir_size,
998 	.get_wol             = aq_ethtool_get_wol,
999 	.set_wol             = aq_ethtool_set_wol,
1000 	.nway_reset          = aq_ethtool_nway_reset,
1001 	.get_ringparam       = aq_get_ringparam,
1002 	.set_ringparam       = aq_set_ringparam,
1003 	.get_eee             = aq_ethtool_get_eee,
1004 	.set_eee             = aq_ethtool_set_eee,
1005 	.get_pauseparam      = aq_ethtool_get_pauseparam,
1006 	.set_pauseparam      = aq_ethtool_set_pauseparam,
1007 	.get_rxfh_key_size   = aq_ethtool_get_rss_key_size,
1008 	.get_rxfh            = aq_ethtool_get_rss,
1009 	.set_rxfh            = aq_ethtool_set_rss,
1010 	.get_rxnfc           = aq_ethtool_get_rxnfc,
1011 	.set_rxnfc           = aq_ethtool_set_rxnfc,
1012 	.get_msglevel        = aq_get_msg_level,
1013 	.set_msglevel        = aq_set_msg_level,
1014 	.get_sset_count      = aq_ethtool_get_sset_count,
1015 	.get_ethtool_stats   = aq_ethtool_stats,
1016 	.get_priv_flags      = aq_ethtool_get_priv_flags,
1017 	.set_priv_flags      = aq_ethtool_set_priv_flags,
1018 	.get_link_ksettings  = aq_ethtool_get_link_ksettings,
1019 	.set_link_ksettings  = aq_ethtool_set_link_ksettings,
1020 	.get_coalesce	     = aq_ethtool_get_coalesce,
1021 	.set_coalesce	     = aq_ethtool_set_coalesce,
1022 	.get_ts_info         = aq_ethtool_get_ts_info,
1023 	.get_phy_tunable     = aq_ethtool_get_phy_tunable,
1024 	.set_phy_tunable     = aq_ethtool_set_phy_tunable,
1025 };
1026