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