e1000_main.c 135.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*******************************************************************************

3 4 5 6 7 8 9 10 11 12
  Intel PRO/1000 Linux driver
  Copyright(c) 1999 - 2006 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
L
Linus Torvalds 已提交
13
  more details.
14

L
Linus Torvalds 已提交
15
  You should have received a copy of the GNU General Public License along with
16 17 18 19 20 21
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

L
Linus Torvalds 已提交
22 23
  Contact Information:
  Linux NICS <linux.nics@intel.com>
24
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
L
Linus Torvalds 已提交
25 26 27 28 29
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include "e1000.h"
A
Andrew Morton 已提交
30
#include <net/ip6_checksum.h>
31
#include <linux/io.h>
32
#include <linux/prefetch.h>
J
Jiri Pirko 已提交
33 34
#include <linux/bitops.h>
#include <linux/if_vlan.h>
35 36 37 38 39

/* Intel Media SOC GbE MDIO physical base address */
static unsigned long ce4100_gbe_mdio_base_phy;
/* Intel Media SOC GbE MDIO virtual base address */
void __iomem *ce4100_gbe_mdio_base_virt;
L
Linus Torvalds 已提交
40 41

char e1000_driver_name[] = "e1000";
42
static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
A
Anupam Chanda 已提交
43
#define DRV_VERSION "7.3.21-k8-NAPI"
S
Stephen Hemminger 已提交
44 45
const char e1000_driver_version[] = DRV_VERSION;
static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
L
Linus Torvalds 已提交
46 47 48 49 50 51 52 53

/* e1000_pci_tbl - PCI Device ID Table
 *
 * Last entry must be all 0s
 *
 * Macro expands to...
 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
 */
54
static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
	INTEL_E1000_ETHERNET_DEVICE(0x1000),
	INTEL_E1000_ETHERNET_DEVICE(0x1001),
	INTEL_E1000_ETHERNET_DEVICE(0x1004),
	INTEL_E1000_ETHERNET_DEVICE(0x1008),
	INTEL_E1000_ETHERNET_DEVICE(0x1009),
	INTEL_E1000_ETHERNET_DEVICE(0x100C),
	INTEL_E1000_ETHERNET_DEVICE(0x100D),
	INTEL_E1000_ETHERNET_DEVICE(0x100E),
	INTEL_E1000_ETHERNET_DEVICE(0x100F),
	INTEL_E1000_ETHERNET_DEVICE(0x1010),
	INTEL_E1000_ETHERNET_DEVICE(0x1011),
	INTEL_E1000_ETHERNET_DEVICE(0x1012),
	INTEL_E1000_ETHERNET_DEVICE(0x1013),
	INTEL_E1000_ETHERNET_DEVICE(0x1014),
	INTEL_E1000_ETHERNET_DEVICE(0x1015),
	INTEL_E1000_ETHERNET_DEVICE(0x1016),
	INTEL_E1000_ETHERNET_DEVICE(0x1017),
	INTEL_E1000_ETHERNET_DEVICE(0x1018),
	INTEL_E1000_ETHERNET_DEVICE(0x1019),
74
	INTEL_E1000_ETHERNET_DEVICE(0x101A),
L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88
	INTEL_E1000_ETHERNET_DEVICE(0x101D),
	INTEL_E1000_ETHERNET_DEVICE(0x101E),
	INTEL_E1000_ETHERNET_DEVICE(0x1026),
	INTEL_E1000_ETHERNET_DEVICE(0x1027),
	INTEL_E1000_ETHERNET_DEVICE(0x1028),
	INTEL_E1000_ETHERNET_DEVICE(0x1075),
	INTEL_E1000_ETHERNET_DEVICE(0x1076),
	INTEL_E1000_ETHERNET_DEVICE(0x1077),
	INTEL_E1000_ETHERNET_DEVICE(0x1078),
	INTEL_E1000_ETHERNET_DEVICE(0x1079),
	INTEL_E1000_ETHERNET_DEVICE(0x107A),
	INTEL_E1000_ETHERNET_DEVICE(0x107B),
	INTEL_E1000_ETHERNET_DEVICE(0x107C),
	INTEL_E1000_ETHERNET_DEVICE(0x108A),
89 90
	INTEL_E1000_ETHERNET_DEVICE(0x1099),
	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
91
	INTEL_E1000_ETHERNET_DEVICE(0x2E6E),
L
Linus Torvalds 已提交
92 93 94 95 96 97
	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

98 99 100 101 102 103 104 105
int e1000_up(struct e1000_adapter *adapter);
void e1000_down(struct e1000_adapter *adapter);
void e1000_reinit_locked(struct e1000_adapter *adapter);
void e1000_reset(struct e1000_adapter *adapter);
int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
106
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
107
                             struct e1000_tx_ring *txdr);
108
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
109
                             struct e1000_rx_ring *rxdr);
110
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
111
                             struct e1000_tx_ring *tx_ring);
112
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
113 114
                             struct e1000_rx_ring *rx_ring);
void e1000_update_stats(struct e1000_adapter *adapter);
L
Linus Torvalds 已提交
115 116 117 118 119

static int e1000_init_module(void);
static void e1000_exit_module(void);
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
static void __devexit e1000_remove(struct pci_dev *pdev);
120
static int e1000_alloc_queues(struct e1000_adapter *adapter);
L
Linus Torvalds 已提交
121 122 123 124 125 126
static int e1000_sw_init(struct e1000_adapter *adapter);
static int e1000_open(struct net_device *netdev);
static int e1000_close(struct net_device *netdev);
static void e1000_configure_tx(struct e1000_adapter *adapter);
static void e1000_configure_rx(struct e1000_adapter *adapter);
static void e1000_setup_rctl(struct e1000_adapter *adapter);
127 128 129 130 131 132
static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
                                struct e1000_tx_ring *tx_ring);
static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
                                struct e1000_rx_ring *rx_ring);
133
static void e1000_set_rx_mode(struct net_device *netdev);
L
Linus Torvalds 已提交
134
static void e1000_update_phy_info(unsigned long data);
J
Jesse Brandeburg 已提交
135
static void e1000_update_phy_info_task(struct work_struct *work);
L
Linus Torvalds 已提交
136 137
static void e1000_watchdog(unsigned long data);
static void e1000_82547_tx_fifo_stall(unsigned long data);
J
Jesse Brandeburg 已提交
138
static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);
139 140
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
				    struct net_device *netdev);
L
Linus Torvalds 已提交
141 142 143
static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
static int e1000_set_mac(struct net_device *netdev, void *p);
144
static irqreturn_t e1000_intr(int irq, void *data);
J
Joe Perches 已提交
145 146
static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
			       struct e1000_tx_ring *tx_ring);
147
static int e1000_clean(struct napi_struct *napi, int budget);
J
Joe Perches 已提交
148 149 150
static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
			       struct e1000_rx_ring *rx_ring,
			       int *work_done, int work_to_do);
151 152 153
static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
				     struct e1000_rx_ring *rx_ring,
				     int *work_done, int work_to_do);
154
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
155
				   struct e1000_rx_ring *rx_ring,
156
				   int cleaned_count);
157 158 159
static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
					 struct e1000_rx_ring *rx_ring,
					 int cleaned_count);
L
Linus Torvalds 已提交
160 161 162 163 164 165
static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
			   int cmd);
static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
static void e1000_tx_timeout(struct net_device *dev);
166
static void e1000_reset_task(struct work_struct *work);
L
Linus Torvalds 已提交
167
static void e1000_smartspeed(struct e1000_adapter *adapter);
168 169
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
                                       struct sk_buff *skb);
L
Linus Torvalds 已提交
170

J
Jiri Pirko 已提交
171 172
static bool e1000_vlan_used(struct e1000_adapter *adapter);
static void e1000_vlan_mode(struct net_device *netdev, u32 features);
173 174
static void e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
L
Linus Torvalds 已提交
175 176
static void e1000_restore_vlan(struct e1000_adapter *adapter);

A
Auke Kok 已提交
177
#ifdef CONFIG_PM
178
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
L
Linus Torvalds 已提交
179 180
static int e1000_resume(struct pci_dev *pdev);
#endif
181
static void e1000_shutdown(struct pci_dev *pdev);
L
Linus Torvalds 已提交
182 183 184 185 186 187

#ifdef CONFIG_NET_POLL_CONTROLLER
/* for netdump / net console */
static void e1000_netpoll (struct net_device *netdev);
#endif

188 189 190 191 192 193
#define COPYBREAK_DEFAULT 256
static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;
module_param(copybreak, uint, 0644);
MODULE_PARM_DESC(copybreak,
	"Maximum size of packet that is copied to a new buffer on receive");

A
Auke Kok 已提交
194 195 196 197 198 199 200 201 202 203
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
                     pci_channel_state_t state);
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
static void e1000_io_resume(struct pci_dev *pdev);

static struct pci_error_handlers e1000_err_handler = {
	.error_detected = e1000_io_error_detected,
	.slot_reset = e1000_io_slot_reset,
	.resume = e1000_io_resume,
};
204

L
Linus Torvalds 已提交
205 206 207 208 209
static struct pci_driver e1000_driver = {
	.name     = e1000_driver_name,
	.id_table = e1000_pci_tbl,
	.probe    = e1000_probe,
	.remove   = __devexit_p(e1000_remove),
210
#ifdef CONFIG_PM
L
Lucas De Marchi 已提交
211
	/* Power Management Hooks */
L
Linus Torvalds 已提交
212
	.suspend  = e1000_suspend,
213
	.resume   = e1000_resume,
L
Linus Torvalds 已提交
214
#endif
A
Auke Kok 已提交
215 216
	.shutdown = e1000_shutdown,
	.err_handler = &e1000_err_handler
L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224 225 226 227
};

MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");

228 229 230 231 232 233 234 235 236 237 238
/**
 * e1000_get_hw_dev - return device
 * used by hardware layer to print debugging information
 *
 **/
struct net_device *e1000_get_hw_dev(struct e1000_hw *hw)
{
	struct e1000_adapter *adapter = hw->back;
	return adapter->netdev;
}

L
Linus Torvalds 已提交
239 240 241 242 243 244 245
/**
 * e1000_init_module - Driver Registration Routine
 *
 * e1000_init_module is the first routine called when the driver is
 * loaded. All it does is register with the PCI subsystem.
 **/

246
static int __init e1000_init_module(void)
L
Linus Torvalds 已提交
247 248
{
	int ret;
249
	pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);
L
Linus Torvalds 已提交
250

251
	pr_info("%s\n", e1000_copyright);
L
Linus Torvalds 已提交
252

253
	ret = pci_register_driver(&e1000_driver);
254 255
	if (copybreak != COPYBREAK_DEFAULT) {
		if (copybreak == 0)
256
			pr_info("copybreak disabled\n");
257
		else
258 259
			pr_info("copybreak enabled for "
				   "packets <= %u bytes\n", copybreak);
260
	}
L
Linus Torvalds 已提交
261 262 263 264 265 266 267 268 269 270 271 272
	return ret;
}

module_init(e1000_init_module);

/**
 * e1000_exit_module - Driver Exit Cleanup Routine
 *
 * e1000_exit_module is called just before the driver is removed
 * from memory.
 **/

273
static void __exit e1000_exit_module(void)
L
Linus Torvalds 已提交
274 275 276 277 278 279
{
	pci_unregister_driver(&e1000_driver);
}

module_exit(e1000_exit_module);

280 281 282
static int e1000_request_irq(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
A
Al Viro 已提交
283
	irq_handler_t handler = e1000_intr;
284 285
	int irq_flags = IRQF_SHARED;
	int err;
286

287 288 289
	err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
	                  netdev);
	if (err) {
290
		e_err(probe, "Unable to allocate interrupt Error: %d\n", err);
291
	}
292 293 294 295 296 297 298 299 300 301 302

	return err;
}

static void e1000_free_irq(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;

	free_irq(adapter->pdev->irq, netdev);
}

L
Linus Torvalds 已提交
303 304 305 306 307
/**
 * e1000_irq_disable - Mask off interrupt generation on the NIC
 * @adapter: board private structure
 **/

308
static void e1000_irq_disable(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
309
{
J
Joe Perches 已提交
310 311 312 313
	struct e1000_hw *hw = &adapter->hw;

	ew32(IMC, ~0);
	E1000_WRITE_FLUSH();
L
Linus Torvalds 已提交
314 315 316 317 318 319 320 321
	synchronize_irq(adapter->pdev->irq);
}

/**
 * e1000_irq_enable - Enable default interrupt generation settings
 * @adapter: board private structure
 **/

322
static void e1000_irq_enable(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
323
{
J
Joe Perches 已提交
324 325 326 327
	struct e1000_hw *hw = &adapter->hw;

	ew32(IMS, IMS_ENABLE_MASK);
	E1000_WRITE_FLUSH();
L
Linus Torvalds 已提交
328
}
329

330
static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
331
{
J
Joe Perches 已提交
332
	struct e1000_hw *hw = &adapter->hw;
333
	struct net_device *netdev = adapter->netdev;
J
Joe Perches 已提交
334
	u16 vid = hw->mng_cookie.vlan_id;
335
	u16 old_vid = adapter->mng_vlan_id;
J
Jesse Brandeburg 已提交
336

J
Jiri Pirko 已提交
337 338 339 340 341 342 343
	if (!e1000_vlan_used(adapter))
		return;

	if (!test_bit(vid, adapter->active_vlans)) {
		if (hw->mng_cookie.status &
		    E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
			e1000_vlan_rx_add_vid(netdev, vid);
344
			adapter->mng_vlan_id = vid;
J
Jiri Pirko 已提交
345 346 347 348 349 350 351 352 353
		} else {
			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
		}
		if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&
		    (vid != old_vid) &&
		    !test_bit(old_vid, adapter->active_vlans))
			e1000_vlan_rx_kill_vid(netdev, old_vid);
	} else {
		adapter->mng_vlan_id = vid;
354 355
	}
}
356

357
static void e1000_init_manageability(struct e1000_adapter *adapter)
358
{
J
Joe Perches 已提交
359 360
	struct e1000_hw *hw = &adapter->hw;

361
	if (adapter->en_mng_pt) {
J
Joe Perches 已提交
362
		u32 manc = er32(MANC);
363 364 365 366

		/* disable hardware interception of ARP */
		manc &= ~(E1000_MANC_ARP_EN);

J
Joe Perches 已提交
367
		ew32(MANC, manc);
368 369 370
	}
}

371
static void e1000_release_manageability(struct e1000_adapter *adapter)
372
{
J
Joe Perches 已提交
373 374
	struct e1000_hw *hw = &adapter->hw;

375
	if (adapter->en_mng_pt) {
J
Joe Perches 已提交
376
		u32 manc = er32(MANC);
377 378 379 380

		/* re-enable hardware interception of ARP */
		manc |= E1000_MANC_ARP_EN;

J
Joe Perches 已提交
381
		ew32(MANC, manc);
382 383 384
	}
}

385 386 387 388 389
/**
 * e1000_configure - configure the hardware for RX and TX
 * @adapter = private board structure
 **/
static void e1000_configure(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
390 391
{
	struct net_device *netdev = adapter->netdev;
392
	int i;
L
Linus Torvalds 已提交
393

394
	e1000_set_rx_mode(netdev);
L
Linus Torvalds 已提交
395 396

	e1000_restore_vlan(adapter);
397
	e1000_init_manageability(adapter);
L
Linus Torvalds 已提交
398 399 400 401

	e1000_configure_tx(adapter);
	e1000_setup_rctl(adapter);
	e1000_configure_rx(adapter);
402 403 404
	/* call E1000_DESC_UNUSED which always leaves
	 * at least 1 descriptor unused to make sure
	 * next_to_use != next_to_clean */
405
	for (i = 0; i < adapter->num_rx_queues; i++) {
406
		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
407 408
		adapter->alloc_rx_buf(adapter, ring,
		                      E1000_DESC_UNUSED(ring));
409
	}
410 411 412 413
}

int e1000_up(struct e1000_adapter *adapter)
{
J
Joe Perches 已提交
414 415
	struct e1000_hw *hw = &adapter->hw;

416 417 418 419
	/* hardware has been reset, we need to reload some things */
	e1000_configure(adapter);

	clear_bit(__E1000_DOWN, &adapter->flags);
420

421
	napi_enable(&adapter->napi);
422

423 424
	e1000_irq_enable(adapter);

425 426
	netif_wake_queue(adapter->netdev);

427
	/* fire a link change interrupt to start the watchdog */
J
Joe Perches 已提交
428
	ew32(ICS, E1000_ICS_LSC);
L
Linus Torvalds 已提交
429 430 431
	return 0;
}

432 433 434 435 436 437 438 439 440 441
/**
 * e1000_power_up_phy - restore link in case the phy was powered down
 * @adapter: address of board private structure
 *
 * The phy may be powered down to save power and turn off link when the
 * driver is unloaded and wake on lan is not enabled (among others)
 * *** this routine MUST be followed by a call to e1000_reset ***
 *
 **/

442
void e1000_power_up_phy(struct e1000_adapter *adapter)
443
{
J
Joe Perches 已提交
444
	struct e1000_hw *hw = &adapter->hw;
445
	u16 mii_reg = 0;
446 447

	/* Just clear the power down bit to wake the phy back up */
J
Joe Perches 已提交
448
	if (hw->media_type == e1000_media_type_copper) {
449 450
		/* according to the manual, the phy will retain its
		 * settings across a power-down/up cycle */
J
Joe Perches 已提交
451
		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
452
		mii_reg &= ~MII_CR_POWER_DOWN;
J
Joe Perches 已提交
453
		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
454 455 456 457 458
	}
}

static void e1000_power_down_phy(struct e1000_adapter *adapter)
{
J
Joe Perches 已提交
459 460
	struct e1000_hw *hw = &adapter->hw;

461
	/* Power down the PHY so no link is implied when interface is down *
J
Joe Perches 已提交
462
	 * The PHY cannot be powered down if any of the following is true *
463 464 465
	 * (a) WoL is enabled
	 * (b) AMT is active
	 * (c) SoL/IDER session is active */
J
Joe Perches 已提交
466 467
	if (!adapter->wol && hw->mac_type >= e1000_82540 &&
	   hw->media_type == e1000_media_type_copper) {
468
		u16 mii_reg = 0;
469

J
Joe Perches 已提交
470
		switch (hw->mac_type) {
471 472 473 474
		case e1000_82540:
		case e1000_82545:
		case e1000_82545_rev_3:
		case e1000_82546:
475
		case e1000_ce4100:
476 477 478 479 480
		case e1000_82546_rev_3:
		case e1000_82541:
		case e1000_82541_rev_2:
		case e1000_82547:
		case e1000_82547_rev_2:
J
Joe Perches 已提交
481
			if (er32(MANC) & E1000_MANC_SMBUS_EN)
482 483 484 485 486
				goto out;
			break;
		default:
			goto out;
		}
J
Joe Perches 已提交
487
		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
488
		mii_reg |= MII_CR_POWER_DOWN;
J
Joe Perches 已提交
489
		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
490 491
		mdelay(1);
	}
492 493
out:
	return;
494 495
}

496
void e1000_down(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
497
{
498
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
499
	struct net_device *netdev = adapter->netdev;
500
	u32 rctl, tctl;
L
Linus Torvalds 已提交
501

A
Auke Kok 已提交
502

503 504 505 506 507
	/* disable receives in the hardware */
	rctl = er32(RCTL);
	ew32(RCTL, rctl & ~E1000_RCTL_EN);
	/* flush and sleep below */

J
Jesse Brandeburg 已提交
508
	netif_tx_disable(netdev);
509 510 511 512 513 514 515 516 517

	/* disable transmits in the hardware */
	tctl = er32(TCTL);
	tctl &= ~E1000_TCTL_EN;
	ew32(TCTL, tctl);
	/* flush both disables and wait for them to finish */
	E1000_WRITE_FLUSH();
	msleep(10);

518
	napi_disable(&adapter->napi);
519

L
Linus Torvalds 已提交
520
	e1000_irq_disable(adapter);
521

A
Anupam Chanda 已提交
522 523 524 525 526 527 528
	/*
	 * Setting DOWN must be after irq_disable to prevent
	 * a screaming interrupt.  Setting DOWN also prevents
	 * timers and tasks from rescheduling.
	 */
	set_bit(__E1000_DOWN, &adapter->flags);

L
Linus Torvalds 已提交
529 530 531 532 533 534 535 536 537
	del_timer_sync(&adapter->tx_fifo_stall_timer);
	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

	adapter->link_speed = 0;
	adapter->link_duplex = 0;
	netif_carrier_off(netdev);

	e1000_reset(adapter);
538 539
	e1000_clean_all_tx_rings(adapter);
	e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
540 541
}

542
static void e1000_reinit_safe(struct e1000_adapter *adapter)
543 544 545 546 547 548 549 550 551 552
{
	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
		msleep(1);
	rtnl_lock();
	e1000_down(adapter);
	e1000_up(adapter);
	rtnl_unlock();
	clear_bit(__E1000_RESETTING, &adapter->flags);
}

553
void e1000_reinit_locked(struct e1000_adapter *adapter)
554
{
555 556
	/* if rtnl_lock is not held the call path is bogus */
	ASSERT_RTNL();
557 558 559 560 561 562
	WARN_ON(in_interrupt());
	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
		msleep(1);
	e1000_down(adapter);
	e1000_up(adapter);
	clear_bit(__E1000_RESETTING, &adapter->flags);
L
Linus Torvalds 已提交
563 564
}

565
void e1000_reset(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
566
{
J
Joe Perches 已提交
567
	struct e1000_hw *hw = &adapter->hw;
568
	u32 pba = 0, tx_space, min_tx_space, min_rx_space;
J
Joe Perches 已提交
569
	bool legacy_pba_adjust = false;
570
	u16 hwm;
L
Linus Torvalds 已提交
571 572 573 574 575

	/* Repartition Pba for greater than 9k mtu
	 * To take effect CTRL.RST is required.
	 */

J
Joe Perches 已提交
576
	switch (hw->mac_type) {
577 578 579 580 581 582 583
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
	case e1000_82543:
	case e1000_82544:
	case e1000_82540:
	case e1000_82541:
	case e1000_82541_rev_2:
J
Joe Perches 已提交
584
		legacy_pba_adjust = true;
585 586 587 588 589
		pba = E1000_PBA_48K;
		break;
	case e1000_82545:
	case e1000_82545_rev_3:
	case e1000_82546:
590
	case e1000_ce4100:
591 592 593
	case e1000_82546_rev_3:
		pba = E1000_PBA_48K;
		break;
594
	case e1000_82547:
595
	case e1000_82547_rev_2:
J
Joe Perches 已提交
596
		legacy_pba_adjust = true;
597 598
		pba = E1000_PBA_30K;
		break;
599 600
	case e1000_undefined:
	case e1000_num_macs:
601 602 603
		break;
	}

J
Joe Perches 已提交
604
	if (legacy_pba_adjust) {
605
		if (hw->max_frame_size > E1000_RXBUFFER_8192)
606
			pba -= 8; /* allocate more FIFO for Tx */
607

J
Joe Perches 已提交
608
		if (hw->mac_type == e1000_82547) {
609 610 611 612 613 614
			adapter->tx_fifo_head = 0;
			adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
			adapter->tx_fifo_size =
				(E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
			atomic_set(&adapter->tx_fifo_stall, 0);
		}
615
	} else if (hw->max_frame_size >  ETH_FRAME_LEN + ETH_FCS_LEN) {
616
		/* adjust PBA for jumbo frames */
J
Joe Perches 已提交
617
		ew32(PBA, pba);
618 619

		/* To maintain wire speed transmits, the Tx FIFO should be
620
		 * large enough to accommodate two full transmit packets,
621
		 * rounded up to the next 1KB and expressed in KB.  Likewise,
622
		 * the Rx FIFO should be large enough to accommodate at least
623 624
		 * one full receive packet and is similarly rounded up and
		 * expressed in KB. */
J
Joe Perches 已提交
625
		pba = er32(PBA);
626 627 628 629
		/* upper 16 bits has Tx packet buffer allocation size in KB */
		tx_space = pba >> 16;
		/* lower 16 bits has Rx packet buffer allocation size in KB */
		pba &= 0xffff;
630 631 632 633 634 635 636
		/*
		 * the tx fifo also stores 16 bytes of information about the tx
		 * but don't include ethernet FCS because hardware appends it
		 */
		min_tx_space = (hw->max_frame_size +
		                sizeof(struct e1000_tx_desc) -
		                ETH_FCS_LEN) * 2;
637
		min_tx_space = ALIGN(min_tx_space, 1024);
638
		min_tx_space >>= 10;
639 640
		/* software strips receive CRC, so leave room for it */
		min_rx_space = hw->max_frame_size;
641
		min_rx_space = ALIGN(min_rx_space, 1024);
642 643 644 645 646 647 648 649 650 651
		min_rx_space >>= 10;

		/* If current Tx allocation is less than the min Tx FIFO size,
		 * and the min Tx FIFO size is less than the current Rx FIFO
		 * allocation, take space away from current Rx allocation */
		if (tx_space < min_tx_space &&
		    ((min_tx_space - tx_space) < pba)) {
			pba = pba - (min_tx_space - tx_space);

			/* PCI/PCIx hardware has PBA alignment constraints */
J
Joe Perches 已提交
652
			switch (hw->mac_type) {
653 654 655 656 657 658 659 660 661
			case e1000_82545 ... e1000_82546_rev_3:
				pba &= ~(E1000_PBA_8K - 1);
				break;
			default:
				break;
			}

			/* if short on rx space, rx wins and must trump tx
			 * adjustment or use Early Receive if available */
662 663
			if (pba < min_rx_space)
				pba = min_rx_space;
664
		}
L
Linus Torvalds 已提交
665
	}
666

J
Joe Perches 已提交
667
	ew32(PBA, pba);
L
Linus Torvalds 已提交
668

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
	/*
	 * flow control settings:
	 * The high water mark must be low enough to fit one full frame
	 * (or the size used for early receive) above it in the Rx FIFO.
	 * Set it to the lower of:
	 * - 90% of the Rx FIFO size, and
	 * - the full Rx FIFO size minus the early receive size (for parts
	 *   with ERT support assuming ERT set to E1000_ERT_2048), or
	 * - the full Rx FIFO size minus one full frame
	 */
	hwm = min(((pba << 10) * 9 / 10),
		  ((pba << 10) - hw->max_frame_size));

	hw->fc_high_water = hwm & 0xFFF8;	/* 8-byte granularity */
	hw->fc_low_water = hw->fc_high_water - 8;
684
	hw->fc_pause_time = E1000_FC_PAUSE_TIME;
J
Joe Perches 已提交
685 686
	hw->fc_send_xon = 1;
	hw->fc = hw->original_fc;
L
Linus Torvalds 已提交
687

688
	/* Allow time for pending master requests to run */
J
Joe Perches 已提交
689 690 691
	e1000_reset_hw(hw);
	if (hw->mac_type >= e1000_82544)
		ew32(WUC, 0);
692

J
Joe Perches 已提交
693
	if (e1000_init_hw(hw))
694
		e_dev_err("Hardware Error\n");
695
	e1000_update_mng_vlan(adapter);
696 697

	/* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
J
Joe Perches 已提交
698 699 700 701
	if (hw->mac_type >= e1000_82544 &&
	    hw->autoneg == 1 &&
	    hw->autoneg_advertised == ADVERTISE_1000_FULL) {
		u32 ctrl = er32(CTRL);
702 703 704 705
		/* clear phy power management bit if we are in gig only mode,
		 * which if enabled will attempt negotiation to 100Mb, which
		 * can cause a loss of link at power off or driver unload */
		ctrl &= ~E1000_CTRL_SWDPIN3;
J
Joe Perches 已提交
706
		ew32(CTRL, ctrl);
707 708
	}

L
Linus Torvalds 已提交
709
	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
J
Joe Perches 已提交
710
	ew32(VET, ETHERNET_IEEE_VLAN_TYPE);
L
Linus Torvalds 已提交
711

J
Joe Perches 已提交
712 713
	e1000_reset_adaptive(hw);
	e1000_phy_get_info(hw, &adapter->phy_info);
A
Auke Kok 已提交
714

715
	e1000_release_manageability(adapter);
L
Linus Torvalds 已提交
716 717
}

718 719 720
/**
 *  Dump the eeprom for users having checksum issues
 **/
721
static void e1000_dump_eeprom(struct e1000_adapter *adapter)
722 723 724 725 726 727 728 729 730 731 732 733 734
{
	struct net_device *netdev = adapter->netdev;
	struct ethtool_eeprom eeprom;
	const struct ethtool_ops *ops = netdev->ethtool_ops;
	u8 *data;
	int i;
	u16 csum_old, csum_new = 0;

	eeprom.len = ops->get_eeprom_len(netdev);
	eeprom.offset = 0;

	data = kmalloc(eeprom.len, GFP_KERNEL);
	if (!data) {
735
		pr_err("Unable to allocate memory to dump EEPROM data\n");
736 737 738 739 740 741 742 743 744 745 746
		return;
	}

	ops->get_eeprom(netdev, &eeprom, data);

	csum_old = (data[EEPROM_CHECKSUM_REG * 2]) +
		   (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8);
	for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2)
		csum_new += data[i] + (data[i + 1] << 8);
	csum_new = EEPROM_SUM - csum_new;

747 748 749
	pr_err("/*********************/\n");
	pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old);
	pr_err("Calculated              : 0x%04x\n", csum_new);
750

751 752
	pr_err("Offset    Values\n");
	pr_err("========  ======\n");
753 754
	print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0);

755 756 757 758 759 760 761 762 763 764 765
	pr_err("Include this output when contacting your support provider.\n");
	pr_err("This is not a software error! Something bad happened to\n");
	pr_err("your hardware or EEPROM image. Ignoring this problem could\n");
	pr_err("result in further problems, possibly loss of data,\n");
	pr_err("corruption or system hangs!\n");
	pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n");
	pr_err("which is invalid and requires you to set the proper MAC\n");
	pr_err("address manually before continuing to enable this network\n");
	pr_err("device. Please inspect the EEPROM dump and report the\n");
	pr_err("issue to your hardware vendor or Intel Customer Support.\n");
	pr_err("/*********************/\n");
766 767 768 769

	kfree(data);
}

T
Taku Izumi 已提交
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
/**
 * e1000_is_need_ioport - determine if an adapter needs ioport resources or not
 * @pdev: PCI device information struct
 *
 * Return true if an adapter needs ioport resources
 **/
static int e1000_is_need_ioport(struct pci_dev *pdev)
{
	switch (pdev->device) {
	case E1000_DEV_ID_82540EM:
	case E1000_DEV_ID_82540EM_LOM:
	case E1000_DEV_ID_82540EP:
	case E1000_DEV_ID_82540EP_LOM:
	case E1000_DEV_ID_82540EP_LP:
	case E1000_DEV_ID_82541EI:
	case E1000_DEV_ID_82541EI_MOBILE:
	case E1000_DEV_ID_82541ER:
	case E1000_DEV_ID_82541ER_LOM:
	case E1000_DEV_ID_82541GI:
	case E1000_DEV_ID_82541GI_LF:
	case E1000_DEV_ID_82541GI_MOBILE:
	case E1000_DEV_ID_82544EI_COPPER:
	case E1000_DEV_ID_82544EI_FIBER:
	case E1000_DEV_ID_82544GC_COPPER:
	case E1000_DEV_ID_82544GC_LOM:
	case E1000_DEV_ID_82545EM_COPPER:
	case E1000_DEV_ID_82545EM_FIBER:
	case E1000_DEV_ID_82546EB_COPPER:
	case E1000_DEV_ID_82546EB_FIBER:
	case E1000_DEV_ID_82546EB_QUAD_COPPER:
		return true;
	default:
		return false;
	}
}

J
Jiri Pirko 已提交
806 807 808 809 810 811 812 813 814 815 816 817 818 819
static u32 e1000_fix_features(struct net_device *netdev, u32 features)
{
	/*
	 * Since there is no support for separate rx/tx vlan accel
	 * enable/disable make sure tx flag is always in same state as rx.
	 */
	if (features & NETIF_F_HW_VLAN_RX)
		features |= NETIF_F_HW_VLAN_TX;
	else
		features &= ~NETIF_F_HW_VLAN_TX;

	return features;
}

820 821 822 823 824
static int e1000_set_features(struct net_device *netdev, u32 features)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	u32 changed = features ^ netdev->features;

J
Jiri Pirko 已提交
825 826 827
	if (changed & NETIF_F_HW_VLAN_RX)
		e1000_vlan_mode(netdev, features);

828 829 830 831 832 833 834 835 836 837 838 839 840
	if (!(changed & NETIF_F_RXCSUM))
		return 0;

	adapter->rx_csum = !!(features & NETIF_F_RXCSUM);

	if (netif_running(netdev))
		e1000_reinit_locked(adapter);
	else
		e1000_reset(adapter);

	return 0;
}

