diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/sfc/ethtool.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/sfc/ethtool.c')
-rw-r--r-- | drivers/net/sfc/ethtool.c | 1012 |
1 files changed, 1012 insertions, 0 deletions
diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c new file mode 100644 index 00000000000..bc4643af6dd --- /dev/null +++ b/drivers/net/sfc/ethtool.c | |||
@@ -0,0 +1,1012 @@ | |||
1 | /**************************************************************************** | ||
2 | * Driver for Solarflare Solarstorm network controllers and boards | ||
3 | * Copyright 2005-2006 Fen Systems Ltd. | ||
4 | * Copyright 2006-2010 Solarflare Communications Inc. | ||
5 | * | ||
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. | ||
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 | |||
22 | struct ethtool_string { | ||
23 | char name[ETH_GSTRING_LEN]; | ||
24 | }; | ||
25 | |||
26 | struct 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); /* Reader function */ | ||
36 | }; | ||
37 | |||
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) { \ | ||
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 | |||
50 | static u64 efx_get_uint_stat(void *field) | ||
51 | { | ||
52 | return *(unsigned int *)field; | ||
53 | } | ||
54 | |||
55 | static u64 efx_get_ulong_stat(void *field) | ||
56 | { | ||
57 | return *(unsigned long *)field; | ||
58 | } | ||
59 | |||
60 | static u64 efx_get_u64_stat(void *field) | ||
61 | { | ||
62 | return *(u64 *) field; | ||
63 | } | ||
64 | |||
65 | static 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 | |||
94 | static 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 | /* Number of ethtool statistics */ | ||
169 | #define EFX_ETHTOOL_NUM_STATS ARRAY_SIZE(efx_ethtool_stats) | ||
170 | |||
171 | #define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB | ||
172 | |||
173 | /************************************************************************** | ||
174 | * | ||
175 | * Ethtool operations | ||
176 | * | ||
177 | ************************************************************************** | ||
178 | */ | ||
179 | |||
180 | /* Identify device by flashing LEDs */ | ||
181 | static 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; /* cycle on/off once per second */ | ||
199 | } | ||
200 | |||
201 | efx->type->set_id_led(efx, mode); | ||
202 | return 0; | ||
203 | } | ||
204 | |||
205 | /* This must be called with rtnl_lock held. */ | ||
206 | static 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 | /* GMAC does not support 1000Mbps HD */ | ||
217 | ecmd->supported &= ~SUPPORTED_1000baseT_Half; | ||
218 | /* Both MACs support pause frames (bidirectional and respond-only) */ | ||
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 | /* This must be called with rtnl_lock held. */ | ||
230 | static 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 | /* GMAC does not support 1000Mbps HD */ | ||
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 | |||
250 | static 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 | |||
263 | static 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 | |||
268 | static 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 | |||
277 | static 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 | |||
283 | static 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 | * efx_fill_test - fill in an individual self-test entry | ||
291 | * @test_index: Index of the test | ||
292 | * @strings: Ethtool strings, or %NULL | ||
293 | * @data: Ethtool test results, or %NULL | ||
294 | * @test: Pointer to test result (used only if data != %NULL) | ||
295 | * @unit_format: Unit name format (e.g. "chan\%d") | ||
296 | * @unit_id: Unit id (e.g. 0 for "chan0") | ||
297 | * @test_format: Test name format (e.g. "loopback.\%s.tx.sent") | ||
298 | * @test_id: Test id (e.g. "PHYXS" for "loopback.PHYXS.tx_sent") | ||
299 | * | ||
300 | * Fill in an individual self-test entry. | ||
301 | */ | ||
302 | static 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 | /* Fill data value, if applicable */ | ||
310 | if (data) | ||
311 | data[test_index] = *test; | ||
312 | |||
313 | /* Fill string, if applicable */ | ||
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 | * efx_fill_loopback_test - fill in a block of loopback self-test entries | ||
336 | * @efx: Efx NIC | ||
337 | * @lb_tests: Efx loopback self-test results structure | ||
338 | * @mode: Loopback test mode | ||
339 | * @test_index: Starting index of the test | ||
340 | * @strings: Ethtool strings, or %NULL | ||
341 | * @data: Ethtool test results, or %NULL | ||
342 | */ | ||
343 | static 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 | * efx_ethtool_fill_self_tests - get self-test details | ||
376 | * @efx: Efx NIC | ||
377 | * @tests: Efx self-test results structure, or %NULL | ||
378 | * @strings: Ethtool strings, or %NULL | ||
379 | * @data: Ethtool test results, or %NULL | ||
380 | */ | ||
381 | static 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 | /* Event queues */ | ||
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 | /* Loopback tests */ | ||
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 | |||
444 | static 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 | |||
458 | static 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 | /* No other string sets */ | ||
479 | break; | ||
480 | } | ||
481 | } | ||
482 | |||
483 | static 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 | /* Update MAC and NIC statistics */ | ||
498 | dev_get_stats(net_dev, &temp); | ||
499 | |||
500 | /* Fill detailed statistics buffer */ | ||
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 | |||
530 | static 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 | /* We need rx buffers and interrupts. */ | ||
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 | |||
572 | fail1: | ||
573 | /* Fill ethtool results structures */ | ||
574 | efx_ethtool_fill_self_tests(efx, efx_tests, NULL, data); | ||
575 | kfree(efx_tests); | ||
576 | fail: | ||
577 | if (rc) | ||
578 | test->flags |= ETH_TEST_FL_FAILED; | ||
579 | } | ||
580 | |||
581 | /* Restart autonegotiation */ | ||
582 | static 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 | static int efx_ethtool_get_coalesce(struct net_device *net_dev, | ||
590 | struct ethtool_coalesce *coalesce) | ||
591 | { | ||
592 | struct efx_nic *efx = netdev_priv(net_dev); | ||
593 | struct efx_channel *channel; | ||
594 | |||
595 | memset(coalesce, 0, sizeof(*coalesce)); | ||
596 | |||
597 | /* Find lowest IRQ moderation across all used TX queues */ | ||
598 | coalesce->tx_coalesce_usecs_irq = ~((u32) 0); | ||
599 | efx_for_each_channel(channel, efx) { | ||
600 | if (!efx_channel_has_tx_queues(channel)) | ||
601 | continue; | ||
602 | if (channel->irq_moderation < coalesce->tx_coalesce_usecs_irq) { | ||
603 | if (channel->channel < efx->n_rx_channels) | ||
604 | coalesce->tx_coalesce_usecs_irq = | ||
605 | channel->irq_moderation; | ||
606 | else | ||
607 | coalesce->tx_coalesce_usecs_irq = 0; | ||
608 | } | ||
609 | } | ||
610 | |||
611 | coalesce->use_adaptive_rx_coalesce = efx->irq_rx_adaptive; | ||
612 | coalesce->rx_coalesce_usecs_irq = efx->irq_rx_moderation; | ||
613 | |||
614 | coalesce->tx_coalesce_usecs_irq *= EFX_IRQ_MOD_RESOLUTION; | ||
615 | coalesce->rx_coalesce_usecs_irq *= EFX_IRQ_MOD_RESOLUTION; | ||
616 | |||
617 | return 0; | ||
618 | } | ||
619 | |||
620 | /* Set coalescing parameters | ||
621 | * The difficulties occur for shared channels | ||
622 | */ | ||
623 | static int efx_ethtool_set_coalesce(struct net_device *net_dev, | ||
624 | struct ethtool_coalesce *coalesce) | ||
625 | { | ||
626 | struct efx_nic *efx = netdev_priv(net_dev); | ||
627 | struct efx_channel *channel; | ||
628 | unsigned tx_usecs, rx_usecs, adaptive; | ||
629 | |||
630 | if (coalesce->use_adaptive_tx_coalesce) | ||
631 | return -EOPNOTSUPP; | ||
632 | |||
633 | if (coalesce->rx_coalesce_usecs || coalesce->tx_coalesce_usecs) { | ||
634 | netif_err(efx, drv, efx->net_dev, "invalid coalescing setting. " | ||
635 | "Only rx/tx_coalesce_usecs_irq are supported\n"); | ||
636 | return -EOPNOTSUPP; | ||
637 | } | ||
638 | |||
639 | rx_usecs = coalesce->rx_coalesce_usecs_irq; | ||
640 | tx_usecs = coalesce->tx_coalesce_usecs_irq; | ||
641 | adaptive = coalesce->use_adaptive_rx_coalesce; | ||
642 | |||
643 | /* If the channel is shared only allow RX parameters to be set */ | ||
644 | efx_for_each_channel(channel, efx) { | ||
645 | if (efx_channel_has_rx_queue(channel) && | ||
646 | efx_channel_has_tx_queues(channel) && | ||
647 | tx_usecs) { | ||
648 | netif_err(efx, drv, efx->net_dev, "Channel is shared. " | ||
649 | "Only RX coalescing may be set\n"); | ||
650 | return -EOPNOTSUPP; | ||
651 | } | ||
652 | } | ||
653 | |||
654 | efx_init_irq_moderation(efx, tx_usecs, rx_usecs, adaptive); | ||
655 | efx_for_each_channel(channel, efx) | ||
656 | efx->type->push_irq_moderation(channel); | ||
657 | |||
658 | return 0; | ||
659 | } | ||
660 | |||
661 | static void efx_ethtool_get_ringparam(struct net_device *net_dev, | ||
662 | struct ethtool_ringparam *ring) | ||
663 | { | ||
664 | struct efx_nic *efx = netdev_priv(net_dev); | ||
665 | |||
666 | ring->rx_max_pending = EFX_MAX_DMAQ_SIZE; | ||
667 | ring->tx_max_pending = EFX_MAX_DMAQ_SIZE; | ||
668 | ring->rx_mini_max_pending = 0; | ||
669 | ring->rx_jumbo_max_pending = 0; | ||
670 | ring->rx_pending = efx->rxq_entries; | ||
671 | ring->tx_pending = efx->txq_entries; | ||
672 | ring->rx_mini_pending = 0; | ||
673 | ring->rx_jumbo_pending = 0; | ||
674 | } | ||
675 | |||
676 | static int efx_ethtool_set_ringparam(struct net_device *net_dev, | ||
677 | struct ethtool_ringparam *ring) | ||
678 | { | ||
679 | struct efx_nic *efx = netdev_priv(net_dev); | ||
680 | |||
681 | if (ring->rx_mini_pending || ring->rx_jumbo_pending || | ||
682 | ring->rx_pending > EFX_MAX_DMAQ_SIZE || | ||
683 | ring->tx_pending > EFX_MAX_DMAQ_SIZE) | ||
684 | return -EINVAL; | ||
685 | |||
686 | if (ring->rx_pending < EFX_MIN_RING_SIZE || | ||
687 | ring->tx_pending < EFX_MIN_RING_SIZE) { | ||
688 | netif_err(efx, drv, efx->net_dev, | ||
689 | "TX and RX queues cannot be smaller than %ld\n", | ||
690 | EFX_MIN_RING_SIZE); | ||
691 | return -EINVAL; | ||
692 | } | ||
693 | |||
694 | return efx_realloc_channels(efx, ring->rx_pending, ring->tx_pending); | ||
695 | } | ||
696 | |||
697 | static int efx_ethtool_set_pauseparam(struct net_device *net_dev, | ||
698 | struct ethtool_pauseparam *pause) | ||
699 | { | ||
700 | struct efx_nic *efx = netdev_priv(net_dev); | ||
701 | u8 wanted_fc, old_fc; | ||
702 | u32 old_adv; | ||
703 | bool reset; | ||
704 | int rc = 0; | ||
705 | |||
706 | mutex_lock(&efx->mac_lock); | ||
707 | |||
708 | wanted_fc = ((pause->rx_pause ? EFX_FC_RX : 0) | | ||
709 | (pause->tx_pause ? EFX_FC_TX : 0) | | ||
710 | (pause->autoneg ? EFX_FC_AUTO : 0)); | ||
711 | |||
712 | if ((wanted_fc & EFX_FC_TX) && !(wanted_fc & EFX_FC_RX)) { | ||
713 | netif_dbg(efx, drv, efx->net_dev, | ||
714 | "Flow control unsupported: tx ON rx OFF\n"); | ||
715 | rc = -EINVAL; | ||
716 | goto out; | ||
717 | } | ||
718 | |||
719 | if ((wanted_fc & EFX_FC_AUTO) && !efx->link_advertising) { | ||
720 | netif_dbg(efx, drv, efx->net_dev, | ||
721 | "Autonegotiation is disabled\n"); | ||
722 | rc = -EINVAL; | ||
723 | goto out; | ||
724 | } | ||
725 | |||
726 | /* TX flow control may automatically turn itself off if the | ||
727 | * link partner (intermittently) stops responding to pause | ||
728 | * frames. There isn't any indication that this has happened, | ||
729 | * so the best we do is leave it up to the user to spot this | ||
730 | * and fix it be cycling transmit flow control on this end. */ | ||
731 | reset = (wanted_fc & EFX_FC_TX) && !(efx->wanted_fc & EFX_FC_TX); | ||
732 | if (EFX_WORKAROUND_11482(efx) && reset) { | ||
733 | if (efx_nic_rev(efx) == EFX_REV_FALCON_B0) { | ||
734 | /* Recover by resetting the EM block */ | ||
735 | falcon_stop_nic_stats(efx); | ||
736 | falcon_drain_tx_fifo(efx); | ||
737 | efx->mac_op->reconfigure(efx); | ||
738 | falcon_start_nic_stats(efx); | ||
739 | } else { | ||
740 | /* Schedule a reset to recover */ | ||
741 | efx_schedule_reset(efx, RESET_TYPE_INVISIBLE); | ||
742 | } | ||
743 | } | ||
744 | |||
745 | old_adv = efx->link_advertising; | ||
746 | old_fc = efx->wanted_fc; | ||
747 | efx_link_set_wanted_fc(efx, wanted_fc); | ||
748 | if (efx->link_advertising != old_adv || | ||
749 | (efx->wanted_fc ^ old_fc) & EFX_FC_AUTO) { | ||
750 | rc = efx->phy_op->reconfigure(efx); | ||
751 | if (rc) { | ||
752 | netif_err(efx, drv, efx->net_dev, | ||
753 | "Unable to advertise requested flow " | ||
754 | "control setting\n"); | ||
755 | goto out; | ||
756 | } | ||
757 | } | ||
758 | |||
759 | /* Reconfigure the MAC. The PHY *may* generate a link state change event | ||
760 | * if the user just changed the advertised capabilities, but there's no | ||
761 | * harm doing this twice */ | ||
762 | efx->mac_op->reconfigure(efx); | ||
763 | |||
764 | out: | ||
765 | mutex_unlock(&efx->mac_lock); | ||
766 | |||
767 | return rc; | ||
768 | } | ||
769 | |||
770 | static void efx_ethtool_get_pauseparam(struct net_device *net_dev, | ||
771 | struct ethtool_pauseparam *pause) | ||
772 | { | ||
773 | struct efx_nic *efx = netdev_priv(net_dev); | ||
774 | |||
775 | pause->rx_pause = !!(efx->wanted_fc & EFX_FC_RX); | ||
776 | pause->tx_pause = !!(efx->wanted_fc & EFX_FC_TX); | ||
777 | pause->autoneg = !!(efx->wanted_fc & EFX_FC_AUTO); | ||
778 | } | ||
779 | |||
780 | |||
781 | static void efx_ethtool_get_wol(struct net_device *net_dev, | ||
782 | struct ethtool_wolinfo *wol) | ||
783 | { | ||
784 | struct efx_nic *efx = netdev_priv(net_dev); | ||
785 | return efx->type->get_wol(efx, wol); | ||
786 | } | ||
787 | |||
788 | |||
789 | static int efx_ethtool_set_wol(struct net_device *net_dev, | ||
790 | struct ethtool_wolinfo *wol) | ||
791 | { | ||
792 | struct efx_nic *efx = netdev_priv(net_dev); | ||
793 | return efx->type->set_wol(efx, wol->wolopts); | ||
794 | } | ||
795 | |||
796 | static int efx_ethtool_reset(struct net_device *net_dev, u32 *flags) | ||
797 | { | ||
798 | struct efx_nic *efx = netdev_priv(net_dev); | ||
799 | int rc; | ||
800 | |||
801 | rc = efx->type->map_reset_flags(flags); | ||
802 | if (rc < 0) | ||
803 | return rc; | ||
804 | |||
805 | return efx_reset(efx, rc); | ||
806 | } | ||
807 | |||
808 | static int | ||
809 | efx_ethtool_get_rxnfc(struct net_device *net_dev, | ||
810 | struct ethtool_rxnfc *info, void *rules __always_unused) | ||
811 | { | ||
812 | struct efx_nic *efx = netdev_priv(net_dev); | ||
813 | |||
814 | switch (info->cmd) { | ||
815 | case ETHTOOL_GRXRINGS: | ||
816 | info->data = efx->n_rx_channels; | ||
817 | return 0; | ||
818 | |||
819 | case ETHTOOL_GRXFH: { | ||
820 | unsigned min_revision = 0; | ||
821 | |||
822 | info->data = 0; | ||
823 | switch (info->flow_type) { | ||
824 | case TCP_V4_FLOW: | ||
825 | info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; | ||
826 | /* fall through */ | ||
827 | case UDP_V4_FLOW: | ||
828 | case SCTP_V4_FLOW: | ||
829 | case AH_ESP_V4_FLOW: | ||
830 | case IPV4_FLOW: | ||
831 | info->data |= RXH_IP_SRC | RXH_IP_DST; | ||
832 | min_revision = EFX_REV_FALCON_B0; | ||
833 | break; | ||
834 | case TCP_V6_FLOW: | ||
835 | info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; | ||
836 | /* fall through */ | ||
837 | case UDP_V6_FLOW: | ||
838 | case SCTP_V6_FLOW: | ||
839 | case AH_ESP_V6_FLOW: | ||
840 | case IPV6_FLOW: | ||
841 | info->data |= RXH_IP_SRC | RXH_IP_DST; | ||
842 | min_revision = EFX_REV_SIENA_A0; | ||
843 | break; | ||
844 | default: | ||
845 | break; | ||
846 | } | ||
847 | if (efx_nic_rev(efx) < min_revision) | ||
848 | info->data = 0; | ||
849 | return 0; | ||
850 | } | ||
851 | |||
852 | default: | ||
853 | return -EOPNOTSUPP; | ||
854 | } | ||
855 | } | ||
856 | |||
857 | static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev, | ||
858 | struct ethtool_rx_ntuple *ntuple) | ||
859 | { | ||
860 | struct efx_nic *efx = netdev_priv(net_dev); | ||
861 | struct ethtool_tcpip4_spec *ip_entry = &ntuple->fs.h_u.tcp_ip4_spec; | ||
862 | struct ethtool_tcpip4_spec *ip_mask = &ntuple->fs.m_u.tcp_ip4_spec; | ||
863 | struct ethhdr *mac_entry = &ntuple->fs.h_u.ether_spec; | ||
864 | struct ethhdr *mac_mask = &ntuple->fs.m_u.ether_spec; | ||
865 | struct efx_filter_spec filter; | ||
866 | int rc; | ||
867 | |||
868 | /* Range-check action */ | ||
869 | if (ntuple->fs.action < ETHTOOL_RXNTUPLE_ACTION_CLEAR || | ||
870 | ntuple->fs.action >= (s32)efx->n_rx_channels) | ||
871 | return -EINVAL; | ||
872 | |||
873 | if (~ntuple->fs.data_mask) | ||
874 | return -EINVAL; | ||
875 | |||
876 | efx_filter_init_rx(&filter, EFX_FILTER_PRI_MANUAL, 0, | ||
877 | (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP) ? | ||
878 | 0xfff : ntuple->fs.action); | ||
879 | |||
880 | switch (ntuple->fs.flow_type) { | ||
881 | case TCP_V4_FLOW: | ||
882 | case UDP_V4_FLOW: { | ||
883 | u8 proto = (ntuple->fs.flow_type == TCP_V4_FLOW ? | ||
884 | IPPROTO_TCP : IPPROTO_UDP); | ||
885 | |||
886 | /* Must match all of destination, */ | ||
887 | if (ip_mask->ip4dst | ip_mask->pdst) | ||
888 | return -EINVAL; | ||
889 | /* all or none of source, */ | ||
890 | if ((ip_mask->ip4src | ip_mask->psrc) && | ||
891 | ((__force u32)~ip_mask->ip4src | | ||
892 | (__force u16)~ip_mask->psrc)) | ||
893 | return -EINVAL; | ||
894 | /* and nothing else */ | ||
895 | if ((u8)~ip_mask->tos | (u16)~ntuple->fs.vlan_tag_mask) | ||
896 | return -EINVAL; | ||
897 | |||
898 | if (!ip_mask->ip4src) | ||
899 | rc = efx_filter_set_ipv4_full(&filter, proto, | ||
900 | ip_entry->ip4dst, | ||
901 | ip_entry->pdst, | ||
902 | ip_entry->ip4src, | ||
903 | ip_entry->psrc); | ||
904 | else | ||
905 | rc = efx_filter_set_ipv4_local(&filter, proto, | ||
906 | ip_entry->ip4dst, | ||
907 | ip_entry->pdst); | ||
908 | if (rc) | ||
909 | return rc; | ||
910 | break; | ||
911 | } | ||
912 | |||
913 | case ETHER_FLOW: | ||
914 | /* Must match all of destination, */ | ||
915 | if (!is_zero_ether_addr(mac_mask->h_dest)) | ||
916 | return -EINVAL; | ||
917 | /* all or none of VID, */ | ||
918 | if (ntuple->fs.vlan_tag_mask != 0xf000 && | ||
919 | ntuple->fs.vlan_tag_mask != 0xffff) | ||
920 | return -EINVAL; | ||
921 | /* and nothing else */ | ||
922 | if (!is_broadcast_ether_addr(mac_mask->h_source) || | ||
923 | mac_mask->h_proto != htons(0xffff)) | ||
924 | return -EINVAL; | ||
925 | |||
926 | rc = efx_filter_set_eth_local( | ||
927 | &filter, | ||
928 | (ntuple->fs.vlan_tag_mask == 0xf000) ? | ||
929 | ntuple->fs.vlan_tag : EFX_FILTER_VID_UNSPEC, | ||
930 | mac_entry->h_dest); | ||
931 | if (rc) | ||
932 | return rc; | ||
933 | break; | ||
934 | |||
935 | default: | ||
936 | return -EINVAL; | ||
937 | } | ||
938 | |||
939 | if (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_CLEAR) | ||
940 | return efx_filter_remove_filter(efx, &filter); | ||
941 | |||
942 | rc = efx_filter_insert_filter(efx, &filter, true); | ||
943 | return rc < 0 ? rc : 0; | ||
944 | } | ||
945 | |||
946 | static int efx_ethtool_get_rxfh_indir(struct net_device *net_dev, | ||
947 | struct ethtool_rxfh_indir *indir) | ||
948 | { | ||
949 | struct efx_nic *efx = netdev_priv(net_dev); | ||
950 | size_t copy_size = | ||
951 | min_t(size_t, indir->size, ARRAY_SIZE(efx->rx_indir_table)); | ||
952 | |||
953 | if (efx_nic_rev(efx) < EFX_REV_FALCON_B0) | ||
954 | return -EOPNOTSUPP; | ||
955 | |||
956 | indir->size = ARRAY_SIZE(efx->rx_indir_table); | ||
957 | memcpy(indir->ring_index, efx->rx_indir_table, | ||
958 | copy_size * sizeof(indir->ring_index[0])); | ||
959 | return 0; | ||
960 | } | ||
961 | |||
962 | static int efx_ethtool_set_rxfh_indir(struct net_device *net_dev, | ||
963 | const struct ethtool_rxfh_indir *indir) | ||
964 | { | ||
965 | struct efx_nic *efx = netdev_priv(net_dev); | ||
966 | size_t i; | ||
967 | |||
968 | if (efx_nic_rev(efx) < EFX_REV_FALCON_B0) | ||
969 | return -EOPNOTSUPP; | ||
970 | |||
971 | /* Validate size and indices */ | ||
972 | if (indir->size != ARRAY_SIZE(efx->rx_indir_table)) | ||
973 | return -EINVAL; | ||
974 | for (i = 0; i < ARRAY_SIZE(efx->rx_indir_table); i++) | ||
975 | if (indir->ring_index[i] >= efx->n_rx_channels) | ||
976 | return -EINVAL; | ||
977 | |||
978 | memcpy(efx->rx_indir_table, indir->ring_index, | ||
979 | sizeof(efx->rx_indir_table)); | ||
980 | efx_nic_push_rx_indir_table(efx); | ||
981 | return 0; | ||
982 | } | ||
983 | |||
984 | const struct ethtool_ops efx_ethtool_ops = { | ||
985 | .get_settings = efx_ethtool_get_settings, | ||
986 | .set_settings = efx_ethtool_set_settings, | ||
987 | .get_drvinfo = efx_ethtool_get_drvinfo, | ||
988 | .get_regs_len = efx_ethtool_get_regs_len, | ||
989 | .get_regs = efx_ethtool_get_regs, | ||
990 | .get_msglevel = efx_ethtool_get_msglevel, | ||
991 | .set_msglevel = efx_ethtool_set_msglevel, | ||
992 | .nway_reset = efx_ethtool_nway_reset, | ||
993 | .get_link = ethtool_op_get_link, | ||
994 | .get_coalesce = efx_ethtool_get_coalesce, | ||
995 | .set_coalesce = efx_ethtool_set_coalesce, | ||
996 | .get_ringparam = efx_ethtool_get_ringparam, | ||
997 | .set_ringparam = efx_ethtool_set_ringparam, | ||
998 | .get_pauseparam = efx_ethtool_get_pauseparam, | ||
999 | .set_pauseparam = efx_ethtool_set_pauseparam, | ||
1000 | .get_sset_count = efx_ethtool_get_sset_count, | ||
1001 | .self_test = efx_ethtool_self_test, | ||
1002 | .get_strings = efx_ethtool_get_strings, | ||
1003 | .set_phys_id = efx_ethtool_phys_id, | ||
1004 | .get_ethtool_stats = efx_ethtool_get_stats, | ||
1005 | .get_wol = efx_ethtool_get_wol, | ||
1006 | .set_wol = efx_ethtool_set_wol, | ||
1007 | .reset = efx_ethtool_reset, | ||
1008 | .get_rxnfc = efx_ethtool_get_rxnfc, | ||
1009 | .set_rx_ntuple = efx_ethtool_set_rx_ntuple, | ||
1010 | .get_rxfh_indir = efx_ethtool_get_rxfh_indir, | ||
1011 | .set_rxfh_indir = efx_ethtool_set_rxfh_indir, | ||
1012 | }; | ||