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

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

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

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

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

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

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

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

#include "e1000.h"
A
Andrew Morton 已提交
30
#include <net/ip6_checksum.h>
L
Linus Torvalds 已提交
31 32

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

/* e1000_pci_tbl - PCI Device ID Table
 *
 * Last entry must be all 0s
 *
 * Macro expands to...
 *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
 */
static struct pci_device_id e1000_pci_tbl[] = {
	INTEL_E1000_ETHERNET_DEVICE(0x1000),
	INTEL_E1000_ETHERNET_DEVICE(0x1001),
	INTEL_E1000_ETHERNET_DEVICE(0x1004),
	INTEL_E1000_ETHERNET_DEVICE(0x1008),
	INTEL_E1000_ETHERNET_DEVICE(0x1009),
	INTEL_E1000_ETHERNET_DEVICE(0x100C),
	INTEL_E1000_ETHERNET_DEVICE(0x100D),
	INTEL_E1000_ETHERNET_DEVICE(0x100E),
	INTEL_E1000_ETHERNET_DEVICE(0x100F),
	INTEL_E1000_ETHERNET_DEVICE(0x1010),
	INTEL_E1000_ETHERNET_DEVICE(0x1011),
	INTEL_E1000_ETHERNET_DEVICE(0x1012),
	INTEL_E1000_ETHERNET_DEVICE(0x1013),
	INTEL_E1000_ETHERNET_DEVICE(0x1014),
	INTEL_E1000_ETHERNET_DEVICE(0x1015),
	INTEL_E1000_ETHERNET_DEVICE(0x1016),
	INTEL_E1000_ETHERNET_DEVICE(0x1017),
	INTEL_E1000_ETHERNET_DEVICE(0x1018),
	INTEL_E1000_ETHERNET_DEVICE(0x1019),
70
	INTEL_E1000_ETHERNET_DEVICE(0x101A),
L
Linus Torvalds 已提交
71 72 73 74 75
	INTEL_E1000_ETHERNET_DEVICE(0x101D),
	INTEL_E1000_ETHERNET_DEVICE(0x101E),
	INTEL_E1000_ETHERNET_DEVICE(0x1026),
	INTEL_E1000_ETHERNET_DEVICE(0x1027),
	INTEL_E1000_ETHERNET_DEVICE(0x1028),
A
Auke Kok 已提交
76 77 78 79 80
	INTEL_E1000_ETHERNET_DEVICE(0x1049),
	INTEL_E1000_ETHERNET_DEVICE(0x104A),
	INTEL_E1000_ETHERNET_DEVICE(0x104B),
	INTEL_E1000_ETHERNET_DEVICE(0x104C),
	INTEL_E1000_ETHERNET_DEVICE(0x104D),
81 82 83
	INTEL_E1000_ETHERNET_DEVICE(0x105E),
	INTEL_E1000_ETHERNET_DEVICE(0x105F),
	INTEL_E1000_ETHERNET_DEVICE(0x1060),
L
Linus Torvalds 已提交
84 85 86 87 88 89 90 91
	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),
92 93 94
	INTEL_E1000_ETHERNET_DEVICE(0x107D),
	INTEL_E1000_ETHERNET_DEVICE(0x107E),
	INTEL_E1000_ETHERNET_DEVICE(0x107F),
L
Linus Torvalds 已提交
95
	INTEL_E1000_ETHERNET_DEVICE(0x108A),
96 97
	INTEL_E1000_ETHERNET_DEVICE(0x108B),
	INTEL_E1000_ETHERNET_DEVICE(0x108C),
98 99
	INTEL_E1000_ETHERNET_DEVICE(0x1096),
	INTEL_E1000_ETHERNET_DEVICE(0x1098),
100
	INTEL_E1000_ETHERNET_DEVICE(0x1099),
101
	INTEL_E1000_ETHERNET_DEVICE(0x109A),
102
	INTEL_E1000_ETHERNET_DEVICE(0x10A4),
103
	INTEL_E1000_ETHERNET_DEVICE(0x10A5),
104
	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
105
	INTEL_E1000_ETHERNET_DEVICE(0x10B9),
A
Auke Kok 已提交
106 107
	INTEL_E1000_ETHERNET_DEVICE(0x10BA),
	INTEL_E1000_ETHERNET_DEVICE(0x10BB),
A
Auke Kok 已提交
108 109 110
	INTEL_E1000_ETHERNET_DEVICE(0x10BC),
	INTEL_E1000_ETHERNET_DEVICE(0x10C4),
	INTEL_E1000_ETHERNET_DEVICE(0x10C5),
111
	INTEL_E1000_ETHERNET_DEVICE(0x10D5),
112 113
	INTEL_E1000_ETHERNET_DEVICE(0x10D9),
	INTEL_E1000_ETHERNET_DEVICE(0x10DA),
L
Linus Torvalds 已提交
114 115 116 117 118 119
	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

120 121 122 123 124 125 126 127 128
int e1000_up(struct e1000_adapter *adapter);
void e1000_down(struct e1000_adapter *adapter);
void e1000_reinit_locked(struct e1000_adapter *adapter);
void e1000_reset(struct e1000_adapter *adapter);
int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
129
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
130
                             struct e1000_tx_ring *txdr);
131
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
132
                             struct e1000_rx_ring *rxdr);
133
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
134
                             struct e1000_tx_ring *tx_ring);
135
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
136 137
                             struct e1000_rx_ring *rx_ring);
void e1000_update_stats(struct e1000_adapter *adapter);
L
Linus Torvalds 已提交
138 139 140 141 142

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);
143
static int e1000_alloc_queues(struct e1000_adapter *adapter);
L
Linus Torvalds 已提交
144 145 146 147 148 149
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);
150 151 152 153 154 155
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 已提交
156 157 158 159 160 161 162 163
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_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);
164
static irqreturn_t e1000_intr(int irq, void *data);
165
static irqreturn_t e1000_intr_msi(int irq, void *data);
166 167
static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,
                                    struct e1000_tx_ring *tx_ring);
L
Linus Torvalds 已提交
168
#ifdef CONFIG_E1000_NAPI
169
static int e1000_clean(struct napi_struct *napi, int budget);
L
Linus Torvalds 已提交
170
static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
171
                                    struct e1000_rx_ring *rx_ring,
L
Linus Torvalds 已提交
172
                                    int *work_done, int work_to_do);
173
static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
174
                                       struct e1000_rx_ring *rx_ring,
175
                                       int *work_done, int work_to_do);
L
Linus Torvalds 已提交
176
#else
177 178 179 180
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 已提交
181
#endif
182
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
183 184
                                   struct e1000_rx_ring *rx_ring,
				   int cleaned_count);
185
static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
186 187
                                      struct e1000_rx_ring *rx_ring,
				      int cleaned_count);
L
Linus Torvalds 已提交
188 189 190 191 192 193
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);
194
static void e1000_reset_task(struct work_struct *work);
L
Linus Torvalds 已提交
195
static void e1000_smartspeed(struct e1000_adapter *adapter);
196 197
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
                                       struct sk_buff *skb);
L
Linus Torvalds 已提交
198 199 200 201 202 203

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

204
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
A
Auke Kok 已提交
205
#ifdef CONFIG_PM
L
Linus Torvalds 已提交
206 207
static int e1000_resume(struct pci_dev *pdev);
#endif
208
static void e1000_shutdown(struct pci_dev *pdev);
L
Linus Torvalds 已提交
209 210 211 212 213 214

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

215 216 217 218 219 220
#define COPYBREAK_DEFAULT 256
static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;
module_param(copybreak, uint, 0644);
MODULE_PARM_DESC(copybreak,
	"Maximum size of packet that is copied to a new buffer on receive");

A
Auke Kok 已提交
221 222 223 224 225 226 227 228 229 230
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
                     pci_channel_state_t state);
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
static void e1000_io_resume(struct pci_dev *pdev);

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

L
Linus Torvalds 已提交
232 233 234 235 236
static struct pci_driver e1000_driver = {
	.name     = e1000_driver_name,
	.id_table = e1000_pci_tbl,
	.probe    = e1000_probe,
	.remove   = __devexit_p(e1000_remove),
237
#ifdef CONFIG_PM
L
Linus Torvalds 已提交
238 239
	/* Power Managment Hooks */
	.suspend  = e1000_suspend,
240
	.resume   = e1000_resume,
L
Linus Torvalds 已提交
241
#endif
A
Auke Kok 已提交
242 243
	.shutdown = e1000_shutdown,
	.err_handler = &e1000_err_handler
L
Linus Torvalds 已提交
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
};

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

271
	ret = pci_register_driver(&e1000_driver);
272 273 274 275 276 277 278
	if (copybreak != COPYBREAK_DEFAULT) {
		if (copybreak == 0)
			printk(KERN_INFO "e1000: copybreak disabled\n");
		else
			printk(KERN_INFO "e1000: copybreak enabled for "
			       "packets <= %u bytes\n", copybreak);
	}
L
Linus Torvalds 已提交
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
	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);

299 300 301
static int e1000_request_irq(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
302 303 304
	void (*handler) = &e1000_intr;
	int irq_flags = IRQF_SHARED;
	int err;
305

306
	if (adapter->hw.mac_type >= e1000_82571) {
307 308 309 310
		adapter->have_msi = !pci_enable_msi(adapter->pdev);
		if (adapter->have_msi) {
			handler = &e1000_intr_msi;
			irq_flags = 0;
311 312
		}
	}
313 314 315 316 317 318

	err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
	                  netdev);
	if (err) {
		if (adapter->have_msi)
			pci_disable_msi(adapter->pdev);
319 320
		DPRINTK(PROBE, ERR,
		        "Unable to allocate interrupt Error: %d\n", err);
321
	}
322 323 324 325 326 327 328 329 330 331 332 333 334 335

	return err;
}

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

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

	if (adapter->have_msi)
		pci_disable_msi(adapter->pdev);
}

L
Linus Torvalds 已提交
336 337 338 339 340
/**
 * e1000_irq_disable - Mask off interrupt generation on the NIC
 * @adapter: board private structure
 **/

341
static void
L
Linus Torvalds 已提交
342 343 344 345 346 347 348 349 350 351 352 353 354
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
 **/

355
static void
L
Linus Torvalds 已提交
356 357
e1000_irq_enable(struct e1000_adapter *adapter)
{
J
Jesse Brandeburg 已提交
358
	if (likely(atomic_dec_and_test(&adapter->irq_sem))) {
L
Linus Torvalds 已提交
359 360 361 362
		E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
		E1000_WRITE_FLUSH(&adapter->hw);
	}
}
363 364

static void
365 366 367 368 369
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 已提交
370
	if (adapter->vlgrp) {
D
Dan Aloni 已提交
371
		if (!vlan_group_get_device(adapter->vlgrp, vid)) {
J
Jesse Brandeburg 已提交
372
			if (adapter->hw.mng_cookie.status &
373 374 375 376 377
				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 已提交
378 379 380

			if ((old_vid != (uint16_t)E1000_MNG_VLAN_NONE) &&
					(vid != old_vid) &&
D
Dan Aloni 已提交
381
			    !vlan_group_get_device(adapter->vlgrp, old_vid))
382
				e1000_vlan_rx_kill_vid(netdev, old_vid);
383 384
		} else
			adapter->mng_vlan_id = vid;
385 386
	}
}
387 388 389 390 391 392 393 394

/**
 * 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
395
 * of the f/w this means that the network i/f is closed.
396
 *
397 398
 **/

399
static void
400 401 402 403 404 405 406 407 408 409 410
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_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm & ~E1000_SWSM_DRV_LOAD);
B
Bruce Allan 已提交
411 412 413 414
		break;
	case e1000_82571:
	case e1000_82572:
	case e1000_80003es2lan:
415
	case e1000_ich8lan:
B
Bruce Allan 已提交
416
		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
417
		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
B
Bruce Allan 已提交
418
				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
419
		break;
420 421 422 423 424 425 426 427 428 429
	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.
430 431
 * For ASF and Pass Through versions of f/w this means that
 * the driver is loaded. For AMT version (only with 82573)
432
 * of the f/w this means that the network i/f is open.
433
 *
434 435
 **/

436
static void
437 438 439 440
e1000_get_hw_control(struct e1000_adapter *adapter)
{
	uint32_t ctrl_ext;
	uint32_t swsm;
441

442 443 444 445 446 447 448
	/* Let firmware know the driver has taken over */
	switch (adapter->hw.mac_type) {
	case e1000_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm | E1000_SWSM_DRV_LOAD);
		break;
B
Bruce Allan 已提交
449 450 451
	case e1000_82571:
	case e1000_82572:
	case e1000_80003es2lan:
452
	case e1000_ich8lan:
B
Bruce Allan 已提交
453 454 455
		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
456
		break;
457 458 459 460 461
	default:
		break;
	}
}

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
static void
e1000_init_manageability(struct e1000_adapter *adapter)
{
	if (adapter->en_mng_pt) {
		uint32_t manc = E1000_READ_REG(&adapter->hw, MANC);

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

		/* enable receiving management packets to the host */
		/* this will probably generate destination unreachable messages
		 * from the host OS, but the packets will be handled on SMBUS */
		if (adapter->hw.has_manc2h) {
			uint32_t manc2h = E1000_READ_REG(&adapter->hw, MANC2H);

			manc |= E1000_MANC_EN_MNG2HOST;
#define E1000_MNG2HOST_PORT_623 (1 << 5)
#define E1000_MNG2HOST_PORT_664 (1 << 6)
			manc2h |= E1000_MNG2HOST_PORT_623;
			manc2h |= E1000_MNG2HOST_PORT_664;
			E1000_WRITE_REG(&adapter->hw, MANC2H, manc2h);
		}

		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}
}

static void
e1000_release_manageability(struct e1000_adapter *adapter)
{
	if (adapter->en_mng_pt) {
		uint32_t manc = E1000_READ_REG(&adapter->hw, MANC);

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

		if (adapter->hw.has_manc2h)
			manc &= ~E1000_MANC_EN_MNG2HOST;

		/* don't explicitly have to mess with MANC2H since
		 * MANC has an enable disable that gates MANC2H */

		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}
}

508 509 510 511 512
/**
 * e1000_configure - configure the hardware for RX and TX
 * @adapter = private board structure
 **/
static void e1000_configure(struct e1000_adapter *adapter)
L
Linus Torvalds 已提交
513 514
{
	struct net_device *netdev = adapter->netdev;
515
	int i;
L
Linus Torvalds 已提交
516 517 518 519

	e1000_set_multi(netdev);

	e1000_restore_vlan(adapter);
520
	e1000_init_manageability(adapter);
L
Linus Torvalds 已提交
521 522 523 524

	e1000_configure_tx(adapter);
	e1000_setup_rctl(adapter);
	e1000_configure_rx(adapter);
525 526 527
	/* call E1000_DESC_UNUSED which always leaves
	 * at least 1 descriptor unused to make sure
	 * next_to_use != next_to_clean */
528
	for (i = 0; i < adapter->num_rx_queues; i++) {
529
		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
530 531
		adapter->alloc_rx_buf(adapter, ring,
		                      E1000_DESC_UNUSED(ring));
532
	}
L
Linus Torvalds 已提交
533

534
	adapter->tx_queue_len = netdev->tx_queue_len;
535 536 537 538 539 540 541 542
}

int e1000_up(struct e1000_adapter *adapter)
{
	/* hardware has been reset, we need to reload some things */
	e1000_configure(adapter);

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

L
Linus Torvalds 已提交
544
#ifdef CONFIG_E1000_NAPI
545
	napi_enable(&adapter->napi);
L
Linus Torvalds 已提交
546
#endif
547 548
	e1000_irq_enable(adapter);

549 550
	/* fire a link change interrupt to start the watchdog */
	E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_LSC);
L
Linus Torvalds 已提交
551 552 553
	return 0;
}

554 555 556 557 558 559 560 561 562 563
/**
 * e1000_power_up_phy - restore link in case the phy was powered down
 * @adapter: address of board private structure
 *
 * The phy may be powered down to save power and turn off link when the
 * driver is unloaded and wake on lan is not enabled (among others)
 * *** this routine MUST be followed by a call to e1000_reset ***
 *
 **/

564
void e1000_power_up_phy(struct e1000_adapter *adapter)
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
{
	uint16_t mii_reg = 0;

	/* Just clear the power down bit to wake the phy back up */
	if (adapter->hw.media_type == e1000_media_type_copper) {
		/* according to the manual, the phy will retain its
		 * settings across a power-down/up cycle */
		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);
	}
}

static void e1000_power_down_phy(struct e1000_adapter *adapter)
{
580 581
	/* 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 *
582 583 584 585
	 * (a) WoL is enabled
	 * (b) AMT is active
	 * (c) SoL/IDER session is active */
	if (!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&
586
	   adapter->hw.media_type == e1000_media_type_copper) {
587
		uint16_t mii_reg = 0;
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614

		switch (adapter->hw.mac_type) {
		case e1000_82540:
		case e1000_82545:
		case e1000_82545_rev_3:
		case e1000_82546:
		case e1000_82546_rev_3:
		case e1000_82541:
		case e1000_82541_rev_2:
		case e1000_82547:
		case e1000_82547_rev_2:
			if (E1000_READ_REG(&adapter->hw, MANC) &
			    E1000_MANC_SMBUS_EN)
				goto out;
			break;
		case e1000_82571:
		case e1000_82572:
		case e1000_82573:
		case e1000_80003es2lan:
		case e1000_ich8lan:
			if (e1000_check_mng_mode(&adapter->hw) ||
			    e1000_check_phy_reset_block(&adapter->hw))
				goto out;
			break;
		default:
			goto out;
		}
615 616 617 618 619
		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);
		mdelay(1);
	}
620 621
out:
	return;
622 623
}

L
Linus Torvalds 已提交
624 625 626 627 628
void
e1000_down(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;

A
Auke Kok 已提交
629 630 631 632
	/* signal that we're down so the interrupt handler does not
	 * reschedule our watchdog timer */
	set_bit(__E1000_DOWN, &adapter->flags);

633
#ifdef CONFIG_E1000_NAPI
634
	napi_disable(&adapter->napi);
635
#endif
L
Linus Torvalds 已提交
636
	e1000_irq_disable(adapter);
637

L
Linus Torvalds 已提交
638 639 640 641
	del_timer_sync(&adapter->tx_fifo_stall_timer);
	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

642
	netdev->tx_queue_len = adapter->tx_queue_len;
L
Linus Torvalds 已提交
643 644 645 646 647 648
	adapter->link_speed = 0;
	adapter->link_duplex = 0;
	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	e1000_reset(adapter);
649 650
	e1000_clean_all_tx_rings(adapter);
	e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
651 652
}

