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

  
4
  Copyright(c) 1999 - 2005 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 25 26 27 28 29 30 31
  
  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>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

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

#include "e1000.h"

/* Change Log
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
 * 7.0.33      3-Feb-2006
 *   o Added another fix for the pass false carrier bit
 * 7.0.32      24-Jan-2006
 *   o Need to rebuild with noew version number for the pass false carrier 
 *     fix in e1000_hw.c
 * 7.0.30      18-Jan-2006
 *   o fixup for tso workaround to disable it for pci-x
 *   o fix mem leak on 82542
 *   o fixes for 10 Mb/s connections and incorrect stats
 * 7.0.28      01/06/2006
 *   o hardware workaround to only set "speed mode" bit for 1G link.
 * 7.0.26      12/23/2005
 *   o wake on lan support modified for device ID 10B5
 *   o fix dhcp + vlan issue not making it to the iAMT firmware
 * 7.0.24      12/9/2005
 *   o New hardware support for the Gigabit NIC embedded in the south bridge
 *   o Fixes to the recycling logic (skb->tail) from IBM LTC
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
 * 6.3.9	12/16/2005
 *   o incorporate fix for recycled skbs from IBM LTC
 * 6.3.7	11/18/2005
 *   o Honor eeprom setting for enabling/disabling Wake On Lan
 * 6.3.5 	11/17/2005
 *   o Fix memory leak in rx ring handling for PCI Express adapters
 * 6.3.4	11/8/05
 *   o Patch from Jesper Juhl to remove redundant NULL checks for kfree
 * 6.3.2	9/20/05
 *   o Render logic that sets/resets DRV_LOAD as inline functions to 
 *     avoid code replication. If f/w is AMT then set DRV_LOAD only when
 *     network interface is open.
 *   o Handle DRV_LOAD set/reset in cases where AMT uses VLANs.
 *   o Adjust PBA partioning for Jumbo frames using MTU size and not
 *     rx_buffer_len
 * 6.3.1	9/19/05
 *   o Use adapter->tx_timeout_factor in Tx Hung Detect logic 
66
 *      (e1000_clean_tx_irq)
67
 *   o Support for 8086:10B5 device (Quad Port)
L
Linus Torvalds 已提交
68 69 70
 */

char e1000_driver_name[] = "e1000";
71
static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
L
Linus Torvalds 已提交
72 73 74 75 76
#ifndef CONFIG_E1000_NAPI
#define DRIVERNAPI
#else
#define DRIVERNAPI "-NAPI"
#endif
77
#define DRV_VERSION "7.0.33-k2"DRIVERNAPI
L
Linus Torvalds 已提交
78
char e1000_driver_version[] = DRV_VERSION;
79
static char e1000_copyright[] = "Copyright (c) 1999-2005 Intel Corporation.";
L
Linus Torvalds 已提交
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107

/* 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),
108
	INTEL_E1000_ETHERNET_DEVICE(0x101A),
L
Linus Torvalds 已提交
109 110 111 112 113
	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),
114 115 116
	INTEL_E1000_ETHERNET_DEVICE(0x105E),
	INTEL_E1000_ETHERNET_DEVICE(0x105F),
	INTEL_E1000_ETHERNET_DEVICE(0x1060),
L
Linus Torvalds 已提交
117 118 119 120 121 122 123 124
	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),
125 126 127
	INTEL_E1000_ETHERNET_DEVICE(0x107D),
	INTEL_E1000_ETHERNET_DEVICE(0x107E),
	INTEL_E1000_ETHERNET_DEVICE(0x107F),
L
Linus Torvalds 已提交
128
	INTEL_E1000_ETHERNET_DEVICE(0x108A),
129 130
	INTEL_E1000_ETHERNET_DEVICE(0x108B),
	INTEL_E1000_ETHERNET_DEVICE(0x108C),
131 132
	INTEL_E1000_ETHERNET_DEVICE(0x1096),
	INTEL_E1000_ETHERNET_DEVICE(0x1098),
133
	INTEL_E1000_ETHERNET_DEVICE(0x1099),
134
	INTEL_E1000_ETHERNET_DEVICE(0x109A),
135
	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
136
	INTEL_E1000_ETHERNET_DEVICE(0x10B9),
L
Linus Torvalds 已提交
137 138 139 140 141 142
	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

143
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
144
                                    struct e1000_tx_ring *txdr);
145
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
146
                                    struct e1000_rx_ring *rxdr);
147
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
148
                                    struct e1000_tx_ring *tx_ring);
149
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
150
                                    struct e1000_rx_ring *rx_ring);
L
Linus Torvalds 已提交
151 152 153 154 155 156 157

/* 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);
158
static int e1000_alloc_queues(struct e1000_adapter *adapter);
L
Linus Torvalds 已提交
159 160 161 162 163 164
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);
165 166 167 168 169 170
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 已提交
171 172 173 174 175 176 177 178 179 180
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);
181 182
static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,
                                    struct e1000_tx_ring *tx_ring);
L
Linus Torvalds 已提交
183
#ifdef CONFIG_E1000_NAPI
184
static int e1000_clean(struct net_device *poll_dev, int *budget);
L
Linus Torvalds 已提交
185
static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
186
                                    struct e1000_rx_ring *rx_ring,
L
Linus Torvalds 已提交
187
                                    int *work_done, int work_to_do);
188
static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
189
                                       struct e1000_rx_ring *rx_ring,
190
                                       int *work_done, int work_to_do);
L
Linus Torvalds 已提交
191
#else
192 193 194 195
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 已提交
196
#endif
197
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
198 199
                                   struct e1000_rx_ring *rx_ring,
				   int cleaned_count);
200
static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
201 202
                                      struct e1000_rx_ring *rx_ring,
				      int cleaned_count);
L
Linus Torvalds 已提交
203 204 205 206 207 208
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);
209
static void e1000_reset_task(struct net_device *dev);
L
Linus Torvalds 已提交
210
static void e1000_smartspeed(struct e1000_adapter *adapter);
211 212
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
                                       struct sk_buff *skb);
L
Linus Torvalds 已提交
213 214 215 216 217 218 219

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
220
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228
static int e1000_resume(struct pci_dev *pdev);
#endif

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

229

L
Linus Torvalds 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
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,
	.resume   = e1000_resume
#endif
};

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

L
Linus Torvalds 已提交
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
	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
 **/

294
static void
L
Linus Torvalds 已提交
295 296 297 298 299 300 301 302 303 304 305 306 307
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
 **/

308
static void
L
Linus Torvalds 已提交
309 310
e1000_irq_enable(struct e1000_adapter *adapter)
{
J
Jesse Brandeburg 已提交
311
	if (likely(atomic_dec_and_test(&adapter->irq_sem))) {
L
Linus Torvalds 已提交
312 313 314 315
		E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
		E1000_WRITE_FLUSH(&adapter->hw);
	}
}
316 317

static void
318 319 320 321 322
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 已提交
323 324 325
	if (adapter->vlgrp) {
		if (!adapter->vlgrp->vlan_devices[vid]) {
			if (adapter->hw.mng_cookie.status &
326 327 328 329 330
				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 已提交
331 332 333

			if ((old_vid != (uint16_t)E1000_MNG_VLAN_NONE) &&
					(vid != old_vid) &&
334 335
					!adapter->vlgrp->vlan_devices[old_vid])
				e1000_vlan_rx_kill_vid(netdev, old_vid);
336 337
		} else
			adapter->mng_vlan_id = vid;
338 339
	}
}
340 341 342 343 344 345 346 347 348 349 350 351

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

352
static void
353 354 355 356 357 358 359 360 361
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:
362
	case e1000_80003es2lan:
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
		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.
 * For ASF and Pass Through versions of f/w this means that 
 * the driver is loaded. For AMT version (only with 82573) 
 * of the f/w this means that the netowrk i/f is open.
 * 
 **/

387
static void
388 389 390 391 392 393 394 395
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:
396
	case e1000_80003es2lan:
397 398 399 400 401 402 403 404 405 406 407 408 409 410
		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 已提交
411 412 413 414
int
e1000_up(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
415
	int i, err;
L
Linus Torvalds 已提交
416 417 418 419

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

	/* Reset the PHY if it was previously powered down */
J
Jesse Brandeburg 已提交
420
	if (adapter->hw.media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
421 422
		uint16_t mii_reg;
		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
J
Jesse Brandeburg 已提交
423
		if (mii_reg & MII_CR_POWER_DOWN)
424
			e1000_phy_hw_reset(&adapter->hw);
L
Linus Torvalds 已提交
425 426 427 428 429 430 431 432 433
	}

	e1000_set_multi(netdev);

	e1000_restore_vlan(adapter);

	e1000_configure_tx(adapter);
	e1000_setup_rctl(adapter);
	e1000_configure_rx(adapter);
434 435 436
	/* call E1000_DESC_UNUSED which always leaves
	 * at least 1 descriptor unused to make sure
	 * next_to_use != next_to_clean */
437
	for (i = 0; i < adapter->num_rx_queues; i++) {
438
		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
439 440
		adapter->alloc_rx_buf(adapter, ring,
		                      E1000_DESC_UNUSED(ring));
441
	}
L
Linus Torvalds 已提交
442

443
#ifdef CONFIG_PCI_MSI
J
Jesse Brandeburg 已提交
444
	if (adapter->hw.mac_type > e1000_82547_rev_2) {
445
		adapter->have_msi = TRUE;
J
Jesse Brandeburg 已提交
446
		if ((err = pci_enable_msi(adapter->pdev))) {
447 448 449 450 451 452
			DPRINTK(PROBE, ERR,
			 "Unable to allocate MSI interrupt Error: %d\n", err);
			adapter->have_msi = FALSE;
		}
	}
#endif
J
Jesse Brandeburg 已提交
453
	if ((err = request_irq(adapter->pdev->irq, &e1000_intr,
L
Linus Torvalds 已提交
454
		              SA_SHIRQ | SA_SAMPLE_RANDOM,
455 456 457
		              netdev->name, netdev))) {
		DPRINTK(PROBE, ERR,
		    "Unable to allocate interrupt Error: %d\n", err);
L
Linus Torvalds 已提交
458
		return err;
459
	}
L
Linus Torvalds 已提交
460

461 462
	adapter->tx_queue_len = netdev->tx_queue_len;

L
Linus Torvalds 已提交
463 464 465 466 467
	mod_timer(&adapter->watchdog_timer, jiffies);

#ifdef CONFIG_E1000_NAPI
	netif_poll_enable(netdev);
#endif
468 469
	e1000_irq_enable(adapter);

L
Linus Torvalds 已提交
470 471 472 473 474 475 476
	return 0;
}

void
e1000_down(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
477 478
	boolean_t mng_mode_enabled = (adapter->hw.mac_type >= e1000_82571) &&
				     e1000_check_mng_mode(&adapter->hw);
L
Linus Torvalds 已提交
479 480

	e1000_irq_disable(adapter);
481

L
Linus Torvalds 已提交
482
	free_irq(adapter->pdev->irq, netdev);
483
#ifdef CONFIG_PCI_MSI
J
Jesse Brandeburg 已提交
484
	if (adapter->hw.mac_type > e1000_82547_rev_2 &&
485 486 487
	   adapter->have_msi == TRUE)
		pci_disable_msi(adapter->pdev);
#endif
L
Linus Torvalds 已提交
488 489 490 491 492 493 494
	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
495
	netdev->tx_queue_len = adapter->tx_queue_len;
L
Linus Torvalds 已提交
496 497 498 499 500 501
	adapter->link_speed = 0;
	adapter->link_duplex = 0;
	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	e1000_reset(adapter);
502 503
	e1000_clean_all_tx_rings(adapter);
	e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
504

505 506 507 508 509 510
	/* 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 &&
511
	   adapter->hw.media_type == e1000_media_type_copper &&
512 513 514
	   !(E1000_READ_REG(&adapter->hw, MANC) & E1000_MANC_SMBUS_EN) &&
	   !mng_mode_enabled &&
	   !e1000_check_phy_reset_block(&adapter->hw)) {
L
Linus Torvalds 已提交
515 516 517 518
		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);
519
		mdelay(1);
L
Linus Torvalds 已提交
520 521 522 523 524 525
	}
}

void
e1000_reset(struct e1000_adapter *adapter)
{
526
	uint32_t pba, manc;
527
	uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
L
Linus Torvalds 已提交
528 529 530 531 532

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

533 534
	switch (adapter->hw.mac_type) {
	case e1000_82547:
535
	case e1000_82547_rev_2:
536 537
		pba = E1000_PBA_30K;
		break;
538 539
	case e1000_82571:
	case e1000_82572:
540
	case e1000_80003es2lan:
541 542
		pba = E1000_PBA_38K;
		break;
543 544 545 546 547 548 549 550
	case e1000_82573:
		pba = E1000_PBA_12K;
		break;
	default:
		pba = E1000_PBA_48K;
		break;
	}

J
Jesse Brandeburg 已提交
551
	if ((adapter->hw.mac_type != e1000_82573) &&
552
	   (adapter->netdev->mtu > E1000_RXBUFFER_8192))
553
		pba -= 8; /* allocate more FIFO for Tx */
554 555


J
Jesse Brandeburg 已提交
556
	if (adapter->hw.mac_type == e1000_82547) {
L
Linus Torvalds 已提交
557 558 559 560 561 562
		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);
	}
