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