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

  
4
  Copyright(c) 1999 - 2006 Intel Corporation. All rights reserved.
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
  
  This program is free software; you can redistribute it and/or modify it 
  under the terms of the GNU General Public License as published by the Free 
  Software Foundation; either version 2 of the License, or (at your option) 
  any later version.
  
  This program is distributed in the hope that 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 
  more details.
  
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59 
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  
  The full GNU General Public License is included in this distribution in the
  file called LICENSE.
  
  Contact Information:
  Linux NICS <linux.nics@intel.com>
25
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
L
Linus Torvalds 已提交
26 27 28 29 30 31 32
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

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

#include "e1000.h"

char e1000_driver_name[] = "e1000";
33
static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
L
Linus Torvalds 已提交
34 35 36 37 38
#ifndef CONFIG_E1000_NAPI
#define DRIVERNAPI
#else
#define DRIVERNAPI "-NAPI"
#endif
A
Auke Kok 已提交
39
#define DRV_VERSION "7.0.38-k4"DRIVERNAPI
L
Linus Torvalds 已提交
40
char e1000_driver_version[] = DRV_VERSION;
41
static char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
L
Linus Torvalds 已提交
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

/* e1000_pci_tbl - PCI Device ID Table
 *
 * Last entry must be all 0s
 *
 * Macro expands to...
 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
 */
static struct pci_device_id e1000_pci_tbl[] = {
	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),
70
	INTEL_E1000_ETHERNET_DEVICE(0x101A),
L
Linus Torvalds 已提交
71 72 73 74 75
	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),
76 77 78
	INTEL_E1000_ETHERNET_DEVICE(0x105E),
	INTEL_E1000_ETHERNET_DEVICE(0x105F),
	INTEL_E1000_ETHERNET_DEVICE(0x1060),
L
Linus Torvalds 已提交
79 80 81 82 83 84 85 86
	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),
87 88 89
	INTEL_E1000_ETHERNET_DEVICE(0x107D),
	INTEL_E1000_ETHERNET_DEVICE(0x107E),
	INTEL_E1000_ETHERNET_DEVICE(0x107F),
L
Linus Torvalds 已提交
90
	INTEL_E1000_ETHERNET_DEVICE(0x108A),
91 92
	INTEL_E1000_ETHERNET_DEVICE(0x108B),
	INTEL_E1000_ETHERNET_DEVICE(0x108C),
93 94
	INTEL_E1000_ETHERNET_DEVICE(0x1096),
	INTEL_E1000_ETHERNET_DEVICE(0x1098),
95
	INTEL_E1000_ETHERNET_DEVICE(0x1099),
96
	INTEL_E1000_ETHERNET_DEVICE(0x109A),
97
	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
98
	INTEL_E1000_ETHERNET_DEVICE(0x10B9),
L
Linus Torvalds 已提交
99 100 101 102 103 104
	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

105
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
106
                                    struct e1000_tx_ring *txdr);
107
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
108
                                    struct e1000_rx_ring *rxdr);
109
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
110
                                    struct e1000_tx_ring *tx_ring);
111
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
112
                                    struct e1000_rx_ring *rx_ring);
L
Linus Torvalds 已提交
113 114 115 116 117 118 119

/* Local Function Prototypes */

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);
L
Linus Torvalds 已提交
133 134 135 136 137 138 139 140 141 142
static void e1000_set_multi(struct net_device *netdev);
static void e1000_update_phy_info(unsigned long data);
static void e1000_watchdog(unsigned long data);
static void e1000_watchdog_task(struct e1000_adapter *adapter);
static void e1000_82547_tx_fifo_stall(unsigned long data);
static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
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);
static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
143 144
static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,
                                    struct e1000_tx_ring *tx_ring);
L
Linus Torvalds 已提交
145
#ifdef CONFIG_E1000_NAPI
146
static int e1000_clean(struct net_device *poll_dev, int *budget);
L
Linus Torvalds 已提交
147
static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
148
                                    struct e1000_rx_ring *rx_ring,
L
Linus Torvalds 已提交
149
                                    int *work_done, int work_to_do);
150
static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
151
                                       struct e1000_rx_ring *rx_ring,
152
                                       int *work_done, int work_to_do);
L
Linus Torvalds 已提交
153
#else
154 155 156 157
static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
                                    struct e1000_rx_ring *rx_ring);
static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                                       struct e1000_rx_ring *rx_ring);
L
Linus Torvalds 已提交
158
#endif
159
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
160 161
                                   struct e1000_rx_ring *rx_ring,
				   int cleaned_count);
162
static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
163 164
                                      struct e1000_rx_ring *rx_ring,
				      int cleaned_count);
L
Linus Torvalds 已提交
165 166 167 168 169 170
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);
171
static void e1000_reset_task(struct net_device *dev);
L
Linus Torvalds 已提交
172
static void e1000_smartspeed(struct e1000_adapter *adapter);
173 174
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
                                       struct sk_buff *skb);
L
Linus Torvalds 已提交
175 176 177 178 179 180 181

static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
static void e1000_restore_vlan(struct e1000_adapter *adapter);

#ifdef CONFIG_PM
182
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
L
Linus Torvalds 已提交
183 184
static int e1000_resume(struct pci_dev *pdev);
#endif
185
static void e1000_shutdown(struct pci_dev *pdev);
L
Linus Torvalds 已提交
186 187 188 189 190 191

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

A
Auke Kok 已提交
192 193 194 195 196 197 198 199 200 201
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,
};
202

L
Linus Torvalds 已提交
203 204 205 206 207 208 209 210
static struct pci_driver e1000_driver = {
	.name     = e1000_driver_name,
	.id_table = e1000_pci_tbl,
	.probe    = e1000_probe,
	.remove   = __devexit_p(e1000_remove),
	/* Power Managment Hooks */
#ifdef CONFIG_PM
	.suspend  = e1000_suspend,
211
	.resume   = e1000_resume,
L
Linus Torvalds 已提交
212
#endif
A
Auke Kok 已提交
213 214
	.shutdown = e1000_shutdown,
	.err_handler = &e1000_err_handler
L
Linus Torvalds 已提交
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
};

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)");

/**
 * 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.
 **/

static int __init
e1000_init_module(void)
{
	int ret;
	printk(KERN_INFO "%s - version %s\n",
	       e1000_driver_string, e1000_driver_version);

	printk(KERN_INFO "%s\n", e1000_copyright);

	ret = pci_module_init(&e1000_driver);
243

L
Linus Torvalds 已提交
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
	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.
 **/

static void __exit
e1000_exit_module(void)
{
	pci_unregister_driver(&e1000_driver);
}

module_exit(e1000_exit_module);

/**
 * e1000_irq_disable - Mask off interrupt generation on the NIC
 * @adapter: board private structure
 **/

269
static void
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280 281 282
e1000_irq_disable(struct e1000_adapter *adapter)
{
	atomic_inc(&adapter->irq_sem);
	E1000_WRITE_REG(&adapter->hw, IMC, ~0);
	E1000_WRITE_FLUSH(&adapter->hw);
	synchronize_irq(adapter->pdev->irq);
}

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

283
static void
L
Linus Torvalds 已提交
284 285
e1000_irq_enable(struct e1000_adapter *adapter)
{
J
Jesse Brandeburg 已提交
286
	if (likely(atomic_dec_and_test(&adapter->irq_sem))) {
L
Linus Torvalds 已提交
287 288 289 290
		E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
		E1000_WRITE_FLUSH(&adapter->hw);
	}
}
291 292

static void
293 294 295 296 297
e1000_update_mng_vlan(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	uint16_t vid = adapter->hw.mng_cookie.vlan_id;
	uint16_t old_vid = adapter->mng_vlan_id;
J
Jesse Brandeburg 已提交
298 299 300
	if (adapter->vlgrp) {
		if (!adapter->vlgrp->vlan_devices[vid]) {
			if (adapter->hw.mng_cookie.status &
301 302 303 304 305
				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
				e1000_vlan_rx_add_vid(netdev, vid);
				adapter->mng_vlan_id = vid;
			} else
				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
J
Jesse Brandeburg 已提交
306 307 308

			if ((old_vid != (uint16_t)E1000_MNG_VLAN_NONE) &&
					(vid != old_vid) &&
309 310
					!adapter->vlgrp->vlan_devices[old_vid])
				e1000_vlan_rx_kill_vid(netdev, old_vid);
311 312
		} else
			adapter->mng_vlan_id = vid;
313 314
	}
}
315 316 317 318 319 320 321 322 323

/**
 * e1000_release_hw_control - release control of the h/w to f/w
 * @adapter: address of board private structure
 *
 * e1000_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
 * For ASF and Pass Through versions of f/w this means that the
 * driver is no longer loaded. For AMT version (only with 82573) i
 * of the f/w this means that the netowrk i/f is closed.
324
 *
325 326
 **/

327
static void
328 329 330 331 332 333 334 335 336
e1000_release_hw_control(struct e1000_adapter *adapter)
{
	uint32_t ctrl_ext;
	uint32_t swsm;

	/* Let firmware taken over control of h/w */
	switch (adapter->hw.mac_type) {
	case e1000_82571:
	case e1000_82572:
337
	case e1000_80003es2lan:
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
		break;
	case e1000_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm & ~E1000_SWSM_DRV_LOAD);
	default:
		break;
	}
}

/**
 * e1000_get_hw_control - get control of the h/w from f/w
 * @adapter: address of board private structure
 *
 * e1000_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
356 357
 * For ASF and Pass Through versions of f/w this means that
 * the driver is loaded. For AMT version (only with 82573)
358
 * of the f/w this means that the netowrk i/f is open.
359
 *
360 361
 **/

362
static void
363 364 365 366 367 368 369 370
e1000_get_hw_control(struct e1000_adapter *adapter)
{
	uint32_t ctrl_ext;
	uint32_t swsm;
	/* Let firmware know the driver has taken over */
	switch (adapter->hw.mac_type) {
	case e1000_82571:
	case e1000_82572:
371
	case e1000_80003es2lan:
372 373 374 375 376 377 378 379 380 381 382 383 384 385
		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
		break;
	case e1000_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm | E1000_SWSM_DRV_LOAD);
		break;
	default:
		break;
	}
}

L
Linus Torvalds 已提交
386 387 388 389
int
e1000_up(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
390
	int i, err;
L
Linus Torvalds 已提交
391 392 393 394

	/* hardware has been reset, we need to reload some things */

	/* Reset the PHY if it was previously powered down */
J
Jesse Brandeburg 已提交
395
	if (adapter->hw.media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
396 397
		uint16_t mii_reg;
		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
J
Jesse Brandeburg 已提交
398
		if (mii_reg & MII_CR_POWER_DOWN)
399
			e1000_phy_hw_reset(&adapter->hw);
L
Linus Torvalds 已提交
400 401 402 403 404 405 406 407 408
	}

	e1000_set_multi(netdev);

	e1000_restore_vlan(adapter);

	e1000_configure_tx(adapter);
	e1000_setup_rctl(adapter);
	e1000_configure_rx(adapter);
409 410 411
	/* call E1000_DESC_UNUSED which always leaves
	 * at least 1 descriptor unused to make sure
	 * next_to_use != next_to_clean */
412
	for (i = 0; i < adapter->num_rx_queues; i++) {
413
		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
414 415
		adapter->alloc_rx_buf(adapter, ring,
		                      E1000_DESC_UNUSED(ring));
416
	}
L
Linus Torvalds 已提交
417

418
#ifdef CONFIG_PCI_MSI
J
Jesse Brandeburg 已提交
419
	if (adapter->hw.mac_type > e1000_82547_rev_2) {
420
		adapter->have_msi = TRUE;
J
Jesse Brandeburg 已提交
421
		if ((err = pci_enable_msi(adapter->pdev))) {
422 423 424 425 426 427
			DPRINTK(PROBE, ERR,
			 "Unable to allocate MSI interrupt Error: %d\n", err);
			adapter->have_msi = FALSE;
		}
	}
#endif
J
Jesse Brandeburg 已提交
428
	if ((err = request_irq(adapter->pdev->irq, &e1000_intr,
L
Linus Torvalds 已提交
429
		              SA_SHIRQ | SA_SAMPLE_RANDOM,
430 431 432
		              netdev->name, netdev))) {
		DPRINTK(PROBE, ERR,
		    "Unable to allocate interrupt Error: %d\n", err);
L
Linus Torvalds 已提交
433
		return err;
434
	}
L
Linus Torvalds 已提交
435

436 437
	adapter->tx_queue_len = netdev->tx_queue_len;

L
Linus Torvalds 已提交
438 439 440 441 442
	mod_timer(&adapter->watchdog_timer, jiffies);

#ifdef CONFIG_E1000_NAPI
	netif_poll_enable(netdev);
#endif
443 444
	e1000_irq_enable(adapter);

L
Linus Torvalds 已提交
445 446 447 448 449 450 451
	return 0;
}

void
e1000_down(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
452 453
	boolean_t mng_mode_enabled = (adapter->hw.mac_type >= e1000_82571) &&
				     e1000_check_mng_mode(&adapter->hw);
L
Linus Torvalds 已提交
454 455

	e1000_irq_disable(adapter);
456

L
Linus Torvalds 已提交
457
	free_irq(adapter->pdev->irq, netdev);
458
#ifdef CONFIG_PCI_MSI
J
Jesse Brandeburg 已提交
459
	if (adapter->hw.mac_type > e1000_82547_rev_2 &&
460 461 462
	   adapter->have_msi == TRUE)
		pci_disable_msi(adapter->pdev);
#endif
L
Linus Torvalds 已提交
463 464 465 466 467 468 469
	del_timer_sync(&adapter->tx_fifo_stall_timer);
	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

#ifdef CONFIG_E1000_NAPI
	netif_poll_disable(netdev);
#endif
470
	netdev->tx_queue_len = adapter->tx_queue_len;
L
Linus Torvalds 已提交
471 472 473 474 475 476
	adapter->link_speed = 0;
	adapter->link_duplex = 0;
	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	e1000_reset(adapter);
477 478
	e1000_clean_all_tx_rings(adapter);
	e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
479

480 481 482 483 484 485
	/* Power down the PHY so no link is implied when interface is down *
	 * The PHY cannot be powered down if any of the following is TRUE *
	 * (a) WoL is enabled
	 * (b) AMT is active
	 * (c) SoL/IDER session is active */
	if (!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&
486
	   adapter->hw.media_type == e1000_media_type_copper &&
487 488 489
	   !(E1000_READ_REG(&adapter->hw, MANC) & E1000_MANC_SMBUS_EN) &&
	   !mng_mode_enabled &&
	   !e1000_check_phy_reset_block(&adapter->hw)) {
L
Linus Torvalds 已提交
490 491 492 493
		uint16_t mii_reg;
		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
		mii_reg |= MII_CR_POWER_DOWN;
		e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);
494
		mdelay(1);
L
Linus Torvalds 已提交
495 496 497 498 499 500
	}
}

void
e1000_reset(struct e1000_adapter *adapter)
{
501
	uint32_t pba, manc;
502
	uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
L
Linus Torvalds 已提交
503 504 505 506 507

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

508 509
	switch (adapter->hw.mac_type) {
	case e1000_82547:
510
	case e1000_82547_rev_2:
511 512
		pba = E1000_PBA_30K;
		break;
513 514
	case e1000_82571:
	case e1000_82572:
515
	case e1000_80003es2lan:
516 517
		pba = E1000_PBA_38K;
		break;
518 519 520 521 522 523 524 525
	case e1000_82573:
		pba = E1000_PBA_12K;
		break;
	default:
		pba = E1000_PBA_48K;
		break;
	}

J
Jesse Brandeburg 已提交
526
	if ((adapter->hw.mac_type != e1000_82573) &&
527
	   (adapter->netdev->mtu > E1000_RXBUFFER_8192))
528
		pba -= 8; /* allocate more FIFO for Tx */
529 530


J
Jesse Brandeburg 已提交
531
	if (adapter->hw.mac_type == e1000_82547) {
L
Linus Torvalds 已提交
532 533 534 535 536 537
		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);
	}
538

L
Linus Torvalds 已提交
539 540 541
	E1000_WRITE_REG(&adapter->hw, PBA, pba);

	/* flow control settings */
542 543 544 545 546 547
	/* Set the FC high water mark to 90% of the FIFO size.
	 * Required to clear last 3 LSB */
	fc_high_water_mark = ((pba * 9216)/10) & 0xFFF8;

	adapter->hw.fc_high_water = fc_high_water_mark;
	adapter->hw.fc_low_water = fc_high_water_mark - 8;
548 549 550 551
	if (adapter->hw.mac_type == e1000_80003es2lan)
		adapter->hw.fc_pause_time = 0xFFFF;
	else
		adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
L
Linus Torvalds 已提交
552 553 554
	adapter->hw.fc_send_xon = 1;
	adapter->hw.fc = adapter->hw.original_fc;

555
	/* Allow time for pending master requests to run */
L
Linus Torvalds 已提交
556
	e1000_reset_hw(&adapter->hw);
J
Jesse Brandeburg 已提交
557
	if (adapter->hw.mac_type >= e1000_82544)
L
Linus Torvalds 已提交
558
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
J
Jesse Brandeburg 已提交
559
	if (e1000_init_hw(&adapter->hw))
L
Linus Torvalds 已提交
560
		DPRINTK(PROBE, ERR, "Hardware Error\n");
561
	e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
562 563 564 565 566
	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
	E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);

	e1000_reset_adaptive(&adapter->hw);
	e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
567 568 569 570 571
	if (adapter->en_mng_pt) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
		manc |= (E1000_MANC_ARP_EN | E1000_MANC_EN_MNG2HOST);
		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}
L
Linus Torvalds 已提交
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
}

/**
 * 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.
 **/

static int __devinit
e1000_probe(struct pci_dev *pdev,
            const struct pci_device_id *ent)
{
	struct net_device *netdev;
	struct e1000_adapter *adapter;
592 593
	unsigned long mmio_start, mmio_len;

L
Linus Torvalds 已提交
594
	static int cards_found = 0;
J
Jeff Kirsher 已提交
595
	static int e1000_ksp3_port_a = 0; /* global ksp3 port a indication */
596
	int i, err, pci_using_dac;
L
Linus Torvalds 已提交
597 598
	uint16_t eeprom_data;
	uint16_t eeprom_apme_mask = E1000_EEPROM_APME;
J
Jesse Brandeburg 已提交
599
	if ((err = pci_enable_device(pdev)))
L
Linus Torvalds 已提交
600 601
		return err;

J
Jesse Brandeburg 已提交
602
	if (!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
L
Linus Torvalds 已提交
603 604
		pci_using_dac = 1;
	} else {
J
Jesse Brandeburg 已提交
605
		if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
L
Linus Torvalds 已提交
606 607 608 609 610 611
			E1000_ERR("No usable DMA configuration, aborting\n");
			return err;
		}
		pci_using_dac = 0;
	}

J
Jesse Brandeburg 已提交
612
	if ((err = pci_request_regions(pdev, e1000_driver_name)))
L
Linus Torvalds 已提交
613 614 615 616 617
		return err;

	pci_set_master(pdev);

	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
J
Jesse Brandeburg 已提交
618
	if (!netdev) {
L
Linus Torvalds 已提交
619 620 621 622 623 624 625 626
		err = -ENOMEM;
		goto err_alloc_etherdev;
	}

	SET_MODULE_OWNER(netdev);
	SET_NETDEV_DEV(netdev, &pdev->dev);

	pci_set_drvdata(pdev, netdev);
627
	adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
628 629 630 631 632 633 634 635 636
	adapter->netdev = netdev;
	adapter->pdev = pdev;
	adapter->hw.back = adapter;
	adapter->msg_enable = (1 << debug) - 1;

	mmio_start = pci_resource_start(pdev, BAR_0);
	mmio_len = pci_resource_len(pdev, BAR_0);

	adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
J
Jesse Brandeburg 已提交
637
	if (!adapter->hw.hw_addr) {
L
Linus Torvalds 已提交
638 639 640 641
		err = -EIO;
		goto err_ioremap;
	}

J
Jesse Brandeburg 已提交
642 643
	for (i = BAR_1; i <= BAR_5; i++) {
		if (pci_resource_len(pdev, i) == 0)
L
Linus Torvalds 已提交
644
			continue;
J
Jesse Brandeburg 已提交
645
		if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
L
Linus Torvalds 已提交
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
			adapter->hw.io_base = pci_resource_start(pdev, i);
			break;
		}
	}

	netdev->open = &e1000_open;
	netdev->stop = &e1000_close;
	netdev->hard_start_xmit = &e1000_xmit_frame;
	netdev->get_stats = &e1000_get_stats;
	netdev->set_multicast_list = &e1000_set_multi;
	netdev->set_mac_address = &e1000_set_mac;
	netdev->change_mtu = &e1000_change_mtu;
	netdev->do_ioctl = &e1000_ioctl;
	e1000_set_ethtool_ops(netdev);
	netdev->tx_timeout = &e1000_tx_timeout;
	netdev->watchdog_timeo = 5 * HZ;
