igc_ethtool.c

   1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright (c)  2018 Intel Corporation */
   3
   4/* ethtool support for igc */
   5#include <linux/if_vlan.h>
   6#include <linux/pm_runtime.h>
   7#include <linux/mdio.h>
   8
   9#include "igc.h"
  10#include "igc_diag.h"
  11#include "igc_tsn.h"
  12
  13/* forward declaration */
  14struct igc_stats {
  15	char stat_string[ETH_GSTRING_LEN];
  16	int sizeof_stat;
  17	int stat_offset;
  18};
  19
  20#define IGC_STAT(_name, _stat) { \
  21	.stat_string = _name, \
  22	.sizeof_stat = sizeof_field(struct igc_adapter, _stat), \
  23	.stat_offset = offsetof(struct igc_adapter, _stat) \
  24}
  25
  26static const struct igc_stats igc_gstrings_stats[] = {
  27	IGC_STAT("rx_packets", stats.gprc),
  28	IGC_STAT("tx_packets", stats.gptc),
  29	IGC_STAT("rx_bytes", stats.gorc),
  30	IGC_STAT("tx_bytes", stats.gotc),
  31	IGC_STAT("rx_broadcast", stats.bprc),
  32	IGC_STAT("tx_broadcast", stats.bptc),
  33	IGC_STAT("rx_multicast", stats.mprc),
  34	IGC_STAT("tx_multicast", stats.mptc),
  35	IGC_STAT("multicast", stats.mprc),
  36	IGC_STAT("collisions", stats.colc),
  37	IGC_STAT("rx_crc_errors", stats.crcerrs),
  38	IGC_STAT("rx_no_buffer_count", stats.rnbc),
  39	IGC_STAT("rx_missed_errors", stats.mpc),
  40	IGC_STAT("tx_aborted_errors", stats.ecol),
  41	IGC_STAT("tx_carrier_errors", stats.tncrs),
  42	IGC_STAT("tx_window_errors", stats.latecol),
  43	IGC_STAT("tx_abort_late_coll", stats.latecol),
  44	IGC_STAT("tx_deferred_ok", stats.dc),
  45	IGC_STAT("tx_single_coll_ok", stats.scc),
  46	IGC_STAT("tx_multi_coll_ok", stats.mcc),
  47	IGC_STAT("tx_timeout_count", tx_timeout_count),
  48	IGC_STAT("rx_long_length_errors", stats.roc),
  49	IGC_STAT("rx_short_length_errors", stats.ruc),
  50	IGC_STAT("rx_align_errors", stats.algnerrc),
  51	IGC_STAT("tx_tcp_seg_good", stats.tsctc),
  52	IGC_STAT("tx_tcp_seg_failed", stats.tsctfc),
  53	IGC_STAT("rx_flow_control_xon", stats.xonrxc),
  54	IGC_STAT("rx_flow_control_xoff", stats.xoffrxc),
  55	IGC_STAT("tx_flow_control_xon", stats.xontxc),
  56	IGC_STAT("tx_flow_control_xoff", stats.xofftxc),
  57	IGC_STAT("rx_long_byte_count", stats.gorc),
  58	IGC_STAT("tx_dma_out_of_sync", stats.doosync),
  59	IGC_STAT("tx_smbus", stats.mgptc),
  60	IGC_STAT("rx_smbus", stats.mgprc),
  61	IGC_STAT("dropped_smbus", stats.mgpdc),
  62	IGC_STAT("os2bmc_rx_by_bmc", stats.o2bgptc),
  63	IGC_STAT("os2bmc_tx_by_bmc", stats.b2ospc),
  64	IGC_STAT("os2bmc_tx_by_host", stats.o2bspc),
  65	IGC_STAT("os2bmc_rx_by_host", stats.b2ogprc),
  66	IGC_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
  67	IGC_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),
  68	IGC_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
  69	IGC_STAT("tx_lpi_counter", stats.tlpic),
  70	IGC_STAT("rx_lpi_counter", stats.rlpic),
  71	IGC_STAT("qbv_config_change_errors", qbv_config_change_errors),
  72};
  73
  74#define IGC_NETDEV_STAT(_net_stat) { \
  75	.stat_string = __stringify(_net_stat), \
  76	.sizeof_stat = sizeof_field(struct rtnl_link_stats64, _net_stat), \
  77	.stat_offset = offsetof(struct rtnl_link_stats64, _net_stat) \
  78}
  79
  80static const struct igc_stats igc_gstrings_net_stats[] = {
  81	IGC_NETDEV_STAT(rx_errors),
  82	IGC_NETDEV_STAT(tx_errors),
  83	IGC_NETDEV_STAT(tx_dropped),
  84	IGC_NETDEV_STAT(rx_length_errors),
  85	IGC_NETDEV_STAT(rx_over_errors),
  86	IGC_NETDEV_STAT(rx_frame_errors),
  87	IGC_NETDEV_STAT(rx_fifo_errors),
  88	IGC_NETDEV_STAT(tx_fifo_errors),
  89	IGC_NETDEV_STAT(tx_heartbeat_errors)
  90};
  91
  92enum igc_diagnostics_results {
  93	TEST_REG = 0,
  94	TEST_EEP,
  95	TEST_IRQ,
  96	TEST_LOOP,
  97	TEST_LINK
  98};
  99
 100static const char igc_gstrings_test[][ETH_GSTRING_LEN] = {
 101	[TEST_REG]  = "Register test  (offline)",
 102	[TEST_EEP]  = "Eeprom test    (offline)",
 103	[TEST_IRQ]  = "Interrupt test (offline)",
 104	[TEST_LOOP] = "Loopback test  (offline)",
 105	[TEST_LINK] = "Link test   (on/offline)"
 106};
 107
 108#define IGC_TEST_LEN (sizeof(igc_gstrings_test) / ETH_GSTRING_LEN)
 109
 110#define IGC_GLOBAL_STATS_LEN	\
 111	(sizeof(igc_gstrings_stats) / sizeof(struct igc_stats))
 112#define IGC_NETDEV_STATS_LEN	\
 113	(sizeof(igc_gstrings_net_stats) / sizeof(struct igc_stats))
 114#define IGC_RX_QUEUE_STATS_LEN \
 115	(sizeof(struct igc_rx_queue_stats) / sizeof(u64))
 116#define IGC_TX_QUEUE_STATS_LEN 3 /* packets, bytes, restart_queue */
 117#define IGC_QUEUE_STATS_LEN \
 118	((((struct igc_adapter *)netdev_priv(netdev))->num_rx_queues * \
 119	  IGC_RX_QUEUE_STATS_LEN) + \
 120	 (((struct igc_adapter *)netdev_priv(netdev))->num_tx_queues * \
 121	  IGC_TX_QUEUE_STATS_LEN))
 122#define IGC_STATS_LEN \
 123	(IGC_GLOBAL_STATS_LEN + IGC_NETDEV_STATS_LEN + IGC_QUEUE_STATS_LEN)
 124
 125#define IGC_PRIV_FLAGS_LEGACY_RX		BIT(0)
 126#define IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO	BIT(1)
 127static const char igc_priv_flags_strings[][ETH_GSTRING_LEN] = {
 128	"legacy-rx",
 129	"reverse-tsn-txq-prio",
 130};
 131
 132#define IGC_PRIV_FLAGS_STR_LEN ARRAY_SIZE(igc_priv_flags_strings)
 133
 134static void igc_ethtool_get_drvinfo(struct net_device *netdev,
 135				    struct ethtool_drvinfo *drvinfo)
 136{
 137	struct igc_adapter *adapter = netdev_priv(netdev);
 138	struct igc_hw *hw = &adapter->hw;
 139	u16 nvm_version = 0;
 140	u16 gphy_version;
 141
 142	strscpy(drvinfo->driver, igc_driver_name, sizeof(drvinfo->driver));
 143
 144	/* NVM image version is reported as firmware version for i225 device */
 145	hw->nvm.ops.read(hw, IGC_NVM_DEV_STARTER, 1, &nvm_version);
 146
 147	/* gPHY firmware version is reported as PHY FW version */
 148	gphy_version = igc_read_phy_fw_version(hw);
 149
 150	scnprintf(adapter->fw_version,
 151		  sizeof(adapter->fw_version),
 152		  "%x:%x",
 153		  nvm_version,
 154		  gphy_version);
 155
 156	strscpy(drvinfo->fw_version, adapter->fw_version,
 157		sizeof(drvinfo->fw_version));
 158
 159	strscpy(drvinfo->bus_info, pci_name(adapter->pdev),
 160		sizeof(drvinfo->bus_info));
 161
 162	drvinfo->n_priv_flags = IGC_PRIV_FLAGS_STR_LEN;
 163}
 164
 165static int igc_ethtool_get_regs_len(struct net_device *netdev)
 166{
 167	return IGC_REGS_LEN * sizeof(u32);
 168}
 169
 170static void igc_ethtool_get_regs(struct net_device *netdev,
 171				 struct ethtool_regs *regs, void *p)
 172{
 173	struct igc_adapter *adapter = netdev_priv(netdev);
 174	struct igc_hw *hw = &adapter->hw;
 175	u32 *regs_buff = p;
 176	u8 i;
 177
 178	memset(p, 0, IGC_REGS_LEN * sizeof(u32));
 179
 180	regs->version = (2u << 24) | (hw->revision_id << 16) | hw->device_id;
 181
 182	/* General Registers */
 183	regs_buff[0] = rd32(IGC_CTRL);
 184	regs_buff[1] = rd32(IGC_STATUS);
 185	regs_buff[2] = rd32(IGC_CTRL_EXT);
 186	regs_buff[3] = rd32(IGC_MDIC);
 187	regs_buff[4] = rd32(IGC_CONNSW);
 188
 189	/* NVM Register */
 190	regs_buff[5] = rd32(IGC_EECD);
 191
 192	/* Interrupt */
 193	/* Reading EICS for EICR because they read the
 194	 * same but EICS does not clear on read
 195	 */
 196	regs_buff[6] = rd32(IGC_EICS);
 197	regs_buff[7] = rd32(IGC_EICS);
 198	regs_buff[8] = rd32(IGC_EIMS);
 199	regs_buff[9] = rd32(IGC_EIMC);
 200	regs_buff[10] = rd32(IGC_EIAC);
 201	regs_buff[11] = rd32(IGC_EIAM);
 202	/* Reading ICS for ICR because they read the
 203	 * same but ICS does not clear on read
 204	 */
 205	regs_buff[12] = rd32(IGC_ICS);
 206	regs_buff[13] = rd32(IGC_ICS);
 207	regs_buff[14] = rd32(IGC_IMS);
 208	regs_buff[15] = rd32(IGC_IMC);
 209	regs_buff[16] = rd32(IGC_IAC);
 210	regs_buff[17] = rd32(IGC_IAM);
 211
 212	/* Flow Control */
 213	regs_buff[18] = rd32(IGC_FCAL);
 214	regs_buff[19] = rd32(IGC_FCAH);
 215	regs_buff[20] = rd32(IGC_FCTTV);
 216	regs_buff[21] = rd32(IGC_FCRTL);
 217	regs_buff[22] = rd32(IGC_FCRTH);
 218	regs_buff[23] = rd32(IGC_FCRTV);
 219
 220	/* Receive */
 221	regs_buff[24] = rd32(IGC_RCTL);
 222	regs_buff[25] = rd32(IGC_RXCSUM);
 223	regs_buff[26] = rd32(IGC_RLPML);
 224	regs_buff[27] = rd32(IGC_RFCTL);
 225
 226	/* Transmit */
 227	regs_buff[28] = rd32(IGC_TCTL);
 228	regs_buff[29] = rd32(IGC_TIPG);
 229
 230	/* Wake Up */
 231
 232	/* MAC */
 233
 234	/* Statistics */
 235	regs_buff[30] = adapter->stats.crcerrs;
 236	regs_buff[31] = adapter->stats.algnerrc;
 237	regs_buff[32] = adapter->stats.symerrs;
 238	regs_buff[33] = adapter->stats.rxerrc;
 239	regs_buff[34] = adapter->stats.mpc;
 240	regs_buff[35] = adapter->stats.scc;
 241	regs_buff[36] = adapter->stats.ecol;
 242	regs_buff[37] = adapter->stats.mcc;
 243	regs_buff[38] = adapter->stats.latecol;
 244	regs_buff[39] = adapter->stats.colc;
 245	regs_buff[40] = adapter->stats.dc;
 246	regs_buff[41] = adapter->stats.tncrs;
 247	regs_buff[42] = adapter->stats.sec;
 248	regs_buff[43] = adapter->stats.htdpmc;
 249	regs_buff[44] = adapter->stats.rlec;
 250	regs_buff[45] = adapter->stats.xonrxc;
 251	regs_buff[46] = adapter->stats.xontxc;
 252	regs_buff[47] = adapter->stats.xoffrxc;
 253	regs_buff[48] = adapter->stats.xofftxc;
 254	regs_buff[49] = adapter->stats.fcruc;
 255	regs_buff[50] = adapter->stats.prc64;
 256	regs_buff[51] = adapter->stats.prc127;
 257	regs_buff[52] = adapter->stats.prc255;
 258	regs_buff[53] = adapter->stats.prc511;
 259	regs_buff[54] = adapter->stats.prc1023;
 260	regs_buff[55] = adapter->stats.prc1522;
 261	regs_buff[56] = adapter->stats.gprc;
 262	regs_buff[57] = adapter->stats.bprc;
 263	regs_buff[58] = adapter->stats.mprc;
 264	regs_buff[59] = adapter->stats.gptc;
 265	regs_buff[60] = adapter->stats.gorc;
 266	regs_buff[61] = adapter->stats.gotc;
 267	regs_buff[62] = adapter->stats.rnbc;
 268	regs_buff[63] = adapter->stats.ruc;
 269	regs_buff[64] = adapter->stats.rfc;
 270	regs_buff[65] = adapter->stats.roc;
 271	regs_buff[66] = adapter->stats.rjc;
 272	regs_buff[67] = adapter->stats.mgprc;
 273	regs_buff[68] = adapter->stats.mgpdc;
 274	regs_buff[69] = adapter->stats.mgptc;
 275	regs_buff[70] = adapter->stats.tor;
 276	regs_buff[71] = adapter->stats.tot;
 277	regs_buff[72] = adapter->stats.tpr;
 278	regs_buff[73] = adapter->stats.tpt;
 279	regs_buff[74] = adapter->stats.ptc64;
 280	regs_buff[75] = adapter->stats.ptc127;
 281	regs_buff[76] = adapter->stats.ptc255;
 282	regs_buff[77] = adapter->stats.ptc511;
 283	regs_buff[78] = adapter->stats.ptc1023;
 284	regs_buff[79] = adapter->stats.ptc1522;
 285	regs_buff[80] = adapter->stats.mptc;
 286	regs_buff[81] = adapter->stats.bptc;
 287	regs_buff[82] = adapter->stats.tsctc;
 288	regs_buff[83] = adapter->stats.iac;
 289	regs_buff[84] = adapter->stats.rpthc;
 290	regs_buff[85] = adapter->stats.hgptc;
 291	regs_buff[86] = adapter->stats.hgorc;
 292	regs_buff[87] = adapter->stats.hgotc;
 293	regs_buff[88] = adapter->stats.lenerrs;
 294	regs_buff[89] = adapter->stats.scvpc;
 295	regs_buff[90] = adapter->stats.hrmpc;
 296
 297	for (i = 0; i < 4; i++)
 298		regs_buff[91 + i] = rd32(IGC_SRRCTL(i));
 299	for (i = 0; i < 4; i++)
 300		regs_buff[95 + i] = rd32(IGC_PSRTYPE(i));
 301	for (i = 0; i < 4; i++)
 302		regs_buff[99 + i] = rd32(IGC_RDBAL(i));
 303	for (i = 0; i < 4; i++)
 304		regs_buff[103 + i] = rd32(IGC_RDBAH(i));
 305	for (i = 0; i < 4; i++)
 306		regs_buff[107 + i] = rd32(IGC_RDLEN(i));
 307	for (i = 0; i < 4; i++)
 308		regs_buff[111 + i] = rd32(IGC_RDH(i));
 309	for (i = 0; i < 4; i++)
 310		regs_buff[115 + i] = rd32(IGC_RDT(i));
 311	for (i = 0; i < 4; i++)
 312		regs_buff[119 + i] = rd32(IGC_RXDCTL(i));
 313
 314	for (i = 0; i < 10; i++)
 315		regs_buff[123 + i] = rd32(IGC_EITR(i));
 316	for (i = 0; i < 16; i++)
 317		regs_buff[139 + i] = rd32(IGC_RAL(i));
 318	for (i = 0; i < 16; i++)
 319		regs_buff[145 + i] = rd32(IGC_RAH(i));
 320
 321	for (i = 0; i < 4; i++)
 322		regs_buff[149 + i] = rd32(IGC_TDBAL(i));
 323	for (i = 0; i < 4; i++)
 324		regs_buff[152 + i] = rd32(IGC_TDBAH(i));
 325	for (i = 0; i < 4; i++)
 326		regs_buff[156 + i] = rd32(IGC_TDLEN(i));
 327	for (i = 0; i < 4; i++)
 328		regs_buff[160 + i] = rd32(IGC_TDH(i));
 329	for (i = 0; i < 4; i++)
 330		regs_buff[164 + i] = rd32(IGC_TDT(i));
 331	for (i = 0; i < 4; i++)
 332		regs_buff[168 + i] = rd32(IGC_TXDCTL(i));
 333
 334	/* XXX: Due to a bug few lines above, RAL and RAH registers are
 335	 * overwritten. To preserve the ABI, we write these registers again in
 336	 * regs_buff.
 337	 */
 338	for (i = 0; i < 16; i++)
 339		regs_buff[172 + i] = rd32(IGC_RAL(i));
 340	for (i = 0; i < 16; i++)
 341		regs_buff[188 + i] = rd32(IGC_RAH(i));
 342
 343	regs_buff[204] = rd32(IGC_VLANPQF);
 344
 345	for (i = 0; i < 8; i++)
 346		regs_buff[205 + i] = rd32(IGC_ETQF(i));
 347
 348	regs_buff[213] = adapter->stats.tlpic;
 349	regs_buff[214] = adapter->stats.rlpic;
 350}
 351
 352static void igc_ethtool_get_wol(struct net_device *netdev,
 353				struct ethtool_wolinfo *wol)
 354{
 355	struct igc_adapter *adapter = netdev_priv(netdev);
 356
 357	wol->wolopts = 0;
 358
 359	if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED))
 360		return;
 361
 362	wol->supported = WAKE_UCAST | WAKE_MCAST |
 363			 WAKE_BCAST | WAKE_MAGIC |
 364			 WAKE_PHY;
 365
 366	/* apply any specific unsupported masks here */
 367	switch (adapter->hw.device_id) {
 368	default:
 369		break;
 370	}
 371
 372	if (adapter->wol & IGC_WUFC_EX)
 373		wol->wolopts |= WAKE_UCAST;
 374	if (adapter->wol & IGC_WUFC_MC)
 375		wol->wolopts |= WAKE_MCAST;
 376	if (adapter->wol & IGC_WUFC_BC)
 377		wol->wolopts |= WAKE_BCAST;
 378	if (adapter->wol & IGC_WUFC_MAG)
 379		wol->wolopts |= WAKE_MAGIC;
 380	if (adapter->wol & IGC_WUFC_LNKC)
 381		wol->wolopts |= WAKE_PHY;
 382}
 383
 384static int igc_ethtool_set_wol(struct net_device *netdev,
 385			       struct ethtool_wolinfo *wol)
 386{
 387	struct igc_adapter *adapter = netdev_priv(netdev);
 388
 389	if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE | WAKE_FILTER))
 390		return -EOPNOTSUPP;
 391
 392	if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED))
 393		return wol->wolopts ? -EOPNOTSUPP : 0;
 394
 395	/* these settings will always override what we currently have */
 396	adapter->wol = 0;
 397
 398	if (wol->wolopts & WAKE_UCAST)
 399		adapter->wol |= IGC_WUFC_EX;
 400	if (wol->wolopts & WAKE_MCAST)
 401		adapter->wol |= IGC_WUFC_MC;
 402	if (wol->wolopts & WAKE_BCAST)
 403		adapter->wol |= IGC_WUFC_BC;
 404	if (wol->wolopts & WAKE_MAGIC)
 405		adapter->wol |= IGC_WUFC_MAG;
 406	if (wol->wolopts & WAKE_PHY)
 407		adapter->wol |= IGC_WUFC_LNKC;
 408	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 409
 410	return 0;
 411}
 412
 413static u32 igc_ethtool_get_msglevel(struct net_device *netdev)
 414{
 415	struct igc_adapter *adapter = netdev_priv(netdev);
 416
 417	return adapter->msg_enable;
 418}
 419
 420static void igc_ethtool_set_msglevel(struct net_device *netdev, u32 data)
 421{
 422	struct igc_adapter *adapter = netdev_priv(netdev);
 423
 424	adapter->msg_enable = data;
 425}
 426
 427static int igc_ethtool_nway_reset(struct net_device *netdev)
 428{
 429	struct igc_adapter *adapter = netdev_priv(netdev);
 430
 431	if (netif_running(netdev))
 432		igc_reinit_locked(adapter);
 433	return 0;
 434}
 435
 436static u32 igc_ethtool_get_link(struct net_device *netdev)
 437{
 438	struct igc_adapter *adapter = netdev_priv(netdev);
 439	struct igc_mac_info *mac = &adapter->hw.mac;
 440
 441	/* If the link is not reported up to netdev, interrupts are disabled,
 442	 * and so the physical link state may have changed since we last
 443	 * looked. Set get_link_status to make sure that the true link
 444	 * state is interrogated, rather than pulling a cached and possibly
 445	 * stale link state from the driver.
 446	 */
 447	if (!netif_carrier_ok(netdev))
 448		mac->get_link_status = 1;
 449
 450	return igc_has_link(adapter);
 451}
 452
 453static int igc_ethtool_get_eeprom_len(struct net_device *netdev)
 454{
 455	struct igc_adapter *adapter = netdev_priv(netdev);
 456
 457	return adapter->hw.nvm.word_size * 2;
 458}
 459
 460static int igc_ethtool_get_eeprom(struct net_device *netdev,
 461				  struct ethtool_eeprom *eeprom, u8 *bytes)
 462{
 463	struct igc_adapter *adapter = netdev_priv(netdev);
 464	struct igc_hw *hw = &adapter->hw;
 465	int first_word, last_word;
 466	u16 *eeprom_buff;
 467	int ret_val = 0;
 468	u16 i;
 469
 470	if (eeprom->len == 0)
 471		return -EINVAL;
 472
 473	eeprom->magic = hw->vendor_id | (hw->device_id << 16);
 474
 475	first_word = eeprom->offset >> 1;
 476	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 477
 478	eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
 479				    GFP_KERNEL);
 480	if (!eeprom_buff)
 481		return -ENOMEM;
 482
 483	if (hw->nvm.type == igc_nvm_eeprom_spi) {
 484		ret_val = hw->nvm.ops.read(hw, first_word,
 485					   last_word - first_word + 1,
 486					   eeprom_buff);
 487	} else {
 488		for (i = 0; i < last_word - first_word + 1; i++) {
 489			ret_val = hw->nvm.ops.read(hw, first_word + i, 1,
 490						   &eeprom_buff[i]);
 491			if (ret_val)
 492				break;
 493		}
 494	}
 495
 496	/* Device's eeprom is always little-endian, word addressable */
 497	for (i = 0; i < last_word - first_word + 1; i++)
 498		le16_to_cpus(&eeprom_buff[i]);
 499
 500	memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
 501	       eeprom->len);
 502	kfree(eeprom_buff);
 503
 504	return ret_val;
 505}
 506
 507static int igc_ethtool_set_eeprom(struct net_device *netdev,
 508				  struct ethtool_eeprom *eeprom, u8 *bytes)
 509{
 510	struct igc_adapter *adapter = netdev_priv(netdev);
 511	struct igc_hw *hw = &adapter->hw;
 512	int max_len, first_word, last_word, ret_val = 0;
 513	u16 *eeprom_buff;
 514	void *ptr;
 515	u16 i;
 516
 517	if (eeprom->len == 0)
 518		return -EOPNOTSUPP;
 519
 520	if (hw->mac.type >= igc_i225 &&
 521	    !igc_get_flash_presence_i225(hw)) {
 522		return -EOPNOTSUPP;
 523	}
 524
 525	if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
 526		return -EFAULT;
 527
 528	max_len = hw->nvm.word_size * 2;
 529
 530	first_word = eeprom->offset >> 1;
 531	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 532	eeprom_buff = kmalloc(max_len, GFP_KERNEL);
 533	if (!eeprom_buff)
 534		return -ENOMEM;
 535
 536	ptr = (void *)eeprom_buff;
 537
 538	if (eeprom->offset & 1) {
 539		/* need read/modify/write of first changed EEPROM word
 540		 * only the second byte of the word is being modified
 541		 */
 542		ret_val = hw->nvm.ops.read(hw, first_word, 1,
 543					    &eeprom_buff[0]);
 544		ptr++;
 545	}
 546	if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) {
 547		/* need read/modify/write of last changed EEPROM word
 548		 * only the first byte of the word is being modified
 549		 */
 550		ret_val = hw->nvm.ops.read(hw, last_word, 1,
 551				   &eeprom_buff[last_word - first_word]);
 552	}
 553
 554	/* Device's eeprom is always little-endian, word addressable */
 555	for (i = 0; i < last_word - first_word + 1; i++)
 556		le16_to_cpus(&eeprom_buff[i]);
 557
 558	memcpy(ptr, bytes, eeprom->len);
 559
 560	for (i = 0; i < last_word - first_word + 1; i++)
 561		cpu_to_le16s(&eeprom_buff[i]);
 562
 563	ret_val = hw->nvm.ops.write(hw, first_word,
 564				    last_word - first_word + 1, eeprom_buff);
 565
 566	/* Update the checksum if nvm write succeeded */
 567	if (ret_val == 0)
 568		hw->nvm.ops.update(hw);
 569
 570	kfree(eeprom_buff);
 571	return ret_val;
 572}
 573
 574static void
 575igc_ethtool_get_ringparam(struct net_device *netdev,
 576			  struct ethtool_ringparam *ring,
 577			  struct kernel_ethtool_ringparam *kernel_ering,
 578			  struct netlink_ext_ack *extack)
 579{
 580	struct igc_adapter *adapter = netdev_priv(netdev);
 581
 582	ring->rx_max_pending = IGC_MAX_RXD;
 583	ring->tx_max_pending = IGC_MAX_TXD;
 584	ring->rx_pending = adapter->rx_ring_count;
 585	ring->tx_pending = adapter->tx_ring_count;
 586}
 587
 588static int
 589igc_ethtool_set_ringparam(struct net_device *netdev,
 590			  struct ethtool_ringparam *ring,
 591			  struct kernel_ethtool_ringparam *kernel_ering,
 592			  struct netlink_ext_ack *extack)
 593{
 594	struct igc_adapter *adapter = netdev_priv(netdev);
 595	struct igc_ring *temp_ring;
 596	u16 new_rx_count, new_tx_count;
 597	int i, err = 0;
 598
 599	if (ring->rx_mini_pending || ring->rx_jumbo_pending)
 600		return -EINVAL;
 601
 602	new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD);
 603	new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD);
 604	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
 605
 606	new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD);
 607	new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD);
 608	new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
 609
 610	if (new_tx_count == adapter->tx_ring_count &&
 611	    new_rx_count == adapter->rx_ring_count) {
 612		/* nothing to do */
 613		return 0;
 614	}
 615
 616	while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
 617		usleep_range(1000, 2000);
 618
 619	if (!netif_running(adapter->netdev)) {
 620		for (i = 0; i < adapter->num_tx_queues; i++)
 621			adapter->tx_ring[i]->count = new_tx_count;
 622		for (i = 0; i < adapter->num_rx_queues; i++)
 623			adapter->rx_ring[i]->count = new_rx_count;
 624		adapter->tx_ring_count = new_tx_count;
 625		adapter->rx_ring_count = new_rx_count;
 626		goto clear_reset;
 627	}
 628
 629	if (adapter->num_tx_queues > adapter->num_rx_queues)
 630		temp_ring = vmalloc_array(adapter->num_tx_queues,
 631					  sizeof(struct igc_ring));
 632	else
 633		temp_ring = vmalloc_array(adapter->num_rx_queues,
 634					  sizeof(struct igc_ring));
 635
 636	if (!temp_ring) {
 637		err = -ENOMEM;
 638		goto clear_reset;
 639	}
 640
 641	igc_down(adapter);
 642
 643	/* We can't just free everything and then setup again,
 644	 * because the ISRs in MSI-X mode get passed pointers
 645	 * to the Tx and Rx ring structs.
 646	 */
 647	if (new_tx_count != adapter->tx_ring_count) {
 648		for (i = 0; i < adapter->num_tx_queues; i++) {
 649			memcpy(&temp_ring[i], adapter->tx_ring[i],
 650			       sizeof(struct igc_ring));
 651
 652			temp_ring[i].count = new_tx_count;
 653			err = igc_setup_tx_resources(&temp_ring[i]);
 654			if (err) {
 655				while (i) {
 656					i--;
 657					igc_free_tx_resources(&temp_ring[i]);
 658				}
 659				goto err_setup;
 660			}
 661		}
 662
 663		for (i = 0; i < adapter->num_tx_queues; i++) {
 664			igc_free_tx_resources(adapter->tx_ring[i]);
 665
 666			memcpy(adapter->tx_ring[i], &temp_ring[i],
 667			       sizeof(struct igc_ring));
 668		}
 669
 670		adapter->tx_ring_count = new_tx_count;
 671	}
 672
 673	if (new_rx_count != adapter->rx_ring_count) {
 674		for (i = 0; i < adapter->num_rx_queues; i++) {
 675			memcpy(&temp_ring[i], adapter->rx_ring[i],
 676			       sizeof(struct igc_ring));
 677
 678			temp_ring[i].count = new_rx_count;
 679			err = igc_setup_rx_resources(&temp_ring[i]);
 680			if (err) {
 681				while (i) {
 682					i--;
 683					igc_free_rx_resources(&temp_ring[i]);
 684				}
 685				goto err_setup;
 686			}
 687		}
 688
 689		for (i = 0; i < adapter->num_rx_queues; i++) {
 690			igc_free_rx_resources(adapter->rx_ring[i]);
 691
 692			memcpy(adapter->rx_ring[i], &temp_ring[i],
 693			       sizeof(struct igc_ring));
 694		}
 695
 696		adapter->rx_ring_count = new_rx_count;
 697	}
 698err_setup:
 699	igc_up(adapter);
 700	vfree(temp_ring);
 701clear_reset:
 702	clear_bit(__IGC_RESETTING, &adapter->state);
 703	return err;
 704}
 705
 706static void igc_ethtool_get_pauseparam(struct net_device *netdev,
 707				       struct ethtool_pauseparam *pause)
 708{
 709	struct igc_adapter *adapter = netdev_priv(netdev);
 710	struct igc_hw *hw = &adapter->hw;
 711
 712	pause->autoneg =
 713		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 714
 715	if (hw->fc.current_mode == igc_fc_rx_pause) {
 716		pause->rx_pause = 1;
 717	} else if (hw->fc.current_mode == igc_fc_tx_pause) {
 718		pause->tx_pause = 1;
 719	} else if (hw->fc.current_mode == igc_fc_full) {
 720		pause->rx_pause = 1;
 721		pause->tx_pause = 1;
 722	}
 723}
 724
 725static int igc_ethtool_set_pauseparam(struct net_device *netdev,
 726				      struct ethtool_pauseparam *pause)
 727{
 728	struct igc_adapter *adapter = netdev_priv(netdev);
 729	struct igc_hw *hw = &adapter->hw;
 730	int retval = 0;
 731
 732	adapter->fc_autoneg = pause->autoneg;
 733
 734	while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
 735		usleep_range(1000, 2000);
 736
 737	if (adapter->fc_autoneg == AUTONEG_ENABLE) {
 738		hw->fc.requested_mode = igc_fc_default;
 739		if (netif_running(adapter->netdev)) {
 740			igc_down(adapter);
 741			igc_up(adapter);
 742		} else {
 743			igc_reset(adapter);
 744		}
 745	} else {
 746		if (pause->rx_pause && pause->tx_pause)
 747			hw->fc.requested_mode = igc_fc_full;
 748		else if (pause->rx_pause && !pause->tx_pause)
 749			hw->fc.requested_mode = igc_fc_rx_pause;
 750		else if (!pause->rx_pause && pause->tx_pause)
 751			hw->fc.requested_mode = igc_fc_tx_pause;
 752		else if (!pause->rx_pause && !pause->tx_pause)
 753			hw->fc.requested_mode = igc_fc_none;
 754
 755		hw->fc.current_mode = hw->fc.requested_mode;
 756
 757		retval = ((hw->phy.media_type == igc_media_type_copper) ?
 758			  igc_force_mac_fc(hw) : igc_setup_link(hw));
 759	}
 760
 761	clear_bit(__IGC_RESETTING, &adapter->state);
 762	return retval;
 763}
 764
 765static void igc_ethtool_get_strings(struct net_device *netdev, u32 stringset,
 766				    u8 *data)
 767{
 768	struct igc_adapter *adapter = netdev_priv(netdev);
 769	u8 *p = data;
 770	int i;
 771
 772	switch (stringset) {
 773	case ETH_SS_TEST:
 774		memcpy(data, *igc_gstrings_test,
 775		       IGC_TEST_LEN * ETH_GSTRING_LEN);
 776		break;
 777	case ETH_SS_STATS:
 778		for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++)
 779			ethtool_puts(&p, igc_gstrings_stats[i].stat_string);
 780		for (i = 0; i < IGC_NETDEV_STATS_LEN; i++)
 781			ethtool_puts(&p, igc_gstrings_net_stats[i].stat_string);
 782		for (i = 0; i < adapter->num_tx_queues; i++) {
 783			ethtool_sprintf(&p, "tx_queue_%u_packets", i);
 784			ethtool_sprintf(&p, "tx_queue_%u_bytes", i);
 785			ethtool_sprintf(&p, "tx_queue_%u_restart", i);
 786		}
 787		for (i = 0; i < adapter->num_rx_queues; i++) {
 788			ethtool_sprintf(&p, "rx_queue_%u_packets", i);
 789			ethtool_sprintf(&p, "rx_queue_%u_bytes", i);
 790			ethtool_sprintf(&p, "rx_queue_%u_drops", i);
 791			ethtool_sprintf(&p, "rx_queue_%u_csum_err", i);
 792			ethtool_sprintf(&p, "rx_queue_%u_alloc_failed", i);
 793		}
 794		/* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */
 795		break;
 796	case ETH_SS_PRIV_FLAGS:
 797		memcpy(data, igc_priv_flags_strings,
 798		       IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
 799		break;
 800	}
 801}
 802
 803static int igc_ethtool_get_sset_count(struct net_device *netdev, int sset)
 804{
 805	switch (sset) {
 806	case ETH_SS_STATS:
 807		return IGC_STATS_LEN;
 808	case ETH_SS_TEST:
 809		return IGC_TEST_LEN;
 810	case ETH_SS_PRIV_FLAGS:
 811		return IGC_PRIV_FLAGS_STR_LEN;
 812	default:
 813		return -EOPNOTSUPP;
 814	}
 815}
 816
 817static void igc_ethtool_get_stats(struct net_device *netdev,
 818				  struct ethtool_stats *stats, u64 *data)
 819{
 820	struct igc_adapter *adapter = netdev_priv(netdev);
 821	struct rtnl_link_stats64 *net_stats = &adapter->stats64;
 822	unsigned int start;
 823	struct igc_ring *ring;
 824	int i, j;
 825	char *p;
 826
 827	spin_lock(&adapter->stats64_lock);
 828	igc_update_stats(adapter);
 829
 830	for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) {
 831		p = (char *)adapter + igc_gstrings_stats[i].stat_offset;
 832		data[i] = (igc_gstrings_stats[i].sizeof_stat ==
 833			sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 834	}
 835	for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) {
 836		p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset;
 837		data[i] = (igc_gstrings_net_stats[j].sizeof_stat ==
 838			sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 839	}
 840	for (j = 0; j < adapter->num_tx_queues; j++) {
 841		u64	restart2;
 842
 843		ring = adapter->tx_ring[j];
 844		do {
 845			start = u64_stats_fetch_begin(&ring->tx_syncp);
 846			data[i]   = ring->tx_stats.packets;
 847			data[i + 1] = ring->tx_stats.bytes;
 848			data[i + 2] = ring->tx_stats.restart_queue;
 849		} while (u64_stats_fetch_retry(&ring->tx_syncp, start));
 850		do {
 851			start = u64_stats_fetch_begin(&ring->tx_syncp2);
 852			restart2  = ring->tx_stats.restart_queue2;
 853		} while (u64_stats_fetch_retry(&ring->tx_syncp2, start));
 854		data[i + 2] += restart2;
 855
 856		i += IGC_TX_QUEUE_STATS_LEN;
 857	}
 858	for (j = 0; j < adapter->num_rx_queues; j++) {
 859		ring = adapter->rx_ring[j];
 860		do {
 861			start = u64_stats_fetch_begin(&ring->rx_syncp);
 862			data[i]   = ring->rx_stats.packets;
 863			data[i + 1] = ring->rx_stats.bytes;
 864			data[i + 2] = ring->rx_stats.drops;
 865			data[i + 3] = ring->rx_stats.csum_err;
 866			data[i + 4] = ring->rx_stats.alloc_failed;
 867		} while (u64_stats_fetch_retry(&ring->rx_syncp, start));
 868		i += IGC_RX_QUEUE_STATS_LEN;
 869	}
 870	spin_unlock(&adapter->stats64_lock);
 871}
 872
 873static int igc_ethtool_get_previous_rx_coalesce(struct igc_adapter *adapter)
 874{
 875	return (adapter->rx_itr_setting <= 3) ?
 876		adapter->rx_itr_setting : adapter->rx_itr_setting >> 2;
 877}
 878
 879static int igc_ethtool_get_previous_tx_coalesce(struct igc_adapter *adapter)
 880{
 881	return (adapter->tx_itr_setting <= 3) ?
 882		adapter->tx_itr_setting : adapter->tx_itr_setting >> 2;
 883}
 884
 885static int igc_ethtool_get_coalesce(struct net_device *netdev,
 886				    struct ethtool_coalesce *ec,
 887				    struct kernel_ethtool_coalesce *kernel_coal,
 888				    struct netlink_ext_ack *extack)
 889{
 890	struct igc_adapter *adapter = netdev_priv(netdev);
 891
 892	ec->rx_coalesce_usecs = igc_ethtool_get_previous_rx_coalesce(adapter);
 893	ec->tx_coalesce_usecs = igc_ethtool_get_previous_tx_coalesce(adapter);
 894
 895	return 0;
 896}
 897
 898static int igc_ethtool_set_coalesce(struct net_device *netdev,
 899				    struct ethtool_coalesce *ec,
 900				    struct kernel_ethtool_coalesce *kernel_coal,
 901				    struct netlink_ext_ack *extack)
 902{
 903	struct igc_adapter *adapter = netdev_priv(netdev);
 904	int i;
 905
 906	if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS ||
 907	    (ec->rx_coalesce_usecs > 3 &&
 908	     ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) ||
 909	    ec->rx_coalesce_usecs == 2)
 910		return -EINVAL;
 911
 912	if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS ||
 913	    (ec->tx_coalesce_usecs > 3 &&
 914	     ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) ||
 915	    ec->tx_coalesce_usecs == 2)
 916		return -EINVAL;
 917
 918	if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) &&
 919	    ec->tx_coalesce_usecs != igc_ethtool_get_previous_tx_coalesce(adapter)) {
 920		NL_SET_ERR_MSG_MOD(extack,
 921				   "Queue Pair mode enabled, both Rx and Tx coalescing controlled by rx-usecs");
 922		return -EINVAL;
 923	}
 924
 925	/* If ITR is disabled, disable DMAC */
 926	if (ec->rx_coalesce_usecs == 0) {
 927		if (adapter->flags & IGC_FLAG_DMAC)
 928			adapter->flags &= ~IGC_FLAG_DMAC;
 929	}
 930
 931	/* convert to rate of irq's per second */
 932	if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3)
 933		adapter->rx_itr_setting = ec->rx_coalesce_usecs;
 934	else
 935		adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2;
 936
 937	/* convert to rate of irq's per second */
 938	if (adapter->flags & IGC_FLAG_QUEUE_PAIRS)
 939		adapter->tx_itr_setting = adapter->rx_itr_setting;
 940	else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3)
 941		adapter->tx_itr_setting = ec->tx_coalesce_usecs;
 942	else
 943		adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2;
 944
 945	for (i = 0; i < adapter->num_q_vectors; i++) {
 946		struct igc_q_vector *q_vector = adapter->q_vector[i];
 947
 948		q_vector->tx.work_limit = adapter->tx_work_limit;
 949		if (q_vector->rx.ring)
 950			q_vector->itr_val = adapter->rx_itr_setting;
 951		else
 952			q_vector->itr_val = adapter->tx_itr_setting;
 953		if (q_vector->itr_val && q_vector->itr_val <= 3)
 954			q_vector->itr_val = IGC_START_ITR;
 955		q_vector->set_itr = 1;
 956	}
 957
 958	return 0;
 959}
 960
 961#define ETHER_TYPE_FULL_MASK ((__force __be16)~0)
 962#define VLAN_TCI_FULL_MASK ((__force __be16)~0)
 963static int igc_ethtool_get_nfc_rule(struct igc_adapter *adapter,
 964				    struct ethtool_rxnfc *cmd)
 965{
 966	struct ethtool_rx_flow_spec *fsp = &cmd->fs;
 967	struct igc_nfc_rule *rule = NULL;
 968
 969	cmd->data = IGC_MAX_RXNFC_RULES;
 970
 971	mutex_lock(&adapter->nfc_rule_lock);
 972
 973	rule = igc_get_nfc_rule(adapter, fsp->location);
 974	if (!rule)
 975		goto out;
 976
 977	fsp->flow_type = ETHER_FLOW;
 978	fsp->ring_cookie = rule->action;
 979
 980	if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {
 981		fsp->h_u.ether_spec.h_proto = htons(rule->filter.etype);
 982		fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK;
 983	}
 984
 985	if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) {
 986		fsp->flow_type |= FLOW_EXT;
 987		fsp->h_ext.vlan_etype = htons(rule->filter.vlan_etype);
 988		fsp->m_ext.vlan_etype = ETHER_TYPE_FULL_MASK;
 989	}
 990
 991	if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) {
 992		fsp->flow_type |= FLOW_EXT;
 993		fsp->h_ext.vlan_tci = htons(rule->filter.vlan_tci);
 994		fsp->m_ext.vlan_tci = htons(rule->filter.vlan_tci_mask);
 995	}
 996
 997	if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {
 998		ether_addr_copy(fsp->h_u.ether_spec.h_dest,
 999				rule->filter.dst_addr);
1000		eth_broadcast_addr(fsp->m_u.ether_spec.h_dest);
1001	}
1002
1003	if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {
1004		ether_addr_copy(fsp->h_u.ether_spec.h_source,
1005				rule->filter.src_addr);
1006		eth_broadcast_addr(fsp->m_u.ether_spec.h_source);
1007	}
1008
1009	if (rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA) {
1010		fsp->flow_type |= FLOW_EXT;
1011		memcpy(fsp->h_ext.data, rule->filter.user_data, sizeof(fsp->h_ext.data));
1012		memcpy(fsp->m_ext.data, rule->filter.user_mask, sizeof(fsp->m_ext.data));
1013	}
1014
1015	mutex_unlock(&adapter->nfc_rule_lock);
1016	return 0;
1017
1018out:
1019	mutex_unlock(&adapter->nfc_rule_lock);
1020	return -EINVAL;
1021}
1022
1023static int igc_ethtool_get_nfc_rules(struct igc_adapter *adapter,
1024				     struct ethtool_rxnfc *cmd,
1025				     u32 *rule_locs)
1026{
1027	struct igc_nfc_rule *rule;
1028	int cnt = 0;
1029
1030	cmd->data = IGC_MAX_RXNFC_RULES;
1031
1032	mutex_lock(&adapter->nfc_rule_lock);
1033
1034	list_for_each_entry(rule, &adapter->nfc_rule_list, list) {
1035		if (cnt == cmd->rule_cnt) {
1036			mutex_unlock(&adapter->nfc_rule_lock);
1037			return -EMSGSIZE;
1038		}
1039		rule_locs[cnt] = rule->location;
1040		cnt++;
1041	}
1042
1043	mutex_unlock(&adapter->nfc_rule_lock);
1044
1045	cmd->rule_cnt = cnt;
1046
1047	return 0;
1048}
1049
1050static int igc_ethtool_get_rxfh_fields(struct net_device *dev,
1051				       struct ethtool_rxfh_fields *cmd)
1052{
1053	struct igc_adapter *adapter = netdev_priv(dev);
1054
1055	cmd->data = 0;
1056
1057	/* Report default options for RSS on igc */
1058	switch (cmd->flow_type) {
1059	case TCP_V4_FLOW:
1060		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1061		fallthrough;
1062	case UDP_V4_FLOW:
1063		if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
1064			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1065		fallthrough;
1066	case SCTP_V4_FLOW:
1067	case AH_ESP_V4_FLOW:
1068	case AH_V4_FLOW:
1069	case ESP_V4_FLOW:
1070	case IPV4_FLOW:
1071		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
1072		break;
1073	case TCP_V6_FLOW:
1074		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1075		fallthrough;
1076	case UDP_V6_FLOW:
1077		if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
1078			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1079		fallthrough;
1080	case SCTP_V6_FLOW:
1081	case AH_ESP_V6_FLOW:
1082	case AH_V6_FLOW:
1083	case ESP_V6_FLOW:
1084	case IPV6_FLOW:
1085		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
1086		break;
1087	default:
1088		return -EINVAL;
1089	}
1090
1091	return 0;
1092}
1093
1094static u32 igc_ethtool_get_rx_ring_count(struct net_device *dev)
1095{
1096	struct igc_adapter *adapter = netdev_priv(dev);
1097
1098	return adapter->num_rx_queues;
1099}
1100
1101static int igc_ethtool_get_rxnfc(struct net_device *dev,
1102				 struct ethtool_rxnfc *cmd, u32 *rule_locs)
1103{
1104	struct igc_adapter *adapter = netdev_priv(dev);
1105
1106	switch (cmd->cmd) {
1107	case ETHTOOL_GRXCLSRLCNT:
1108		cmd->rule_cnt = adapter->nfc_rule_count;
1109		return 0;
1110	case ETHTOOL_GRXCLSRULE:
1111		return igc_ethtool_get_nfc_rule(adapter, cmd);
1112	case ETHTOOL_GRXCLSRLALL:
1113		return igc_ethtool_get_nfc_rules(adapter, cmd, rule_locs);
1114	default:
1115		return -EOPNOTSUPP;
1116	}
1117}
1118
1119#define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \
1120		       IGC_FLAG_RSS_FIELD_IPV6_UDP)
1121static int igc_ethtool_set_rxfh_fields(struct net_device *dev,
1122				       const struct ethtool_rxfh_fields *nfc,
1123				       struct netlink_ext_ack *extack)
1124{
1125	struct igc_adapter *adapter = netdev_priv(dev);
1126	u32 flags = adapter->flags;
1127
1128	/* RSS does not support anything other than hashing
1129	 * to queues on src and dst IPs and ports
1130	 */
1131	if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
1132			  RXH_L4_B_0_1 | RXH_L4_B_2_3))
1133		return -EINVAL;
1134
1135	switch (nfc->flow_type) {
1136	case TCP_V4_FLOW:
1137	case TCP_V6_FLOW:
1138		if (!(nfc->data & RXH_IP_SRC) ||
1139		    !(nfc->data & RXH_IP_DST) ||
1140		    !(nfc->data & RXH_L4_B_0_1) ||
1141		    !(nfc->data & RXH_L4_B_2_3))
1142			return -EINVAL;
1143		break;
1144	case UDP_V4_FLOW:
1145		if (!(nfc->data & RXH_IP_SRC) ||
1146		    !(nfc->data & RXH_IP_DST))
1147			return -EINVAL;
1148		switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1149		case 0:
1150			flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP;
1151			break;
1152		case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1153			flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP;
1154			break;
1155		default:
1156			return -EINVAL;
1157		}
1158		break;
1159	case UDP_V6_FLOW:
1160		if (!(nfc->data & RXH_IP_SRC) ||
1161		    !(nfc->data & RXH_IP_DST))
1162			return -EINVAL;
1163		switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1164		case 0:
1165			flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP;
1166			break;
1167		case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1168			flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP;
1169			break;
1170		default:
1171			return -EINVAL;
1172		}
1173		break;
1174	case AH_ESP_V4_FLOW:
1175	case AH_V4_FLOW:
1176	case ESP_V4_FLOW:
1177	case SCTP_V4_FLOW:
1178	case AH_ESP_V6_FLOW:
1179	case AH_V6_FLOW:
1180	case ESP_V6_FLOW:
1181	case SCTP_V6_FLOW:
1182		if (!(nfc->data & RXH_IP_SRC) ||
1183		    !(nfc->data & RXH_IP_DST) ||
1184		    (nfc->data & RXH_L4_B_0_1) ||
1185		    (nfc->data & RXH_L4_B_2_3))
1186			return -EINVAL;
1187		break;
1188	default:
1189		return -EINVAL;
1190	}
1191
1192	/* if we changed something we need to update flags */
1193	if (flags != adapter->flags) {
1194		struct igc_hw *hw = &adapter->hw;
1195		u32 mrqc = rd32(IGC_MRQC);
1196
1197		if ((flags & UDP_RSS_FLAGS) &&
1198		    !(adapter->flags & UDP_RSS_FLAGS))
1199			netdev_err(adapter->netdev,
1200				   "Enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
1201
1202		adapter->flags = flags;
1203
1204		/* Perform hash on these packet types */
1205		mrqc |= IGC_MRQC_RSS_FIELD_IPV4 |
1206			IGC_MRQC_RSS_FIELD_IPV4_TCP |
1207			IGC_MRQC_RSS_FIELD_IPV6 |
1208			IGC_MRQC_RSS_FIELD_IPV6_TCP;
1209
1210		mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP |
1211			  IGC_MRQC_RSS_FIELD_IPV6_UDP);
1212
1213		if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
1214			mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP;
1215
1216		if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
1217			mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP;
1218
1219		wr32(IGC_MRQC, mrqc);
1220	}
1221
1222	return 0;
1223}
1224
1225static void igc_ethtool_init_nfc_rule(struct igc_nfc_rule *rule,
1226				      const struct ethtool_rx_flow_spec *fsp)
1227{
1228	INIT_LIST_HEAD(&rule->list);
1229
1230	rule->action = fsp->ring_cookie;
1231	rule->location = fsp->location;
1232
1233	if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) {
1234		rule->filter.vlan_tci = ntohs(fsp->h_ext.vlan_tci);
1235		rule->filter.vlan_tci_mask = ntohs(fsp->m_ext.vlan_tci);
1236		rule->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI;
1237	}
1238
1239	if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) {
1240		rule->filter.etype = ntohs(fsp->h_u.ether_spec.h_proto);
1241		rule->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE;
1242	}
1243
1244	/* Both source and destination address filters only support the full
1245	 * mask.
1246	 */
1247	if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) {
1248		rule->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR;
1249		ether_addr_copy(rule->filter.src_addr,
1250				fsp->h_u.ether_spec.h_source);
1251	}
1252
1253	if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) {
1254		rule->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR;
1255		ether_addr_copy(rule->filter.dst_addr,
1256				fsp->h_u.ether_spec.h_dest);
1257	}
1258
1259	/* VLAN etype matching */
1260	if ((fsp->flow_type & FLOW_EXT) && fsp->h_ext.vlan_etype) {
1261		rule->filter.vlan_etype = ntohs(fsp->h_ext.vlan_etype);
1262		rule->filter.match_flags |= IGC_FILTER_FLAG_VLAN_ETYPE;
1263	}
1264
1265	/* Check for user defined data */
1266	if ((fsp->flow_type & FLOW_EXT) &&
1267	    (fsp->h_ext.data[0] || fsp->h_ext.data[1])) {
1268		rule->filter.match_flags |= IGC_FILTER_FLAG_USER_DATA;
1269		memcpy(rule->filter.user_data, fsp->h_ext.data, sizeof(fsp->h_ext.data));
1270		memcpy(rule->filter.user_mask, fsp->m_ext.data, sizeof(fsp->m_ext.data));
1271	}
1272
1273	/* The i225/i226 has various different filters. Flex filters provide a
1274	 * way to match up to the first 128 bytes of a packet. Use them for:
1275	 *   a) For specific user data
1276	 *   b) For VLAN EtherType
1277	 *   c) For full TCI match
1278	 *   d) Or in case multiple filter criteria are set
1279	 *
1280	 * Otherwise, use the simple MAC, VLAN PRIO or EtherType filters.
1281	 */
1282	if ((rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA) ||
1283	    (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) ||
1284	    ((rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) &&
1285	     rule->filter.vlan_tci_mask == ntohs(VLAN_TCI_FULL_MASK)) ||
1286	    (rule->filter.match_flags & (rule->filter.match_flags - 1)))
1287		rule->flex = true;
1288	else
1289		rule->flex = false;
1290
1291	/* The wildcard rule is only applied if:
1292	 *  a) None of the other filtering rules match (match_flags is zero)
1293	 *  b) The flow type is ETHER_FLOW only (no additional fields set)
1294	 *  c) Mask for Source MAC address is not specified (all zeros)
1295	 *  d) Mask for Destination MAC address is not specified (all zeros)
1296	 *  e) Mask for L2 EtherType is not specified (zero)
1297	 *
1298	 * If all these conditions are met, the rule is treated as a wildcard
1299	 * rule. Default queue feature will be used, so that all packets that do
1300	 * not match any other rule will be routed to the default queue.
1301	 */
1302	if (!rule->filter.match_flags &&
1303	    fsp->flow_type == ETHER_FLOW &&
1304	    is_zero_ether_addr(fsp->m_u.ether_spec.h_source) &&
1305	    is_zero_ether_addr(fsp->m_u.ether_spec.h_dest) &&
1306	    !fsp->m_u.ether_spec.h_proto)
1307		rule->filter.match_flags = IGC_FILTER_FLAG_DEFAULT_QUEUE;
1308}
1309
1310/**
1311 * igc_ethtool_check_nfc_rule() - Check if NFC rule is valid
1312 * @adapter: Pointer to adapter
1313 * @rule: Rule under evaluation
1314 *
1315 * The driver doesn't support rules with multiple matches so if more than
1316 * one bit in filter flags is set, @rule is considered invalid.
1317 *
1318 * Also, if there is already another rule with the same filter in a different
1319 * location, @rule is considered invalid.
1320 *
1321 * Context: Expects adapter->nfc_rule_lock to be held by caller.
1322 *
1323 * Return: 0 in case of success, negative errno code otherwise.
1324 */
1325static int igc_ethtool_check_nfc_rule(struct igc_adapter *adapter,
1326				      struct igc_nfc_rule *rule)
1327{
1328	struct net_device *dev = adapter->netdev;
1329	u8 flags = rule->filter.match_flags;
1330	struct igc_nfc_rule *tmp;
1331
1332	if (!flags) {
1333		netdev_dbg(dev, "Rule with no match\n");
1334		return -EINVAL;
1335	}
1336
1337	list_for_each_entry(tmp, &adapter->nfc_rule_list, list) {
1338		if (!memcmp(&rule->filter, &tmp->filter,
1339			    sizeof(rule->filter)) &&
1340		    tmp->location != rule->location) {
1341			netdev_dbg(dev, "Rule already exists\n");
1342			return -EEXIST;
1343		}
1344	}
1345
1346	return 0;
1347}
1348
1349static int igc_ethtool_add_nfc_rule(struct igc_adapter *adapter,
1350				    struct ethtool_rxnfc *cmd)
1351{
1352	struct net_device *netdev = adapter->netdev;
1353	struct ethtool_rx_flow_spec *fsp =
1354		(struct ethtool_rx_flow_spec *)&cmd->fs;
1355	struct igc_nfc_rule *rule, *old_rule;
1356	int err;
1357
1358	if (!(netdev->hw_features & NETIF_F_NTUPLE)) {
1359		netdev_dbg(netdev, "N-tuple filters disabled\n");
1360		return -EOPNOTSUPP;
1361	}
1362
1363	if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW) {
1364		netdev_dbg(netdev, "Only ethernet flow type is supported\n");
1365		return -EOPNOTSUPP;
1366	}
1367
1368	if (fsp->ring_cookie >= adapter->num_rx_queues) {
1369		netdev_dbg(netdev, "Invalid action\n");
1370		return -EINVAL;
1371	}
1372
1373	/* There are two ways to match the VLAN TCI:
1374	 *  1. Match on PCP field and use vlan prio filter for it
1375	 *  2. Match on complete TCI field and use flex filter for it
1376	 */
1377	if ((fsp->flow_type & FLOW_EXT) &&
1378	    fsp->m_ext.vlan_tci &&
1379	    fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK) &&
1380	    fsp->m_ext.vlan_tci != VLAN_TCI_FULL_MASK) {
1381		netdev_dbg(netdev, "VLAN mask not supported\n");
1382		return -EOPNOTSUPP;
1383	}
1384
1385	/* VLAN EtherType can only be matched by full mask. */
1386	if ((fsp->flow_type & FLOW_EXT) &&
1387	    fsp->m_ext.vlan_etype &&
1388	    fsp->m_ext.vlan_etype != ETHER_TYPE_FULL_MASK) {
1389		netdev_dbg(netdev, "VLAN EtherType mask not supported\n");
1390		return -EOPNOTSUPP;
1391	}
1392
1393	if (fsp->location >= IGC_MAX_RXNFC_RULES) {
1394		netdev_dbg(netdev, "Invalid location\n");
1395		return -EINVAL;
1396	}
1397
1398	rule = kzalloc(sizeof(*rule), GFP_KERNEL);
1399	if (!rule)
1400		return -ENOMEM;
1401
1402	igc_ethtool_init_nfc_rule(rule, fsp);
1403
1404	mutex_lock(&adapter->nfc_rule_lock);
1405
1406	err = igc_ethtool_check_nfc_rule(adapter, rule);
1407	if (err)
1408		goto err;
1409
1410	old_rule = igc_get_nfc_rule(adapter, fsp->location);
1411	if (old_rule)
1412		igc_del_nfc_rule(adapter, old_rule);
1413
1414	err = igc_add_nfc_rule(adapter, rule);
1415	if (err)
1416		goto err;
1417
1418	mutex_unlock(&adapter->nfc_rule_lock);
1419	return 0;
1420
1421err:
1422	mutex_unlock(&adapter->nfc_rule_lock);
1423	kfree(rule);
1424	return err;
1425}
1426
1427static int igc_ethtool_del_nfc_rule(struct igc_adapter *adapter,
1428				    struct ethtool_rxnfc *cmd)
1429{
1430	struct ethtool_rx_flow_spec *fsp =
1431		(struct ethtool_rx_flow_spec *)&cmd->fs;
1432	struct igc_nfc_rule *rule;
1433
1434	mutex_lock(&adapter->nfc_rule_lock);
1435
1436	rule = igc_get_nfc_rule(adapter, fsp->location);
1437	if (!rule) {
1438		mutex_unlock(&adapter->nfc_rule_lock);
1439		return -EINVAL;
1440	}
1441
1442	igc_del_nfc_rule(adapter, rule);
1443
1444	mutex_unlock(&adapter->nfc_rule_lock);
1445	return 0;
1446}
1447
1448static int igc_ethtool_set_rxnfc(struct net_device *dev,
1449				 struct ethtool_rxnfc *cmd)
1450{
1451	struct igc_adapter *adapter = netdev_priv(dev);
1452
1453	switch (cmd->cmd) {
1454	case ETHTOOL_SRXCLSRLINS:
1455		return igc_ethtool_add_nfc_rule(adapter, cmd);
1456	case ETHTOOL_SRXCLSRLDEL:
1457		return igc_ethtool_del_nfc_rule(adapter, cmd);
1458	default:
1459		return -EOPNOTSUPP;
1460	}
1461}
1462
1463void igc_write_rss_indir_tbl(struct igc_adapter *adapter)
1464{
1465	struct igc_hw *hw = &adapter->hw;
1466	u32 reg = IGC_RETA(0);
1467	u32 shift = 0;
1468	int i = 0;
1469
1470	while (i < IGC_RETA_SIZE) {
1471		u32 val = 0;
1472		int j;
1473
1474		for (j = 3; j >= 0; j--) {
1475			val <<= 8;
1476			val |= adapter->rss_indir_tbl[i + j];
1477		}
1478
1479		wr32(reg, val << shift);
1480		reg += 4;
1481		i += 4;
1482	}
1483}
1484
1485static u32 igc_ethtool_get_rxfh_indir_size(struct net_device *netdev)
1486{
1487	return IGC_RETA_SIZE;
1488}
1489
1490static int igc_ethtool_get_rxfh(struct net_device *netdev,
1491				struct ethtool_rxfh_param *rxfh)
1492{
1493	struct igc_adapter *adapter = netdev_priv(netdev);
1494	int i;
1495
1496	rxfh->hfunc = ETH_RSS_HASH_TOP;
1497	if (!rxfh->indir)
1498		return 0;
1499	for (i = 0; i < IGC_RETA_SIZE; i++)
1500		rxfh->indir[i] = adapter->rss_indir_tbl[i];
1501
1502	return 0;
1503}
1504
1505static int igc_ethtool_set_rxfh(struct net_device *netdev,
1506				struct ethtool_rxfh_param *rxfh,
1507				struct netlink_ext_ack *extack)
1508{
1509	struct igc_adapter *adapter = netdev_priv(netdev);
1510	u32 num_queues;
1511	int i;
1512
1513	/* We do not allow change in unsupported parameters */
1514	if (rxfh->key ||
1515	    (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
1516	     rxfh->hfunc != ETH_RSS_HASH_TOP))
1517		return -EOPNOTSUPP;
1518	if (!rxfh->indir)
1519		return 0;
1520
1521	num_queues = adapter->rss_queues;
1522
1523	/* Verify user input. */
1524	for (i = 0; i < IGC_RETA_SIZE; i++)
1525		if (rxfh->indir[i] >= num_queues)
1526			return -EINVAL;
1527
1528	for (i = 0; i < IGC_RETA_SIZE; i++)
1529		adapter->rss_indir_tbl[i] = rxfh->indir[i];
1530
1531	igc_write_rss_indir_tbl(adapter);
1532
1533	return 0;
1534}
1535
1536static void igc_ethtool_get_channels(struct net_device *netdev,
1537				     struct ethtool_channels *ch)
1538{
1539	struct igc_adapter *adapter = netdev_priv(netdev);
1540
1541	/* Report maximum channels */
1542	ch->max_combined = igc_get_max_rss_queues(adapter);
1543
1544	/* Report info for other vector */
1545	if (adapter->flags & IGC_FLAG_HAS_MSIX) {
1546		ch->max_other = NON_Q_VECTORS;
1547		ch->other_count = NON_Q_VECTORS;
1548	}
1549
1550	ch->combined_count = adapter->rss_queues;
1551}
1552
1553static int igc_ethtool_set_channels(struct net_device *netdev,
1554				    struct ethtool_channels *ch)
1555{
1556	struct igc_adapter *adapter = netdev_priv(netdev);
1557	unsigned int count = ch->combined_count;
1558	unsigned int max_combined = 0;
1559
1560	/* Verify they are not requesting separate vectors */
1561	if (!count || ch->rx_count || ch->tx_count)
1562		return -EINVAL;
1563
1564	/* Verify other_count is valid and has not been changed */
1565	if (ch->other_count != NON_Q_VECTORS)
1566		return -EINVAL;
1567
1568	/* Do not allow channel reconfiguration when any TSN qdisc is enabled */
1569	if (adapter->flags & IGC_FLAG_TSN_ANY_ENABLED)
1570		return -EINVAL;
1571
1572	/* Verify the number of channels doesn't exceed hw limits */
1573	max_combined = igc_get_max_rss_queues(adapter);
1574	if (count > max_combined)
1575		return -EINVAL;
1576
1577	if (count != adapter->rss_queues) {
1578		adapter->rss_queues = count;
1579		igc_set_flag_queue_pairs(adapter, max_combined);
1580
1581		/* Hardware has to reinitialize queues and interrupts to
1582		 * match the new configuration.
1583		 */
1584		return igc_reinit_queues(adapter);
1585	}
1586
1587	return 0;
1588}
1589
1590static int igc_ethtool_get_ts_info(struct net_device *dev,
1591				   struct kernel_ethtool_ts_info *info)
1592{
1593	struct igc_adapter *adapter = netdev_priv(dev);
1594
1595	if (adapter->ptp_clock)
1596		info->phc_index = ptp_clock_index(adapter->ptp_clock);
1597
1598	switch (adapter->hw.mac.type) {
1599	case igc_i225:
1600		info->so_timestamping =
1601			SOF_TIMESTAMPING_TX_SOFTWARE |
1602			SOF_TIMESTAMPING_TX_HARDWARE |
1603			SOF_TIMESTAMPING_RX_HARDWARE |
1604			SOF_TIMESTAMPING_RAW_HARDWARE;
1605
1606		info->tx_types =
1607			BIT(HWTSTAMP_TX_OFF) |
1608			BIT(HWTSTAMP_TX_ON);
1609
1610		info->rx_filters = BIT(HWTSTAMP_FILTER_NONE);
1611		info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL);
1612
1613		return 0;
1614	default:
1615		return -EOPNOTSUPP;
1616	}
1617}
1618
1619static u32 igc_ethtool_get_priv_flags(struct net_device *netdev)
1620{
1621	struct igc_adapter *adapter = netdev_priv(netdev);
1622	u32 priv_flags = 0;
1623
1624	if (adapter->flags & IGC_FLAG_RX_LEGACY)
1625		priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX;
1626
1627	if (adapter->flags & IGC_FLAG_TSN_REVERSE_TXQ_PRIO)
1628		priv_flags |= IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO;
1629
1630	return priv_flags;
1631}
1632
1633static int igc_ethtool_set_priv_flags(struct net_device *netdev, u32 priv_flags)
1634{
1635	struct igc_adapter *adapter = netdev_priv(netdev);
1636	unsigned int flags = adapter->flags;
1637
1638	flags &= ~(IGC_FLAG_RX_LEGACY | IGC_FLAG_TSN_REVERSE_TXQ_PRIO);
1639	if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX)
1640		flags |= IGC_FLAG_RX_LEGACY;
1641
1642	if (priv_flags & IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO)
1643		flags |= IGC_FLAG_TSN_REVERSE_TXQ_PRIO;
1644
1645	if (flags != adapter->flags) {
1646		adapter->flags = flags;
1647
1648		/* reset interface to repopulate queues */
1649		if (netif_running(netdev))
1650			igc_reinit_locked(adapter);
1651	}
1652
1653	return 0;
1654}
1655
1656static int igc_ethtool_get_eee(struct net_device *netdev,
1657			       struct ethtool_keee *edata)
1658{
1659	struct igc_adapter *adapter = netdev_priv(netdev);
1660	struct igc_hw *hw = &adapter->hw;
1661	struct igc_phy_info *phy = &hw->phy;
1662	u16 eee_advert, eee_lp_advert;
1663	u32 eeer, ret_val;
1664
1665	/* EEE supported */
1666	linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
1667			 edata->supported);
1668	linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1669			 edata->supported);
1670	linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1671			 edata->supported);
1672
1673	/* EEE Advertisement 1 - reg 7.60 */
1674	ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK <<
1675				    MMD_DEVADDR_SHIFT) |
1676				    IGC_ANEG_EEE_AB1,
1677				    &eee_advert);
1678	if (ret_val) {
1679		netdev_err(adapter->netdev,
1680			   "Failed to read IEEE 7.60 register\n");
1681		return -EINVAL;
1682	}
1683
1684	if (eee_advert & IGC_EEE_1000BT_MASK)
1685		linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1686				 edata->advertised);
1687
1688	if (eee_advert & IGC_EEE_100BT_MASK)
1689		linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1690				 edata->advertised);
1691
1692	/* EEE Advertisement 2 - reg 7.62 */
1693	ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK <<
1694				    MMD_DEVADDR_SHIFT) |
1695				    IGC_ANEG_EEE_AB2,
1696				    &eee_advert);
1697	if (ret_val) {
1698		netdev_err(adapter->netdev,
1699			   "Failed to read IEEE 7.62 register\n");
1700		return -EINVAL;
1701	}
1702
1703	if (eee_advert & IGC_EEE_2500BT_MASK)
1704		linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
1705				 edata->advertised);
1706
1707	/* EEE Link-Partner Ability 1 - reg 7.61 */
1708	ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK <<
1709				    MMD_DEVADDR_SHIFT) |
1710				    IGC_ANEG_EEE_LP_AB1,
1711				    &eee_lp_advert);
1712	if (ret_val) {
1713		netdev_err(adapter->netdev,
1714			   "Failed to read IEEE 7.61 register\n");
1715		return -EINVAL;
1716	}
1717
1718	if (eee_lp_advert & IGC_LP_EEE_1000BT_MASK)
1719		linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1720				 edata->lp_advertised);
1721
1722	if (eee_lp_advert & IGC_LP_EEE_100BT_MASK)
1723		linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1724				 edata->lp_advertised);
1725
1726	/* EEE Link-Partner Ability 2 - reg 7.63 */
1727	ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK <<
1728				    MMD_DEVADDR_SHIFT) |
1729				    IGC_ANEG_EEE_LP_AB2,
1730				    &eee_lp_advert);
1731	if (ret_val) {
1732		netdev_err(adapter->netdev,
1733			   "Failed to read IEEE 7.63 register\n");
1734		return -EINVAL;
1735	}
1736
1737	if (eee_lp_advert & IGC_LP_EEE_2500BT_MASK)
1738		linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
1739				 edata->lp_advertised);
1740
1741	eeer = rd32(IGC_EEER);
1742
1743	/* EEE status on negotiated link */
1744	if (eeer & IGC_EEER_EEE_NEG)
1745		edata->eee_active = true;
1746
1747	if (eeer & IGC_EEER_TX_LPI_EN)
1748		edata->tx_lpi_enabled = true;
1749
1750	edata->eee_enabled = hw->dev_spec._base.eee_enable;
1751
1752	/* Report correct negotiated EEE status for devices that
1753	 * wrongly report EEE at half-duplex
1754	 */
1755	if (adapter->link_duplex == HALF_DUPLEX) {
1756		edata->eee_enabled = false;
1757		edata->eee_active = false;
1758		edata->tx_lpi_enabled = false;
1759		linkmode_zero(edata->advertised);
1760	}
1761
1762	return 0;
1763}
1764
1765static int igc_ethtool_set_eee(struct net_device *netdev,
1766			       struct ethtool_keee *edata)
1767{
1768	struct igc_adapter *adapter = netdev_priv(netdev);
1769	struct igc_hw *hw = &adapter->hw;
1770	struct ethtool_keee eee_curr;
1771	s32 ret_val;
1772
1773	memset(&eee_curr, 0, sizeof(struct ethtool_keee));
1774
1775	ret_val = igc_ethtool_get_eee(netdev, &eee_curr);
1776	if (ret_val) {
1777		netdev_err(netdev,
1778			   "Problem setting EEE advertisement options\n");
1779		return -EINVAL;
1780	}
1781
1782	if (eee_curr.eee_enabled) {
1783		if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
1784			netdev_err(netdev,
1785				   "Setting EEE tx-lpi is not supported\n");
1786			return -EINVAL;
1787		}
1788
1789		/* Tx LPI timer is not implemented currently */
1790		if (edata->tx_lpi_timer) {
1791			netdev_err(netdev,
1792				   "Setting EEE Tx LPI timer is not supported\n");
1793			return -EINVAL;
1794		}
1795	} else if (!edata->eee_enabled) {
1796		netdev_err(netdev,
1797			   "Setting EEE options are not supported with EEE disabled\n");
1798		return -EINVAL;
1799	}
1800
1801	if (hw->dev_spec._base.eee_enable != edata->eee_enabled) {
1802		hw->dev_spec._base.eee_enable = edata->eee_enabled;
1803		adapter->flags |= IGC_FLAG_EEE;
1804
1805		/* reset link */
1806		if (netif_running(netdev))
1807			igc_reinit_locked(adapter);
1808		else
1809			igc_reset(adapter);
1810	}
1811
1812	return 0;
1813}
1814
1815static int igc_ethtool_get_mm(struct net_device *netdev,
1816			      struct ethtool_mm_state *cmd)
1817{
1818	struct igc_adapter *adapter = netdev_priv(netdev);
1819	struct igc_fpe_t *fpe = &adapter->fpe;
1820
1821	ethtool_mmsv_get_mm(&fpe->mmsv, cmd);
1822	cmd->tx_min_frag_size = fpe->tx_min_frag_size;
1823	cmd->rx_min_frag_size = IGC_RX_MIN_FRAG_SIZE;
1824
1825	return 0;
1826}
1827
1828static int igc_ethtool_set_mm(struct net_device *netdev,
1829			      struct ethtool_mm_cfg *cmd,
1830			      struct netlink_ext_ack *extack)
1831{
1832	struct igc_adapter *adapter = netdev_priv(netdev);
1833	struct igc_fpe_t *fpe = &adapter->fpe;
1834
1835	fpe->tx_min_frag_size = igc_fpe_get_supported_frag_size(cmd->tx_min_frag_size);
1836	if (fpe->tx_min_frag_size != cmd->tx_min_frag_size)
1837		NL_SET_ERR_MSG_MOD(extack,
1838				   "tx-min-frag-size value set is unsupported. Rounded up to supported value (64, 128, 192, 256)");
1839
1840	if (fpe->mmsv.pmac_enabled != cmd->pmac_enabled) {
1841		if (cmd->pmac_enabled)
1842			static_branch_inc(&igc_fpe_enabled);
1843		else
1844			static_branch_dec(&igc_fpe_enabled);
1845	}
1846
1847	ethtool_mmsv_set_mm(&fpe->mmsv, cmd);
1848
1849	return igc_tsn_offload_apply(adapter);
1850}
1851
1852/**
1853 * igc_ethtool_get_frame_ass_error - Get the frame assembly error count.
1854 * @reg_value: Register value for IGC_PRMEXCPRCNT
1855 * Return: The count of frame assembly errors.
1856 */
1857static u64 igc_ethtool_get_frame_ass_error(u32 reg_value)
1858{
1859	/* Out of order statistics */
1860	u32 ooo_frame_cnt, ooo_frag_cnt;
1861	u32 miss_frame_frag_cnt;
1862
1863	ooo_frame_cnt = FIELD_GET(IGC_PRMEXCPRCNT_OOO_FRAME_CNT, reg_value);
1864	ooo_frag_cnt = FIELD_GET(IGC_PRMEXCPRCNT_OOO_FRAG_CNT, reg_value);
1865	miss_frame_frag_cnt = FIELD_GET(IGC_PRMEXCPRCNT_MISS_FRAME_FRAG_CNT,
1866					reg_value);
1867
1868	return ooo_frame_cnt + ooo_frag_cnt + miss_frame_frag_cnt;
1869}
1870
1871static u64 igc_ethtool_get_frame_smd_error(u32 reg_value)
1872{
1873	return FIELD_GET(IGC_PRMEXCPRCNT_OOO_SMDC, reg_value);
1874}
1875
1876static void igc_ethtool_get_mm_stats(struct net_device *dev,
1877				     struct ethtool_mm_stats *stats)
1878{
1879	struct igc_adapter *adapter = netdev_priv(dev);
1880	struct igc_hw *hw = &adapter->hw;
1881	u32 reg_value;
1882
1883	reg_value = rd32(IGC_PRMEXCPRCNT);
1884
1885	stats->MACMergeFrameAssErrorCount = igc_ethtool_get_frame_ass_error(reg_value);
1886	stats->MACMergeFrameSmdErrorCount = igc_ethtool_get_frame_smd_error(reg_value);
1887	stats->MACMergeFrameAssOkCount = rd32(IGC_PRMPTDRCNT);
1888	stats->MACMergeFragCountRx = rd32(IGC_PRMEVNTRCNT);
1889	stats->MACMergeFragCountTx = rd32(IGC_PRMEVNTTCNT);
1890}
1891
1892static int igc_ethtool_get_link_ksettings(struct net_device *netdev,
1893					  struct ethtool_link_ksettings *cmd)
1894{
1895	struct igc_adapter *adapter = netdev_priv(netdev);
1896	struct igc_hw *hw = &adapter->hw;
1897	u32 status;
1898	u32 speed;
1899
1900	ethtool_link_ksettings_zero_link_mode(cmd, supported);
1901	ethtool_link_ksettings_zero_link_mode(cmd, advertising);
1902
1903	/* supported link modes */
1904	ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
1905	ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full);
1906	ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half);
1907	ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full);
1908	ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full);
1909	ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full);
1910
1911	/* twisted pair */
1912	cmd->base.port = PORT_TP;
1913	cmd->base.phy_address = hw->phy.addr;
1914	ethtool_link_ksettings_add_link_mode(cmd, supported, TP);
1915	ethtool_link_ksettings_add_link_mode(cmd, advertising, TP);
1916
1917	/* advertising link modes */
1918	if (hw->phy.autoneg_advertised & ADVERTISE_10_HALF)
1919		ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half);
1920	if (hw->phy.autoneg_advertised & ADVERTISE_10_FULL)
1921		ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full);
1922	if (hw->phy.autoneg_advertised & ADVERTISE_100_HALF)
1923		ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half);
1924	if (hw->phy.autoneg_advertised & ADVERTISE_100_FULL)
1925		ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full);
1926	if (hw->phy.autoneg_advertised & ADVERTISE_1000_FULL)
1927		ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full);
1928	if (hw->phy.autoneg_advertised & ADVERTISE_2500_FULL)
1929		ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full);
1930
1931	/* set autoneg settings */
1932	ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg);
1933	ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg);
1934
1935	/* Set pause flow control settings */
1936	ethtool_link_ksettings_add_link_mode(cmd, supported, Pause);
1937
1938	switch (hw->fc.requested_mode) {
1939	case igc_fc_full:
1940		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1941		break;
1942	case igc_fc_rx_pause:
1943		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1944		ethtool_link_ksettings_add_link_mode(cmd, advertising,
1945						     Asym_Pause);
1946		break;
1947	case igc_fc_tx_pause:
1948		ethtool_link_ksettings_add_link_mode(cmd, advertising,
1949						     Asym_Pause);
1950		break;
1951	default:
1952		break;
1953	}
1954
1955	status = pm_runtime_suspended(&adapter->pdev->dev) ?
1956		 0 : rd32(IGC_STATUS);
1957
1958	if (status & IGC_STATUS_LU) {
1959		if (status & IGC_STATUS_SPEED_1000) {
1960			/* For I225, STATUS will indicate 1G speed in both
1961			 * 1 Gbps and 2.5 Gbps link modes.
1962			 * An additional bit is used
1963			 * to differentiate between 1 Gbps and 2.5 Gbps.
1964			 */
1965			if (hw->mac.type == igc_i225 &&
1966			    (status & IGC_STATUS_SPEED_2500)) {
1967				speed = SPEED_2500;
1968			} else {
1969				speed = SPEED_1000;
1970			}
1971		} else if (status & IGC_STATUS_SPEED_100) {
1972			speed = SPEED_100;
1973		} else {
1974			speed = SPEED_10;
1975		}
1976		if ((status & IGC_STATUS_FD) ||
1977		    hw->phy.media_type != igc_media_type_copper)
1978			cmd->base.duplex = DUPLEX_FULL;
1979		else
1980			cmd->base.duplex = DUPLEX_HALF;
1981	} else {
1982		speed = SPEED_UNKNOWN;
1983		cmd->base.duplex = DUPLEX_UNKNOWN;
1984	}
1985	cmd->base.speed = speed;
1986	cmd->base.autoneg = AUTONEG_ENABLE;
1987
1988	/* MDI-X => 2; MDI =>1; Invalid =>0 */
1989	if (hw->phy.media_type == igc_media_type_copper)
1990		cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X :
1991						      ETH_TP_MDI;
1992	else
1993		cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
1994
1995	if (hw->phy.mdix == AUTO_ALL_MODES)
1996		cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
1997	else
1998		cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;
1999
2000	return 0;
2001}
2002
2003static int
2004igc_ethtool_set_link_ksettings(struct net_device *netdev,
2005			       const struct ethtool_link_ksettings *cmd)
2006{
2007	struct igc_adapter *adapter = netdev_priv(netdev);
2008	struct net_device *dev = adapter->netdev;
2009	struct igc_hw *hw = &adapter->hw;
2010	u16 advertised = 0;
2011
2012	/* When adapter in resetting mode, autoneg/speed/duplex
2013	 * cannot be changed
2014	 */
2015	if (igc_check_reset_block(hw)) {
2016		netdev_err(dev, "Cannot change link characteristics when reset is active\n");
2017		return -EINVAL;
2018	}
2019
2020	/* MDI setting is only allowed when autoneg enabled because
2021	 * some hardware doesn't allow MDI setting when speed or
2022	 * duplex is forced.
2023	 */
2024	if (cmd->base.eth_tp_mdix_ctrl) {
2025		if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO &&
2026		    cmd->base.autoneg != AUTONEG_ENABLE) {
2027			netdev_err(dev, "Forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
2028			return -EINVAL;
2029		}
2030	}
2031
2032	while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
2033		usleep_range(1000, 2000);
2034
2035	if (ethtool_link_ksettings_test_link_mode(cmd, advertising,
2036						  2500baseT_Full))
2037		advertised |= ADVERTISE_2500_FULL;
2038
2039	if (ethtool_link_ksettings_test_link_mode(cmd, advertising,
2040						  1000baseT_Full))
2041		advertised |= ADVERTISE_1000_FULL;
2042
2043	if (ethtool_link_ksettings_test_link_mode(cmd, advertising,
2044						  100baseT_Full))
2045		advertised |= ADVERTISE_100_FULL;
2046
2047	if (ethtool_link_ksettings_test_link_mode(cmd, advertising,
2048						  100baseT_Half))
2049		advertised |= ADVERTISE_100_HALF;
2050
2051	if (ethtool_link_ksettings_test_link_mode(cmd, advertising,
2052						  10baseT_Full))
2053		advertised |= ADVERTISE_10_FULL;
2054
2055	if (ethtool_link_ksettings_test_link_mode(cmd, advertising,
2056						  10baseT_Half))
2057		advertised |= ADVERTISE_10_HALF;
2058
2059	if (cmd->base.autoneg == AUTONEG_ENABLE) {
2060		hw->phy.autoneg_advertised = advertised;
2061		if (adapter->fc_autoneg)
2062			hw->fc.requested_mode = igc_fc_default;
2063	} else {
2064		netdev_info(dev, "Force mode currently not supported\n");
2065	}
2066
2067	/* MDI-X => 2; MDI => 1; Auto => 3 */
2068	if (cmd->base.eth_tp_mdix_ctrl) {
2069		/* fix up the value for auto (3 => 0) as zero is mapped
2070		 * internally to auto
2071		 */
2072		if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
2073			hw->phy.mdix = AUTO_ALL_MODES;
2074		else
2075			hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
2076	}
2077
2078	/* reset the link */
2079	if (netif_running(adapter->netdev)) {
2080		igc_down(adapter);
2081		igc_up(adapter);
2082	} else {
2083		igc_reset(adapter);
2084	}
2085
2086	clear_bit(__IGC_RESETTING, &adapter->state);
2087
2088	return 0;
2089}
2090
2091static void igc_ethtool_diag_test(struct net_device *netdev,
2092				  struct ethtool_test *eth_test, u64 *data)
2093{
2094	struct igc_adapter *adapter = netdev_priv(netdev);
2095	bool if_running = netif_running(netdev);
2096
2097	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
2098		netdev_info(adapter->netdev, "Offline testing starting");
2099		set_bit(__IGC_TESTING, &adapter->state);
2100
2101		/* power up PHY for link test */
2102		igc_power_up_phy_copper(&adapter->hw);
2103
2104		/* Link test performed before hardware reset so autoneg doesn't
2105		 * interfere with test result
2106		 */
2107		if (!igc_link_test(adapter, &data[TEST_LINK]))
2108			eth_test->flags |= ETH_TEST_FL_FAILED;
2109
2110		if (if_running)
2111			igc_close(netdev);
2112		else
2113			igc_reset(adapter);
2114
2115		netdev_info(adapter->netdev, "Register testing starting");
2116		if (!igc_reg_test(adapter, &data[TEST_REG]))
2117			eth_test->flags |= ETH_TEST_FL_FAILED;
2118
2119		igc_reset(adapter);
2120
2121		netdev_info(adapter->netdev, "EEPROM testing starting");
2122		if (!igc_eeprom_test(adapter, &data[TEST_EEP]))
2123			eth_test->flags |= ETH_TEST_FL_FAILED;
2124
2125		igc_reset(adapter);
2126
2127		/* loopback and interrupt tests
2128		 * will be implemented in the future
2129		 */
2130		data[TEST_LOOP] = 0;
2131		data[TEST_IRQ] = 0;
2132
2133		clear_bit(__IGC_TESTING, &adapter->state);
2134		if (if_running)
2135			igc_open(netdev);
2136	} else {
2137		netdev_info(adapter->netdev, "Online testing starting");
2138
2139		/* register, eeprom, intr and loopback tests not run online */
2140		data[TEST_REG] = 0;
2141		data[TEST_EEP] = 0;
2142		data[TEST_IRQ] = 0;
2143		data[TEST_LOOP] = 0;
2144
2145		if (!igc_link_test(adapter, &data[TEST_LINK]))
2146			eth_test->flags |= ETH_TEST_FL_FAILED;
2147	}
2148
2149	msleep_interruptible(4 * 1000);
2150}
2151
2152static const struct ethtool_ops igc_ethtool_ops = {
2153	.supported_coalesce_params = ETHTOOL_COALESCE_USECS,
2154	.get_drvinfo		= igc_ethtool_get_drvinfo,
2155	.get_regs_len		= igc_ethtool_get_regs_len,
2156	.get_regs		= igc_ethtool_get_regs,
2157	.get_wol		= igc_ethtool_get_wol,
2158	.set_wol		= igc_ethtool_set_wol,
2159	.get_msglevel		= igc_ethtool_get_msglevel,
2160	.set_msglevel		= igc_ethtool_set_msglevel,
2161	.nway_reset		= igc_ethtool_nway_reset,
2162	.get_link		= igc_ethtool_get_link,
2163	.get_eeprom_len		= igc_ethtool_get_eeprom_len,
2164	.get_eeprom		= igc_ethtool_get_eeprom,
2165	.set_eeprom		= igc_ethtool_set_eeprom,
2166	.get_ringparam		= igc_ethtool_get_ringparam,
2167	.set_ringparam		= igc_ethtool_set_ringparam,
2168	.get_pauseparam		= igc_ethtool_get_pauseparam,
2169	.set_pauseparam		= igc_ethtool_set_pauseparam,
2170	.get_strings		= igc_ethtool_get_strings,
2171	.get_sset_count		= igc_ethtool_get_sset_count,
2172	.get_ethtool_stats	= igc_ethtool_get_stats,
2173	.get_coalesce		= igc_ethtool_get_coalesce,
2174	.set_coalesce		= igc_ethtool_set_coalesce,
2175	.get_rxnfc		= igc_ethtool_get_rxnfc,
2176	.set_rxnfc		= igc_ethtool_set_rxnfc,
2177	.get_rx_ring_count	= igc_ethtool_get_rx_ring_count,
2178	.get_rxfh_indir_size	= igc_ethtool_get_rxfh_indir_size,
2179	.get_rxfh		= igc_ethtool_get_rxfh,
2180	.set_rxfh		= igc_ethtool_set_rxfh,
2181	.get_rxfh_fields	= igc_ethtool_get_rxfh_fields,
2182	.set_rxfh_fields	= igc_ethtool_set_rxfh_fields,
2183	.get_ts_info		= igc_ethtool_get_ts_info,
2184	.get_channels		= igc_ethtool_get_channels,
2185	.set_channels		= igc_ethtool_set_channels,
2186	.get_priv_flags		= igc_ethtool_get_priv_flags,
2187	.set_priv_flags		= igc_ethtool_set_priv_flags,
2188	.get_eee		= igc_ethtool_get_eee,
2189	.set_eee		= igc_ethtool_set_eee,
2190	.get_link_ksettings	= igc_ethtool_get_link_ksettings,
2191	.set_link_ksettings	= igc_ethtool_set_link_ksettings,
2192	.self_test		= igc_ethtool_diag_test,
2193	.get_mm			= igc_ethtool_get_mm,
2194	.get_mm_stats		= igc_ethtool_get_mm_stats,
2195	.set_mm			= igc_ethtool_set_mm,
2196};
2197
2198void igc_ethtool_set_ops(struct net_device *netdev)
2199{
2200	netdev->ethtool_ops = &igc_ethtool_ops;
2201}