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 */
14	struct 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
26	static 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
80	static 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
92	enum igc_diagnostics_results {
93	TEST_REG = 0,
94	TEST_EEP,
95	TEST_IRQ,
96	TEST_LOOP,
97	TEST_LINK
98	};
99
100	static 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)
127	static 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
134	static void igc_ethtool_get_drvinfo(struct net_device *netdev,
135	struct ethtool_drvinfo *drvinfo)
136	{
137	struct igc_adapter *adapter = netdev_priv(dev: 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(buf: adapter->fw_version,
151	size: sizeof(adapter->fw_version),
152	fmt: "%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
165	static int igc_ethtool_get_regs_len(struct net_device *netdev)
166	{
167	return IGC_REGS_LEN * sizeof(u32);
168	}
169
170	static void igc_ethtool_get_regs(struct net_device *netdev,
171	struct ethtool_regs *regs, void *p)
172	{
173	struct igc_adapter *adapter = netdev_priv(dev: 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
352	static void igc_ethtool_get_wol(struct net_device *netdev,
353	struct ethtool_wolinfo *wol)
354	{
355	struct igc_adapter *adapter = netdev_priv(dev: 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
384	static int igc_ethtool_set_wol(struct net_device *netdev,
385	struct ethtool_wolinfo *wol)
386	{
387	struct igc_adapter *adapter = netdev_priv(dev: 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(dev: &adapter->pdev->dev, enable: adapter->wol);
409
410	return 0;
411	}
412
413	static u32 igc_ethtool_get_msglevel(struct net_device *netdev)
414	{
415	struct igc_adapter *adapter = netdev_priv(dev: netdev);
416
417	return adapter->msg_enable;
418	}
419
420	static void igc_ethtool_set_msglevel(struct net_device *netdev, u32 data)
421	{
422	struct igc_adapter *adapter = netdev_priv(dev: netdev);
423
424	adapter->msg_enable = data;
425	}
426
427	static int igc_ethtool_nway_reset(struct net_device *netdev)
428	{
429	struct igc_adapter *adapter = netdev_priv(dev: netdev);
430
431	if (netif_running(dev: netdev))
432	igc_reinit_locked(adapter);
433	return 0;
434	}
435
436	static u32 igc_ethtool_get_link(struct net_device *netdev)
437	{
438	struct igc_adapter *adapter = netdev_priv(dev: 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(dev: netdev))
448	mac->get_link_status = 1;
449
450	return igc_has_link(adapter);
451	}
452
453	static int igc_ethtool_get_eeprom_len(struct net_device *netdev)
454	{
455	struct igc_adapter *adapter = netdev_priv(dev: netdev);
456
457	return adapter->hw.nvm.word_size * 2;
458	}
459
460	static int igc_ethtool_get_eeprom(struct net_device *netdev,
461	struct ethtool_eeprom *eeprom, u8 *bytes)
462	{
463	struct igc_adapter *adapter = netdev_priv(dev: 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(objp: eeprom_buff);
503
504	return ret_val;
505	}
506
507	static int igc_ethtool_set_eeprom(struct net_device *netdev,
508	struct ethtool_eeprom *eeprom, u8 *bytes)
509	{
510	struct igc_adapter *adapter = netdev_priv(dev: 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(objp: eeprom_buff);
571	return ret_val;
572	}
573
574	static void
575	igc_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(dev: 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
588	static int
589	igc_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(dev: 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(nr: __IGC_RESETTING, addr: &adapter->state))
617	usleep_range(min: 1000, max: 2000);
618
619	if (!netif_running(dev: 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(ring: &temp_ring[i]);
654	if (err) {
655	while (i) {
656	i--;
657	igc_free_tx_resources(ring: &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(ring: 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(ring: &temp_ring[i]);
680	if (err) {
681	while (i) {
682	i--;
683	igc_free_rx_resources(ring: &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(ring: 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	}
698	err_setup:
699	igc_up(adapter);
700	vfree(addr: temp_ring);
701	clear_reset:
702	clear_bit(nr: __IGC_RESETTING, addr: &adapter->state);
703	return err;
704	}
705
706	static void igc_ethtool_get_pauseparam(struct net_device *netdev,
707	struct ethtool_pauseparam *pause)
708	{
709	struct igc_adapter *adapter = netdev_priv(dev: 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
725	static int igc_ethtool_set_pauseparam(struct net_device *netdev,
726	struct ethtool_pauseparam *pause)
727	{
728	struct igc_adapter *adapter = netdev_priv(dev: 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(nr: __IGC_RESETTING, addr: &adapter->state))
735	usleep_range(min: 1000, max: 2000);
736
737	if (adapter->fc_autoneg == AUTONEG_ENABLE) {
738	hw->fc.requested_mode = igc_fc_default;
739	if (netif_running(dev: 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(nr: __IGC_RESETTING, addr: &adapter->state);
762	return retval;
763	}
764
765	static void igc_ethtool_get_strings(struct net_device *netdev, u32 stringset,
766	u8 *data)
767	{
768	struct igc_adapter *adapter = netdev_priv(dev: 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(data: &p, str: igc_gstrings_stats[i].stat_string);
780	for (i = 0; i < IGC_NETDEV_STATS_LEN; i++)
781	ethtool_puts(data: &p, str: igc_gstrings_net_stats[i].stat_string);
782	for (i = 0; i < adapter->num_tx_queues; i++) {
783	ethtool_sprintf(data: &p, fmt: "tx_queue_%u_packets", i);
784	ethtool_sprintf(data: &p, fmt: "tx_queue_%u_bytes", i);
785	ethtool_sprintf(data: &p, fmt: "tx_queue_%u_restart", i);
786	}
787	for (i = 0; i < adapter->num_rx_queues; i++) {
788	ethtool_sprintf(data: &p, fmt: "rx_queue_%u_packets", i);
789	ethtool_sprintf(data: &p, fmt: "rx_queue_%u_bytes", i);
790	ethtool_sprintf(data: &p, fmt: "rx_queue_%u_drops", i);
791	ethtool_sprintf(data: &p, fmt: "rx_queue_%u_csum_err", i);
792	ethtool_sprintf(data: &p, fmt: "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
803	static 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
817	static void igc_ethtool_get_stats(struct net_device *netdev,
818	struct ethtool_stats *stats, u64 *data)
819	{
820	struct igc_adapter *adapter = netdev_priv(dev: 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(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(syncp: &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(syncp: &ring->tx_syncp, start));
850	do {
851	start = u64_stats_fetch_begin(syncp: &ring->tx_syncp2);
852	restart2 = ring->tx_stats.restart_queue2;
853	} while (u64_stats_fetch_retry(syncp: &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(syncp: &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(syncp: &ring->rx_syncp, start));
868	i += IGC_RX_QUEUE_STATS_LEN;
869	}
870	spin_unlock(lock: &adapter->stats64_lock);
871	}
872
873	static 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
879	static 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
885	static 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(dev: 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
898	static 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(dev: 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)
963	static 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, location: 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(dst: fsp->h_u.ether_spec.h_dest,
999	src: rule->filter.dst_addr);
1000	eth_broadcast_addr(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(dst: fsp->h_u.ether_spec.h_source,
1005	src: rule->filter.src_addr);
1006	eth_broadcast_addr(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(lock: &adapter->nfc_rule_lock);
1016	return 0;
1017
1018	out:
1019	mutex_unlock(lock: &adapter->nfc_rule_lock);
1020	return -EINVAL;
1021	}
1022
1023	static 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(lock: &adapter->nfc_rule_lock);
1037	return -EMSGSIZE;
1038	}
1039	rule_locs[cnt] = rule->location;
1040	cnt++;
1041	}
1042
1043	mutex_unlock(lock: &adapter->nfc_rule_lock);
1044
1045	cmd->rule_cnt = cnt;
1046
1047	return 0;
1048	}
1049
1050	static 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
1094	static 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
1101	static 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)
1121	static 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(dev: adapter->netdev,
1200	format: "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
1225	static void igc_ethtool_init_nfc_rule(struct igc_nfc_rule *rule,
1226	const struct ethtool_rx_flow_spec *fsp)
1227	{
1228	INIT_LIST_HEAD(list: &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(addr: fsp->m_u.ether_spec.h_source)) {
1248	rule->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR;
1249	ether_addr_copy(dst: rule->filter.src_addr,
1250	src: fsp->h_u.ether_spec.h_source);
1251	}
1252
1253	if (is_broadcast_ether_addr(addr: fsp->m_u.ether_spec.h_dest)) {
1254	rule->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR;
1255	ether_addr_copy(dst: rule->filter.dst_addr,
1256	src: 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(addr: fsp->m_u.ether_spec.h_source) &&
1305	is_zero_ether_addr(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	*/
1325	static 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(p: &rule->filter, q: &tmp->filter,
1339	size: 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
1349	static 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, location: fsp->location);
1411	if (old_rule)
1412	igc_del_nfc_rule(adapter, rule: old_rule);
1413
1414	err = igc_add_nfc_rule(adapter, rule);
1415	if (err)
1416	goto err;
1417
1418	mutex_unlock(lock: &adapter->nfc_rule_lock);
1419	return 0;
1420
1421	err:
1422	mutex_unlock(lock: &adapter->nfc_rule_lock);
1423	kfree(objp: rule);
1424	return err;
1425	}
1426
1427	static 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, location: fsp->location);
1437	if (!rule) {
1438	mutex_unlock(lock: &adapter->nfc_rule_lock);
1439	return -EINVAL;
1440	}
1441
1442	igc_del_nfc_rule(adapter, rule);
1443
1444	mutex_unlock(lock: &adapter->nfc_rule_lock);
1445	return 0;
1446	}
1447
1448	static 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
1463	void 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
1485	static u32 igc_ethtool_get_rxfh_indir_size(struct net_device *netdev)
1486	{
1487	return IGC_RETA_SIZE;
1488	}
1489
1490	static int igc_ethtool_get_rxfh(struct net_device *netdev,
1491	struct ethtool_rxfh_param *rxfh)
1492	{
1493	struct igc_adapter *adapter = netdev_priv(dev: 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
1505	static 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(dev: 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
1536	static void igc_ethtool_get_channels(struct net_device *netdev,
1537	struct ethtool_channels *ch)
1538	{
1539	struct igc_adapter *adapter = netdev_priv(dev: 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
1553	static int igc_ethtool_set_channels(struct net_device *netdev,
1554	struct ethtool_channels *ch)
1555	{
1556	struct igc_adapter *adapter = netdev_priv(dev: 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_rss_queues: 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
1590	static 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(ptp: 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
1619	static u32 igc_ethtool_get_priv_flags(struct net_device *netdev)
1620	{
1621	struct igc_adapter *adapter = netdev_priv(dev: 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
1633	static int igc_ethtool_set_priv_flags(struct net_device *netdev, u32 priv_flags)
1634	{
1635	struct igc_adapter *adapter = netdev_priv(dev: 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(dev: netdev))
1650	igc_reinit_locked(adapter);
1651	}
1652
1653	return 0;
1654	}
1655
1656	static int igc_ethtool_get_eee(struct net_device *netdev,
1657	struct ethtool_keee *edata)
1658	{
1659	struct igc_adapter *adapter = netdev_priv(dev: 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(dev: adapter->netdev,
1680	format: "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(dev: adapter->netdev,
1699	format: "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(dev: adapter->netdev,
1714	format: "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(dev: adapter->netdev,
1733	format: "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(dst: edata->advertised);
1760	}
1761
1762	return 0;
1763	}
1764
1765	static int igc_ethtool_set_eee(struct net_device *netdev,
1766	struct ethtool_keee *edata)
1767	{
1768	struct igc_adapter *adapter = netdev_priv(dev: 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, edata: &eee_curr);
1776	if (ret_val) {
1777	netdev_err(dev: netdev,
1778	format: "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(dev: netdev,
1785	format: "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(dev: netdev,
1792	format: "Setting EEE Tx LPI timer is not supported\n");
1793	return -EINVAL;
1794	}
1795	} else if (!edata->eee_enabled) {
1796	netdev_err(dev: netdev,
1797	format: "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(dev: netdev))
1807	igc_reinit_locked(adapter);
1808	else
1809	igc_reset(adapter);
1810	}
1811
1812	return 0;
1813	}
1814
1815	static int igc_ethtool_get_mm(struct net_device *netdev,
1816	struct ethtool_mm_state *cmd)
1817	{
1818	struct igc_adapter *adapter = netdev_priv(dev: netdev);
1819	struct igc_fpe_t *fpe = &adapter->fpe;
1820
1821	ethtool_mmsv_get_mm(mmsv: &fpe->mmsv, state: 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
1828	static 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(dev: netdev);
1833	struct igc_fpe_t *fpe = &adapter->fpe;
1834
1835	fpe->tx_min_frag_size = igc_fpe_get_supported_frag_size(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(mmsv: &fpe->mmsv, cfg: 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	*/
1857	static 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
1871	static u64 igc_ethtool_get_frame_smd_error(u32 reg_value)
1872	{
1873	return FIELD_GET(IGC_PRMEXCPRCNT_OOO_SMDC, reg_value);
1874	}
1875
1876	static 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
1892	static int igc_ethtool_get_link_ksettings(struct net_device *netdev,
1893	struct ethtool_link_ksettings *cmd)
1894	{
1895	struct igc_adapter *adapter = netdev_priv(dev: 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(dev: &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
2003	static int
2004	igc_ethtool_set_link_ksettings(struct net_device *netdev,
2005	const struct ethtool_link_ksettings *cmd)
2006	{
2007	struct igc_adapter *adapter = netdev_priv(dev: 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, format: "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, format: "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(nr: __IGC_RESETTING, addr: &adapter->state))
2033	usleep_range(min: 1000, max: 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, format: "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(dev: adapter->netdev)) {
2080	igc_down(adapter);
2081	igc_up(adapter);
2082	} else {
2083	igc_reset(adapter);
2084	}
2085
2086	clear_bit(nr: __IGC_RESETTING, addr: &adapter->state);
2087
2088	return 0;
2089	}
2090
2091	static 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(dev: netdev);
2095	bool if_running = netif_running(dev: netdev);
2096
2097	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
2098	netdev_info(dev: adapter->netdev, format: "Offline testing starting");
2099	set_bit(nr: __IGC_TESTING, addr: &adapter->state);
2100
2101	/* power up PHY for link test */
2102	igc_power_up_phy_copper(hw: &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: &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(dev: adapter->netdev, format: "Register testing starting");
2116	if (!igc_reg_test(adapter, data: &data[TEST_REG]))
2117	eth_test->flags |= ETH_TEST_FL_FAILED;
2118
2119	igc_reset(adapter);
2120
2121	netdev_info(dev: adapter->netdev, format: "EEPROM testing starting");
2122	if (!igc_eeprom_test(adapter, data: &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(nr: __IGC_TESTING, addr: &adapter->state);
2134	if (if_running)
2135	igc_open(netdev);
2136	} else {
2137	netdev_info(dev: adapter->netdev, format: "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: &data[TEST_LINK]))
2146	eth_test->flags |= ETH_TEST_FL_FAILED;
2147	}
2148
2149	msleep_interruptible(msecs: 4 * 1000);
2150	}
2151
2152	static 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
2198	void igc_ethtool_set_ops(struct net_device *netdev)
2199	{
2200	netdev->ethtool_ops = &igc_ethtool_ops;
2201	}
2202