1 /****************************************************************************
2 * Driver for Solarflare Solarstorm network controllers and boards
3 * Copyright 2005-2006 Fen Systems Ltd.
4 * Copyright 2006-2009 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>
14 #include "net_driver.h"
15 #include "workarounds.h"
23 struct ethtool_string
{
24 char name
[ETH_GSTRING_LEN
];
27 struct efx_ethtool_stat
{
30 EFX_ETHTOOL_STAT_SOURCE_mac_stats
,
31 EFX_ETHTOOL_STAT_SOURCE_nic
,
32 EFX_ETHTOOL_STAT_SOURCE_channel
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_ulong_stat(void *field
)
57 return *(unsigned long *)field
;
60 static u64
efx_get_u64_stat(void *field
)
62 return *(u64
*) field
;
65 static u64
efx_get_atomic_stat(void *field
)
67 return atomic_read((atomic_t
*) field
);
70 #define EFX_ETHTOOL_ULONG_MAC_STAT(field) \
71 EFX_ETHTOOL_STAT(field, mac_stats, field, \
72 unsigned long, efx_get_ulong_stat)
74 #define EFX_ETHTOOL_U64_MAC_STAT(field) \
75 EFX_ETHTOOL_STAT(field, mac_stats, field, \
76 u64, efx_get_u64_stat)
78 #define EFX_ETHTOOL_UINT_NIC_STAT(name) \
79 EFX_ETHTOOL_STAT(name, nic, n_##name, \
80 unsigned int, efx_get_uint_stat)
82 #define EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(field) \
83 EFX_ETHTOOL_STAT(field, nic, field, \
84 atomic_t, efx_get_atomic_stat)
86 #define EFX_ETHTOOL_UINT_CHANNEL_STAT(field) \
87 EFX_ETHTOOL_STAT(field, channel, n_##field, \
88 unsigned int, efx_get_uint_stat)
90 static struct efx_ethtool_stat efx_ethtool_stats
[] = {
91 EFX_ETHTOOL_U64_MAC_STAT(tx_bytes
),
92 EFX_ETHTOOL_U64_MAC_STAT(tx_good_bytes
),
93 EFX_ETHTOOL_U64_MAC_STAT(tx_bad_bytes
),
94 EFX_ETHTOOL_ULONG_MAC_STAT(tx_packets
),
95 EFX_ETHTOOL_ULONG_MAC_STAT(tx_bad
),
96 EFX_ETHTOOL_ULONG_MAC_STAT(tx_pause
),
97 EFX_ETHTOOL_ULONG_MAC_STAT(tx_control
),
98 EFX_ETHTOOL_ULONG_MAC_STAT(tx_unicast
),
99 EFX_ETHTOOL_ULONG_MAC_STAT(tx_multicast
),
100 EFX_ETHTOOL_ULONG_MAC_STAT(tx_broadcast
),
101 EFX_ETHTOOL_ULONG_MAC_STAT(tx_lt64
),
102 EFX_ETHTOOL_ULONG_MAC_STAT(tx_64
),
103 EFX_ETHTOOL_ULONG_MAC_STAT(tx_65_to_127
),
104 EFX_ETHTOOL_ULONG_MAC_STAT(tx_128_to_255
),
105 EFX_ETHTOOL_ULONG_MAC_STAT(tx_256_to_511
),
106 EFX_ETHTOOL_ULONG_MAC_STAT(tx_512_to_1023
),
107 EFX_ETHTOOL_ULONG_MAC_STAT(tx_1024_to_15xx
),
108 EFX_ETHTOOL_ULONG_MAC_STAT(tx_15xx_to_jumbo
),
109 EFX_ETHTOOL_ULONG_MAC_STAT(tx_gtjumbo
),
110 EFX_ETHTOOL_ULONG_MAC_STAT(tx_collision
),
111 EFX_ETHTOOL_ULONG_MAC_STAT(tx_single_collision
),
112 EFX_ETHTOOL_ULONG_MAC_STAT(tx_multiple_collision
),
113 EFX_ETHTOOL_ULONG_MAC_STAT(tx_excessive_collision
),
114 EFX_ETHTOOL_ULONG_MAC_STAT(tx_deferred
),
115 EFX_ETHTOOL_ULONG_MAC_STAT(tx_late_collision
),
116 EFX_ETHTOOL_ULONG_MAC_STAT(tx_excessive_deferred
),
117 EFX_ETHTOOL_ULONG_MAC_STAT(tx_non_tcpudp
),
118 EFX_ETHTOOL_ULONG_MAC_STAT(tx_mac_src_error
),
119 EFX_ETHTOOL_ULONG_MAC_STAT(tx_ip_src_error
),
120 EFX_ETHTOOL_U64_MAC_STAT(rx_bytes
),
121 EFX_ETHTOOL_U64_MAC_STAT(rx_good_bytes
),
122 EFX_ETHTOOL_U64_MAC_STAT(rx_bad_bytes
),
123 EFX_ETHTOOL_ULONG_MAC_STAT(rx_packets
),
124 EFX_ETHTOOL_ULONG_MAC_STAT(rx_good
),
125 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad
),
126 EFX_ETHTOOL_ULONG_MAC_STAT(rx_pause
),
127 EFX_ETHTOOL_ULONG_MAC_STAT(rx_control
),
128 EFX_ETHTOOL_ULONG_MAC_STAT(rx_unicast
),
129 EFX_ETHTOOL_ULONG_MAC_STAT(rx_multicast
),
130 EFX_ETHTOOL_ULONG_MAC_STAT(rx_broadcast
),
131 EFX_ETHTOOL_ULONG_MAC_STAT(rx_lt64
),
132 EFX_ETHTOOL_ULONG_MAC_STAT(rx_64
),
133 EFX_ETHTOOL_ULONG_MAC_STAT(rx_65_to_127
),
134 EFX_ETHTOOL_ULONG_MAC_STAT(rx_128_to_255
),
135 EFX_ETHTOOL_ULONG_MAC_STAT(rx_256_to_511
),
136 EFX_ETHTOOL_ULONG_MAC_STAT(rx_512_to_1023
),
137 EFX_ETHTOOL_ULONG_MAC_STAT(rx_1024_to_15xx
),
138 EFX_ETHTOOL_ULONG_MAC_STAT(rx_15xx_to_jumbo
),
139 EFX_ETHTOOL_ULONG_MAC_STAT(rx_gtjumbo
),
140 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_lt64
),
141 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_64_to_15xx
),
142 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_15xx_to_jumbo
),
143 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_gtjumbo
),
144 EFX_ETHTOOL_ULONG_MAC_STAT(rx_overflow
),
145 EFX_ETHTOOL_ULONG_MAC_STAT(rx_missed
),
146 EFX_ETHTOOL_ULONG_MAC_STAT(rx_false_carrier
),
147 EFX_ETHTOOL_ULONG_MAC_STAT(rx_symbol_error
),
148 EFX_ETHTOOL_ULONG_MAC_STAT(rx_align_error
),
149 EFX_ETHTOOL_ULONG_MAC_STAT(rx_length_error
),
150 EFX_ETHTOOL_ULONG_MAC_STAT(rx_internal_error
),
151 EFX_ETHTOOL_UINT_NIC_STAT(rx_nodesc_drop_cnt
),
152 EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(rx_reset
),
153 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc
),
154 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err
),
155 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err
),
156 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch
),
157 EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc
),
160 /* Number of ethtool statistics */
161 #define EFX_ETHTOOL_NUM_STATS ARRAY_SIZE(efx_ethtool_stats)
163 #define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB
165 /**************************************************************************
169 **************************************************************************
172 /* Identify device by flashing LEDs */
173 static int efx_ethtool_phys_id(struct net_device
*net_dev
, u32 count
)
175 struct efx_nic
*efx
= netdev_priv(net_dev
);
178 efx
->type
->set_id_led(efx
, EFX_LED_ON
);
179 schedule_timeout_interruptible(HZ
/ 2);
181 efx
->type
->set_id_led(efx
, EFX_LED_OFF
);
182 schedule_timeout_interruptible(HZ
/ 2);
183 } while (!signal_pending(current
) && --count
!= 0);
185 efx
->type
->set_id_led(efx
, EFX_LED_DEFAULT
);
189 /* This must be called with rtnl_lock held. */
190 static int efx_ethtool_get_settings(struct net_device
*net_dev
,
191 struct ethtool_cmd
*ecmd
)
193 struct efx_nic
*efx
= netdev_priv(net_dev
);
194 struct efx_link_state
*link_state
= &efx
->link_state
;
196 mutex_lock(&efx
->mac_lock
);
197 efx
->phy_op
->get_settings(efx
, ecmd
);
198 mutex_unlock(&efx
->mac_lock
);
200 /* GMAC does not support 1000Mbps HD */
201 ecmd
->supported
&= ~SUPPORTED_1000baseT_Half
;
202 /* Both MACs support pause frames (bidirectional and respond-only) */
203 ecmd
->supported
|= SUPPORTED_Pause
| SUPPORTED_Asym_Pause
;
205 if (LOOPBACK_INTERNAL(efx
)) {
206 ecmd
->speed
= link_state
->speed
;
207 ecmd
->duplex
= link_state
->fd
? DUPLEX_FULL
: DUPLEX_HALF
;
213 /* This must be called with rtnl_lock held. */
214 static int efx_ethtool_set_settings(struct net_device
*net_dev
,
215 struct ethtool_cmd
*ecmd
)
217 struct efx_nic
*efx
= netdev_priv(net_dev
);
220 /* GMAC does not support 1000Mbps HD */
221 if (ecmd
->speed
== SPEED_1000
&& ecmd
->duplex
!= DUPLEX_FULL
) {
222 netif_dbg(efx
, drv
, efx
->net_dev
,
223 "rejecting unsupported 1000Mbps HD setting\n");
227 mutex_lock(&efx
->mac_lock
);
228 rc
= efx
->phy_op
->set_settings(efx
, ecmd
);
229 mutex_unlock(&efx
->mac_lock
);
233 static void efx_ethtool_get_drvinfo(struct net_device
*net_dev
,
234 struct ethtool_drvinfo
*info
)
236 struct efx_nic
*efx
= netdev_priv(net_dev
);
238 strlcpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
));
239 strlcpy(info
->version
, EFX_DRIVER_VERSION
, sizeof(info
->version
));
240 if (efx_nic_rev(efx
) >= EFX_REV_SIENA_A0
)
241 siena_print_fwver(efx
, info
->fw_version
,
242 sizeof(info
->fw_version
));
243 strlcpy(info
->bus_info
, pci_name(efx
->pci_dev
), sizeof(info
->bus_info
));
246 static int efx_ethtool_get_regs_len(struct net_device
*net_dev
)
248 return efx_nic_get_regs_len(netdev_priv(net_dev
));
251 static void efx_ethtool_get_regs(struct net_device
*net_dev
,
252 struct ethtool_regs
*regs
, void *buf
)
254 struct efx_nic
*efx
= netdev_priv(net_dev
);
256 regs
->version
= efx
->type
->revision
;
257 efx_nic_get_regs(efx
, buf
);
260 static u32
efx_ethtool_get_msglevel(struct net_device
*net_dev
)
262 struct efx_nic
*efx
= netdev_priv(net_dev
);
263 return efx
->msg_enable
;
266 static void efx_ethtool_set_msglevel(struct net_device
*net_dev
, u32 msg_enable
)
268 struct efx_nic
*efx
= netdev_priv(net_dev
);
269 efx
->msg_enable
= msg_enable
;
273 * efx_fill_test - fill in an individual self-test entry
274 * @test_index: Index of the test
275 * @strings: Ethtool strings, or %NULL
276 * @data: Ethtool test results, or %NULL
277 * @test: Pointer to test result (used only if data != %NULL)
278 * @unit_format: Unit name format (e.g. "chan\%d")
279 * @unit_id: Unit id (e.g. 0 for "chan0")
280 * @test_format: Test name format (e.g. "loopback.\%s.tx.sent")
281 * @test_id: Test id (e.g. "PHYXS" for "loopback.PHYXS.tx_sent")
283 * Fill in an individual self-test entry.
285 static void efx_fill_test(unsigned int test_index
,
286 struct ethtool_string
*strings
, u64
*data
,
287 int *test
, const char *unit_format
, int unit_id
,
288 const char *test_format
, const char *test_id
)
290 struct ethtool_string unit_str
, test_str
;
292 /* Fill data value, if applicable */
294 data
[test_index
] = *test
;
296 /* Fill string, if applicable */
298 if (strchr(unit_format
, '%'))
299 snprintf(unit_str
.name
, sizeof(unit_str
.name
),
300 unit_format
, unit_id
);
302 strcpy(unit_str
.name
, unit_format
);
303 snprintf(test_str
.name
, sizeof(test_str
.name
),
304 test_format
, test_id
);
305 snprintf(strings
[test_index
].name
,
306 sizeof(strings
[test_index
].name
),
307 "%-6s %-24s", unit_str
.name
, test_str
.name
);
311 #define EFX_CHANNEL_NAME(_channel) "chan%d", _channel->channel
312 #define EFX_TX_QUEUE_NAME(_tx_queue) "txq%d", _tx_queue->queue
313 #define EFX_RX_QUEUE_NAME(_rx_queue) "rxq%d", _rx_queue->queue
314 #define EFX_LOOPBACK_NAME(_mode, _counter) \
315 "loopback.%s." _counter, STRING_TABLE_LOOKUP(_mode, efx_loopback_mode)
318 * efx_fill_loopback_test - fill in a block of loopback self-test entries
320 * @lb_tests: Efx loopback self-test results structure
321 * @mode: Loopback test mode
322 * @test_index: Starting index of the test
323 * @strings: Ethtool strings, or %NULL
324 * @data: Ethtool test results, or %NULL
326 static int efx_fill_loopback_test(struct efx_nic
*efx
,
327 struct efx_loopback_self_tests
*lb_tests
,
328 enum efx_loopback_mode mode
,
329 unsigned int test_index
,
330 struct ethtool_string
*strings
, u64
*data
)
332 struct efx_channel
*channel
= efx_get_channel(efx
, 0);
333 struct efx_tx_queue
*tx_queue
;
335 efx_for_each_channel_tx_queue(tx_queue
, channel
) {
336 efx_fill_test(test_index
++, strings
, data
,
337 &lb_tests
->tx_sent
[tx_queue
->queue
],
338 EFX_TX_QUEUE_NAME(tx_queue
),
339 EFX_LOOPBACK_NAME(mode
, "tx_sent"));
340 efx_fill_test(test_index
++, strings
, data
,
341 &lb_tests
->tx_done
[tx_queue
->queue
],
342 EFX_TX_QUEUE_NAME(tx_queue
),
343 EFX_LOOPBACK_NAME(mode
, "tx_done"));
345 efx_fill_test(test_index
++, strings
, data
,
348 EFX_LOOPBACK_NAME(mode
, "rx_good"));
349 efx_fill_test(test_index
++, strings
, data
,
352 EFX_LOOPBACK_NAME(mode
, "rx_bad"));
358 * efx_ethtool_fill_self_tests - get self-test details
360 * @tests: Efx self-test results structure, or %NULL
361 * @strings: Ethtool strings, or %NULL
362 * @data: Ethtool test results, or %NULL
364 static int efx_ethtool_fill_self_tests(struct efx_nic
*efx
,
365 struct efx_self_tests
*tests
,
366 struct ethtool_string
*strings
,
369 struct efx_channel
*channel
;
370 unsigned int n
= 0, i
;
371 enum efx_loopback_mode mode
;
373 efx_fill_test(n
++, strings
, data
, &tests
->phy_alive
,
374 "phy", 0, "alive", NULL
);
375 efx_fill_test(n
++, strings
, data
, &tests
->nvram
,
376 "core", 0, "nvram", NULL
);
377 efx_fill_test(n
++, strings
, data
, &tests
->interrupt
,
378 "core", 0, "interrupt", NULL
);
381 efx_for_each_channel(channel
, efx
) {
382 efx_fill_test(n
++, strings
, data
,
383 &tests
->eventq_dma
[channel
->channel
],
384 EFX_CHANNEL_NAME(channel
),
386 efx_fill_test(n
++, strings
, data
,
387 &tests
->eventq_int
[channel
->channel
],
388 EFX_CHANNEL_NAME(channel
),
390 efx_fill_test(n
++, strings
, data
,
391 &tests
->eventq_poll
[channel
->channel
],
392 EFX_CHANNEL_NAME(channel
),
393 "eventq.poll", NULL
);
396 efx_fill_test(n
++, strings
, data
, &tests
->registers
,
397 "core", 0, "registers", NULL
);
399 if (efx
->phy_op
->run_tests
!= NULL
) {
400 EFX_BUG_ON_PARANOID(efx
->phy_op
->test_name
== NULL
);
402 for (i
= 0; true; ++i
) {
405 EFX_BUG_ON_PARANOID(i
>= EFX_MAX_PHY_TESTS
);
406 name
= efx
->phy_op
->test_name(efx
, i
);
410 efx_fill_test(n
++, strings
, data
, &tests
->phy_ext
[i
],
411 "phy", 0, name
, NULL
);
416 for (mode
= LOOPBACK_NONE
; mode
<= LOOPBACK_TEST_MAX
; mode
++) {
417 if (!(efx
->loopback_modes
& (1 << mode
)))
419 n
= efx_fill_loopback_test(efx
,
420 &tests
->loopback
[mode
], mode
, n
,
427 static int efx_ethtool_get_sset_count(struct net_device
*net_dev
,
430 switch (string_set
) {
432 return EFX_ETHTOOL_NUM_STATS
;
434 return efx_ethtool_fill_self_tests(netdev_priv(net_dev
),
441 static void efx_ethtool_get_strings(struct net_device
*net_dev
,
442 u32 string_set
, u8
*strings
)
444 struct efx_nic
*efx
= netdev_priv(net_dev
);
445 struct ethtool_string
*ethtool_strings
=
446 (struct ethtool_string
*)strings
;
449 switch (string_set
) {
451 for (i
= 0; i
< EFX_ETHTOOL_NUM_STATS
; i
++)
452 strncpy(ethtool_strings
[i
].name
,
453 efx_ethtool_stats
[i
].name
,
454 sizeof(ethtool_strings
[i
].name
));
457 efx_ethtool_fill_self_tests(efx
, NULL
,
458 ethtool_strings
, NULL
);
461 /* No other string sets */
466 static void efx_ethtool_get_stats(struct net_device
*net_dev
,
467 struct ethtool_stats
*stats
,
470 struct efx_nic
*efx
= netdev_priv(net_dev
);
471 struct efx_mac_stats
*mac_stats
= &efx
->mac_stats
;
472 struct efx_ethtool_stat
*stat
;
473 struct efx_channel
*channel
;
474 struct rtnl_link_stats64 temp
;
477 EFX_BUG_ON_PARANOID(stats
->n_stats
!= EFX_ETHTOOL_NUM_STATS
);
479 /* Update MAC and NIC statistics */
480 dev_get_stats(net_dev
, &temp
);
482 /* Fill detailed statistics buffer */
483 for (i
= 0; i
< EFX_ETHTOOL_NUM_STATS
; i
++) {
484 stat
= &efx_ethtool_stats
[i
];
485 switch (stat
->source
) {
486 case EFX_ETHTOOL_STAT_SOURCE_mac_stats
:
487 data
[i
] = stat
->get_stat((void *)mac_stats
+
490 case EFX_ETHTOOL_STAT_SOURCE_nic
:
491 data
[i
] = stat
->get_stat((void *)efx
+ stat
->offset
);
493 case EFX_ETHTOOL_STAT_SOURCE_channel
:
495 efx_for_each_channel(channel
, efx
)
496 data
[i
] += stat
->get_stat((void *)channel
+
503 static int efx_ethtool_set_tso(struct net_device
*net_dev
, u32 enable
)
505 struct efx_nic
*efx
__attribute__ ((unused
)) = netdev_priv(net_dev
);
506 unsigned long features
;
508 features
= NETIF_F_TSO
;
509 if (efx
->type
->offload_features
& NETIF_F_V6_CSUM
)
510 features
|= NETIF_F_TSO6
;
513 net_dev
->features
|= features
;
515 net_dev
->features
&= ~features
;
520 static int efx_ethtool_set_tx_csum(struct net_device
*net_dev
, u32 enable
)
522 struct efx_nic
*efx
= netdev_priv(net_dev
);
523 unsigned long features
= efx
->type
->offload_features
& NETIF_F_ALL_CSUM
;
526 net_dev
->features
|= features
;
528 net_dev
->features
&= ~features
;
533 static int efx_ethtool_set_rx_csum(struct net_device
*net_dev
, u32 enable
)
535 struct efx_nic
*efx
= netdev_priv(net_dev
);
537 /* No way to stop the hardware doing the checks; we just
540 efx
->rx_checksum_enabled
= !!enable
;
545 static u32
efx_ethtool_get_rx_csum(struct net_device
*net_dev
)
547 struct efx_nic
*efx
= netdev_priv(net_dev
);
549 return efx
->rx_checksum_enabled
;
552 static int efx_ethtool_set_flags(struct net_device
*net_dev
, u32 data
)
554 struct efx_nic
*efx
= netdev_priv(net_dev
);
555 u32 supported
= (efx
->type
->offload_features
&
556 (ETH_FLAG_RXHASH
| ETH_FLAG_NTUPLE
));
559 rc
= ethtool_op_set_flags(net_dev
, data
, supported
);
563 if (!(data
& ETH_FLAG_NTUPLE
)) {
564 efx_filter_table_clear(efx
, EFX_FILTER_TABLE_RX_IP
,
565 EFX_FILTER_PRI_MANUAL
);
566 efx_filter_table_clear(efx
, EFX_FILTER_TABLE_RX_MAC
,
567 EFX_FILTER_PRI_MANUAL
);
573 static void efx_ethtool_self_test(struct net_device
*net_dev
,
574 struct ethtool_test
*test
, u64
*data
)
576 struct efx_nic
*efx
= netdev_priv(net_dev
);
577 struct efx_self_tests efx_tests
;
582 if (efx
->state
!= STATE_RUNNING
) {
587 /* We need rx buffers and interrupts. */
588 already_up
= (efx
->net_dev
->flags
& IFF_UP
);
590 rc
= dev_open(efx
->net_dev
);
592 netif_err(efx
, drv
, efx
->net_dev
,
593 "failed opening device.\n");
598 memset(&efx_tests
, 0, sizeof(efx_tests
));
600 rc
= efx_selftest(efx
, &efx_tests
, test
->flags
);
603 dev_close(efx
->net_dev
);
605 netif_dbg(efx
, drv
, efx
->net_dev
, "%s %sline self-tests\n",
606 rc
== 0 ? "passed" : "failed",
607 (test
->flags
& ETH_TEST_FL_OFFLINE
) ? "off" : "on");
611 /* Fill ethtool results structures */
612 efx_ethtool_fill_self_tests(efx
, &efx_tests
, NULL
, data
);
614 test
->flags
|= ETH_TEST_FL_FAILED
;
617 /* Restart autonegotiation */
618 static int efx_ethtool_nway_reset(struct net_device
*net_dev
)
620 struct efx_nic
*efx
= netdev_priv(net_dev
);
622 return mdio45_nway_restart(&efx
->mdio
);
625 static u32
efx_ethtool_get_link(struct net_device
*net_dev
)
627 struct efx_nic
*efx
= netdev_priv(net_dev
);
629 return efx
->link_state
.up
;
632 static int efx_ethtool_get_eeprom_len(struct net_device
*net_dev
)
634 struct efx_nic
*efx
= netdev_priv(net_dev
);
635 struct efx_spi_device
*spi
= efx
->spi_eeprom
;
639 return min(spi
->size
, EFX_EEPROM_BOOTCONFIG_END
) -
640 min(spi
->size
, EFX_EEPROM_BOOTCONFIG_START
);
643 static int efx_ethtool_get_eeprom(struct net_device
*net_dev
,
644 struct ethtool_eeprom
*eeprom
, u8
*buf
)
646 struct efx_nic
*efx
= netdev_priv(net_dev
);
647 struct efx_spi_device
*spi
= efx
->spi_eeprom
;
651 rc
= mutex_lock_interruptible(&efx
->spi_lock
);
654 rc
= falcon_spi_read(efx
, spi
,
655 eeprom
->offset
+ EFX_EEPROM_BOOTCONFIG_START
,
656 eeprom
->len
, &len
, buf
);
657 mutex_unlock(&efx
->spi_lock
);
659 eeprom
->magic
= EFX_ETHTOOL_EEPROM_MAGIC
;
664 static int efx_ethtool_set_eeprom(struct net_device
*net_dev
,
665 struct ethtool_eeprom
*eeprom
, u8
*buf
)
667 struct efx_nic
*efx
= netdev_priv(net_dev
);
668 struct efx_spi_device
*spi
= efx
->spi_eeprom
;
672 if (eeprom
->magic
!= EFX_ETHTOOL_EEPROM_MAGIC
)
675 rc
= mutex_lock_interruptible(&efx
->spi_lock
);
678 rc
= falcon_spi_write(efx
, spi
,
679 eeprom
->offset
+ EFX_EEPROM_BOOTCONFIG_START
,
680 eeprom
->len
, &len
, buf
);
681 mutex_unlock(&efx
->spi_lock
);
687 static int efx_ethtool_get_coalesce(struct net_device
*net_dev
,
688 struct ethtool_coalesce
*coalesce
)
690 struct efx_nic
*efx
= netdev_priv(net_dev
);
691 struct efx_channel
*channel
;
693 memset(coalesce
, 0, sizeof(*coalesce
));
695 /* Find lowest IRQ moderation across all used TX queues */
696 coalesce
->tx_coalesce_usecs_irq
= ~((u32
) 0);
697 efx_for_each_channel(channel
, efx
) {
698 if (!efx_channel_get_tx_queue(channel
, 0))
700 if (channel
->irq_moderation
< coalesce
->tx_coalesce_usecs_irq
) {
701 if (channel
->channel
< efx
->n_rx_channels
)
702 coalesce
->tx_coalesce_usecs_irq
=
703 channel
->irq_moderation
;
705 coalesce
->tx_coalesce_usecs_irq
= 0;
709 coalesce
->use_adaptive_rx_coalesce
= efx
->irq_rx_adaptive
;
710 coalesce
->rx_coalesce_usecs_irq
= efx
->irq_rx_moderation
;
712 coalesce
->tx_coalesce_usecs_irq
*= EFX_IRQ_MOD_RESOLUTION
;
713 coalesce
->rx_coalesce_usecs_irq
*= EFX_IRQ_MOD_RESOLUTION
;
718 /* Set coalescing parameters
719 * The difficulties occur for shared channels
721 static int efx_ethtool_set_coalesce(struct net_device
*net_dev
,
722 struct ethtool_coalesce
*coalesce
)
724 struct efx_nic
*efx
= netdev_priv(net_dev
);
725 struct efx_channel
*channel
;
726 unsigned tx_usecs
, rx_usecs
, adaptive
;
728 if (coalesce
->use_adaptive_tx_coalesce
)
731 if (coalesce
->rx_coalesce_usecs
|| coalesce
->tx_coalesce_usecs
) {
732 netif_err(efx
, drv
, efx
->net_dev
, "invalid coalescing setting. "
733 "Only rx/tx_coalesce_usecs_irq are supported\n");
737 rx_usecs
= coalesce
->rx_coalesce_usecs_irq
;
738 tx_usecs
= coalesce
->tx_coalesce_usecs_irq
;
739 adaptive
= coalesce
->use_adaptive_rx_coalesce
;
741 /* If the channel is shared only allow RX parameters to be set */
742 efx_for_each_channel(channel
, efx
) {
743 if (efx_channel_get_rx_queue(channel
) &&
744 efx_channel_get_tx_queue(channel
, 0) &&
746 netif_err(efx
, drv
, efx
->net_dev
, "Channel is shared. "
747 "Only RX coalescing may be set\n");
752 efx_init_irq_moderation(efx
, tx_usecs
, rx_usecs
, adaptive
);
753 efx_for_each_channel(channel
, efx
)
754 efx
->type
->push_irq_moderation(channel
);
759 static void efx_ethtool_get_ringparam(struct net_device
*net_dev
,
760 struct ethtool_ringparam
*ring
)
762 struct efx_nic
*efx
= netdev_priv(net_dev
);
764 ring
->rx_max_pending
= EFX_MAX_DMAQ_SIZE
;
765 ring
->tx_max_pending
= EFX_MAX_DMAQ_SIZE
;
766 ring
->rx_mini_max_pending
= 0;
767 ring
->rx_jumbo_max_pending
= 0;
768 ring
->rx_pending
= efx
->rxq_entries
;
769 ring
->tx_pending
= efx
->txq_entries
;
770 ring
->rx_mini_pending
= 0;
771 ring
->rx_jumbo_pending
= 0;
774 static int efx_ethtool_set_ringparam(struct net_device
*net_dev
,
775 struct ethtool_ringparam
*ring
)
777 struct efx_nic
*efx
= netdev_priv(net_dev
);
779 if (ring
->rx_mini_pending
|| ring
->rx_jumbo_pending
||
780 ring
->rx_pending
> EFX_MAX_DMAQ_SIZE
||
781 ring
->tx_pending
> EFX_MAX_DMAQ_SIZE
)
784 if (ring
->rx_pending
< EFX_MIN_RING_SIZE
||
785 ring
->tx_pending
< EFX_MIN_RING_SIZE
) {
786 netif_err(efx
, drv
, efx
->net_dev
,
787 "TX and RX queues cannot be smaller than %ld\n",
792 return efx_realloc_channels(efx
, ring
->rx_pending
, ring
->tx_pending
);
795 static int efx_ethtool_set_pauseparam(struct net_device
*net_dev
,
796 struct ethtool_pauseparam
*pause
)
798 struct efx_nic
*efx
= netdev_priv(net_dev
);
799 enum efx_fc_type wanted_fc
, old_fc
;
804 mutex_lock(&efx
->mac_lock
);
806 wanted_fc
= ((pause
->rx_pause
? EFX_FC_RX
: 0) |
807 (pause
->tx_pause
? EFX_FC_TX
: 0) |
808 (pause
->autoneg
? EFX_FC_AUTO
: 0));
810 if ((wanted_fc
& EFX_FC_TX
) && !(wanted_fc
& EFX_FC_RX
)) {
811 netif_dbg(efx
, drv
, efx
->net_dev
,
812 "Flow control unsupported: tx ON rx OFF\n");
817 if ((wanted_fc
& EFX_FC_AUTO
) && !efx
->link_advertising
) {
818 netif_dbg(efx
, drv
, efx
->net_dev
,
819 "Autonegotiation is disabled\n");
824 /* TX flow control may automatically turn itself off if the
825 * link partner (intermittently) stops responding to pause
826 * frames. There isn't any indication that this has happened,
827 * so the best we do is leave it up to the user to spot this
828 * and fix it be cycling transmit flow control on this end. */
829 reset
= (wanted_fc
& EFX_FC_TX
) && !(efx
->wanted_fc
& EFX_FC_TX
);
830 if (EFX_WORKAROUND_11482(efx
) && reset
) {
831 if (efx_nic_rev(efx
) == EFX_REV_FALCON_B0
) {
832 /* Recover by resetting the EM block */
833 falcon_stop_nic_stats(efx
);
834 falcon_drain_tx_fifo(efx
);
835 efx
->mac_op
->reconfigure(efx
);
836 falcon_start_nic_stats(efx
);
838 /* Schedule a reset to recover */
839 efx_schedule_reset(efx
, RESET_TYPE_INVISIBLE
);
843 old_adv
= efx
->link_advertising
;
844 old_fc
= efx
->wanted_fc
;
845 efx_link_set_wanted_fc(efx
, wanted_fc
);
846 if (efx
->link_advertising
!= old_adv
||
847 (efx
->wanted_fc
^ old_fc
) & EFX_FC_AUTO
) {
848 rc
= efx
->phy_op
->reconfigure(efx
);
850 netif_err(efx
, drv
, efx
->net_dev
,
851 "Unable to advertise requested flow "
852 "control setting\n");
857 /* Reconfigure the MAC. The PHY *may* generate a link state change event
858 * if the user just changed the advertised capabilities, but there's no
859 * harm doing this twice */
860 efx
->mac_op
->reconfigure(efx
);
863 mutex_unlock(&efx
->mac_lock
);
868 static void efx_ethtool_get_pauseparam(struct net_device
*net_dev
,
869 struct ethtool_pauseparam
*pause
)
871 struct efx_nic
*efx
= netdev_priv(net_dev
);
873 pause
->rx_pause
= !!(efx
->wanted_fc
& EFX_FC_RX
);
874 pause
->tx_pause
= !!(efx
->wanted_fc
& EFX_FC_TX
);
875 pause
->autoneg
= !!(efx
->wanted_fc
& EFX_FC_AUTO
);
879 static void efx_ethtool_get_wol(struct net_device
*net_dev
,
880 struct ethtool_wolinfo
*wol
)
882 struct efx_nic
*efx
= netdev_priv(net_dev
);
883 return efx
->type
->get_wol(efx
, wol
);
887 static int efx_ethtool_set_wol(struct net_device
*net_dev
,
888 struct ethtool_wolinfo
*wol
)
890 struct efx_nic
*efx
= netdev_priv(net_dev
);
891 return efx
->type
->set_wol(efx
, wol
->wolopts
);
894 static int efx_ethtool_reset(struct net_device
*net_dev
, u32
*flags
)
896 struct efx_nic
*efx
= netdev_priv(net_dev
);
897 enum reset_type method
;
899 ETH_RESET_EFX_INVISIBLE
= (ETH_RESET_DMA
| ETH_RESET_FILTER
|
900 ETH_RESET_OFFLOAD
| ETH_RESET_MAC
)
903 /* Check for minimal reset flags */
904 if ((*flags
& ETH_RESET_EFX_INVISIBLE
) != ETH_RESET_EFX_INVISIBLE
)
906 *flags
^= ETH_RESET_EFX_INVISIBLE
;
907 method
= RESET_TYPE_INVISIBLE
;
909 if (*flags
& ETH_RESET_PHY
) {
910 *flags
^= ETH_RESET_PHY
;
911 method
= RESET_TYPE_ALL
;
914 if ((*flags
& efx
->type
->reset_world_flags
) ==
915 efx
->type
->reset_world_flags
) {
916 *flags
^= efx
->type
->reset_world_flags
;
917 method
= RESET_TYPE_WORLD
;
920 return efx_reset(efx
, method
);
924 efx_ethtool_get_rxnfc(struct net_device
*net_dev
,
925 struct ethtool_rxnfc
*info
, void *rules __always_unused
)
927 struct efx_nic
*efx
= netdev_priv(net_dev
);
930 case ETHTOOL_GRXRINGS
:
931 info
->data
= efx
->n_rx_channels
;
934 case ETHTOOL_GRXFH
: {
935 unsigned min_revision
= 0;
938 switch (info
->flow_type
) {
940 info
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
946 info
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
947 min_revision
= EFX_REV_FALCON_B0
;
950 info
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
956 info
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
957 min_revision
= EFX_REV_SIENA_A0
;
962 if (efx_nic_rev(efx
) < min_revision
)
972 static int efx_ethtool_set_rx_ntuple(struct net_device
*net_dev
,
973 struct ethtool_rx_ntuple
*ntuple
)
975 struct efx_nic
*efx
= netdev_priv(net_dev
);
976 struct ethtool_tcpip4_spec
*ip_entry
= &ntuple
->fs
.h_u
.tcp_ip4_spec
;
977 struct ethtool_tcpip4_spec
*ip_mask
= &ntuple
->fs
.m_u
.tcp_ip4_spec
;
978 struct ethhdr
*mac_entry
= &ntuple
->fs
.h_u
.ether_spec
;
979 struct ethhdr
*mac_mask
= &ntuple
->fs
.m_u
.ether_spec
;
980 struct efx_filter_spec filter
;
982 /* Range-check action */
983 if (ntuple
->fs
.action
< ETHTOOL_RXNTUPLE_ACTION_CLEAR
||
984 ntuple
->fs
.action
>= (s32
)efx
->n_rx_channels
)
987 if (~ntuple
->fs
.data_mask
)
990 switch (ntuple
->fs
.flow_type
) {
993 /* Must match all of destination, */
994 if (ip_mask
->ip4dst
| ip_mask
->pdst
)
996 /* all or none of source, */
997 if ((ip_mask
->ip4src
| ip_mask
->psrc
) &&
998 ((__force u32
)~ip_mask
->ip4src
|
999 (__force u16
)~ip_mask
->psrc
))
1001 /* and nothing else */
1002 if ((u8
)~ip_mask
->tos
| (u16
)~ntuple
->fs
.vlan_tag_mask
)
1006 /* Must match all of destination, */
1007 if (!is_zero_ether_addr(mac_mask
->h_dest
))
1009 /* all or none of VID, */
1010 if (ntuple
->fs
.vlan_tag_mask
!= 0xf000 &&
1011 ntuple
->fs
.vlan_tag_mask
!= 0xffff)
1013 /* and nothing else */
1014 if (!is_broadcast_ether_addr(mac_mask
->h_source
) ||
1015 mac_mask
->h_proto
!= htons(0xffff))
1022 filter
.priority
= EFX_FILTER_PRI_MANUAL
;
1025 switch (ntuple
->fs
.flow_type
) {
1027 if (!ip_mask
->ip4src
)
1028 efx_filter_set_rx_tcp_full(&filter
,
1029 htonl(ip_entry
->ip4src
),
1030 htons(ip_entry
->psrc
),
1031 htonl(ip_entry
->ip4dst
),
1032 htons(ip_entry
->pdst
));
1034 efx_filter_set_rx_tcp_wild(&filter
,
1035 htonl(ip_entry
->ip4dst
),
1036 htons(ip_entry
->pdst
));
1039 if (!ip_mask
->ip4src
)
1040 efx_filter_set_rx_udp_full(&filter
,
1041 htonl(ip_entry
->ip4src
),
1042 htons(ip_entry
->psrc
),
1043 htonl(ip_entry
->ip4dst
),
1044 htons(ip_entry
->pdst
));
1046 efx_filter_set_rx_udp_wild(&filter
,
1047 htonl(ip_entry
->ip4dst
),
1048 htons(ip_entry
->pdst
));
1051 if (ntuple
->fs
.vlan_tag_mask
== 0xf000)
1052 efx_filter_set_rx_mac_full(&filter
,
1053 ntuple
->fs
.vlan_tag
& 0xfff,
1056 efx_filter_set_rx_mac_wild(&filter
, mac_entry
->h_dest
);
1060 if (ntuple
->fs
.action
== ETHTOOL_RXNTUPLE_ACTION_CLEAR
) {
1061 return efx_filter_remove_filter(efx
, &filter
);
1063 if (ntuple
->fs
.action
== ETHTOOL_RXNTUPLE_ACTION_DROP
)
1064 filter
.dmaq_id
= 0xfff;
1066 filter
.dmaq_id
= ntuple
->fs
.action
;
1067 return efx_filter_insert_filter(efx
, &filter
, true);
1071 static int efx_ethtool_get_rxfh_indir(struct net_device
*net_dev
,
1072 struct ethtool_rxfh_indir
*indir
)
1074 struct efx_nic
*efx
= netdev_priv(net_dev
);
1076 min_t(size_t, indir
->size
, ARRAY_SIZE(efx
->rx_indir_table
));
1078 if (efx_nic_rev(efx
) < EFX_REV_FALCON_B0
)
1081 indir
->size
= ARRAY_SIZE(efx
->rx_indir_table
);
1082 memcpy(indir
->ring_index
, efx
->rx_indir_table
,
1083 copy_size
* sizeof(indir
->ring_index
[0]));
1087 static int efx_ethtool_set_rxfh_indir(struct net_device
*net_dev
,
1088 const struct ethtool_rxfh_indir
*indir
)
1090 struct efx_nic
*efx
= netdev_priv(net_dev
);
1093 if (efx_nic_rev(efx
) < EFX_REV_FALCON_B0
)
1096 /* Validate size and indices */
1097 if (indir
->size
!= ARRAY_SIZE(efx
->rx_indir_table
))
1099 for (i
= 0; i
< ARRAY_SIZE(efx
->rx_indir_table
); i
++)
1100 if (indir
->ring_index
[i
] >= efx
->n_rx_channels
)
1103 memcpy(efx
->rx_indir_table
, indir
->ring_index
,
1104 sizeof(efx
->rx_indir_table
));
1105 efx_nic_push_rx_indir_table(efx
);
1109 const struct ethtool_ops efx_ethtool_ops
= {
1110 .get_settings
= efx_ethtool_get_settings
,
1111 .set_settings
= efx_ethtool_set_settings
,
1112 .get_drvinfo
= efx_ethtool_get_drvinfo
,
1113 .get_regs_len
= efx_ethtool_get_regs_len
,
1114 .get_regs
= efx_ethtool_get_regs
,
1115 .get_msglevel
= efx_ethtool_get_msglevel
,
1116 .set_msglevel
= efx_ethtool_set_msglevel
,
1117 .nway_reset
= efx_ethtool_nway_reset
,
1118 .get_link
= efx_ethtool_get_link
,
1119 .get_eeprom_len
= efx_ethtool_get_eeprom_len
,
1120 .get_eeprom
= efx_ethtool_get_eeprom
,
1121 .set_eeprom
= efx_ethtool_set_eeprom
,
1122 .get_coalesce
= efx_ethtool_get_coalesce
,
1123 .set_coalesce
= efx_ethtool_set_coalesce
,
1124 .get_ringparam
= efx_ethtool_get_ringparam
,
1125 .set_ringparam
= efx_ethtool_set_ringparam
,
1126 .get_pauseparam
= efx_ethtool_get_pauseparam
,
1127 .set_pauseparam
= efx_ethtool_set_pauseparam
,
1128 .get_rx_csum
= efx_ethtool_get_rx_csum
,
1129 .set_rx_csum
= efx_ethtool_set_rx_csum
,
1130 .get_tx_csum
= ethtool_op_get_tx_csum
,
1131 /* Need to enable/disable IPv6 too */
1132 .set_tx_csum
= efx_ethtool_set_tx_csum
,
1133 .get_sg
= ethtool_op_get_sg
,
1134 .set_sg
= ethtool_op_set_sg
,
1135 .get_tso
= ethtool_op_get_tso
,
1136 /* Need to enable/disable TSO-IPv6 too */
1137 .set_tso
= efx_ethtool_set_tso
,
1138 .get_flags
= ethtool_op_get_flags
,
1139 .set_flags
= efx_ethtool_set_flags
,
1140 .get_sset_count
= efx_ethtool_get_sset_count
,
1141 .self_test
= efx_ethtool_self_test
,
1142 .get_strings
= efx_ethtool_get_strings
,
1143 .phys_id
= efx_ethtool_phys_id
,
1144 .get_ethtool_stats
= efx_ethtool_get_stats
,
1145 .get_wol
= efx_ethtool_get_wol
,
1146 .set_wol
= efx_ethtool_set_wol
,
1147 .reset
= efx_ethtool_reset
,
1148 .get_rxnfc
= efx_ethtool_get_rxnfc
,
1149 .set_rx_ntuple
= efx_ethtool_set_rx_ntuple
,
1150 .get_rxfh_indir
= efx_ethtool_get_rxfh_indir
,
1151 .set_rxfh_indir
= efx_ethtool_set_rxfh_indir
,