841 842 843
static const struct net_device_ops e1000_netdev_ops = {
	.ndo_open		= e1000_open,
	.ndo_stop		= e1000_close,
844
	.ndo_start_xmit		= e1000_xmit_frame,
845 846 847
	.ndo_get_stats		= e1000_get_stats,
	.ndo_set_rx_mode	= e1000_set_rx_mode,
	.ndo_set_mac_address	= e1000_set_mac,
J
Jiri Pirko 已提交
848
	.ndo_tx_timeout		= e1000_tx_timeout,
849 850 851 852 853 854 855 856
	.ndo_change_mtu		= e1000_change_mtu,
	.ndo_do_ioctl		= e1000_ioctl,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_vlan_rx_add_vid	= e1000_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= e1000_vlan_rx_kill_vid,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= e1000_netpoll,
#endif
J
Jiri Pirko 已提交
857 858
	.ndo_fix_features	= e1000_fix_features,
	.ndo_set_features	= e1000_set_features,
859 860
};

861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
/**
 * e1000_init_hw_struct - initialize members of hw struct
 * @adapter: board private struct
 * @hw: structure used by e1000_hw.c
 *
 * Factors out initialization of the e1000_hw struct to its own function
 * that can be called very early at init (just after struct allocation).
 * Fields are initialized based on PCI device information and
 * OS network device settings (MTU size).
 * Returns negative error codes if MAC type setup fails.
 */
static int e1000_init_hw_struct(struct e1000_adapter *adapter,
				struct e1000_hw *hw)
{
	struct pci_dev *pdev = adapter->pdev;

	/* PCI config space info */
	hw->vendor_id = pdev->vendor;
	hw->device_id = pdev->device;
	hw->subsystem_vendor_id = pdev->subsystem_vendor;
	hw->subsystem_id = pdev->subsystem_device;
	hw->revision_id = pdev->revision;

	pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);

	hw->max_frame_size = adapter->netdev->mtu +
			     ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
	hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;

	/* identify the MAC */
	if (e1000_set_mac_type(hw)) {
		e_err(probe, "Unknown MAC Type\n");
		return -EIO;
	}

	switch (hw->mac_type) {
	default:
		break;
	case e1000_82541:
	case e1000_82547:
	case e1000_82541_rev_2:
	case e1000_82547_rev_2:
		hw->phy_init_script = 1;
		break;
	}

	e1000_set_media_type(hw);
	e1000_get_bus_info(hw);

	hw->wait_autoneg_complete = false;
	hw->tbi_compatibility_en = true;
	hw->adaptive_ifs = true;

	/* Copper options */

	if (hw->media_type == e1000_media_type_copper) {
		hw->mdix = AUTO_ALL_MODES;
		hw->disable_polarity_correction = false;
		hw->master_slave = E1000_MASTER_SLAVE;
	}

	return 0;
}

L
Linus Torvalds 已提交
925 926 927 928 929 930 931 932 933 934 935
/**
 * e1000_probe - Device Initialization Routine
 * @pdev: PCI device information struct
 * @ent: entry in e1000_pci_tbl
 *
 * Returns 0 on success, negative on failure
 *
 * e1000_probe initializes an adapter identified by a pci_dev structure.
 * The OS initialization, configuring of the adapter private structure,
 * and a hardware reset occur.
 **/
J
Joe Perches 已提交
936 937
static int __devinit e1000_probe(struct pci_dev *pdev,
				 const struct pci_device_id *ent)
L
Linus Torvalds 已提交
938 939 940
{
	struct net_device *netdev;
	struct e1000_adapter *adapter;
J
Joe Perches 已提交
941
	struct e1000_hw *hw;
942

L
Linus Torvalds 已提交
943
	static int cards_found = 0;
944
	static int global_quad_port_a = 0; /* global ksp3 port a indication */
945
	int i, err, pci_using_dac;
946
	u16 eeprom_data = 0;
947
	u16 tmp = 0;
948
	u16 eeprom_apme_mask = E1000_EEPROM_APME;
T
Taku Izumi 已提交
949
	int bars, need_ioport;
950

T
Taku Izumi 已提交
951 952 953 954 955 956 957
	/* do not allocate ioport bars when not needed */
	need_ioport = e1000_is_need_ioport(pdev);
	if (need_ioport) {
		bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
		err = pci_enable_device(pdev);
	} else {
		bars = pci_select_bars(pdev, IORESOURCE_MEM);
958
		err = pci_enable_device_mem(pdev);
T
Taku Izumi 已提交
959
	}
960
	if (err)
L
Linus Torvalds 已提交
961 962
		return err;

T
Taku Izumi 已提交
963
	err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
964
	if (err)
965
		goto err_pci_reg;
L
Linus Torvalds 已提交
966 967

	pci_set_master(pdev);
968 969 970
	err = pci_save_state(pdev);
	if (err)
		goto err_alloc_etherdev;
L
Linus Torvalds 已提交
971

972
	err = -ENOMEM;
L
Linus Torvalds 已提交
973
	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
974
	if (!netdev)
L
Linus Torvalds 已提交
975 976 977 978 979
		goto err_alloc_etherdev;

	SET_NETDEV_DEV(netdev, &pdev->dev);

	pci_set_drvdata(pdev, netdev);
980
	adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
981 982 983
	adapter->netdev = netdev;
	adapter->pdev = pdev;
	adapter->msg_enable = (1 << debug) - 1;
T
Taku Izumi 已提交
984 985
	adapter->bars = bars;
	adapter->need_ioport = need_ioport;
L
Linus Torvalds 已提交
986

J
Joe Perches 已提交
987 988 989
	hw = &adapter->hw;
	hw->back = adapter;

990
	err = -EIO;
991
	hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
J
Joe Perches 已提交
992
	if (!hw->hw_addr)
L
Linus Torvalds 已提交
993 994
		goto err_ioremap;

T
Taku Izumi 已提交
995 996 997 998 999 1000 1001 1002
	if (adapter->need_ioport) {
		for (i = BAR_1; i <= BAR_5; i++) {
			if (pci_resource_len(pdev, i) == 0)
				continue;
			if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
				hw->io_base = pci_resource_start(pdev, i);
				break;
			}
L
Linus Torvalds 已提交
1003 1004 1005
		}
	}

1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
	/* make ready for any if (hw->...) below */
	err = e1000_init_hw_struct(adapter, hw);
	if (err)
		goto err_sw_init;

	/*
	 * there is a workaround being applied below that limits
	 * 64-bit DMA addresses to 64-bit hardware.  There are some
	 * 32-bit adapters that Tx hang when given 64-bit DMA addresses
	 */
	pci_using_dac = 0;
	if ((hw->bus_type == e1000_bus_type_pcix) &&
	    !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
		/*
		 * according to DMA-API-HOWTO, coherent calls will always
		 * succeed if the set call did
		 */
		dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
		pci_using_dac = 1;
	} else {
1026 1027 1028 1029 1030 1031
		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
		if (err) {
			pr_err("No usable DMA config, aborting\n");
			goto err_dma;
		}
		dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
1032 1033
	}

1034
	netdev->netdev_ops = &e1000_netdev_ops;
L
Linus Torvalds 已提交
1035 1036
	e1000_set_ethtool_ops(netdev);
	netdev->watchdog_timeo = 5 * HZ;
1037
	netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
1038

1039
	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
L
Linus Torvalds 已提交
1040 1041 1042 1043 1044

	adapter->bd_number = cards_found;

	/* setup the private structure */

1045 1046
	err = e1000_sw_init(adapter);
	if (err)
L
Linus Torvalds 已提交
1047 1048
		goto err_sw_init;

1049
	err = -EIO;
1050 1051 1052 1053 1054 1055 1056 1057
	if (hw->mac_type == e1000_ce4100) {
		ce4100_gbe_mdio_base_phy = pci_resource_start(pdev, BAR_1);
		ce4100_gbe_mdio_base_virt = ioremap(ce4100_gbe_mdio_base_phy,
		                                pci_resource_len(pdev, BAR_1));

		if (!ce4100_gbe_mdio_base_virt)
			goto err_mdio_ioremap;
	}
1058

J
Joe Perches 已提交
1059
	if (hw->mac_type >= e1000_82543) {
1060
		netdev->hw_features = NETIF_F_SG |
J
Jiri Pirko 已提交
1061 1062
				   NETIF_F_HW_CSUM |
				   NETIF_F_HW_VLAN_RX;
1063
		netdev->features = NETIF_F_HW_VLAN_TX |
L
Linus Torvalds 已提交
1064 1065 1066
				   NETIF_F_HW_VLAN_FILTER;
	}

J
Joe Perches 已提交
1067 1068
	if ((hw->mac_type >= e1000_82544) &&
	   (hw->mac_type != e1000_82547))
1069 1070 1071 1072
		netdev->hw_features |= NETIF_F_TSO;

	netdev->features |= netdev->hw_features;
	netdev->hw_features |= NETIF_F_RXCSUM;
1073

1074
	if (pci_using_dac) {
L
Linus Torvalds 已提交
1075
		netdev->features |= NETIF_F_HIGHDMA;
1076 1077
		netdev->vlan_features |= NETIF_F_HIGHDMA;
	}
L
Linus Torvalds 已提交
1078

1079 1080 1081 1082
	netdev->vlan_features |= NETIF_F_TSO;
	netdev->vlan_features |= NETIF_F_HW_CSUM;
	netdev->vlan_features |= NETIF_F_SG;

J
Joe Perches 已提交
1083
	adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw);
1084

1085
	/* initialize eeprom parameters */
J
Joe Perches 已提交
1086
	if (e1000_init_eeprom_params(hw)) {
1087
		e_err(probe, "EEPROM initialization failed\n");
1088
		goto err_eeprom;
1089 1090
	}

J
Jesse Brandeburg 已提交
1091
	/* before reading the EEPROM, reset the controller to
L
Linus Torvalds 已提交
1092
	 * put the device in a known good starting state */
J
Jesse Brandeburg 已提交
1093

J
Joe Perches 已提交
1094
	e1000_reset_hw(hw);
L
Linus Torvalds 已提交
1095 1096

	/* make sure the EEPROM is good */
J
Joe Perches 已提交
1097
	if (e1000_validate_eeprom_checksum(hw) < 0) {
1098
		e_err(probe, "The EEPROM Checksum Is Not Valid\n");
1099 1100 1101 1102 1103 1104 1105 1106 1107
		e1000_dump_eeprom(adapter);
		/*
		 * set MAC address to all zeroes to invalidate and temporary
		 * disable this device for the user. This blocks regular
		 * traffic while still permitting ethtool ioctls from reaching
		 * the hardware as well as allowing the user to run the
		 * interface after manually setting a hw addr using
		 * `ip set address`
		 */
J
Joe Perches 已提交
1108
		memset(hw->mac_addr, 0, netdev->addr_len);
1109 1110
	} else {
		/* copy the MAC address out of the EEPROM */
J
Joe Perches 已提交
1111
		if (e1000_read_mac_addr(hw))
1112
			e_err(probe, "EEPROM Read Error\n");
L
Linus Torvalds 已提交
1113
	}
1114
	/* don't block initalization here due to bad MAC address */
J
Joe Perches 已提交
1115 1116
	memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);
	memcpy(netdev->perm_addr, hw->mac_addr, netdev->addr_len);
L
Linus Torvalds 已提交
1117

1118
	if (!is_valid_ether_addr(netdev->perm_addr))
1119
		e_err(probe, "Invalid MAC Address\n");
L
Linus Torvalds 已提交
1120 1121

	init_timer(&adapter->tx_fifo_stall_timer);
1122
	adapter->tx_fifo_stall_timer.function = e1000_82547_tx_fifo_stall;
1123
	adapter->tx_fifo_stall_timer.data = (unsigned long)adapter;
L
Linus Torvalds 已提交
1124 1125

	init_timer(&adapter->watchdog_timer);
1126
	adapter->watchdog_timer.function = e1000_watchdog;
L
Linus Torvalds 已提交
1127 1128 1129
	adapter->watchdog_timer.data = (unsigned long) adapter;

	init_timer(&adapter->phy_info_timer);
1130
	adapter->phy_info_timer.function = e1000_update_phy_info;
1131
	adapter->phy_info_timer.data = (unsigned long)adapter;
L
Linus Torvalds 已提交
1132

J
Jesse Brandeburg 已提交
1133
	INIT_WORK(&adapter->fifo_stall_task, e1000_82547_tx_fifo_stall_task);
1134
	INIT_WORK(&adapter->reset_task, e1000_reset_task);
J
Jesse Brandeburg 已提交
1135
	INIT_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);
L
Linus Torvalds 已提交
1136 1137 1138 1139 1140 1141 1142 1143

	e1000_check_options(adapter);

	/* Initial Wake on LAN setting
	 * If APM wake is enabled in the EEPROM,
	 * enable the ACPI Magic Packet filter
	 */

J
Joe Perches 已提交
1144
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1145 1146 1147 1148 1149
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
	case e1000_82543:
		break;
	case e1000_82544:
J
Joe Perches 已提交
1150
		e1000_read_eeprom(hw,
L
Linus Torvalds 已提交
1151 1152 1153 1154 1155
			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
		eeprom_apme_mask = E1000_EEPROM_82544_APM;
		break;
	case e1000_82546:
	case e1000_82546_rev_3:
J
Joe Perches 已提交
1156 1157
		if (er32(STATUS) & E1000_STATUS_FUNC_1){
			e1000_read_eeprom(hw,
L
Linus Torvalds 已提交
1158 1159 1160 1161 1162
				EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
			break;
		}
		/* Fall Through */
	default:
J
Joe Perches 已提交
1163
		e1000_read_eeprom(hw,
L
Linus Torvalds 已提交
1164 1165 1166
			EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
		break;
	}
J
Jesse Brandeburg 已提交
1167
	if (eeprom_data & eeprom_apme_mask)
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
		adapter->eeprom_wol |= E1000_WUFC_MAG;

	/* now that we have the eeprom settings, apply the special cases
	 * where the eeprom may be wrong or the board simply won't support
	 * wake on lan on a particular port */
	switch (pdev->device) {
	case E1000_DEV_ID_82546GB_PCIE:
		adapter->eeprom_wol = 0;
		break;
	case E1000_DEV_ID_82546EB_FIBER:
	case E1000_DEV_ID_82546GB_FIBER:
		/* Wake events only supported on port A for dual fiber
		 * regardless of eeprom setting */
J
Joe Perches 已提交
1181
		if (er32(STATUS) & E1000_STATUS_FUNC_1)
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
			adapter->eeprom_wol = 0;
		break;
	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
		/* if quad port adapter, disable WoL on all but port A */
		if (global_quad_port_a != 0)
			adapter->eeprom_wol = 0;
		else
			adapter->quad_port_a = 1;
		/* Reset for multiple quad port adapters */
		if (++global_quad_port_a == 4)
			global_quad_port_a = 0;
		break;
	}

	/* initialize the wol settings based on the eeprom settings */
	adapter->wol = adapter->eeprom_wol;
1198
	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
L
Linus Torvalds 已提交
1199

1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
	/* Auto detect PHY address */
	if (hw->mac_type == e1000_ce4100) {
		for (i = 0; i < 32; i++) {
			hw->phy_addr = i;
			e1000_read_phy_reg(hw, PHY_ID2, &tmp);
			if (tmp == 0 || tmp == 0xFF) {
				if (i == 31)
					goto err_eeprom;
				continue;
			} else
				break;
		}
	}

1214 1215 1216 1217 1218 1219 1220 1221
	/* reset the hardware with the new settings */
	e1000_reset(adapter);

	strcpy(netdev->name, "eth%d");
	err = register_netdev(netdev);
	if (err)
		goto err_register;

J
Jiri Pirko 已提交
1222 1223
	e1000_vlan_mode(netdev, netdev->features);

1224
	/* print bus type/speed/width info */
1225
	e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",
J
Joe Perches 已提交
1226 1227 1228 1229 1230 1231 1232
	       ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),
	       ((hw->bus_speed == e1000_bus_speed_133) ? 133 :
		(hw->bus_speed == e1000_bus_speed_120) ? 120 :
		(hw->bus_speed == e1000_bus_speed_100) ? 100 :
		(hw->bus_speed == e1000_bus_speed_66) ? 66 : 33),
	       ((hw->bus_width == e1000_bus_width_64) ? 64 : 32),
	       netdev->dev_addr);
A
Auke Kok 已提交
1233

1234 1235 1236
	/* carrier off reporting is important to ethtool even BEFORE open */
	netif_carrier_off(netdev);

1237
	e_info(probe, "Intel(R) PRO/1000 Network Connection\n");
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242

	cards_found++;
	return 0;

err_register:
1243
err_eeprom:
1244
	e1000_phy_hw_reset(hw);
1245

J
Joe Perches 已提交
1246 1247
	if (hw->flash_address)
		iounmap(hw->flash_address);
