fm10k_ethtool.c

   1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright(c) 2013 - 2019 Intel Corporation. */
   3
   4#include <linux/ethtool.h>
   5#include <linux/vmalloc.h>
   6
   7#include "fm10k.h"
   8
   9struct fm10k_stats {
  10	/* The stat_string is expected to be a format string formatted using
  11	 * vsnprintf by fm10k_add_stat_strings. Every member of a stats array
  12	 * should use the same format specifiers as they will be formatted
  13	 * using the same variadic arguments.
  14	 */
  15	char stat_string[ETH_GSTRING_LEN];
  16	int sizeof_stat;
  17	int stat_offset;
  18};
  19
  20#define FM10K_STAT_FIELDS(_type, _name, _stat) { \
  21	.stat_string = _name, \
  22	.sizeof_stat = sizeof_field(_type, _stat), \
  23	.stat_offset = offsetof(_type, _stat) \
  24}
  25
  26/* netdevice statistics */
  27#define FM10K_NETDEV_STAT(_net_stat) \
  28	FM10K_STAT_FIELDS(struct net_device_stats, __stringify(_net_stat), \
  29			  _net_stat)
  30
  31static const struct fm10k_stats fm10k_gstrings_net_stats[] = {
  32	FM10K_NETDEV_STAT(tx_packets),
  33	FM10K_NETDEV_STAT(tx_bytes),
  34	FM10K_NETDEV_STAT(tx_errors),
  35	FM10K_NETDEV_STAT(rx_packets),
  36	FM10K_NETDEV_STAT(rx_bytes),
  37	FM10K_NETDEV_STAT(rx_errors),
  38	FM10K_NETDEV_STAT(rx_dropped),
  39
  40	/* detailed Rx errors */
  41	FM10K_NETDEV_STAT(rx_length_errors),
  42	FM10K_NETDEV_STAT(rx_crc_errors),
  43	FM10K_NETDEV_STAT(rx_fifo_errors),
  44};
  45
  46#define FM10K_NETDEV_STATS_LEN	ARRAY_SIZE(fm10k_gstrings_net_stats)
  47
  48/* General interface statistics */
  49#define FM10K_STAT(_name, _stat) \
  50	FM10K_STAT_FIELDS(struct fm10k_intfc, _name, _stat)
  51
  52static const struct fm10k_stats fm10k_gstrings_global_stats[] = {
  53	FM10K_STAT("tx_restart_queue", restart_queue),
  54	FM10K_STAT("tx_busy", tx_busy),
  55	FM10K_STAT("tx_csum_errors", tx_csum_errors),
  56	FM10K_STAT("rx_alloc_failed", alloc_failed),
  57	FM10K_STAT("rx_csum_errors", rx_csum_errors),
  58
  59	FM10K_STAT("tx_packets_nic", tx_packets_nic),
  60	FM10K_STAT("tx_bytes_nic", tx_bytes_nic),
  61	FM10K_STAT("rx_packets_nic", rx_packets_nic),
  62	FM10K_STAT("rx_bytes_nic", rx_bytes_nic),
  63	FM10K_STAT("rx_drops_nic", rx_drops_nic),
  64	FM10K_STAT("rx_overrun_pf", rx_overrun_pf),
  65	FM10K_STAT("rx_overrun_vf", rx_overrun_vf),
  66
  67	FM10K_STAT("swapi_status", hw.swapi.status),
  68	FM10K_STAT("mac_rules_used", hw.swapi.mac.used),
  69	FM10K_STAT("mac_rules_avail", hw.swapi.mac.avail),
  70
  71	FM10K_STAT("reset_while_pending", hw.mac.reset_while_pending),
  72
  73	FM10K_STAT("tx_hang_count", tx_timeout_count),
  74};
  75
  76static const struct fm10k_stats fm10k_gstrings_pf_stats[] = {
  77	FM10K_STAT("timeout", stats.timeout.count),
  78	FM10K_STAT("ur", stats.ur.count),
  79	FM10K_STAT("ca", stats.ca.count),
  80	FM10K_STAT("um", stats.um.count),
  81	FM10K_STAT("xec", stats.xec.count),
  82	FM10K_STAT("vlan_drop", stats.vlan_drop.count),
  83	FM10K_STAT("loopback_drop", stats.loopback_drop.count),
  84	FM10K_STAT("nodesc_drop", stats.nodesc_drop.count),
  85};
  86
  87/* mailbox statistics */
  88#define FM10K_MBX_STAT(_name, _stat) \
  89	FM10K_STAT_FIELDS(struct fm10k_mbx_info, _name, _stat)
  90
  91static const struct fm10k_stats fm10k_gstrings_mbx_stats[] = {
  92	FM10K_MBX_STAT("mbx_tx_busy", tx_busy),
  93	FM10K_MBX_STAT("mbx_tx_dropped", tx_dropped),
  94	FM10K_MBX_STAT("mbx_tx_messages", tx_messages),
  95	FM10K_MBX_STAT("mbx_tx_dwords", tx_dwords),
  96	FM10K_MBX_STAT("mbx_tx_mbmem_pulled", tx_mbmem_pulled),
  97	FM10K_MBX_STAT("mbx_rx_messages", rx_messages),
  98	FM10K_MBX_STAT("mbx_rx_dwords", rx_dwords),
  99	FM10K_MBX_STAT("mbx_rx_parse_err", rx_parse_err),
 100	FM10K_MBX_STAT("mbx_rx_mbmem_pushed", rx_mbmem_pushed),
 101};
 102
 103/* per-queue ring statistics */
 104#define FM10K_QUEUE_STAT(_name, _stat) \
 105	FM10K_STAT_FIELDS(struct fm10k_ring, _name, _stat)
 106
 107static const struct fm10k_stats fm10k_gstrings_queue_stats[] = {
 108	FM10K_QUEUE_STAT("%s_queue_%u_packets", stats.packets),
 109	FM10K_QUEUE_STAT("%s_queue_%u_bytes", stats.bytes),
 110};
 111
 112#define FM10K_GLOBAL_STATS_LEN ARRAY_SIZE(fm10k_gstrings_global_stats)
 113#define FM10K_PF_STATS_LEN ARRAY_SIZE(fm10k_gstrings_pf_stats)
 114#define FM10K_MBX_STATS_LEN ARRAY_SIZE(fm10k_gstrings_mbx_stats)
 115#define FM10K_QUEUE_STATS_LEN ARRAY_SIZE(fm10k_gstrings_queue_stats)
 116
 117#define FM10K_STATIC_STATS_LEN (FM10K_GLOBAL_STATS_LEN + \
 118				FM10K_NETDEV_STATS_LEN + \
 119				FM10K_MBX_STATS_LEN)
 120
 121static const char fm10k_gstrings_test[][ETH_GSTRING_LEN] = {
 122	"Mailbox test (on/offline)"
 123};
 124
 125#define FM10K_TEST_LEN (sizeof(fm10k_gstrings_test) / ETH_GSTRING_LEN)
 126
 127enum fm10k_self_test_types {
 128	FM10K_TEST_MBX,
 129	FM10K_TEST_MAX = FM10K_TEST_LEN
 130};
 131
 132enum {
 133	FM10K_PRV_FLAG_LEN,
 134};
 135
 136static const char fm10k_prv_flags[FM10K_PRV_FLAG_LEN][ETH_GSTRING_LEN] = {
 137};
 138
 139static void __fm10k_add_stat_strings(u8 **p, const struct fm10k_stats stats[],
 140				     const unsigned int size, ...)
 141{
 142	unsigned int i;
 143
 144	for (i = 0; i < size; i++) {
 145		va_list args;
 146
 147		va_start(args, size);
 148		vsnprintf(*p, ETH_GSTRING_LEN, stats[i].stat_string, args);
 149		*p += ETH_GSTRING_LEN;
 150		va_end(args);
 151	}
 152}
 153
 154#define fm10k_add_stat_strings(p, stats, ...) \
 155	__fm10k_add_stat_strings(p, stats, ARRAY_SIZE(stats), ## __VA_ARGS__)
 156
 157static void fm10k_get_stat_strings(struct net_device *dev, u8 *data)
 158{
 159	struct fm10k_intfc *interface = netdev_priv(dev);
 160	unsigned int i;
 161
 162	fm10k_add_stat_strings(&data, fm10k_gstrings_net_stats);
 163
 164	fm10k_add_stat_strings(&data, fm10k_gstrings_global_stats);
 165
 166	fm10k_add_stat_strings(&data, fm10k_gstrings_mbx_stats);
 167
 168	if (interface->hw.mac.type != fm10k_mac_vf)
 169		fm10k_add_stat_strings(&data, fm10k_gstrings_pf_stats);
 170
 171	for (i = 0; i < interface->hw.mac.max_queues; i++) {
 172		fm10k_add_stat_strings(&data, fm10k_gstrings_queue_stats,
 173				       "tx", i);
 174
 175		fm10k_add_stat_strings(&data, fm10k_gstrings_queue_stats,
 176				       "rx", i);
 177	}
 178}
 179
 180static void fm10k_get_strings(struct net_device *dev,
 181			      u32 stringset, u8 *data)
 182{
 183	switch (stringset) {
 184	case ETH_SS_TEST:
 185		memcpy(data, fm10k_gstrings_test,
 186		       FM10K_TEST_LEN * ETH_GSTRING_LEN);
 187		break;
 188	case ETH_SS_STATS:
 189		fm10k_get_stat_strings(dev, data);
 190		break;
 191	case ETH_SS_PRIV_FLAGS:
 192		memcpy(data, fm10k_prv_flags,
 193		       FM10K_PRV_FLAG_LEN * ETH_GSTRING_LEN);
 194		break;
 195	}
 196}
 197
 198static int fm10k_get_sset_count(struct net_device *dev, int sset)
 199{
 200	struct fm10k_intfc *interface = netdev_priv(dev);
 201	struct fm10k_hw *hw = &interface->hw;
 202	int stats_len = FM10K_STATIC_STATS_LEN;
 203
 204	switch (sset) {
 205	case ETH_SS_TEST:
 206		return FM10K_TEST_LEN;
 207	case ETH_SS_STATS:
 208		stats_len += hw->mac.max_queues * 2 * FM10K_QUEUE_STATS_LEN;
 209
 210		if (hw->mac.type != fm10k_mac_vf)
 211			stats_len += FM10K_PF_STATS_LEN;
 212
 213		return stats_len;
 214	case ETH_SS_PRIV_FLAGS:
 215		return FM10K_PRV_FLAG_LEN;
 216	default:
 217		return -EOPNOTSUPP;
 218	}
 219}
 220
 221static void __fm10k_add_ethtool_stats(u64 **data, void *pointer,
 222				      const struct fm10k_stats stats[],
 223				      const unsigned int size)
 224{
 225	unsigned int i;
 226
 227	if (!pointer) {
 228		/* memory is not zero allocated so we have to clear it */
 229		for (i = 0; i < size; i++)
 230			*((*data)++) = 0;
 231		return;
 232	}
 233
 234	for (i = 0; i < size; i++) {
 235		char *p = (char *)pointer + stats[i].stat_offset;
 236
 237		switch (stats[i].sizeof_stat) {
 238		case sizeof(u64):
 239			*((*data)++) = *(u64 *)p;
 240			break;
 241		case sizeof(u32):
 242			*((*data)++) = *(u32 *)p;
 243			break;
 244		case sizeof(u16):
 245			*((*data)++) = *(u16 *)p;
 246			break;
 247		case sizeof(u8):
 248			*((*data)++) = *(u8 *)p;
 249			break;
 250		default:
 251			WARN_ONCE(1, "unexpected stat size for %s",
 252				  stats[i].stat_string);
 253			*((*data)++) = 0;
 254		}
 255	}
 256}
 257
 258#define fm10k_add_ethtool_stats(data, pointer, stats) \
 259	__fm10k_add_ethtool_stats(data, pointer, stats, ARRAY_SIZE(stats))
 260
 261static void fm10k_get_ethtool_stats(struct net_device *netdev,
 262				    struct ethtool_stats __always_unused *stats,
 263				    u64 *data)
 264{
 265	struct fm10k_intfc *interface = netdev_priv(netdev);
 266	struct net_device_stats *net_stats = &netdev->stats;
 267	int i;
 268
 269	fm10k_update_stats(interface);
 270
 271	fm10k_add_ethtool_stats(&data, net_stats, fm10k_gstrings_net_stats);
 272
 273	fm10k_add_ethtool_stats(&data, interface, fm10k_gstrings_global_stats);
 274
 275	fm10k_add_ethtool_stats(&data, &interface->hw.mbx,
 276				fm10k_gstrings_mbx_stats);
 277
 278	if (interface->hw.mac.type != fm10k_mac_vf) {
 279		fm10k_add_ethtool_stats(&data, interface,
 280					fm10k_gstrings_pf_stats);
 281	}
 282
 283	for (i = 0; i < interface->hw.mac.max_queues; i++) {
 284		struct fm10k_ring *ring;
 285
 286		ring = interface->tx_ring[i];
 287		fm10k_add_ethtool_stats(&data, ring,
 288					fm10k_gstrings_queue_stats);
 289
 290		ring = interface->rx_ring[i];
 291		fm10k_add_ethtool_stats(&data, ring,
 292					fm10k_gstrings_queue_stats);
 293	}
 294}
 295
 296/* If function below adds more registers this define needs to be updated */
 297#define FM10K_REGS_LEN_Q 29
 298
 299static void fm10k_get_reg_q(struct fm10k_hw *hw, u32 *buff, int i)
 300{
 301	int idx = 0;
 302
 303	buff[idx++] = fm10k_read_reg(hw, FM10K_RDBAL(i));
 304	buff[idx++] = fm10k_read_reg(hw, FM10K_RDBAH(i));
 305	buff[idx++] = fm10k_read_reg(hw, FM10K_RDLEN(i));
 306	buff[idx++] = fm10k_read_reg(hw, FM10K_TPH_RXCTRL(i));
 307	buff[idx++] = fm10k_read_reg(hw, FM10K_RDH(i));
 308	buff[idx++] = fm10k_read_reg(hw, FM10K_RDT(i));
 309	buff[idx++] = fm10k_read_reg(hw, FM10K_RXQCTL(i));
 310	buff[idx++] = fm10k_read_reg(hw, FM10K_RXDCTL(i));
 311	buff[idx++] = fm10k_read_reg(hw, FM10K_RXINT(i));
 312	buff[idx++] = fm10k_read_reg(hw, FM10K_SRRCTL(i));
 313	buff[idx++] = fm10k_read_reg(hw, FM10K_QPRC(i));
 314	buff[idx++] = fm10k_read_reg(hw, FM10K_QPRDC(i));
 315	buff[idx++] = fm10k_read_reg(hw, FM10K_QBRC_L(i));
 316	buff[idx++] = fm10k_read_reg(hw, FM10K_QBRC_H(i));
 317	buff[idx++] = fm10k_read_reg(hw, FM10K_TDBAL(i));
 318	buff[idx++] = fm10k_read_reg(hw, FM10K_TDBAH(i));
 319	buff[idx++] = fm10k_read_reg(hw, FM10K_TDLEN(i));
 320	buff[idx++] = fm10k_read_reg(hw, FM10K_TPH_TXCTRL(i));
 321	buff[idx++] = fm10k_read_reg(hw, FM10K_TDH(i));
 322	buff[idx++] = fm10k_read_reg(hw, FM10K_TDT(i));
 323	buff[idx++] = fm10k_read_reg(hw, FM10K_TXDCTL(i));
 324	buff[idx++] = fm10k_read_reg(hw, FM10K_TXQCTL(i));
 325	buff[idx++] = fm10k_read_reg(hw, FM10K_TXINT(i));
 326	buff[idx++] = fm10k_read_reg(hw, FM10K_QPTC(i));
 327	buff[idx++] = fm10k_read_reg(hw, FM10K_QBTC_L(i));
 328	buff[idx++] = fm10k_read_reg(hw, FM10K_QBTC_H(i));
 329	buff[idx++] = fm10k_read_reg(hw, FM10K_TQDLOC(i));
 330	buff[idx++] = fm10k_read_reg(hw, FM10K_TX_SGLORT(i));
 331	buff[idx++] = fm10k_read_reg(hw, FM10K_PFVTCTL(i));
 332
 333	BUG_ON(idx != FM10K_REGS_LEN_Q);
 334}
 335
 336/* If function above adds more registers this define needs to be updated */
 337#define FM10K_REGS_LEN_VSI 43
 338
 339static void fm10k_get_reg_vsi(struct fm10k_hw *hw, u32 *buff, int i)
 340{
 341	int idx = 0, j;
 342
 343	buff[idx++] = fm10k_read_reg(hw, FM10K_MRQC(i));
 344	for (j = 0; j < 10; j++)
 345		buff[idx++] = fm10k_read_reg(hw, FM10K_RSSRK(i, j));
 346	for (j = 0; j < 32; j++)
 347		buff[idx++] = fm10k_read_reg(hw, FM10K_RETA(i, j));
 348
 349	BUG_ON(idx != FM10K_REGS_LEN_VSI);
 350}
 351
 352static void fm10k_get_regs(struct net_device *netdev,
 353			   struct ethtool_regs *regs, void *p)
 354{
 355	struct fm10k_intfc *interface = netdev_priv(netdev);
 356	struct fm10k_hw *hw = &interface->hw;
 357	u32 *buff = p;
 358	u16 i;
 359
 360	regs->version = BIT(24) | (hw->revision_id << 16) | hw->device_id;
 361
 362	switch (hw->mac.type) {
 363	case fm10k_mac_pf:
 364		/* General PF Registers */
 365		*(buff++) = fm10k_read_reg(hw, FM10K_CTRL);
 366		*(buff++) = fm10k_read_reg(hw, FM10K_CTRL_EXT);
 367		*(buff++) = fm10k_read_reg(hw, FM10K_GCR);
 368		*(buff++) = fm10k_read_reg(hw, FM10K_GCR_EXT);
 369
 370		for (i = 0; i < 8; i++) {
 371			*(buff++) = fm10k_read_reg(hw, FM10K_DGLORTMAP(i));
 372			*(buff++) = fm10k_read_reg(hw, FM10K_DGLORTDEC(i));
 373		}
 374
 375		for (i = 0; i < 65; i++) {
 376			fm10k_get_reg_vsi(hw, buff, i);
 377			buff += FM10K_REGS_LEN_VSI;
 378		}
 379
 380		*(buff++) = fm10k_read_reg(hw, FM10K_DMA_CTRL);
 381		*(buff++) = fm10k_read_reg(hw, FM10K_DMA_CTRL2);
 382
 383		for (i = 0; i < FM10K_MAX_QUEUES_PF; i++) {
 384			fm10k_get_reg_q(hw, buff, i);
 385			buff += FM10K_REGS_LEN_Q;
 386		}
 387
 388		*(buff++) = fm10k_read_reg(hw, FM10K_TPH_CTRL);
 389
 390		for (i = 0; i < 8; i++)
 391			*(buff++) = fm10k_read_reg(hw, FM10K_INT_MAP(i));
 392
 393		/* Interrupt Throttling Registers */
 394		for (i = 0; i < 130; i++)
 395			*(buff++) = fm10k_read_reg(hw, FM10K_ITR(i));
 396
 397		break;
 398	case fm10k_mac_vf:
 399		/* General VF registers */
 400		*(buff++) = fm10k_read_reg(hw, FM10K_VFCTRL);
 401		*(buff++) = fm10k_read_reg(hw, FM10K_VFINT_MAP);
 402		*(buff++) = fm10k_read_reg(hw, FM10K_VFSYSTIME);
 403
 404		/* Interrupt Throttling Registers */
 405		for (i = 0; i < 8; i++)
 406			*(buff++) = fm10k_read_reg(hw, FM10K_VFITR(i));
 407
 408		fm10k_get_reg_vsi(hw, buff, 0);
 409		buff += FM10K_REGS_LEN_VSI;
 410
 411		for (i = 0; i < FM10K_MAX_QUEUES_POOL; i++) {
 412			if (i < hw->mac.max_queues)
 413				fm10k_get_reg_q(hw, buff, i);
 414			else
 415				memset(buff, 0, sizeof(u32) * FM10K_REGS_LEN_Q);
 416			buff += FM10K_REGS_LEN_Q;
 417		}
 418
 419		break;
 420	default:
 421		return;
 422	}
 423}
 424
 425/* If function above adds more registers these define need to be updated */
 426#define FM10K_REGS_LEN_PF \
 427(162 + (65 * FM10K_REGS_LEN_VSI) + (FM10K_MAX_QUEUES_PF * FM10K_REGS_LEN_Q))
 428#define FM10K_REGS_LEN_VF \
 429(11 + FM10K_REGS_LEN_VSI + (FM10K_MAX_QUEUES_POOL * FM10K_REGS_LEN_Q))
 430
 431static int fm10k_get_regs_len(struct net_device *netdev)
 432{
 433	struct fm10k_intfc *interface = netdev_priv(netdev);
 434	struct fm10k_hw *hw = &interface->hw;
 435
 436	switch (hw->mac.type) {
 437	case fm10k_mac_pf:
 438		return FM10K_REGS_LEN_PF * sizeof(u32);
 439	case fm10k_mac_vf:
 440		return FM10K_REGS_LEN_VF * sizeof(u32);
 441	default:
 442		return 0;
 443	}
 444}
 445
 446static void fm10k_get_drvinfo(struct net_device *dev,
 447			      struct ethtool_drvinfo *info)
 448{
 449	struct fm10k_intfc *interface = netdev_priv(dev);
 450
 451	strscpy(info->driver, fm10k_driver_name,
 452		sizeof(info->driver));
 453	strscpy(info->bus_info, pci_name(interface->pdev),
 454		sizeof(info->bus_info));
 455}
 456
 457static void fm10k_get_pauseparam(struct net_device *dev,
 458				 struct ethtool_pauseparam *pause)
 459{
 460	struct fm10k_intfc *interface = netdev_priv(dev);
 461
 462	/* record fixed values for autoneg and tx pause */
 463	pause->autoneg = 0;
 464	pause->tx_pause = 1;
 465
 466	pause->rx_pause = interface->rx_pause ? 1 : 0;
 467}
 468
 469static int fm10k_set_pauseparam(struct net_device *dev,
 470				struct ethtool_pauseparam *pause)
 471{
 472	struct fm10k_intfc *interface = netdev_priv(dev);
 473	struct fm10k_hw *hw = &interface->hw;
 474
 475	if (pause->autoneg || !pause->tx_pause)
 476		return -EINVAL;
 477
 478	/* we can only support pause on the PF to avoid head-of-line blocking */
 479	if (hw->mac.type == fm10k_mac_pf)
 480		interface->rx_pause = pause->rx_pause ? ~0 : 0;
 481	else if (pause->rx_pause)
 482		return -EINVAL;
 483
 484	if (netif_running(dev))
 485		fm10k_update_rx_drop_en(interface);
 486
 487	return 0;
 488}
 489
 490static u32 fm10k_get_msglevel(struct net_device *netdev)
 491{
 492	struct fm10k_intfc *interface = netdev_priv(netdev);
 493
 494	return interface->msg_enable;
 495}
 496
 497static void fm10k_set_msglevel(struct net_device *netdev, u32 data)
 498{
 499	struct fm10k_intfc *interface = netdev_priv(netdev);
 500
 501	interface->msg_enable = data;
 502}
 503
 504static void fm10k_get_ringparam(struct net_device *netdev,
 505				struct ethtool_ringparam *ring,
 506				struct kernel_ethtool_ringparam *kernel_ring,
 507				struct netlink_ext_ack *extack)
 508{
 509	struct fm10k_intfc *interface = netdev_priv(netdev);
 510
 511	ring->rx_max_pending = FM10K_MAX_RXD;
 512	ring->tx_max_pending = FM10K_MAX_TXD;
 513	ring->rx_mini_max_pending = 0;
 514	ring->rx_jumbo_max_pending = 0;
 515	ring->rx_pending = interface->rx_ring_count;
 516	ring->tx_pending = interface->tx_ring_count;
 517	ring->rx_mini_pending = 0;
 518	ring->rx_jumbo_pending = 0;
 519}
 520
 521static int fm10k_set_ringparam(struct net_device *netdev,
 522			       struct ethtool_ringparam *ring,
 523			       struct kernel_ethtool_ringparam *kernel_ring,
 524			       struct netlink_ext_ack *extack)
 525{
 526	struct fm10k_intfc *interface = netdev_priv(netdev);
 527	struct fm10k_ring *temp_ring;
 528	int i, err = 0;
 529	u32 new_rx_count, new_tx_count;
 530
 531	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 532		return -EINVAL;
 533
 534	new_tx_count = clamp_t(u32, ring->tx_pending,
 535			       FM10K_MIN_TXD, FM10K_MAX_TXD);
 536	new_tx_count = ALIGN(new_tx_count, FM10K_REQ_TX_DESCRIPTOR_MULTIPLE);
 537
 538	new_rx_count = clamp_t(u32, ring->rx_pending,
 539			       FM10K_MIN_RXD, FM10K_MAX_RXD);
 540	new_rx_count = ALIGN(new_rx_count, FM10K_REQ_RX_DESCRIPTOR_MULTIPLE);
 541
 542	if ((new_tx_count == interface->tx_ring_count) &&
 543	    (new_rx_count == interface->rx_ring_count)) {
 544		/* nothing to do */
 545		return 0;
 546	}
 547
 548	while (test_and_set_bit(__FM10K_RESETTING, interface->state))
 549		usleep_range(1000, 2000);
 550
 551	if (!netif_running(interface->netdev)) {
 552		for (i = 0; i < interface->num_tx_queues; i++)
 553			interface->tx_ring[i]->count = new_tx_count;
 554		for (i = 0; i < interface->num_rx_queues; i++)
 555			interface->rx_ring[i]->count = new_rx_count;
 556		interface->tx_ring_count = new_tx_count;
 557		interface->rx_ring_count = new_rx_count;
 558		goto clear_reset;
 559	}
 560
 561	/* allocate temporary buffer to store rings in */
 562	i = max_t(int, interface->num_tx_queues, interface->num_rx_queues);
 563	temp_ring = vmalloc_array(i, sizeof(struct fm10k_ring));
 564
 565	if (!temp_ring) {
 566		err = -ENOMEM;
 567		goto clear_reset;
 568	}
 569
 570	fm10k_down(interface);
 571
 572	/* Setup new Tx resources and free the old Tx resources in that order.
 573	 * We can then assign the new resources to the rings via a memcpy.
 574	 * The advantage to this approach is that we are guaranteed to still
 575	 * have resources even in the case of an allocation failure.
 576	 */
 577	if (new_tx_count != interface->tx_ring_count) {
 578		for (i = 0; i < interface->num_tx_queues; i++) {
 579			memcpy(&temp_ring[i], interface->tx_ring[i],
 580			       sizeof(struct fm10k_ring));
 581
 582			temp_ring[i].count = new_tx_count;
 583			err = fm10k_setup_tx_resources(&temp_ring[i]);
 584			if (err) {
 585				while (i) {
 586					i--;
 587					fm10k_free_tx_resources(&temp_ring[i]);
 588				}
 589				goto err_setup;
 590			}
 591		}
 592
 593		for (i = 0; i < interface->num_tx_queues; i++) {
 594			fm10k_free_tx_resources(interface->tx_ring[i]);
 595
 596			memcpy(interface->tx_ring[i], &temp_ring[i],
 597			       sizeof(struct fm10k_ring));
 598		}
 599
 600		interface->tx_ring_count = new_tx_count;
 601	}
 602
 603	/* Repeat the process for the Rx rings if needed */
 604	if (new_rx_count != interface->rx_ring_count) {
 605		for (i = 0; i < interface->num_rx_queues; i++) {
 606			memcpy(&temp_ring[i], interface->rx_ring[i],
 607			       sizeof(struct fm10k_ring));
 608
 609			temp_ring[i].count = new_rx_count;
 610			err = fm10k_setup_rx_resources(&temp_ring[i]);
 611			if (err) {
 612				while (i) {
 613					i--;
 614					fm10k_free_rx_resources(&temp_ring[i]);
 615				}
 616				goto err_setup;
 617			}
 618		}
 619
 620		for (i = 0; i < interface->num_rx_queues; i++) {
 621			fm10k_free_rx_resources(interface->rx_ring[i]);
 622
 623			memcpy(interface->rx_ring[i], &temp_ring[i],
 624			       sizeof(struct fm10k_ring));
 625		}
 626
 627		interface->rx_ring_count = new_rx_count;
 628	}
 629
 630err_setup:
 631	fm10k_up(interface);
 632	vfree(temp_ring);
 633clear_reset:
 634	clear_bit(__FM10K_RESETTING, interface->state);
 635	return err;
 636}
 637
 638static int fm10k_get_coalesce(struct net_device *dev,
 639			      struct ethtool_coalesce *ec,
 640			      struct kernel_ethtool_coalesce *kernel_coal,
 641			      struct netlink_ext_ack *extack)
 642{
 643	struct fm10k_intfc *interface = netdev_priv(dev);
 644
 645	ec->use_adaptive_tx_coalesce = ITR_IS_ADAPTIVE(interface->tx_itr);
 646	ec->tx_coalesce_usecs = interface->tx_itr & ~FM10K_ITR_ADAPTIVE;
 647
 648	ec->use_adaptive_rx_coalesce = ITR_IS_ADAPTIVE(interface->rx_itr);
 649	ec->rx_coalesce_usecs = interface->rx_itr & ~FM10K_ITR_ADAPTIVE;
 650
 651	return 0;
 652}
 653
 654static int fm10k_set_coalesce(struct net_device *dev,
 655			      struct ethtool_coalesce *ec,
 656			      struct kernel_ethtool_coalesce *kernel_coal,
 657			      struct netlink_ext_ack *extack)
 658{
 659	struct fm10k_intfc *interface = netdev_priv(dev);
 660	u16 tx_itr, rx_itr;
 661	int i;
 662
 663	/* verify limits */
 664	if ((ec->rx_coalesce_usecs > FM10K_ITR_MAX) ||
 665	    (ec->tx_coalesce_usecs > FM10K_ITR_MAX))
 666		return -EINVAL;
 667
 668	/* record settings */
 669	tx_itr = ec->tx_coalesce_usecs;
 670	rx_itr = ec->rx_coalesce_usecs;
 671
 672	/* set initial values for adaptive ITR */
 673	if (ec->use_adaptive_tx_coalesce)
 674		tx_itr = FM10K_ITR_ADAPTIVE | FM10K_TX_ITR_DEFAULT;
 675
 676	if (ec->use_adaptive_rx_coalesce)
 677		rx_itr = FM10K_ITR_ADAPTIVE | FM10K_RX_ITR_DEFAULT;
 678
 679	/* update interface */
 680	interface->tx_itr = tx_itr;
 681	interface->rx_itr = rx_itr;
 682
 683	/* update q_vectors */
 684	for (i = 0; i < interface->num_q_vectors; i++) {
 685		struct fm10k_q_vector *qv = interface->q_vector[i];
 686
 687		qv->tx.itr = tx_itr;
 688		qv->rx.itr = rx_itr;
 689	}
 690
 691	return 0;
 692}
 693
 694static int fm10k_get_rssh_fields(struct net_device *dev,
 695				 struct ethtool_rxfh_fields *cmd)
 696{
 697	struct fm10k_intfc *interface = netdev_priv(dev);
 698
 699	cmd->data = 0;
 700
 701	/* Report default options for RSS on fm10k */
 702	switch (cmd->flow_type) {
 703	case TCP_V4_FLOW:
 704	case TCP_V6_FLOW:
 705		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 706		fallthrough;
 707	case UDP_V4_FLOW:
 708		if (test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
 709			     interface->flags))
 710			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 711		fallthrough;
 712	case SCTP_V4_FLOW:
 713	case SCTP_V6_FLOW:
 714	case AH_ESP_V4_FLOW:
 715	case AH_ESP_V6_FLOW:
 716	case AH_V4_FLOW:
 717	case AH_V6_FLOW:
 718	case ESP_V4_FLOW:
 719	case ESP_V6_FLOW:
 720	case IPV4_FLOW:
 721	case IPV6_FLOW:
 722		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 723		break;
 724	case UDP_V6_FLOW:
 725		if (test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
 726			     interface->flags))
 727			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 728		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 729		break;
 730	default:
 731		return -EINVAL;
 732	}
 733
 734	return 0;
 735}
 736
 737static u32 fm10k_get_rx_ring_count(struct net_device *dev)
 738{
 739	struct fm10k_intfc *interface = netdev_priv(dev);
 740
 741	return interface->num_rx_queues;
 742}
 743
 744static int fm10k_set_rssh_fields(struct net_device *dev,
 745				 const struct ethtool_rxfh_fields *nfc,
 746				 struct netlink_ext_ack *extack)
 747{
 748	struct fm10k_intfc *interface = netdev_priv(dev);
 749	int rss_ipv4_udp = test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
 750				    interface->flags);
 751	int rss_ipv6_udp = test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
 752				    interface->flags);
 753
 754	/* RSS does not support anything other than hashing
 755	 * to queues on src and dst IPs and ports
 756	 */
 757	if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
 758			  RXH_L4_B_0_1 | RXH_L4_B_2_3))
 759		return -EINVAL;
 760
 761	switch (nfc->flow_type) {
 762	case TCP_V4_FLOW:
 763	case TCP_V6_FLOW:
 764		if (!(nfc->data & RXH_IP_SRC) ||
 765		    !(nfc->data & RXH_IP_DST) ||
 766		    !(nfc->data & RXH_L4_B_0_1) ||
 767		    !(nfc->data & RXH_L4_B_2_3))
 768			return -EINVAL;
 769		break;
 770	case UDP_V4_FLOW:
 771		if (!(nfc->data & RXH_IP_SRC) ||
 772		    !(nfc->data & RXH_IP_DST))
 773			return -EINVAL;
 774		switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 775		case 0:
 776			clear_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
 777				  interface->flags);
 778			break;
 779		case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 780			set_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
 781				interface->flags);
 782			break;
 783		default:
 784			return -EINVAL;
 785		}
 786		break;
 787	case UDP_V6_FLOW:
 788		if (!(nfc->data & RXH_IP_SRC) ||
 789		    !(nfc->data & RXH_IP_DST))
 790			return -EINVAL;
 791		switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 792		case 0:
 793			clear_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
 794				  interface->flags);
 795			break;
 796		case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 797			set_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
 798				interface->flags);
 799			break;
 800		default:
 801			return -EINVAL;
 802		}
 803		break;
 804	case AH_ESP_V4_FLOW:
 805	case AH_V4_FLOW:
 806	case ESP_V4_FLOW:
 807	case SCTP_V4_FLOW:
 808	case AH_ESP_V6_FLOW:
 809	case AH_V6_FLOW:
 810	case ESP_V6_FLOW:
 811	case SCTP_V6_FLOW:
 812		if (!(nfc->data & RXH_IP_SRC) ||
 813		    !(nfc->data & RXH_IP_DST) ||
 814		    (nfc->data & RXH_L4_B_0_1) ||
 815		    (nfc->data & RXH_L4_B_2_3))
 816			return -EINVAL;
 817		break;
 818	default:
 819		return -EINVAL;
 820	}
 821
 822	/* If something changed we need to update the MRQC register. Note that
 823	 * test_bit() is guaranteed to return strictly 0 or 1, so testing for
 824	 * equality is safe.
 825	 */
 826	if ((rss_ipv4_udp != test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
 827				      interface->flags)) ||
 828	    (rss_ipv6_udp != test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
 829				      interface->flags))) {
 830		struct fm10k_hw *hw = &interface->hw;
 831		bool warn = false;
 832		u32 mrqc;
 833
 834		/* Perform hash on these packet types */
 835		mrqc = FM10K_MRQC_IPV4 |
 836		       FM10K_MRQC_TCP_IPV4 |
 837		       FM10K_MRQC_IPV6 |
 838		       FM10K_MRQC_TCP_IPV6;
 839
 840		if (test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
 841			     interface->flags)) {
 842			mrqc |= FM10K_MRQC_UDP_IPV4;
 843			warn = true;
 844		}
 845		if (test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
 846			     interface->flags)) {
 847			mrqc |= FM10K_MRQC_UDP_IPV6;
 848			warn = true;
 849		}
 850
 851		/* If we enable UDP RSS display a warning that this may cause
 852		 * fragmented UDP packets to arrive out of order.
 853		 */
 854		if (warn)
 855			netif_warn(interface, drv, interface->netdev,
 856				   "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
 857
 858		fm10k_write_reg(hw, FM10K_MRQC(0), mrqc);
 859	}
 860
 861	return 0;
 862}
 863
 864static int fm10k_mbx_test(struct fm10k_intfc *interface, u64 *data)
 865{
 866	struct fm10k_hw *hw = &interface->hw;
 867	struct fm10k_mbx_info *mbx = &hw->mbx;
 868	u32 attr_flag, test_msg[6];
 869	unsigned long timeout;
 870	int err = -EINVAL;
 871
 872	/* For now this is a VF only feature */
 873	if (hw->mac.type != fm10k_mac_vf)
 874		return 0;
 875
 876	/* loop through both nested and unnested attribute types */
 877	for (attr_flag = BIT(FM10K_TEST_MSG_UNSET);
 878	     attr_flag < BIT(2 * FM10K_TEST_MSG_NESTED);
 879	     attr_flag += attr_flag) {
 880		/* generate message to be tested */
 881		fm10k_tlv_msg_test_create(test_msg, attr_flag);
 882
 883		fm10k_mbx_lock(interface);
 884		mbx->test_result = FM10K_NOT_IMPLEMENTED;
 885		err = mbx->ops.enqueue_tx(hw, mbx, test_msg);
 886		fm10k_mbx_unlock(interface);
 887
 888		/* wait up to 1 second for response */
 889		timeout = jiffies + HZ;
 890		do {
 891			if (err < 0)
 892				goto err_out;
 893
 894			usleep_range(500, 1000);
 895
 896			fm10k_mbx_lock(interface);
 897			mbx->ops.process(hw, mbx);
 898			fm10k_mbx_unlock(interface);
 899
 900			err = mbx->test_result;
 901			if (!err)
 902				break;
 903		} while (time_is_after_jiffies(timeout));
 904
 905		/* reporting errors */
 906		if (err)
 907			goto err_out;
 908	}
 909
 910err_out:
 911	*data = err < 0 ? (attr_flag) : (err > 0);
 912	return err;
 913}
 914
 915static void fm10k_self_test(struct net_device *dev,
 916			    struct ethtool_test *eth_test, u64 *data)
 917{
 918	struct fm10k_intfc *interface = netdev_priv(dev);
 919	struct fm10k_hw *hw = &interface->hw;
 920
 921	memset(data, 0, sizeof(*data) * FM10K_TEST_LEN);
 922
 923	if (FM10K_REMOVED(hw->hw_addr)) {
 924		netif_err(interface, drv, dev,
 925			  "Interface removed - test blocked\n");
 926		eth_test->flags |= ETH_TEST_FL_FAILED;
 927		return;
 928	}
 929
 930	if (fm10k_mbx_test(interface, &data[FM10K_TEST_MBX]))
 931		eth_test->flags |= ETH_TEST_FL_FAILED;
 932}
 933
 934static u32 fm10k_get_priv_flags(struct net_device *netdev)
 935{
 936	return 0;
 937}
 938
 939static int fm10k_set_priv_flags(struct net_device *netdev, u32 priv_flags)
 940{
 941	if (priv_flags >= BIT(FM10K_PRV_FLAG_LEN))
 942		return -EINVAL;
 943
 944	return 0;
 945}
 946
 947static u32 fm10k_get_reta_size(struct net_device __always_unused *netdev)
 948{
 949	return FM10K_RETA_SIZE * FM10K_RETA_ENTRIES_PER_REG;
 950}
 951
 952void fm10k_write_reta(struct fm10k_intfc *interface, const u32 *indir)
 953{
 954	u16 rss_i = interface->ring_feature[RING_F_RSS].indices;
 955	struct fm10k_hw *hw = &interface->hw;
 956	u32 table[4];
 957	int i, j;
 958
 959	/* record entries to reta table */
 960	for (i = 0; i < FM10K_RETA_SIZE; i++) {
 961		u32 reta, n;
 962
 963		/* generate a new table if we weren't given one */
 964		for (j = 0; j < 4; j++) {
 965			if (indir)
 966				n = indir[4 * i + j];
 967			else
 968				n = ethtool_rxfh_indir_default(4 * i + j,
 969							       rss_i);
 970
 971			table[j] = n;
 972		}
 973
 974		reta = table[0] |
 975			(table[1] << 8) |
 976			(table[2] << 16) |
 977			(table[3] << 24);
 978
 979		if (interface->reta[i] == reta)
 980			continue;
 981
 982		interface->reta[i] = reta;
 983		fm10k_write_reg(hw, FM10K_RETA(0, i), reta);
 984	}
 985}
 986
 987static int fm10k_get_reta(struct net_device *netdev, u32 *indir)
 988{
 989	struct fm10k_intfc *interface = netdev_priv(netdev);
 990	int i;
 991
 992	if (!indir)
 993		return 0;
 994
 995	for (i = 0; i < FM10K_RETA_SIZE; i++, indir += 4) {
 996		u32 reta = interface->reta[i];
 997
 998		indir[0] = (reta << 24) >> 24;
 999		indir[1] = (reta << 16) >> 24;
1000		indir[2] = (reta <<  8) >> 24;
1001		indir[3] = (reta) >> 24;
1002	}
1003
1004	return 0;
1005}
1006
1007static int fm10k_set_reta(struct net_device *netdev, const u32 *indir)
1008{
1009	struct fm10k_intfc *interface = netdev_priv(netdev);
1010	int i;
1011	u16 rss_i;
1012
1013	if (!indir)
1014		return 0;
1015
1016	/* Verify user input. */
1017	rss_i = interface->ring_feature[RING_F_RSS].indices;
1018	for (i = fm10k_get_reta_size(netdev); i--;) {
1019		if (indir[i] < rss_i)
1020			continue;
1021		return -EINVAL;
1022	}
1023
1024	fm10k_write_reta(interface, indir);
1025
1026	return 0;
1027}
1028
1029static u32 fm10k_get_rssrk_size(struct net_device __always_unused *netdev)
1030{
1031	return FM10K_RSSRK_SIZE * FM10K_RSSRK_ENTRIES_PER_REG;
1032}
1033
1034static int fm10k_get_rssh(struct net_device *netdev,
1035			  struct ethtool_rxfh_param *rxfh)
1036{
1037	struct fm10k_intfc *interface = netdev_priv(netdev);
1038	u8 *key = rxfh->key;
1039	int i, err;
1040
1041	rxfh->hfunc = ETH_RSS_HASH_TOP;
1042
1043	err = fm10k_get_reta(netdev, rxfh->indir);
1044	if (err || !key)
1045		return err;
1046
1047	for (i = 0; i < FM10K_RSSRK_SIZE; i++, key += 4)
1048		*(__le32 *)key = cpu_to_le32(interface->rssrk[i]);
1049
1050	return 0;
1051}
1052
1053static int fm10k_set_rssh(struct net_device *netdev,
1054			  struct ethtool_rxfh_param *rxfh,
1055			  struct netlink_ext_ack *extack)
1056{
1057	struct fm10k_intfc *interface = netdev_priv(netdev);
1058	struct fm10k_hw *hw = &interface->hw;
1059	int i, err;
1060
1061	/* We do not allow change in unsupported parameters */
1062	if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
1063	    rxfh->hfunc != ETH_RSS_HASH_TOP)
1064		return -EOPNOTSUPP;
1065
1066	err = fm10k_set_reta(netdev, rxfh->indir);
1067	if (err || !rxfh->key)
1068		return err;
1069
1070	for (i = 0; i < FM10K_RSSRK_SIZE; i++, rxfh->key += 4) {
1071		u32 rssrk = le32_to_cpu(*(__le32 *)rxfh->key);
1072
1073		if (interface->rssrk[i] == rssrk)
1074			continue;
1075
1076		interface->rssrk[i] = rssrk;
1077		fm10k_write_reg(hw, FM10K_RSSRK(0, i), rssrk);
1078	}
1079
1080	return 0;
1081}
1082
1083static unsigned int fm10k_max_channels(struct net_device *dev)
1084{
1085	struct fm10k_intfc *interface = netdev_priv(dev);
1086	unsigned int max_combined = interface->hw.mac.max_queues;
1087	u8 tcs = netdev_get_num_tc(dev);
1088
1089	/* For QoS report channels per traffic class */
1090	if (tcs > 1)
1091		max_combined = BIT((fls(max_combined / tcs) - 1));
1092
1093	return max_combined;
1094}
1095
1096static void fm10k_get_channels(struct net_device *dev,
1097			       struct ethtool_channels *ch)
1098{
1099	struct fm10k_intfc *interface = netdev_priv(dev);
1100
1101	/* report maximum channels */
1102	ch->max_combined = fm10k_max_channels(dev);
1103
1104	/* report info for other vector */
1105	ch->max_other = NON_Q_VECTORS;
1106	ch->other_count = ch->max_other;
1107
1108	/* record RSS queues */
1109	ch->combined_count = interface->ring_feature[RING_F_RSS].indices;
1110}
1111
1112static int fm10k_set_channels(struct net_device *dev,
1113			      struct ethtool_channels *ch)
1114{
1115	struct fm10k_intfc *interface = netdev_priv(dev);
1116	unsigned int count = ch->combined_count;
1117
1118	/* verify they are not requesting separate vectors */
1119	if (!count || ch->rx_count || ch->tx_count)
1120		return -EINVAL;
1121
1122	/* verify other_count has not changed */
1123	if (ch->other_count != NON_Q_VECTORS)
1124		return -EINVAL;
1125
1126	/* verify the number of channels does not exceed hardware limits */
1127	if (count > fm10k_max_channels(dev))
1128		return -EINVAL;
1129
1130	interface->ring_feature[RING_F_RSS].limit = count;
1131
1132	/* use setup TC to update any traffic class queue mapping */
1133	return fm10k_setup_tc(dev, netdev_get_num_tc(dev));
1134}
1135
1136static const struct ethtool_ops fm10k_ethtool_ops = {
1137	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1138				     ETHTOOL_COALESCE_USE_ADAPTIVE,
1139	.get_strings		= fm10k_get_strings,
1140	.get_sset_count		= fm10k_get_sset_count,
1141	.get_ethtool_stats      = fm10k_get_ethtool_stats,
1142	.get_drvinfo		= fm10k_get_drvinfo,
1143	.get_link		= ethtool_op_get_link,
1144	.get_pauseparam		= fm10k_get_pauseparam,
1145	.set_pauseparam		= fm10k_set_pauseparam,
1146	.get_msglevel		= fm10k_get_msglevel,
1147	.set_msglevel		= fm10k_set_msglevel,
1148	.get_ringparam		= fm10k_get_ringparam,
1149	.set_ringparam		= fm10k_set_ringparam,
1150	.get_coalesce		= fm10k_get_coalesce,
1151	.set_coalesce		= fm10k_set_coalesce,
1152	.get_rx_ring_count	= fm10k_get_rx_ring_count,
1153	.get_regs               = fm10k_get_regs,
1154	.get_regs_len           = fm10k_get_regs_len,
1155	.self_test		= fm10k_self_test,
1156	.get_priv_flags		= fm10k_get_priv_flags,
1157	.set_priv_flags		= fm10k_set_priv_flags,
1158	.get_rxfh_indir_size	= fm10k_get_reta_size,
1159	.get_rxfh_key_size	= fm10k_get_rssrk_size,
1160	.get_rxfh		= fm10k_get_rssh,
1161	.set_rxfh		= fm10k_set_rssh,
1162	.get_rxfh_fields	= fm10k_get_rssh_fields,
1163	.set_rxfh_fields	= fm10k_set_rssh_fields,
1164	.get_channels		= fm10k_get_channels,
1165	.set_channels		= fm10k_set_channels,
1166	.get_ts_info		= ethtool_op_get_ts_info,
1167};
1168
1169void fm10k_set_ethtool_ops(struct net_device *dev)
1170{
1171	dev->ethtool_ops = &fm10k_ethtool_ops;
1172}