563

L
Linus Torvalds 已提交
564 565 566
	E1000_WRITE_REG(&adapter->hw, PBA, pba);

	/* flow control settings */
567 568 569 570 571 572
	/* 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;
573 574 575 576
	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 已提交
577 578 579
	adapter->hw.fc_send_xon = 1;
	adapter->hw.fc = adapter->hw.original_fc;

580
	/* Allow time for pending master requests to run */
L
Linus Torvalds 已提交
581
	e1000_reset_hw(&adapter->hw);
J
Jesse Brandeburg 已提交
582
	if (adapter->hw.mac_type >= e1000_82544)
L
Linus Torvalds 已提交
583
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
J
Jesse Brandeburg 已提交
584
	if (e1000_init_hw(&adapter->hw))
L
Linus Torvalds 已提交
585
		DPRINTK(PROBE, ERR, "Hardware Error\n");
586
	e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
587 588 589 590 591
	/* 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);
592 593 594 595 596
	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 已提交
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
}

/**
 * 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;
617 618
	unsigned long mmio_start, mmio_len;

L
Linus Torvalds 已提交
619
	static int cards_found = 0;
J
Jeff Kirsher 已提交
620
	static int e1000_ksp3_port_a = 0; /* global ksp3 port a indication */
621
	int i, err, pci_using_dac;
L
Linus Torvalds 已提交
622 623
	uint16_t eeprom_data;
	uint16_t eeprom_apme_mask = E1000_EEPROM_APME;
J
Jesse Brandeburg 已提交
624
	if ((err = pci_enable_device(pdev)))
L
Linus Torvalds 已提交
625 626
		return err;

J
Jesse Brandeburg 已提交
627
	if (!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
L
Linus Torvalds 已提交
628 629
		pci_using_dac = 1;
	} else {
J
Jesse Brandeburg 已提交
630
		if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
L
Linus Torvalds 已提交
631 632 633 634 635 636
			E1000_ERR("No usable DMA configuration, aborting\n");
			return err;
		}
		pci_using_dac = 0;
	}

J
Jesse Brandeburg 已提交
637
	if ((err = pci_request_regions(pdev, e1000_driver_name)))
L
Linus Torvalds 已提交
638 639 640 641 642
		return err;

	pci_set_master(pdev);

	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
J
Jesse Brandeburg 已提交
643
	if (!netdev) {
L
Linus Torvalds 已提交
644 645 646 647 648 649 650 651
		err = -ENOMEM;
		goto err_alloc_etherdev;
	}

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

	pci_set_drvdata(pdev, netdev);
652
	adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661
	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 已提交
662
	if (!adapter->hw.hw_addr) {
L
Linus Torvalds 已提交
663 664 665 666
		err = -EIO;
		goto err_ioremap;
	}

J
Jesse Brandeburg 已提交
667 668
	for (i = BAR_1; i <= BAR_5; i++) {
		if (pci_resource_len(pdev, i) == 0)
L
Linus Torvalds 已提交
669
			continue;
J
Jesse Brandeburg 已提交
670
		if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
L
Linus Torvalds 已提交
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
			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 已提交
707
	if ((err = e1000_sw_init(adapter)))
L
Linus Torvalds 已提交
708 709
		goto err_sw_init;

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

J
Jeff Kirsher 已提交
713 714 715 716 717 718 719 720 721
	/* if ksp3, indicate if it's port a being setup */
	if (pdev->device == E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3 && 
			e1000_ksp3_port_a == 0) 
		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 已提交
722
	if (adapter->hw.mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
723 724 725 726 727 728 729 730
		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 已提交
731
	if ((adapter->hw.mac_type >= e1000_82544) &&
L
Linus Torvalds 已提交
732 733
	   (adapter->hw.mac_type != e1000_82547))
		netdev->features |= NETIF_F_TSO;
734 735

#ifdef NETIF_F_TSO_IPV6
J
Jesse Brandeburg 已提交
736
	if (adapter->hw.mac_type > e1000_82547_rev_2)
737 738
		netdev->features |= NETIF_F_TSO_IPV6;
#endif
L
Linus Torvalds 已提交
739
#endif
J
Jesse Brandeburg 已提交
740
	if (pci_using_dac)
L
Linus Torvalds 已提交
741 742 743 744 745
		netdev->features |= NETIF_F_HIGHDMA;

 	/* hard_start_xmit is safe against parallel locking */
 	netdev->features |= NETIF_F_LLTX; 
 
746 747
	adapter->en_mng_pt = e1000_enable_mng_pass_thru(&adapter->hw);

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

L
Linus Torvalds 已提交
751 752 753 754
	e1000_reset_hw(&adapter->hw);

	/* make sure the EEPROM is good */

J
Jesse Brandeburg 已提交
755
	if (e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
L
Linus Torvalds 已提交
756 757 758 759 760 761 762
		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 已提交
763
	if (e1000_read_mac_addr(&adapter->hw))
L
Linus Torvalds 已提交
764 765
		DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
	memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
766
	memcpy(netdev->perm_addr, adapter->hw.mac_addr, netdev->addr_len);
L
Linus Torvalds 已提交
767

J
Jesse Brandeburg 已提交
768
	if (!is_valid_ether_addr(netdev->perm_addr)) {
L
Linus Torvalds 已提交
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
		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;

793 794
	INIT_WORK(&adapter->reset_task,
		(void (*)(void *))e1000_reset_task, netdev);
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802 803 804 805 806 807

	/* 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 已提交
808
	switch (adapter->hw.mac_type) {
L
Linus Torvalds 已提交
809 810 811 812 813 814 815 816 817 818 819
	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 已提交
820
	case e1000_82571:
821
	case e1000_80003es2lan:
J
Jesse Brandeburg 已提交
822
		if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1){
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830 831 832
			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 已提交
833
	if (eeprom_data & eeprom_apme_mask)
L
Linus Torvalds 已提交
834 835
		adapter->wol |= E1000_WUFC_MAG;

836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
	/* 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 已提交
856 857 858
	/* reset the hardware with the new settings */
	e1000_reset(adapter);

859 860 861 862 863 864 865
	/* 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);
866

L
Linus Torvalds 已提交
867
	strcpy(netdev->name, "eth%d");
J
Jesse Brandeburg 已提交
868
	if ((err = register_netdev(netdev)))
L
Linus Torvalds 已提交
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
		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);
901
	struct e1000_adapter *adapter = netdev_priv(netdev);
902
	uint32_t manc;
903 904 905
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
906

J
Jeff Garzik 已提交
907 908
	flush_scheduled_work();

J
Jesse Brandeburg 已提交
909
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
910 911
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
J
Jesse Brandeburg 已提交
912
		if (manc & E1000_MANC_SMBUS_EN) {
L
Linus Torvalds 已提交
913 914 915 916 917
			manc |= E1000_MANC_ARP_EN;
			E1000_WRITE_REG(&adapter->hw, MANC, manc);
		}
	}

918 919 920
	/* 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);
921

L
Linus Torvalds 已提交
922
	unregister_netdev(netdev);
923
#ifdef CONFIG_E1000_NAPI
924
	for (i = 0; i < adapter->num_rx_queues; i++)
925
		dev_put(&adapter->polling_netdev[i]);
926
#endif
L
Linus Torvalds 已提交
927

J
Jesse Brandeburg 已提交
928
	if (!e1000_check_phy_reset_block(&adapter->hw))
929
		e1000_phy_hw_reset(&adapter->hw);
L
Linus Torvalds 已提交
930

931 932 933 934 935 936
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
#ifdef CONFIG_E1000_NAPI
	kfree(adapter->polling_netdev);
#endif

L
Linus Torvalds 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
	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;
960 961 962
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
963 964 965 966 967 968 969 970 971 972 973 974 975

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

	adapter->rx_buffer_len = E1000_RXBUFFER_2048;
976
	adapter->rx_ps_bsize0 = E1000_RXBUFFER_256;
L
Linus Torvalds 已提交
977 978 979 980 981 982
	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 已提交
983
	if (e1000_set_mac_type(hw)) {
L
Linus Torvalds 已提交
984 985 986 987 988 989
		DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
		return -EIO;
	}

	/* initialize eeprom parameters */

J
Jesse Brandeburg 已提交
990
	if (e1000_init_eeprom_params(hw)) {
991 992 993
		E1000_ERR("EEPROM initialization failed\n");
		return -EIO;
	}
L
Linus Torvalds 已提交
994

J
Jesse Brandeburg 已提交
995
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	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 已提交
1014
	if (hw->media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019
		hw->mdix = AUTO_ALL_MODES;
		hw->disable_polarity_correction = FALSE;
		hw->master_slave = E1000_MASTER_SLAVE;
	}

1020 1021
	adapter->num_tx_queues = 1;
	adapter->num_rx_queues = 1;
1022 1023 1024 1025 1026 1027 1028

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

#ifdef CONFIG_E1000_NAPI
1029
	for (i = 0; i < adapter->num_rx_queues; i++) {
1030 1031 1032 1033 1034 1035
		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);
	}
1036
	spin_lock_init(&adapter->tx_queue_lock);
1037 1038
#endif

L
Linus Torvalds 已提交
1039 1040 1041 1042 1043 1044
	atomic_set(&adapter->irq_sem, 1);
	spin_lock_init(&adapter->stats_lock);

	return 0;
}

1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
/**
 * 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;

1059
	size = sizeof(struct e1000_tx_ring) * adapter->num_tx_queues;
1060 1061 1062 1063 1064
	adapter->tx_ring = kmalloc(size, GFP_KERNEL);
	if (!adapter->tx_ring)
		return -ENOMEM;
	memset(adapter->tx_ring, 0, size);

1065
	size = sizeof(struct e1000_rx_ring) * adapter->num_rx_queues;
1066 1067 1068 1069 1070 1071 1072 1073
	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
1074
	size = sizeof(struct net_device) * adapter->num_rx_queues;
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
	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 已提交
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
/**
 * 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)
{
1103
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1104 1105 1106 1107
	int err;

	/* allocate transmit descriptors */

1108
	if ((err = e1000_setup_all_tx_resources(adapter)))
L
Linus Torvalds 已提交
1109 1110 1111 1112
		goto err_setup_tx;

	/* allocate receive descriptors */

1113
	if ((err = e1000_setup_all_rx_resources(adapter)))
L
Linus Torvalds 已提交
1114 1115
		goto err_setup_rx;

J
Jesse Brandeburg 已提交
1116
	if ((err = e1000_up(adapter)))
L
Linus Torvalds 已提交
1117
		goto err_up;
1118
	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
J
Jesse Brandeburg 已提交
1119
	if ((adapter->hw.mng_cookie.status &
1120 1121 1122
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_update_mng_vlan(adapter);
	}
L
Linus Torvalds 已提交
1123

1124 1125 1126 1127 1128 1129
	/* 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 已提交
1130 1131 1132
	return E1000_SUCCESS;

err_up:
1133
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1134
err_setup_rx:
1135
	e1000_free_all_tx_resources(adapter);
L
Linus Torvalds 已提交
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
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)
{
1157
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1158 1159 1160

	e1000_down(adapter);

1161 1162
	e1000_free_all_tx_resources(adapter);
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1163

J
Jesse Brandeburg 已提交
1164
	if ((adapter->hw.mng_cookie.status &
1165 1166 1167
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
	}
1168 1169 1170 1171 1172 1173 1174

	/* 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 已提交
1175 1176 1177 1178 1179 1180
	return 0;
}

/**
 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
 * @adapter: address of board private structure
1181 1182
 * @start: address of beginning of memory
 * @len: length of memory
L
Linus Torvalds 已提交
1183
 **/
1184
static boolean_t
L
Linus Torvalds 已提交
1185 1186 1187 1188 1189 1190
e1000_check_64k_bound(struct e1000_adapter *adapter,
		      void *start, unsigned long len)
{
	unsigned long begin = (unsigned long) start;
	unsigned long end = begin + len;

1191 1192
	/* First rev 82545 and 82546 need to not allow any memory
	 * write location to cross 64k boundary due to errata 23 */
L
Linus Torvalds 已提交
1193
	if (adapter->hw.mac_type == e1000_82545 ||
1194
	    adapter->hw.mac_type == e1000_82546) {
L
Linus Torvalds 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203
		return ((begin ^ (end - 1)) >> 16) != 0 ? FALSE : TRUE;
	}

	return TRUE;
}

/**
 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 * @adapter: board private structure
1204
 * @txdr:    tx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1205 1206 1207 1208
 *
 * Return 0 on success, negative on failure
 **/

1209
static int
1210 1211
e1000_setup_tx_resources(struct e1000_adapter *adapter,
                         struct e1000_tx_ring *txdr)
L
Linus Torvalds 已提交
1212 1213 1214 1215 1216
{
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct e1000_buffer) * txdr->count;
1217 1218

	txdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
J
Jesse Brandeburg 已提交
1219
	if (!txdr->buffer_info) {
1220 1221
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
		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 已提交
1232
	if (!txdr->desc) {
L
Linus Torvalds 已提交
1233 1234
setup_tx_desc_die:
		vfree(txdr->buffer_info);
1235 1236
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1237 1238 1239
		return -ENOMEM;
	}

1240
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1241 1242 1243
	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
		void *olddesc = txdr->desc;
		dma_addr_t olddma = txdr->dma;
1244 1245 1246
		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 已提交
1247
		txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
1248
		/* Failed allocation, critical failure */
J
Jesse Brandeburg 已提交
1249
		if (!txdr->desc) {
L
Linus Torvalds 已提交
1250 1251 1252 1253 1254 1255
			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 */
1256 1257
			pci_free_consistent(pdev, txdr->size, txdr->desc,
					    txdr->dma);
L
Linus Torvalds 已提交
1258 1259
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
			DPRINTK(PROBE, ERR,
1260 1261
				"Unable to allocate aligned memory "
				"for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1262 1263 1264
			vfree(txdr->buffer_info);
			return -ENOMEM;
		} else {
1265
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1266 1267 1268 1269 1270 1271 1272
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
		}
	}
	memset(txdr->desc, 0, txdr->size);

	txdr->next_to_use = 0;
	txdr->next_to_clean = 0;
1273
	spin_lock_init(&txdr->tx_lock);
L
Linus Torvalds 已提交
1274 1275 1276 1277

	return 0;
}

1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
/**
 * 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;

1295
	for (i = 0; i < adapter->num_tx_queues; i++) {
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
		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 已提交
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
/**
 * 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)
{
1317 1318 1319
	uint64_t tdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t tdlen, tctl, tipg, tarc;
1320
	uint32_t ipgr1, ipgr2;
L
Linus Torvalds 已提交
1321 1322 1323

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

1324
	switch (adapter->num_tx_queues) {
1325 1326
	case 1:
	default:
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
		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;
1337 1338
		break;
	}
L
Linus Torvalds 已提交
1339 1340 1341

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

1342 1343 1344 1345 1346 1347
	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;

1348
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1349 1350 1351
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
		tipg = DEFAULT_82542_TIPG_IPGT;
1352 1353
		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
L
Linus Torvalds 已提交
1354
		break;
1355 1356 1357 1358
	case e1000_80003es2lan:
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_80003ES2LAN_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1359
	default:
1360 1361 1362
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1363
	}
1364 1365
	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
1366
	E1000_WRITE_REG(hw, TIPG, tipg);
L
Linus Torvalds 已提交
1367 1368 1369

	/* Set the Tx Interrupt Delay register */

1370 1371 1372
	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 已提交
1373 1374 1375

	/* Program the Transmit Control Register */

1376
	tctl = E1000_READ_REG(hw, TCTL);
L
Linus Torvalds 已提交
1377 1378

	tctl &= ~E1000_TCTL_CT;
1379
	tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
L
Linus Torvalds 已提交
1380 1381
		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);

1382 1383 1384 1385
#ifdef DISABLE_MULR
	/* disable Multiple Reads for debugging */
	tctl &= ~E1000_TCTL_MULR;
#endif
L
Linus Torvalds 已提交
1386

1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
	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);
1398 1399 1400 1401 1402 1403 1404 1405 1406
	} 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);