1248 1249
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
1250
err_dma:
L
Linus Torvalds 已提交
1251
err_sw_init:
1252 1253
err_mdio_ioremap:
	iounmap(ce4100_gbe_mdio_base_virt);
J
Joe Perches 已提交
1254
	iounmap(hw->hw_addr);
L
Linus Torvalds 已提交
1255 1256 1257
err_ioremap:
	free_netdev(netdev);
err_alloc_etherdev:
T
Taku Izumi 已提交
1258
	pci_release_selected_regions(pdev, bars);
1259 1260
err_pci_reg:
	pci_disable_device(pdev);
L
Linus Torvalds 已提交
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
	return err;
}

/**
 * e1000_remove - Device Removal Routine
 * @pdev: PCI device information struct
 *
 * e1000_remove is called by the PCI subsystem to alert the driver
 * that it should release a PCI device.  The could be caused by a
 * Hot-Plug event, or because the driver is going to be removed from
 * memory.
 **/

1274
static void __devexit e1000_remove(struct pci_dev *pdev)
L
Linus Torvalds 已提交
1275 1276
{
	struct net_device *netdev = pci_get_drvdata(pdev);
1277
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
1278
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
1279

1280 1281 1282 1283 1284
	set_bit(__E1000_DOWN, &adapter->flags);
	del_timer_sync(&adapter->tx_fifo_stall_timer);
	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

1285
	cancel_work_sync(&adapter->reset_task);
J
Jeff Garzik 已提交
1286

1287
	e1000_release_manageability(adapter);
L
Linus Torvalds 已提交
1288

1289 1290
	unregister_netdev(netdev);

1291
	e1000_phy_hw_reset(hw);
L
Linus Torvalds 已提交
1292

1293 1294 1295
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);

J
Joe Perches 已提交
1296 1297 1298
	iounmap(hw->hw_addr);
	if (hw->flash_address)
		iounmap(hw->flash_address);
T
Taku Izumi 已提交
1299
	pci_release_selected_regions(pdev, adapter->bars);
L
Linus Torvalds 已提交
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310

	free_netdev(netdev);

	pci_disable_device(pdev);
}

/**
 * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
 * @adapter: board private structure to initialize
 *
 * e1000_sw_init initializes the Adapter private data structure.
1311
 * e1000_init_hw_struct MUST be called before this function
L
Linus Torvalds 已提交
1312 1313
 **/

1314
static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
1315
{
1316
	adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
L
Linus Torvalds 已提交
1317

1318 1319
	adapter->num_tx_queues = 1;
	adapter->num_rx_queues = 1;
1320 1321

	if (e1000_alloc_queues(adapter)) {
1322
		e_err(probe, "Unable to allocate memory for queues\n");
1323 1324 1325
		return -ENOMEM;
	}

1326 1327 1328
	/* Explicitly disable IRQ since the NIC can be in any state. */
	e1000_irq_disable(adapter);

L
Linus Torvalds 已提交
1329 1330
	spin_lock_init(&adapter->stats_lock);

A
Auke Kok 已提交
1331 1332
	set_bit(__E1000_DOWN, &adapter->flags);

L
Linus Torvalds 已提交
1333 1334 1335
	return 0;
}

1336 1337 1338 1339 1340
/**
 * e1000_alloc_queues - Allocate memory for all rings
 * @adapter: board private structure to initialize
 *
 * We allocate one ring per queue at run-time since we don't know the
1341
 * number of queues at compile-time.
1342 1343
 **/

1344
static int __devinit e1000_alloc_queues(struct e1000_adapter *adapter)
1345
{
Y
Yan Burman 已提交
1346 1347
	adapter->tx_ring = kcalloc(adapter->num_tx_queues,
	                           sizeof(struct e1000_tx_ring), GFP_KERNEL);
1348 1349 1350
	if (!adapter->tx_ring)
		return -ENOMEM;

Y
Yan Burman 已提交
1351 1352
	adapter->rx_ring = kcalloc(adapter->num_rx_queues,
	                           sizeof(struct e1000_rx_ring), GFP_KERNEL);
1353 1354 1355 1356 1357 1358 1359 1360
	if (!adapter->rx_ring) {
		kfree(adapter->tx_ring);
		return -ENOMEM;
	}

	return E1000_SUCCESS;
}

L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
/**
 * e1000_open - Called when a network interface is made active
 * @netdev: network interface device structure
 *
 * Returns 0 on success, negative value on failure
 *
 * The open entry point is called when a network interface is made
 * active by the system (IFF_UP).  At this point all resources needed
 * for transmit and receive operations are allocated, the interrupt
 * handler is registered with the OS, the watchdog timer is started,
 * and the stack is notified that the interface is ready.
 **/

1374
static int e1000_open(struct net_device *netdev)
L
Linus Torvalds 已提交
1375
{
1376
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
1377
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
1378 1379
	int err;

1380
	/* disallow open during test */
A
Auke Kok 已提交
1381
	if (test_bit(__E1000_TESTING, &adapter->flags))
1382 1383
		return -EBUSY;

1384 1385
	netif_carrier_off(netdev);

L
Linus Torvalds 已提交
1386
	/* allocate transmit descriptors */
1387 1388
	err = e1000_setup_all_tx_resources(adapter);
	if (err)
L
Linus Torvalds 已提交
1389 1390 1391
		goto err_setup_tx;

	/* allocate receive descriptors */
1392
	err = e1000_setup_all_rx_resources(adapter);
1393
	if (err)
1394
		goto err_setup_rx;
1395

1396 1397
	e1000_power_up_phy(adapter);

1398
	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
J
Joe Perches 已提交
1399
	if ((hw->mng_cookie.status &
1400 1401 1402
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_update_mng_vlan(adapter);
	}
L
Linus Torvalds 已提交
1403

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
	/* before we allocate an interrupt, we must be ready to handle it.
	 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
	 * as soon as we call pci_request_irq, so we have to setup our
	 * clean_rx handler before we do so.  */
	e1000_configure(adapter);

	err = e1000_request_irq(adapter);
	if (err)
		goto err_req_irq;

	/* From here on the code is the same as e1000_up() */
	clear_bit(__E1000_DOWN, &adapter->flags);

1417
	napi_enable(&adapter->napi);
1418

1419 1420
	e1000_irq_enable(adapter);

B
Ben Hutchings 已提交
1421 1422
	netif_start_queue(netdev);

1423
	/* fire a link status change interrupt to start the watchdog */
J
Joe Perches 已提交
1424
	ew32(ICS, E1000_ICS_LSC);
1425

L
Linus Torvalds 已提交
1426 1427
	return E1000_SUCCESS;

1428
err_req_irq:
1429
	e1000_power_down_phy(adapter);
1430
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1431
err_setup_rx:
1432
	e1000_free_all_tx_resources(adapter);
L
Linus Torvalds 已提交
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
err_setup_tx:
	e1000_reset(adapter);

	return err;
}

/**
 * e1000_close - Disables a network interface
 * @netdev: network interface device structure
 *
 * Returns 0, this is not allowed to fail
 *
 * The close entry point is called when an interface is de-activated
 * by the OS.  The hardware is still under the drivers control, but
 * needs to be disabled.  A global MAC reset is issued to stop the
 * hardware, and all transmit and receive resources are freed.
 **/

1451
static int e1000_close(struct net_device *netdev)
L
Linus Torvalds 已提交
1452
{
1453
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
1454
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
1455

1456
	WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
L
Linus Torvalds 已提交
1457
	e1000_down(adapter);
1458
	e1000_power_down_phy(adapter);
1459
	e1000_free_irq(adapter);
L
Linus Torvalds 已提交
1460

1461 1462
	e1000_free_all_tx_resources(adapter);
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1463

1464 1465
	/* kill manageability vlan ID if supported, but not if a vlan with
	 * the same ID is registered on the host OS (let 8021q kill it) */
J
Joe Perches 已提交
1466
	if ((hw->mng_cookie.status &
1467
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
J
Jiri Pirko 已提交
1468
	     !test_bit(adapter->mng_vlan_id, adapter->active_vlans)) {
1469 1470
		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
	}
1471

L
Linus Torvalds 已提交
1472 1473 1474 1475 1476 1477
	return 0;
}

/**
 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
 * @adapter: address of board private structure
1478 1479
 * @start: address of beginning of memory
 * @len: length of memory
L
Linus Torvalds 已提交
1480
 **/
1481 1482
static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start,
				  unsigned long len)
L
Linus Torvalds 已提交
1483
{
J
Joe Perches 已提交
1484
	struct e1000_hw *hw = &adapter->hw;
1485
	unsigned long begin = (unsigned long)start;
L
Linus Torvalds 已提交
1486 1487
	unsigned long end = begin + len;

1488 1489
	/* First rev 82545 and 82546 need to not allow any memory
	 * write location to cross 64k boundary due to errata 23 */
J
Joe Perches 已提交
1490
	if (hw->mac_type == e1000_82545 ||
1491
	    hw->mac_type == e1000_ce4100 ||
J
Joe Perches 已提交
1492
	    hw->mac_type == e1000_82546) {
J
Joe Perches 已提交
1493
		return ((begin ^ (end - 1)) >> 16) != 0 ? false : true;
L
Linus Torvalds 已提交
1494 1495
	}

J
Joe Perches 已提交
1496
	return true;
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501
}

/**
 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 * @adapter: board private structure
1502
 * @txdr:    tx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1503 1504 1505 1506
 *
 * Return 0 on success, negative on failure
 **/

1507 1508
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
				    struct e1000_tx_ring *txdr)
L
Linus Torvalds 已提交
1509 1510 1511 1512 1513
{
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct e1000_buffer) * txdr->count;
E
Eric Dumazet 已提交
1514
	txdr->buffer_info = vzalloc(size);
J
Jesse Brandeburg 已提交
1515
	if (!txdr->buffer_info) {
1516 1517
		e_err(probe, "Unable to allocate memory for the Tx descriptor "
		      "ring\n");
L
Linus Torvalds 已提交
1518 1519 1520 1521 1522 1523
		return -ENOMEM;
	}

	/* round up to nearest 4K */

	txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
1524
	txdr->size = ALIGN(txdr->size, 4096);
L
Linus Torvalds 已提交
1525

1526 1527
	txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
					GFP_KERNEL);
J
Jesse Brandeburg 已提交
1528
	if (!txdr->desc) {
L
Linus Torvalds 已提交
1529 1530
setup_tx_desc_die:
		vfree(txdr->buffer_info);
1531 1532
		e_err(probe, "Unable to allocate memory for the Tx descriptor "
		      "ring\n");
L
Linus Torvalds 已提交
1533 1534 1535
		return -ENOMEM;
	}

1536
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1537 1538 1539
	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
		void *olddesc = txdr->desc;
		dma_addr_t olddma = txdr->dma;
1540
		e_err(tx_err, "txdr align check failed: %u bytes at %p\n",
1541
		      txdr->size, txdr->desc);
1542
		/* Try again, without freeing the previous */
1543 1544
		txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size,
						&txdr->dma, GFP_KERNEL);
1545
		/* Failed allocation, critical failure */
J
Jesse Brandeburg 已提交
1546
		if (!txdr->desc) {
1547 1548
			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
					  olddma);
L
Linus Torvalds 已提交
1549 1550 1551 1552 1553
			goto setup_tx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
			/* give up */
1554 1555 1556 1557
			dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
					  txdr->dma);
			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
					  olddma);
1558
			e_err(probe, "Unable to allocate aligned memory "
1559
			      "for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1560 1561 1562
			vfree(txdr->buffer_info);
			return -ENOMEM;
		} else {
1563
			/* Free old allocation, new allocation was successful */
1564 1565
			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
					  olddma);
L
Linus Torvalds 已提交
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
		}
	}
	memset(txdr->desc, 0, txdr->size);

	txdr->next_to_use = 0;
	txdr->next_to_clean = 0;

	return 0;
}

1576 1577 1578 1579 1580 1581 1582 1583
/**
 * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * Return 0 on success, negative on failure
 **/

1584
int e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
1585 1586 1587
{
	int i, err = 0;

1588
	for (i = 0; i < adapter->num_tx_queues; i++) {
1589 1590
		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
		if (err) {
1591
			e_err(probe, "Allocation for Tx Queue %u failed\n", i);
1592 1593 1594
			for (i-- ; i >= 0; i--)
				e1000_free_tx_resources(adapter,
							&adapter->tx_ring[i]);
1595 1596 1597 1598 1599 1600 1601
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1602 1603 1604 1605 1606 1607 1608
/**
 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
 * @adapter: board private structure
 *
 * Configure the Tx unit of the MAC after a reset.
 **/

1609
static void e1000_configure_tx(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
1610
{
1611
	u64 tdba;
1612
	struct e1000_hw *hw = &adapter->hw;
1613
	u32 tdlen, tctl, tipg;
1614
	u32 ipgr1, ipgr2;
L
Linus Torvalds 已提交
1615 1616 1617

	/* Setup the HW Tx Head and Tail descriptor pointers */

1618
	switch (adapter->num_tx_queues) {
1619 1620
	case 1:
	default:
1621 1622 1623
		tdba = adapter->tx_ring[0].dma;
		tdlen = adapter->tx_ring[0].count *
			sizeof(struct e1000_tx_desc);
J
Joe Perches 已提交
1624 1625 1626 1627 1628
		ew32(TDLEN, tdlen);
		ew32(TDBAH, (tdba >> 32));
		ew32(TDBAL, (tdba & 0x00000000ffffffffULL));
		ew32(TDT, 0);
		ew32(TDH, 0);
1629 1630
		adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ? E1000_TDH : E1000_82542_TDH);
		adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ? E1000_TDT : E1000_82542_TDT);
1631 1632
		break;
	}
L
Linus Torvalds 已提交
1633 1634

	/* Set the default values for the Tx Inter Packet Gap timer */
1635
	if ((hw->media_type == e1000_media_type_fiber ||
1636
	     hw->media_type == e1000_media_type_internal_serdes))
1637 1638 1639 1640
		tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
	else
		tipg = DEFAULT_82543_TIPG_IPGT_COPPER;

1641
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1642 1643 1644
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
		tipg = DEFAULT_82542_TIPG_IPGT;
1645 1646
		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
L
Linus Torvalds 已提交
1647 1648
		break;
	default:
1649 1650 1651
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1652
	}
1653 1654
	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
J
Joe Perches 已提交
1655
	ew32(TIPG, tipg);
L
Linus Torvalds 已提交
1656 1657 1658

	/* Set the Tx Interrupt Delay register */

J
Joe Perches 已提交
1659
	ew32(TIDV, adapter->tx_int_delay);
1660
	if (hw->mac_type >= e1000_82540)
J
Joe Perches 已提交
1661
		ew32(TADV, adapter->tx_abs_int_delay);
L
Linus Torvalds 已提交
1662 1663 1664

	/* Program the Transmit Control Register */

J
Joe Perches 已提交
1665
	tctl = er32(TCTL);
L
Linus Torvalds 已提交
1666
	tctl &= ~E1000_TCTL_CT;
1667
	tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
L
Linus Torvalds 已提交
1668 1669
		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);

1670
	e1000_config_collision_dist(hw);
L
Linus Torvalds 已提交
1671 1672

	/* Setup Transmit Descriptor Settings for eop descriptor */
1673 1674 1675 1676 1677
	adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;

	/* only set IDE if we are delaying interrupts using the timers */
	if (adapter->tx_int_delay)
		adapter->txd_cmd |= E1000_TXD_CMD_IDE;
L
Linus Torvalds 已提交
1678

1679
	if (hw->mac_type < e1000_82543)
L
Linus Torvalds 已提交
1680 1681 1682 1683 1684 1685
		adapter->txd_cmd |= E1000_TXD_CMD_RPS;
	else
		adapter->txd_cmd |= E1000_TXD_CMD_RS;

	/* Cache if we're 82544 running in PCI-X because we'll
	 * need this to apply a workaround later in the send path. */
1686 1687
	if (hw->mac_type == e1000_82544 &&
	    hw->bus_type == e1000_bus_type_pcix)
L
Linus Torvalds 已提交
1688
		adapter->pcix_82544 = 1;
1689

J
Joe Perches 已提交
1690
	ew32(TCTL, tctl);
1691

L
Linus Torvalds 已提交
1692 1693 1694 1695 1696
}

/**
 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 * @adapter: board private structure
1697
 * @rxdr:    rx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1698 1699 1700 1701
 *
 * Returns 0 on success, negative on failure
 **/

1702 1703
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
				    struct e1000_rx_ring *rxdr)
L
Linus Torvalds 已提交
1704 1705
{
	struct pci_dev *pdev = adapter->pdev;
1706
	int size, desc_len;
L
Linus Torvalds 已提交
1707 1708

	size = sizeof(struct e1000_buffer) * rxdr->count;
E
Eric Dumazet 已提交
1709
	rxdr->buffer_info = vzalloc(size);
1710
	if (!rxdr->buffer_info) {
1711 1712
		e_err(probe, "Unable to allocate memory for the Rx descriptor "
		      "ring\n");
L
Linus Torvalds 已提交
1713 1714 1715
		return -ENOMEM;
	}

1716
	desc_len = sizeof(struct e1000_rx_desc);
1717

L
Linus Torvalds 已提交
1718 1719
	/* Round up to nearest 4K */

1720
	rxdr->size = rxdr->count * desc_len;
1721
	rxdr->size = ALIGN(rxdr->size, 4096);
L
Linus Torvalds 已提交
1722

1723 1724
	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
					GFP_KERNEL);
L
Linus Torvalds 已提交
1725

1726
	if (!rxdr->desc) {
1727 1728
		e_err(probe, "Unable to allocate memory for the Rx descriptor "
		      "ring\n");
L
Linus Torvalds 已提交
1729 1730 1731 1732 1733
setup_rx_desc_die:
		vfree(rxdr->buffer_info);
		return -ENOMEM;
	}

1734
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1735 1736 1737
	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
		void *olddesc = rxdr->desc;
		dma_addr_t olddma = rxdr->dma;
1738
		e_err(rx_err, "rxdr align check failed: %u bytes at %p\n",
1739
		      rxdr->size, rxdr->desc);
1740
		/* Try again, without freeing the previous */
1741 1742
		rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size,
						&rxdr->dma, GFP_KERNEL);
1743
		/* Failed allocation, critical failure */
1744
		if (!rxdr->desc) {
1745 1746
			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
					  olddma);
1747 1748
			e_err(probe, "Unable to allocate memory for the Rx "
			      "descriptor ring\n");
L
Linus Torvalds 已提交
1749 1750 1751 1752 1753
			goto setup_rx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
			/* give up */
1754 1755 1756 1757
			dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
					  rxdr->dma);
			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
					  olddma);
1758 1759
			e_err(probe, "Unable to allocate aligned memory for "
			      "the Rx descriptor ring\n");
1760
			goto setup_rx_desc_die;
L
Linus Torvalds 已提交
1761
		} else {
1762
			/* Free old allocation, new allocation was successful */
1763 1764
			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
					  olddma);
L
Linus Torvalds 已提交
1765 1766 1767 1768 1769 1770
		}
	}
	memset(rxdr->desc, 0, rxdr->size);

	rxdr->next_to_clean = 0;
	rxdr->next_to_use = 0;
1771
	rxdr->rx_skb_top = NULL;
L
Linus Torvalds 已提交
1772 1773 1774 1775

	return 0;
}

1776 1777 1778 1779 1780 1781 1782 1783
/**
 * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * Return 0 on success, negative on failure
 **/

1784
int e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
1785 1786 1787
{
	int i, err = 0;

1788
	for (i = 0; i < adapter->num_rx_queues; i++) {
1789 1790
		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
		if (err) {
1791
			e_err(probe, "Allocation for Rx Queue %u failed\n", i);
1792 1793 1794
			for (i-- ; i >= 0; i--)
				e1000_free_rx_resources(adapter,
							&adapter->rx_ring[i]);
1795 1796 1797 1798 1799 1800 1801
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1802
/**
1803
 * e1000_setup_rctl - configure the receive control registers
L
Linus Torvalds 已提交
1804 1805
 * @adapter: Board private structure
 **/
1806
static void e1000_setup_rctl(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
1807
{
J
Joe Perches 已提交
1808
	struct e1000_hw *hw = &adapter->hw;
1809
	u32 rctl;
L
Linus Torvalds 已提交
1810

J
Joe Perches 已提交
1811
	rctl = er32(RCTL);
L
Linus Torvalds 已提交
1812 1813 1814 1815 1816

	rctl &= ~(3 << E1000_RCTL_MO_SHIFT);

	rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
		E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
J
Joe Perches 已提交
1817
		(hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
L
Linus Torvalds 已提交
1818

J
Joe Perches 已提交
1819
	if (hw->tbi_compatibility_on == 1)
L
Linus Torvalds 已提交
1820 1821 1822 1823
		rctl |= E1000_RCTL_SBP;
	else
		rctl &= ~E1000_RCTL_SBP;

1824 1825 1826 1827 1828
	if (adapter->netdev->mtu <= ETH_DATA_LEN)
		rctl &= ~E1000_RCTL_LPE;
	else
		rctl |= E1000_RCTL_LPE;

L
Linus Torvalds 已提交
1829
	/* Setup buffer sizes */
1830 1831 1832
	rctl &= ~E1000_RCTL_SZ_4096;
	rctl |= E1000_RCTL_BSEX;
	switch (adapter->rx_buffer_len) {
1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846
		case E1000_RXBUFFER_2048:
		default:
			rctl |= E1000_RCTL_SZ_2048;
			rctl &= ~E1000_RCTL_BSEX;
			break;
		case E1000_RXBUFFER_4096:
			rctl |= E1000_RCTL_SZ_4096;
			break;
		case E1000_RXBUFFER_8192:
			rctl |= E1000_RCTL_SZ_8192;
			break;
		case E1000_RXBUFFER_16384:
			rctl |= E1000_RCTL_SZ_16384;
			break;
1847 1848
	}

J
Joe Perches 已提交
1849
	ew32(RCTL, rctl);
L
Linus Torvalds 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858
}

/**
 * e1000_configure_rx - Configure 8254x Receive Unit after Reset
 * @adapter: board private structure
 *
 * Configure the Rx unit of the MAC after a reset.
 **/

1859
static void e1000_configure_rx(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
1860
{
1861
	u64 rdba;
1862
	struct e1000_hw *hw = &adapter->hw;
1863
	u32 rdlen, rctl, rxcsum;
1864

1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
	if (adapter->netdev->mtu > ETH_DATA_LEN) {
		rdlen = adapter->rx_ring[0].count *
		        sizeof(struct e1000_rx_desc);
		adapter->clean_rx = e1000_clean_jumbo_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
	} else {
		rdlen = adapter->rx_ring[0].count *
		        sizeof(struct e1000_rx_desc);
		adapter->clean_rx = e1000_clean_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
	}
L
Linus Torvalds 已提交
1876 1877

	/* disable receives while setting up the descriptors */
J
Joe Perches 已提交
1878 1879
	rctl = er32(RCTL);
	ew32(RCTL, rctl & ~E1000_RCTL_EN);
L
Linus Torvalds 已提交
1880 1881

	/* set the Receive Delay Timer Register */
J
Joe Perches 已提交
1882
	ew32(RDTR, adapter->rx_int_delay);
L
Linus Torvalds 已提交
1883

1884
	if (hw->mac_type >= e1000_82540) {
J
Joe Perches 已提交
1885
		ew32(RADV, adapter->rx_abs_int_delay);
J
Jesse Brandeburg 已提交
1886
		if (adapter->itr_setting != 0)
J
Joe Perches 已提交
1887
			ew32(ITR, 1000000000 / (adapter->itr * 256));
L
Linus Torvalds 已提交
1888 1889
	}

1890 1891
	/* Setup the HW Rx Head and Tail Descriptor Pointers and
	 * the Base and Length of the Rx Descriptor Ring */
1892
	switch (adapter->num_rx_queues) {
1893 1894
	case 1:
	default:
1895
		rdba = adapter->rx_ring[0].dma;
J
Joe Perches 已提交
1896 1897 1898 1899 1900
		ew32(RDLEN, rdlen);
		ew32(RDBAH, (rdba >> 32));
		ew32(RDBAL, (rdba & 0x00000000ffffffffULL));
		ew32(RDT, 0);
		ew32(RDH, 0);
1901 1902
		adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? E1000_RDH : E1000_82542_RDH);
		adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? E1000_RDT : E1000_82542_RDT);
1903
		break;
1904 1905
	}

L
Linus Torvalds 已提交
1906
	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
1907
	if (hw->mac_type >= e1000_82543) {
J
Joe Perches 已提交
1908
		rxcsum = er32(RXCSUM);
1909
		if (adapter->rx_csum)
1910
			rxcsum |= E1000_RXCSUM_TUOFL;
1911
		else
1912
			/* don't need to clear IPPCSE as it defaults to 0 */
1913
			rxcsum &= ~E1000_RXCSUM_TUOFL;
J
Joe Perches 已提交
1914
		ew32(RXCSUM, rxcsum);
L
Linus Torvalds 已提交
1915 1916 1917
	}

	/* Enable Receives */
J
Joe Perches 已提交
1918
	ew32(RCTL, rctl);
L
Linus Torvalds 已提交
1919 1920 1921
}

/**
1922
 * e1000_free_tx_resources - Free Tx Resources per Queue
L
Linus Torvalds 已提交
1923
 * @adapter: board private structure
1924
 * @tx_ring: Tx descriptor ring for a specific queue
L
Linus Torvalds 已提交
1925 1926 1927 1928
 *
 * Free all transmit software resources
 **/

1929 1930
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
				    struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1931 1932 1933
{
	struct pci_dev *pdev = adapter->pdev;

1934
	e1000_clean_tx_ring(adapter, tx_ring);
L
Linus Torvalds 已提交
1935

1936 1937
	vfree(tx_ring->buffer_info);
	tx_ring->buffer_info = NULL;
L
Linus Torvalds 已提交
1938

1939 1940
	dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
			  tx_ring->dma);
L
Linus Torvalds 已提交
1941

1942 1943 1944 1945 1946 1947 1948 1949 1950 1951
	tx_ring->desc = NULL;
}

/**
 * e1000_free_all_tx_resources - Free Tx Resources for All Queues
 * @adapter: board private structure
 *
 * Free all transmit software resources
 **/

1952
void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
1953 1954 1955
{
	int i;

1956
	for (i = 0; i < adapter->num_tx_queues; i++)
1957
		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
1958 1959
}

1960 1961
static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
					     struct e1000_buffer *buffer_info)
L
Linus Torvalds 已提交
1962
{
1963 1964
	if (buffer_info->dma) {
		if (buffer_info->mapped_as_page)
1965 1966
			dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
				       buffer_info->length, DMA_TO_DEVICE);
1967
		else
1968
			dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
1969
					 buffer_info->length,
1970
					 DMA_TO_DEVICE);
1971 1972
		buffer_info->dma = 0;
	}
1973
	if (buffer_info->skb) {
L
Linus Torvalds 已提交
1974
		dev_kfree_skb_any(buffer_info->skb);
1975 1976
		buffer_info->skb = NULL;
	}
1977
	buffer_info->time_stamp = 0;
1978
	/* buffer_info must be completely set up in the transmit path */
L
Linus Torvalds 已提交
1979 1980 1981 1982 1983
}

