1
2
3
4
5
6
7
8
9
10
11#include <linux/netdevice.h>
12#include <linux/ethtool.h>
13#include <linux/rtnetlink.h>
14#include <linux/in.h>
15#include "net_driver.h"
16#include "workarounds.h"
17#include "selftest.h"
18#include "efx.h"
19#include "filter.h"
20#include "nic.h"
21
22struct ethtool_string {
23 char name[ETH_GSTRING_LEN];
24};
25
26struct efx_ethtool_stat {
27 const char *name;
28 enum {
29 EFX_ETHTOOL_STAT_SOURCE_mac_stats,
30 EFX_ETHTOOL_STAT_SOURCE_nic,
31 EFX_ETHTOOL_STAT_SOURCE_channel,
32 EFX_ETHTOOL_STAT_SOURCE_tx_queue
33 } source;
34 unsigned offset;
35 u64(*get_stat) (void *field);
36};
37
38
39#define EFX_ETHTOOL_STAT(stat_name, source_name, field, field_type, \
40 get_stat_function) { \
41 .name = #stat_name, \
42 .source = EFX_ETHTOOL_STAT_SOURCE_##source_name, \
43 .offset = ((((field_type *) 0) == \
44 &((struct efx_##source_name *)0)->field) ? \
45 offsetof(struct efx_##source_name, field) : \
46 offsetof(struct efx_##source_name, field)), \
47 .get_stat = get_stat_function, \
48}
49
50static u64 efx_get_uint_stat(void *field)
51{
52 return *(unsigned int *)field;
53}
54
55static u64 efx_get_ulong_stat(void *field)
56{
57 return *(unsigned long *)field;
58}
59
60static u64 efx_get_u64_stat(void *field)
61{
62 return *(u64 *) field;
63}
64
65static u64 efx_get_atomic_stat(void *field)
66{
67 return atomic_read((atomic_t *) field);
68}
69
70#define EFX_ETHTOOL_ULONG_MAC_STAT(field) \
71 EFX_ETHTOOL_STAT(field, mac_stats, field, \
72 unsigned long, efx_get_ulong_stat)
73
74#define EFX_ETHTOOL_U64_MAC_STAT(field) \
75 EFX_ETHTOOL_STAT(field, mac_stats, field, \
76 u64, efx_get_u64_stat)
77
78#define EFX_ETHTOOL_UINT_NIC_STAT(name) \
79 EFX_ETHTOOL_STAT(name, nic, n_##name, \
80 unsigned int, efx_get_uint_stat)
81
82#define EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(field) \
83 EFX_ETHTOOL_STAT(field, nic, field, \
84 atomic_t, efx_get_atomic_stat)
85
86#define EFX_ETHTOOL_UINT_CHANNEL_STAT(field) \
87 EFX_ETHTOOL_STAT(field, channel, n_##field, \
88 unsigned int, efx_get_uint_stat)
89
90#define EFX_ETHTOOL_UINT_TXQ_STAT(field) \
91 EFX_ETHTOOL_STAT(tx_##field, tx_queue, field, \
92 unsigned int, efx_get_uint_stat)
93
94static struct efx_ethtool_stat efx_ethtool_stats[] = {
95 EFX_ETHTOOL_U64_MAC_STAT(tx_bytes),
96 EFX_ETHTOOL_U64_MAC_STAT(tx_good_bytes),
97 EFX_ETHTOOL_U64_MAC_STAT(tx_bad_bytes),
98 EFX_ETHTOOL_ULONG_MAC_STAT(tx_packets),
99 EFX_ETHTOOL_ULONG_MAC_STAT(tx_bad),
100 EFX_ETHTOOL_ULONG_MAC_STAT(tx_pause),
101 EFX_ETHTOOL_ULONG_MAC_STAT(tx_control),
102 EFX_ETHTOOL_ULONG_MAC_STAT(tx_unicast),
103 EFX_ETHTOOL_ULONG_MAC_STAT(tx_multicast),
104 EFX_ETHTOOL_ULONG_MAC_STAT(tx_broadcast),
105 EFX_ETHTOOL_ULONG_MAC_STAT(tx_lt64),
106 EFX_ETHTOOL_ULONG_MAC_STAT(tx_64),
107 EFX_ETHTOOL_ULONG_MAC_STAT(tx_65_to_127),
108 EFX_ETHTOOL_ULONG_MAC_STAT(tx_128_to_255),
109 EFX_ETHTOOL_ULONG_MAC_STAT(tx_256_to_511),
110 EFX_ETHTOOL_ULONG_MAC_STAT(tx_512_to_1023),
111 EFX_ETHTOOL_ULONG_MAC_STAT(tx_1024_to_15xx),
112 EFX_ETHTOOL_ULONG_MAC_STAT(tx_15xx_to_jumbo),
113 EFX_ETHTOOL_ULONG_MAC_STAT(tx_gtjumbo),
114 EFX_ETHTOOL_ULONG_MAC_STAT(tx_collision),
115 EFX_ETHTOOL_ULONG_MAC_STAT(tx_single_collision),
116 EFX_ETHTOOL_ULONG_MAC_STAT(tx_multiple_collision),
117 EFX_ETHTOOL_ULONG_MAC_STAT(tx_excessive_collision),
118 EFX_ETHTOOL_ULONG_MAC_STAT(tx_deferred),
119 EFX_ETHTOOL_ULONG_MAC_STAT(tx_late_collision),
120 EFX_ETHTOOL_ULONG_MAC_STAT(tx_excessive_deferred),
121 EFX_ETHTOOL_ULONG_MAC_STAT(tx_non_tcpudp),
122 EFX_ETHTOOL_ULONG_MAC_STAT(tx_mac_src_error),
123 EFX_ETHTOOL_ULONG_MAC_STAT(tx_ip_src_error),
124 EFX_ETHTOOL_UINT_TXQ_STAT(tso_bursts),
125 EFX_ETHTOOL_UINT_TXQ_STAT(tso_long_headers),
126 EFX_ETHTOOL_UINT_TXQ_STAT(tso_packets),
127 EFX_ETHTOOL_UINT_TXQ_STAT(pushes),
128 EFX_ETHTOOL_U64_MAC_STAT(rx_bytes),
129 EFX_ETHTOOL_U64_MAC_STAT(rx_good_bytes),
130 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_bytes),
131 EFX_ETHTOOL_ULONG_MAC_STAT(rx_packets),
132 EFX_ETHTOOL_ULONG_MAC_STAT(rx_good),
133 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad),
134 EFX_ETHTOOL_ULONG_MAC_STAT(rx_pause),
135 EFX_ETHTOOL_ULONG_MAC_STAT(rx_control),
136 EFX_ETHTOOL_ULONG_MAC_STAT(rx_unicast),
137 EFX_ETHTOOL_ULONG_MAC_STAT(rx_multicast),
138 EFX_ETHTOOL_ULONG_MAC_STAT(rx_broadcast),
139 EFX_ETHTOOL_ULONG_MAC_STAT(rx_lt64),
140 EFX_ETHTOOL_ULONG_MAC_STAT(rx_64),
141 EFX_ETHTOOL_ULONG_MAC_STAT(rx_65_to_127),
142 EFX_ETHTOOL_ULONG_MAC_STAT(rx_128_to_255),
143 EFX_ETHTOOL_ULONG_MAC_STAT(rx_256_to_511),
144 EFX_ETHTOOL_ULONG_MAC_STAT(rx_512_to_1023),
145 EFX_ETHTOOL_ULONG_MAC_STAT(rx_1024_to_15xx),
146 EFX_ETHTOOL_ULONG_MAC_STAT(rx_15xx_to_jumbo),
147 EFX_ETHTOOL_ULONG_MAC_STAT(rx_gtjumbo),
148 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_lt64),
149 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_64_to_15xx),
150 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_15xx_to_jumbo),
151 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_gtjumbo),
152 EFX_ETHTOOL_ULONG_MAC_STAT(rx_overflow),
153 EFX_ETHTOOL_ULONG_MAC_STAT(rx_missed),
154 EFX_ETHTOOL_ULONG_MAC_STAT(rx_false_carrier),
155 EFX_ETHTOOL_ULONG_MAC_STAT(rx_symbol_error),
156 EFX_ETHTOOL_ULONG_MAC_STAT(rx_align_error),
157 EFX_ETHTOOL_ULONG_MAC_STAT(rx_length_error),
158 EFX_ETHTOOL_ULONG_MAC_STAT(rx_internal_error),
159 EFX_ETHTOOL_UINT_NIC_STAT(rx_nodesc_drop_cnt),
160 EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(rx_reset),
161 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc),
162 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err),
163 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err),
164 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch),
165 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc),
166};
167
168
169#define EFX_ETHTOOL_NUM_STATS ARRAY_SIZE(efx_ethtool_stats)
170
171#define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB
172
173
174
175
176
177
178
179
180
181static int efx_ethtool_phys_id(struct net_device *net_dev,
182 enum ethtool_phys_id_state state)
183{
184 struct efx_nic *efx = netdev_priv(net_dev);
185 enum efx_led_mode mode = EFX_LED_DEFAULT;
186
187 switch (state) {
188 case ETHTOOL_ID_ON:
189 mode = EFX_LED_ON;
190 break;
191 case ETHTOOL_ID_OFF:
192 mode = EFX_LED_OFF;
193 break;
194 case ETHTOOL_ID_INACTIVE:
195 mode = EFX_LED_DEFAULT;
196 break;
197 case ETHTOOL_ID_ACTIVE:
198 return 1;
199 }
200
201 efx->type->set_id_led(efx, mode);
202 return 0;
203}
204
205
206static int efx_ethtool_get_settings(struct net_device *net_dev,
207 struct ethtool_cmd *ecmd)
208{
209 struct efx_nic *efx = netdev_priv(net_dev);
210 struct efx_link_state *link_state = &efx->link_state;
211
212 mutex_lock(&efx->mac_lock);
213 efx->phy_op->get_settings(efx, ecmd);
214 mutex_unlock(&efx->mac_lock);
215
216
217 ecmd->supported &= ~SUPPORTED_1000baseT_Half;
218
219 ecmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
220
221 if (LOOPBACK_INTERNAL(efx)) {
222 ethtool_cmd_speed_set(ecmd, link_state->speed);
223 ecmd->duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
224 }
225
226 return 0;
227}
228
229
230static int efx_ethtool_set_settings(struct net_device *net_dev,
231 struct ethtool_cmd *ecmd)
232{
233 struct efx_nic *efx = netdev_priv(net_dev);
234 int rc;
235
236
237 if ((ethtool_cmd_speed(ecmd) == SPEED_1000) &&
238 (ecmd->duplex != DUPLEX_FULL)) {
239 netif_dbg(efx, drv, efx->net_dev,
240 "rejecting unsupported 1000Mbps HD setting\n");
241 return -EINVAL;
242 }
243
244 mutex_lock(&efx->mac_lock);
245 rc = efx->phy_op->set_settings(efx, ecmd);
246 mutex_unlock(&efx->mac_lock);
247 return rc;
248}
249
250static void efx_ethtool_get_drvinfo(struct net_device *net_dev,
251 struct ethtool_drvinfo *info)
252{
253 struct efx_nic *efx = netdev_priv(net_dev);
254
255 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
256 strlcpy(info->version, EFX_DRIVER_VERSION, sizeof(info->version));
257 if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0)
258 efx_mcdi_print_fwver(efx, info->fw_version,
259 sizeof(info->fw_version));
260 strlcpy(info->bus_info, pci_name(efx->pci_dev), sizeof(info->bus_info));
261}
262
263static int efx_ethtool_get_regs_len(struct net_device *net_dev)
264{
265 return efx_nic_get_regs_len(netdev_priv(net_dev));
266}
267
268static void efx_ethtool_get_regs(struct net_device *net_dev,
269 struct ethtool_regs *regs, void *buf)
270{
271 struct efx_nic *efx = netdev_priv(net_dev);
272
273 regs->version = efx->type->revision;
274 efx_nic_get_regs(efx, buf);
275}
276
277static u32 efx_ethtool_get_msglevel(struct net_device *net_dev)
278{
279 struct efx_nic *efx = netdev_priv(net_dev);
280 return efx->msg_enable;
281}
282
283static void efx_ethtool_set_msglevel(struct net_device *net_dev, u32 msg_enable)
284{
285 struct efx_nic *efx = netdev_priv(net_dev);
286 efx->msg_enable = msg_enable;
287}
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302static void efx_fill_test(unsigned int test_index,
303 struct ethtool_string *strings, u64 *data,
304 int *test, const char *unit_format, int unit_id,
305 const char *test_format, const char *test_id)
306{
307 struct ethtool_string unit_str, test_str;
308
309
310 if (data)
311 data[test_index] = *test;
312
313
314 if (strings) {
315 if (strchr(unit_format, '%'))
316 snprintf(unit_str.name, sizeof(unit_str.name),
317 unit_format, unit_id);
318 else
319 strcpy(unit_str.name, unit_format);
320 snprintf(test_str.name, sizeof(test_str.name),
321 test_format, test_id);
322 snprintf(strings[test_index].name,
323 sizeof(strings[test_index].name),
324 "%-6s %-24s", unit_str.name, test_str.name);
325 }
326}
327
328#define EFX_CHANNEL_NAME(_channel) "chan%d", _channel->channel
329#define EFX_TX_QUEUE_NAME(_tx_queue) "txq%d", _tx_queue->queue
330#define EFX_RX_QUEUE_NAME(_rx_queue) "rxq%d", _rx_queue->queue
331#define EFX_LOOPBACK_NAME(_mode, _counter) \
332 "loopback.%s." _counter, STRING_TABLE_LOOKUP(_mode, efx_loopback_mode)
333
334
335
336
337
338
339
340
341
342
343static int efx_fill_loopback_test(struct efx_nic *efx,
344 struct efx_loopback_self_tests *lb_tests,
345 enum efx_loopback_mode mode,
346 unsigned int test_index,
347 struct ethtool_string *strings, u64 *data)
348{
349 struct efx_channel *channel = efx_get_channel(efx, 0);
350 struct efx_tx_queue *tx_queue;
351
352 efx_for_each_channel_tx_queue(tx_queue, channel) {
353 efx_fill_test(test_index++, strings, data,
354 &lb_tests->tx_sent[tx_queue->queue],
355 EFX_TX_QUEUE_NAME(tx_queue),
356 EFX_LOOPBACK_NAME(mode, "tx_sent"));
357 efx_fill_test(test_index++, strings, data,
358 &lb_tests->tx_done[tx_queue->queue],
359 EFX_TX_QUEUE_NAME(tx_queue),
360 EFX_LOOPBACK_NAME(mode, "tx_done"));
361 }
362 efx_fill_test(test_index++, strings, data,
363 &lb_tests->rx_good,
364 "rx", 0,
365 EFX_LOOPBACK_NAME(mode, "rx_good"));
366 efx_fill_test(test_index++, strings, data,
367 &lb_tests->rx_bad,
368 "rx", 0,
369 EFX_LOOPBACK_NAME(mode, "rx_bad"));
370
371 return test_index;
372}
373
374
375
376
377
378
379
380
381static int efx_ethtool_fill_self_tests(struct efx_nic *efx,
382 struct efx_self_tests *tests,
383 struct ethtool_string *strings,
384 u64 *data)
385{
386 struct efx_channel *channel;
387 unsigned int n = 0, i;
388 enum efx_loopback_mode mode;
389
390 efx_fill_test(n++, strings, data, &tests->phy_alive,
391 "phy", 0, "alive", NULL);
392 efx_fill_test(n++, strings, data, &tests->nvram,
393 "core", 0, "nvram", NULL);
394 efx_fill_test(n++, strings, data, &tests->interrupt,
395 "core", 0, "interrupt", NULL);
396
397
398 efx_for_each_channel(channel, efx) {
399 efx_fill_test(n++, strings, data,
400 &tests->eventq_dma[channel->channel],
401 EFX_CHANNEL_NAME(channel),
402 "eventq.dma", NULL);
403 efx_fill_test(n++, strings, data,
404 &tests->eventq_int[channel->channel],
405 EFX_CHANNEL_NAME(channel),
406 "eventq.int", NULL);
407 efx_fill_test(n++, strings, data,
408 &tests->eventq_poll[channel->channel],
409 EFX_CHANNEL_NAME(channel),
410 "eventq.poll", NULL);
411 }
412
413 efx_fill_test(n++, strings, data, &tests->registers,
414 "core", 0, "registers", NULL);
415
416 if (efx->phy_op->run_tests != NULL) {
417 EFX_BUG_ON_PARANOID(efx->phy_op->test_name == NULL);
418
419 for (i = 0; true; ++i) {
420 const char *name;
421
422 EFX_BUG_ON_PARANOID(i >= EFX_MAX_PHY_TESTS);
423 name = efx->phy_op->test_name(efx, i);
424 if (name == NULL)
425 break;
426
427 efx_fill_test(n++, strings, data, &tests->phy_ext[i],
428 "phy", 0, name, NULL);
429 }
430 }
431
432
433 for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) {
434 if (!(efx->loopback_modes & (1 << mode)))
435 continue;
436 n = efx_fill_loopback_test(efx,
437 &tests->loopback[mode], mode, n,
438 strings, data);
439 }
440
441 return n;
442}
443
444static int efx_ethtool_get_sset_count(struct net_device *net_dev,
445 int string_set)
446{
447 switch (string_set) {
448 case ETH_SS_STATS:
449 return EFX_ETHTOOL_NUM_STATS;
450 case ETH_SS_TEST:
451 return efx_ethtool_fill_self_tests(netdev_priv(net_dev),
452 NULL, NULL, NULL);
453 default:
454 return -EINVAL;
455 }
456}
457
458static void efx_ethtool_get_strings(struct net_device *net_dev,
459 u32 string_set, u8 *strings)
460{
461 struct efx_nic *efx = netdev_priv(net_dev);
462 struct ethtool_string *ethtool_strings =
463 (struct ethtool_string *)strings;
464 int i;
465
466 switch (string_set) {
467 case ETH_SS_STATS:
468 for (i = 0; i < EFX_ETHTOOL_NUM_STATS; i++)
469 strncpy(ethtool_strings[i].name,
470 efx_ethtool_stats[i].name,
471 sizeof(ethtool_strings[i].name));
472 break;
473 case ETH_SS_TEST:
474 efx_ethtool_fill_self_tests(efx, NULL,
475 ethtool_strings, NULL);
476 break;
477 default:
478
479 break;
480 }
481}
482
483static void efx_ethtool_get_stats(struct net_device *net_dev,
484 struct ethtool_stats *stats,
485 u64 *data)
486{
487 struct efx_nic *efx = netdev_priv(net_dev);
488 struct efx_mac_stats *mac_stats = &efx->mac_stats;
489 struct efx_ethtool_stat *stat;
490 struct efx_channel *channel;
491 struct efx_tx_queue *tx_queue;
492 struct rtnl_link_stats64 temp;
493 int i;
494
495 EFX_BUG_ON_PARANOID(stats->n_stats != EFX_ETHTOOL_NUM_STATS);
496
497
498 dev_get_stats(net_dev, &temp);
499
500
501 for (i = 0; i < EFX_ETHTOOL_NUM_STATS; i++) {
502 stat = &efx_ethtool_stats[i];
503 switch (stat->source) {
504 case EFX_ETHTOOL_STAT_SOURCE_mac_stats:
505 data[i] = stat->get_stat((void *)mac_stats +
506 stat->offset);
507 break;
508 case EFX_ETHTOOL_STAT_SOURCE_nic:
509 data[i] = stat->get_stat((void *)efx + stat->offset);
510 break;
511 case EFX_ETHTOOL_STAT_SOURCE_channel:
512 data[i] = 0;
513 efx_for_each_channel(channel, efx)
514 data[i] += stat->get_stat((void *)channel +
515 stat->offset);
516 break;
517 case EFX_ETHTOOL_STAT_SOURCE_tx_queue:
518 data[i] = 0;
519 efx_for_each_channel(channel, efx) {
520 efx_for_each_channel_tx_queue(tx_queue, channel)
521 data[i] +=
522 stat->get_stat((void *)tx_queue
523 + stat->offset);
524 }
525 break;
526 }
527 }
528}
529
530static void efx_ethtool_self_test(struct net_device *net_dev,
531 struct ethtool_test *test, u64 *data)
532{
533 struct efx_nic *efx = netdev_priv(net_dev);
534 struct efx_self_tests *efx_tests;
535 int already_up;
536 int rc = -ENOMEM;
537
538 efx_tests = kzalloc(sizeof(*efx_tests), GFP_KERNEL);
539 if (!efx_tests)
540 goto fail;
541
542
543 ASSERT_RTNL();
544 if (efx->state != STATE_RUNNING) {
545 rc = -EIO;
546 goto fail1;
547 }
548
549 netif_info(efx, drv, efx->net_dev, "starting %sline testing\n",
550 (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
551
552
553 already_up = (efx->net_dev->flags & IFF_UP);
554 if (!already_up) {
555 rc = dev_open(efx->net_dev);
556 if (rc) {
557 netif_err(efx, drv, efx->net_dev,
558 "failed opening device.\n");
559 goto fail1;
560 }
561 }
562
563 rc = efx_selftest(efx, efx_tests, test->flags);
564
565 if (!already_up)
566 dev_close(efx->net_dev);
567
568 netif_info(efx, drv, efx->net_dev, "%s %sline self-tests\n",
569 rc == 0 ? "passed" : "failed",
570 (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
571
572fail1:
573
574 efx_ethtool_fill_self_tests(efx, efx_tests, NULL, data);
575 kfree(efx_tests);
576fail:
577 if (rc)
578 test->flags |= ETH_TEST_FL_FAILED;
579}
580
581
582static int efx_ethtool_nway_reset(struct net_device *net_dev)
583{
584 struct efx_nic *efx = netdev_priv(net_dev);
585
586 return mdio45_nway_restart(&efx->mdio);
587}
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618static int efx_ethtool_get_coalesce(struct net_device *net_dev,
619 struct ethtool_coalesce *coalesce)
620{
621 struct efx_nic *efx = netdev_priv(net_dev);
622 unsigned int tx_usecs, rx_usecs;
623 bool rx_adaptive;
624
625 efx_get_irq_moderation(efx, &tx_usecs, &rx_usecs, &rx_adaptive);
626
627 coalesce->tx_coalesce_usecs = tx_usecs;
628 coalesce->tx_coalesce_usecs_irq = tx_usecs;
629 coalesce->rx_coalesce_usecs = rx_usecs;
630 coalesce->rx_coalesce_usecs_irq = rx_usecs;
631 coalesce->use_adaptive_rx_coalesce = rx_adaptive;
632
633 return 0;
634}
635
636static int efx_ethtool_set_coalesce(struct net_device *net_dev,
637 struct ethtool_coalesce *coalesce)
638{
639 struct efx_nic *efx = netdev_priv(net_dev);
640 struct efx_channel *channel;
641 unsigned int tx_usecs, rx_usecs;
642 bool adaptive, rx_may_override_tx;
643 int rc;
644
645 if (coalesce->use_adaptive_tx_coalesce)
646 return -EINVAL;
647
648 efx_get_irq_moderation(efx, &tx_usecs, &rx_usecs, &adaptive);
649
650 if (coalesce->rx_coalesce_usecs != rx_usecs)
651 rx_usecs = coalesce->rx_coalesce_usecs;
652 else
653 rx_usecs = coalesce->rx_coalesce_usecs_irq;
654
655 adaptive = coalesce->use_adaptive_rx_coalesce;
656
657
658
659
660 rx_may_override_tx = (coalesce->tx_coalesce_usecs == tx_usecs &&
661 coalesce->tx_coalesce_usecs_irq == tx_usecs);
662 if (coalesce->tx_coalesce_usecs != tx_usecs)
663 tx_usecs = coalesce->tx_coalesce_usecs;
664 else
665 tx_usecs = coalesce->tx_coalesce_usecs_irq;
666
667 rc = efx_init_irq_moderation(efx, tx_usecs, rx_usecs, adaptive,
668 rx_may_override_tx);
669 if (rc != 0)
670 return rc;
671
672 efx_for_each_channel(channel, efx)
673 efx->type->push_irq_moderation(channel);
674
675 return 0;
676}
677
678static void efx_ethtool_get_ringparam(struct net_device *net_dev,
679 struct ethtool_ringparam *ring)
680{
681 struct efx_nic *efx = netdev_priv(net_dev);
682
683 ring->rx_max_pending = EFX_MAX_DMAQ_SIZE;
684 ring->tx_max_pending = EFX_MAX_DMAQ_SIZE;
685 ring->rx_pending = efx->rxq_entries;
686 ring->tx_pending = efx->txq_entries;
687}
688
689static int efx_ethtool_set_ringparam(struct net_device *net_dev,
690 struct ethtool_ringparam *ring)
691{
692 struct efx_nic *efx = netdev_priv(net_dev);
693
694 if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
695 ring->rx_pending > EFX_MAX_DMAQ_SIZE ||
696 ring->tx_pending > EFX_MAX_DMAQ_SIZE)
697 return -EINVAL;
698
699 if (ring->rx_pending < EFX_MIN_RING_SIZE ||
700 ring->tx_pending < EFX_MIN_RING_SIZE) {
701 netif_err(efx, drv, efx->net_dev,
702 "TX and RX queues cannot be smaller than %ld\n",
703 EFX_MIN_RING_SIZE);
704 return -EINVAL;
705 }
706
707 return efx_realloc_channels(efx, ring->rx_pending, ring->tx_pending);
708}
709
710static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
711 struct ethtool_pauseparam *pause)
712{
713 struct efx_nic *efx = netdev_priv(net_dev);
714 u8 wanted_fc, old_fc;
715 u32 old_adv;
716 bool reset;
717 int rc = 0;
718
719 mutex_lock(&efx->mac_lock);
720
721 wanted_fc = ((pause->rx_pause ? EFX_FC_RX : 0) |
722 (pause->tx_pause ? EFX_FC_TX : 0) |
723 (pause->autoneg ? EFX_FC_AUTO : 0));
724
725 if ((wanted_fc & EFX_FC_TX) && !(wanted_fc & EFX_FC_RX)) {
726 netif_dbg(efx, drv, efx->net_dev,
727 "Flow control unsupported: tx ON rx OFF\n");
728 rc = -EINVAL;
729 goto out;
730 }
731
732 if ((wanted_fc & EFX_FC_AUTO) && !efx->link_advertising) {
733 netif_dbg(efx, drv, efx->net_dev,
734 "Autonegotiation is disabled\n");
735 rc = -EINVAL;
736 goto out;
737 }
738
739
740
741
742
743
744 reset = (wanted_fc & EFX_FC_TX) && !(efx->wanted_fc & EFX_FC_TX);
745 if (EFX_WORKAROUND_11482(efx) && reset) {
746 if (efx_nic_rev(efx) == EFX_REV_FALCON_B0) {
747
748 falcon_stop_nic_stats(efx);
749 falcon_drain_tx_fifo(efx);
750 efx->mac_op->reconfigure(efx);
751 falcon_start_nic_stats(efx);
752 } else {
753
754 efx_schedule_reset(efx, RESET_TYPE_INVISIBLE);
755 }
756 }
757
758 old_adv = efx->link_advertising;
759 old_fc = efx->wanted_fc;
760 efx_link_set_wanted_fc(efx, wanted_fc);
761 if (efx->link_advertising != old_adv ||
762 (efx->wanted_fc ^ old_fc) & EFX_FC_AUTO) {
763 rc = efx->phy_op->reconfigure(efx);
764 if (rc) {
765 netif_err(efx, drv, efx->net_dev,
766 "Unable to advertise requested flow "
767 "control setting\n");
768 goto out;
769 }
770 }
771
772
773
774
775 efx->mac_op->reconfigure(efx);
776
777out:
778 mutex_unlock(&efx->mac_lock);
779
780 return rc;
781}
782
783static void efx_ethtool_get_pauseparam(struct net_device *net_dev,
784 struct ethtool_pauseparam *pause)
785{
786 struct efx_nic *efx = netdev_priv(net_dev);
787
788 pause->rx_pause = !!(efx->wanted_fc & EFX_FC_RX);
789 pause->tx_pause = !!(efx->wanted_fc & EFX_FC_TX);
790 pause->autoneg = !!(efx->wanted_fc & EFX_FC_AUTO);
791}
792
793
794static void efx_ethtool_get_wol(struct net_device *net_dev,
795 struct ethtool_wolinfo *wol)
796{
797 struct efx_nic *efx = netdev_priv(net_dev);
798 return efx->type->get_wol(efx, wol);
799}
800
801
802static int efx_ethtool_set_wol(struct net_device *net_dev,
803 struct ethtool_wolinfo *wol)
804{
805 struct efx_nic *efx = netdev_priv(net_dev);
806 return efx->type->set_wol(efx, wol->wolopts);
807}
808
809static int efx_ethtool_reset(struct net_device *net_dev, u32 *flags)
810{
811 struct efx_nic *efx = netdev_priv(net_dev);
812 int rc;
813
814 rc = efx->type->map_reset_flags(flags);
815 if (rc < 0)
816 return rc;
817
818 return efx_reset(efx, rc);
819}
820
821static int efx_ethtool_get_class_rule(struct efx_nic *efx,
822 struct ethtool_rx_flow_spec *rule)
823{
824 struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
825 struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
826 struct efx_filter_spec spec;
827 u16 vid;
828 u8 proto;
829 int rc;
830
831 rc = efx_filter_get_filter_safe(efx, EFX_FILTER_PRI_MANUAL,
832 rule->location, &spec);
833 if (rc)
834 return rc;
835
836 if (spec.dmaq_id == 0xfff)
837 rule->ring_cookie = RX_CLS_FLOW_DISC;
838 else
839 rule->ring_cookie = spec.dmaq_id;
840
841 rc = efx_filter_get_eth_local(&spec, &vid,
842 rule->h_u.ether_spec.h_dest);
843 if (rc == 0) {
844 rule->flow_type = ETHER_FLOW;
845 memset(rule->m_u.ether_spec.h_dest, ~0, ETH_ALEN);
846 if (vid != EFX_FILTER_VID_UNSPEC) {
847 rule->flow_type |= FLOW_EXT;
848 rule->h_ext.vlan_tci = htons(vid);
849 rule->m_ext.vlan_tci = htons(0xfff);
850 }
851 return 0;
852 }
853
854 rc = efx_filter_get_ipv4_local(&spec, &proto,
855 &ip_entry->ip4dst, &ip_entry->pdst);
856 if (rc != 0) {
857 rc = efx_filter_get_ipv4_full(
858 &spec, &proto, &ip_entry->ip4src, &ip_entry->psrc,
859 &ip_entry->ip4dst, &ip_entry->pdst);
860 EFX_WARN_ON_PARANOID(rc);
861 ip_mask->ip4src = ~0;
862 ip_mask->psrc = ~0;
863 }
864 rule->flow_type = (proto == IPPROTO_TCP) ? TCP_V4_FLOW : UDP_V4_FLOW;
865 ip_mask->ip4dst = ~0;
866 ip_mask->pdst = ~0;
867 return rc;
868}
869
870static int
871efx_ethtool_get_rxnfc(struct net_device *net_dev,
872 struct ethtool_rxnfc *info, u32 *rule_locs)
873{
874 struct efx_nic *efx = netdev_priv(net_dev);
875
876 switch (info->cmd) {
877 case ETHTOOL_GRXRINGS:
878 info->data = efx->n_rx_channels;
879 return 0;
880
881 case ETHTOOL_GRXFH: {
882 unsigned min_revision = 0;
883
884 info->data = 0;
885 switch (info->flow_type) {
886 case TCP_V4_FLOW:
887 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
888
889 case UDP_V4_FLOW:
890 case SCTP_V4_FLOW:
891 case AH_ESP_V4_FLOW:
892 case IPV4_FLOW:
893 info->data |= RXH_IP_SRC | RXH_IP_DST;
894 min_revision = EFX_REV_FALCON_B0;
895 break;
896 case TCP_V6_FLOW:
897 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
898
899 case UDP_V6_FLOW:
900 case SCTP_V6_FLOW:
901 case AH_ESP_V6_FLOW:
902 case IPV6_FLOW:
903 info->data |= RXH_IP_SRC | RXH_IP_DST;
904 min_revision = EFX_REV_SIENA_A0;
905 break;
906 default:
907 break;
908 }
909 if (efx_nic_rev(efx) < min_revision)
910 info->data = 0;
911 return 0;
912 }
913
914 case ETHTOOL_GRXCLSRLCNT:
915 info->data = efx_filter_get_rx_id_limit(efx);
916 if (info->data == 0)
917 return -EOPNOTSUPP;
918 info->data |= RX_CLS_LOC_SPECIAL;
919 info->rule_cnt =
920 efx_filter_count_rx_used(efx, EFX_FILTER_PRI_MANUAL);
921 return 0;
922
923 case ETHTOOL_GRXCLSRULE:
924 if (efx_filter_get_rx_id_limit(efx) == 0)
925 return -EOPNOTSUPP;
926 return efx_ethtool_get_class_rule(efx, &info->fs);
927
928 case ETHTOOL_GRXCLSRLALL: {
929 s32 rc;
930 info->data = efx_filter_get_rx_id_limit(efx);
931 if (info->data == 0)
932 return -EOPNOTSUPP;
933 rc = efx_filter_get_rx_ids(efx, EFX_FILTER_PRI_MANUAL,
934 rule_locs, info->rule_cnt);
935 if (rc < 0)
936 return rc;
937 info->rule_cnt = rc;
938 return 0;
939 }
940
941 default:
942 return -EOPNOTSUPP;
943 }
944}
945
946static int efx_ethtool_set_class_rule(struct efx_nic *efx,
947 struct ethtool_rx_flow_spec *rule)
948{
949 struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
950 struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
951 struct ethhdr *mac_entry = &rule->h_u.ether_spec;
952 struct ethhdr *mac_mask = &rule->m_u.ether_spec;
953 struct efx_filter_spec spec;
954 int rc;
955
956
957 if (rule->location != RX_CLS_LOC_ANY &&
958 rule->location != RX_CLS_LOC_FIRST &&
959 rule->location != RX_CLS_LOC_LAST)
960 return -EINVAL;
961
962
963 if (rule->ring_cookie >= efx->n_rx_channels &&
964 rule->ring_cookie != RX_CLS_FLOW_DISC)
965 return -EINVAL;
966
967
968 if ((rule->flow_type & FLOW_EXT) &&
969 (rule->m_ext.vlan_etype | rule->m_ext.data[0] |
970 rule->m_ext.data[1]))
971 return -EINVAL;
972
973 efx_filter_init_rx(&spec, EFX_FILTER_PRI_MANUAL,
974 (rule->location == RX_CLS_LOC_FIRST) ?
975 EFX_FILTER_FLAG_RX_OVERRIDE_IP : 0,
976 (rule->ring_cookie == RX_CLS_FLOW_DISC) ?
977 0xfff : rule->ring_cookie);
978
979 switch (rule->flow_type) {
980 case TCP_V4_FLOW:
981 case UDP_V4_FLOW: {
982 u8 proto = (rule->flow_type == TCP_V4_FLOW ?
983 IPPROTO_TCP : IPPROTO_UDP);
984
985
986 if ((__force u32)~ip_mask->ip4dst |
987 (__force u16)~ip_mask->pdst)
988 return -EINVAL;
989
990 if ((ip_mask->ip4src | ip_mask->psrc) &&
991 ((__force u32)~ip_mask->ip4src |
992 (__force u16)~ip_mask->psrc))
993 return -EINVAL;
994
995 if (ip_mask->tos | rule->m_ext.vlan_tci)
996 return -EINVAL;
997
998 if (ip_mask->ip4src)
999 rc = efx_filter_set_ipv4_full(&spec, proto,
1000 ip_entry->ip4dst,
1001 ip_entry->pdst,
1002 ip_entry->ip4src,
1003 ip_entry->psrc);
1004 else
1005 rc = efx_filter_set_ipv4_local(&spec, proto,
1006 ip_entry->ip4dst,
1007 ip_entry->pdst);
1008 if (rc)
1009 return rc;
1010 break;
1011 }
1012
1013 case ETHER_FLOW | FLOW_EXT:
1014
1015 if (rule->m_ext.vlan_tci != htons(0xfff) &&
1016 rule->m_ext.vlan_tci != 0)
1017 return -EINVAL;
1018 case ETHER_FLOW:
1019
1020 if (!is_broadcast_ether_addr(mac_mask->h_dest))
1021 return -EINVAL;
1022
1023 if (!is_zero_ether_addr(mac_mask->h_source) ||
1024 mac_mask->h_proto)
1025 return -EINVAL;
1026
1027 rc = efx_filter_set_eth_local(
1028 &spec,
1029 (rule->flow_type & FLOW_EXT && rule->m_ext.vlan_tci) ?
1030 ntohs(rule->h_ext.vlan_tci) : EFX_FILTER_VID_UNSPEC,
1031 mac_entry->h_dest);
1032 if (rc)
1033 return rc;
1034 break;
1035
1036 default:
1037 return -EINVAL;
1038 }
1039
1040 rc = efx_filter_insert_filter(efx, &spec, true);
1041 if (rc < 0)
1042 return rc;
1043
1044 rule->location = rc;
1045 return 0;
1046}
1047
1048static int efx_ethtool_set_rxnfc(struct net_device *net_dev,
1049 struct ethtool_rxnfc *info)
1050{
1051 struct efx_nic *efx = netdev_priv(net_dev);
1052
1053 if (efx_filter_get_rx_id_limit(efx) == 0)
1054 return -EOPNOTSUPP;
1055
1056 switch (info->cmd) {
1057 case ETHTOOL_SRXCLSRLINS:
1058 return efx_ethtool_set_class_rule(efx, &info->fs);
1059
1060 case ETHTOOL_SRXCLSRLDEL:
1061 return efx_filter_remove_id_safe(efx, EFX_FILTER_PRI_MANUAL,
1062 info->fs.location);
1063
1064 default:
1065 return -EOPNOTSUPP;
1066 }
1067}
1068
1069static u32 efx_ethtool_get_rxfh_indir_size(struct net_device *net_dev)
1070{
1071 struct efx_nic *efx = netdev_priv(net_dev);
1072
1073 return (efx_nic_rev(efx) < EFX_REV_FALCON_B0 ?
1074 0 : ARRAY_SIZE(efx->rx_indir_table));
1075}
1076
1077static int efx_ethtool_get_rxfh_indir(struct net_device *net_dev, u32 *indir)
1078{
1079 struct efx_nic *efx = netdev_priv(net_dev);
1080
1081 memcpy(indir, efx->rx_indir_table, sizeof(efx->rx_indir_table));
1082 return 0;
1083}
1084
1085static int efx_ethtool_set_rxfh_indir(struct net_device *net_dev,
1086 const u32 *indir)
1087{
1088 struct efx_nic *efx = netdev_priv(net_dev);
1089
1090 memcpy(efx->rx_indir_table, indir, sizeof(efx->rx_indir_table));
1091 efx_nic_push_rx_indir_table(efx);
1092 return 0;
1093}
1094
1095const struct ethtool_ops efx_ethtool_ops = {
1096 .get_settings = efx_ethtool_get_settings,
1097 .set_settings = efx_ethtool_set_settings,
1098 .get_drvinfo = efx_ethtool_get_drvinfo,
1099 .get_regs_len = efx_ethtool_get_regs_len,
1100 .get_regs = efx_ethtool_get_regs,
1101 .get_msglevel = efx_ethtool_get_msglevel,
1102 .set_msglevel = efx_ethtool_set_msglevel,
1103 .nway_reset = efx_ethtool_nway_reset,
1104 .get_link = ethtool_op_get_link,
1105 .get_coalesce = efx_ethtool_get_coalesce,
1106 .set_coalesce = efx_ethtool_set_coalesce,
1107 .get_ringparam = efx_ethtool_get_ringparam,
1108 .set_ringparam = efx_ethtool_set_ringparam,
1109 .get_pauseparam = efx_ethtool_get_pauseparam,
1110 .set_pauseparam = efx_ethtool_set_pauseparam,
1111 .get_sset_count = efx_ethtool_get_sset_count,
1112 .self_test = efx_ethtool_self_test,
1113 .get_strings = efx_ethtool_get_strings,
1114 .set_phys_id = efx_ethtool_phys_id,
1115 .get_ethtool_stats = efx_ethtool_get_stats,
1116 .get_wol = efx_ethtool_get_wol,
1117 .set_wol = efx_ethtool_set_wol,
1118 .reset = efx_ethtool_reset,
1119 .get_rxnfc = efx_ethtool_get_rxnfc,
1120 .set_rxnfc = efx_ethtool_set_rxnfc,
1121 .get_rxfh_indir_size = efx_ethtool_get_rxfh_indir_size,
1122 .get_rxfh_indir = efx_ethtool_get_rxfh_indir,
1123 .set_rxfh_indir = efx_ethtool_set_rxfh_indir,
1124};
1125
