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
  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); /* 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
  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 * Ethtool operations
  85 *
  86 **************************************************************************
  87 */
  88
  89/* Identify device by flashing LEDs */
  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;	/* 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. */
 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	/* 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. */
 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	/* 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
 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	strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
 166	strscpy(info->version, EF4_DRIVER_VERSION, sizeof(info->version));
 167	strscpy(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 * 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 */
 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	/* 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 */
 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 * 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 */
 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	/* 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
 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			strscpy(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
 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	/* 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
 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	/* 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
 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/* Restart autonegotiation */
 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 * 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
 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	/* 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
 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	/* Hook for Falcon bug 11482 workaround */
 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	/* Reconfigure the MAC. The PHY *may* generate a link state change event
 732	 * if the user just changed the advertised capabilities, but there's no
 733	 * harm doing this twice */
 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/* MAC address mask including only I/G bit */
 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		/* The above should handle all filters that we insert */
 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	/* Check that user wants us to choose the location */
1045	if (rule->location != RX_CLS_LOC_ANY)
1046		return -EINVAL;
1047
1048	/* Range-check ring_cookie */
1049	if (rule->ring_cookie >= efx->n_rx_channels &&
1050	    rule->ring_cookie != RX_CLS_FLOW_DISC)
1051		return -EINVAL;
1052
1053	/* Check for unsupported extensions */
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,
1261				struct ethtool_rxfh_param *rxfh)
1262{
1263	struct ef4_nic *efx = netdev_priv(net_dev);
1264
1265	rxfh->hfunc = ETH_RSS_HASH_TOP;
1266	if (rxfh->indir)
1267		memcpy(rxfh->indir, efx->rx_indir_table,
1268		       sizeof(efx->rx_indir_table));
1269	return 0;
1270}
1271
1272static int ef4_ethtool_set_rxfh(struct net_device *net_dev,
1273				struct ethtool_rxfh_param *rxfh,
1274				struct netlink_ext_ack *extack)
1275{
1276	struct ef4_nic *efx = netdev_priv(net_dev);
1277
1278	/* We do not allow change in unsupported parameters */
1279	if (rxfh->key ||
1280	    (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
1281	     rxfh->hfunc != ETH_RSS_HASH_TOP))
1282		return -EOPNOTSUPP;
1283	if (!rxfh->indir)
1284		return 0;
1285
1286	return efx->type->rx_push_rss_config(efx, true, rxfh->indir);
1287}
1288
1289static int ef4_ethtool_get_module_eeprom(struct net_device *net_dev,
1290					 struct ethtool_eeprom *ee,
1291					 u8 *data)
1292{
1293	struct ef4_nic *efx = netdev_priv(net_dev);
1294	int ret;
1295
1296	if (!efx->phy_op || !efx->phy_op->get_module_eeprom)
1297		return -EOPNOTSUPP;
1298
1299	mutex_lock(&efx->mac_lock);
1300	ret = efx->phy_op->get_module_eeprom(efx, ee, data);
1301	mutex_unlock(&efx->mac_lock);
1302
1303	return ret;
1304}
1305
1306static int ef4_ethtool_get_module_info(struct net_device *net_dev,
1307				       struct ethtool_modinfo *modinfo)
1308{
1309	struct ef4_nic *efx = netdev_priv(net_dev);
1310	int ret;
1311
1312	if (!efx->phy_op || !efx->phy_op->get_module_info)
1313		return -EOPNOTSUPP;
1314
1315	mutex_lock(&efx->mac_lock);
1316	ret = efx->phy_op->get_module_info(efx, modinfo);
1317	mutex_unlock(&efx->mac_lock);
1318
1319	return ret;
1320}
1321
1322const struct ethtool_ops ef4_ethtool_ops = {
1323	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1324				     ETHTOOL_COALESCE_USECS_IRQ |
1325				     ETHTOOL_COALESCE_USE_ADAPTIVE_RX,
1326	.get_drvinfo		= ef4_ethtool_get_drvinfo,
1327	.get_regs_len		= ef4_ethtool_get_regs_len,
1328	.get_regs		= ef4_ethtool_get_regs,
1329	.get_msglevel		= ef4_ethtool_get_msglevel,
1330	.set_msglevel		= ef4_ethtool_set_msglevel,
1331	.nway_reset		= ef4_ethtool_nway_reset,
1332	.get_link		= ethtool_op_get_link,
1333	.get_coalesce		= ef4_ethtool_get_coalesce,
1334	.set_coalesce		= ef4_ethtool_set_coalesce,
1335	.get_ringparam		= ef4_ethtool_get_ringparam,
1336	.set_ringparam		= ef4_ethtool_set_ringparam,
1337	.get_pauseparam         = ef4_ethtool_get_pauseparam,
1338	.set_pauseparam         = ef4_ethtool_set_pauseparam,
1339	.get_sset_count		= ef4_ethtool_get_sset_count,
1340	.self_test		= ef4_ethtool_self_test,
1341	.get_strings		= ef4_ethtool_get_strings,
1342	.set_phys_id		= ef4_ethtool_phys_id,
1343	.get_ethtool_stats	= ef4_ethtool_get_stats,
1344	.get_wol                = ef4_ethtool_get_wol,
1345	.set_wol                = ef4_ethtool_set_wol,
1346	.reset			= ef4_ethtool_reset,
1347	.get_rxnfc		= ef4_ethtool_get_rxnfc,
1348	.set_rxnfc		= ef4_ethtool_set_rxnfc,
1349	.get_rxfh_indir_size	= ef4_ethtool_get_rxfh_indir_size,
1350	.get_rxfh		= ef4_ethtool_get_rxfh,
1351	.set_rxfh		= ef4_ethtool_set_rxfh,
1352	.get_module_info	= ef4_ethtool_get_module_info,
1353	.get_module_eeprom	= ef4_ethtool_get_module_eeprom,
1354	.get_link_ksettings	= ef4_ethtool_get_link_ksettings,
1355	.set_link_ksettings	= ef4_ethtool_set_link_ksettings,
1356};