/**
 * e1000_clean_tx_ring - Free Tx Buffers
 * @adapter: board private structure
1984
 * @tx_ring: ring to be cleaned
L
Linus Torvalds 已提交
1985 1986
 **/

1987 1988
static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
				struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1989
{
J
Joe Perches 已提交
1990
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
1991 1992 1993 1994 1995 1996
	struct e1000_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	/* Free all the Tx ring sk_buffs */

J
Jesse Brandeburg 已提交
1997
	for (i = 0; i < tx_ring->count; i++) {
L
Linus Torvalds 已提交
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
		buffer_info = &tx_ring->buffer_info[i];
		e1000_unmap_and_free_tx_resource(adapter, buffer_info);
	}

	size = sizeof(struct e1000_buffer) * tx_ring->count;
	memset(tx_ring->buffer_info, 0, size);

	/* Zero out the descriptor ring */

	memset(tx_ring->desc, 0, tx_ring->size);

	tx_ring->next_to_use = 0;
	tx_ring->next_to_clean = 0;
J
Jeff Kirsher 已提交
2011
	tx_ring->last_tx_tso = 0;
L
Linus Torvalds 已提交
2012

J
Joe Perches 已提交
2013 2014
	writel(0, hw->hw_addr + tx_ring->tdh);
	writel(0, hw->hw_addr + tx_ring->tdt);
2015 2016 2017 2018 2019 2020 2021
}

/**
 * e1000_clean_all_tx_rings - Free Tx Buffers for all queues
 * @adapter: board private structure
 **/

2022
static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
2023 2024 2025
{
	int i;

2026
	for (i = 0; i < adapter->num_tx_queues; i++)
2027
		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
2028 2029 2030 2031 2032
}

/**
 * e1000_free_rx_resources - Free Rx Resources
 * @adapter: board private structure
2033
 * @rx_ring: ring to clean the resources from
L
Linus Torvalds 已提交
2034 2035 2036 2037
 *
 * Free all receive software resources
 **/

2038 2039
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
				    struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
2040 2041 2042
{
	struct pci_dev *pdev = adapter->pdev;

2043
	e1000_clean_rx_ring(adapter, rx_ring);
L
Linus Torvalds 已提交
2044 2045 2046 2047

	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;

2048 2049
	dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
			  rx_ring->dma);
L
Linus Torvalds 已提交
2050 2051 2052 2053 2054

	rx_ring->desc = NULL;
}

/**
2055
 * e1000_free_all_rx_resources - Free Rx Resources for All Queues
L
Linus Torvalds 已提交
2056
 * @adapter: board private structure
2057 2058 2059 2060
 *
 * Free all receive software resources
 **/

2061
void e1000_free_all_rx_resources(struct e1000_adapter *adapter)
2062 2063 2064
{
	int i;

2065
	for (i = 0; i < adapter->num_rx_queues; i++)
2066 2067 2068 2069 2070 2071 2072
		e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
}

/**
 * e1000_clean_rx_ring - Free Rx Buffers per Queue
 * @adapter: board private structure
 * @rx_ring: ring to free buffers from
L
Linus Torvalds 已提交
2073 2074
 **/

2075 2076
static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
				struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
2077
{
J
Joe Perches 已提交
2078
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2079 2080 2081
	struct e1000_buffer *buffer_info;
	struct pci_dev *pdev = adapter->pdev;
	unsigned long size;
2082
	unsigned int i;
L
Linus Torvalds 已提交
2083 2084

	/* Free all the Rx ring sk_buffs */
J
Jesse Brandeburg 已提交
2085
	for (i = 0; i < rx_ring->count; i++) {
L
Linus Torvalds 已提交
2086
		buffer_info = &rx_ring->buffer_info[i];
2087 2088
		if (buffer_info->dma &&
		    adapter->clean_rx == e1000_clean_rx_irq) {
2089
			dma_unmap_single(&pdev->dev, buffer_info->dma,
2090
			                 buffer_info->length,
2091
					 DMA_FROM_DEVICE);
2092 2093
		} else if (buffer_info->dma &&
		           adapter->clean_rx == e1000_clean_jumbo_rx_irq) {
2094 2095 2096
			dma_unmap_page(&pdev->dev, buffer_info->dma,
				       buffer_info->length,
				       DMA_FROM_DEVICE);
J
Jesse Brandeburg 已提交
2097
		}
L
Linus Torvalds 已提交
2098

J
Jesse Brandeburg 已提交
2099
		buffer_info->dma = 0;
2100 2101 2102 2103
		if (buffer_info->page) {
			put_page(buffer_info->page);
			buffer_info->page = NULL;
		}
J
Jesse Brandeburg 已提交
2104
		if (buffer_info->skb) {
L
Linus Torvalds 已提交
2105 2106
			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
2107
		}
L
Linus Torvalds 已提交
2108 2109
	}

2110 2111 2112 2113 2114 2115
	/* there also may be some cached data from a chained receive */
	if (rx_ring->rx_skb_top) {
		dev_kfree_skb(rx_ring->rx_skb_top);
		rx_ring->rx_skb_top = NULL;
	}

L
Linus Torvalds 已提交
2116 2117 2118 2119 2120 2121 2122 2123 2124
	size = sizeof(struct e1000_buffer) * rx_ring->count;
	memset(rx_ring->buffer_info, 0, size);

	/* Zero out the descriptor ring */
	memset(rx_ring->desc, 0, rx_ring->size);

	rx_ring->next_to_clean = 0;
	rx_ring->next_to_use = 0;

J
Joe Perches 已提交
2125 2126
	writel(0, hw->hw_addr + rx_ring->rdh);
	writel(0, hw->hw_addr + rx_ring->rdt);
2127 2128 2129 2130 2131 2132 2133
}

/**
 * e1000_clean_all_rx_rings - Free Rx Buffers for all queues
 * @adapter: board private structure
 **/

2134
static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
2135 2136 2137
{
	int i;

2138
	for (i = 0; i < adapter->num_rx_queues; i++)
2139
		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
L
Linus Torvalds 已提交
2140 2141 2142 2143 2144
}

/* The 82542 2.0 (revision 2) needs to have the receive unit in reset
 * and memory write and invalidate disabled for certain operations
 */
2145
static void e1000_enter_82542_rst(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
2146
{
J
Joe Perches 已提交
2147
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2148
	struct net_device *netdev = adapter->netdev;
2149
	u32 rctl;
L
Linus Torvalds 已提交
2150

J
Joe Perches 已提交
2151
	e1000_pci_clear_mwi(hw);
L
Linus Torvalds 已提交
2152

J
Joe Perches 已提交
2153
	rctl = er32(RCTL);
L
Linus Torvalds 已提交
2154
	rctl |= E1000_RCTL_RST;
J
Joe Perches 已提交
2155 2156
	ew32(RCTL, rctl);
	E1000_WRITE_FLUSH();
L
Linus Torvalds 已提交
2157 2158
	mdelay(5);

J
Jesse Brandeburg 已提交
2159
	if (netif_running(netdev))
2160
		e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
2161 2162
}

2163
static void e1000_leave_82542_rst(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
2164
{
J
Joe Perches 已提交
2165
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2166
	struct net_device *netdev = adapter->netdev;
2167
	u32 rctl;
L
Linus Torvalds 已提交
2168

J
Joe Perches 已提交
2169
	rctl = er32(RCTL);
L
Linus Torvalds 已提交
2170
	rctl &= ~E1000_RCTL_RST;
J
Joe Perches 已提交
2171 2172
	ew32(RCTL, rctl);
	E1000_WRITE_FLUSH();
L
Linus Torvalds 已提交
2173 2174
	mdelay(5);

J
Joe Perches 已提交
2175 2176
	if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
		e1000_pci_set_mwi(hw);
L
Linus Torvalds 已提交
2177

J
Jesse Brandeburg 已提交
2178
	if (netif_running(netdev)) {
2179 2180
		/* No need to loop, because 82542 supports only 1 queue */
		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2181
		e1000_configure_rx(adapter);
2182
		adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
L
Linus Torvalds 已提交
2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
	}
}

/**
 * e1000_set_mac - Change the Ethernet Address of the NIC
 * @netdev: network interface device structure
 * @p: pointer to an address structure
 *
 * Returns 0 on success, negative on failure
 **/

2194
static int e1000_set_mac(struct net_device *netdev, void *p)
L
Linus Torvalds 已提交
2195
{
2196
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
2197
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2198 2199
	struct sockaddr *addr = p;

J
Jesse Brandeburg 已提交
2200
	if (!is_valid_ether_addr(addr->sa_data))
L
Linus Torvalds 已提交
2201 2202 2203 2204
		return -EADDRNOTAVAIL;

	/* 82542 2.0 needs to be in reset to write receive address registers */

J
Joe Perches 已提交
2205
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2206 2207 2208
		e1000_enter_82542_rst(adapter);

	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
J
Joe Perches 已提交
2209
	memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
L
Linus Torvalds 已提交
2210

J
Joe Perches 已提交
2211
	e1000_rar_set(hw, hw->mac_addr, 0);
L
Linus Torvalds 已提交
2212

J
Joe Perches 已提交
2213
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2214 2215 2216 2217 2218 2219
		e1000_leave_82542_rst(adapter);

	return 0;
}

/**
2220
 * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
L
Linus Torvalds 已提交
2221 2222
 * @netdev: network interface device structure
 *
2223 2224 2225
 * The set_rx_mode entry point is called whenever the unicast or multicast
 * address lists or the network interface flags are updated. This routine is
 * responsible for configuring the hardware for proper unicast, multicast,
L
Linus Torvalds 已提交
2226 2227 2228
 * promiscuous mode, and all-multi behavior.
 **/

2229
static void e1000_set_rx_mode(struct net_device *netdev)
L
Linus Torvalds 已提交
2230
{
2231
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2232
	struct e1000_hw *hw = &adapter->hw;
J
Jiri Pirko 已提交
2233 2234
	struct netdev_hw_addr *ha;
	bool use_uc = false;
2235 2236
	u32 rctl;
	u32 hash_value;
2237
	int i, rar_entries = E1000_RAR_ENTRIES;
2238
	int mta_reg_count = E1000_NUM_MTA_REGISTERS;
2239 2240 2241
	u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);

	if (!mcarray) {
2242
		e_err(probe, "memory allocation failed\n");
2243 2244
		return;
	}
2245

2246 2247
	/* Check for Promiscuous and All Multicast modes */

J
Joe Perches 已提交
2248
	rctl = er32(RCTL);
L
Linus Torvalds 已提交
2249

J
Jesse Brandeburg 已提交
2250
	if (netdev->flags & IFF_PROMISC) {
L
Linus Torvalds 已提交
2251
		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
2252
		rctl &= ~E1000_RCTL_VFE;
L
Linus Torvalds 已提交
2253
	} else {
2254
		if (netdev->flags & IFF_ALLMULTI)
2255
			rctl |= E1000_RCTL_MPE;
2256
		else
2257
			rctl &= ~E1000_RCTL_MPE;
2258
		/* Enable VLAN filter if there is a VLAN */
J
Jiri Pirko 已提交
2259
		if (e1000_vlan_used(adapter))
2260
			rctl |= E1000_RCTL_VFE;
2261 2262
	}

2263
	if (netdev_uc_count(netdev) > rar_entries - 1) {
2264 2265 2266
		rctl |= E1000_RCTL_UPE;
	} else if (!(netdev->flags & IFF_PROMISC)) {
		rctl &= ~E1000_RCTL_UPE;
J
Jiri Pirko 已提交
2267
		use_uc = true;
L
Linus Torvalds 已提交
2268 2269
	}

J
Joe Perches 已提交
2270
	ew32(RCTL, rctl);
L
Linus Torvalds 已提交
2271 2272 2273

	/* 82542 2.0 needs to be in reset to write receive address registers */

J
Jesse Brandeburg 已提交
2274
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2275 2276
		e1000_enter_82542_rst(adapter);

2277 2278 2279 2280
	/* load the first 14 addresses into the exact filters 1-14. Unicast
	 * addresses take precedence to avoid disabling unicast filtering
	 * when possible.
	 *
2281
	 * RAR 0 is used for the station MAC address
L
Linus Torvalds 已提交
2282 2283
	 * if there are not 14 addresses, go ahead and clear the filters
	 */
J
Jiri Pirko 已提交
2284 2285
	i = 1;
	if (use_uc)
2286
		netdev_for_each_uc_addr(ha, netdev) {
J
Jiri Pirko 已提交
2287 2288 2289 2290 2291
			if (i == rar_entries)
				break;
			e1000_rar_set(hw, ha->addr, i++);
		}

2292
	netdev_for_each_mc_addr(ha, netdev) {
2293 2294 2295
		if (i == rar_entries) {
			/* load any remaining addresses into the hash table */
			u32 hash_reg, hash_bit, mta;
2296
			hash_value = e1000_hash_mc_addr(hw, ha->addr);
2297 2298 2299 2300
			hash_reg = (hash_value >> 5) & 0x7F;
			hash_bit = hash_value & 0x1F;
			mta = (1 << hash_bit);
			mcarray[hash_reg] |= mta;
2301
		} else {
2302
			e1000_rar_set(hw, ha->addr, i++);
L
Linus Torvalds 已提交
2303 2304 2305
		}
	}

2306 2307 2308 2309 2310
	for (; i < rar_entries; i++) {
		E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
		E1000_WRITE_FLUSH();
		E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
		E1000_WRITE_FLUSH();
L
Linus Torvalds 已提交
2311 2312
	}

2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
	/* write the hash table completely, write from bottom to avoid
	 * both stupid write combining chipsets, and flushing each write */
	for (i = mta_reg_count - 1; i >= 0 ; i--) {
		/*
		 * If we are on an 82544 has an errata where writing odd
		 * offsets overwrites the previous even offset, but writing
		 * backwards over the range solves the issue by always
		 * writing the odd offset first
		 */
		E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]);
	}
	E1000_WRITE_FLUSH();

J
Jesse Brandeburg 已提交
2326
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2327
		e1000_leave_82542_rst(adapter);
2328 2329

	kfree(mcarray);
L
Linus Torvalds 已提交
2330 2331 2332 2333 2334
}

/* Need to wait a few seconds after link up to get diagnostic information from
 * the phy */

2335
static void e1000_update_phy_info(unsigned long data)
L
Linus Torvalds 已提交
2336
{
2337
	struct e1000_adapter *adapter = (struct e1000_adapter *)data;
J
Jesse Brandeburg 已提交
2338 2339 2340 2341 2342 2343 2344 2345
	schedule_work(&adapter->phy_info_task);
}

static void e1000_update_phy_info_task(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work,
	                                             struct e1000_adapter,
	                                             phy_info_task);
J
Joe Perches 已提交
2346
	struct e1000_hw *hw = &adapter->hw;
2347 2348

	rtnl_lock();
J
Joe Perches 已提交
2349
	e1000_phy_get_info(hw, &adapter->phy_info);
2350
	rtnl_unlock();
L
Linus Torvalds 已提交
2351 2352 2353 2354 2355 2356
}

/**
 * e1000_82547_tx_fifo_stall - Timer Call-back
 * @data: pointer to adapter cast into an unsigned long
 **/
2357
static void e1000_82547_tx_fifo_stall(unsigned long data)
L
Linus Torvalds 已提交
2358
{
2359
	struct e1000_adapter *adapter = (struct e1000_adapter *)data;
J
Jesse Brandeburg 已提交
2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371
	schedule_work(&adapter->fifo_stall_task);
}

/**
 * e1000_82547_tx_fifo_stall_task - task to complete work
 * @work: work struct contained inside adapter struct
 **/
static void e1000_82547_tx_fifo_stall_task(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work,
	                                             struct e1000_adapter,
	                                             fifo_stall_task);
J
Joe Perches 已提交
2372
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2373
	struct net_device *netdev = adapter->netdev;
2374
	u32 tctl;
L
Linus Torvalds 已提交
2375

2376
	rtnl_lock();
J
Jesse Brandeburg 已提交
2377
	if (atomic_read(&adapter->tx_fifo_stall)) {
J
Joe Perches 已提交
2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
		if ((er32(TDT) == er32(TDH)) &&
		   (er32(TDFT) == er32(TDFH)) &&
		   (er32(TDFTS) == er32(TDFHS))) {
			tctl = er32(TCTL);
			ew32(TCTL, tctl & ~E1000_TCTL_EN);
			ew32(TDFT, adapter->tx_head_addr);
			ew32(TDFH, adapter->tx_head_addr);
			ew32(TDFTS, adapter->tx_head_addr);
			ew32(TDFHS, adapter->tx_head_addr);
			ew32(TCTL, tctl);
			E1000_WRITE_FLUSH();
L
Linus Torvalds 已提交
2389 2390 2391 2392

			adapter->tx_fifo_head = 0;
			atomic_set(&adapter->tx_fifo_stall, 0);
			netif_wake_queue(netdev);
2393
		} else if (!test_bit(__E1000_DOWN, &adapter->flags)) {
L
Linus Torvalds 已提交
2394 2395 2396
			mod_timer(&adapter->tx_fifo_stall_timer, jiffies + 1);
		}
	}
2397
	rtnl_unlock();
L
Linus Torvalds 已提交
2398 2399
}

2400
bool e1000_has_link(struct e1000_adapter *adapter)
2401 2402 2403 2404
{
	struct e1000_hw *hw = &adapter->hw;
	bool link_active = false;

2405 2406 2407 2408 2409
	/* get_link_status is set on LSC (link status) interrupt or rx
	 * sequence error interrupt (except on intel ce4100).
	 * get_link_status will stay false until the
	 * e1000_check_for_link establishes link for copper adapters
	 * ONLY
2410 2411 2412
	 */
	switch (hw->media_type) {
	case e1000_media_type_copper:
2413 2414
		if (hw->mac_type == e1000_ce4100)
			hw->get_link_status = 1;
2415
		if (hw->get_link_status) {
2416
			e1000_check_for_link(hw);
2417 2418 2419 2420 2421 2422
			link_active = !hw->get_link_status;
		} else {
			link_active = true;
		}
		break;
	case e1000_media_type_fiber:
2423
		e1000_check_for_link(hw);
2424 2425 2426
		link_active = !!(er32(STATUS) & E1000_STATUS_LU);
		break;
	case e1000_media_type_internal_serdes:
2427
		e1000_check_for_link(hw);
2428 2429 2430 2431 2432 2433 2434 2435 2436
		link_active = hw->serdes_has_link;
		break;
	default:
		break;
	}

	return link_active;
}

L
Linus Torvalds 已提交
2437 2438 2439 2440
/**
 * e1000_watchdog - Timer Call-back
 * @data: pointer to adapter cast into an unsigned long
 **/
2441
static void e1000_watchdog(unsigned long data)
L
Linus Torvalds 已提交
2442
{
2443
	struct e1000_adapter *adapter = (struct e1000_adapter *)data;
J
Joe Perches 已提交
2444
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2445
	struct net_device *netdev = adapter->netdev;
J
Jeff Kirsher 已提交
2446
	struct e1000_tx_ring *txdr = adapter->tx_ring;
2447
	u32 link, tctl;
2448

2449 2450 2451
	link = e1000_has_link(adapter);
	if ((netif_carrier_ok(netdev)) && link)
		goto link_up;
L
Linus Torvalds 已提交
2452

J
Jesse Brandeburg 已提交
2453 2454
	if (link) {
		if (!netif_carrier_ok(netdev)) {
2455
			u32 ctrl;
J
Joe Perches 已提交
2456
			bool txb2b = true;
2457
			/* update snapshot of PHY registers on LSC */
J
Joe Perches 已提交
2458
			e1000_get_speed_and_duplex(hw,
L
Linus Torvalds 已提交
2459 2460 2461
			                           &adapter->link_speed,
			                           &adapter->link_duplex);

J
Joe Perches 已提交
2462
			ctrl = er32(CTRL);
2463 2464 2465 2466 2467 2468 2469 2470 2471 2472
			pr_info("%s NIC Link is Up %d Mbps %s, "
				"Flow Control: %s\n",
				netdev->name,
				adapter->link_speed,
				adapter->link_duplex == FULL_DUPLEX ?
				"Full Duplex" : "Half Duplex",
				((ctrl & E1000_CTRL_TFCE) && (ctrl &
				E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
				E1000_CTRL_RFCE) ? "RX" : ((ctrl &
				E1000_CTRL_TFCE) ? "TX" : "None")));
L
Linus Torvalds 已提交
2473

2474
			/* adjust timeout factor according to speed/duplex */
2475
			adapter->tx_timeout_factor = 1;
2476 2477
			switch (adapter->link_speed) {
			case SPEED_10:
J
Joe Perches 已提交
2478
				txb2b = false;
2479
				adapter->tx_timeout_factor = 16;
2480 2481
				break;
			case SPEED_100:
J
Joe Perches 已提交
2482
				txb2b = false;
2483 2484 2485 2486
				/* maybe add some timeout factor ? */
				break;
			}

2487
			/* enable transmits in the hardware */
J
Joe Perches 已提交
2488
			tctl = er32(TCTL);
2489
			tctl |= E1000_TCTL_EN;
J
Joe Perches 已提交
2490
			ew32(TCTL, tctl);
2491

L
Linus Torvalds 已提交
2492
			netif_carrier_on(netdev);
2493 2494 2495
			if (!test_bit(__E1000_DOWN, &adapter->flags))
				mod_timer(&adapter->phy_info_timer,
				          round_jiffies(jiffies + 2 * HZ));
L
Linus Torvalds 已提交
2496 2497 2498
			adapter->smartspeed = 0;
		}
	} else {
J
Jesse Brandeburg 已提交
2499
		if (netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
2500 2501
			adapter->link_speed = 0;
			adapter->link_duplex = 0;
2502 2503
			pr_info("%s NIC Link is Down\n",
				netdev->name);
L
Linus Torvalds 已提交
2504
			netif_carrier_off(netdev);
2505 2506 2507 2508

			if (!test_bit(__E1000_DOWN, &adapter->flags))
				mod_timer(&adapter->phy_info_timer,
				          round_jiffies(jiffies + 2 * HZ));
L
Linus Torvalds 已提交
2509 2510 2511 2512 2513
		}

		e1000_smartspeed(adapter);
	}

2514
link_up:
L
Linus Torvalds 已提交
2515 2516
	e1000_update_stats(adapter);

J
Joe Perches 已提交
2517
	hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
L
Linus Torvalds 已提交
2518
	adapter->tpt_old = adapter->stats.tpt;
J
Joe Perches 已提交
2519
	hw->collision_delta = adapter->stats.colc - adapter->colc_old;
L
Linus Torvalds 已提交
2520 2521 2522 2523 2524 2525 2526
	adapter->colc_old = adapter->stats.colc;

	adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
	adapter->gorcl_old = adapter->stats.gorcl;
	adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
	adapter->gotcl_old = adapter->stats.gotcl;

J
Joe Perches 已提交
2527
	e1000_update_adaptive(hw);
L
Linus Torvalds 已提交
2528

2529
	if (!netif_carrier_ok(netdev)) {
2530
		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
L
Linus Torvalds 已提交
2531 2532 2533 2534
			/* We've lost link, so the controller stops DMA,
			 * but we've got queued Tx work that's never going
			 * to get done, so reset controller to flush Tx.
			 * (Do the reset outside of interrupt context). */
2535 2536
			adapter->tx_timeout_count++;
			schedule_work(&adapter->reset_task);
2537 2538
			/* return immediately since reset is imminent */
			return;
L
Linus Torvalds 已提交
2539 2540 2541
		}
	}