653 654 655 656 657 658 659 660 661
void
e1000_reinit_locked(struct e1000_adapter *adapter)
{
	WARN_ON(in_interrupt());
	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
		msleep(1);
	e1000_down(adapter);
	e1000_up(adapter);
	clear_bit(__E1000_RESETTING, &adapter->flags);
L
Linus Torvalds 已提交
662 663 664 665 666
}

void
e1000_reset(struct e1000_adapter *adapter)
{
667
	uint32_t pba = 0, tx_space, min_tx_space, min_rx_space;
668
	uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
669
	boolean_t legacy_pba_adjust = FALSE;
L
Linus Torvalds 已提交
670 671 672 673 674

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

675
	switch (adapter->hw.mac_type) {
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
	case e1000_82543:
	case e1000_82544:
	case e1000_82540:
	case e1000_82541:
	case e1000_82541_rev_2:
		legacy_pba_adjust = TRUE;
		pba = E1000_PBA_48K;
		break;
	case e1000_82545:
	case e1000_82545_rev_3:
	case e1000_82546:
	case e1000_82546_rev_3:
		pba = E1000_PBA_48K;
		break;
692
	case e1000_82547:
693
	case e1000_82547_rev_2:
694
		legacy_pba_adjust = TRUE;
695 696
		pba = E1000_PBA_30K;
		break;
697 698
	case e1000_82571:
	case e1000_82572:
699
	case e1000_80003es2lan:
700 701
		pba = E1000_PBA_38K;
		break;
702
	case e1000_82573:
703
		pba = E1000_PBA_20K;
704
		break;
705 706
	case e1000_ich8lan:
		pba = E1000_PBA_8K;
707 708
	case e1000_undefined:
	case e1000_num_macs:
709 710 711
		break;
	}

712 713 714
	if (legacy_pba_adjust == TRUE) {
		if (adapter->netdev->mtu > E1000_RXBUFFER_8192)
			pba -= 8; /* allocate more FIFO for Tx */
715

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
		if (adapter->hw.mac_type == e1000_82547) {
			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);
		}
	} else if (adapter->hw.max_frame_size > MAXIMUM_ETHERNET_FRAME_SIZE) {
		/* adjust PBA for jumbo frames */
		E1000_WRITE_REG(&adapter->hw, PBA, pba);

		/* To maintain wire speed transmits, the Tx FIFO should be
		 * large enough to accomodate two full transmit packets,
		 * rounded up to the next 1KB and expressed in KB.  Likewise,
		 * the Rx FIFO should be large enough to accomodate at least
		 * one full receive packet and is similarly rounded up and
		 * expressed in KB. */
		pba = E1000_READ_REG(&adapter->hw, PBA);
		/* upper 16 bits has Tx packet buffer allocation size in KB */
		tx_space = pba >> 16;
		/* lower 16 bits has Rx packet buffer allocation size in KB */
		pba &= 0xffff;
		/* don't include ethernet FCS because hardware appends/strips */
		min_rx_space = adapter->netdev->mtu + ENET_HEADER_SIZE +
		               VLAN_TAG_SIZE;
		min_tx_space = min_rx_space;
		min_tx_space *= 2;
743
		min_tx_space = ALIGN(min_tx_space, 1024);
744
		min_tx_space >>= 10;
745
		min_rx_space = ALIGN(min_rx_space, 1024);
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
		min_rx_space >>= 10;

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

			/* PCI/PCIx hardware has PBA alignment constraints */
			switch (adapter->hw.mac_type) {
			case e1000_82545 ... e1000_82546_rev_3:
				pba &= ~(E1000_PBA_8K - 1);
				break;
			default:
				break;
			}

			/* if short on rx space, rx wins and must trump tx
			 * adjustment or use Early Receive if available */
			if (pba < min_rx_space) {
				switch (adapter->hw.mac_type) {
				case e1000_82573:
					/* ERT enabled in e1000_configure_rx */
					break;
				default:
					pba = min_rx_space;
					break;
				}
			}
		}
L
Linus Torvalds 已提交
777
	}
778

L
Linus Torvalds 已提交
779 780 781
	E1000_WRITE_REG(&adapter->hw, PBA, pba);

	/* flow control settings */
782 783 784
	/* 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;
785 786 787 788 789 790
	/* We can't use 90% on small FIFOs because the remainder
	 * would be less than 1 full frame.  In this case, we size
	 * it to allow at least a full frame above the high water
	 *  mark. */
	if (pba < E1000_PBA_16K)
		fc_high_water_mark = (pba * 1024) - 1600;
791 792 793

	adapter->hw.fc_high_water = fc_high_water_mark;
	adapter->hw.fc_low_water = fc_high_water_mark - 8;
794 795 796 797
	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 已提交
798 799 800
	adapter->hw.fc_send_xon = 1;
	adapter->hw.fc = adapter->hw.original_fc;

801
	/* Allow time for pending master requests to run */
L
Linus Torvalds 已提交
802
	e1000_reset_hw(&adapter->hw);
J
Jesse Brandeburg 已提交
803
	if (adapter->hw.mac_type >= e1000_82544)
L
Linus Torvalds 已提交
804
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
805

J
Jesse Brandeburg 已提交
806
	if (e1000_init_hw(&adapter->hw))
L
Linus Torvalds 已提交
807
		DPRINTK(PROBE, ERR, "Hardware Error\n");
808
	e1000_update_mng_vlan(adapter);
809 810 811 812 813 814 815 816 817 818 819 820 821 822

	/* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
	if (adapter->hw.mac_type >= e1000_82544 &&
	    adapter->hw.mac_type <= e1000_82547_rev_2 &&
	    adapter->hw.autoneg == 1 &&
	    adapter->hw.autoneg_advertised == ADVERTISE_1000_FULL) {
		uint32_t ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		/* clear phy power management bit if we are in gig only mode,
		 * which if enabled will attempt negotiation to 100Mb, which
		 * can cause a loss of link at power off or driver unload */
		ctrl &= ~E1000_CTRL_SWDPIN3;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
	}

L
Linus Torvalds 已提交
823 824 825 826 827
	/* 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);
A
Auke Kok 已提交
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842

	if (!adapter->smart_power_down &&
	    (adapter->hw.mac_type == e1000_82571 ||
	     adapter->hw.mac_type == e1000_82572)) {
		uint16_t phy_data = 0;
		/* speed up time to link by disabling smart power down, ignore
		 * the return value of this function because there is nothing
		 * different we would do if it failed */
		e1000_read_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
		                   &phy_data);
		phy_data &= ~IGP02E1000_PM_SPD;
		e1000_write_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
		                    phy_data);
	}

843
	e1000_release_manageability(adapter);
L
Linus Torvalds 已提交
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
}

/**
 * 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;
864
	unsigned long mmio_start, mmio_len;
865
	unsigned long flash_start, flash_len;
866

L
Linus Torvalds 已提交
867
	static int cards_found = 0;
868
	static int global_quad_port_a = 0; /* global ksp3 port a indication */
869
	int i, err, pci_using_dac;
870
	uint16_t eeprom_data = 0;
L
Linus Torvalds 已提交
871
	uint16_t eeprom_apme_mask = E1000_EEPROM_APME;
872 873
	DECLARE_MAC_BUF(mac);

J
Jesse Brandeburg 已提交
874
	if ((err = pci_enable_device(pdev)))
L
Linus Torvalds 已提交
875 876
		return err;

877 878
	if (!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK)) &&
	    !(err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))) {
L
Linus Torvalds 已提交
879 880
		pci_using_dac = 1;
	} else {
881 882
		if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) &&
		    (err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK))) {
L
Linus Torvalds 已提交
883
			E1000_ERR("No usable DMA configuration, aborting\n");
884
			goto err_dma;
L
Linus Torvalds 已提交
885 886 887 888
		}
		pci_using_dac = 0;
	}

J
Jesse Brandeburg 已提交
889
	if ((err = pci_request_regions(pdev, e1000_driver_name)))
890
		goto err_pci_reg;
L
Linus Torvalds 已提交
891 892 893

	pci_set_master(pdev);

894
	err = -ENOMEM;
L
Linus Torvalds 已提交
895
	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
896
	if (!netdev)
L
Linus Torvalds 已提交
897 898 899 900 901
		goto err_alloc_etherdev;

	SET_NETDEV_DEV(netdev, &pdev->dev);

	pci_set_drvdata(pdev, netdev);
902
	adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
903 904 905 906 907 908 909 910
	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);

911
	err = -EIO;
L
Linus Torvalds 已提交
912
	adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
913
	if (!adapter->hw.hw_addr)
L
Linus Torvalds 已提交
914 915
		goto err_ioremap;

J
Jesse Brandeburg 已提交
916 917
	for (i = BAR_1; i <= BAR_5; i++) {
		if (pci_resource_len(pdev, i) == 0)
L
Linus Torvalds 已提交
918
			continue;
J
Jesse Brandeburg 已提交
919
		if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
L
Linus Torvalds 已提交
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936
			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
937
	netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
L
Linus Torvalds 已提交
938 939 940 941 942 943 944
#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
945
	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
L
Linus Torvalds 已提交
946 947 948 949 950 951 952 953 954

	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 已提交
955
	if ((err = e1000_sw_init(adapter)))
L
Linus Torvalds 已提交
956 957
		goto err_sw_init;

958
	err = -EIO;
959 960 961 962 963 964 965
	/* Flash BAR mapping must happen after e1000_sw_init
	 * because it depends on mac_type */
	if ((adapter->hw.mac_type == e1000_ich8lan) &&
	   (pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) {
		flash_start = pci_resource_start(pdev, 1);
		flash_len = pci_resource_len(pdev, 1);
		adapter->hw.flash_address = ioremap(flash_start, flash_len);
966
		if (!adapter->hw.flash_address)
967 968 969
			goto err_flashmap;
	}

970
	if (e1000_check_phy_reset_block(&adapter->hw))
971 972
		DPRINTK(PROBE, INFO, "PHY reset is blocked due to SOL/IDER session.\n");

J
Jesse Brandeburg 已提交
973
	if (adapter->hw.mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
974 975 976 977 978
		netdev->features = NETIF_F_SG |
				   NETIF_F_HW_CSUM |
				   NETIF_F_HW_VLAN_TX |
				   NETIF_F_HW_VLAN_RX |
				   NETIF_F_HW_VLAN_FILTER;
979 980
		if (adapter->hw.mac_type == e1000_ich8lan)
			netdev->features &= ~NETIF_F_HW_VLAN_FILTER;
L
Linus Torvalds 已提交
981 982
	}

J
Jesse Brandeburg 已提交
983
	if ((adapter->hw.mac_type >= e1000_82544) &&
L
Linus Torvalds 已提交
984 985
	   (adapter->hw.mac_type != e1000_82547))
		netdev->features |= NETIF_F_TSO;
986

J
Jesse Brandeburg 已提交
987
	if (adapter->hw.mac_type > e1000_82547_rev_2)
A
Auke Kok 已提交
988
		netdev->features |= NETIF_F_TSO6;
J
Jesse Brandeburg 已提交
989
	if (pci_using_dac)
L
Linus Torvalds 已提交
990 991
		netdev->features |= NETIF_F_HIGHDMA;

992 993
	netdev->features |= NETIF_F_LLTX;

994 995
	adapter->en_mng_pt = e1000_enable_mng_pass_thru(&adapter->hw);

996 997 998 999
	/* initialize eeprom parameters */

	if (e1000_init_eeprom_params(&adapter->hw)) {
		E1000_ERR("EEPROM initialization failed\n");
1000
		goto err_eeprom;
1001 1002
	}

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

L
Linus Torvalds 已提交
1006 1007 1008 1009
	e1000_reset_hw(&adapter->hw);

	/* make sure the EEPROM is good */

J
Jesse Brandeburg 已提交
1010
	if (e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
L
Linus Torvalds 已提交
1011 1012 1013 1014 1015 1016
		DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
		goto err_eeprom;
	}

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

J
Jesse Brandeburg 已提交
1017
	if (e1000_read_mac_addr(&adapter->hw))
L
Linus Torvalds 已提交
1018 1019
		DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
	memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
1020
	memcpy(netdev->perm_addr, adapter->hw.mac_addr, netdev->addr_len);
L
Linus Torvalds 已提交
1021

J
Jesse Brandeburg 已提交
1022
	if (!is_valid_ether_addr(netdev->perm_addr)) {
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
		DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
		goto err_eeprom;
	}

	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_timer(&adapter->phy_info_timer);
	adapter->phy_info_timer.function = &e1000_update_phy_info;
	adapter->phy_info_timer.data = (unsigned long) adapter;

1041
	INIT_WORK(&adapter->reset_task, e1000_reset_task);
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046 1047 1048 1049

	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 已提交
1050
	switch (adapter->hw.mac_type) {
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055 1056 1057 1058 1059
	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;
1060 1061 1062 1063 1064
	case e1000_ich8lan:
		e1000_read_eeprom(&adapter->hw,
			EEPROM_INIT_CONTROL1_REG, 1, &eeprom_data);
		eeprom_apme_mask = E1000_EEPROM_ICH8_APME;
		break;
L
Linus Torvalds 已提交
1065 1066
	case e1000_82546:
	case e1000_82546_rev_3:
J
Jeff Kirsher 已提交
1067
	case e1000_82571:
1068
	case e1000_80003es2lan:
J
Jesse Brandeburg 已提交
1069
		if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1){
L
Linus Torvalds 已提交
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
			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 已提交
1080
	if (eeprom_data & eeprom_apme_mask)
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
		adapter->eeprom_wol |= E1000_WUFC_MAG;

	/* now that we have the eeprom settings, apply the special cases
	 * where the eeprom may be wrong or the board simply won't support
	 * wake on lan on a particular port */
	switch (pdev->device) {
	case E1000_DEV_ID_82546GB_PCIE:
		adapter->eeprom_wol = 0;
		break;
	case E1000_DEV_ID_82546EB_FIBER:
	case E1000_DEV_ID_82546GB_FIBER:
	case E1000_DEV_ID_82571EB_FIBER:
		/* Wake events only supported on port A for dual fiber
		 * regardless of eeprom setting */
		if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1)
			adapter->eeprom_wol = 0;
		break;
	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1099
	case E1000_DEV_ID_82571EB_QUAD_COPPER:
1100
	case E1000_DEV_ID_82571EB_QUAD_FIBER:
A
Auke Kok 已提交
1101
	case E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE:
1102
	case E1000_DEV_ID_82571PT_QUAD_COPPER:
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
		/* if quad port adapter, disable WoL on all but port A */
		if (global_quad_port_a != 0)
			adapter->eeprom_wol = 0;
		else
			adapter->quad_port_a = 1;
		/* Reset for multiple quad port adapters */
		if (++global_quad_port_a == 4)
			global_quad_port_a = 0;
		break;
	}

	/* initialize the wol settings based on the eeprom settings */
	adapter->wol = adapter->eeprom_wol;
L
Linus Torvalds 已提交
1116

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	/* 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"));
	}

1134
	printk("%s\n", print_mac(mac, netdev->dev_addr));
1135

L
Linus Torvalds 已提交
1136 1137 1138
	/* reset the hardware with the new settings */
	e1000_reset(adapter);

1139 1140 1141 1142 1143 1144 1145
	/* 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);
1146

A
Auke Kok 已提交
1147 1148 1149
	/* tell the stack to leave us alone until e1000_open() is called */
	netif_carrier_off(netdev);
	netif_stop_queue(netdev);
1150 1151 1152 1153

	strcpy(netdev->name, "eth%d");
	if ((err = register_netdev(netdev)))
		goto err_register;
A
Auke Kok 已提交
1154

L
Linus Torvalds 已提交
1155 1156 1157 1158 1159 1160
	DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");

	cards_found++;
	return 0;

err_register:
1161 1162 1163 1164 1165
	e1000_release_hw_control(adapter);
err_eeprom:
	if (!e1000_check_phy_reset_block(&adapter->hw))
		e1000_phy_hw_reset(&adapter->hw);

1166 1167 1168
	if (adapter->hw.flash_address)
		iounmap(adapter->hw.flash_address);
err_flashmap:
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
#ifdef CONFIG_E1000_NAPI
	for (i = 0; i < adapter->num_rx_queues; i++)
		dev_put(&adapter->polling_netdev[i]);
#endif

	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
#ifdef CONFIG_E1000_NAPI
	kfree(adapter->polling_netdev);
#endif
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184
err_sw_init:
	iounmap(adapter->hw.hw_addr);
err_ioremap:
	free_netdev(netdev);
err_alloc_etherdev:
	pci_release_regions(pdev);
1185 1186 1187
err_pci_reg:
err_dma:
	pci_disable_device(pdev);
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
	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);
1205
	struct e1000_adapter *adapter = netdev_priv(netdev);
1206 1207 1208
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
1209

1210
	cancel_work_sync(&adapter->reset_task);
J
Jeff Garzik 已提交
1211

1212
	e1000_release_manageability(adapter);
L
Linus Torvalds 已提交
1213

1214 1215 1216
	/* 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);
1217

1218
#ifdef CONFIG_E1000_NAPI
1219
	for (i = 0; i < adapter->num_rx_queues; i++)
1220
		dev_put(&adapter->polling_netdev[i]);
1221
#endif
L
Linus Torvalds 已提交
1222

1223 1224
	unregister_netdev(netdev);

J
Jesse Brandeburg 已提交
1225
	if (!e1000_check_phy_reset_block(&adapter->hw))
1226
		e1000_phy_hw_reset(&adapter->hw);
L
Linus Torvalds 已提交
1227

1228 1229 1230 1231 1232 1233
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
#ifdef CONFIG_E1000_NAPI
	kfree(adapter->polling_netdev);
#endif

L
Linus Torvalds 已提交
1234
	iounmap(adapter->hw.hw_addr);
1235 1236
	if (adapter->hw.flash_address)
		iounmap(adapter->hw.flash_address);
L
Linus Torvalds 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
	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;
1259 1260 1261
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
1262 1263 1264 1265 1266 1267 1268

	/* 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;
1269
	hw->revision_id = pdev->revision;
L
Linus Torvalds 已提交
1270 1271 1272

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

1273
	adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
1274
	adapter->rx_ps_bsize0 = E1000_RXBUFFER_128;
L
Linus Torvalds 已提交
1275 1276 1277 1278 1279 1280
	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 已提交
1281
	if (e1000_set_mac_type(hw)) {
L
Linus Torvalds 已提交
1282 1283 1284 1285
		DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
		return -EIO;
	}

J
Jesse Brandeburg 已提交
1286
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
	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 已提交
1305
	if (hw->media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
1306 1307 1308 1309 1310
		hw->mdix = AUTO_ALL_MODES;
		hw->disable_polarity_correction = FALSE;
		hw->master_slave = E1000_MASTER_SLAVE;
	}

1311 1312
	adapter->num_tx_queues = 1;
	adapter->num_rx_queues = 1;
1313 1314 1315 1316 1317 1318 1319

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

#ifdef CONFIG_E1000_NAPI
1320
	for (i = 0; i < adapter->num_rx_queues; i++) {
1321 1322 1323 1324
		adapter->polling_netdev[i].priv = adapter;
		dev_hold(&adapter->polling_netdev[i]);
		set_bit(__LINK_STATE_START, &adapter->polling_netdev[i].state);
	}
1325
	spin_lock_init(&adapter->tx_queue_lock);
1326 1327
#endif

1328 1329 1330 1331
	/* Explicitly disable IRQ since the NIC can be in any state. */
	atomic_set(&adapter->irq_sem, 0);
	e1000_irq_disable(adapter);

L
Linus Torvalds 已提交
1332 1333
	spin_lock_init(&adapter->stats_lock);

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

L
Linus Torvalds 已提交
1336 1337 1338
	return 0;
}

