1 /****************************************************************************
2 * Driver for Solarflare Solarstorm network controllers and boards
3 * Copyright 2005-2006 Fen Systems Ltd.
4 * Copyright 2006-2010 Solarflare Communications Inc.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published
8 * by the Free Software Foundation, incorporated herein by reference.
11 #include <linux/netdevice.h>
12 #include <linux/ethtool.h>
13 #include <linux/rtnetlink.h>
15 #include "net_driver.h"
16 #include "workarounds.h"
22 struct ethtool_string
{
23 char name
[ETH_GSTRING_LEN
];
26 struct efx_ethtool_stat
{
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
35 u64(*get_stat
) (void *field
); /* Reader function */
38 /* Initialiser for a struct #efx_ethtool_stat with type-checking */
39 #define EFX_ETHTOOL_STAT(stat_name, source_name, field, field_type, \
40 get_stat_function) { \
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, \
50 static u64
efx_get_uint_stat(void *field
)
52 return *(unsigned int *)field
;
55 static u64
efx_get_u64_stat(void *field
)
57 return *(u64
*) field
;
60 static u64
efx_get_atomic_stat(void *field
)
62 return atomic_read((atomic_t
*) field
);
65 #define EFX_ETHTOOL_U64_MAC_STAT(field) \
66 EFX_ETHTOOL_STAT(field, mac_stats, field, \
67 u64, efx_get_u64_stat)
69 #define EFX_ETHTOOL_UINT_NIC_STAT(name) \
70 EFX_ETHTOOL_STAT(name, nic, n_##name, \
71 unsigned int, efx_get_uint_stat)
73 #define EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(field) \
74 EFX_ETHTOOL_STAT(field, nic, field, \
75 atomic_t, efx_get_atomic_stat)
77 #define EFX_ETHTOOL_UINT_CHANNEL_STAT(field) \
78 EFX_ETHTOOL_STAT(field, channel, n_##field, \
79 unsigned int, efx_get_uint_stat)
81 #define EFX_ETHTOOL_UINT_TXQ_STAT(field) \
82 EFX_ETHTOOL_STAT(tx_##field, tx_queue, field, \
83 unsigned int, efx_get_uint_stat)
85 static const struct efx_ethtool_stat efx_ethtool_stats
[] = {
86 EFX_ETHTOOL_U64_MAC_STAT(tx_bytes
),
87 EFX_ETHTOOL_U64_MAC_STAT(tx_good_bytes
),
88 EFX_ETHTOOL_U64_MAC_STAT(tx_bad_bytes
),
89 EFX_ETHTOOL_U64_MAC_STAT(tx_packets
),
90 EFX_ETHTOOL_U64_MAC_STAT(tx_bad
),
91 EFX_ETHTOOL_U64_MAC_STAT(tx_pause
),
92 EFX_ETHTOOL_U64_MAC_STAT(tx_control
),
93 EFX_ETHTOOL_U64_MAC_STAT(tx_unicast
),
94 EFX_ETHTOOL_U64_MAC_STAT(tx_multicast
),
95 EFX_ETHTOOL_U64_MAC_STAT(tx_broadcast
),
96 EFX_ETHTOOL_U64_MAC_STAT(tx_lt64
),
97 EFX_ETHTOOL_U64_MAC_STAT(tx_64
),
98 EFX_ETHTOOL_U64_MAC_STAT(tx_65_to_127
),
99 EFX_ETHTOOL_U64_MAC_STAT(tx_128_to_255
),
100 EFX_ETHTOOL_U64_MAC_STAT(tx_256_to_511
),
101 EFX_ETHTOOL_U64_MAC_STAT(tx_512_to_1023
),
102 EFX_ETHTOOL_U64_MAC_STAT(tx_1024_to_15xx
),
103 EFX_ETHTOOL_U64_MAC_STAT(tx_15xx_to_jumbo
),
104 EFX_ETHTOOL_U64_MAC_STAT(tx_gtjumbo
),
105 EFX_ETHTOOL_U64_MAC_STAT(tx_collision
),
106 EFX_ETHTOOL_U64_MAC_STAT(tx_single_collision
),
107 EFX_ETHTOOL_U64_MAC_STAT(tx_multiple_collision
),
108 EFX_ETHTOOL_U64_MAC_STAT(tx_excessive_collision
),
109 EFX_ETHTOOL_U64_MAC_STAT(tx_deferred
),
110 EFX_ETHTOOL_U64_MAC_STAT(tx_late_collision
),
111 EFX_ETHTOOL_U64_MAC_STAT(tx_excessive_deferred
),
112 EFX_ETHTOOL_U64_MAC_STAT(tx_non_tcpudp
),
113 EFX_ETHTOOL_U64_MAC_STAT(tx_mac_src_error
),
114 EFX_ETHTOOL_U64_MAC_STAT(tx_ip_src_error
),
115 EFX_ETHTOOL_UINT_TXQ_STAT(tso_bursts
),
116 EFX_ETHTOOL_UINT_TXQ_STAT(tso_long_headers
),
117 EFX_ETHTOOL_UINT_TXQ_STAT(tso_packets
),
118 EFX_ETHTOOL_UINT_TXQ_STAT(pushes
),
119 EFX_ETHTOOL_U64_MAC_STAT(rx_bytes
),
120 EFX_ETHTOOL_U64_MAC_STAT(rx_good_bytes
),
121 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_bytes
),
122 EFX_ETHTOOL_U64_MAC_STAT(rx_packets
),
123 EFX_ETHTOOL_U64_MAC_STAT(rx_good
),
124 EFX_ETHTOOL_U64_MAC_STAT(rx_bad
),
125 EFX_ETHTOOL_U64_MAC_STAT(rx_pause
),
126 EFX_ETHTOOL_U64_MAC_STAT(rx_control
),
127 EFX_ETHTOOL_U64_MAC_STAT(rx_unicast
),
128 EFX_ETHTOOL_U64_MAC_STAT(rx_multicast
),
129 EFX_ETHTOOL_U64_MAC_STAT(rx_broadcast
),
130 EFX_ETHTOOL_U64_MAC_STAT(rx_lt64
),
131 EFX_ETHTOOL_U64_MAC_STAT(rx_64
),
132 EFX_ETHTOOL_U64_MAC_STAT(rx_65_to_127
),
133 EFX_ETHTOOL_U64_MAC_STAT(rx_128_to_255
),
134 EFX_ETHTOOL_U64_MAC_STAT(rx_256_to_511
),
135 EFX_ETHTOOL_U64_MAC_STAT(rx_512_to_1023
),
136 EFX_ETHTOOL_U64_MAC_STAT(rx_1024_to_15xx
),
137 EFX_ETHTOOL_U64_MAC_STAT(rx_15xx_to_jumbo
),
138 EFX_ETHTOOL_U64_MAC_STAT(rx_gtjumbo
),
139 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_lt64
),
140 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_64_to_15xx
),
141 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_15xx_to_jumbo
),
142 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_gtjumbo
),
143 EFX_ETHTOOL_U64_MAC_STAT(rx_overflow
),
144 EFX_ETHTOOL_U64_MAC_STAT(rx_missed
),
145 EFX_ETHTOOL_U64_MAC_STAT(rx_false_carrier
),
146 EFX_ETHTOOL_U64_MAC_STAT(rx_symbol_error
),
147 EFX_ETHTOOL_U64_MAC_STAT(rx_align_error
),
148 EFX_ETHTOOL_U64_MAC_STAT(rx_length_error
),
149 EFX_ETHTOOL_U64_MAC_STAT(rx_internal_error
),
150 EFX_ETHTOOL_UINT_NIC_STAT(rx_nodesc_drop_cnt
),
151 EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(rx_reset
),
152 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc
),
153 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err
),
154 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err
),
155 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch
),
156 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc
),
159 /* Number of ethtool statistics */
160 #define EFX_ETHTOOL_NUM_STATS ARRAY_SIZE(efx_ethtool_stats)
162 #define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB
164 /**************************************************************************
168 **************************************************************************
171 /* Identify device by flashing LEDs */
172 static int efx_ethtool_phys_id(struct net_device
*net_dev
,
173 enum ethtool_phys_id_state state
)
175 struct efx_nic
*efx
= netdev_priv(net_dev
);
176 enum efx_led_mode mode
= EFX_LED_DEFAULT
;
185 case ETHTOOL_ID_INACTIVE
:
186 mode
= EFX_LED_DEFAULT
;
188 case ETHTOOL_ID_ACTIVE
:
189 return 1; /* cycle on/off once per second */
192 efx
->type
->set_id_led(efx
, mode
);
196 /* This must be called with rtnl_lock held. */
197 static int efx_ethtool_get_settings(struct net_device
*net_dev
,
198 struct ethtool_cmd
*ecmd
)
200 struct efx_nic
*efx
= netdev_priv(net_dev
);
201 struct efx_link_state
*link_state
= &efx
->link_state
;
203 mutex_lock(&efx
->mac_lock
);
204 efx
->phy_op
->get_settings(efx
, ecmd
);
205 mutex_unlock(&efx
->mac_lock
);
207 /* GMAC does not support 1000Mbps HD */
208 ecmd
->supported
&= ~SUPPORTED_1000baseT_Half
;
209 /* Both MACs support pause frames (bidirectional and respond-only) */
210 ecmd
->supported
|= SUPPORTED_Pause
| SUPPORTED_Asym_Pause
;
212 if (LOOPBACK_INTERNAL(efx
)) {
213 ethtool_cmd_speed_set(ecmd
, link_state
->speed
);
214 ecmd
->duplex
= link_state
->fd
? DUPLEX_FULL
: DUPLEX_HALF
;
220 /* This must be called with rtnl_lock held. */
221 static int efx_ethtool_set_settings(struct net_device
*net_dev
,
222 struct ethtool_cmd
*ecmd
)
224 struct efx_nic
*efx
= netdev_priv(net_dev
);
227 /* GMAC does not support 1000Mbps HD */
228 if ((ethtool_cmd_speed(ecmd
) == SPEED_1000
) &&
229 (ecmd
->duplex
!= DUPLEX_FULL
)) {
230 netif_dbg(efx
, drv
, efx
->net_dev
,
231 "rejecting unsupported 1000Mbps HD setting\n");
235 mutex_lock(&efx
->mac_lock
);
236 rc
= efx
->phy_op
->set_settings(efx
, ecmd
);
237 mutex_unlock(&efx
->mac_lock
);
241 static void efx_ethtool_get_drvinfo(struct net_device
*net_dev
,
242 struct ethtool_drvinfo
*info
)
244 struct efx_nic
*efx
= netdev_priv(net_dev
);
246 strlcpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
));
247 strlcpy(info
->version
, EFX_DRIVER_VERSION
, sizeof(info
->version
));
248 if (efx_nic_rev(efx
) >= EFX_REV_SIENA_A0
)
249 efx_mcdi_print_fwver(efx
, info
->fw_version
,
250 sizeof(info
->fw_version
));
251 strlcpy(info
->bus_info
, pci_name(efx
->pci_dev
), sizeof(info
->bus_info
));
254 static int efx_ethtool_get_regs_len(struct net_device
*net_dev
)
256 return efx_nic_get_regs_len(netdev_priv(net_dev
));
259 static void efx_ethtool_get_regs(struct net_device
*net_dev
,
260 struct ethtool_regs
*regs
, void *buf
)
262 struct efx_nic
*efx
= netdev_priv(net_dev
);
264 regs
->version
= efx
->type
->revision
;
265 efx_nic_get_regs(efx
, buf
);
268 static u32
efx_ethtool_get_msglevel(struct net_device
*net_dev
)
270 struct efx_nic
*efx
= netdev_priv(net_dev
);
271 return efx
->msg_enable
;
274 static void efx_ethtool_set_msglevel(struct net_device
*net_dev
, u32 msg_enable
)
276 struct efx_nic
*efx
= netdev_priv(net_dev
);
277 efx
->msg_enable
= msg_enable
;
281 * efx_fill_test - fill in an individual self-test entry
282 * @test_index: Index of the test
283 * @strings: Ethtool strings, or %NULL
284 * @data: Ethtool test results, or %NULL
285 * @test: Pointer to test result (used only if data != %NULL)
286 * @unit_format: Unit name format (e.g. "chan\%d")
287 * @unit_id: Unit id (e.g. 0 for "chan0")
288 * @test_format: Test name format (e.g. "loopback.\%s.tx.sent")
289 * @test_id: Test id (e.g. "PHYXS" for "loopback.PHYXS.tx_sent")
291 * Fill in an individual self-test entry.
293 static void efx_fill_test(unsigned int test_index
,
294 struct ethtool_string
*strings
, u64
*data
,
295 int *test
, const char *unit_format
, int unit_id
,
296 const char *test_format
, const char *test_id
)
298 struct ethtool_string unit_str
, test_str
;
300 /* Fill data value, if applicable */
302 data
[test_index
] = *test
;
304 /* Fill string, if applicable */
306 if (strchr(unit_format
, '%'))
307 snprintf(unit_str
.name
, sizeof(unit_str
.name
),
308 unit_format
, unit_id
);
310 strcpy(unit_str
.name
, unit_format
);
311 snprintf(test_str
.name
, sizeof(test_str
.name
),
312 test_format
, test_id
);
313 snprintf(strings
[test_index
].name
,
314 sizeof(strings
[test_index
].name
),
315 "%-6s %-24s", unit_str
.name
, test_str
.name
);
319 #define EFX_CHANNEL_NAME(_channel) "chan%d", _channel->channel
320 #define EFX_TX_QUEUE_NAME(_tx_queue) "txq%d", _tx_queue->queue
321 #define EFX_RX_QUEUE_NAME(_rx_queue) "rxq%d", _rx_queue->queue
322 #define EFX_LOOPBACK_NAME(_mode, _counter) \
323 "loopback.%s." _counter, STRING_TABLE_LOOKUP(_mode, efx_loopback_mode)
326 * efx_fill_loopback_test - fill in a block of loopback self-test entries
328 * @lb_tests: Efx loopback self-test results structure
329 * @mode: Loopback test mode
330 * @test_index: Starting index of the test
331 * @strings: Ethtool strings, or %NULL
332 * @data: Ethtool test results, or %NULL
334 static int efx_fill_loopback_test(struct efx_nic
*efx
,
335 struct efx_loopback_self_tests
*lb_tests
,
336 enum efx_loopback_mode mode
,
337 unsigned int test_index
,
338 struct ethtool_string
*strings
, u64
*data
)
340 struct efx_channel
*channel
=
341 efx_get_channel(efx
, efx
->tx_channel_offset
);
342 struct efx_tx_queue
*tx_queue
;
344 efx_for_each_channel_tx_queue(tx_queue
, channel
) {
345 efx_fill_test(test_index
++, strings
, data
,
346 &lb_tests
->tx_sent
[tx_queue
->queue
],
347 EFX_TX_QUEUE_NAME(tx_queue
),
348 EFX_LOOPBACK_NAME(mode
, "tx_sent"));
349 efx_fill_test(test_index
++, strings
, data
,
350 &lb_tests
->tx_done
[tx_queue
->queue
],
351 EFX_TX_QUEUE_NAME(tx_queue
),
352 EFX_LOOPBACK_NAME(mode
, "tx_done"));
354 efx_fill_test(test_index
++, strings
, data
,
357 EFX_LOOPBACK_NAME(mode
, "rx_good"));
358 efx_fill_test(test_index
++, strings
, data
,
361 EFX_LOOPBACK_NAME(mode
, "rx_bad"));
367 * efx_ethtool_fill_self_tests - get self-test details
369 * @tests: Efx self-test results structure, or %NULL
370 * @strings: Ethtool strings, or %NULL
371 * @data: Ethtool test results, or %NULL
373 static int efx_ethtool_fill_self_tests(struct efx_nic
*efx
,
374 struct efx_self_tests
*tests
,
375 struct ethtool_string
*strings
,
378 struct efx_channel
*channel
;
379 unsigned int n
= 0, i
;
380 enum efx_loopback_mode mode
;
382 efx_fill_test(n
++, strings
, data
, &tests
->phy_alive
,
383 "phy", 0, "alive", NULL
);
384 efx_fill_test(n
++, strings
, data
, &tests
->nvram
,
385 "core", 0, "nvram", NULL
);
386 efx_fill_test(n
++, strings
, data
, &tests
->interrupt
,
387 "core", 0, "interrupt", NULL
);
390 efx_for_each_channel(channel
, efx
) {
391 efx_fill_test(n
++, strings
, data
,
392 &tests
->eventq_dma
[channel
->channel
],
393 EFX_CHANNEL_NAME(channel
),
395 efx_fill_test(n
++, strings
, data
,
396 &tests
->eventq_int
[channel
->channel
],
397 EFX_CHANNEL_NAME(channel
),
401 efx_fill_test(n
++, strings
, data
, &tests
->registers
,
402 "core", 0, "registers", NULL
);
404 if (efx
->phy_op
->run_tests
!= NULL
) {
405 EFX_BUG_ON_PARANOID(efx
->phy_op
->test_name
== NULL
);
407 for (i
= 0; true; ++i
) {
410 EFX_BUG_ON_PARANOID(i
>= EFX_MAX_PHY_TESTS
);
411 name
= efx
->phy_op
->test_name(efx
, i
);
415 efx_fill_test(n
++, strings
, data
, &tests
->phy_ext
[i
],
416 "phy", 0, name
, NULL
);
421 for (mode
= LOOPBACK_NONE
; mode
<= LOOPBACK_TEST_MAX
; mode
++) {
422 if (!(efx
->loopback_modes
& (1 << mode
)))
424 n
= efx_fill_loopback_test(efx
,
425 &tests
->loopback
[mode
], mode
, n
,
432 static int efx_ethtool_get_sset_count(struct net_device
*net_dev
,
435 switch (string_set
) {
437 return EFX_ETHTOOL_NUM_STATS
;
439 return efx_ethtool_fill_self_tests(netdev_priv(net_dev
),
446 static void efx_ethtool_get_strings(struct net_device
*net_dev
,
447 u32 string_set
, u8
*strings
)
449 struct efx_nic
*efx
= netdev_priv(net_dev
);
450 struct ethtool_string
*ethtool_strings
=
451 (struct ethtool_string
*)strings
;
454 switch (string_set
) {
456 for (i
= 0; i
< EFX_ETHTOOL_NUM_STATS
; i
++)
457 strlcpy(ethtool_strings
[i
].name
,
458 efx_ethtool_stats
[i
].name
,
459 sizeof(ethtool_strings
[i
].name
));
462 efx_ethtool_fill_self_tests(efx
, NULL
,
463 ethtool_strings
, NULL
);
466 /* No other string sets */
471 static void efx_ethtool_get_stats(struct net_device
*net_dev
,
472 struct ethtool_stats
*stats
,
475 struct efx_nic
*efx
= netdev_priv(net_dev
);
476 struct efx_mac_stats
*mac_stats
= &efx
->mac_stats
;
477 const struct efx_ethtool_stat
*stat
;
478 struct efx_channel
*channel
;
479 struct efx_tx_queue
*tx_queue
;
482 EFX_BUG_ON_PARANOID(stats
->n_stats
!= EFX_ETHTOOL_NUM_STATS
);
484 spin_lock_bh(&efx
->stats_lock
);
486 /* Update MAC and NIC statistics */
487 efx
->type
->update_stats(efx
);
489 /* Fill detailed statistics buffer */
490 for (i
= 0; i
< EFX_ETHTOOL_NUM_STATS
; i
++) {
491 stat
= &efx_ethtool_stats
[i
];
492 switch (stat
->source
) {
493 case EFX_ETHTOOL_STAT_SOURCE_mac_stats
:
494 data
[i
] = stat
->get_stat((void *)mac_stats
+
497 case EFX_ETHTOOL_STAT_SOURCE_nic
:
498 data
[i
] = stat
->get_stat((void *)efx
+ stat
->offset
);
500 case EFX_ETHTOOL_STAT_SOURCE_channel
:
502 efx_for_each_channel(channel
, efx
)
503 data
[i
] += stat
->get_stat((void *)channel
+
506 case EFX_ETHTOOL_STAT_SOURCE_tx_queue
:
508 efx_for_each_channel(channel
, efx
) {
509 efx_for_each_channel_tx_queue(tx_queue
, channel
)
511 stat
->get_stat((void *)tx_queue
518 spin_unlock_bh(&efx
->stats_lock
);
521 static void efx_ethtool_self_test(struct net_device
*net_dev
,
522 struct ethtool_test
*test
, u64
*data
)
524 struct efx_nic
*efx
= netdev_priv(net_dev
);
525 struct efx_self_tests
*efx_tests
;
529 efx_tests
= kzalloc(sizeof(*efx_tests
), GFP_KERNEL
);
533 if (efx
->state
!= STATE_READY
) {
538 netif_info(efx
, drv
, efx
->net_dev
, "starting %sline testing\n",
539 (test
->flags
& ETH_TEST_FL_OFFLINE
) ? "off" : "on");
541 /* We need rx buffers and interrupts. */
542 already_up
= (efx
->net_dev
->flags
& IFF_UP
);
544 rc
= dev_open(efx
->net_dev
);
546 netif_err(efx
, drv
, efx
->net_dev
,
547 "failed opening device.\n");
552 rc
= efx_selftest(efx
, efx_tests
, test
->flags
);
555 dev_close(efx
->net_dev
);
557 netif_info(efx
, drv
, efx
->net_dev
, "%s %sline self-tests\n",
558 rc
== 0 ? "passed" : "failed",
559 (test
->flags
& ETH_TEST_FL_OFFLINE
) ? "off" : "on");
562 /* Fill ethtool results structures */
563 efx_ethtool_fill_self_tests(efx
, efx_tests
, NULL
, data
);
567 test
->flags
|= ETH_TEST_FL_FAILED
;
570 /* Restart autonegotiation */
571 static int efx_ethtool_nway_reset(struct net_device
*net_dev
)
573 struct efx_nic
*efx
= netdev_priv(net_dev
);
575 return mdio45_nway_restart(&efx
->mdio
);
579 * Each channel has a single IRQ and moderation timer, started by any
580 * completion (or other event). Unless the module parameter
581 * separate_tx_channels is set, IRQs and moderation are therefore
582 * shared between RX and TX completions. In this case, when RX IRQ
583 * moderation is explicitly changed then TX IRQ moderation is
584 * automatically changed too, but otherwise we fail if the two values
585 * are requested to be different.
587 * The hardware does not support a limit on the number of completions
588 * before an IRQ, so we do not use the max_frames fields. We should
589 * report and require that max_frames == (usecs != 0), but this would
590 * invalidate existing user documentation.
592 * The hardware does not have distinct settings for interrupt
593 * moderation while the previous IRQ is being handled, so we should
594 * not use the 'irq' fields. However, an earlier developer
595 * misunderstood the meaning of the 'irq' fields and the driver did
596 * not support the standard fields. To avoid invalidating existing
597 * user documentation, we report and accept changes through either the
598 * standard or 'irq' fields. If both are changed at the same time, we
599 * prefer the standard field.
601 * We implement adaptive IRQ moderation, but use a different algorithm
602 * from that assumed in the definition of struct ethtool_coalesce.
603 * Therefore we do not use any of the adaptive moderation parameters
607 static int efx_ethtool_get_coalesce(struct net_device
*net_dev
,
608 struct ethtool_coalesce
*coalesce
)
610 struct efx_nic
*efx
= netdev_priv(net_dev
);
611 unsigned int tx_usecs
, rx_usecs
;
614 efx_get_irq_moderation(efx
, &tx_usecs
, &rx_usecs
, &rx_adaptive
);
616 coalesce
->tx_coalesce_usecs
= tx_usecs
;
617 coalesce
->tx_coalesce_usecs_irq
= tx_usecs
;
618 coalesce
->rx_coalesce_usecs
= rx_usecs
;
619 coalesce
->rx_coalesce_usecs_irq
= rx_usecs
;
620 coalesce
->use_adaptive_rx_coalesce
= rx_adaptive
;
625 static int efx_ethtool_set_coalesce(struct net_device
*net_dev
,
626 struct ethtool_coalesce
*coalesce
)
628 struct efx_nic
*efx
= netdev_priv(net_dev
);
629 struct efx_channel
*channel
;
630 unsigned int tx_usecs
, rx_usecs
;
631 bool adaptive
, rx_may_override_tx
;
634 if (coalesce
->use_adaptive_tx_coalesce
)
637 efx_get_irq_moderation(efx
, &tx_usecs
, &rx_usecs
, &adaptive
);
639 if (coalesce
->rx_coalesce_usecs
!= rx_usecs
)
640 rx_usecs
= coalesce
->rx_coalesce_usecs
;
642 rx_usecs
= coalesce
->rx_coalesce_usecs_irq
;
644 adaptive
= coalesce
->use_adaptive_rx_coalesce
;
646 /* If channels are shared, TX IRQ moderation can be quietly
647 * overridden unless it is changed from its old value.
649 rx_may_override_tx
= (coalesce
->tx_coalesce_usecs
== tx_usecs
&&
650 coalesce
->tx_coalesce_usecs_irq
== tx_usecs
);
651 if (coalesce
->tx_coalesce_usecs
!= tx_usecs
)
652 tx_usecs
= coalesce
->tx_coalesce_usecs
;
654 tx_usecs
= coalesce
->tx_coalesce_usecs_irq
;
656 rc
= efx_init_irq_moderation(efx
, tx_usecs
, rx_usecs
, adaptive
,
661 efx_for_each_channel(channel
, efx
)
662 efx
->type
->push_irq_moderation(channel
);
667 static void efx_ethtool_get_ringparam(struct net_device
*net_dev
,
668 struct ethtool_ringparam
*ring
)
670 struct efx_nic
*efx
= netdev_priv(net_dev
);
672 ring
->rx_max_pending
= EFX_MAX_DMAQ_SIZE
;
673 ring
->tx_max_pending
= EFX_MAX_DMAQ_SIZE
;
674 ring
->rx_pending
= efx
->rxq_entries
;
675 ring
->tx_pending
= efx
->txq_entries
;
678 static int efx_ethtool_set_ringparam(struct net_device
*net_dev
,
679 struct ethtool_ringparam
*ring
)
681 struct efx_nic
*efx
= netdev_priv(net_dev
);
684 if (ring
->rx_mini_pending
|| ring
->rx_jumbo_pending
||
685 ring
->rx_pending
> EFX_MAX_DMAQ_SIZE
||
686 ring
->tx_pending
> EFX_MAX_DMAQ_SIZE
)
689 if (ring
->rx_pending
< EFX_RXQ_MIN_ENT
) {
690 netif_err(efx
, drv
, efx
->net_dev
,
691 "RX queues cannot be smaller than %u\n",
696 txq_entries
= max(ring
->tx_pending
, EFX_TXQ_MIN_ENT(efx
));
697 if (txq_entries
!= ring
->tx_pending
)
698 netif_warn(efx
, drv
, efx
->net_dev
,
699 "increasing TX queue size to minimum of %u\n",
702 return efx_realloc_channels(efx
, ring
->rx_pending
, txq_entries
);
705 static int efx_ethtool_set_pauseparam(struct net_device
*net_dev
,
706 struct ethtool_pauseparam
*pause
)
708 struct efx_nic
*efx
= netdev_priv(net_dev
);
709 u8 wanted_fc
, old_fc
;
714 mutex_lock(&efx
->mac_lock
);
716 wanted_fc
= ((pause
->rx_pause
? EFX_FC_RX
: 0) |
717 (pause
->tx_pause
? EFX_FC_TX
: 0) |
718 (pause
->autoneg
? EFX_FC_AUTO
: 0));
720 if ((wanted_fc
& EFX_FC_TX
) && !(wanted_fc
& EFX_FC_RX
)) {
721 netif_dbg(efx
, drv
, efx
->net_dev
,
722 "Flow control unsupported: tx ON rx OFF\n");
727 if ((wanted_fc
& EFX_FC_AUTO
) && !efx
->link_advertising
) {
728 netif_dbg(efx
, drv
, efx
->net_dev
,
729 "Autonegotiation is disabled\n");
734 /* TX flow control may automatically turn itself off if the
735 * link partner (intermittently) stops responding to pause
736 * frames. There isn't any indication that this has happened,
737 * so the best we do is leave it up to the user to spot this
738 * and fix it be cycling transmit flow control on this end. */
739 reset
= (wanted_fc
& EFX_FC_TX
) && !(efx
->wanted_fc
& EFX_FC_TX
);
740 if (EFX_WORKAROUND_11482(efx
) && reset
) {
741 if (efx_nic_rev(efx
) == EFX_REV_FALCON_B0
) {
742 /* Recover by resetting the EM block */
743 falcon_stop_nic_stats(efx
);
744 falcon_drain_tx_fifo(efx
);
745 falcon_reconfigure_xmac(efx
);
746 falcon_start_nic_stats(efx
);
748 /* Schedule a reset to recover */
749 efx_schedule_reset(efx
, RESET_TYPE_INVISIBLE
);
753 old_adv
= efx
->link_advertising
;
754 old_fc
= efx
->wanted_fc
;
755 efx_link_set_wanted_fc(efx
, wanted_fc
);
756 if (efx
->link_advertising
!= old_adv
||
757 (efx
->wanted_fc
^ old_fc
) & EFX_FC_AUTO
) {
758 rc
= efx
->phy_op
->reconfigure(efx
);
760 netif_err(efx
, drv
, efx
->net_dev
,
761 "Unable to advertise requested flow "
762 "control setting\n");
767 /* Reconfigure the MAC. The PHY *may* generate a link state change event
768 * if the user just changed the advertised capabilities, but there's no
769 * harm doing this twice */
770 efx
->type
->reconfigure_mac(efx
);
773 mutex_unlock(&efx
->mac_lock
);
778 static void efx_ethtool_get_pauseparam(struct net_device
*net_dev
,
779 struct ethtool_pauseparam
*pause
)
781 struct efx_nic
*efx
= netdev_priv(net_dev
);
783 pause
->rx_pause
= !!(efx
->wanted_fc
& EFX_FC_RX
);
784 pause
->tx_pause
= !!(efx
->wanted_fc
& EFX_FC_TX
);
785 pause
->autoneg
= !!(efx
->wanted_fc
& EFX_FC_AUTO
);
789 static void efx_ethtool_get_wol(struct net_device
*net_dev
,
790 struct ethtool_wolinfo
*wol
)
792 struct efx_nic
*efx
= netdev_priv(net_dev
);
793 return efx
->type
->get_wol(efx
, wol
);
797 static int efx_ethtool_set_wol(struct net_device
*net_dev
,
798 struct ethtool_wolinfo
*wol
)
800 struct efx_nic
*efx
= netdev_priv(net_dev
);
801 return efx
->type
->set_wol(efx
, wol
->wolopts
);
804 static int efx_ethtool_reset(struct net_device
*net_dev
, u32
*flags
)
806 struct efx_nic
*efx
= netdev_priv(net_dev
);
809 rc
= efx
->type
->map_reset_flags(flags
);
813 return efx_reset(efx
, rc
);
816 /* MAC address mask including only MC flag */
817 static const u8 mac_addr_mc_mask
[ETH_ALEN
] = { 0x01, 0, 0, 0, 0, 0 };
819 #define IP4_ADDR_FULL_MASK ((__force __be32)~0)
820 #define PORT_FULL_MASK ((__force __be16)~0)
822 static int efx_ethtool_get_class_rule(struct efx_nic
*efx
,
823 struct ethtool_rx_flow_spec
*rule
)
825 struct ethtool_tcpip4_spec
*ip_entry
= &rule
->h_u
.tcp_ip4_spec
;
826 struct ethtool_tcpip4_spec
*ip_mask
= &rule
->m_u
.tcp_ip4_spec
;
827 struct ethhdr
*mac_entry
= &rule
->h_u
.ether_spec
;
828 struct ethhdr
*mac_mask
= &rule
->m_u
.ether_spec
;
829 struct efx_filter_spec spec
;
834 rc
= efx_filter_get_filter_safe(efx
, EFX_FILTER_PRI_MANUAL
,
835 rule
->location
, &spec
);
839 if (spec
.dmaq_id
== 0xfff)
840 rule
->ring_cookie
= RX_CLS_FLOW_DISC
;
842 rule
->ring_cookie
= spec
.dmaq_id
;
844 if (spec
.type
== EFX_FILTER_MC_DEF
|| spec
.type
== EFX_FILTER_UC_DEF
) {
845 rule
->flow_type
= ETHER_FLOW
;
846 memcpy(mac_mask
->h_dest
, mac_addr_mc_mask
, ETH_ALEN
);
847 if (spec
.type
== EFX_FILTER_MC_DEF
)
848 memcpy(mac_entry
->h_dest
, mac_addr_mc_mask
, ETH_ALEN
);
852 rc
= efx_filter_get_eth_local(&spec
, &vid
, mac_entry
->h_dest
);
854 rule
->flow_type
= ETHER_FLOW
;
855 memset(mac_mask
->h_dest
, ~0, ETH_ALEN
);
856 if (vid
!= EFX_FILTER_VID_UNSPEC
) {
857 rule
->flow_type
|= FLOW_EXT
;
858 rule
->h_ext
.vlan_tci
= htons(vid
);
859 rule
->m_ext
.vlan_tci
= htons(0xfff);
864 rc
= efx_filter_get_ipv4_local(&spec
, &proto
,
865 &ip_entry
->ip4dst
, &ip_entry
->pdst
);
867 rc
= efx_filter_get_ipv4_full(
868 &spec
, &proto
, &ip_entry
->ip4dst
, &ip_entry
->pdst
,
869 &ip_entry
->ip4src
, &ip_entry
->psrc
);
870 EFX_WARN_ON_PARANOID(rc
);
871 ip_mask
->ip4src
= IP4_ADDR_FULL_MASK
;
872 ip_mask
->psrc
= PORT_FULL_MASK
;
874 rule
->flow_type
= (proto
== IPPROTO_TCP
) ? TCP_V4_FLOW
: UDP_V4_FLOW
;
875 ip_mask
->ip4dst
= IP4_ADDR_FULL_MASK
;
876 ip_mask
->pdst
= PORT_FULL_MASK
;
881 efx_ethtool_get_rxnfc(struct net_device
*net_dev
,
882 struct ethtool_rxnfc
*info
, u32
*rule_locs
)
884 struct efx_nic
*efx
= netdev_priv(net_dev
);
887 case ETHTOOL_GRXRINGS
:
888 info
->data
= efx
->n_rx_channels
;
891 case ETHTOOL_GRXFH
: {
892 unsigned min_revision
= 0;
895 switch (info
->flow_type
) {
897 info
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
903 info
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
904 min_revision
= EFX_REV_FALCON_B0
;
907 info
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
913 info
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
914 min_revision
= EFX_REV_SIENA_A0
;
919 if (efx_nic_rev(efx
) < min_revision
)
924 case ETHTOOL_GRXCLSRLCNT
:
925 info
->data
= efx_filter_get_rx_id_limit(efx
);
928 info
->data
|= RX_CLS_LOC_SPECIAL
;
930 efx_filter_count_rx_used(efx
, EFX_FILTER_PRI_MANUAL
);
933 case ETHTOOL_GRXCLSRULE
:
934 if (efx_filter_get_rx_id_limit(efx
) == 0)
936 return efx_ethtool_get_class_rule(efx
, &info
->fs
);
938 case ETHTOOL_GRXCLSRLALL
: {
940 info
->data
= efx_filter_get_rx_id_limit(efx
);
943 rc
= efx_filter_get_rx_ids(efx
, EFX_FILTER_PRI_MANUAL
,
944 rule_locs
, info
->rule_cnt
);
956 static int efx_ethtool_set_class_rule(struct efx_nic
*efx
,
957 struct ethtool_rx_flow_spec
*rule
)
959 struct ethtool_tcpip4_spec
*ip_entry
= &rule
->h_u
.tcp_ip4_spec
;
960 struct ethtool_tcpip4_spec
*ip_mask
= &rule
->m_u
.tcp_ip4_spec
;
961 struct ethhdr
*mac_entry
= &rule
->h_u
.ether_spec
;
962 struct ethhdr
*mac_mask
= &rule
->m_u
.ether_spec
;
963 struct efx_filter_spec spec
;
966 /* Check that user wants us to choose the location */
967 if (rule
->location
!= RX_CLS_LOC_ANY
)
970 /* Range-check ring_cookie */
971 if (rule
->ring_cookie
>= efx
->n_rx_channels
&&
972 rule
->ring_cookie
!= RX_CLS_FLOW_DISC
)
975 /* Check for unsupported extensions */
976 if ((rule
->flow_type
& FLOW_EXT
) &&
977 (rule
->m_ext
.vlan_etype
|| rule
->m_ext
.data
[0] ||
978 rule
->m_ext
.data
[1]))
981 efx_filter_init_rx(&spec
, EFX_FILTER_PRI_MANUAL
, 0,
982 (rule
->ring_cookie
== RX_CLS_FLOW_DISC
) ?
983 0xfff : rule
->ring_cookie
);
985 switch (rule
->flow_type
) {
988 u8 proto
= (rule
->flow_type
== TCP_V4_FLOW
?
989 IPPROTO_TCP
: IPPROTO_UDP
);
991 /* Must match all of destination, */
992 if (!(ip_mask
->ip4dst
== IP4_ADDR_FULL_MASK
&&
993 ip_mask
->pdst
== PORT_FULL_MASK
))
995 /* all or none of source, */
996 if ((ip_mask
->ip4src
|| ip_mask
->psrc
) &&
997 !(ip_mask
->ip4src
== IP4_ADDR_FULL_MASK
&&
998 ip_mask
->psrc
== PORT_FULL_MASK
))
1000 /* and nothing else */
1001 if (ip_mask
->tos
|| rule
->m_ext
.vlan_tci
)
1004 if (ip_mask
->ip4src
)
1005 rc
= efx_filter_set_ipv4_full(&spec
, proto
,
1011 rc
= efx_filter_set_ipv4_local(&spec
, proto
,
1019 case ETHER_FLOW
| FLOW_EXT
:
1021 u16 vlan_tag_mask
= (rule
->flow_type
& FLOW_EXT
?
1022 ntohs(rule
->m_ext
.vlan_tci
) : 0);
1024 /* Must not match on source address or Ethertype */
1025 if (!is_zero_ether_addr(mac_mask
->h_source
) ||
1029 /* Is it a default UC or MC filter? */
1030 if (ether_addr_equal(mac_mask
->h_dest
, mac_addr_mc_mask
) &&
1031 vlan_tag_mask
== 0) {
1032 if (is_multicast_ether_addr(mac_entry
->h_dest
))
1033 rc
= efx_filter_set_mc_def(&spec
);
1035 rc
= efx_filter_set_uc_def(&spec
);
1037 /* Otherwise, it must match all of destination and all
1040 else if (is_broadcast_ether_addr(mac_mask
->h_dest
) &&
1041 (vlan_tag_mask
== 0xfff || vlan_tag_mask
== 0)) {
1042 rc
= efx_filter_set_eth_local(
1045 ntohs(rule
->h_ext
.vlan_tci
) : EFX_FILTER_VID_UNSPEC
,
1059 rc
= efx_filter_insert_filter(efx
, &spec
, true);
1063 rule
->location
= rc
;
1067 static int efx_ethtool_set_rxnfc(struct net_device
*net_dev
,
1068 struct ethtool_rxnfc
*info
)
1070 struct efx_nic
*efx
= netdev_priv(net_dev
);
1072 if (efx_filter_get_rx_id_limit(efx
) == 0)
1075 switch (info
->cmd
) {
1076 case ETHTOOL_SRXCLSRLINS
:
1077 return efx_ethtool_set_class_rule(efx
, &info
->fs
);
1079 case ETHTOOL_SRXCLSRLDEL
:
1080 return efx_filter_remove_id_safe(efx
, EFX_FILTER_PRI_MANUAL
,
1088 static u32
efx_ethtool_get_rxfh_indir_size(struct net_device
*net_dev
)
1090 struct efx_nic
*efx
= netdev_priv(net_dev
);
1092 return ((efx_nic_rev(efx
) < EFX_REV_FALCON_B0
||
1093 efx
->n_rx_channels
== 1) ?
1094 0 : ARRAY_SIZE(efx
->rx_indir_table
));
1097 static int efx_ethtool_get_rxfh_indir(struct net_device
*net_dev
, u32
*indir
)
1099 struct efx_nic
*efx
= netdev_priv(net_dev
);
1101 memcpy(indir
, efx
->rx_indir_table
, sizeof(efx
->rx_indir_table
));
1105 static int efx_ethtool_set_rxfh_indir(struct net_device
*net_dev
,
1108 struct efx_nic
*efx
= netdev_priv(net_dev
);
1110 memcpy(efx
->rx_indir_table
, indir
, sizeof(efx
->rx_indir_table
));
1111 efx_nic_push_rx_indir_table(efx
);
1115 static int efx_ethtool_get_module_eeprom(struct net_device
*net_dev
,
1116 struct ethtool_eeprom
*ee
,
1119 struct efx_nic
*efx
= netdev_priv(net_dev
);
1122 if (!efx
->phy_op
|| !efx
->phy_op
->get_module_eeprom
)
1125 mutex_lock(&efx
->mac_lock
);
1126 ret
= efx
->phy_op
->get_module_eeprom(efx
, ee
, data
);
1127 mutex_unlock(&efx
->mac_lock
);
1132 static int efx_ethtool_get_module_info(struct net_device
*net_dev
,
1133 struct ethtool_modinfo
*modinfo
)
1135 struct efx_nic
*efx
= netdev_priv(net_dev
);
1138 if (!efx
->phy_op
|| !efx
->phy_op
->get_module_info
)
1141 mutex_lock(&efx
->mac_lock
);
1142 ret
= efx
->phy_op
->get_module_info(efx
, modinfo
);
1143 mutex_unlock(&efx
->mac_lock
);
1148 const struct ethtool_ops efx_ethtool_ops
= {
1149 .get_settings
= efx_ethtool_get_settings
,
1150 .set_settings
= efx_ethtool_set_settings
,
1151 .get_drvinfo
= efx_ethtool_get_drvinfo
,
1152 .get_regs_len
= efx_ethtool_get_regs_len
,
1153 .get_regs
= efx_ethtool_get_regs
,
1154 .get_msglevel
= efx_ethtool_get_msglevel
,
1155 .set_msglevel
= efx_ethtool_set_msglevel
,
1156 .nway_reset
= efx_ethtool_nway_reset
,
1157 .get_link
= ethtool_op_get_link
,
1158 .get_coalesce
= efx_ethtool_get_coalesce
,
1159 .set_coalesce
= efx_ethtool_set_coalesce
,
1160 .get_ringparam
= efx_ethtool_get_ringparam
,
1161 .set_ringparam
= efx_ethtool_set_ringparam
,
1162 .get_pauseparam
= efx_ethtool_get_pauseparam
,
1163 .set_pauseparam
= efx_ethtool_set_pauseparam
,
1164 .get_sset_count
= efx_ethtool_get_sset_count
,
1165 .self_test
= efx_ethtool_self_test
,
1166 .get_strings
= efx_ethtool_get_strings
,
1167 .set_phys_id
= efx_ethtool_phys_id
,
1168 .get_ethtool_stats
= efx_ethtool_get_stats
,
1169 .get_wol
= efx_ethtool_get_wol
,
1170 .set_wol
= efx_ethtool_set_wol
,
1171 .reset
= efx_ethtool_reset
,
1172 .get_rxnfc
= efx_ethtool_get_rxnfc
,
1173 .set_rxnfc
= efx_ethtool_set_rxnfc
,
1174 .get_rxfh_indir_size
= efx_ethtool_get_rxfh_indir_size
,
1175 .get_rxfh_indir
= efx_ethtool_get_rxfh_indir
,
1176 .set_rxfh_indir
= efx_ethtool_set_rxfh_indir
,
1177 .get_ts_info
= efx_ptp_get_ts_info
,
1178 .get_module_info
= efx_ethtool_get_module_info
,
1179 .get_module_eeprom
= efx_ethtool_get_module_eeprom
,