#ifdef CONFIG_E1000_NAPI
	netdev->poll = &e1000_clean;
	netdev->weight = 64;
#endif
	netdev->vlan_rx_register = e1000_vlan_rx_register;
	netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
	netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
#ifdef CONFIG_NET_POLL_CONTROLLER
	netdev->poll_controller = e1000_netpoll;
#endif
	strcpy(netdev->name, pci_name(pdev));

	netdev->mem_start = mmio_start;
	netdev->mem_end = mmio_start + mmio_len;
	netdev->base_addr = adapter->hw.io_base;

	adapter->bd_number = cards_found;

	/* setup the private structure */

J
Jesse Brandeburg 已提交
682
	if ((err = e1000_sw_init(adapter)))
L
Linus Torvalds 已提交
683 684
		goto err_sw_init;

J
Jesse Brandeburg 已提交
685
	if ((err = e1000_check_phy_reset_block(&adapter->hw)))
686 687
		DPRINTK(PROBE, INFO, "PHY reset is blocked due to SOL/IDER session.\n");

J
Jeff Kirsher 已提交
688
	/* if ksp3, indicate if it's port a being setup */
689 690
	if (pdev->device == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3 &&
			e1000_ksp3_port_a == 0)
J
Jeff Kirsher 已提交
691 692 693 694 695 696
		adapter->ksp3_port_a = 1;
	e1000_ksp3_port_a++;
	/* Reset for multiple KP3 adapters */
	if (e1000_ksp3_port_a == 4)
		e1000_ksp3_port_a = 0;

J
Jesse Brandeburg 已提交
697
	if (adapter->hw.mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
698 699 700 701 702 703 704 705
		netdev->features = NETIF_F_SG |
				   NETIF_F_HW_CSUM |
				   NETIF_F_HW_VLAN_TX |
				   NETIF_F_HW_VLAN_RX |
				   NETIF_F_HW_VLAN_FILTER;
	}

#ifdef NETIF_F_TSO
J
Jesse Brandeburg 已提交
706
	if ((adapter->hw.mac_type >= e1000_82544) &&
L
Linus Torvalds 已提交
707 708
	   (adapter->hw.mac_type != e1000_82547))
		netdev->features |= NETIF_F_TSO;
709 710

#ifdef NETIF_F_TSO_IPV6
J
Jesse Brandeburg 已提交
711
	if (adapter->hw.mac_type > e1000_82547_rev_2)
712 713
		netdev->features |= NETIF_F_TSO_IPV6;
#endif
L
Linus Torvalds 已提交
714
#endif
J
Jesse Brandeburg 已提交
715
	if (pci_using_dac)
L
Linus Torvalds 已提交
716 717
		netdev->features |= NETIF_F_HIGHDMA;

718 719 720
	/* hard_start_xmit is safe against parallel locking */
	netdev->features |= NETIF_F_LLTX;

721 722
	adapter->en_mng_pt = e1000_enable_mng_pass_thru(&adapter->hw);

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

L
Linus Torvalds 已提交
726 727 728 729
	e1000_reset_hw(&adapter->hw);

	/* make sure the EEPROM is good */

J
Jesse Brandeburg 已提交
730
	if (e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
L
Linus Torvalds 已提交
731 732 733 734 735 736 737
		DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
		err = -EIO;
		goto err_eeprom;
	}

	/* copy the MAC address out of the EEPROM */

J
Jesse Brandeburg 已提交
738
	if (e1000_read_mac_addr(&adapter->hw))
L
Linus Torvalds 已提交
739 740
		DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
	memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
741
	memcpy(netdev->perm_addr, adapter->hw.mac_addr, netdev->addr_len);
L
Linus Torvalds 已提交
742

J
Jesse Brandeburg 已提交
743
	if (!is_valid_ether_addr(netdev->perm_addr)) {
L
Linus Torvalds 已提交
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
		DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
		err = -EIO;
		goto err_eeprom;
	}

	e1000_read_part_num(&adapter->hw, &(adapter->part_num));

	e1000_get_bus_info(&adapter->hw);

	init_timer(&adapter->tx_fifo_stall_timer);
	adapter->tx_fifo_stall_timer.function = &e1000_82547_tx_fifo_stall;
	adapter->tx_fifo_stall_timer.data = (unsigned long) adapter;

	init_timer(&adapter->watchdog_timer);
	adapter->watchdog_timer.function = &e1000_watchdog;
	adapter->watchdog_timer.data = (unsigned long) adapter;

	INIT_WORK(&adapter->watchdog_task,
		(void (*)(void *))e1000_watchdog_task, adapter);

	init_timer(&adapter->phy_info_timer);
	adapter->phy_info_timer.function = &e1000_update_phy_info;
	adapter->phy_info_timer.data = (unsigned long) adapter;

768 769
	INIT_WORK(&adapter->reset_task,
		(void (*)(void *))e1000_reset_task, netdev);
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778 779 780 781 782

	/* we're going to reset, so assume we have no link for now */

	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	e1000_check_options(adapter);

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

