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
  17enum { NETDEV_STATS, E1000_STATS };
  18
  19struct e1000_stats {
  20	char stat_string[ETH_GSTRING_LEN];
  21	int type;
  22	int sizeof_stat;
  23	int stat_offset;
  24};
  25
  26static 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
  44static 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)
 102static 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
 110static 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(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(netdev)) {
 155		if (netif_carrier_ok(netdev)) {
 156			speed = adapter->link_speed;
 157			cmd->base.duplex = adapter->link_duplex - 1;
 158		}
 159	} else if (!pm_runtime_suspended(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(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(adapter->phy_regs.stat1000);
 198	lp_advertising = lpa_t |
 199	mii_lpa_to_ethtool_lpa_t(adapter->phy_regs.lpa);
 200
 201	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 202						supported);
 203	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 204						advertising);
 205	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
 206						lp_advertising);
 207
 208	return 0;
 209}
 210
 211static 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
 261err_inval:
 262	e_err("Unsupported Speed/Duplex configuration\n");
 263	return -EINVAL;
 264}
 265
 266static int e1000_set_link_ksettings(struct net_device *netdev,
 267				    const struct ethtool_link_ksettings *cmd)
 268{
 269	struct e1000_adapter *adapter = netdev_priv(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(&advertising,
 275						cmd->link_modes.advertising);
 276
 277	pm_runtime_get_sync(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(__E1000_RESETTING, &adapter->state))
 308		usleep_range(1000, 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, speed, 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(adapter->netdev)) {
 343		e1000e_down(adapter, true);
 344		e1000e_up(adapter);
 345	} else {
 346		e1000e_reset(adapter);
 347	}
 348
 349out:
 350	pm_runtime_put_sync(netdev->dev.parent);
 351	clear_bit(__E1000_RESETTING, &adapter->state);
 352	return ret_val;
 353}
 354
 355static void e1000_get_pauseparam(struct net_device *netdev,
 356				 struct ethtool_pauseparam *pause)
 357{
 358	struct e1000_adapter *adapter = netdev_priv(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
 374static int e1000_set_pauseparam(struct net_device *netdev,
 375				struct ethtool_pauseparam *pause)
 376{
 377	struct e1000_adapter *adapter = netdev_priv(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(__E1000_RESETTING, &adapter->state))
 384		usleep_range(1000, 2000);
 385
 386	pm_runtime_get_sync(netdev->dev.parent);
 387
 388	if (adapter->fc_autoneg == AUTONEG_ENABLE) {
 389		hw->fc.requested_mode = e1000_fc_default;
 390		if (netif_running(adapter->netdev)) {
 391			e1000e_down(adapter, 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
 419out:
 420	pm_runtime_put_sync(netdev->dev.parent);
 421	clear_bit(__E1000_RESETTING, &adapter->state);
 422	return retval;
 423}
 424
 425static u32 e1000_get_msglevel(struct net_device *netdev)
 426{
 427	struct e1000_adapter *adapter = netdev_priv(netdev);
 428	return adapter->msg_enable;
 429}
 430
 431static void e1000_set_msglevel(struct net_device *netdev, u32 data)
 432{
 433	struct e1000_adapter *adapter = netdev_priv(netdev);
 434	adapter->msg_enable = data;
 435}
 436
 437static 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
 443static void e1000_get_regs(struct net_device *netdev,
 444			   struct ethtool_regs *regs, void *p)
 445{
 446	struct e1000_adapter *adapter = netdev_priv(netdev);
 447	struct e1000_hw *hw = &adapter->hw;
 448	u32 *regs_buff = p;
 449	u16 phy_data;
 450
 451	pm_runtime_get_sync(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, &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, &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, &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(netdev->dev.parent);
 500}
 501
 502static int e1000_get_eeprom_len(struct net_device *netdev)
 503{
 504	struct e1000_adapter *adapter = netdev_priv(netdev);
 505	return adapter->hw.nvm.word_size * 2;
 506}
 507
 508static int e1000_get_eeprom(struct net_device *netdev,
 509			    struct ethtool_eeprom *eeprom, u8 *bytes)
 510{
 511	struct e1000_adapter *adapter = netdev_priv(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(last_word - first_word + 1, sizeof(u16),
 528				    GFP_KERNEL);
 529	if (!eeprom_buff)
 530		return -ENOMEM;
 531
 532	pm_runtime_get_sync(netdev->dev.parent);
 533
 534	if (hw->nvm.type == e1000_nvm_eeprom_spi) {
 535		ret_val = e1000_read_nvm(hw, first_word,
 536					 last_word - first_word + 1,
 537					 eeprom_buff);
 538	} else {
 539		for (i = 0; i < last_word - first_word + 1; i++) {
 540			ret_val = e1000_read_nvm(hw, first_word + i, 1,
 541						 &eeprom_buff[i]);
 542			if (ret_val)
 543				break;
 544		}
 545	}
 546
 547	pm_runtime_put_sync(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(eeprom_buff);
 561
 562	return ret_val;
 563}
 564
 565static int e1000_set_eeprom(struct net_device *netdev,
 566			    struct ethtool_eeprom *eeprom, u8 *bytes)
 567{
 568	struct e1000_adapter *adapter = netdev_priv(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(max_len, GFP_KERNEL);
 593	if (!eeprom_buff)
 594		return -ENOMEM;
 595
 596	ptr = (void *)eeprom_buff;
 597
 598	pm_runtime_get_sync(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, first_word, 1, &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, last_word, 1,
 610					 &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, first_word,
 625				  last_word - first_word + 1, 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
 639out:
 640	pm_runtime_put_sync(netdev->dev.parent);
 641	kfree(eeprom_buff);
 642	return ret_val;
 643}
 644
 645static void e1000_get_drvinfo(struct net_device *netdev,
 646			      struct ethtool_drvinfo *drvinfo)
 647{
 648	struct e1000_adapter *adapter = netdev_priv(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(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 656		 "%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
 665static 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(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
 678static 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(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(__E1000_RESETTING, &adapter->state))
 706		usleep_range(1000, 2000);
 707
 708	if (!netif_running(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(netdev->dev.parent);
 737
 738	e1000e_down(adapter, 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(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(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(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(adapter->rx_ring);
 767		memcpy(adapter->rx_ring, temp_rx, size);
 768		adapter->rx_ring_count = new_rx_count;
 769	}
 770
 771err_setup_rx:
 772	if (err && set_tx)
 773		e1000e_free_tx_resources(temp_tx);
 774err_setup:
 775	e1000e_up(adapter);
 776	pm_runtime_put_sync(netdev->dev.parent);
 777free_temp:
 778	vfree(temp_tx);
 779	vfree(temp_rx);
 780clear_reset:
 781	clear_bit(__E1000_RESETTING, &adapter->state);
 782	return err;
 783}
 784
 785static 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
 807static 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(&adapter->hw, reg, write & mask);
 813	val = __er32(&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
 837static 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
 969static 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(&adapter->hw, i, 1, &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
 992static 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(netdev);
 996	struct e1000_hw *hw = &adapter->hw;
 997
 998	adapter->test_icr |= er32(ICR);
 999
1000	return IRQ_HANDLED;
1001}
1002
1003static 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, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
1025			 netdev)) {
1026		shared_int = 0;
1027	} else if (request_irq(irq, e1000_test_intr, IRQF_SHARED, netdev->name,
1028			       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(10000, 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(10000, 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(10000, 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(10000, 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(10000, 11000);
1119
1120	/* Unhook test interrupt handler */
1121	free_irq(irq, netdev);
1122
1123out:
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
1133static 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(&pdev->dev, tx_ring->size, tx_ring->desc,
1168				  tx_ring->dma);
1169		tx_ring->desc = NULL;
1170	}
1171	if (rx_ring->desc) {
1172		dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
1173				  rx_ring->dma);
1174		rx_ring->desc = NULL;
1175	}
1176
1177	kfree(tx_ring->buffer_info);
1178	tx_ring->buffer_info = NULL;
1179	kfree(rx_ring->buffer_info);
1180	rx_ring->buffer_info = NULL;
1181}
1182
1183static 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(tx_ring->count,
1199				       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(&pdev->dev, tx_ring->size,
1208					   &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(skb_size, GFP_KERNEL);
1231		if (!skb) {
1232			ret_val = 3;
1233			goto err_nomem;
1234		}
1235		skb_put(skb, 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(&pdev->dev,
1242				      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(rx_ring->count,
1260				       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(&pdev->dev, rx_ring->size,
1268					   &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(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(&pdev->dev,
1306				      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
1318err_nomem:
1319	e1000_free_desc_rings(adapter);
1320	return ret_val;
1321}
1322
1323static 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(&adapter->hw, 29, 0x001F);
1327	e1e_wphy(&adapter->hw, 30, 0x8FFC);
1328	e1e_wphy(&adapter->hw, 29, 0x001A);
1329	e1e_wphy(&adapter->hw, 30, 0x8FF0);
1330}
1331
1332static 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, 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(500, 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, 0x0808);
1365		/* reset to update Auto-MDI/MDIX */
1366		e1e_wphy(hw, MII_BMCR, 0x9140);
1367		/* autoneg off */
1368		e1e_wphy(hw, MII_BMCR, 0x8140);
1369		break;
1370	case e1000_phy_gg82563:
1371		e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC);
1372		break;
1373	case e1000_phy_bm:
1374		/* Set Default MAC Interface speed to 1GB */
1375		e1e_rphy(hw, PHY_REG(2, 21), &phy_reg);
1376		phy_reg &= ~0x0007;
1377		phy_reg |= 0x006;
1378		e1e_wphy(hw, PHY_REG(2, 21), phy_reg);
1379		/* Assert SW reset for above settings to take effect */
1380		hw->phy.ops.commit(hw);
1381		usleep_range(1000, 2000);
1382		/* Force Full Duplex */
1383		e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1384		e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C);
1385		/* Set Link Up (in force link) */
1386		e1e_rphy(hw, PHY_REG(776, 16), &phy_reg);
1387		e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040);
1388		/* Force Link */
1389		e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1390		e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040);
1391		/* Set Early Link Enable */
1392		e1e_rphy(hw, PHY_REG(769, 20), &phy_reg);
1393		e1e_wphy(hw, PHY_REG(769, 20), 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, 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), &phy_reg);
1409		e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~BIT(3));
1410		/* Disable full chip energy detect */
1411		e1e_rphy(hw, PHY_REG(776, 18), &phy_reg);
1412		e1e_wphy(hw, PHY_REG(776, 18), phy_reg | 1);
1413		/* Enable loopback on the PHY */
 
1414		e1e_wphy(hw, I82577_PHY_LBK_CTRL, 0x8001);
1415		break;
1416	default:
1417		break;
1418	}
1419
1420	/* force 1000, set loopback */
1421	e1e_wphy(hw, MII_BMCR, 0x4140);
1422	msleep(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(500, 1000);
1455
1456	return 0;
1457}
1458
1459static 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(10000, 11000);
1493
1494	return 0;
1495}
1496
1497/* only call this for fiber/serdes connections to es2lan */
1498static 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
1533static 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
1570static 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(10000, 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, 0x180);
1620		e1e_rphy(hw, MII_BMCR, &phy_reg);
1621		if (phy_reg & BMCR_LOOPBACK) {
1622			phy_reg &= ~BMCR_LOOPBACK;
1623			e1e_wphy(hw, MII_BMCR, phy_reg);
1624			if (hw->phy.ops.commit)
1625				hw->phy.ops.commit(hw);
1626		}
1627		break;
1628	}
1629}
1630
1631static 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
1641static 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
1652static 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(buffer_info->skb, 1024);
1686			dma_sync_single_for_device(&pdev->dev,
1687						   buffer_info->dma,
1688						   buffer_info->length,
1689						   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(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(&pdev->dev,
1704						buffer_info->dma, 2048,
1705						DMA_FROM_DEVICE);
1706
1707			ret_val = e1000_check_lbtest_frame(buffer_info->skb,
1708							   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
1731static 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
1754err_loopback:
1755	e1000_free_desc_rings(adapter);
1756out:
1757	return *data;
1758}
1759
1760static 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(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(5000);
1788
1789		if (!(er32(STATUS) & E1000_STATUS_LU))
1790			*data = 1;
1791	}
1792	return *data;
1793}
1794
1795static 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
1810static void e1000_diag_test(struct net_device *netdev,
1811			    struct ethtool_test *eth_test, u64 *data)
1812{
1813	struct e1000_adapter *adapter = netdev_priv(netdev);
1814	u16 autoneg_advertised;
1815	u8 forced_speed_duplex;
1816	u8 autoneg;
1817	bool if_running = netif_running(netdev);
1818
1819	pm_runtime_get_sync(netdev->dev.parent);
1820
1821	set_bit(__E1000_TESTING, &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[0]))
1850			eth_test->flags |= ETH_TEST_FL_FAILED;
1851
1852		e1000e_reset(adapter);
1853		if (e1000_eeprom_test(adapter, &data[1]))
1854			eth_test->flags |= ETH_TEST_FL_FAILED;
1855
1856		e1000e_reset(adapter);
1857		if (e1000_intr_test(adapter, &data[2]))
1858			eth_test->flags |= ETH_TEST_FL_FAILED;
1859
1860		e1000e_reset(adapter);
1861		if (e1000_loopback_test(adapter, &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[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(__E1000_TESTING, &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[4]))
1893			eth_test->flags |= ETH_TEST_FL_FAILED;
1894
1895		clear_bit(__E1000_TESTING, &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(4 * 1000);
1906
1907	pm_runtime_put_sync(netdev->dev.parent);
1908}
1909
1910static void e1000_get_wol(struct net_device *netdev,
1911			  struct ethtool_wolinfo *wol)
1912{
1913	struct e1000_adapter *adapter = netdev_priv(netdev);
1914
1915	wol->supported = 0;
1916	wol->wolopts = 0;
1917
1918	if (!(adapter->flags & FLAG_HAS_WOL) ||
1919	    !device_can_wakeup(&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
1945static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1946{
1947	struct e1000_adapter *adapter = netdev_priv(netdev);
1948
1949	if (!(adapter->flags & FLAG_HAS_WOL) ||
1950	    !device_can_wakeup(&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(&adapter->pdev->dev, adapter->wol);
1970
1971	return 0;
1972}
1973
1974static int e1000_set_phys_id(struct net_device *netdev,
1975			     enum ethtool_phys_id_state state)
1976{
1977	struct e1000_adapter *adapter = netdev_priv(netdev);
1978	struct e1000_hw *hw = &adapter->hw;
1979
1980	switch (state) {
1981	case ETHTOOL_ID_ACTIVE:
1982		pm_runtime_get_sync(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, 0);
1993		hw->mac.ops.led_off(hw);
1994		hw->mac.ops.cleanup_led(hw);
1995		pm_runtime_put_sync(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
2010static 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(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
2025static 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(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(netdev->dev.parent);
2050
2051	if (adapter->itr_setting != 0)
2052		e1000e_write_itr(adapter, adapter->itr);
2053	else
2054		e1000e_write_itr(adapter, 0);
2055
2056	pm_runtime_put_sync(netdev->dev.parent);
2057
2058	return 0;
2059}
2060
2061static int e1000_nway_reset(struct net_device *netdev)
2062{
2063	struct e1000_adapter *adapter = netdev_priv(netdev);
2064
2065	if (!netif_running(netdev))
2066		return -EAGAIN;
2067
2068	if (!adapter->hw.mac.autoneg)
2069		return -EINVAL;
2070
2071	pm_runtime_get_sync(netdev->dev.parent);
2072	e1000e_reinit_locked(adapter);
2073	pm_runtime_put_sync(netdev->dev.parent);
2074
2075	return 0;
2076}
2077
2078static 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(netdev);
2083	struct rtnl_link_stats64 net_stats;
2084	int i;
2085	char *p = NULL;
2086
2087	pm_runtime_get_sync(netdev->dev.parent);
2088
2089	dev_get_stats(netdev, &net_stats);
2090
2091	pm_runtime_put_sync(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
2113static 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
2137static 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(netdev);
2146		struct e1000_hw *hw = &adapter->hw;
2147		u32 mrqc;
2148
2149		pm_runtime_get_sync(netdev->dev.parent);
2150		mrqc = er32(MRQC);
2151		pm_runtime_put_sync(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
2189static int e1000e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
2190{
2191	struct e1000_adapter *adapter = netdev_priv(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(netdev->dev.parent);
2215
2216	ret_val = hw->phy.ops.acquire(hw);
2217	if (ret_val) {
2218		pm_runtime_put_sync(netdev->dev.parent);
2219		return -EBUSY;
2220	}
2221
2222	/* EEE Capability */
2223	ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);
2224	if (ret_val)
2225		goto release;
2226	edata->supported = mmd_eee_cap_to_ethtool_sup_t(phy_data);
2227
2228	/* EEE Advertised */
2229	edata->advertised = mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
2230
2231	/* EEE Link Partner Advertised */
2232	ret_val = e1000_read_emi_reg_locked(hw, lpa_addr, &phy_data);
2233	if (ret_val)
2234		goto release;
2235	edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
2236
2237	/* EEE PCS Status */
2238	ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &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
2255release:
2256	hw->phy.ops.release(hw);
2257	if (ret_val)
2258		ret_val = -ENODATA;
2259
2260	pm_runtime_put_sync(netdev->dev.parent);
2261
2262	return ret_val;
2263}
2264
2265static int e1000e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
2266{
2267	struct e1000_adapter *adapter = netdev_priv(netdev);
2268	struct e1000_hw *hw = &adapter->hw;
2269	struct ethtool_eee eee_curr;
2270	s32 ret_val;
2271
2272	ret_val = e1000e_get_eee(netdev, &eee_curr);
2273	if (ret_val)
2274		return ret_val;
2275
2276	if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
2277		e_err("Setting EEE tx-lpi is not supported\n");
2278		return -EINVAL;
2279	}
2280
2281	if (eee_curr.tx_lpi_timer != edata->tx_lpi_timer) {
2282		e_err("Setting EEE Tx LPI timer is not supported\n");
2283		return -EINVAL;
2284	}
2285
2286	if (edata->advertised & ~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL)) {
2287		e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");
2288		return -EINVAL;
2289	}
2290
2291	adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
2292
2293	hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;
2294
2295	pm_runtime_get_sync(netdev->dev.parent);
2296
2297	/* reset the link */
2298	if (netif_running(netdev))
2299		e1000e_reinit_locked(adapter);
2300	else
2301		e1000e_reset(adapter);
2302
2303	pm_runtime_put_sync(netdev->dev.parent);
2304
2305	return 0;
2306}
2307
2308static int e1000e_get_ts_info(struct net_device *netdev,
2309			      struct ethtool_ts_info *info)
2310{
2311	struct e1000_adapter *adapter = netdev_priv(netdev);
2312
2313	ethtool_op_get_ts_info(netdev, info);
2314
2315	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
2316		return 0;
2317
2318	info->so_timestamping |= (SOF_TIMESTAMPING_TX_HARDWARE |
2319				  SOF_TIMESTAMPING_RX_HARDWARE |
2320				  SOF_TIMESTAMPING_RAW_HARDWARE);
2321
2322	info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
2323
2324	info->rx_filters = (BIT(HWTSTAMP_FILTER_NONE) |
2325			    BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
2326			    BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
2327			    BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
2328			    BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
2329			    BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
2330			    BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
2331			    BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
2332			    BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |
2333			    BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
2334			    BIT(HWTSTAMP_FILTER_ALL));
2335
2336	if (adapter->ptp_clock)
2337		info->phc_index = ptp_clock_index(adapter->ptp_clock);
2338
2339	return 0;
2340}
2341
2342static u32 e1000e_get_priv_flags(struct net_device *netdev)
2343{
2344	struct e1000_adapter *adapter = netdev_priv(netdev);
2345	u32 priv_flags = 0;
2346
2347	if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
2348		priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;
2349
2350	return priv_flags;
2351}
2352
2353static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)
2354{
2355	struct e1000_adapter *adapter = netdev_priv(netdev);
2356	unsigned int flags2 = adapter->flags2;
2357
2358	flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;
2359	if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {
2360		struct e1000_hw *hw = &adapter->hw;
2361
2362		if (hw->mac.type < e1000_pch_cnp)
2363			return -EINVAL;
2364		flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
2365	}
2366
2367	if (flags2 != adapter->flags2)
2368		adapter->flags2 = flags2;
2369
2370	return 0;
2371}
2372
2373static const struct ethtool_ops e1000_ethtool_ops = {
2374	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
 
2375	.get_drvinfo		= e1000_get_drvinfo,
2376	.get_regs_len		= e1000_get_regs_len,
2377	.get_regs		= e1000_get_regs,
2378	.get_wol		= e1000_get_wol,
2379	.set_wol		= e1000_set_wol,
2380	.get_msglevel		= e1000_get_msglevel,
2381	.set_msglevel		= e1000_set_msglevel,
2382	.nway_reset		= e1000_nway_reset,
2383	.get_link		= ethtool_op_get_link,
2384	.get_eeprom_len		= e1000_get_eeprom_len,
2385	.get_eeprom		= e1000_get_eeprom,
2386	.set_eeprom		= e1000_set_eeprom,
2387	.get_ringparam		= e1000_get_ringparam,
2388	.set_ringparam		= e1000_set_ringparam,
2389	.get_pauseparam		= e1000_get_pauseparam,
2390	.set_pauseparam		= e1000_set_pauseparam,
2391	.self_test		= e1000_diag_test,
2392	.get_strings		= e1000_get_strings,
2393	.set_phys_id		= e1000_set_phys_id,
2394	.get_ethtool_stats	= e1000_get_ethtool_stats,
2395	.get_sset_count		= e1000e_get_sset_count,
2396	.get_coalesce		= e1000_get_coalesce,
2397	.set_coalesce		= e1000_set_coalesce,
2398	.get_rxnfc		= e1000_get_rxnfc,
2399	.get_ts_info		= e1000e_get_ts_info,
2400	.get_eee		= e1000e_get_eee,
2401	.set_eee		= e1000e_set_eee,
2402	.get_link_ksettings	= e1000_get_link_ksettings,
2403	.set_link_ksettings	= e1000_set_link_ksettings,
2404	.get_priv_flags		= e1000e_get_priv_flags,
2405	.set_priv_flags		= e1000e_set_priv_flags,
2406};
2407
2408void e1000e_set_ethtool_ops(struct net_device *netdev)
2409{
2410	netdev->ethtool_ops = &e1000_ethtool_ops;
2411}