1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
/**
 * 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)
{
Y
Yan Burman 已提交
1351 1352
	adapter->tx_ring = kcalloc(adapter->num_tx_queues,
	                           sizeof(struct e1000_tx_ring), GFP_KERNEL);
1353 1354 1355
	if (!adapter->tx_ring)
		return -ENOMEM;

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

#ifdef CONFIG_E1000_NAPI
Y
Yan Burman 已提交
1364 1365 1366
	adapter->polling_netdev = kcalloc(adapter->num_rx_queues,
	                                  sizeof(struct net_device),
	                                  GFP_KERNEL);
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
	if (!adapter->polling_netdev) {
		kfree(adapter->tx_ring);
		kfree(adapter->rx_ring);
		return -ENOMEM;
	}
#endif

	return E1000_SUCCESS;
}

L
Linus Torvalds 已提交
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
/**
 * 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)
{
1393
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1394 1395
	int err;

1396
	/* disallow open during test */
A
Auke Kok 已提交
1397
	if (test_bit(__E1000_TESTING, &adapter->flags))
1398 1399
		return -EBUSY;

L
Linus Torvalds 已提交
1400
	/* allocate transmit descriptors */
1401 1402
	err = e1000_setup_all_tx_resources(adapter);
	if (err)
L
Linus Torvalds 已提交
1403 1404 1405
		goto err_setup_tx;

	/* allocate receive descriptors */
1406
	err = e1000_setup_all_rx_resources(adapter);
1407
	if (err)
1408
		goto err_setup_rx;
1409

1410 1411
	e1000_power_up_phy(adapter);

1412
	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
J
Jesse Brandeburg 已提交
1413
	if ((adapter->hw.mng_cookie.status &
1414 1415 1416
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_update_mng_vlan(adapter);
	}
L
Linus Torvalds 已提交
1417

1418 1419 1420 1421 1422 1423
	/* 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);

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
	/* before we allocate an interrupt, we must be ready to handle it.
	 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
	 * as soon as we call pci_request_irq, so we have to setup our
	 * clean_rx handler before we do so.  */
	e1000_configure(adapter);

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

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

1437
#ifdef CONFIG_E1000_NAPI
1438
	napi_enable(&adapter->napi);
1439 1440
#endif

1441 1442 1443 1444 1445
	e1000_irq_enable(adapter);

	/* fire a link status change interrupt to start the watchdog */
	E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_LSC);

L
Linus Torvalds 已提交
1446 1447
	return E1000_SUCCESS;

1448
err_req_irq:
1449 1450
	e1000_release_hw_control(adapter);
	e1000_power_down_phy(adapter);
1451
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1452
err_setup_rx:
1453
	e1000_free_all_tx_resources(adapter);
L
Linus Torvalds 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
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)
{
1475
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1476

1477
	WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
L
Linus Torvalds 已提交
1478
	e1000_down(adapter);
1479
	e1000_power_down_phy(adapter);
1480
	e1000_free_irq(adapter);
L
Linus Torvalds 已提交
1481

1482 1483
	e1000_free_all_tx_resources(adapter);
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1484

1485 1486
	/* kill manageability vlan ID if supported, but not if a vlan with
	 * the same ID is registered on the host OS (let 8021q kill it) */
J
Jesse Brandeburg 已提交
1487
	if ((adapter->hw.mng_cookie.status &
1488 1489
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
	     !(adapter->vlgrp &&
D
Dan Aloni 已提交
1490
	       vlan_group_get_device(adapter->vlgrp, adapter->mng_vlan_id))) {
1491 1492
		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
	}
1493 1494 1495 1496 1497 1498 1499

	/* 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 已提交
1500 1501 1502 1503 1504 1505
	return 0;
}

/**
 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
 * @adapter: address of board private structure
1506 1507
 * @start: address of beginning of memory
 * @len: length of memory
L
Linus Torvalds 已提交
1508
 **/
1509
static boolean_t
L
Linus Torvalds 已提交
1510 1511 1512 1513 1514 1515
e1000_check_64k_bound(struct e1000_adapter *adapter,
		      void *start, unsigned long len)
{
	unsigned long begin = (unsigned long) start;
	unsigned long end = begin + len;

1516 1517
	/* First rev 82545 and 82546 need to not allow any memory
	 * write location to cross 64k boundary due to errata 23 */
L
Linus Torvalds 已提交
1518
	if (adapter->hw.mac_type == e1000_82545 ||
1519
	    adapter->hw.mac_type == e1000_82546) {
L
Linus Torvalds 已提交
1520 1521 1522 1523 1524 1525 1526 1527 1528
		return ((begin ^ (end - 1)) >> 16) != 0 ? FALSE : TRUE;
	}

	return TRUE;
}

/**
 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 * @adapter: board private structure
1529
 * @txdr:    tx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1530 1531 1532 1533
 *
 * Return 0 on success, negative on failure
 **/

1534
static int
1535 1536
e1000_setup_tx_resources(struct e1000_adapter *adapter,
                         struct e1000_tx_ring *txdr)
L
Linus Torvalds 已提交
1537 1538 1539 1540 1541
{
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct e1000_buffer) * txdr->count;
1542
	txdr->buffer_info = vmalloc(size);
J
Jesse Brandeburg 已提交
1543
	if (!txdr->buffer_info) {
1544 1545
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1546 1547 1548 1549 1550 1551 1552
		return -ENOMEM;
	}
	memset(txdr->buffer_info, 0, size);

	/* round up to nearest 4K */

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

	txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
J
Jesse Brandeburg 已提交
1556
	if (!txdr->desc) {
L
Linus Torvalds 已提交
1557 1558
setup_tx_desc_die:
		vfree(txdr->buffer_info);
1559 1560
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1561 1562 1563
		return -ENOMEM;
	}

1564
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1565 1566 1567
	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
		void *olddesc = txdr->desc;
		dma_addr_t olddma = txdr->dma;
1568 1569 1570
		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 已提交
1571
		txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
1572
		/* Failed allocation, critical failure */
J
Jesse Brandeburg 已提交
1573
		if (!txdr->desc) {
L
Linus Torvalds 已提交
1574 1575 1576 1577 1578 1579
			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 */
1580 1581
			pci_free_consistent(pdev, txdr->size, txdr->desc,
					    txdr->dma);
L
Linus Torvalds 已提交
1582 1583
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
			DPRINTK(PROBE, ERR,
1584 1585
				"Unable to allocate aligned memory "
				"for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1586 1587 1588
			vfree(txdr->buffer_info);
			return -ENOMEM;
		} else {
1589
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1590 1591 1592 1593 1594 1595 1596
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
		}
	}
	memset(txdr->desc, 0, txdr->size);

	txdr->next_to_use = 0;
	txdr->next_to_clean = 0;
1597
	spin_lock_init(&txdr->tx_lock);
L
Linus Torvalds 已提交
1598 1599 1600 1601

	return 0;
}

1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
/**
 * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * Return 0 on success, negative on failure
 **/

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

1615
	for (i = 0; i < adapter->num_tx_queues; i++) {
1616 1617 1618 1619
		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
		if (err) {
			DPRINTK(PROBE, ERR,
				"Allocation for Tx Queue %u failed\n", i);
1620 1621 1622
			for (i-- ; i >= 0; i--)
				e1000_free_tx_resources(adapter,
							&adapter->tx_ring[i]);
1623 1624 1625 1626 1627 1628 1629
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
/**
 * 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)
{
1640 1641 1642
	uint64_t tdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t tdlen, tctl, tipg, tarc;
1643
	uint32_t ipgr1, ipgr2;
L
Linus Torvalds 已提交
1644 1645 1646

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

1647
	switch (adapter->num_tx_queues) {
1648 1649
	case 1:
	default:
1650 1651 1652 1653
		tdba = adapter->tx_ring[0].dma;
		tdlen = adapter->tx_ring[0].count *
			sizeof(struct e1000_tx_desc);
		E1000_WRITE_REG(hw, TDLEN, tdlen);
1654 1655
		E1000_WRITE_REG(hw, TDBAH, (tdba >> 32));
		E1000_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
1656
		E1000_WRITE_REG(hw, TDT, 0);
1657
		E1000_WRITE_REG(hw, TDH, 0);
1658 1659
		adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ? E1000_TDH : E1000_82542_TDH);
		adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ? E1000_TDT : E1000_82542_TDT);
1660 1661
		break;
	}
L
Linus Torvalds 已提交
1662 1663

	/* Set the default values for the Tx Inter Packet Gap timer */
1664 1665 1666
	if (adapter->hw.mac_type <= e1000_82547_rev_2 &&
	    (hw->media_type == e1000_media_type_fiber ||
	     hw->media_type == e1000_media_type_internal_serdes))
1667 1668 1669 1670
		tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
	else
		tipg = DEFAULT_82543_TIPG_IPGT_COPPER;

1671
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1672 1673 1674
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
		tipg = DEFAULT_82542_TIPG_IPGT;
1675 1676
		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
L
Linus Torvalds 已提交
1677
		break;
1678 1679 1680 1681
	case e1000_80003es2lan:
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_80003ES2LAN_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1682
	default:
1683 1684 1685
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1686
	}
1687 1688
	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
1689
	E1000_WRITE_REG(hw, TIPG, tipg);
L
Linus Torvalds 已提交
1690 1691 1692

	/* Set the Tx Interrupt Delay register */

1693 1694 1695
	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 已提交
1696 1697 1698

	/* Program the Transmit Control Register */

1699
	tctl = E1000_READ_REG(hw, TCTL);
L
Linus Torvalds 已提交
1700
	tctl &= ~E1000_TCTL_CT;
1701
	tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
L
Linus Torvalds 已提交
1702 1703
		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);

1704 1705
	if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572) {
		tarc = E1000_READ_REG(hw, TARC0);
1706 1707
		/* set the speed mode bit, we'll clear it if we're not at
		 * gigabit link later */
1708
		tarc |= (1 << 21);
1709
		E1000_WRITE_REG(hw, TARC0, tarc);
1710 1711 1712 1713 1714 1715 1716
	} else if (hw->mac_type == e1000_80003es2lan) {
		tarc = E1000_READ_REG(hw, TARC0);
		tarc |= 1;
		E1000_WRITE_REG(hw, TARC0, tarc);
		tarc = E1000_READ_REG(hw, TARC1);
		tarc |= 1;
		E1000_WRITE_REG(hw, TARC1, tarc);
1717 1718
	}

1719
	e1000_config_collision_dist(hw);
L
Linus Torvalds 已提交
1720 1721

	/* Setup Transmit Descriptor Settings for eop descriptor */
1722 1723 1724 1725 1726
	adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;

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

1728
	if (hw->mac_type < e1000_82543)
L
Linus Torvalds 已提交
1729 1730 1731 1732 1733 1734
		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. */
1735 1736
	if (hw->mac_type == e1000_82544 &&
	    hw->bus_type == e1000_bus_type_pcix)
L
Linus Torvalds 已提交
1737
		adapter->pcix_82544 = 1;
1738 1739 1740

	E1000_WRITE_REG(hw, TCTL, tctl);

L
Linus Torvalds 已提交
1741 1742 1743 1744 1745
}

/**
 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 * @adapter: board private structure
1746
 * @rxdr:    rx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1747 1748 1749 1750
 *
 * Returns 0 on success, negative on failure
 **/

1751
static int
1752 1753
e1000_setup_rx_resources(struct e1000_adapter *adapter,
                         struct e1000_rx_ring *rxdr)
L
Linus Torvalds 已提交
1754 1755
{
	struct pci_dev *pdev = adapter->pdev;
1756
	int size, desc_len;
L
Linus Torvalds 已提交
1757 1758

	size = sizeof(struct e1000_buffer) * rxdr->count;
1759
	rxdr->buffer_info = vmalloc(size);
1760
	if (!rxdr->buffer_info) {
1761 1762
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1763 1764 1765 1766
		return -ENOMEM;
	}
	memset(rxdr->buffer_info, 0, size);

Y
Yan Burman 已提交
1767 1768
	rxdr->ps_page = kcalloc(rxdr->count, sizeof(struct e1000_ps_page),
	                        GFP_KERNEL);
J
Jesse Brandeburg 已提交
1769
	if (!rxdr->ps_page) {
1770 1771 1772 1773 1774 1775
		vfree(rxdr->buffer_info);
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
		return -ENOMEM;
	}

Y
Yan Burman 已提交
1776 1777 1778
	rxdr->ps_page_dma = kcalloc(rxdr->count,
	                            sizeof(struct e1000_ps_page_dma),
	                            GFP_KERNEL);
J
Jesse Brandeburg 已提交
1779
	if (!rxdr->ps_page_dma) {
1780 1781 1782 1783 1784 1785 1786
		vfree(rxdr->buffer_info);
		kfree(rxdr->ps_page);
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
		return -ENOMEM;
	}

J
Jesse Brandeburg 已提交
1787
	if (adapter->hw.mac_type <= e1000_82547_rev_2)
1788 1789 1790 1791
		desc_len = sizeof(struct e1000_rx_desc);
	else
		desc_len = sizeof(union e1000_rx_desc_packet_split);

L
Linus Torvalds 已提交
1792 1793
	/* Round up to nearest 4K */

1794
	rxdr->size = rxdr->count * desc_len;
1795
	rxdr->size = ALIGN(rxdr->size, 4096);
L
Linus Torvalds 已提交
1796 1797 1798

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

1799 1800 1801
	if (!rxdr->desc) {
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1802 1803
setup_rx_desc_die:
		vfree(rxdr->buffer_info);
1804 1805
		kfree(rxdr->ps_page);
		kfree(rxdr->ps_page_dma);
L
Linus Torvalds 已提交
1806 1807 1808
		return -ENOMEM;
	}

1809
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1810 1811 1812
	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
		void *olddesc = rxdr->desc;
		dma_addr_t olddma = rxdr->dma;
1813 1814 1815
		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 已提交
1816
		rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
1817
		/* Failed allocation, critical failure */
1818
		if (!rxdr->desc) {
L
Linus Torvalds 已提交
1819
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1820 1821 1822
			DPRINTK(PROBE, ERR,
				"Unable to allocate memory "
				"for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1823 1824 1825 1826 1827
			goto setup_rx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
			/* give up */
1828 1829
			pci_free_consistent(pdev, rxdr->size, rxdr->desc,
					    rxdr->dma);
L
Linus Torvalds 已提交
1830
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1831 1832 1833
			DPRINTK(PROBE, ERR,
				"Unable to allocate aligned memory "
				"for the receive descriptor ring\n");
1834
			goto setup_rx_desc_die;
L
Linus Torvalds 已提交
1835
		} else {
1836
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
			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;
}

1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860
/**
 * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * Return 0 on success, negative on failure
 **/

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

1861
	for (i = 0; i < adapter->num_rx_queues; i++) {
1862 1863 1864 1865
		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
		if (err) {
			DPRINTK(PROBE, ERR,
				"Allocation for Rx Queue %u failed\n", i);
1866 1867 1868
			for (i-- ; i >= 0; i--)
				e1000_free_rx_resources(adapter,
							&adapter->rx_ring[i]);
1869 1870 1871 1872 1873 1874 1875
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1876
/**
1877
 * e1000_setup_rctl - configure the receive control registers
L
Linus Torvalds 已提交
1878 1879
 * @adapter: Board private structure
 **/
1880 1881
#define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
			(((S) & (PAGE_SIZE - 1)) ? 1 : 0))
L
Linus Torvalds 已提交
1882 1883 1884
static void
e1000_setup_rctl(struct e1000_adapter *adapter)
{
1885 1886
	uint32_t rctl, rfctl;
	uint32_t psrctl = 0;
1887
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1888 1889
	uint32_t pages = 0;
#endif
L
Linus Torvalds 已提交
1890 1891 1892 1893 1894 1895 1896 1897 1898

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

1899
	if (adapter->hw.tbi_compatibility_on == 1)
L
Linus Torvalds 已提交
1900 1901 1902 1903
		rctl |= E1000_RCTL_SBP;
	else
		rctl &= ~E1000_RCTL_SBP;

1904 1905 1906 1907 1908
	if (adapter->netdev->mtu <= ETH_DATA_LEN)
		rctl &= ~E1000_RCTL_LPE;
	else
		rctl |= E1000_RCTL_LPE;

L
Linus Torvalds 已提交
1909
	/* Setup buffer sizes */
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
	rctl &= ~E1000_RCTL_SZ_4096;
	rctl |= E1000_RCTL_BSEX;
	switch (adapter->rx_buffer_len) {
		case E1000_RXBUFFER_256:
			rctl |= E1000_RCTL_SZ_256;
			rctl &= ~E1000_RCTL_BSEX;
			break;
		case E1000_RXBUFFER_512:
			rctl |= E1000_RCTL_SZ_512;
			rctl &= ~E1000_RCTL_BSEX;
			break;
		case E1000_RXBUFFER_1024:
			rctl |= E1000_RCTL_SZ_1024;
			rctl &= ~E1000_RCTL_BSEX;
			break;
1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
		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;
1939 1940
	}

1941
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1942 1943 1944 1945 1946 1947 1948
	/* 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.
	 */
1949 1950
	/* allocations using alloc_page take too long for regular MTU
	 * so only enable packet split for jumbo frames */
1951
	pages = PAGE_USE_COUNT(adapter->netdev->mtu);
1952 1953
	if ((adapter->hw.mac_type >= e1000_82571) && (pages <= 3) &&
	    PAGE_SIZE <= 16384 && (rctl & E1000_RCTL_LPE))
1954 1955 1956
		adapter->rx_ps_pages = pages;
	else
		adapter->rx_ps_pages = 0;
1957
#endif
1958
	if (adapter->rx_ps_pages) {
1959 1960 1961
		/* Configure extra packet-split registers */
		rfctl = E1000_READ_REG(&adapter->hw, RFCTL);
		rfctl |= E1000_RFCTL_EXTEN;
A
Auke Kok 已提交
1962 1963 1964 1965 1966
		/* disable packet split support for IPv6 extension headers,
		 * because some malformed IPv6 headers can hang the RX */
		rfctl |= (E1000_RFCTL_IPV6_EX_DIS |
		          E1000_RFCTL_NEW_IPV6_EXT_DIS);

1967 1968
		E1000_WRITE_REG(&adapter->hw, RFCTL, rfctl);

1969
		rctl |= E1000_RCTL_DTYP_PS;
J
Jesse Brandeburg 已提交
1970

1971 1972
		psrctl |= adapter->rx_ps_bsize0 >>
			E1000_PSRCTL_BSIZE0_SHIFT;
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985

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

		E1000_WRITE_REG(&adapter->hw, PSRCTL, psrctl);
L
Linus Torvalds 已提交
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
	}

	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)
{
2003 2004 2005
	uint64_t rdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t rdlen, rctl, rxcsum, ctrl_ext;
2006

2007
	if (adapter->rx_ps_pages) {
2008
		/* this is a 32 byte descriptor */
2009
		rdlen = adapter->rx_ring[0].count *
2010 2011 2012 2013
			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 {
2014 2015
		rdlen = adapter->rx_ring[0].count *
			sizeof(struct e1000_rx_desc);
2016 2017 2018
		adapter->clean_rx = e1000_clean_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
	}
L
Linus Torvalds 已提交
2019 2020

	/* disable receives while setting up the descriptors */
2021 2022
	rctl = E1000_READ_REG(hw, RCTL);
	E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
L
Linus Torvalds 已提交
2023 2024

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

2027 2028
	if (hw->mac_type >= e1000_82540) {
		E1000_WRITE_REG(hw, RADV, adapter->rx_abs_int_delay);
J
Jesse Brandeburg 已提交
2029
		if (adapter->itr_setting != 0)
2030
			E1000_WRITE_REG(hw, ITR,
L
Linus Torvalds 已提交
2031 2032 2033
				1000000000 / (adapter->itr * 256));
	}

2034 2035
	if (hw->mac_type >= e1000_82571) {
		ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
2036
		/* Reset delay timers after every interrupt */
A
Auke Kok 已提交
2037
		ctrl_ext |= E1000_CTRL_EXT_INT_TIMER_CLR;
2038
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
2039
		/* Auto-Mask interrupts upon ICR access */
2040
		ctrl_ext |= E1000_CTRL_EXT_IAME;
J
Jesse Brandeburg 已提交
2041
		E1000_WRITE_REG(hw, IAM, 0xffffffff);
2042
#endif
2043 2044 2045 2046
		E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
		E1000_WRITE_FLUSH(hw);
	}

2047 2048
	/* Setup the HW Rx Head and Tail Descriptor Pointers and
	 * the Base and Length of the Rx Descriptor Ring */
2049
	switch (adapter->num_rx_queues) {
2050 2051
	case 1:
	default:
2052 2053
		rdba = adapter->rx_ring[0].dma;
		E1000_WRITE_REG(hw, RDLEN, rdlen);
2054 2055
		E1000_WRITE_REG(hw, RDBAH, (rdba >> 32));
		E1000_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL));
2056
		E1000_WRITE_REG(hw, RDT, 0);
2057
		E1000_WRITE_REG(hw, RDH, 0);
2058 2059
		adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? E1000_RDH : E1000_82542_RDH);
		adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? E1000_RDT : E1000_82542_RDT);
2060
		break;
2061 2062
	}

L
Linus Torvalds 已提交
2063
	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
2064 2065
	if (hw->mac_type >= e1000_82543) {
		rxcsum = E1000_READ_REG(hw, RXCSUM);
J
Jesse Brandeburg 已提交
2066
		if (adapter->rx_csum == TRUE) {
2067 2068
			rxcsum |= E1000_RXCSUM_TUOFL;

2069
			/* Enable 82571 IPv4 payload checksum for UDP fragments
2070
			 * Must be used in conjunction with packet-split. */
J
Jesse Brandeburg 已提交
2071 2072
			if ((hw->mac_type >= e1000_82571) &&
			    (adapter->rx_ps_pages)) {
2073 2074 2075 2076 2077 2078
				rxcsum |= E1000_RXCSUM_IPPCSE;
			}
		} else {
			rxcsum &= ~E1000_RXCSUM_TUOFL;
			/* don't need to clear IPPCSE as it defaults to 0 */
		}
2079
		E1000_WRITE_REG(hw, RXCSUM, rxcsum);
L
Linus Torvalds 已提交
2080 2081
	}

2082 2083 2084 2085 2086 2087
	/* enable early receives on 82573, only takes effect if using > 2048
	 * byte total frame size.  for example only for jumbo frames */
#define E1000_ERT_2048 0x100
	if (hw->mac_type == e1000_82573)
		E1000_WRITE_REG(hw, ERT, E1000_ERT_2048);

L
Linus Torvalds 已提交
2088
	/* Enable Receives */
2089
	E1000_WRITE_REG(hw, RCTL, rctl);
L
Linus Torvalds 已提交
2090 2091 2092
}