J
Jesse Brandeburg 已提交
783
	switch (adapter->hw.mac_type) {
L
Linus Torvalds 已提交
784 785 786 787 788 789 790 791 792 793 794
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
	case e1000_82543:
		break;
	case e1000_82544:
		e1000_read_eeprom(&adapter->hw,
			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
		eeprom_apme_mask = E1000_EEPROM_82544_APM;
		break;
	case e1000_82546:
	case e1000_82546_rev_3:
J
Jeff Kirsher 已提交
795
	case e1000_82571:
796
	case e1000_80003es2lan:
J
Jesse Brandeburg 已提交
797
		if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1){
L
Linus Torvalds 已提交
798 799 800 801 802 803 804 805 806 807
			e1000_read_eeprom(&adapter->hw,
				EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
			break;
		}
		/* Fall Through */
	default:
		e1000_read_eeprom(&adapter->hw,
			EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
		break;
	}
J
Jesse Brandeburg 已提交
808
	if (eeprom_data & eeprom_apme_mask)
L
Linus Torvalds 已提交
809 810
		adapter->wol |= E1000_WUFC_MAG;

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
	/* print bus type/speed/width info */
	{
	struct e1000_hw *hw = &adapter->hw;
	DPRINTK(PROBE, INFO, "(PCI%s:%s:%s) ",
		((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
		 (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
		((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
		 (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
		 (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
		 (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
		 (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
		((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
		 (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
		 (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
		 "32-bit"));
	}

	for (i = 0; i < 6; i++)
		printk("%2.2x%c", netdev->dev_addr[i], i == 5 ? '\n' : ':');

L
Linus Torvalds 已提交
831 832 833
	/* reset the hardware with the new settings */
	e1000_reset(adapter);

834 835 836 837 838 839 840
	/* If the controller is 82573 and f/w is AMT, do not set
	 * DRV_LOAD until the interface is up.  For all other cases,
	 * let the f/w know that the h/w is now under the control
	 * of the driver. */
	if (adapter->hw.mac_type != e1000_82573 ||
	    !e1000_check_mng_mode(&adapter->hw))
		e1000_get_hw_control(adapter);
841

L
Linus Torvalds 已提交
842
	strcpy(netdev->name, "eth%d");
J
Jesse Brandeburg 已提交
843
	if ((err = register_netdev(netdev)))
L
Linus Torvalds 已提交
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
		goto err_register;

	DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");

	cards_found++;
	return 0;

err_register:
err_sw_init:
err_eeprom:
	iounmap(adapter->hw.hw_addr);
err_ioremap:
	free_netdev(netdev);
err_alloc_etherdev:
	pci_release_regions(pdev);
	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.
 **/

static void __devexit
e1000_remove(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
876
	struct e1000_adapter *adapter = netdev_priv(netdev);
877
	uint32_t manc;
878 879 880
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
881

J
Jeff Garzik 已提交
882 883
	flush_scheduled_work();

J
Jesse Brandeburg 已提交
884
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
885 886
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
J
Jesse Brandeburg 已提交
887
		if (manc & E1000_MANC_SMBUS_EN) {
L
Linus Torvalds 已提交
888 889 890 891 892
			manc |= E1000_MANC_ARP_EN;
			E1000_WRITE_REG(&adapter->hw, MANC, manc);
		}
	}

893 894 895
	/* Release control of h/w to f/w.  If f/w is AMT enabled, this
	 * would have already happened in close and is redundant. */
	e1000_release_hw_control(adapter);
896

L
Linus Torvalds 已提交
897
	unregister_netdev(netdev);
898
#ifdef CONFIG_E1000_NAPI
899
	for (i = 0; i < adapter->num_rx_queues; i++)
900
		dev_put(&adapter->polling_netdev[i]);
901
#endif
L
Linus Torvalds 已提交
902

J
Jesse Brandeburg 已提交
903
	if (!e1000_check_phy_reset_block(&adapter->hw))
904
		e1000_phy_hw_reset(&adapter->hw);
L
Linus Torvalds 已提交
905

906 907 908 909 910 911
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
#ifdef CONFIG_E1000_NAPI
	kfree(adapter->polling_netdev);
#endif

L
Linus Torvalds 已提交
912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
	iounmap(adapter->hw.hw_addr);
	pci_release_regions(pdev);

	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.
 * Fields are initialized based on PCI device information and
 * OS network device settings (MTU size).
 **/

static int __devinit
e1000_sw_init(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
935 936 937
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
938 939 940 941 942 943 944 945 946 947 948 949

	/* 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;

	pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);

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

950 951
	adapter->rx_buffer_len = MAXIMUM_ETHERNET_FRAME_SIZE;
	adapter->rx_ps_bsize0 = E1000_RXBUFFER_128;
L
Linus Torvalds 已提交
952 953 954 955 956 957
	hw->max_frame_size = netdev->mtu +
			     ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
	hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;

	/* identify the MAC */

J
Jesse Brandeburg 已提交
958
	if (e1000_set_mac_type(hw)) {
L
Linus Torvalds 已提交
959 960 961 962 963 964
		DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
		return -EIO;
	}

	/* initialize eeprom parameters */

J
Jesse Brandeburg 已提交
965
	if (e1000_init_eeprom_params(hw)) {
966 967 968
		E1000_ERR("EEPROM initialization failed\n");
		return -EIO;
	}
L
Linus Torvalds 已提交
969

J
Jesse Brandeburg 已提交
970
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
	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);

	hw->wait_autoneg_complete = FALSE;
	hw->tbi_compatibility_en = TRUE;
	hw->adaptive_ifs = TRUE;

	/* Copper options */

J
Jesse Brandeburg 已提交
989
	if (hw->media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
990 991 992 993 994
		hw->mdix = AUTO_ALL_MODES;
		hw->disable_polarity_correction = FALSE;
		hw->master_slave = E1000_MASTER_SLAVE;
	}

995 996
	adapter->num_tx_queues = 1;
	adapter->num_rx_queues = 1;
997 998 999 1000 1001 1002 1003

	if (e1000_alloc_queues(adapter)) {
		DPRINTK(PROBE, ERR, "Unable to allocate memory for queues\n");
		return -ENOMEM;
	}

#ifdef CONFIG_E1000_NAPI
1004
	for (i = 0; i < adapter->num_rx_queues; i++) {
1005 1006 1007 1008 1009 1010
		adapter->polling_netdev[i].priv = adapter;
		adapter->polling_netdev[i].poll = &e1000_clean;
		adapter->polling_netdev[i].weight = 64;
		dev_hold(&adapter->polling_netdev[i]);
		set_bit(__LINK_STATE_START, &adapter->polling_netdev[i].state);
	}
1011
	spin_lock_init(&adapter->tx_queue_lock);
1012 1013
#endif

L
Linus Torvalds 已提交
1014 1015 1016 1017 1018 1019
	atomic_set(&adapter->irq_sem, 1);
	spin_lock_init(&adapter->stats_lock);

	return 0;
}

1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
/**
 * 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
 * number of queues at compile-time.  The polling_netdev array is
 * intended for Multiqueue, but should work fine with a single queue.
 **/

static int __devinit
e1000_alloc_queues(struct e1000_adapter *adapter)
{
	int size;

1034
	size = sizeof(struct e1000_tx_ring) * adapter->num_tx_queues;
1035 1036 1037 1038 1039
	adapter->tx_ring = kmalloc(size, GFP_KERNEL);
	if (!adapter->tx_ring)
		return -ENOMEM;
	memset(adapter->tx_ring, 0, size);

1040
	size = sizeof(struct e1000_rx_ring) * adapter->num_rx_queues;
1041 1042 1043 1044 1045 1046 1047 1048
	adapter->rx_ring = kmalloc(size, GFP_KERNEL);
	if (!adapter->rx_ring) {
		kfree(adapter->tx_ring);
		return -ENOMEM;
	}
	memset(adapter->rx_ring, 0, size);

#ifdef CONFIG_E1000_NAPI
1049
	size = sizeof(struct net_device) * adapter->num_rx_queues;
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
	adapter->polling_netdev = kmalloc(size, GFP_KERNEL);
	if (!adapter->polling_netdev) {
		kfree(adapter->tx_ring);
		kfree(adapter->rx_ring);
		return -ENOMEM;
	}
	memset(adapter->polling_netdev, 0, size);
#endif

	return E1000_SUCCESS;
}

L
Linus Torvalds 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
/**
 * 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.
 **/

static int
e1000_open(struct net_device *netdev)
{
1078
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1079 1080 1081 1082
	int err;

	/* allocate transmit descriptors */

1083
	if ((err = e1000_setup_all_tx_resources(adapter)))
L
Linus Torvalds 已提交
1084 1085 1086 1087
		goto err_setup_tx;

	/* allocate receive descriptors */

1088
	if ((err = e1000_setup_all_rx_resources(adapter)))
L
Linus Torvalds 已提交
1089 1090
		goto err_setup_rx;

J
Jesse Brandeburg 已提交
1091
	if ((err = e1000_up(adapter)))
L
Linus Torvalds 已提交
1092
		goto err_up;
1093
	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
J
Jesse Brandeburg 已提交
1094
	if ((adapter->hw.mng_cookie.status &
1095 1096 1097
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_update_mng_vlan(adapter);
	}
L
Linus Torvalds 已提交
1098

1099 1100 1101 1102 1103 1104
	/* If AMT is enabled, let the firmware know that the network
	 * interface is now open */
	if (adapter->hw.mac_type == e1000_82573 &&
	    e1000_check_mng_mode(&adapter->hw))
		e1000_get_hw_control(adapter);

L
Linus Torvalds 已提交
1105 1106 1107
	return E1000_SUCCESS;

err_up:
1108
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1109
err_setup_rx:
1110
	e1000_free_all_tx_resources(adapter);
L
Linus Torvalds 已提交
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
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.
 **/

static int
e1000_close(struct net_device *netdev)
{
1132
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1133 1134 1135

	e1000_down(adapter);

1136 1137
	e1000_free_all_tx_resources(adapter);
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1138

J
Jesse Brandeburg 已提交
1139
	if ((adapter->hw.mng_cookie.status &
1140 1141 1142
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
	}
1143 1144 1145 1146 1147 1148 1149

	/* If AMT is enabled, let the firmware know that the network
	 * interface is now closed */
	if (adapter->hw.mac_type == e1000_82573 &&
	    e1000_check_mng_mode(&adapter->hw))
		e1000_release_hw_control(adapter);

L
Linus Torvalds 已提交
1150 1151 1152 1153 1154 1155
	return 0;
}

/**
 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
 * @adapter: address of board private structure
1156 1157
 * @start: address of beginning of memory
 * @len: length of memory
L
Linus Torvalds 已提交
1158
 **/
1159
static boolean_t
L
Linus Torvalds 已提交
1160 1161 1162 1163 1164 1165
e1000_check_64k_bound(struct e1000_adapter *adapter,
		      void *start, unsigned long len)
{
	unsigned long begin = (unsigned long) start;
	unsigned long end = begin + len;

1166 1167
	/* First rev 82545 and 82546 need to not allow any memory
	 * write location to cross 64k boundary due to errata 23 */
L
Linus Torvalds 已提交
1168
	if (adapter->hw.mac_type == e1000_82545 ||
1169
	    adapter->hw.mac_type == e1000_82546) {
L
Linus Torvalds 已提交
1170 1171 1172 1173 1174 1175 1176 1177 1178
		return ((begin ^ (end - 1)) >> 16) != 0 ? FALSE : TRUE;
	}

	return TRUE;
}

/**
 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 * @adapter: board private structure
1179
 * @txdr:    tx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1180 1181 1182 1183
 *
 * Return 0 on success, negative on failure
 **/

1184
static int
1185 1186
e1000_setup_tx_resources(struct e1000_adapter *adapter,
                         struct e1000_tx_ring *txdr)
L
Linus Torvalds 已提交
1187 1188 1189 1190 1191
{
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct e1000_buffer) * txdr->count;
1192 1193

	txdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
J
Jesse Brandeburg 已提交
1194
	if (!txdr->buffer_info) {
1195 1196
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
		return -ENOMEM;
	}
	memset(txdr->buffer_info, 0, size);

	/* round up to nearest 4K */

	txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
	E1000_ROUNDUP(txdr->size, 4096);

	txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
J
Jesse Brandeburg 已提交
1207
	if (!txdr->desc) {
L
Linus Torvalds 已提交
1208 1209
setup_tx_desc_die:
		vfree(txdr->buffer_info);
1210 1211
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1212 1213 1214
		return -ENOMEM;
	}

1215
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1216 1217 1218
	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
		void *olddesc = txdr->desc;
		dma_addr_t olddma = txdr->dma;
1219 1220 1221
		DPRINTK(TX_ERR, ERR, "txdr align check failed: %u bytes "
				     "at %p\n", txdr->size, txdr->desc);
		/* Try again, without freeing the previous */
L
Linus Torvalds 已提交
1222
		txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
1223
		/* Failed allocation, critical failure */
J
Jesse Brandeburg 已提交
1224
		if (!txdr->desc) {
L
Linus Torvalds 已提交
1225 1226 1227 1228 1229 1230
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
			goto setup_tx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
			/* give up */
1231 1232
			pci_free_consistent(pdev, txdr->size, txdr->desc,
					    txdr->dma);
L
Linus Torvalds 已提交
1233 1234
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
			DPRINTK(PROBE, ERR,
1235 1236
				"Unable to allocate aligned memory "
				"for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1237 1238 1239
			vfree(txdr->buffer_info);
			return -ENOMEM;
		} else {
1240
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1241 1242 1243 1244 1245 1246 1247
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
		}
	}
	memset(txdr->desc, 0, txdr->size);

	txdr->next_to_use = 0;
	txdr->next_to_clean = 0;
1248
	spin_lock_init(&txdr->tx_lock);
L
Linus Torvalds 已提交
1249 1250 1251 1252

	return 0;
}

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
/**
 * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * If this function returns with an error, then it's possible one or
 * more of the rings is populated (while the rest are not).  It is the
 * callers duty to clean those orphaned rings.
 *
 * Return 0 on success, negative on failure
 **/

int
e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
{
	int i, err = 0;

1270
	for (i = 0; i < adapter->num_tx_queues; i++) {
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
		if (err) {
			DPRINTK(PROBE, ERR,
				"Allocation for Tx Queue %u failed\n", i);
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
/**
 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
 * @adapter: board private structure
 *
 * Configure the Tx unit of the MAC after a reset.
 **/

static void
e1000_configure_tx(struct e1000_adapter *adapter)
{
1292 1293 1294
	uint64_t tdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t tdlen, tctl, tipg, tarc;
1295
	uint32_t ipgr1, ipgr2;
L
Linus Torvalds 已提交
1296 1297 1298

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

1299
	switch (adapter->num_tx_queues) {
1300 1301
	case 1:
	default:
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
		tdba = adapter->tx_ring[0].dma;
		tdlen = adapter->tx_ring[0].count *
			sizeof(struct e1000_tx_desc);
		E1000_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
		E1000_WRITE_REG(hw, TDBAH, (tdba >> 32));
		E1000_WRITE_REG(hw, TDLEN, tdlen);
		E1000_WRITE_REG(hw, TDH, 0);
		E1000_WRITE_REG(hw, TDT, 0);
		adapter->tx_ring[0].tdh = E1000_TDH;
		adapter->tx_ring[0].tdt = E1000_TDT;
1312 1313
		break;
	}
L
Linus Torvalds 已提交
1314 1315 1316

	/* Set the default values for the Tx Inter Packet Gap timer */

1317 1318 1319 1320 1321 1322
	if (hw->media_type == e1000_media_type_fiber ||
	    hw->media_type == e1000_media_type_internal_serdes)
		tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
	else
		tipg = DEFAULT_82543_TIPG_IPGT_COPPER;

1323
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1324 1325 1326
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
		tipg = DEFAULT_82542_TIPG_IPGT;
1327 1328
		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
L
Linus Torvalds 已提交
1329
		break;
1330 1331 1332 1333
	case e1000_80003es2lan:
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_80003ES2LAN_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1334
	default:
1335 1336 1337
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1338
	}
1339 1340
	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
1341
	E1000_WRITE_REG(hw, TIPG, tipg);
L
Linus Torvalds 已提交
1342 1343 1344

	/* Set the Tx Interrupt Delay register */

1345 1346 1347
	E1000_WRITE_REG(hw, TIDV, adapter->tx_int_delay);
	if (hw->mac_type >= e1000_82540)
		E1000_WRITE_REG(hw, TADV, adapter->tx_abs_int_delay);
L
Linus Torvalds 已提交
1348 1349 1350

	/* Program the Transmit Control Register */

1351
	tctl = E1000_READ_REG(hw, TCTL);
L
Linus Torvalds 已提交
1352 1353

	tctl &= ~E1000_TCTL_CT;
1354
	tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
L
Linus Torvalds 已提交
1355 1356
		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);

1357 1358 1359 1360
#ifdef DISABLE_MULR
	/* disable Multiple Reads for debugging */
	tctl &= ~E1000_TCTL_MULR;
#endif
L
Linus Torvalds 已提交
1361

1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
	if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572) {
		tarc = E1000_READ_REG(hw, TARC0);
		tarc |= ((1 << 25) | (1 << 21));
		E1000_WRITE_REG(hw, TARC0, tarc);
		tarc = E1000_READ_REG(hw, TARC1);
		tarc |= (1 << 25);
		if (tctl & E1000_TCTL_MULR)
			tarc &= ~(1 << 28);
		else
			tarc |= (1 << 28);
		E1000_WRITE_REG(hw, TARC1, tarc);
1373 1374 1375 1376 1377 1378 1379 1380 1381
	} else if (hw->mac_type == e1000_80003es2lan) {
		tarc = E1000_READ_REG(hw, TARC0);
		tarc |= 1;
		if (hw->media_type == e1000_media_type_internal_serdes)
			tarc |= (1 << 20);
		E1000_WRITE_REG(hw, TARC0, tarc);
		tarc = E1000_READ_REG(hw, TARC1);
		tarc |= 1;
		E1000_WRITE_REG(hw, TARC1, tarc);
1382 1383
	}

1384
	e1000_config_collision_dist(hw);
L
Linus Torvalds 已提交
1385 1386 1387 1388 1389

	/* Setup Transmit Descriptor Settings for eop descriptor */
	adapter->txd_cmd = E1000_TXD_CMD_IDE | E1000_TXD_CMD_EOP |
		E1000_TXD_CMD_IFCS;

1390
	if (hw->mac_type < e1000_82543)
L
Linus Torvalds 已提交
1391 1392 1393 1394 1395 1396
		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. */
1397 1398
	if (hw->mac_type == e1000_82544 &&
	    hw->bus_type == e1000_bus_type_pcix)
L
Linus Torvalds 已提交
1399
		adapter->pcix_82544 = 1;
1400 1401 1402

	E1000_WRITE_REG(hw, TCTL, tctl);

L
Linus Torvalds 已提交
1403 1404 1405 1406 1407
}

/**
 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 * @adapter: board private structure
1408
 * @rxdr:    rx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1409 1410 1411 1412
 *
 * Returns 0 on success, negative on failure
 **/

1413
static int
1414 1415
e1000_setup_rx_resources(struct e1000_adapter *adapter,
                         struct e1000_rx_ring *rxdr)
L
Linus Torvalds 已提交
1416 1417
{
	struct pci_dev *pdev = adapter->pdev;
1418
	int size, desc_len;
L
Linus Torvalds 已提交
1419 1420

	size = sizeof(struct e1000_buffer) * rxdr->count;
1421
	rxdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
1422
	if (!rxdr->buffer_info) {
1423 1424
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1425 1426 1427 1428
		return -ENOMEM;
	}
	memset(rxdr->buffer_info, 0, size);

1429 1430
	size = sizeof(struct e1000_ps_page) * rxdr->count;
	rxdr->ps_page = kmalloc(size, GFP_KERNEL);
J
Jesse Brandeburg 已提交
1431
	if (!rxdr->ps_page) {
1432 1433 1434 1435 1436 1437 1438 1439 1440
		vfree(rxdr->buffer_info);
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
		return -ENOMEM;
	}
	memset(rxdr->ps_page, 0, size);

	size = sizeof(struct e1000_ps_page_dma) * rxdr->count;
	rxdr->ps_page_dma = kmalloc(size, GFP_KERNEL);
J
Jesse Brandeburg 已提交
1441
	if (!rxdr->ps_page_dma) {
1442 1443 1444 1445 1446 1447 1448 1449
		vfree(rxdr->buffer_info);
		kfree(rxdr->ps_page);
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
		return -ENOMEM;
	}
	memset(rxdr->ps_page_dma, 0, size);

J
Jesse Brandeburg 已提交
1450
	if (adapter->hw.mac_type <= e1000_82547_rev_2)
1451 1452 1453 1454
		desc_len = sizeof(struct e1000_rx_desc);
	else
		desc_len = sizeof(union e1000_rx_desc_packet_split);

L
Linus Torvalds 已提交
1455 1456
	/* Round up to nearest 4K */

1457
	rxdr->size = rxdr->count * desc_len;
L
Linus Torvalds 已提交
1458 1459 1460 1461
	E1000_ROUNDUP(rxdr->size, 4096);

	rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);

1462 1463 1464
	if (!rxdr->desc) {
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1465 1466
setup_rx_desc_die:
		vfree(rxdr->buffer_info);
1467 1468
		kfree(rxdr->ps_page);
		kfree(rxdr->ps_page_dma);
L
Linus Torvalds 已提交
1469 1470 1471
		return -ENOMEM;
	}

1472
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1473 1474 1475
	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
		void *olddesc = rxdr->desc;
		dma_addr_t olddma = rxdr->dma;
1476 1477 1478
		DPRINTK(RX_ERR, ERR, "rxdr align check failed: %u bytes "
				     "at %p\n", rxdr->size, rxdr->desc);
		/* Try again, without freeing the previous */
L
Linus Torvalds 已提交
1479
		rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
1480
		/* Failed allocation, critical failure */
1481
		if (!rxdr->desc) {
L
Linus Torvalds 已提交
1482
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1483 1484 1485
			DPRINTK(PROBE, ERR,
				"Unable to allocate memory "
				"for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1486 1487 1488 1489 1490
			goto setup_rx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
			/* give up */
1491 1492
			pci_free_consistent(pdev, rxdr->size, rxdr->desc,
					    rxdr->dma);
L
Linus Torvalds 已提交
1493
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1494 1495 1496
			DPRINTK(PROBE, ERR,
				"Unable to allocate aligned memory "
				"for the receive descriptor ring\n");
1497
			goto setup_rx_desc_die;
L
Linus Torvalds 已提交
1498
		} else {
1499
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
		}
	}
	memset(rxdr->desc, 0, rxdr->size);

	rxdr->next_to_clean = 0;
	rxdr->next_to_use = 0;

	return 0;
}

1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
/**
 * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * If this function returns with an error, then it's possible one or
 * more of the rings is populated (while the rest are not).  It is the
 * callers duty to clean those orphaned rings.
 *
 * Return 0 on success, negative on failure
 **/

int
e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
{
	int i, err = 0;

1528
	for (i = 0; i < adapter->num_rx_queues; i++) {
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
		if (err) {
			DPRINTK(PROBE, ERR,
				"Allocation for Rx Queue %u failed\n", i);
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1540
/**
1541
 * e1000_setup_rctl - configure the receive control registers
L
Linus Torvalds 已提交
1542 1543
 * @adapter: Board private structure
 **/
1544 1545
#define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
			(((S) & (PAGE_SIZE - 1)) ? 1 : 0))
L
Linus Torvalds 已提交
1546 1547 1548
static void
e1000_setup_rctl(struct e1000_adapter *adapter)
{
1549 1550
	uint32_t rctl, rfctl;
	uint32_t psrctl = 0;
1551
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1552 1553
	uint32_t pages = 0;
#endif
L
Linus Torvalds 已提交
1554 1555 1556 1557 1558 1559 1560 1561 1562

	rctl = E1000_READ_REG(&adapter->hw, RCTL);

	rctl &= ~(3 << E1000_RCTL_MO_SHIFT);

	rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
		E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
		(adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);

1563 1564 1565 1566
	if (adapter->hw.mac_type > e1000_82543)
		rctl |= E1000_RCTL_SECRC;

	if (adapter->hw.tbi_compatibility_on == 1)
L
Linus Torvalds 已提交
1567 1568 1569 1570
		rctl |= E1000_RCTL_SBP;
	else
		rctl &= ~E1000_RCTL_SBP;

1571 1572 1573 1574 1575
	if (adapter->netdev->mtu <= ETH_DATA_LEN)
		rctl &= ~E1000_RCTL_LPE;
	else
		rctl |= E1000_RCTL_LPE;

L
Linus Torvalds 已提交
1576
	/* Setup buffer sizes */
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
	rctl &= ~E1000_RCTL_SZ_4096;
	rctl |= E1000_RCTL_BSEX;
	switch (adapter->rx_buffer_len) {
		case E1000_RXBUFFER_256:
			rctl |= E1000_RCTL_SZ_256;
			rctl &= ~E1000_RCTL_BSEX;
			break;
		case E1000_RXBUFFER_512:
			rctl |= E1000_RCTL_SZ_512;
			rctl &= ~E1000_RCTL_BSEX;
			break;
		case E1000_RXBUFFER_1024:
			rctl |= E1000_RCTL_SZ_1024;
			rctl &= ~E1000_RCTL_BSEX;
			break;
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605
		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;
1606 1607
	}

1608
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1609 1610 1611 1612 1613 1614 1615
	/* 82571 and greater support packet-split where the protocol
	 * header is placed in skb->data and the packet data is
	 * placed in pages hanging off of skb_shinfo(skb)->nr_frags.
	 * In the case of a non-split, skb->data is linearly filled,
	 * followed by the page buffers.  Therefore, skb->data is
	 * sized to hold the largest protocol header.
	 */
1616 1617 1618 1619 1620 1621
	pages = PAGE_USE_COUNT(adapter->netdev->mtu);
	if ((adapter->hw.mac_type > e1000_82547_rev_2) && (pages <= 3) &&
	    PAGE_SIZE <= 16384)
		adapter->rx_ps_pages = pages;
	else
		adapter->rx_ps_pages = 0;
1622
#endif
1623
	if (adapter->rx_ps_pages) {
1624 1625 1626 1627 1628 1629 1630 1631
		/* Configure extra packet-split registers */
		rfctl = E1000_READ_REG(&adapter->hw, RFCTL);
		rfctl |= E1000_RFCTL_EXTEN;
		/* disable IPv6 packet split support */
		rfctl |= E1000_RFCTL_IPV6_DIS;
		E1000_WRITE_REG(&adapter->hw, RFCTL, rfctl);

		rctl |= E1000_RCTL_DTYP_PS | E1000_RCTL_SECRC;
J
Jesse Brandeburg 已提交
1632

1633 1634
		psrctl |= adapter->rx_ps_bsize0 >>
			E1000_PSRCTL_BSIZE0_SHIFT;
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647

		switch (adapter->rx_ps_pages) {
		case 3:
			psrctl |= PAGE_SIZE <<
				E1000_PSRCTL_BSIZE3_SHIFT;
		case 2:
			psrctl |= PAGE_SIZE <<
				E1000_PSRCTL_BSIZE2_SHIFT;
		case 1:
			psrctl |= PAGE_SIZE >>
				E1000_PSRCTL_BSIZE1_SHIFT;
			break;
		}
1648 1649

		E1000_WRITE_REG(&adapter->hw, PSRCTL, psrctl);
L
Linus Torvalds 已提交
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
	}

	E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
}

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

static void
e1000_configure_rx(struct e1000_adapter *adapter)
{
1665 1666 1667
	uint64_t rdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t rdlen, rctl, rxcsum, ctrl_ext;
1668

1669
	if (adapter->rx_ps_pages) {
1670
		/* this is a 32 byte descriptor */
1671
		rdlen = adapter->rx_ring[0].count *
1672 1673 1674 1675
			sizeof(union e1000_rx_desc_packet_split);
		adapter->clean_rx = e1000_clean_rx_irq_ps;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers_ps;
	} else {
1676 1677
		rdlen = adapter->rx_ring[0].count *
			sizeof(struct e1000_rx_desc);
1678 1679 1680
		adapter->clean_rx = e1000_clean_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
	}
L
Linus Torvalds 已提交
1681 1682

	/* disable receives while setting up the descriptors */
1683 1684
	rctl = E1000_READ_REG(hw, RCTL);
	E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
L
Linus Torvalds 已提交
1685 1686

	/* set the Receive Delay Timer Register */
1687
	E1000_WRITE_REG(hw, RDTR, adapter->rx_int_delay);
L
Linus Torvalds 已提交
1688

1689 1690
	if (hw->mac_type >= e1000_82540) {
		E1000_WRITE_REG(hw, RADV, adapter->rx_abs_int_delay);
J
Jesse Brandeburg 已提交
1691
		if (adapter->itr > 1)
1692
			E1000_WRITE_REG(hw, ITR,
L
Linus Torvalds 已提交
1693 1694 1695
				1000000000 / (adapter->itr * 256));
	}

1696 1697
	if (hw->mac_type >= e1000_82571) {
		ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
1698
		/* Reset delay timers after every interrupt */
A
Auke Kok 已提交
1699
		ctrl_ext |= E1000_CTRL_EXT_INT_TIMER_CLR;
1700 1701 1702 1703
#ifdef CONFIG_E1000_NAPI
		/* Auto-Mask interrupts upon ICR read. */
		ctrl_ext |= E1000_CTRL_EXT_IAME;
#endif
1704
		E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
1705
		E1000_WRITE_REG(hw, IAM, ~0);
1706 1707 1708
		E1000_WRITE_FLUSH(hw);
	}

1709 1710
	/* Setup the HW Rx Head and Tail Descriptor Pointers and
	 * the Base and Length of the Rx Descriptor Ring */
1711
	switch (adapter->num_rx_queues) {
1712 1713
	case 1:
	default:
1714 1715 1716 1717 1718 1719 1720 1721 1722
		rdba = adapter->rx_ring[0].dma;
		E1000_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL));
		E1000_WRITE_REG(hw, RDBAH, (rdba >> 32));
		E1000_WRITE_REG(hw, RDLEN, rdlen);
		E1000_WRITE_REG(hw, RDH, 0);
		E1000_WRITE_REG(hw, RDT, 0);
		adapter->rx_ring[0].rdh = E1000_RDH;
		adapter->rx_ring[0].rdt = E1000_RDT;
		break;
1723 1724
	}

L
Linus Torvalds 已提交
1725
	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
1726 1727
	if (hw->mac_type >= e1000_82543) {
		rxcsum = E1000_READ_REG(hw, RXCSUM);
J
Jesse Brandeburg 已提交
1728
		if (adapter->rx_csum == TRUE) {
1729 1730
			rxcsum |= E1000_RXCSUM_TUOFL;

1731
			/* Enable 82571 IPv4 payload checksum for UDP fragments
1732
			 * Must be used in conjunction with packet-split. */
J
Jesse Brandeburg 已提交
1733 1734
			if ((hw->mac_type >= e1000_82571) &&
			    (adapter->rx_ps_pages)) {
1735 1736 1737 1738 1739 1740
				rxcsum |= E1000_RXCSUM_IPPCSE;
			}
		} else {
			rxcsum &= ~E1000_RXCSUM_TUOFL;
			/* don't need to clear IPPCSE as it defaults to 0 */
		}
1741
		E1000_WRITE_REG(hw, RXCSUM, rxcsum);
L
Linus Torvalds 已提交
1742 1743
	}

1744 1745
	if (hw->mac_type == e1000_82573)
		E1000_WRITE_REG(hw, ERT, 0x0100);
1746

L
Linus Torvalds 已提交
1747
	/* Enable Receives */
1748
	E1000_WRITE_REG(hw, RCTL, rctl);
L
Linus Torvalds 已提交
1749 1750 1751
}

/**
1752
 * e1000_free_tx_resources - Free Tx Resources per Queue
L
Linus Torvalds 已提交
1753
 * @adapter: board private structure
1754
 * @tx_ring: Tx descriptor ring for a specific queue
L
Linus Torvalds 已提交
1755 1756 1757 1758
 *
 * Free all transmit software resources
 **/

1759
static void
1760 1761
e1000_free_tx_resources(struct e1000_adapter *adapter,
                        struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1762 1763 1764
{
	struct pci_dev *pdev = adapter->pdev;

1765
	e1000_clean_tx_ring(adapter, tx_ring);
L
Linus Torvalds 已提交
1766

1767 1768
	vfree(tx_ring->buffer_info);
	tx_ring->buffer_info = NULL;
L
Linus Torvalds 已提交
1769

1770
	pci_free_consistent(pdev, tx_ring->size, tx_ring->desc, tx_ring->dma);
L
Linus Torvalds 已提交
1771

1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
	tx_ring->desc = NULL;
}

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

void
e1000_free_all_tx_resources(struct e1000_adapter *adapter)
{
	int i;

1787
	for (i = 0; i < adapter->num_tx_queues; i++)
1788
		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
1789 1790
}

1791
static void
L
Linus Torvalds 已提交
1792 1793 1794
e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
			struct e1000_buffer *buffer_info)
{
J
Jesse Brandeburg 已提交
1795
	if (buffer_info->dma) {
1796 1797 1798 1799
		pci_unmap_page(adapter->pdev,
				buffer_info->dma,
				buffer_info->length,
				PCI_DMA_TODEVICE);
L
Linus Torvalds 已提交
1800
	}
1801
	if (buffer_info->skb)
L
Linus Torvalds 已提交
1802
		dev_kfree_skb_any(buffer_info->skb);
1803
	memset(buffer_info, 0, sizeof(struct e1000_buffer));
L
Linus Torvalds 已提交
1804 1805 1806 1807 1808
}

/**
 * e1000_clean_tx_ring - Free Tx Buffers
 * @adapter: board private structure
1809
 * @tx_ring: ring to be cleaned
L
Linus Torvalds 已提交
1810 1811 1812
 **/

static void
1813 1814
e1000_clean_tx_ring(struct e1000_adapter *adapter,
                    struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1815 1816 1817 1818 1819 1820 1821
{
	struct e1000_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	/* Free all the Tx ring sk_buffs */

J
Jesse Brandeburg 已提交
1822
	for (i = 0; i < tx_ring->count; i++) {
L
Linus Torvalds 已提交
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
		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 已提交
1836
	tx_ring->last_tx_tso = 0;
L
Linus Torvalds 已提交
1837

1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
	writel(0, adapter->hw.hw_addr + tx_ring->tdh);
	writel(0, adapter->hw.hw_addr + tx_ring->tdt);
}

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

static void
e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
{
	int i;

1852
	for (i = 0; i < adapter->num_tx_queues; i++)
1853
		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
1854 1855 1856 1857 1858
}

/**
 * e1000_free_rx_resources - Free Rx Resources
 * @adapter: board private structure
1859
 * @rx_ring: ring to clean the resources from
L
Linus Torvalds 已提交
1860 1861 1862 1863
 *
 * Free all receive software resources
 **/

1864
static void
1865 1866
e1000_free_rx_resources(struct e1000_adapter *adapter,
                        struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
1867 1868 1869
{
	struct pci_dev *pdev = adapter->pdev;

1870
	e1000_clean_rx_ring(adapter, rx_ring);
L
Linus Torvalds 已提交
1871 1872 1873

	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;
1874 1875 1876 1877
	kfree(rx_ring->ps_page);
	rx_ring->ps_page = NULL;
	kfree(rx_ring->ps_page_dma);
	rx_ring->ps_page_dma = NULL;
L
Linus Torvalds 已提交
1878 1879 1880 1881 1882 1883 1884

	pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);

	rx_ring->desc = NULL;
}

/**
1885
 * e1000_free_all_rx_resources - Free Rx Resources for All Queues
L
Linus Torvalds 已提交
1886
 * @adapter: board private structure
1887 1888 1889 1890 1891 1892 1893 1894 1895
 *
 * Free all receive software resources
 **/

void
e1000_free_all_rx_resources(struct e1000_adapter *adapter)
{
	int i;

1896
	for (i = 0; i < adapter->num_rx_queues; i++)
1897 1898 1899 1900 1901 1902 1903
		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 已提交
1904 1905 1906
 **/

static void
1907 1908
e1000_clean_rx_ring(struct e1000_adapter *adapter,
                    struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
1909 1910
{
	struct e1000_buffer *buffer_info;
1911 1912
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
L
Linus Torvalds 已提交
1913 1914
	struct pci_dev *pdev = adapter->pdev;
	unsigned long size;
1915
	unsigned int i, j;
L
Linus Torvalds 已提交
1916 1917

	/* Free all the Rx ring sk_buffs */
J
Jesse Brandeburg 已提交
1918
	for (i = 0; i < rx_ring->count; i++) {
L
Linus Torvalds 已提交
1919
		buffer_info = &rx_ring->buffer_info[i];
J
Jesse Brandeburg 已提交
1920
		if (buffer_info->skb) {
L
Linus Torvalds 已提交
1921 1922 1923 1924 1925 1926 1927
			pci_unmap_single(pdev,
					 buffer_info->dma,
					 buffer_info->length,
					 PCI_DMA_FROMDEVICE);

			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
		}
		ps_page = &rx_ring->ps_page[i];
		ps_page_dma = &rx_ring->ps_page_dma[i];
		for (j = 0; j < adapter->rx_ps_pages; j++) {
			if (!ps_page->ps_page[j]) break;
			pci_unmap_page(pdev,
				       ps_page_dma->ps_page_dma[j],
				       PAGE_SIZE, PCI_DMA_FROMDEVICE);
			ps_page_dma->ps_page_dma[j] = 0;
			put_page(ps_page->ps_page[j]);
			ps_page->ps_page[j] = NULL;
L
Linus Torvalds 已提交
1939 1940 1941 1942 1943
		}
	}

	size = sizeof(struct e1000_buffer) * rx_ring->count;
	memset(rx_ring->buffer_info, 0, size);
1944 1945 1946 1947
	size = sizeof(struct e1000_ps_page) * rx_ring->count;
	memset(rx_ring->ps_page, 0, size);
	size = sizeof(struct e1000_ps_page_dma) * rx_ring->count;
	memset(rx_ring->ps_page_dma, 0, size);
L
Linus Torvalds 已提交
1948 1949 1950 1951 1952 1953 1954 1955

	/* 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;

1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
	writel(0, adapter->hw.hw_addr + rx_ring->rdh);
	writel(0, adapter->hw.hw_addr + rx_ring->rdt);
}

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

static void
e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
{
	int i;

1970
	for (i = 0; i < adapter->num_rx_queues; i++)
1971
		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
L
Linus Torvalds 已提交
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
}

/* The 82542 2.0 (revision 2) needs to have the receive unit in reset
 * and memory write and invalidate disabled for certain operations
 */
static void
e1000_enter_82542_rst(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	uint32_t rctl;

	e1000_pci_clear_mwi(&adapter->hw);

	rctl = E1000_READ_REG(&adapter->hw, RCTL);
	rctl |= E1000_RCTL_RST;
	E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
	E1000_WRITE_FLUSH(&adapter->hw);
	mdelay(5);

J
Jesse Brandeburg 已提交
1991
	if (netif_running(netdev))
1992
		e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
}

static void
e1000_leave_82542_rst(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	uint32_t rctl;

	rctl = E1000_READ_REG(&adapter->hw, RCTL);
	rctl &= ~E1000_RCTL_RST;
	E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
	E1000_WRITE_FLUSH(&adapter->hw);
	mdelay(5);

J
Jesse Brandeburg 已提交
2007
	if (adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
L
Linus Torvalds 已提交
2008 2009
		e1000_pci_set_mwi(&adapter->hw);

J
Jesse Brandeburg 已提交
2010
	if (netif_running(netdev)) {
2011 2012
		/* No need to loop, because 82542 supports only 1 queue */
		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2013
		e1000_configure_rx(adapter);
2014
		adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
L
Linus Torvalds 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
	}
}

/**
 * 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
 **/

static int
e1000_set_mac(struct net_device *netdev, void *p)
{
2029
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2030 2031
	struct sockaddr *addr = p;

J
Jesse Brandeburg 已提交
2032
	if (!is_valid_ether_addr(addr->sa_data))
L
Linus Torvalds 已提交
2033 2034 2035 2036
		return -EADDRNOTAVAIL;

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

J
Jesse Brandeburg 已提交
2037
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2038 2039 2040 2041 2042 2043 2044
		e1000_enter_82542_rst(adapter);

	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
	memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);

	e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);

2045 2046 2047 2048 2049 2050
	/* With 82571 controllers, LAA may be overwritten (with the default)
	 * due to controller reset from the other port. */
	if (adapter->hw.mac_type == e1000_82571) {
		/* activate the work around */
		adapter->hw.laa_is_present = 1;

J
Jesse Brandeburg 已提交
2051 2052 2053
		/* Hold a copy of the LAA in RAR[14] This is done so that
		 * between the time RAR[0] gets clobbered  and the time it
		 * gets fixed (in e1000_watchdog), the actual LAA is in one
2054
		 * of the RARs and no incoming packets directed to this port
J
Jesse Brandeburg 已提交
2055
		 * are dropped. Eventaully the LAA will be in RAR[0] and
2056
		 * RAR[14] */
J
Jesse Brandeburg 已提交
2057
		e1000_rar_set(&adapter->hw, adapter->hw.mac_addr,
2058 2059 2060
					E1000_RAR_ENTRIES - 1);
	}

J
Jesse Brandeburg 已提交
2061
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
		e1000_leave_82542_rst(adapter);

	return 0;
}

/**
 * e1000_set_multi - Multicast and Promiscuous mode set
 * @netdev: network interface device structure
 *
 * The set_multi entry point is called whenever the multicast address
 * list or the network interface flags are updated.  This routine is
 * responsible for configuring the hardware for proper multicast,
 * promiscuous mode, and all-multi behavior.
 **/

static void
e1000_set_multi(struct net_device *netdev)
{
2080
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2081 2082 2083 2084
	struct e1000_hw *hw = &adapter->hw;
	struct dev_mc_list *mc_ptr;
	uint32_t rctl;
	uint32_t hash_value;
2085
	int i, rar_entries = E1000_RAR_ENTRIES;
L
Linus Torvalds 已提交
2086

2087 2088 2089
	/* reserve RAR[14] for LAA over-write work-around */
	if (adapter->hw.mac_type == e1000_82571)
		rar_entries--;
L
Linus Torvalds 已提交
2090

2091 2092
	/* Check for Promiscuous and All Multicast modes */

L
Linus Torvalds 已提交
2093 2094
	rctl = E1000_READ_REG(hw, RCTL);

J
Jesse Brandeburg 已提交
2095
	if (netdev->flags & IFF_PROMISC) {
L
Linus Torvalds 已提交
2096
		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
J
Jesse Brandeburg 已提交
2097
	} else if (netdev->flags & IFF_ALLMULTI) {
L
Linus Torvalds 已提交
2098 2099 2100 2101 2102 2103 2104 2105 2106 2107
		rctl |= E1000_RCTL_MPE;
		rctl &= ~E1000_RCTL_UPE;
	} else {
		rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
	}

	E1000_WRITE_REG(hw, RCTL, rctl);

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

J
Jesse Brandeburg 已提交
2108
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2109 2110 2111 2112 2113
		e1000_enter_82542_rst(adapter);

	/* load the first 14 multicast address into the exact filters 1-14
	 * RAR 0 is used for the station MAC adddress
	 * if there are not 14 addresses, go ahead and clear the filters
2114
	 * -- with 82571 controllers only 0-13 entries are filled here
L
Linus Torvalds 已提交
2115 2116 2117
	 */
	mc_ptr = netdev->mc_list;

J
Jesse Brandeburg 已提交
2118
	for (i = 1; i < rar_entries; i++) {
2119
		if (mc_ptr) {
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
			e1000_rar_set(hw, mc_ptr->dmi_addr, i);
			mc_ptr = mc_ptr->next;
		} else {
			E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
			E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
		}
	}

	/* clear the old settings from the multicast hash table */

J
Jesse Brandeburg 已提交
2130
	for (i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
L
Linus Torvalds 已提交
2131 2132 2133 2134
		E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);

	/* load any remaining addresses into the hash table */

J
Jesse Brandeburg 已提交
2135
	for (; mc_ptr; mc_ptr = mc_ptr->next) {
L
Linus Torvalds 已提交
2136 2137 2138 2139
		hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
		e1000_mta_set(hw, hash_value);
	}

J
Jesse Brandeburg 已提交
2140
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
		e1000_leave_82542_rst(adapter);
}

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

static void
e1000_update_phy_info(unsigned long data)
{
	struct e1000_adapter *adapter = (struct e1000_adapter *) data;
	e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
}

/**
 * e1000_82547_tx_fifo_stall - Timer Call-back
 * @data: pointer to adapter cast into an unsigned long
 **/

static void
e1000_82547_tx_fifo_stall(unsigned long data)
{
	struct e1000_adapter *adapter = (struct e1000_adapter *) data;
	struct net_device *netdev = adapter->netdev;
	uint32_t tctl;

J
Jesse Brandeburg 已提交
2166 2167
	if (atomic_read(&adapter->tx_fifo_stall)) {
		if ((E1000_READ_REG(&adapter->hw, TDT) ==
L
Linus Torvalds 已提交
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
		    E1000_READ_REG(&adapter->hw, TDH)) &&
		   (E1000_READ_REG(&adapter->hw, TDFT) ==
		    E1000_READ_REG(&adapter->hw, TDFH)) &&
		   (E1000_READ_REG(&adapter->hw, TDFTS) ==
		    E1000_READ_REG(&adapter->hw, TDFHS))) {
			tctl = E1000_READ_REG(&adapter->hw, TCTL);
			E1000_WRITE_REG(&adapter->hw, TCTL,
					tctl & ~E1000_TCTL_EN);
			E1000_WRITE_REG(&adapter->hw, TDFT,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TDFH,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TDFTS,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TDFHS,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
			E1000_WRITE_FLUSH(&adapter->hw);

			adapter->tx_fifo_head = 0;
			atomic_set(&adapter->tx_fifo_stall, 0);
			netif_wake_queue(netdev);
		} else {
			mod_timer(&adapter->tx_fifo_stall_timer, jiffies + 1);
		}
	}
}

/**
 * e1000_watchdog - Timer Call-back
 * @data: pointer to adapter cast into an unsigned long
 **/
static void
e1000_watchdog(unsigned long data)
{
	struct e1000_adapter *adapter = (struct e1000_adapter *) data;

	/* Do the rest outside of interrupt context */
	schedule_work(&adapter->watchdog_task);
}

static void
e1000_watchdog_task(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
J
Jeff Kirsher 已提交
2213
	struct e1000_tx_ring *txdr = adapter->tx_ring;
2214
	uint32_t link, tctl;
L
Linus Torvalds 已提交
2215 2216

	e1000_check_for_link(&adapter->hw);
2217 2218
	if (adapter->hw.mac_type == e1000_82573) {
		e1000_enable_tx_pkt_filtering(&adapter->hw);
J
Jesse Brandeburg 已提交
2219
		if (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id)
2220
			e1000_update_mng_vlan(adapter);
J
Jesse Brandeburg 已提交
2221
	}
L
Linus Torvalds 已提交
2222

J
Jesse Brandeburg 已提交
2223
	if ((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
L
Linus Torvalds 已提交
2224 2225 2226 2227 2228
	   !(E1000_READ_REG(&adapter->hw, TXCW) & E1000_TXCW_ANE))
		link = !adapter->hw.serdes_link_down;
	else
		link = E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU;

J
Jesse Brandeburg 已提交
2229 2230
	if (link) {
		if (!netif_carrier_ok(netdev)) {
2231
			boolean_t txb2b = 1;
L
Linus Torvalds 已提交
2232 2233 2234 2235 2236 2237 2238 2239 2240
			e1000_get_speed_and_duplex(&adapter->hw,
			                           &adapter->link_speed,
			                           &adapter->link_duplex);

			DPRINTK(LINK, INFO, "NIC Link is Up %d Mbps %s\n",
			       adapter->link_speed,
			       adapter->link_duplex == FULL_DUPLEX ?
			       "Full Duplex" : "Half Duplex");

2241 2242
			/* tweak tx_queue_len according to speed/duplex
			 * and adjust the timeout factor */
2243 2244
			netdev->tx_queue_len = adapter->tx_queue_len;
			adapter->tx_timeout_factor = 1;
2245 2246
			switch (adapter->link_speed) {
			case SPEED_10:
2247
				txb2b = 0;
2248 2249 2250 2251
				netdev->tx_queue_len = 10;
				adapter->tx_timeout_factor = 8;
				break;
			case SPEED_100:
2252
				txb2b = 0;
2253 2254 2255 2256 2257
				netdev->tx_queue_len = 100;
				/* maybe add some timeout factor ? */
				break;
			}

2258
			if ((adapter->hw.mac_type == e1000_82571 ||
2259
			     adapter->hw.mac_type == e1000_82572) &&
2260
			    txb2b == 0) {
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
#define SPEED_MODE_BIT (1 << 21)
				uint32_t tarc0;
				tarc0 = E1000_READ_REG(&adapter->hw, TARC0);
				tarc0 &= ~SPEED_MODE_BIT;
				E1000_WRITE_REG(&adapter->hw, TARC0, tarc0);
			}
				
#ifdef NETIF_F_TSO
			/* disable TSO for pcie and 10/100 speeds, to avoid
			 * some hardware issues */
			if (!adapter->tso_force &&
			    adapter->hw.bus_type == e1000_bus_type_pci_express){
2273 2274 2275
				switch (adapter->link_speed) {
				case SPEED_10:
				case SPEED_100:
2276 2277 2278 2279 2280 2281 2282 2283 2284
					DPRINTK(PROBE,INFO,
				        "10/100 speed: disabling TSO\n");
					netdev->features &= ~NETIF_F_TSO;
					break;
				case SPEED_1000:
					netdev->features |= NETIF_F_TSO;
					break;
				default:
					/* oops */
2285 2286 2287
					break;
				}
			}
2288 2289 2290 2291 2292 2293 2294
#endif

			/* enable transmits in the hardware, need to do this
			 * after setting TARC0 */
			tctl = E1000_READ_REG(&adapter->hw, TCTL);
			tctl |= E1000_TCTL_EN;
			E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
2295

L
Linus Torvalds 已提交
2296 2297 2298 2299 2300 2301
			netif_carrier_on(netdev);
			netif_wake_queue(netdev);
			mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
			adapter->smartspeed = 0;
		}
	} else {
J
Jesse Brandeburg 已提交
2302
		if (netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
2303 2304 2305 2306 2307 2308
			adapter->link_speed = 0;
			adapter->link_duplex = 0;
			DPRINTK(LINK, INFO, "NIC Link is Down\n");
			netif_carrier_off(netdev);
			netif_stop_queue(netdev);
			mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318

			/* 80003ES2LAN workaround--
			 * For packet buffer work-around on link down event;
			 * disable receives in the ISR and
			 * reset device here in the watchdog
			 */
			if (adapter->hw.mac_type == e1000_80003es2lan) {
				/* reset device */
				schedule_work(&adapter->reset_task);
			}
L
Linus Torvalds 已提交
2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337
		}

		e1000_smartspeed(adapter);
	}

	e1000_update_stats(adapter);

	adapter->hw.tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
	adapter->tpt_old = adapter->stats.tpt;
	adapter->hw.collision_delta = adapter->stats.colc - adapter->colc_old;
	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;

	e1000_update_adaptive(&adapter->hw);

2338
	if (!netif_carrier_ok(netdev)) {
2339
		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
L
Linus Torvalds 已提交
2340 2341 2342 2343
			/* 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). */
2344 2345
			adapter->tx_timeout_count++;
			schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
2346 2347 2348 2349
		}
	}

	/* Dynamic mode for Interrupt Throttle Rate (ITR) */
J
Jesse Brandeburg 已提交
2350
	if (adapter->hw.mac_type >= e1000_82540 && adapter->itr == 1) {
L
Linus Torvalds 已提交
2351 2352 2353 2354
		/* Symmetric Tx/Rx gets a reduced ITR=2000; Total
		 * asymmetrical Tx or Rx gets ITR=8000; everyone
		 * else is between 2000-8000. */
		uint32_t goc = (adapter->gotcl + adapter->gorcl) / 10000;
J
Jesse Brandeburg 已提交
2355
		uint32_t dif = (adapter->gotcl > adapter->gorcl ?
L
Linus Torvalds 已提交
2356 2357 2358 2359 2360 2361 2362 2363 2364
			adapter->gotcl - adapter->gorcl :
			adapter->gorcl - adapter->gotcl) / 10000;
		uint32_t itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
		E1000_WRITE_REG(&adapter->hw, ITR, 1000000000 / (itr * 256));
	}

	/* Cause software interrupt to ensure rx ring is cleaned */
	E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0);

2365
	/* Force detection of hung controller every watchdog period */
L
Linus Torvalds 已提交
2366 2367
	adapter->detect_tx_hung = TRUE;

J
Jesse Brandeburg 已提交
2368
	/* With 82571 controllers, LAA may be overwritten due to controller
2369 2370 2371 2372
	 * reset from the other port. Set the appropriate LAA in RAR[0] */
	if (adapter->hw.mac_type == e1000_82571 && adapter->hw.laa_is_present)
		e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);

L
Linus Torvalds 已提交
2373 2374 2375 2376 2377 2378 2379
	/* Reset the timer */
	mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
}

#define E1000_TX_FLAGS_CSUM		0x00000001
#define E1000_TX_FLAGS_VLAN		0x00000002
#define E1000_TX_FLAGS_TSO		0x00000004
2380
#define E1000_TX_FLAGS_IPV4		0x00000008
L
Linus Torvalds 已提交
2381 2382 2383
#define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT	16

2384
static int
2385 2386
e1000_tso(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
          struct sk_buff *skb)
L
Linus Torvalds 已提交
2387 2388 2389
{
#ifdef NETIF_F_TSO
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2390
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2391 2392
	unsigned int i;
	uint32_t cmd_length = 0;
2393
	uint16_t ipcse = 0, tucse, mss;
L
Linus Torvalds 已提交
2394 2395 2396
	uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
	int err;

J
Jesse Brandeburg 已提交
2397
	if (skb_shinfo(skb)->tso_size) {
L
Linus Torvalds 已提交
2398 2399 2400 2401 2402 2403 2404 2405
		if (skb_header_cloned(skb)) {
			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
			if (err)
				return err;
		}

		hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
		mss = skb_shinfo(skb)->tso_size;
A
Alexey Dobriyan 已提交
2406
		if (skb->protocol == htons(ETH_P_IP)) {
2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417
			skb->nh.iph->tot_len = 0;
			skb->nh.iph->check = 0;
			skb->h.th->check =
				~csum_tcpudp_magic(skb->nh.iph->saddr,
						   skb->nh.iph->daddr,
						   0,
						   IPPROTO_TCP,
						   0);
			cmd_length = E1000_TXD_CMD_IP;
			ipcse = skb->h.raw - skb->data - 1;
#ifdef NETIF_F_TSO_IPV6
J
Jesse Brandeburg 已提交
2418
		} else if (skb->protocol == ntohs(ETH_P_IPV6)) {
2419 2420 2421 2422 2423 2424 2425 2426 2427 2428
			skb->nh.ipv6h->payload_len = 0;
			skb->h.th->check =
				~csum_ipv6_magic(&skb->nh.ipv6h->saddr,
						 &skb->nh.ipv6h->daddr,
						 0,
						 IPPROTO_TCP,
						 0);
			ipcse = 0;
#endif
		}
L
Linus Torvalds 已提交
2429 2430 2431 2432 2433 2434 2435
		ipcss = skb->nh.raw - skb->data;
		ipcso = (void *)&(skb->nh.iph->check) - (void *)skb->data;
		tucss = skb->h.raw - skb->data;
		tucso = (void *)&(skb->h.th->check) - (void *)skb->data;
		tucse = 0;

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

2438 2439
		i = tx_ring->next_to_use;
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
J
Jeff Kirsher 已提交
2440
		buffer_info = &tx_ring->buffer_info[i];
L
Linus Torvalds 已提交
2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451

		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 已提交
2452 2453
		buffer_info->time_stamp = jiffies;

2454 2455
		if (++i == tx_ring->count) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2456

2457
		return TRUE;
L
Linus Torvalds 已提交
2458 2459 2460
	}
#endif

2461
	return FALSE;
L
Linus Torvalds 已提交
2462 2463
}

2464
static boolean_t
2465 2466
e1000_tx_csum(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
              struct sk_buff *skb)
L
Linus Torvalds 已提交
2467 2468
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2469
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2470 2471 2472
	unsigned int i;
	uint8_t css;

J
Jesse Brandeburg 已提交
2473
	if (likely(skb->ip_summed == CHECKSUM_HW)) {
L
Linus Torvalds 已提交
2474 2475
		css = skb->h.raw - skb->data;

2476
		i = tx_ring->next_to_use;
J
Jeff Kirsher 已提交
2477
		buffer_info = &tx_ring->buffer_info[i];
2478
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
L
Linus Torvalds 已提交
2479 2480 2481 2482 2483 2484 2485

		context_desc->upper_setup.tcp_fields.tucss = css;
		context_desc->upper_setup.tcp_fields.tucso = css + skb->csum;
		context_desc->upper_setup.tcp_fields.tucse = 0;
		context_desc->tcp_seg_setup.data = 0;
		context_desc->cmd_and_length = cpu_to_le32(E1000_TXD_CMD_DEXT);

J
Jeff Kirsher 已提交
2486 2487
		buffer_info->time_stamp = jiffies;

2488 2489
		if (unlikely(++i == tx_ring->count)) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2490 2491 2492 2493 2494 2495 2496 2497 2498 2499

		return TRUE;
	}

	return FALSE;
}

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

2500
static int
2501 2502 2503
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 已提交
2504 2505 2506 2507 2508 2509 2510 2511 2512
{
	struct e1000_buffer *buffer_info;
	unsigned int len = skb->len;
	unsigned int offset = 0, size, count = 0, i;
	unsigned int f;
	len -= skb->data_len;

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
2513
	while (len) {
L
Linus Torvalds 已提交
2514 2515 2516
		buffer_info = &tx_ring->buffer_info[i];
		size = min(len, max_per_txd);
#ifdef NETIF_F_TSO
J
Jeff Kirsher 已提交
2517 2518 2519
		/* 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
2520
		 * DMA'd to the controller */
J
Jeff Kirsher 已提交
2521
		if (!skb->data_len && tx_ring->last_tx_tso &&
2522
		    !skb_shinfo(skb)->tso_size) {
J
Jeff Kirsher 已提交
2523 2524 2525 2526
			tx_ring->last_tx_tso = 0;
			size -= 4;
		}

L
Linus Torvalds 已提交
2527 2528
		/* Workaround for premature desc write-backs
		 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2529
		if (unlikely(mss && !nr_frags && size == len && size > 8))
L
Linus Torvalds 已提交
2530 2531
			size -= 4;
#endif
2532 2533 2534 2535 2536
		/* 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
Jesse Brandeburg 已提交
2537
		if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
2538 2539
		                (size > 2015) && count == 0))
		        size = 2015;
J
Jesse Brandeburg 已提交
2540

L
Linus Torvalds 已提交
2541 2542
		/* Workaround for potential 82544 hang in PCI-X.  Avoid
		 * terminating buffers within evenly-aligned dwords. */
J
Jesse Brandeburg 已提交
2543
		if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
		   !((unsigned long)(skb->data + offset + size - 1) & 4) &&
		   size > 4))
			size -= 4;

		buffer_info->length = size;
		buffer_info->dma =
			pci_map_single(adapter->pdev,
				skb->data + offset,
				size,
				PCI_DMA_TODEVICE);
		buffer_info->time_stamp = jiffies;

		len -= size;
		offset += size;
		count++;
J
Jesse Brandeburg 已提交
2559
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2560 2561
	}

J
Jesse Brandeburg 已提交
2562
	for (f = 0; f < nr_frags; f++) {
L
Linus Torvalds 已提交
2563 2564 2565 2566 2567 2568
		struct skb_frag_struct *frag;

		frag = &skb_shinfo(skb)->frags[f];
		len = frag->size;
		offset = frag->page_offset;

J
Jesse Brandeburg 已提交
2569
		while (len) {
L
Linus Torvalds 已提交
2570 2571 2572 2573 2574
			buffer_info = &tx_ring->buffer_info[i];
			size = min(len, max_per_txd);
#ifdef NETIF_F_TSO
			/* Workaround for premature desc write-backs
			 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2575
			if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
L
Linus Torvalds 已提交
2576 2577 2578 2579 2580
				size -= 4;
#endif
			/* Workaround for potential 82544 hang in PCI-X.
			 * Avoid terminating buffers within evenly-aligned
			 * dwords. */
J
Jesse Brandeburg 已提交
2581
			if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
			   !((unsigned long)(frag->page+offset+size-1) & 4) &&
			   size > 4))
				size -= 4;

			buffer_info->length = size;
			buffer_info->dma =
				pci_map_page(adapter->pdev,
					frag->page,
					offset,
					size,
					PCI_DMA_TODEVICE);
			buffer_info->time_stamp = jiffies;

			len -= size;
			offset += size;
			count++;
J
Jesse Brandeburg 已提交
2598
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2599 2600 2601 2602 2603 2604 2605 2606 2607 2608
		}
	}

	i = (i == 0) ? tx_ring->count - 1 : i - 1;
	tx_ring->buffer_info[i].skb = skb;
	tx_ring->buffer_info[first].next_to_watch = i;

	return count;
}

2609
static void
2610 2611
e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
               int tx_flags, int count)
L
Linus Torvalds 已提交
2612 2613 2614 2615 2616 2617
{
	struct e1000_tx_desc *tx_desc = NULL;
	struct e1000_buffer *buffer_info;
	uint32_t txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
	unsigned int i;

J
Jesse Brandeburg 已提交
2618
	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
L
Linus Torvalds 已提交
2619 2620
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
		             E1000_TXD_CMD_TSE;
2621 2622
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;

J
Jesse Brandeburg 已提交
2623
		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2624
			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
L
Linus Torvalds 已提交
2625 2626
	}

J
Jesse Brandeburg 已提交
2627
	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
L
Linus Torvalds 已提交
2628 2629 2630 2631
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
	}

J
Jesse Brandeburg 已提交
2632
	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
L
Linus Torvalds 已提交
2633 2634 2635 2636 2637 2638
		txd_lower |= E1000_TXD_CMD_VLE;
		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
	}

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
2639
	while (count--) {
L
Linus Torvalds 已提交
2640 2641 2642 2643 2644 2645
		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 已提交
2646
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657
	}

	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;
2658
	writel(i, adapter->hw.hw_addr + tx_ring->tdt);
L
Linus Torvalds 已提交
2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672
}

/**
 * 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

2673
static int
L
Linus Torvalds 已提交
2674 2675 2676 2677 2678 2679 2680
e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
{
	uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
	uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;

	E1000_ROUNDUP(skb_fifo_len, E1000_FIFO_HDR);

J
Jesse Brandeburg 已提交
2681
	if (adapter->link_duplex != HALF_DUPLEX)
L
Linus Torvalds 已提交
2682 2683
		goto no_fifo_stall_required;

J
Jesse Brandeburg 已提交
2684
	if (atomic_read(&adapter->tx_fifo_stall))
L
Linus Torvalds 已提交
2685 2686
		return 1;

J
Jesse Brandeburg 已提交
2687
	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
L
Linus Torvalds 已提交
2688 2689 2690 2691 2692 2693
		atomic_set(&adapter->tx_fifo_stall, 1);
		return 1;
	}

no_fifo_stall_required:
	adapter->tx_fifo_head += skb_fifo_len;
J
Jesse Brandeburg 已提交
2694
	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
L
Linus Torvalds 已提交
2695 2696 2697 2698
		adapter->tx_fifo_head -= adapter->tx_fifo_size;
	return 0;
}

2699
#define MINIMUM_DHCP_PACKET_SIZE 282
2700
static int
2701 2702 2703 2704
e1000_transfer_dhcp_info(struct e1000_adapter *adapter, struct sk_buff *skb)
{
	struct e1000_hw *hw =  &adapter->hw;
	uint16_t length, offset;
J
Jesse Brandeburg 已提交
2705 2706
	if (vlan_tx_tag_present(skb)) {
		if (!((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
2707 2708 2709 2710
			( adapter->hw.mng_cookie.status &
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) )
			return 0;
	}
2711
	if (skb->len > MINIMUM_DHCP_PACKET_SIZE) {
2712
		struct ethhdr *eth = (struct ethhdr *) skb->data;
J
Jesse Brandeburg 已提交
2713 2714
		if ((htons(ETH_P_IP) == eth->h_proto)) {
			const struct iphdr *ip =
2715
				(struct iphdr *)((uint8_t *)skb->data+14);
J
Jesse Brandeburg 已提交
2716 2717 2718
			if (IPPROTO_UDP == ip->protocol) {
				struct udphdr *udp =
					(struct udphdr *)((uint8_t *)ip +
2719
						(ip->ihl << 2));
J
Jesse Brandeburg 已提交
2720
				if (ntohs(udp->dest) == 67) {
2721 2722 2723 2724
					offset = (uint8_t *)udp + 8 - skb->data;
					length = skb->len - offset;

					return e1000_mng_write_dhcp_info(hw,
J
Jesse Brandeburg 已提交
2725
							(uint8_t *)udp + 8,
2726 2727 2728 2729 2730 2731 2732 2733
							length);
				}
			}
		}
	}
	return 0;
}

L
Linus Torvalds 已提交
2734 2735 2736 2737
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
static int
e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
{
2738
	struct e1000_adapter *adapter = netdev_priv(netdev);
2739
	struct e1000_tx_ring *tx_ring;
L
Linus Torvalds 已提交
2740 2741 2742 2743 2744 2745 2746 2747
	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;
	unsigned int len = skb->len;
	unsigned long flags;
	unsigned int nr_frags = 0;
	unsigned int mss = 0;
	int count = 0;
2748
	int tso;
L
Linus Torvalds 已提交
2749 2750 2751
	unsigned int f;
	len -= skb->data_len;

2752
	tx_ring = adapter->tx_ring;
2753

2754
	if (unlikely(skb->len <= 0)) {
L
Linus Torvalds 已提交
2755 2756 2757 2758 2759 2760
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

#ifdef NETIF_F_TSO
	mss = skb_shinfo(skb)->tso_size;
2761
	/* The controller does a simple calculation to
L
Linus Torvalds 已提交
2762 2763 2764 2765 2766
	 * 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 已提交
2767
	if (mss) {
J
Jeff Kirsher 已提交
2768
		uint8_t hdr_len;
L
Linus Torvalds 已提交
2769 2770
		max_per_txd = min(mss << 2, max_per_txd);
		max_txd_pwr = fls(max_per_txd) - 1;
J
Jeff Kirsher 已提交
2771

2772
	/* TSO Workaround for 82571/2/3 Controllers -- if skb->data
J
Jeff Kirsher 已提交
2773 2774 2775
	 * points to just header, pull a few bytes of payload from
	 * frags into skb->data */
		hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
2776 2777 2778 2779 2780 2781 2782 2783
		if (skb->data_len && (hdr_len == (skb->len - skb->data_len))) {
			switch (adapter->hw.mac_type) {
				unsigned int pull_size;
			case e1000_82571:
			case e1000_82572:
			case e1000_82573:
				pull_size = min((unsigned int)4, skb->data_len);
				if (!__pskb_pull_tail(skb, pull_size)) {
2784
					printk(KERN_ERR
2785 2786
						"__pskb_pull_tail failed.\n");
					dev_kfree_skb_any(skb);
J
Jeff Garzik 已提交
2787
					return NETDEV_TX_OK;
2788 2789 2790 2791 2792 2793
				}
				len = skb->len - skb->data_len;
				break;
			default:
				/* do nothing */
				break;
2794
			}
J
Jeff Kirsher 已提交
2795
		}
L
Linus Torvalds 已提交
2796 2797
	}

J
Jeff Kirsher 已提交
2798
	/* reserve a descriptor for the offload context */
J
Jesse Brandeburg 已提交
2799
	if ((mss) || (skb->ip_summed == CHECKSUM_HW))
L
Linus Torvalds 已提交
2800
		count++;
2801
	count++;
L
Linus Torvalds 已提交
2802
#else
J
Jesse Brandeburg 已提交
2803
	if (skb->ip_summed == CHECKSUM_HW)
L
Linus Torvalds 已提交
2804 2805
		count++;
#endif
J
Jeff Kirsher 已提交
2806 2807 2808 2809

#ifdef NETIF_F_TSO
	/* Controller Erratum workaround */
	if (!skb->data_len && tx_ring->last_tx_tso &&
2810
	    !skb_shinfo(skb)->tso_size)
J
Jeff Kirsher 已提交
2811 2812 2813
		count++;
#endif

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

J
Jesse Brandeburg 已提交
2816
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
2817 2818
		count++;

J
Jesse Brandeburg 已提交
2819
	/* work-around for errata 10 and it applies to all controllers
2820 2821
	 * in PCI-X mode, so add one more descriptor to the count
	 */
J
Jesse Brandeburg 已提交
2822
	if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
2823 2824 2825
			(len > 2015)))
		count++;

L
Linus Torvalds 已提交
2826
	nr_frags = skb_shinfo(skb)->nr_frags;
J
Jesse Brandeburg 已提交
2827
	for (f = 0; f < nr_frags; f++)
L
Linus Torvalds 已提交
2828 2829
		count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
				       max_txd_pwr);
J
Jesse Brandeburg 已提交
2830
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
2831 2832
		count += nr_frags;

2833 2834 2835

	if (adapter->hw.tx_pkt_filtering &&
	    (adapter->hw.mac_type == e1000_82573))
2836 2837
		e1000_transfer_dhcp_info(adapter, skb);

2838 2839 2840 2841 2842 2843
	local_irq_save(flags);
	if (!spin_trylock(&tx_ring->tx_lock)) {
		/* Collision - tell upper layer to requeue */
		local_irq_restore(flags);
		return NETDEV_TX_LOCKED;
	}
L
Linus Torvalds 已提交
2844 2845 2846

	/* need: count + 2 desc gap to keep tail from touching
	 * head, otherwise try next time */
2847
	if (unlikely(E1000_DESC_UNUSED(tx_ring) < count + 2)) {
L
Linus Torvalds 已提交
2848
		netif_stop_queue(netdev);
2849
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2850 2851 2852
		return NETDEV_TX_BUSY;
	}

J
Jesse Brandeburg 已提交
2853 2854
	if (unlikely(adapter->hw.mac_type == e1000_82547)) {
		if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
L
Linus Torvalds 已提交
2855 2856
			netif_stop_queue(netdev);
			mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
2857
			spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2858 2859 2860 2861
			return NETDEV_TX_BUSY;
		}
	}

J
Jesse Brandeburg 已提交
2862
	if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
L
Linus Torvalds 已提交
2863 2864 2865 2866
		tx_flags |= E1000_TX_FLAGS_VLAN;
		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
	}

2867
	first = tx_ring->next_to_use;
J
Jesse Brandeburg 已提交
2868

2869
	tso = e1000_tso(adapter, tx_ring, skb);
L
Linus Torvalds 已提交
2870 2871
	if (tso < 0) {
		dev_kfree_skb_any(skb);
2872
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2873 2874 2875
		return NETDEV_TX_OK;
	}

J
Jeff Kirsher 已提交
2876 2877
	if (likely(tso)) {
		tx_ring->last_tx_tso = 1;
L
Linus Torvalds 已提交
2878
		tx_flags |= E1000_TX_FLAGS_TSO;
J
Jeff Kirsher 已提交
2879
	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
L
Linus Torvalds 已提交
2880 2881
		tx_flags |= E1000_TX_FLAGS_CSUM;

2882
	/* Old method was to assume IPv4 packet by default if TSO was enabled.
2883
	 * 82571 hardware supports TSO capabilities for IPv6 as well...
2884
	 * no longer assume, we must. */
A
Alexey Dobriyan 已提交
2885
	if (likely(skb->protocol == htons(ETH_P_IP)))
2886 2887
		tx_flags |= E1000_TX_FLAGS_IPV4;

2888 2889 2890
	e1000_tx_queue(adapter, tx_ring, tx_flags,
	               e1000_tx_map(adapter, tx_ring, skb, first,
	                            max_per_txd, nr_frags, mss));
L
Linus Torvalds 已提交
2891 2892 2893 2894

	netdev->trans_start = jiffies;

	/* Make sure there is space in the ring for the next send. */
2895
	if (unlikely(E1000_DESC_UNUSED(tx_ring) < MAX_SKB_FRAGS + 2))
L
Linus Torvalds 已提交
2896 2897
		netif_stop_queue(netdev);

2898
	spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909
	return NETDEV_TX_OK;
}

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

static void
e1000_tx_timeout(struct net_device *netdev)
{
2910
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2911 2912

	/* Do the reset outside of interrupt context */
2913 2914
	adapter->tx_timeout_count++;
	schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
2915 2916 2917
}

static void
2918
e1000_reset_task(struct net_device *netdev)
L
Linus Torvalds 已提交
2919
{
2920
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936

	e1000_down(adapter);
	e1000_up(adapter);
}

/**
 * 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.
 **/

static struct net_device_stats *
e1000_get_stats(struct net_device *netdev)
{
2937
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2938

J
Jeff Kirsher 已提交
2939
	/* only return the current stats */
L
Linus Torvalds 已提交
2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953
	return &adapter->net_stats;
}

/**
 * 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
 **/

static int
e1000_change_mtu(struct net_device *netdev, int new_mtu)
{
2954
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2955
	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
2956
	uint16_t eeprom_data = 0;
L
Linus Torvalds 已提交
2957

J
Jesse Brandeburg 已提交
2958 2959 2960
	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
		DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
L
Linus Torvalds 已提交
2961
		return -EINVAL;
2962
	}
L
Linus Torvalds 已提交
2963

2964 2965
	/* Adapter-specific max frame size limits. */
	switch (adapter->hw.mac_type) {
2966
	case e1000_undefined ... e1000_82542_rev2_1:
2967 2968
		if (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
			DPRINTK(PROBE, ERR, "Jumbo Frames not supported.\n");
2969 2970
			return -EINVAL;
		}
2971
		break;
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985
	case e1000_82573:
		/* only enable jumbo frames if ASPM is disabled completely
		 * this means both bits must be zero in 0x1A bits 3:2 */
		e1000_read_eeprom(&adapter->hw, EEPROM_INIT_3GIO_3, 1,
		                  &eeprom_data);
		if (eeprom_data & EEPROM_WORD1A_ASPM_MASK) {
			if (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
				DPRINTK(PROBE, ERR,
			            	"Jumbo Frames not supported.\n");
				return -EINVAL;
			}
			break;
		}
		/* fall through to get support */
2986 2987
	case e1000_82571:
	case e1000_82572:
2988
	case e1000_80003es2lan:
2989 2990 2991 2992 2993 2994 2995 2996 2997
#define MAX_STD_JUMBO_FRAME_SIZE 9234
		if (max_frame > MAX_STD_JUMBO_FRAME_SIZE) {
			DPRINTK(PROBE, ERR, "MTU > 9216 not supported.\n");
			return -EINVAL;
		}
		break;
	default:
		/* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
		break;
L
Linus Torvalds 已提交
2998 2999
	}

3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
	/* NOTE: dev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
	 * means we reserve 2 more, this pushes us to allocate from the next
	 * larger slab size
	 * i.e. RXBUFFER_2048 --> size-4096 slab */

	if (max_frame <= E1000_RXBUFFER_256)
		adapter->rx_buffer_len = E1000_RXBUFFER_256;
	else if (max_frame <= E1000_RXBUFFER_512)
		adapter->rx_buffer_len = E1000_RXBUFFER_512;
	else if (max_frame <= E1000_RXBUFFER_1024)
		adapter->rx_buffer_len = E1000_RXBUFFER_1024;
	else if (max_frame <= E1000_RXBUFFER_2048)
		adapter->rx_buffer_len = E1000_RXBUFFER_2048;
	else if (max_frame <= E1000_RXBUFFER_4096)
		adapter->rx_buffer_len = E1000_RXBUFFER_4096;
	else if (max_frame <= E1000_RXBUFFER_8192)
		adapter->rx_buffer_len = E1000_RXBUFFER_8192;
	else if (max_frame <= E1000_RXBUFFER_16384)
		adapter->rx_buffer_len = E1000_RXBUFFER_16384;

	/* adjust allocation if LPE protects us, and we aren't using SBP */
#define MAXIMUM_ETHERNET_VLAN_SIZE 1522
	if (!adapter->hw.tbi_compatibility_on &&
	    ((max_frame == MAXIMUM_ETHERNET_FRAME_SIZE) ||
	     (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
		adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
3026

3027 3028
	netdev->mtu = new_mtu;

J
Jesse Brandeburg 已提交
3029
	if (netif_running(netdev)) {
L
Linus Torvalds 已提交
3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052
		e1000_down(adapter);
		e1000_up(adapter);
	}

	adapter->hw.max_frame_size = max_frame;

	return 0;
}

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

void
e1000_update_stats(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	unsigned long flags;
	uint16_t phy_tmp;

#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF

A
Auke Kok 已提交
3053 3054 3055 3056
	/* Prevent stats update while adapter is being reset */
	if (adapter->link_speed == 0)
		return;

L
Linus Torvalds 已提交
3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119
	spin_lock_irqsave(&adapter->stats_lock, flags);

	/* these counters are modified from e1000_adjust_tbi_stats,
	 * called from the interrupt context, so they must only
	 * be written while holding adapter->stats_lock
	 */

	adapter->stats.crcerrs += E1000_READ_REG(hw, CRCERRS);
	adapter->stats.gprc += E1000_READ_REG(hw, GPRC);
	adapter->stats.gorcl += E1000_READ_REG(hw, GORCL);
	adapter->stats.gorch += E1000_READ_REG(hw, GORCH);
	adapter->stats.bprc += E1000_READ_REG(hw, BPRC);
	adapter->stats.mprc += E1000_READ_REG(hw, MPRC);
	adapter->stats.roc += E1000_READ_REG(hw, ROC);
	adapter->stats.prc64 += E1000_READ_REG(hw, PRC64);
	adapter->stats.prc127 += E1000_READ_REG(hw, PRC127);
	adapter->stats.prc255 += E1000_READ_REG(hw, PRC255);
	adapter->stats.prc511 += E1000_READ_REG(hw, PRC511);
	adapter->stats.prc1023 += E1000_READ_REG(hw, PRC1023);
	adapter->stats.prc1522 += E1000_READ_REG(hw, PRC1522);

	adapter->stats.symerrs += E1000_READ_REG(hw, SYMERRS);
	adapter->stats.mpc += E1000_READ_REG(hw, MPC);
	adapter->stats.scc += E1000_READ_REG(hw, SCC);
	adapter->stats.ecol += E1000_READ_REG(hw, ECOL);
	adapter->stats.mcc += E1000_READ_REG(hw, MCC);
	adapter->stats.latecol += E1000_READ_REG(hw, LATECOL);
	adapter->stats.dc += E1000_READ_REG(hw, DC);
	adapter->stats.sec += E1000_READ_REG(hw, SEC);
	adapter->stats.rlec += E1000_READ_REG(hw, RLEC);
	adapter->stats.xonrxc += E1000_READ_REG(hw, XONRXC);
	adapter->stats.xontxc += E1000_READ_REG(hw, XONTXC);
	adapter->stats.xoffrxc += E1000_READ_REG(hw, XOFFRXC);
	adapter->stats.xofftxc += E1000_READ_REG(hw, XOFFTXC);
	adapter->stats.fcruc += E1000_READ_REG(hw, FCRUC);
	adapter->stats.gptc += E1000_READ_REG(hw, GPTC);
	adapter->stats.gotcl += E1000_READ_REG(hw, GOTCL);
	adapter->stats.gotch += E1000_READ_REG(hw, GOTCH);
	adapter->stats.rnbc += E1000_READ_REG(hw, RNBC);
	adapter->stats.ruc += E1000_READ_REG(hw, RUC);
	adapter->stats.rfc += E1000_READ_REG(hw, RFC);
	adapter->stats.rjc += E1000_READ_REG(hw, RJC);
	adapter->stats.torl += E1000_READ_REG(hw, TORL);
	adapter->stats.torh += E1000_READ_REG(hw, TORH);
	adapter->stats.totl += E1000_READ_REG(hw, TOTL);
	adapter->stats.toth += E1000_READ_REG(hw, TOTH);
	adapter->stats.tpr += E1000_READ_REG(hw, TPR);
	adapter->stats.ptc64 += E1000_READ_REG(hw, PTC64);
	adapter->stats.ptc127 += E1000_READ_REG(hw, PTC127);
	adapter->stats.ptc255 += E1000_READ_REG(hw, PTC255);
	adapter->stats.ptc511 += E1000_READ_REG(hw, PTC511);
	adapter->stats.ptc1023 += E1000_READ_REG(hw, PTC1023);
	adapter->stats.ptc1522 += E1000_READ_REG(hw, PTC1522);
	adapter->stats.mptc += E1000_READ_REG(hw, MPTC);
	adapter->stats.bptc += E1000_READ_REG(hw, BPTC);

	/* used for adaptive IFS */

	hw->tx_packet_delta = E1000_READ_REG(hw, TPT);
	adapter->stats.tpt += hw->tx_packet_delta;
	hw->collision_delta = E1000_READ_REG(hw, COLC);
	adapter->stats.colc += hw->collision_delta;

J
Jesse Brandeburg 已提交
3120
	if (hw->mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
3121 3122 3123 3124 3125 3126 3127
		adapter->stats.algnerrc += E1000_READ_REG(hw, ALGNERRC);
		adapter->stats.rxerrc += E1000_READ_REG(hw, RXERRC);
		adapter->stats.tncrs += E1000_READ_REG(hw, TNCRS);
		adapter->stats.cexterr += E1000_READ_REG(hw, CEXTERR);
		adapter->stats.tsctc += E1000_READ_REG(hw, TSCTC);
		adapter->stats.tsctfc += E1000_READ_REG(hw, TSCTFC);
	}
J
Jesse Brandeburg 已提交
3128
	if (hw->mac_type > e1000_82547_rev_2) {
3129 3130 3131 3132 3133 3134 3135 3136 3137 3138
		adapter->stats.iac += E1000_READ_REG(hw, IAC);
		adapter->stats.icrxoc += E1000_READ_REG(hw, ICRXOC);
		adapter->stats.icrxptc += E1000_READ_REG(hw, ICRXPTC);
		adapter->stats.icrxatc += E1000_READ_REG(hw, ICRXATC);
		adapter->stats.ictxptc += E1000_READ_REG(hw, ICTXPTC);
		adapter->stats.ictxatc += E1000_READ_REG(hw, ICTXATC);
		adapter->stats.ictxqec += E1000_READ_REG(hw, ICTXQEC);
		adapter->stats.ictxqmtc += E1000_READ_REG(hw, ICTXQMTC);
		adapter->stats.icrxdmtc += E1000_READ_REG(hw, ICRXDMTC);
	}
L
Linus Torvalds 已提交
3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150

	/* Fill out the OS statistics structure */

	adapter->net_stats.rx_packets = adapter->stats.gprc;
	adapter->net_stats.tx_packets = adapter->stats.gptc;
	adapter->net_stats.rx_bytes = adapter->stats.gorcl;
	adapter->net_stats.tx_bytes = adapter->stats.gotcl;
	adapter->net_stats.multicast = adapter->stats.mprc;
	adapter->net_stats.collisions = adapter->stats.colc;

	/* Rx Errors */

3151 3152
	/* RLEC on some newer hardware can be incorrect so build
	* our own version based on RUC and ROC */
L
Linus Torvalds 已提交
3153 3154
	adapter->net_stats.rx_errors = adapter->stats.rxerrc +
		adapter->stats.crcerrs + adapter->stats.algnerrc +
3155 3156 3157 3158
		adapter->stats.ruc + adapter->stats.roc +
		adapter->stats.cexterr;
	adapter->net_stats.rx_length_errors = adapter->stats.ruc +
	                                      adapter->stats.roc;
L
Linus Torvalds 已提交
3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
	adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
	adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
	adapter->net_stats.rx_missed_errors = adapter->stats.mpc;

	/* Tx Errors */

	adapter->net_stats.tx_errors = adapter->stats.ecol +
	                               adapter->stats.latecol;
	adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
	adapter->net_stats.tx_window_errors = adapter->stats.latecol;
	adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;

	/* Tx Dropped needs to be maintained elsewhere */

	/* Phy Stats */

J
Jesse Brandeburg 已提交
3175 3176
	if (hw->media_type == e1000_media_type_copper) {
		if ((adapter->link_speed == SPEED_1000) &&
L
Linus Torvalds 已提交
3177 3178 3179 3180 3181
		   (!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 已提交
3182
		if ((hw->mac_type <= e1000_82546) &&
L
Linus Torvalds 已提交
3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201
		   (hw->phy_type == e1000_phy_m88) &&
		   !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
			adapter->phy_stats.receive_errors += phy_tmp;
	}

	spin_unlock_irqrestore(&adapter->stats_lock, flags);
}

/**
 * e1000_intr - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 * @pt_regs: CPU registers structure
 **/

static irqreturn_t
e1000_intr(int irq, void *data, struct pt_regs *regs)
{
	struct net_device *netdev = data;
3202
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3203
	struct e1000_hw *hw = &adapter->hw;
3204
	uint32_t rctl, icr = E1000_READ_REG(hw, ICR);
3205
#ifndef CONFIG_E1000_NAPI
3206
	int i;
3207 3208 3209 3210 3211 3212 3213
#else
	/* Interrupt Auto-Mask...upon reading ICR,
	 * interrupts are masked.  No need for the
	 * IMC write, but it does mean we should
	 * account for it ASAP. */
	if (likely(hw->mac_type >= e1000_82571))
		atomic_inc(&adapter->irq_sem);
J
Jeff Garzik 已提交
3214
#endif
L
Linus Torvalds 已提交
3215

3216 3217 3218 3219 3220
	if (unlikely(!icr)) {
#ifdef CONFIG_E1000_NAPI
		if (hw->mac_type >= e1000_82571)
			e1000_irq_enable(adapter);
#endif
L
Linus Torvalds 已提交
3221
		return IRQ_NONE;  /* Not our interrupt */
3222
	}
L
Linus Torvalds 已提交
3223

J
Jesse Brandeburg 已提交
3224
	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
L
Linus Torvalds 已提交
3225
		hw->get_link_status = 1;
3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236
		/* 80003ES2LAN workaround--
		 * For packet buffer work-around on link down event;
		 * disable receives here in the ISR and
		 * reset adapter in watchdog
		 */
		if (netif_carrier_ok(netdev) &&
		    (adapter->hw.mac_type == e1000_80003es2lan)) {
			/* disable receives */
			rctl = E1000_READ_REG(hw, RCTL);
			E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
		}
L
Linus Torvalds 已提交
3237 3238 3239 3240
		mod_timer(&adapter->watchdog_timer, jiffies);
	}

#ifdef CONFIG_E1000_NAPI
3241 3242 3243 3244 3245
	if (unlikely(hw->mac_type < e1000_82571)) {
		atomic_inc(&adapter->irq_sem);
		E1000_WRITE_REG(hw, IMC, ~0);
		E1000_WRITE_FLUSH(hw);
	}
3246 3247 3248 3249
	if (likely(netif_rx_schedule_prep(&adapter->polling_netdev[0])))
		__netif_rx_schedule(&adapter->polling_netdev[0]);
	else
		e1000_irq_enable(adapter);
3250
#else
L
Linus Torvalds 已提交
3251
	/* Writing IMC and IMS is needed for 82547.
J
Jesse Brandeburg 已提交
3252 3253 3254 3255 3256 3257 3258 3259 3260 3261
	 * Due to Hub Link bus being occupied, an interrupt
	 * de-assertion message is not able to be sent.
	 * When an interrupt assertion message is generated later,
	 * two messages are re-ordered and sent out.
	 * That causes APIC to think 82547 is in de-assertion
	 * state, while 82547 is in assertion state, resulting
	 * in dead lock. Writing IMC forces 82547 into
	 * de-assertion state.
	 */
	if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2) {
L
Linus Torvalds 已提交
3262
		atomic_inc(&adapter->irq_sem);
3263
		E1000_WRITE_REG(hw, IMC, ~0);
L
Linus Torvalds 已提交
3264 3265
	}

J
Jesse Brandeburg 已提交
3266 3267
	for (i = 0; i < E1000_MAX_INTR; i++)
		if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) &
3268
		   !e1000_clean_tx_irq(adapter, adapter->tx_ring)))
L
Linus Torvalds 已提交
3269 3270
			break;

J
Jesse Brandeburg 已提交
3271
	if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)
L
Linus Torvalds 已提交
3272
		e1000_irq_enable(adapter);
3273

3274
#endif
L
Linus Torvalds 已提交
3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285

	return IRQ_HANDLED;
}

#ifdef CONFIG_E1000_NAPI
/**
 * e1000_clean - NAPI Rx polling callback
 * @adapter: board private structure
 **/

static int
3286
e1000_clean(struct net_device *poll_dev, int *budget)
L
Linus Torvalds 已提交
3287
{
3288 3289
	struct e1000_adapter *adapter;
	int work_to_do = min(*budget, poll_dev->quota);
3290
	int tx_cleaned = 0, i = 0, work_done = 0;
3291 3292 3293 3294 3295 3296 3297

	/* Must NOT use netdev_priv macro here. */
	adapter = poll_dev->priv;

	/* Keep link state information with original netdev */
	if (!netif_carrier_ok(adapter->netdev))
		goto quit_polling;
3298

3299 3300
	while (poll_dev != &adapter->polling_netdev[i]) {
		i++;
3301
		BUG_ON(i == adapter->num_rx_queues);
3302 3303
	}

3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316
	if (likely(adapter->num_tx_queues == 1)) {
		/* e1000_clean is called per-cpu.  This lock protects
		 * tx_ring[0] from being cleaned by multiple cpus
		 * simultaneously.  A failure obtaining the lock means
		 * tx_ring[0] is currently being cleaned anyway. */
		if (spin_trylock(&adapter->tx_queue_lock)) {
			tx_cleaned = e1000_clean_tx_irq(adapter,
							&adapter->tx_ring[0]);
			spin_unlock(&adapter->tx_queue_lock);
		}
	} else
		tx_cleaned = e1000_clean_tx_irq(adapter, &adapter->tx_ring[i]);

3317 3318
	adapter->clean_rx(adapter, &adapter->rx_ring[i],
	                  &work_done, work_to_do);
L
Linus Torvalds 已提交
3319 3320

	*budget -= work_done;
3321
	poll_dev->quota -= work_done;
J
Jesse Brandeburg 已提交
3322

3323
	/* If no Tx and not enough Rx work done, exit the polling mode */
J
Jesse Brandeburg 已提交
3324
	if ((!tx_cleaned && (work_done == 0)) ||
3325 3326 3327
	   !netif_running(adapter->netdev)) {
quit_polling:
		netif_rx_complete(poll_dev);
L
Linus Torvalds 已提交
3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341
		e1000_irq_enable(adapter);
		return 0;
	}

	return 1;
}

#endif
/**
 * e1000_clean_tx_irq - Reclaim resources after transmit completes
 * @adapter: board private structure
 **/

static boolean_t
3342 3343
e1000_clean_tx_irq(struct e1000_adapter *adapter,
                   struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
3344 3345 3346 3347 3348
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_tx_desc *tx_desc, *eop_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i, eop;
3349 3350 3351
#ifdef CONFIG_E1000_NAPI
	unsigned int count = 0;
#endif
L
Linus Torvalds 已提交
3352 3353 3354 3355 3356 3357
	boolean_t cleaned = FALSE;

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

3358
	while (eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
J
Jesse Brandeburg 已提交
3359
		for (cleaned = FALSE; !cleaned; ) {
L
Linus Torvalds 已提交
3360 3361 3362 3363
			tx_desc = E1000_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];
			cleaned = (i == eop);

J
Jeff Kirsher 已提交
3364
			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3365
			memset(tx_desc, 0, sizeof(struct e1000_tx_desc));
L
Linus Torvalds 已提交
3366

J
Jesse Brandeburg 已提交
3367
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3368
		}
3369

3370

L
Linus Torvalds 已提交
3371 3372
		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = E1000_TX_DESC(*tx_ring, eop);
3373 3374 3375 3376 3377
#ifdef CONFIG_E1000_NAPI
#define E1000_TX_WEIGHT 64
		/* weight of a sort for tx, to avoid endless transmit cleanup */
		if (count++ == E1000_TX_WEIGHT) break;
#endif
L
Linus Torvalds 已提交
3378 3379 3380 3381
	}

	tx_ring->next_to_clean = i;

3382
#define TX_WAKE_THRESHOLD 32
J
Jesse Brandeburg 已提交
3383
	if (unlikely(cleaned && netif_queue_stopped(netdev) &&
3384 3385 3386 3387 3388 3389 3390
	             netif_carrier_ok(netdev))) {
		spin_lock(&tx_ring->tx_lock);
		if (netif_queue_stopped(netdev) &&
		    (E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD))
			netif_wake_queue(netdev);
		spin_unlock(&tx_ring->tx_lock);
	}
3391

3392
	if (adapter->detect_tx_hung) {
3393
		/* Detect a transmit hang in hardware, this serializes the
L
Linus Torvalds 已提交
3394 3395
		 * check with the clearing of time_stamp and movement of i */
		adapter->detect_tx_hung = FALSE;
3396 3397
		if (tx_ring->buffer_info[eop].dma &&
		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
3398
		               (adapter->tx_timeout_factor * HZ))
3399
		    && !(E1000_READ_REG(&adapter->hw, STATUS) &
3400
		         E1000_STATUS_TXOFF)) {
3401 3402

			/* detected Tx unit hang */
3403
			DPRINTK(DRV, ERR, "Detected Tx Unit Hang\n"
3404
					"  Tx Queue             <%lu>\n"
3405 3406 3407 3408 3409 3410 3411 3412 3413
					"  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",
3414 3415
				(unsigned long)((tx_ring - adapter->tx_ring) /
					sizeof(struct e1000_tx_ring)),
3416 3417
				readl(adapter->hw.hw_addr + tx_ring->tdh),
				readl(adapter->hw.hw_addr + tx_ring->tdt),
3418
				tx_ring->next_to_use,
3419 3420
				tx_ring->next_to_clean,
				tx_ring->buffer_info[eop].time_stamp,
3421 3422 3423
				eop,
				jiffies,
				eop_desc->upper.fields.status);
L
Linus Torvalds 已提交
3424
			netif_stop_queue(netdev);
3425
		}
L
Linus Torvalds 已提交
3426 3427 3428 3429 3430 3431
	}
	return cleaned;
}