2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557
	/* Simple mode for Interrupt Throttle Rate (ITR) */
	if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
		/*
		 * Symmetric Tx/Rx gets a reduced ITR=2000;
		 * Total asymmetrical Tx or Rx gets ITR=8000;
		 * everyone else is between 2000-8000.
		 */
		u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
		u32 dif = (adapter->gotcl > adapter->gorcl ?
			    adapter->gotcl - adapter->gorcl :
			    adapter->gorcl - adapter->gotcl) / 10000;
		u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;

		ew32(ITR, 1000000000 / (itr * 256));
	}

L
Linus Torvalds 已提交
2558
	/* Cause software interrupt to ensure rx ring is cleaned */
J
Joe Perches 已提交
2559
	ew32(ICS, E1000_ICS_RXDMT0);
L
Linus Torvalds 已提交
2560

2561
	/* Force detection of hung controller every watchdog period */
J
Joe Perches 已提交
2562
	adapter->detect_tx_hung = true;
L
Linus Torvalds 已提交
2563 2564

	/* Reset the timer */
2565 2566 2567
	if (!test_bit(__E1000_DOWN, &adapter->flags))
		mod_timer(&adapter->watchdog_timer,
		          round_jiffies(jiffies + 2 * HZ));
L
Linus Torvalds 已提交
2568 2569
}

J
Jesse Brandeburg 已提交
2570 2571 2572 2573 2574 2575 2576 2577 2578
enum latency_range {
	lowest_latency = 0,
	low_latency = 1,
	bulk_latency = 2,
	latency_invalid = 255
};

/**
 * e1000_update_itr - update the dynamic ITR value based on statistics
2579 2580 2581 2582 2583
 * @adapter: pointer to adapter
 * @itr_setting: current adapter->itr
 * @packets: the number of packets during this measurement interval
 * @bytes: the number of bytes during this measurement interval
 *
J
Jesse Brandeburg 已提交
2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594
 *      Stores a new ITR value based on packets and byte
 *      counts during the last interrupt.  The advantage of per interrupt
 *      computation is faster updates and more accurate ITR for the current
 *      traffic pattern.  Constants in this function were computed
 *      based on theoretical maximum wire speed and thresholds were set based
 *      on testing data as well as attempting to minimize response time
 *      while increasing bulk throughput.
 *      this functionality is controlled by the InterruptThrottleRate module
 *      parameter (see e1000_param.c)
 **/
static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
2595
				     u16 itr_setting, int packets, int bytes)
J
Jesse Brandeburg 已提交
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607
{
	unsigned int retval = itr_setting;
	struct e1000_hw *hw = &adapter->hw;

	if (unlikely(hw->mac_type < e1000_82540))
		goto update_itr_done;

	if (packets == 0)
		goto update_itr_done;

	switch (itr_setting) {
	case lowest_latency:
2608 2609 2610 2611
		/* jumbo frames get bulk treatment*/
		if (bytes/packets > 8000)
			retval = bulk_latency;
		else if ((packets < 5) && (bytes > 512))
J
Jesse Brandeburg 已提交
2612 2613 2614 2615
			retval = low_latency;
		break;
	case low_latency:  /* 50 usec aka 20000 ints/s */
		if (bytes > 10000) {
2616 2617 2618 2619
			/* jumbo frames need bulk latency setting */
			if (bytes/packets > 8000)
				retval = bulk_latency;
			else if ((packets < 10) || ((bytes/packets) > 1200))
J
Jesse Brandeburg 已提交
2620 2621 2622
				retval = bulk_latency;
			else if ((packets > 35))
				retval = lowest_latency;
2623 2624 2625
		} else if (bytes/packets > 2000)
			retval = bulk_latency;
		else if (packets <= 2 && bytes < 512)
J
Jesse Brandeburg 已提交
2626 2627 2628 2629 2630 2631
			retval = lowest_latency;
		break;
	case bulk_latency: /* 250 usec aka 4000 ints/s */
		if (bytes > 25000) {
			if (packets > 35)
				retval = low_latency;
2632 2633
		} else if (bytes < 6000) {
			retval = low_latency;
J
Jesse Brandeburg 已提交
2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644
		}
		break;
	}

update_itr_done:
	return retval;
}

static void e1000_set_itr(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
2645 2646
	u16 current_itr;
	u32 new_itr = adapter->itr;
J
Jesse Brandeburg 已提交
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661

	if (unlikely(hw->mac_type < e1000_82540))
		return;

	/* for non-gigabit speeds, just fix the interrupt rate at 4000 */
	if (unlikely(adapter->link_speed != SPEED_1000)) {
		current_itr = 0;
		new_itr = 4000;
		goto set_itr_now;
	}

	adapter->tx_itr = e1000_update_itr(adapter,
	                            adapter->tx_itr,
	                            adapter->total_tx_packets,
	                            adapter->total_tx_bytes);
2662 2663 2664 2665
	/* conservative mode (itr 3) eliminates the lowest_latency setting */
	if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
		adapter->tx_itr = low_latency;

J
Jesse Brandeburg 已提交
2666 2667 2668 2669
	adapter->rx_itr = e1000_update_itr(adapter,
	                            adapter->rx_itr,
	                            adapter->total_rx_packets,
	                            adapter->total_rx_bytes);
2670 2671 2672
	/* conservative mode (itr 3) eliminates the lowest_latency setting */
	if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
		adapter->rx_itr = low_latency;
J
Jesse Brandeburg 已提交
2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699

	current_itr = max(adapter->rx_itr, adapter->tx_itr);

	switch (current_itr) {
	/* counts and packets in update_itr are dependent on these numbers */
	case lowest_latency:
		new_itr = 70000;
		break;
	case low_latency:
		new_itr = 20000; /* aka hwitr = ~200 */
		break;
	case bulk_latency:
		new_itr = 4000;
		break;
	default:
		break;
	}

set_itr_now:
	if (new_itr != adapter->itr) {
		/* this attempts to bias the interrupt rate towards Bulk
		 * by adding intermediate steps when interrupt rate is
		 * increasing */
		new_itr = new_itr > adapter->itr ?
		             min(adapter->itr + (new_itr >> 2), new_itr) :
		             new_itr;
		adapter->itr = new_itr;
J
Joe Perches 已提交
2700
		ew32(ITR, 1000000000 / (new_itr * 256));
J
Jesse Brandeburg 已提交
2701 2702 2703
	}
}

L
Linus Torvalds 已提交
2704 2705 2706
#define E1000_TX_FLAGS_CSUM		0x00000001
#define E1000_TX_FLAGS_VLAN		0x00000002
#define E1000_TX_FLAGS_TSO		0x00000004
2707
#define E1000_TX_FLAGS_IPV4		0x00000008
L
Linus Torvalds 已提交
2708 2709 2710
#define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT	16

2711 2712
static int e1000_tso(struct e1000_adapter *adapter,
		     struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
L
Linus Torvalds 已提交
2713 2714
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2715
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2716
	unsigned int i;
2717 2718 2719
	u32 cmd_length = 0;
	u16 ipcse = 0, tucse, mss;
	u8 ipcss, ipcso, tucss, tucso, hdr_len;
L
Linus Torvalds 已提交
2720 2721
	int err;

H
Herbert Xu 已提交
2722
	if (skb_is_gso(skb)) {
L
Linus Torvalds 已提交
2723 2724 2725 2726 2727 2728
		if (skb_header_cloned(skb)) {
			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
			if (err)
				return err;
		}

2729
		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
2730
		mss = skb_shinfo(skb)->gso_size;
A
Alexey Dobriyan 已提交
2731
		if (skb->protocol == htons(ETH_P_IP)) {
2732 2733 2734
			struct iphdr *iph = ip_hdr(skb);
			iph->tot_len = 0;
			iph->check = 0;
2735 2736 2737 2738
			tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
								 iph->daddr, 0,
								 IPPROTO_TCP,
								 0);
2739
			cmd_length = E1000_TXD_CMD_IP;
2740
			ipcse = skb_transport_offset(skb) - 1;
2741
		} else if (skb->protocol == htons(ETH_P_IPV6)) {
2742
			ipv6_hdr(skb)->payload_len = 0;
2743
			tcp_hdr(skb)->check =
2744 2745 2746
				~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
						 &ipv6_hdr(skb)->daddr,
						 0, IPPROTO_TCP, 0);
2747 2748
			ipcse = 0;
		}
2749
		ipcss = skb_network_offset(skb);
2750
		ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
2751
		tucss = skb_transport_offset(skb);
2752
		tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
L
Linus Torvalds 已提交
2753 2754 2755
		tucse = 0;

		cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
2756
			       E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
L
Linus Torvalds 已提交
2757

2758 2759
		i = tx_ring->next_to_use;
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
J
Jeff Kirsher 已提交
2760
		buffer_info = &tx_ring->buffer_info[i];
L
Linus Torvalds 已提交
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771

		context_desc->lower_setup.ip_fields.ipcss  = ipcss;
		context_desc->lower_setup.ip_fields.ipcso  = ipcso;
		context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
		context_desc->upper_setup.tcp_fields.tucss = tucss;
		context_desc->upper_setup.tcp_fields.tucso = tucso;
		context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
		context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
		context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
		context_desc->cmd_and_length = cpu_to_le32(cmd_length);

J
Jeff Kirsher 已提交
2772
		buffer_info->time_stamp = jiffies;
2773
		buffer_info->next_to_watch = i;
J
Jeff Kirsher 已提交
2774

2775 2776
		if (++i == tx_ring->count) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2777

J
Joe Perches 已提交
2778
		return true;
L
Linus Torvalds 已提交
2779
	}
J
Joe Perches 已提交
2780
	return false;
L
Linus Torvalds 已提交
2781 2782
}

2783 2784
static bool e1000_tx_csum(struct e1000_adapter *adapter,
			  struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
L
Linus Torvalds 已提交
2785 2786
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2787
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2788
	unsigned int i;
2789
	u8 css;
2790
	u32 cmd_len = E1000_TXD_CMD_DEXT;
L
Linus Torvalds 已提交
2791

2792 2793
	if (skb->ip_summed != CHECKSUM_PARTIAL)
		return false;
L
Linus Torvalds 已提交
2794

2795
	switch (skb->protocol) {
2796
	case cpu_to_be16(ETH_P_IP):
2797 2798 2799
		if (ip_hdr(skb)->protocol == IPPROTO_TCP)
			cmd_len |= E1000_TXD_CMD_TCP;
		break;
2800
	case cpu_to_be16(ETH_P_IPV6):
2801 2802 2803 2804 2805 2806
		/* XXX not handling all IPV6 headers */
		if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
			cmd_len |= E1000_TXD_CMD_TCP;
		break;
	default:
		if (unlikely(net_ratelimit()))
2807 2808
			e_warn(drv, "checksum_partial proto=%x!\n",
			       skb->protocol);
2809 2810
		break;
	}
L
Linus Torvalds 已提交
2811

2812
	css = skb_checksum_start_offset(skb);
L
Linus Torvalds 已提交
2813

2814 2815 2816
	i = tx_ring->next_to_use;
	buffer_info = &tx_ring->buffer_info[i];
	context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
J
Jeff Kirsher 已提交
2817

2818 2819 2820 2821 2822 2823 2824
	context_desc->lower_setup.ip_config = 0;
	context_desc->upper_setup.tcp_fields.tucss = css;
	context_desc->upper_setup.tcp_fields.tucso =
		css + skb->csum_offset;
	context_desc->upper_setup.tcp_fields.tucse = 0;
	context_desc->tcp_seg_setup.data = 0;
	context_desc->cmd_and_length = cpu_to_le32(cmd_len);
L
Linus Torvalds 已提交
2825

2826 2827
	buffer_info->time_stamp = jiffies;
	buffer_info->next_to_watch = i;
L
Linus Torvalds 已提交
2828

2829 2830 2831 2832
	if (unlikely(++i == tx_ring->count)) i = 0;
	tx_ring->next_to_use = i;

	return true;
L
Linus Torvalds 已提交
2833 2834 2835 2836 2837
}

#define E1000_MAX_TXD_PWR	12
#define E1000_MAX_DATA_PER_TXD	(1<<E1000_MAX_TXD_PWR)

2838 2839 2840 2841 2842
static int e1000_tx_map(struct e1000_adapter *adapter,
			struct e1000_tx_ring *tx_ring,
			struct sk_buff *skb, unsigned int first,
			unsigned int max_per_txd, unsigned int nr_frags,
			unsigned int mss)
L
Linus Torvalds 已提交
2843
{
J
Joe Perches 已提交
2844
	struct e1000_hw *hw = &adapter->hw;
2845
	struct pci_dev *pdev = adapter->pdev;
2846
	struct e1000_buffer *buffer_info;
J
Jesse Brandeburg 已提交
2847
	unsigned int len = skb_headlen(skb);
2848
	unsigned int offset = 0, size, count = 0, i;
L
Linus Torvalds 已提交
2849 2850 2851 2852
	unsigned int f;

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
2853
	while (len) {
2854
		buffer_info = &tx_ring->buffer_info[i];
L
Linus Torvalds 已提交
2855
		size = min(len, max_per_txd);
J
Jeff Kirsher 已提交
2856 2857 2858
		/* Workaround for Controller erratum --
		 * descriptor for non-tso packet in a linear SKB that follows a
		 * tso gets written back prematurely before the data is fully
2859
		 * DMA'd to the controller */
J
Jeff Kirsher 已提交
2860
		if (!skb->data_len && tx_ring->last_tx_tso &&
H
Herbert Xu 已提交
2861
		    !skb_is_gso(skb)) {
J
Jeff Kirsher 已提交
2862 2863 2864 2865
			tx_ring->last_tx_tso = 0;
			size -= 4;
		}

L
Linus Torvalds 已提交
2866 2867
		/* Workaround for premature desc write-backs
		 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2868
		if (unlikely(mss && !nr_frags && size == len && size > 8))
L
Linus Torvalds 已提交
2869
			size -= 4;
2870 2871 2872 2873 2874
		/* work-around for errata 10 and it applies
		 * to all controllers in PCI-X mode
		 * The fix is to make sure that the first descriptor of a
		 * packet is smaller than 2048 - 16 - 16 (or 2016) bytes
		 */
J
Joe Perches 已提交
2875
		if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
2876 2877
		                (size > 2015) && count == 0))
		        size = 2015;
J
Jesse Brandeburg 已提交
2878

L
Linus Torvalds 已提交
2879 2880
		/* Workaround for potential 82544 hang in PCI-X.  Avoid
		 * terminating buffers within evenly-aligned dwords. */
J
Jesse Brandeburg 已提交
2881
		if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2882 2883 2884 2885 2886
		   !((unsigned long)(skb->data + offset + size - 1) & 4) &&
		   size > 4))
			size -= 4;

		buffer_info->length = size;
2887
		/* set time_stamp *before* dma to help avoid a possible race */
L
Linus Torvalds 已提交
2888
		buffer_info->time_stamp = jiffies;
2889
		buffer_info->mapped_as_page = false;
2890 2891 2892 2893
		buffer_info->dma = dma_map_single(&pdev->dev,
						  skb->data + offset,
						  size,	DMA_TO_DEVICE);
		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2894
			goto dma_error;
2895
		buffer_info->next_to_watch = i;
L
Linus Torvalds 已提交
2896 2897 2898 2899

		len -= size;
		offset += size;
		count++;
2900 2901 2902 2903 2904
		if (len) {
			i++;
			if (unlikely(i == tx_ring->count))
				i = 0;
		}
L
Linus Torvalds 已提交
2905 2906
	}

J
Jesse Brandeburg 已提交
2907
	for (f = 0; f < nr_frags; f++) {
L
Linus Torvalds 已提交
2908 2909 2910 2911
		struct skb_frag_struct *frag;

		frag = &skb_shinfo(skb)->frags[f];
		len = frag->size;
2912
		offset = frag->page_offset;
L
Linus Torvalds 已提交
2913

J
Jesse Brandeburg 已提交
2914
		while (len) {
2915 2916 2917 2918
			i++;
			if (unlikely(i == tx_ring->count))
				i = 0;

L
Linus Torvalds 已提交
2919 2920 2921 2922
			buffer_info = &tx_ring->buffer_info[i];
			size = min(len, max_per_txd);
			/* Workaround for premature desc write-backs
			 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2923
			if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
L
Linus Torvalds 已提交
2924 2925 2926 2927
				size -= 4;
			/* Workaround for potential 82544 hang in PCI-X.
			 * Avoid terminating buffers within evenly-aligned
			 * dwords. */
J
Jesse Brandeburg 已提交
2928
			if (unlikely(adapter->pcix_82544 &&
2929 2930 2931
			    !((unsigned long)(page_to_phys(frag->page) + offset
			                      + size - 1) & 4) &&
			    size > 4))
L
Linus Torvalds 已提交
2932 2933 2934 2935
				size -= 4;

			buffer_info->length = size;
			buffer_info->time_stamp = jiffies;
2936
			buffer_info->mapped_as_page = true;
2937
			buffer_info->dma = dma_map_page(&pdev->dev, frag->page,
2938
							offset,	size,
2939 2940
							DMA_TO_DEVICE);
			if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2941
				goto dma_error;
2942
			buffer_info->next_to_watch = i;
L
Linus Torvalds 已提交
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953

			len -= size;
			offset += size;
			count++;
		}
	}

	tx_ring->buffer_info[i].skb = skb;
	tx_ring->buffer_info[first].next_to_watch = i;

	return count;
2954 2955 2956 2957

dma_error:
	dev_err(&pdev->dev, "TX DMA map failed\n");
	buffer_info->dma = 0;
2958
	if (count)
2959
		count--;
2960 2961 2962

	while (count--) {
		if (i==0)
2963
			i += tx_ring->count;
2964
		i--;
2965 2966 2967 2968 2969
		buffer_info = &tx_ring->buffer_info[i];
		e1000_unmap_and_free_tx_resource(adapter, buffer_info);
	}

	return 0;
L
Linus Torvalds 已提交
2970 2971
}

2972 2973 2974
static void e1000_tx_queue(struct e1000_adapter *adapter,
			   struct e1000_tx_ring *tx_ring, int tx_flags,
			   int count)
L
Linus Torvalds 已提交
2975
{
J
Joe Perches 已提交
2976
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
2977 2978
	struct e1000_tx_desc *tx_desc = NULL;
	struct e1000_buffer *buffer_info;
2979
	u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
L
Linus Torvalds 已提交
2980 2981
	unsigned int i;

J
Jesse Brandeburg 已提交
2982
	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
L
Linus Torvalds 已提交
2983 2984
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
		             E1000_TXD_CMD_TSE;
2985 2986
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;

J
Jesse Brandeburg 已提交
2987
		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2988
			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
L
Linus Torvalds 已提交
2989 2990
	}

J
Jesse Brandeburg 已提交
2991
	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
L
Linus Torvalds 已提交
2992 2993 2994 2995
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
	}

J
Jesse Brandeburg 已提交
2996
	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
L
Linus Torvalds 已提交
2997 2998 2999 3000 3001 3002
		txd_lower |= E1000_TXD_CMD_VLE;
		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
	}

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
3003
	while (count--) {
L
Linus Torvalds 已提交
3004 3005 3006 3007 3008 3009
		buffer_info = &tx_ring->buffer_info[i];
		tx_desc = E1000_TX_DESC(*tx_ring, i);
		tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
		tx_desc->lower.data =
			cpu_to_le32(txd_lower | buffer_info->length);
		tx_desc->upper.data = cpu_to_le32(txd_upper);
J
Jesse Brandeburg 已提交
3010
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021
	}

	tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);

	/* Force memory writes to complete before letting h/w
	 * know there are new descriptors to fetch.  (Only
	 * applicable for weak-ordered memory model archs,
	 * such as IA-64). */
	wmb();

	tx_ring->next_to_use = i;
J
Joe Perches 已提交
3022
	writel(i, hw->hw_addr + tx_ring->tdt);
3023 3024 3025
	/* we need this if more than one processor can write to our tail
	 * at a time, it syncronizes IO on IA64/Altix systems */
	mmiowb();
L
Linus Torvalds 已提交
3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
}

/**
 * 82547 workaround to avoid controller hang in half-duplex environment.
 * The workaround is to avoid queuing a large packet that would span
 * the internal Tx FIFO ring boundary by notifying the stack to resend
 * the packet at a later time.  This gives the Tx FIFO an opportunity to
 * flush all packets.  When that occurs, we reset the Tx FIFO pointers
 * to the beginning of the Tx FIFO.
 **/

#define E1000_FIFO_HDR			0x10
#define E1000_82547_PAD_LEN		0x3E0

3040 3041
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
				       struct sk_buff *skb)
L
Linus Torvalds 已提交
3042
{
3043 3044
	u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
	u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
L
Linus Torvalds 已提交
3045

3046
	skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
L
Linus Torvalds 已提交
3047

J
Jesse Brandeburg 已提交
3048
	if (adapter->link_duplex != HALF_DUPLEX)
L
Linus Torvalds 已提交
3049 3050
		goto no_fifo_stall_required;

J
Jesse Brandeburg 已提交
3051
	if (atomic_read(&adapter->tx_fifo_stall))
L
Linus Torvalds 已提交
3052 3053
		return 1;

J
Jesse Brandeburg 已提交
3054
	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
L
Linus Torvalds 已提交
3055 3056 3057 3058 3059 3060
		atomic_set(&adapter->tx_fifo_stall, 1);
		return 1;
	}

no_fifo_stall_required:
	adapter->tx_fifo_head += skb_fifo_len;
J
Jesse Brandeburg 已提交
3061
	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
L
Linus Torvalds 已提交
3062 3063 3064 3065
		adapter->tx_fifo_head -= adapter->tx_fifo_size;
	return 0;
}

3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_tx_ring *tx_ring = adapter->tx_ring;

	netif_stop_queue(netdev);
	/* Herbert's original patch had:
	 *  smp_mb__after_netif_stop_queue();
	 * but since that doesn't exist yet, just open code it. */
	smp_mb();

	/* We need to check again in a case another CPU has just
	 * made room available. */
	if (likely(E1000_DESC_UNUSED(tx_ring) < size))
		return -EBUSY;

	/* A reprieve! */
	netif_start_queue(netdev);
3084
	++adapter->restart_queue;
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
	return 0;
}

static int e1000_maybe_stop_tx(struct net_device *netdev,
                               struct e1000_tx_ring *tx_ring, int size)
{
	if (likely(E1000_DESC_UNUSED(tx_ring) >= size))
		return 0;
	return __e1000_maybe_stop_tx(netdev, size);
}

L
Linus Torvalds 已提交
3096
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
3097 3098
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
				    struct net_device *netdev)
