1 // SPDX-License-Identifier: GPL-2.0-only
2 /****************************************************************************
3  * Driver for Solarflare network controllers and boards
4  * Copyright 2005-2006 Fen Systems Ltd.
5  * Copyright 2006-2013 Solarflare Communications Inc.
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 
19 struct 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); /* Reader function */
28 };
29 
30 /* Initialiser for a struct ef4_sw_stat_desc with type-checking */
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 
42 static u64 ef4_get_uint_stat(void *field)
43 {
44 	return *(unsigned int *)field;
45 }
46 
47 static 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 
64 static 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  * Ethtool operations
85  *
86  **************************************************************************
87  */
88 
89 /* Identify device by flashing LEDs */
90 static 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;	/* cycle on/off once per second */
108 	}
109 
110 	efx->type->set_id_led(efx, mode);
111 	return 0;
112 }
113 
114 /* This must be called with rtnl_lock held. */
115 static int
116 ef4_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 	/* Both MACs support pause frames (bidirectional and respond-only) */
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 /* This must be called with rtnl_lock held. */
139 static int
140 ef4_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 	/* GMAC does not support 1000Mbps HD */
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 
160 static 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 
170 static 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 
175 static 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 
184 static 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 
190 static 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  * ef4_fill_test - fill in an individual self-test entry
198  * @test_index:		Index of the test
199  * @strings:		Ethtool strings, or %NULL
200  * @data:		Ethtool test results, or %NULL
201  * @test:		Pointer to test result (used only if data != %NULL)
202  * @unit_format:	Unit name format (e.g. "chan\%d")
203  * @unit_id:		Unit id (e.g. 0 for "chan0")
204  * @test_format:	Test name format (e.g. "loopback.\%s.tx.sent")
205  * @test_id:		Test id (e.g. "PHYXS" for "loopback.PHYXS.tx_sent")
206  *
207  * Fill in an individual self-test entry.
208  */
209 static 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 	/* Fill data value, if applicable */
216 	if (data)
217 		data[test_index] = *test;
218 
219 	/* Fill string, if applicable */
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  * ef4_fill_loopback_test - fill in a block of loopback self-test entries
241  * @efx:		Efx NIC
242  * @lb_tests:		Efx loopback self-test results structure
243  * @mode:		Loopback test mode
244  * @test_index:		Starting index of the test
245  * @strings:		Ethtool strings, or %NULL
246  * @data:		Ethtool test results, or %NULL
247  *
248  * Fill in a block of loopback self-test entries.  Return new test
249  * index.
250  */
251 static 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  * ef4_ethtool_fill_self_tests - get self-test details
285  * @efx:		Efx NIC
286  * @tests:		Efx self-test results structure, or %NULL
287  * @strings:		Ethtool strings, or %NULL
288  * @data:		Ethtool test results, or %NULL
289  *
290  * Get self-test number of strings, strings, and/or test results.
291  * Return number of strings (== number of test results).
292  *
293  * The reason for merging these three functions is to make sure that
294  * they can never be inconsistent.
295  */
296 static 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 	/* Event queues */
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 	/* Loopback tests */
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 
356 static 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 
387 static 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 
404 static 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 		/* No other string sets */
426 		break;
427 	}
428 }
429 
430 static 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 	/* Get NIC statistics */
444 	data += efx->type->update_stats(efx, data, NULL);
445 
446 	/* Get software statistics */
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 
494 static 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 	/* We need rx buffers and interrupts. */
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 
534 out:
535 	ef4_ethtool_fill_self_tests(efx, ef4_tests, NULL, data);
536 	kfree(ef4_tests);
537 fail:
538 	if (rc)
539 		test->flags |= ETH_TEST_FL_FAILED;
540 }
541 
542 /* Restart autonegotiation */
543 static 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  * Each channel has a single IRQ and moderation timer, started by any
552  * completion (or other event).  Unless the module parameter
553  * separate_tx_channels is set, IRQs and moderation are therefore
554  * shared between RX and TX completions.  In this case, when RX IRQ
555  * moderation is explicitly changed then TX IRQ moderation is
556  * automatically changed too, but otherwise we fail if the two values
557  * are requested to be different.
558  *
559  * The hardware does not support a limit on the number of completions
560  * before an IRQ, so we do not use the max_frames fields.  We should
561  * report and require that max_frames == (usecs != 0), but this would
562  * invalidate existing user documentation.
563  *
564  * The hardware does not have distinct settings for interrupt
565  * moderation while the previous IRQ is being handled, so we should
566  * not use the 'irq' fields.  However, an earlier developer
567  * misunderstood the meaning of the 'irq' fields and the driver did
568  * not support the standard fields.  To avoid invalidating existing
569  * user documentation, we report and accept changes through either the
570  * standard or 'irq' fields.  If both are changed at the same time, we
571  * prefer the standard field.
572  *
573  * We implement adaptive IRQ moderation, but use a different algorithm
574  * from that assumed in the definition of struct ethtool_coalesce.
575  * Therefore we do not use any of the adaptive moderation parameters
576  * in it.
577  */
578 
579 static 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 
599 static 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 	/* If channels are shared, TX IRQ moderation can be quietly
620 	 * overridden unless it is changed from its old value.
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 
640 static void ef4_ethtool_get_ringparam(struct net_device *net_dev,
641 				      struct ethtool_ringparam *ring)
642 {
643 	struct ef4_nic *efx = netdev_priv(net_dev);
644 
645 	ring->rx_max_pending = EF4_MAX_DMAQ_SIZE;
646 	ring->tx_max_pending = EF4_MAX_DMAQ_SIZE;
647 	ring->rx_pending = efx->rxq_entries;
648 	ring->tx_pending = efx->txq_entries;
649 }
650 
651 static int ef4_ethtool_set_ringparam(struct net_device *net_dev,
652 				     struct ethtool_ringparam *ring)
653 {
654 	struct ef4_nic *efx = netdev_priv(net_dev);
655 	u32 txq_entries;
656 
657 	if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
658 	    ring->rx_pending > EF4_MAX_DMAQ_SIZE ||
659 	    ring->tx_pending > EF4_MAX_DMAQ_SIZE)
660 		return -EINVAL;
661 
662 	if (ring->rx_pending < EF4_RXQ_MIN_ENT) {
663 		netif_err(efx, drv, efx->net_dev,
664 			  "RX queues cannot be smaller than %u\n",
665 			  EF4_RXQ_MIN_ENT);
666 		return -EINVAL;
667 	}
668 
669 	txq_entries = max(ring->tx_pending, EF4_TXQ_MIN_ENT(efx));
670 	if (txq_entries != ring->tx_pending)
671 		netif_warn(efx, drv, efx->net_dev,
672 			   "increasing TX queue size to minimum of %u\n",
673 			   txq_entries);
674 
675 	return ef4_realloc_channels(efx, ring->rx_pending, txq_entries);
676 }
677 
678 static int ef4_ethtool_set_pauseparam(struct net_device *net_dev,
679 				      struct ethtool_pauseparam *pause)
680 {
681 	struct ef4_nic *efx = netdev_priv(net_dev);
682 	u8 wanted_fc, old_fc;
683 	u32 old_adv;
684 	int rc = 0;
685 
686 	mutex_lock(&efx->mac_lock);
687 
688 	wanted_fc = ((pause->rx_pause ? EF4_FC_RX : 0) |
689 		     (pause->tx_pause ? EF4_FC_TX : 0) |
690 		     (pause->autoneg ? EF4_FC_AUTO : 0));
691 
692 	if ((wanted_fc & EF4_FC_TX) && !(wanted_fc & EF4_FC_RX)) {
693 		netif_dbg(efx, drv, efx->net_dev,
694 			  "Flow control unsupported: tx ON rx OFF\n");
695 		rc = -EINVAL;
696 		goto out;
697 	}
698 
699 	if ((wanted_fc & EF4_FC_AUTO) && !efx->link_advertising) {
700 		netif_dbg(efx, drv, efx->net_dev,
701 			  "Autonegotiation is disabled\n");
702 		rc = -EINVAL;
703 		goto out;
704 	}
705 
706 	/* Hook for Falcon bug 11482 workaround */
707 	if (efx->type->prepare_enable_fc_tx &&
708 	    (wanted_fc & EF4_FC_TX) && !(efx->wanted_fc & EF4_FC_TX))
709 		efx->type->prepare_enable_fc_tx(efx);
710 
711 	old_adv = efx->link_advertising;
712 	old_fc = efx->wanted_fc;
713 	ef4_link_set_wanted_fc(efx, wanted_fc);
714 	if (efx->link_advertising != old_adv ||
715 	    (efx->wanted_fc ^ old_fc) & EF4_FC_AUTO) {
716 		rc = efx->phy_op->reconfigure(efx);
717 		if (rc) {
718 			netif_err(efx, drv, efx->net_dev,
719 				  "Unable to advertise requested flow "
720 				  "control setting\n");
721 			goto out;
722 		}
723 	}
724 
725 	/* Reconfigure the MAC. The PHY *may* generate a link state change event
726 	 * if the user just changed the advertised capabilities, but there's no
727 	 * harm doing this twice */
728 	ef4_mac_reconfigure(efx);
729 
730 out:
731 	mutex_unlock(&efx->mac_lock);
732 
733 	return rc;
734 }
735 
736 static void ef4_ethtool_get_pauseparam(struct net_device *net_dev,
737 				       struct ethtool_pauseparam *pause)
738 {
739 	struct ef4_nic *efx = netdev_priv(net_dev);
740 
741 	pause->rx_pause = !!(efx->wanted_fc & EF4_FC_RX);
742 	pause->tx_pause = !!(efx->wanted_fc & EF4_FC_TX);
743 	pause->autoneg = !!(efx->wanted_fc & EF4_FC_AUTO);
744 }
745 
746 static void ef4_ethtool_get_wol(struct net_device *net_dev,
747 				struct ethtool_wolinfo *wol)
748 {
749 	struct ef4_nic *efx = netdev_priv(net_dev);
750 	return efx->type->get_wol(efx, wol);
751 }
752 
753 
754 static int ef4_ethtool_set_wol(struct net_device *net_dev,
755 			       struct ethtool_wolinfo *wol)
756 {
757 	struct ef4_nic *efx = netdev_priv(net_dev);
758 	return efx->type->set_wol(efx, wol->wolopts);
759 }
760 
761 static int ef4_ethtool_reset(struct net_device *net_dev, u32 *flags)
762 {
763 	struct ef4_nic *efx = netdev_priv(net_dev);
764 	int rc;
765 
766 	rc = efx->type->map_reset_flags(flags);
767 	if (rc < 0)
768 		return rc;
769 
770 	return ef4_reset(efx, rc);
771 }
772 
773 /* MAC address mask including only I/G bit */
774 static const u8 mac_addr_ig_mask[ETH_ALEN] __aligned(2) = {0x01, 0, 0, 0, 0, 0};
775 
776 #define IP4_ADDR_FULL_MASK	((__force __be32)~0)
777 #define IP_PROTO_FULL_MASK	0xFF
778 #define PORT_FULL_MASK		((__force __be16)~0)
779 #define ETHER_TYPE_FULL_MASK	((__force __be16)~0)
780 
781 static inline void ip6_fill_mask(__be32 *mask)
782 {
783 	mask[0] = mask[1] = mask[2] = mask[3] = ~(__be32)0;
784 }
785 
786 static int ef4_ethtool_get_class_rule(struct ef4_nic *efx,
787 				      struct ethtool_rx_flow_spec *rule)
788 {
789 	struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
790 	struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
791 	struct ethtool_usrip4_spec *uip_entry = &rule->h_u.usr_ip4_spec;
792 	struct ethtool_usrip4_spec *uip_mask = &rule->m_u.usr_ip4_spec;
793 	struct ethtool_tcpip6_spec *ip6_entry = &rule->h_u.tcp_ip6_spec;
794 	struct ethtool_tcpip6_spec *ip6_mask = &rule->m_u.tcp_ip6_spec;
795 	struct ethtool_usrip6_spec *uip6_entry = &rule->h_u.usr_ip6_spec;
796 	struct ethtool_usrip6_spec *uip6_mask = &rule->m_u.usr_ip6_spec;
797 	struct ethhdr *mac_entry = &rule->h_u.ether_spec;
798 	struct ethhdr *mac_mask = &rule->m_u.ether_spec;
799 	struct ef4_filter_spec spec;
800 	int rc;
801 
802 	rc = ef4_filter_get_filter_safe(efx, EF4_FILTER_PRI_MANUAL,
803 					rule->location, &spec);
804 	if (rc)
805 		return rc;
806 
807 	if (spec.dmaq_id == EF4_FILTER_RX_DMAQ_ID_DROP)
808 		rule->ring_cookie = RX_CLS_FLOW_DISC;
809 	else
810 		rule->ring_cookie = spec.dmaq_id;
811 
812 	if ((spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE) &&
813 	    spec.ether_type == htons(ETH_P_IP) &&
814 	    (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) &&
815 	    (spec.ip_proto == IPPROTO_TCP || spec.ip_proto == IPPROTO_UDP) &&
816 	    !(spec.match_flags &
817 	      ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
818 		EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
819 		EF4_FILTER_MATCH_IP_PROTO |
820 		EF4_FILTER_MATCH_LOC_PORT | EF4_FILTER_MATCH_REM_PORT))) {
821 		rule->flow_type = ((spec.ip_proto == IPPROTO_TCP) ?
822 				   TCP_V4_FLOW : UDP_V4_FLOW);
823 		if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
824 			ip_entry->ip4dst = spec.loc_host[0];
825 			ip_mask->ip4dst = IP4_ADDR_FULL_MASK;
826 		}
827 		if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
828 			ip_entry->ip4src = spec.rem_host[0];
829 			ip_mask->ip4src = IP4_ADDR_FULL_MASK;
830 		}
831 		if (spec.match_flags & EF4_FILTER_MATCH_LOC_PORT) {
832 			ip_entry->pdst = spec.loc_port;
833 			ip_mask->pdst = PORT_FULL_MASK;
834 		}
835 		if (spec.match_flags & EF4_FILTER_MATCH_REM_PORT) {
836 			ip_entry->psrc = spec.rem_port;
837 			ip_mask->psrc = PORT_FULL_MASK;
838 		}
839 	} else if ((spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE) &&
840 	    spec.ether_type == htons(ETH_P_IPV6) &&
841 	    (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) &&
842 	    (spec.ip_proto == IPPROTO_TCP || spec.ip_proto == IPPROTO_UDP) &&
843 	    !(spec.match_flags &
844 	      ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
845 		EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
846 		EF4_FILTER_MATCH_IP_PROTO |
847 		EF4_FILTER_MATCH_LOC_PORT | EF4_FILTER_MATCH_REM_PORT))) {
848 		rule->flow_type = ((spec.ip_proto == IPPROTO_TCP) ?
849 				   TCP_V6_FLOW : UDP_V6_FLOW);
850 		if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
851 			memcpy(ip6_entry->ip6dst, spec.loc_host,
852 			       sizeof(ip6_entry->ip6dst));
853 			ip6_fill_mask(ip6_mask->ip6dst);
854 		}
855 		if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
856 			memcpy(ip6_entry->ip6src, spec.rem_host,
857 			       sizeof(ip6_entry->ip6src));
858 			ip6_fill_mask(ip6_mask->ip6src);
859 		}
860 		if (spec.match_flags & EF4_FILTER_MATCH_LOC_PORT) {
861 			ip6_entry->pdst = spec.loc_port;
862 			ip6_mask->pdst = PORT_FULL_MASK;
863 		}
864 		if (spec.match_flags & EF4_FILTER_MATCH_REM_PORT) {
865 			ip6_entry->psrc = spec.rem_port;
866 			ip6_mask->psrc = PORT_FULL_MASK;
867 		}
868 	} else if (!(spec.match_flags &
869 		     ~(EF4_FILTER_MATCH_LOC_MAC | EF4_FILTER_MATCH_LOC_MAC_IG |
870 		       EF4_FILTER_MATCH_REM_MAC | EF4_FILTER_MATCH_ETHER_TYPE |
871 		       EF4_FILTER_MATCH_OUTER_VID))) {
872 		rule->flow_type = ETHER_FLOW;
873 		if (spec.match_flags &
874 		    (EF4_FILTER_MATCH_LOC_MAC | EF4_FILTER_MATCH_LOC_MAC_IG)) {
875 			ether_addr_copy(mac_entry->h_dest, spec.loc_mac);
876 			if (spec.match_flags & EF4_FILTER_MATCH_LOC_MAC)
877 				eth_broadcast_addr(mac_mask->h_dest);
878 			else
879 				ether_addr_copy(mac_mask->h_dest,
880 						mac_addr_ig_mask);
881 		}
882 		if (spec.match_flags & EF4_FILTER_MATCH_REM_MAC) {
883 			ether_addr_copy(mac_entry->h_source, spec.rem_mac);
884 			eth_broadcast_addr(mac_mask->h_source);
885 		}
886 		if (spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE) {
887 			mac_entry->h_proto = spec.ether_type;
888 			mac_mask->h_proto = ETHER_TYPE_FULL_MASK;
889 		}
890 	} else if (spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE &&
891 		   spec.ether_type == htons(ETH_P_IP) &&
892 		   !(spec.match_flags &
893 		     ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
894 		       EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
895 		       EF4_FILTER_MATCH_IP_PROTO))) {
896 		rule->flow_type = IPV4_USER_FLOW;
897 		uip_entry->ip_ver = ETH_RX_NFC_IP4;
898 		if (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) {
899 			uip_mask->proto = IP_PROTO_FULL_MASK;
900 			uip_entry->proto = spec.ip_proto;
901 		}
902 		if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
903 			uip_entry->ip4dst = spec.loc_host[0];
904 			uip_mask->ip4dst = IP4_ADDR_FULL_MASK;
905 		}
906 		if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
907 			uip_entry->ip4src = spec.rem_host[0];
908 			uip_mask->ip4src = IP4_ADDR_FULL_MASK;
909 		}
910 	} else if (spec.match_flags & EF4_FILTER_MATCH_ETHER_TYPE &&
911 		   spec.ether_type == htons(ETH_P_IPV6) &&
912 		   !(spec.match_flags &
913 		     ~(EF4_FILTER_MATCH_ETHER_TYPE | EF4_FILTER_MATCH_OUTER_VID |
914 		       EF4_FILTER_MATCH_LOC_HOST | EF4_FILTER_MATCH_REM_HOST |
915 		       EF4_FILTER_MATCH_IP_PROTO))) {
916 		rule->flow_type = IPV6_USER_FLOW;
917 		if (spec.match_flags & EF4_FILTER_MATCH_IP_PROTO) {
918 			uip6_mask->l4_proto = IP_PROTO_FULL_MASK;
919 			uip6_entry->l4_proto = spec.ip_proto;
920 		}
921 		if (spec.match_flags & EF4_FILTER_MATCH_LOC_HOST) {
922 			memcpy(uip6_entry->ip6dst, spec.loc_host,
923 			       sizeof(uip6_entry->ip6dst));
924 			ip6_fill_mask(uip6_mask->ip6dst);
925 		}
926 		if (spec.match_flags & EF4_FILTER_MATCH_REM_HOST) {
927 			memcpy(uip6_entry->ip6src, spec.rem_host,
928 			       sizeof(uip6_entry->ip6src));
929 			ip6_fill_mask(uip6_mask->ip6src);
930 		}
931 	} else {
932 		/* The above should handle all filters that we insert */
933 		WARN_ON(1);
934 		return -EINVAL;
935 	}
936 
937 	if (spec.match_flags & EF4_FILTER_MATCH_OUTER_VID) {
938 		rule->flow_type |= FLOW_EXT;
939 		rule->h_ext.vlan_tci = spec.outer_vid;
940 		rule->m_ext.vlan_tci = htons(0xfff);
941 	}
942 
943 	return rc;
944 }
945 
946 static int
947 ef4_ethtool_get_rxnfc(struct net_device *net_dev,
948 		      struct ethtool_rxnfc *info, u32 *rule_locs)
949 {
950 	struct ef4_nic *efx = netdev_priv(net_dev);
951 
952 	switch (info->cmd) {
953 	case ETHTOOL_GRXRINGS:
954 		info->data = efx->n_rx_channels;
955 		return 0;
956 
957 	case ETHTOOL_GRXFH: {
958 		unsigned min_revision = 0;
959 
960 		info->data = 0;
961 		switch (info->flow_type) {
962 		case TCP_V4_FLOW:
963 			info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
964 			fallthrough;
965 		case UDP_V4_FLOW:
966 		case SCTP_V4_FLOW:
967 		case AH_ESP_V4_FLOW:
968 		case IPV4_FLOW:
969 			info->data |= RXH_IP_SRC | RXH_IP_DST;
970 			min_revision = EF4_REV_FALCON_B0;
971 			break;
972 		default:
973 			break;
974 		}
975 		if (ef4_nic_rev(efx) < min_revision)
976 			info->data = 0;
977 		return 0;
978 	}
979 
980 	case ETHTOOL_GRXCLSRLCNT:
981 		info->data = ef4_filter_get_rx_id_limit(efx);
982 		if (info->data == 0)
983 			return -EOPNOTSUPP;
984 		info->data |= RX_CLS_LOC_SPECIAL;
985 		info->rule_cnt =
986 			ef4_filter_count_rx_used(efx, EF4_FILTER_PRI_MANUAL);
987 		return 0;
988 
989 	case ETHTOOL_GRXCLSRULE:
990 		if (ef4_filter_get_rx_id_limit(efx) == 0)
991 			return -EOPNOTSUPP;
992 		return ef4_ethtool_get_class_rule(efx, &info->fs);
993 
994 	case ETHTOOL_GRXCLSRLALL: {
995 		s32 rc;
996 		info->data = ef4_filter_get_rx_id_limit(efx);
997 		if (info->data == 0)
998 			return -EOPNOTSUPP;
999 		rc = ef4_filter_get_rx_ids(efx, EF4_FILTER_PRI_MANUAL,
1000 					   rule_locs, info->rule_cnt);
1001 		if (rc < 0)
1002 			return rc;
1003 		info->rule_cnt = rc;
1004 		return 0;
1005 	}
1006 
1007 	default:
1008 		return -EOPNOTSUPP;
1009 	}
1010 }
1011 
1012 static inline bool ip6_mask_is_full(__be32 mask[4])
1013 {
1014 	return !~(mask[0] & mask[1] & mask[2] & mask[3]);
1015 }
1016 
1017 static inline bool ip6_mask_is_empty(__be32 mask[4])
1018 {
1019 	return !(mask[0] | mask[1] | mask[2] | mask[3]);
1020 }
1021 
1022 static int ef4_ethtool_set_class_rule(struct ef4_nic *efx,
1023 				      struct ethtool_rx_flow_spec *rule)
1024 {
1025 	struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
1026 	struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
1027 	struct ethtool_usrip4_spec *uip_entry = &rule->h_u.usr_ip4_spec;
1028 	struct ethtool_usrip4_spec *uip_mask = &rule->m_u.usr_ip4_spec;
1029 	struct ethtool_tcpip6_spec *ip6_entry = &rule->h_u.tcp_ip6_spec;
1030 	struct ethtool_tcpip6_spec *ip6_mask = &rule->m_u.tcp_ip6_spec;
1031 	struct ethtool_usrip6_spec *uip6_entry = &rule->h_u.usr_ip6_spec;
1032 	struct ethtool_usrip6_spec *uip6_mask = &rule->m_u.usr_ip6_spec;
1033 	struct ethhdr *mac_entry = &rule->h_u.ether_spec;
1034 	struct ethhdr *mac_mask = &rule->m_u.ether_spec;
1035 	struct ef4_filter_spec spec;
1036 	int rc;
1037 
1038 	/* Check that user wants us to choose the location */
1039 	if (rule->location != RX_CLS_LOC_ANY)
1040 		return -EINVAL;
1041 
1042 	/* Range-check ring_cookie */
1043 	if (rule->ring_cookie >= efx->n_rx_channels &&
1044 	    rule->ring_cookie != RX_CLS_FLOW_DISC)
1045 		return -EINVAL;
1046 
1047 	/* Check for unsupported extensions */
1048 	if ((rule->flow_type & FLOW_EXT) &&
1049 	    (rule->m_ext.vlan_etype || rule->m_ext.data[0] ||
1050 	     rule->m_ext.data[1]))
1051 		return -EINVAL;
1052 
1053 	ef4_filter_init_rx(&spec, EF4_FILTER_PRI_MANUAL,
1054 			   efx->rx_scatter ? EF4_FILTER_FLAG_RX_SCATTER : 0,
1055 			   (rule->ring_cookie == RX_CLS_FLOW_DISC) ?
1056 			   EF4_FILTER_RX_DMAQ_ID_DROP : rule->ring_cookie);
1057 
1058 	switch (rule->flow_type & ~FLOW_EXT) {
1059 	case TCP_V4_FLOW:
1060 	case UDP_V4_FLOW:
1061 		spec.match_flags = (EF4_FILTER_MATCH_ETHER_TYPE |
1062 				    EF4_FILTER_MATCH_IP_PROTO);
1063 		spec.ether_type = htons(ETH_P_IP);
1064 		spec.ip_proto = ((rule->flow_type & ~FLOW_EXT) == TCP_V4_FLOW ?
1065 				 IPPROTO_TCP : IPPROTO_UDP);
1066 		if (ip_mask->ip4dst) {
1067 			if (ip_mask->ip4dst != IP4_ADDR_FULL_MASK)
1068 				return -EINVAL;
1069 			spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1070 			spec.loc_host[0] = ip_entry->ip4dst;
1071 		}
1072 		if (ip_mask->ip4src) {
1073 			if (ip_mask->ip4src != IP4_ADDR_FULL_MASK)
1074 				return -EINVAL;
1075 			spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1076 			spec.rem_host[0] = ip_entry->ip4src;
1077 		}
1078 		if (ip_mask->pdst) {
1079 			if (ip_mask->pdst != PORT_FULL_MASK)
1080 				return -EINVAL;
1081 			spec.match_flags |= EF4_FILTER_MATCH_LOC_PORT;
1082 			spec.loc_port = ip_entry->pdst;
1083 		}
1084 		if (ip_mask->psrc) {
1085 			if (ip_mask->psrc != PORT_FULL_MASK)
1086 				return -EINVAL;
1087 			spec.match_flags |= EF4_FILTER_MATCH_REM_PORT;
1088 			spec.rem_port = ip_entry->psrc;
1089 		}
1090 		if (ip_mask->tos)
1091 			return -EINVAL;
1092 		break;
1093 
1094 	case TCP_V6_FLOW:
1095 	case UDP_V6_FLOW:
1096 		spec.match_flags = (EF4_FILTER_MATCH_ETHER_TYPE |
1097 				    EF4_FILTER_MATCH_IP_PROTO);
1098 		spec.ether_type = htons(ETH_P_IPV6);
1099 		spec.ip_proto = ((rule->flow_type & ~FLOW_EXT) == TCP_V6_FLOW ?
1100 				 IPPROTO_TCP : IPPROTO_UDP);
1101 		if (!ip6_mask_is_empty(ip6_mask->ip6dst)) {
1102 			if (!ip6_mask_is_full(ip6_mask->ip6dst))
1103 				return -EINVAL;
1104 			spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1105 			memcpy(spec.loc_host, ip6_entry->ip6dst, sizeof(spec.loc_host));
1106 		}
1107 		if (!ip6_mask_is_empty(ip6_mask->ip6src)) {
1108 			if (!ip6_mask_is_full(ip6_mask->ip6src))
1109 				return -EINVAL;
1110 			spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1111 			memcpy(spec.rem_host, ip6_entry->ip6src, sizeof(spec.rem_host));
1112 		}
1113 		if (ip6_mask->pdst) {
1114 			if (ip6_mask->pdst != PORT_FULL_MASK)
1115 				return -EINVAL;
1116 			spec.match_flags |= EF4_FILTER_MATCH_LOC_PORT;
1117 			spec.loc_port = ip6_entry->pdst;
1118 		}
1119 		if (ip6_mask->psrc) {
1120 			if (ip6_mask->psrc != PORT_FULL_MASK)
1121 				return -EINVAL;
1122 			spec.match_flags |= EF4_FILTER_MATCH_REM_PORT;
1123 			spec.rem_port = ip6_entry->psrc;
1124 		}
1125 		if (ip6_mask->tclass)
1126 			return -EINVAL;
1127 		break;
1128 
1129 	case IPV4_USER_FLOW:
1130 		if (uip_mask->l4_4_bytes || uip_mask->tos || uip_mask->ip_ver ||
1131 		    uip_entry->ip_ver != ETH_RX_NFC_IP4)
1132 			return -EINVAL;
1133 		spec.match_flags = EF4_FILTER_MATCH_ETHER_TYPE;
1134 		spec.ether_type = htons(ETH_P_IP);
1135 		if (uip_mask->ip4dst) {
1136 			if (uip_mask->ip4dst != IP4_ADDR_FULL_MASK)
1137 				return -EINVAL;
1138 			spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1139 			spec.loc_host[0] = uip_entry->ip4dst;
1140 		}
1141 		if (uip_mask->ip4src) {
1142 			if (uip_mask->ip4src != IP4_ADDR_FULL_MASK)
1143 				return -EINVAL;
1144 			spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1145 			spec.rem_host[0] = uip_entry->ip4src;
1146 		}
1147 		if (uip_mask->proto) {
1148 			if (uip_mask->proto != IP_PROTO_FULL_MASK)
1149 				return -EINVAL;
1150 			spec.match_flags |= EF4_FILTER_MATCH_IP_PROTO;
1151 			spec.ip_proto = uip_entry->proto;
1152 		}
1153 		break;
1154 
1155 	case IPV6_USER_FLOW:
1156 		if (uip6_mask->l4_4_bytes || uip6_mask->tclass)
1157 			return -EINVAL;
1158 		spec.match_flags = EF4_FILTER_MATCH_ETHER_TYPE;
1159 		spec.ether_type = htons(ETH_P_IPV6);
1160 		if (!ip6_mask_is_empty(uip6_mask->ip6dst)) {
1161 			if (!ip6_mask_is_full(uip6_mask->ip6dst))
1162 				return -EINVAL;
1163 			spec.match_flags |= EF4_FILTER_MATCH_LOC_HOST;
1164 			memcpy(spec.loc_host, uip6_entry->ip6dst, sizeof(spec.loc_host));
1165 		}
1166 		if (!ip6_mask_is_empty(uip6_mask->ip6src)) {
1167 			if (!ip6_mask_is_full(uip6_mask->ip6src))
1168 				return -EINVAL;
1169 			spec.match_flags |= EF4_FILTER_MATCH_REM_HOST;
1170 			memcpy(spec.rem_host, uip6_entry->ip6src, sizeof(spec.rem_host));
1171 		}
1172 		if (uip6_mask->l4_proto) {
1173 			if (uip6_mask->l4_proto != IP_PROTO_FULL_MASK)
1174 				return -EINVAL;
1175 			spec.match_flags |= EF4_FILTER_MATCH_IP_PROTO;
1176 			spec.ip_proto = uip6_entry->l4_proto;
1177 		}
1178 		break;
1179 
1180 	case ETHER_FLOW:
1181 		if (!is_zero_ether_addr(mac_mask->h_dest)) {
1182 			if (ether_addr_equal(mac_mask->h_dest,
1183 					     mac_addr_ig_mask))
1184 				spec.match_flags |= EF4_FILTER_MATCH_LOC_MAC_IG;
1185 			else if (is_broadcast_ether_addr(mac_mask->h_dest))
1186 				spec.match_flags |= EF4_FILTER_MATCH_LOC_MAC;
1187 			else
1188 				return -EINVAL;
1189 			ether_addr_copy(spec.loc_mac, mac_entry->h_dest);
1190 		}
1191 		if (!is_zero_ether_addr(mac_mask->h_source)) {
1192 			if (!is_broadcast_ether_addr(mac_mask->h_source))
1193 				return -EINVAL;
1194 			spec.match_flags |= EF4_FILTER_MATCH_REM_MAC;
1195 			ether_addr_copy(spec.rem_mac, mac_entry->h_source);
1196 		}
1197 		if (mac_mask->h_proto) {
1198 			if (mac_mask->h_proto != ETHER_TYPE_FULL_MASK)
1199 				return -EINVAL;
1200 			spec.match_flags |= EF4_FILTER_MATCH_ETHER_TYPE;
1201 			spec.ether_type = mac_entry->h_proto;
1202 		}
1203 		break;
1204 
1205 	default:
1206 		return -EINVAL;
1207 	}
1208 
1209 	if ((rule->flow_type & FLOW_EXT) && rule->m_ext.vlan_tci) {
1210 		if (rule->m_ext.vlan_tci != htons(0xfff))
1211 			return -EINVAL;
1212 		spec.match_flags |= EF4_FILTER_MATCH_OUTER_VID;
1213 		spec.outer_vid = rule->h_ext.vlan_tci;
1214 	}
1215 
1216 	rc = ef4_filter_insert_filter(efx, &spec, true);
1217 	if (rc < 0)
1218 		return rc;
1219 
1220 	rule->location = rc;
1221 	return 0;
1222 }
1223 
1224 static int ef4_ethtool_set_rxnfc(struct net_device *net_dev,
1225 				 struct ethtool_rxnfc *info)
1226 {
1227 	struct ef4_nic *efx = netdev_priv(net_dev);
1228 
1229 	if (ef4_filter_get_rx_id_limit(efx) == 0)
1230 		return -EOPNOTSUPP;
1231 
1232 	switch (info->cmd) {
1233 	case ETHTOOL_SRXCLSRLINS:
1234 		return ef4_ethtool_set_class_rule(efx, &info->fs);
1235 
1236 	case ETHTOOL_SRXCLSRLDEL:
1237 		return ef4_filter_remove_id_safe(efx, EF4_FILTER_PRI_MANUAL,
1238 						 info->fs.location);
1239 
1240 	default:
1241 		return -EOPNOTSUPP;
1242 	}
1243 }
1244 
1245 static u32 ef4_ethtool_get_rxfh_indir_size(struct net_device *net_dev)
1246 {
1247 	struct ef4_nic *efx = netdev_priv(net_dev);
1248 
1249 	return ((ef4_nic_rev(efx) < EF4_REV_FALCON_B0 ||
1250 		 efx->n_rx_channels == 1) ?
1251 		0 : ARRAY_SIZE(efx->rx_indir_table));
1252 }
1253 
1254 static int ef4_ethtool_get_rxfh(struct net_device *net_dev, u32 *indir, u8 *key,
1255 				u8 *hfunc)
1256 {
1257 	struct ef4_nic *efx = netdev_priv(net_dev);
1258 
1259 	if (hfunc)
1260 		*hfunc = ETH_RSS_HASH_TOP;
1261 	if (indir)
1262 		memcpy(indir, efx->rx_indir_table, sizeof(efx->rx_indir_table));
1263 	return 0;
1264 }
1265 
1266 static int ef4_ethtool_set_rxfh(struct net_device *net_dev, const u32 *indir,
1267 				const u8 *key, const u8 hfunc)
1268 {
1269 	struct ef4_nic *efx = netdev_priv(net_dev);
1270 
1271 	/* We do not allow change in unsupported parameters */
1272 	if (key ||
1273 	    (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
1274 		return -EOPNOTSUPP;
1275 	if (!indir)
1276 		return 0;
1277 
1278 	return efx->type->rx_push_rss_config(efx, true, indir);
1279 }
1280 
1281 static int ef4_ethtool_get_module_eeprom(struct net_device *net_dev,
1282 					 struct ethtool_eeprom *ee,
1283 					 u8 *data)
1284 {
1285 	struct ef4_nic *efx = netdev_priv(net_dev);
1286 	int ret;
1287 
1288 	if (!efx->phy_op || !efx->phy_op->get_module_eeprom)
1289 		return -EOPNOTSUPP;
1290 
1291 	mutex_lock(&efx->mac_lock);
1292 	ret = efx->phy_op->get_module_eeprom(efx, ee, data);
1293 	mutex_unlock(&efx->mac_lock);
1294 
1295 	return ret;
1296 }
1297 
1298 static int ef4_ethtool_get_module_info(struct net_device *net_dev,
1299 				       struct ethtool_modinfo *modinfo)
1300 {
1301 	struct ef4_nic *efx = netdev_priv(net_dev);
1302 	int ret;
1303 
1304 	if (!efx->phy_op || !efx->phy_op->get_module_info)
1305 		return -EOPNOTSUPP;
1306 
1307 	mutex_lock(&efx->mac_lock);
1308 	ret = efx->phy_op->get_module_info(efx, modinfo);
1309 	mutex_unlock(&efx->mac_lock);
1310 
1311 	return ret;
1312 }
1313 
1314 const struct ethtool_ops ef4_ethtool_ops = {
1315 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1316 				     ETHTOOL_COALESCE_USECS_IRQ |
1317 				     ETHTOOL_COALESCE_USE_ADAPTIVE_RX,
1318 	.get_drvinfo		= ef4_ethtool_get_drvinfo,
1319 	.get_regs_len		= ef4_ethtool_get_regs_len,
1320 	.get_regs		= ef4_ethtool_get_regs,
1321 	.get_msglevel		= ef4_ethtool_get_msglevel,
1322 	.set_msglevel		= ef4_ethtool_set_msglevel,
1323 	.nway_reset		= ef4_ethtool_nway_reset,
1324 	.get_link		= ethtool_op_get_link,
1325 	.get_coalesce		= ef4_ethtool_get_coalesce,
1326 	.set_coalesce		= ef4_ethtool_set_coalesce,
1327 	.get_ringparam		= ef4_ethtool_get_ringparam,
1328 	.set_ringparam		= ef4_ethtool_set_ringparam,
1329 	.get_pauseparam         = ef4_ethtool_get_pauseparam,
1330 	.set_pauseparam         = ef4_ethtool_set_pauseparam,
1331 	.get_sset_count		= ef4_ethtool_get_sset_count,
1332 	.self_test		= ef4_ethtool_self_test,
1333 	.get_strings		= ef4_ethtool_get_strings,
1334 	.set_phys_id		= ef4_ethtool_phys_id,
1335 	.get_ethtool_stats	= ef4_ethtool_get_stats,
1336 	.get_wol                = ef4_ethtool_get_wol,
1337 	.set_wol                = ef4_ethtool_set_wol,
1338 	.reset			= ef4_ethtool_reset,
1339 	.get_rxnfc		= ef4_ethtool_get_rxnfc,
1340 	.set_rxnfc		= ef4_ethtool_set_rxnfc,
1341 	.get_rxfh_indir_size	= ef4_ethtool_get_rxfh_indir_size,
1342 	.get_rxfh		= ef4_ethtool_get_rxfh,
1343 	.set_rxfh		= ef4_ethtool_set_rxfh,
1344 	.get_module_info	= ef4_ethtool_get_module_info,
1345 	.get_module_eeprom	= ef4_ethtool_get_module_eeprom,
1346 	.get_link_ksettings	= ef4_ethtool_get_link_ksettings,
1347 	.set_link_ksettings	= ef4_ethtool_set_link_ksettings,
1348 };
1349