/**
 * e1000_rx_checksum - Receive Checksum Offload for 82543
3432 3433 3434 3435
 * @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 已提交
3436 3437
 **/

3438
static void
L
Linus Torvalds 已提交
3439
e1000_rx_checksum(struct e1000_adapter *adapter,
3440 3441
		  uint32_t status_err, uint32_t csum,
		  struct sk_buff *skb)
L
Linus Torvalds 已提交
3442
{
3443 3444 3445 3446
	uint16_t status = (uint16_t)status_err;
	uint8_t errors = (uint8_t)(status_err >> 24);
	skb->ip_summed = CHECKSUM_NONE;

L
Linus Torvalds 已提交
3447
	/* 82543 or newer only */
J
Jesse Brandeburg 已提交
3448
	if (unlikely(adapter->hw.mac_type < e1000_82543)) return;
L
Linus Torvalds 已提交
3449
	/* Ignore Checksum bit is set */
J
Jesse Brandeburg 已提交
3450
	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3451
	/* TCP/UDP checksum error bit is set */
J
Jesse Brandeburg 已提交
3452
	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
L
Linus Torvalds 已提交
3453 3454
		/* let the stack verify checksum errors */
		adapter->hw_csum_err++;
3455 3456 3457
		return;
	}
	/* TCP/UDP Checksum has not been calculated */