L
Linus Torvalds 已提交
3099
{
3100
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
3101
	struct e1000_hw *hw = &adapter->hw;
3102
	struct e1000_tx_ring *tx_ring;
L
Linus Torvalds 已提交
3103 3104 3105
	unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
	unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
	unsigned int tx_flags = 0;
E
Eric Dumazet 已提交
3106
	unsigned int len = skb_headlen(skb);
3107 3108
	unsigned int nr_frags;
	unsigned int mss;
L
Linus Torvalds 已提交
3109
	int count = 0;
3110
	int tso;
L
Linus Torvalds 已提交
3111 3112
	unsigned int f;

3113 3114 3115 3116
	/* This goes back to the question of how to logically map a tx queue
	 * to a flow.  Right now, performance is impacted slightly negatively
	 * if using multiple tx queues.  If the stack breaks away from a
	 * single qdisc implementation, we can look at this again. */
3117
	tx_ring = adapter->tx_ring;
3118

3119
	if (unlikely(skb->len <= 0)) {
L
Linus Torvalds 已提交
3120 3121 3122 3123
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

3124
	mss = skb_shinfo(skb)->gso_size;
3125
	/* The controller does a simple calculation to
L
Linus Torvalds 已提交
3126 3127 3128 3129 3130
	 * make sure there is enough room in the FIFO before
	 * initiating the DMA for each buffer.  The calc is:
	 * 4 = ceil(buffer len/mss).  To make sure we don't
	 * overrun the FIFO, adjust the max buffer len if mss
	 * drops. */
J
Jesse Brandeburg 已提交
3131
	if (mss) {
3132
		u8 hdr_len;
L
Linus Torvalds 已提交
3133 3134
		max_per_txd = min(mss << 2, max_per_txd);
		max_txd_pwr = fls(max_per_txd) - 1;
J
Jeff Kirsher 已提交
3135

3136
		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
3137
		if (skb->data_len && hdr_len == len) {
J
Joe Perches 已提交
3138
			switch (hw->mac_type) {
3139
				unsigned int pull_size;
3140 3141 3142 3143 3144 3145 3146
			case e1000_82544:
				/* Make sure we have room to chop off 4 bytes,
				 * and that the end alignment will work out to
				 * this hardware's requirements
				 * NOTE: this is a TSO only workaround
				 * if end byte alignment not correct move us
				 * into the next dword */
3147
				if ((unsigned long)(skb_tail_pointer(skb) - 1) & 4)
3148 3149
					break;
				/* fall through */
3150 3151
				pull_size = min((unsigned int)4, skb->data_len);
				if (!__pskb_pull_tail(skb, pull_size)) {
3152 3153
					e_err(drv, "__pskb_pull_tail "
					      "failed.\n");
3154
					dev_kfree_skb_any(skb);
J
Jeff Garzik 已提交
3155
					return NETDEV_TX_OK;
3156
				}
E
Eric Dumazet 已提交
3157
				len = skb_headlen(skb);
3158 3159 3160 3161
				break;
			default:
				/* do nothing */
				break;
3162
			}
J
Jeff Kirsher 已提交
3163
		}
L
Linus Torvalds 已提交
3164 3165
	}

J
Jeff Kirsher 已提交
3166
	/* reserve a descriptor for the offload context */
3167
	if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
L
Linus Torvalds 已提交
3168
		count++;
3169
	count++;
J
Jeff Kirsher 已提交
3170 3171

	/* Controller Erratum workaround */
H
Herbert Xu 已提交
3172
	if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb))
J
Jeff Kirsher 已提交
3173 3174
		count++;

L
Linus Torvalds 已提交
3175 3176
	count += TXD_USE_COUNT(len, max_txd_pwr);

J
Jesse Brandeburg 已提交
3177
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
3178 3179
		count++;

J
Jesse Brandeburg 已提交
3180
	/* work-around for errata 10 and it applies to all controllers
3181 3182
	 * in PCI-X mode, so add one more descriptor to the count
	 */
J
Joe Perches 已提交
3183
	if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
3184 3185 3186
			(len > 2015)))
		count++;

L
Linus Torvalds 已提交
3187
	nr_frags = skb_shinfo(skb)->nr_frags;
J
Jesse Brandeburg 已提交
3188
	for (f = 0; f < nr_frags; f++)
L
Linus Torvalds 已提交
3189 3190
		count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
				       max_txd_pwr);
J
Jesse Brandeburg 已提交
3191
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
3192 3193 3194 3195
		count += nr_frags;

	/* need: count + 2 desc gap to keep tail from touching
	 * head, otherwise try next time */
3196
	if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
L
Linus Torvalds 已提交
3197 3198
		return NETDEV_TX_BUSY;

J
Joe Perches 已提交
3199
	if (unlikely(hw->mac_type == e1000_82547)) {
J
Jesse Brandeburg 已提交
3200
		if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
L
Linus Torvalds 已提交
3201
			netif_stop_queue(netdev);
3202 3203 3204
			if (!test_bit(__E1000_DOWN, &adapter->flags))
				mod_timer(&adapter->tx_fifo_stall_timer,
				          jiffies + 1);
L
Linus Torvalds 已提交
3205 3206 3207 3208
			return NETDEV_TX_BUSY;
		}
	}

J
Jiri Pirko 已提交
3209
	if (vlan_tx_tag_present(skb)) {
L
Linus Torvalds 已提交
3210 3211 3212 3213
		tx_flags |= E1000_TX_FLAGS_VLAN;
		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
	}

3214
	first = tx_ring->next_to_use;
J
Jesse Brandeburg 已提交
3215

3216
	tso = e1000_tso(adapter, tx_ring, skb);
L
Linus Torvalds 已提交
3217 3218 3219 3220 3221
	if (tso < 0) {
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

J
Jeff Kirsher 已提交
3222
	if (likely(tso)) {
3223 3224
		if (likely(hw->mac_type != e1000_82544))
			tx_ring->last_tx_tso = 1;
L
Linus Torvalds 已提交
3225
		tx_flags |= E1000_TX_FLAGS_TSO;
J
Jeff Kirsher 已提交
3226
	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
L
Linus Torvalds 已提交
3227 3228
		tx_flags |= E1000_TX_FLAGS_CSUM;

A
Alexey Dobriyan 已提交
3229
	if (likely(skb->protocol == htons(ETH_P_IP)))
3230 3231
		tx_flags |= E1000_TX_FLAGS_IPV4;

3232 3233
	count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd,
	                     nr_frags, mss);
L
Linus Torvalds 已提交
3234

3235 3236 3237 3238
	if (count) {
		e1000_tx_queue(adapter, tx_ring, tx_flags, count);
		/* Make sure there is space in the ring for the next send. */
		e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
L
Linus Torvalds 已提交
3239

3240 3241 3242 3243 3244
	} else {
		dev_kfree_skb_any(skb);
		tx_ring->buffer_info[first].time_stamp = 0;
		tx_ring->next_to_use = first;
	}
L
Linus Torvalds 已提交
3245 3246 3247 3248 3249 3250 3251 3252 3253

	return NETDEV_TX_OK;
}

/**
 * e1000_tx_timeout - Respond to a Tx Hang
 * @netdev: network interface device structure
 **/

3254
static void e1000_tx_timeout(struct net_device *netdev)
L
Linus Torvalds 已提交
3255
{
3256
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3257 3258

	/* Do the reset outside of interrupt context */
3259 3260
	adapter->tx_timeout_count++;
	schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
3261 3262
}

3263
static void e1000_reset_task(struct work_struct *work)
L
Linus Torvalds 已提交
3264
{
3265 3266
	struct e1000_adapter *adapter =
		container_of(work, struct e1000_adapter, reset_task);
L
Linus Torvalds 已提交
3267

3268
	e1000_reinit_safe(adapter);
L
Linus Torvalds 已提交
3269 3270 3271 3272 3273 3274 3275 3276 3277 3278
}

/**
 * e1000_get_stats - Get System Network Statistics
 * @netdev: network interface device structure
 *
 * Returns the address of the device statistics structure.
 * The statistics are actually updated from the timer callback.
 **/

3279
static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
L
Linus Torvalds 已提交
3280
{
J
Jeff Kirsher 已提交
3281
	/* only return the current stats */
3282
	return &netdev->stats;
L
Linus Torvalds 已提交
3283 3284 3285 3286 3287 3288 3289 3290 3291 3292
}

/**
 * e1000_change_mtu - Change the Maximum Transfer Unit
 * @netdev: network interface device structure
 * @new_mtu: new value for maximum frame size
 *
 * Returns 0 on success, negative on failure
 **/

3293
static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
L
Linus Torvalds 已提交
3294
{
3295
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
3296
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
3297 3298
	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;

J
Jesse Brandeburg 已提交
3299 3300
	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
3301
		e_err(probe, "Invalid MTU setting\n");
L
Linus Torvalds 已提交
3302
		return -EINVAL;
3303
	}
L
Linus Torvalds 已提交
3304

3305
	/* Adapter-specific max frame size limits. */
J
Joe Perches 已提交
3306
	switch (hw->mac_type) {
3307
	case e1000_undefined ... e1000_82542_rev2_1:
3308
		if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
3309
			e_err(probe, "Jumbo Frames not supported.\n");
3310 3311
			return -EINVAL;
		}
3312 3313 3314 3315
		break;
	default:
		/* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
		break;
L
Linus Torvalds 已提交
3316 3317
	}

3318 3319 3320 3321 3322 3323 3324
	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
		msleep(1);
	/* e1000_down has a dependency on max_frame_size */
	hw->max_frame_size = max_frame;
	if (netif_running(netdev))
		e1000_down(adapter);

3325
	/* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
3326
	 * means we reserve 2 more, this pushes us to allocate from the next
3327 3328 3329 3330
	 * larger slab size.
	 * i.e. RXBUFFER_2048 --> size-4096 slab
	 *  however with the new *_jumbo_rx* routines, jumbo receives will use
	 *  fragmented skbs */
3331

3332
	if (max_frame <= E1000_RXBUFFER_2048)
3333
		adapter->rx_buffer_len = E1000_RXBUFFER_2048;
3334 3335
	else
#if (PAGE_SIZE >= E1000_RXBUFFER_16384)
3336
		adapter->rx_buffer_len = E1000_RXBUFFER_16384;
3337 3338 3339
#elif (PAGE_SIZE >= E1000_RXBUFFER_4096)
		adapter->rx_buffer_len = PAGE_SIZE;
#endif
3340 3341

	/* adjust allocation if LPE protects us, and we aren't using SBP */
J
Joe Perches 已提交
3342
	if (!hw->tbi_compatibility_on &&
3343
	    ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) ||
3344 3345
	     (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
		adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
3346

3347 3348
	pr_info("%s changing MTU from %d to %d\n",
		netdev->name, netdev->mtu, new_mtu);
3349 3350
	netdev->mtu = new_mtu;

3351
	if (netif_running(netdev))
3352 3353 3354 3355 3356
		e1000_up(adapter);
	else
		e1000_reset(adapter);

	clear_bit(__E1000_RESETTING, &adapter->flags);
L
Linus Torvalds 已提交
3357 3358 3359 3360 3361 3362 3363 3364 3365

	return 0;
}

/**
 * e1000_update_stats - Update the board statistics counters
 * @adapter: board private structure
 **/

3366
void e1000_update_stats(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
3367
{
3368
	struct net_device *netdev = adapter->netdev;
L
Linus Torvalds 已提交
3369
	struct e1000_hw *hw = &adapter->hw;
3370
	struct pci_dev *pdev = adapter->pdev;
L
Linus Torvalds 已提交
3371
	unsigned long flags;
3372
	u16 phy_tmp;
L
Linus Torvalds 已提交
3373 3374 3375

#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF

3376 3377 3378 3379
	/*
	 * Prevent stats update while adapter is being reset, or if the pci
	 * connection is down.
	 */
A
Auke Kok 已提交
3380
	if (adapter->link_speed == 0)
3381
		return;
3382
	if (pci_channel_offline(pdev))
A
Auke Kok 已提交
3383 3384
		return;

L
Linus Torvalds 已提交
3385 3386
	spin_lock_irqsave(&adapter->stats_lock, flags);

3387
	/* these counters are modified from e1000_tbi_adjust_stats,
L
Linus Torvalds 已提交
3388 3389 3390 3391
	 * called from the interrupt context, so they must only
	 * be written while holding adapter->stats_lock
	 */

J
Joe Perches 已提交
3392 3393 3394 3395 3396 3397 3398 3399
	adapter->stats.crcerrs += er32(CRCERRS);
	adapter->stats.gprc += er32(GPRC);
	adapter->stats.gorcl += er32(GORCL);
	adapter->stats.gorch += er32(GORCH);
	adapter->stats.bprc += er32(BPRC);
	adapter->stats.mprc += er32(MPRC);
	adapter->stats.roc += er32(ROC);

3400 3401 3402 3403 3404 3405
	adapter->stats.prc64 += er32(PRC64);
	adapter->stats.prc127 += er32(PRC127);
	adapter->stats.prc255 += er32(PRC255);
	adapter->stats.prc511 += er32(PRC511);
	adapter->stats.prc1023 += er32(PRC1023);
	adapter->stats.prc1522 += er32(PRC1522);
J
Joe Perches 已提交
3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433

	adapter->stats.symerrs += er32(SYMERRS);
	adapter->stats.mpc += er32(MPC);
	adapter->stats.scc += er32(SCC);
	adapter->stats.ecol += er32(ECOL);
	adapter->stats.mcc += er32(MCC);
	adapter->stats.latecol += er32(LATECOL);
	adapter->stats.dc += er32(DC);
	adapter->stats.sec += er32(SEC);
	adapter->stats.rlec += er32(RLEC);
	adapter->stats.xonrxc += er32(XONRXC);
	adapter->stats.xontxc += er32(XONTXC);
	adapter->stats.xoffrxc += er32(XOFFRXC);
	adapter->stats.xofftxc += er32(XOFFTXC);
	adapter->stats.fcruc += er32(FCRUC);
	adapter->stats.gptc += er32(GPTC);
	adapter->stats.gotcl += er32(GOTCL);
	adapter->stats.gotch += er32(GOTCH);
	adapter->stats.rnbc += er32(RNBC);
	adapter->stats.ruc += er32(RUC);
	adapter->stats.rfc += er32(RFC);
	adapter->stats.rjc += er32(RJC);
	adapter->stats.torl += er32(TORL);
	adapter->stats.torh += er32(TORH);
	adapter->stats.totl += er32(TOTL);
	adapter->stats.toth += er32(TOTH);
	adapter->stats.tpr += er32(TPR);

3434 3435 3436 3437 3438 3439
	adapter->stats.ptc64 += er32(PTC64);
	adapter->stats.ptc127 += er32(PTC127);
	adapter->stats.ptc255 += er32(PTC255);
	adapter->stats.ptc511 += er32(PTC511);
	adapter->stats.ptc1023 += er32(PTC1023);
	adapter->stats.ptc1522 += er32(PTC1522);
J
Joe Perches 已提交
3440 3441 3442

	adapter->stats.mptc += er32(MPTC);
	adapter->stats.bptc += er32(BPTC);
L
Linus Torvalds 已提交
3443 3444 3445

	/* used for adaptive IFS */

J
Joe Perches 已提交
3446
	hw->tx_packet_delta = er32(TPT);
L
Linus Torvalds 已提交
3447
	adapter->stats.tpt += hw->tx_packet_delta;
J
Joe Perches 已提交
3448
	hw->collision_delta = er32(COLC);
L
Linus Torvalds 已提交
3449 3450
	adapter->stats.colc += hw->collision_delta;

J
Jesse Brandeburg 已提交
3451
	if (hw->mac_type >= e1000_82543) {
J
Joe Perches 已提交
3452 3453 3454 3455 3456 3457
		adapter->stats.algnerrc += er32(ALGNERRC);
		adapter->stats.rxerrc += er32(RXERRC);
		adapter->stats.tncrs += er32(TNCRS);
		adapter->stats.cexterr += er32(CEXTERR);
		adapter->stats.tsctc += er32(TSCTC);
		adapter->stats.tsctfc += er32(TSCTFC);
L
Linus Torvalds 已提交
3458 3459 3460
	}

	/* Fill out the OS statistics structure */
3461 3462
	netdev->stats.multicast = adapter->stats.mprc;
	netdev->stats.collisions = adapter->stats.colc;
L
Linus Torvalds 已提交
3463 3464 3465

	/* Rx Errors */

3466 3467
	/* RLEC on some newer hardware can be incorrect so build
	* our own version based on RUC and ROC */
3468
	netdev->stats.rx_errors = adapter->stats.rxerrc +
L
Linus Torvalds 已提交
3469
		adapter->stats.crcerrs + adapter->stats.algnerrc +
3470 3471
		adapter->stats.ruc + adapter->stats.roc +
		adapter->stats.cexterr;
3472
	adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
3473 3474 3475 3476
	netdev->stats.rx_length_errors = adapter->stats.rlerrc;
	netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
	netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
	netdev->stats.rx_missed_errors = adapter->stats.mpc;
L
Linus Torvalds 已提交
3477 3478

	/* Tx Errors */
3479
	adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
3480 3481 3482 3483
	netdev->stats.tx_errors = adapter->stats.txerrc;
	netdev->stats.tx_aborted_errors = adapter->stats.ecol;
	netdev->stats.tx_window_errors = adapter->stats.latecol;
	netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
J
Joe Perches 已提交
3484
	if (hw->bad_tx_carr_stats_fd &&
3485
	    adapter->link_duplex == FULL_DUPLEX) {
3486
		netdev->stats.tx_carrier_errors = 0;
3487 3488
		adapter->stats.tncrs = 0;
	}
L
Linus Torvalds 已提交
3489 3490 3491 3492

	/* Tx Dropped needs to be maintained elsewhere */

	/* Phy Stats */
J
Jesse Brandeburg 已提交
3493 3494
	if (hw->media_type == e1000_media_type_copper) {
		if ((adapter->link_speed == SPEED_1000) &&
L
Linus Torvalds 已提交
3495 3496 3497 3498 3499
		   (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
			phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
			adapter->phy_stats.idle_errors += phy_tmp;
		}

J
Jesse Brandeburg 已提交
3500
		if ((hw->mac_type <= e1000_82546) &&
L
Linus Torvalds 已提交
3501 3502 3503 3504 3505
		   (hw->phy_type == e1000_phy_m88) &&
		   !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
			adapter->phy_stats.receive_errors += phy_tmp;
	}

3506
	/* Management Stats */
J
Joe Perches 已提交
3507 3508 3509 3510
	if (hw->has_smbus) {
		adapter->stats.mgptc += er32(MGTPTC);
		adapter->stats.mgprc += er32(MGTPRC);
		adapter->stats.mgpdc += er32(MGTPDC);
3511 3512
	}

L
Linus Torvalds 已提交
3513 3514
	spin_unlock_irqrestore(&adapter->stats_lock, flags);
}
3515

L
Linus Torvalds 已提交
3516 3517 3518 3519 3520 3521
/**
 * e1000_intr - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/

3522
static irqreturn_t e1000_intr(int irq, void *data)
L
Linus Torvalds 已提交
3523 3524
{
	struct net_device *netdev = data;
3525
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3526
	struct e1000_hw *hw = &adapter->hw;
3527
	u32 icr = er32(ICR);
3528

J
Jesse Brandeburg 已提交
3529
	if (unlikely((!icr)))
J
Jesse Brandeburg 已提交
3530 3531
		return IRQ_NONE;  /* Not our interrupt */

J
Jesse Brandeburg 已提交
3532 3533 3534 3535 3536 3537 3538 3539
	/*
	 * we might have caused the interrupt, but the above
	 * read cleared it, and just in case the driver is
	 * down there is nothing to do so return handled
	 */
	if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
		return IRQ_HANDLED;

J
Jesse Brandeburg 已提交
3540
	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
L
Linus Torvalds 已提交
3541
		hw->get_link_status = 1;
A
Auke Kok 已提交
3542 3543 3544
		/* guard against interrupt when we're going down */
		if (!test_bit(__E1000_DOWN, &adapter->flags))
			mod_timer(&adapter->watchdog_timer, jiffies + 1);
L
Linus Torvalds 已提交
3545 3546
	}

3547 3548 3549 3550
	/* disable interrupts, without the synchronize_irq bit */
	ew32(IMC, ~0);
	E1000_WRITE_FLUSH();

3551
	if (likely(napi_schedule_prep(&adapter->napi))) {
J
Jesse Brandeburg 已提交
3552 3553 3554 3555
		adapter->total_tx_bytes = 0;
		adapter->total_tx_packets = 0;
		adapter->total_rx_bytes = 0;
		adapter->total_rx_packets = 0;
3556
		__napi_schedule(&adapter->napi);
3557
	} else {
3558 3559
		/* this really should not happen! if it does it is basically a
		 * bug, but not a hard error, so enable ints and continue */
3560 3561 3562
		if (!test_bit(__E1000_DOWN, &adapter->flags))
			e1000_irq_enable(adapter);
	}
L
Linus Torvalds 已提交
3563 3564 3565 3566 3567 3568 3569 3570

	return IRQ_HANDLED;
}

/**
 * e1000_clean - NAPI Rx polling callback
 * @adapter: board private structure
 **/
3571
static int e1000_clean(struct napi_struct *napi, int budget)
L
Linus Torvalds 已提交
3572
{
3573
	struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, napi);
3574
	int tx_clean_complete = 0, work_done = 0;
3575

3576
	tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
3577

3578
	adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
3579

3580
	if (!tx_clean_complete)
3581 3582
		work_done = budget;

3583 3584
	/* If budget not fully consumed, exit the polling mode */
	if (work_done < budget) {
J
Jesse Brandeburg 已提交
3585 3586
		if (likely(adapter->itr_setting & 3))
			e1000_set_itr(adapter);
3587
		napi_complete(napi);
3588 3589
		if (!test_bit(__E1000_DOWN, &adapter->flags))
			e1000_irq_enable(adapter);
L
Linus Torvalds 已提交
3590 3591
	}

3592
	return work_done;
L
Linus Torvalds 已提交
3593 3594 3595 3596 3597 3598
}

/**
 * e1000_clean_tx_irq - Reclaim resources after transmit completes
 * @adapter: board private structure
 **/
3599 3600
static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
			       struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
3601
{
J
Joe Perches 已提交
3602
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
3603 3604 3605 3606
	struct net_device *netdev = adapter->netdev;
	struct e1000_tx_desc *tx_desc, *eop_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i, eop;
3607
	unsigned int count = 0;
J
Jesse Brandeburg 已提交
3608
	unsigned int total_tx_bytes=0, total_tx_packets=0;
L
Linus Torvalds 已提交
3609 3610 3611 3612 3613

	i = tx_ring->next_to_clean;
	eop = tx_ring->buffer_info[i].next_to_watch;
	eop_desc = E1000_TX_DESC(*tx_ring, eop);

3614 3615
	while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
	       (count < tx_ring->count)) {
3616
		bool cleaned = false;
3617
		rmb();	/* read buffer_info after eop_desc */
3618
		for ( ; !cleaned; count++) {
L
Linus Torvalds 已提交
3619 3620 3621 3622
			tx_desc = E1000_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];
			cleaned = (i == eop);

J
Jesse Brandeburg 已提交
3623
			if (cleaned) {
3624
				struct sk_buff *skb = buffer_info->skb;
3625 3626 3627 3628 3629
				unsigned int segs, bytecount;
				segs = skb_shinfo(skb)->gso_segs ?: 1;
				/* multiply data chunks by size of headers */
				bytecount = ((segs - 1) * skb_headlen(skb)) +
				            skb->len;
3630
				total_tx_packets += segs;
3631
				total_tx_bytes += bytecount;
J
Jesse Brandeburg 已提交
3632
			}
J
Jeff Kirsher 已提交
3633
			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3634
			tx_desc->upper.data = 0;
L
Linus Torvalds 已提交
3635

J
Jesse Brandeburg 已提交
3636
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3637
		}
3638

L
Linus Torvalds 已提交
3639 3640 3641 3642 3643 3644
		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = E1000_TX_DESC(*tx_ring, eop);
	}

	tx_ring->next_to_clean = i;

3645
#define TX_WAKE_THRESHOLD 32
3646
	if (unlikely(count && netif_carrier_ok(netdev) &&
3647 3648 3649 3650 3651
		     E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
		/* Make sure that anybody stopping the queue after this
		 * sees the new next_to_clean.
		 */
		smp_mb();
3652 3653 3654

		if (netif_queue_stopped(netdev) &&
		    !(test_bit(__E1000_DOWN, &adapter->flags))) {
3655
			netif_wake_queue(netdev);
3656 3657
			++adapter->restart_queue;
		}
3658
	}
3659

3660
	if (adapter->detect_tx_hung) {
3661
		/* Detect a transmit hang in hardware, this serializes the
L
Linus Torvalds 已提交
3662
		 * check with the clearing of time_stamp and movement of i */
J
Joe Perches 已提交
3663
		adapter->detect_tx_hung = false;
3664 3665
		if (tx_ring->buffer_info[eop].time_stamp &&
		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
3666 3667
		               (adapter->tx_timeout_factor * HZ)) &&
		    !(er32(STATUS) & E1000_STATUS_TXOFF)) {
3668 3669

			/* detected Tx unit hang */
3670
			e_err(drv, "Detected Tx Unit Hang\n"
3671 3672 3673 3674 3675 3676 3677 3678 3679 3680
			      "  Tx Queue             <%lu>\n"
			      "  TDH                  <%x>\n"
			      "  TDT                  <%x>\n"
			      "  next_to_use          <%x>\n"
			      "  next_to_clean        <%x>\n"
			      "buffer_info[next_to_clean]\n"
			      "  time_stamp           <%lx>\n"
			      "  next_to_watch        <%x>\n"
			      "  jiffies              <%lx>\n"
			      "  next_to_watch.status <%x>\n",
3681 3682
				(unsigned long)((tx_ring - adapter->tx_ring) /
					sizeof(struct e1000_tx_ring)),
J
Joe Perches 已提交
3683 3684
				readl(hw->hw_addr + tx_ring->tdh),
				readl(hw->hw_addr + tx_ring->tdt),
3685
				tx_ring->next_to_use,
3686
				tx_ring->next_to_clean,
3687
				tx_ring->buffer_info[eop].time_stamp,
3688 3689 3690
				eop,
				jiffies,
				eop_desc->upper.fields.status);
L
Linus Torvalds 已提交
3691
			netif_stop_queue(netdev);
3692
		}
L
Linus Torvalds 已提交
3693
	}