/**
2093
 * e1000_free_tx_resources - Free Tx Resources per Queue
L
Linus Torvalds 已提交
2094
 * @adapter: board private structure
2095
 * @tx_ring: Tx descriptor ring for a specific queue
L
Linus Torvalds 已提交
2096 2097 2098 2099
 *
 * Free all transmit software resources
 **/

2100
static void
2101 2102
e1000_free_tx_resources(struct e1000_adapter *adapter,
                        struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
2103 2104 2105
{
	struct pci_dev *pdev = adapter->pdev;

2106
	e1000_clean_tx_ring(adapter, tx_ring);
L
Linus Torvalds 已提交
2107

2108 2109
	vfree(tx_ring->buffer_info);
	tx_ring->buffer_info = NULL;
L
Linus Torvalds 已提交
2110

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

2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
	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;

2128
	for (i = 0; i < adapter->num_tx_queues; i++)
2129
		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
2130 2131
}

2132
static void
L
Linus Torvalds 已提交
2133 2134 2135
e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
			struct e1000_buffer *buffer_info)
{
J
Jesse Brandeburg 已提交
2136
	if (buffer_info->dma) {
2137 2138 2139 2140
		pci_unmap_page(adapter->pdev,
				buffer_info->dma,
				buffer_info->length,
				PCI_DMA_TODEVICE);
2141
		buffer_info->dma = 0;
L
Linus Torvalds 已提交
2142
	}
2143
	if (buffer_info->skb) {
L
Linus Torvalds 已提交
2144
		dev_kfree_skb_any(buffer_info->skb);
2145 2146 2147
		buffer_info->skb = NULL;
	}
	/* buffer_info must be completely set up in the transmit path */
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152
}

/**
 * e1000_clean_tx_ring - Free Tx Buffers
 * @adapter: board private structure
2153
 * @tx_ring: ring to be cleaned
L
Linus Torvalds 已提交
2154 2155 2156
 **/

static void
2157 2158
e1000_clean_tx_ring(struct e1000_adapter *adapter,
                    struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
2159 2160 2161 2162 2163 2164 2165
{
	struct e1000_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	/* Free all the Tx ring sk_buffs */

J
Jesse Brandeburg 已提交
2166
	for (i = 0; i < tx_ring->count; i++) {
L
Linus Torvalds 已提交
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
		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 已提交
2180
	tx_ring->last_tx_tso = 0;
L
Linus Torvalds 已提交
2181

2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
	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;

2196
	for (i = 0; i < adapter->num_tx_queues; i++)
2197
		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
2198 2199 2200 2201 2202
}

/**
 * e1000_free_rx_resources - Free Rx Resources
 * @adapter: board private structure
2203
 * @rx_ring: ring to clean the resources from
L
Linus Torvalds 已提交
2204 2205 2206 2207
 *
 * Free all receive software resources
 **/

2208
static void
2209 2210
e1000_free_rx_resources(struct e1000_adapter *adapter,
                        struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
2211 2212 2213
{
	struct pci_dev *pdev = adapter->pdev;

2214
	e1000_clean_rx_ring(adapter, rx_ring);
L
Linus Torvalds 已提交
2215 2216 2217

	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;
2218 2219 2220 2221
	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 已提交
2222 2223 2224 2225 2226 2227 2228

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

	rx_ring->desc = NULL;
}

/**
2229
 * e1000_free_all_rx_resources - Free Rx Resources for All Queues
L
Linus Torvalds 已提交
2230
 * @adapter: board private structure
2231 2232 2233 2234 2235 2236 2237 2238 2239
 *
 * Free all receive software resources
 **/

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

2240
	for (i = 0; i < adapter->num_rx_queues; i++)
2241 2242 2243 2244 2245 2246 2247
		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 已提交
2248 2249 2250
 **/

static void
2251 2252
e1000_clean_rx_ring(struct e1000_adapter *adapter,
                    struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
2253 2254
{
	struct e1000_buffer *buffer_info;
2255 2256
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
L
Linus Torvalds 已提交
2257 2258
	struct pci_dev *pdev = adapter->pdev;
	unsigned long size;
2259
	unsigned int i, j;
L
Linus Torvalds 已提交
2260 2261

	/* Free all the Rx ring sk_buffs */
J
Jesse Brandeburg 已提交
2262
	for (i = 0; i < rx_ring->count; i++) {
L
Linus Torvalds 已提交
2263
		buffer_info = &rx_ring->buffer_info[i];
J
Jesse Brandeburg 已提交
2264
		if (buffer_info->skb) {
L
Linus Torvalds 已提交
2265 2266 2267 2268 2269 2270 2271
			pci_unmap_single(pdev,
					 buffer_info->dma,
					 buffer_info->length,
					 PCI_DMA_FROMDEVICE);

			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282
		}
		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 已提交
2283 2284 2285 2286 2287
		}
	}

	size = sizeof(struct e1000_buffer) * rx_ring->count;
	memset(rx_ring->buffer_info, 0, size);
2288 2289 2290 2291
	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 已提交
2292 2293 2294 2295 2296 2297 2298 2299

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

2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
	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;

2314
	for (i = 0; i < adapter->num_rx_queues; i++)
2315
		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
L
Linus Torvalds 已提交
2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334
}

/* 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 已提交
2335
	if (netif_running(netdev))
2336
		e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350
}

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

J
Jesse Brandeburg 已提交
2354
	if (netif_running(netdev)) {
2355 2356
		/* No need to loop, because 82542 supports only 1 queue */
		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2357
		e1000_configure_rx(adapter);
2358
		adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
L
Linus Torvalds 已提交
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372
	}
}

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

J
Jesse Brandeburg 已提交
2376
	if (!is_valid_ether_addr(addr->sa_data))
L
Linus Torvalds 已提交
2377 2378 2379 2380
		return -EADDRNOTAVAIL;

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

J
Jesse Brandeburg 已提交
2381
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2382 2383 2384 2385 2386 2387 2388
		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);

2389 2390 2391 2392 2393 2394
	/* 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 已提交
2395 2396 2397
		/* 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
2398
		 * of the RARs and no incoming packets directed to this port
J
Jesse Brandeburg 已提交
2399
		 * are dropped. Eventaully the LAA will be in RAR[0] and
2400
		 * RAR[14] */
J
Jesse Brandeburg 已提交
2401
		e1000_rar_set(&adapter->hw, adapter->hw.mac_addr,
2402 2403 2404
					E1000_RAR_ENTRIES - 1);
	}

