1// SPDX-License-Identifier: GPL-2.0
   2/*******************************************************************************
   3 * Intel PRO/1000 Linux driver
   4 * Copyright(c) 1999 - 2006 Intel Corporation.
   5 *
   6 * This program is free software; you can redistribute it and/or modify it
   7 * under the terms and conditions of the GNU General Public License,
   8 * version 2, as published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope it will be useful, but WITHOUT
  11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13 * more details.
  14 *
  15 * The full GNU General Public License is included in this distribution in
  16 * the file called "COPYING".
  17 *
  18 * Contact Information:
  19 * Linux NICS <linux.nics@intel.com>
  20 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  21 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  22 *
  23 ******************************************************************************/
  24
  25/* ethtool support for e1000 */
  26
  27#include "e1000.h"
  28#include <linux/jiffies.h>
  29#include <linux/uaccess.h>
  30
  31enum {NETDEV_STATS, E1000_STATS};
  32
  33struct e1000_stats {
  34	char stat_string[ETH_GSTRING_LEN];
  35	int type;
  36	int sizeof_stat;
  37	int stat_offset;
  38};
  39
  40#define E1000_STAT(m)		E1000_STATS, \
  41				sizeof(((struct e1000_adapter *)0)->m), \
  42				offsetof(struct e1000_adapter, m)
  43#define E1000_NETDEV_STAT(m)	NETDEV_STATS, \
  44				sizeof(((struct net_device *)0)->m), \
  45				offsetof(struct net_device, m)
  46
  47static const struct e1000_stats e1000_gstrings_stats[] = {
  48	{ "rx_packets", E1000_STAT(stats.gprc) },
  49	{ "tx_packets", E1000_STAT(stats.gptc) },
  50	{ "rx_bytes", E1000_STAT(stats.gorcl) },
  51	{ "tx_bytes", E1000_STAT(stats.gotcl) },
  52	{ "rx_broadcast", E1000_STAT(stats.bprc) },
  53	{ "tx_broadcast", E1000_STAT(stats.bptc) },
  54	{ "rx_multicast", E1000_STAT(stats.mprc) },
  55	{ "tx_multicast", E1000_STAT(stats.mptc) },
  56	{ "rx_errors", E1000_STAT(stats.rxerrc) },
  57	{ "tx_errors", E1000_STAT(stats.txerrc) },
  58	{ "tx_dropped", E1000_NETDEV_STAT(stats.tx_dropped) },
  59	{ "multicast", E1000_STAT(stats.mprc) },
  60	{ "collisions", E1000_STAT(stats.colc) },
  61	{ "rx_length_errors", E1000_STAT(stats.rlerrc) },
  62	{ "rx_over_errors", E1000_NETDEV_STAT(stats.rx_over_errors) },
  63	{ "rx_crc_errors", E1000_STAT(stats.crcerrs) },
  64	{ "rx_frame_errors", E1000_NETDEV_STAT(stats.rx_frame_errors) },
  65	{ "rx_no_buffer_count", E1000_STAT(stats.rnbc) },
  66	{ "rx_missed_errors", E1000_STAT(stats.mpc) },
  67	{ "tx_aborted_errors", E1000_STAT(stats.ecol) },
  68	{ "tx_carrier_errors", E1000_STAT(stats.tncrs) },
  69	{ "tx_fifo_errors", E1000_NETDEV_STAT(stats.tx_fifo_errors) },
  70	{ "tx_heartbeat_errors", E1000_NETDEV_STAT(stats.tx_heartbeat_errors) },
  71	{ "tx_window_errors", E1000_STAT(stats.latecol) },
  72	{ "tx_abort_late_coll", E1000_STAT(stats.latecol) },
  73	{ "tx_deferred_ok", E1000_STAT(stats.dc) },
  74	{ "tx_single_coll_ok", E1000_STAT(stats.scc) },
  75	{ "tx_multi_coll_ok", E1000_STAT(stats.mcc) },
  76	{ "tx_timeout_count", E1000_STAT(tx_timeout_count) },
  77	{ "tx_restart_queue", E1000_STAT(restart_queue) },
  78	{ "rx_long_length_errors", E1000_STAT(stats.roc) },
  79	{ "rx_short_length_errors", E1000_STAT(stats.ruc) },
  80	{ "rx_align_errors", E1000_STAT(stats.algnerrc) },
  81	{ "tx_tcp_seg_good", E1000_STAT(stats.tsctc) },
  82	{ "tx_tcp_seg_failed", E1000_STAT(stats.tsctfc) },
  83	{ "rx_flow_control_xon", E1000_STAT(stats.xonrxc) },
  84	{ "rx_flow_control_xoff", E1000_STAT(stats.xoffrxc) },
  85	{ "tx_flow_control_xon", E1000_STAT(stats.xontxc) },
  86	{ "tx_flow_control_xoff", E1000_STAT(stats.xofftxc) },
  87	{ "rx_long_byte_count", E1000_STAT(stats.gorcl) },
  88	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },
  89	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },
  90	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },
  91	{ "tx_smbus", E1000_STAT(stats.mgptc) },
  92	{ "rx_smbus", E1000_STAT(stats.mgprc) },
  93	{ "dropped_smbus", E1000_STAT(stats.mgpdc) },
  94};
  95
  96#define E1000_QUEUE_STATS_LEN 0
  97#define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)
  98#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN)
  99static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
 100	"Register test  (offline)", "Eeprom test    (offline)",
 101	"Interrupt test (offline)", "Loopback test  (offline)",
 102	"Link test   (on/offline)"
 103};
 104
 105#define E1000_TEST_LEN	ARRAY_SIZE(e1000_gstrings_test)
 106
 107static int e1000_get_link_ksettings(struct net_device *netdev,
 108				    struct ethtool_link_ksettings *cmd)
 109{
 110	struct e1000_adapter *adapter = netdev_priv(netdev);
 111	struct e1000_hw *hw = &adapter->hw;
 112	u32 supported, advertising;
 113
 114	if (hw->media_type == e1000_media_type_copper) {
 115		supported = (SUPPORTED_10baseT_Half |
 116			     SUPPORTED_10baseT_Full |
 117			     SUPPORTED_100baseT_Half |
 118			     SUPPORTED_100baseT_Full |
 119			     SUPPORTED_1000baseT_Full|
 120			     SUPPORTED_Autoneg |
 121			     SUPPORTED_TP);
 122		advertising = ADVERTISED_TP;
 123
 124		if (hw->autoneg == 1) {
 125			advertising |= ADVERTISED_Autoneg;
 126			/* the e1000 autoneg seems to match ethtool nicely */
 127			advertising |= hw->autoneg_advertised;
 128		}
 129
 130		cmd->base.port = PORT_TP;
 131		cmd->base.phy_address = hw->phy_addr;
 132	} else {
 133		supported   = (SUPPORTED_1000baseT_Full |
 134			       SUPPORTED_FIBRE |
 135			       SUPPORTED_Autoneg);
 136
 137		advertising = (ADVERTISED_1000baseT_Full |
 138			       ADVERTISED_FIBRE |
 139			       ADVERTISED_Autoneg);
 140
 141		cmd->base.port = PORT_FIBRE;
 142	}
 143
 144	if (er32(STATUS) & E1000_STATUS_LU) {
 145		e1000_get_speed_and_duplex(hw, &adapter->link_speed,
 146					   &adapter->link_duplex);
 147		cmd->base.speed = adapter->link_speed;
 148
 149		/* unfortunately FULL_DUPLEX != DUPLEX_FULL
 150		 * and HALF_DUPLEX != DUPLEX_HALF
 151		 */
 152		if (adapter->link_duplex == FULL_DUPLEX)
 153			cmd->base.duplex = DUPLEX_FULL;
 154		else
 155			cmd->base.duplex = DUPLEX_HALF;
 156	} else {
 157		cmd->base.speed = SPEED_UNKNOWN;
 158		cmd->base.duplex = DUPLEX_UNKNOWN;
 159	}
 160
 161	cmd->base.autoneg = ((hw->media_type == e1000_media_type_fiber) ||
 162			 hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
 163
 164	/* MDI-X => 1; MDI => 0 */
 165	if ((hw->media_type == e1000_media_type_copper) &&
 166	    netif_carrier_ok(netdev))
 167		cmd->base.eth_tp_mdix = (!!adapter->phy_info.mdix_mode ?
 168				     ETH_TP_MDI_X : ETH_TP_MDI);
 169	else
 170		cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
 171
 172	if (hw->mdix == AUTO_ALL_MODES)
 173		cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
 174	else
 175		cmd->base.eth_tp_mdix_ctrl = hw->mdix;
 176
 177	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 178						supported);
 179	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 180						advertising);
 181
 182	return 0;
 183}
 184
 185static int e1000_set_link_ksettings(struct net_device *netdev,
 186				    const struct ethtool_link_ksettings *cmd)
 187{
 188	struct e1000_adapter *adapter = netdev_priv(netdev);
 189	struct e1000_hw *hw = &adapter->hw;
 190	u32 advertising;
 191
 192	ethtool_convert_link_mode_to_legacy_u32(&advertising,
 193						cmd->link_modes.advertising);
 194
 195	/* MDI setting is only allowed when autoneg enabled because
 196	 * some hardware doesn't allow MDI setting when speed or
 197	 * duplex is forced.
 198	 */
 199	if (cmd->base.eth_tp_mdix_ctrl) {
 200		if (hw->media_type != e1000_media_type_copper)
 201			return -EOPNOTSUPP;
 202
 203		if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
 204		    (cmd->base.autoneg != AUTONEG_ENABLE)) {
 205			e_err(drv, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
 206			return -EINVAL;
 207		}
 208	}
 209
 210	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 211		msleep(1);
 212
 213	if (cmd->base.autoneg == AUTONEG_ENABLE) {
 214		hw->autoneg = 1;
 215		if (hw->media_type == e1000_media_type_fiber)
 216			hw->autoneg_advertised = ADVERTISED_1000baseT_Full |
 217						 ADVERTISED_FIBRE |
 218						 ADVERTISED_Autoneg;
 219		else
 220			hw->autoneg_advertised = advertising |
 221						 ADVERTISED_TP |
 222						 ADVERTISED_Autoneg;
 223	} else {
 224		u32 speed = cmd->base.speed;
 225		/* calling this overrides forced MDI setting */
 226		if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {
 227			clear_bit(__E1000_RESETTING, &adapter->flags);
 228			return -EINVAL;
 229		}
 230	}
 231
 232	/* MDI-X => 2; MDI => 1; Auto => 3 */
 233	if (cmd->base.eth_tp_mdix_ctrl) {
 234		if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
 235			hw->mdix = AUTO_ALL_MODES;
 236		else
 237			hw->mdix = cmd->base.eth_tp_mdix_ctrl;
 238	}
 239
 240	/* reset the link */
 241
 242	if (netif_running(adapter->netdev)) {
 243		e1000_down(adapter);
 244		e1000_up(adapter);
 245	} else {
 246		e1000_reset(adapter);
 247	}
 248	clear_bit(__E1000_RESETTING, &adapter->flags);
 249	return 0;
 250}
 251
 252static u32 e1000_get_link(struct net_device *netdev)
 253{
 254	struct e1000_adapter *adapter = netdev_priv(netdev);
 255
 256	/* If the link is not reported up to netdev, interrupts are disabled,
 257	 * and so the physical link state may have changed since we last
 258	 * looked. Set get_link_status to make sure that the true link
 259	 * state is interrogated, rather than pulling a cached and possibly
 260	 * stale link state from the driver.
 261	 */
 262	if (!netif_carrier_ok(netdev))
 263		adapter->hw.get_link_status = 1;
 264
 265	return e1000_has_link(adapter);
 266}
 267
 268static void e1000_get_pauseparam(struct net_device *netdev,
 269				 struct ethtool_pauseparam *pause)
 270{
 271	struct e1000_adapter *adapter = netdev_priv(netdev);
 272	struct e1000_hw *hw = &adapter->hw;
 273
 274	pause->autoneg =
 275		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 276
 277	if (hw->fc == E1000_FC_RX_PAUSE) {
 278		pause->rx_pause = 1;
 279	} else if (hw->fc == E1000_FC_TX_PAUSE) {
 280		pause->tx_pause = 1;
 281	} else if (hw->fc == E1000_FC_FULL) {
 282		pause->rx_pause = 1;
 283		pause->tx_pause = 1;
 284	}
 285}
 286
 287static int e1000_set_pauseparam(struct net_device *netdev,
 288				struct ethtool_pauseparam *pause)
 289{
 290	struct e1000_adapter *adapter = netdev_priv(netdev);
 291	struct e1000_hw *hw = &adapter->hw;
 292	int retval = 0;
 293
 294	adapter->fc_autoneg = pause->autoneg;
 295
 296	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 297		msleep(1);
 298
 299	if (pause->rx_pause && pause->tx_pause)
 300		hw->fc = E1000_FC_FULL;
 301	else if (pause->rx_pause && !pause->tx_pause)
 302		hw->fc = E1000_FC_RX_PAUSE;
 303	else if (!pause->rx_pause && pause->tx_pause)
 304		hw->fc = E1000_FC_TX_PAUSE;
 305	else if (!pause->rx_pause && !pause->tx_pause)
 306		hw->fc = E1000_FC_NONE;
 307
 308	hw->original_fc = hw->fc;
 309
 310	if (adapter->fc_autoneg == AUTONEG_ENABLE) {
 311		if (netif_running(adapter->netdev)) {
 312			e1000_down(adapter);
 313			e1000_up(adapter);
 314		} else {
 315			e1000_reset(adapter);
 316		}
 317	} else
 318		retval = ((hw->media_type == e1000_media_type_fiber) ?
 319			  e1000_setup_link(hw) : e1000_force_mac_fc(hw));
 320
 321	clear_bit(__E1000_RESETTING, &adapter->flags);
 322	return retval;
 323}
 324
 325static u32 e1000_get_msglevel(struct net_device *netdev)
 326{
 327	struct e1000_adapter *adapter = netdev_priv(netdev);
 328
 329	return adapter->msg_enable;
 330}
 331
 332static void e1000_set_msglevel(struct net_device *netdev, u32 data)
 333{
 334	struct e1000_adapter *adapter = netdev_priv(netdev);
 335
 336	adapter->msg_enable = data;
 337}
 338
 339static int e1000_get_regs_len(struct net_device *netdev)
 340{
 341#define E1000_REGS_LEN 32
 342	return E1000_REGS_LEN * sizeof(u32);
 343}
 344
 345static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
 346			   void *p)
 347{
 348	struct e1000_adapter *adapter = netdev_priv(netdev);
 349	struct e1000_hw *hw = &adapter->hw;
 350	u32 *regs_buff = p;
 351	u16 phy_data;
 352
 353	memset(p, 0, E1000_REGS_LEN * sizeof(u32));
 354
 355	regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
 356
 357	regs_buff[0]  = er32(CTRL);
 358	regs_buff[1]  = er32(STATUS);
 359
 360	regs_buff[2]  = er32(RCTL);
 361	regs_buff[3]  = er32(RDLEN);
 362	regs_buff[4]  = er32(RDH);
 363	regs_buff[5]  = er32(RDT);
 364	regs_buff[6]  = er32(RDTR);
 365
 366	regs_buff[7]  = er32(TCTL);
 367	regs_buff[8]  = er32(TDLEN);
 368	regs_buff[9]  = er32(TDH);
 369	regs_buff[10] = er32(TDT);
 370	regs_buff[11] = er32(TIDV);
 371
 372	regs_buff[12] = hw->phy_type;  /* PHY type (IGP=1, M88=0) */
 373	if (hw->phy_type == e1000_phy_igp) {
 374		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 375				    IGP01E1000_PHY_AGC_A);
 376		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &
 377				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 378		regs_buff[13] = (u32)phy_data; /* cable length */
 379		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 380				    IGP01E1000_PHY_AGC_B);
 381		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &
 382				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 383		regs_buff[14] = (u32)phy_data; /* cable length */
 384		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 385				    IGP01E1000_PHY_AGC_C);
 386		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &
 387				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 388		regs_buff[15] = (u32)phy_data; /* cable length */
 389		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 390				    IGP01E1000_PHY_AGC_D);
 391		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &
 392				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 393		regs_buff[16] = (u32)phy_data; /* cable length */
 394		regs_buff[17] = 0; /* extended 10bt distance (not needed) */
 395		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
 396		e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &
 397				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 398		regs_buff[18] = (u32)phy_data; /* cable polarity */
 399		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
 400				    IGP01E1000_PHY_PCS_INIT_REG);
 401		e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &
 402				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);
 403		regs_buff[19] = (u32)phy_data; /* cable polarity */
 404		regs_buff[20] = 0; /* polarity correction enabled (always) */
 405		regs_buff[22] = 0; /* phy receive errors (unavailable) */
 406		regs_buff[23] = regs_buff[18]; /* mdix mode */
 407		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
 408	} else {
 409		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
 410		regs_buff[13] = (u32)phy_data; /* cable length */
 411		regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 412		regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 413		regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 414		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
 415		regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
 416		regs_buff[18] = regs_buff[13]; /* cable polarity */
 417		regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 418		regs_buff[20] = regs_buff[17]; /* polarity correction */
 419		/* phy receive errors */
 420		regs_buff[22] = adapter->phy_stats.receive_errors;
 421		regs_buff[23] = regs_buff[13]; /* mdix mode */
 422	}
 423	regs_buff[21] = adapter->phy_stats.idle_errors;  /* phy idle errors */
 424	e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
 425	regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
 426	regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
 427	if (hw->mac_type >= e1000_82540 &&
 428	    hw->media_type == e1000_media_type_copper) {
 429		regs_buff[26] = er32(MANC);
 430	}
 431}
 432
 433static int e1000_get_eeprom_len(struct net_device *netdev)
 434{
 435	struct e1000_adapter *adapter = netdev_priv(netdev);
 436	struct e1000_hw *hw = &adapter->hw;
 437
 438	return hw->eeprom.word_size * 2;
 439}
 440
 441static int e1000_get_eeprom(struct net_device *netdev,
 442			    struct ethtool_eeprom *eeprom, u8 *bytes)
 443{
 444	struct e1000_adapter *adapter = netdev_priv(netdev);
 445	struct e1000_hw *hw = &adapter->hw;
 446	u16 *eeprom_buff;
 447	int first_word, last_word;
 448	int ret_val = 0;
 449	u16 i;
 450
 451	if (eeprom->len == 0)
 452		return -EINVAL;
 453
 454	eeprom->magic = hw->vendor_id | (hw->device_id << 16);
 455
 456	first_word = eeprom->offset >> 1;
 457	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 458
 459	eeprom_buff = kmalloc(sizeof(u16) *
 460			(last_word - first_word + 1), GFP_KERNEL);
 461	if (!eeprom_buff)
 462		return -ENOMEM;
 463
 464	if (hw->eeprom.type == e1000_eeprom_spi)
 465		ret_val = e1000_read_eeprom(hw, first_word,
 466					    last_word - first_word + 1,
 467					    eeprom_buff);
 468	else {
 469		for (i = 0; i < last_word - first_word + 1; i++) {
 470			ret_val = e1000_read_eeprom(hw, first_word + i, 1,
 471						    &eeprom_buff[i]);
 472			if (ret_val)
 473				break;
 474		}
 475	}
 476
 477	/* Device's eeprom is always little-endian, word addressable */
 478	for (i = 0; i < last_word - first_word + 1; i++)
 479		le16_to_cpus(&eeprom_buff[i]);
 480
 481	memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
 482	       eeprom->len);
 483	kfree(eeprom_buff);
 484
 485	return ret_val;
 486}
 487
 488static int e1000_set_eeprom(struct net_device *netdev,
 489			    struct ethtool_eeprom *eeprom, u8 *bytes)
 490{
 491	struct e1000_adapter *adapter = netdev_priv(netdev);
 492	struct e1000_hw *hw = &adapter->hw;
 493	u16 *eeprom_buff;
 494	void *ptr;
 495	int max_len, first_word, last_word, ret_val = 0;
 496	u16 i;
 497
 498	if (eeprom->len == 0)
 499		return -EOPNOTSUPP;
 500
 501	if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
 502		return -EFAULT;
 503
 504	max_len = hw->eeprom.word_size * 2;
 505
 506	first_word = eeprom->offset >> 1;
 507	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 508	eeprom_buff = kmalloc(max_len, GFP_KERNEL);
 509	if (!eeprom_buff)
 510		return -ENOMEM;
 511
 512	ptr = (void *)eeprom_buff;
 513
 514	if (eeprom->offset & 1) {
 515		/* need read/modify/write of first changed EEPROM word
 516		 * only the second byte of the word is being modified
 517		 */
 518		ret_val = e1000_read_eeprom(hw, first_word, 1,
 519					    &eeprom_buff[0]);
 520		ptr++;
 521	}
 522	if (((eeprom->offset + eeprom->len) & 1) && (ret_val == 0)) {
 523		/* need read/modify/write of last changed EEPROM word
 524		 * only the first byte of the word is being modified
 525		 */
 526		ret_val = e1000_read_eeprom(hw, last_word, 1,
 527					    &eeprom_buff[last_word - first_word]);
 528	}
 529
 530	/* Device's eeprom is always little-endian, word addressable */
 531	for (i = 0; i < last_word - first_word + 1; i++)
 532		le16_to_cpus(&eeprom_buff[i]);
 533
 534	memcpy(ptr, bytes, eeprom->len);
 535
 536	for (i = 0; i < last_word - first_word + 1; i++)
 537		eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]);
 538
 539	ret_val = e1000_write_eeprom(hw, first_word,
 540				     last_word - first_word + 1, eeprom_buff);
 541
 542	/* Update the checksum over the first part of the EEPROM if needed */
 543	if ((ret_val == 0) && (first_word <= EEPROM_CHECKSUM_REG))
 544		e1000_update_eeprom_checksum(hw);
 545
 546	kfree(eeprom_buff);
 547	return ret_val;
 548}
 549
 550static void e1000_get_drvinfo(struct net_device *netdev,
 551			      struct ethtool_drvinfo *drvinfo)
 552{
 553	struct e1000_adapter *adapter = netdev_priv(netdev);
 554
 555	strlcpy(drvinfo->driver,  e1000_driver_name,
 556		sizeof(drvinfo->driver));
 557	strlcpy(drvinfo->version, e1000_driver_version,
 558		sizeof(drvinfo->version));
 559
 560	strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 561		sizeof(drvinfo->bus_info));
 562}
 563
 564static void e1000_get_ringparam(struct net_device *netdev,
 565				struct ethtool_ringparam *ring)
 566{
 567	struct e1000_adapter *adapter = netdev_priv(netdev);
 568	struct e1000_hw *hw = &adapter->hw;
 569	e1000_mac_type mac_type = hw->mac_type;
 570	struct e1000_tx_ring *txdr = adapter->tx_ring;
 571	struct e1000_rx_ring *rxdr = adapter->rx_ring;
 572
 573	ring->rx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_RXD :
 574		E1000_MAX_82544_RXD;
 575	ring->tx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_TXD :
 576		E1000_MAX_82544_TXD;
 577	ring->rx_pending = rxdr->count;
 578	ring->tx_pending = txdr->count;
 579}
 580
 581static int e1000_set_ringparam(struct net_device *netdev,
 582			       struct ethtool_ringparam *ring)
 583{
 584	struct e1000_adapter *adapter = netdev_priv(netdev);
 585	struct e1000_hw *hw = &adapter->hw;
 586	e1000_mac_type mac_type = hw->mac_type;
 587	struct e1000_tx_ring *txdr, *tx_old;
 588	struct e1000_rx_ring *rxdr, *rx_old;
 589	int i, err;
 590
 591	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 592		return -EINVAL;
 593
 594	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 595		msleep(1);
 596
 597	if (netif_running(adapter->netdev))
 598		e1000_down(adapter);
 599
 600	tx_old = adapter->tx_ring;
 601	rx_old = adapter->rx_ring;
 602
 603	err = -ENOMEM;
 604	txdr = kcalloc(adapter->num_tx_queues, sizeof(struct e1000_tx_ring),
 605		       GFP_KERNEL);
 606	if (!txdr)
 607		goto err_alloc_tx;
 608
 609	rxdr = kcalloc(adapter->num_rx_queues, sizeof(struct e1000_rx_ring),
 610		       GFP_KERNEL);
 611	if (!rxdr)
 612		goto err_alloc_rx;
 613
 614	adapter->tx_ring = txdr;
 615	adapter->rx_ring = rxdr;
 616
 617	rxdr->count = max(ring->rx_pending, (u32)E1000_MIN_RXD);
 618	rxdr->count = min(rxdr->count, (u32)(mac_type < e1000_82544 ?
 619			  E1000_MAX_RXD : E1000_MAX_82544_RXD));
 620	rxdr->count = ALIGN(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE);
 621	txdr->count = max(ring->tx_pending, (u32)E1000_MIN_TXD);
 622	txdr->count = min(txdr->count, (u32)(mac_type < e1000_82544 ?
 623			  E1000_MAX_TXD : E1000_MAX_82544_TXD));
 624	txdr->count = ALIGN(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE);
 625
 626	for (i = 0; i < adapter->num_tx_queues; i++)
 627		txdr[i].count = txdr->count;
 628	for (i = 0; i < adapter->num_rx_queues; i++)
 629		rxdr[i].count = rxdr->count;
 630
 
 631	if (netif_running(adapter->netdev)) {
 632		/* Try to get new resources before deleting old */
 633		err = e1000_setup_all_rx_resources(adapter);
 634		if (err)
 635			goto err_setup_rx;
 636		err = e1000_setup_all_tx_resources(adapter);
 637		if (err)
 638			goto err_setup_tx;
 639
 640		/* save the new, restore the old in order to free it,
 641		 * then restore the new back again
 642		 */
 643
 644		adapter->rx_ring = rx_old;
 645		adapter->tx_ring = tx_old;
 646		e1000_free_all_rx_resources(adapter);
 647		e1000_free_all_tx_resources(adapter);
 648		kfree(tx_old);
 649		kfree(rx_old);
 650		adapter->rx_ring = rxdr;
 651		adapter->tx_ring = txdr;
 652		err = e1000_up(adapter);
 653		if (err)
 654			goto err_setup;
 655	}
 
 
 656
 657	clear_bit(__E1000_RESETTING, &adapter->flags);
 658	return 0;
 
 659err_setup_tx:
 660	e1000_free_all_rx_resources(adapter);
 661err_setup_rx:
 662	adapter->rx_ring = rx_old;
 663	adapter->tx_ring = tx_old;
 664	kfree(rxdr);
 665err_alloc_rx:
 666	kfree(txdr);
 667err_alloc_tx:
 668	e1000_up(adapter);
 669err_setup:
 670	clear_bit(__E1000_RESETTING, &adapter->flags);
 671	return err;
 672}
 673
 674static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg,
 675			     u32 mask, u32 write)
 676{
 677	struct e1000_hw *hw = &adapter->hw;
 678	static const u32 test[] = {
 679		0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
 680	};
 681	u8 __iomem *address = hw->hw_addr + reg;
 682	u32 read;
 683	int i;
 684
 685	for (i = 0; i < ARRAY_SIZE(test); i++) {
 686		writel(write & test[i], address);
 687		read = readl(address);
 688		if (read != (write & test[i] & mask)) {
 689			e_err(drv, "pattern test reg %04X failed: "
 690			      "got 0x%08X expected 0x%08X\n",
 691			      reg, read, (write & test[i] & mask));
 692			*data = reg;
 693			return true;
 694		}
 695	}
 696	return false;
 697}
 698
 699static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg,
 700			      u32 mask, u32 write)
 701{
 702	struct e1000_hw *hw = &adapter->hw;
 703	u8 __iomem *address = hw->hw_addr + reg;
 704	u32 read;
 705
 706	writel(write & mask, address);
 707	read = readl(address);
 708	if ((read & mask) != (write & mask)) {
 709		e_err(drv, "set/check reg %04X test failed: "
 710		      "got 0x%08X expected 0x%08X\n",
 711		      reg, (read & mask), (write & mask));
 712		*data = reg;
 713		return true;
 714	}
 715	return false;
 716}
 717
 718#define REG_PATTERN_TEST(reg, mask, write)			     \
 719	do {							     \
 720		if (reg_pattern_test(adapter, data,		     \
 721			     (hw->mac_type >= e1000_82543)   \
 722			     ? E1000_##reg : E1000_82542_##reg,	     \
 723			     mask, write))			     \
 724			return 1;				     \
 725	} while (0)
 726
 727#define REG_SET_AND_CHECK(reg, mask, write)			     \
 728	do {							     \
 729		if (reg_set_and_check(adapter, data,		     \
 730			      (hw->mac_type >= e1000_82543)  \
 731			      ? E1000_##reg : E1000_82542_##reg,     \
 732			      mask, write))			     \
 733			return 1;				     \
 734	} while (0)
 735
 736static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
 737{
 738	u32 value, before, after;
 739	u32 i, toggle;
 740	struct e1000_hw *hw = &adapter->hw;
 741
 742	/* The status register is Read Only, so a write should fail.
 743	 * Some bits that get toggled are ignored.
 744	 */
 745
 746	/* there are several bits on newer hardware that are r/w */
 747	toggle = 0xFFFFF833;
 748
 749	before = er32(STATUS);
 750	value = (er32(STATUS) & toggle);
 751	ew32(STATUS, toggle);
 752	after = er32(STATUS) & toggle;
 753	if (value != after) {
 754		e_err(drv, "failed STATUS register test got: "
 755		      "0x%08X expected: 0x%08X\n", after, value);
 756		*data = 1;
 757		return 1;
 758	}
 759	/* restore previous status */
 760	ew32(STATUS, before);
 761
 762	REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
 763	REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF);
 764	REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF);
 765	REG_PATTERN_TEST(VET, 0x0000FFFF, 0xFFFFFFFF);
 766
 767	REG_PATTERN_TEST(RDTR, 0x0000FFFF, 0xFFFFFFFF);
 768	REG_PATTERN_TEST(RDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
 769	REG_PATTERN_TEST(RDLEN, 0x000FFF80, 0x000FFFFF);
 770	REG_PATTERN_TEST(RDH, 0x0000FFFF, 0x0000FFFF);
 771	REG_PATTERN_TEST(RDT, 0x0000FFFF, 0x0000FFFF);
 772	REG_PATTERN_TEST(FCRTH, 0x0000FFF8, 0x0000FFF8);
 773	REG_PATTERN_TEST(FCTTV, 0x0000FFFF, 0x0000FFFF);
 774	REG_PATTERN_TEST(TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
 775	REG_PATTERN_TEST(TDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
 776	REG_PATTERN_TEST(TDLEN, 0x000FFF80, 0x000FFFFF);
 777
 778	REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000);
 779
 780	before = 0x06DFB3FE;
 781	REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB);
 782	REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000);
 783
 784	if (hw->mac_type >= e1000_82543) {
 785		REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF);
 786		REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
 787		REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF);
 788		REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
 789		REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF);
 790		value = E1000_RAR_ENTRIES;
 791		for (i = 0; i < value; i++) {
 792			REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2),
 793					 0x8003FFFF, 0xFFFFFFFF);
 794		}
 795	} else {
 796		REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x01FFFFFF);
 797		REG_PATTERN_TEST(RDBAL, 0xFFFFF000, 0xFFFFFFFF);
 798		REG_PATTERN_TEST(TXCW, 0x0000FFFF, 0x0000FFFF);
 799		REG_PATTERN_TEST(TDBAL, 0xFFFFF000, 0xFFFFFFFF);
 800	}
 801
 802	value = E1000_MC_TBL_SIZE;
 803	for (i = 0; i < value; i++)
 804		REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF);
 805
 806	*data = 0;
 807	return 0;
 808}
 809
 810static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
 811{
 812	struct e1000_hw *hw = &adapter->hw;
 813	u16 temp;
 814	u16 checksum = 0;
 815	u16 i;
 816
 817	*data = 0;
 818	/* Read and add up the contents of the EEPROM */
 819	for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
 820		if ((e1000_read_eeprom(hw, i, 1, &temp)) < 0) {
 821			*data = 1;
 822			break;
 823		}
 824		checksum += temp;
 825	}
 826
 827	/* If Checksum is not Correct return error else test passed */
 828	if ((checksum != (u16)EEPROM_SUM) && !(*data))
 829		*data = 2;
 830
 831	return *data;
 832}
 833
 834static irqreturn_t e1000_test_intr(int irq, void *data)
 835{
 836	struct net_device *netdev = (struct net_device *)data;
 837	struct e1000_adapter *adapter = netdev_priv(netdev);
 838	struct e1000_hw *hw = &adapter->hw;
 839
 840	adapter->test_icr |= er32(ICR);
 841
 842	return IRQ_HANDLED;
 843}
 844
 845static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 846{
 847	struct net_device *netdev = adapter->netdev;
 848	u32 mask, i = 0;
 849	bool shared_int = true;
 850	u32 irq = adapter->pdev->irq;
 851	struct e1000_hw *hw = &adapter->hw;
 852
 853	*data = 0;
 854
 855	/* NOTE: we don't test MSI interrupts here, yet
 856	 * Hook up test interrupt handler just for this test
 857	 */
 858	if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
 859			 netdev))
 860		shared_int = false;
 861	else if (request_irq(irq, e1000_test_intr, IRQF_SHARED,
 862			     netdev->name, netdev)) {
 863		*data = 1;
 864		return -1;
 865	}
 866	e_info(hw, "testing %s interrupt\n", (shared_int ?
 867	       "shared" : "unshared"));
 868
 869	/* Disable all the interrupts */
 870	ew32(IMC, 0xFFFFFFFF);
 871	E1000_WRITE_FLUSH();
 872	msleep(10);
 873
 874	/* Test each interrupt */
 875	for (; i < 10; i++) {
 876		/* Interrupt to test */
 877		mask = 1 << i;
 878
 879		if (!shared_int) {
 880			/* Disable the interrupt to be reported in
 881			 * the cause register and then force the same
 882			 * interrupt and see if one gets posted.  If
 883			 * an interrupt was posted to the bus, the
 884			 * test failed.
 885			 */
 886			adapter->test_icr = 0;
 887			ew32(IMC, mask);
 888			ew32(ICS, mask);
 889			E1000_WRITE_FLUSH();
 890			msleep(10);
 891
 892			if (adapter->test_icr & mask) {
 893				*data = 3;
 894				break;
 895			}
 896		}
 897
 898		/* Enable the interrupt to be reported in
 899		 * the cause register and then force the same
 900		 * interrupt and see if one gets posted.  If
 901		 * an interrupt was not posted to the bus, the
 902		 * test failed.
 903		 */
 904		adapter->test_icr = 0;
 905		ew32(IMS, mask);
 906		ew32(ICS, mask);
 907		E1000_WRITE_FLUSH();
 908		msleep(10);
 909
 910		if (!(adapter->test_icr & mask)) {
 911			*data = 4;
 912			break;
 913		}
 914
 915		if (!shared_int) {
 916			/* Disable the other interrupts to be reported in
 917			 * the cause register and then force the other
 918			 * interrupts and see if any get posted.  If
 919			 * an interrupt was posted to the bus, the
 920			 * test failed.
 921			 */
 922			adapter->test_icr = 0;
 923			ew32(IMC, ~mask & 0x00007FFF);
 924			ew32(ICS, ~mask & 0x00007FFF);
 925			E1000_WRITE_FLUSH();
 926			msleep(10);
 927
 928			if (adapter->test_icr) {
 929				*data = 5;
 930				break;
 931			}
 932		}
 933	}
 934
 935	/* Disable all the interrupts */
 936	ew32(IMC, 0xFFFFFFFF);
 937	E1000_WRITE_FLUSH();
 938	msleep(10);
 939
 940	/* Unhook test interrupt handler */
 941	free_irq(irq, netdev);
 942
 943	return *data;
 944}
 945
 946static void e1000_free_desc_rings(struct e1000_adapter *adapter)
 947{
 948	struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
 949	struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
 950	struct pci_dev *pdev = adapter->pdev;
 951	int i;
 952
 953	if (txdr->desc && txdr->buffer_info) {
 954		for (i = 0; i < txdr->count; i++) {
 955			if (txdr->buffer_info[i].dma)
 956				dma_unmap_single(&pdev->dev,
 957						 txdr->buffer_info[i].dma,
 958						 txdr->buffer_info[i].length,
 959						 DMA_TO_DEVICE);
 960			if (txdr->buffer_info[i].skb)
 961				dev_kfree_skb(txdr->buffer_info[i].skb);
 962		}
 963	}
 964
 965	if (rxdr->desc && rxdr->buffer_info) {
 966		for (i = 0; i < rxdr->count; i++) {
 967			if (rxdr->buffer_info[i].dma)
 968				dma_unmap_single(&pdev->dev,
 969						 rxdr->buffer_info[i].dma,
 970						 E1000_RXBUFFER_2048,
 971						 DMA_FROM_DEVICE);
 972			kfree(rxdr->buffer_info[i].rxbuf.data);
 973		}
 974	}
 975
 976	if (txdr->desc) {
 977		dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
 978				  txdr->dma);
 979		txdr->desc = NULL;
 980	}
 981	if (rxdr->desc) {
 982		dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
 983				  rxdr->dma);
 984		rxdr->desc = NULL;
 985	}
 986
 987	kfree(txdr->buffer_info);
 988	txdr->buffer_info = NULL;
 989	kfree(rxdr->buffer_info);
 990	rxdr->buffer_info = NULL;
 991}
 992
 993static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
 994{
 995	struct e1000_hw *hw = &adapter->hw;
 996	struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
 997	struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
 998	struct pci_dev *pdev = adapter->pdev;
 999	u32 rctl;
1000	int i, ret_val;
1001
1002	/* Setup Tx descriptor ring and Tx buffers */
1003
1004	if (!txdr->count)
1005		txdr->count = E1000_DEFAULT_TXD;
1006
1007	txdr->buffer_info = kcalloc(txdr->count, sizeof(struct e1000_tx_buffer),
1008				    GFP_KERNEL);
1009	if (!txdr->buffer_info) {
1010		ret_val = 1;
1011		goto err_nomem;
1012	}
1013
1014	txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
1015	txdr->size = ALIGN(txdr->size, 4096);
1016	txdr->desc = dma_zalloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
1017					 GFP_KERNEL);
1018	if (!txdr->desc) {
1019		ret_val = 2;
1020		goto err_nomem;
1021	}
1022	txdr->next_to_use = txdr->next_to_clean = 0;
1023
1024	ew32(TDBAL, ((u64)txdr->dma & 0x00000000FFFFFFFF));
1025	ew32(TDBAH, ((u64)txdr->dma >> 32));
1026	ew32(TDLEN, txdr->count * sizeof(struct e1000_tx_desc));
1027	ew32(TDH, 0);
1028	ew32(TDT, 0);
1029	ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN |
1030	     E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1031	     E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1032
1033	for (i = 0; i < txdr->count; i++) {
1034		struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i);
1035		struct sk_buff *skb;
1036		unsigned int size = 1024;
1037
1038		skb = alloc_skb(size, GFP_KERNEL);
1039		if (!skb) {
1040			ret_val = 3;
1041			goto err_nomem;
1042		}
1043		skb_put(skb, size);
1044		txdr->buffer_info[i].skb = skb;
1045		txdr->buffer_info[i].length = skb->len;
1046		txdr->buffer_info[i].dma =
1047			dma_map_single(&pdev->dev, skb->data, skb->len,
1048				       DMA_TO_DEVICE);
1049		if (dma_mapping_error(&pdev->dev, txdr->buffer_info[i].dma)) {
1050			ret_val = 4;
1051			goto err_nomem;
1052		}
1053		tx_desc->buffer_addr = cpu_to_le64(txdr->buffer_info[i].dma);
1054		tx_desc->lower.data = cpu_to_le32(skb->len);
1055		tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1056						   E1000_TXD_CMD_IFCS |
1057						   E1000_TXD_CMD_RPS);
1058		tx_desc->upper.data = 0;
1059	}
1060
1061	/* Setup Rx descriptor ring and Rx buffers */
1062
1063	if (!rxdr->count)
1064		rxdr->count = E1000_DEFAULT_RXD;
1065
1066	rxdr->buffer_info = kcalloc(rxdr->count, sizeof(struct e1000_rx_buffer),
1067				    GFP_KERNEL);
1068	if (!rxdr->buffer_info) {
1069		ret_val = 5;
1070		goto err_nomem;
1071	}
1072
1073	rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
1074	rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
1075					 GFP_KERNEL);
1076	if (!rxdr->desc) {
1077		ret_val = 6;
1078		goto err_nomem;
1079	}
1080	rxdr->next_to_use = rxdr->next_to_clean = 0;
1081
1082	rctl = er32(RCTL);
1083	ew32(RCTL, rctl & ~E1000_RCTL_EN);
1084	ew32(RDBAL, ((u64)rxdr->dma & 0xFFFFFFFF));
1085	ew32(RDBAH, ((u64)rxdr->dma >> 32));
1086	ew32(RDLEN, rxdr->size);
1087	ew32(RDH, 0);
1088	ew32(RDT, 0);
1089	rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1090		E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1091		(hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
1092	ew32(RCTL, rctl);
1093
1094	for (i = 0; i < rxdr->count; i++) {
1095		struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i);
1096		u8 *buf;
1097
1098		buf = kzalloc(E1000_RXBUFFER_2048 + NET_SKB_PAD + NET_IP_ALIGN,
1099			      GFP_KERNEL);
1100		if (!buf) {
1101			ret_val = 7;
1102			goto err_nomem;
1103		}
1104		rxdr->buffer_info[i].rxbuf.data = buf;
1105
1106		rxdr->buffer_info[i].dma =
1107			dma_map_single(&pdev->dev,
1108				       buf + NET_SKB_PAD + NET_IP_ALIGN,
1109				       E1000_RXBUFFER_2048, DMA_FROM_DEVICE);
1110		if (dma_mapping_error(&pdev->dev, rxdr->buffer_info[i].dma)) {
1111			ret_val = 8;
1112			goto err_nomem;
1113		}
1114		rx_desc->buffer_addr = cpu_to_le64(rxdr->buffer_info[i].dma);
1115	}
1116
1117	return 0;
1118
1119err_nomem:
1120	e1000_free_desc_rings(adapter);
1121	return ret_val;
1122}
1123
1124static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1125{
1126	struct e1000_hw *hw = &adapter->hw;
1127
1128	/* Write out to PHY registers 29 and 30 to disable the Receiver. */
1129	e1000_write_phy_reg(hw, 29, 0x001F);
1130	e1000_write_phy_reg(hw, 30, 0x8FFC);
1131	e1000_write_phy_reg(hw, 29, 0x001A);
1132	e1000_write_phy_reg(hw, 30, 0x8FF0);
1133}
1134
1135static void e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter)
1136{
1137	struct e1000_hw *hw = &adapter->hw;
1138	u16 phy_reg;
1139
1140	/* Because we reset the PHY above, we need to re-force TX_CLK in the
1141	 * Extended PHY Specific Control Register to 25MHz clock.  This
1142	 * value defaults back to a 2.5MHz clock when the PHY is reset.
1143	 */
1144	e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
1145	phy_reg |= M88E1000_EPSCR_TX_CLK_25;
1146	e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_reg);
1147
1148	/* In addition, because of the s/w reset above, we need to enable
1149	 * CRS on TX.  This must be set for both full and half duplex
1150	 * operation.
1151	 */
1152	e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
1153	phy_reg |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1154	e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
1155}
1156
1157static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
1158{
1159	struct e1000_hw *hw = &adapter->hw;
1160	u32 ctrl_reg;
1161	u16 phy_reg;
1162
1163	/* Setup the Device Control Register for PHY loopback test. */
1164
1165	ctrl_reg = er32(CTRL);
1166	ctrl_reg |= (E1000_CTRL_ILOS |		/* Invert Loss-Of-Signal */
1167		     E1000_CTRL_FRCSPD |	/* Set the Force Speed Bit */
1168		     E1000_CTRL_FRCDPX |	/* Set the Force Duplex Bit */
1169		     E1000_CTRL_SPD_1000 |	/* Force Speed to 1000 */
1170		     E1000_CTRL_FD);		/* Force Duplex to FULL */
1171
1172	ew32(CTRL, ctrl_reg);
1173
1174	/* Read the PHY Specific Control Register (0x10) */
1175	e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
1176
1177	/* Clear Auto-Crossover bits in PHY Specific Control Register
1178	 * (bits 6:5).
1179	 */
1180	phy_reg &= ~M88E1000_PSCR_AUTO_X_MODE;
1181	e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
1182
1183	/* Perform software reset on the PHY */
1184	e1000_phy_reset(hw);
1185
1186	/* Have to setup TX_CLK and TX_CRS after software reset */
1187	e1000_phy_reset_clk_and_crs(adapter);
1188
1189	e1000_write_phy_reg(hw, PHY_CTRL, 0x8100);
1190
1191	/* Wait for reset to complete. */
1192	udelay(500);
1193
1194	/* Have to setup TX_CLK and TX_CRS after software reset */
1195	e1000_phy_reset_clk_and_crs(adapter);
1196
1197	/* Write out to PHY registers 29 and 30 to disable the Receiver. */
1198	e1000_phy_disable_receiver(adapter);
1199
1200	/* Set the loopback bit in the PHY control register. */
1201	e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1202	phy_reg |= MII_CR_LOOPBACK;
1203	e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1204
1205	/* Setup TX_CLK and TX_CRS one more time. */
1206	e1000_phy_reset_clk_and_crs(adapter);
1207
1208	/* Check Phy Configuration */
1209	e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1210	if (phy_reg != 0x4100)
1211		return 9;
1212
1213	e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
1214	if (phy_reg != 0x0070)
1215		return 10;
1216
1217	e1000_read_phy_reg(hw, 29, &phy_reg);
1218	if (phy_reg != 0x001A)
1219		return 11;
1220
1221	return 0;
1222}
1223
1224static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1225{
1226	struct e1000_hw *hw = &adapter->hw;
1227	u32 ctrl_reg = 0;
1228	u32 stat_reg = 0;
1229
1230	hw->autoneg = false;
1231
1232	if (hw->phy_type == e1000_phy_m88) {
1233		/* Auto-MDI/MDIX Off */
1234		e1000_write_phy_reg(hw,
1235				    M88E1000_PHY_SPEC_CTRL, 0x0808);
1236		/* reset to update Auto-MDI/MDIX */
1237		e1000_write_phy_reg(hw, PHY_CTRL, 0x9140);
1238		/* autoneg off */
1239		e1000_write_phy_reg(hw, PHY_CTRL, 0x8140);
1240	}
1241
1242	ctrl_reg = er32(CTRL);
1243
1244	/* force 1000, set loopback */
1245	e1000_write_phy_reg(hw, PHY_CTRL, 0x4140);
1246
1247	/* Now set up the MAC to the same speed/duplex as the PHY. */
1248	ctrl_reg = er32(CTRL);
1249	ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1250	ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1251			E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1252			E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1253			E1000_CTRL_FD); /* Force Duplex to FULL */
1254
1255	if (hw->media_type == e1000_media_type_copper &&
1256	    hw->phy_type == e1000_phy_m88)
1257		ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
1258	else {
1259		/* Set the ILOS bit on the fiber Nic is half
1260		 * duplex link is detected.
1261		 */
1262		stat_reg = er32(STATUS);
1263		if ((stat_reg & E1000_STATUS_FD) == 0)
1264			ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1265	}
1266
1267	ew32(CTRL, ctrl_reg);
1268
1269	/* Disable the receiver on the PHY so when a cable is plugged in, the
1270	 * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1271	 */
1272	if (hw->phy_type == e1000_phy_m88)
1273		e1000_phy_disable_receiver(adapter);
1274
1275	udelay(500);
1276
1277	return 0;
1278}
1279
1280static int e1000_set_phy_loopback(struct e1000_adapter *adapter)
1281{
1282	struct e1000_hw *hw = &adapter->hw;
1283	u16 phy_reg = 0;
1284	u16 count = 0;
1285
1286	switch (hw->mac_type) {
1287	case e1000_82543:
1288		if (hw->media_type == e1000_media_type_copper) {
1289			/* Attempt to setup Loopback mode on Non-integrated PHY.
1290			 * Some PHY registers get corrupted at random, so
1291			 * attempt this 10 times.
1292			 */
1293			while (e1000_nonintegrated_phy_loopback(adapter) &&
1294			       count++ < 10);
1295			if (count < 11)
1296				return 0;
1297		}
1298		break;
1299
1300	case e1000_82544:
1301	case e1000_82540:
1302	case e1000_82545:
1303	case e1000_82545_rev_3:
1304	case e1000_82546:
1305	case e1000_82546_rev_3:
1306	case e1000_82541:
1307	case e1000_82541_rev_2:
1308	case e1000_82547:
1309	case e1000_82547_rev_2:
1310		return e1000_integrated_phy_loopback(adapter);
1311	default:
1312		/* Default PHY loopback work is to read the MII
1313		 * control register and assert bit 14 (loopback mode).
1314		 */
1315		e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1316		phy_reg |= MII_CR_LOOPBACK;
1317		e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1318		return 0;
1319	}
1320
1321	return 8;
1322}
1323
1324static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1325{
1326	struct e1000_hw *hw = &adapter->hw;
1327	u32 rctl;
1328
1329	if (hw->media_type == e1000_media_type_fiber ||
1330	    hw->media_type == e1000_media_type_internal_serdes) {
1331		switch (hw->mac_type) {
1332		case e1000_82545:
1333		case e1000_82546:
1334		case e1000_82545_rev_3:
1335		case e1000_82546_rev_3:
1336			return e1000_set_phy_loopback(adapter);
1337		default:
1338			rctl = er32(RCTL);
1339			rctl |= E1000_RCTL_LBM_TCVR;
1340			ew32(RCTL, rctl);
1341			return 0;
1342		}
1343	} else if (hw->media_type == e1000_media_type_copper) {
1344		return e1000_set_phy_loopback(adapter);
1345	}
1346
1347	return 7;
1348}
1349
1350static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1351{
1352	struct e1000_hw *hw = &adapter->hw;
1353	u32 rctl;
1354	u16 phy_reg;
1355
1356	rctl = er32(RCTL);
1357	rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1358	ew32(RCTL, rctl);
1359
1360	switch (hw->mac_type) {
1361	case e1000_82545:
1362	case e1000_82546:
1363	case e1000_82545_rev_3:
1364	case e1000_82546_rev_3:
1365	default:
1366		hw->autoneg = true;
1367		e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1368		if (phy_reg & MII_CR_LOOPBACK) {
1369			phy_reg &= ~MII_CR_LOOPBACK;
1370			e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1371			e1000_phy_reset(hw);
1372		}
1373		break;
1374	}
1375}
1376
1377static void e1000_create_lbtest_frame(struct sk_buff *skb,
1378				      unsigned int frame_size)
1379{
1380	memset(skb->data, 0xFF, frame_size);
1381	frame_size &= ~1;
1382	memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1383	memset(&skb->data[frame_size / 2 + 10], 0xBE, 1);
1384	memset(&skb->data[frame_size / 2 + 12], 0xAF, 1);
1385}
1386
1387static int e1000_check_lbtest_frame(const unsigned char *data,
1388				    unsigned int frame_size)
1389{
1390	frame_size &= ~1;
1391	if (*(data + 3) == 0xFF) {
1392		if ((*(data + frame_size / 2 + 10) == 0xBE) &&
1393		    (*(data + frame_size / 2 + 12) == 0xAF)) {
1394			return 0;
1395		}
1396	}
1397	return 13;
1398}
1399
1400static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1401{
1402	struct e1000_hw *hw = &adapter->hw;
1403	struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
1404	struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
1405	struct pci_dev *pdev = adapter->pdev;
1406	int i, j, k, l, lc, good_cnt, ret_val = 0;
1407	unsigned long time;
1408
1409	ew32(RDT, rxdr->count - 1);
1410
1411	/* Calculate the loop count based on the largest descriptor ring
1412	 * The idea is to wrap the largest ring a number of times using 64
1413	 * send/receive pairs during each loop
1414	 */
1415
1416	if (rxdr->count <= txdr->count)
1417		lc = ((txdr->count / 64) * 2) + 1;
1418	else
1419		lc = ((rxdr->count / 64) * 2) + 1;
1420
1421	k = l = 0;
1422	for (j = 0; j <= lc; j++) { /* loop count loop */
1423		for (i = 0; i < 64; i++) { /* send the packets */
1424			e1000_create_lbtest_frame(txdr->buffer_info[i].skb,
1425						  1024);
1426			dma_sync_single_for_device(&pdev->dev,
1427						   txdr->buffer_info[k].dma,
1428						   txdr->buffer_info[k].length,
1429						   DMA_TO_DEVICE);
1430			if (unlikely(++k == txdr->count))
1431				k = 0;
1432		}
1433		ew32(TDT, k);
1434		E1000_WRITE_FLUSH();
1435		msleep(200);
1436		time = jiffies; /* set the start time for the receive */
1437		good_cnt = 0;
1438		do { /* receive the sent packets */
1439			dma_sync_single_for_cpu(&pdev->dev,
1440						rxdr->buffer_info[l].dma,
1441						E1000_RXBUFFER_2048,
1442						DMA_FROM_DEVICE);
1443
1444			ret_val = e1000_check_lbtest_frame(
1445					rxdr->buffer_info[l].rxbuf.data +
1446					NET_SKB_PAD + NET_IP_ALIGN,
1447					1024);
1448			if (!ret_val)
1449				good_cnt++;
1450			if (unlikely(++l == rxdr->count))
1451				l = 0;
1452			/* time + 20 msecs (200 msecs on 2.4) is more than
1453			 * enough time to complete the receives, if it's
1454			 * exceeded, break and error off
1455			 */
1456		} while (good_cnt < 64 && time_after(time + 20, jiffies));
1457
1458		if (good_cnt != 64) {
1459			ret_val = 13; /* ret_val is the same as mis-compare */
1460			break;
1461		}
1462		if (time_after_eq(jiffies, time + 2)) {
1463			ret_val = 14; /* error code for time out error */
1464			break;
1465		}
1466	} /* end loop count loop */
1467	return ret_val;
1468}
1469
1470static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1471{
1472	*data = e1000_setup_desc_rings(adapter);
1473	if (*data)
1474		goto out;
1475	*data = e1000_setup_loopback_test(adapter);
1476	if (*data)
1477		goto err_loopback;
1478	*data = e1000_run_loopback_test(adapter);
1479	e1000_loopback_cleanup(adapter);
1480
1481err_loopback:
1482	e1000_free_desc_rings(adapter);
1483out:
1484	return *data;
1485}
1486
1487static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1488{
1489	struct e1000_hw *hw = &adapter->hw;
1490	*data = 0;
1491	if (hw->media_type == e1000_media_type_internal_serdes) {
1492		int i = 0;
1493
1494		hw->serdes_has_link = false;
1495
1496		/* On some blade server designs, link establishment
1497		 * could take as long as 2-3 minutes
1498		 */
1499		do {
1500			e1000_check_for_link(hw);
1501			if (hw->serdes_has_link)
1502				return *data;
1503			msleep(20);
1504		} while (i++ < 3750);
1505
1506		*data = 1;
1507	} else {
1508		e1000_check_for_link(hw);
1509		if (hw->autoneg)  /* if auto_neg is set wait for it */
1510			msleep(4000);
1511
1512		if (!(er32(STATUS) & E1000_STATUS_LU))
1513			*data = 1;
1514	}
1515	return *data;
1516}
1517
1518static int e1000_get_sset_count(struct net_device *netdev, int sset)
1519{
1520	switch (sset) {
1521	case ETH_SS_TEST:
1522		return E1000_TEST_LEN;
1523	case ETH_SS_STATS:
1524		return E1000_STATS_LEN;
1525	default:
1526		return -EOPNOTSUPP;
1527	}
1528}
1529
1530static void e1000_diag_test(struct net_device *netdev,
1531			    struct ethtool_test *eth_test, u64 *data)
1532{
1533	struct e1000_adapter *adapter = netdev_priv(netdev);
1534	struct e1000_hw *hw = &adapter->hw;
1535	bool if_running = netif_running(netdev);
1536
1537	set_bit(__E1000_TESTING, &adapter->flags);
1538	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1539		/* Offline tests */
1540
1541		/* save speed, duplex, autoneg settings */
1542		u16 autoneg_advertised = hw->autoneg_advertised;
1543		u8 forced_speed_duplex = hw->forced_speed_duplex;
1544		u8 autoneg = hw->autoneg;
1545
1546		e_info(hw, "offline testing starting\n");
1547
1548		/* Link test performed before hardware reset so autoneg doesn't
1549		 * interfere with test result
1550		 */
1551		if (e1000_link_test(adapter, &data[4]))
1552			eth_test->flags |= ETH_TEST_FL_FAILED;
1553
1554		if (if_running)
1555			/* indicate we're in test mode */
1556			e1000_close(netdev);
1557		else
1558			e1000_reset(adapter);
1559
1560		if (e1000_reg_test(adapter, &data[0]))
1561			eth_test->flags |= ETH_TEST_FL_FAILED;
1562
1563		e1000_reset(adapter);
1564		if (e1000_eeprom_test(adapter, &data[1]))
1565			eth_test->flags |= ETH_TEST_FL_FAILED;
1566
1567		e1000_reset(adapter);
1568		if (e1000_intr_test(adapter, &data[2]))
1569			eth_test->flags |= ETH_TEST_FL_FAILED;
1570
1571		e1000_reset(adapter);
1572		/* make sure the phy is powered up */
1573		e1000_power_up_phy(adapter);
1574		if (e1000_loopback_test(adapter, &data[3]))
1575			eth_test->flags |= ETH_TEST_FL_FAILED;
1576
1577		/* restore speed, duplex, autoneg settings */
1578		hw->autoneg_advertised = autoneg_advertised;
1579		hw->forced_speed_duplex = forced_speed_duplex;
1580		hw->autoneg = autoneg;
1581
1582		e1000_reset(adapter);
1583		clear_bit(__E1000_TESTING, &adapter->flags);
1584		if (if_running)
1585			e1000_open(netdev);
1586	} else {
1587		e_info(hw, "online testing starting\n");
1588		/* Online tests */
1589		if (e1000_link_test(adapter, &data[4]))
1590			eth_test->flags |= ETH_TEST_FL_FAILED;
1591
1592		/* Online tests aren't run; pass by default */
1593		data[0] = 0;
1594		data[1] = 0;
1595		data[2] = 0;
1596		data[3] = 0;
1597
1598		clear_bit(__E1000_TESTING, &adapter->flags);
1599	}
1600	msleep_interruptible(4 * 1000);
1601}
1602
1603static int e1000_wol_exclusion(struct e1000_adapter *adapter,
1604			       struct ethtool_wolinfo *wol)
1605{
1606	struct e1000_hw *hw = &adapter->hw;
1607	int retval = 1; /* fail by default */
1608
1609	switch (hw->device_id) {
1610	case E1000_DEV_ID_82542:
1611	case E1000_DEV_ID_82543GC_FIBER:
1612	case E1000_DEV_ID_82543GC_COPPER:
1613	case E1000_DEV_ID_82544EI_FIBER:
1614	case E1000_DEV_ID_82546EB_QUAD_COPPER:
1615	case E1000_DEV_ID_82545EM_FIBER:
1616	case E1000_DEV_ID_82545EM_COPPER:
1617	case E1000_DEV_ID_82546GB_QUAD_COPPER:
1618	case E1000_DEV_ID_82546GB_PCIE:
1619		/* these don't support WoL at all */
1620		wol->supported = 0;
1621		break;
1622	case E1000_DEV_ID_82546EB_FIBER:
1623	case E1000_DEV_ID_82546GB_FIBER:
1624		/* Wake events not supported on port B */
1625		if (er32(STATUS) & E1000_STATUS_FUNC_1) {
1626			wol->supported = 0;
1627			break;
1628		}
1629		/* return success for non excluded adapter ports */
1630		retval = 0;
1631		break;
1632	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1633		/* quad port adapters only support WoL on port A */
1634		if (!adapter->quad_port_a) {
1635			wol->supported = 0;
1636			break;
1637		}
1638		/* return success for non excluded adapter ports */
1639		retval = 0;
1640		break;
1641	default:
1642		/* dual port cards only support WoL on port A from now on
1643		 * unless it was enabled in the eeprom for port B
1644		 * so exclude FUNC_1 ports from having WoL enabled
1645		 */
1646		if (er32(STATUS) & E1000_STATUS_FUNC_1 &&
1647		    !adapter->eeprom_wol) {
1648			wol->supported = 0;
1649			break;
1650		}
1651
1652		retval = 0;
1653	}
1654
1655	return retval;
1656}
1657
1658static void e1000_get_wol(struct net_device *netdev,
1659			  struct ethtool_wolinfo *wol)
1660{
1661	struct e1000_adapter *adapter = netdev_priv(netdev);
1662	struct e1000_hw *hw = &adapter->hw;
1663
1664	wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC;
1665	wol->wolopts = 0;
1666
1667	/* this function will set ->supported = 0 and return 1 if wol is not
1668	 * supported by this hardware
1669	 */
1670	if (e1000_wol_exclusion(adapter, wol) ||
1671	    !device_can_wakeup(&adapter->pdev->dev))
1672		return;
1673
1674	/* apply any specific unsupported masks here */
1675	switch (hw->device_id) {
1676	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1677		/* KSP3 does not support UCAST wake-ups */
1678		wol->supported &= ~WAKE_UCAST;
1679
1680		if (adapter->wol & E1000_WUFC_EX)
1681			e_err(drv, "Interface does not support directed "
1682			      "(unicast) frame wake-up packets\n");
1683		break;
1684	default:
1685		break;
1686	}
1687
1688	if (adapter->wol & E1000_WUFC_EX)
1689		wol->wolopts |= WAKE_UCAST;
1690	if (adapter->wol & E1000_WUFC_MC)
1691		wol->wolopts |= WAKE_MCAST;
1692	if (adapter->wol & E1000_WUFC_BC)
1693		wol->wolopts |= WAKE_BCAST;
1694	if (adapter->wol & E1000_WUFC_MAG)
1695		wol->wolopts |= WAKE_MAGIC;
1696}
1697
1698static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1699{
1700	struct e1000_adapter *adapter = netdev_priv(netdev);
1701	struct e1000_hw *hw = &adapter->hw;
1702
1703	if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
1704		return -EOPNOTSUPP;
1705
1706	if (e1000_wol_exclusion(adapter, wol) ||
1707	    !device_can_wakeup(&adapter->pdev->dev))
1708		return wol->wolopts ? -EOPNOTSUPP : 0;
1709
1710	switch (hw->device_id) {
1711	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1712		if (wol->wolopts & WAKE_UCAST) {
1713			e_err(drv, "Interface does not support directed "
1714			      "(unicast) frame wake-up packets\n");
1715			return -EOPNOTSUPP;
1716		}
1717		break;
1718	default:
1719		break;
1720	}
1721
1722	/* these settings will always override what we currently have */
1723	adapter->wol = 0;
1724
1725	if (wol->wolopts & WAKE_UCAST)
1726		adapter->wol |= E1000_WUFC_EX;
1727	if (wol->wolopts & WAKE_MCAST)
1728		adapter->wol |= E1000_WUFC_MC;
1729	if (wol->wolopts & WAKE_BCAST)
1730		adapter->wol |= E1000_WUFC_BC;
1731	if (wol->wolopts & WAKE_MAGIC)
1732		adapter->wol |= E1000_WUFC_MAG;
1733
1734	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1735
1736	return 0;
1737}
1738
1739static int e1000_set_phys_id(struct net_device *netdev,
1740			     enum ethtool_phys_id_state state)
1741{
1742	struct e1000_adapter *adapter = netdev_priv(netdev);
1743	struct e1000_hw *hw = &adapter->hw;
1744
1745	switch (state) {
1746	case ETHTOOL_ID_ACTIVE:
1747		e1000_setup_led(hw);
1748		return 2;
1749
1750	case ETHTOOL_ID_ON:
1751		e1000_led_on(hw);
1752		break;
1753
1754	case ETHTOOL_ID_OFF:
1755		e1000_led_off(hw);
1756		break;
1757
1758	case ETHTOOL_ID_INACTIVE:
1759		e1000_cleanup_led(hw);
1760	}
1761
1762	return 0;
1763}
1764
1765static int e1000_get_coalesce(struct net_device *netdev,
1766			      struct ethtool_coalesce *ec)
1767{
1768	struct e1000_adapter *adapter = netdev_priv(netdev);
1769
1770	if (adapter->hw.mac_type < e1000_82545)
1771		return -EOPNOTSUPP;
1772
1773	if (adapter->itr_setting <= 4)
1774		ec->rx_coalesce_usecs = adapter->itr_setting;
1775	else
1776		ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
1777
1778	return 0;
1779}
1780
1781static int e1000_set_coalesce(struct net_device *netdev,
1782			      struct ethtool_coalesce *ec)
1783{
1784	struct e1000_adapter *adapter = netdev_priv(netdev);
1785	struct e1000_hw *hw = &adapter->hw;
1786
1787	if (hw->mac_type < e1000_82545)
1788		return -EOPNOTSUPP;
1789
1790	if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
1791	    ((ec->rx_coalesce_usecs > 4) &&
1792	     (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
1793	    (ec->rx_coalesce_usecs == 2))
1794		return -EINVAL;
1795
1796	if (ec->rx_coalesce_usecs == 4) {
1797		adapter->itr = adapter->itr_setting = 4;
1798	} else if (ec->rx_coalesce_usecs <= 3) {
1799		adapter->itr = 20000;
1800		adapter->itr_setting = ec->rx_coalesce_usecs;
1801	} else {
1802		adapter->itr = (1000000 / ec->rx_coalesce_usecs);
1803		adapter->itr_setting = adapter->itr & ~3;
1804	}
1805
1806	if (adapter->itr_setting != 0)
1807		ew32(ITR, 1000000000 / (adapter->itr * 256));
1808	else
1809		ew32(ITR, 0);
1810
1811	return 0;
1812}
1813
1814static int e1000_nway_reset(struct net_device *netdev)
1815{
1816	struct e1000_adapter *adapter = netdev_priv(netdev);
1817
1818	if (netif_running(netdev))
1819		e1000_reinit_locked(adapter);
1820	return 0;
1821}
1822
1823static void e1000_get_ethtool_stats(struct net_device *netdev,
1824				    struct ethtool_stats *stats, u64 *data)
1825{
1826	struct e1000_adapter *adapter = netdev_priv(netdev);
1827	int i;
1828	const struct e1000_stats *stat = e1000_gstrings_stats;
1829
1830	e1000_update_stats(adapter);
1831	for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++, stat++) {
1832		char *p;
1833
1834		switch (stat->type) {
1835		case NETDEV_STATS:
1836			p = (char *)netdev + stat->stat_offset;
1837			break;
1838		case E1000_STATS:
1839			p = (char *)adapter + stat->stat_offset;
1840			break;
1841		default:
1842			netdev_WARN_ONCE(netdev, "Invalid E1000 stat type: %u index %d\n",
1843					 stat->type, i);
1844			continue;
1845		}
1846
1847		if (stat->sizeof_stat == sizeof(u64))
1848			data[i] = *(u64 *)p;
1849		else
1850			data[i] = *(u32 *)p;
1851	}
1852/* BUG_ON(i != E1000_STATS_LEN); */
1853}
1854
1855static void e1000_get_strings(struct net_device *netdev, u32 stringset,
1856			      u8 *data)
1857{
1858	u8 *p = data;
1859	int i;
1860
1861	switch (stringset) {
1862	case ETH_SS_TEST:
1863		memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
1864		break;
1865	case ETH_SS_STATS:
1866		for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
1867			memcpy(p, e1000_gstrings_stats[i].stat_string,
1868			       ETH_GSTRING_LEN);
1869			p += ETH_GSTRING_LEN;
1870		}
1871		/* BUG_ON(p - data != E1000_STATS_LEN * ETH_GSTRING_LEN); */
1872		break;
1873	}
1874}
1875
1876static const struct ethtool_ops e1000_ethtool_ops = {
1877	.get_drvinfo		= e1000_get_drvinfo,
1878	.get_regs_len		= e1000_get_regs_len,
1879	.get_regs		= e1000_get_regs,
1880	.get_wol		= e1000_get_wol,
1881	.set_wol		= e1000_set_wol,
1882	.get_msglevel		= e1000_get_msglevel,
1883	.set_msglevel		= e1000_set_msglevel,
1884	.nway_reset		= e1000_nway_reset,
1885	.get_link		= e1000_get_link,
1886	.get_eeprom_len		= e1000_get_eeprom_len,
1887	.get_eeprom		= e1000_get_eeprom,
1888	.set_eeprom		= e1000_set_eeprom,
1889	.get_ringparam		= e1000_get_ringparam,
1890	.set_ringparam		= e1000_set_ringparam,
1891	.get_pauseparam		= e1000_get_pauseparam,
1892	.set_pauseparam		= e1000_set_pauseparam,
1893	.self_test		= e1000_diag_test,
1894	.get_strings		= e1000_get_strings,
1895	.set_phys_id		= e1000_set_phys_id,
1896	.get_ethtool_stats	= e1000_get_ethtool_stats,
1897	.get_sset_count		= e1000_get_sset_count,
1898	.get_coalesce		= e1000_get_coalesce,
1899	.set_coalesce		= e1000_set_coalesce,
1900	.get_ts_info		= ethtool_op_get_ts_info,
1901	.get_link_ksettings	= e1000_get_link_ksettings,
1902	.set_link_ksettings	= e1000_set_link_ksettings,
1903};
1904
1905void e1000_set_ethtool_ops(struct net_device *netdev)
1906{
1907	netdev->ethtool_ops = &e1000_ethtool_ops;
1908}