1
2
3
4
5
6
7
8#include <linux/netdevice.h>
9#include <linux/ethtool.h>
10#include <linux/rtnetlink.h>
11#include <linux/in.h>
12#include "net_driver.h"
13#include "workarounds.h"
14#include "selftest.h"
15#include "efx.h"
16#include "filter.h"
17#include "nic.h"
18
19struct ef4_sw_stat_desc {
20 const char *name;
21 enum {
22 EF4_ETHTOOL_STAT_SOURCE_nic,
23 EF4_ETHTOOL_STAT_SOURCE_channel,
24 EF4_ETHTOOL_STAT_SOURCE_tx_queue
25 } source;
26 unsigned offset;
27 u64(*get_stat) (void *field);
28};
29
30
31#define EF4_ETHTOOL_STAT(stat_name, source_name, field, field_type, \
32 get_stat_function) { \
33 .name = #stat_name, \
34 .source = EF4_ETHTOOL_STAT_SOURCE_##source_name, \
35 .offset = ((((field_type *) 0) == \
36 &((struct ef4_##source_name *)0)->field) ? \
37 offsetof(struct ef4_##source_name, field) : \
38 offsetof(struct ef4_##source_name, field)), \
39 .get_stat = get_stat_function, \
40}
41
42static u64 ef4_get_uint_stat(void *field)
43{
44 return *(unsigned int *)field;
45}
46
47static u64 ef4_get_atomic_stat(void *field)
48{
49 return atomic_read((atomic_t *) field);
50}
51
52#define EF4_ETHTOOL_ATOMIC_NIC_ERROR_STAT(field) \
53 EF4_ETHTOOL_STAT(field, nic, field, \
54 atomic_t, ef4_get_atomic_stat)
55
56#define EF4_ETHTOOL_UINT_CHANNEL_STAT(field) \
57 EF4_ETHTOOL_STAT(field, channel, n_##field, \
58 unsigned int, ef4_get_uint_stat)
59
60#define EF4_ETHTOOL_UINT_TXQ_STAT(field) \
61 EF4_ETHTOOL_STAT(tx_##field, tx_queue, field, \
62 unsigned int, ef4_get_uint_stat)
63
64static const struct ef4_sw_stat_desc ef4_sw_stat_desc[] = {
65 EF4_ETHTOOL_UINT_TXQ_STAT(merge_events),
66 EF4_ETHTOOL_UINT_TXQ_STAT(pushes),
67 EF4_ETHTOOL_UINT_TXQ_STAT(cb_packets),
68 EF4_ETHTOOL_ATOMIC_NIC_ERROR_STAT(rx_reset),
69 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc),
70 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err),
71 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err),
72 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch),
73 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc),
74 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_merge_events),
75 EF4_ETHTOOL_UINT_CHANNEL_STAT(rx_merge_packets),
76};
77
78#define EF4_ETHTOOL_SW_STAT_COUNT ARRAY_SIZE(ef4_sw_stat_desc)
79
80#define EF4_ETHTOOL_EEPROM_MAGIC 0xEFAB
81
82
83
84
85
86
87
88
89
90static int ef4_ethtool_phys_id(struct net_device *net_dev,
91 enum ethtool_phys_id_state state)
92{
93 struct ef4_nic *efx = netdev_priv(net_dev);
94 enum ef4_led_mode mode = EF4_LED_DEFAULT;
95
96 switch (state) {
97 case ETHTOOL_ID_ON:
98 mode = EF4_LED_ON;
99 break;
100 case ETHTOOL_ID_OFF:
101 mode = EF4_LED_OFF;
102 break;
103 case ETHTOOL_ID_INACTIVE:
104 mode = EF4_LED_DEFAULT;
105 break;
106 case ETHTOOL_ID_ACTIVE:
107 return 1;
108 }
109
110 efx->type->set_id_led(efx, mode);
111 return 0;
112}
113
114
115static int
116ef4_ethtool_get_link_ksettings(struct net_device *net_dev,
117 struct ethtool_link_ksettings *cmd)
118{
119 struct ef4_nic *efx = netdev_priv(net_dev);
120 struct ef4_link_state *link_state = &efx->link_state;
121
122 mutex_lock(&efx->mac_lock);
123 efx->phy_op->get_link_ksettings(efx, cmd);
124 mutex_unlock(&efx->mac_lock);
125
126
127 ethtool_link_ksettings_add_link_mode(cmd, supported, Pause);
128 ethtool_link_ksettings_add_link_mode(cmd, supported, Asym_Pause);
129
130 if (LOOPBACK_INTERNAL(efx)) {
131 cmd->base.speed = link_state->speed;
132 cmd->base.duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
133 }
134
135 return 0;
136}
137
138
139static int
140ef4_ethtool_set_link_ksettings(struct net_device *net_dev,
141 const struct ethtool_link_ksettings *cmd)
142{
143 struct ef4_nic *efx = netdev_priv(net_dev);
144 int rc;
145
146
147 if ((cmd->base.speed == SPEED_1000) &&
148 (cmd->base.duplex != DUPLEX_FULL)) {
149 netif_dbg(efx, drv, efx->net_dev,
150 "rejecting unsupported 1000Mbps HD setting\n");
151 return -EINVAL;
152 }
153
154 mutex_lock(&efx->mac_lock);
155 rc = efx->phy_op->set_link_ksettings(efx, cmd);
156 mutex_unlock(&efx->mac_lock);
157 return rc;
158}
159
160static void ef4_ethtool_get_drvinfo(struct net_device *net_dev,
161 struct ethtool_drvinfo *info)
162{
163 struct ef4_nic *efx = netdev_priv(net_dev);
164
165 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
166 strlcpy(info->version, EF4_DRIVER_VERSION, sizeof(info->version));
167 strlcpy(info->bus_info, pci_name(efx->pci_dev), sizeof(info->bus_info));
168}
169
170static int ef4_ethtool_get_regs_len(struct net_device *net_dev)
171{
172 return ef4_nic_get_regs_len(netdev_priv(net_dev));
173}
174
175static void ef4_ethtool_get_regs(struct net_device *net_dev,
176 struct ethtool_regs *regs, void *buf)
177{
178 struct ef4_nic *efx = netdev_priv(net_dev);
179
180 regs->version = efx->type->revision;
181 ef4_nic_get_regs(efx, buf);
182}
183
184static u32 ef4_ethtool_get_msglevel(struct net_device *net_dev)
185{
186 struct ef4_nic *efx = netdev_priv(net_dev);
187 return efx->msg_enable;
188}
189
190static void ef4_ethtool_set_msglevel(struct net_device *net_dev, u32 msg_enable)
191{
192 struct ef4_nic *efx = netdev_priv(net_dev);
193 efx->msg_enable = msg_enable;
194}
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209static void ef4_fill_test(unsigned int test_index, u8 *strings, u64 *data,
210 int *test, const char *unit_format, int unit_id,
211 const char *test_format, const char *test_id)
212{
213 char unit_str[ETH_GSTRING_LEN], test_str[ETH_GSTRING_LEN];
214
215
216 if (data)
217 data[test_index] = *test;
218
219
220 if (strings) {
221 if (strchr(unit_format, '%'))
222 snprintf(unit_str, sizeof(unit_str),
223 unit_format, unit_id);
224 else
225 strcpy(unit_str, unit_format);
226 snprintf(test_str, sizeof(test_str), test_format, test_id);
227 snprintf(strings + test_index * ETH_GSTRING_LEN,
228 ETH_GSTRING_LEN,
229 "%-6s %-24s", unit_str, test_str);
230 }
231}
232
233#define EF4_CHANNEL_NAME(_channel) "chan%d", _channel->channel
234#define EF4_TX_QUEUE_NAME(_tx_queue) "txq%d", _tx_queue->queue
235#define EF4_RX_QUEUE_NAME(_rx_queue) "rxq%d", _rx_queue->queue
236#define EF4_LOOPBACK_NAME(_mode, _counter) \
237 "loopback.%s." _counter, STRING_TABLE_LOOKUP(_mode, ef4_loopback_mode)
238
239
240
241
242
243
244
245
246
247
248
249
250
251static int ef4_fill_loopback_test(struct ef4_nic *efx,
252 struct ef4_loopback_self_tests *lb_tests,
253 enum ef4_loopback_mode mode,
254 unsigned int test_index,
255 u8 *strings, u64 *data)
256{
257 struct ef4_channel *channel =
258 ef4_get_channel(efx, efx->tx_channel_offset);
259 struct ef4_tx_queue *tx_queue;
260
261 ef4_for_each_channel_tx_queue(tx_queue, channel) {
262 ef4_fill_test(test_index++, strings, data,
263 &lb_tests->tx_sent[tx_queue->queue],
264 EF4_TX_QUEUE_NAME(tx_queue),
265 EF4_LOOPBACK_NAME(mode, "tx_sent"));
266 ef4_fill_test(test_index++, strings, data,
267 &lb_tests->tx_done[tx_queue->queue],
268 EF4_TX_QUEUE_NAME(tx_queue),
269 EF4_LOOPBACK_NAME(mode, "tx_done"));
270 }
271 ef4_fill_test(test_index++, strings, data,
272 &lb_tests->rx_good,
273 "rx", 0,
274 EF4_LOOPBACK_NAME(mode, "rx_good"));
275 ef4_fill_test(test_index++, strings, data,
276 &lb_tests->rx_bad,
277 "rx", 0,
278 EF4_LOOPBACK_NAME(mode, "rx_bad"));
279
280 return test_index;
281}
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296static int ef4_ethtool_fill_self_tests(struct ef4_nic *efx,
297 struct ef4_self_tests *tests,
298 u8 *strings, u64 *data)
299{
300 struct ef4_channel *channel;
301 unsigned int n = 0, i;
302 enum ef4_loopback_mode mode;
303
304 ef4_fill_test(n++, strings, data, &tests->phy_alive,
305 "phy", 0, "alive", NULL);
306 ef4_fill_test(n++, strings, data, &tests->nvram,
307 "core", 0, "nvram", NULL);
308 ef4_fill_test(n++, strings, data, &tests->interrupt,
309 "core", 0, "interrupt", NULL);
310
311
312 ef4_for_each_channel(channel, efx) {
313 ef4_fill_test(n++, strings, data,
314 &tests->eventq_dma[channel->channel],
315 EF4_CHANNEL_NAME(channel),
316 "eventq.dma", NULL);
317 ef4_fill_test(n++, strings, data,
318 &tests->eventq_int[channel->channel],
319 EF4_CHANNEL_NAME(channel),
320 "eventq.int", NULL);
321 }
322
323 ef4_fill_test(n++, strings, data, &tests->memory,
324 "core", 0, "memory", NULL);
325 ef4_fill_test(n++, strings, data, &tests->registers,
326 "core", 0, "registers", NULL);
327
328 if (efx->phy_op->run_tests != NULL) {
329 EF4_BUG_ON_PARANOID(efx->phy_op->test_name == NULL);
330
331 for (i = 0; true; ++i) {
332 const char *name;
333
334 EF4_BUG_ON_PARANOID(i >= EF4_MAX_PHY_TESTS);
335 name = efx->phy_op->test_name(efx, i);
336 if (name == NULL)
337 break;
338
339 ef4_fill_test(n++, strings, data, &tests->phy_ext[i],
340 "phy", 0, name, NULL);
341 }
342 }
343
344
345 for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) {
346 if (!(efx->loopback_modes & (1 << mode)))
347 continue;
348 n = ef4_fill_loopback_test(efx,
349 &tests->loopback[mode], mode, n,
350 strings, data);
351 }
352
353 return n;
354}
355
356static size_t ef4_describe_per_queue_stats(struct ef4_nic *efx, u8 *strings)
357{
358 size_t n_stats = 0;
359 struct ef4_channel *channel;
360
361 ef4_for_each_channel(channel, efx) {
362 if (ef4_channel_has_tx_queues(channel)) {
363 n_stats++;
364 if (strings != NULL) {
365 snprintf(strings, ETH_GSTRING_LEN,
366 "tx-%u.tx_packets",
367 channel->tx_queue[0].queue /
368 EF4_TXQ_TYPES);
369
370 strings += ETH_GSTRING_LEN;
371 }
372 }
373 }
374 ef4_for_each_channel(channel, efx) {
375 if (ef4_channel_has_rx_queue(channel)) {
376 n_stats++;
377 if (strings != NULL) {
378 snprintf(strings, ETH_GSTRING_LEN,
379 "rx-%d.rx_packets", channel->channel);
380 strings += ETH_GSTRING_LEN;
381 }
382 }
383 }
384 return n_stats;
385}
386
387static int ef4_ethtool_get_sset_count(struct net_device *net_dev,
388 int string_set)
389{
390 struct ef4_nic *efx = netdev_priv(net_dev);
391
392 switch (string_set) {
393 case ETH_SS_STATS:
394 return efx->type->describe_stats(efx, NULL) +
395 EF4_ETHTOOL_SW_STAT_COUNT +
396 ef4_describe_per_queue_stats(efx, NULL);
397 case ETH_SS_TEST:
398 return ef4_ethtool_fill_self_tests(efx, NULL, NULL, NULL);
399 default:
400 return -EINVAL;
401 }
402}
403
404static void ef4_ethtool_get_strings(struct net_device *net_dev,
405 u32 string_set, u8 *strings)
406{
407 struct ef4_nic *efx = netdev_priv(net_dev);
408 int i;
409
410 switch (string_set) {
411 case ETH_SS_STATS:
412 strings += (efx->type->describe_stats(efx, strings) *
413 ETH_GSTRING_LEN);
414 for (i = 0; i < EF4_ETHTOOL_SW_STAT_COUNT; i++)
415 strlcpy(strings + i * ETH_GSTRING_LEN,
416 ef4_sw_stat_desc[i].name, ETH_GSTRING_LEN);
417 strings += EF4_ETHTOOL_SW_STAT_COUNT * ETH_GSTRING_LEN;
418 strings += (ef4_describe_per_queue_stats(efx, strings) *
419 ETH_GSTRING_LEN);
420 break;
421 case ETH_SS_TEST:
422 ef4_ethtool_fill_self_tests(efx, NULL, strings, NULL);
423 break;
424 default:
425
426 break;
427 }
428}
429
430static void ef4_ethtool_get_stats(struct net_device *net_dev,
431 struct ethtool_stats *stats,
432 u64 *data)
433{
434 struct ef4_nic *efx = netdev_priv(net_dev);
435 const struct ef4_sw_stat_desc *stat;
436 struct ef4_channel *channel;
437 struct ef4_tx_queue *tx_queue;
438 struct ef4_rx_queue *rx_queue;
439 int i;
440
441 spin_lock_bh(&efx->stats_lock);
442
443
444 data += efx->type->update_stats(efx, data, NULL);
445
446
447 for (i = 0; i < EF4_ETHTOOL_SW_STAT_COUNT; i++) {
448 stat = &ef4_sw_stat_desc[i];
449 switch (stat->source) {
450 case EF4_ETHTOOL_STAT_SOURCE_nic:
451 data[i] = stat->get_stat((void *)efx + stat->offset);
452 break;
453 case EF4_ETHTOOL_STAT_SOURCE_channel:
454 data[i] = 0;
455 ef4_for_each_channel(channel, efx)
456 data[i] += stat->get_stat((void *)channel +
457 stat->offset);
458 break;
459 case EF4_ETHTOOL_STAT_SOURCE_tx_queue:
460 data[i] = 0;
461 ef4_for_each_channel(channel, efx) {
462 ef4_for_each_channel_tx_queue(tx_queue, channel)
463 data[i] +=
464 stat->get_stat((void *)tx_queue
465 + stat->offset);
466 }
467 break;
468 }
469 }
470 data += EF4_ETHTOOL_SW_STAT_COUNT;
471
472 spin_unlock_bh(&efx->stats_lock);
473
474 ef4_for_each_channel(channel, efx) {
475 if (ef4_channel_has_tx_queues(channel)) {
476 *data = 0;
477 ef4_for_each_channel_tx_queue(tx_queue, channel) {
478 *data += tx_queue->tx_packets;
479 }
480 data++;
481 }
482 }
483 ef4_for_each_channel(channel, efx) {
484 if (ef4_channel_has_rx_queue(channel)) {
485 *data = 0;
486 ef4_for_each_channel_rx_queue(rx_queue, channel) {
487 *data += rx_queue->rx_packets;
488 }
489 data++;
490 }
491 }
492}
493
494static void ef4_ethtool_self_test(struct net_device *net_dev,
495 struct ethtool_test *test, u64 *data)
496{
497 struct ef4_nic *efx = netdev_priv(net_dev);
498 struct ef4_self_tests *ef4_tests;
499 bool already_up;
500 int rc = -ENOMEM;
501
502 ef4_tests = kzalloc(sizeof(*ef4_tests), GFP_KERNEL);
503 if (!ef4_tests)
504 goto fail;
505
506 if (efx->state != STATE_READY) {
507 rc = -EBUSY;
508 goto out;
509 }
510
511 netif_info(efx, drv, efx->net_dev, "starting %sline testing\n",
512 (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
513
514
515 already_up = (efx->net_dev->flags & IFF_UP);
516 if (!already_up) {
517 rc = dev_open(efx->net_dev, NULL);
518 if (rc) {
519 netif_err(efx, drv, efx->net_dev,
520 "failed opening device.\n");
521 goto out;
522 }
523 }
524
525 rc = ef4_selftest(efx, ef4_tests, test->flags);
526
527 if (!already_up)
528 dev_close(efx->net_dev);
529
530 netif_info(efx, drv, efx->net_dev, "%s %sline self-tests\n",
531 rc == 0 ? "passed" : "failed",
532 (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
533
534out:
535 ef4_ethtool_fill_self_tests(efx, ef4_tests, NULL, data);
536 kfree(ef4_tests);
537fail:
538 if (rc)
539 test->flags |= ETH_TEST_FL_FAILED;
540}
541
542
543static int ef4_ethtool_nway_reset(struct net_device *net_dev)
544{
545 struct ef4_nic *efx = netdev_priv(net_dev);
546
547 return mdio45_nway_restart(&efx->mdio);
548}
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579static int ef4_ethtool_get_coalesce(struct net_device *net_dev,
580 struct ethtool_coalesce *coalesce,
581 struct kernel_ethtool_coalesce *kernel_coal,
582 struct netlink_ext_ack *extack)
583{
584 struct ef4_nic *efx = netdev_priv(net_dev);
585 unsigned int tx_usecs, rx_usecs;
586 bool rx_adaptive;
587
588 ef4_get_irq_moderation(efx, &tx_usecs, &rx_usecs, &rx_adaptive);
589
590 coalesce->tx_coalesce_usecs = tx_usecs;
591 coalesce->tx_coalesce_usecs_irq = tx_usecs;
592 coalesce->rx_coalesce_usecs = rx_usecs;
593 coalesce->rx_coalesce_usecs_irq = rx_usecs;
594 coalesce->use_adaptive_rx_coalesce = rx_adaptive;
595
596 return 0;
597}
598
599static int ef4_ethtool_set_coalesce(struct net_device *net_dev,
600 struct ethtool_coalesce *coalesce,
601 struct kernel_ethtool_coalesce *kernel_coal,
602 struct netlink_ext_ack *extack)
603{
604 struct ef4_nic *efx = netdev_priv(net_dev);
605 struct ef4_channel *channel;
606 unsigned int tx_usecs, rx_usecs;
607 bool adaptive, rx_may_override_tx;
608 int rc;
609
610 ef4_get_irq_moderation(efx, &tx_usecs, &rx_usecs, &adaptive);
611
612 if (coalesce->rx_coalesce_usecs != rx_usecs)
613 rx_usecs = coalesce->rx_coalesce_usecs;
614 else
615 rx_usecs = coalesce->rx_coalesce_usecs_irq;
616
617 adaptive = coalesce->use_adaptive_rx_coalesce;
618
619
620
621
622 rx_may_override_tx = (coalesce->tx_coalesce_usecs == tx_usecs &&
623 coalesce->tx_coalesce_usecs_irq == tx_usecs);
624 if (coalesce->tx_coalesce_usecs != tx_usecs)
625 tx_usecs = coalesce->tx_coalesce_usecs;
626 else
627 tx_usecs = coalesce->tx_coalesce_usecs_irq;
628
629 rc = ef4_init_irq_moderation(efx, tx_usecs, rx_usecs, adaptive,
630 rx_may_override_tx);
631 if (rc != 0)
632 return rc;
633
634 ef4_for_each_channel(channel, efx)
635 efx->type->push_irq_moderation(channel);
636
637 return 0;
638}
639
640static void
641ef4_ethtool_get_ringparam(struct net_device *net_dev,
642 struct ethtool_ringparam *ring,
643 struct kernel_ethtool_ringparam *kernel_ring,
644 struct netlink_ext_ack *extack)
645{
646 struct ef4_nic *efx = netdev_priv(net_dev);
647
648 ring->rx_max_pending = EF4_MAX_DMAQ_SIZE;
649 ring->tx_max_pending = EF4_MAX_DMAQ_SIZE;
650 ring->rx_pending = efx->rxq_entries;
651 ring->tx_pending = efx->txq_entries;
652}
653
654static int
655ef4_ethtool_set_ringparam(struct net_device *net_dev,
656 struct ethtool_ringparam *ring,
657 struct kernel_ethtool_ringparam *kernel_ring,
658 struct netlink_ext_ack *extack)
659{
660 struct ef4_nic *efx = netdev_priv(net_dev);
661 u32 txq_entries;
662
663 if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
664 ring->rx_pending > EF4_MAX_DMAQ_SIZE ||
665 ring->tx_pending > EF4_MAX_DMAQ_SIZE)
666 return -EINVAL;
667
668 if (ring->rx_pending < EF4_RXQ_MIN_ENT) {
669 netif_err(efx, drv, efx->net_dev,
670 "RX queues cannot be smaller than %u\n",
671 EF4_RXQ_MIN_ENT);
672 return -EINVAL;
673 }
674
675 txq_entries = max(ring->tx_pending, EF4_TXQ_MIN_ENT(efx));
676 if (txq_entries != ring->tx_pending)
677 netif_warn(efx, drv, efx->net_dev,
678 "increasing TX queue size to minimum of %u\n",
679 txq_entries);
680
681 return ef4_realloc_channels(efx, ring->rx_pending, txq_entries);
682}
683
684static int ef4_ethtool_set_pauseparam(struct net_device *net_dev,
685 struct ethtool_pauseparam *pause)
686{
687 struct ef4_nic *efx = netdev_priv(net_dev);
688 u8 wanted_fc, old_fc;
689 u32 old_adv;
690 int rc = 0;
691
692 mutex_lock(&efx->mac_lock);
693
694 wanted_fc = ((pause->rx_pause ? EF4_FC_RX : 0) |
695 (pause->tx_pause ? EF4_FC_TX : 0) |
696 (pause->autoneg ? EF4_FC_AUTO : 0));
697
698 if ((wanted_fc & EF4_FC_TX) && !(wanted_fc & EF4_FC_RX)) {
699 netif_dbg(efx, drv, efx->net_dev,
700 "Flow control unsupported: tx ON rx OFF\n");
701 rc = -EINVAL;
702 goto out;
703 }
704
705 if ((wanted_fc & EF4_FC_AUTO) && !efx->link_advertising) {
706 netif_dbg(efx, drv, efx->net_dev,
707 "Autonegotiation is disabled\n");
708 rc = -EINVAL;
709 goto out;
710 }
711
712
713 if (efx->type->prepare_enable_fc_tx &&
714 (wanted_fc & EF4_FC_TX) && !(efx->wanted_fc & EF4_FC_TX))
715 efx->type->prepare_enable_fc_tx(efx);
716
717 old_adv = efx->link_advertising;
718 old_fc = efx->wanted_fc;
719 ef4_link_set_wanted_fc(efx, wanted_fc);
720 if (efx->link_advertising != old_adv ||
721 (efx->wanted_fc ^ old_fc) & EF4_FC_AUTO) {
722 rc = efx->phy_op->reconfigure(efx);
723 if (rc) {
724 netif_err(efx, drv, efx->net_dev,
725 "Unable to advertise requested flow "
726 "control setting\n");
727 goto out;
728 }
729 }
730
731
732
733
734 ef4_mac_reconfigure(efx);
735
736out:
737 mutex_unlock(&efx->mac_lock);
738
739 return rc;
740}
741
742static void ef4_ethtool_get_pauseparam(struct net_device *net_dev,
743 struct ethtool_pauseparam *pause)
744{
745 struct ef4_nic *efx = netdev_priv(net_dev);
746
747 pause->rx_pause = !!(efx->wanted_fc & EF4_FC_RX);
748 pause->tx_pause = !!(efx->wanted_fc & EF4_FC_TX);
749 pause->autoneg = !!(efx->wanted_fc & EF4_FC_AUTO);
750}
751
752static void ef4_ethtool_get_wol(struct net_device *net_dev,
753 struct ethtool_wolinfo *wol)
754{
755 struct ef4_nic *efx = netdev_priv(net_dev);
756 return efx->type->get_wol(efx, wol);
757}
758
759
760static int ef4_ethtool_set_wol(struct net_device *net_dev,
761 struct ethtool_wolinfo *wol)
762{
763 struct ef4_nic *efx = netdev_priv(net_dev);
764 return efx->type->set_wol(efx, wol->wolopts);
765}
766
767static int ef4_ethtool_reset(struct net_device *net_dev, u32 *flags)
768{
769 struct ef4_nic *efx = netdev_priv(net_dev);
770 int rc;
771
772 rc = efx->type->map_reset_flags(flags);
773 if (rc < 0)
774 return rc;
775
776 return ef4_reset(efx, rc);
777}
778
779
780static const u8 mac_addr_ig_mask[ETH_ALEN] __aligned(2) = {0x01, 0, 0, 0, 0, 0};
781
782#define IP4_ADDR_FULL_MASK ((__force __be32)~0)
783#define IP_PROTO_FULL_MASK 0xFF
784#define PORT_FULL_MASK ((__force __be16)~0)
785#define ETHER_TYPE_FULL_MASK ((__force __be16)~0)
786
787static inline void ip6_fill_mask(__be32 *mask)
788{
789 mask[0] = mask[1] = mask[2] = mask[3] = ~(__be32)0;
790}
791
792static int ef4_ethtool_get_class_rule(struct ef4_nic *efx,
793 struct ethtool_rx_flow_spec *rule)
794{
795 struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
796 struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
797 struct ethtool_usrip4_spec *uip_entry = &rule->h_u.usr_ip4_spec;
798 struct ethtool_usrip4_spec *uip_mask = &rule->m_u.usr_ip4_spec;
799 struct ethtool_tcpip6_spec *ip6_entry = &rule->h_u.tcp_ip6_spec;
800 struct ethtool_tcpip6_spec *ip6_mask = &rule->m_u.tcp_ip6_spec;
801 struct ethtool_usrip6_spec *uip6_entry = &rule->h_u.usr_ip6_spec;
802 struct ethtool_usrip6_spec *uip6_mask = &rule->m_u.usr_ip6_spec;
803 struct ethhdr *mac_entry = &rule->h_u.ether_spec;
804 struct ethhdr *mac_mask = &rule->m_u.ether_spec;
805 struct ef4_filter_spec spec;
806 int rc;
807
808 rc = ef4_filter_get_filter_safe(efx, EF4_FILTER_PRI_MANUAL,
809 rule->location, &spec);
810 if (rc)
811 return rc;
812
813 if (spec.dmaq_id == EF4_FILTER_RX_DMAQ_ID_DROP)
814 rule->ring_cookie = RX_CLS_FLOW_DISC;
815 else
816 rule->ring_cookie = spec.dmaq_id;
817
818 if ((spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE) &&
819 spec.ether_type == htons(ETH_P_IP) &&
820 (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) &&
821 (spec.ip_proto == IPPROTO_TCP || spec.ip_proto == IPPROTO_UDP) &&
822 !(spec.match_flags &
823 ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
824 EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
825 EF4_FILTER_MATCH_IP_PROTO |
826 EF4_FILTER_MATCH_LOC_PORT | EF4_FILTER_MATCH_REM_PORT))) {
827 rule->flow_type = ((spec.ip_proto == IPPROTO_TCP) ?
828 TCP_V4_FLOW : UDP_V4_FLOW);
829 if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
830 ip_entry->ip4dst = spec.loc_host[0];
831 ip_mask->ip4dst = IP4_ADDR_FULL_MASK;
832 }
833 if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
834 ip_entry->ip4src = spec.rem_host[0];
835 ip_mask->ip4src = IP4_ADDR_FULL_MASK;
836 }
837 if (spec.match_flags & EF4_FILTER_MATCH_LOC_PORT) {
838 ip_entry->pdst = spec.loc_port;
839 ip_mask->pdst = PORT_FULL_MASK;
840 }
841 if (spec.match_flags & EF4_FILTER_MATCH_REM_PORT) {
842 ip_entry->psrc = spec.rem_port;
843 ip_mask->psrc = PORT_FULL_MASK;
844 }
845 } else if ((spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE) &&
846 spec.ether_type == htons(ETH_P_IPV6) &&
847 (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) &&
848 (spec.ip_proto == IPPROTO_TCP || spec.ip_proto == IPPROTO_UDP) &&
849 !(spec.match_flags &
850 ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
851 EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
852 EF4_FILTER_MATCH_IP_PROTO |
853 EF4_FILTER_MATCH_LOC_PORT | EF4_FILTER_MATCH_REM_PORT))) {
854 rule->flow_type = ((spec.ip_proto == IPPROTO_TCP) ?
855 TCP_V6_FLOW : UDP_V6_FLOW);
856 if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
857 memcpy(ip6_entry->ip6dst, spec.loc_host,
858 sizeof(ip6_entry->ip6dst));
859 ip6_fill_mask(ip6_mask->ip6dst);
860 }
861 if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
862 memcpy(ip6_entry->ip6src, spec.rem_host,
863 sizeof(ip6_entry->ip6src));
864 ip6_fill_mask(ip6_mask->ip6src);
865 }
866 if (spec.match_flags & EF4_FILTER_MATCH_LOC_PORT) {
867 ip6_entry->pdst = spec.loc_port;
868 ip6_mask->pdst = PORT_FULL_MASK;
869 }
870 if (spec.match_flags & EF4_FILTER_MATCH_REM_PORT) {
871 ip6_entry->psrc = spec.rem_port;
872 ip6_mask->psrc = PORT_FULL_MASK;
873 }
874 } else if (!(spec.match_flags &
875 ~(EF4_FILTER_MATCH_LOC_MAC | EF4_FILTER_MATCH_LOC_MAC_IG |
876 EF4_FILTER_MATCH_REM_MAC | EF4_FILTER_MATCH_ETHER_TYPE |
877 EF4_FILTER_MATCH_OUTER_VID))) {
878 rule->flow_type = ETHER_FLOW;
879 if (spec.match_flags &
880 (EF4_FILTER_MATCH_LOC_MAC | EF4_FILTER_MATCH_LOC_MAC_IG)) {
881 ether_addr_copy(mac_entry->h_dest, spec.loc_mac);
882 if (spec.match_flags & EF4_FILTER_MATCH_LOC_MAC)
883 eth_broadcast_addr(mac_mask->h_dest);
884 else
885 ether_addr_copy(mac_mask->h_dest,
886 mac_addr_ig_mask);
887 }
888 if (spec.match_flags & EF4_FILTER_MATCH_REM_MAC) {
889 ether_addr_copy(mac_entry->h_source, spec.rem_mac);
890 eth_broadcast_addr(mac_mask->h_source);
891 }
892 if (spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE) {
893 mac_entry->h_proto = spec.ether_type;
894 mac_mask->h_proto = ETHER_TYPE_FULL_MASK;
895 }
896 } else if (spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE &&
897 spec.ether_type == htons(ETH_P_IP) &&
898 !(spec.match_flags &
899 ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
900 EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
901 EF4_FILTER_MATCH_IP_PROTO))) {
902 rule->flow_type = IPV4_USER_FLOW;
903 uip_entry->ip_ver = ETH_RX_NFC_IP4;
904 if (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) {
905 uip_mask->proto = IP_PROTO_FULL_MASK;
906 uip_entry->proto = spec.ip_proto;
907 }
908 if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
909 uip_entry->ip4dst = spec.loc_host[0];
910 uip_mask->ip4dst = IP4_ADDR_FULL_MASK;
911 }
912 if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
913 uip_entry->ip4src = spec.rem_host[0];
914 uip_mask->ip4src = IP4_ADDR_FULL_MASK;
915 }
916 } else if (spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE &&
917 spec.ether_type == htons(ETH_P_IPV6) &&
918 !(spec.match_flags &
919 ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
920 EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
921 EF4_FILTER_MATCH_IP_PROTO))) {
922 rule->flow_type = IPV6_USER_FLOW;
923 if (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) {
924 uip6_mask->l4_proto = IP_PROTO_FULL_MASK;
925 uip6_entry->l4_proto = spec.ip_proto;
926 }
927 if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
928 memcpy(uip6_entry->ip6dst, spec.loc_host,
929 sizeof(uip6_entry->ip6dst));
930 ip6_fill_mask(uip6_mask->ip6dst);
931 }
932 if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
933 memcpy(uip6_entry->ip6src, spec.rem_host,
934 sizeof(uip6_entry->ip6src));
935 ip6_fill_mask(uip6_mask->ip6src);
936 }
937 } else {
938
939 WARN_ON(1);
940 return -EINVAL;
941 }
942
943 if (spec.match_flags & EF4_FILTER_MATCH_OUTER_VID) {
944 rule->flow_type |= FLOW_EXT;
945 rule->h_ext.vlan_tci = spec.outer_vid;
946 rule->m_ext.vlan_tci = htons(0xfff);
947 }
948
949 return rc;
950}
951
952static int
953ef4_ethtool_get_rxnfc(struct net_device *net_dev,
954 struct ethtool_rxnfc *info, u32 *rule_locs)
955{
956 struct ef4_nic *efx = netdev_priv(net_dev);
957
958 switch (info->cmd) {
959 case ETHTOOL_GRXRINGS:
960 info->data = efx->n_rx_channels;
961 return 0;
962
963 case ETHTOOL_GRXFH: {
964 unsigned min_revision = 0;
965
966 info->data = 0;
967 switch (info->flow_type) {
968 case TCP_V4_FLOW:
969 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
970 fallthrough;
971 case UDP_V4_FLOW:
972 case SCTP_V4_FLOW:
973 case AH_ESP_V4_FLOW:
974 case IPV4_FLOW:
975 info->data |= RXH_IP_SRC | RXH_IP_DST;
976 min_revision = EF4_REV_FALCON_B0;
977 break;
978 default:
979 break;
980 }
981 if (ef4_nic_rev(efx) < min_revision)
982 info->data = 0;
983 return 0;
984 }
985
986 case ETHTOOL_GRXCLSRLCNT:
987 info->data = ef4_filter_get_rx_id_limit(efx);
988 if (info->data == 0)
989 return -EOPNOTSUPP;
990 info->data |= RX_CLS_LOC_SPECIAL;
991 info->rule_cnt =
992 ef4_filter_count_rx_used(efx, EF4_FILTER_PRI_MANUAL);
993 return 0;
994
995 case ETHTOOL_GRXCLSRULE:
996 if (ef4_filter_get_rx_id_limit(efx) == 0)
997 return -EOPNOTSUPP;
998 return ef4_ethtool_get_class_rule(efx, &info->fs);
999
1000 case ETHTOOL_GRXCLSRLALL: {
1001 s32 rc;
1002 info->data = ef4_filter_get_rx_id_limit(efx);
1003 if (info->data == 0)
1004 return -EOPNOTSUPP;
1005 rc = ef4_filter_get_rx_ids(efx, EF4_FILTER_PRI_MANUAL,
1006 rule_locs, info->rule_cnt);
1007 if (rc < 0)
1008 return rc;
1009 info->rule_cnt = rc;
1010 return 0;
1011 }
1012
1013 default:
1014 return -EOPNOTSUPP;
1015 }
1016}
1017
1018static inline bool ip6_mask_is_full(__be32 mask[4])
1019{
1020 return !~(mask[0] & mask[1] & mask[2] & mask[3]);
1021}
1022
1023static inline bool ip6_mask_is_empty(__be32 mask[4])
1024{
1025 return !(mask[0] | mask[1] | mask[2] | mask[3]);
1026}
1027
1028static int ef4_ethtool_set_class_rule(struct ef4_nic *efx,
1029 struct ethtool_rx_flow_spec *rule)
1030{
1031 struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
1032 struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
1033 struct ethtool_usrip4_spec *uip_entry = &rule->h_u.usr_ip4_spec;
1034 struct ethtool_usrip4_spec *uip_mask = &rule->m_u.usr_ip4_spec;
1035 struct ethtool_tcpip6_spec *ip6_entry = &rule->h_u.tcp_ip6_spec;
1036 struct ethtool_tcpip6_spec *ip6_mask = &rule->m_u.tcp_ip6_spec;
1037 struct ethtool_usrip6_spec *uip6_entry = &rule->h_u.usr_ip6_spec;
1038 struct ethtool_usrip6_spec *uip6_mask = &rule->m_u.usr_ip6_spec;
1039 struct ethhdr *mac_entry = &rule->h_u.ether_spec;
1040 struct ethhdr *mac_mask = &rule->m_u.ether_spec;
1041 struct ef4_filter_spec spec;
1042 int rc;
1043
1044
1045 if (rule->location != RX_CLS_LOC_ANY)
1046 return -EINVAL;
1047
1048
1049 if (rule->ring_cookie >= efx->n_rx_channels &&
1050 rule->ring_cookie != RX_CLS_FLOW_DISC)
1051 return -EINVAL;
1052
1053
1054 if ((rule->flow_type & FLOW_EXT) &&
1055 (rule->m_ext.vlan_etype || rule->m_ext.data[0] ||
1056 rule->m_ext.data[1]))
1057 return -EINVAL;
1058
1059 ef4_filter_init_rx(&spec, EF4_FILTER_PRI_MANUAL,
1060 efx->rx_scatter ? EF4_FILTER_FLAG_RX_SCATTER : 0,
1061 (rule->ring_cookie == RX_CLS_FLOW_DISC) ?
1062 EF4_FILTER_RX_DMAQ_ID_DROP : rule->ring_cookie);
1063
1064 switch (rule->flow_type & ~FLOW_EXT) {
1065 case TCP_V4_FLOW:
1066 case UDP_V4_FLOW:
1067 spec.match_flags = (EF4_FILTER_MATCH_ETHER_TYPE |
1068 EF4_FILTER_MATCH_IP_PROTO);
1069 spec.ether_type = htons(ETH_P_IP);
1070 spec.ip_proto = ((rule->flow_type & ~FLOW_EXT) == TCP_V4_FLOW ?
1071 IPPROTO_TCP : IPPROTO_UDP);
1072 if (ip_mask->ip4dst) {
1073 if (ip_mask->ip4dst != IP4_ADDR_FULL_MASK)
1074 return -EINVAL;
1075 spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1076 spec.loc_host[0] = ip_entry->ip4dst;
1077 }
1078 if (ip_mask->ip4src) {
1079 if (ip_mask->ip4src != IP4_ADDR_FULL_MASK)
1080 return -EINVAL;
1081 spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1082 spec.rem_host[0] = ip_entry->ip4src;
1083 }
1084 if (ip_mask->pdst) {
1085 if (ip_mask->pdst != PORT_FULL_MASK)
1086 return -EINVAL;
1087 spec.match_flags |= EF4_FILTER_MATCH_LOC_PORT;
1088 spec.loc_port = ip_entry->pdst;
1089 }
1090 if (ip_mask->psrc) {
1091 if (ip_mask->psrc != PORT_FULL_MASK)
1092 return -EINVAL;
1093 spec.match_flags |= EF4_FILTER_MATCH_REM_PORT;
1094 spec.rem_port = ip_entry->psrc;
1095 }
1096 if (ip_mask->tos)
1097 return -EINVAL;
1098 break;
1099
1100 case TCP_V6_FLOW:
1101 case UDP_V6_FLOW:
1102 spec.match_flags = (EF4_FILTER_MATCH_ETHER_TYPE |
1103 EF4_FILTER_MATCH_IP_PROTO);
1104 spec.ether_type = htons(ETH_P_IPV6);
1105 spec.ip_proto = ((rule->flow_type & ~FLOW_EXT) == TCP_V6_FLOW ?
1106 IPPROTO_TCP : IPPROTO_UDP);
1107 if (!ip6_mask_is_empty(ip6_mask->ip6dst)) {
1108 if (!ip6_mask_is_full(ip6_mask->ip6dst))
1109 return -EINVAL;
1110 spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1111 memcpy(spec.loc_host, ip6_entry->ip6dst, sizeof(spec.loc_host));
1112 }
1113 if (!ip6_mask_is_empty(ip6_mask->ip6src)) {
1114 if (!ip6_mask_is_full(ip6_mask->ip6src))
1115 return -EINVAL;
1116 spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1117 memcpy(spec.rem_host, ip6_entry->ip6src, sizeof(spec.rem_host));
1118 }
1119 if (ip6_mask->pdst) {
1120 if (ip6_mask->pdst != PORT_FULL_MASK)
1121 return -EINVAL;
1122 spec.match_flags |= EF4_FILTER_MATCH_LOC_PORT;
1123 spec.loc_port = ip6_entry->pdst;
1124 }
1125 if (ip6_mask->psrc) {
1126 if (ip6_mask->psrc != PORT_FULL_MASK)
1127 return -EINVAL;
1128 spec.match_flags |= EF4_FILTER_MATCH_REM_PORT;
1129 spec.rem_port = ip6_entry->psrc;
1130 }
1131 if (ip6_mask->tclass)
1132 return -EINVAL;
1133 break;
1134
1135 case IPV4_USER_FLOW:
1136 if (uip_mask->l4_4_bytes || uip_mask->tos || uip_mask->ip_ver ||
1137 uip_entry->ip_ver != ETH_RX_NFC_IP4)
1138 return -EINVAL;
1139 spec.match_flags = EF4_FILTER_MATCH_ETHER_TYPE;
1140 spec.ether_type = htons(ETH_P_IP);
1141 if (uip_mask->ip4dst) {
1142 if (uip_mask->ip4dst != IP4_ADDR_FULL_MASK)
1143 return -EINVAL;
1144 spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1145 spec.loc_host[0] = uip_entry->ip4dst;
1146 }
1147 if (uip_mask->ip4src) {
1148 if (uip_mask->ip4src != IP4_ADDR_FULL_MASK)
1149 return -EINVAL;
1150 spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1151 spec.rem_host[0] = uip_entry->ip4src;
1152 }
1153 if (uip_mask->proto) {
1154 if (uip_mask->proto != IP_PROTO_FULL_MASK)
1155 return -EINVAL;
1156 spec.match_flags |= EF4_FILTER_MATCH_IP_PROTO;
1157 spec.ip_proto = uip_entry->proto;
1158 }
1159 break;
1160
1161 case IPV6_USER_FLOW:
1162 if (uip6_mask->l4_4_bytes || uip6_mask->tclass)
1163 return -EINVAL;
1164 spec.match_flags = EF4_FILTER_MATCH_ETHER_TYPE;
1165 spec.ether_type = htons(ETH_P_IPV6);
1166 if (!ip6_mask_is_empty(uip6_mask->ip6dst)) {
1167 if (!ip6_mask_is_full(uip6_mask->ip6dst))
1168 return -EINVAL;
1169 spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1170 memcpy(spec.loc_host, uip6_entry->ip6dst, sizeof(spec.loc_host));
1171 }
1172 if (!ip6_mask_is_empty(uip6_mask->ip6src)) {
1173 if (!ip6_mask_is_full(uip6_mask->ip6src))
1174 return -EINVAL;
1175 spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1176 memcpy(spec.rem_host, uip6_entry->ip6src, sizeof(spec.rem_host));
1177 }
1178 if (uip6_mask->l4_proto) {
1179 if (uip6_mask->l4_proto != IP_PROTO_FULL_MASK)
1180 return -EINVAL;
1181 spec.match_flags |= EF4_FILTER_MATCH_IP_PROTO;
1182 spec.ip_proto = uip6_entry->l4_proto;
1183 }
1184 break;
1185
1186 case ETHER_FLOW:
1187 if (!is_zero_ether_addr(mac_mask->h_dest)) {
1188 if (ether_addr_equal(mac_mask->h_dest,
1189 mac_addr_ig_mask))
1190 spec.match_flags |= EF4_FILTER_MATCH_LOC_MAC_IG;
1191 else if (is_broadcast_ether_addr(mac_mask->h_dest))
1192 spec.match_flags |= EF4_FILTER_MATCH_LOC_MAC;
1193 else
1194 return -EINVAL;
1195 ether_addr_copy(spec.loc_mac, mac_entry->h_dest);
1196 }
1197 if (!is_zero_ether_addr(mac_mask->h_source)) {
1198 if (!is_broadcast_ether_addr(mac_mask->h_source))
1199 return -EINVAL;
1200 spec.match_flags |= EF4_FILTER_MATCH_REM_MAC;
1201 ether_addr_copy(spec.rem_mac, mac_entry->h_source);
1202 }
1203 if (mac_mask->h_proto) {
1204 if (mac_mask->h_proto != ETHER_TYPE_FULL_MASK)
1205 return -EINVAL;
1206 spec.match_flags |= EF4_FILTER_MATCH_ETHER_TYPE;
1207 spec.ether_type = mac_entry->h_proto;
1208 }
1209 break;
1210
1211 default:
1212 return -EINVAL;
1213 }
1214
1215 if ((rule->flow_type & FLOW_EXT) && rule->m_ext.vlan_tci) {
1216 if (rule->m_ext.vlan_tci != htons(0xfff))
1217 return -EINVAL;
1218 spec.match_flags |= EF4_FILTER_MATCH_OUTER_VID;
1219 spec.outer_vid = rule->h_ext.vlan_tci;
1220 }
1221
1222 rc = ef4_filter_insert_filter(efx, &spec, true);
1223 if (rc < 0)
1224 return rc;
1225
1226 rule->location = rc;
1227 return 0;
1228}
1229
1230static int ef4_ethtool_set_rxnfc(struct net_device *net_dev,
1231 struct ethtool_rxnfc *info)
1232{
1233 struct ef4_nic *efx = netdev_priv(net_dev);
1234
1235 if (ef4_filter_get_rx_id_limit(efx) == 0)
1236 return -EOPNOTSUPP;
1237
1238 switch (info->cmd) {
1239 case ETHTOOL_SRXCLSRLINS:
1240 return ef4_ethtool_set_class_rule(efx, &info->fs);
1241
1242 case ETHTOOL_SRXCLSRLDEL:
1243 return ef4_filter_remove_id_safe(efx, EF4_FILTER_PRI_MANUAL,
1244 info->fs.location);
1245
1246 default:
1247 return -EOPNOTSUPP;
1248 }
1249}
1250
1251static u32 ef4_ethtool_get_rxfh_indir_size(struct net_device *net_dev)
1252{
1253 struct ef4_nic *efx = netdev_priv(net_dev);
1254
1255 return ((ef4_nic_rev(efx) < EF4_REV_FALCON_B0 ||
1256 efx->n_rx_channels == 1) ?
1257 0 : ARRAY_SIZE(efx->rx_indir_table));
1258}
1259
1260static int ef4_ethtool_get_rxfh(struct net_device *net_dev, u32 *indir, u8 *key,
1261 u8 *hfunc)
1262{
1263 struct ef4_nic *efx = netdev_priv(net_dev);
1264
1265 if (hfunc)
1266 *hfunc = ETH_RSS_HASH_TOP;
1267 if (indir)
1268 memcpy(indir, efx->rx_indir_table, sizeof(efx->rx_indir_table));
1269 return 0;
1270}
1271
1272static int ef4_ethtool_set_rxfh(struct net_device *net_dev, const u32 *indir,
1273 const u8 *key, const u8 hfunc)
1274{
1275 struct ef4_nic *efx = netdev_priv(net_dev);
1276
1277
1278 if (key ||
1279 (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
1280 return -EOPNOTSUPP;
1281 if (!indir)
1282 return 0;
1283
1284 return efx->type->rx_push_rss_config(efx, true, indir);
1285}
1286
1287static int ef4_ethtool_get_module_eeprom(struct net_device *net_dev,
1288 struct ethtool_eeprom *ee,
1289 u8 *data)
1290{
1291 struct ef4_nic *efx = netdev_priv(net_dev);
1292 int ret;
1293
1294 if (!efx->phy_op || !efx->phy_op->get_module_eeprom)
1295 return -EOPNOTSUPP;
1296
1297 mutex_lock(&efx->mac_lock);
1298 ret = efx->phy_op->get_module_eeprom(efx, ee, data);
1299 mutex_unlock(&efx->mac_lock);
1300
1301 return ret;
1302}
1303
1304static int ef4_ethtool_get_module_info(struct net_device *net_dev,
1305 struct ethtool_modinfo *modinfo)
1306{
1307 struct ef4_nic *efx = netdev_priv(net_dev);
1308 int ret;
1309
1310 if (!efx->phy_op || !efx->phy_op->get_module_info)
1311 return -EOPNOTSUPP;
1312
1313 mutex_lock(&efx->mac_lock);
1314 ret = efx->phy_op->get_module_info(efx, modinfo);
1315 mutex_unlock(&efx->mac_lock);
1316
1317 return ret;
1318}
1319
1320const struct ethtool_ops ef4_ethtool_ops = {
1321 .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1322 ETHTOOL_COALESCE_USECS_IRQ |
1323 ETHTOOL_COALESCE_USE_ADAPTIVE_RX,
1324 .get_drvinfo = ef4_ethtool_get_drvinfo,
1325 .get_regs_len = ef4_ethtool_get_regs_len,
1326 .get_regs = ef4_ethtool_get_regs,
1327 .get_msglevel = ef4_ethtool_get_msglevel,
1328 .set_msglevel = ef4_ethtool_set_msglevel,
1329 .nway_reset = ef4_ethtool_nway_reset,
1330 .get_link = ethtool_op_get_link,
1331 .get_coalesce = ef4_ethtool_get_coalesce,
1332 .set_coalesce = ef4_ethtool_set_coalesce,
1333 .get_ringparam = ef4_ethtool_get_ringparam,
1334 .set_ringparam = ef4_ethtool_set_ringparam,
1335 .get_pauseparam = ef4_ethtool_get_pauseparam,
1336 .set_pauseparam = ef4_ethtool_set_pauseparam,
1337 .get_sset_count = ef4_ethtool_get_sset_count,
1338 .self_test = ef4_ethtool_self_test,
1339 .get_strings = ef4_ethtool_get_strings,
1340 .set_phys_id = ef4_ethtool_phys_id,
1341 .get_ethtool_stats = ef4_ethtool_get_stats,
1342 .get_wol = ef4_ethtool_get_wol,
1343 .set_wol = ef4_ethtool_set_wol,
1344 .reset = ef4_ethtool_reset,
1345 .get_rxnfc = ef4_ethtool_get_rxnfc,
1346 .set_rxnfc = ef4_ethtool_set_rxnfc,
1347 .get_rxfh_indir_size = ef4_ethtool_get_rxfh_indir_size,
1348 .get_rxfh = ef4_ethtool_get_rxfh,
1349 .set_rxfh = ef4_ethtool_set_rxfh,
1350 .get_module_info = ef4_ethtool_get_module_info,
1351 .get_module_eeprom = ef4_ethtool_get_module_eeprom,
1352 .get_link_ksettings = ef4_ethtool_get_link_ksettings,
1353 .set_link_ksettings = ef4_ethtool_set_link_ksettings,
1354};
1355
