1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright(c) 1999 - 2018 Intel Corporation. */
3
4	/* ethtool support for e1000 */
5
6	#include <linux/netdevice.h>
7	#include <linux/interrupt.h>
8	#include <linux/ethtool.h>
9	#include <linux/pci.h>
10	#include <linux/slab.h>
11	#include <linux/delay.h>
12	#include <linux/vmalloc.h>
13	#include <linux/pm_runtime.h>
14
15	#include "e1000.h"
16
17	enum { NETDEV_STATS, E1000_STATS };
18
19	struct e1000_stats {
20	char stat_string[ETH_GSTRING_LEN];
21	int type;
22	int sizeof_stat;
23	int stat_offset;
24	};
25
26	static const char e1000e_priv_flags_strings[][ETH_GSTRING_LEN] = {
27	#define E1000E_PRIV_FLAGS_S0IX_ENABLED BIT(0)
28	"s0ix-enabled",
29	};
30
31	#define E1000E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(e1000e_priv_flags_strings)
32
33	#define E1000_STAT(str, m) { \
34	.stat_string = str, \
35	.type = E1000_STATS, \
36	.sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
37	.stat_offset = offsetof(struct e1000_adapter, m) }
38	#define E1000_NETDEV_STAT(str, m) { \
39	.stat_string = str, \
40	.type = NETDEV_STATS, \
41	.sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \
42	.stat_offset = offsetof(struct rtnl_link_stats64, m) }
43
44	static const struct e1000_stats e1000_gstrings_stats[] = {
45	E1000_STAT("rx_packets", stats.gprc),
46	E1000_STAT("tx_packets", stats.gptc),
47	E1000_STAT("rx_bytes", stats.gorc),
48	E1000_STAT("tx_bytes", stats.gotc),
49	E1000_STAT("rx_broadcast", stats.bprc),
50	E1000_STAT("tx_broadcast", stats.bptc),
51	E1000_STAT("rx_multicast", stats.mprc),
52	E1000_STAT("tx_multicast", stats.mptc),
53	E1000_NETDEV_STAT("rx_errors", rx_errors),
54	E1000_NETDEV_STAT("tx_errors", tx_errors),
55	E1000_NETDEV_STAT("tx_dropped", tx_dropped),
56	E1000_STAT("multicast", stats.mprc),
57	E1000_STAT("collisions", stats.colc),
58	E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),
59	E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),
60	E1000_STAT("rx_crc_errors", stats.crcerrs),
61	E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),
62	E1000_STAT("rx_no_buffer_count", stats.rnbc),
63	E1000_STAT("rx_missed_errors", stats.mpc),
64	E1000_STAT("tx_aborted_errors", stats.ecol),
65	E1000_STAT("tx_carrier_errors", stats.tncrs),
66	E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),
67	E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),
68	E1000_STAT("tx_window_errors", stats.latecol),
69	E1000_STAT("tx_abort_late_coll", stats.latecol),
70	E1000_STAT("tx_deferred_ok", stats.dc),
71	E1000_STAT("tx_single_coll_ok", stats.scc),
72	E1000_STAT("tx_multi_coll_ok", stats.mcc),
73	E1000_STAT("tx_timeout_count", tx_timeout_count),
74	E1000_STAT("tx_restart_queue", restart_queue),
75	E1000_STAT("rx_long_length_errors", stats.roc),
76	E1000_STAT("rx_short_length_errors", stats.ruc),
77	E1000_STAT("rx_align_errors", stats.algnerrc),
78	E1000_STAT("tx_tcp_seg_good", stats.tsctc),
79	E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),
80	E1000_STAT("rx_flow_control_xon", stats.xonrxc),
81	E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),
82	E1000_STAT("tx_flow_control_xon", stats.xontxc),
83	E1000_STAT("tx_flow_control_xoff", stats.xofftxc),
84	E1000_STAT("rx_csum_offload_good", hw_csum_good),
85	E1000_STAT("rx_csum_offload_errors", hw_csum_err),
86	E1000_STAT("rx_header_split", rx_hdr_split),
87	E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),
88	E1000_STAT("tx_smbus", stats.mgptc),
89	E1000_STAT("rx_smbus", stats.mgprc),
90	E1000_STAT("dropped_smbus", stats.mgpdc),
91	E1000_STAT("rx_dma_failed", rx_dma_failed),
92	E1000_STAT("tx_dma_failed", tx_dma_failed),
93	E1000_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
94	E1000_STAT("uncorr_ecc_errors", uncorr_errors),
95	E1000_STAT("corr_ecc_errors", corr_errors),
96	E1000_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
97	E1000_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),
98	};
99
100	#define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)
101	#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)
102	static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
103	"Register test (offline)", "Eeprom test (offline)",
104	"Interrupt test (offline)", "Loopback test (offline)",
105	"Link test (on/offline)"
106	};
107
108	#define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)
109
110	static int e1000_get_link_ksettings(struct net_device *netdev,
111	struct ethtool_link_ksettings *cmd)
112	{
113	u32 speed, supported, advertising, lp_advertising, lpa_t;
114	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
115	struct e1000_hw *hw = &adapter->hw;
116
117	if (hw->phy.media_type == e1000_media_type_copper) {
118	supported = (SUPPORTED_10baseT_Half |
119	SUPPORTED_10baseT_Full |
120	SUPPORTED_100baseT_Half |
121	SUPPORTED_100baseT_Full |
122	SUPPORTED_1000baseT_Full |
123	SUPPORTED_Asym_Pause |
124	SUPPORTED_Autoneg |
125	SUPPORTED_Pause |
126	SUPPORTED_TP);
127	if (hw->phy.type == e1000_phy_ife)
128	supported &= ~SUPPORTED_1000baseT_Full;
129	advertising = ADVERTISED_TP;
130
131	if (hw->mac.autoneg == 1) {
132	advertising |= ADVERTISED_Autoneg;
133	/* the e1000 autoneg seems to match ethtool nicely */
134	advertising |= hw->phy.autoneg_advertised;
135	}
136
137	cmd->base.port = PORT_TP;
138	cmd->base.phy_address = hw->phy.addr;
139	} else {
140	supported = (SUPPORTED_1000baseT_Full |
141	SUPPORTED_FIBRE |
142	SUPPORTED_Autoneg);
143
144	advertising = (ADVERTISED_1000baseT_Full |
145	ADVERTISED_FIBRE |
146	ADVERTISED_Autoneg);
147
148	cmd->base.port = PORT_FIBRE;
149	}
150
151	speed = SPEED_UNKNOWN;
152	cmd->base.duplex = DUPLEX_UNKNOWN;
153
154	if (netif_running(dev: netdev)) {
155	if (netif_carrier_ok(dev: netdev)) {
156	speed = adapter->link_speed;
157	cmd->base.duplex = adapter->link_duplex - 1;
158	}
159	} else if (!pm_runtime_suspended(dev: netdev->dev.parent)) {
160	u32 status = er32(STATUS);
161
162	if (status & E1000_STATUS_LU) {
163	if (status & E1000_STATUS_SPEED_1000)
164	speed = SPEED_1000;
165	else if (status & E1000_STATUS_SPEED_100)
166	speed = SPEED_100;
167	else
168	speed = SPEED_10;
169
170	if (status & E1000_STATUS_FD)
171	cmd->base.duplex = DUPLEX_FULL;
172	else
173	cmd->base.duplex = DUPLEX_HALF;
174	}
175	}
176
177	cmd->base.speed = speed;
178	cmd->base.autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
179	hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
180
181	/* MDI-X => 2; MDI =>1; Invalid =>0 */
182	if ((hw->phy.media_type == e1000_media_type_copper) &&
183	netif_carrier_ok(dev: netdev))
184	cmd->base.eth_tp_mdix = hw->phy.is_mdix ?
185	ETH_TP_MDI_X : ETH_TP_MDI;
186	else
187	cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
188
189	if (hw->phy.mdix == AUTO_ALL_MODES)
190	cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
191	else
192	cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;
193
194	if (hw->phy.media_type != e1000_media_type_copper)
195	cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;
196
197	lpa_t = mii_stat1000_to_ethtool_lpa_t(lpa: adapter->phy_regs.stat1000);
198	lp_advertising = lpa_t |
199	mii_lpa_to_ethtool_lpa_t(lpa: adapter->phy_regs.lpa);
200
201	ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.supported,
202	legacy_u32: supported);
203	ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.advertising,
204	legacy_u32: advertising);
205	ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.lp_advertising,
206	legacy_u32: lp_advertising);
207
208	return 0;
209	}
210
211	static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
212	{
213	struct e1000_mac_info *mac = &adapter->hw.mac;
214
215	mac->autoneg = 0;
216
217	/* Make sure dplx is at most 1 bit and lsb of speed is not set
218	* for the switch() below to work
219	*/
220	if ((spd & 1) || (dplx & ~1))
221	goto err_inval;
222
223	/* Fiber NICs only allow 1000 gbps Full duplex */
224	if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
225	(spd != SPEED_1000) && (dplx != DUPLEX_FULL)) {
226	goto err_inval;
227	}
228
229	switch (spd + dplx) {
230	case SPEED_10 + DUPLEX_HALF:
231	mac->forced_speed_duplex = ADVERTISE_10_HALF;
232	break;
233	case SPEED_10 + DUPLEX_FULL:
234	mac->forced_speed_duplex = ADVERTISE_10_FULL;
235	break;
236	case SPEED_100 + DUPLEX_HALF:
237	mac->forced_speed_duplex = ADVERTISE_100_HALF;
238	break;
239	case SPEED_100 + DUPLEX_FULL:
240	mac->forced_speed_duplex = ADVERTISE_100_FULL;
241	break;
242	case SPEED_1000 + DUPLEX_FULL:
243	if (adapter->hw.phy.media_type == e1000_media_type_copper) {
244	mac->autoneg = 1;
245	adapter->hw.phy.autoneg_advertised =
246	ADVERTISE_1000_FULL;
247	} else {
248	mac->forced_speed_duplex = ADVERTISE_1000_FULL;
249	}
250	break;
251	case SPEED_1000 + DUPLEX_HALF: /* not supported */
252	default:
253	goto err_inval;
254	}
255
256	/* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
257	adapter->hw.phy.mdix = AUTO_ALL_MODES;
258
259	return 0;
260
261	err_inval:
262	e_err("Unsupported Speed/Duplex configuration\n");
263	return -EINVAL;
264	}
265
266	static int e1000_set_link_ksettings(struct net_device *netdev,
267	const struct ethtool_link_ksettings *cmd)
268	{
269	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
270	struct e1000_hw *hw = &adapter->hw;
271	int ret_val = 0;
272	u32 advertising;
273
274	ethtool_convert_link_mode_to_legacy_u32(legacy_u32: &advertising,
275	src: cmd->link_modes.advertising);
276
277	pm_runtime_get_sync(dev: netdev->dev.parent);
278
279	/* When SoL/IDER sessions are active, autoneg/speed/duplex
280	* cannot be changed
281	*/
282	if (hw->phy.ops.check_reset_block &&
283	hw->phy.ops.check_reset_block(hw)) {
284	e_err("Cannot change link characteristics when SoL/IDER is active.\n");
285	ret_val = -EINVAL;
286	goto out;
287	}
288
289	/* MDI setting is only allowed when autoneg enabled because
290	* some hardware doesn't allow MDI setting when speed or
291	* duplex is forced.
292	*/
293	if (cmd->base.eth_tp_mdix_ctrl) {
294	if (hw->phy.media_type != e1000_media_type_copper) {
295	ret_val = -EOPNOTSUPP;
296	goto out;
297	}
298
299	if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
300	(cmd->base.autoneg != AUTONEG_ENABLE)) {
301	e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
302	ret_val = -EINVAL;
303	goto out;
304	}
305	}
306
307	while (test_and_set_bit(nr: __E1000_RESETTING, addr: &adapter->state))
308	usleep_range(min: 1000, max: 2000);
309
310	if (cmd->base.autoneg == AUTONEG_ENABLE) {
311	hw->mac.autoneg = 1;
312	if (hw->phy.media_type == e1000_media_type_fiber)
313	hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
314	ADVERTISED_FIBRE | ADVERTISED_Autoneg;
315	else
316	hw->phy.autoneg_advertised = advertising |
317	ADVERTISED_TP | ADVERTISED_Autoneg;
318	advertising = hw->phy.autoneg_advertised;
319	if (adapter->fc_autoneg)
320	hw->fc.requested_mode = e1000_fc_default;
321	} else {
322	u32 speed = cmd->base.speed;
323	/* calling this overrides forced MDI setting */
324	if (e1000_set_spd_dplx(adapter, spd: speed, dplx: cmd->base.duplex)) {
325	ret_val = -EINVAL;
326	goto out;
327	}
328	}
329
330	/* MDI-X => 2; MDI => 1; Auto => 3 */
331	if (cmd->base.eth_tp_mdix_ctrl) {
332	/* fix up the value for auto (3 => 0) as zero is mapped
333	* internally to auto
334	*/
335	if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
336	hw->phy.mdix = AUTO_ALL_MODES;
337	else
338	hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
339	}
340
341	/* reset the link */
342	if (netif_running(dev: adapter->netdev)) {
343	e1000e_down(adapter, reset: true);
344	e1000e_up(adapter);
345	} else {
346	e1000e_reset(adapter);
347	}
348
349	out:
350	pm_runtime_put_sync(dev: netdev->dev.parent);
351	clear_bit(nr: __E1000_RESETTING, addr: &adapter->state);
352	return ret_val;
353	}
354
355	static void e1000_get_pauseparam(struct net_device *netdev,
356	struct ethtool_pauseparam *pause)
357	{
358	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
359	struct e1000_hw *hw = &adapter->hw;
360
361	pause->autoneg =
362	(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
363
364	if (hw->fc.current_mode == e1000_fc_rx_pause) {
365	pause->rx_pause = 1;
366	} else if (hw->fc.current_mode == e1000_fc_tx_pause) {
367	pause->tx_pause = 1;
368	} else if (hw->fc.current_mode == e1000_fc_full) {
369	pause->rx_pause = 1;
370	pause->tx_pause = 1;
371	}
372	}
373
374	static int e1000_set_pauseparam(struct net_device *netdev,
375	struct ethtool_pauseparam *pause)
376	{
377	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
378	struct e1000_hw *hw = &adapter->hw;
379	int retval = 0;
380
381	adapter->fc_autoneg = pause->autoneg;
382
383	while (test_and_set_bit(nr: __E1000_RESETTING, addr: &adapter->state))
384	usleep_range(min: 1000, max: 2000);
385
386	pm_runtime_get_sync(dev: netdev->dev.parent);
387
388	if (adapter->fc_autoneg == AUTONEG_ENABLE) {
389	hw->fc.requested_mode = e1000_fc_default;
390	if (netif_running(dev: adapter->netdev)) {
391	e1000e_down(adapter, reset: true);
392	e1000e_up(adapter);
393	} else {
394	e1000e_reset(adapter);
395	}
396	} else {
397	if (pause->rx_pause && pause->tx_pause)
398	hw->fc.requested_mode = e1000_fc_full;
399	else if (pause->rx_pause && !pause->tx_pause)
400	hw->fc.requested_mode = e1000_fc_rx_pause;
401	else if (!pause->rx_pause && pause->tx_pause)
402	hw->fc.requested_mode = e1000_fc_tx_pause;
403	else if (!pause->rx_pause && !pause->tx_pause)
404	hw->fc.requested_mode = e1000_fc_none;
405
406	hw->fc.current_mode = hw->fc.requested_mode;
407
408	if (hw->phy.media_type == e1000_media_type_fiber) {
409	retval = hw->mac.ops.setup_link(hw);
410	/* implicit goto out */
411	} else {
412	retval = e1000e_force_mac_fc(hw);
413	if (retval)
414	goto out;
415	e1000e_set_fc_watermarks(hw);
416	}
417	}
418
419	out:
420	pm_runtime_put_sync(dev: netdev->dev.parent);
421	clear_bit(nr: __E1000_RESETTING, addr: &adapter->state);
422	return retval;
423	}
424
425	static u32 e1000_get_msglevel(struct net_device *netdev)
426	{
427	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
428	return adapter->msg_enable;
429	}
430
431	static void e1000_set_msglevel(struct net_device *netdev, u32 data)
432	{
433	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
434	adapter->msg_enable = data;
435	}
436
437	static int e1000_get_regs_len(struct net_device __always_unused *netdev)
438	{
439	#define E1000_REGS_LEN 32 /* overestimate */
440	return E1000_REGS_LEN * sizeof(u32);
441	}
442
443	static void e1000_get_regs(struct net_device *netdev,
444	struct ethtool_regs *regs, void *p)
445	{
446	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
447	struct e1000_hw *hw = &adapter->hw;
448	u32 *regs_buff = p;
449	u16 phy_data;
450
451	pm_runtime_get_sync(dev: netdev->dev.parent);
452
453	memset(p, 0, E1000_REGS_LEN * sizeof(u32));
454
455	regs->version = (1u << 24) |
456	(adapter->pdev->revision << 16) |
457	adapter->pdev->device;
458
459	regs_buff[0] = er32(CTRL);
460	regs_buff[1] = er32(STATUS);
461
462	regs_buff[2] = er32(RCTL);
463	regs_buff[3] = er32(RDLEN(0));
464	regs_buff[4] = er32(RDH(0));
465	regs_buff[5] = er32(RDT(0));
466	regs_buff[6] = er32(RDTR);
467
468	regs_buff[7] = er32(TCTL);
469	regs_buff[8] = er32(TDLEN(0));
470	regs_buff[9] = er32(TDH(0));
471	regs_buff[10] = er32(TDT(0));
472	regs_buff[11] = er32(TIDV);
473
474	regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */
475
476	/* ethtool doesn't use anything past this point, so all this
477	* code is likely legacy junk for apps that may or may not exist
478	*/
479	if (hw->phy.type == e1000_phy_m88) {
480	e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, data: &phy_data);
481	regs_buff[13] = (u32)phy_data; /* cable length */
482	regs_buff[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */
483	regs_buff[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */
484	regs_buff[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */
485	e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, data: &phy_data);
486	regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
487	regs_buff[18] = regs_buff[13]; /* cable polarity */
488	regs_buff[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */
489	regs_buff[20] = regs_buff[17]; /* polarity correction */
490	/* phy receive errors */
491	regs_buff[22] = adapter->phy_stats.receive_errors;
492	regs_buff[23] = regs_buff[13]; /* mdix mode */
493	}
494	regs_buff[21] = 0; /* was idle_errors */
495	e1e_rphy(hw, MII_STAT1000, data: &phy_data);
496	regs_buff[24] = (u32)phy_data; /* phy local receiver status */
497	regs_buff[25] = regs_buff[24]; /* phy remote receiver status */
498
499	pm_runtime_put_sync(dev: netdev->dev.parent);
500	}
501
502	static int e1000_get_eeprom_len(struct net_device *netdev)
503	{
504	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
505	return adapter->hw.nvm.word_size * 2;
506	}
507
508	static int e1000_get_eeprom(struct net_device *netdev,
509	struct ethtool_eeprom *eeprom, u8 *bytes)
510	{
511	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
512	struct e1000_hw *hw = &adapter->hw;
513	u16 *eeprom_buff;
514	int first_word;
515	int last_word;
516	int ret_val = 0;
517	u16 i;
518
519	if (eeprom->len == 0)
520	return -EINVAL;
521
522	eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16);
523
524	first_word = eeprom->offset >> 1;
525	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
526
527	eeprom_buff = kmalloc_array(n: last_word - first_word + 1, size: sizeof(u16),
528	GFP_KERNEL);
529	if (!eeprom_buff)
530	return -ENOMEM;
531
532	pm_runtime_get_sync(dev: netdev->dev.parent);
533
534	if (hw->nvm.type == e1000_nvm_eeprom_spi) {
535	ret_val = e1000_read_nvm(hw, offset: first_word,
536	words: last_word - first_word + 1,
537	data: eeprom_buff);
538	} else {
539	for (i = 0; i < last_word - first_word + 1; i++) {
540	ret_val = e1000_read_nvm(hw, offset: first_word + i, words: 1,
541	data: &eeprom_buff[i]);
542	if (ret_val)
543	break;
544	}
545	}
546
547	pm_runtime_put_sync(dev: netdev->dev.parent);
548
549	if (ret_val) {
550	/* a read error occurred, throw away the result */
551	memset(eeprom_buff, 0xff, sizeof(u16) *
552	(last_word - first_word + 1));
553	} else {
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
559	memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
560	kfree(objp: eeprom_buff);
561
562	return ret_val;
563	}
564
565	static int e1000_set_eeprom(struct net_device *netdev,
566	struct ethtool_eeprom *eeprom, u8 *bytes)
567	{
568	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
569	struct e1000_hw *hw = &adapter->hw;
570	u16 *eeprom_buff;
571	void *ptr;
572	int max_len;
573	int first_word;
574	int last_word;
575	int ret_val = 0;
576	u16 i;
577
578	if (eeprom->len == 0)
579	return -EOPNOTSUPP;
580
581	if (eeprom->magic !=
582	(adapter->pdev->vendor | (adapter->pdev->device << 16)))
583	return -EFAULT;
584
585	if (adapter->flags & FLAG_READ_ONLY_NVM)
586	return -EINVAL;
587
588	max_len = hw->nvm.word_size * 2;
589
590	first_word = eeprom->offset >> 1;
591	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
592	eeprom_buff = kmalloc(size: max_len, GFP_KERNEL);
593	if (!eeprom_buff)
594	return -ENOMEM;
595
596	ptr = (void *)eeprom_buff;
597
598	pm_runtime_get_sync(dev: netdev->dev.parent);
599
600	if (eeprom->offset & 1) {
601	/* need read/modify/write of first changed EEPROM word */
602	/* only the second byte of the word is being modified */
603	ret_val = e1000_read_nvm(hw, offset: first_word, words: 1, data: &eeprom_buff[0]);
604	ptr++;
605	}
606	if (((eeprom->offset + eeprom->len) & 1) && (!ret_val))
607	/* need read/modify/write of last changed EEPROM word */
608	/* only the first byte of the word is being modified */
609	ret_val = e1000_read_nvm(hw, offset: last_word, words: 1,
610	data: &eeprom_buff[last_word - first_word]);
611
612	if (ret_val)
613	goto out;
614
615	/* Device's eeprom is always little-endian, word addressable */
616	for (i = 0; i < last_word - first_word + 1; i++)
617	le16_to_cpus(&eeprom_buff[i]);
618
619	memcpy(ptr, bytes, eeprom->len);
620
621	for (i = 0; i < last_word - first_word + 1; i++)
622	cpu_to_le16s(&eeprom_buff[i]);
623
624	ret_val = e1000_write_nvm(hw, offset: first_word,
625	words: last_word - first_word + 1, data: eeprom_buff);
626
627	if (ret_val)
628	goto out;
629
630	/* Update the checksum over the first part of the EEPROM if needed
631	* and flush shadow RAM for applicable controllers
632	*/
633	if ((first_word <= NVM_CHECKSUM_REG) ||
634	(hw->mac.type == e1000_82583) ||
635	(hw->mac.type == e1000_82574) ||
636	(hw->mac.type == e1000_82573))
637	ret_val = e1000e_update_nvm_checksum(hw);
638
639	out:
640	pm_runtime_put_sync(dev: netdev->dev.parent);
641	kfree(objp: eeprom_buff);
642	return ret_val;
643	}
644
645	static void e1000_get_drvinfo(struct net_device *netdev,
646	struct ethtool_drvinfo *drvinfo)
647	{
648	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
649
650	strscpy(drvinfo->driver, e1000e_driver_name, sizeof(drvinfo->driver));
651
652	/* EEPROM image version # is reported as firmware version # for
653	* PCI-E controllers
654	*/
655	snprintf(buf: drvinfo->fw_version, size: sizeof(drvinfo->fw_version),
656	fmt: "%d.%d-%d",
657	FIELD_GET(0xF000, adapter->eeprom_vers),
658	FIELD_GET(0x0FF0, adapter->eeprom_vers),
659	(adapter->eeprom_vers & 0x000F));
660
661	strscpy(drvinfo->bus_info, pci_name(adapter->pdev),
662	sizeof(drvinfo->bus_info));
663	}
664
665	static void e1000_get_ringparam(struct net_device *netdev,
666	struct ethtool_ringparam *ring,
667	struct kernel_ethtool_ringparam *kernel_ring,
668	struct netlink_ext_ack *extack)
669	{
670	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
671
672	ring->rx_max_pending = E1000_MAX_RXD;
673	ring->tx_max_pending = E1000_MAX_TXD;
674	ring->rx_pending = adapter->rx_ring_count;
675	ring->tx_pending = adapter->tx_ring_count;
676	}
677
678	static int e1000_set_ringparam(struct net_device *netdev,
679	struct ethtool_ringparam *ring,
680	struct kernel_ethtool_ringparam *kernel_ring,
681	struct netlink_ext_ack *extack)
682	{
683	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
684	struct e1000_ring *temp_tx = NULL, *temp_rx = NULL;
685	int err = 0, size = sizeof(struct e1000_ring);
686	bool set_tx = false, set_rx = false;
687	u16 new_rx_count, new_tx_count;
688
689	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
690	return -EINVAL;
691
692	new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD,
693	E1000_MAX_RXD);
694	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
695
696	new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD,
697	E1000_MAX_TXD);
698	new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
699
700	if ((new_tx_count == adapter->tx_ring_count) &&
701	(new_rx_count == adapter->rx_ring_count))
702	/* nothing to do */
703	return 0;
704
705	while (test_and_set_bit(nr: __E1000_RESETTING, addr: &adapter->state))
706	usleep_range(min: 1000, max: 2000);
707
708	if (!netif_running(dev: adapter->netdev)) {
709	/* Set counts now and allocate resources during open() */
710	adapter->tx_ring->count = new_tx_count;
711	adapter->rx_ring->count = new_rx_count;
712	adapter->tx_ring_count = new_tx_count;
713	adapter->rx_ring_count = new_rx_count;
714	goto clear_reset;
715	}
716
717	set_tx = (new_tx_count != adapter->tx_ring_count);
718	set_rx = (new_rx_count != adapter->rx_ring_count);
719
720	/* Allocate temporary storage for ring updates */
721	if (set_tx) {
722	temp_tx = vmalloc(size);
723	if (!temp_tx) {
724	err = -ENOMEM;
725	goto free_temp;
726	}
727	}
728	if (set_rx) {
729	temp_rx = vmalloc(size);
730	if (!temp_rx) {
731	err = -ENOMEM;
732	goto free_temp;
733	}
734	}
735
736	pm_runtime_get_sync(dev: netdev->dev.parent);
737
738	e1000e_down(adapter, reset: true);
739
740	/* We can't just free everything and then setup again, because the
741	* ISRs in MSI-X mode get passed pointers to the Tx and Rx ring
742	* structs. First, attempt to allocate new resources...
743	*/
744	if (set_tx) {
745	memcpy(temp_tx, adapter->tx_ring, size);
746	temp_tx->count = new_tx_count;
747	err = e1000e_setup_tx_resources(ring: temp_tx);
748	if (err)
749	goto err_setup;
750	}
751	if (set_rx) {
752	memcpy(temp_rx, adapter->rx_ring, size);
753	temp_rx->count = new_rx_count;
754	err = e1000e_setup_rx_resources(ring: temp_rx);
755	if (err)
756	goto err_setup_rx;
757	}
758
759	/* ...then free the old resources and copy back any new ring data */
760	if (set_tx) {
761	e1000e_free_tx_resources(ring: adapter->tx_ring);
762	memcpy(adapter->tx_ring, temp_tx, size);
763	adapter->tx_ring_count = new_tx_count;
764	}
765	if (set_rx) {
766	e1000e_free_rx_resources(ring: adapter->rx_ring);
767	memcpy(adapter->rx_ring, temp_rx, size);
768	adapter->rx_ring_count = new_rx_count;
769	}
770
771	err_setup_rx:
772	if (err && set_tx)
773	e1000e_free_tx_resources(ring: temp_tx);
774	err_setup:
775	e1000e_up(adapter);
776	pm_runtime_put_sync(dev: netdev->dev.parent);
777	free_temp:
778	vfree(addr: temp_tx);
779	vfree(addr: temp_rx);
780	clear_reset:
781	clear_bit(nr: __E1000_RESETTING, addr: &adapter->state);
782	return err;
783	}
784
785	static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
786	int reg, int offset, u32 mask, u32 write)
787	{
788	u32 pat, val;
789	static const u32 test[] = {
790	0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
791	};
792	for (pat = 0; pat < ARRAY_SIZE(test); pat++) {
793	E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset,
794	(test[pat] & write));
795	val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset);
796	if (val != (test[pat] & write & mask)) {
797	e_err("pattern test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
798	reg + (offset << 2), val,
799	(test[pat] & write & mask));
800	*data = reg;
801	return true;
802	}
803	}
804	return false;
805	}
806
807	static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
808	int reg, u32 mask, u32 write)
809	{
810	u32 val;
811
812	__ew32(hw: &adapter->hw, reg, val: write & mask);
813	val = __er32(hw: &adapter->hw, reg);
814	if ((write & mask) != (val & mask)) {
815	e_err("set/check test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
816	reg, (val & mask), (write & mask));
817	*data = reg;
818	return true;
819	}
820	return false;
821	}
822
823	#define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write) \
824	do { \
825	if (reg_pattern_test(adapter, data, reg, offset, mask, write)) \
826	return 1; \
827	} while (0)
828	#define REG_PATTERN_TEST(reg, mask, write) \
829	REG_PATTERN_TEST_ARRAY(reg, 0, mask, write)
830
831	#define REG_SET_AND_CHECK(reg, mask, write) \
832	do { \
833	if (reg_set_and_check(adapter, data, reg, mask, write)) \
834	return 1; \
835	} while (0)
836
837	static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
838	{
839	struct e1000_hw *hw = &adapter->hw;
840	struct e1000_mac_info *mac = &adapter->hw.mac;
841	u32 value;
842	u32 before;
843	u32 after;
844	u32 i;
845	u32 toggle;
846	u32 mask;
847	u32 wlock_mac = 0;
848
849	/* The status register is Read Only, so a write should fail.
850	* Some bits that get toggled are ignored. There are several bits
851	* on newer hardware that are r/w.
852	*/
853	switch (mac->type) {
854	case e1000_82571:
855	case e1000_82572:
856	case e1000_80003es2lan:
857	toggle = 0x7FFFF3FF;
858	break;
859	default:
860	toggle = 0x7FFFF033;
861	break;
862	}
863
864	before = er32(STATUS);
865	value = (er32(STATUS) & toggle);
866	ew32(STATUS, toggle);
867	after = er32(STATUS) & toggle;
868	if (value != after) {
869	e_err("failed STATUS register test got: 0x%08X expected: 0x%08X\n",
870	after, value);
871	*data = 1;
872	return 1;
873	}
874	/* restore previous status */
875	ew32(STATUS, before);
876
877	if (!(adapter->flags & FLAG_IS_ICH)) {
878	REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
879	REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF);
880	REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF);
881	REG_PATTERN_TEST(E1000_VET, 0x0000FFFF, 0xFFFFFFFF);
882	}
883
884	REG_PATTERN_TEST(E1000_RDTR, 0x0000FFFF, 0xFFFFFFFF);
885	REG_PATTERN_TEST(E1000_RDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
886	REG_PATTERN_TEST(E1000_RDLEN(0), 0x000FFF80, 0x000FFFFF);
887	REG_PATTERN_TEST(E1000_RDH(0), 0x0000FFFF, 0x0000FFFF);
888	REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF);
889	REG_PATTERN_TEST(E1000_FCRTH, 0x0000FFF8, 0x0000FFF8);
890	REG_PATTERN_TEST(E1000_FCTTV, 0x0000FFFF, 0x0000FFFF);
891	REG_PATTERN_TEST(E1000_TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
892	REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
893	REG_PATTERN_TEST(E1000_TDLEN(0), 0x000FFF80, 0x000FFFFF);
894
895	REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000);
896
897	before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE);
898	REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB);
899	REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000);
900
901	REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF);
902	REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
903	if (!(adapter->flags & FLAG_IS_ICH))
904	REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF);
905	REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
906	REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF);
907	mask = 0x8003FFFF;
908	switch (mac->type) {
909	case e1000_ich10lan:
910	case e1000_pchlan:
911	case e1000_pch2lan:
912	case e1000_pch_lpt:
913	case e1000_pch_spt:
914	case e1000_pch_cnp:
915	case e1000_pch_tgp:
916	case e1000_pch_adp:
917	case e1000_pch_mtp:
918	case e1000_pch_lnp:
919	case e1000_pch_ptp:
920	case e1000_pch_nvp:
921	mask |= BIT(18);
922	break;
923	default:
924	break;
925	}
926
927	if (mac->type >= e1000_pch_lpt)
928	wlock_mac = FIELD_GET(E1000_FWSM_WLOCK_MAC_MASK, er32(FWSM));
929
930	for (i = 0; i < mac->rar_entry_count; i++) {
931	if (mac->type >= e1000_pch_lpt) {
932	/* Cannot test write-protected SHRAL[n] registers */
933	if ((wlock_mac == 1) || (wlock_mac && (i > wlock_mac)))
934	continue;
935
936	/* SHRAH[9] different than the others */
937	if (i == 10)
938	mask |= BIT(30);
939	else
940	mask &= ~BIT(30);
941	}
942	if (mac->type == e1000_pch2lan) {
943	/* SHRAH[0,1,2] different than previous */
944	if (i == 1)
945	mask &= 0xFFF4FFFF;
946	/* SHRAH[3] different than SHRAH[0,1,2] */
947	if (i == 4)
948	mask |= BIT(30);
949	/* RAR[1-6] owned by management engine - skipping */
950	if (i > 0)
951	i += 6;
952	}
953
954	REG_PATTERN_TEST_ARRAY(E1000_RA, ((i << 1) + 1), mask,
955	0xFFFFFFFF);
956	/* reset index to actual value */
957	if ((mac->type == e1000_pch2lan) && (i > 6))
958	i -= 6;
959	}
960
961	for (i = 0; i < mac->mta_reg_count; i++)
962	REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF);
963
964	*data = 0;
965
966	return 0;
967	}
968
969	static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
970	{
971	u16 temp;
972	u16 checksum = 0;
973	u16 i;
974
975	*data = 0;
976	/* Read and add up the contents of the EEPROM */
977	for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
978	if ((e1000_read_nvm(hw: &adapter->hw, offset: i, words: 1, data: &temp)) < 0) {
979	*data = 1;
980	return *data;
981	}
982	checksum += temp;
983	}
984
985	/* If Checksum is not Correct return error else test passed */
986	if ((checksum != (u16)NVM_SUM) && !(*data))
987	*data = 2;
988
989	return *data;
990	}
991
992	static irqreturn_t e1000_test_intr(int __always_unused irq, void *data)
993	{
994	struct net_device *netdev = (struct net_device *)data;
995	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
996	struct e1000_hw *hw = &adapter->hw;
997
998	adapter->test_icr |= er32(ICR);
999
1000	return IRQ_HANDLED;
1001	}
1002
1003	static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
1004	{
1005	struct net_device *netdev = adapter->netdev;
1006	struct e1000_hw *hw = &adapter->hw;
1007	u32 mask;
1008	u32 shared_int = 1;
1009	u32 irq = adapter->pdev->irq;
1010	int i;
1011	int ret_val = 0;
1012	int int_mode = E1000E_INT_MODE_LEGACY;
1013
1014	*data = 0;
1015
1016	/* NOTE: we don't test MSI/MSI-X interrupts here, yet */
1017	if (adapter->int_mode == E1000E_INT_MODE_MSIX) {
1018	int_mode = adapter->int_mode;
1019	e1000e_reset_interrupt_capability(adapter);
1020	adapter->int_mode = E1000E_INT_MODE_LEGACY;
1021	e1000e_set_interrupt_capability(adapter);
1022	}
1023	/* Hook up test interrupt handler just for this test */
1024	if (!request_irq(irq, handler: e1000_test_intr, IRQF_PROBE_SHARED, name: netdev->name,
1025	dev: netdev)) {
1026	shared_int = 0;
1027	} else if (request_irq(irq, handler: e1000_test_intr, IRQF_SHARED, name: netdev->name,
1028	dev: netdev)) {
1029	*data = 1;
1030	ret_val = -1;
1031	goto out;
1032	}
1033	e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared"));
1034
1035	/* Disable all the interrupts */
1036	ew32(IMC, 0xFFFFFFFF);
1037	e1e_flush();
1038	usleep_range(min: 10000, max: 11000);
1039
1040	/* Test each interrupt */
1041	for (i = 0; i < 10; i++) {
1042	/* Interrupt to test */
1043	mask = BIT(i);
1044
1045	if (adapter->flags & FLAG_IS_ICH) {
1046	switch (mask) {
1047	case E1000_ICR_RXSEQ:
1048	continue;
1049	case 0x00000100:
1050	if (adapter->hw.mac.type == e1000_ich8lan ||
1051	adapter->hw.mac.type == e1000_ich9lan)
1052	continue;
1053	break;
1054	default:
1055	break;
1056	}
1057	}
1058
1059	if (!shared_int) {
1060	/* Disable the interrupt to be reported in
1061	* the cause register and then force the same
1062	* interrupt and see if one gets posted. If
1063	* an interrupt was posted to the bus, the
1064	* test failed.
1065	*/
1066	adapter->test_icr = 0;
1067	ew32(IMC, mask);
1068	ew32(ICS, mask);
1069	e1e_flush();
1070	usleep_range(min: 10000, max: 11000);
1071
1072	if (adapter->test_icr & mask) {
1073	*data = 3;
1074	break;
1075	}
1076	}
1077
1078	/* Enable the interrupt to be reported in
1079	* the cause register and then force the same
1080	* interrupt and see if one gets posted. If
1081	* an interrupt was not posted to the bus, the
1082	* test failed.
1083	*/
1084	adapter->test_icr = 0;
1085	ew32(IMS, mask);
1086	ew32(ICS, mask);
1087	e1e_flush();
1088	usleep_range(min: 10000, max: 11000);
1089
1090	if (!(adapter->test_icr & mask)) {
1091	*data = 4;
1092	break;
1093	}
1094
1095	if (!shared_int) {
1096	/* Disable the other interrupts to be reported in
1097	* the cause register and then force the other
1098	* interrupts and see if any get posted. If
1099	* an interrupt was posted to the bus, the
1100	* test failed.
1101	*/
1102	adapter->test_icr = 0;
1103	ew32(IMC, ~mask & 0x00007FFF);
1104	ew32(ICS, ~mask & 0x00007FFF);
1105	e1e_flush();
1106	usleep_range(min: 10000, max: 11000);
1107
1108	if (adapter->test_icr) {
1109	*data = 5;
1110	break;
1111	}
1112	}
1113	}
1114
1115	/* Disable all the interrupts */
1116	ew32(IMC, 0xFFFFFFFF);
1117	e1e_flush();
1118	usleep_range(min: 10000, max: 11000);
1119
1120	/* Unhook test interrupt handler */
1121	free_irq(irq, netdev);
1122
1123	out:
1124	if (int_mode == E1000E_INT_MODE_MSIX) {
1125	e1000e_reset_interrupt_capability(adapter);
1126	adapter->int_mode = int_mode;
1127	e1000e_set_interrupt_capability(adapter);
1128	}
1129
1130	return ret_val;
1131	}
1132
1133	static void e1000_free_desc_rings(struct e1000_adapter *adapter)
1134	{
1135	struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1136	struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1137	struct pci_dev *pdev = adapter->pdev;
1138	struct e1000_buffer *buffer_info;
1139	int i;
1140
1141	if (tx_ring->desc && tx_ring->buffer_info) {
1142	for (i = 0; i < tx_ring->count; i++) {
1143	buffer_info = &tx_ring->buffer_info[i];
1144
1145	if (buffer_info->dma)
1146	dma_unmap_single(&pdev->dev,
1147	buffer_info->dma,
1148	buffer_info->length,
1149	DMA_TO_DEVICE);
1150	dev_kfree_skb(buffer_info->skb);
1151	}
1152	}
1153
1154	if (rx_ring->desc && rx_ring->buffer_info) {
1155	for (i = 0; i < rx_ring->count; i++) {
1156	buffer_info = &rx_ring->buffer_info[i];
1157
1158	if (buffer_info->dma)
1159	dma_unmap_single(&pdev->dev,
1160	buffer_info->dma,
1161	2048, DMA_FROM_DEVICE);
1162	dev_kfree_skb(buffer_info->skb);
1163	}
1164	}
1165
1166	if (tx_ring->desc) {
1167	dma_free_coherent(dev: &pdev->dev, size: tx_ring->size, cpu_addr: tx_ring->desc,
1168	dma_handle: tx_ring->dma);
1169	tx_ring->desc = NULL;
1170	}
1171	if (rx_ring->desc) {
1172	dma_free_coherent(dev: &pdev->dev, size: rx_ring->size, cpu_addr: rx_ring->desc,
1173	dma_handle: rx_ring->dma);
1174	rx_ring->desc = NULL;
1175	}
1176
1177	kfree(objp: tx_ring->buffer_info);
1178	tx_ring->buffer_info = NULL;
1179	kfree(objp: rx_ring->buffer_info);
1180	rx_ring->buffer_info = NULL;
1181	}
1182
1183	static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
1184	{
1185	struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1186	struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1187	struct pci_dev *pdev = adapter->pdev;
1188	struct e1000_hw *hw = &adapter->hw;
1189	u32 rctl;
1190	int i;
1191	int ret_val;
1192
1193	/* Setup Tx descriptor ring and Tx buffers */
1194
1195	if (!tx_ring->count)
1196	tx_ring->count = E1000_DEFAULT_TXD;
1197
1198	tx_ring->buffer_info = kcalloc(n: tx_ring->count,
1199	size: sizeof(struct e1000_buffer), GFP_KERNEL);
1200	if (!tx_ring->buffer_info) {
1201	ret_val = 1;
1202	goto err_nomem;
1203	}
1204
1205	tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);
1206	tx_ring->size = ALIGN(tx_ring->size, 4096);
1207	tx_ring->desc = dma_alloc_coherent(dev: &pdev->dev, size: tx_ring->size,
1208	dma_handle: &tx_ring->dma, GFP_KERNEL);
1209	if (!tx_ring->desc) {
1210	ret_val = 2;
1211	goto err_nomem;
1212	}
1213	tx_ring->next_to_use = 0;
1214	tx_ring->next_to_clean = 0;
1215
1216	ew32(TDBAL(0), ((u64)tx_ring->dma & 0x00000000FFFFFFFF));
1217	ew32(TDBAH(0), ((u64)tx_ring->dma >> 32));
1218	ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc));
1219	ew32(TDH(0), 0);
1220	ew32(TDT(0), 0);
1221	ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_TCTL_MULR |
1222	E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1223	E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1224
1225	for (i = 0; i < tx_ring->count; i++) {
1226	struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
1227	struct sk_buff *skb;
1228	unsigned int skb_size = 1024;
1229
1230	skb = alloc_skb(size: skb_size, GFP_KERNEL);
1231	if (!skb) {
1232	ret_val = 3;
1233	goto err_nomem;
1234	}
1235	skb_put(skb, len: skb_size);
1236	tx_ring->buffer_info[i].skb = skb;
1237	tx_ring->buffer_info[i].length = skb->len;
1238	tx_ring->buffer_info[i].dma =
1239	dma_map_single(&pdev->dev, skb->data, skb->len,
1240	DMA_TO_DEVICE);
1241	if (dma_mapping_error(dev: &pdev->dev,
1242	dma_addr: tx_ring->buffer_info[i].dma)) {
1243	ret_val = 4;
1244	goto err_nomem;
1245	}
1246	tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
1247	tx_desc->lower.data = cpu_to_le32(skb->len);
1248	tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1249	E1000_TXD_CMD_IFCS |
1250	E1000_TXD_CMD_RS);
1251	tx_desc->upper.data = 0;
1252	}
1253
1254	/* Setup Rx descriptor ring and Rx buffers */
1255
1256	if (!rx_ring->count)
1257	rx_ring->count = E1000_DEFAULT_RXD;
1258
1259	rx_ring->buffer_info = kcalloc(n: rx_ring->count,
1260	size: sizeof(struct e1000_buffer), GFP_KERNEL);
1261	if (!rx_ring->buffer_info) {
1262	ret_val = 5;
1263	goto err_nomem;
1264	}
1265
1266	rx_ring->size = rx_ring->count * sizeof(union e1000_rx_desc_extended);
1267	rx_ring->desc = dma_alloc_coherent(dev: &pdev->dev, size: rx_ring->size,
1268	dma_handle: &rx_ring->dma, GFP_KERNEL);
1269	if (!rx_ring->desc) {
1270	ret_val = 6;
1271	goto err_nomem;
1272	}
1273	rx_ring->next_to_use = 0;
1274	rx_ring->next_to_clean = 0;
1275
1276	rctl = er32(RCTL);
1277	if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
1278	ew32(RCTL, rctl & ~E1000_RCTL_EN);
1279	ew32(RDBAL(0), ((u64)rx_ring->dma & 0xFFFFFFFF));
1280	ew32(RDBAH(0), ((u64)rx_ring->dma >> 32));
1281	ew32(RDLEN(0), rx_ring->size);
1282	ew32(RDH(0), 0);
1283	ew32(RDT(0), 0);
1284	rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1285	E1000_RCTL_UPE | E1000_RCTL_MPE | E1000_RCTL_LPE |
1286	E1000_RCTL_SBP | E1000_RCTL_SECRC |
1287	E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1288	(adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
1289	ew32(RCTL, rctl);
1290
1291	for (i = 0; i < rx_ring->count; i++) {
1292	union e1000_rx_desc_extended *rx_desc;
1293	struct sk_buff *skb;
1294
1295	skb = alloc_skb(size: 2048 + NET_IP_ALIGN, GFP_KERNEL);
1296	if (!skb) {
1297	ret_val = 7;
1298	goto err_nomem;
1299	}
1300	skb_reserve(skb, NET_IP_ALIGN);
1301	rx_ring->buffer_info[i].skb = skb;
1302	rx_ring->buffer_info[i].dma =
1303	dma_map_single(&pdev->dev, skb->data, 2048,
1304	DMA_FROM_DEVICE);
1305	if (dma_mapping_error(dev: &pdev->dev,
1306	dma_addr: rx_ring->buffer_info[i].dma)) {
1307	ret_val = 8;
1308	goto err_nomem;
1309	}
1310	rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
1311	rx_desc->read.buffer_addr =
1312	cpu_to_le64(rx_ring->buffer_info[i].dma);
1313	memset(skb->data, 0x00, skb->len);
1314	}
1315
1316	return 0;
1317
1318	err_nomem:
1319	e1000_free_desc_rings(adapter);
1320	return ret_val;
1321	}
1322
1323	static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1324	{
1325	/* Write out to PHY registers 29 and 30 to disable the Receiver. */
1326	e1e_wphy(hw: &adapter->hw, offset: 29, data: 0x001F);
1327	e1e_wphy(hw: &adapter->hw, offset: 30, data: 0x8FFC);
1328	e1e_wphy(hw: &adapter->hw, offset: 29, data: 0x001A);
1329	e1e_wphy(hw: &adapter->hw, offset: 30, data: 0x8FF0);
1330	}
1331
1332	static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1333	{
1334	struct e1000_hw *hw = &adapter->hw;
1335	u32 ctrl_reg = 0;
1336	u16 phy_reg = 0;
1337	s32 ret_val = 0;
1338
1339	hw->mac.autoneg = 0;
1340
1341	if (hw->phy.type == e1000_phy_ife) {
1342	/* force 100, set loopback */
1343	e1e_wphy(hw, MII_BMCR, data: 0x6100);
1344
1345	/* Now set up the MAC to the same speed/duplex as the PHY. */
1346	ctrl_reg = er32(CTRL);
1347	ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1348	ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1349	E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1350	E1000_CTRL_SPD_100 |/* Force Speed to 100 */
1351	E1000_CTRL_FD); /* Force Duplex to FULL */
1352
1353	ew32(CTRL, ctrl_reg);
1354	e1e_flush();
1355	usleep_range(min: 500, max: 1000);
1356
1357	return 0;
1358	}
1359
1360	/* Specific PHY configuration for loopback */
1361	switch (hw->phy.type) {
1362	case e1000_phy_m88:
1363	/* Auto-MDI/MDIX Off */
1364	e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, data: 0x0808);
1365	/* reset to update Auto-MDI/MDIX */
1366	e1e_wphy(hw, MII_BMCR, data: 0x9140);
1367	/* autoneg off */
1368	e1e_wphy(hw, MII_BMCR, data: 0x8140);
1369	break;
1370	case e1000_phy_gg82563:
1371	e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, data: 0x1CC);
1372	break;
1373	case e1000_phy_bm:
1374	/* Set Default MAC Interface speed to 1GB */
1375	e1e_rphy(hw, PHY_REG(2, 21), data: &phy_reg);
1376	phy_reg &= ~0x0007;
1377	phy_reg |= 0x006;
1378	e1e_wphy(hw, PHY_REG(2, 21), data: phy_reg);
1379	/* Assert SW reset for above settings to take effect */
1380	hw->phy.ops.commit(hw);
1381	usleep_range(min: 1000, max: 2000);
1382	/* Force Full Duplex */
1383	e1e_rphy(hw, PHY_REG(769, 16), data: &phy_reg);
1384	e1e_wphy(hw, PHY_REG(769, 16), data: phy_reg | 0x000C);
1385	/* Set Link Up (in force link) */
1386	e1e_rphy(hw, PHY_REG(776, 16), data: &phy_reg);
1387	e1e_wphy(hw, PHY_REG(776, 16), data: phy_reg | 0x0040);
1388	/* Force Link */
1389	e1e_rphy(hw, PHY_REG(769, 16), data: &phy_reg);
1390	e1e_wphy(hw, PHY_REG(769, 16), data: phy_reg | 0x0040);
1391	/* Set Early Link Enable */
1392	e1e_rphy(hw, PHY_REG(769, 20), data: &phy_reg);
1393	e1e_wphy(hw, PHY_REG(769, 20), data: phy_reg | 0x0400);
1394	break;
1395	case e1000_phy_82577:
1396	case e1000_phy_82578:
1397	/* Workaround: K1 must be disabled for stable 1Gbps operation */
1398	ret_val = hw->phy.ops.acquire(hw);
1399	if (ret_val) {
1400	e_err("Cannot setup 1Gbps loopback.\n");
1401	return ret_val;
1402	}
1403	e1000_configure_k1_ich8lan(hw, k1_enable: false);
1404	hw->phy.ops.release(hw);
1405	break;
1406	case e1000_phy_82579:
1407	/* Disable PHY energy detect power down */
1408	e1e_rphy(hw, PHY_REG(0, 21), data: &phy_reg);
1409	e1e_wphy(hw, PHY_REG(0, 21), data: phy_reg & ~BIT(3));
1410	/* Disable full chip energy detect */
1411	e1e_rphy(hw, PHY_REG(776, 18), data: &phy_reg);
1412	e1e_wphy(hw, PHY_REG(776, 18), data: phy_reg | 1);
1413	/* Enable loopback on the PHY */
1414	e1e_wphy(hw, I82577_PHY_LBK_CTRL, data: 0x8001);
1415	break;
1416	default:
1417	break;
1418	}
1419
1420	/* force 1000, set loopback */
1421	e1e_wphy(hw, MII_BMCR, data: 0x4140);
1422	msleep(msecs: 250);
1423
1424	/* Now set up the MAC to the same speed/duplex as the PHY. */
1425	ctrl_reg = er32(CTRL);
1426	ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1427	ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1428	E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1429	E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1430	E1000_CTRL_FD); /* Force Duplex to FULL */
1431
1432	if (adapter->flags & FLAG_IS_ICH)
1433	ctrl_reg |= E1000_CTRL_SLU; /* Set Link Up */
1434
1435	if (hw->phy.media_type == e1000_media_type_copper &&
1436	hw->phy.type == e1000_phy_m88) {
1437	ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
1438	} else {
1439	/* Set the ILOS bit on the fiber Nic if half duplex link is
1440	* detected.
1441	*/
1442	if ((er32(STATUS) & E1000_STATUS_FD) == 0)
1443	ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1444	}
1445
1446	ew32(CTRL, ctrl_reg);
1447
1448	/* Disable the receiver on the PHY so when a cable is plugged in, the
1449	* PHY does not begin to autoneg when a cable is reconnected to the NIC.
1450	*/
1451	if (hw->phy.type == e1000_phy_m88)
1452	e1000_phy_disable_receiver(adapter);
1453
1454	usleep_range(min: 500, max: 1000);
1455
1456	return 0;
1457	}
1458
1459	static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter)
1460	{
1461	struct e1000_hw *hw = &adapter->hw;
1462	u32 ctrl = er32(CTRL);
1463	int link;
1464
1465	/* special requirements for 82571/82572 fiber adapters */
1466
1467	/* jump through hoops to make sure link is up because serdes
1468	* link is hardwired up
1469	*/
1470	ctrl |= E1000_CTRL_SLU;
1471	ew32(CTRL, ctrl);
1472
1473	/* disable autoneg */
1474	ctrl = er32(TXCW);
1475	ctrl &= ~BIT(31);
1476	ew32(TXCW, ctrl);
1477
1478	link = (er32(STATUS) & E1000_STATUS_LU);
1479
1480	if (!link) {
1481	/* set invert loss of signal */
1482	ctrl = er32(CTRL);
1483	ctrl |= E1000_CTRL_ILOS;
1484	ew32(CTRL, ctrl);
1485	}
1486
1487	/* special write to serdes control register to enable SerDes analog
1488	* loopback
1489	*/
1490	ew32(SCTL, E1000_SCTL_ENABLE_SERDES_LOOPBACK);
1491	e1e_flush();
1492	usleep_range(min: 10000, max: 11000);
1493
1494	return 0;
1495	}
1496
1497	/* only call this for fiber/serdes connections to es2lan */
1498	static int e1000_set_es2lan_mac_loopback(struct e1000_adapter *adapter)
1499	{
1500	struct e1000_hw *hw = &adapter->hw;
1501	u32 ctrlext = er32(CTRL_EXT);
1502	u32 ctrl = er32(CTRL);
1503
1504	/* save CTRL_EXT to restore later, reuse an empty variable (unused
1505	* on mac_type 80003es2lan)
1506	*/
1507	adapter->tx_fifo_head = ctrlext;
1508
1509	/* clear the serdes mode bits, putting the device into mac loopback */
1510	ctrlext &= ~E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
1511	ew32(CTRL_EXT, ctrlext);
1512
1513	/* force speed to 1000/FD, link up */
1514	ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1515	ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX |
1516	E1000_CTRL_SPD_1000 | E1000_CTRL_FD);
1517	ew32(CTRL, ctrl);
1518
1519	/* set mac loopback */
1520	ctrl = er32(RCTL);
1521	ctrl |= E1000_RCTL_LBM_MAC;
1522	ew32(RCTL, ctrl);
1523
1524	/* set testing mode parameters (no need to reset later) */
1525	#define KMRNCTRLSTA_OPMODE (0x1F << 16)
1526	#define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x0582
1527	ew32(KMRNCTRLSTA,
1528	(KMRNCTRLSTA_OPMODE | KMRNCTRLSTA_OPMODE_1GB_FD_GMII));
1529
1530	return 0;
1531	}
1532
1533	static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1534	{
1535	struct e1000_hw *hw = &adapter->hw;
1536	u32 rctl, fext_nvm11, tarc0;
1537
1538	if (hw->mac.type >= e1000_pch_spt) {
1539	fext_nvm11 = er32(FEXTNVM11);
1540	fext_nvm11 |= E1000_FEXTNVM11_DISABLE_MULR_FIX;
1541	ew32(FEXTNVM11, fext_nvm11);
1542	tarc0 = er32(TARC(0));
1543	/* clear bits 28 & 29 (control of MULR concurrent requests) */
1544	tarc0 &= 0xcfffffff;
1545	/* set bit 29 (value of MULR requests is now 2) */
1546	tarc0 |= 0x20000000;
1547	ew32(TARC(0), tarc0);
1548	}
1549	if (hw->phy.media_type == e1000_media_type_fiber ||
1550	hw->phy.media_type == e1000_media_type_internal_serdes) {
1551	switch (hw->mac.type) {
1552	case e1000_80003es2lan:
1553	return e1000_set_es2lan_mac_loopback(adapter);
1554	case e1000_82571:
1555	case e1000_82572:
1556	return e1000_set_82571_fiber_loopback(adapter);
1557	default:
1558	rctl = er32(RCTL);
1559	rctl |= E1000_RCTL_LBM_TCVR;
1560	ew32(RCTL, rctl);
1561	return 0;
1562	}
1563	} else if (hw->phy.media_type == e1000_media_type_copper) {
1564	return e1000_integrated_phy_loopback(adapter);
1565	}
1566
1567	return 7;
1568	}
1569
1570	static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1571	{
1572	struct e1000_hw *hw = &adapter->hw;
1573	u32 rctl, fext_nvm11, tarc0;
1574	u16 phy_reg;
1575
1576	rctl = er32(RCTL);
1577	rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1578	ew32(RCTL, rctl);
1579
1580	switch (hw->mac.type) {
1581	case e1000_pch_spt:
1582	case e1000_pch_cnp:
1583	case e1000_pch_tgp:
1584	case e1000_pch_adp:
1585	case e1000_pch_mtp:
1586	case e1000_pch_lnp:
1587	case e1000_pch_ptp:
1588	case e1000_pch_nvp:
1589	fext_nvm11 = er32(FEXTNVM11);
1590	fext_nvm11 &= ~E1000_FEXTNVM11_DISABLE_MULR_FIX;
1591	ew32(FEXTNVM11, fext_nvm11);
1592	tarc0 = er32(TARC(0));
1593	/* clear bits 28 & 29 (control of MULR concurrent requests) */
1594	/* set bit 29 (value of MULR requests is now 0) */
1595	tarc0 &= 0xcfffffff;
1596	ew32(TARC(0), tarc0);
1597	fallthrough;
1598	case e1000_80003es2lan:
1599	if (hw->phy.media_type == e1000_media_type_fiber ||
1600	hw->phy.media_type == e1000_media_type_internal_serdes) {
1601	/* restore CTRL_EXT, stealing space from tx_fifo_head */
1602	ew32(CTRL_EXT, adapter->tx_fifo_head);
1603	adapter->tx_fifo_head = 0;
1604	}
1605	fallthrough;
1606	case e1000_82571:
1607	case e1000_82572:
1608	if (hw->phy.media_type == e1000_media_type_fiber ||
1609	hw->phy.media_type == e1000_media_type_internal_serdes) {
1610	ew32(SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1611	e1e_flush();
1612	usleep_range(min: 10000, max: 11000);
1613	break;
1614	}
1615	fallthrough;
1616	default:
1617	hw->mac.autoneg = 1;
1618	if (hw->phy.type == e1000_phy_gg82563)
1619	e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, data: 0x180);
1620	e1e_rphy(hw, MII_BMCR, data: &phy_reg);
1621	if (phy_reg & BMCR_LOOPBACK) {
1622	phy_reg &= ~BMCR_LOOPBACK;
1623	e1e_wphy(hw, MII_BMCR, data: phy_reg);
1624	if (hw->phy.ops.commit)
1625	hw->phy.ops.commit(hw);
1626	}
1627	break;
1628	}
1629	}
1630
1631	static void e1000_create_lbtest_frame(struct sk_buff *skb,
1632	unsigned int frame_size)
1633	{
1634	memset(skb->data, 0xFF, frame_size);
1635	frame_size &= ~1;
1636	memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1637	skb->data[frame_size / 2 + 10] = 0xBE;
1638	skb->data[frame_size / 2 + 12] = 0xAF;
1639	}
1640
1641	static int e1000_check_lbtest_frame(struct sk_buff *skb,
1642	unsigned int frame_size)
1643	{
1644	frame_size &= ~1;
1645	if (*(skb->data + 3) == 0xFF)
1646	if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
1647	(*(skb->data + frame_size / 2 + 12) == 0xAF))
1648	return 0;
1649	return 13;
1650	}
1651
1652	static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1653	{
1654	struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1655	struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1656	struct pci_dev *pdev = adapter->pdev;
1657	struct e1000_hw *hw = &adapter->hw;
1658	struct e1000_buffer *buffer_info;
1659	int i, j, k, l;
1660	int lc;
1661	int good_cnt;
1662	int ret_val = 0;
1663	unsigned long time;
1664
1665	ew32(RDT(0), rx_ring->count - 1);
1666
1667	/* Calculate the loop count based on the largest descriptor ring
1668	* The idea is to wrap the largest ring a number of times using 64
1669	* send/receive pairs during each loop
1670	*/
1671
1672	if (rx_ring->count <= tx_ring->count)
1673	lc = ((tx_ring->count / 64) * 2) + 1;
1674	else
1675	lc = ((rx_ring->count / 64) * 2) + 1;
1676
1677	k = 0;
1678	l = 0;
1679	/* loop count loop */
1680	for (j = 0; j <= lc; j++) {
1681	/* send the packets */
1682	for (i = 0; i < 64; i++) {
1683	buffer_info = &tx_ring->buffer_info[k];
1684
1685	e1000_create_lbtest_frame(skb: buffer_info->skb, frame_size: 1024);
1686	dma_sync_single_for_device(dev: &pdev->dev,
1687	addr: buffer_info->dma,
1688	size: buffer_info->length,
1689	dir: DMA_TO_DEVICE);
1690	k++;
1691	if (k == tx_ring->count)
1692	k = 0;
1693	}
1694	ew32(TDT(0), k);
1695	e1e_flush();
1696	msleep(msecs: 200);
1697	time = jiffies; /* set the start time for the receive */
1698	good_cnt = 0;
1699	/* receive the sent packets */
1700	do {
1701	buffer_info = &rx_ring->buffer_info[l];
1702
1703	dma_sync_single_for_cpu(dev: &pdev->dev,
1704	addr: buffer_info->dma, size: 2048,
1705	dir: DMA_FROM_DEVICE);
1706
1707	ret_val = e1000_check_lbtest_frame(skb: buffer_info->skb,
1708	frame_size: 1024);
1709	if (!ret_val)
1710	good_cnt++;
1711	l++;
1712	if (l == rx_ring->count)
1713	l = 0;
1714	/* time + 20 msecs (200 msecs on 2.4) is more than
1715	* enough time to complete the receives, if it's
1716	* exceeded, break and error off
1717	*/
1718	} while ((good_cnt < 64) && !time_after(jiffies, time + 20));
1719	if (good_cnt != 64) {
1720	ret_val = 13; /* ret_val is the same as mis-compare */
1721	break;
1722	}
1723	if (time_after(jiffies, time + 20)) {
1724	ret_val = 14; /* error code for time out error */
1725	break;
1726	}
1727	}
1728	return ret_val;
1729	}
1730
1731	static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1732	{
1733	struct e1000_hw *hw = &adapter->hw;
1734
1735	/* PHY loopback cannot be performed if SoL/IDER sessions are active */
1736	if (hw->phy.ops.check_reset_block &&
1737	hw->phy.ops.check_reset_block(hw)) {
1738	e_err("Cannot do PHY loopback test when SoL/IDER is active.\n");
1739	*data = 0;
1740	goto out;
1741	}
1742
1743	*data = e1000_setup_desc_rings(adapter);
1744	if (*data)
1745	goto out;
1746
1747	*data = e1000_setup_loopback_test(adapter);
1748	if (*data)
1749	goto err_loopback;
1750
1751	*data = e1000_run_loopback_test(adapter);
1752	e1000_loopback_cleanup(adapter);
1753
1754	err_loopback:
1755	e1000_free_desc_rings(adapter);
1756	out:
1757	return *data;
1758	}
1759
1760	static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1761	{
1762	struct e1000_hw *hw = &adapter->hw;
1763
1764	*data = 0;
1765	if (hw->phy.media_type == e1000_media_type_internal_serdes) {
1766	int i = 0;
1767
1768	hw->mac.serdes_has_link = false;
1769
1770	/* On some blade server designs, link establishment
1771	* could take as long as 2-3 minutes
1772	*/
1773	do {
1774	hw->mac.ops.check_for_link(hw);
1775	if (hw->mac.serdes_has_link)
1776	return *data;
1777	msleep(msecs: 20);
1778	} while (i++ < 3750);
1779
1780	*data = 1;
1781	} else {
1782	hw->mac.ops.check_for_link(hw);
1783	if (hw->mac.autoneg)
1784	/* On some Phy/switch combinations, link establishment
1785	* can take a few seconds more than expected.
1786	*/
1787	msleep_interruptible(msecs: 5000);
1788
1789	if (!(er32(STATUS) & E1000_STATUS_LU))
1790	*data = 1;
1791	}
1792	return *data;
1793	}
1794
1795	static int e1000e_get_sset_count(struct net_device __always_unused *netdev,
1796	int sset)
1797	{
1798	switch (sset) {
1799	case ETH_SS_TEST:
1800	return E1000_TEST_LEN;
1801	case ETH_SS_STATS:
1802	return E1000_STATS_LEN;
1803	case ETH_SS_PRIV_FLAGS:
1804	return E1000E_PRIV_FLAGS_STR_LEN;
1805	default:
1806	return -EOPNOTSUPP;
1807	}
1808	}
1809
1810	static void e1000_diag_test(struct net_device *netdev,
1811	struct ethtool_test *eth_test, u64 *data)
1812	{
1813	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
1814	u16 autoneg_advertised;
1815	u8 forced_speed_duplex;
1816	u8 autoneg;
1817	bool if_running = netif_running(dev: netdev);
1818
1819	pm_runtime_get_sync(dev: netdev->dev.parent);
1820
1821	set_bit(nr: __E1000_TESTING, addr: &adapter->state);
1822
1823	if (!if_running) {
1824	/* Get control of and reset hardware */
1825	if (adapter->flags & FLAG_HAS_AMT)
1826	e1000e_get_hw_control(adapter);
1827
1828	e1000e_power_up_phy(adapter);
1829
1830	adapter->hw.phy.autoneg_wait_to_complete = 1;
1831	e1000e_reset(adapter);
1832	adapter->hw.phy.autoneg_wait_to_complete = 0;
1833	}
1834
1835	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1836	/* Offline tests */
1837
1838	/* save speed, duplex, autoneg settings */
1839	autoneg_advertised = adapter->hw.phy.autoneg_advertised;
1840	forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;
1841	autoneg = adapter->hw.mac.autoneg;
1842
1843	e_info("offline testing starting\n");
1844
1845	if (if_running)
1846	/* indicate we're in test mode */
1847	e1000e_close(netdev);
1848
1849	if (e1000_reg_test(adapter, data: &data[0]))
1850	eth_test->flags |= ETH_TEST_FL_FAILED;
1851
1852	e1000e_reset(adapter);
1853	if (e1000_eeprom_test(adapter, data: &data[1]))
1854	eth_test->flags |= ETH_TEST_FL_FAILED;
1855
1856	e1000e_reset(adapter);
1857	if (e1000_intr_test(adapter, data: &data[2]))
1858	eth_test->flags |= ETH_TEST_FL_FAILED;
1859
1860	e1000e_reset(adapter);
1861	if (e1000_loopback_test(adapter, data: &data[3]))
1862	eth_test->flags |= ETH_TEST_FL_FAILED;
1863
1864	/* force this routine to wait until autoneg complete/timeout */
1865	adapter->hw.phy.autoneg_wait_to_complete = 1;
1866	e1000e_reset(adapter);
1867	adapter->hw.phy.autoneg_wait_to_complete = 0;
1868
1869	if (e1000_link_test(adapter, data: &data[4]))
1870	eth_test->flags |= ETH_TEST_FL_FAILED;
1871
1872	/* restore speed, duplex, autoneg settings */
1873	adapter->hw.phy.autoneg_advertised = autoneg_advertised;
1874	adapter->hw.mac.forced_speed_duplex = forced_speed_duplex;
1875	adapter->hw.mac.autoneg = autoneg;
1876	e1000e_reset(adapter);
1877
1878	clear_bit(nr: __E1000_TESTING, addr: &adapter->state);
1879	if (if_running)
1880	e1000e_open(netdev);
1881	} else {
1882	/* Online tests */
1883
1884	e_info("online testing starting\n");
1885
1886	/* register, eeprom, intr and loopback tests not run online */
1887	data[0] = 0;
1888	data[1] = 0;
1889	data[2] = 0;
1890	data[3] = 0;
1891
1892	if (e1000_link_test(adapter, data: &data[4]))
1893	eth_test->flags |= ETH_TEST_FL_FAILED;
1894
1895	clear_bit(nr: __E1000_TESTING, addr: &adapter->state);
1896	}
1897
1898	if (!if_running) {
1899	e1000e_reset(adapter);
1900
1901	if (adapter->flags & FLAG_HAS_AMT)
1902	e1000e_release_hw_control(adapter);
1903	}
1904
1905	msleep_interruptible(msecs: 4 * 1000);
1906
1907	pm_runtime_put_sync(dev: netdev->dev.parent);
1908	}
1909
1910	static void e1000_get_wol(struct net_device *netdev,
1911	struct ethtool_wolinfo *wol)
1912	{
1913	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
1914
1915	wol->supported = 0;
1916	wol->wolopts = 0;
1917
1918	if (!(adapter->flags & FLAG_HAS_WOL) ||
1919	!device_can_wakeup(dev: &adapter->pdev->dev))
1920	return;
1921
1922	wol->supported = WAKE_UCAST | WAKE_MCAST |
1923	WAKE_BCAST | WAKE_MAGIC | WAKE_PHY;
1924
1925	/* apply any specific unsupported masks here */
1926	if (adapter->flags & FLAG_NO_WAKE_UCAST) {
1927	wol->supported &= ~WAKE_UCAST;
1928
1929	if (adapter->wol & E1000_WUFC_EX)
1930	e_err("Interface does not support directed (unicast) frame wake-up packets\n");
1931	}
1932
1933	if (adapter->wol & E1000_WUFC_EX)
1934	wol->wolopts |= WAKE_UCAST;
1935	if (adapter->wol & E1000_WUFC_MC)
1936	wol->wolopts |= WAKE_MCAST;
1937	if (adapter->wol & E1000_WUFC_BC)
1938	wol->wolopts |= WAKE_BCAST;
1939	if (adapter->wol & E1000_WUFC_MAG)
1940	wol->wolopts |= WAKE_MAGIC;
1941	if (adapter->wol & E1000_WUFC_LNKC)
1942	wol->wolopts |= WAKE_PHY;
1943	}
1944
1945	static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1946	{
1947	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
1948
1949	if (!(adapter->flags & FLAG_HAS_WOL) ||
1950	!device_can_wakeup(dev: &adapter->pdev->dev) ||
1951	(wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
1952	WAKE_MAGIC | WAKE_PHY)))
1953	return -EOPNOTSUPP;
1954
1955	/* these settings will always override what we currently have */
1956	adapter->wol = 0;
1957
1958	if (wol->wolopts & WAKE_UCAST)
1959	adapter->wol |= E1000_WUFC_EX;
1960	if (wol->wolopts & WAKE_MCAST)
1961	adapter->wol |= E1000_WUFC_MC;
1962	if (wol->wolopts & WAKE_BCAST)
1963	adapter->wol |= E1000_WUFC_BC;
1964	if (wol->wolopts & WAKE_MAGIC)
1965	adapter->wol |= E1000_WUFC_MAG;
1966	if (wol->wolopts & WAKE_PHY)
1967	adapter->wol |= E1000_WUFC_LNKC;
1968
1969	device_set_wakeup_enable(dev: &adapter->pdev->dev, enable: adapter->wol);
1970
1971	return 0;
1972	}
1973
1974	static int e1000_set_phys_id(struct net_device *netdev,
1975	enum ethtool_phys_id_state state)
1976	{
1977	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
1978	struct e1000_hw *hw = &adapter->hw;
1979
1980	switch (state) {
1981	case ETHTOOL_ID_ACTIVE:
1982	pm_runtime_get_sync(dev: netdev->dev.parent);
1983
1984	if (!hw->mac.ops.blink_led)
1985	return 2; /* cycle on/off twice per second */
1986
1987	hw->mac.ops.blink_led(hw);
1988	break;
1989
1990	case ETHTOOL_ID_INACTIVE:
1991	if (hw->phy.type == e1000_phy_ife)
1992	e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, data: 0);
1993	hw->mac.ops.led_off(hw);
1994	hw->mac.ops.cleanup_led(hw);
1995	pm_runtime_put_sync(dev: netdev->dev.parent);
1996	break;
1997
1998	case ETHTOOL_ID_ON:
1999	hw->mac.ops.led_on(hw);
2000	break;
2001
2002	case ETHTOOL_ID_OFF:
2003	hw->mac.ops.led_off(hw);
2004	break;
2005	}
2006
2007	return 0;
2008	}
2009
2010	static int e1000_get_coalesce(struct net_device *netdev,
2011	struct ethtool_coalesce *ec,
2012	struct kernel_ethtool_coalesce *kernel_coal,
2013	struct netlink_ext_ack *extack)
2014	{
2015	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2016
2017	if (adapter->itr_setting <= 4)
2018	ec->rx_coalesce_usecs = adapter->itr_setting;
2019	else
2020	ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
2021
2022	return 0;
2023	}
2024
2025	static int e1000_set_coalesce(struct net_device *netdev,
2026	struct ethtool_coalesce *ec,
2027	struct kernel_ethtool_coalesce *kernel_coal,
2028	struct netlink_ext_ack *extack)
2029	{
2030	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2031
2032	if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
2033	((ec->rx_coalesce_usecs > 4) &&
2034	(ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
2035	(ec->rx_coalesce_usecs == 2))
2036	return -EINVAL;
2037
2038	if (ec->rx_coalesce_usecs == 4) {
2039	adapter->itr_setting = 4;
2040	adapter->itr = adapter->itr_setting;
2041	} else if (ec->rx_coalesce_usecs <= 3) {
2042	adapter->itr = 20000;
2043	adapter->itr_setting = ec->rx_coalesce_usecs;
2044	} else {
2045	adapter->itr = (1000000 / ec->rx_coalesce_usecs);
2046	adapter->itr_setting = adapter->itr & ~3;
2047	}
2048
2049	pm_runtime_get_sync(dev: netdev->dev.parent);
2050
2051	if (adapter->itr_setting != 0)
2052	e1000e_write_itr(adapter, itr: adapter->itr);
2053	else
2054	e1000e_write_itr(adapter, itr: 0);
2055
2056	pm_runtime_put_sync(dev: netdev->dev.parent);
2057
2058	return 0;
2059	}
2060
2061	static int e1000_nway_reset(struct net_device *netdev)
2062	{
2063	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2064
2065	if (!netif_running(dev: netdev))
2066	return -EAGAIN;
2067
2068	if (!adapter->hw.mac.autoneg)
2069	return -EINVAL;
2070
2071	pm_runtime_get_sync(dev: netdev->dev.parent);
2072	e1000e_reinit_locked(adapter);
2073	pm_runtime_put_sync(dev: netdev->dev.parent);
2074
2075	return 0;
2076	}
2077
2078	static void e1000_get_ethtool_stats(struct net_device *netdev,
2079	struct ethtool_stats __always_unused *stats,
2080	u64 *data)
2081	{
2082	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2083	struct rtnl_link_stats64 net_stats;
2084	int i;
2085	char *p = NULL;
2086
2087	pm_runtime_get_sync(dev: netdev->dev.parent);
2088
2089	dev_get_stats(dev: netdev, storage: &net_stats);
2090
2091	pm_runtime_put_sync(dev: netdev->dev.parent);
2092
2093	for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2094	switch (e1000_gstrings_stats[i].type) {
2095	case NETDEV_STATS:
2096	p = (char *)&net_stats +
2097	e1000_gstrings_stats[i].stat_offset;
2098	break;
2099	case E1000_STATS:
2100	p = (char *)adapter +
2101	e1000_gstrings_stats[i].stat_offset;
2102	break;
2103	default:
2104	data[i] = 0;
2105	continue;
2106	}
2107
2108	data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
2109	sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
2110	}
2111	}
2112
2113	static void e1000_get_strings(struct net_device __always_unused *netdev,
2114	u32 stringset, u8 *data)
2115	{
2116	u8 *p = data;
2117	int i;
2118
2119	switch (stringset) {
2120	case ETH_SS_TEST:
2121	memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
2122	break;
2123	case ETH_SS_STATS:
2124	for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2125	memcpy(p, e1000_gstrings_stats[i].stat_string,
2126	ETH_GSTRING_LEN);
2127	p += ETH_GSTRING_LEN;
2128	}
2129	break;
2130	case ETH_SS_PRIV_FLAGS:
2131	memcpy(data, e1000e_priv_flags_strings,
2132	E1000E_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
2133	break;
2134	}
2135	}
2136
2137	static int e1000_get_rxnfc(struct net_device *netdev,
2138	struct ethtool_rxnfc *info,
2139	u32 __always_unused *rule_locs)
2140	{
2141	info->data = 0;
2142
2143	switch (info->cmd) {
2144	case ETHTOOL_GRXFH: {
2145	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2146	struct e1000_hw *hw = &adapter->hw;
2147	u32 mrqc;
2148
2149	pm_runtime_get_sync(dev: netdev->dev.parent);
2150	mrqc = er32(MRQC);
2151	pm_runtime_put_sync(dev: netdev->dev.parent);
2152
2153	if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))
2154	return 0;
2155
2156	switch (info->flow_type) {
2157	case TCP_V4_FLOW:
2158	if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP)
2159	info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2160	fallthrough;
2161	case UDP_V4_FLOW:
2162	case SCTP_V4_FLOW:
2163	case AH_ESP_V4_FLOW:
2164	case IPV4_FLOW:
2165	if (mrqc & E1000_MRQC_RSS_FIELD_IPV4)
2166	info->data |= RXH_IP_SRC | RXH_IP_DST;
2167	break;
2168	case TCP_V6_FLOW:
2169	if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP)
2170	info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2171	fallthrough;
2172	case UDP_V6_FLOW:
2173	case SCTP_V6_FLOW:
2174	case AH_ESP_V6_FLOW:
2175	case IPV6_FLOW:
2176	if (mrqc & E1000_MRQC_RSS_FIELD_IPV6)
2177	info->data |= RXH_IP_SRC | RXH_IP_DST;
2178	break;
2179	default:
2180	break;
2181	}
2182	return 0;
2183	}
2184	default:
2185	return -EOPNOTSUPP;
2186	}
2187	}
2188
2189	static int e1000e_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
2190	{
2191	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2192	struct e1000_hw *hw = &adapter->hw;
2193	u16 cap_addr, lpa_addr, pcs_stat_addr, phy_data;
2194	u32 ret_val;
2195
2196	if (!(adapter->flags2 & FLAG2_HAS_EEE))
2197	return -EOPNOTSUPP;
2198
2199	switch (hw->phy.type) {
2200	case e1000_phy_82579:
2201	cap_addr = I82579_EEE_CAPABILITY;
2202	lpa_addr = I82579_EEE_LP_ABILITY;
2203	pcs_stat_addr = I82579_EEE_PCS_STATUS;
2204	break;
2205	case e1000_phy_i217:
2206	cap_addr = I217_EEE_CAPABILITY;
2207	lpa_addr = I217_EEE_LP_ABILITY;
2208	pcs_stat_addr = I217_EEE_PCS_STATUS;
2209	break;
2210	default:
2211	return -EOPNOTSUPP;
2212	}
2213
2214	pm_runtime_get_sync(dev: netdev->dev.parent);
2215
2216	ret_val = hw->phy.ops.acquire(hw);
2217	if (ret_val) {
2218	pm_runtime_put_sync(dev: netdev->dev.parent);
2219	return -EBUSY;
2220	}
2221
2222	/* EEE Capability */
2223	ret_val = e1000_read_emi_reg_locked(hw, addr: cap_addr, data: &phy_data);
2224	if (ret_val)
2225	goto release;
2226	mii_eee_cap1_mod_linkmode_t(adv: edata->supported, val: phy_data);
2227
2228	/* EEE Advertised */
2229	mii_eee_cap1_mod_linkmode_t(adv: edata->advertised, val: adapter->eee_advert);
2230
2231	/* EEE Link Partner Advertised */
2232	ret_val = e1000_read_emi_reg_locked(hw, addr: lpa_addr, data: &phy_data);
2233	if (ret_val)
2234	goto release;
2235	mii_eee_cap1_mod_linkmode_t(adv: edata->lp_advertised, val: phy_data);
2236
2237	/* EEE PCS Status */
2238	ret_val = e1000_read_emi_reg_locked(hw, addr: pcs_stat_addr, data: &phy_data);
2239	if (ret_val)
2240	goto release;
2241	if (hw->phy.type == e1000_phy_82579)
2242	phy_data <<= 8;
2243
2244	/* Result of the EEE auto negotiation - there is no register that
2245	* has the status of the EEE negotiation so do a best-guess based
2246	* on whether Tx or Rx LPI indications have been received.
2247	*/
2248	if (phy_data & (E1000_EEE_TX_LPI_RCVD | E1000_EEE_RX_LPI_RCVD))
2249	edata->eee_active = true;
2250
2251	edata->eee_enabled = !hw->dev_spec.ich8lan.eee_disable;
2252	edata->tx_lpi_enabled = true;
2253	edata->tx_lpi_timer = er32(LPIC) >> E1000_LPIC_LPIET_SHIFT;
2254
2255	release:
2256	hw->phy.ops.release(hw);
2257	if (ret_val)
2258	ret_val = -ENODATA;
2259
2260	pm_runtime_put_sync(dev: netdev->dev.parent);
2261
2262	return ret_val;
2263	}
2264
2265	static int e1000e_set_eee(struct net_device *netdev, struct ethtool_keee *edata)
2266	{
2267	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2268	__ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {};
2269	__ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = {};
2270	struct e1000_hw *hw = &adapter->hw;
2271	struct ethtool_keee eee_curr;
2272	s32 ret_val;
2273
2274	ret_val = e1000e_get_eee(netdev, edata: &eee_curr);
2275	if (ret_val)
2276	return ret_val;
2277
2278	if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
2279	e_err("Setting EEE tx-lpi is not supported\n");
2280	return -EINVAL;
2281	}
2282
2283	if (eee_curr.tx_lpi_timer != edata->tx_lpi_timer) {
2284	e_err("Setting EEE Tx LPI timer is not supported\n");
2285	return -EINVAL;
2286	}
2287
2288	linkmode_set_bit(nr: ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2289	addr: supported);
2290	linkmode_set_bit(nr: ETHTOOL_LINK_MODE_100baseT_Full_BIT,
2291	addr: supported);
2292
2293	if (linkmode_andnot(dst: tmp, src1: edata->advertised, src2: supported)) {
2294	e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");
2295	return -EINVAL;
2296	}
2297
2298	adapter->eee_advert = linkmode_to_mii_eee_cap1_t(adv: edata->advertised);
2299
2300	hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;
2301
2302	pm_runtime_get_sync(dev: netdev->dev.parent);
2303
2304	/* reset the link */
2305	if (netif_running(dev: netdev))
2306	e1000e_reinit_locked(adapter);
2307	else
2308	e1000e_reset(adapter);
2309
2310	pm_runtime_put_sync(dev: netdev->dev.parent);
2311
2312	return 0;
2313	}
2314
2315	static int e1000e_get_ts_info(struct net_device *netdev,
2316	struct ethtool_ts_info *info)
2317	{
2318	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2319
2320	ethtool_op_get_ts_info(dev: netdev, eti: info);
2321
2322	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
2323	return 0;
2324
2325	info->so_timestamping |= (SOF_TIMESTAMPING_TX_HARDWARE |
2326	SOF_TIMESTAMPING_RX_HARDWARE |
2327	SOF_TIMESTAMPING_RAW_HARDWARE);
2328
2329	info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
2330
2331	info->rx_filters = (BIT(HWTSTAMP_FILTER_NONE) |
2332	BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
2333	BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
2334	BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
2335	BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
2336	BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
2337	BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
2338	BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
2339	BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |
2340	BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
2341	BIT(HWTSTAMP_FILTER_ALL));
2342
2343	if (adapter->ptp_clock)
2344	info->phc_index = ptp_clock_index(ptp: adapter->ptp_clock);
2345
2346	return 0;
2347	}
2348
2349	static u32 e1000e_get_priv_flags(struct net_device *netdev)
2350	{
2351	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2352	u32 priv_flags = 0;
2353
2354	if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
2355	priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;
2356
2357	return priv_flags;
2358	}
2359
2360	static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)
2361	{
2362	struct e1000_adapter *adapter = netdev_priv(dev: netdev);
2363	unsigned int flags2 = adapter->flags2;
2364
2365	flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;
2366	if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {
2367	struct e1000_hw *hw = &adapter->hw;
2368
2369	if (hw->mac.type < e1000_pch_cnp)
2370	return -EINVAL;
2371	flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
2372	}
2373
2374	if (flags2 != adapter->flags2)
2375	adapter->flags2 = flags2;
2376
2377	return 0;
2378	}
2379
2380	static const struct ethtool_ops e1000_ethtool_ops = {
2381	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
2382	.get_drvinfo = e1000_get_drvinfo,
2383	.get_regs_len = e1000_get_regs_len,
2384	.get_regs = e1000_get_regs,
2385	.get_wol = e1000_get_wol,
2386	.set_wol = e1000_set_wol,
2387	.get_msglevel = e1000_get_msglevel,
2388	.set_msglevel = e1000_set_msglevel,
2389	.nway_reset = e1000_nway_reset,
2390	.get_link = ethtool_op_get_link,
2391	.get_eeprom_len = e1000_get_eeprom_len,
2392	.get_eeprom = e1000_get_eeprom,
2393	.set_eeprom = e1000_set_eeprom,
2394	.get_ringparam = e1000_get_ringparam,
2395	.set_ringparam = e1000_set_ringparam,
2396	.get_pauseparam = e1000_get_pauseparam,
2397	.set_pauseparam = e1000_set_pauseparam,
2398	.self_test = e1000_diag_test,
2399	.get_strings = e1000_get_strings,
2400	.set_phys_id = e1000_set_phys_id,
2401	.get_ethtool_stats = e1000_get_ethtool_stats,
2402	.get_sset_count = e1000e_get_sset_count,
2403	.get_coalesce = e1000_get_coalesce,
2404	.set_coalesce = e1000_set_coalesce,
2405	.get_rxnfc = e1000_get_rxnfc,
2406	.get_ts_info = e1000e_get_ts_info,
2407	.get_eee = e1000e_get_eee,
2408	.set_eee = e1000e_set_eee,
2409	.get_link_ksettings = e1000_get_link_ksettings,
2410	.set_link_ksettings = e1000_set_link_ksettings,
2411	.get_priv_flags = e1000e_get_priv_flags,
2412	.set_priv_flags = e1000e_set_priv_flags,
2413	};
2414
2415	void e1000e_set_ethtool_ops(struct net_device *netdev)
2416	{
2417	netdev->ethtool_ops = &e1000_ethtool_ops;
2418	}
2419