J
Jesse Brandeburg 已提交
2405
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423
		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)
{
2424
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2425 2426 2427 2428
	struct e1000_hw *hw = &adapter->hw;
	struct dev_mc_list *mc_ptr;
	uint32_t rctl;
	uint32_t hash_value;
2429
	int i, rar_entries = E1000_RAR_ENTRIES;
2430 2431 2432 2433 2434 2435
	int mta_reg_count = (hw->mac_type == e1000_ich8lan) ?
				E1000_NUM_MTA_REGISTERS_ICH8LAN :
				E1000_NUM_MTA_REGISTERS;

	if (adapter->hw.mac_type == e1000_ich8lan)
		rar_entries = E1000_RAR_ENTRIES_ICH8LAN;
L
Linus Torvalds 已提交
2436

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

2441 2442
	/* Check for Promiscuous and All Multicast modes */

L
Linus Torvalds 已提交
2443 2444
	rctl = E1000_READ_REG(hw, RCTL);

J
Jesse Brandeburg 已提交
2445
	if (netdev->flags & IFF_PROMISC) {
L
Linus Torvalds 已提交
2446
		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
J
Jesse Brandeburg 已提交
2447
	} else if (netdev->flags & IFF_ALLMULTI) {
L
Linus Torvalds 已提交
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457
		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 已提交
2458
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2459 2460 2461 2462 2463
		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
2464
	 * -- with 82571 controllers only 0-13 entries are filled here
L
Linus Torvalds 已提交
2465 2466 2467
	 */
	mc_ptr = netdev->mc_list;

J
Jesse Brandeburg 已提交
2468
	for (i = 1; i < rar_entries; i++) {
2469
		if (mc_ptr) {
L
Linus Torvalds 已提交
2470 2471 2472 2473
			e1000_rar_set(hw, mc_ptr->dmi_addr, i);
			mc_ptr = mc_ptr->next;
		} else {
			E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
2474
			E1000_WRITE_FLUSH(hw);
L
Linus Torvalds 已提交
2475
			E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
2476
			E1000_WRITE_FLUSH(hw);
L
Linus Torvalds 已提交
2477 2478 2479 2480 2481
		}
	}

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

2482
	for (i = 0; i < mta_reg_count; i++) {
L
Linus Torvalds 已提交
2483
		E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
2484 2485
		E1000_WRITE_FLUSH(hw);
	}
L
Linus Torvalds 已提交
2486 2487 2488

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

J
Jesse Brandeburg 已提交
2489
	for (; mc_ptr; mc_ptr = mc_ptr->next) {
L
Linus Torvalds 已提交
2490 2491 2492 2493
		hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
		e1000_mta_set(hw, hash_value);
	}

J
Jesse Brandeburg 已提交
2494
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
		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 已提交
2520 2521
	if (atomic_read(&adapter->tx_fifo_stall)) {
		if ((E1000_READ_REG(&adapter->hw, TDT) ==
L
Linus Torvalds 已提交
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
		    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;
	struct net_device *netdev = adapter->netdev;
J
Jeff Kirsher 已提交
2559
	struct e1000_tx_ring *txdr = adapter->tx_ring;
2560
	uint32_t link, tctl;
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
	int32_t ret_val;

	ret_val = e1000_check_for_link(&adapter->hw);
	if ((ret_val == E1000_ERR_PHY) &&
	    (adapter->hw.phy_type == e1000_phy_igp_3) &&
	    (E1000_READ_REG(&adapter->hw, CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) {
		/* See e1000_kumeran_lock_loss_workaround() */
		DPRINTK(LINK, INFO,
			"Gigabit has been disabled, downgrading speed\n");
	}
2571

2572 2573
	if (adapter->hw.mac_type == e1000_82573) {
		e1000_enable_tx_pkt_filtering(&adapter->hw);
J
Jesse Brandeburg 已提交
2574
		if (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id)
2575
			e1000_update_mng_vlan(adapter);
J
Jesse Brandeburg 已提交
2576
	}
L
Linus Torvalds 已提交
2577

J
Jesse Brandeburg 已提交
2578
	if ((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
L
Linus Torvalds 已提交
2579 2580 2581 2582 2583
	   !(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 已提交
2584 2585
	if (link) {
		if (!netif_carrier_ok(netdev)) {
2586
			uint32_t ctrl;
2587
			boolean_t txb2b = 1;
L
Linus Torvalds 已提交
2588 2589 2590 2591
			e1000_get_speed_and_duplex(&adapter->hw,
			                           &adapter->link_speed,
			                           &adapter->link_duplex);

2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
			ctrl = E1000_READ_REG(&adapter->hw, CTRL);
			DPRINTK(LINK, INFO, "NIC Link is Up %d Mbps %s, "
			        "Flow Control: %s\n",
			        adapter->link_speed,
			        adapter->link_duplex == FULL_DUPLEX ?
			        "Full Duplex" : "Half Duplex",
			        ((ctrl & E1000_CTRL_TFCE) && (ctrl &
			        E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
			        E1000_CTRL_RFCE) ? "RX" : ((ctrl &
			        E1000_CTRL_TFCE) ? "TX" : "None" )));
L
Linus Torvalds 已提交
2602

2603 2604
			/* tweak tx_queue_len according to speed/duplex
			 * and adjust the timeout factor */
2605 2606
			netdev->tx_queue_len = adapter->tx_queue_len;
			adapter->tx_timeout_factor = 1;
2607 2608
			switch (adapter->link_speed) {
			case SPEED_10:
2609
				txb2b = 0;
2610 2611 2612 2613
				netdev->tx_queue_len = 10;
				adapter->tx_timeout_factor = 8;
				break;
			case SPEED_100:
2614
				txb2b = 0;
2615 2616 2617 2618 2619
				netdev->tx_queue_len = 100;
				/* maybe add some timeout factor ? */
				break;
			}

2620
			if ((adapter->hw.mac_type == e1000_82571 ||
2621
			     adapter->hw.mac_type == e1000_82572) &&
2622
			    txb2b == 0) {
2623 2624
				uint32_t tarc0;
				tarc0 = E1000_READ_REG(&adapter->hw, TARC0);
2625
				tarc0 &= ~(1 << 21);
2626 2627
				E1000_WRITE_REG(&adapter->hw, TARC0, tarc0);
			}
2628

2629 2630 2631 2632
			/* 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){
2633 2634 2635
				switch (adapter->link_speed) {
				case SPEED_10:
				case SPEED_100:
2636 2637 2638
					DPRINTK(PROBE,INFO,
				        "10/100 speed: disabling TSO\n");
					netdev->features &= ~NETIF_F_TSO;
A
Auke Kok 已提交
2639
					netdev->features &= ~NETIF_F_TSO6;
2640 2641 2642
					break;
				case SPEED_1000:
					netdev->features |= NETIF_F_TSO;
A
Auke Kok 已提交
2643
					netdev->features |= NETIF_F_TSO6;
2644 2645 2646
					break;
				default:
					/* oops */
2647 2648 2649
					break;
				}
			}
2650 2651 2652 2653 2654 2655

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

L
Linus Torvalds 已提交
2657 2658
			netif_carrier_on(netdev);
			netif_wake_queue(netdev);
2659
			mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
L
Linus Torvalds 已提交
2660
			adapter->smartspeed = 0;
2661 2662 2663 2664 2665 2666 2667
		} else {
			/* make sure the receive unit is started */
			if (adapter->hw.rx_needs_kicking) {
				struct e1000_hw *hw = &adapter->hw;
				uint32_t rctl = E1000_READ_REG(hw, RCTL);
				E1000_WRITE_REG(hw, RCTL, rctl | E1000_RCTL_EN);
			}
L
Linus Torvalds 已提交
2668 2669
		}
	} else {
J
Jesse Brandeburg 已提交
2670
		if (netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
2671 2672 2673 2674 2675
			adapter->link_speed = 0;
			adapter->link_duplex = 0;
			DPRINTK(LINK, INFO, "NIC Link is Down\n");
			netif_carrier_off(netdev);
			netif_stop_queue(netdev);
2676
			mod_timer(&adapter->phy_info_timer, round_jiffies(jiffies + 2 * HZ));
2677 2678 2679 2680 2681 2682

			/* 80003ES2LAN workaround--
			 * For packet buffer work-around on link down event;
			 * disable receives in the ISR and
			 * reset device here in the watchdog
			 */
2683
			if (adapter->hw.mac_type == e1000_80003es2lan)
2684 2685
				/* reset device */
				schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704
		}

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

2705
	if (!netif_carrier_ok(netdev)) {
2706
		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
L
Linus Torvalds 已提交
2707 2708 2709 2710
			/* 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). */
2711 2712
			adapter->tx_timeout_count++;
			schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
2713 2714 2715 2716 2717 2718
		}
	}

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

2719
	/* Force detection of hung controller every watchdog period */
L
Linus Torvalds 已提交
2720 2721
	adapter->detect_tx_hung = TRUE;

J
Jesse Brandeburg 已提交
2722
	/* With 82571 controllers, LAA may be overwritten due to controller
2723 2724 2725 2726
	 * 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 已提交
2727
	/* Reset the timer */
2728
	mod_timer(&adapter->watchdog_timer, round_jiffies(jiffies + 2 * HZ));
L
Linus Torvalds 已提交
2729 2730
}

J
Jesse Brandeburg 已提交
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
enum latency_range {
	lowest_latency = 0,
	low_latency = 1,
	bulk_latency = 2,
	latency_invalid = 255
};

/**
 * e1000_update_itr - update the dynamic ITR value based on statistics
 *      Stores a new ITR value based on packets and byte
 *      counts during the last interrupt.  The advantage of per interrupt
 *      computation is faster updates and more accurate ITR for the current
 *      traffic pattern.  Constants in this function were computed
 *      based on theoretical maximum wire speed and thresholds were set based
 *      on testing data as well as attempting to minimize response time
 *      while increasing bulk throughput.
 *      this functionality is controlled by the InterruptThrottleRate module
 *      parameter (see e1000_param.c)
 * @adapter: pointer to adapter
 * @itr_setting: current adapter->itr
 * @packets: the number of packets during this measurement interval
 * @bytes: the number of bytes during this measurement interval
 **/
static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
                                   uint16_t itr_setting,
                                   int packets,
                                   int bytes)
{
	unsigned int retval = itr_setting;
	struct e1000_hw *hw = &adapter->hw;

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

	if (packets == 0)
		goto update_itr_done;

	switch (itr_setting) {
	case lowest_latency:
2770 2771 2772 2773
		/* jumbo frames get bulk treatment*/
		if (bytes/packets > 8000)
			retval = bulk_latency;
		else if ((packets < 5) && (bytes > 512))
J
Jesse Brandeburg 已提交
2774 2775 2776 2777
			retval = low_latency;
		break;
	case low_latency:  /* 50 usec aka 20000 ints/s */
		if (bytes > 10000) {
2778 2779 2780 2781
			/* jumbo frames need bulk latency setting */
			if (bytes/packets > 8000)
				retval = bulk_latency;
			else if ((packets < 10) || ((bytes/packets) > 1200))
J
Jesse Brandeburg 已提交
2782 2783 2784
				retval = bulk_latency;
			else if ((packets > 35))
				retval = lowest_latency;
2785 2786 2787
		} else if (bytes/packets > 2000)
			retval = bulk_latency;
		else if (packets <= 2 && bytes < 512)
J
Jesse Brandeburg 已提交
2788 2789 2790 2791 2792 2793
			retval = lowest_latency;
		break;
	case bulk_latency: /* 250 usec aka 4000 ints/s */
		if (bytes > 25000) {
			if (packets > 35)
				retval = low_latency;
2794 2795
		} else if (bytes < 6000) {
			retval = low_latency;
J
Jesse Brandeburg 已提交
2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823
		}
		break;
	}

update_itr_done:
	return retval;
}

static void e1000_set_itr(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	uint16_t current_itr;
	uint32_t new_itr = adapter->itr;

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

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

	adapter->tx_itr = e1000_update_itr(adapter,
	                            adapter->tx_itr,
	                            adapter->total_tx_packets,
	                            adapter->total_tx_bytes);
2824 2825 2826 2827
	/* conservative mode (itr 3) eliminates the lowest_latency setting */
	if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
		adapter->tx_itr = low_latency;

J
Jesse Brandeburg 已提交
2828 2829 2830 2831
	adapter->rx_itr = e1000_update_itr(adapter,
	                            adapter->rx_itr,
	                            adapter->total_rx_packets,
	                            adapter->total_rx_bytes);
2832 2833 2834
	/* conservative mode (itr 3) eliminates the lowest_latency setting */
	if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
		adapter->rx_itr = low_latency;
J
Jesse Brandeburg 已提交
2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867

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

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

set_itr_now:
	if (new_itr != adapter->itr) {
		/* this attempts to bias the interrupt rate towards Bulk
		 * by adding intermediate steps when interrupt rate is
		 * increasing */
		new_itr = new_itr > adapter->itr ?
		             min(adapter->itr + (new_itr >> 2), new_itr) :
		             new_itr;
		adapter->itr = new_itr;
		E1000_WRITE_REG(hw, ITR, 1000000000 / (new_itr * 256));
	}

	return;
}

L
Linus Torvalds 已提交
2868 2869 2870
#define E1000_TX_FLAGS_CSUM		0x00000001
#define E1000_TX_FLAGS_VLAN		0x00000002
#define E1000_TX_FLAGS_TSO		0x00000004
2871
#define E1000_TX_FLAGS_IPV4		0x00000008
L
Linus Torvalds 已提交
2872 2873 2874
#define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT	16

2875
static int
2876 2877
e1000_tso(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
          struct sk_buff *skb)
L
Linus Torvalds 已提交
2878 2879
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2880
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2881 2882
	unsigned int i;
	uint32_t cmd_length = 0;
2883
	uint16_t ipcse = 0, tucse, mss;
L
Linus Torvalds 已提交
2884 2885 2886
	uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
	int err;

H
Herbert Xu 已提交
2887
	if (skb_is_gso(skb)) {
L
Linus Torvalds 已提交
2888 2889 2890 2891 2892 2893
		if (skb_header_cloned(skb)) {
			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
			if (err)
				return err;
		}

2894
		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
2895
		mss = skb_shinfo(skb)->gso_size;
A
Alexey Dobriyan 已提交
2896
		if (skb->protocol == htons(ETH_P_IP)) {
2897 2898 2899
			struct iphdr *iph = ip_hdr(skb);
			iph->tot_len = 0;
			iph->check = 0;
2900 2901 2902 2903
			tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
								 iph->daddr, 0,
								 IPPROTO_TCP,
								 0);
2904
			cmd_length = E1000_TXD_CMD_IP;
2905
			ipcse = skb_transport_offset(skb) - 1;
2906
		} else if (skb->protocol == htons(ETH_P_IPV6)) {
2907
			ipv6_hdr(skb)->payload_len = 0;
2908
			tcp_hdr(skb)->check =
2909 2910 2911
				~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
						 &ipv6_hdr(skb)->daddr,
						 0, IPPROTO_TCP, 0);
2912 2913
			ipcse = 0;
		}
2914
		ipcss = skb_network_offset(skb);
2915
		ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
2916
		tucss = skb_transport_offset(skb);
2917
		tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
L
Linus Torvalds 已提交
2918 2919 2920
		tucse = 0;

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

2923 2924
		i = tx_ring->next_to_use;
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
J
Jeff Kirsher 已提交
2925
		buffer_info = &tx_ring->buffer_info[i];
L
Linus Torvalds 已提交
2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936

		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 已提交
2937
		buffer_info->time_stamp = jiffies;
2938
		buffer_info->next_to_watch = i;
J
Jeff Kirsher 已提交
2939

2940 2941
		if (++i == tx_ring->count) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2942

2943
		return TRUE;
L
Linus Torvalds 已提交
2944
	}
2945
	return FALSE;
L
Linus Torvalds 已提交
2946 2947
}

2948
static boolean_t
2949 2950
e1000_tx_csum(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
              struct sk_buff *skb)
L
Linus Torvalds 已提交
2951 2952
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2953
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2954 2955 2956
	unsigned int i;
	uint8_t css;

2957
	if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
2958
		css = skb_transport_offset(skb);
L
Linus Torvalds 已提交
2959

2960
		i = tx_ring->next_to_use;
J
Jeff Kirsher 已提交
2961
		buffer_info = &tx_ring->buffer_info[i];
2962
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
L
Linus Torvalds 已提交
2963

2964
		context_desc->lower_setup.ip_config = 0;
L
Linus Torvalds 已提交
2965
		context_desc->upper_setup.tcp_fields.tucss = css;
2966 2967
		context_desc->upper_setup.tcp_fields.tucso =
			css + skb->csum_offset;
L
Linus Torvalds 已提交
2968 2969 2970 2971
		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 已提交
2972
		buffer_info->time_stamp = jiffies;
2973
		buffer_info->next_to_watch = i;
J
Jeff Kirsher 已提交
2974

2975 2976
		if (unlikely(++i == tx_ring->count)) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2977 2978 2979 2980 2981 2982 2983 2984 2985 2986

		return TRUE;
	}

	return FALSE;
}

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

2987
static int
2988 2989 2990
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 已提交
2991 2992 2993 2994 2995 2996 2997 2998 2999
{
	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 已提交
3000
	while (len) {
L
Linus Torvalds 已提交
3001 3002
		buffer_info = &tx_ring->buffer_info[i];
		size = min(len, max_per_txd);
J
Jeff Kirsher 已提交
3003 3004 3005
		/* 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
3006
		 * DMA'd to the controller */
J
Jeff Kirsher 已提交
3007
		if (!skb->data_len && tx_ring->last_tx_tso &&
H
Herbert Xu 已提交
3008
		    !skb_is_gso(skb)) {
J
Jeff Kirsher 已提交
3009 3010 3011 3012
			tx_ring->last_tx_tso = 0;
			size -= 4;
		}

L
Linus Torvalds 已提交
3013 3014
		/* Workaround for premature desc write-backs
		 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
3015
		if (unlikely(mss && !nr_frags && size == len && size > 8))
L
Linus Torvalds 已提交
3016
			size -= 4;
3017 3018 3019 3020 3021
		/* 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 已提交
3022
		if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
3023 3024
		                (size > 2015) && count == 0))
		        size = 2015;
J
Jesse Brandeburg 已提交
3025

L
Linus Torvalds 已提交
3026 3027
		/* Workaround for potential 82544 hang in PCI-X.  Avoid
		 * terminating buffers within evenly-aligned dwords. */
J
Jesse Brandeburg 已提交
3028
		if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
		   !((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;
3040
		buffer_info->next_to_watch = i;
L
Linus Torvalds 已提交
3041 3042 3043 3044

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

J
Jesse Brandeburg 已提交
3048
	for (f = 0; f < nr_frags; f++) {
L
Linus Torvalds 已提交
3049 3050 3051 3052 3053 3054
		struct skb_frag_struct *frag;

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

J
Jesse Brandeburg 已提交
3055
		while (len) {
L
Linus Torvalds 已提交
3056 3057 3058 3059
			buffer_info = &tx_ring->buffer_info[i];
			size = min(len, max_per_txd);
			/* Workaround for premature desc write-backs
			 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
3060
			if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
L
Linus Torvalds 已提交
3061 3062 3063 3064
				size -= 4;
			/* Workaround for potential 82544 hang in PCI-X.
			 * Avoid terminating buffers within evenly-aligned
			 * dwords. */
J
Jesse Brandeburg 已提交
3065
			if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077
			   !((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;
3078
			buffer_info->next_to_watch = i;
L
Linus Torvalds 已提交
3079 3080 3081 3082

			len -= size;
			offset += size;
			count++;
J
Jesse Brandeburg 已提交
3083
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
		}
	}

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

3094
static void
3095 3096
e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
               int tx_flags, int count)
L
Linus Torvalds 已提交
3097 3098 3099 3100 3101 3102
{
	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 已提交
3103
	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
L
Linus Torvalds 已提交
3104 3105
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
		             E1000_TXD_CMD_TSE;
3106 3107
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;

J
Jesse Brandeburg 已提交
3108
		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
3109
			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
L
Linus Torvalds 已提交
3110 3111
	}

J
Jesse Brandeburg 已提交
3112
	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
L
Linus Torvalds 已提交
3113 3114 3115 3116
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
	}

J
Jesse Brandeburg 已提交
3117
	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
L
Linus Torvalds 已提交
3118 3119 3120 3121 3122 3123
		txd_lower |= E1000_TXD_CMD_VLE;
		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
	}

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
3124
	while (count--) {
L
Linus Torvalds 已提交
3125 3126 3127 3128 3129 3130
		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 已提交
3131
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142
	}

	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;
3143
	writel(i, adapter->hw.hw_addr + tx_ring->tdt);
3144 3145 3146
	/* we need this if more than one processor can write to our tail
	 * at a time, it syncronizes IO on IA64/Altix systems */
	mmiowb();
L
Linus Torvalds 已提交
3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
}

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

3161
static int
L
Linus Torvalds 已提交
3162 3163 3164 3165 3166
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;

3167
	skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
L
Linus Torvalds 已提交
3168

J
Jesse Brandeburg 已提交
3169
	if (adapter->link_duplex != HALF_DUPLEX)
L
Linus Torvalds 已提交
3170 3171
		goto no_fifo_stall_required;

J
Jesse Brandeburg 已提交
3172
	if (atomic_read(&adapter->tx_fifo_stall))
L
Linus Torvalds 已提交
3173 3174
		return 1;

J
Jesse Brandeburg 已提交
3175
	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
L
Linus Torvalds 已提交
3176 3177 3178 3179 3180 3181
		atomic_set(&adapter->tx_fifo_stall, 1);
		return 1;
	}

no_fifo_stall_required:
	adapter->tx_fifo_head += skb_fifo_len;
J
Jesse Brandeburg 已提交
3182
	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
L
Linus Torvalds 已提交
3183 3184 3185 3186
		adapter->tx_fifo_head -= adapter->tx_fifo_size;
	return 0;
}

3187
#define MINIMUM_DHCP_PACKET_SIZE 282
3188
static int
3189 3190 3191 3192
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 已提交
3193 3194
	if (vlan_tx_tag_present(skb)) {
		if (!((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
3195 3196 3197 3198
			( adapter->hw.mng_cookie.status &
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) )
			return 0;
	}
3199
	if (skb->len > MINIMUM_DHCP_PACKET_SIZE) {
3200
		struct ethhdr *eth = (struct ethhdr *) skb->data;
J
Jesse Brandeburg 已提交
3201 3202
		if ((htons(ETH_P_IP) == eth->h_proto)) {
			const struct iphdr *ip =
3203
				(struct iphdr *)((uint8_t *)skb->data+14);
J
Jesse Brandeburg 已提交
3204 3205 3206
			if (IPPROTO_UDP == ip->protocol) {
				struct udphdr *udp =
					(struct udphdr *)((uint8_t *)ip +
3207
						(ip->ihl << 2));
J
Jesse Brandeburg 已提交
3208
				if (ntohs(udp->dest) == 67) {
3209 3210 3211 3212
					offset = (uint8_t *)udp + 8 - skb->data;
					length = skb->len - offset;

					return e1000_mng_write_dhcp_info(hw,
J
Jesse Brandeburg 已提交
3213
							(uint8_t *)udp + 8,
3214 3215 3216 3217 3218 3219 3220 3221
							length);
				}
			}
		}
	}
	return 0;
}

3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
{
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_tx_ring *tx_ring = adapter->tx_ring;

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

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

	/* A reprieve! */
	netif_start_queue(netdev);
3240
	++adapter->restart_queue;
3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251
	return 0;
}

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

L
Linus Torvalds 已提交
3252 3253 3254 3255
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
static int
e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
{
3256
	struct e1000_adapter *adapter = netdev_priv(netdev);
3257
	struct e1000_tx_ring *tx_ring;
L
Linus Torvalds 已提交
3258 3259 3260
	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;
3261
	unsigned int len = skb->len - skb->data_len;
L
Linus Torvalds 已提交
3262
	unsigned long flags;
3263 3264
	unsigned int nr_frags;
	unsigned int mss;
L
Linus Torvalds 已提交
3265
	int count = 0;
3266
	int tso;
L
Linus Torvalds 已提交
3267 3268
	unsigned int f;

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

3275
	if (unlikely(skb->len <= 0)) {
L
Linus Torvalds 已提交
3276 3277 3278 3279
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

3280 3281 3282 3283 3284
	/* 82571 and newer doesn't need the workaround that limited descriptor
	 * length to 4kB */
	if (adapter->hw.mac_type >= e1000_82571)
		max_per_txd = 8192;

3285
	mss = skb_shinfo(skb)->gso_size;
3286
	/* The controller does a simple calculation to
L
Linus Torvalds 已提交
3287 3288 3289 3290 3291
	 * 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 已提交
3292
	if (mss) {
J
Jeff Kirsher 已提交
3293
		uint8_t hdr_len;
L
Linus Torvalds 已提交
3294 3295
		max_per_txd = min(mss << 2, max_per_txd);
		max_txd_pwr = fls(max_per_txd) - 1;
J
Jeff Kirsher 已提交
3296

3297 3298 3299
		/* TSO Workaround for 82571/2/3 Controllers -- if skb->data
		* points to just header, pull a few bytes of payload from
		* frags into skb->data */
3300
		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
3301
		if (skb->data_len && hdr_len == len) {
3302 3303
			switch (adapter->hw.mac_type) {
				unsigned int pull_size;
3304 3305 3306 3307 3308 3309 3310
			case e1000_82544:
				/* Make sure we have room to chop off 4 bytes,
				 * and that the end alignment will work out to
				 * this hardware's requirements
				 * NOTE: this is a TSO only workaround
				 * if end byte alignment not correct move us
				 * into the next dword */
3311
				if ((unsigned long)(skb_tail_pointer(skb) - 1) & 4)
3312 3313
					break;
				/* fall through */
3314 3315 3316
			case e1000_82571:
			case e1000_82572:
			case e1000_82573:
3317
			case e1000_ich8lan:
3318 3319
				pull_size = min((unsigned int)4, skb->data_len);
				if (!__pskb_pull_tail(skb, pull_size)) {
A
Auke Kok 已提交
3320
					DPRINTK(DRV, ERR,
3321 3322
						"__pskb_pull_tail failed.\n");
					dev_kfree_skb_any(skb);
J
Jeff Garzik 已提交
3323
					return NETDEV_TX_OK;
3324 3325 3326 3327 3328 3329
				}
				len = skb->len - skb->data_len;
				break;
			default:
				/* do nothing */
				break;
3330
			}
J
Jeff Kirsher 已提交
3331
		}
L
Linus Torvalds 已提交
3332 3333
	}

J
Jeff Kirsher 已提交
3334
	/* reserve a descriptor for the offload context */
3335
	if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
L
Linus Torvalds 已提交
3336
		count++;
3337
	count++;
J
Jeff Kirsher 已提交
3338 3339

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

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

J
Jesse Brandeburg 已提交
3345
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
3346 3347
		count++;

J
Jesse Brandeburg 已提交
3348
	/* work-around for errata 10 and it applies to all controllers
3349 3350
	 * in PCI-X mode, so add one more descriptor to the count
	 */
J
Jesse Brandeburg 已提交
3351
	if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
3352 3353 3354
			(len > 2015)))
		count++;

L
Linus Torvalds 已提交
3355
	nr_frags = skb_shinfo(skb)->nr_frags;
J
Jesse Brandeburg 已提交
3356
	for (f = 0; f < nr_frags; f++)
L
Linus Torvalds 已提交
3357 3358
		count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
				       max_txd_pwr);
