1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * aQuantia Corporation Network Driver
4  * Copyright (C) 2014-2019 aQuantia Corporation. All rights reserved
5  */
6 
7 /* File aq_ethtool.c: Definition of ethertool related functions. */
8 
9 #include "aq_ethtool.h"
10 #include "aq_nic.h"
11 #include "aq_vec.h"
12 #include "aq_ptp.h"
13 #include "aq_filters.h"
14 
15 #include <linux/ptp_clock_kernel.h>
16 
17 static void aq_ethtool_get_regs(struct net_device *ndev,
18 				struct ethtool_regs *regs, void *p)
19 {
20 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
21 	u32 regs_count;
22 
23 	regs_count = aq_nic_get_regs_count(aq_nic);
24 
25 	memset(p, 0, regs_count * sizeof(u32));
26 	aq_nic_get_regs(aq_nic, regs, p);
27 }
28 
29 static int aq_ethtool_get_regs_len(struct net_device *ndev)
30 {
31 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
32 	u32 regs_count;
33 
34 	regs_count = aq_nic_get_regs_count(aq_nic);
35 
36 	return regs_count * sizeof(u32);
37 }
38 
39 static u32 aq_ethtool_get_link(struct net_device *ndev)
40 {
41 	return ethtool_op_get_link(ndev);
42 }
43 
44 static int aq_ethtool_get_link_ksettings(struct net_device *ndev,
45 					 struct ethtool_link_ksettings *cmd)
46 {
47 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
48 
49 	aq_nic_get_link_ksettings(aq_nic, cmd);
50 	cmd->base.speed = netif_carrier_ok(ndev) ?
51 				aq_nic_get_link_speed(aq_nic) : 0U;
52 
53 	return 0;
54 }
55 
56 static int
57 aq_ethtool_set_link_ksettings(struct net_device *ndev,
58 			      const struct ethtool_link_ksettings *cmd)
59 {
60 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
61 
62 	return aq_nic_set_link_ksettings(aq_nic, cmd);
63 }
64 
65 static const char aq_ethtool_stat_names[][ETH_GSTRING_LEN] = {
66 	"InPackets",
67 	"InUCast",
68 	"InMCast",
69 	"InBCast",
70 	"InErrors",
71 	"OutPackets",
72 	"OutUCast",
73 	"OutMCast",
74 	"OutBCast",
75 	"InUCastOctets",
76 	"OutUCastOctets",
77 	"InMCastOctets",
78 	"OutMCastOctets",
79 	"InBCastOctets",
80 	"OutBCastOctets",
81 	"InOctets",
82 	"OutOctets",
83 	"InPacketsDma",
84 	"OutPacketsDma",
85 	"InOctetsDma",
86 	"OutOctetsDma",
87 	"InDroppedDma",
88 };
89 
90 static const char aq_ethtool_queue_stat_names[][ETH_GSTRING_LEN] = {
91 	"Queue[%d] InPackets",
92 	"Queue[%d] OutPackets",
93 	"Queue[%d] Restarts",
94 	"Queue[%d] InJumboPackets",
95 	"Queue[%d] InLroPackets",
96 	"Queue[%d] InErrors",
97 };
98 
99 static const char aq_ethtool_priv_flag_names[][ETH_GSTRING_LEN] = {
100 	"DMASystemLoopback",
101 	"PKTSystemLoopback",
102 	"DMANetworkLoopback",
103 	"PHYInternalLoopback",
104 	"PHYExternalLoopback",
105 };
106 
107 static void aq_ethtool_stats(struct net_device *ndev,
108 			     struct ethtool_stats *stats, u64 *data)
109 {
110 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
111 	struct aq_nic_cfg_s *cfg;
112 
113 	cfg = aq_nic_get_cfg(aq_nic);
114 
115 	memset(data, 0, (ARRAY_SIZE(aq_ethtool_stat_names) +
116 			 ARRAY_SIZE(aq_ethtool_queue_stat_names) *
117 			 cfg->vecs) * sizeof(u64));
118 	aq_nic_get_stats(aq_nic, data);
119 }
120 
121 static void aq_ethtool_get_drvinfo(struct net_device *ndev,
122 				   struct ethtool_drvinfo *drvinfo)
123 {
124 	struct pci_dev *pdev = to_pci_dev(ndev->dev.parent);
125 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
126 	struct aq_nic_cfg_s *cfg;
127 	u32 firmware_version;
128 	u32 regs_count;
129 
130 	cfg = aq_nic_get_cfg(aq_nic);
131 	firmware_version = aq_nic_get_fw_version(aq_nic);
132 	regs_count = aq_nic_get_regs_count(aq_nic);
133 
134 	strlcat(drvinfo->driver, AQ_CFG_DRV_NAME, sizeof(drvinfo->driver));
135 
136 	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
137 		 "%u.%u.%u", firmware_version >> 24,
138 		 (firmware_version >> 16) & 0xFFU, firmware_version & 0xFFFFU);
139 
140 	strlcpy(drvinfo->bus_info, pdev ? pci_name(pdev) : "",
141 		sizeof(drvinfo->bus_info));
142 	drvinfo->n_stats = ARRAY_SIZE(aq_ethtool_stat_names) +
143 		cfg->vecs * ARRAY_SIZE(aq_ethtool_queue_stat_names);
144 	drvinfo->testinfo_len = 0;
145 	drvinfo->regdump_len = regs_count;
146 	drvinfo->eedump_len = 0;
147 }
148 
149 static void aq_ethtool_get_strings(struct net_device *ndev,
150 				   u32 stringset, u8 *data)
151 {
152 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
153 	struct aq_nic_cfg_s *cfg;
154 	u8 *p = data;
155 	int i, si;
156 
157 	cfg = aq_nic_get_cfg(aq_nic);
158 
159 	switch (stringset) {
160 	case ETH_SS_STATS:
161 		memcpy(p, aq_ethtool_stat_names,
162 		       sizeof(aq_ethtool_stat_names));
163 		p = p + sizeof(aq_ethtool_stat_names);
164 		for (i = 0; i < cfg->vecs; i++) {
165 			for (si = 0;
166 				si < ARRAY_SIZE(aq_ethtool_queue_stat_names);
167 				si++) {
168 				snprintf(p, ETH_GSTRING_LEN,
169 					 aq_ethtool_queue_stat_names[si], i);
170 				p += ETH_GSTRING_LEN;
171 			}
172 		}
173 		break;
174 	case ETH_SS_PRIV_FLAGS:
175 		memcpy(p, aq_ethtool_priv_flag_names,
176 		       sizeof(aq_ethtool_priv_flag_names));
177 		break;
178 	}
179 }
180 
181 static int aq_ethtool_set_phys_id(struct net_device *ndev,
182 				  enum ethtool_phys_id_state state)
183 {
184 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
185 	struct aq_hw_s *hw = aq_nic->aq_hw;
186 	int ret = 0;
187 
188 	if (!aq_nic->aq_fw_ops->led_control)
189 		return -EOPNOTSUPP;
190 
191 	mutex_lock(&aq_nic->fwreq_mutex);
192 
193 	switch (state) {
194 	case ETHTOOL_ID_ACTIVE:
195 		ret = aq_nic->aq_fw_ops->led_control(hw, AQ_HW_LED_BLINK |
196 				 AQ_HW_LED_BLINK << 2 | AQ_HW_LED_BLINK << 4);
197 		break;
198 	case ETHTOOL_ID_INACTIVE:
199 		ret = aq_nic->aq_fw_ops->led_control(hw, AQ_HW_LED_DEFAULT);
200 		break;
201 	default:
202 		break;
203 	}
204 
205 	mutex_unlock(&aq_nic->fwreq_mutex);
206 
207 	return ret;
208 }
209 
210 static int aq_ethtool_get_sset_count(struct net_device *ndev, int stringset)
211 {
212 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
213 	struct aq_nic_cfg_s *cfg;
214 	int ret = 0;
215 
216 	cfg = aq_nic_get_cfg(aq_nic);
217 
218 	switch (stringset) {
219 	case ETH_SS_STATS:
220 		ret = ARRAY_SIZE(aq_ethtool_stat_names) +
221 			cfg->vecs * ARRAY_SIZE(aq_ethtool_queue_stat_names);
222 		break;
223 	case ETH_SS_PRIV_FLAGS:
224 		ret = ARRAY_SIZE(aq_ethtool_priv_flag_names);
225 		break;
226 	default:
227 		ret = -EOPNOTSUPP;
228 	}
229 
230 	return ret;
231 }
232 
233 static u32 aq_ethtool_get_rss_indir_size(struct net_device *ndev)
234 {
235 	return AQ_CFG_RSS_INDIRECTION_TABLE_MAX;
236 }
237 
238 static u32 aq_ethtool_get_rss_key_size(struct net_device *ndev)
239 {
240 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
241 	struct aq_nic_cfg_s *cfg;
242 
243 	cfg = aq_nic_get_cfg(aq_nic);
244 
245 	return sizeof(cfg->aq_rss.hash_secret_key);
246 }
247 
248 static int aq_ethtool_get_rss(struct net_device *ndev, u32 *indir, u8 *key,
249 			      u8 *hfunc)
250 {
251 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
252 	struct aq_nic_cfg_s *cfg;
253 	unsigned int i = 0U;
254 
255 	cfg = aq_nic_get_cfg(aq_nic);
256 
257 	if (hfunc)
258 		*hfunc = ETH_RSS_HASH_TOP; /* Toeplitz */
259 	if (indir) {
260 		for (i = 0; i < AQ_CFG_RSS_INDIRECTION_TABLE_MAX; i++)
261 			indir[i] = cfg->aq_rss.indirection_table[i];
262 	}
263 	if (key)
264 		memcpy(key, cfg->aq_rss.hash_secret_key,
265 		       sizeof(cfg->aq_rss.hash_secret_key));
266 
267 	return 0;
268 }
269 
270 static int aq_ethtool_set_rss(struct net_device *netdev, const u32 *indir,
271 			      const u8 *key, const u8 hfunc)
272 {
273 	struct aq_nic_s *aq_nic = netdev_priv(netdev);
274 	struct aq_nic_cfg_s *cfg;
275 	unsigned int i = 0U;
276 	u32 rss_entries;
277 	int err = 0;
278 
279 	cfg = aq_nic_get_cfg(aq_nic);
280 	rss_entries = cfg->aq_rss.indirection_table_size;
281 
282 	/* We do not allow change in unsupported parameters */
283 	if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
284 		return -EOPNOTSUPP;
285 	/* Fill out the redirection table */
286 	if (indir)
287 		for (i = 0; i < rss_entries; i++)
288 			cfg->aq_rss.indirection_table[i] = indir[i];
289 
290 	/* Fill out the rss hash key */
291 	if (key) {
292 		memcpy(cfg->aq_rss.hash_secret_key, key,
293 		       sizeof(cfg->aq_rss.hash_secret_key));
294 		err = aq_nic->aq_hw_ops->hw_rss_hash_set(aq_nic->aq_hw,
295 			&cfg->aq_rss);
296 		if (err)
297 			return err;
298 	}
299 
300 	err = aq_nic->aq_hw_ops->hw_rss_set(aq_nic->aq_hw, &cfg->aq_rss);
301 
302 	return err;
303 }
304 
305 static int aq_ethtool_get_rxnfc(struct net_device *ndev,
306 				struct ethtool_rxnfc *cmd,
307 				u32 *rule_locs)
308 {
309 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
310 	struct aq_nic_cfg_s *cfg;
311 	int err = 0;
312 
313 	cfg = aq_nic_get_cfg(aq_nic);
314 
315 	switch (cmd->cmd) {
316 	case ETHTOOL_GRXRINGS:
317 		cmd->data = cfg->vecs;
318 		break;
319 	case ETHTOOL_GRXCLSRLCNT:
320 		cmd->rule_cnt = aq_get_rxnfc_count_all_rules(aq_nic);
321 		break;
322 	case ETHTOOL_GRXCLSRULE:
323 		err = aq_get_rxnfc_rule(aq_nic, cmd);
324 		break;
325 	case ETHTOOL_GRXCLSRLALL:
326 		err = aq_get_rxnfc_all_rules(aq_nic, cmd, rule_locs);
327 		break;
328 	default:
329 		err = -EOPNOTSUPP;
330 		break;
331 	}
332 
333 	return err;
334 }
335 
336 static int aq_ethtool_set_rxnfc(struct net_device *ndev,
337 				struct ethtool_rxnfc *cmd)
338 {
339 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
340 	int err = 0;
341 
342 	switch (cmd->cmd) {
343 	case ETHTOOL_SRXCLSRLINS:
344 		err = aq_add_rxnfc_rule(aq_nic, cmd);
345 		break;
346 	case ETHTOOL_SRXCLSRLDEL:
347 		err = aq_del_rxnfc_rule(aq_nic, cmd);
348 		break;
349 	default:
350 		err = -EOPNOTSUPP;
351 		break;
352 	}
353 
354 	return err;
355 }
356 
357 static int aq_ethtool_get_coalesce(struct net_device *ndev,
358 				   struct ethtool_coalesce *coal)
359 {
360 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
361 	struct aq_nic_cfg_s *cfg;
362 
363 	cfg = aq_nic_get_cfg(aq_nic);
364 
365 	if (cfg->itr == AQ_CFG_INTERRUPT_MODERATION_ON ||
366 	    cfg->itr == AQ_CFG_INTERRUPT_MODERATION_AUTO) {
367 		coal->rx_coalesce_usecs = cfg->rx_itr;
368 		coal->tx_coalesce_usecs = cfg->tx_itr;
369 		coal->rx_max_coalesced_frames = 0;
370 		coal->tx_max_coalesced_frames = 0;
371 	} else {
372 		coal->rx_coalesce_usecs = 0;
373 		coal->tx_coalesce_usecs = 0;
374 		coal->rx_max_coalesced_frames = 1;
375 		coal->tx_max_coalesced_frames = 1;
376 	}
377 
378 	return 0;
379 }
380 
381 static int aq_ethtool_set_coalesce(struct net_device *ndev,
382 				   struct ethtool_coalesce *coal)
383 {
384 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
385 	struct aq_nic_cfg_s *cfg;
386 
387 	cfg = aq_nic_get_cfg(aq_nic);
388 
389 	/* Atlantic only supports timing based coalescing
390 	 */
391 	if (coal->rx_max_coalesced_frames > 1 ||
392 	    coal->tx_max_coalesced_frames > 1)
393 		return -EOPNOTSUPP;
394 
395 	/* We do not support frame counting. Check this
396 	 */
397 	if (!(coal->rx_max_coalesced_frames == !coal->rx_coalesce_usecs))
398 		return -EOPNOTSUPP;
399 	if (!(coal->tx_max_coalesced_frames == !coal->tx_coalesce_usecs))
400 		return -EOPNOTSUPP;
401 
402 	if (coal->rx_coalesce_usecs > AQ_CFG_INTERRUPT_MODERATION_USEC_MAX ||
403 	    coal->tx_coalesce_usecs > AQ_CFG_INTERRUPT_MODERATION_USEC_MAX)
404 		return -EINVAL;
405 
406 	cfg->itr = AQ_CFG_INTERRUPT_MODERATION_ON;
407 
408 	cfg->rx_itr = coal->rx_coalesce_usecs;
409 	cfg->tx_itr = coal->tx_coalesce_usecs;
410 
411 	return aq_nic_update_interrupt_moderation_settings(aq_nic);
412 }
413 
414 static void aq_ethtool_get_wol(struct net_device *ndev,
415 			       struct ethtool_wolinfo *wol)
416 {
417 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
418 	struct aq_nic_cfg_s *cfg;
419 
420 	cfg = aq_nic_get_cfg(aq_nic);
421 
422 	wol->supported = AQ_NIC_WOL_MODES;
423 	wol->wolopts = cfg->wol;
424 }
425 
426 static int aq_ethtool_set_wol(struct net_device *ndev,
427 			      struct ethtool_wolinfo *wol)
428 {
429 	struct pci_dev *pdev = to_pci_dev(ndev->dev.parent);
430 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
431 	struct aq_nic_cfg_s *cfg;
432 	int err = 0;
433 
434 	cfg = aq_nic_get_cfg(aq_nic);
435 
436 	if (wol->wolopts & ~AQ_NIC_WOL_MODES)
437 		return -EOPNOTSUPP;
438 
439 	cfg->wol = wol->wolopts;
440 
441 	err = device_set_wakeup_enable(&pdev->dev, !!cfg->wol);
442 
443 	return err;
444 }
445 
446 static int aq_ethtool_get_ts_info(struct net_device *ndev,
447 				  struct ethtool_ts_info *info)
448 {
449 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
450 
451 	ethtool_op_get_ts_info(ndev, info);
452 
453 	if (!aq_nic->aq_ptp)
454 		return 0;
455 
456 	info->so_timestamping |=
457 		SOF_TIMESTAMPING_TX_HARDWARE |
458 		SOF_TIMESTAMPING_RX_HARDWARE |
459 		SOF_TIMESTAMPING_RAW_HARDWARE;
460 
461 	info->tx_types = BIT(HWTSTAMP_TX_OFF) |
462 			 BIT(HWTSTAMP_TX_ON);
463 
464 	info->rx_filters = BIT(HWTSTAMP_FILTER_NONE);
465 
466 	info->rx_filters |= BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
467 			    BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
468 			    BIT(HWTSTAMP_FILTER_PTP_V2_EVENT);
469 
470 	info->phc_index = ptp_clock_index(aq_ptp_get_ptp_clock(aq_nic->aq_ptp));
471 
472 	return 0;
473 }
474 
475 static enum hw_atl_fw2x_rate eee_mask_to_ethtool_mask(u32 speed)
476 {
477 	u32 rate = 0;
478 
479 	if (speed & AQ_NIC_RATE_EEE_10G)
480 		rate |= SUPPORTED_10000baseT_Full;
481 
482 	if (speed & AQ_NIC_RATE_EEE_2GS)
483 		rate |= SUPPORTED_2500baseX_Full;
484 
485 	if (speed & AQ_NIC_RATE_EEE_1G)
486 		rate |= SUPPORTED_1000baseT_Full;
487 
488 	return rate;
489 }
490 
491 static int aq_ethtool_get_eee(struct net_device *ndev, struct ethtool_eee *eee)
492 {
493 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
494 	u32 rate, supported_rates;
495 	int err = 0;
496 
497 	if (!aq_nic->aq_fw_ops->get_eee_rate)
498 		return -EOPNOTSUPP;
499 
500 	mutex_lock(&aq_nic->fwreq_mutex);
501 	err = aq_nic->aq_fw_ops->get_eee_rate(aq_nic->aq_hw, &rate,
502 					      &supported_rates);
503 	mutex_unlock(&aq_nic->fwreq_mutex);
504 	if (err < 0)
505 		return err;
506 
507 	eee->supported = eee_mask_to_ethtool_mask(supported_rates);
508 
509 	if (aq_nic->aq_nic_cfg.eee_speeds)
510 		eee->advertised = eee->supported;
511 
512 	eee->lp_advertised = eee_mask_to_ethtool_mask(rate);
513 
514 	eee->eee_enabled = !!eee->advertised;
515 
516 	eee->tx_lpi_enabled = eee->eee_enabled;
517 	if (eee->advertised & eee->lp_advertised)
518 		eee->eee_active = true;
519 
520 	return 0;
521 }
522 
523 static int aq_ethtool_set_eee(struct net_device *ndev, struct ethtool_eee *eee)
524 {
525 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
526 	u32 rate, supported_rates;
527 	struct aq_nic_cfg_s *cfg;
528 	int err = 0;
529 
530 	cfg = aq_nic_get_cfg(aq_nic);
531 
532 	if (unlikely(!aq_nic->aq_fw_ops->get_eee_rate ||
533 		     !aq_nic->aq_fw_ops->set_eee_rate))
534 		return -EOPNOTSUPP;
535 
536 	mutex_lock(&aq_nic->fwreq_mutex);
537 	err = aq_nic->aq_fw_ops->get_eee_rate(aq_nic->aq_hw, &rate,
538 					      &supported_rates);
539 	mutex_unlock(&aq_nic->fwreq_mutex);
540 	if (err < 0)
541 		return err;
542 
543 	if (eee->eee_enabled) {
544 		rate = supported_rates;
545 		cfg->eee_speeds = rate;
546 	} else {
547 		rate = 0;
548 		cfg->eee_speeds = 0;
549 	}
550 
551 	mutex_lock(&aq_nic->fwreq_mutex);
552 	err = aq_nic->aq_fw_ops->set_eee_rate(aq_nic->aq_hw, rate);
553 	mutex_unlock(&aq_nic->fwreq_mutex);
554 
555 	return err;
556 }
557 
558 static int aq_ethtool_nway_reset(struct net_device *ndev)
559 {
560 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
561 	int err = 0;
562 
563 	if (unlikely(!aq_nic->aq_fw_ops->renegotiate))
564 		return -EOPNOTSUPP;
565 
566 	if (netif_running(ndev)) {
567 		mutex_lock(&aq_nic->fwreq_mutex);
568 		err = aq_nic->aq_fw_ops->renegotiate(aq_nic->aq_hw);
569 		mutex_unlock(&aq_nic->fwreq_mutex);
570 	}
571 
572 	return err;
573 }
574 
575 static void aq_ethtool_get_pauseparam(struct net_device *ndev,
576 				      struct ethtool_pauseparam *pause)
577 {
578 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
579 	u32 fc = aq_nic->aq_nic_cfg.fc.req;
580 
581 	pause->autoneg = 0;
582 
583 	pause->rx_pause = !!(fc & AQ_NIC_FC_RX);
584 	pause->tx_pause = !!(fc & AQ_NIC_FC_TX);
585 
586 }
587 
588 static int aq_ethtool_set_pauseparam(struct net_device *ndev,
589 				     struct ethtool_pauseparam *pause)
590 {
591 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
592 	int err = 0;
593 
594 	if (!aq_nic->aq_fw_ops->set_flow_control)
595 		return -EOPNOTSUPP;
596 
597 	if (pause->autoneg == AUTONEG_ENABLE)
598 		return -EOPNOTSUPP;
599 
600 	if (pause->rx_pause)
601 		aq_nic->aq_hw->aq_nic_cfg->fc.req |= AQ_NIC_FC_RX;
602 	else
603 		aq_nic->aq_hw->aq_nic_cfg->fc.req &= ~AQ_NIC_FC_RX;
604 
605 	if (pause->tx_pause)
606 		aq_nic->aq_hw->aq_nic_cfg->fc.req |= AQ_NIC_FC_TX;
607 	else
608 		aq_nic->aq_hw->aq_nic_cfg->fc.req &= ~AQ_NIC_FC_TX;
609 
610 	mutex_lock(&aq_nic->fwreq_mutex);
611 	err = aq_nic->aq_fw_ops->set_flow_control(aq_nic->aq_hw);
612 	mutex_unlock(&aq_nic->fwreq_mutex);
613 
614 	return err;
615 }
616 
617 static void aq_get_ringparam(struct net_device *ndev,
618 			     struct ethtool_ringparam *ring)
619 {
620 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
621 	struct aq_nic_cfg_s *cfg;
622 
623 	cfg = aq_nic_get_cfg(aq_nic);
624 
625 	ring->rx_pending = cfg->rxds;
626 	ring->tx_pending = cfg->txds;
627 
628 	ring->rx_max_pending = cfg->aq_hw_caps->rxds_max;
629 	ring->tx_max_pending = cfg->aq_hw_caps->txds_max;
630 }
631 
632 static int aq_set_ringparam(struct net_device *ndev,
633 			    struct ethtool_ringparam *ring)
634 {
635 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
636 	const struct aq_hw_caps_s *hw_caps;
637 	bool ndev_running = false;
638 	struct aq_nic_cfg_s *cfg;
639 	int err = 0;
640 
641 	cfg = aq_nic_get_cfg(aq_nic);
642 	hw_caps = cfg->aq_hw_caps;
643 
644 	if (ring->rx_mini_pending || ring->rx_jumbo_pending) {
645 		err = -EOPNOTSUPP;
646 		goto err_exit;
647 	}
648 
649 	if (netif_running(ndev)) {
650 		ndev_running = true;
651 		dev_close(ndev);
652 	}
653 
654 	aq_nic_free_vectors(aq_nic);
655 
656 	cfg->rxds = max(ring->rx_pending, hw_caps->rxds_min);
657 	cfg->rxds = min(cfg->rxds, hw_caps->rxds_max);
658 	cfg->rxds = ALIGN(cfg->rxds, AQ_HW_RXD_MULTIPLE);
659 
660 	cfg->txds = max(ring->tx_pending, hw_caps->txds_min);
661 	cfg->txds = min(cfg->txds, hw_caps->txds_max);
662 	cfg->txds = ALIGN(cfg->txds, AQ_HW_TXD_MULTIPLE);
663 
664 	for (aq_nic->aq_vecs = 0; aq_nic->aq_vecs < cfg->vecs;
665 	     aq_nic->aq_vecs++) {
666 		aq_nic->aq_vec[aq_nic->aq_vecs] =
667 		    aq_vec_alloc(aq_nic, aq_nic->aq_vecs, cfg);
668 		if (unlikely(!aq_nic->aq_vec[aq_nic->aq_vecs])) {
669 			err = -ENOMEM;
670 			goto err_exit;
671 		}
672 	}
673 	if (ndev_running)
674 		err = dev_open(ndev, NULL);
675 
676 err_exit:
677 	return err;
678 }
679 
680 static u32 aq_get_msg_level(struct net_device *ndev)
681 {
682 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
683 
684 	return aq_nic->msg_enable;
685 }
686 
687 static void aq_set_msg_level(struct net_device *ndev, u32 data)
688 {
689 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
690 
691 	aq_nic->msg_enable = data;
692 }
693 
694 static u32 aq_ethtool_get_priv_flags(struct net_device *ndev)
695 {
696 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
697 
698 	return aq_nic->aq_nic_cfg.priv_flags;
699 }
700 
701 static int aq_ethtool_set_priv_flags(struct net_device *ndev, u32 flags)
702 {
703 	struct aq_nic_s *aq_nic = netdev_priv(ndev);
704 	struct aq_nic_cfg_s *cfg;
705 	u32 priv_flags;
706 
707 	cfg = aq_nic_get_cfg(aq_nic);
708 	priv_flags = cfg->priv_flags;
709 
710 	if (flags & ~AQ_PRIV_FLAGS_MASK)
711 		return -EOPNOTSUPP;
712 
713 	if (hweight32((flags | priv_flags) & AQ_HW_LOOPBACK_MASK) > 1) {
714 		netdev_info(ndev, "Can't enable more than one loopback simultaneously\n");
715 		return -EINVAL;
716 	}
717 
718 	cfg->priv_flags = flags;
719 
720 	if ((priv_flags ^ flags) & BIT(AQ_HW_LOOPBACK_DMA_NET)) {
721 		if (netif_running(ndev)) {
722 			dev_close(ndev);
723 
724 			dev_open(ndev, NULL);
725 		}
726 	} else if ((priv_flags ^ flags) & AQ_HW_LOOPBACK_MASK) {
727 		aq_nic_set_loopback(aq_nic);
728 	}
729 
730 	return 0;
731 }
732 
733 const struct ethtool_ops aq_ethtool_ops = {
734 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
735 				     ETHTOOL_COALESCE_MAX_FRAMES,
736 	.get_link            = aq_ethtool_get_link,
737 	.get_regs_len        = aq_ethtool_get_regs_len,
738 	.get_regs            = aq_ethtool_get_regs,
739 	.get_drvinfo         = aq_ethtool_get_drvinfo,
740 	.get_strings         = aq_ethtool_get_strings,
741 	.set_phys_id         = aq_ethtool_set_phys_id,
742 	.get_rxfh_indir_size = aq_ethtool_get_rss_indir_size,
743 	.get_wol             = aq_ethtool_get_wol,
744 	.set_wol             = aq_ethtool_set_wol,
745 	.nway_reset          = aq_ethtool_nway_reset,
746 	.get_ringparam       = aq_get_ringparam,
747 	.set_ringparam       = aq_set_ringparam,
748 	.get_eee             = aq_ethtool_get_eee,
749 	.set_eee             = aq_ethtool_set_eee,
750 	.get_pauseparam      = aq_ethtool_get_pauseparam,
751 	.set_pauseparam      = aq_ethtool_set_pauseparam,
752 	.get_rxfh_key_size   = aq_ethtool_get_rss_key_size,
753 	.get_rxfh            = aq_ethtool_get_rss,
754 	.set_rxfh            = aq_ethtool_set_rss,
755 	.get_rxnfc           = aq_ethtool_get_rxnfc,
756 	.set_rxnfc           = aq_ethtool_set_rxnfc,
757 	.get_msglevel        = aq_get_msg_level,
758 	.set_msglevel        = aq_set_msg_level,
759 	.get_sset_count      = aq_ethtool_get_sset_count,
760 	.get_ethtool_stats   = aq_ethtool_stats,
761 	.get_priv_flags      = aq_ethtool_get_priv_flags,
762 	.set_priv_flags      = aq_ethtool_set_priv_flags,
763 	.get_link_ksettings  = aq_ethtool_get_link_ksettings,
764 	.set_link_ksettings  = aq_ethtool_set_link_ksettings,
765 	.get_coalesce	     = aq_ethtool_get_coalesce,
766 	.set_coalesce	     = aq_ethtool_set_coalesce,
767 	.get_ts_info         = aq_ethtool_get_ts_info,
768 };
769