J
Jesse Brandeburg 已提交
3458 3459
	if (adapter->hw.mac_type <= e1000_82547_rev_2) {
		if (!(status & E1000_RXD_STAT_TCPCS))
3460
			return;
L
Linus Torvalds 已提交
3461
	} else {
J
Jesse Brandeburg 已提交
3462
		if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))
3463 3464 3465 3466
			return;
	}
	/* It must be a TCP or UDP packet with a valid checksum */
	if (likely(status & E1000_RXD_STAT_TCPCS)) {
L
Linus Torvalds 已提交
3467 3468
		/* TCP checksum is good */
		skb->ip_summed = CHECKSUM_UNNECESSARY;
3469 3470 3471 3472 3473 3474 3475 3476
	} else if (adapter->hw.mac_type > e1000_82547_rev_2) {
		/* IP fragment with UDP payload */
		/* Hardware complements the payload checksum, so we undo it
		 * and then put the value in host order for further stack use.
		 */
		csum = ntohl(csum ^ 0xFFFF);
		skb->csum = csum;
		skb->ip_summed = CHECKSUM_HW;
L
Linus Torvalds 已提交
3477
	}
3478
	adapter->hw_csum_good++;
L
Linus Torvalds 已提交
3479 3480 3481
}

/**
3482
 * e1000_clean_rx_irq - Send received data up the network stack; legacy
L
Linus Torvalds 已提交
3483 3484 3485 3486 3487
 * @adapter: board private structure
 **/