J
Jesse Brandeburg 已提交
3359
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
3360 3361
		count += nr_frags;

3362 3363 3364

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

3367
	if (!spin_trylock_irqsave(&tx_ring->tx_lock, flags))
3368 3369
		/* Collision - tell upper layer to requeue */
		return NETDEV_TX_LOCKED;
L
Linus Torvalds 已提交
3370 3371 3372

	/* need: count + 2 desc gap to keep tail from touching
	 * head, otherwise try next time */
3373
	if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2))) {
3374
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
3375 3376 3377
		return NETDEV_TX_BUSY;
	}

J
Jesse Brandeburg 已提交
3378 3379
	if (unlikely(adapter->hw.mac_type == e1000_82547)) {
		if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
L
Linus Torvalds 已提交
3380
			netif_stop_queue(netdev);
A
Auke Kok 已提交
3381
			mod_timer(&adapter->tx_fifo_stall_timer, jiffies + 1);
3382
			spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
3383 3384 3385 3386
			return NETDEV_TX_BUSY;
		}
	}

J
Jesse Brandeburg 已提交
3387
	if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
L
Linus Torvalds 已提交
3388 3389 3390 3391
		tx_flags |= E1000_TX_FLAGS_VLAN;
		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
	}

3392
	first = tx_ring->next_to_use;
J
Jesse Brandeburg 已提交
3393

3394
	tso = e1000_tso(adapter, tx_ring, skb);
L
Linus Torvalds 已提交
3395 3396
	if (tso < 0) {
		dev_kfree_skb_any(skb);
3397
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
3398 3399 3400
		return NETDEV_TX_OK;
	}

J
Jeff Kirsher 已提交
3401 3402
	if (likely(tso)) {
		tx_ring->last_tx_tso = 1;
L
Linus Torvalds 已提交
3403
		tx_flags |= E1000_TX_FLAGS_TSO;
J
Jeff Kirsher 已提交
3404
	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
L
Linus Torvalds 已提交
3405 3406
		tx_flags |= E1000_TX_FLAGS_CSUM;

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

3413 3414 3415
	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 已提交
3416 3417 3418 3419

	netdev->trans_start = jiffies;

	/* Make sure there is space in the ring for the next send. */
3420
	e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
L
Linus Torvalds 已提交
3421

3422
	spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433
	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)
{
3434
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3435 3436

	/* Do the reset outside of interrupt context */
3437 3438
	adapter->tx_timeout_count++;
	schedule_work(&adapter->reset_task);
L
Linus Torvalds 已提交
3439 3440 3441
}

static void
3442
e1000_reset_task(struct work_struct *work)
L
Linus Torvalds 已提交
3443
{
3444 3445
	struct e1000_adapter *adapter =
		container_of(work, struct e1000_adapter, reset_task);
L
Linus Torvalds 已提交
3446

3447
	e1000_reinit_locked(adapter);
L
Linus Torvalds 已提交
3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460
}

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

J
Jeff Kirsher 已提交
3463
	/* only return the current stats */
L
Linus Torvalds 已提交
3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477
	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)
{
3478
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3479
	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
3480
	uint16_t eeprom_data = 0;
L
Linus Torvalds 已提交
3481

J
Jesse Brandeburg 已提交
3482 3483 3484
	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
		DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
L
Linus Torvalds 已提交
3485
		return -EINVAL;
3486
	}
L
Linus Torvalds 已提交
3487

3488 3489
	/* Adapter-specific max frame size limits. */
	switch (adapter->hw.mac_type) {
3490
	case e1000_undefined ... e1000_82542_rev2_1:
3491
	case e1000_ich8lan:
3492 3493
		if (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
			DPRINTK(PROBE, ERR, "Jumbo Frames not supported.\n");
3494 3495
			return -EINVAL;
		}
3496
		break;
3497
	case e1000_82573:
3498 3499 3500
		/* Jumbo Frames not supported if:
		 * - this is not an 82573L device
		 * - ASPM is enabled in any way (0x1A bits 3:2) */
3501 3502
		e1000_read_eeprom(&adapter->hw, EEPROM_INIT_3GIO_3, 1,
		                  &eeprom_data);
3503 3504
		if ((adapter->hw.device_id != E1000_DEV_ID_82573L) ||
		    (eeprom_data & EEPROM_WORD1A_ASPM_MASK)) {
3505 3506 3507 3508 3509 3510 3511
			if (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
				DPRINTK(PROBE, ERR,
			            	"Jumbo Frames not supported.\n");
				return -EINVAL;
			}
			break;
		}
3512 3513
		/* ERT will be enabled later to enable wire speed receives */

3514
		/* fall through to get support */
3515 3516
	case e1000_82571:
	case e1000_82572:
3517
	case e1000_80003es2lan:
3518 3519 3520 3521 3522 3523 3524 3525 3526
#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 已提交
3527 3528
	}

3529
	/* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553
	 * means we reserve 2 more, this pushes us to allocate from the next
	 * larger slab size
	 * i.e. RXBUFFER_2048 --> size-4096 slab */

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

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

3555
	netdev->mtu = new_mtu;
3556
	adapter->hw.max_frame_size = max_frame;
3557

3558 3559
	if (netif_running(netdev))
		e1000_reinit_locked(adapter);
L
Linus Torvalds 已提交
3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572

	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;
3573
	struct pci_dev *pdev = adapter->pdev;
L
Linus Torvalds 已提交
3574 3575 3576 3577 3578
	unsigned long flags;
	uint16_t phy_tmp;

#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF

3579 3580 3581 3582
	/*
	 * Prevent stats update while adapter is being reset, or if the pci
	 * connection is down.
	 */
A
Auke Kok 已提交
3583
	if (adapter->link_speed == 0)
3584
		return;
3585
	if (pci_channel_offline(pdev))
A
Auke Kok 已提交
3586 3587
		return;

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

3590
	/* these counters are modified from e1000_tbi_adjust_stats,
L
Linus Torvalds 已提交
3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601
	 * 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);
3602 3603

	if (adapter->hw.mac_type != e1000_ich8lan) {
3604 3605 3606 3607 3608 3609
		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);
3610
	}
L
Linus Torvalds 已提交
3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637

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

	if (adapter->hw.mac_type != e1000_ich8lan) {
3640 3641 3642 3643 3644 3645
		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);
3646 3647
	}

L
Linus Torvalds 已提交
3648 3649 3650 3651 3652 3653 3654 3655 3656 3657
	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 已提交
3658
	if (hw->mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
3659 3660 3661 3662 3663 3664 3665
		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 已提交
3666
	if (hw->mac_type > e1000_82547_rev_2) {
3667 3668
		adapter->stats.iac += E1000_READ_REG(hw, IAC);
		adapter->stats.icrxoc += E1000_READ_REG(hw, ICRXOC);
3669 3670

		if (adapter->hw.mac_type != e1000_ich8lan) {
3671 3672 3673 3674 3675 3676 3677
			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);
3678
		}
3679
	}
L
Linus Torvalds 已提交
3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690

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

3691 3692
	/* RLEC on some newer hardware can be incorrect so build
	* our own version based on RUC and ROC */
L
Linus Torvalds 已提交
3693 3694
	adapter->net_stats.rx_errors = adapter->stats.rxerrc +
		adapter->stats.crcerrs + adapter->stats.algnerrc +
3695 3696
		adapter->stats.ruc + adapter->stats.roc +
		adapter->stats.cexterr;
3697 3698
	adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
	adapter->net_stats.rx_length_errors = adapter->stats.rlerrc;
L
Linus Torvalds 已提交
3699 3700 3701 3702 3703
	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 */
3704 3705
	adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
	adapter->net_stats.tx_errors = adapter->stats.txerrc;
L
Linus Torvalds 已提交
3706 3707 3708
	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;
3709 3710 3711 3712 3713
	if (adapter->hw.bad_tx_carr_stats_fd &&
	    adapter->link_duplex == FULL_DUPLEX) {
		adapter->net_stats.tx_carrier_errors = 0;
		adapter->stats.tncrs = 0;
	}
L
Linus Torvalds 已提交
3714 3715 3716 3717

	/* Tx Dropped needs to be maintained elsewhere */

	/* Phy Stats */
J
Jesse Brandeburg 已提交
3718 3719
	if (hw->media_type == e1000_media_type_copper) {
		if ((adapter->link_speed == SPEED_1000) &&
L
Linus Torvalds 已提交
3720 3721 3722 3723 3724
		   (!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 已提交
3725
		if ((hw->mac_type <= e1000_82546) &&
L
Linus Torvalds 已提交
3726 3727 3728 3729 3730
		   (hw->phy_type == e1000_phy_m88) &&
		   !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
			adapter->phy_stats.receive_errors += phy_tmp;
	}

3731 3732 3733 3734 3735 3736 3737
	/* Management Stats */
	if (adapter->hw.has_smbus) {
		adapter->stats.mgptc += E1000_READ_REG(hw, MGTPTC);
		adapter->stats.mgprc += E1000_READ_REG(hw, MGTPRC);
		adapter->stats.mgpdc += E1000_READ_REG(hw, MGTPDC);
	}

L
Linus Torvalds 已提交
3738 3739
	spin_unlock_irqrestore(&adapter->stats_lock, flags);
}
3740 3741 3742 3743 3744 3745 3746

/**
 * e1000_intr_msi - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/

3747 3748
static irqreturn_t
e1000_intr_msi(int irq, void *data)
3749 3750 3751 3752 3753 3754 3755
{
	struct net_device *netdev = data;
	struct e1000_adapter *adapter = netdev_priv(netdev);
	struct e1000_hw *hw = &adapter->hw;
#ifndef CONFIG_E1000_NAPI
	int i;
#endif
3756
	uint32_t icr = E1000_READ_REG(hw, ICR);
3757 3758

#ifdef CONFIG_E1000_NAPI
3759 3760 3761
	/* read ICR disables interrupts using IAM, so keep up with our
	 * enable/disable accounting */
	atomic_inc(&adapter->irq_sem);
3762
#endif
3763 3764 3765 3766 3767 3768 3769 3770 3771 3772
	if (icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
		hw->get_link_status = 1;
		/* 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 */
			uint32_t rctl = E1000_READ_REG(hw, RCTL);
			E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
3773
		}
3774 3775 3776
		/* guard against interrupt when we're going down */
		if (!test_bit(__E1000_DOWN, &adapter->flags))
			mod_timer(&adapter->watchdog_timer, jiffies + 1);
3777 3778 3779
	}

#ifdef CONFIG_E1000_NAPI
3780
	if (likely(netif_rx_schedule_prep(netdev, &adapter->napi))) {
J
Jesse Brandeburg 已提交
3781 3782 3783 3784
		adapter->total_tx_bytes = 0;
		adapter->total_tx_packets = 0;
		adapter->total_rx_bytes = 0;
		adapter->total_rx_packets = 0;
3785
		__netif_rx_schedule(netdev, &adapter->napi);
J
Jesse Brandeburg 已提交
3786
	} else
3787 3788
		e1000_irq_enable(adapter);
#else
J
Jesse Brandeburg 已提交
3789 3790 3791 3792 3793
	adapter->total_tx_bytes = 0;
	adapter->total_rx_bytes = 0;
	adapter->total_tx_packets = 0;
	adapter->total_rx_packets = 0;

3794 3795
	for (i = 0; i < E1000_MAX_INTR; i++)
		if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) &
3796
		   !e1000_clean_tx_irq(adapter, adapter->tx_ring)))
3797
			break;
J
Jesse Brandeburg 已提交
3798 3799 3800

	if (likely(adapter->itr_setting & 3))
		e1000_set_itr(adapter);
3801 3802 3803 3804
#endif

	return IRQ_HANDLED;
}
L
Linus Torvalds 已提交
3805 3806 3807 3808 3809 3810 3811 3812

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

static irqreturn_t
3813
e1000_intr(int irq, void *data)
L
Linus Torvalds 已提交
3814 3815
{
	struct net_device *netdev = data;
3816
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3817
	struct e1000_hw *hw = &adapter->hw;
3818
	uint32_t rctl, icr = E1000_READ_REG(hw, ICR);
3819
#ifndef CONFIG_E1000_NAPI
3820
	int i;
J
Jesse Brandeburg 已提交
3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
#endif
	if (unlikely(!icr))
		return IRQ_NONE;  /* Not our interrupt */

#ifdef CONFIG_E1000_NAPI
	/* IMS will not auto-mask if INT_ASSERTED is not set, and if it is
	 * not set, then the adapter didn't send an interrupt */
	if (unlikely(hw->mac_type >= e1000_82571 &&
	             !(icr & E1000_ICR_INT_ASSERTED)))
		return IRQ_NONE;

3832 3833 3834 3835 3836 3837
	/* 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 已提交
3838
#endif
L
Linus Torvalds 已提交
3839

J
Jesse Brandeburg 已提交
3840
	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
L
Linus Torvalds 已提交
3841
		hw->get_link_status = 1;
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852
		/* 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);
		}
A
Auke Kok 已提交
3853 3854 3855
		/* guard against interrupt when we're going down */
		if (!test_bit(__E1000_DOWN, &adapter->flags))
			mod_timer(&adapter->watchdog_timer, jiffies + 1);
L
Linus Torvalds 已提交
3856 3857 3858
	}

#ifdef CONFIG_E1000_NAPI
3859
	if (unlikely(hw->mac_type < e1000_82571)) {
J
Jesse Brandeburg 已提交
3860
		/* disable interrupts, without the synchronize_irq bit */
3861 3862 3863 3864
		atomic_inc(&adapter->irq_sem);
		E1000_WRITE_REG(hw, IMC, ~0);
		E1000_WRITE_FLUSH(hw);
	}
3865
	if (likely(netif_rx_schedule_prep(netdev, &adapter->napi))) {
J
Jesse Brandeburg 已提交
3866 3867 3868 3869
		adapter->total_tx_bytes = 0;
		adapter->total_tx_packets = 0;
		adapter->total_rx_bytes = 0;
		adapter->total_rx_packets = 0;
3870
		__netif_rx_schedule(netdev, &adapter->napi);
J
Jesse Brandeburg 已提交
3871
	} else
3872 3873
		/* this really should not happen! if it does it is basically a
		 * bug, but not a hard error, so enable ints and continue */
3874
		e1000_irq_enable(adapter);
3875
#else
L
Linus Torvalds 已提交
3876
	/* Writing IMC and IMS is needed for 82547.
J
Jesse Brandeburg 已提交
3877 3878 3879 3880 3881 3882 3883 3884 3885 3886
	 * 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 已提交
3887
		atomic_inc(&adapter->irq_sem);
3888
		E1000_WRITE_REG(hw, IMC, ~0);
L
Linus Torvalds 已提交
3889 3890
	}

J
Jesse Brandeburg 已提交
3891 3892 3893 3894 3895
	adapter->total_tx_bytes = 0;
	adapter->total_rx_bytes = 0;
	adapter->total_tx_packets = 0;
	adapter->total_rx_packets = 0;

J
Jesse Brandeburg 已提交
3896 3897
	for (i = 0; i < E1000_MAX_INTR; i++)
		if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) &
3898
		   !e1000_clean_tx_irq(adapter, adapter->tx_ring)))
L
Linus Torvalds 已提交
3899 3900
			break;

J
Jesse Brandeburg 已提交
3901 3902 3903
	if (likely(adapter->itr_setting & 3))
		e1000_set_itr(adapter);

J
Jesse Brandeburg 已提交
3904
	if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)
L
Linus Torvalds 已提交
3905
		e1000_irq_enable(adapter);
3906

3907
#endif
L
Linus Torvalds 已提交
3908 3909 3910 3911 3912 3913 3914 3915 3916 3917
	return IRQ_HANDLED;
}

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

static int
3918
e1000_clean(struct napi_struct *napi, int budget)
L
Linus Torvalds 已提交
3919
{
3920 3921
	struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, napi);
	struct net_device *poll_dev = adapter->netdev;
3922
	int work_done = 0;
3923 3924 3925 3926

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

3927 3928 3929 3930 3931
	/* 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)) {
3932 3933
		e1000_clean_tx_irq(adapter,
				   &adapter->tx_ring[0]);
3934
		spin_unlock(&adapter->tx_queue_lock);
3935 3936
	}

3937
	adapter->clean_rx(adapter, &adapter->rx_ring[0],
3938
	                  &work_done, budget);
J
Jesse Brandeburg 已提交
3939

3940 3941
	/* If budget not fully consumed, exit the polling mode */
	if (work_done < budget) {
J
Jesse Brandeburg 已提交
3942 3943
		if (likely(adapter->itr_setting & 3))
			e1000_set_itr(adapter);
3944
		netif_rx_complete(poll_dev, napi);
L
Linus Torvalds 已提交
3945 3946 3947
		e1000_irq_enable(adapter);
	}

3948
	return work_done;
L
Linus Torvalds 已提交
3949 3950 3951 3952 3953 3954 3955 3956 3957
}

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