1407 1408
	}

1409
	e1000_config_collision_dist(hw);
L
Linus Torvalds 已提交
1410 1411 1412 1413 1414

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

1415
	if (hw->mac_type < e1000_82543)
L
Linus Torvalds 已提交
1416 1417 1418 1419 1420 1421
		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. */
1422 1423
	if (hw->mac_type == e1000_82544 &&
	    hw->bus_type == e1000_bus_type_pcix)
L
Linus Torvalds 已提交
1424
		adapter->pcix_82544 = 1;
1425 1426 1427

	E1000_WRITE_REG(hw, TCTL, tctl);

L
Linus Torvalds 已提交
1428 1429 1430 1431 1432
}

/**
 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 * @adapter: board private structure
1433
 * @rxdr:    rx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1434 1435 1436 1437
 *
 * Returns 0 on success, negative on failure
 **/

1438
static int
1439 1440
e1000_setup_rx_resources(struct e1000_adapter *adapter,
                         struct e1000_rx_ring *rxdr)
L
Linus Torvalds 已提交
1441 1442
{
	struct pci_dev *pdev = adapter->pdev;
1443
	int size, desc_len;
L
Linus Torvalds 已提交
1444 1445

	size = sizeof(struct e1000_buffer) * rxdr->count;
1446
	rxdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
1447
	if (!rxdr->buffer_info) {
1448 1449
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1450 1451 1452 1453
		return -ENOMEM;
	}
	memset(rxdr->buffer_info, 0, size);

1454 1455
	size = sizeof(struct e1000_ps_page) * rxdr->count;
	rxdr->ps_page = kmalloc(size, GFP_KERNEL);
J
Jesse Brandeburg 已提交
1456
	if (!rxdr->ps_page) {
1457 1458 1459 1460 1461 1462 1463 1464 1465
		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 已提交
1466
	if (!rxdr->ps_page_dma) {
1467 1468 1469 1470 1471 1472 1473 1474
		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 已提交
1475
	if (adapter->hw.mac_type <= e1000_82547_rev_2)
1476 1477 1478 1479
		desc_len = sizeof(struct e1000_rx_desc);
	else
		desc_len = sizeof(union e1000_rx_desc_packet_split);

L
Linus Torvalds 已提交
1480 1481
	/* Round up to nearest 4K */

1482
	rxdr->size = rxdr->count * desc_len;
L
Linus Torvalds 已提交
1483 1484 1485 1486
	E1000_ROUNDUP(rxdr->size, 4096);

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

1487 1488 1489
	if (!rxdr->desc) {
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1490 1491
setup_rx_desc_die:
		vfree(rxdr->buffer_info);
1492 1493
		kfree(rxdr->ps_page);
		kfree(rxdr->ps_page_dma);
L
Linus Torvalds 已提交
1494 1495 1496
		return -ENOMEM;
	}

1497
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1498 1499 1500
	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
		void *olddesc = rxdr->desc;
		dma_addr_t olddma = rxdr->dma;
1501 1502 1503
		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 已提交
1504
		rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
1505
		/* Failed allocation, critical failure */
1506
		if (!rxdr->desc) {
L
Linus Torvalds 已提交
1507
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1508 1509 1510
			DPRINTK(PROBE, ERR,
				"Unable to allocate memory "
				"for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1511 1512 1513 1514 1515
			goto setup_rx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
			/* give up */
1516 1517
			pci_free_consistent(pdev, rxdr->size, rxdr->desc,
					    rxdr->dma);
L
Linus Torvalds 已提交
1518
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1519 1520 1521
			DPRINTK(PROBE, ERR,
				"Unable to allocate aligned memory "
				"for the receive descriptor ring\n");
1522
			goto setup_rx_desc_die;
L
Linus Torvalds 已提交
1523
		} else {
1524
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
			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;
}

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
/**
 * 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;

1553
	for (i = 0; i < adapter->num_rx_queues; i++) {
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
		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 已提交
1565
/**
1566
 * e1000_setup_rctl - configure the receive control registers
L
Linus Torvalds 已提交
1567 1568
 * @adapter: Board private structure
 **/
1569 1570
#define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
			(((S) & (PAGE_SIZE - 1)) ? 1 : 0))
L
Linus Torvalds 已提交
1571 1572 1573
static void
e1000_setup_rctl(struct e1000_adapter *adapter)
{
1574 1575
	uint32_t rctl, rfctl;
	uint32_t psrctl = 0;
1576
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1577 1578
	uint32_t pages = 0;
#endif
L
Linus Torvalds 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587

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

1588 1589 1590 1591
	if (adapter->hw.mac_type > e1000_82543)
		rctl |= E1000_RCTL_SECRC;

	if (adapter->hw.tbi_compatibility_on == 1)
L
Linus Torvalds 已提交
1592 1593 1594 1595
		rctl |= E1000_RCTL_SBP;
	else
		rctl &= ~E1000_RCTL_SBP;

1596 1597 1598 1599 1600
	if (adapter->netdev->mtu <= ETH_DATA_LEN)
		rctl &= ~E1000_RCTL_LPE;
	else
		rctl |= E1000_RCTL_LPE;

L
Linus Torvalds 已提交
1601
	/* Setup buffer sizes */
J
Jesse Brandeburg 已提交
1602
	if (adapter->hw.mac_type >= e1000_82571) {
1603 1604 1605 1606 1607
		/* We can now specify buffers in 1K increments.
		 * BSIZE and BSEX are ignored in this case. */
		rctl |= adapter->rx_buffer_len << 0x11;
	} else {
		rctl &= ~E1000_RCTL_SZ_4096;
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
		rctl |= E1000_RCTL_BSEX; 
		switch (adapter->rx_buffer_len) {
		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;
		}
1625 1626
	}

1627
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1628 1629 1630 1631 1632 1633 1634
	/* 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.
	 */
1635 1636 1637 1638 1639 1640
	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;
1641
#endif
1642
	if (adapter->rx_ps_pages) {
1643 1644 1645 1646 1647 1648 1649 1650
		/* 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 已提交
1651

1652 1653
		psrctl |= adapter->rx_ps_bsize0 >>
			E1000_PSRCTL_BSIZE0_SHIFT;
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666

		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;
		}
1667 1668

		E1000_WRITE_REG(&adapter->hw, PSRCTL, psrctl);
L
Linus Torvalds 已提交
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
	}

	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)
{
1684 1685 1686
	uint64_t rdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t rdlen, rctl, rxcsum, ctrl_ext;
1687

1688
	if (adapter->rx_ps_pages) {
1689
		/* this is a 32 byte descriptor */
1690
		rdlen = adapter->rx_ring[0].count *
1691 1692 1693 1694
			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 {
1695 1696
		rdlen = adapter->rx_ring[0].count *
			sizeof(struct e1000_rx_desc);
1697 1698 1699
		adapter->clean_rx = e1000_clean_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
	}
L
Linus Torvalds 已提交
1700 1701

	/* disable receives while setting up the descriptors */
1702 1703
	rctl = E1000_READ_REG(hw, RCTL);
	E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
L
Linus Torvalds 已提交
1704 1705

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

1708 1709
	if (hw->mac_type >= e1000_82540) {
		E1000_WRITE_REG(hw, RADV, adapter->rx_abs_int_delay);
J
Jesse Brandeburg 已提交
1710
		if (adapter->itr > 1)
1711
			E1000_WRITE_REG(hw, ITR,
L
Linus Torvalds 已提交
1712 1713 1714
				1000000000 / (adapter->itr * 256));
	}

1715 1716
	if (hw->mac_type >= e1000_82571) {
		ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
1717
		/* Reset delay timers after every interrupt */
1718
		ctrl_ext |= E1000_CTRL_EXT_CANC;
1719 1720 1721 1722
#ifdef CONFIG_E1000_NAPI
		/* Auto-Mask interrupts upon ICR read. */
		ctrl_ext |= E1000_CTRL_EXT_IAME;
#endif
1723
		E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
1724
		E1000_WRITE_REG(hw, IAM, ~0);
1725 1726 1727
		E1000_WRITE_FLUSH(hw);
	}

1728 1729
	/* Setup the HW Rx Head and Tail Descriptor Pointers and
	 * the Base and Length of the Rx Descriptor Ring */
1730
	switch (adapter->num_rx_queues) {
1731 1732
	case 1:
	default:
1733 1734 1735 1736 1737 1738 1739 1740 1741
		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;
1742 1743
	}

L
Linus Torvalds 已提交
1744
	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
1745 1746
	if (hw->mac_type >= e1000_82543) {
		rxcsum = E1000_READ_REG(hw, RXCSUM);
J
Jesse Brandeburg 已提交
1747
		if (adapter->rx_csum == TRUE) {
1748 1749
			rxcsum |= E1000_RXCSUM_TUOFL;

1750
			/* Enable 82571 IPv4 payload checksum for UDP fragments
1751
			 * Must be used in conjunction with packet-split. */
J
Jesse Brandeburg 已提交
1752 1753
			if ((hw->mac_type >= e1000_82571) &&
			    (adapter->rx_ps_pages)) {
1754 1755 1756 1757 1758 1759
				rxcsum |= E1000_RXCSUM_IPPCSE;
			}
		} else {
			rxcsum &= ~E1000_RXCSUM_TUOFL;
			/* don't need to clear IPPCSE as it defaults to 0 */
		}
1760
		E1000_WRITE_REG(hw, RXCSUM, rxcsum);
L
Linus Torvalds 已提交
1761 1762
	}

1763 1764
	if (hw->mac_type == e1000_82573)
		E1000_WRITE_REG(hw, ERT, 0x0100);
1765

L
Linus Torvalds 已提交
1766
	/* Enable Receives */
1767
	E1000_WRITE_REG(hw, RCTL, rctl);
L
Linus Torvalds 已提交
1768 1769 1770
}

/**
1771
 * e1000_free_tx_resources - Free Tx Resources per Queue
L
Linus Torvalds 已提交
1772
 * @adapter: board private structure
1773
 * @tx_ring: Tx descriptor ring for a specific queue
L
Linus Torvalds 已提交
1774 1775 1776 1777
 *
 * Free all transmit software resources
 **/

1778
static void
1779 1780
e1000_free_tx_resources(struct e1000_adapter *adapter,
                        struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1781 1782 1783
{
	struct pci_dev *pdev = adapter->pdev;

1784
	e1000_clean_tx_ring(adapter, tx_ring);
L
Linus Torvalds 已提交
1785

1786 1787
	vfree(tx_ring->buffer_info);
	tx_ring->buffer_info = NULL;
L
Linus Torvalds 已提交
1788

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

1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
	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;

1806
	for (i = 0; i < adapter->num_tx_queues; i++)
1807
		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
1808 1809
}

1810
static void
L
Linus Torvalds 已提交
1811 1812 1813
e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
			struct e1000_buffer *buffer_info)
{
J
Jesse Brandeburg 已提交
1814
	if (buffer_info->dma) {
1815 1816 1817 1818
		pci_unmap_page(adapter->pdev,
				buffer_info->dma,
				buffer_info->length,
				PCI_DMA_TODEVICE);
L
Linus Torvalds 已提交
1819
	}
1820
	if (buffer_info->skb)
L
Linus Torvalds 已提交
1821
		dev_kfree_skb_any(buffer_info->skb);
1822
	memset(buffer_info, 0, sizeof(struct e1000_buffer));
L
Linus Torvalds 已提交
1823 1824 1825 1826 1827
}

/**
 * e1000_clean_tx_ring - Free Tx Buffers
 * @adapter: board private structure
1828
 * @tx_ring: ring to be cleaned
L
Linus Torvalds 已提交
1829 1830 1831
 **/

static void
1832 1833
e1000_clean_tx_ring(struct e1000_adapter *adapter,
                    struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1834 1835 1836 1837 1838 1839 1840
{
	struct e1000_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	/* Free all the Tx ring sk_buffs */

J
Jesse Brandeburg 已提交
1841
	for (i = 0; i < tx_ring->count; i++) {
L
Linus Torvalds 已提交
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
		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 已提交
1855
	tx_ring->last_tx_tso = 0;
L
Linus Torvalds 已提交
1856

1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870
	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;

1871
	for (i = 0; i < adapter->num_tx_queues; i++)
1872
		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
1873 1874 1875 1876 1877
}

/**
 * e1000_free_rx_resources - Free Rx Resources
 * @adapter: board private structure
1878
 * @rx_ring: ring to clean the resources from
L
Linus Torvalds 已提交
1879 1880 1881 1882
 *
 * Free all receive software resources
 **/

1883
static void
1884 1885
e1000_free_rx_resources(struct e1000_adapter *adapter,
                        struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
1886 1887 1888
{
	struct pci_dev *pdev = adapter->pdev;

1889
	e1000_clean_rx_ring(adapter, rx_ring);
L
Linus Torvalds 已提交
1890 1891 1892

	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;
1893 1894 1895 1896
	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 已提交
1897 1898 1899 1900 1901 1902 1903

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

	rx_ring->desc = NULL;
}

/**
1904
 * e1000_free_all_rx_resources - Free Rx Resources for All Queues
L
Linus Torvalds 已提交
1905
 * @adapter: board private structure
1906 1907 1908 1909 1910 1911 1912 1913 1914
 *
 * Free all receive software resources
 **/

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

1915
	for (i = 0; i < adapter->num_rx_queues; i++)
1916 1917 1918 1919 1920 1921 1922
		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 已提交
1923 1924 1925
 **/

static void
1926 1927
e1000_clean_rx_ring(struct e1000_adapter *adapter,
                    struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
1928 1929
{
	struct e1000_buffer *buffer_info;
1930 1931
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
L
Linus Torvalds 已提交
1932 1933
	struct pci_dev *pdev = adapter->pdev;
	unsigned long size;
1934
	unsigned int i, j;
L
Linus Torvalds 已提交
1935 1936

	/* Free all the Rx ring sk_buffs */
J
Jesse Brandeburg 已提交
1937
	for (i = 0; i < rx_ring->count; i++) {
L
Linus Torvalds 已提交
1938
		buffer_info = &rx_ring->buffer_info[i];
J
Jesse Brandeburg 已提交
1939
		if (buffer_info->skb) {
L
Linus Torvalds 已提交
1940 1941 1942 1943 1944 1945 1946
			pci_unmap_single(pdev,
					 buffer_info->dma,
					 buffer_info->length,
					 PCI_DMA_FROMDEVICE);

			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
		}
		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 已提交
1958 1959 1960 1961 1962
		}
	}

	size = sizeof(struct e1000_buffer) * rx_ring->count;
	memset(rx_ring->buffer_info, 0, size);
1963 1964 1965 1966
	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 已提交
1967 1968 1969 1970 1971 1972 1973 1974

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

1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
	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;

1989
	for (i = 0; i < adapter->num_rx_queues; i++)
1990
		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
L
Linus Torvalds 已提交
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
}

/* 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 已提交
2010
	if (netif_running(netdev))
2011
		e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
}

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 已提交
2026
	if (adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
L
Linus Torvalds 已提交
2027 2028
		e1000_pci_set_mwi(&adapter->hw);

J
Jesse Brandeburg 已提交
2029
	if (netif_running(netdev)) {
2030 2031
		/* No need to loop, because 82542 supports only 1 queue */
		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2032
		e1000_configure_rx(adapter);
2033
		adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
L
Linus Torvalds 已提交
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
	}
}

/**
 * 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)
{
2048
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2049 2050
	struct sockaddr *addr = p;

J
Jesse Brandeburg 已提交
2051
	if (!is_valid_ether_addr(addr->sa_data))
L
Linus Torvalds 已提交
2052 2053 2054 2055
		return -EADDRNOTAVAIL;

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

J
Jesse Brandeburg 已提交
2056
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2057 2058 2059 2060 2061 2062 2063
		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);

2064 2065 2066 2067 2068 2069
	/* 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 已提交
2070 2071 2072
		/* 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
2073
		 * of the RARs and no incoming packets directed to this port
J
Jesse Brandeburg 已提交
2074
		 * are dropped. Eventaully the LAA will be in RAR[0] and
2075
		 * RAR[14] */
J
Jesse Brandeburg 已提交
2076
		e1000_rar_set(&adapter->hw, adapter->hw.mac_addr,
2077 2078 2079
					E1000_RAR_ENTRIES - 1);
	}

J
Jesse Brandeburg 已提交
2080
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
		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)
{
2099
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2100 2101 2102 2103
	struct e1000_hw *hw = &adapter->hw;
	struct dev_mc_list *mc_ptr;
	uint32_t rctl;
	uint32_t hash_value;
2104
	int i, rar_entries = E1000_RAR_ENTRIES;
L
Linus Torvalds 已提交
2105

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

2110 2111
	/* Check for Promiscuous and All Multicast modes */

L
Linus Torvalds 已提交
2112 2113
	rctl = E1000_READ_REG(hw, RCTL);

J
Jesse Brandeburg 已提交
2114
	if (netdev->flags & IFF_PROMISC) {
L
Linus Torvalds 已提交
2115
		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
J
Jesse Brandeburg 已提交
2116
	} else if (netdev->flags & IFF_ALLMULTI) {
L
Linus Torvalds 已提交
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
		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 已提交
2127
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2128 2129 2130 2131 2132
		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
2133
	 * -- with 82571 controllers only 0-13 entries are filled here
L
Linus Torvalds 已提交
2134 2135 2136
	 */
	mc_ptr = netdev->mc_list;

J
Jesse Brandeburg 已提交
2137
	for (i = 1; i < rar_entries; i++) {
2138
		if (mc_ptr) {
L
Linus Torvalds 已提交
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
			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 已提交
2149
	for (i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
L
Linus Torvalds 已提交
2150 2151 2152 2153
		E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);

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

J
Jesse Brandeburg 已提交
2154
	for (; mc_ptr; mc_ptr = mc_ptr->next) {
L
Linus Torvalds 已提交
2155 2156 2157 2158
		hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
		e1000_mta_set(hw, hash_value);
	}

J
Jesse Brandeburg 已提交
2159
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184
		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 已提交
2185 2186
	if (atomic_read(&adapter->tx_fifo_stall)) {
		if ((E1000_READ_REG(&adapter->hw, TDT) ==
L
Linus Torvalds 已提交
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 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
		    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 已提交
2232
	struct e1000_tx_ring *txdr = adapter->tx_ring;
2233
	uint32_t link, tctl;
L
Linus Torvalds 已提交
2234 2235

	e1000_check_for_link(&adapter->hw);
2236 2237
	if (adapter->hw.mac_type == e1000_82573) {
		e1000_enable_tx_pkt_filtering(&adapter->hw);
J
Jesse Brandeburg 已提交
2238
		if (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id)
2239
			e1000_update_mng_vlan(adapter);
J
Jesse Brandeburg 已提交
2240
	}
L
Linus Torvalds 已提交
2241

J
Jesse Brandeburg 已提交
2242
	if ((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
L
Linus Torvalds 已提交
2243 2244 2245 2246 2247
	   !(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 已提交
2248 2249
	if (link) {
		if (!netif_carrier_ok(netdev)) {
2250
			boolean_t txb2b = 1;
L
Linus Torvalds 已提交
2251 2252 2253 2254 2255 2256 2257 2258 2259
			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");

2260 2261
			/* tweak tx_queue_len according to speed/duplex
			 * and adjust the timeout factor */
2262 2263
			netdev->tx_queue_len = adapter->tx_queue_len;
			adapter->tx_timeout_factor = 1;
2264 2265
			switch (adapter->link_speed) {
			case SPEED_10:
2266
				txb2b = 0;
2267 2268 2269 2270
				netdev->tx_queue_len = 10;
				adapter->tx_timeout_factor = 8;
				break;
			case SPEED_100:
2271
				txb2b = 0;
2272 2273 2274 2275 2276
				netdev->tx_queue_len = 100;
				/* maybe add some timeout factor ? */
				break;
			}

2277
			if ((adapter->hw.mac_type == e1000_82571 ||
2278
			     adapter->hw.mac_type == e1000_82572) &&
2279
			    txb2b == 0) {
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
#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){
2292 2293 2294
				switch (adapter->link_speed) {
				case SPEED_10:
				case SPEED_100:
2295 2296 2297 2298 2299 2300 2301 2302 2303
					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 */
2304 2305 2306
					break;
				}
			}
2307 2308 2309 2310 2311 2312 2313
#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);
2314

L
Linus Torvalds 已提交
2315 2316 2317 2318 2319 2320
			netif_carrier_on(netdev);
			netif_wake_queue(netdev);
			mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
			adapter->smartspeed = 0;
		}
	} else {
J
Jesse Brandeburg 已提交
2321
		if (netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
2322 2323 2324 2325 2326 2327
			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);
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337

			/* 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 已提交
2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
		}

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

2357
	if (!netif_carrier_ok(netdev)) {
2358
		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
L
Linus Torvalds 已提交
2359 2360 2361 2362
			/* 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). */
2363 2364
			adapter->tx_timeout_count++;
			schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
2365 2366 2367 2368
		}
	}

	/* Dynamic mode for Interrupt Throttle Rate (ITR) */
J
Jesse Brandeburg 已提交
2369
	if (adapter->hw.mac_type >= e1000_82540 && adapter->itr == 1) {
L
Linus Torvalds 已提交
2370 2371 2372 2373
		/* 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 已提交
2374
		uint32_t dif = (adapter->gotcl > adapter->gorcl ?
L
Linus Torvalds 已提交
2375 2376 2377 2378 2379 2380 2381 2382 2383
			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);

2384
	/* Force detection of hung controller every watchdog period */
L
Linus Torvalds 已提交
2385 2386
	adapter->detect_tx_hung = TRUE;

J
Jesse Brandeburg 已提交
2387
	/* With 82571 controllers, LAA may be overwritten due to controller
2388 2389 2390 2391
	 * 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 已提交
2392 2393 2394 2395 2396 2397 2398
	/* 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
2399
#define E1000_TX_FLAGS_IPV4		0x00000008
L
Linus Torvalds 已提交
2400 2401 2402
#define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT	16

2403
static int
2404 2405
e1000_tso(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
          struct sk_buff *skb)
L
Linus Torvalds 已提交
2406 2407 2408
{
#ifdef NETIF_F_TSO
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2409
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2410 2411
	unsigned int i;
	uint32_t cmd_length = 0;
2412
	uint16_t ipcse = 0, tucse, mss;
L
Linus Torvalds 已提交
2413 2414 2415
	uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
	int err;

J
Jesse Brandeburg 已提交
2416
	if (skb_shinfo(skb)->tso_size) {
L
Linus Torvalds 已提交
2417 2418 2419 2420 2421 2422 2423 2424
		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;
J
Jesse Brandeburg 已提交
2425
		if (skb->protocol == ntohs(ETH_P_IP)) {
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
			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 已提交
2437
		} else if (skb->protocol == ntohs(ETH_P_IPV6)) {
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
			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 已提交
2448 2449 2450 2451 2452 2453 2454
		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 |
2455
			       E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
L
Linus Torvalds 已提交
2456

2457 2458
		i = tx_ring->next_to_use;
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
J
Jeff Kirsher 已提交
2459
		buffer_info = &tx_ring->buffer_info[i];
L
Linus Torvalds 已提交
2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470

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

2473 2474
		if (++i == tx_ring->count) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2475

2476
		return TRUE;
L
Linus Torvalds 已提交
2477 2478 2479
	}
#endif

2480
	return FALSE;
L
Linus Torvalds 已提交
2481 2482
}

2483
static boolean_t
2484 2485
e1000_tx_csum(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
              struct sk_buff *skb)
L
Linus Torvalds 已提交
2486 2487
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2488
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2489 2490 2491
	unsigned int i;
	uint8_t css;

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

2495
		i = tx_ring->next_to_use;
J
Jeff Kirsher 已提交
2496
		buffer_info = &tx_ring->buffer_info[i];
2497
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
L
Linus Torvalds 已提交
2498 2499 2500 2501 2502 2503 2504

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

2507 2508
		if (unlikely(++i == tx_ring->count)) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518

		return TRUE;
	}

	return FALSE;
}

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

2519
static int
2520 2521 2522
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 已提交
2523 2524 2525 2526 2527 2528 2529 2530 2531
{
	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 已提交
2532
	while (len) {
L
Linus Torvalds 已提交
2533 2534 2535
		buffer_info = &tx_ring->buffer_info[i];
		size = min(len, max_per_txd);
#ifdef NETIF_F_TSO
J
Jeff Kirsher 已提交
2536 2537 2538
		/* 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
2539
		 * DMA'd to the controller */
J
Jeff Kirsher 已提交
2540
		if (!skb->data_len && tx_ring->last_tx_tso &&
2541
		    !skb_shinfo(skb)->tso_size) {
J
Jeff Kirsher 已提交
2542 2543 2544 2545
			tx_ring->last_tx_tso = 0;
			size -= 4;
		}

L
Linus Torvalds 已提交
2546 2547
		/* Workaround for premature desc write-backs
		 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2548
		if (unlikely(mss && !nr_frags && size == len && size > 8))
L
Linus Torvalds 已提交
2549 2550
			size -= 4;
#endif
2551 2552 2553 2554 2555
		/* 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 已提交
2556
		if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
2557 2558
		                (size > 2015) && count == 0))
		        size = 2015;
J
Jesse Brandeburg 已提交
2559

L
Linus Torvalds 已提交
2560 2561
		/* Workaround for potential 82544 hang in PCI-X.  Avoid
		 * terminating buffers within evenly-aligned dwords. */
J
Jesse Brandeburg 已提交
2562
		if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
		   !((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 已提交
2578
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2579 2580
	}

J
Jesse Brandeburg 已提交
2581
	for (f = 0; f < nr_frags; f++) {
L
Linus Torvalds 已提交
2582 2583 2584 2585 2586 2587
		struct skb_frag_struct *frag;

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

J
Jesse Brandeburg 已提交
2588
		while (len) {
L
Linus Torvalds 已提交
2589 2590 2591 2592 2593
			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 已提交
2594
			if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
L
Linus Torvalds 已提交
2595 2596 2597 2598 2599
				size -= 4;
#endif
			/* Workaround for potential 82544 hang in PCI-X.
			 * Avoid terminating buffers within evenly-aligned
			 * dwords. */
J
Jesse Brandeburg 已提交
2600
			if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616
			   !((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 已提交
2617
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
		}
	}

	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;
}

2628
static void
2629 2630
e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
               int tx_flags, int count)
L
Linus Torvalds 已提交
2631 2632 2633 2634 2635 2636
{
	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 已提交
2637
	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
L
Linus Torvalds 已提交
2638 2639
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
		             E1000_TXD_CMD_TSE;
2640 2641
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;

J
Jesse Brandeburg 已提交
2642
		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2643
			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
L
Linus Torvalds 已提交
2644 2645
	}

J
Jesse Brandeburg 已提交
2646
	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
L
Linus Torvalds 已提交
2647 2648 2649 2650
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
	}

J
Jesse Brandeburg 已提交
2651
	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
L
Linus Torvalds 已提交
2652 2653 2654 2655 2656 2657
		txd_lower |= E1000_TXD_CMD_VLE;
		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
	}

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
2658
	while (count--) {
L
Linus Torvalds 已提交
2659 2660 2661 2662 2663 2664
		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 已提交
2665
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676
	}

	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;
2677
	writel(i, adapter->hw.hw_addr + tx_ring->tdt);
L
Linus Torvalds 已提交
2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
}

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

2692
static int
L
Linus Torvalds 已提交
2693 2694 2695 2696 2697 2698 2699
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 已提交
2700
	if (adapter->link_duplex != HALF_DUPLEX)
L
Linus Torvalds 已提交
2701 2702
		goto no_fifo_stall_required;

J
Jesse Brandeburg 已提交
2703
	if (atomic_read(&adapter->tx_fifo_stall))
L
Linus Torvalds 已提交
2704 2705
		return 1;

J
Jesse Brandeburg 已提交
2706
	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
L
Linus Torvalds 已提交
2707 2708 2709 2710 2711 2712
		atomic_set(&adapter->tx_fifo_stall, 1);
		return 1;
	}

no_fifo_stall_required:
	adapter->tx_fifo_head += skb_fifo_len;
J
Jesse Brandeburg 已提交
2713
	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
L
Linus Torvalds 已提交
2714 2715 2716 2717
		adapter->tx_fifo_head -= adapter->tx_fifo_size;
	return 0;
}

2718
#define MINIMUM_DHCP_PACKET_SIZE 282
2719
static int
2720 2721 2722 2723
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 已提交
2724 2725
	if (vlan_tx_tag_present(skb)) {
		if (!((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
2726 2727 2728 2729
			( adapter->hw.mng_cookie.status &
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) )
			return 0;
	}
2730
	if (skb->len > MINIMUM_DHCP_PACKET_SIZE) {
2731
		struct ethhdr *eth = (struct ethhdr *) skb->data;
J
Jesse Brandeburg 已提交
2732 2733
		if ((htons(ETH_P_IP) == eth->h_proto)) {
			const struct iphdr *ip =
2734
				(struct iphdr *)((uint8_t *)skb->data+14);
J
Jesse Brandeburg 已提交
2735 2736 2737
			if (IPPROTO_UDP == ip->protocol) {
				struct udphdr *udp =
					(struct udphdr *)((uint8_t *)ip +
2738
						(ip->ihl << 2));
J
Jesse Brandeburg 已提交
2739
				if (ntohs(udp->dest) == 67) {
2740 2741 2742 2743
					offset = (uint8_t *)udp + 8 - skb->data;
					length = skb->len - offset;

					return e1000_mng_write_dhcp_info(hw,
J
Jesse Brandeburg 已提交
2744
							(uint8_t *)udp + 8,
2745 2746 2747 2748 2749 2750 2751 2752
							length);
				}
			}
		}
	}
	return 0;
}

L
Linus Torvalds 已提交
2753 2754 2755 2756
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
static int
e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
{
2757
	struct e1000_adapter *adapter = netdev_priv(netdev);
2758
	struct e1000_tx_ring *tx_ring;
L
Linus Torvalds 已提交
2759 2760 2761 2762 2763 2764 2765 2766
	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;
J
Jesse Brandeburg 已提交
2767
 	int tso;
L
Linus Torvalds 已提交
2768 2769 2770
	unsigned int f;
	len -= skb->data_len;

2771
	tx_ring = adapter->tx_ring;
2772

2773
	if (unlikely(skb->len <= 0)) {
L
Linus Torvalds 已提交
2774 2775 2776 2777 2778 2779
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

#ifdef NETIF_F_TSO
	mss = skb_shinfo(skb)->tso_size;
2780
	/* The controller does a simple calculation to 
L
Linus Torvalds 已提交
2781 2782 2783 2784 2785
	 * 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 已提交
2786
	if (mss) {
J
Jeff Kirsher 已提交
2787
		uint8_t hdr_len;
L
Linus Torvalds 已提交
2788 2789
		max_per_txd = min(mss << 2, max_per_txd);
		max_txd_pwr = fls(max_per_txd) - 1;
J
Jeff Kirsher 已提交
2790

2791
	/* TSO Workaround for 82571/2/3 Controllers -- if skb->data
J
Jeff Kirsher 已提交
2792 2793 2794
	 * 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));
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805
		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)) {
					printk(KERN_ERR 
						"__pskb_pull_tail failed.\n");
					dev_kfree_skb_any(skb);
J
Jeff Garzik 已提交
2806
					return NETDEV_TX_OK;
2807 2808 2809 2810 2811 2812
				}
				len = skb->len - skb->data_len;
				break;
			default:
				/* do nothing */
				break;
2813
			}
J
Jeff Kirsher 已提交
2814
		}
L
Linus Torvalds 已提交
2815 2816
	}

J
Jeff Kirsher 已提交
2817
	/* reserve a descriptor for the offload context */
J
Jesse Brandeburg 已提交
2818
	if ((mss) || (skb->ip_summed == CHECKSUM_HW))
L
Linus Torvalds 已提交
2819
		count++;
2820
	count++;
L
Linus Torvalds 已提交
2821
#else
J
Jesse Brandeburg 已提交
2822
	if (skb->ip_summed == CHECKSUM_HW)
L
Linus Torvalds 已提交
2823 2824
		count++;
#endif
J
Jeff Kirsher 已提交
2825 2826 2827 2828

#ifdef NETIF_F_TSO
	/* Controller Erratum workaround */
	if (!skb->data_len && tx_ring->last_tx_tso &&
2829
	    !skb_shinfo(skb)->tso_size)
J
Jeff Kirsher 已提交
2830 2831 2832
		count++;
#endif

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

J
Jesse Brandeburg 已提交
2835
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
2836 2837
		count++;

J
Jesse Brandeburg 已提交
2838
	/* work-around for errata 10 and it applies to all controllers
2839 2840
	 * in PCI-X mode, so add one more descriptor to the count
	 */
J
Jesse Brandeburg 已提交
2841
	if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
2842 2843 2844
			(len > 2015)))
		count++;

L
Linus Torvalds 已提交
2845
	nr_frags = skb_shinfo(skb)->nr_frags;
J
Jesse Brandeburg 已提交
2846
	for (f = 0; f < nr_frags; f++)
L
Linus Torvalds 已提交
2847 2848
		count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
				       max_txd_pwr);
J
Jesse Brandeburg 已提交
2849
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
2850 2851
		count += nr_frags;

2852 2853 2854

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

2857 2858 2859 2860 2861 2862
	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 已提交
2863 2864 2865

	/* need: count + 2 desc gap to keep tail from touching
	 * head, otherwise try next time */
2866
	if (unlikely(E1000_DESC_UNUSED(tx_ring) < count + 2)) {
L
Linus Torvalds 已提交
2867
		netif_stop_queue(netdev);
2868
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2869 2870 2871
		return NETDEV_TX_BUSY;
	}

J
Jesse Brandeburg 已提交
2872 2873
	if (unlikely(adapter->hw.mac_type == e1000_82547)) {
		if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
L
Linus Torvalds 已提交
2874 2875
			netif_stop_queue(netdev);
			mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
2876
			spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2877 2878 2879 2880
			return NETDEV_TX_BUSY;
		}
	}

J
Jesse Brandeburg 已提交
2881
	if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
L
Linus Torvalds 已提交
2882 2883 2884 2885
		tx_flags |= E1000_TX_FLAGS_VLAN;
		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
	}

2886
	first = tx_ring->next_to_use;
J
Jesse Brandeburg 已提交
2887

2888
	tso = e1000_tso(adapter, tx_ring, skb);
L
Linus Torvalds 已提交
2889 2890
	if (tso < 0) {
		dev_kfree_skb_any(skb);
2891
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2892 2893 2894
		return NETDEV_TX_OK;
	}

J
Jeff Kirsher 已提交
2895 2896
	if (likely(tso)) {
		tx_ring->last_tx_tso = 1;
L
Linus Torvalds 已提交
2897
		tx_flags |= E1000_TX_FLAGS_TSO;
J
Jeff Kirsher 已提交
2898
	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
L
Linus Torvalds 已提交
2899 2900
		tx_flags |= E1000_TX_FLAGS_CSUM;

2901
	/* Old method was to assume IPv4 packet by default if TSO was enabled.
2902
	 * 82571 hardware supports TSO capabilities for IPv6 as well...
2903
	 * no longer assume, we must. */
2904
	if (likely(skb->protocol == ntohs(ETH_P_IP)))
2905 2906
		tx_flags |= E1000_TX_FLAGS_IPV4;

2907 2908 2909
	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 已提交
2910 2911 2912 2913

	netdev->trans_start = jiffies;

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

2917
	spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
	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)
{
2929
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2930 2931

	/* Do the reset outside of interrupt context */
2932 2933
	adapter->tx_timeout_count++;
	schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
2934 2935 2936
}

static void
2937
e1000_reset_task(struct net_device *netdev)
L
Linus Torvalds 已提交
2938
{
2939
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955

	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)
{
2956
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2957

J
Jeff Kirsher 已提交
2958
	/* only return the current stats */
L
Linus Torvalds 已提交
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972
	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)
{
2973
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2974
	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
2975
	uint16_t eeprom_data = 0;
L
Linus Torvalds 已提交
2976

J
Jesse Brandeburg 已提交
2977 2978 2979
	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
		DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
L
Linus Torvalds 已提交
2980
		return -EINVAL;
2981
	}
L
Linus Torvalds 已提交
2982

2983 2984 2985 2986 2987 2988
	/* Adapter-specific max frame size limits. */
	switch (adapter->hw.mac_type) {
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
		if (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
			DPRINTK(PROBE, ERR, "Jumbo Frames not supported.\n");
2989 2990
			return -EINVAL;
		}
2991
		break;
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005
	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 */
3006 3007
	case e1000_82571:
	case e1000_82572:
3008
	case e1000_80003es2lan:
3009 3010 3011 3012 3013 3014 3015 3016 3017
#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 已提交
3018 3019
	}

3020 3021

	if (adapter->hw.mac_type > e1000_82547_rev_2) {
3022
		adapter->rx_buffer_len = max_frame;
3023
		E1000_ROUNDUP(adapter->rx_buffer_len, 1024);
3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040
	} else {
		if(unlikely((adapter->hw.mac_type < e1000_82543) &&
		   (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE))) {
			DPRINTK(PROBE, ERR, "Jumbo Frames not supported "
					    "on 82542\n");
			return -EINVAL;
		} 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;
		}
	}
3041

3042 3043
	netdev->mtu = new_mtu;

J
Jesse Brandeburg 已提交
3044
	if (netif_running(netdev)) {
L
Linus Torvalds 已提交
3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 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 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130
		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

	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 已提交
3131
	if (hw->mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
3132 3133 3134 3135 3136 3137 3138
		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 已提交
3139
	if (hw->mac_type > e1000_82547_rev_2) {
3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
		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 已提交
3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161

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

3162 3163
	/* RLEC on some newer hardware can be incorrect so build
	* our own version based on RUC and ROC */
L
Linus Torvalds 已提交
3164 3165
	adapter->net_stats.rx_errors = adapter->stats.rxerrc +
		adapter->stats.crcerrs + adapter->stats.algnerrc +
3166 3167
		adapter->stats.ruc + adapter->stats.roc +
		adapter->stats.cexterr;
J
Jeff Kirsher 已提交
3168
	adapter->net_stats.rx_dropped = 0;
3169 3170
	adapter->net_stats.rx_length_errors = adapter->stats.ruc +
	                                      adapter->stats.roc;
L
Linus Torvalds 已提交
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186
	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 已提交
3187 3188
	if (hw->media_type == e1000_media_type_copper) {
		if ((adapter->link_speed == SPEED_1000) &&
L
Linus Torvalds 已提交
3189 3190 3191 3192 3193
		   (!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 已提交
3194
		if ((hw->mac_type <= e1000_82546) &&
L
Linus Torvalds 已提交
3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213
		   (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;
3214
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3215
	struct e1000_hw *hw = &adapter->hw;
3216
	uint32_t rctl, icr = E1000_READ_REG(hw, ICR);
3217
#ifndef CONFIG_E1000_NAPI
3218
	int i;
3219 3220 3221 3222 3223 3224 3225
#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 已提交
3226
#endif
L
Linus Torvalds 已提交
3227

3228 3229 3230 3231 3232
	if (unlikely(!icr)) {
#ifdef CONFIG_E1000_NAPI
		if (hw->mac_type >= e1000_82571)
			e1000_irq_enable(adapter);
#endif
L
Linus Torvalds 已提交
3233
		return IRQ_NONE;  /* Not our interrupt */
3234
	}
L
Linus Torvalds 已提交
3235

J
Jesse Brandeburg 已提交
3236
	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
L
Linus Torvalds 已提交
3237
		hw->get_link_status = 1;
3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248
		/* 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 已提交
3249 3250 3251 3252
		mod_timer(&adapter->watchdog_timer, jiffies);
	}

#ifdef CONFIG_E1000_NAPI
3253 3254 3255 3256 3257
	if (unlikely(hw->mac_type < e1000_82571)) {
		atomic_inc(&adapter->irq_sem);
		E1000_WRITE_REG(hw, IMC, ~0);
		E1000_WRITE_FLUSH(hw);
	}
3258 3259 3260 3261
	if (likely(netif_rx_schedule_prep(&adapter->polling_netdev[0])))
		__netif_rx_schedule(&adapter->polling_netdev[0]);
	else
		e1000_irq_enable(adapter);
3262
#else
L
Linus Torvalds 已提交
3263
	/* Writing IMC and IMS is needed for 82547.
J
Jesse Brandeburg 已提交
3264 3265 3266 3267 3268 3269 3270 3271 3272 3273
	 * 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 已提交
3274
		atomic_inc(&adapter->irq_sem);
3275
		E1000_WRITE_REG(hw, IMC, ~0);
L
Linus Torvalds 已提交
3276 3277
	}

J
Jesse Brandeburg 已提交
3278 3279
	for (i = 0; i < E1000_MAX_INTR; i++)
		if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) &
3280
		   !e1000_clean_tx_irq(adapter, adapter->tx_ring)))
L
Linus Torvalds 已提交
3281 3282
			break;

J
Jesse Brandeburg 已提交
3283
	if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)
L
Linus Torvalds 已提交
3284
		e1000_irq_enable(adapter);
3285

3286
#endif
L
Linus Torvalds 已提交
3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297

	return IRQ_HANDLED;
}

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

static int
3298
e1000_clean(struct net_device *poll_dev, int *budget)
L
Linus Torvalds 已提交
3299
{
3300 3301
	struct e1000_adapter *adapter;
	int work_to_do = min(*budget, poll_dev->quota);
3302
	int tx_cleaned = 0, i = 0, work_done = 0;
3303 3304 3305 3306 3307 3308 3309

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

3311 3312
	while (poll_dev != &adapter->polling_netdev[i]) {
		i++;
3313
		BUG_ON(i == adapter->num_rx_queues);
3314 3315
	}

3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
	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]);

3329 3330
	adapter->clean_rx(adapter, &adapter->rx_ring[i],
	                  &work_done, work_to_do);
L
Linus Torvalds 已提交
3331 3332

	*budget -= work_done;
3333
	poll_dev->quota -= work_done;
J
Jesse Brandeburg 已提交
3334

3335
	/* If no Tx and not enough Rx work done, exit the polling mode */
J
Jesse Brandeburg 已提交
3336
	if ((!tx_cleaned && (work_done == 0)) ||
3337 3338 3339
	   !netif_running(adapter->netdev)) {
quit_polling:
		netif_rx_complete(poll_dev);
L
Linus Torvalds 已提交
3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353
		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
3354 3355
e1000_clean_tx_irq(struct e1000_adapter *adapter,
                   struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
3356 3357 3358 3359 3360
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_tx_desc *tx_desc, *eop_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i, eop;
3361 3362 3363
#ifdef CONFIG_E1000_NAPI
	unsigned int count = 0;
#endif
L
Linus Torvalds 已提交
3364 3365 3366 3367 3368 3369
	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);

3370
	while (eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
J
Jesse Brandeburg 已提交
3371
		for (cleaned = FALSE; !cleaned; ) {
L
Linus Torvalds 已提交
3372 3373 3374 3375
			tx_desc = E1000_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];
			cleaned = (i == eop);

J
Jeff Kirsher 已提交
3376
			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3377
			memset(tx_desc, 0, sizeof(struct e1000_tx_desc));
L
Linus Torvalds 已提交
3378

J
Jesse Brandeburg 已提交
3379
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3380
		}
3381

3382

L
Linus Torvalds 已提交
3383 3384
		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = E1000_TX_DESC(*tx_ring, eop);
3385 3386 3387 3388 3389
#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 已提交
3390 3391 3392 3393
	}

	tx_ring->next_to_clean = i;

3394
	spin_lock(&tx_ring->tx_lock);
L
Linus Torvalds 已提交
3395

J
Jesse Brandeburg 已提交
3396
	if (unlikely(cleaned && netif_queue_stopped(netdev) &&
L
Linus Torvalds 已提交
3397 3398 3399
		    netif_carrier_ok(netdev)))
		netif_wake_queue(netdev);

3400
	spin_unlock(&tx_ring->tx_lock);
3401

3402
	if (adapter->detect_tx_hung) {
3403
		/* Detect a transmit hang in hardware, this serializes the
L
Linus Torvalds 已提交
3404 3405
		 * check with the clearing of time_stamp and movement of i */
		adapter->detect_tx_hung = FALSE;
3406 3407
		if (tx_ring->buffer_info[eop].dma &&
		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
3408
		               (adapter->tx_timeout_factor * HZ))
3409
		    && !(E1000_READ_REG(&adapter->hw, STATUS) &
3410
		         E1000_STATUS_TXOFF)) {
3411 3412

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

/**
 * e1000_rx_checksum - Receive Checksum Offload for 82543
3442 3443 3444 3445
 * @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 已提交
3446 3447
 **/

3448
static void
L
Linus Torvalds 已提交
3449
e1000_rx_checksum(struct e1000_adapter *adapter,
3450 3451
		  uint32_t status_err, uint32_t csum,
		  struct sk_buff *skb)
L
Linus Torvalds 已提交
3452
{
3453 3454 3455 3456
	uint16_t status = (uint16_t)status_err;
	uint8_t errors = (uint8_t)(status_err >> 24);
	skb->ip_summed = CHECKSUM_NONE;

L
Linus Torvalds 已提交
3457
	/* 82543 or newer only */
J
Jesse Brandeburg 已提交
3458
	if (unlikely(adapter->hw.mac_type < e1000_82543)) return;
L
Linus Torvalds 已提交
3459
	/* Ignore Checksum bit is set */
J
Jesse Brandeburg 已提交
3460
	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3461
	/* TCP/UDP checksum error bit is set */
J
Jesse Brandeburg 已提交
3462
	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
L
Linus Torvalds 已提交
3463 3464
		/* let the stack verify checksum errors */
		adapter->hw_csum_err++;
3465 3466 3467
		return;
	}
	/* TCP/UDP Checksum has not been calculated */
J
Jesse Brandeburg 已提交
3468 3469
	if (adapter->hw.mac_type <= e1000_82547_rev_2) {
		if (!(status & E1000_RXD_STAT_TCPCS))
3470
			return;
L
Linus Torvalds 已提交
3471
	} else {
J
Jesse Brandeburg 已提交
3472
		if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))
3473 3474 3475 3476
			return;
	}
	/* It must be a TCP or UDP packet with a valid checksum */
	if (likely(status & E1000_RXD_STAT_TCPCS)) {
L
Linus Torvalds 已提交
3477 3478
		/* TCP checksum is good */
		skb->ip_summed = CHECKSUM_UNNECESSARY;
3479 3480 3481 3482 3483 3484 3485 3486
	} 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 已提交
3487
	}
3488
	adapter->hw_csum_good++;
L
Linus Torvalds 已提交
3489 3490 3491
}

/**
3492
 * e1000_clean_rx_irq - Send received data up the network stack; legacy
L
Linus Torvalds 已提交
3493 3494 3495 3496 3497
 * @adapter: board private structure
 **/

static boolean_t
#ifdef CONFIG_E1000_NAPI
3498 3499 3500
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring,
                   int *work_done, int work_to_do)
L
Linus Torvalds 已提交
3501
#else
3502 3503
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
3504 3505 3506 3507
#endif
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3508 3509
	struct e1000_rx_desc *rx_desc, *next_rxd;
	struct e1000_buffer *buffer_info, *next_buffer;
L
Linus Torvalds 已提交
3510 3511 3512 3513
	unsigned long flags;
	uint32_t length;
	uint8_t last_byte;
	unsigned int i;
3514
	int cleaned_count = 0;
3515
	boolean_t cleaned = FALSE;
L
Linus Torvalds 已提交
3516 3517 3518

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

3521
	while (rx_desc->status & E1000_RXD_STAT_DD) {
3522
		struct sk_buff *skb, *next_skb;
3523
		u8 status;
L
Linus Torvalds 已提交
3524
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3525
		if (*work_done >= work_to_do)
L
Linus Torvalds 已提交
3526 3527 3528
			break;
		(*work_done)++;
#endif
3529
		status = rx_desc->status;
3530
		skb = buffer_info->skb;
3531 3532
		buffer_info->skb = NULL;

3533 3534
		prefetch(skb->data - NET_IP_ALIGN);

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

3539 3540
		next_buffer = &rx_ring->buffer_info[i];
		next_skb = next_buffer->skb;
3541
		prefetch(next_skb->data - NET_IP_ALIGN);
3542

3543 3544
		cleaned = TRUE;
		cleaned_count++;
3545 3546 3547
		pci_unmap_single(pdev,
		                 buffer_info->dma,
		                 buffer_info->length,
L
Linus Torvalds 已提交
3548 3549 3550 3551
		                 PCI_DMA_FROMDEVICE);

		length = le16_to_cpu(rx_desc->length);

3552 3553 3554 3555 3556
		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 已提交
3557 3558 3559
			goto next_desc;
		}

J
Jesse Brandeburg 已提交
3560
		if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
L
Linus Torvalds 已提交
3561
			last_byte = *(skb->data + length - 1);
3562
			if (TBI_ACCEPT(&adapter->hw, status,
L
Linus Torvalds 已提交
3563 3564
			              rx_desc->errors, length, last_byte)) {
				spin_lock_irqsave(&adapter->stats_lock, flags);
3565 3566
				e1000_tbi_adjust_stats(&adapter->hw,
				                       &adapter->stats,
L
Linus Torvalds 已提交
3567 3568 3569 3570 3571 3572 3573 3574 3575 3576
				                       length, skb->data);
				spin_unlock_irqrestore(&adapter->stats_lock,
				                       flags);
				length--;
			} else {
				dev_kfree_skb_irq(skb);
				goto next_desc;
			}
		}

3577 3578 3579 3580
		/* 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
3581
		if (length < E1000_CB_LENGTH) {
3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594
			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);
			}
3595 3596
		} else
			skb_put(skb, length);
3597 3598

		/* end copybreak code */
L
Linus Torvalds 已提交
3599 3600

		/* Receive Checksum Offload */
3601 3602
		e1000_rx_checksum(adapter,
				  (uint32_t)(status) |
3603
				  ((uint32_t)(rx_desc->errors) << 24),
D
David S. Miller 已提交
3604
				  le16_to_cpu(rx_desc->csum), skb);
J
Jesse Brandeburg 已提交
3605

L
Linus Torvalds 已提交
3606 3607
		skb->protocol = eth_type_trans(skb, netdev);
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3608
		if (unlikely(adapter->vlgrp &&
3609
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
3610
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
3611 3612
						 le16_to_cpu(rx_desc->special) &
						 E1000_RXD_SPC_VLAN_MASK);
L
Linus Torvalds 已提交
3613 3614 3615 3616
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
3617
		if (unlikely(adapter->vlgrp &&
3618
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630
			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;

3631 3632 3633 3634 3635 3636
		/* 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;
		}

3637
		/* use prefetched values */
3638 3639
		rx_desc = next_rxd;
		buffer_info = next_buffer;
L
Linus Torvalds 已提交
3640 3641
	}
	rx_ring->next_to_clean = i;
3642 3643 3644 3645

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656

	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
3657 3658 3659
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring,
                      int *work_done, int work_to_do)
3660
#else
3661 3662
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring)
3663 3664
#endif
{
3665
	union e1000_rx_desc_packet_split *rx_desc, *next_rxd;
3666 3667
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3668
	struct e1000_buffer *buffer_info, *next_buffer;
3669 3670
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
3671
	struct sk_buff *skb, *next_skb;
3672 3673
	unsigned int i, j;
	uint32_t length, staterr;
3674
	int cleaned_count = 0;
3675 3676 3677 3678
	boolean_t cleaned = FALSE;

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC_PS(*rx_ring, i);
3679
	staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
3680

J
Jesse Brandeburg 已提交
3681
	while (staterr & E1000_RXD_STAT_DD) {
3682
		buffer_info = &rx_ring->buffer_info[i];
3683 3684 3685
		ps_page = &rx_ring->ps_page[i];
		ps_page_dma = &rx_ring->ps_page_dma[i];
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3686
		if (unlikely(*work_done >= work_to_do))
3687 3688 3689
			break;
		(*work_done)++;
#endif
3690 3691
		skb = buffer_info->skb;

3692 3693 3694
		/* in the packet split case this is header only */
		prefetch(skb->data - NET_IP_ALIGN);

3695 3696
		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC_PS(*rx_ring, i);
3697 3698
		prefetch(next_rxd);

3699 3700
		next_buffer = &rx_ring->buffer_info[i];
		next_skb = next_buffer->skb;
3701
		prefetch(next_skb->data - NET_IP_ALIGN);
3702

3703
		cleaned = TRUE;
3704
		cleaned_count++;
3705 3706 3707 3708
		pci_unmap_single(pdev, buffer_info->dma,
				 buffer_info->length,
				 PCI_DMA_FROMDEVICE);

J
Jesse Brandeburg 已提交
3709
		if (unlikely(!(staterr & E1000_RXD_STAT_EOP))) {
3710 3711 3712 3713 3714
			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 已提交
3715

J
Jesse Brandeburg 已提交
3716
		if (unlikely(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) {
3717 3718 3719 3720 3721 3722
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

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

J
Jesse Brandeburg 已提交
3723
		if (unlikely(!length)) {
3724 3725 3726 3727 3728 3729 3730 3731 3732
			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);

3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761
		{
		/* 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*/
		if (l1 && ((length + l1) < E1000_CB_LENGTH)) {
			u8 *vaddr;
			/* there is no documentation about how to call 
			 * 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 已提交
3762
		for (j = 0; j < adapter->rx_ps_pages; j++) {
3763
			if (!(length= le16_to_cpu(rx_desc->wb.upper.length[j])))
3764 3765 3766 3767
				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;
3768 3769
			skb_fill_page_desc(skb, j, ps_page->ps_page[j], 0,
			                   length);
3770 3771 3772
			ps_page->ps_page[j] = NULL;
			skb->len += length;
			skb->data_len += length;
3773
			skb->truesize += length;
3774 3775
		}

3776
copydone:
3777
		e1000_rx_checksum(adapter, staterr,
D
David S. Miller 已提交
3778
				  le16_to_cpu(rx_desc->wb.lower.hi_dword.csum_ip.csum), skb);
3779 3780
		skb->protocol = eth_type_trans(skb, netdev);

J
Jesse Brandeburg 已提交
3781
		if (likely(rx_desc->wb.upper.header_status &
D
David S. Miller 已提交
3782
			   cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP)))
3783
			adapter->rx_hdr_split++;
3784
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3785
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
3786
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
3787 3788
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
3789 3790 3791 3792
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
3793
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
3794
			vlan_hwaccel_rx(skb, adapter->vlgrp,
3795 3796
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
3797 3798 3799 3800 3801 3802 3803
		} else {
			netif_rx(skb);
		}
#endif /* CONFIG_E1000_NAPI */
		netdev->last_rx = jiffies;

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

3807 3808 3809 3810 3811 3812
		/* 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;
		}

3813
		/* use prefetched values */
3814 3815 3816
		rx_desc = next_rxd;
		buffer_info = next_buffer;

3817
		staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
3818 3819
	}
	rx_ring->next_to_clean = i;
3820 3821 3822 3823

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
L
Linus Torvalds 已提交
3824 3825 3826 3827 3828

	return cleaned;
}

/**
3829
 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
L
Linus Torvalds 已提交
3830 3831 3832 3833
 * @adapter: address of board private structure
 **/

static void
3834
e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
3835
                       struct e1000_rx_ring *rx_ring,
3836
		       int cleaned_count)
L
Linus Torvalds 已提交
3837 3838 3839 3840 3841 3842
{
	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;
3843 3844
	unsigned int i;
	unsigned int bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
L
Linus Torvalds 已提交
3845 3846 3847 3848

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

3849 3850 3851 3852 3853 3854 3855 3856
	while (cleaned_count--) {
		if (!(skb = buffer_info->skb))
			skb = dev_alloc_skb(bufsz);
		else {
			skb_trim(skb, 0);
			goto map_skb;
		}

J
Jesse Brandeburg 已提交
3857
		if (unlikely(!skb)) {
L
Linus Torvalds 已提交
3858
			/* Better luck next round */
3859
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
3860 3861 3862
			break;
		}

3863
		/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
3864 3865
		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
			struct sk_buff *oldskb = skb;
3866 3867 3868
			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 已提交
3869
			skb = dev_alloc_skb(bufsz);
3870
			/* Failed allocation, critical failure */
L
Linus Torvalds 已提交
3871 3872 3873 3874
			if (!skb) {
				dev_kfree_skb(oldskb);
				break;
			}
3875

L
Linus Torvalds 已提交
3876 3877 3878 3879 3880 3881
			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 {
3882
				/* Use new allocation */
L
Linus Torvalds 已提交
3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895
				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;
3896
map_skb:
L
Linus Torvalds 已提交
3897 3898 3899 3900 3901
		buffer_info->dma = pci_map_single(pdev,
						  skb->data,
						  adapter->rx_buffer_len,
						  PCI_DMA_FROMDEVICE);

3902 3903 3904 3905 3906 3907 3908 3909
		/* 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 已提交
3910 3911 3912
			dev_kfree_skb(skb);
			buffer_info->skb = NULL;

3913
			pci_unmap_single(pdev, buffer_info->dma,
L
Linus Torvalds 已提交
3914 3915 3916 3917 3918 3919 3920 3921
					 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 已提交
3922 3923
		if (unlikely(++i == rx_ring->count))
			i = 0;
L
Linus Torvalds 已提交
3924 3925 3926
		buffer_info = &rx_ring->buffer_info[i];
	}

3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938
	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 已提交
3939 3940
}

3941 3942 3943 3944 3945 3946
/**
 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split
 * @adapter: address of board private structure
 **/

static void
3947
e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
3948 3949
                          struct e1000_rx_ring *rx_ring,
			  int cleaned_count)
3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964
{
	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];

3965
	while (cleaned_count--) {
3966 3967
		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

J
Jesse Brandeburg 已提交
3968
		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
3969 3970 3971 3972
			if (j < adapter->rx_ps_pages) {
				if (likely(!ps_page->ps_page[j])) {
					ps_page->ps_page[j] =
						alloc_page(GFP_ATOMIC);
3973 3974
					if (unlikely(!ps_page->ps_page[j])) {
						adapter->alloc_rx_buff_failed++;
3975
						goto no_buffers;
3976
					}
3977 3978 3979 3980 3981 3982 3983
					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 已提交
3984
				 * change because each write-back erases
3985 3986 3987 3988 3989 3990
				 * 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;
3991 3992 3993 3994
		}

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

3995 3996
		if (unlikely(!skb)) {
			adapter->alloc_rx_buff_failed++;
3997
			break;
3998
		}
3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015

		/* 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 已提交
4016
		if (unlikely(++i == rx_ring->count)) i = 0;
4017 4018 4019 4020 4021 4022
		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:
4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037
	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);
	}
4038 4039
}

L
Linus Torvalds 已提交
4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
/**
 * 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 已提交
4051
	if ((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
L
Linus Torvalds 已提交
4052 4053 4054
	   !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
		return;

J
Jesse Brandeburg 已提交
4055
	if (adapter->smartspeed == 0) {
L
Linus Torvalds 已提交
4056 4057 4058
		/* 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 已提交
4059
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4060
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4061
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4062
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
J
Jesse Brandeburg 已提交
4063
		if (phy_ctrl & CR_1000T_MS_ENABLE) {
L
Linus Torvalds 已提交
4064 4065 4066 4067
			phy_ctrl &= ~CR_1000T_MS_ENABLE;
			e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
					    phy_ctrl);
			adapter->smartspeed++;
J
Jesse Brandeburg 已提交
4068
			if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4069 4070 4071 4072 4073 4074 4075 4076 4077
			   !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 已提交
4078
	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
L
Linus Torvalds 已提交
4079 4080 4081 4082
		/* 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 已提交
4083
		if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4084 4085 4086 4087 4088 4089 4090
		   !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 已提交
4091
	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
L
Linus Torvalds 已提交
4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124
		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)
{
4125
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4126 4127 4128 4129
	struct mii_ioctl_data *data = if_mii(ifr);
	int retval;
	uint16_t mii_reg;
	uint16_t spddplx;
4130
	unsigned long flags;
L
Linus Torvalds 已提交
4131

J
Jesse Brandeburg 已提交
4132
	if (adapter->hw.media_type != e1000_media_type_copper)
L
Linus Torvalds 已提交
4133 4134 4135 4136 4137 4138 4139
		return -EOPNOTSUPP;

	switch (cmd) {
	case SIOCGMIIPHY:
		data->phy_id = adapter->hw.phy_addr;
		break;
	case SIOCGMIIREG:
J
Jesse Brandeburg 已提交
4140
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4141
			return -EPERM;
4142
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4143
		if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
4144 4145
				   &data->val_out)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4146
			return -EIO;
4147 4148
		}
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4149 4150
		break;
	case SIOCSMIIREG:
J
Jesse Brandeburg 已提交
4151
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4152
			return -EPERM;
J
Jesse Brandeburg 已提交
4153
		if (data->reg_num & ~(0x1F))
L
Linus Torvalds 已提交
4154 4155
			return -EFAULT;
		mii_reg = data->val_in;
4156
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4157
		if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
4158 4159
					mii_reg)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4160
			return -EIO;
4161
		}
4162
		if (adapter->hw.phy_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
4163 4164
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4165
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4166
					break;
J
Jesse Brandeburg 已提交
4167
				if (mii_reg & MII_CR_AUTO_NEG_EN) {
L
Linus Torvalds 已提交
4168 4169 4170 4171 4172 4173 4174 4175 4176 4177
					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)
4178 4179
						   ? DUPLEX_FULL :
						   DUPLEX_HALF;
L
Linus Torvalds 已提交
4180 4181
					retval = e1000_set_spd_dplx(adapter,
								    spddplx);
J
Jesse Brandeburg 已提交
4182
					if (retval) {
4183
						spin_unlock_irqrestore(
J
Jesse Brandeburg 已提交
4184
							&adapter->stats_lock,
4185
							flags);
L
Linus Torvalds 已提交
4186
						return retval;
4187
					}
L
Linus Torvalds 已提交
4188
				}
J
Jesse Brandeburg 已提交
4189
				if (netif_running(adapter->netdev)) {
L
Linus Torvalds 已提交
4190 4191 4192 4193 4194 4195 4196
					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 已提交
4197
				if (e1000_phy_reset(&adapter->hw)) {
4198 4199
					spin_unlock_irqrestore(
						&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4200
					return -EIO;
4201
				}
L
Linus Torvalds 已提交
4202 4203 4204 4205 4206
				break;
			}
		} else {
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4207
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4208
					break;
J
Jesse Brandeburg 已提交
4209
				if (netif_running(adapter->netdev)) {
L
Linus Torvalds 已提交
4210 4211 4212 4213 4214 4215 4216
					e1000_down(adapter);
					e1000_up(adapter);
				} else
					e1000_reset(adapter);
				break;
			}
		}
4217
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
		break;
	default:
		return -EOPNOTSUPP;
	}
	return E1000_SUCCESS;
}

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

J
Jesse Brandeburg 已提交
4231
	if (ret_val)
4232
		DPRINTK(PROBE, ERR, "Error in setting MWI\n");
L
Linus Torvalds 已提交
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 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273
}

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)
{
4274
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4275 4276 4277 4278 4279
	uint32_t ctrl, rctl;

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

J
Jesse Brandeburg 已提交
4280
	if (grp) {
L
Linus Torvalds 已提交
4281 4282 4283 4284 4285 4286 4287 4288 4289 4290
		/* 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);
4291
		e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
4292 4293 4294 4295 4296 4297 4298 4299 4300 4301
	} 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 已提交
4302
		if (adapter->mng_vlan_id != (uint16_t)E1000_MNG_VLAN_NONE) {
4303 4304 4305
			e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
		}
L
Linus Torvalds 已提交
4306 4307 4308 4309 4310 4311 4312 4313
	}

	e1000_irq_enable(adapter);
}

static void
e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
{
4314
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4315
	uint32_t vfta, index;
J
Jesse Brandeburg 已提交
4316 4317 4318 4319

	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
	    (vid == adapter->mng_vlan_id))
4320
		return;
L
Linus Torvalds 已提交
4321 4322 4323 4324 4325 4326 4327 4328 4329 4330
	/* 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)
{
4331
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4332 4333 4334 4335
	uint32_t vfta, index;

	e1000_irq_disable(adapter);

J
Jesse Brandeburg 已提交
4336
	if (adapter->vlgrp)
L
Linus Torvalds 已提交
4337 4338 4339 4340
		adapter->vlgrp->vlan_devices[vid] = NULL;

	e1000_irq_enable(adapter);

J
Jesse Brandeburg 已提交
4341 4342
	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
J
Jeff Kirsher 已提交
4343 4344 4345
	    (vid == adapter->mng_vlan_id)) {
		/* release control to f/w */
		e1000_release_hw_control(adapter);
4346
		return;
J
Jeff Kirsher 已提交
4347 4348
	}

L
Linus Torvalds 已提交
4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360
	/* 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 已提交
4361
	if (adapter->vlgrp) {
L
Linus Torvalds 已提交
4362
		uint16_t vid;
J
Jesse Brandeburg 已提交
4363 4364
		for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
			if (!adapter->vlgrp->vlan_devices[vid])
L
Linus Torvalds 已提交
4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375
				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;

4376
	/* Fiber NICs only allow 1000 gbps Full duplex */
J
Jesse Brandeburg 已提交
4377
	if ((adapter->hw.media_type == e1000_media_type_fiber) &&
4378 4379 4380 4381 4382
		spddplx != (SPEED_1000 + DUPLEX_FULL)) {
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
		return -EINVAL;
	}

J
Jesse Brandeburg 已提交
4383
	switch (spddplx) {
L
Linus Torvalds 已提交
4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401
	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:
4402
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
L
Linus Torvalds 已提交
4403 4404 4405 4406 4407
		return -EINVAL;
	}
	return 0;
}

4408
#ifdef CONFIG_PM
4409 4410
/* Save/restore 16 or 64 dwords of PCI config space depending on which
 * bus we're on (PCI(X) vs. PCI-E)
4411 4412 4413 4414 4415 4416 4417 4418 4419
 */
#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;
4420

4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
	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;
4444

4445 4446
	if (adapter->config_space == NULL)
		return;
4447

4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459
	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 已提交
4460
static int
4461
e1000_suspend(struct pci_dev *pdev, pm_message_t state)
L
Linus Torvalds 已提交
4462 4463
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4464
	struct e1000_adapter *adapter = netdev_priv(netdev);
4465
	uint32_t ctrl, ctrl_ext, rctl, manc, status;
L
Linus Torvalds 已提交
4466
	uint32_t wufc = adapter->wol;
4467
	int retval = 0;
L
Linus Torvalds 已提交
4468 4469 4470

	netif_device_detach(netdev);

J
Jesse Brandeburg 已提交
4471
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4472 4473
		e1000_down(adapter);

4474
#ifdef CONFIG_PM
4475 4476
	/* Implement our own version of pci_save_state(pdev) because pci-
	 * express adapters have 256-byte config spaces. */
4477 4478 4479 4480 4481
	retval = e1000_pci_save_state(adapter);
	if (retval)
		return retval;
#endif

L
Linus Torvalds 已提交
4482
	status = E1000_READ_REG(&adapter->hw, STATUS);
J
Jesse Brandeburg 已提交
4483
	if (status & E1000_STATUS_LU)
L
Linus Torvalds 已提交
4484 4485
		wufc &= ~E1000_WUFC_LNKC;

J
Jesse Brandeburg 已提交
4486
	if (wufc) {
L
Linus Torvalds 已提交
4487 4488 4489 4490
		e1000_setup_rctl(adapter);
		e1000_set_multi(netdev);

		/* turn on all-multi mode if wake on multicast is enabled */
J
Jesse Brandeburg 已提交
4491
		if (adapter->wol & E1000_WUFC_MC) {
L
Linus Torvalds 已提交
4492 4493 4494 4495 4496
			rctl = E1000_READ_REG(&adapter->hw, RCTL);
			rctl |= E1000_RCTL_MPE;
			E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
		}

J
Jesse Brandeburg 已提交
4497
		if (adapter->hw.mac_type >= e1000_82540) {
L
Linus Torvalds 已提交
4498 4499 4500 4501 4502 4503 4504 4505 4506 4507
			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 已提交
4508
		if (adapter->hw.media_type == e1000_media_type_fiber ||
L
Linus Torvalds 已提交
4509 4510 4511 4512 4513 4514 4515
		   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);
		}

4516 4517 4518
		/* Allow time for pending master requests to run */
		e1000_disable_pciex_master(&adapter->hw);

L
Linus Torvalds 已提交
4519 4520
		E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
		E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
4521 4522
		pci_enable_wake(pdev, PCI_D3hot, 1);
		pci_enable_wake(pdev, PCI_D3cold, 1);
L
Linus Torvalds 已提交
4523 4524 4525
	} else {
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
		E1000_WRITE_REG(&adapter->hw, WUFC, 0);
4526 4527
		pci_enable_wake(pdev, PCI_D3hot, 0);
		pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
4528 4529
	}

J
Jesse Brandeburg 已提交
4530
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
4531 4532
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
J
Jesse Brandeburg 已提交
4533
		if (manc & E1000_MANC_SMBUS_EN) {
L
Linus Torvalds 已提交
4534 4535
			manc |= E1000_MANC_ARP_EN;
			E1000_WRITE_REG(&adapter->hw, MANC, manc);
4536 4537
			pci_enable_wake(pdev, PCI_D3hot, 1);
			pci_enable_wake(pdev, PCI_D3cold, 1);
L
Linus Torvalds 已提交
4538 4539 4540
		}
	}

4541 4542 4543
	/* 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);
4544

L
Linus Torvalds 已提交
4545
	pci_disable_device(pdev);
4546

4547
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
L
Linus Torvalds 已提交
4548 4549 4550 4551

	return 0;
}

4552
#ifdef CONFIG_PM
L
Linus Torvalds 已提交
4553 4554 4555 4556
static int
e1000_resume(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4557
	struct e1000_adapter *adapter = netdev_priv(netdev);
4558
	uint32_t manc, ret_val;
L
Linus Torvalds 已提交
4559

4560
	pci_set_power_state(pdev, PCI_D0);
4561
	e1000_pci_restore_state(adapter);
4562
	ret_val = pci_enable_device(pdev);
4563
	pci_set_master(pdev);
L
Linus Torvalds 已提交
4564

4565 4566
	pci_enable_wake(pdev, PCI_D3hot, 0);
	pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
4567 4568 4569 4570

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

J
Jesse Brandeburg 已提交
4571
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4572 4573 4574 4575
		e1000_up(adapter);

	netif_device_attach(netdev);

J
Jesse Brandeburg 已提交
4576
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
4577 4578 4579 4580 4581 4582
	   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);
	}

4583 4584 4585 4586 4587 4588 4589
	/* 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);
4590

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

/* e1000_main.c */