static boolean_t
#ifdef CONFIG_E1000_NAPI
3488 3489 3490
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring,
                   int *work_done, int work_to_do)
L
Linus Torvalds 已提交
3491
#else
3492 3493
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
3494 3495 3496 3497
#endif
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3498 3499
	struct e1000_rx_desc *rx_desc, *next_rxd;
	struct e1000_buffer *buffer_info, *next_buffer;
L
Linus Torvalds 已提交
3500 3501 3502 3503
	unsigned long flags;
	uint32_t length;
	uint8_t last_byte;
	unsigned int i;
3504
	int cleaned_count = 0;
3505
	boolean_t cleaned = FALSE;
L
Linus Torvalds 已提交
3506 3507 3508

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

3511
	while (rx_desc->status & E1000_RXD_STAT_DD) {
3512
		struct sk_buff *skb;
3513
		u8 status;
L
Linus Torvalds 已提交
3514
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3515
		if (*work_done >= work_to_do)
L
Linus Torvalds 已提交
3516 3517 3518
			break;
		(*work_done)++;
#endif
3519
		status = rx_desc->status;
3520
		skb = buffer_info->skb;
3521 3522
		buffer_info->skb = NULL;

3523 3524
		prefetch(skb->data - NET_IP_ALIGN);

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

3529 3530
		next_buffer = &rx_ring->buffer_info[i];

3531 3532
		cleaned = TRUE;
		cleaned_count++;
3533 3534 3535
		pci_unmap_single(pdev,
		                 buffer_info->dma,
		                 buffer_info->length,
L
Linus Torvalds 已提交
3536 3537 3538 3539
		                 PCI_DMA_FROMDEVICE);

		length = le16_to_cpu(rx_desc->length);

3540 3541 3542 3543 3544
		if (unlikely(!(status & E1000_RXD_STAT_EOP))) {
			/* All receives must fit into a single buffer */
			E1000_DBG("%s: Receive packet consumed multiple"
				  " buffers\n", netdev->name);
			dev_kfree_skb_irq(skb);
L
Linus Torvalds 已提交
3545 3546 3547
			goto next_desc;
		}

J
Jesse Brandeburg 已提交
3548
		if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
L
Linus Torvalds 已提交
3549
			last_byte = *(skb->data + length - 1);
3550
			if (TBI_ACCEPT(&adapter->hw, status,
L
Linus Torvalds 已提交
3551 3552
			              rx_desc->errors, length, last_byte)) {
				spin_lock_irqsave(&adapter->stats_lock, flags);
3553 3554
				e1000_tbi_adjust_stats(&adapter->hw,
				                       &adapter->stats,
L
Linus Torvalds 已提交
3555 3556 3557 3558 3559
				                       length, skb->data);
				spin_unlock_irqrestore(&adapter->stats_lock,
				                       flags);
				length--;
			} else {
3560 3561
				/* recycle */
				buffer_info->skb = skb;
L
Linus Torvalds 已提交
3562 3563
				goto next_desc;
			}
A
Auke Kok 已提交
3564
		}