static boolean_t
3958 3959
e1000_clean_tx_irq(struct e1000_adapter *adapter,
                   struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
3960 3961 3962 3963 3964
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_tx_desc *tx_desc, *eop_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i, eop;
3965 3966 3967
#ifdef CONFIG_E1000_NAPI
	unsigned int count = 0;
#endif
3968
	boolean_t cleaned = FALSE;
J
Jesse Brandeburg 已提交
3969
	unsigned int total_tx_bytes=0, total_tx_packets=0;
L
Linus Torvalds 已提交
3970 3971 3972 3973 3974

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

3975
	while (eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
J
Jesse Brandeburg 已提交
3976
		for (cleaned = FALSE; !cleaned; ) {
L
Linus Torvalds 已提交
3977 3978 3979 3980
			tx_desc = E1000_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];
			cleaned = (i == eop);

J
Jesse Brandeburg 已提交
3981
			if (cleaned) {
3982
				struct sk_buff *skb = buffer_info->skb;
3983 3984 3985 3986 3987
				unsigned int segs, bytecount;
				segs = skb_shinfo(skb)->gso_segs ?: 1;
				/* multiply data chunks by size of headers */
				bytecount = ((segs - 1) * skb_headlen(skb)) +
				            skb->len;
3988
				total_tx_packets += segs;
3989
				total_tx_bytes += bytecount;
J
Jesse Brandeburg 已提交
3990
			}
J
Jeff Kirsher 已提交
3991
			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3992
			tx_desc->upper.data = 0;
L
Linus Torvalds 已提交
3993

J
Jesse Brandeburg 已提交
3994
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3995
		}
3996

L
Linus Torvalds 已提交
3997 3998
		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = E1000_TX_DESC(*tx_ring, eop);
3999 4000 4001
#ifdef CONFIG_E1000_NAPI
#define E1000_TX_WEIGHT 64
		/* weight of a sort for tx, to avoid endless transmit cleanup */
4002
		if (count++ == E1000_TX_WEIGHT) break;
4003
#endif
L
Linus Torvalds 已提交
4004 4005 4006 4007
	}

	tx_ring->next_to_clean = i;

4008
#define TX_WAKE_THRESHOLD 32
4009 4010 4011 4012 4013 4014
	if (unlikely(cleaned && netif_carrier_ok(netdev) &&
		     E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
		/* Make sure that anybody stopping the queue after this
		 * sees the new next_to_clean.
		 */
		smp_mb();
4015
		if (netif_queue_stopped(netdev)) {
4016
			netif_wake_queue(netdev);
4017 4018
			++adapter->restart_queue;
		}
4019
	}
4020

4021
	if (adapter->detect_tx_hung) {
4022
		/* Detect a transmit hang in hardware, this serializes the
L
Linus Torvalds 已提交
4023 4024
		 * check with the clearing of time_stamp and movement of i */
		adapter->detect_tx_hung = FALSE;
4025 4026
		if (tx_ring->buffer_info[eop].dma &&
		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
4027
		               (adapter->tx_timeout_factor * HZ))
4028
		    && !(E1000_READ_REG(&adapter->hw, STATUS) &
4029
		         E1000_STATUS_TXOFF)) {
4030 4031

			/* detected Tx unit hang */
4032
			DPRINTK(DRV, ERR, "Detected Tx Unit Hang\n"
4033
					"  Tx Queue             <%lu>\n"
4034 4035 4036 4037 4038 4039 4040 4041 4042
					"  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",
4043 4044
				(unsigned long)((tx_ring - adapter->tx_ring) /
					sizeof(struct e1000_tx_ring)),
4045 4046
				readl(adapter->hw.hw_addr + tx_ring->tdh),
				readl(adapter->hw.hw_addr + tx_ring->tdt),
4047
				tx_ring->next_to_use,
4048 4049
				tx_ring->next_to_clean,
				tx_ring->buffer_info[eop].time_stamp,
4050 4051 4052
				eop,
				jiffies,
				eop_desc->upper.fields.status);
L
Linus Torvalds 已提交
4053
			netif_stop_queue(netdev);
4054
		}
L
Linus Torvalds 已提交
4055
	}
J
Jesse Brandeburg 已提交
4056 4057
	adapter->total_tx_bytes += total_tx_bytes;
	adapter->total_tx_packets += total_tx_packets;
L
Linus Torvalds 已提交
4058 4059 4060 4061 4062
	return cleaned;
}

/**
 * e1000_rx_checksum - Receive Checksum Offload for 82543
4063 4064 4065 4066
 * @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 已提交
4067 4068
 **/

4069
static void
L
Linus Torvalds 已提交
4070
e1000_rx_checksum(struct e1000_adapter *adapter,
4071 4072
		  uint32_t status_err, uint32_t csum,
		  struct sk_buff *skb)
L
Linus Torvalds 已提交
4073
{
4074 4075 4076 4077
	uint16_t status = (uint16_t)status_err;
	uint8_t errors = (uint8_t)(status_err >> 24);
	skb->ip_summed = CHECKSUM_NONE;

L
Linus Torvalds 已提交
4078
	/* 82543 or newer only */
J
Jesse Brandeburg 已提交
4079
	if (unlikely(adapter->hw.mac_type < e1000_82543)) return;
L
Linus Torvalds 已提交
4080
	/* Ignore Checksum bit is set */
J
Jesse Brandeburg 已提交
4081
	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
4082
	/* TCP/UDP checksum error bit is set */
J
Jesse Brandeburg 已提交
4083
	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
L
Linus Torvalds 已提交
4084 4085
		/* let the stack verify checksum errors */
		adapter->hw_csum_err++;
4086 4087 4088
		return;
	}
	/* TCP/UDP Checksum has not been calculated */
J
Jesse Brandeburg 已提交
4089 4090
	if (adapter->hw.mac_type <= e1000_82547_rev_2) {
		if (!(status & E1000_RXD_STAT_TCPCS))
4091
			return;
L
Linus Torvalds 已提交
4092
	} else {
J
Jesse Brandeburg 已提交
4093
		if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))
4094 4095 4096 4097
			return;
	}
	/* It must be a TCP or UDP packet with a valid checksum */
	if (likely(status & E1000_RXD_STAT_TCPCS)) {
L
Linus Torvalds 已提交
4098 4099
		/* TCP checksum is good */
		skb->ip_summed = CHECKSUM_UNNECESSARY;
4100 4101 4102 4103 4104 4105 4106
	} 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;
4107
		skb->ip_summed = CHECKSUM_COMPLETE;
L
Linus Torvalds 已提交
4108
	}
4109
	adapter->hw_csum_good++;
L
Linus Torvalds 已提交
4110 4111 4112
}

/**
4113
 * e1000_clean_rx_irq - Send received data up the network stack; legacy
L
Linus Torvalds 已提交
4114 4115 4116 4117 4118
 * @adapter: board private structure
 **/

static boolean_t
#ifdef CONFIG_E1000_NAPI
4119 4120 4121
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring,
                   int *work_done, int work_to_do)
L
Linus Torvalds 已提交
4122
#else
4123 4124
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
4125 4126 4127 4128
#endif
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
4129 4130
	struct e1000_rx_desc *rx_desc, *next_rxd;
	struct e1000_buffer *buffer_info, *next_buffer;
L
Linus Torvalds 已提交
4131 4132 4133 4134
	unsigned long flags;
	uint32_t length;
	uint8_t last_byte;
	unsigned int i;
4135
	int cleaned_count = 0;
4136
	boolean_t cleaned = FALSE;
J
Jesse Brandeburg 已提交
4137
	unsigned int total_rx_bytes=0, total_rx_packets=0;
L
Linus Torvalds 已提交
4138 4139 4140

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

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

L
Linus Torvalds 已提交
4147
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
4148
		if (*work_done >= work_to_do)
L
Linus Torvalds 已提交
4149 4150 4151
			break;
		(*work_done)++;
#endif
4152
		status = rx_desc->status;
4153
		skb = buffer_info->skb;
4154 4155
		buffer_info->skb = NULL;

4156 4157
		prefetch(skb->data - NET_IP_ALIGN);

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

4162 4163
		next_buffer = &rx_ring->buffer_info[i];

4164 4165
		cleaned = TRUE;
		cleaned_count++;
4166 4167 4168
		pci_unmap_single(pdev,
		                 buffer_info->dma,
		                 buffer_info->length,
L
Linus Torvalds 已提交
4169 4170 4171 4172
		                 PCI_DMA_FROMDEVICE);

		length = le16_to_cpu(rx_desc->length);

4173 4174 4175 4176
		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);
A
Auke Kok 已提交
4177
			/* recycle */
4178
			buffer_info->skb = skb;
L
Linus Torvalds 已提交
4179 4180 4181
			goto next_desc;
		}

J
Jesse Brandeburg 已提交
4182
		if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
L
Linus Torvalds 已提交
4183
			last_byte = *(skb->data + length - 1);
4184
			if (TBI_ACCEPT(&adapter->hw, status,
L
Linus Torvalds 已提交
4185 4186
			              rx_desc->errors, length, last_byte)) {
				spin_lock_irqsave(&adapter->stats_lock, flags);
4187 4188
				e1000_tbi_adjust_stats(&adapter->hw,
				                       &adapter->stats,
L
Linus Torvalds 已提交
4189 4190 4191 4192 4193
				                       length, skb->data);
				spin_unlock_irqrestore(&adapter->stats_lock,
				                       flags);
				length--;
			} else {
4194 4195
				/* recycle */
				buffer_info->skb = skb;
L
Linus Torvalds 已提交
4196 4197
				goto next_desc;
			}
A
Auke Kok 已提交
4198
		}
L
Linus Torvalds 已提交
4199

4200 4201 4202 4203
		/* adjust length to remove Ethernet CRC, this must be
		 * done after the TBI_ACCEPT workaround above */
		length -= 4;

J
Jesse Brandeburg 已提交
4204 4205 4206 4207
		/* probably a little skewed due to removing CRC */
		total_rx_bytes += length;
		total_rx_packets++;

4208 4209 4210
		/* code added for copybreak, this should improve
		 * performance for small packets with large amounts
		 * of reassembly being done in the stack */
4211
		if (length < copybreak) {
4212
			struct sk_buff *new_skb =
4213
			    netdev_alloc_skb(netdev, length + NET_IP_ALIGN);
4214 4215
			if (new_skb) {
				skb_reserve(new_skb, NET_IP_ALIGN);
4216 4217 4218 4219 4220 4221
				skb_copy_to_linear_data_offset(new_skb,
							       -NET_IP_ALIGN,
							       (skb->data -
							        NET_IP_ALIGN),
							       (length +
							        NET_IP_ALIGN));
4222 4223 4224 4225
				/* save the skb in buffer_info as good */
				buffer_info->skb = skb;
				skb = new_skb;
			}
A
Auke Kok 已提交
4226 4227
			/* else just continue with the old one */
		}
4228
		/* end copybreak code */
A
Auke Kok 已提交
4229
		skb_put(skb, length);
L
Linus Torvalds 已提交
4230 4231

		/* Receive Checksum Offload */
4232 4233
		e1000_rx_checksum(adapter,
				  (uint32_t)(status) |
4234
				  ((uint32_t)(rx_desc->errors) << 24),
D
David S. Miller 已提交
4235
				  le16_to_cpu(rx_desc->csum), skb);
J
Jesse Brandeburg 已提交
4236

L
Linus Torvalds 已提交
4237 4238
		skb->protocol = eth_type_trans(skb, netdev);
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
4239
		if (unlikely(adapter->vlgrp &&
4240
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
4241
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
4242 4243
						 le16_to_cpu(rx_desc->special) &
						 E1000_RXD_SPC_VLAN_MASK);
L
Linus Torvalds 已提交
4244 4245 4246 4247
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
4248
		if (unlikely(adapter->vlgrp &&
4249
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261
			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;

4262 4263 4264 4265 4266 4267
		/* 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;
		}

4268
		/* use prefetched values */
4269 4270
		rx_desc = next_rxd;
		buffer_info = next_buffer;
L
Linus Torvalds 已提交
4271 4272
	}
	rx_ring->next_to_clean = i;
4273 4274 4275 4276

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

J
Jesse Brandeburg 已提交
4278 4279
	adapter->total_rx_packets += total_rx_packets;
	adapter->total_rx_bytes += total_rx_bytes;
4280 4281 4282 4283 4284 4285 4286 4287 4288 4289
	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
4290 4291 4292
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring,
                      int *work_done, int work_to_do)
4293
#else
4294 4295
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring)
4296 4297
#endif
{
4298
	union e1000_rx_desc_packet_split *rx_desc, *next_rxd;
4299 4300
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
4301
	struct e1000_buffer *buffer_info, *next_buffer;
4302 4303
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
4304
	struct sk_buff *skb;
4305 4306
	unsigned int i, j;
	uint32_t length, staterr;
4307
	int cleaned_count = 0;
4308
	boolean_t cleaned = FALSE;
J
Jesse Brandeburg 已提交
4309
	unsigned int total_rx_bytes=0, total_rx_packets=0;
4310 4311 4312

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC_PS(*rx_ring, i);
4313
	staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
4314
	buffer_info = &rx_ring->buffer_info[i];
4315

J
Jesse Brandeburg 已提交
4316
	while (staterr & E1000_RXD_STAT_DD) {
4317 4318 4319
		ps_page = &rx_ring->ps_page[i];
		ps_page_dma = &rx_ring->ps_page_dma[i];
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
4320
		if (unlikely(*work_done >= work_to_do))
4321 4322 4323
			break;
		(*work_done)++;
#endif
4324 4325
		skb = buffer_info->skb;

4326 4327 4328
		/* in the packet split case this is header only */
		prefetch(skb->data - NET_IP_ALIGN);

4329 4330
		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC_PS(*rx_ring, i);
4331 4332
		prefetch(next_rxd);

4333 4334
		next_buffer = &rx_ring->buffer_info[i];

4335
		cleaned = TRUE;
4336
		cleaned_count++;
4337 4338 4339 4340
		pci_unmap_single(pdev, buffer_info->dma,
				 buffer_info->length,
				 PCI_DMA_FROMDEVICE);

J
Jesse Brandeburg 已提交
4341
		if (unlikely(!(staterr & E1000_RXD_STAT_EOP))) {
4342 4343 4344 4345 4346
			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 已提交
4347

J
Jesse Brandeburg 已提交
4348
		if (unlikely(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) {
4349 4350 4351 4352 4353 4354
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

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

J
Jesse Brandeburg 已提交
4355
		if (unlikely(!length)) {
4356 4357 4358 4359 4360 4361 4362 4363 4364
			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);

4365 4366 4367 4368 4369 4370 4371
		{
		/* 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*/
4372
		if (l1 && (l1 <= copybreak) && ((length + l1) <= adapter->rx_ps_bsize0)) {
4373
			u8 *vaddr;
4374
			/* there is no documentation about how to call
4375 4376 4377 4378 4379 4380 4381 4382
			 * 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);
4383
			memcpy(skb_tail_pointer(skb), vaddr, l1);
4384 4385 4386 4387
			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);
4388 4389
			/* remove the CRC */
			l1 -= 4;
4390 4391 4392 4393
			skb_put(skb, l1);
			goto copydone;
		} /* if */
		}
4394

J
Jesse Brandeburg 已提交
4395
		for (j = 0; j < adapter->rx_ps_pages; j++) {
4396
			if (!(length= le16_to_cpu(rx_desc->wb.upper.length[j])))
4397 4398 4399 4400
				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;
4401 4402
			skb_fill_page_desc(skb, j, ps_page->ps_page[j], 0,
			                   length);
4403 4404 4405
			ps_page->ps_page[j] = NULL;
			skb->len += length;
			skb->data_len += length;
4406
			skb->truesize += length;
4407 4408
		}

4409 4410 4411 4412
		/* strip the ethernet crc, problem is we're using pages now so
		 * this whole operation can get a little cpu intensive */
		pskb_trim(skb, skb->len - 4);

4413
copydone:
J
Jesse Brandeburg 已提交
4414 4415 4416
		total_rx_bytes += skb->len;
		total_rx_packets++;

4417
		e1000_rx_checksum(adapter, staterr,
D
David S. Miller 已提交
4418
				  le16_to_cpu(rx_desc->wb.lower.hi_dword.csum_ip.csum), skb);
4419 4420
		skb->protocol = eth_type_trans(skb, netdev);

J
Jesse Brandeburg 已提交
4421
		if (likely(rx_desc->wb.upper.header_status &
D
David S. Miller 已提交
4422
			   cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP)))
4423
			adapter->rx_hdr_split++;
4424
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
4425
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
4426
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
4427 4428
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
4429 4430 4431 4432
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
4433
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
4434
			vlan_hwaccel_rx(skb, adapter->vlgrp,
4435 4436
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
4437 4438 4439 4440 4441 4442 4443
		} else {
			netif_rx(skb);
		}
#endif /* CONFIG_E1000_NAPI */
		netdev->last_rx = jiffies;

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

4447 4448 4449 4450 4451 4452
		/* 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;
		}

4453
		/* use prefetched values */
4454 4455 4456
		rx_desc = next_rxd;
		buffer_info = next_buffer;

4457
		staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
4458 4459
	}
	rx_ring->next_to_clean = i;
4460 4461 4462 4463

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
L
Linus Torvalds 已提交
4464

J
Jesse Brandeburg 已提交
4465 4466
	adapter->total_rx_packets += total_rx_packets;
	adapter->total_rx_bytes += total_rx_bytes;
L
Linus Torvalds 已提交
4467 4468 4469 4470
	return cleaned;
}

/**
4471
 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
L
Linus Torvalds 已提交
4472 4473 4474 4475
 * @adapter: address of board private structure
 **/

static void
4476
e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
4477
                       struct e1000_rx_ring *rx_ring,
4478
		       int cleaned_count)
L
Linus Torvalds 已提交
4479 4480 4481 4482 4483 4484
{
	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;
4485 4486
	unsigned int i;
	unsigned int bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
L
Linus Torvalds 已提交
4487 4488 4489 4490

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

4491
	while (cleaned_count--) {
4492 4493
		skb = buffer_info->skb;
		if (skb) {
4494 4495 4496 4497
			skb_trim(skb, 0);
			goto map_skb;
		}

4498
		skb = netdev_alloc_skb(netdev, bufsz);
J
Jesse Brandeburg 已提交
4499
		if (unlikely(!skb)) {
L
Linus Torvalds 已提交
4500
			/* Better luck next round */
4501
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
4502 4503 4504
			break;
		}

4505
		/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
4506 4507
		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
			struct sk_buff *oldskb = skb;
4508 4509 4510
			DPRINTK(RX_ERR, ERR, "skb align check failed: %u bytes "
					     "at %p\n", bufsz, skb->data);
			/* Try again, without freeing the previous */
4511
			skb = netdev_alloc_skb(netdev, bufsz);
4512
			/* Failed allocation, critical failure */
L
Linus Torvalds 已提交
4513 4514 4515 4516
			if (!skb) {
				dev_kfree_skb(oldskb);
				break;
			}
4517

L
Linus Torvalds 已提交
4518 4519 4520 4521 4522 4523
			if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
				/* give up */
				dev_kfree_skb(skb);
				dev_kfree_skb(oldskb);
				break; /* while !buffer_info->skb */
			}
4524 4525 4526

			/* Use new allocation */
			dev_kfree_skb(oldskb);
L
Linus Torvalds 已提交
4527 4528 4529 4530 4531 4532 4533 4534 4535
		}
		/* 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);

		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_buffer_len;
4536
map_skb:
L
Linus Torvalds 已提交
4537 4538 4539 4540 4541
		buffer_info->dma = pci_map_single(pdev,
						  skb->data,
						  adapter->rx_buffer_len,
						  PCI_DMA_FROMDEVICE);

4542 4543 4544 4545 4546 4547 4548 4549
		/* 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 已提交
4550 4551 4552
			dev_kfree_skb(skb);
			buffer_info->skb = NULL;

4553
			pci_unmap_single(pdev, buffer_info->dma,
L
Linus Torvalds 已提交
4554 4555 4556 4557 4558 4559 4560 4561
					 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 已提交
4562 4563
		if (unlikely(++i == rx_ring->count))
			i = 0;
L
Linus Torvalds 已提交
4564 4565 4566
		buffer_info = &rx_ring->buffer_info[i];
	}

4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578
	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 已提交
4579 4580
}

4581 4582 4583 4584 4585 4586
/**
 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split
 * @adapter: address of board private structure
 **/

static void
4587
e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
4588 4589
                          struct e1000_rx_ring *rx_ring,
			  int cleaned_count)