J
Jesse Brandeburg 已提交
3694 3695
	adapter->total_tx_bytes += total_tx_bytes;
	adapter->total_tx_packets += total_tx_packets;
3696 3697
	netdev->stats.tx_bytes += total_tx_bytes;
	netdev->stats.tx_packets += total_tx_packets;
3698
	return count < tx_ring->count;
L
Linus Torvalds 已提交
3699 3700 3701 3702
}

/**
 * e1000_rx_checksum - Receive Checksum Offload for 82543
3703 3704 3705 3706
 * @adapter:     board private structure
 * @status_err:  receive descriptor status and error fields
 * @csum:        receive descriptor csum field
 * @sk_buff:     socket buffer with received data
L
Linus Torvalds 已提交
3707 3708
 **/

3709 3710
static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
			      u32 csum, struct sk_buff *skb)
L
Linus Torvalds 已提交
3711
{
J
Joe Perches 已提交
3712
	struct e1000_hw *hw = &adapter->hw;
3713 3714
	u16 status = (u16)status_err;
	u8 errors = (u8)(status_err >> 24);
3715 3716

	skb_checksum_none_assert(skb);
3717

L
Linus Torvalds 已提交
3718
	/* 82543 or newer only */
J
Joe Perches 已提交
3719
	if (unlikely(hw->mac_type < e1000_82543)) return;
L
Linus Torvalds 已提交
3720
	/* Ignore Checksum bit is set */
J
Jesse Brandeburg 已提交
3721
	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3722
	/* TCP/UDP checksum error bit is set */
J
Jesse Brandeburg 已提交
3723
	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
L
Linus Torvalds 已提交
3724 3725
		/* let the stack verify checksum errors */
		adapter->hw_csum_err++;
3726 3727 3728
		return;
	}
	/* TCP/UDP Checksum has not been calculated */
3729 3730 3731
	if (!(status & E1000_RXD_STAT_TCPCS))
		return;

3732 3733
	/* It must be a TCP or UDP packet with a valid checksum */
	if (likely(status & E1000_RXD_STAT_TCPCS)) {
L
Linus Torvalds 已提交
3734 3735 3736
		/* TCP checksum is good */
		skb->ip_summed = CHECKSUM_UNNECESSARY;
	}
3737
	adapter->hw_csum_good++;
L
Linus Torvalds 已提交
3738 3739
}

3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761
/**
 * e1000_consume_page - helper function
 **/
static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
                               u16 length)
{
	bi->page = NULL;
	skb->len += length;
	skb->data_len += length;
	skb->truesize += length;
}

/**
 * e1000_receive_skb - helper function to handle rx indications
 * @adapter: board private structure
 * @status: descriptor status field as written by hardware
 * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
 * @skb: pointer to sk_buff to be indicated to stack
 */
static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status,
			      __le16 vlan, struct sk_buff *skb)
{
J
Jesse Brandeburg 已提交
3762 3763
	skb->protocol = eth_type_trans(skb, adapter->netdev);

J
Jiri Pirko 已提交
3764 3765 3766 3767 3768 3769
	if (status & E1000_RXD_STAT_VP) {
		u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;

		__vlan_hwaccel_put_tag(skb, vid);
	}
	napi_gro_receive(&adapter->napi, skb);
3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
}

/**
 * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
 * @adapter: board private structure
 * @rx_ring: ring to clean
 * @work_done: amount of napi work completed this call
 * @work_to_do: max amount of work allowed for this call to do
 *
 * the return value indicates whether actual cleaning was done, there
 * is no guarantee that everything was cleaned
 */
static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
				     struct e1000_rx_ring *rx_ring,
				     int *work_done, int work_to_do)
{
	struct e1000_hw *hw = &adapter->hw;
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	struct e1000_rx_desc *rx_desc, *next_rxd;
	struct e1000_buffer *buffer_info, *next_buffer;
	unsigned long irq_flags;
	u32 length;
	unsigned int i;
	int cleaned_count = 0;
	bool cleaned = false;
	unsigned int total_rx_bytes=0, total_rx_packets=0;

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC(*rx_ring, i);
	buffer_info = &rx_ring->buffer_info[i];

	while (rx_desc->status & E1000_RXD_STAT_DD) {
		struct sk_buff *skb;
		u8 status;

		if (*work_done >= work_to_do)
			break;
		(*work_done)++;
3809
		rmb(); /* read descriptor and rx_buffer_info after status DD */
3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822

		status = rx_desc->status;
		skb = buffer_info->skb;
		buffer_info->skb = NULL;

		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC(*rx_ring, i);
		prefetch(next_rxd);

		next_buffer = &rx_ring->buffer_info[i];

		cleaned = true;
		cleaned_count++;
3823 3824
		dma_unmap_page(&pdev->dev, buffer_info->dma,
			       buffer_info->length, DMA_FROM_DEVICE);
3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921
		buffer_info->dma = 0;

		length = le16_to_cpu(rx_desc->length);

		/* errors is only valid for DD + EOP descriptors */
		if (unlikely((status & E1000_RXD_STAT_EOP) &&
		    (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
			u8 last_byte = *(skb->data + length - 1);
			if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
				       last_byte)) {
				spin_lock_irqsave(&adapter->stats_lock,
				                  irq_flags);
				e1000_tbi_adjust_stats(hw, &adapter->stats,
				                       length, skb->data);
				spin_unlock_irqrestore(&adapter->stats_lock,
				                       irq_flags);
				length--;
			} else {
				/* recycle both page and skb */
				buffer_info->skb = skb;
				/* an error means any chain goes out the window
				 * too */
				if (rx_ring->rx_skb_top)
					dev_kfree_skb(rx_ring->rx_skb_top);
				rx_ring->rx_skb_top = NULL;
				goto next_desc;
			}
		}

#define rxtop rx_ring->rx_skb_top
		if (!(status & E1000_RXD_STAT_EOP)) {
			/* this descriptor is only the beginning (or middle) */
			if (!rxtop) {
				/* this is the beginning of a chain */
				rxtop = skb;
				skb_fill_page_desc(rxtop, 0, buffer_info->page,
				                   0, length);
			} else {
				/* this is the middle of a chain */
				skb_fill_page_desc(rxtop,
				    skb_shinfo(rxtop)->nr_frags,
				    buffer_info->page, 0, length);
				/* re-use the skb, only consumed the page */
				buffer_info->skb = skb;
			}
			e1000_consume_page(buffer_info, rxtop, length);
			goto next_desc;
		} else {
			if (rxtop) {
				/* end of the chain */
				skb_fill_page_desc(rxtop,
				    skb_shinfo(rxtop)->nr_frags,
				    buffer_info->page, 0, length);
				/* re-use the current skb, we only consumed the
				 * page */
				buffer_info->skb = skb;
				skb = rxtop;
				rxtop = NULL;
				e1000_consume_page(buffer_info, skb, length);
			} else {
				/* no chain, got EOP, this buf is the packet
				 * copybreak to save the put_page/alloc_page */
				if (length <= copybreak &&
				    skb_tailroom(skb) >= length) {
					u8 *vaddr;
					vaddr = kmap_atomic(buffer_info->page,
					                    KM_SKB_DATA_SOFTIRQ);
					memcpy(skb_tail_pointer(skb), vaddr, length);
					kunmap_atomic(vaddr,
					              KM_SKB_DATA_SOFTIRQ);
					/* re-use the page, so don't erase
					 * buffer_info->page */
					skb_put(skb, length);
				} else {
					skb_fill_page_desc(skb, 0,
					                   buffer_info->page, 0,
				                           length);
					e1000_consume_page(buffer_info, skb,
					                   length);
				}
			}
		}

		/* Receive Checksum Offload XXX recompute due to CRC strip? */
		e1000_rx_checksum(adapter,
		                  (u32)(status) |
		                  ((u32)(rx_desc->errors) << 24),
		                  le16_to_cpu(rx_desc->csum), skb);

		pskb_trim(skb, skb->len - 4);

		/* probably a little skewed due to removing CRC */
		total_rx_bytes += skb->len;
		total_rx_packets++;

		/* eth type trans needs skb->data to point to something */
		if (!pskb_may_pull(skb, ETH_HLEN)) {
3922
			e_err(drv, "pskb_may_pull failed.\n");
3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
			dev_kfree_skb(skb);
			goto next_desc;
		}

		e1000_receive_skb(adapter, status, rx_desc->special, skb);

next_desc:
		rx_desc->status = 0;

		/* return some buffers to hardware, one at a time is too slow */
		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
			cleaned_count = 0;
		}

		/* use prefetched values */
		rx_desc = next_rxd;
		buffer_info = next_buffer;
	}
	rx_ring->next_to_clean = i;

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);

	adapter->total_rx_packets += total_rx_packets;
	adapter->total_rx_bytes += total_rx_bytes;
3950 3951
	netdev->stats.rx_bytes += total_rx_bytes;
	netdev->stats.rx_packets += total_rx_packets;
3952 3953 3954
	return cleaned;
}

3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979
/*
 * this should improve performance for small packets with large amounts
 * of reassembly being done in the stack
 */
static void e1000_check_copybreak(struct net_device *netdev,
				 struct e1000_buffer *buffer_info,
				 u32 length, struct sk_buff **skb)
{
	struct sk_buff *new_skb;

	if (length > copybreak)
		return;

	new_skb = netdev_alloc_skb_ip_align(netdev, length);
	if (!new_skb)
		return;

	skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
				       (*skb)->data - NET_IP_ALIGN,
				       length + NET_IP_ALIGN);
	/* save the skb in buffer_info as good */
	buffer_info->skb = *skb;
	*skb = new_skb;
}

L
Linus Torvalds 已提交
3980
/**
3981
 * e1000_clean_rx_irq - Send received data up the network stack; legacy
L
Linus Torvalds 已提交
3982
 * @adapter: board private structure
3983 3984 3985 3986
 * @rx_ring: ring to clean
 * @work_done: amount of napi work completed this call
 * @work_to_do: max amount of work allowed for this call to do
 */
3987 3988 3989
static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
			       struct e1000_rx_ring *rx_ring,
			       int *work_done, int work_to_do)
L
Linus Torvalds 已提交
3990
{
J
Joe Perches 已提交
3991
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
3992 3993
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3994 3995
	struct e1000_rx_desc *rx_desc, *next_rxd;
	struct e1000_buffer *buffer_info, *next_buffer;
L
Linus Torvalds 已提交
3996
	unsigned long flags;
3997
	u32 length;
L
Linus Torvalds 已提交
3998
	unsigned int i;
3999
	int cleaned_count = 0;
J
Joe Perches 已提交
4000
	bool cleaned = false;
J
Jesse Brandeburg 已提交
4001
	unsigned int total_rx_bytes=0, total_rx_packets=0;
L
Linus Torvalds 已提交
4002 4003 4004

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC(*rx_ring, i);
4005
	buffer_info = &rx_ring->buffer_info[i];
L
Linus Torvalds 已提交
4006

4007
	while (rx_desc->status & E1000_RXD_STAT_DD) {
4008
		struct sk_buff *skb;
4009
		u8 status;
4010

J
Jesse Brandeburg 已提交
4011
		if (*work_done >= work_to_do)
L
Linus Torvalds 已提交
4012 4013
			break;
		(*work_done)++;
4014
		rmb(); /* read descriptor and rx_buffer_info after status DD */
4015

4016
		status = rx_desc->status;
4017
		skb = buffer_info->skb;
4018 4019
		buffer_info->skb = NULL;

4020 4021
		prefetch(skb->data - NET_IP_ALIGN);

4022 4023
		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC(*rx_ring, i);
4024 4025
		prefetch(next_rxd);

4026 4027
		next_buffer = &rx_ring->buffer_info[i];

J
Joe Perches 已提交
4028
		cleaned = true;
4029
		cleaned_count++;
4030 4031
		dma_unmap_single(&pdev->dev, buffer_info->dma,
				 buffer_info->length, DMA_FROM_DEVICE);
J
Jesse Brandeburg 已提交
4032
		buffer_info->dma = 0;
L
Linus Torvalds 已提交
4033 4034

		length = le16_to_cpu(rx_desc->length);
4035
		/* !EOP means multiple descriptors were used to store a single
4036 4037 4038 4039 4040 4041 4042 4043 4044
		 * packet, if thats the case we need to toss it.  In fact, we
		 * to toss every packet with the EOP bit clear and the next
		 * frame that _does_ have the EOP bit set, as it is by
		 * definition only a frame fragment
		 */
		if (unlikely(!(status & E1000_RXD_STAT_EOP)))
			adapter->discarding = true;

		if (adapter->discarding) {
4045
			/* All receives must fit into a single buffer */
4046
			e_dbg("Receive packet consumed multiple buffers\n");
A
Auke Kok 已提交
4047
			/* recycle */
4048
			buffer_info->skb = skb;
4049 4050
			if (status & E1000_RXD_STAT_EOP)
				adapter->discarding = false;
L
Linus Torvalds 已提交
4051 4052 4053
			goto next_desc;
		}

J
Jesse Brandeburg 已提交
4054
		if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
4055
			u8 last_byte = *(skb->data + length - 1);
J
Joe Perches 已提交
4056 4057
			if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
				       last_byte)) {
L
Linus Torvalds 已提交
4058
				spin_lock_irqsave(&adapter->stats_lock, flags);
J
Joe Perches 已提交
4059
				e1000_tbi_adjust_stats(hw, &adapter->stats,
L
Linus Torvalds 已提交
4060 4061 4062 4063 4064
				                       length, skb->data);
				spin_unlock_irqrestore(&adapter->stats_lock,
				                       flags);
				length--;
			} else {
4065 4066
				/* recycle */
				buffer_info->skb = skb;
L
Linus Torvalds 已提交
4067 4068
				goto next_desc;
			}
A
Auke Kok 已提交
4069
		}
L
Linus Torvalds 已提交
4070

4071 4072 4073 4074
		/* adjust length to remove Ethernet CRC, this must be
		 * done after the TBI_ACCEPT workaround above */
		length -= 4;

J
Jesse Brandeburg 已提交
4075 4076 4077 4078
		/* probably a little skewed due to removing CRC */
		total_rx_bytes += length;
		total_rx_packets++;

4079 4080
		e1000_check_copybreak(netdev, buffer_info, length, &skb);

A
Auke Kok 已提交
4081
		skb_put(skb, length);
L
Linus Torvalds 已提交
4082 4083

		/* Receive Checksum Offload */
4084
		e1000_rx_checksum(adapter,
4085 4086
				  (u32)(status) |
				  ((u32)(rx_desc->errors) << 24),
D
David S. Miller 已提交
4087
				  le16_to_cpu(rx_desc->csum), skb);
J
Jesse Brandeburg 已提交
4088

4089
		e1000_receive_skb(adapter, status, rx_desc->special, skb);
4090

L
Linus Torvalds 已提交
4091 4092 4093
next_desc:
		rx_desc->status = 0;

4094 4095 4096 4097 4098 4099
		/* return some buffers to hardware, one at a time is too slow */
		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
			cleaned_count = 0;
		}

4100
		/* use prefetched values */
4101 4102
		rx_desc = next_rxd;
		buffer_info = next_buffer;
L
Linus Torvalds 已提交
4103 4104
	}
	rx_ring->next_to_clean = i;
4105 4106 4107 4108

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4109

J
Jesse Brandeburg 已提交
4110 4111
	adapter->total_rx_packets += total_rx_packets;
	adapter->total_rx_bytes += total_rx_bytes;
4112 4113
	netdev->stats.rx_bytes += total_rx_bytes;
	netdev->stats.rx_packets += total_rx_packets;
4114 4115 4116
	return cleaned;
}

4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133
/**
 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
 * @adapter: address of board private structure
 * @rx_ring: pointer to receive ring structure
 * @cleaned_count: number of buffers to allocate this pass
 **/

static void
e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
                             struct e1000_rx_ring *rx_ring, int cleaned_count)
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	struct e1000_rx_desc *rx_desc;
	struct e1000_buffer *buffer_info;
	struct sk_buff *skb;
	unsigned int i;
4134
	unsigned int bufsz = 256 - 16 /*for skb_reserve */ ;
4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145

	i = rx_ring->next_to_use;
	buffer_info = &rx_ring->buffer_info[i];

	while (cleaned_count--) {
		skb = buffer_info->skb;
		if (skb) {
			skb_trim(skb, 0);
			goto check_page;
		}

4146
		skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4147 4148 4149 4150 4151 4152 4153 4154 4155
		if (unlikely(!skb)) {
			/* Better luck next round */
			adapter->alloc_rx_buff_failed++;
			break;
		}

		/* Fix for errata 23, can't cross 64kB boundary */
		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
			struct sk_buff *oldskb = skb;
4156 4157
			e_err(rx_err, "skb align check failed: %u bytes at "
			      "%p\n", bufsz, skb->data);
4158
			/* Try again, without freeing the previous */
4159
			skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188
			/* Failed allocation, critical failure */
			if (!skb) {
				dev_kfree_skb(oldskb);
				adapter->alloc_rx_buff_failed++;
				break;
			}

			if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
				/* give up */
				dev_kfree_skb(skb);
				dev_kfree_skb(oldskb);
				break; /* while (cleaned_count--) */
			}

			/* Use new allocation */
			dev_kfree_skb(oldskb);
		}
		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_buffer_len;
check_page:
		/* allocate a new page if necessary */
		if (!buffer_info->page) {
			buffer_info->page = alloc_page(GFP_ATOMIC);
			if (unlikely(!buffer_info->page)) {
				adapter->alloc_rx_buff_failed++;
				break;
			}
		}

4189
		if (!buffer_info->dma) {
4190
			buffer_info->dma = dma_map_page(&pdev->dev,
4191
			                                buffer_info->page, 0,
4192 4193 4194
							buffer_info->length,
							DMA_FROM_DEVICE);
			if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4195 4196 4197 4198 4199 4200 4201 4202 4203
				put_page(buffer_info->page);
				dev_kfree_skb(skb);
				buffer_info->page = NULL;
				buffer_info->skb = NULL;
				buffer_info->dma = 0;
				adapter->alloc_rx_buff_failed++;
				break; /* while !buffer_info->skb */
			}
		}
4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226

		rx_desc = E1000_RX_DESC(*rx_ring, i);
		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);

		if (unlikely(++i == rx_ring->count))
			i = 0;
		buffer_info = &rx_ring->buffer_info[i];
	}

	if (likely(rx_ring->next_to_use != i)) {
		rx_ring->next_to_use = i;
		if (unlikely(i-- == 0))
			i = (rx_ring->count - 1);

		/* Force memory writes to complete before letting h/w
		 * know there are new descriptors to fetch.  (Only
		 * applicable for weak-ordered memory model archs,
		 * such as IA-64). */
		wmb();
		writel(i, adapter->hw.hw_addr + rx_ring->rdt);
	}
}

L
Linus Torvalds 已提交
4227
/**
4228
 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
L
Linus Torvalds 已提交
4229 4230 4231
 * @adapter: address of board private structure
 **/

4232 4233 4234
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
				   struct e1000_rx_ring *rx_ring,
				   int cleaned_count)
L
Linus Torvalds 已提交
4235
{
J
Joe Perches 已提交
4236
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
4237 4238 4239 4240 4241
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	struct e1000_rx_desc *rx_desc;
	struct e1000_buffer *buffer_info;
	struct sk_buff *skb;
4242
	unsigned int i;
4243
	unsigned int bufsz = adapter->rx_buffer_len;
L
Linus Torvalds 已提交
4244 4245 4246 4247

	i = rx_ring->next_to_use;
	buffer_info = &rx_ring->buffer_info[i];

4248
	while (cleaned_count--) {
4249 4250
		skb = buffer_info->skb;
		if (skb) {
4251 4252 4253 4254
			skb_trim(skb, 0);
			goto map_skb;
		}

4255
		skb = netdev_alloc_skb_ip_align(netdev, bufsz);
J
Jesse Brandeburg 已提交
4256
		if (unlikely(!skb)) {
L
Linus Torvalds 已提交
4257
			/* Better luck next round */
4258
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
4259 4260 4261
			break;
		}

4262
		/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
4263 4264
		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
			struct sk_buff *oldskb = skb;
4265 4266
			e_err(rx_err, "skb align check failed: %u bytes at "
			      "%p\n", bufsz, skb->data);
4267
			/* Try again, without freeing the previous */
4268
			skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4269
			/* Failed allocation, critical failure */
L
Linus Torvalds 已提交
4270 4271
			if (!skb) {
				dev_kfree_skb(oldskb);
4272
				adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
4273 4274
				break;
			}
4275

L
Linus Torvalds 已提交
4276 4277 4278 4279
			if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
				/* give up */
				dev_kfree_skb(skb);
				dev_kfree_skb(oldskb);
4280
				adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
4281 4282
				break; /* while !buffer_info->skb */
			}
4283 4284 4285

			/* Use new allocation */
			dev_kfree_skb(oldskb);
L
Linus Torvalds 已提交
4286 4287 4288
		}
		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_buffer_len;
4289
map_skb:
4290
		buffer_info->dma = dma_map_single(&pdev->dev,
L
Linus Torvalds 已提交
4291
						  skb->data,
4292
						  buffer_info->length,
4293 4294
						  DMA_FROM_DEVICE);
		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4295 4296 4297 4298 4299 4300
			dev_kfree_skb(skb);
			buffer_info->skb = NULL;
			buffer_info->dma = 0;
			adapter->alloc_rx_buff_failed++;
			break; /* while !buffer_info->skb */
		}
L
Linus Torvalds 已提交
4301

4302 4303 4304 4305 4306
		/*
		 * XXX if it was allocated cleanly it will never map to a
		 * boundary crossing
		 */

4307 4308 4309 4310
		/* Fix for errata 23, can't cross 64kB boundary */
		if (!e1000_check_64k_bound(adapter,
					(void *)(unsigned long)buffer_info->dma,
					adapter->rx_buffer_len)) {
4311 4312
			e_err(rx_err, "dma align check failed: %u bytes at "
			      "%p\n", adapter->rx_buffer_len,
4313
			      (void *)(unsigned long)buffer_info->dma);
L
Linus Torvalds 已提交
4314 4315 4316
			dev_kfree_skb(skb);
			buffer_info->skb = NULL;

4317
			dma_unmap_single(&pdev->dev, buffer_info->dma,
L
Linus Torvalds 已提交
4318
					 adapter->rx_buffer_len,
4319
					 DMA_FROM_DEVICE);
J
Jesse Brandeburg 已提交
4320
			buffer_info->dma = 0;
L
Linus Torvalds 已提交
4321

4322
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
4323 4324 4325 4326 4327
			break; /* while !buffer_info->skb */
		}
		rx_desc = E1000_RX_DESC(*rx_ring, i);
		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);

J
Jesse Brandeburg 已提交
4328 4329
		if (unlikely(++i == rx_ring->count))
			i = 0;
L
Linus Torvalds 已提交
4330 4331 4332
		buffer_info = &rx_ring->buffer_info[i];
	}

4333 4334 4335 4336 4337 4338 4339 4340 4341 4342
	if (likely(rx_ring->next_to_use != i)) {
		rx_ring->next_to_use = i;
		if (unlikely(i-- == 0))
			i = (rx_ring->count - 1);

		/* Force memory writes to complete before letting h/w
		 * know there are new descriptors to fetch.  (Only
		 * applicable for weak-ordered memory model archs,
		 * such as IA-64). */
		wmb();
J
Joe Perches 已提交
4343
		writel(i, hw->hw_addr + rx_ring->rdt);
4344
	}
L
Linus Torvalds 已提交
4345 4346 4347 4348 4349 4350 4351
}

/**
 * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
 * @adapter:
 **/