L
Linus Torvalds 已提交
3565

3566 3567 3568 3569
		/* code added for copybreak, this should improve
		 * performance for small packets with large amounts
		 * of reassembly being done in the stack */
#define E1000_CB_LENGTH 256
3570
		if (length < E1000_CB_LENGTH) {
3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583
			struct sk_buff *new_skb =
			    dev_alloc_skb(length + NET_IP_ALIGN);
			if (new_skb) {
				skb_reserve(new_skb, NET_IP_ALIGN);
				new_skb->dev = netdev;
				memcpy(new_skb->data - 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;
				skb_put(skb, length);
			}
3584 3585
		} else
			skb_put(skb, length);
3586 3587

		/* end copybreak code */
L
Linus Torvalds 已提交
3588 3589

		/* Receive Checksum Offload */
3590 3591
		e1000_rx_checksum(adapter,
				  (uint32_t)(status) |
3592
				  ((uint32_t)(rx_desc->errors) << 24),
D
David S. Miller 已提交
3593
				  le16_to_cpu(rx_desc->csum), skb);
J
Jesse Brandeburg 已提交
3594

L
Linus Torvalds 已提交
3595 3596
		skb->protocol = eth_type_trans(skb, netdev);
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3597
		if (unlikely(adapter->vlgrp &&
3598
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
3599
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
3600 3601
						 le16_to_cpu(rx_desc->special) &
						 E1000_RXD_SPC_VLAN_MASK);
L
Linus Torvalds 已提交
3602 3603 3604 3605
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
3606
		if (unlikely(adapter->vlgrp &&
3607
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619
			vlan_hwaccel_rx(skb, adapter->vlgrp,
					le16_to_cpu(rx_desc->special) &
					E1000_RXD_SPC_VLAN_MASK);
		} else {
			netif_rx(skb);
		}
#endif /* CONFIG_E1000_NAPI */
		netdev->last_rx = jiffies;

next_desc:
		rx_desc->status = 0;

3620 3621 3622 3623 3624 3625
		/* 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;
		}

3626
		/* use prefetched values */
3627 3628
		rx_desc = next_rxd;
		buffer_info = next_buffer;
L
Linus Torvalds 已提交
3629 3630
	}
	rx_ring->next_to_clean = i;
3631 3632 3633 3634

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645

	return cleaned;
}

/**
 * e1000_clean_rx_irq_ps - Send received data up the network stack; packet split
 * @adapter: board private structure
 **/

static boolean_t
#ifdef CONFIG_E1000_NAPI
3646 3647 3648
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring,
                      int *work_done, int work_to_do)
3649
#else
3650 3651
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring)
3652 3653
#endif
{
3654
	union e1000_rx_desc_packet_split *rx_desc, *next_rxd;
3655 3656
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3657
	struct e1000_buffer *buffer_info, *next_buffer;
3658 3659
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
3660
	struct sk_buff *skb;
3661 3662
	unsigned int i, j;
	uint32_t length, staterr;
3663
	int cleaned_count = 0;
3664 3665 3666 3667
	boolean_t cleaned = FALSE;

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC_PS(*rx_ring, i);
3668
	staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
3669
	buffer_info = &rx_ring->buffer_info[i];
3670

J
Jesse Brandeburg 已提交
3671
	while (staterr & E1000_RXD_STAT_DD) {
3672
		buffer_info = &rx_ring->buffer_info[i];
3673 3674 3675
		ps_page = &rx_ring->ps_page[i];
		ps_page_dma = &rx_ring->ps_page_dma[i];
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3676
		if (unlikely(*work_done >= work_to_do))
3677 3678 3679
			break;
		(*work_done)++;
#endif
3680 3681
		skb = buffer_info->skb;

3682 3683 3684
		/* in the packet split case this is header only */
		prefetch(skb->data - NET_IP_ALIGN);

3685 3686
		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC_PS(*rx_ring, i);
3687 3688
		prefetch(next_rxd);

3689 3690
		next_buffer = &rx_ring->buffer_info[i];

3691
		cleaned = TRUE;
3692
		cleaned_count++;
3693 3694 3695 3696
		pci_unmap_single(pdev, buffer_info->dma,
				 buffer_info->length,
				 PCI_DMA_FROMDEVICE);

J
Jesse Brandeburg 已提交
3697
		if (unlikely(!(staterr & E1000_RXD_STAT_EOP))) {
3698 3699 3700 3701 3702
			E1000_DBG("%s: Packet Split buffers didn't pick up"
				  " the full packet\n", netdev->name);
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}
L
Linus Torvalds 已提交
3703

J
Jesse Brandeburg 已提交
3704
		if (unlikely(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) {
3705 3706 3707 3708 3709 3710
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

		length = le16_to_cpu(rx_desc->wb.middle.length0);

J
Jesse Brandeburg 已提交
3711
		if (unlikely(!length)) {
3712 3713 3714 3715 3716 3717 3718 3719 3720
			E1000_DBG("%s: Last part of the packet spanning"
				  " multiple descriptors\n", netdev->name);
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

		/* Good Receive */
		skb_put(skb, length);

3721 3722 3723 3724 3725 3726 3727
		{
		/* this looks ugly, but it seems compiler issues make it
		   more efficient than reusing j */
		int l1 = le16_to_cpu(rx_desc->wb.upper.length[0]);

		/* page alloc/put takes too long and effects small packet
		 * throughput, so unsplit small packets and save the alloc/put*/
3728
		if (l1 && ((length + l1) <= adapter->rx_ps_bsize0)) {
3729
			u8 *vaddr;
3730
			/* there is no documentation about how to call
3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749
			 * kmap_atomic, so we can't hold the mapping
			 * very long */
			pci_dma_sync_single_for_cpu(pdev,
				ps_page_dma->ps_page_dma[0],
				PAGE_SIZE,
				PCI_DMA_FROMDEVICE);
			vaddr = kmap_atomic(ps_page->ps_page[0],
			                    KM_SKB_DATA_SOFTIRQ);
			memcpy(skb->tail, vaddr, l1);
			kunmap_atomic(vaddr, KM_SKB_DATA_SOFTIRQ);
			pci_dma_sync_single_for_device(pdev,
				ps_page_dma->ps_page_dma[0],
				PAGE_SIZE, PCI_DMA_FROMDEVICE);
			skb_put(skb, l1);
			length += l1;
			goto copydone;
		} /* if */
		}
		
J
Jesse Brandeburg 已提交
3750
		for (j = 0; j < adapter->rx_ps_pages; j++) {
3751
			if (!(length= le16_to_cpu(rx_desc->wb.upper.length[j])))
3752 3753 3754 3755
				break;
			pci_unmap_page(pdev, ps_page_dma->ps_page_dma[j],
					PAGE_SIZE, PCI_DMA_FROMDEVICE);
			ps_page_dma->ps_page_dma[j] = 0;
3756 3757
			skb_fill_page_desc(skb, j, ps_page->ps_page[j], 0,
			                   length);
3758 3759 3760
			ps_page->ps_page[j] = NULL;
			skb->len += length;
			skb->data_len += length;
3761
			skb->truesize += length;
3762 3763
		}

3764
copydone:
3765
		e1000_rx_checksum(adapter, staterr,
D
David S. Miller 已提交
3766
				  le16_to_cpu(rx_desc->wb.lower.hi_dword.csum_ip.csum), skb);
3767 3768
		skb->protocol = eth_type_trans(skb, netdev);

J
Jesse Brandeburg 已提交
3769
		if (likely(rx_desc->wb.upper.header_status &
D
David S. Miller 已提交
3770
			   cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP)))
3771
			adapter->rx_hdr_split++;
3772
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3773
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
3774
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
3775 3776
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
3777 3778 3779 3780
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
3781
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
3782
			vlan_hwaccel_rx(skb, adapter->vlgrp,
3783 3784
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
3785 3786 3787 3788 3789 3790 3791
		} else {
			netif_rx(skb);
		}
#endif /* CONFIG_E1000_NAPI */
		netdev->last_rx = jiffies;

next_desc:
D
David S. Miller 已提交
3792
		rx_desc->wb.middle.status_error &= cpu_to_le32(~0xFF);
3793 3794
		buffer_info->skb = NULL;

3795 3796 3797 3798 3799 3800
		/* 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;
		}

3801
		/* use prefetched values */
3802 3803 3804
		rx_desc = next_rxd;
		buffer_info = next_buffer;

3805
		staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
3806 3807
	}
	rx_ring->next_to_clean = i;
3808 3809 3810 3811

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
L
Linus Torvalds 已提交
3812 3813 3814 3815 3816

	return cleaned;
}

/**
3817
 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
L
Linus Torvalds 已提交
3818 3819 3820 3821
 * @adapter: address of board private structure
 **/

static void
3822
e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
3823
                       struct e1000_rx_ring *rx_ring,
3824
		       int cleaned_count)
L
Linus Torvalds 已提交
3825 3826 3827 3828 3829 3830
{
	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;
3831 3832
	unsigned int i;
	unsigned int bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
L
Linus Torvalds 已提交
3833 3834 3835 3836

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

3837 3838 3839 3840 3841 3842 3843 3844
	while (cleaned_count--) {
		if (!(skb = buffer_info->skb))
			skb = dev_alloc_skb(bufsz);
		else {
			skb_trim(skb, 0);
			goto map_skb;
		}

J
Jesse Brandeburg 已提交
3845
		if (unlikely(!skb)) {
L
Linus Torvalds 已提交
3846
			/* Better luck next round */
3847
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
3848 3849 3850
			break;
		}

3851
		/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
3852 3853
		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
			struct sk_buff *oldskb = skb;
3854 3855 3856
			DPRINTK(RX_ERR, ERR, "skb align check failed: %u bytes "
					     "at %p\n", bufsz, skb->data);
			/* Try again, without freeing the previous */
L
Linus Torvalds 已提交
3857
			skb = dev_alloc_skb(bufsz);
3858
			/* Failed allocation, critical failure */
L
Linus Torvalds 已提交
3859 3860 3861 3862
			if (!skb) {
				dev_kfree_skb(oldskb);
				break;
			}
3863

L
Linus Torvalds 已提交
3864 3865 3866 3867 3868 3869
			if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
				/* give up */
				dev_kfree_skb(skb);
				dev_kfree_skb(oldskb);
				break; /* while !buffer_info->skb */
			} else {
3870
				/* Use new allocation */
L
Linus Torvalds 已提交
3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883
				dev_kfree_skb(oldskb);
			}
		}
		/* Make buffer alignment 2 beyond a 16 byte boundary
		 * this will result in a 16 byte aligned IP header after
		 * the 14 byte MAC header is removed
		 */
		skb_reserve(skb, NET_IP_ALIGN);

		skb->dev = netdev;

		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_buffer_len;
3884
map_skb:
L
Linus Torvalds 已提交
3885 3886 3887 3888 3889
		buffer_info->dma = pci_map_single(pdev,
						  skb->data,
						  adapter->rx_buffer_len,
						  PCI_DMA_FROMDEVICE);

3890 3891 3892 3893 3894 3895 3896 3897
		/* 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)) {
			DPRINTK(RX_ERR, ERR,
				"dma align check failed: %u bytes at %p\n",
				adapter->rx_buffer_len,
				(void *)(unsigned long)buffer_info->dma);
L
Linus Torvalds 已提交
3898 3899 3900
			dev_kfree_skb(skb);
			buffer_info->skb = NULL;

3901
			pci_unmap_single(pdev, buffer_info->dma,
L
Linus Torvalds 已提交
3902 3903 3904 3905 3906 3907 3908 3909
					 adapter->rx_buffer_len,
					 PCI_DMA_FROMDEVICE);

			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 已提交
3910 3911
		if (unlikely(++i == rx_ring->count))
			i = 0;
L
Linus Torvalds 已提交
3912 3913 3914
		buffer_info = &rx_ring->buffer_info[i];
	}

3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926
	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 已提交
3927 3928
}

3929 3930 3931 3932 3933 3934
/**
 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split
 * @adapter: address of board private structure
 **/

static void
3935
e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
3936 3937
                          struct e1000_rx_ring *rx_ring,
			  int cleaned_count)
3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
	union e1000_rx_desc_packet_split *rx_desc;
	struct e1000_buffer *buffer_info;
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
	struct sk_buff *skb;
	unsigned int i, j;

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

3953
	while (cleaned_count--) {
3954 3955
		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

J
Jesse Brandeburg 已提交
3956
		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
3957 3958 3959 3960
			if (j < adapter->rx_ps_pages) {
				if (likely(!ps_page->ps_page[j])) {
					ps_page->ps_page[j] =
						alloc_page(GFP_ATOMIC);
3961 3962
					if (unlikely(!ps_page->ps_page[j])) {
						adapter->alloc_rx_buff_failed++;
3963
						goto no_buffers;
3964
					}
3965 3966 3967 3968 3969 3970 3971
					ps_page_dma->ps_page_dma[j] =
						pci_map_page(pdev,
							    ps_page->ps_page[j],
							    0, PAGE_SIZE,
							    PCI_DMA_FROMDEVICE);
				}
				/* Refresh the desc even if buffer_addrs didn't
J
Jesse Brandeburg 已提交
3972
				 * change because each write-back erases
3973 3974 3975 3976 3977 3978
				 * this info.
				 */
				rx_desc->read.buffer_addr[j+1] =
				     cpu_to_le64(ps_page_dma->ps_page_dma[j]);
			} else
				rx_desc->read.buffer_addr[j+1] = ~0;
3979 3980 3981 3982
		}

		skb = dev_alloc_skb(adapter->rx_ps_bsize0 + NET_IP_ALIGN);

3983 3984
		if (unlikely(!skb)) {
			adapter->alloc_rx_buff_failed++;
3985
			break;
3986
		}
3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003

		/* Make buffer alignment 2 beyond a 16 byte boundary
		 * this will result in a 16 byte aligned IP header after
		 * the 14 byte MAC header is removed
		 */
		skb_reserve(skb, NET_IP_ALIGN);

		skb->dev = netdev;

		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_ps_bsize0;
		buffer_info->dma = pci_map_single(pdev, skb->data,
						  adapter->rx_ps_bsize0,
						  PCI_DMA_FROMDEVICE);

		rx_desc->read.buffer_addr[0] = cpu_to_le64(buffer_info->dma);

J
Jesse Brandeburg 已提交
4004
		if (unlikely(++i == rx_ring->count)) i = 0;
4005 4006 4007 4008 4009 4010
		buffer_info = &rx_ring->buffer_info[i];
		ps_page = &rx_ring->ps_page[i];
		ps_page_dma = &rx_ring->ps_page_dma[i];
	}

no_buffers:
4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025
	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();
		/* Hardware increments by 16 bytes, but packet split
		 * descriptors are 32 bytes...so we increment tail
		 * twice as much.
		 */
		writel(i<<1, adapter->hw.hw_addr + rx_ring->rdt);
	}
4026 4027
}

L
Linus Torvalds 已提交
4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038
/**
 * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
 * @adapter:
 **/

static void
e1000_smartspeed(struct e1000_adapter *adapter)
{
	uint16_t phy_status;
	uint16_t phy_ctrl;

J
Jesse Brandeburg 已提交
4039
	if ((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
L
Linus Torvalds 已提交
4040 4041 4042
	   !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
		return;

J
Jesse Brandeburg 已提交
4043
	if (adapter->smartspeed == 0) {
L
Linus Torvalds 已提交
4044 4045 4046
		/* If Master/Slave config fault is asserted twice,
		 * we assume back-to-back */
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4047
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4048
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4049
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4050
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
J
Jesse Brandeburg 已提交
4051
		if (phy_ctrl & CR_1000T_MS_ENABLE) {
L
Linus Torvalds 已提交
4052 4053 4054 4055
			phy_ctrl &= ~CR_1000T_MS_ENABLE;
			e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
					    phy_ctrl);
			adapter->smartspeed++;
J
Jesse Brandeburg 已提交
4056
			if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4057 4058 4059 4060 4061 4062 4063 4064 4065
			   !e1000_read_phy_reg(&adapter->hw, PHY_CTRL,
				   	       &phy_ctrl)) {
				phy_ctrl |= (MII_CR_AUTO_NEG_EN |
					     MII_CR_RESTART_AUTO_NEG);
				e1000_write_phy_reg(&adapter->hw, PHY_CTRL,
						    phy_ctrl);
			}
		}
		return;
J
Jesse Brandeburg 已提交
4066
	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
L
Linus Torvalds 已提交
4067 4068 4069 4070
		/* If still no link, perhaps using 2/3 pair cable */
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
		phy_ctrl |= CR_1000T_MS_ENABLE;
		e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_ctrl);
J
Jesse Brandeburg 已提交
4071
		if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4072 4073 4074 4075 4076 4077 4078
		   !e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_ctrl)) {
			phy_ctrl |= (MII_CR_AUTO_NEG_EN |
				     MII_CR_RESTART_AUTO_NEG);
			e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_ctrl);
		}
	}
	/* Restart process after E1000_SMARTSPEED_MAX iterations */