4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604
{
	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];

4605
	while (cleaned_count--) {
4606 4607
		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

J
Jesse Brandeburg 已提交
4608
		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
4609 4610 4611 4612
			if (j < adapter->rx_ps_pages) {
				if (likely(!ps_page->ps_page[j])) {
					ps_page->ps_page[j] =
						alloc_page(GFP_ATOMIC);
4613 4614
					if (unlikely(!ps_page->ps_page[j])) {
						adapter->alloc_rx_buff_failed++;
4615
						goto no_buffers;
4616
					}
4617 4618 4619 4620 4621 4622 4623
					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 已提交
4624
				 * change because each write-back erases
4625 4626 4627 4628 4629 4630
				 * 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;
4631 4632
		}

4633
		skb = netdev_alloc_skb(netdev,
4634
		                       adapter->rx_ps_bsize0 + NET_IP_ALIGN);
4635

4636 4637
		if (unlikely(!skb)) {
			adapter->alloc_rx_buff_failed++;
4638
			break;
4639
		}
4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654

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

		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 已提交
4655
		if (unlikely(++i == rx_ring->count)) i = 0;
4656 4657 4658 4659 4660 4661
		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:
4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676
	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);
	}
4677 4678
}

L
Linus Torvalds 已提交
4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689
/**
 * 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 已提交
4690
	if ((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
L
Linus Torvalds 已提交
4691 4692 4693
	   !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
		return;

J
Jesse Brandeburg 已提交
4694
	if (adapter->smartspeed == 0) {
L
Linus Torvalds 已提交
4695 4696 4697
		/* 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 已提交
4698
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4699
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4700
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4701
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
J
Jesse Brandeburg 已提交
4702
		if (phy_ctrl & CR_1000T_MS_ENABLE) {
L
Linus Torvalds 已提交
4703 4704 4705 4706
			phy_ctrl &= ~CR_1000T_MS_ENABLE;
			e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
					    phy_ctrl);
			adapter->smartspeed++;
J
Jesse Brandeburg 已提交
4707
			if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4708 4709 4710 4711 4712 4713 4714 4715 4716
			   !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 已提交
4717
	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
L
Linus Torvalds 已提交
4718 4719 4720 4721
		/* 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 已提交
4722
		if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4723 4724 4725 4726 4727 4728 4729
		   !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 已提交
4730
	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
L
Linus Torvalds 已提交
4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763
		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)
{
4764
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4765 4766 4767 4768
	struct mii_ioctl_data *data = if_mii(ifr);
	int retval;
	uint16_t mii_reg;
	uint16_t spddplx;
4769
	unsigned long flags;
L
Linus Torvalds 已提交
4770

J
Jesse Brandeburg 已提交
4771
	if (adapter->hw.media_type != e1000_media_type_copper)
L
Linus Torvalds 已提交
4772 4773 4774 4775 4776 4777 4778
		return -EOPNOTSUPP;

	switch (cmd) {
	case SIOCGMIIPHY:
		data->phy_id = adapter->hw.phy_addr;
		break;
	case SIOCGMIIREG:
J
Jesse Brandeburg 已提交
4779
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4780
			return -EPERM;
4781
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4782
		if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
4783 4784
				   &data->val_out)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4785
			return -EIO;
4786 4787
		}
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4788 4789
		break;
	case SIOCSMIIREG:
J
Jesse Brandeburg 已提交
4790
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4791
			return -EPERM;
J
Jesse Brandeburg 已提交
4792
		if (data->reg_num & ~(0x1F))
L
Linus Torvalds 已提交
4793 4794
			return -EFAULT;
		mii_reg = data->val_in;
4795
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4796
		if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
4797 4798
					mii_reg)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4799
			return -EIO;
4800
		}
4801
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
4802
		if (adapter->hw.media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
4803 4804
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4805
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4806
					break;
J
Jesse Brandeburg 已提交
4807
				if (mii_reg & MII_CR_AUTO_NEG_EN) {
L
Linus Torvalds 已提交
4808 4809 4810 4811 4812 4813 4814 4815 4816 4817
					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)
4818 4819
						   ? DUPLEX_FULL :
						   DUPLEX_HALF;
L
Linus Torvalds 已提交
4820 4821
					retval = e1000_set_spd_dplx(adapter,
								    spddplx);
4822
					if (retval)
L
Linus Torvalds 已提交
4823 4824
						return retval;
				}
4825 4826 4827
				if (netif_running(adapter->netdev))
					e1000_reinit_locked(adapter);
				else
L
Linus Torvalds 已提交
4828 4829 4830 4831
					e1000_reset(adapter);
				break;
			case M88E1000_PHY_SPEC_CTRL:
			case M88E1000_EXT_PHY_SPEC_CTRL:
4832
				if (e1000_phy_reset(&adapter->hw))
L
Linus Torvalds 已提交
4833 4834 4835 4836 4837 4838
					return -EIO;
				break;
			}
		} else {
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4839
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4840
					break;
4841 4842 4843
				if (netif_running(adapter->netdev))
					e1000_reinit_locked(adapter);
				else
L
Linus Torvalds 已提交
4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858
					e1000_reset(adapter);
				break;
			}
		}
		break;
	default:
		return -EOPNOTSUPP;
	}
	return E1000_SUCCESS;
}

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

J
Jesse Brandeburg 已提交
4861
	if (ret_val)
4862
		DPRINTK(PROBE, ERR, "Error in setting MWI\n");
L
Linus Torvalds 已提交
4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888
}

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

4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902
int
e1000_pcix_get_mmrbc(struct e1000_hw *hw)
{
	struct e1000_adapter *adapter = hw->back;
	return pcix_get_mmrbc(adapter->pdev);
}

void
e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
{
	struct e1000_adapter *adapter = hw->back;
	pcix_set_mmrbc(adapter->pdev, mmrbc);
}

4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917
int32_t
e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
{
    struct e1000_adapter *adapter = hw->back;
    uint16_t cap_offset;

    cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
    if (!cap_offset)
        return -E1000_ERR_CONFIG;

    pci_read_config_word(adapter->pdev, cap_offset + reg, value);

    return E1000_SUCCESS;
}

L
Linus Torvalds 已提交
4918 4919 4920 4921 4922 4923 4924 4925 4926
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)
{
4927
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4928 4929 4930 4931 4932
	uint32_t ctrl, rctl;

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

J
Jesse Brandeburg 已提交
4933
	if (grp) {
L
Linus Torvalds 已提交
4934 4935 4936 4937 4938
		/* enable VLAN tag insert/strip */
		ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		ctrl |= E1000_CTRL_VME;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);

4939
		if (adapter->hw.mac_type != e1000_ich8lan) {
4940 4941 4942 4943 4944 4945
			/* 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);
			e1000_update_mng_vlan(adapter);
4946
		}
L
Linus Torvalds 已提交
4947 4948 4949 4950 4951 4952
	} else {
		/* disable VLAN tag insert/strip */
		ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		ctrl &= ~E1000_CTRL_VME;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);

4953
		if (adapter->hw.mac_type != e1000_ich8lan) {
4954 4955 4956 4957 4958 4959 4960 4961 4962 4963
			/* disable VLAN filtering */
			rctl = E1000_READ_REG(&adapter->hw, RCTL);
			rctl &= ~E1000_RCTL_VFE;
			E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
			if (adapter->mng_vlan_id !=
			    (uint16_t)E1000_MNG_VLAN_NONE) {
				e1000_vlan_rx_kill_vid(netdev,
				                       adapter->mng_vlan_id);
				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
			}
4964
		}
L
Linus Torvalds 已提交
4965 4966 4967 4968 4969 4970 4971 4972
	}

	e1000_irq_enable(adapter);
}

static void
e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
{
4973
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4974
	uint32_t vfta, index;
J
Jesse Brandeburg 已提交
4975 4976 4977 4978

	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
	    (vid == adapter->mng_vlan_id))
4979
		return;
L
Linus Torvalds 已提交
4980 4981 4982 4983 4984 4985 4986 4987 4988 4989
	/* 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)
{
4990
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4991 4992 4993
	uint32_t vfta, index;

	e1000_irq_disable(adapter);
D
Dan Aloni 已提交
4994
	vlan_group_set_device(adapter->vlgrp, vid, NULL);
L
Linus Torvalds 已提交
4995 4996
	e1000_irq_enable(adapter);

J
Jesse Brandeburg 已提交
4997 4998
	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
J
Jeff Kirsher 已提交
4999 5000 5001
	    (vid == adapter->mng_vlan_id)) {
		/* release control to f/w */
		e1000_release_hw_control(adapter);
5002
		return;
J
Jeff Kirsher 已提交
5003 5004
	}

L
Linus Torvalds 已提交
5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016
	/* 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 已提交
5017
	if (adapter->vlgrp) {
L
Linus Torvalds 已提交
5018
		uint16_t vid;
J
Jesse Brandeburg 已提交
5019
		for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
D
Dan Aloni 已提交
5020
			if (!vlan_group_get_device(adapter->vlgrp, vid))
L
Linus Torvalds 已提交
5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031
				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;

5032
	/* Fiber NICs only allow 1000 gbps Full duplex */
J
Jesse Brandeburg 已提交
5033
	if ((adapter->hw.media_type == e1000_media_type_fiber) &&
5034 5035 5036 5037 5038
		spddplx != (SPEED_1000 + DUPLEX_FULL)) {
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
		return -EINVAL;
	}

J
Jesse Brandeburg 已提交
5039
	switch (spddplx) {
L
Linus Torvalds 已提交
5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057
	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:
5058
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
L
Linus Torvalds 已提交
5059 5060 5061 5062 5063 5064
		return -EINVAL;
	}
	return 0;
}

static int
5065
e1000_suspend(struct pci_dev *pdev, pm_message_t state)
L
Linus Torvalds 已提交
5066 5067
{
	struct net_device *netdev = pci_get_drvdata(pdev);
5068
	struct e1000_adapter *adapter = netdev_priv(netdev);
5069
	uint32_t ctrl, ctrl_ext, rctl, status;
L
Linus Torvalds 已提交
5070
	uint32_t wufc = adapter->wol;
A
Auke Kok 已提交
5071
#ifdef CONFIG_PM
5072
	int retval = 0;
A
Auke Kok 已提交
5073
#endif
L
Linus Torvalds 已提交
5074 5075 5076

	netif_device_detach(netdev);

5077 5078
	if (netif_running(netdev)) {
		WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
L
Linus Torvalds 已提交
5079
		e1000_down(adapter);
5080
	}
L
Linus Torvalds 已提交
5081

5082
#ifdef CONFIG_PM
5083
	retval = pci_save_state(pdev);
5084 5085 5086 5087
	if (retval)
		return retval;
#endif

L
Linus Torvalds 已提交
5088
	status = E1000_READ_REG(&adapter->hw, STATUS);
J
Jesse Brandeburg 已提交
5089
	if (status & E1000_STATUS_LU)
L
Linus Torvalds 已提交
5090 5091
		wufc &= ~E1000_WUFC_LNKC;

J
Jesse Brandeburg 已提交
5092
	if (wufc) {
L
Linus Torvalds 已提交
5093 5094 5095 5096
		e1000_setup_rctl(adapter);
		e1000_set_multi(netdev);

		/* turn on all-multi mode if wake on multicast is enabled */
5097
		if (wufc & E1000_WUFC_MC) {
L
Linus Torvalds 已提交
5098 5099 5100 5101 5102
			rctl = E1000_READ_REG(&adapter->hw, RCTL);
			rctl |= E1000_RCTL_MPE;
			E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
		}

J
Jesse Brandeburg 已提交
5103
		if (adapter->hw.mac_type >= e1000_82540) {
L
Linus Torvalds 已提交
5104 5105 5106 5107 5108 5109 5110 5111 5112 5113
			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 已提交
5114
		if (adapter->hw.media_type == e1000_media_type_fiber ||
L
Linus Torvalds 已提交
5115 5116 5117 5118 5119 5120 5121
		   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);
		}

5122 5123 5124
		/* Allow time for pending master requests to run */
		e1000_disable_pciex_master(&adapter->hw);

L
Linus Torvalds 已提交
5125 5126
		E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
		E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
5127 5128
		pci_enable_wake(pdev, PCI_D3hot, 1);
		pci_enable_wake(pdev, PCI_D3cold, 1);
L
Linus Torvalds 已提交
5129 5130 5131
	} else {
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
		E1000_WRITE_REG(&adapter->hw, WUFC, 0);
5132 5133
		pci_enable_wake(pdev, PCI_D3hot, 0);
		pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
5134 5135
	}

5136 5137 5138 5139 5140 5141
	e1000_release_manageability(adapter);

	/* make sure adapter isn't asleep if manageability is enabled */
	if (adapter->en_mng_pt) {
		pci_enable_wake(pdev, PCI_D3hot, 1);
		pci_enable_wake(pdev, PCI_D3cold, 1);
L
Linus Torvalds 已提交
5142 5143
	}

5144 5145 5146
	if (adapter->hw.phy_type == e1000_phy_igp_3)
		e1000_phy_powerdown_workaround(&adapter->hw);

5147 5148 5149
	if (netif_running(netdev))
		e1000_free_irq(adapter);

5150 5151 5152
	/* 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);
5153

L
Linus Torvalds 已提交
5154
	pci_disable_device(pdev);
5155

5156
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
L
Linus Torvalds 已提交
5157 5158 5159 5160

	return 0;
}

5161
#ifdef CONFIG_PM
L
Linus Torvalds 已提交
5162 5163 5164 5165
static int
e1000_resume(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
5166
	struct e1000_adapter *adapter = netdev_priv(netdev);
5167
	uint32_t err;
L
Linus Torvalds 已提交
5168

5169
	pci_set_power_state(pdev, PCI_D0);
5170
	pci_restore_state(pdev);
5171 5172 5173 5174
	if ((err = pci_enable_device(pdev))) {
		printk(KERN_ERR "e1000: Cannot enable PCI device from suspend\n");
		return err;
	}
5175
	pci_set_master(pdev);
L
Linus Torvalds 已提交
5176

5177 5178
	pci_enable_wake(pdev, PCI_D3hot, 0);
	pci_enable_wake(pdev, PCI_D3cold, 0);
L
Linus Torvalds 已提交
5179

5180 5181 5182 5183
	if (netif_running(netdev) && (err = e1000_request_irq(adapter)))
		return err;

	e1000_power_up_phy(adapter);
L
Linus Torvalds 已提交
5184 5185 5186
	e1000_reset(adapter);
	E1000_WRITE_REG(&adapter->hw, WUS, ~0);

5187 5188
	e1000_init_manageability(adapter);

J
Jesse Brandeburg 已提交
5189
	if (netif_running(netdev))
L
Linus Torvalds 已提交
5190 5191 5192 5193
		e1000_up(adapter);

	netif_device_attach(netdev);

5194 5195 5196 5197 5198 5199 5200
	/* 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);
5201

L
Linus Torvalds 已提交
5202 5203 5204
	return 0;
}
#endif
5205 5206 5207 5208 5209 5210

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

L
Linus Torvalds 已提交
5211 5212 5213 5214 5215 5216 5217
#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
5218
e1000_netpoll(struct net_device *netdev)
L
Linus Torvalds 已提交
5219
{
5220
	struct e1000_adapter *adapter = netdev_priv(netdev);
5221

L
Linus Torvalds 已提交
5222
	disable_irq(adapter->pdev->irq);
5223
	e1000_intr(adapter->pdev->irq, netdev);
A
Andrew Morton 已提交
5224
	e1000_clean_tx_irq(adapter, adapter->tx_ring);
J
Jeff Kirsher 已提交
5225 5226 5227
#ifndef CONFIG_E1000_NAPI
	adapter->clean_rx(adapter, adapter->rx_ring);
#endif
L
Linus Torvalds 已提交
5228 5229 5230 5231
	enable_irq(adapter->pdev->irq);
}
#endif

A
Auke Kok 已提交
5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248
/**
 * e1000_io_error_detected - called when PCI error is detected
 * @pdev: Pointer to PCI device
 * @state: The current pci conneection state
 *
 * This function is called after a PCI bus error affecting
 * this device has been detected.
 */
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev->priv;

	netif_device_detach(netdev);

	if (netif_running(netdev))
		e1000_down(adapter);
5249
	pci_disable_device(pdev);
A
Auke Kok 已提交
5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272

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

/**
 * e1000_io_slot_reset - called after the pci bus has been reset.
 * @pdev: Pointer to PCI device
 *
 * Restart the card from scratch, as if from a cold-boot. Implementation
 * resembles the first-half of the e1000_resume routine.
 */
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
	struct e1000_adapter *adapter = netdev->priv;

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

5273 5274
	pci_enable_wake(pdev, PCI_D3hot, 0);
	pci_enable_wake(pdev, PCI_D3cold, 0);
A
Auke Kok 已提交
5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293

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

	return PCI_ERS_RESULT_RECOVERED;
}

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

	e1000_init_manageability(adapter);
A
Auke Kok 已提交
5296 5297 5298 5299 5300 5301 5302 5303 5304 5305

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

	netif_device_attach(netdev);

5306 5307 5308 5309 5310 5311 5312
	/* 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);
A
Auke Kok 已提交
5313 5314 5315

}

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