1 /****************************************************************************
2 * Driver for Solarflare Solarstorm network controllers and boards
3 * Copyright 2005-2006 Fen Systems Ltd.
4 * Copyright 2006-2008 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"
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
34 u64(*get_stat
) (void *field
); /* Reader function */
37 /* Initialiser for a struct #efx_ethtool_stat with type-checking */
38 #define EFX_ETHTOOL_STAT(stat_name, source_name, field, field_type, \
39 get_stat_function) { \
41 .source = EFX_ETHTOOL_STAT_SOURCE_##source_name, \
42 .offset = ((((field_type *) 0) == \
43 &((struct efx_##source_name *)0)->field) ? \
44 offsetof(struct efx_##source_name, field) : \
45 offsetof(struct efx_##source_name, field)), \
46 .get_stat = get_stat_function, \
49 static u64
efx_get_uint_stat(void *field
)
51 return *(unsigned int *)field
;
54 static u64
efx_get_ulong_stat(void *field
)
56 return *(unsigned long *)field
;
59 static u64
efx_get_u64_stat(void *field
)
61 return *(u64
*) field
;
64 static u64
efx_get_atomic_stat(void *field
)
66 return atomic_read((atomic_t
*) field
);
69 #define EFX_ETHTOOL_ULONG_MAC_STAT(field) \
70 EFX_ETHTOOL_STAT(field, mac_stats, field, \
71 unsigned long, efx_get_ulong_stat)
73 #define EFX_ETHTOOL_U64_MAC_STAT(field) \
74 EFX_ETHTOOL_STAT(field, mac_stats, field, \
75 u64, efx_get_u64_stat)
77 #define EFX_ETHTOOL_UINT_NIC_STAT(name) \
78 EFX_ETHTOOL_STAT(name, nic, n_##name, \
79 unsigned int, efx_get_uint_stat)
81 #define EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(field) \
82 EFX_ETHTOOL_STAT(field, nic, field, \
83 atomic_t, efx_get_atomic_stat)
85 #define EFX_ETHTOOL_UINT_CHANNEL_STAT(field) \
86 EFX_ETHTOOL_STAT(field, channel, n_##field, \
87 unsigned int, efx_get_uint_stat)
89 static struct efx_ethtool_stat efx_ethtool_stats
[] = {
90 EFX_ETHTOOL_U64_MAC_STAT(tx_bytes
),
91 EFX_ETHTOOL_U64_MAC_STAT(tx_good_bytes
),
92 EFX_ETHTOOL_U64_MAC_STAT(tx_bad_bytes
),
93 EFX_ETHTOOL_ULONG_MAC_STAT(tx_packets
),
94 EFX_ETHTOOL_ULONG_MAC_STAT(tx_bad
),
95 EFX_ETHTOOL_ULONG_MAC_STAT(tx_pause
),
96 EFX_ETHTOOL_ULONG_MAC_STAT(tx_control
),
97 EFX_ETHTOOL_ULONG_MAC_STAT(tx_unicast
),
98 EFX_ETHTOOL_ULONG_MAC_STAT(tx_multicast
),
99 EFX_ETHTOOL_ULONG_MAC_STAT(tx_broadcast
),
100 EFX_ETHTOOL_ULONG_MAC_STAT(tx_lt64
),
101 EFX_ETHTOOL_ULONG_MAC_STAT(tx_64
),
102 EFX_ETHTOOL_ULONG_MAC_STAT(tx_65_to_127
),
103 EFX_ETHTOOL_ULONG_MAC_STAT(tx_128_to_255
),
104 EFX_ETHTOOL_ULONG_MAC_STAT(tx_256_to_511
),
105 EFX_ETHTOOL_ULONG_MAC_STAT(tx_512_to_1023
),
106 EFX_ETHTOOL_ULONG_MAC_STAT(tx_1024_to_15xx
),
107 EFX_ETHTOOL_ULONG_MAC_STAT(tx_15xx_to_jumbo
),
108 EFX_ETHTOOL_ULONG_MAC_STAT(tx_gtjumbo
),
109 EFX_ETHTOOL_ULONG_MAC_STAT(tx_collision
),
110 EFX_ETHTOOL_ULONG_MAC_STAT(tx_single_collision
),
111 EFX_ETHTOOL_ULONG_MAC_STAT(tx_multiple_collision
),
112 EFX_ETHTOOL_ULONG_MAC_STAT(tx_excessive_collision
),
113 EFX_ETHTOOL_ULONG_MAC_STAT(tx_deferred
),
114 EFX_ETHTOOL_ULONG_MAC_STAT(tx_late_collision
),
115 EFX_ETHTOOL_ULONG_MAC_STAT(tx_excessive_deferred
),
116 EFX_ETHTOOL_ULONG_MAC_STAT(tx_non_tcpudp
),
117 EFX_ETHTOOL_ULONG_MAC_STAT(tx_mac_src_error
),
118 EFX_ETHTOOL_ULONG_MAC_STAT(tx_ip_src_error
),
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_ULONG_MAC_STAT(rx_packets
),
123 EFX_ETHTOOL_ULONG_MAC_STAT(rx_good
),
124 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad
),
125 EFX_ETHTOOL_ULONG_MAC_STAT(rx_pause
),
126 EFX_ETHTOOL_ULONG_MAC_STAT(rx_control
),
127 EFX_ETHTOOL_ULONG_MAC_STAT(rx_unicast
),
128 EFX_ETHTOOL_ULONG_MAC_STAT(rx_multicast
),
129 EFX_ETHTOOL_ULONG_MAC_STAT(rx_broadcast
),
130 EFX_ETHTOOL_ULONG_MAC_STAT(rx_lt64
),
131 EFX_ETHTOOL_ULONG_MAC_STAT(rx_64
),
132 EFX_ETHTOOL_ULONG_MAC_STAT(rx_65_to_127
),
133 EFX_ETHTOOL_ULONG_MAC_STAT(rx_128_to_255
),
134 EFX_ETHTOOL_ULONG_MAC_STAT(rx_256_to_511
),
135 EFX_ETHTOOL_ULONG_MAC_STAT(rx_512_to_1023
),
136 EFX_ETHTOOL_ULONG_MAC_STAT(rx_1024_to_15xx
),
137 EFX_ETHTOOL_ULONG_MAC_STAT(rx_15xx_to_jumbo
),
138 EFX_ETHTOOL_ULONG_MAC_STAT(rx_gtjumbo
),
139 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_lt64
),
140 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_64_to_15xx
),
141 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_15xx_to_jumbo
),
142 EFX_ETHTOOL_ULONG_MAC_STAT(rx_bad_gtjumbo
),
143 EFX_ETHTOOL_ULONG_MAC_STAT(rx_overflow
),
144 EFX_ETHTOOL_ULONG_MAC_STAT(rx_missed
),
145 EFX_ETHTOOL_ULONG_MAC_STAT(rx_false_carrier
),
146 EFX_ETHTOOL_ULONG_MAC_STAT(rx_symbol_error
),
147 EFX_ETHTOOL_ULONG_MAC_STAT(rx_align_error
),
148 EFX_ETHTOOL_ULONG_MAC_STAT(rx_length_error
),
149 EFX_ETHTOOL_ULONG_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
, u32 count
)
174 struct efx_nic
*efx
= netdev_priv(net_dev
);
177 efx
->type
->set_id_led(efx
, EFX_LED_ON
);
178 schedule_timeout_interruptible(HZ
/ 2);
180 efx
->type
->set_id_led(efx
, EFX_LED_OFF
);
181 schedule_timeout_interruptible(HZ
/ 2);
182 } while (!signal_pending(current
) && --count
!= 0);
184 efx
->type
->set_id_led(efx
, EFX_LED_DEFAULT
);
188 /* This must be called with rtnl_lock held. */
189 int efx_ethtool_get_settings(struct net_device
*net_dev
,
190 struct ethtool_cmd
*ecmd
)
192 struct efx_nic
*efx
= netdev_priv(net_dev
);
193 struct efx_link_state
*link_state
= &efx
->link_state
;
195 mutex_lock(&efx
->mac_lock
);
196 efx
->phy_op
->get_settings(efx
, ecmd
);
197 mutex_unlock(&efx
->mac_lock
);
199 /* Falcon GMAC does not support 1000Mbps HD */
200 ecmd
->supported
&= ~SUPPORTED_1000baseT_Half
;
201 /* Both MACs support pause frames (bidirectional and respond-only) */
202 ecmd
->supported
|= SUPPORTED_Pause
| SUPPORTED_Asym_Pause
;
204 if (LOOPBACK_INTERNAL(efx
)) {
205 ecmd
->speed
= link_state
->speed
;
206 ecmd
->duplex
= link_state
->fd
? DUPLEX_FULL
: DUPLEX_HALF
;
212 /* This must be called with rtnl_lock held. */
213 int efx_ethtool_set_settings(struct net_device
*net_dev
,
214 struct ethtool_cmd
*ecmd
)
216 struct efx_nic
*efx
= netdev_priv(net_dev
);
219 /* Falcon GMAC does not support 1000Mbps HD */
220 if (ecmd
->speed
== SPEED_1000
&& ecmd
->duplex
!= DUPLEX_FULL
) {
221 EFX_LOG(efx
, "rejecting unsupported 1000Mbps HD"
226 mutex_lock(&efx
->mac_lock
);
227 rc
= efx
->phy_op
->set_settings(efx
, ecmd
);
228 mutex_unlock(&efx
->mac_lock
);
232 static void efx_ethtool_get_drvinfo(struct net_device
*net_dev
,
233 struct ethtool_drvinfo
*info
)
235 struct efx_nic
*efx
= netdev_priv(net_dev
);
237 strlcpy(info
->driver
, EFX_DRIVER_NAME
, sizeof(info
->driver
));
238 strlcpy(info
->version
, EFX_DRIVER_VERSION
, sizeof(info
->version
));
239 strlcpy(info
->bus_info
, pci_name(efx
->pci_dev
), sizeof(info
->bus_info
));
243 * efx_fill_test - fill in an individual self-test entry
244 * @test_index: Index of the test
245 * @strings: Ethtool strings, or %NULL
246 * @data: Ethtool test results, or %NULL
247 * @test: Pointer to test result (used only if data != %NULL)
248 * @unit_format: Unit name format (e.g. "chan\%d")
249 * @unit_id: Unit id (e.g. 0 for "chan0")
250 * @test_format: Test name format (e.g. "loopback.\%s.tx.sent")
251 * @test_id: Test id (e.g. "PHYXS" for "loopback.PHYXS.tx_sent")
253 * Fill in an individual self-test entry.
255 static void efx_fill_test(unsigned int test_index
,
256 struct ethtool_string
*strings
, u64
*data
,
257 int *test
, const char *unit_format
, int unit_id
,
258 const char *test_format
, const char *test_id
)
260 struct ethtool_string unit_str
, test_str
;
262 /* Fill data value, if applicable */
264 data
[test_index
] = *test
;
266 /* Fill string, if applicable */
268 if (strchr(unit_format
, '%'))
269 snprintf(unit_str
.name
, sizeof(unit_str
.name
),
270 unit_format
, unit_id
);
272 strcpy(unit_str
.name
, unit_format
);
273 snprintf(test_str
.name
, sizeof(test_str
.name
),
274 test_format
, test_id
);
275 snprintf(strings
[test_index
].name
,
276 sizeof(strings
[test_index
].name
),
277 "%-6s %-24s", unit_str
.name
, test_str
.name
);
281 #define EFX_CHANNEL_NAME(_channel) "chan%d", _channel->channel
282 #define EFX_TX_QUEUE_NAME(_tx_queue) "txq%d", _tx_queue->queue
283 #define EFX_RX_QUEUE_NAME(_rx_queue) "rxq%d", _rx_queue->queue
284 #define EFX_LOOPBACK_NAME(_mode, _counter) \
285 "loopback.%s." _counter, STRING_TABLE_LOOKUP(_mode, efx_loopback_mode)
288 * efx_fill_loopback_test - fill in a block of loopback self-test entries
290 * @lb_tests: Efx loopback self-test results structure
291 * @mode: Loopback test mode
292 * @test_index: Starting index of the test
293 * @strings: Ethtool strings, or %NULL
294 * @data: Ethtool test results, or %NULL
296 static int efx_fill_loopback_test(struct efx_nic
*efx
,
297 struct efx_loopback_self_tests
*lb_tests
,
298 enum efx_loopback_mode mode
,
299 unsigned int test_index
,
300 struct ethtool_string
*strings
, u64
*data
)
302 struct efx_tx_queue
*tx_queue
;
304 efx_for_each_tx_queue(tx_queue
, efx
) {
305 efx_fill_test(test_index
++, strings
, data
,
306 &lb_tests
->tx_sent
[tx_queue
->queue
],
307 EFX_TX_QUEUE_NAME(tx_queue
),
308 EFX_LOOPBACK_NAME(mode
, "tx_sent"));
309 efx_fill_test(test_index
++, strings
, data
,
310 &lb_tests
->tx_done
[tx_queue
->queue
],
311 EFX_TX_QUEUE_NAME(tx_queue
),
312 EFX_LOOPBACK_NAME(mode
, "tx_done"));
314 efx_fill_test(test_index
++, strings
, data
,
317 EFX_LOOPBACK_NAME(mode
, "rx_good"));
318 efx_fill_test(test_index
++, strings
, data
,
321 EFX_LOOPBACK_NAME(mode
, "rx_bad"));
327 * efx_ethtool_fill_self_tests - get self-test details
329 * @tests: Efx self-test results structure, or %NULL
330 * @strings: Ethtool strings, or %NULL
331 * @data: Ethtool test results, or %NULL
333 static int efx_ethtool_fill_self_tests(struct efx_nic
*efx
,
334 struct efx_self_tests
*tests
,
335 struct ethtool_string
*strings
,
338 struct efx_channel
*channel
;
339 unsigned int n
= 0, i
;
340 enum efx_loopback_mode mode
;
342 efx_fill_test(n
++, strings
, data
, &tests
->mdio
,
343 "core", 0, "mdio", NULL
);
344 efx_fill_test(n
++, strings
, data
, &tests
->nvram
,
345 "core", 0, "nvram", NULL
);
346 efx_fill_test(n
++, strings
, data
, &tests
->interrupt
,
347 "core", 0, "interrupt", NULL
);
350 efx_for_each_channel(channel
, efx
) {
351 efx_fill_test(n
++, strings
, data
,
352 &tests
->eventq_dma
[channel
->channel
],
353 EFX_CHANNEL_NAME(channel
),
355 efx_fill_test(n
++, strings
, data
,
356 &tests
->eventq_int
[channel
->channel
],
357 EFX_CHANNEL_NAME(channel
),
359 efx_fill_test(n
++, strings
, data
,
360 &tests
->eventq_poll
[channel
->channel
],
361 EFX_CHANNEL_NAME(channel
),
362 "eventq.poll", NULL
);
365 efx_fill_test(n
++, strings
, data
, &tests
->registers
,
366 "core", 0, "registers", NULL
);
368 if (efx
->phy_op
->run_tests
!= NULL
) {
369 EFX_BUG_ON_PARANOID(efx
->phy_op
->test_name
== NULL
);
371 for (i
= 0; true; ++i
) {
374 EFX_BUG_ON_PARANOID(i
>= EFX_MAX_PHY_TESTS
);
375 name
= efx
->phy_op
->test_name(efx
, i
);
379 efx_fill_test(n
++, strings
, data
, &tests
->phy
[i
],
380 "phy", 0, name
, NULL
);
385 for (mode
= LOOPBACK_NONE
; mode
<= LOOPBACK_TEST_MAX
; mode
++) {
386 if (!(efx
->loopback_modes
& (1 << mode
)))
388 n
= efx_fill_loopback_test(efx
,
389 &tests
->loopback
[mode
], mode
, n
,
396 static int efx_ethtool_get_sset_count(struct net_device
*net_dev
,
399 switch (string_set
) {
401 return EFX_ETHTOOL_NUM_STATS
;
403 return efx_ethtool_fill_self_tests(netdev_priv(net_dev
),
410 static void efx_ethtool_get_strings(struct net_device
*net_dev
,
411 u32 string_set
, u8
*strings
)
413 struct efx_nic
*efx
= netdev_priv(net_dev
);
414 struct ethtool_string
*ethtool_strings
=
415 (struct ethtool_string
*)strings
;
418 switch (string_set
) {
420 for (i
= 0; i
< EFX_ETHTOOL_NUM_STATS
; i
++)
421 strncpy(ethtool_strings
[i
].name
,
422 efx_ethtool_stats
[i
].name
,
423 sizeof(ethtool_strings
[i
].name
));
426 efx_ethtool_fill_self_tests(efx
, NULL
,
427 ethtool_strings
, NULL
);
430 /* No other string sets */
435 static void efx_ethtool_get_stats(struct net_device
*net_dev
,
436 struct ethtool_stats
*stats
,
439 struct efx_nic
*efx
= netdev_priv(net_dev
);
440 struct efx_mac_stats
*mac_stats
= &efx
->mac_stats
;
441 struct efx_ethtool_stat
*stat
;
442 struct efx_channel
*channel
;
445 EFX_BUG_ON_PARANOID(stats
->n_stats
!= EFX_ETHTOOL_NUM_STATS
);
447 /* Update MAC and NIC statistics */
448 dev_get_stats(net_dev
);
450 /* Fill detailed statistics buffer */
451 for (i
= 0; i
< EFX_ETHTOOL_NUM_STATS
; i
++) {
452 stat
= &efx_ethtool_stats
[i
];
453 switch (stat
->source
) {
454 case EFX_ETHTOOL_STAT_SOURCE_mac_stats
:
455 data
[i
] = stat
->get_stat((void *)mac_stats
+
458 case EFX_ETHTOOL_STAT_SOURCE_nic
:
459 data
[i
] = stat
->get_stat((void *)efx
+ stat
->offset
);
461 case EFX_ETHTOOL_STAT_SOURCE_channel
:
463 efx_for_each_channel(channel
, efx
)
464 data
[i
] += stat
->get_stat((void *)channel
+
471 static int efx_ethtool_set_tx_csum(struct net_device
*net_dev
, u32 enable
)
473 struct efx_nic
*efx
= netdev_priv(net_dev
);
474 unsigned long features
= efx
->type
->offload_features
& NETIF_F_ALL_CSUM
;
477 net_dev
->features
|= features
;
479 net_dev
->features
&= ~features
;
484 static int efx_ethtool_set_rx_csum(struct net_device
*net_dev
, u32 enable
)
486 struct efx_nic
*efx
= netdev_priv(net_dev
);
488 /* No way to stop the hardware doing the checks; we just
491 efx
->rx_checksum_enabled
= !!enable
;
496 static u32
efx_ethtool_get_rx_csum(struct net_device
*net_dev
)
498 struct efx_nic
*efx
= netdev_priv(net_dev
);
500 return efx
->rx_checksum_enabled
;
503 static void efx_ethtool_self_test(struct net_device
*net_dev
,
504 struct ethtool_test
*test
, u64
*data
)
506 struct efx_nic
*efx
= netdev_priv(net_dev
);
507 struct efx_self_tests efx_tests
;
512 if (efx
->state
!= STATE_RUNNING
) {
517 /* We need rx buffers and interrupts. */
518 already_up
= (efx
->net_dev
->flags
& IFF_UP
);
520 rc
= dev_open(efx
->net_dev
);
522 EFX_ERR(efx
, "failed opening device.\n");
527 memset(&efx_tests
, 0, sizeof(efx_tests
));
529 rc
= efx_selftest(efx
, &efx_tests
, test
->flags
);
532 dev_close(efx
->net_dev
);
534 EFX_LOG(efx
, "%s %sline self-tests\n",
535 rc
== 0 ? "passed" : "failed",
536 (test
->flags
& ETH_TEST_FL_OFFLINE
) ? "off" : "on");
540 /* Fill ethtool results structures */
541 efx_ethtool_fill_self_tests(efx
, &efx_tests
, NULL
, data
);
543 test
->flags
|= ETH_TEST_FL_FAILED
;
546 /* Restart autonegotiation */
547 static int efx_ethtool_nway_reset(struct net_device
*net_dev
)
549 struct efx_nic
*efx
= netdev_priv(net_dev
);
551 return mdio45_nway_restart(&efx
->mdio
);
554 static u32
efx_ethtool_get_link(struct net_device
*net_dev
)
556 struct efx_nic
*efx
= netdev_priv(net_dev
);
558 return efx
->link_state
.up
;
561 static int efx_ethtool_get_eeprom_len(struct net_device
*net_dev
)
563 struct efx_nic
*efx
= netdev_priv(net_dev
);
564 struct efx_spi_device
*spi
= efx
->spi_eeprom
;
568 return min(spi
->size
, EFX_EEPROM_BOOTCONFIG_END
) -
569 min(spi
->size
, EFX_EEPROM_BOOTCONFIG_START
);
572 static int efx_ethtool_get_eeprom(struct net_device
*net_dev
,
573 struct ethtool_eeprom
*eeprom
, u8
*buf
)
575 struct efx_nic
*efx
= netdev_priv(net_dev
);
576 struct efx_spi_device
*spi
= efx
->spi_eeprom
;
580 rc
= mutex_lock_interruptible(&efx
->spi_lock
);
583 rc
= falcon_spi_read(efx
, spi
,
584 eeprom
->offset
+ EFX_EEPROM_BOOTCONFIG_START
,
585 eeprom
->len
, &len
, buf
);
586 mutex_unlock(&efx
->spi_lock
);
588 eeprom
->magic
= EFX_ETHTOOL_EEPROM_MAGIC
;
593 static int efx_ethtool_set_eeprom(struct net_device
*net_dev
,
594 struct ethtool_eeprom
*eeprom
, u8
*buf
)
596 struct efx_nic
*efx
= netdev_priv(net_dev
);
597 struct efx_spi_device
*spi
= efx
->spi_eeprom
;
601 if (eeprom
->magic
!= EFX_ETHTOOL_EEPROM_MAGIC
)
604 rc
= mutex_lock_interruptible(&efx
->spi_lock
);
607 rc
= falcon_spi_write(efx
, spi
,
608 eeprom
->offset
+ EFX_EEPROM_BOOTCONFIG_START
,
609 eeprom
->len
, &len
, buf
);
610 mutex_unlock(&efx
->spi_lock
);
616 static int efx_ethtool_get_coalesce(struct net_device
*net_dev
,
617 struct ethtool_coalesce
*coalesce
)
619 struct efx_nic
*efx
= netdev_priv(net_dev
);
620 struct efx_tx_queue
*tx_queue
;
621 struct efx_channel
*channel
;
623 memset(coalesce
, 0, sizeof(*coalesce
));
625 /* Find lowest IRQ moderation across all used TX queues */
626 coalesce
->tx_coalesce_usecs_irq
= ~((u32
) 0);
627 efx_for_each_tx_queue(tx_queue
, efx
) {
628 channel
= tx_queue
->channel
;
629 if (channel
->irq_moderation
< coalesce
->tx_coalesce_usecs_irq
) {
630 if (channel
->used_flags
!= EFX_USED_BY_RX_TX
)
631 coalesce
->tx_coalesce_usecs_irq
=
632 channel
->irq_moderation
;
634 coalesce
->tx_coalesce_usecs_irq
= 0;
638 coalesce
->use_adaptive_rx_coalesce
= efx
->irq_rx_adaptive
;
639 coalesce
->rx_coalesce_usecs_irq
= efx
->irq_rx_moderation
;
641 coalesce
->tx_coalesce_usecs_irq
*= EFX_IRQ_MOD_RESOLUTION
;
642 coalesce
->rx_coalesce_usecs_irq
*= EFX_IRQ_MOD_RESOLUTION
;
647 /* Set coalescing parameters
648 * The difficulties occur for shared channels
650 static int efx_ethtool_set_coalesce(struct net_device
*net_dev
,
651 struct ethtool_coalesce
*coalesce
)
653 struct efx_nic
*efx
= netdev_priv(net_dev
);
654 struct efx_channel
*channel
;
655 struct efx_tx_queue
*tx_queue
;
656 unsigned tx_usecs
, rx_usecs
, adaptive
;
658 if (coalesce
->use_adaptive_tx_coalesce
)
661 if (coalesce
->rx_coalesce_usecs
|| coalesce
->tx_coalesce_usecs
) {
662 EFX_ERR(efx
, "invalid coalescing setting. "
663 "Only rx/tx_coalesce_usecs_irq are supported\n");
667 rx_usecs
= coalesce
->rx_coalesce_usecs_irq
;
668 tx_usecs
= coalesce
->tx_coalesce_usecs_irq
;
669 adaptive
= coalesce
->use_adaptive_rx_coalesce
;
671 /* If the channel is shared only allow RX parameters to be set */
672 efx_for_each_tx_queue(tx_queue
, efx
) {
673 if ((tx_queue
->channel
->used_flags
== EFX_USED_BY_RX_TX
) &&
675 EFX_ERR(efx
, "Channel is shared. "
676 "Only RX coalescing may be set\n");
681 efx_init_irq_moderation(efx
, tx_usecs
, rx_usecs
, adaptive
);
682 efx_for_each_channel(channel
, efx
)
683 efx
->type
->push_irq_moderation(channel
);
688 static int efx_ethtool_set_pauseparam(struct net_device
*net_dev
,
689 struct ethtool_pauseparam
*pause
)
691 struct efx_nic
*efx
= netdev_priv(net_dev
);
692 enum efx_fc_type wanted_fc
, old_fc
;
697 mutex_lock(&efx
->mac_lock
);
699 wanted_fc
= ((pause
->rx_pause
? EFX_FC_RX
: 0) |
700 (pause
->tx_pause
? EFX_FC_TX
: 0) |
701 (pause
->autoneg
? EFX_FC_AUTO
: 0));
703 if ((wanted_fc
& EFX_FC_TX
) && !(wanted_fc
& EFX_FC_RX
)) {
704 EFX_LOG(efx
, "Flow control unsupported: tx ON rx OFF\n");
709 if ((wanted_fc
& EFX_FC_AUTO
) && !efx
->link_advertising
) {
710 EFX_LOG(efx
, "Autonegotiation is disabled\n");
715 /* TX flow control may automatically turn itself off if the
716 * link partner (intermittently) stops responding to pause
717 * frames. There isn't any indication that this has happened,
718 * so the best we do is leave it up to the user to spot this
719 * and fix it be cycling transmit flow control on this end. */
720 reset
= (wanted_fc
& EFX_FC_TX
) && !(efx
->wanted_fc
& EFX_FC_TX
);
721 if (EFX_WORKAROUND_11482(efx
) && reset
) {
722 if (efx_nic_rev(efx
) == EFX_REV_FALCON_B0
) {
723 /* Recover by resetting the EM block */
724 falcon_stop_nic_stats(efx
);
725 falcon_drain_tx_fifo(efx
);
726 efx
->mac_op
->reconfigure(efx
);
727 falcon_start_nic_stats(efx
);
729 /* Schedule a reset to recover */
730 efx_schedule_reset(efx
, RESET_TYPE_INVISIBLE
);
734 old_adv
= efx
->link_advertising
;
735 old_fc
= efx
->wanted_fc
;
736 efx_link_set_wanted_fc(efx
, wanted_fc
);
737 if (efx
->link_advertising
!= old_adv
||
738 (efx
->wanted_fc
^ old_fc
) & EFX_FC_AUTO
) {
739 rc
= efx
->phy_op
->reconfigure(efx
);
741 EFX_ERR(efx
, "Unable to advertise requested flow "
742 "control setting\n");
747 /* Reconfigure the MAC. The PHY *may* generate a link state change event
748 * if the user just changed the advertised capabilities, but there's no
749 * harm doing this twice */
750 efx
->mac_op
->reconfigure(efx
);
753 mutex_unlock(&efx
->mac_lock
);
758 static void efx_ethtool_get_pauseparam(struct net_device
*net_dev
,
759 struct ethtool_pauseparam
*pause
)
761 struct efx_nic
*efx
= netdev_priv(net_dev
);
763 pause
->rx_pause
= !!(efx
->wanted_fc
& EFX_FC_RX
);
764 pause
->tx_pause
= !!(efx
->wanted_fc
& EFX_FC_TX
);
765 pause
->autoneg
= !!(efx
->wanted_fc
& EFX_FC_AUTO
);
769 static void efx_ethtool_get_wol(struct net_device
*net_dev
,
770 struct ethtool_wolinfo
*wol
)
772 struct efx_nic
*efx
= netdev_priv(net_dev
);
773 return efx
->type
->get_wol(efx
, wol
);
777 static int efx_ethtool_set_wol(struct net_device
*net_dev
,
778 struct ethtool_wolinfo
*wol
)
780 struct efx_nic
*efx
= netdev_priv(net_dev
);
781 return efx
->type
->set_wol(efx
, wol
->wolopts
);
784 extern int efx_ethtool_reset(struct net_device
*net_dev
, u32
*flags
)
786 struct efx_nic
*efx
= netdev_priv(net_dev
);
787 enum reset_type method
;
789 ETH_RESET_EFX_INVISIBLE
= (ETH_RESET_DMA
| ETH_RESET_FILTER
|
790 ETH_RESET_OFFLOAD
| ETH_RESET_MAC
)
793 /* Check for minimal reset flags */
794 if ((*flags
& ETH_RESET_EFX_INVISIBLE
) != ETH_RESET_EFX_INVISIBLE
)
796 *flags
^= ETH_RESET_EFX_INVISIBLE
;
797 method
= RESET_TYPE_INVISIBLE
;
799 if (*flags
& ETH_RESET_PHY
) {
800 *flags
^= ETH_RESET_PHY
;
801 method
= RESET_TYPE_ALL
;
804 if ((*flags
& efx
->type
->reset_world_flags
) ==
805 efx
->type
->reset_world_flags
) {
806 *flags
^= efx
->type
->reset_world_flags
;
807 method
= RESET_TYPE_WORLD
;
810 return efx_reset(efx
, method
);
813 const struct ethtool_ops efx_ethtool_ops
= {
814 .get_settings
= efx_ethtool_get_settings
,
815 .set_settings
= efx_ethtool_set_settings
,
816 .get_drvinfo
= efx_ethtool_get_drvinfo
,
817 .nway_reset
= efx_ethtool_nway_reset
,
818 .get_link
= efx_ethtool_get_link
,
819 .get_eeprom_len
= efx_ethtool_get_eeprom_len
,
820 .get_eeprom
= efx_ethtool_get_eeprom
,
821 .set_eeprom
= efx_ethtool_set_eeprom
,
822 .get_coalesce
= efx_ethtool_get_coalesce
,
823 .set_coalesce
= efx_ethtool_set_coalesce
,
824 .get_pauseparam
= efx_ethtool_get_pauseparam
,
825 .set_pauseparam
= efx_ethtool_set_pauseparam
,
826 .get_rx_csum
= efx_ethtool_get_rx_csum
,
827 .set_rx_csum
= efx_ethtool_set_rx_csum
,
828 .get_tx_csum
= ethtool_op_get_tx_csum
,
829 /* Need to enable/disable IPv6 too */
830 .set_tx_csum
= efx_ethtool_set_tx_csum
,
831 .get_sg
= ethtool_op_get_sg
,
832 .set_sg
= ethtool_op_set_sg
,
833 .get_tso
= ethtool_op_get_tso
,
834 .set_tso
= ethtool_op_set_tso
,
835 .get_flags
= ethtool_op_get_flags
,
836 .set_flags
= ethtool_op_set_flags
,
837 .get_sset_count
= efx_ethtool_get_sset_count
,
838 .self_test
= efx_ethtool_self_test
,
839 .get_strings
= efx_ethtool_get_strings
,
840 .phys_id
= efx_ethtool_phys_id
,
841 .get_ethtool_stats
= efx_ethtool_get_stats
,
842 .get_wol
= efx_ethtool_get_wol
,
843 .set_wol
= efx_ethtool_set_wol
,
844 .reset
= efx_ethtool_reset
,