J
Jesse Brandeburg 已提交
4079
	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
L
Linus Torvalds 已提交
4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
		adapter->smartspeed = 0;
}

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

static int
e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
{
	switch (cmd) {
	case SIOCGMIIPHY:
	case SIOCGMIIREG:
	case SIOCSMIIREG:
		return e1000_mii_ioctl(netdev, ifr, cmd);
	default:
		return -EOPNOTSUPP;
	}
}

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

static int
e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
{
4113
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4114 4115 4116 4117
	struct mii_ioctl_data *data = if_mii(ifr);
	int retval;
	uint16_t mii_reg;
	uint16_t spddplx;
4118
	unsigned long flags;
L
Linus Torvalds 已提交
4119

J
Jesse Brandeburg 已提交
4120
	if (adapter->hw.media_type != e1000_media_type_copper)
L
Linus Torvalds 已提交
4121 4122 4123 4124 4125 4126 4127
		return -EOPNOTSUPP;

	switch (cmd) {
	case SIOCGMIIPHY:
		data->phy_id = adapter->hw.phy_addr;
		break;
	case SIOCGMIIREG:
J
Jesse Brandeburg 已提交
4128
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4129
			return -EPERM;
4130
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4131
		if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
4132 4133
				   &data->val_out)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4134
			return -EIO;
4135 4136
		}
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4137 4138
		break;
	case SIOCSMIIREG:
J
Jesse Brandeburg 已提交
4139
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4140
			return -EPERM;
J
Jesse Brandeburg 已提交
4141
		if (data->reg_num & ~(0x1F))
L
Linus Torvalds 已提交
4142 4143
			return -EFAULT;
		mii_reg = data->val_in;
4144
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4145
		if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
4146 4147
					mii_reg)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4148
			return -EIO;
4149
		}
4150
		if (adapter->hw.media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
4151 4152
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4153
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4154
					break;
J
Jesse Brandeburg 已提交
4155
				if (mii_reg & MII_CR_AUTO_NEG_EN) {
L
Linus Torvalds 已提交
4156 4157 4158 4159 4160 4161 4162 4163 4164 4165
					adapter->hw.autoneg = 1;
					adapter->hw.autoneg_advertised = 0x2F;
				} else {
					if (mii_reg & 0x40)
						spddplx = SPEED_1000;
					else if (mii_reg & 0x2000)
						spddplx = SPEED_100;
					else
						spddplx = SPEED_10;
					spddplx += (mii_reg & 0x100)
4166 4167
						   ? DUPLEX_FULL :
						   DUPLEX_HALF;
L
Linus Torvalds 已提交
4168 4169
					retval = e1000_set_spd_dplx(adapter,
								    spddplx);
J
Jesse Brandeburg 已提交
4170
					if (retval) {
4171
						spin_unlock_irqrestore(
J
Jesse Brandeburg 已提交
4172
							&adapter->stats_lock,
4173
							flags);
L
Linus Torvalds 已提交
4174
						return retval;
4175
					}
L
Linus Torvalds 已提交
4176
				}
J
Jesse Brandeburg 已提交
4177
				if (netif_running(adapter->netdev)) {
L
Linus Torvalds 已提交
4178 4179 4180 4181 4182 4183 4184
					e1000_down(adapter);
					e1000_up(adapter);
				} else
					e1000_reset(adapter);
				break;
			case M88E1000_PHY_SPEC_CTRL:
			case M88E1000_EXT_PHY_SPEC_CTRL:
J
Jesse Brandeburg 已提交
4185
				if (e1000_phy_reset(&adapter->hw)) {
4186 4187
					spin_unlock_irqrestore(
						&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4188
					return -EIO;
4189
				}
L
Linus Torvalds 已提交
4190 4191 4192 4193 4194
				break;
			}
		} else {
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4195
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4196
					break;
J
Jesse Brandeburg 已提交
4197
				if (netif_running(adapter->netdev)) {
L
Linus Torvalds 已提交
4198 4199 4200 4201 4202 4203 4204
					e1000_down(adapter);
					e1000_up(adapter);
				} else
					e1000_reset(adapter);
				break;
			}
		}
4205
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216
		break;
	default:
		return -EOPNOTSUPP;
	}
	return E1000_SUCCESS;
}

void
e1000_pci_set_mwi(struct e1000_hw *hw)
{
	struct e1000_adapter *adapter = hw->back;
4217
	int ret_val = pci_set_mwi(adapter->pdev);
L
Linus Torvalds 已提交
4218

J
Jesse Brandeburg 已提交
4219
	if (ret_val)
4220
		DPRINTK(PROBE, ERR, "Error in setting MWI\n");
L
Linus Torvalds 已提交
4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261
}

void
e1000_pci_clear_mwi(struct e1000_hw *hw)
{
	struct e1000_adapter *adapter = hw->back;

	pci_clear_mwi(adapter->pdev);
}

void
e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
{
	struct e1000_adapter *adapter = hw->back;

	pci_read_config_word(adapter->pdev, reg, value);
}

void
e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
{
	struct e1000_adapter *adapter = hw->back;

	pci_write_config_word(adapter->pdev, reg, *value);
}

uint32_t
e1000_io_read(struct e1000_hw *hw, unsigned long port)
{
	return inl(port);
}

void
e1000_io_write(struct e1000_hw *hw, unsigned long port, uint32_t value)
{
	outl(value, port);
}

static void
e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
{
4262
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4263 4264 4265 4266 4267
	uint32_t ctrl, rctl;

	e1000_irq_disable(adapter);
	adapter->vlgrp = grp;

J
Jesse Brandeburg 已提交
4268
	if (grp) {
L
Linus Torvalds 已提交
4269 4270 4271 4272 4273 4274 4275 4276 4277 4278
		/* enable VLAN tag insert/strip */
		ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		ctrl |= E1000_CTRL_VME;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);

		/* enable VLAN receive filtering */
		rctl = E1000_READ_REG(&adapter->hw, RCTL);
		rctl |= E1000_RCTL_VFE;
		rctl &= ~E1000_RCTL_CFIEN;
		E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
4279
		e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
4280 4281 4282 4283 4284 4285 4286 4287 4288 4289
	} else {
		/* disable VLAN tag insert/strip */
		ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		ctrl &= ~E1000_CTRL_VME;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);

		/* disable VLAN filtering */
		rctl = E1000_READ_REG(&adapter->hw, RCTL);
		rctl &= ~E1000_RCTL_VFE;
		E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
J
Jesse Brandeburg 已提交
4290
		if (adapter->mng_vlan_id != (uint16_t)E1000_MNG_VLAN_NONE) {
4291 4292 4293
			e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
		}
L
Linus Torvalds 已提交
4294 4295 4296 4297 4298 4299 4300 4301
	}

	e1000_irq_enable(adapter);
}

static void
e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
{
4302
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4303
	uint32_t vfta, index;
J
Jesse Brandeburg 已提交
4304 4305 4306 4307

	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
	    (vid == adapter->mng_vlan_id))
4308
		return;
L
Linus Torvalds 已提交
4309 4310 4311 4312 4313 4314 4315 4316 4317 4318
	/* add VID to filter table */
	index = (vid >> 5) & 0x7F;
	vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
	vfta |= (1 << (vid & 0x1F));
	e1000_write_vfta(&adapter->hw, index, vfta);
}

static void
e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
{
4319
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4320 4321 4322 4323
	uint32_t vfta, index;

	e1000_irq_disable(adapter);

J
Jesse Brandeburg 已提交
4324
	if (adapter->vlgrp)
L
Linus Torvalds 已提交
4325 4326 4327 4328
		adapter->vlgrp->vlan_devices[vid] = NULL;

	e1000_irq_enable(adapter);

J
Jesse Brandeburg 已提交
4329 4330
	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
J
Jeff Kirsher 已提交
4331 4332 4333
	    (vid == adapter->mng_vlan_id)) {
		/* release control to f/w */
		e1000_release_hw_control(adapter);
4334
		return;
J
Jeff Kirsher 已提交
4335 4336
	}

L
Linus Torvalds 已提交
4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348
	/* remove VID from filter table */
	index = (vid >> 5) & 0x7F;
	vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
	vfta &= ~(1 << (vid & 0x1F));
	e1000_write_vfta(&adapter->hw, index, vfta);
}

static void
e1000_restore_vlan(struct e1000_adapter *adapter)
{
	e1000_vlan_rx_register(adapter->netdev, adapter->vlgrp);

J
Jesse Brandeburg 已提交
4349
	if (adapter->vlgrp) {
L
Linus Torvalds 已提交
4350
		uint16_t vid;
J
Jesse Brandeburg 已提交
4351 4352
		for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
			if (!adapter->vlgrp->vlan_devices[vid])
L
Linus Torvalds 已提交
4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363
				continue;
			e1000_vlan_rx_add_vid(adapter->netdev, vid);
		}
	}
}

int
e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
{
	adapter->hw.autoneg = 0;

4364
	/* Fiber NICs only allow 1000 gbps Full duplex */
J
Jesse Brandeburg 已提交
4365
	if ((adapter->hw.media_type == e1000_media_type_fiber) &&
4366 4367 4368 4369 4370
		spddplx != (SPEED_1000 + DUPLEX_FULL)) {
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
		return -EINVAL;
	}

J
Jesse Brandeburg 已提交
4371
	switch (spddplx) {
L
Linus Torvalds 已提交
4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389
	case SPEED_10 + DUPLEX_HALF:
		adapter->hw.forced_speed_duplex = e1000_10_half;
		break;
	case SPEED_10 + DUPLEX_FULL:
		adapter->hw.forced_speed_duplex = e1000_10_full;
		break;
	case SPEED_100 + DUPLEX_HALF:
		adapter->hw.forced_speed_duplex = e1000_100_half;
		break;
	case SPEED_100 + DUPLEX_FULL:
		adapter->hw.forced_speed_duplex = e1000_100_full;
		break;
	case SPEED_1000 + DUPLEX_FULL:
		adapter->hw.autoneg = 1;
		adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
		break;
	case SPEED_1000 + DUPLEX_HALF: /* not supported */
	default:
4390
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
L
Linus Torvalds 已提交
4391 4392 4393 4394 4395
		return -EINVAL;
	}
	return 0;
}

4396
#ifdef CONFIG_PM
4397 4398
/* Save/restore 16 or 64 dwords of PCI config space depending on which
 * bus we're on (PCI(X) vs. PCI-E)
4399 4400 4401 4402 4403 4404 4405 4406 4407
 */
#define PCIE_CONFIG_SPACE_LEN 256
#define PCI_CONFIG_SPACE_LEN 64
static int
e1000_pci_save_state(struct e1000_adapter *adapter)
{
	struct pci_dev *dev = adapter->pdev;
	int size;
	int i;
4408

4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431
	if (adapter->hw.mac_type >= e1000_82571)
		size = PCIE_CONFIG_SPACE_LEN;
	else
		size = PCI_CONFIG_SPACE_LEN;

	WARN_ON(adapter->config_space != NULL);

	adapter->config_space = kmalloc(size, GFP_KERNEL);
	if (!adapter->config_space) {
		DPRINTK(PROBE, ERR, "unable to allocate %d bytes\n", size);
		return -ENOMEM;
	}
	for (i = 0; i < (size / 4); i++)
		pci_read_config_dword(dev, i * 4, &adapter->config_space[i]);
	return 0;
}

static void
e1000_pci_restore_state(struct e1000_adapter *adapter)
{
	struct pci_dev *dev = adapter->pdev;
	int size;
	int i;
4432

4433 4434
	if (adapter->config_space == NULL)
		return;
4435

4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
	if (adapter->hw.mac_type >= e1000_82571)
		size = PCIE_CONFIG_SPACE_LEN;
	else
		size = PCI_CONFIG_SPACE_LEN;
	for (i = 0; i < (size / 4); i++)
		pci_write_config_dword(dev, i * 4, adapter->config_space[i]);
	kfree(adapter->config_space);
	adapter->config_space = NULL;
	return;
}
#endif /* CONFIG_PM */

L
Linus Torvalds 已提交
4448
static int
4449
e1000_suspend(struct pci_dev *pdev, pm_message_t state)
L
Linus Torvalds 已提交
4450 4451
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4452
	struct e1000_adapter *adapter = netdev_priv(netdev);
4453
	uint32_t ctrl, ctrl_ext, rctl, manc, status;
L
Linus Torvalds 已提交
4454
	uint32_t wufc = adapter->wol;
4455
	int retval = 0;
L
Linus Torvalds 已提交
4456 4457 4458

	netif_device_detach(netdev);

J
Jesse Brandeburg 已提交
4459
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4460 4461
		e1000_down(adapter);

4462
#ifdef CONFIG_PM
4463 4464
	/* Implement our own version of pci_save_state(pdev) because pci-
	 * express adapters have 256-byte config spaces. */
4465 4466 4467 4468 4469
	retval = e1000_pci_save_state(adapter);
	if (retval)
		return retval;
#endif

L
Linus Torvalds 已提交
4470
	status = E1000_READ_REG(&adapter->hw, STATUS);
J
Jesse Brandeburg 已提交
4471
	if (status & E1000_STATUS_LU)
L
Linus Torvalds 已提交
4472 4473
		wufc &= ~E1000_WUFC_LNKC;

J
Jesse Brandeburg 已提交
4474
	if (wufc) {
L
Linus Torvalds 已提交
4475 4476 4477 4478
		e1000_setup_rctl(adapter);
		e1000_set_multi(netdev);

		/* turn on all-multi mode if wake on multicast is enabled */
J
Jesse Brandeburg 已提交
4479
		if (adapter->wol & E1000_WUFC_MC) {
L
Linus Torvalds 已提交
4480 4481 4482 4483 4484
			rctl = E1000_READ_REG(&adapter->hw, RCTL);
			rctl |= E1000_RCTL_MPE;
			E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
		}

J
Jesse Brandeburg 已提交
4485
		if (adapter->hw.mac_type >= e1000_82540) {
L
Linus Torvalds 已提交
4486 4487 4488 4489 4490 4491 4492 4493 4494 4495
			ctrl = E1000_READ_REG(&adapter->hw, CTRL);
			/* 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;
			E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
		}

J
Jesse Brandeburg 已提交
4496
		if (adapter->hw.media_type == e1000_media_type_fiber ||
L
Linus Torvalds 已提交
4497 4498 4499 4500 4501 4502 4503
		   adapter->hw.media_type == e1000_media_type_internal_serdes) {
			/* keep the laser running in D3 */
			ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
			ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
			E1000_WRITE_REG(&adapter->hw, CTRL_EXT, ctrl_ext);
		}

4504 4505 4506
		/* Allow time for pending master requests to run */
		e1000_disable_pciex_master(&adapter->hw);

L
Linus Torvalds 已提交
4507 4508
		E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
		E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
4509 4510
		pci_enable_wake(pdev, PCI_D3hot, 1);
		pci_enable_wake(pdev, PCI_D3cold, 1);
L
Linus Torvalds 已提交
4511 4512 4513
	} else {
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
		E1000_WRITE_REG(&adapter->hw, WUFC, 0);
4514 4515
		pci_enable_wake(pdev, PCI_D3hot, 0);
		pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
4516 4517
	}

J
Jesse Brandeburg 已提交
4518
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
4519 4520
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
J
Jesse Brandeburg 已提交
4521
		if (manc & E1000_MANC_SMBUS_EN) {
L
Linus Torvalds 已提交
4522 4523
			manc |= E1000_MANC_ARP_EN;
			E1000_WRITE_REG(&adapter->hw, MANC, manc);
4524 4525
			pci_enable_wake(pdev, PCI_D3hot, 1);
			pci_enable_wake(pdev, PCI_D3cold, 1);
L
Linus Torvalds 已提交
4526 4527 4528
		}
	}

4529 4530 4531
	/* Release control of h/w to f/w.  If f/w is AMT enabled, this
	 * would have already happened in close and is redundant. */
	e1000_release_hw_control(adapter);
4532

L
Linus Torvalds 已提交
4533
	pci_disable_device(pdev);
4534

4535
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
L
Linus Torvalds 已提交
4536 4537 4538 4539

	return 0;
}

4540
#ifdef CONFIG_PM
L
Linus Torvalds 已提交
4541 4542 4543 4544
static int
e1000_resume(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4545
	struct e1000_adapter *adapter = netdev_priv(netdev);
4546
	uint32_t manc, ret_val;
L
Linus Torvalds 已提交
4547

4548
	pci_set_power_state(pdev, PCI_D0);
4549
	e1000_pci_restore_state(adapter);
4550
	ret_val = pci_enable_device(pdev);
4551
	pci_set_master(pdev);
L
Linus Torvalds 已提交
4552

4553 4554
	pci_enable_wake(pdev, PCI_D3hot, 0);
	pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
4555 4556 4557 4558

	e1000_reset(adapter);
	E1000_WRITE_REG(&adapter->hw, WUS, ~0);

J
Jesse Brandeburg 已提交
4559
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4560 4561 4562 4563
		e1000_up(adapter);

	netif_device_attach(netdev);

J
Jesse Brandeburg 已提交
4564
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
4565 4566 4567 4568 4569 4570
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
		manc &= ~(E1000_MANC_ARP_EN);
		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}

4571 4572 4573 4574 4575 4576 4577
	/* If the controller is 82573 and f/w is AMT, do not set
	 * DRV_LOAD until the interface is up.  For all other cases,
	 * let the f/w know that the h/w is now under the control
	 * of the driver. */
	if (adapter->hw.mac_type != e1000_82573 ||
	    !e1000_check_mng_mode(&adapter->hw))
		e1000_get_hw_control(adapter);
4578

L
Linus Torvalds 已提交
4579 4580 4581
	return 0;
}
#endif
4582 4583 4584 4585 4586 4587

static void e1000_shutdown(struct pci_dev *pdev)
{
	e1000_suspend(pdev, PMSG_SUSPEND);
}

L
Linus Torvalds 已提交
4588 4589 4590 4591 4592 4593 4594
#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.
 */
static void
4595
e1000_netpoll(struct net_device *netdev)
L
Linus Torvalds 已提交
4596
{
4597
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4598 4599
	disable_irq(adapter->pdev->irq);
	e1000_intr(adapter->pdev->irq, netdev, NULL);
A
Andrew Morton 已提交
4600
	e1000_clean_tx_irq(adapter, adapter->tx_ring);
J
Jeff Kirsher 已提交
4601 4602 4603
#ifndef CONFIG_E1000_NAPI
	adapter->clean_rx(adapter, adapter->rx_ring);
#endif
L
Linus Torvalds 已提交
4604 4605 4606 4607
	enable_irq(adapter->pdev->irq);
}
#endif

A
Auke Kok 已提交
4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704
/**
 * e1000_io_error_detected - called when PCI error is detected
 * @pdev: Pointer to PCI device
 * @state: The current pci conneection state
 *
 * This function is called after a PCI bus error affecting
 * this device has been detected.
 */
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev->priv;

	netif_device_detach(netdev);

	if (netif_running(netdev))
		e1000_down(adapter);

	/* 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);
	struct e1000_adapter *adapter = netdev->priv;

	if (pci_enable_device(pdev)) {
		printk(KERN_ERR "e1000: Cannot re-enable PCI device after reset.\n");
		return PCI_ERS_RESULT_DISCONNECT;
	}
	pci_set_master(pdev);

	pci_enable_wake(pdev, 3, 0);
	pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */

	/* Perform card reset only on one instance of the card */
	if (PCI_FUNC (pdev->devfn) != 0)
		return PCI_ERS_RESULT_RECOVERED;

	e1000_reset(adapter);
	E1000_WRITE_REG(&adapter->hw, WUS, ~0);

	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);
	struct e1000_adapter *adapter = netdev->priv;
	uint32_t manc, swsm;

	if (netif_running(netdev)) {
		if (e1000_up(adapter)) {
			printk("e1000: can't bring device back up after reset\n");
			return;
		}
	}

	netif_device_attach(netdev);

	if (adapter->hw.mac_type >= e1000_82540 &&
	    adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
		manc &= ~(E1000_MANC_ARP_EN);
		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}

	switch (adapter->hw.mac_type) {
	case e1000_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm | E1000_SWSM_DRV_LOAD);
		break;
	default:
		break;
	}

	if (netif_running(netdev))
		mod_timer(&adapter->watchdog_timer, jiffies);
}

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