4352
static void e1000_smartspeed(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
4353
{
J
Joe Perches 已提交
4354
	struct e1000_hw *hw = &adapter->hw;
4355 4356
	u16 phy_status;
	u16 phy_ctrl;
L
Linus Torvalds 已提交
4357

J
Joe Perches 已提交
4358 4359
	if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg ||
	   !(hw->autoneg_advertised & ADVERTISE_1000_FULL))
L
Linus Torvalds 已提交
4360 4361
		return;

J
Jesse Brandeburg 已提交
4362
	if (adapter->smartspeed == 0) {
L
Linus Torvalds 已提交
4363 4364
		/* If Master/Slave config fault is asserted twice,
		 * we assume back-to-back */
J
Joe Perches 已提交
4365
		e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4366
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
J
Joe Perches 已提交
4367
		e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4368
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
J
Joe Perches 已提交
4369
		e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
J
Jesse Brandeburg 已提交
4370
		if (phy_ctrl & CR_1000T_MS_ENABLE) {
L
Linus Torvalds 已提交
4371
			phy_ctrl &= ~CR_1000T_MS_ENABLE;
J
Joe Perches 已提交
4372
			e1000_write_phy_reg(hw, PHY_1000T_CTRL,
L
Linus Torvalds 已提交
4373 4374
					    phy_ctrl);
			adapter->smartspeed++;
J
Joe Perches 已提交
4375 4376
			if (!e1000_phy_setup_autoneg(hw) &&
			   !e1000_read_phy_reg(hw, PHY_CTRL,
L
Linus Torvalds 已提交
4377 4378 4379
				   	       &phy_ctrl)) {
				phy_ctrl |= (MII_CR_AUTO_NEG_EN |
					     MII_CR_RESTART_AUTO_NEG);
J
Joe Perches 已提交
4380
				e1000_write_phy_reg(hw, PHY_CTRL,
L
Linus Torvalds 已提交
4381 4382 4383 4384
						    phy_ctrl);
			}
		}
		return;
J
Jesse Brandeburg 已提交
4385
	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
L
Linus Torvalds 已提交
4386
		/* If still no link, perhaps using 2/3 pair cable */
J
Joe Perches 已提交
4387
		e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
L
Linus Torvalds 已提交
4388
		phy_ctrl |= CR_1000T_MS_ENABLE;
J
Joe Perches 已提交
4389 4390 4391
		e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl);
		if (!e1000_phy_setup_autoneg(hw) &&
		   !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) {
L
Linus Torvalds 已提交
4392 4393
			phy_ctrl |= (MII_CR_AUTO_NEG_EN |
				     MII_CR_RESTART_AUTO_NEG);
J
Joe Perches 已提交
4394
			e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl);
L
Linus Torvalds 已提交
4395 4396 4397
		}
	}
	/* Restart process after E1000_SMARTSPEED_MAX iterations */
J
Jesse Brandeburg 已提交
4398
	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
L
Linus Torvalds 已提交
4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
		adapter->smartspeed = 0;
}

/**
 * e1000_ioctl -
 * @netdev:
 * @ifreq:
 * @cmd:
 **/

4409
static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427
{
	switch (cmd) {
	case SIOCGMIIPHY:
	case SIOCGMIIREG:
	case SIOCSMIIREG:
		return e1000_mii_ioctl(netdev, ifr, cmd);
	default:
		return -EOPNOTSUPP;
	}
}

/**
 * e1000_mii_ioctl -
 * @netdev:
 * @ifreq:
 * @cmd:
 **/

4428 4429
static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
			   int cmd)
L
Linus Torvalds 已提交
4430
{
4431
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
4432
	struct e1000_hw *hw = &adapter->hw;
L
Linus Torvalds 已提交
4433 4434
	struct mii_ioctl_data *data = if_mii(ifr);
	int retval;
4435
	u16 mii_reg;
4436
	unsigned long flags;
L
Linus Torvalds 已提交
4437

J
Joe Perches 已提交
4438
	if (hw->media_type != e1000_media_type_copper)
L
Linus Torvalds 已提交
4439 4440 4441 4442
		return -EOPNOTSUPP;

	switch (cmd) {
	case SIOCGMIIPHY:
J
Joe Perches 已提交
4443
		data->phy_id = hw->phy_addr;
L
Linus Torvalds 已提交
4444 4445
		break;
	case SIOCGMIIREG:
4446
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Joe Perches 已提交
4447
		if (e1000_read_phy_reg(hw, data->reg_num & 0x1F,
4448 4449
				   &data->val_out)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4450
			return -EIO;
4451 4452
		}
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4453 4454
		break;
	case SIOCSMIIREG:
J
Jesse Brandeburg 已提交
4455
		if (data->reg_num & ~(0x1F))
L
Linus Torvalds 已提交
4456 4457
			return -EFAULT;
		mii_reg = data->val_in;
4458
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Joe Perches 已提交
4459
		if (e1000_write_phy_reg(hw, data->reg_num,
4460 4461
					mii_reg)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4462
			return -EIO;
4463
		}
4464
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
J
Joe Perches 已提交
4465
		if (hw->media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
4466 4467
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4468
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4469
					break;
J
Jesse Brandeburg 已提交
4470
				if (mii_reg & MII_CR_AUTO_NEG_EN) {
J
Joe Perches 已提交
4471 4472
					hw->autoneg = 1;
					hw->autoneg_advertised = 0x2F;
L
Linus Torvalds 已提交
4473
				} else {
4474
					u32 speed;
L
Linus Torvalds 已提交
4475
					if (mii_reg & 0x40)
4476
						speed = SPEED_1000;
L
Linus Torvalds 已提交
4477
					else if (mii_reg & 0x2000)
4478
						speed = SPEED_100;
L
Linus Torvalds 已提交
4479
					else
4480 4481 4482 4483 4484 4485
						speed = SPEED_10;
					retval = e1000_set_spd_dplx(
						adapter, speed,
						((mii_reg & 0x100)
						 ? DUPLEX_FULL :
						 DUPLEX_HALF));
4486
					if (retval)
L
Linus Torvalds 已提交
4487 4488
						return retval;
				}
4489 4490 4491
				if (netif_running(adapter->netdev))
					e1000_reinit_locked(adapter);
				else
L
Linus Torvalds 已提交
4492 4493 4494 4495
					e1000_reset(adapter);
				break;
			case M88E1000_PHY_SPEC_CTRL:
			case M88E1000_EXT_PHY_SPEC_CTRL:
J
Joe Perches 已提交
4496
				if (e1000_phy_reset(hw))
L
Linus Torvalds 已提交
4497 4498 4499 4500 4501 4502
					return -EIO;
				break;
			}
		} else {
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4503
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4504
					break;
4505 4506 4507
				if (netif_running(adapter->netdev))
					e1000_reinit_locked(adapter);
				else
L
Linus Torvalds 已提交
4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518
					e1000_reset(adapter);
				break;
			}
		}
		break;
	default:
		return -EOPNOTSUPP;
	}
	return E1000_SUCCESS;
}

4519
void e1000_pci_set_mwi(struct e1000_hw *hw)
L
Linus Torvalds 已提交
4520 4521
{
	struct e1000_adapter *adapter = hw->back;
4522
	int ret_val = pci_set_mwi(adapter->pdev);
L
Linus Torvalds 已提交
4523

J
Jesse Brandeburg 已提交
4524
	if (ret_val)
4525
		e_err(probe, "Error in setting MWI\n");
L
Linus Torvalds 已提交
4526 4527
}

4528
void e1000_pci_clear_mwi(struct e1000_hw *hw)
L
Linus Torvalds 已提交
4529 4530 4531 4532 4533 4534
{
	struct e1000_adapter *adapter = hw->back;

	pci_clear_mwi(adapter->pdev);
}

4535
int e1000_pcix_get_mmrbc(struct e1000_hw *hw)
4536 4537 4538 4539 4540
{
	struct e1000_adapter *adapter = hw->back;
	return pcix_get_mmrbc(adapter->pdev);
}

4541
void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
4542 4543 4544 4545 4546
{
	struct e1000_adapter *adapter = hw->back;
	pcix_set_mmrbc(adapter->pdev, mmrbc);
}

4547
void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
L
Linus Torvalds 已提交
4548 4549 4550 4551
{
	outl(value, port);
}

J
Jiri Pirko 已提交
4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562
static bool e1000_vlan_used(struct e1000_adapter *adapter)
{
	u16 vid;

	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
		return true;
	return false;
}

static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
				     bool filter_on)
L
Linus Torvalds 已提交
4563
{
J
Joe Perches 已提交
4564
	struct e1000_hw *hw = &adapter->hw;
J
Jiri Pirko 已提交
4565
	u32 rctl;
L
Linus Torvalds 已提交
4566

J
Jesse Brandeburg 已提交
4567 4568
	if (!test_bit(__E1000_DOWN, &adapter->flags))
		e1000_irq_disable(adapter);
L
Linus Torvalds 已提交
4569

J
Jiri Pirko 已提交
4570
	if (filter_on) {
4571 4572 4573
		/* enable VLAN receive filtering */
		rctl = er32(RCTL);
		rctl &= ~E1000_RCTL_CFIEN;
J
Jiri Pirko 已提交
4574
		if (!(adapter->netdev->flags & IFF_PROMISC))
4575 4576 4577
			rctl |= E1000_RCTL_VFE;
		ew32(RCTL, rctl);
		e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
4578
	} else {
4579 4580 4581 4582
		/* disable VLAN receive filtering */
		rctl = er32(RCTL);
		rctl &= ~E1000_RCTL_VFE;
		ew32(RCTL, rctl);
J
Jiri Pirko 已提交
4583
	}
4584

J
Jiri Pirko 已提交
4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604
	if (!test_bit(__E1000_DOWN, &adapter->flags))
		e1000_irq_enable(adapter);
}

static void e1000_vlan_mode(struct net_device *netdev, u32 features)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
	u32 ctrl;

	if (!test_bit(__E1000_DOWN, &adapter->flags))
		e1000_irq_disable(adapter);

	ctrl = er32(CTRL);
	if (features & NETIF_F_HW_VLAN_RX) {
		/* enable VLAN tag insert/strip */
		ctrl |= E1000_CTRL_VME;
	} else {
		/* disable VLAN tag insert/strip */
		ctrl &= ~E1000_CTRL_VME;
L
Linus Torvalds 已提交
4605
	}
J
Jiri Pirko 已提交
4606
	ew32(CTRL, ctrl);
L
Linus Torvalds 已提交
4607

J
Jesse Brandeburg 已提交
4608 4609
	if (!test_bit(__E1000_DOWN, &adapter->flags))
		e1000_irq_enable(adapter);
L
Linus Torvalds 已提交
4610 4611
}

4612
static void e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
L
Linus Torvalds 已提交
4613
{
4614
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
4615
	struct e1000_hw *hw = &adapter->hw;
4616
	u32 vfta, index;
J
Jesse Brandeburg 已提交
4617

J
Joe Perches 已提交
4618
	if ((hw->mng_cookie.status &
J
Jesse Brandeburg 已提交
4619 4620
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
	    (vid == adapter->mng_vlan_id))
4621
		return;
J
Jiri Pirko 已提交
4622 4623 4624 4625

	if (!e1000_vlan_used(adapter))
		e1000_vlan_filter_on_off(adapter, true);

L
Linus Torvalds 已提交
4626 4627
	/* add VID to filter table */
	index = (vid >> 5) & 0x7F;
J
Joe Perches 已提交
4628
	vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
L
Linus Torvalds 已提交
4629
	vfta |= (1 << (vid & 0x1F));
J
Joe Perches 已提交
4630
	e1000_write_vfta(hw, index, vfta);
J
Jiri Pirko 已提交
4631 4632

	set_bit(vid, adapter->active_vlans);
L
Linus Torvalds 已提交
4633 4634
}

4635
static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
L
Linus Torvalds 已提交
4636
{
4637
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
4638
	struct e1000_hw *hw = &adapter->hw;
4639
	u32 vfta, index;
L
Linus Torvalds 已提交
4640

J
Jesse Brandeburg 已提交
4641 4642 4643 4644
	if (!test_bit(__E1000_DOWN, &adapter->flags))
		e1000_irq_disable(adapter);
	if (!test_bit(__E1000_DOWN, &adapter->flags))
		e1000_irq_enable(adapter);
L
Linus Torvalds 已提交
4645 4646 4647

	/* remove VID from filter table */
	index = (vid >> 5) & 0x7F;
J
Joe Perches 已提交
4648
	vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
L
Linus Torvalds 已提交
4649
	vfta &= ~(1 << (vid & 0x1F));
J
Joe Perches 已提交
4650
	e1000_write_vfta(hw, index, vfta);
J
Jiri Pirko 已提交
4651 4652 4653 4654 4655

	clear_bit(vid, adapter->active_vlans);

	if (!e1000_vlan_used(adapter))
		e1000_vlan_filter_on_off(adapter, false);
L
Linus Torvalds 已提交
4656 4657
}

4658
static void e1000_restore_vlan(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
4659
{
J
Jiri Pirko 已提交
4660
	u16 vid;
L
Linus Torvalds 已提交
4661

J
Jiri Pirko 已提交
4662 4663 4664 4665 4666 4667
	if (!e1000_vlan_used(adapter))
		return;

	e1000_vlan_filter_on_off(adapter, true);
	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
		e1000_vlan_rx_add_vid(adapter->netdev, vid);
L
Linus Torvalds 已提交
4668 4669
}

4670
int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
L
Linus Torvalds 已提交
4671
{
J
Joe Perches 已提交
4672 4673 4674
	struct e1000_hw *hw = &adapter->hw;

	hw->autoneg = 0;
L
Linus Torvalds 已提交
4675

4676 4677 4678 4679 4680
	/* Make sure dplx is at most 1 bit and lsb of speed is not set
	 * for the switch() below to work */
	if ((spd & 1) || (dplx & ~1))
		goto err_inval;

4681
	/* Fiber NICs only allow 1000 gbps Full duplex */
J
Joe Perches 已提交
4682
	if ((hw->media_type == e1000_media_type_fiber) &&
4683 4684 4685
	    spd != SPEED_1000 &&
	    dplx != DUPLEX_FULL)
		goto err_inval;
4686

4687
	switch (spd + dplx) {
L
Linus Torvalds 已提交
4688
	case SPEED_10 + DUPLEX_HALF:
J
Joe Perches 已提交
4689
		hw->forced_speed_duplex = e1000_10_half;
L
Linus Torvalds 已提交
4690 4691
		break;
	case SPEED_10 + DUPLEX_FULL:
J
Joe Perches 已提交
4692
		hw->forced_speed_duplex = e1000_10_full;
L
Linus Torvalds 已提交
4693 4694
		break;
	case SPEED_100 + DUPLEX_HALF:
J
Joe Perches 已提交
4695
		hw->forced_speed_duplex = e1000_100_half;
L
Linus Torvalds 已提交
4696 4697
		break;
	case SPEED_100 + DUPLEX_FULL:
J
Joe Perches 已提交
4698
		hw->forced_speed_duplex = e1000_100_full;
L
Linus Torvalds 已提交
4699 4700
		break;
	case SPEED_1000 + DUPLEX_FULL:
J
Joe Perches 已提交
4701 4702
		hw->autoneg = 1;
		hw->autoneg_advertised = ADVERTISE_1000_FULL;
L
Linus Torvalds 已提交
4703 4704 4705
		break;
	case SPEED_1000 + DUPLEX_HALF: /* not supported */
	default:
4706
		goto err_inval;
L
Linus Torvalds 已提交
4707 4708
	}
	return 0;
4709 4710 4711 4712

err_inval:
	e_err(probe, "Unsupported Speed/Duplex configuration\n");
	return -EINVAL;
L
Linus Torvalds 已提交
4713 4714
}

4715
static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
L
Linus Torvalds 已提交
4716 4717
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4718
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
4719
	struct e1000_hw *hw = &adapter->hw;
4720 4721
	u32 ctrl, ctrl_ext, rctl, status;
	u32 wufc = adapter->wol;
A
Auke Kok 已提交
4722
#ifdef CONFIG_PM
4723
	int retval = 0;
A
Auke Kok 已提交
4724
#endif
L
Linus Torvalds 已提交
4725 4726 4727

	netif_device_detach(netdev);

4728 4729
	if (netif_running(netdev)) {
		WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
L
Linus Torvalds 已提交
4730
		e1000_down(adapter);
4731
	}
L
Linus Torvalds 已提交
4732

4733
#ifdef CONFIG_PM
4734
	retval = pci_save_state(pdev);
4735 4736 4737 4738
	if (retval)
		return retval;
#endif

J
Joe Perches 已提交
4739
	status = er32(STATUS);
J
Jesse Brandeburg 已提交
4740
	if (status & E1000_STATUS_LU)
L
Linus Torvalds 已提交
4741 4742
		wufc &= ~E1000_WUFC_LNKC;

J
Jesse Brandeburg 已提交
4743
	if (wufc) {
L
Linus Torvalds 已提交
4744
		e1000_setup_rctl(adapter);
4745
		e1000_set_rx_mode(netdev);
L
Linus Torvalds 已提交
4746 4747

		/* turn on all-multi mode if wake on multicast is enabled */
4748
		if (wufc & E1000_WUFC_MC) {
J
Joe Perches 已提交
4749
			rctl = er32(RCTL);
L
Linus Torvalds 已提交
4750
			rctl |= E1000_RCTL_MPE;
J
Joe Perches 已提交
4751
			ew32(RCTL, rctl);
L
Linus Torvalds 已提交
4752 4753
		}

J
Joe Perches 已提交
4754 4755
		if (hw->mac_type >= e1000_82540) {
			ctrl = er32(CTRL);
L
Linus Torvalds 已提交
4756 4757 4758 4759 4760 4761
			/* advertise wake from D3Cold */
			#define E1000_CTRL_ADVD3WUC 0x00100000
			/* phy power management enable */
			#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
			ctrl |= E1000_CTRL_ADVD3WUC |
				E1000_CTRL_EN_PHY_PWR_MGMT;
J
Joe Perches 已提交
4762
			ew32(CTRL, ctrl);
L
Linus Torvalds 已提交
4763 4764
		}

J
Joe Perches 已提交
4765
		if (hw->media_type == e1000_media_type_fiber ||
4766
		    hw->media_type == e1000_media_type_internal_serdes) {
L
Linus Torvalds 已提交
4767
			/* keep the laser running in D3 */
J
Joe Perches 已提交
4768
			ctrl_ext = er32(CTRL_EXT);
L
Linus Torvalds 已提交
4769
			ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
J
Joe Perches 已提交
4770
			ew32(CTRL_EXT, ctrl_ext);
L
Linus Torvalds 已提交
4771 4772
		}

J
Joe Perches 已提交
4773 4774
		ew32(WUC, E1000_WUC_PME_EN);
		ew32(WUFC, wufc);
L
Linus Torvalds 已提交
4775
	} else {
J
Joe Perches 已提交
4776 4777
		ew32(WUC, 0);
		ew32(WUFC, 0);
L
Linus Torvalds 已提交
4778 4779
	}

4780 4781
	e1000_release_manageability(adapter);

4782 4783
	*enable_wake = !!wufc;

4784
	/* make sure adapter isn't asleep if manageability is enabled */
4785 4786
	if (adapter->en_mng_pt)
		*enable_wake = true;
L
Linus Torvalds 已提交
4787

4788 4789 4790
	if (netif_running(netdev))
		e1000_free_irq(adapter);

L
Linus Torvalds 已提交
4791
	pci_disable_device(pdev);
4792

L
Linus Torvalds 已提交
4793 4794 4795
	return 0;
}

4796
#ifdef CONFIG_PM
4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
{
	int retval;
	bool wake;

	retval = __e1000_shutdown(pdev, &wake);
	if (retval)
		return retval;

	if (wake) {
		pci_prepare_to_sleep(pdev);
	} else {
		pci_wake_from_d3(pdev, false);
		pci_set_power_state(pdev, PCI_D3hot);
	}

	return 0;
}

4816
static int e1000_resume(struct pci_dev *pdev)
L
Linus Torvalds 已提交
4817 4818
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4819
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
4820
	struct e1000_hw *hw = &adapter->hw;
4821
	u32 err;
L
Linus Torvalds 已提交
4822

4823
	pci_set_power_state(pdev, PCI_D0);
4824
	pci_restore_state(pdev);
4825
	pci_save_state(pdev);
T
Taku Izumi 已提交
4826 4827 4828 4829 4830

	if (adapter->need_ioport)
		err = pci_enable_device(pdev);
	else
		err = pci_enable_device_mem(pdev);
4831
	if (err) {
4832
		pr_err("Cannot enable PCI device from suspend\n");
4833 4834
		return err;
	}
4835
	pci_set_master(pdev);
L
Linus Torvalds 已提交
4836

4837 4838
	pci_enable_wake(pdev, PCI_D3hot, 0);
	pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
4839

4840 4841 4842 4843 4844
	if (netif_running(netdev)) {
		err = e1000_request_irq(adapter);
		if (err)
			return err;
	}
4845 4846

	e1000_power_up_phy(adapter);
L
Linus Torvalds 已提交
4847
	e1000_reset(adapter);
J
Joe Perches 已提交
4848
	ew32(WUS, ~0);
L
Linus Torvalds 已提交
4849

4850 4851
	e1000_init_manageability(adapter);

J
Jesse Brandeburg 已提交
4852
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4853 4854 4855 4856 4857 4858 4859
		e1000_up(adapter);

	netif_device_attach(netdev);

	return 0;
}
#endif
4860 4861 4862

static void e1000_shutdown(struct pci_dev *pdev)
{
4863 4864 4865 4866 4867 4868 4869 4870
	bool wake;

	__e1000_shutdown(pdev, &wake);

	if (system_state == SYSTEM_POWER_OFF) {
		pci_wake_from_d3(pdev, wake);
		pci_set_power_state(pdev, PCI_D3hot);
	}
4871 4872
}

L
Linus Torvalds 已提交
4873 4874 4875 4876 4877 4878
#ifdef CONFIG_NET_POLL_CONTROLLER
/*
 * Polling 'interrupt' - used by things like netconsole to send skbs
 * without having to re-enable interrupts. It's not called while
 * the interrupt routine is executing.
 */
4879
static void e1000_netpoll(struct net_device *netdev)
L
Linus Torvalds 已提交
4880
{
4881
	struct e1000_adapter *adapter = netdev_priv(netdev);
4882

L
Linus Torvalds 已提交
4883
	disable_irq(adapter->pdev->irq);
4884
	e1000_intr(adapter->pdev->irq, netdev);
L
Linus Torvalds 已提交
4885 4886 4887 4888
	enable_irq(adapter->pdev->irq);
}
#endif

A
Auke Kok 已提交
4889 4890 4891
/**
 * e1000_io_error_detected - called when PCI error is detected
 * @pdev: Pointer to PCI device
4892
 * @state: The current pci connection state
A
Auke Kok 已提交
4893 4894 4895 4896
 *
 * This function is called after a PCI bus error affecting
 * this device has been detected.
 */
4897 4898
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
						pci_channel_state_t state)
A
Auke Kok 已提交
4899 4900
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4901
	struct e1000_adapter *adapter = netdev_priv(netdev);
A
Auke Kok 已提交
4902 4903 4904

	netif_device_detach(netdev);

4905 4906 4907
	if (state == pci_channel_io_perm_failure)
		return PCI_ERS_RESULT_DISCONNECT;

A
Auke Kok 已提交
4908 4909
	if (netif_running(netdev))
		e1000_down(adapter);
4910
	pci_disable_device(pdev);
A
Auke Kok 已提交
4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925

	/* Request a slot slot reset. */
	return PCI_ERS_RESULT_NEED_RESET;
}

/**
 * e1000_io_slot_reset - called after the pci bus has been reset.
 * @pdev: Pointer to PCI device
 *
 * Restart the card from scratch, as if from a cold-boot. Implementation
 * resembles the first-half of the e1000_resume routine.
 */
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4926
	struct e1000_adapter *adapter = netdev_priv(netdev);
J
Joe Perches 已提交
4927
	struct e1000_hw *hw = &adapter->hw;
T
Taku Izumi 已提交
4928
	int err;
A
Auke Kok 已提交
4929

T
Taku Izumi 已提交
4930 4931 4932 4933 4934
	if (adapter->need_ioport)
		err = pci_enable_device(pdev);
	else
		err = pci_enable_device_mem(pdev);
	if (err) {
4935
		pr_err("Cannot re-enable PCI device after reset.\n");
A
Auke Kok 已提交
4936 4937 4938 4939
		return PCI_ERS_RESULT_DISCONNECT;
	}
	pci_set_master(pdev);

4940 4941
	pci_enable_wake(pdev, PCI_D3hot, 0);
	pci_enable_wake(pdev, PCI_D3cold, 0);
A
Auke Kok 已提交
4942 4943

	e1000_reset(adapter);
J
Joe Perches 已提交
4944
	ew32(WUS, ~0);
A
Auke Kok 已提交
4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959

	return PCI_ERS_RESULT_RECOVERED;
}

/**
 * e1000_io_resume - called when traffic can start flowing again.
 * @pdev: Pointer to PCI device
 *
 * This callback is called when the error recovery driver tells us that
 * its OK to resume normal operation. Implementation resembles the
 * second-half of the e1000_resume routine.
 */
static void e1000_io_resume(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4960
	struct e1000_adapter *adapter = netdev_priv(netdev);
4961 4962

	e1000_init_manageability(adapter);
A
Auke Kok 已提交
4963 4964 4965

	if (netif_running(netdev)) {
		if (e1000_up(adapter)) {
4966
			pr_info("can't bring device back up after reset\n");
A
Auke Kok 已提交
4967 4968 4969 4970 4971 4972 4973
			return;
		}
	}

	netif_device_attach(netdev);
}

L
Linus Torvalds 已提交
4974
/* e1000_main.c */