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

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

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

#include "e1000.h"

/* Change Log
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
 * 6.3.9	12/16/2005
 *   o incorporate fix for recycled skbs from IBM LTC
 * 6.3.7	11/18/2005
 *   o Honor eeprom setting for enabling/disabling Wake On Lan
 * 6.3.5 	11/17/2005
 *   o Fix memory leak in rx ring handling for PCI Express adapters
 * 6.3.4	11/8/05
 *   o Patch from Jesper Juhl to remove redundant NULL checks for kfree
 * 6.3.2	9/20/05
 *   o Render logic that sets/resets DRV_LOAD as inline functions to 
 *     avoid code replication. If f/w is AMT then set DRV_LOAD only when
 *     network interface is open.
 *   o Handle DRV_LOAD set/reset in cases where AMT uses VLANs.
 *   o Adjust PBA partioning for Jumbo frames using MTU size and not
 *     rx_buffer_len
 * 6.3.1	9/19/05
 *   o Use adapter->tx_timeout_factor in Tx Hung Detect logic 
       (e1000_clean_tx_irq)
 *   o Support for 8086:10B5 device (Quad Port)
 * 6.2.14	9/15/05
 *   o In AMT enabled configurations, set/reset DRV_LOAD bit on interface 
 *     open/close 
 * 6.2.13       9/14/05
 *   o Invoke e1000_check_mng_mode only for 8257x controllers since it 
 *     accesses the FWSM that is not supported in other controllers
 * 6.2.12       9/9/05
 *   o Add support for device id E1000_DEV_ID_82546GB_QUAD_COPPER
 *   o set RCTL:SECRC only for controllers newer than 82543. 
 *   o When the n/w interface comes down reset DRV_LOAD bit to notify f/w.
 *     This code was moved from e1000_remove to e1000_close
 * 6.2.10       9/6/05
 *   o Fix error in updating RDT in el1000_alloc_rx_buffers[_ps] -- one off.
 *   o Enable fc by default on 82573 controllers (do not read eeprom)
 *   o Fix rx_errors statistic not to include missed_packet_count
 *   o Fix rx_dropped statistic not to include missed_packet_count 
       (Padraig Brady)
 * 6.2.9        8/30/05
 *   o Remove call to update statistics from the controller ib e1000_get_stats
 * 6.2.8        8/30/05
 *   o Improved algorithm for rx buffer allocation/rdt update
 *   o Flow control watermarks relative to rx PBA size
 *   o Simplified 'Tx Hung' detect logic
 * 6.2.7 	8/17/05
 *   o Report rx buffer allocation failures and tx timeout counts in stats
 * 6.2.6 	8/16/05
 *   o Implement workaround for controller erratum -- linear non-tso packet
 *     following a TSO gets written back prematurely
 * 6.2.5	8/15/05
 *   o Set netdev->tx_queue_len based on link speed/duplex settings.
 *   o Fix net_stats.rx_fifo_errors <p@draigBrady.com>
 *   o Do not power off PHY if SoL/IDER session is active
 * 6.2.4	8/10/05
 *   o Fix loopback test setup/cleanup for 82571/3 controllers
 *   o Fix parsing of outgoing packets (e1000_transfer_dhcp_info) to treat
 *     all packets as raw
 *   o Prevent operations that will cause the PHY to be reset if SoL/IDER
 *     sessions are active and log a message
 * 6.2.2	7/21/05
 *   o used fixed size descriptors for all MTU sizes, reduces memory load
 * 6.1.2	4/13/05
 *   o Fixed ethtool diagnostics
 *   o Enabled flow control to take default eeprom settings
 *   o Added stats_lock around e1000_read_phy_reg commands to avoid concurrent
 *     calls, one from mii_ioctl and other from within update_stats while 
 *     processing MIIREG ioctl.
L
Linus Torvalds 已提交
97 98 99
 */

char e1000_driver_name[] = "e1000";
100
static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
L
Linus Torvalds 已提交
101 102 103 104 105
#ifndef CONFIG_E1000_NAPI
#define DRIVERNAPI
#else
#define DRIVERNAPI "-NAPI"
#endif
106
#define DRV_VERSION "6.3.9-k4"DRIVERNAPI
L
Linus Torvalds 已提交
107
char e1000_driver_version[] = DRV_VERSION;
108
static char e1000_copyright[] = "Copyright (c) 1999-2005 Intel Corporation.";
L
Linus Torvalds 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136

/* 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),
137
	INTEL_E1000_ETHERNET_DEVICE(0x101A),
L
Linus Torvalds 已提交
138 139 140 141 142
	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),
143 144 145
	INTEL_E1000_ETHERNET_DEVICE(0x105E),
	INTEL_E1000_ETHERNET_DEVICE(0x105F),
	INTEL_E1000_ETHERNET_DEVICE(0x1060),
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153
	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),
154 155 156
	INTEL_E1000_ETHERNET_DEVICE(0x107D),
	INTEL_E1000_ETHERNET_DEVICE(0x107E),
	INTEL_E1000_ETHERNET_DEVICE(0x107F),
L
Linus Torvalds 已提交
157
	INTEL_E1000_ETHERNET_DEVICE(0x108A),
158 159
	INTEL_E1000_ETHERNET_DEVICE(0x108B),
	INTEL_E1000_ETHERNET_DEVICE(0x108C),
160
	INTEL_E1000_ETHERNET_DEVICE(0x1099),
161
	INTEL_E1000_ETHERNET_DEVICE(0x109A),
162
	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170 171 172
	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);

int e1000_up(struct e1000_adapter *adapter);
void e1000_down(struct e1000_adapter *adapter);
void e1000_reset(struct e1000_adapter *adapter);
int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
173 174 175 176
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);
177 178 179 180 181 182 183 184
static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
				    struct e1000_tx_ring *txdr);
static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
				    struct e1000_rx_ring *rxdr);
static void e1000_free_tx_resources(struct e1000_adapter *adapter,
				    struct e1000_tx_ring *tx_ring);
static void e1000_free_rx_resources(struct e1000_adapter *adapter,
				    struct e1000_rx_ring *rx_ring);
L
Linus Torvalds 已提交
185 186 187 188 189 190 191 192
void e1000_update_stats(struct e1000_adapter *adapter);

/* Local Function Prototypes */

static int e1000_init_module(void);
static void e1000_exit_module(void);
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
static void __devexit e1000_remove(struct pci_dev *pdev);
193 194 195 196
static int e1000_alloc_queues(struct e1000_adapter *adapter);
#ifdef CONFIG_E1000_MQ
static void e1000_setup_queue_mapping(struct e1000_adapter *adapter);
#endif
L
Linus Torvalds 已提交
197 198 199 200 201 202
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);
203 204 205 206 207 208
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 已提交
209 210 211 212 213 214 215 216 217 218
static void e1000_set_multi(struct net_device *netdev);
static void e1000_update_phy_info(unsigned long data);
static void e1000_watchdog(unsigned long data);
static void e1000_watchdog_task(struct e1000_adapter *adapter);
static void e1000_82547_tx_fifo_stall(unsigned long data);
static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
static int e1000_set_mac(struct net_device *netdev, void *p);
static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
219 220
static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,
                                    struct e1000_tx_ring *tx_ring);
L
Linus Torvalds 已提交
221
#ifdef CONFIG_E1000_NAPI
222
static int e1000_clean(struct net_device *poll_dev, int *budget);
L
Linus Torvalds 已提交
223
static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
224
                                    struct e1000_rx_ring *rx_ring,
L
Linus Torvalds 已提交
225
                                    int *work_done, int work_to_do);
226
static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
227
                                       struct e1000_rx_ring *rx_ring,
228
                                       int *work_done, int work_to_do);
L
Linus Torvalds 已提交
229
#else
230 231 232 233
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 已提交
234
#endif
235
static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
236 237
                                   struct e1000_rx_ring *rx_ring,
				   int cleaned_count);
238
static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
239 240
                                      struct e1000_rx_ring *rx_ring,
				      int cleaned_count);
L
Linus Torvalds 已提交
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
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);
void e1000_set_ethtool_ops(struct net_device *netdev);
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);
static void e1000_tx_timeout_task(struct net_device *dev);
static void e1000_smartspeed(struct e1000_adapter *adapter);
static inline int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
					      struct sk_buff *skb);

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

#ifdef CONFIG_PM
259
static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
L
Linus Torvalds 已提交
260 261 262 263 264 265 266 267
static int e1000_resume(struct pci_dev *pdev);
#endif

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

268 269 270 271 272
#ifdef CONFIG_E1000_MQ
/* for multiple Rx queues */
void e1000_rx_schedule(void *data);
#endif

L
Linus Torvalds 已提交
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
/* Exported from other modules */

extern void e1000_check_options(struct e1000_adapter *adapter);

static struct pci_driver e1000_driver = {
	.name     = e1000_driver_name,
	.id_table = e1000_pci_tbl,
	.probe    = e1000_probe,
	.remove   = __devexit_p(e1000_remove),
	/* Power Managment Hooks */
#ifdef CONFIG_PM
	.suspend  = e1000_suspend,
	.resume   = e1000_resume
#endif
};

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

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

/**
 * e1000_init_module - Driver Registration Routine
 *
 * e1000_init_module is the first routine called when the driver is
 * loaded. All it does is register with the PCI subsystem.
 **/

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

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

	ret = pci_module_init(&e1000_driver);
315

L
Linus Torvalds 已提交
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
	return ret;
}

module_init(e1000_init_module);

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

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

module_exit(e1000_exit_module);

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

static inline void
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
 **/

static inline void
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 371 372
	if (adapter->vlgrp) {
		if (!adapter->vlgrp->vlan_devices[vid]) {
			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) &&
381 382 383 384 385
					!adapter->vlgrp->vlan_devices[old_vid])
				e1000_vlan_rx_kill_vid(netdev, old_vid);
		}
	}
}
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454

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

static inline void 
e1000_release_hw_control(struct e1000_adapter *adapter)
{
	uint32_t ctrl_ext;
	uint32_t swsm;

	/* Let firmware taken over control of h/w */
	switch (adapter->hw.mac_type) {
	case e1000_82571:
	case e1000_82572:
		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
		break;
	case e1000_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm & ~E1000_SWSM_DRV_LOAD);
	default:
		break;
	}
}

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

static inline void 
e1000_get_hw_control(struct e1000_adapter *adapter)
{
	uint32_t ctrl_ext;
	uint32_t swsm;
	/* Let firmware know the driver has taken over */
	switch (adapter->hw.mac_type) {
	case e1000_82571:
	case e1000_82572:
		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
		break;
	case e1000_82573:
		swsm = E1000_READ_REG(&adapter->hw, SWSM);
		E1000_WRITE_REG(&adapter->hw, SWSM,
				swsm | E1000_SWSM_DRV_LOAD);
		break;
	default:
		break;
	}
}

L
Linus Torvalds 已提交
455 456 457 458
int
e1000_up(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
459
	int i, err;
L
Linus Torvalds 已提交
460 461 462 463

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

	/* Reset the PHY if it was previously powered down */
J
Jesse Brandeburg 已提交
464
	if (adapter->hw.media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
465 466
		uint16_t mii_reg;
		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
J
Jesse Brandeburg 已提交
467
		if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
468 469 470 471 472 473 474 475 476 477
			e1000_phy_reset(&adapter->hw);
	}

	e1000_set_multi(netdev);

	e1000_restore_vlan(adapter);

	e1000_configure_tx(adapter);
	e1000_setup_rctl(adapter);
	e1000_configure_rx(adapter);
478 479 480
	/* call E1000_DESC_UNUSED which always leaves
	 * at least 1 descriptor unused to make sure
	 * next_to_use != next_to_clean */
481
	for (i = 0; i < adapter->num_rx_queues; i++) {
482
		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
483 484
		adapter->alloc_rx_buf(adapter, ring,
		                      E1000_DESC_UNUSED(ring));
485
	}
L
Linus Torvalds 已提交
486

487
#ifdef CONFIG_PCI_MSI
J
Jesse Brandeburg 已提交
488
	if (adapter->hw.mac_type > e1000_82547_rev_2) {
489
		adapter->have_msi = TRUE;
J
Jesse Brandeburg 已提交
490
		if ((err = pci_enable_msi(adapter->pdev))) {
491 492 493 494 495 496
			DPRINTK(PROBE, ERR,
			 "Unable to allocate MSI interrupt Error: %d\n", err);
			adapter->have_msi = FALSE;
		}
	}
#endif
J
Jesse Brandeburg 已提交
497
	if ((err = request_irq(adapter->pdev->irq, &e1000_intr,
L
Linus Torvalds 已提交
498
		              SA_SHIRQ | SA_SAMPLE_RANDOM,
499 500 501
		              netdev->name, netdev))) {
		DPRINTK(PROBE, ERR,
		    "Unable to allocate interrupt Error: %d\n", err);
L
Linus Torvalds 已提交
502
		return err;
503
	}
L
Linus Torvalds 已提交
504

505 506 507 508 509 510
#ifdef CONFIG_E1000_MQ
	e1000_setup_queue_mapping(adapter);
#endif

	adapter->tx_queue_len = netdev->tx_queue_len;

L
Linus Torvalds 已提交
511 512 513 514 515
	mod_timer(&adapter->watchdog_timer, jiffies);

#ifdef CONFIG_E1000_NAPI
	netif_poll_enable(netdev);
#endif
516 517
	e1000_irq_enable(adapter);

L
Linus Torvalds 已提交
518 519 520 521 522 523 524
	return 0;
}

void
e1000_down(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
525 526
	boolean_t mng_mode_enabled = (adapter->hw.mac_type >= e1000_82571) &&
				     e1000_check_mng_mode(&adapter->hw);
L
Linus Torvalds 已提交
527 528

	e1000_irq_disable(adapter);
529 530 531
#ifdef CONFIG_E1000_MQ
	while (atomic_read(&adapter->rx_sched_call_data.count) != 0);
#endif
L
Linus Torvalds 已提交
532
	free_irq(adapter->pdev->irq, netdev);
533
#ifdef CONFIG_PCI_MSI
J
Jesse Brandeburg 已提交
534
	if (adapter->hw.mac_type > e1000_82547_rev_2 &&
535 536 537
	   adapter->have_msi == TRUE)
		pci_disable_msi(adapter->pdev);
#endif
L
Linus Torvalds 已提交
538 539 540 541 542 543 544
	del_timer_sync(&adapter->tx_fifo_stall_timer);
	del_timer_sync(&adapter->watchdog_timer);
	del_timer_sync(&adapter->phy_info_timer);

#ifdef CONFIG_E1000_NAPI
	netif_poll_disable(netdev);
#endif
545
	netdev->tx_queue_len = adapter->tx_queue_len;
L
Linus Torvalds 已提交
546 547 548 549 550 551
	adapter->link_speed = 0;
	adapter->link_duplex = 0;
	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	e1000_reset(adapter);
552 553
	e1000_clean_all_tx_rings(adapter);
	e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
554

555 556 557 558 559 560
	/* Power down the PHY so no link is implied when interface is down *
	 * The PHY cannot be powered down if any of the following is TRUE *
	 * (a) WoL is enabled
	 * (b) AMT is active
	 * (c) SoL/IDER session is active */
	if (!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&
561
	   adapter->hw.media_type == e1000_media_type_copper &&
562 563 564
	   !(E1000_READ_REG(&adapter->hw, MANC) & E1000_MANC_SMBUS_EN) &&
	   !mng_mode_enabled &&
	   !e1000_check_phy_reset_block(&adapter->hw)) {
L
Linus Torvalds 已提交
565 566 567 568
		uint16_t mii_reg;
		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
		mii_reg |= MII_CR_POWER_DOWN;
		e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);
569
		mdelay(1);
L
Linus Torvalds 已提交
570 571 572 573 574 575
	}
}

void
e1000_reset(struct e1000_adapter *adapter)
{
576
	uint32_t pba, manc;
577
	uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
L
Linus Torvalds 已提交
578 579 580 581 582

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

583 584
	switch (adapter->hw.mac_type) {
	case e1000_82547:
585
	case e1000_82547_rev_2:
586 587
		pba = E1000_PBA_30K;
		break;
588 589 590 591
	case e1000_82571:
	case e1000_82572:
		pba = E1000_PBA_38K;
		break;
592 593 594 595 596 597 598 599
	case e1000_82573:
		pba = E1000_PBA_12K;
		break;
	default:
		pba = E1000_PBA_48K;
		break;
	}

J
Jesse Brandeburg 已提交
600
	if ((adapter->hw.mac_type != e1000_82573) &&
601
	   (adapter->netdev->mtu > E1000_RXBUFFER_8192))
602
		pba -= 8; /* allocate more FIFO for Tx */
603 604


J
Jesse Brandeburg 已提交
605
	if (adapter->hw.mac_type == e1000_82547) {
L
Linus Torvalds 已提交
606 607 608 609 610 611
		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);
	}
612

L
Linus Torvalds 已提交
613 614 615
	E1000_WRITE_REG(&adapter->hw, PBA, pba);

	/* flow control settings */
616 617 618 619 620 621
	/* Set the FC high water mark to 90% of the FIFO size.
	 * Required to clear last 3 LSB */
	fc_high_water_mark = ((pba * 9216)/10) & 0xFFF8;

	adapter->hw.fc_high_water = fc_high_water_mark;
	adapter->hw.fc_low_water = fc_high_water_mark - 8;
L
Linus Torvalds 已提交
622 623 624 625
	adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
	adapter->hw.fc_send_xon = 1;
	adapter->hw.fc = adapter->hw.original_fc;

626
	/* Allow time for pending master requests to run */
L
Linus Torvalds 已提交
627
	e1000_reset_hw(&adapter->hw);
J
Jesse Brandeburg 已提交
628
	if (adapter->hw.mac_type >= e1000_82544)
L
Linus Torvalds 已提交
629
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
J
Jesse Brandeburg 已提交
630
	if (e1000_init_hw(&adapter->hw))
L
Linus Torvalds 已提交
631
		DPRINTK(PROBE, ERR, "Hardware Error\n");
632
	e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
633 634 635 636 637
	/* 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);
638 639 640 641 642
	if (adapter->en_mng_pt) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
		manc |= (E1000_MANC_ARP_EN | E1000_MANC_EN_MNG2HOST);
		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}
L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
}

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

L
Linus Torvalds 已提交
665
	static int cards_found = 0;
666
	int i, err, pci_using_dac;
L
Linus Torvalds 已提交
667 668
	uint16_t eeprom_data;
	uint16_t eeprom_apme_mask = E1000_EEPROM_APME;
J
Jesse Brandeburg 已提交
669
	if ((err = pci_enable_device(pdev)))
L
Linus Torvalds 已提交
670 671
		return err;

J
Jesse Brandeburg 已提交
672
	if (!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
L
Linus Torvalds 已提交
673 674
		pci_using_dac = 1;
	} else {
J
Jesse Brandeburg 已提交
675
		if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
L
Linus Torvalds 已提交
676 677 678 679 680 681
			E1000_ERR("No usable DMA configuration, aborting\n");
			return err;
		}
		pci_using_dac = 0;
	}

J
Jesse Brandeburg 已提交
682
	if ((err = pci_request_regions(pdev, e1000_driver_name)))
L
Linus Torvalds 已提交
683 684 685 686 687
		return err;

	pci_set_master(pdev);

	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
J
Jesse Brandeburg 已提交
688
	if (!netdev) {
L
Linus Torvalds 已提交
689 690 691 692 693 694 695 696
		err = -ENOMEM;
		goto err_alloc_etherdev;
	}

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

	pci_set_drvdata(pdev, netdev);
697
	adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
698 699 700 701 702 703 704 705 706
	adapter->netdev = netdev;
	adapter->pdev = pdev;
	adapter->hw.back = adapter;
	adapter->msg_enable = (1 << debug) - 1;

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

	adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
J
Jesse Brandeburg 已提交
707
	if (!adapter->hw.hw_addr) {
L
Linus Torvalds 已提交
708 709 710 711
		err = -EIO;
		goto err_ioremap;
	}

J
Jesse Brandeburg 已提交
712 713
	for (i = BAR_1; i <= BAR_5; i++) {
		if (pci_resource_len(pdev, i) == 0)
L
Linus Torvalds 已提交
714
			continue;
J
Jesse Brandeburg 已提交
715
		if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
L
Linus Torvalds 已提交
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 743 744 745 746 747 748 749 750 751
			adapter->hw.io_base = pci_resource_start(pdev, i);
			break;
		}
	}

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

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

	adapter->bd_number = cards_found;

	/* setup the private structure */

J
Jesse Brandeburg 已提交
752
	if ((err = e1000_sw_init(adapter)))
L
Linus Torvalds 已提交
753 754
		goto err_sw_init;

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

J
Jesse Brandeburg 已提交
758
	if (adapter->hw.mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766
		netdev->features = NETIF_F_SG |
				   NETIF_F_HW_CSUM |
				   NETIF_F_HW_VLAN_TX |
				   NETIF_F_HW_VLAN_RX |
				   NETIF_F_HW_VLAN_FILTER;
	}

#ifdef NETIF_F_TSO
J
Jesse Brandeburg 已提交
767
	if ((adapter->hw.mac_type >= e1000_82544) &&
L
Linus Torvalds 已提交
768 769
	   (adapter->hw.mac_type != e1000_82547))
		netdev->features |= NETIF_F_TSO;
770 771

#ifdef NETIF_F_TSO_IPV6
J
Jesse Brandeburg 已提交
772
	if (adapter->hw.mac_type > e1000_82547_rev_2)
773 774
		netdev->features |= NETIF_F_TSO_IPV6;
#endif
L
Linus Torvalds 已提交
775
#endif
J
Jesse Brandeburg 已提交
776
	if (pci_using_dac)
L
Linus Torvalds 已提交
777 778 779 780 781
		netdev->features |= NETIF_F_HIGHDMA;

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

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

L
Linus Torvalds 已提交
787 788 789 790
	e1000_reset_hw(&adapter->hw);

	/* make sure the EEPROM is good */

J
Jesse Brandeburg 已提交
791
	if (e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
L
Linus Torvalds 已提交
792 793 794 795 796 797 798
		DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
		err = -EIO;
		goto err_eeprom;
	}

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

J
Jesse Brandeburg 已提交
799
	if (e1000_read_mac_addr(&adapter->hw))
L
Linus Torvalds 已提交
800 801
		DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
	memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
802
	memcpy(netdev->perm_addr, adapter->hw.mac_addr, netdev->addr_len);
L
Linus Torvalds 已提交
803

J
Jesse Brandeburg 已提交
804
	if (!is_valid_ether_addr(netdev->perm_addr)) {
L
Linus Torvalds 已提交
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
		DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
		err = -EIO;
		goto err_eeprom;
	}

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

	e1000_get_bus_info(&adapter->hw);

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

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

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

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

	INIT_WORK(&adapter->tx_timeout_task,
		(void (*)(void *))e1000_tx_timeout_task, netdev);

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

	netif_carrier_off(netdev);
	netif_stop_queue(netdev);

	e1000_check_options(adapter);

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

J
Jesse Brandeburg 已提交
844
	switch (adapter->hw.mac_type) {
L
Linus Torvalds 已提交
845 846 847 848 849 850 851 852 853 854 855
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
	case e1000_82543:
		break;
	case e1000_82544:
		e1000_read_eeprom(&adapter->hw,
			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
		eeprom_apme_mask = E1000_EEPROM_82544_APM;
		break;
	case e1000_82546:
	case e1000_82546_rev_3:
J
Jeff Kirsher 已提交
856
	case e1000_82571:
J
Jesse Brandeburg 已提交
857
		if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1){
L
Linus Torvalds 已提交
858 859 860 861 862 863 864 865 866 867
			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 已提交
868
	if (eeprom_data & eeprom_apme_mask)
L
Linus Torvalds 已提交
869 870
		adapter->wol |= E1000_WUFC_MAG;

871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
	/* print bus type/speed/width info */
	{
	struct e1000_hw *hw = &adapter->hw;
	DPRINTK(PROBE, INFO, "(PCI%s:%s:%s) ",
		((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
		 (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
		((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
		 (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
		 (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
		 (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
		 (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
		((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
		 (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
		 (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
		 "32-bit"));
	}

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

L
Linus Torvalds 已提交
891 892 893
	/* reset the hardware with the new settings */
	e1000_reset(adapter);

894 895 896 897 898 899 900
	/* 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);
901

L
Linus Torvalds 已提交
902
	strcpy(netdev->name, "eth%d");
J
Jesse Brandeburg 已提交
903
	if ((err = register_netdev(netdev)))
L
Linus Torvalds 已提交
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
		goto err_register;

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

	cards_found++;
	return 0;

err_register:
err_sw_init:
err_eeprom:
	iounmap(adapter->hw.hw_addr);
err_ioremap:
	free_netdev(netdev);
err_alloc_etherdev:
	pci_release_regions(pdev);
	return err;
}

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

static void __devexit
e1000_remove(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
936
	struct e1000_adapter *adapter = netdev_priv(netdev);
937
	uint32_t manc;
938 939 940
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
941

J
Jeff Garzik 已提交
942 943
	flush_scheduled_work();

J
Jesse Brandeburg 已提交
944
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
945 946
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
J
Jesse Brandeburg 已提交
947
		if (manc & E1000_MANC_SMBUS_EN) {
L
Linus Torvalds 已提交
948 949 950 951 952
			manc |= E1000_MANC_ARP_EN;
			E1000_WRITE_REG(&adapter->hw, MANC, manc);
		}
	}

953 954 955
	/* 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);
956

L
Linus Torvalds 已提交
957
	unregister_netdev(netdev);
958
#ifdef CONFIG_E1000_NAPI
959
	for (i = 0; i < adapter->num_rx_queues; i++)
960 961
		__dev_put(&adapter->polling_netdev[i]);
#endif
L
Linus Torvalds 已提交
962

J
Jesse Brandeburg 已提交
963
	if (!e1000_check_phy_reset_block(&adapter->hw))
964
		e1000_phy_hw_reset(&adapter->hw);
L
Linus Torvalds 已提交
965

966 967 968 969 970 971
	kfree(adapter->tx_ring);
	kfree(adapter->rx_ring);
#ifdef CONFIG_E1000_NAPI
	kfree(adapter->polling_netdev);
#endif

L
Linus Torvalds 已提交
972 973 974
	iounmap(adapter->hw.hw_addr);
	pci_release_regions(pdev);

975 976 977 978
#ifdef CONFIG_E1000_MQ
	free_percpu(adapter->cpu_netdev);
	free_percpu(adapter->cpu_tx_ring);
#endif
L
Linus Torvalds 已提交
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
	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;
999 1000 1001
#ifdef CONFIG_E1000_NAPI
	int i;
#endif
L
Linus Torvalds 已提交
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014

	/* PCI config space info */

	hw->vendor_id = pdev->vendor;
	hw->device_id = pdev->device;
	hw->subsystem_vendor_id = pdev->subsystem_vendor;
	hw->subsystem_id = pdev->subsystem_device;

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

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

	adapter->rx_buffer_len = E1000_RXBUFFER_2048;
1015
	adapter->rx_ps_bsize0 = E1000_RXBUFFER_256;
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020 1021
	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 已提交
1022
	if (e1000_set_mac_type(hw)) {
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028
		DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
		return -EIO;
	}

	/* initialize eeprom parameters */

J
Jesse Brandeburg 已提交
1029
	if (e1000_init_eeprom_params(hw)) {
1030 1031 1032
		E1000_ERR("EEPROM initialization failed\n");
		return -EIO;
	}
L
Linus Torvalds 已提交
1033

J
Jesse Brandeburg 已提交
1034
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
	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 已提交
1053
	if (hw->media_type == e1000_media_type_copper) {
L
Linus Torvalds 已提交
1054 1055 1056 1057 1058
		hw->mdix = AUTO_ALL_MODES;
		hw->disable_polarity_correction = FALSE;
		hw->master_slave = E1000_MASTER_SLAVE;
	}

1059 1060 1061 1062 1063
#ifdef CONFIG_E1000_MQ
	/* Number of supported queues */
	switch (hw->mac_type) {
	case e1000_82571:
	case e1000_82572:
1064 1065 1066 1067 1068 1069 1070 1071
		/* These controllers support 2 tx queues, but with a single
		 * qdisc implementation, multiple tx queues aren't quite as
		 * interesting.  If we can find a logical way of mapping
		 * flows to a queue, then perhaps we can up the num_tx_queue
		 * count back to its default.  Until then, we run the risk of
		 * terrible performance due to SACK overload. */
		adapter->num_tx_queues = 1;
		adapter->num_rx_queues = 2;
1072 1073
		break;
	default:
1074 1075
		adapter->num_tx_queues = 1;
		adapter->num_rx_queues = 1;
1076 1077
		break;
	}
1078 1079
	adapter->num_rx_queues = min(adapter->num_rx_queues, num_online_cpus());
	adapter->num_tx_queues = min(adapter->num_tx_queues, num_online_cpus());
1080 1081 1082 1083 1084 1085 1086 1087 1088
	DPRINTK(DRV, INFO, "Multiqueue Enabled: Rx Queue count = %u %s\n",
		adapter->num_rx_queues,
		((adapter->num_rx_queues == 1)
		 ? ((num_online_cpus() > 1)
			? "(due to unsupported feature in current adapter)"
			: "(due to unsupported system configuration)")
		 : ""));
	DPRINTK(DRV, INFO, "Multiqueue Enabled: Tx Queue count = %u\n",
		adapter->num_tx_queues);
1089
#else
1090 1091
	adapter->num_tx_queues = 1;
	adapter->num_rx_queues = 1;
1092
#endif
1093 1094 1095 1096 1097 1098 1099

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

#ifdef CONFIG_E1000_NAPI
1100
	for (i = 0; i < adapter->num_rx_queues; i++) {
1101 1102 1103 1104 1105 1106
		adapter->polling_netdev[i].priv = adapter;
		adapter->polling_netdev[i].poll = &e1000_clean;
		adapter->polling_netdev[i].weight = 64;
		dev_hold(&adapter->polling_netdev[i]);
		set_bit(__LINK_STATE_START, &adapter->polling_netdev[i].state);
	}
1107
	spin_lock_init(&adapter->tx_queue_lock);
1108 1109
#endif

L
Linus Torvalds 已提交
1110 1111 1112 1113 1114 1115
	atomic_set(&adapter->irq_sem, 1);
	spin_lock_init(&adapter->stats_lock);

	return 0;
}

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
/**
 * e1000_alloc_queues - Allocate memory for all rings
 * @adapter: board private structure to initialize
 *
 * We allocate one ring per queue at run-time since we don't know the
 * number of queues at compile-time.  The polling_netdev array is
 * intended for Multiqueue, but should work fine with a single queue.
 **/

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

1130
	size = sizeof(struct e1000_tx_ring) * adapter->num_tx_queues;
1131 1132 1133 1134 1135
	adapter->tx_ring = kmalloc(size, GFP_KERNEL);
	if (!adapter->tx_ring)
		return -ENOMEM;
	memset(adapter->tx_ring, 0, size);

1136
	size = sizeof(struct e1000_rx_ring) * adapter->num_rx_queues;
1137 1138 1139 1140 1141 1142 1143 1144
	adapter->rx_ring = kmalloc(size, GFP_KERNEL);
	if (!adapter->rx_ring) {
		kfree(adapter->tx_ring);
		return -ENOMEM;
	}
	memset(adapter->rx_ring, 0, size);

#ifdef CONFIG_E1000_NAPI
1145
	size = sizeof(struct net_device) * adapter->num_rx_queues;
1146 1147 1148 1149 1150 1151 1152 1153 1154
	adapter->polling_netdev = kmalloc(size, GFP_KERNEL);
	if (!adapter->polling_netdev) {
		kfree(adapter->tx_ring);
		kfree(adapter->rx_ring);
		return -ENOMEM;
	}
	memset(adapter->polling_netdev, 0, size);
#endif

1155 1156 1157 1158 1159 1160 1161 1162
#ifdef CONFIG_E1000_MQ
	adapter->rx_sched_call_data.func = e1000_rx_schedule;
	adapter->rx_sched_call_data.info = adapter->netdev;

	adapter->cpu_netdev = alloc_percpu(struct net_device *);
	adapter->cpu_tx_ring = alloc_percpu(struct e1000_tx_ring *);
#endif

1163 1164 1165
	return E1000_SUCCESS;
}

1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
#ifdef CONFIG_E1000_MQ
static void __devinit
e1000_setup_queue_mapping(struct e1000_adapter *adapter)
{
	int i, cpu;

	adapter->rx_sched_call_data.func = e1000_rx_schedule;
	adapter->rx_sched_call_data.info = adapter->netdev;
	cpus_clear(adapter->rx_sched_call_data.cpumask);

	adapter->cpu_netdev = alloc_percpu(struct net_device *);
	adapter->cpu_tx_ring = alloc_percpu(struct e1000_tx_ring *);

	lock_cpu_hotplug();
	i = 0;
	for_each_online_cpu(cpu) {
1182
		*per_cpu_ptr(adapter->cpu_tx_ring, cpu) = &adapter->tx_ring[i % adapter->num_tx_queues];
1183 1184 1185 1186
		/* This is incomplete because we'd like to assign separate
		 * physical cpus to these netdev polling structures and
		 * avoid saturating a subset of cpus.
		 */
1187
		if (i < adapter->num_rx_queues) {
1188
			*per_cpu_ptr(adapter->cpu_netdev, cpu) = &adapter->polling_netdev[i];
1189 1190
			adapter->rx_ring[i].cpu = cpu;
			cpu_set(cpu, adapter->cpumask);
1191 1192 1193 1194 1195 1196 1197 1198 1199
		} else
			*per_cpu_ptr(adapter->cpu_netdev, cpu) = NULL;

		i++;
	}
	unlock_cpu_hotplug();
}
#endif

L
Linus Torvalds 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
/**
 * 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)
{
1216
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1217 1218 1219 1220
	int err;

	/* allocate transmit descriptors */

1221
	if ((err = e1000_setup_all_tx_resources(adapter)))
L
Linus Torvalds 已提交
1222 1223 1224 1225
		goto err_setup_tx;

	/* allocate receive descriptors */

1226
	if ((err = e1000_setup_all_rx_resources(adapter)))
L
Linus Torvalds 已提交
1227 1228
		goto err_setup_rx;

J
Jesse Brandeburg 已提交
1229
	if ((err = e1000_up(adapter)))
L
Linus Torvalds 已提交
1230
		goto err_up;
1231
	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
J
Jesse Brandeburg 已提交
1232
	if ((adapter->hw.mng_cookie.status &
1233 1234 1235
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_update_mng_vlan(adapter);
	}
L
Linus Torvalds 已提交
1236

1237 1238 1239 1240 1241 1242
	/* If AMT is enabled, let the firmware know that the network
	 * interface is now open */
	if (adapter->hw.mac_type == e1000_82573 &&
	    e1000_check_mng_mode(&adapter->hw))
		e1000_get_hw_control(adapter);

L
Linus Torvalds 已提交
1243 1244 1245
	return E1000_SUCCESS;

err_up:
1246
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1247
err_setup_rx:
1248
	e1000_free_all_tx_resources(adapter);
L
Linus Torvalds 已提交
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
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)
{
1270
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
1271 1272 1273

	e1000_down(adapter);

1274 1275
	e1000_free_all_tx_resources(adapter);
	e1000_free_all_rx_resources(adapter);
L
Linus Torvalds 已提交
1276

J
Jesse Brandeburg 已提交
1277
	if ((adapter->hw.mng_cookie.status &
1278 1279 1280
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
	}
1281 1282 1283 1284 1285 1286 1287

	/* 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 已提交
1288 1289 1290 1291 1292 1293
	return 0;
}

/**
 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
 * @adapter: address of board private structure
1294 1295
 * @start: address of beginning of memory
 * @len: length of memory
L
Linus Torvalds 已提交
1296 1297 1298 1299 1300 1301 1302 1303
 **/
static inline boolean_t
e1000_check_64k_bound(struct e1000_adapter *adapter,
		      void *start, unsigned long len)
{
	unsigned long begin = (unsigned long) start;
	unsigned long end = begin + len;

1304 1305
	/* First rev 82545 and 82546 need to not allow any memory
	 * write location to cross 64k boundary due to errata 23 */
L
Linus Torvalds 已提交
1306
	if (adapter->hw.mac_type == e1000_82545 ||
1307
	    adapter->hw.mac_type == e1000_82546) {
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313 1314 1315 1316
		return ((begin ^ (end - 1)) >> 16) != 0 ? FALSE : TRUE;
	}

	return TRUE;
}

/**
 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 * @adapter: board private structure
1317
 * @txdr:    tx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1318 1319 1320 1321
 *
 * Return 0 on success, negative on failure
 **/

1322
static int
1323 1324
e1000_setup_tx_resources(struct e1000_adapter *adapter,
                         struct e1000_tx_ring *txdr)
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329
{
	struct pci_dev *pdev = adapter->pdev;
	int size;

	size = sizeof(struct e1000_buffer) * txdr->count;
1330 1331

	txdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
J
Jesse Brandeburg 已提交
1332
	if (!txdr->buffer_info) {
1333 1334
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
		return -ENOMEM;
	}
	memset(txdr->buffer_info, 0, size);

	/* round up to nearest 4K */

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

	txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
J
Jesse Brandeburg 已提交
1345
	if (!txdr->desc) {
L
Linus Torvalds 已提交
1346 1347
setup_tx_desc_die:
		vfree(txdr->buffer_info);
1348 1349
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1350 1351 1352
		return -ENOMEM;
	}

1353
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1354 1355 1356
	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
		void *olddesc = txdr->desc;
		dma_addr_t olddma = txdr->dma;
1357 1358 1359
		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 已提交
1360
		txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
1361
		/* Failed allocation, critical failure */
J
Jesse Brandeburg 已提交
1362
		if (!txdr->desc) {
L
Linus Torvalds 已提交
1363 1364 1365 1366 1367 1368
			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 */
1369 1370
			pci_free_consistent(pdev, txdr->size, txdr->desc,
					    txdr->dma);
L
Linus Torvalds 已提交
1371 1372
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
			DPRINTK(PROBE, ERR,
1373 1374
				"Unable to allocate aligned memory "
				"for the transmit descriptor ring\n");
L
Linus Torvalds 已提交
1375 1376 1377
			vfree(txdr->buffer_info);
			return -ENOMEM;
		} else {
1378
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1379 1380 1381 1382 1383 1384 1385
			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
		}
	}
	memset(txdr->desc, 0, txdr->size);

	txdr->next_to_use = 0;
	txdr->next_to_clean = 0;
1386
	spin_lock_init(&txdr->tx_lock);
L
Linus Torvalds 已提交
1387 1388 1389 1390

	return 0;
}

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
/**
 * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * If this function returns with an error, then it's possible one or
 * more of the rings is populated (while the rest are not).  It is the
 * callers duty to clean those orphaned rings.
 *
 * Return 0 on success, negative on failure
 **/

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

1408
	for (i = 0; i < adapter->num_tx_queues; i++) {
1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
		if (err) {
			DPRINTK(PROBE, ERR,
				"Allocation for Tx Queue %u failed\n", i);
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
/**
 * 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)
{
1430 1431 1432
	uint64_t tdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t tdlen, tctl, tipg, tarc;
1433
	uint32_t ipgr1, ipgr2;
L
Linus Torvalds 已提交
1434 1435 1436

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

1437
	switch (adapter->num_tx_queues) {
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
	case 2:
		tdba = adapter->tx_ring[1].dma;
		tdlen = adapter->tx_ring[1].count *
			sizeof(struct e1000_tx_desc);
		E1000_WRITE_REG(hw, TDBAL1, (tdba & 0x00000000ffffffffULL));
		E1000_WRITE_REG(hw, TDBAH1, (tdba >> 32));
		E1000_WRITE_REG(hw, TDLEN1, tdlen);
		E1000_WRITE_REG(hw, TDH1, 0);
		E1000_WRITE_REG(hw, TDT1, 0);
		adapter->tx_ring[1].tdh = E1000_TDH1;
		adapter->tx_ring[1].tdt = E1000_TDT1;
		/* Fall Through */
	case 1:
	default:
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
		tdba = adapter->tx_ring[0].dma;
		tdlen = adapter->tx_ring[0].count *
			sizeof(struct e1000_tx_desc);
		E1000_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
		E1000_WRITE_REG(hw, TDBAH, (tdba >> 32));
		E1000_WRITE_REG(hw, TDLEN, tdlen);
		E1000_WRITE_REG(hw, TDH, 0);
		E1000_WRITE_REG(hw, TDT, 0);
		adapter->tx_ring[0].tdh = E1000_TDH;
		adapter->tx_ring[0].tdt = E1000_TDT;
1462 1463
		break;
	}
L
Linus Torvalds 已提交
1464 1465 1466

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

1467 1468 1469 1470 1471 1472
	if (hw->media_type == e1000_media_type_fiber ||
	    hw->media_type == e1000_media_type_internal_serdes)
		tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
	else
		tipg = DEFAULT_82543_TIPG_IPGT_COPPER;

1473
	switch (hw->mac_type) {
L
Linus Torvalds 已提交
1474 1475 1476
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
		tipg = DEFAULT_82542_TIPG_IPGT;
1477 1478
		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
L
Linus Torvalds 已提交
1479 1480
		break;
	default:
1481 1482 1483
		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
		break;
L
Linus Torvalds 已提交
1484
	}
1485 1486
	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
1487
	E1000_WRITE_REG(hw, TIPG, tipg);
L
Linus Torvalds 已提交
1488 1489 1490

	/* Set the Tx Interrupt Delay register */

1491 1492 1493
	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 已提交
1494 1495 1496

	/* Program the Transmit Control Register */

1497
	tctl = E1000_READ_REG(hw, TCTL);
L
Linus Torvalds 已提交
1498 1499

	tctl &= ~E1000_TCTL_CT;
1500
	tctl |= E1000_TCTL_EN | E1000_TCTL_PSP | E1000_TCTL_RTLC |
L
Linus Torvalds 已提交
1501 1502
		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);

1503
	E1000_WRITE_REG(hw, TCTL, tctl);
L
Linus Torvalds 已提交
1504

1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
	if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572) {
		tarc = E1000_READ_REG(hw, TARC0);
		tarc |= ((1 << 25) | (1 << 21));
		E1000_WRITE_REG(hw, TARC0, tarc);
		tarc = E1000_READ_REG(hw, TARC1);
		tarc |= (1 << 25);
		if (tctl & E1000_TCTL_MULR)
			tarc &= ~(1 << 28);
		else
			tarc |= (1 << 28);
		E1000_WRITE_REG(hw, TARC1, tarc);
	}

1518
	e1000_config_collision_dist(hw);
L
Linus Torvalds 已提交
1519 1520 1521 1522 1523

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

1524
	if (hw->mac_type < e1000_82543)
L
Linus Torvalds 已提交
1525 1526 1527 1528 1529 1530
		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. */
1531 1532
	if (hw->mac_type == e1000_82544 &&
	    hw->bus_type == e1000_bus_type_pcix)
L
Linus Torvalds 已提交
1533 1534 1535 1536 1537 1538
		adapter->pcix_82544 = 1;
}

/**
 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 * @adapter: board private structure
1539
 * @rxdr:    rx descriptor ring (for a specific queue) to setup
L
Linus Torvalds 已提交
1540 1541 1542 1543
 *
 * Returns 0 on success, negative on failure
 **/

1544
static int
1545 1546
e1000_setup_rx_resources(struct e1000_adapter *adapter,
                         struct e1000_rx_ring *rxdr)
L
Linus Torvalds 已提交
1547 1548
{
	struct pci_dev *pdev = adapter->pdev;
1549
	int size, desc_len;
L
Linus Torvalds 已提交
1550 1551

	size = sizeof(struct e1000_buffer) * rxdr->count;
1552
	rxdr->buffer_info = vmalloc_node(size, pcibus_to_node(pdev->bus));
1553
	if (!rxdr->buffer_info) {
1554 1555
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1556 1557 1558 1559
		return -ENOMEM;
	}
	memset(rxdr->buffer_info, 0, size);

1560 1561
	size = sizeof(struct e1000_ps_page) * rxdr->count;
	rxdr->ps_page = kmalloc(size, GFP_KERNEL);
J
Jesse Brandeburg 已提交
1562
	if (!rxdr->ps_page) {
1563 1564 1565 1566 1567 1568 1569 1570 1571
		vfree(rxdr->buffer_info);
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
		return -ENOMEM;
	}
	memset(rxdr->ps_page, 0, size);

	size = sizeof(struct e1000_ps_page_dma) * rxdr->count;
	rxdr->ps_page_dma = kmalloc(size, GFP_KERNEL);
J
Jesse Brandeburg 已提交
1572
	if (!rxdr->ps_page_dma) {
1573 1574 1575 1576 1577 1578 1579 1580
		vfree(rxdr->buffer_info);
		kfree(rxdr->ps_page);
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
		return -ENOMEM;
	}
	memset(rxdr->ps_page_dma, 0, size);

J
Jesse Brandeburg 已提交
1581
	if (adapter->hw.mac_type <= e1000_82547_rev_2)
1582 1583 1584 1585
		desc_len = sizeof(struct e1000_rx_desc);
	else
		desc_len = sizeof(union e1000_rx_desc_packet_split);

L
Linus Torvalds 已提交
1586 1587
	/* Round up to nearest 4K */

1588
	rxdr->size = rxdr->count * desc_len;
L
Linus Torvalds 已提交
1589 1590 1591 1592
	E1000_ROUNDUP(rxdr->size, 4096);

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

1593 1594 1595
	if (!rxdr->desc) {
		DPRINTK(PROBE, ERR,
		"Unable to allocate memory for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1596 1597
setup_rx_desc_die:
		vfree(rxdr->buffer_info);
1598 1599
		kfree(rxdr->ps_page);
		kfree(rxdr->ps_page_dma);
L
Linus Torvalds 已提交
1600 1601 1602
		return -ENOMEM;
	}

1603
	/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
1604 1605 1606
	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
		void *olddesc = rxdr->desc;
		dma_addr_t olddma = rxdr->dma;
1607 1608 1609
		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 已提交
1610
		rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
1611
		/* Failed allocation, critical failure */
1612
		if (!rxdr->desc) {
L
Linus Torvalds 已提交
1613
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1614 1615 1616
			DPRINTK(PROBE, ERR,
				"Unable to allocate memory "
				"for the receive descriptor ring\n");
L
Linus Torvalds 已提交
1617 1618 1619 1620 1621
			goto setup_rx_desc_die;
		}

		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
			/* give up */
1622 1623
			pci_free_consistent(pdev, rxdr->size, rxdr->desc,
					    rxdr->dma);
L
Linus Torvalds 已提交
1624
			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1625 1626 1627
			DPRINTK(PROBE, ERR,
				"Unable to allocate aligned memory "
				"for the receive descriptor ring\n");
1628
			goto setup_rx_desc_die;
L
Linus Torvalds 已提交
1629
		} else {
1630
			/* Free old allocation, new allocation was successful */
L
Linus Torvalds 已提交
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
			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;
}

1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
/**
 * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
 * 				  (Descriptors) for all queues
 * @adapter: board private structure
 *
 * If this function returns with an error, then it's possible one or
 * more of the rings is populated (while the rest are not).  It is the
 * callers duty to clean those orphaned rings.
 *
 * Return 0 on success, negative on failure
 **/

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

1659
	for (i = 0; i < adapter->num_rx_queues; i++) {
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
		if (err) {
			DPRINTK(PROBE, ERR,
				"Allocation for Rx Queue %u failed\n", i);
			break;
		}
	}

	return err;
}

L
Linus Torvalds 已提交
1671
/**
1672
 * e1000_setup_rctl - configure the receive control registers
L
Linus Torvalds 已提交
1673 1674
 * @adapter: Board private structure
 **/
1675 1676
#define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
			(((S) & (PAGE_SIZE - 1)) ? 1 : 0))
L
Linus Torvalds 已提交
1677 1678 1679
static void
e1000_setup_rctl(struct e1000_adapter *adapter)
{
1680 1681
	uint32_t rctl, rfctl;
	uint32_t psrctl = 0;
1682
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1683 1684
	uint32_t pages = 0;
#endif
L
Linus Torvalds 已提交
1685 1686 1687 1688 1689 1690 1691 1692 1693

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

1694 1695 1696 1697
	if (adapter->hw.mac_type > e1000_82543)
		rctl |= E1000_RCTL_SECRC;

	if (adapter->hw.tbi_compatibility_on == 1)
L
Linus Torvalds 已提交
1698 1699 1700 1701
		rctl |= E1000_RCTL_SBP;
	else
		rctl &= ~E1000_RCTL_SBP;

1702 1703 1704 1705 1706
	if (adapter->netdev->mtu <= ETH_DATA_LEN)
		rctl &= ~E1000_RCTL_LPE;
	else
		rctl |= E1000_RCTL_LPE;

L
Linus Torvalds 已提交
1707
	/* Setup buffer sizes */
J
Jesse Brandeburg 已提交
1708
	if (adapter->hw.mac_type >= e1000_82571) {
1709 1710 1711 1712 1713
		/* We can now specify buffers in 1K increments.
		 * BSIZE and BSEX are ignored in this case. */
		rctl |= adapter->rx_buffer_len << 0x11;
	} else {
		rctl &= ~E1000_RCTL_SZ_4096;
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
		rctl |= E1000_RCTL_BSEX; 
		switch (adapter->rx_buffer_len) {
		case E1000_RXBUFFER_2048:
		default:
			rctl |= E1000_RCTL_SZ_2048;
			rctl &= ~E1000_RCTL_BSEX;
			break;
		case E1000_RXBUFFER_4096:
			rctl |= E1000_RCTL_SZ_4096;
			break;
		case E1000_RXBUFFER_8192:
			rctl |= E1000_RCTL_SZ_8192;
			break;
		case E1000_RXBUFFER_16384:
			rctl |= E1000_RCTL_SZ_16384;
			break;
		}
1731 1732
	}

1733
#ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
1734 1735 1736 1737 1738 1739 1740
	/* 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.
	 */
1741 1742 1743 1744 1745 1746
	pages = PAGE_USE_COUNT(adapter->netdev->mtu);
	if ((adapter->hw.mac_type > e1000_82547_rev_2) && (pages <= 3) &&
	    PAGE_SIZE <= 16384)
		adapter->rx_ps_pages = pages;
	else
		adapter->rx_ps_pages = 0;
1747
#endif
1748
	if (adapter->rx_ps_pages) {
1749 1750 1751 1752 1753 1754 1755 1756
		/* Configure extra packet-split registers */
		rfctl = E1000_READ_REG(&adapter->hw, RFCTL);
		rfctl |= E1000_RFCTL_EXTEN;
		/* disable IPv6 packet split support */
		rfctl |= E1000_RFCTL_IPV6_DIS;
		E1000_WRITE_REG(&adapter->hw, RFCTL, rfctl);

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

1758 1759
		psrctl |= adapter->rx_ps_bsize0 >>
			E1000_PSRCTL_BSIZE0_SHIFT;
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772

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

		E1000_WRITE_REG(&adapter->hw, PSRCTL, psrctl);
L
Linus Torvalds 已提交
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
	}

	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)
{
1790 1791 1792 1793 1794 1795 1796
	uint64_t rdba;
	struct e1000_hw *hw = &adapter->hw;
	uint32_t rdlen, rctl, rxcsum, ctrl_ext;
#ifdef CONFIG_E1000_MQ
	uint32_t reta, mrqc;
	int i;
#endif
1797

1798
	if (adapter->rx_ps_pages) {
1799
		rdlen = adapter->rx_ring[0].count *
1800 1801 1802 1803
			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 {
1804 1805
		rdlen = adapter->rx_ring[0].count *
			sizeof(struct e1000_rx_desc);
1806 1807 1808
		adapter->clean_rx = e1000_clean_rx_irq;
		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
	}
L
Linus Torvalds 已提交
1809 1810

	/* disable receives while setting up the descriptors */
1811 1812
	rctl = E1000_READ_REG(hw, RCTL);
	E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
L
Linus Torvalds 已提交
1813 1814

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

1817 1818
	if (hw->mac_type >= e1000_82540) {
		E1000_WRITE_REG(hw, RADV, adapter->rx_abs_int_delay);
J
Jesse Brandeburg 已提交
1819
		if (adapter->itr > 1)
1820
			E1000_WRITE_REG(hw, ITR,
L
Linus Torvalds 已提交
1821 1822 1823
				1000000000 / (adapter->itr * 256));
	}

1824 1825
	if (hw->mac_type >= e1000_82571) {
		ctrl_ext = E1000_READ_REG(hw, CTRL_EXT);
1826
		/* Reset delay timers after every interrupt */
1827
		ctrl_ext |= E1000_CTRL_EXT_CANC;
1828 1829 1830 1831
#ifdef CONFIG_E1000_NAPI
		/* Auto-Mask interrupts upon ICR read. */
		ctrl_ext |= E1000_CTRL_EXT_IAME;
#endif
1832
		E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext);
1833
		E1000_WRITE_REG(hw, IAM, ~0);
1834 1835 1836
		E1000_WRITE_FLUSH(hw);
	}

1837 1838
	/* Setup the HW Rx Head and Tail Descriptor Pointers and
	 * the Base and Length of the Rx Descriptor Ring */
1839
	switch (adapter->num_rx_queues) {
1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853
#ifdef CONFIG_E1000_MQ
	case 2:
		rdba = adapter->rx_ring[1].dma;
		E1000_WRITE_REG(hw, RDBAL1, (rdba & 0x00000000ffffffffULL));
		E1000_WRITE_REG(hw, RDBAH1, (rdba >> 32));
		E1000_WRITE_REG(hw, RDLEN1, rdlen);
		E1000_WRITE_REG(hw, RDH1, 0);
		E1000_WRITE_REG(hw, RDT1, 0);
		adapter->rx_ring[1].rdh = E1000_RDH1;
		adapter->rx_ring[1].rdt = E1000_RDT1;
		/* Fall Through */
#endif
	case 1:
	default:
1854 1855 1856 1857 1858 1859 1860 1861 1862
		rdba = adapter->rx_ring[0].dma;
		E1000_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL));
		E1000_WRITE_REG(hw, RDBAH, (rdba >> 32));
		E1000_WRITE_REG(hw, RDLEN, rdlen);
		E1000_WRITE_REG(hw, RDH, 0);
		E1000_WRITE_REG(hw, RDT, 0);
		adapter->rx_ring[0].rdh = E1000_RDH;
		adapter->rx_ring[0].rdt = E1000_RDT;
		break;
1863 1864 1865
	}

#ifdef CONFIG_E1000_MQ
1866
	if (adapter->num_rx_queues > 1) {
1867 1868 1869 1870 1871 1872 1873 1874 1875
		uint32_t random[10];

		get_random_bytes(&random[0], 40);

		if (hw->mac_type <= e1000_82572) {
			E1000_WRITE_REG(hw, RSSIR, 0);
			E1000_WRITE_REG(hw, RSSIM, 0);
		}

1876
		switch (adapter->num_rx_queues) {
1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
		case 2:
		default:
			reta = 0x00800080;
			mrqc = E1000_MRQC_ENABLE_RSS_2Q;
			break;
		}

		/* Fill out redirection table */
		for (i = 0; i < 32; i++)
			E1000_WRITE_REG_ARRAY(hw, RETA, i, reta);
		/* Fill out hash function seeds */
		for (i = 0; i < 10; i++)
			E1000_WRITE_REG_ARRAY(hw, RSSRK, i, random[i]);

		mrqc |= (E1000_MRQC_RSS_FIELD_IPV4 |
			 E1000_MRQC_RSS_FIELD_IPV4_TCP);
		E1000_WRITE_REG(hw, MRQC, mrqc);
	}

	/* Multiqueue and packet checksumming are mutually exclusive. */
	if (hw->mac_type >= e1000_82571) {
		rxcsum = E1000_READ_REG(hw, RXCSUM);
		rxcsum |= E1000_RXCSUM_PCSD;
		E1000_WRITE_REG(hw, RXCSUM, rxcsum);
	}

#else
L
Linus Torvalds 已提交
1904 1905

	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
1906 1907
	if (hw->mac_type >= e1000_82543) {
		rxcsum = E1000_READ_REG(hw, RXCSUM);
J
Jesse Brandeburg 已提交
1908
		if (adapter->rx_csum == TRUE) {
1909 1910
			rxcsum |= E1000_RXCSUM_TUOFL;

1911
			/* Enable 82571 IPv4 payload checksum for UDP fragments
1912
			 * Must be used in conjunction with packet-split. */
J
Jesse Brandeburg 已提交
1913 1914
			if ((hw->mac_type >= e1000_82571) &&
			    (adapter->rx_ps_pages)) {
1915 1916 1917 1918 1919 1920
				rxcsum |= E1000_RXCSUM_IPPCSE;
			}
		} else {
			rxcsum &= ~E1000_RXCSUM_TUOFL;
			/* don't need to clear IPPCSE as it defaults to 0 */
		}
1921
		E1000_WRITE_REG(hw, RXCSUM, rxcsum);
L
Linus Torvalds 已提交
1922
	}
1923
#endif /* CONFIG_E1000_MQ */
L
Linus Torvalds 已提交
1924

1925 1926
	if (hw->mac_type == e1000_82573)
		E1000_WRITE_REG(hw, ERT, 0x0100);
1927

L
Linus Torvalds 已提交
1928
	/* Enable Receives */
1929
	E1000_WRITE_REG(hw, RCTL, rctl);
L
Linus Torvalds 已提交
1930 1931 1932
}

/**
1933
 * e1000_free_tx_resources - Free Tx Resources per Queue
L
Linus Torvalds 已提交
1934
 * @adapter: board private structure
1935
 * @tx_ring: Tx descriptor ring for a specific queue
L
Linus Torvalds 已提交
1936 1937 1938 1939
 *
 * Free all transmit software resources
 **/

1940
static void
1941 1942
e1000_free_tx_resources(struct e1000_adapter *adapter,
                        struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1943 1944 1945
{
	struct pci_dev *pdev = adapter->pdev;

1946
	e1000_clean_tx_ring(adapter, tx_ring);
L
Linus Torvalds 已提交
1947

1948 1949
	vfree(tx_ring->buffer_info);
	tx_ring->buffer_info = NULL;
L
Linus Torvalds 已提交
1950

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

1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
	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;

1968
	for (i = 0; i < adapter->num_tx_queues; i++)
1969
		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
1970 1971 1972 1973 1974 1975
}

static inline void
e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
			struct e1000_buffer *buffer_info)
{
J
Jesse Brandeburg 已提交
1976
	if (buffer_info->dma) {
1977 1978 1979 1980
		pci_unmap_page(adapter->pdev,
				buffer_info->dma,
				buffer_info->length,
				PCI_DMA_TODEVICE);
L
Linus Torvalds 已提交
1981
	}
1982
	if (buffer_info->skb)
L
Linus Torvalds 已提交
1983
		dev_kfree_skb_any(buffer_info->skb);
1984
	memset(buffer_info, 0, sizeof(struct e1000_buffer));
L
Linus Torvalds 已提交
1985 1986 1987 1988 1989
}

/**
 * e1000_clean_tx_ring - Free Tx Buffers
 * @adapter: board private structure
1990
 * @tx_ring: ring to be cleaned
L
Linus Torvalds 已提交
1991 1992 1993
 **/

static void
1994 1995
e1000_clean_tx_ring(struct e1000_adapter *adapter,
                    struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
1996 1997 1998 1999 2000 2001 2002
{
	struct e1000_buffer *buffer_info;
	unsigned long size;
	unsigned int i;

	/* Free all the Tx ring sk_buffs */

J
Jesse Brandeburg 已提交
2003
	for (i = 0; i < tx_ring->count; i++) {
L
Linus Torvalds 已提交
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
		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 已提交
2017
	tx_ring->last_tx_tso = 0;
L
Linus Torvalds 已提交
2018

2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
	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;

2033
	for (i = 0; i < adapter->num_tx_queues; i++)
2034
		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
L
Linus Torvalds 已提交
2035 2036 2037 2038 2039
}

/**
 * e1000_free_rx_resources - Free Rx Resources
 * @adapter: board private structure
2040
 * @rx_ring: ring to clean the resources from
L
Linus Torvalds 已提交
2041 2042 2043 2044
 *
 * Free all receive software resources
 **/

2045
static void
2046 2047
e1000_free_rx_resources(struct e1000_adapter *adapter,
                        struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
2048 2049 2050
{
	struct pci_dev *pdev = adapter->pdev;

2051
	e1000_clean_rx_ring(adapter, rx_ring);
L
Linus Torvalds 已提交
2052 2053 2054

	vfree(rx_ring->buffer_info);
	rx_ring->buffer_info = NULL;
2055 2056 2057 2058
	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 已提交
2059 2060 2061 2062 2063 2064 2065

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

	rx_ring->desc = NULL;
}

/**
2066
 * e1000_free_all_rx_resources - Free Rx Resources for All Queues
L
Linus Torvalds 已提交
2067
 * @adapter: board private structure
2068 2069 2070 2071 2072 2073 2074 2075 2076
 *
 * Free all receive software resources
 **/

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

2077
	for (i = 0; i < adapter->num_rx_queues; i++)
2078 2079 2080 2081 2082 2083 2084
		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 已提交
2085 2086 2087
 **/

static void
2088 2089
e1000_clean_rx_ring(struct e1000_adapter *adapter,
                    struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
2090 2091
{
	struct e1000_buffer *buffer_info;
2092 2093
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
L
Linus Torvalds 已提交
2094 2095
	struct pci_dev *pdev = adapter->pdev;
	unsigned long size;
2096
	unsigned int i, j;
L
Linus Torvalds 已提交
2097 2098

	/* Free all the Rx ring sk_buffs */
J
Jesse Brandeburg 已提交
2099
	for (i = 0; i < rx_ring->count; i++) {
L
Linus Torvalds 已提交
2100
		buffer_info = &rx_ring->buffer_info[i];
J
Jesse Brandeburg 已提交
2101
		if (buffer_info->skb) {
L
Linus Torvalds 已提交
2102 2103 2104 2105 2106 2107 2108
			pci_unmap_single(pdev,
					 buffer_info->dma,
					 buffer_info->length,
					 PCI_DMA_FROMDEVICE);

			dev_kfree_skb(buffer_info->skb);
			buffer_info->skb = NULL;
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119
		}
		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 已提交
2120 2121 2122 2123 2124
		}
	}

	size = sizeof(struct e1000_buffer) * rx_ring->count;
	memset(rx_ring->buffer_info, 0, size);
2125 2126 2127 2128
	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 已提交
2129 2130 2131 2132 2133 2134 2135 2136

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

2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
	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;

2151
	for (i = 0; i < adapter->num_rx_queues; i++)
2152
		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
L
Linus Torvalds 已提交
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
}

/* 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 已提交
2172
	if (netif_running(netdev))
2173
		e1000_clean_all_rx_rings(adapter);
L
Linus Torvalds 已提交
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
}

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

J
Jesse Brandeburg 已提交
2191
	if (netif_running(netdev)) {
2192 2193
		/* No need to loop, because 82542 supports only 1 queue */
		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2194
		e1000_configure_rx(adapter);
2195
		adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
L
Linus Torvalds 已提交
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209
	}
}

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

J
Jesse Brandeburg 已提交
2213
	if (!is_valid_ether_addr(addr->sa_data))
L
Linus Torvalds 已提交
2214 2215 2216 2217
		return -EADDRNOTAVAIL;

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

J
Jesse Brandeburg 已提交
2218
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2219 2220 2221 2222 2223 2224 2225
		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);

2226 2227 2228 2229 2230 2231
	/* 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 已提交
2232 2233 2234
		/* 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
2235
		 * of the RARs and no incoming packets directed to this port
J
Jesse Brandeburg 已提交
2236
		 * are dropped. Eventaully the LAA will be in RAR[0] and
2237
		 * RAR[14] */
J
Jesse Brandeburg 已提交
2238
		e1000_rar_set(&adapter->hw, adapter->hw.mac_addr,
2239 2240 2241
					E1000_RAR_ENTRIES - 1);
	}

J
Jesse Brandeburg 已提交
2242
	if (adapter->hw.mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
		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)
{
2261
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
2262 2263 2264 2265
	struct e1000_hw *hw = &adapter->hw;
	struct dev_mc_list *mc_ptr;
	uint32_t rctl;
	uint32_t hash_value;
2266
	int i, rar_entries = E1000_RAR_ENTRIES;
L
Linus Torvalds 已提交
2267

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

2272 2273
	/* Check for Promiscuous and All Multicast modes */

L
Linus Torvalds 已提交
2274 2275
	rctl = E1000_READ_REG(hw, RCTL);

J
Jesse Brandeburg 已提交
2276
	if (netdev->flags & IFF_PROMISC) {
L
Linus Torvalds 已提交
2277
		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
J
Jesse Brandeburg 已提交
2278
	} else if (netdev->flags & IFF_ALLMULTI) {
L
Linus Torvalds 已提交
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
		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 已提交
2289
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2290 2291 2292 2293 2294
		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
2295
	 * -- with 82571 controllers only 0-13 entries are filled here
L
Linus Torvalds 已提交
2296 2297 2298
	 */
	mc_ptr = netdev->mc_list;

J
Jesse Brandeburg 已提交
2299
	for (i = 1; i < rar_entries; i++) {
2300
		if (mc_ptr) {
L
Linus Torvalds 已提交
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
			e1000_rar_set(hw, mc_ptr->dmi_addr, i);
			mc_ptr = mc_ptr->next;
		} else {
			E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
			E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
		}
	}

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

J
Jesse Brandeburg 已提交
2311
	for (i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
L
Linus Torvalds 已提交
2312 2313 2314 2315
		E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);

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

J
Jesse Brandeburg 已提交
2316
	for (; mc_ptr; mc_ptr = mc_ptr->next) {
L
Linus Torvalds 已提交
2317 2318 2319 2320
		hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
		e1000_mta_set(hw, hash_value);
	}

J
Jesse Brandeburg 已提交
2321
	if (hw->mac_type == e1000_82542_rev2_0)
L
Linus Torvalds 已提交
2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
		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 已提交
2347 2348
	if (atomic_read(&adapter->tx_fifo_stall)) {
		if ((E1000_READ_REG(&adapter->hw, TDT) ==
L
Linus Torvalds 已提交
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
		    E1000_READ_REG(&adapter->hw, TDH)) &&
		   (E1000_READ_REG(&adapter->hw, TDFT) ==
		    E1000_READ_REG(&adapter->hw, TDFH)) &&
		   (E1000_READ_REG(&adapter->hw, TDFTS) ==
		    E1000_READ_REG(&adapter->hw, TDFHS))) {
			tctl = E1000_READ_REG(&adapter->hw, TCTL);
			E1000_WRITE_REG(&adapter->hw, TCTL,
					tctl & ~E1000_TCTL_EN);
			E1000_WRITE_REG(&adapter->hw, TDFT,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TDFH,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TDFTS,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TDFHS,
					adapter->tx_head_addr);
			E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
			E1000_WRITE_FLUSH(&adapter->hw);

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

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

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

static void
e1000_watchdog_task(struct e1000_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
J
Jeff Kirsher 已提交
2394
	struct e1000_tx_ring *txdr = adapter->tx_ring;
L
Linus Torvalds 已提交
2395 2396 2397
	uint32_t link;

	e1000_check_for_link(&adapter->hw);
2398 2399
	if (adapter->hw.mac_type == e1000_82573) {
		e1000_enable_tx_pkt_filtering(&adapter->hw);
J
Jesse Brandeburg 已提交
2400
		if (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id)
2401
			e1000_update_mng_vlan(adapter);
J
Jesse Brandeburg 已提交
2402
	}
L
Linus Torvalds 已提交
2403

J
Jesse Brandeburg 已提交
2404
	if ((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
L
Linus Torvalds 已提交
2405 2406 2407 2408 2409
	   !(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 已提交
2410 2411
	if (link) {
		if (!netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
2412 2413 2414 2415 2416 2417 2418 2419 2420
			e1000_get_speed_and_duplex(&adapter->hw,
			                           &adapter->link_speed,
			                           &adapter->link_duplex);

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

2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
			/* tweak tx_queue_len according to speed/duplex */
			netdev->tx_queue_len = adapter->tx_queue_len;
			adapter->tx_timeout_factor = 1;
			if (adapter->link_duplex == HALF_DUPLEX) {
				switch (adapter->link_speed) {
				case SPEED_10:
					netdev->tx_queue_len = 10;
					adapter->tx_timeout_factor = 8;
					break;
				case SPEED_100:
					netdev->tx_queue_len = 100;
					break;
				}
			}

L
Linus Torvalds 已提交
2436 2437 2438 2439 2440 2441
			netif_carrier_on(netdev);
			netif_wake_queue(netdev);
			mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
			adapter->smartspeed = 0;
		}
	} else {
J
Jesse Brandeburg 已提交
2442
		if (netif_carrier_ok(netdev)) {
L
Linus Torvalds 已提交
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
			adapter->link_speed = 0;
			adapter->link_duplex = 0;
			DPRINTK(LINK, INFO, "NIC Link is Down\n");
			netif_carrier_off(netdev);
			netif_stop_queue(netdev);
			mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
		}

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

2468 2469 2470 2471
#ifdef CONFIG_E1000_MQ
	txdr = *per_cpu_ptr(adapter->cpu_tx_ring, smp_processor_id());
#endif
	if (!netif_carrier_ok(netdev)) {
2472
		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
L
Linus Torvalds 已提交
2473 2474 2475 2476 2477 2478 2479 2480 2481
			/* 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). */
			schedule_work(&adapter->tx_timeout_task);
		}
	}

	/* Dynamic mode for Interrupt Throttle Rate (ITR) */
J
Jesse Brandeburg 已提交
2482
	if (adapter->hw.mac_type >= e1000_82540 && adapter->itr == 1) {
L
Linus Torvalds 已提交
2483 2484 2485 2486
		/* Symmetric Tx/Rx gets a reduced ITR=2000; Total
		 * asymmetrical Tx or Rx gets ITR=8000; everyone
		 * else is between 2000-8000. */
		uint32_t goc = (adapter->gotcl + adapter->gorcl) / 10000;
J
Jesse Brandeburg 已提交
2487
		uint32_t dif = (adapter->gotcl > adapter->gorcl ?
L
Linus Torvalds 已提交
2488 2489 2490 2491 2492 2493 2494 2495 2496
			adapter->gotcl - adapter->gorcl :
			adapter->gorcl - adapter->gotcl) / 10000;
		uint32_t itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
		E1000_WRITE_REG(&adapter->hw, ITR, 1000000000 / (itr * 256));
	}

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

2497
	/* Force detection of hung controller every watchdog period */
L
Linus Torvalds 已提交
2498 2499
	adapter->detect_tx_hung = TRUE;

J
Jesse Brandeburg 已提交
2500
	/* With 82571 controllers, LAA may be overwritten due to controller
2501 2502 2503 2504
	 * 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 已提交
2505 2506 2507 2508 2509 2510 2511
	/* Reset the timer */
	mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
}

#define E1000_TX_FLAGS_CSUM		0x00000001
#define E1000_TX_FLAGS_VLAN		0x00000002
#define E1000_TX_FLAGS_TSO		0x00000004
2512
#define E1000_TX_FLAGS_IPV4		0x00000008
L
Linus Torvalds 已提交
2513 2514 2515 2516
#define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
#define E1000_TX_FLAGS_VLAN_SHIFT	16

static inline int
2517 2518
e1000_tso(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
          struct sk_buff *skb)
L
Linus Torvalds 已提交
2519 2520 2521
{
#ifdef NETIF_F_TSO
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2522
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2523 2524
	unsigned int i;
	uint32_t cmd_length = 0;
2525
	uint16_t ipcse = 0, tucse, mss;
L
Linus Torvalds 已提交
2526 2527 2528
	uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
	int err;

J
Jesse Brandeburg 已提交
2529
	if (skb_shinfo(skb)->tso_size) {
L
Linus Torvalds 已提交
2530 2531 2532 2533 2534 2535 2536 2537
		if (skb_header_cloned(skb)) {
			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
			if (err)
				return err;
		}

		hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
		mss = skb_shinfo(skb)->tso_size;
J
Jesse Brandeburg 已提交
2538
		if (skb->protocol == ntohs(ETH_P_IP)) {
2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
			skb->nh.iph->tot_len = 0;
			skb->nh.iph->check = 0;
			skb->h.th->check =
				~csum_tcpudp_magic(skb->nh.iph->saddr,
						   skb->nh.iph->daddr,
						   0,
						   IPPROTO_TCP,
						   0);
			cmd_length = E1000_TXD_CMD_IP;
			ipcse = skb->h.raw - skb->data - 1;
#ifdef NETIF_F_TSO_IPV6
J
Jesse Brandeburg 已提交
2550
		} else if (skb->protocol == ntohs(ETH_P_IPV6)) {
2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
			skb->nh.ipv6h->payload_len = 0;
			skb->h.th->check =
				~csum_ipv6_magic(&skb->nh.ipv6h->saddr,
						 &skb->nh.ipv6h->daddr,
						 0,
						 IPPROTO_TCP,
						 0);
			ipcse = 0;
#endif
		}
L
Linus Torvalds 已提交
2561 2562 2563 2564 2565 2566 2567
		ipcss = skb->nh.raw - skb->data;
		ipcso = (void *)&(skb->nh.iph->check) - (void *)skb->data;
		tucss = skb->h.raw - skb->data;
		tucso = (void *)&(skb->h.th->check) - (void *)skb->data;
		tucse = 0;

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

2570 2571
		i = tx_ring->next_to_use;
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
J
Jeff Kirsher 已提交
2572
		buffer_info = &tx_ring->buffer_info[i];
L
Linus Torvalds 已提交
2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583

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

2586 2587
		if (++i == tx_ring->count) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2588

2589
		return TRUE;
L
Linus Torvalds 已提交
2590 2591 2592
	}
#endif

2593
	return FALSE;
L
Linus Torvalds 已提交
2594 2595 2596
}

static inline boolean_t
2597 2598
e1000_tx_csum(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
              struct sk_buff *skb)
L
Linus Torvalds 已提交
2599 2600
{
	struct e1000_context_desc *context_desc;
J
Jeff Kirsher 已提交
2601
	struct e1000_buffer *buffer_info;
L
Linus Torvalds 已提交
2602 2603 2604
	unsigned int i;
	uint8_t css;

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

2608
		i = tx_ring->next_to_use;
J
Jeff Kirsher 已提交
2609
		buffer_info = &tx_ring->buffer_info[i];
2610
		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
L
Linus Torvalds 已提交
2611 2612 2613 2614 2615 2616 2617

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

J
Jeff Kirsher 已提交
2618 2619
		buffer_info->time_stamp = jiffies;

2620 2621
		if (unlikely(++i == tx_ring->count)) i = 0;
		tx_ring->next_to_use = i;
L
Linus Torvalds 已提交
2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632

		return TRUE;
	}

	return FALSE;
}

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

static inline int
2633 2634 2635
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 已提交
2636 2637 2638 2639 2640 2641 2642 2643 2644
{
	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 已提交
2645
	while (len) {
L
Linus Torvalds 已提交
2646 2647 2648
		buffer_info = &tx_ring->buffer_info[i];
		size = min(len, max_per_txd);
#ifdef NETIF_F_TSO
J
Jeff Kirsher 已提交
2649 2650 2651 2652 2653 2654 2655 2656 2657 2658
		/* 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
		 * DMAd to the controller */
		if (!skb->data_len && tx_ring->last_tx_tso &&
				!skb_shinfo(skb)->tso_size) {
			tx_ring->last_tx_tso = 0;
			size -= 4;
		}

L
Linus Torvalds 已提交
2659 2660
		/* Workaround for premature desc write-backs
		 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2661
		if (unlikely(mss && !nr_frags && size == len && size > 8))
L
Linus Torvalds 已提交
2662 2663
			size -= 4;
#endif
2664 2665 2666 2667 2668
		/* 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 已提交
2669
		if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
2670 2671
		                (size > 2015) && count == 0))
		        size = 2015;
J
Jesse Brandeburg 已提交
2672

L
Linus Torvalds 已提交
2673 2674
		/* Workaround for potential 82544 hang in PCI-X.  Avoid
		 * terminating buffers within evenly-aligned dwords. */
J
Jesse Brandeburg 已提交
2675
		if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690
		   !((unsigned long)(skb->data + offset + size - 1) & 4) &&
		   size > 4))
			size -= 4;

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

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

J
Jesse Brandeburg 已提交
2694
	for (f = 0; f < nr_frags; f++) {
L
Linus Torvalds 已提交
2695 2696 2697 2698 2699 2700
		struct skb_frag_struct *frag;

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

J
Jesse Brandeburg 已提交
2701
		while (len) {
L
Linus Torvalds 已提交
2702 2703 2704 2705 2706
			buffer_info = &tx_ring->buffer_info[i];
			size = min(len, max_per_txd);
#ifdef NETIF_F_TSO
			/* Workaround for premature desc write-backs
			 * in TSO mode.  Append 4-byte sentinel desc */
J
Jesse Brandeburg 已提交
2707
			if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
L
Linus Torvalds 已提交
2708 2709 2710 2711 2712
				size -= 4;
#endif
			/* Workaround for potential 82544 hang in PCI-X.
			 * Avoid terminating buffers within evenly-aligned
			 * dwords. */
J
Jesse Brandeburg 已提交
2713
			if (unlikely(adapter->pcix_82544 &&
L
Linus Torvalds 已提交
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729
			   !((unsigned long)(frag->page+offset+size-1) & 4) &&
			   size > 4))
				size -= 4;

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

			len -= size;
			offset += size;
			count++;
J
Jesse Brandeburg 已提交
2730
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
		}
	}

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

static inline void
2742 2743
e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
               int tx_flags, int count)
L
Linus Torvalds 已提交
2744 2745 2746 2747 2748 2749
{
	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 已提交
2750
	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
L
Linus Torvalds 已提交
2751 2752
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
		             E1000_TXD_CMD_TSE;
2753 2754
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;

J
Jesse Brandeburg 已提交
2755
		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2756
			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
L
Linus Torvalds 已提交
2757 2758
	}

J
Jesse Brandeburg 已提交
2759
	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
L
Linus Torvalds 已提交
2760 2761 2762 2763
		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
	}

J
Jesse Brandeburg 已提交
2764
	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
L
Linus Torvalds 已提交
2765 2766 2767 2768 2769 2770
		txd_lower |= E1000_TXD_CMD_VLE;
		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
	}

	i = tx_ring->next_to_use;

J
Jesse Brandeburg 已提交
2771
	while (count--) {
L
Linus Torvalds 已提交
2772 2773 2774 2775 2776 2777
		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 已提交
2778
		if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789
	}

	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;
2790
	writel(i, adapter->hw.hw_addr + tx_ring->tdt);
L
Linus Torvalds 已提交
2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
}

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

static inline int
e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
{
	uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
	uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;

	E1000_ROUNDUP(skb_fifo_len, E1000_FIFO_HDR);

J
Jesse Brandeburg 已提交
2813
	if (adapter->link_duplex != HALF_DUPLEX)
L
Linus Torvalds 已提交
2814 2815
		goto no_fifo_stall_required;

J
Jesse Brandeburg 已提交
2816
	if (atomic_read(&adapter->tx_fifo_stall))
L
Linus Torvalds 已提交
2817 2818
		return 1;

J
Jesse Brandeburg 已提交
2819
	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
L
Linus Torvalds 已提交
2820 2821 2822 2823 2824 2825
		atomic_set(&adapter->tx_fifo_stall, 1);
		return 1;
	}

no_fifo_stall_required:
	adapter->tx_fifo_head += skb_fifo_len;
J
Jesse Brandeburg 已提交
2826
	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
L
Linus Torvalds 已提交
2827 2828 2829 2830
		adapter->tx_fifo_head -= adapter->tx_fifo_size;
	return 0;
}

2831 2832 2833 2834 2835 2836
#define MINIMUM_DHCP_PACKET_SIZE 282
static inline int
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 已提交
2837 2838
	if (vlan_tx_tag_present(skb)) {
		if (!((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
2839 2840 2841 2842
			( adapter->hw.mng_cookie.status &
			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) )
			return 0;
	}
J
Jesse Brandeburg 已提交
2843
	if ((skb->len > MINIMUM_DHCP_PACKET_SIZE) && (!skb->protocol)) {
2844
		struct ethhdr *eth = (struct ethhdr *) skb->data;
J
Jesse Brandeburg 已提交
2845 2846
		if ((htons(ETH_P_IP) == eth->h_proto)) {
			const struct iphdr *ip =
2847
				(struct iphdr *)((uint8_t *)skb->data+14);
J
Jesse Brandeburg 已提交
2848 2849 2850
			if (IPPROTO_UDP == ip->protocol) {
				struct udphdr *udp =
					(struct udphdr *)((uint8_t *)ip +
2851
						(ip->ihl << 2));
J
Jesse Brandeburg 已提交
2852
				if (ntohs(udp->dest) == 67) {
2853 2854 2855 2856
					offset = (uint8_t *)udp + 8 - skb->data;
					length = skb->len - offset;

					return e1000_mng_write_dhcp_info(hw,
J
Jesse Brandeburg 已提交
2857
							(uint8_t *)udp + 8,
2858 2859 2860 2861 2862 2863 2864 2865
							length);
				}
			}
		}
	}
	return 0;
}

L
Linus Torvalds 已提交
2866 2867 2868 2869
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
static int
e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
{
2870
	struct e1000_adapter *adapter = netdev_priv(netdev);
2871
	struct e1000_tx_ring *tx_ring;
L
Linus Torvalds 已提交
2872 2873 2874 2875 2876 2877 2878 2879
	unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
	unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
	unsigned int tx_flags = 0;
	unsigned int len = skb->len;
	unsigned long flags;
	unsigned int nr_frags = 0;
	unsigned int mss = 0;
	int count = 0;
J
Jesse Brandeburg 已提交
2880
 	int tso;
L
Linus Torvalds 已提交
2881 2882 2883
	unsigned int f;
	len -= skb->data_len;

2884 2885 2886
#ifdef CONFIG_E1000_MQ
	tx_ring = *per_cpu_ptr(adapter->cpu_tx_ring, smp_processor_id());
#else
2887
	tx_ring = adapter->tx_ring;
2888 2889
#endif

2890
	if (unlikely(skb->len <= 0)) {
L
Linus Torvalds 已提交
2891 2892 2893 2894 2895 2896
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}

#ifdef NETIF_F_TSO
	mss = skb_shinfo(skb)->tso_size;
2897
	/* The controller does a simple calculation to 
L
Linus Torvalds 已提交
2898 2899 2900 2901 2902
	 * 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 已提交
2903
	if (mss) {
J
Jeff Kirsher 已提交
2904
		uint8_t hdr_len;
L
Linus Torvalds 已提交
2905 2906
		max_per_txd = min(mss << 2, max_per_txd);
		max_txd_pwr = fls(max_per_txd) - 1;
J
Jeff Kirsher 已提交
2907 2908 2909 2910 2911 2912 2913 2914

	/* TSO Workaround for 82571/2 Controllers -- if skb->data
	 * points to just header, pull a few bytes of payload from
	 * frags into skb->data */
		hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
		if (skb->data_len && (hdr_len == (skb->len - skb->data_len)) &&
			(adapter->hw.mac_type == e1000_82571 ||
			adapter->hw.mac_type == e1000_82572)) {
2915 2916 2917 2918 2919 2920 2921
			unsigned int pull_size;
			pull_size = min((unsigned int)4, skb->data_len);
			if (!__pskb_pull_tail(skb, pull_size)) {
				printk(KERN_ERR "__pskb_pull_tail failed.\n");
				dev_kfree_skb_any(skb);
				return -EFAULT;
			}
J
Jeff Kirsher 已提交
2922 2923
			len = skb->len - skb->data_len;
		}
L
Linus Torvalds 已提交
2924 2925
	}

J
Jeff Kirsher 已提交
2926
	/* reserve a descriptor for the offload context */
J
Jesse Brandeburg 已提交
2927
	if ((mss) || (skb->ip_summed == CHECKSUM_HW))
L
Linus Torvalds 已提交
2928
		count++;
2929
	count++;
L
Linus Torvalds 已提交
2930
#else
J
Jesse Brandeburg 已提交
2931
	if (skb->ip_summed == CHECKSUM_HW)
L
Linus Torvalds 已提交
2932 2933
		count++;
#endif
J
Jeff Kirsher 已提交
2934 2935 2936 2937 2938 2939 2940 2941

#ifdef NETIF_F_TSO
	/* Controller Erratum workaround */
	if (!skb->data_len && tx_ring->last_tx_tso &&
		!skb_shinfo(skb)->tso_size)
		count++;
#endif

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

J
Jesse Brandeburg 已提交
2944
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
2945 2946
		count++;

J
Jesse Brandeburg 已提交
2947
	/* work-around for errata 10 and it applies to all controllers
2948 2949
	 * in PCI-X mode, so add one more descriptor to the count
	 */
J
Jesse Brandeburg 已提交
2950
	if (unlikely((adapter->hw.bus_type == e1000_bus_type_pcix) &&
2951 2952 2953
			(len > 2015)))
		count++;

L
Linus Torvalds 已提交
2954
	nr_frags = skb_shinfo(skb)->nr_frags;
J
Jesse Brandeburg 已提交
2955
	for (f = 0; f < nr_frags; f++)
L
Linus Torvalds 已提交
2956 2957
		count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
				       max_txd_pwr);
J
Jesse Brandeburg 已提交
2958
	if (adapter->pcix_82544)
L
Linus Torvalds 已提交
2959 2960
		count += nr_frags;

J
Jesse Brandeburg 已提交
2961
	if (adapter->hw.tx_pkt_filtering && (adapter->hw.mac_type == e1000_82573) )
2962 2963
		e1000_transfer_dhcp_info(adapter, skb);

2964 2965 2966 2967 2968 2969
	local_irq_save(flags);
	if (!spin_trylock(&tx_ring->tx_lock)) {
		/* Collision - tell upper layer to requeue */
		local_irq_restore(flags);
		return NETDEV_TX_LOCKED;
	}
L
Linus Torvalds 已提交
2970 2971 2972

	/* need: count + 2 desc gap to keep tail from touching
	 * head, otherwise try next time */
2973
	if (unlikely(E1000_DESC_UNUSED(tx_ring) < count + 2)) {
L
Linus Torvalds 已提交
2974
		netif_stop_queue(netdev);
2975
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2976 2977 2978
		return NETDEV_TX_BUSY;
	}

J
Jesse Brandeburg 已提交
2979 2980
	if (unlikely(adapter->hw.mac_type == e1000_82547)) {
		if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
L
Linus Torvalds 已提交
2981 2982
			netif_stop_queue(netdev);
			mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
2983
			spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2984 2985 2986 2987
			return NETDEV_TX_BUSY;
		}
	}

J
Jesse Brandeburg 已提交
2988
	if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
L
Linus Torvalds 已提交
2989 2990 2991 2992
		tx_flags |= E1000_TX_FLAGS_VLAN;
		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
	}

2993
	first = tx_ring->next_to_use;
J
Jesse Brandeburg 已提交
2994

2995
	tso = e1000_tso(adapter, tx_ring, skb);
L
Linus Torvalds 已提交
2996 2997
	if (tso < 0) {
		dev_kfree_skb_any(skb);
2998
		spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
2999 3000 3001
		return NETDEV_TX_OK;
	}

J
Jeff Kirsher 已提交
3002 3003
	if (likely(tso)) {
		tx_ring->last_tx_tso = 1;
L
Linus Torvalds 已提交
3004
		tx_flags |= E1000_TX_FLAGS_TSO;
J
Jeff Kirsher 已提交
3005
	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
L
Linus Torvalds 已提交
3006 3007
		tx_flags |= E1000_TX_FLAGS_CSUM;

3008
	/* Old method was to assume IPv4 packet by default if TSO was enabled.
3009
	 * 82571 hardware supports TSO capabilities for IPv6 as well...
3010
	 * no longer assume, we must. */
3011
	if (likely(skb->protocol == ntohs(ETH_P_IP)))
3012 3013
		tx_flags |= E1000_TX_FLAGS_IPV4;

3014 3015 3016
	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 已提交
3017 3018 3019 3020

	netdev->trans_start = jiffies;

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

3024
	spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
L
Linus Torvalds 已提交
3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035
	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)
{
3036
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3037 3038 3039 3040 3041 3042 3043 3044

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

static void
e1000_tx_timeout_task(struct net_device *netdev)
{
3045
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3046

J
Jeff Kirsher 已提交
3047
	adapter->tx_timeout_count++;
L
Linus Torvalds 已提交
3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062
	e1000_down(adapter);
	e1000_up(adapter);
}

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

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

J
Jeff Kirsher 已提交
3065
	/* only return the current stats */
L
Linus Torvalds 已提交
3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
	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)
{
3080
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3081 3082
	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;

J
Jesse Brandeburg 已提交
3083 3084 3085
	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
		DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
L
Linus Torvalds 已提交
3086
		return -EINVAL;
3087
	}
L
Linus Torvalds 已提交
3088

3089 3090 3091 3092 3093 3094 3095
	/* Adapter-specific max frame size limits. */
	switch (adapter->hw.mac_type) {
	case e1000_82542_rev2_0:
	case e1000_82542_rev2_1:
	case e1000_82573:
		if (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE) {
			DPRINTK(PROBE, ERR, "Jumbo Frames not supported.\n");
3096 3097
			return -EINVAL;
		}
3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109
		break;
	case e1000_82571:
	case e1000_82572:
#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 已提交
3110 3111
	}

3112 3113

	if (adapter->hw.mac_type > e1000_82547_rev_2) {
3114
		adapter->rx_buffer_len = max_frame;
3115
		E1000_ROUNDUP(adapter->rx_buffer_len, 1024);
3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132
	} else {
		if(unlikely((adapter->hw.mac_type < e1000_82543) &&
		   (max_frame > MAXIMUM_ETHERNET_FRAME_SIZE))) {
			DPRINTK(PROBE, ERR, "Jumbo Frames not supported "
					    "on 82542\n");
			return -EINVAL;
		} else {
			if(max_frame <= E1000_RXBUFFER_2048)
				adapter->rx_buffer_len = E1000_RXBUFFER_2048;
			else if(max_frame <= E1000_RXBUFFER_4096)
				adapter->rx_buffer_len = E1000_RXBUFFER_4096;
			else if(max_frame <= E1000_RXBUFFER_8192)
				adapter->rx_buffer_len = E1000_RXBUFFER_8192;
			else if(max_frame <= E1000_RXBUFFER_16384)
				adapter->rx_buffer_len = E1000_RXBUFFER_16384;
		}
	}
3133

3134 3135
	netdev->mtu = new_mtu;

J
Jesse Brandeburg 已提交
3136
	if (netif_running(netdev)) {
L
Linus Torvalds 已提交
3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
		e1000_down(adapter);
		e1000_up(adapter);
	}

	adapter->hw.max_frame_size = max_frame;

	return 0;
}

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

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

#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF

	spin_lock_irqsave(&adapter->stats_lock, flags);

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

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

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

	/* used for adaptive IFS */

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

J
Jesse Brandeburg 已提交
3223
	if (hw->mac_type >= e1000_82543) {
L
Linus Torvalds 已提交
3224 3225 3226 3227 3228 3229 3230
		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 已提交
3231
	if (hw->mac_type > e1000_82547_rev_2) {
3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
		adapter->stats.iac += E1000_READ_REG(hw, IAC);
		adapter->stats.icrxoc += E1000_READ_REG(hw, ICRXOC);
		adapter->stats.icrxptc += E1000_READ_REG(hw, ICRXPTC);
		adapter->stats.icrxatc += E1000_READ_REG(hw, ICRXATC);
		adapter->stats.ictxptc += E1000_READ_REG(hw, ICTXPTC);
		adapter->stats.ictxatc += E1000_READ_REG(hw, ICTXATC);
		adapter->stats.ictxqec += E1000_READ_REG(hw, ICTXQEC);
		adapter->stats.ictxqmtc += E1000_READ_REG(hw, ICTXQMTC);
		adapter->stats.icrxdmtc += E1000_READ_REG(hw, ICRXDMTC);
	}
L
Linus Torvalds 已提交
3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255

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

	adapter->net_stats.rx_errors = adapter->stats.rxerrc +
		adapter->stats.crcerrs + adapter->stats.algnerrc +
J
Jeff Kirsher 已提交
3256 3257
		adapter->stats.rlec + adapter->stats.cexterr;
	adapter->net_stats.rx_dropped = 0;
L
Linus Torvalds 已提交
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274
	adapter->net_stats.rx_length_errors = adapter->stats.rlec;
	adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
	adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
	adapter->net_stats.rx_missed_errors = adapter->stats.mpc;

	/* Tx Errors */

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

	/* Tx Dropped needs to be maintained elsewhere */

	/* Phy Stats */

J
Jesse Brandeburg 已提交
3275 3276
	if (hw->media_type == e1000_media_type_copper) {
		if ((adapter->link_speed == SPEED_1000) &&
L
Linus Torvalds 已提交
3277 3278 3279 3280 3281
		   (!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 已提交
3282
		if ((hw->mac_type <= e1000_82546) &&
L
Linus Torvalds 已提交
3283 3284 3285 3286 3287 3288 3289 3290
		   (hw->phy_type == e1000_phy_m88) &&
		   !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
			adapter->phy_stats.receive_errors += phy_tmp;
	}

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

3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313
#ifdef CONFIG_E1000_MQ
void
e1000_rx_schedule(void *data)
{
	struct net_device *poll_dev, *netdev = data;
	struct e1000_adapter *adapter = netdev->priv;
	int this_cpu = get_cpu();

	poll_dev = *per_cpu_ptr(adapter->cpu_netdev, this_cpu);
	if (poll_dev == NULL) {
		put_cpu();
		return;
	}

	if (likely(netif_rx_schedule_prep(poll_dev)))
		__netif_rx_schedule(poll_dev);
	else
		e1000_irq_enable(adapter);

	put_cpu();
}
#endif

L
Linus Torvalds 已提交
3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324
/**
 * e1000_intr - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 * @pt_regs: CPU registers structure
 **/

static irqreturn_t
e1000_intr(int irq, void *data, struct pt_regs *regs)
{
	struct net_device *netdev = data;
3325
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
3326 3327
	struct e1000_hw *hw = &adapter->hw;
	uint32_t icr = E1000_READ_REG(hw, ICR);
3328
#ifndef CONFIG_E1000_NAPI
3329
	int i;
3330 3331 3332 3333 3334 3335 3336
#else
	/* Interrupt Auto-Mask...upon reading ICR,
	 * interrupts are masked.  No need for the
	 * IMC write, but it does mean we should
	 * account for it ASAP. */
	if (likely(hw->mac_type >= e1000_82571))
		atomic_inc(&adapter->irq_sem);
J
Jeff Garzik 已提交
3337
#endif
L
Linus Torvalds 已提交
3338

3339 3340 3341 3342 3343
	if (unlikely(!icr)) {
#ifdef CONFIG_E1000_NAPI
		if (hw->mac_type >= e1000_82571)
			e1000_irq_enable(adapter);
#endif
L
Linus Torvalds 已提交
3344
		return IRQ_NONE;  /* Not our interrupt */
3345
	}
L
Linus Torvalds 已提交
3346

J
Jesse Brandeburg 已提交
3347
	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
L
Linus Torvalds 已提交
3348 3349 3350 3351 3352
		hw->get_link_status = 1;
		mod_timer(&adapter->watchdog_timer, jiffies);
	}

#ifdef CONFIG_E1000_NAPI
3353 3354 3355 3356 3357
	if (unlikely(hw->mac_type < e1000_82571)) {
		atomic_inc(&adapter->irq_sem);
		E1000_WRITE_REG(hw, IMC, ~0);
		E1000_WRITE_FLUSH(hw);
	}
3358 3359
#ifdef CONFIG_E1000_MQ
	if (atomic_read(&adapter->rx_sched_call_data.count) == 0) {
3360 3361 3362 3363 3364 3365
		/* We must setup the cpumask once count == 0 since
		 * each cpu bit is cleared when the work is done. */
		adapter->rx_sched_call_data.cpumask = adapter->cpumask;
		atomic_add(adapter->num_rx_queues - 1, &adapter->irq_sem);
		atomic_set(&adapter->rx_sched_call_data.count,
		           adapter->num_rx_queues);
3366 3367 3368
		smp_call_async_mask(&adapter->rx_sched_call_data);
	} else {
		printk("call_data.count == %u\n", atomic_read(&adapter->rx_sched_call_data.count));
L
Linus Torvalds 已提交
3369
	}
J
Jeff Garzik 已提交
3370
#else /* if !CONFIG_E1000_MQ */
3371 3372 3373 3374
	if (likely(netif_rx_schedule_prep(&adapter->polling_netdev[0])))
		__netif_rx_schedule(&adapter->polling_netdev[0]);
	else
		e1000_irq_enable(adapter);
J
Jeff Garzik 已提交
3375 3376 3377
#endif /* CONFIG_E1000_MQ */

#else /* if !CONFIG_E1000_NAPI */
L
Linus Torvalds 已提交
3378
	/* Writing IMC and IMS is needed for 82547.
J
Jesse Brandeburg 已提交
3379 3380 3381 3382 3383 3384 3385 3386 3387 3388
	 * 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 已提交
3389
		atomic_inc(&adapter->irq_sem);
3390
		E1000_WRITE_REG(hw, IMC, ~0);
L
Linus Torvalds 已提交
3391 3392
	}

J
Jesse Brandeburg 已提交
3393 3394
	for (i = 0; i < E1000_MAX_INTR; i++)
		if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) &
3395
		   !e1000_clean_tx_irq(adapter, adapter->tx_ring)))
L
Linus Torvalds 已提交
3396 3397
			break;

J
Jesse Brandeburg 已提交
3398
	if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)
L
Linus Torvalds 已提交
3399
		e1000_irq_enable(adapter);
3400

J
Jeff Garzik 已提交
3401
#endif /* CONFIG_E1000_NAPI */
L
Linus Torvalds 已提交
3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412

	return IRQ_HANDLED;
}

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

static int
3413
e1000_clean(struct net_device *poll_dev, int *budget)
L
Linus Torvalds 已提交
3414
{
3415 3416
	struct e1000_adapter *adapter;
	int work_to_do = min(*budget, poll_dev->quota);
3417
	int tx_cleaned = 0, i = 0, work_done = 0;
3418 3419 3420 3421 3422 3423 3424

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

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

3426 3427
	while (poll_dev != &adapter->polling_netdev[i]) {
		i++;
3428
		if (unlikely(i == adapter->num_rx_queues))
3429 3430 3431
			BUG();
	}

3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444
	if (likely(adapter->num_tx_queues == 1)) {
		/* e1000_clean is called per-cpu.  This lock protects
		 * tx_ring[0] from being cleaned by multiple cpus
		 * simultaneously.  A failure obtaining the lock means
		 * tx_ring[0] is currently being cleaned anyway. */
		if (spin_trylock(&adapter->tx_queue_lock)) {
			tx_cleaned = e1000_clean_tx_irq(adapter,
							&adapter->tx_ring[0]);
			spin_unlock(&adapter->tx_queue_lock);
		}
	} else
		tx_cleaned = e1000_clean_tx_irq(adapter, &adapter->tx_ring[i]);

3445 3446
	adapter->clean_rx(adapter, &adapter->rx_ring[i],
	                  &work_done, work_to_do);
L
Linus Torvalds 已提交
3447 3448

	*budget -= work_done;
3449
	poll_dev->quota -= work_done;
J
Jesse Brandeburg 已提交
3450

3451
	/* If no Tx and not enough Rx work done, exit the polling mode */
J
Jesse Brandeburg 已提交
3452
	if ((!tx_cleaned && (work_done == 0)) ||
3453 3454 3455
	   !netif_running(adapter->netdev)) {
quit_polling:
		netif_rx_complete(poll_dev);
L
Linus Torvalds 已提交
3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469
		e1000_irq_enable(adapter);
		return 0;
	}

	return 1;
}

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

static boolean_t
3470 3471
e1000_clean_tx_irq(struct e1000_adapter *adapter,
                   struct e1000_tx_ring *tx_ring)
L
Linus Torvalds 已提交
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482
{
	struct net_device *netdev = adapter->netdev;
	struct e1000_tx_desc *tx_desc, *eop_desc;
	struct e1000_buffer *buffer_info;
	unsigned int i, eop;
	boolean_t cleaned = FALSE;

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

3483
	while (eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
J
Jesse Brandeburg 已提交
3484
		for (cleaned = FALSE; !cleaned; ) {
L
Linus Torvalds 已提交
3485 3486 3487 3488
			tx_desc = E1000_TX_DESC(*tx_ring, i);
			buffer_info = &tx_ring->buffer_info[i];
			cleaned = (i == eop);

3489 3490 3491
#ifdef CONFIG_E1000_MQ
			tx_ring->tx_stats.bytes += buffer_info->length;
#endif
J
Jeff Kirsher 已提交
3492
			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3493
			memset(tx_desc, 0, sizeof(struct e1000_tx_desc));
L
Linus Torvalds 已提交
3494

J
Jesse Brandeburg 已提交
3495
			if (unlikely(++i == tx_ring->count)) i = 0;
L
Linus Torvalds 已提交
3496
		}
3497

3498 3499 3500 3501
#ifdef CONFIG_E1000_MQ
		tx_ring->tx_stats.packets++;
#endif

L
Linus Torvalds 已提交
3502 3503 3504 3505 3506 3507
		eop = tx_ring->buffer_info[i].next_to_watch;
		eop_desc = E1000_TX_DESC(*tx_ring, eop);
	}

	tx_ring->next_to_clean = i;

3508
	spin_lock(&tx_ring->tx_lock);
L
Linus Torvalds 已提交
3509

J
Jesse Brandeburg 已提交
3510
	if (unlikely(cleaned && netif_queue_stopped(netdev) &&
L
Linus Torvalds 已提交
3511 3512 3513
		    netif_carrier_ok(netdev)))
		netif_wake_queue(netdev);

3514
	spin_unlock(&tx_ring->tx_lock);
3515

3516
	if (adapter->detect_tx_hung) {
3517
		/* Detect a transmit hang in hardware, this serializes the
L
Linus Torvalds 已提交
3518 3519
		 * check with the clearing of time_stamp and movement of i */
		adapter->detect_tx_hung = FALSE;
3520 3521 3522
		if (tx_ring->buffer_info[eop].dma &&
		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
		               adapter->tx_timeout_factor * HZ)
3523
		    && !(E1000_READ_REG(&adapter->hw, STATUS) &
3524
		         E1000_STATUS_TXOFF)) {
3525 3526

			/* detected Tx unit hang */
3527
			DPRINTK(DRV, ERR, "Detected Tx Unit Hang\n"
3528
					"  Tx Queue             <%lu>\n"
3529 3530 3531 3532 3533 3534 3535 3536 3537
					"  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",
3538 3539
				(unsigned long)((tx_ring - adapter->tx_ring) /
					sizeof(struct e1000_tx_ring)),
3540 3541
				readl(adapter->hw.hw_addr + tx_ring->tdh),
				readl(adapter->hw.hw_addr + tx_ring->tdt),
3542
				tx_ring->next_to_use,
3543 3544
				tx_ring->next_to_clean,
				tx_ring->buffer_info[eop].time_stamp,
3545 3546 3547
				eop,
				jiffies,
				eop_desc->upper.fields.status);
L
Linus Torvalds 已提交
3548
			netif_stop_queue(netdev);
3549
		}
L
Linus Torvalds 已提交
3550 3551 3552 3553 3554 3555
	}
	return cleaned;
}

/**
 * e1000_rx_checksum - Receive Checksum Offload for 82543
3556 3557 3558 3559
 * @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 已提交
3560 3561 3562 3563
 **/

static inline void
e1000_rx_checksum(struct e1000_adapter *adapter,
3564 3565
		  uint32_t status_err, uint32_t csum,
		  struct sk_buff *skb)
L
Linus Torvalds 已提交
3566
{
3567 3568 3569 3570
	uint16_t status = (uint16_t)status_err;
	uint8_t errors = (uint8_t)(status_err >> 24);
	skb->ip_summed = CHECKSUM_NONE;

L
Linus Torvalds 已提交
3571
	/* 82543 or newer only */
J
Jesse Brandeburg 已提交
3572
	if (unlikely(adapter->hw.mac_type < e1000_82543)) return;
L
Linus Torvalds 已提交
3573
	/* Ignore Checksum bit is set */
J
Jesse Brandeburg 已提交
3574
	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3575
	/* TCP/UDP checksum error bit is set */
J
Jesse Brandeburg 已提交
3576
	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
L
Linus Torvalds 已提交
3577 3578
		/* let the stack verify checksum errors */
		adapter->hw_csum_err++;
3579 3580 3581
		return;
	}
	/* TCP/UDP Checksum has not been calculated */
J
Jesse Brandeburg 已提交
3582 3583
	if (adapter->hw.mac_type <= e1000_82547_rev_2) {
		if (!(status & E1000_RXD_STAT_TCPCS))
3584
			return;
L
Linus Torvalds 已提交
3585
	} else {
J
Jesse Brandeburg 已提交
3586
		if (!(status & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)))
3587 3588 3589 3590
			return;
	}
	/* It must be a TCP or UDP packet with a valid checksum */
	if (likely(status & E1000_RXD_STAT_TCPCS)) {
L
Linus Torvalds 已提交
3591 3592
		/* TCP checksum is good */
		skb->ip_summed = CHECKSUM_UNNECESSARY;
3593 3594 3595 3596 3597 3598 3599 3600
	} else if (adapter->hw.mac_type > e1000_82547_rev_2) {
		/* IP fragment with UDP payload */
		/* Hardware complements the payload checksum, so we undo it
		 * and then put the value in host order for further stack use.
		 */
		csum = ntohl(csum ^ 0xFFFF);
		skb->csum = csum;
		skb->ip_summed = CHECKSUM_HW;
L
Linus Torvalds 已提交
3601
	}
3602
	adapter->hw_csum_good++;
L
Linus Torvalds 已提交
3603 3604 3605
}

/**
3606
 * e1000_clean_rx_irq - Send received data up the network stack; legacy
L
Linus Torvalds 已提交
3607 3608 3609 3610 3611
 * @adapter: board private structure
 **/

static boolean_t
#ifdef CONFIG_E1000_NAPI
3612 3613 3614
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring,
                   int *work_done, int work_to_do)
L
Linus Torvalds 已提交
3615
#else
3616 3617
e1000_clean_rx_irq(struct e1000_adapter *adapter,
                   struct e1000_rx_ring *rx_ring)
L
Linus Torvalds 已提交
3618 3619 3620 3621
#endif
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3622 3623
	struct e1000_rx_desc *rx_desc, *next_rxd;
	struct e1000_buffer *buffer_info, *next_buffer;
L
Linus Torvalds 已提交
3624 3625 3626 3627
	unsigned long flags;
	uint32_t length;
	uint8_t last_byte;
	unsigned int i;
3628
	int cleaned_count = 0;
3629
	boolean_t cleaned = FALSE;
L
Linus Torvalds 已提交
3630 3631 3632

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

3635
	while (rx_desc->status & E1000_RXD_STAT_DD) {
3636
		struct sk_buff *skb, *next_skb;
3637
		u8 status;
L
Linus Torvalds 已提交
3638
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3639
		if (*work_done >= work_to_do)
L
Linus Torvalds 已提交
3640 3641 3642
			break;
		(*work_done)++;
#endif
3643
		status = rx_desc->status;
3644
		skb = buffer_info->skb;
3645 3646 3647 3648 3649 3650 3651
		buffer_info->skb = NULL;

		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC(*rx_ring, i);
		next_buffer = &rx_ring->buffer_info[i];
		next_skb = next_buffer->skb;

3652 3653
		cleaned = TRUE;
		cleaned_count++;
3654 3655 3656
		pci_unmap_single(pdev,
		                 buffer_info->dma,
		                 buffer_info->length,
L
Linus Torvalds 已提交
3657 3658 3659 3660
		                 PCI_DMA_FROMDEVICE);

		length = le16_to_cpu(rx_desc->length);

3661 3662 3663 3664 3665
		if (unlikely(!(status & E1000_RXD_STAT_EOP))) {
			/* All receives must fit into a single buffer */
			E1000_DBG("%s: Receive packet consumed multiple"
				  " buffers\n", netdev->name);
			dev_kfree_skb_irq(skb);
L
Linus Torvalds 已提交
3666 3667 3668
			goto next_desc;
		}

J
Jesse Brandeburg 已提交
3669
		if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
L
Linus Torvalds 已提交
3670
			last_byte = *(skb->data + length - 1);
3671
			if (TBI_ACCEPT(&adapter->hw, status,
L
Linus Torvalds 已提交
3672 3673
			              rx_desc->errors, length, last_byte)) {
				spin_lock_irqsave(&adapter->stats_lock, flags);
3674 3675
				e1000_tbi_adjust_stats(&adapter->hw,
				                       &adapter->stats,
L
Linus Torvalds 已提交
3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
				                       length, skb->data);
				spin_unlock_irqrestore(&adapter->stats_lock,
				                       flags);
				length--;
			} else {
				dev_kfree_skb_irq(skb);
				goto next_desc;
			}
		}

3686 3687 3688 3689
		/* code added for copybreak, this should improve
		 * performance for small packets with large amounts
		 * of reassembly being done in the stack */
#define E1000_CB_LENGTH 256
3690
		if (length < E1000_CB_LENGTH) {
3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703
			struct sk_buff *new_skb =
			    dev_alloc_skb(length + NET_IP_ALIGN);
			if (new_skb) {
				skb_reserve(new_skb, NET_IP_ALIGN);
				new_skb->dev = netdev;
				memcpy(new_skb->data - NET_IP_ALIGN,
				       skb->data - NET_IP_ALIGN,
				       length + NET_IP_ALIGN);
				/* save the skb in buffer_info as good */
				buffer_info->skb = skb;
				skb = new_skb;
				skb_put(skb, length);
			}
3704 3705
		} else
			skb_put(skb, length);
3706 3707

		/* end copybreak code */
L
Linus Torvalds 已提交
3708 3709

		/* Receive Checksum Offload */
3710 3711
		e1000_rx_checksum(adapter,
				  (uint32_t)(status) |
3712 3713
				  ((uint32_t)(rx_desc->errors) << 24),
				  rx_desc->csum, skb);
J
Jesse Brandeburg 已提交
3714

L
Linus Torvalds 已提交
3715 3716
		skb->protocol = eth_type_trans(skb, netdev);
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3717
		if (unlikely(adapter->vlgrp &&
3718
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
3719
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
3720 3721
						 le16_to_cpu(rx_desc->special) &
						 E1000_RXD_SPC_VLAN_MASK);
L
Linus Torvalds 已提交
3722 3723 3724 3725
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
3726
		if (unlikely(adapter->vlgrp &&
3727
			    (status & E1000_RXD_STAT_VP))) {
L
Linus Torvalds 已提交
3728 3729 3730 3731 3732 3733 3734 3735
			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;
3736 3737 3738 3739
#ifdef CONFIG_E1000_MQ
		rx_ring->rx_stats.packets++;
		rx_ring->rx_stats.bytes += length;
#endif
L
Linus Torvalds 已提交
3740 3741 3742 3743

next_desc:
		rx_desc->status = 0;

3744 3745 3746 3747 3748 3749
		/* 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;
		}

3750 3751
		rx_desc = next_rxd;
		buffer_info = next_buffer;
L
Linus Torvalds 已提交
3752 3753
	}
	rx_ring->next_to_clean = i;
3754 3755 3756 3757

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768

	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
3769 3770 3771
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring,
                      int *work_done, int work_to_do)
3772
#else
3773 3774
e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                      struct e1000_rx_ring *rx_ring)
3775 3776
#endif
{
3777
	union e1000_rx_desc_packet_split *rx_desc, *next_rxd;
3778 3779
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
3780
	struct e1000_buffer *buffer_info, *next_buffer;
3781 3782
	struct e1000_ps_page *ps_page;
	struct e1000_ps_page_dma *ps_page_dma;
3783
	struct sk_buff *skb, *next_skb;
3784 3785
	unsigned int i, j;
	uint32_t length, staterr;
3786
	int cleaned_count = 0;
3787 3788 3789 3790
	boolean_t cleaned = FALSE;

	i = rx_ring->next_to_clean;
	rx_desc = E1000_RX_DESC_PS(*rx_ring, i);
3791
	staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
3792
	buffer_info = &rx_ring->buffer_info[i];
3793

J
Jesse Brandeburg 已提交
3794
	while (staterr & E1000_RXD_STAT_DD) {
3795 3796 3797
		ps_page = &rx_ring->ps_page[i];
		ps_page_dma = &rx_ring->ps_page_dma[i];
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3798
		if (unlikely(*work_done >= work_to_do))
3799 3800 3801
			break;
		(*work_done)++;
#endif
3802 3803 3804 3805 3806 3807 3808
		skb = buffer_info->skb;

		if (++i == rx_ring->count) i = 0;
		next_rxd = E1000_RX_DESC_PS(*rx_ring, i);
		next_buffer = &rx_ring->buffer_info[i];
		next_skb = next_buffer->skb;

3809
		cleaned = TRUE;
3810
		cleaned_count++;
3811 3812 3813 3814
		pci_unmap_single(pdev, buffer_info->dma,
				 buffer_info->length,
				 PCI_DMA_FROMDEVICE);

J
Jesse Brandeburg 已提交
3815
		if (unlikely(!(staterr & E1000_RXD_STAT_EOP))) {
3816 3817 3818 3819 3820
			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 已提交
3821

J
Jesse Brandeburg 已提交
3822
		if (unlikely(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) {
3823 3824 3825 3826 3827 3828
			dev_kfree_skb_irq(skb);
			goto next_desc;
		}

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

J
Jesse Brandeburg 已提交
3829
		if (unlikely(!length)) {
3830 3831 3832 3833 3834 3835 3836 3837 3838
			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);

J
Jesse Brandeburg 已提交
3839 3840
		for (j = 0; j < adapter->rx_ps_pages; j++) {
			if (!(length = le16_to_cpu(rx_desc->wb.upper.length[j])))
3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859
				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;
			skb_shinfo(skb)->frags[j].page =
				ps_page->ps_page[j];
			ps_page->ps_page[j] = NULL;
			skb_shinfo(skb)->frags[j].page_offset = 0;
			skb_shinfo(skb)->frags[j].size = length;
			skb_shinfo(skb)->nr_frags++;
			skb->len += length;
			skb->data_len += length;
		}

		e1000_rx_checksum(adapter, staterr,
				  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
		skb->protocol = eth_type_trans(skb, netdev);

J
Jesse Brandeburg 已提交
3860
		if (likely(rx_desc->wb.upper.header_status &
3861
			  E1000_RXDPS_HDRSTAT_HDRSP))
3862
			adapter->rx_hdr_split++;
3863
#ifdef CONFIG_E1000_NAPI
J
Jesse Brandeburg 已提交
3864
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
3865
			vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
3866 3867
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
3868 3869 3870 3871
		} else {
			netif_receive_skb(skb);
		}
#else /* CONFIG_E1000_NAPI */
J
Jesse Brandeburg 已提交
3872
		if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) {
3873
			vlan_hwaccel_rx(skb, adapter->vlgrp,
3874 3875
				le16_to_cpu(rx_desc->wb.middle.vlan) &
				E1000_RXD_SPC_VLAN_MASK);
3876 3877 3878 3879 3880
		} else {
			netif_rx(skb);
		}
#endif /* CONFIG_E1000_NAPI */
		netdev->last_rx = jiffies;
3881 3882 3883 3884
#ifdef CONFIG_E1000_MQ
		rx_ring->rx_stats.packets++;
		rx_ring->rx_stats.bytes += length;
#endif
3885 3886 3887 3888 3889

next_desc:
		rx_desc->wb.middle.status_error &= ~0xFF;
		buffer_info->skb = NULL;

3890 3891 3892 3893 3894 3895
		/* 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;
		}

3896 3897 3898
		rx_desc = next_rxd;
		buffer_info = next_buffer;

3899
		staterr = le32_to_cpu(rx_desc->wb.middle.status_error);
3900 3901
	}
	rx_ring->next_to_clean = i;
3902 3903 3904 3905

	cleaned_count = E1000_DESC_UNUSED(rx_ring);
	if (cleaned_count)
		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
L
Linus Torvalds 已提交
3906 3907 3908 3909 3910

	return cleaned;
}

/**
3911
 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
L
Linus Torvalds 已提交
3912 3913 3914 3915
 * @adapter: address of board private structure
 **/

static void
3916
e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
3917
                       struct e1000_rx_ring *rx_ring,
3918
		       int cleaned_count)
L
Linus Torvalds 已提交
3919 3920 3921 3922 3923 3924
{
	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;
3925 3926
	unsigned int i;
	unsigned int bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
L
Linus Torvalds 已提交
3927 3928 3929 3930

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

3931 3932 3933 3934 3935 3936 3937 3938
	while (cleaned_count--) {
		if (!(skb = buffer_info->skb))
			skb = dev_alloc_skb(bufsz);
		else {
			skb_trim(skb, 0);
			goto map_skb;
		}

3939

J
Jesse Brandeburg 已提交
3940
		if (unlikely(!skb)) {
L
Linus Torvalds 已提交
3941
			/* Better luck next round */
3942
			adapter->alloc_rx_buff_failed++;
L
Linus Torvalds 已提交
3943 3944 3945
			break;
		}

3946
		/* Fix for errata 23, can't cross 64kB boundary */
L
Linus Torvalds 已提交
3947 3948
		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
			struct sk_buff *oldskb = skb;
3949 3950 3951
			DPRINTK(RX_ERR, ERR, "skb align check failed: %u bytes "
					     "at %p\n", bufsz, skb->data);
			/* Try again, without freeing the previous */
L
Linus Torvalds 已提交
3952
			skb = dev_alloc_skb(bufsz);
3953
			/* Failed allocation, critical failure */
L
Linus Torvalds 已提交
3954 3955 3956 3957
			if (!skb) {
				dev_kfree_skb(oldskb);
				break;
			}
3958

L
Linus Torvalds 已提交
3959 3960 3961 3962 3963 3964
			if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
				/* give up */
				dev_kfree_skb(skb);
				dev_kfree_skb(oldskb);
				break; /* while !buffer_info->skb */
			} else {
3965
				/* Use new allocation */
L
Linus Torvalds 已提交
3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
				dev_kfree_skb(oldskb);
			}
		}
		/* Make buffer alignment 2 beyond a 16 byte boundary
		 * this will result in a 16 byte aligned IP header after
		 * the 14 byte MAC header is removed
		 */
		skb_reserve(skb, NET_IP_ALIGN);

		skb->dev = netdev;

		buffer_info->skb = skb;
		buffer_info->length = adapter->rx_buffer_len;
3979
map_skb:
L
Linus Torvalds 已提交
3980 3981 3982 3983 3984
		buffer_info->dma = pci_map_single(pdev,
						  skb->data,
						  adapter->rx_buffer_len,
						  PCI_DMA_FROMDEVICE);

3985 3986 3987 3988 3989 3990 3991 3992
		/* 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 已提交
3993 3994 3995
			dev_kfree_skb(skb);
			buffer_info->skb = NULL;

3996
			pci_unmap_single(pdev, buffer_info->dma,
L
Linus Torvalds 已提交
3997 3998 3999 4000 4001 4002 4003 4004
					 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 已提交
4005 4006
		if (unlikely(++i == rx_ring->count))
			i = 0;
L
Linus Torvalds 已提交
4007 4008 4009
		buffer_info = &rx_ring->buffer_info[i];
	}

4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021
	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 已提交
4022 4023
}

4024 4025 4026 4027 4028 4029
/**
 * e1000_alloc_rx_buffers_ps - Replace used receive buffers; packet split
 * @adapter: address of board private structure
 **/

static void
4030
e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
4031 4032
                          struct e1000_rx_ring *rx_ring,
			  int cleaned_count)
4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047
{
	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];

4048
	while (cleaned_count--) {
4049 4050
		rx_desc = E1000_RX_DESC_PS(*rx_ring, i);

J
Jesse Brandeburg 已提交
4051
		for (j = 0; j < PS_PAGE_BUFFERS; j++) {
4052 4053 4054 4055
			if (j < adapter->rx_ps_pages) {
				if (likely(!ps_page->ps_page[j])) {
					ps_page->ps_page[j] =
						alloc_page(GFP_ATOMIC);
4056 4057
					if (unlikely(!ps_page->ps_page[j])) {
						adapter->alloc_rx_buff_failed++;
4058
						goto no_buffers;
4059
					}
4060 4061 4062 4063 4064 4065 4066
					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 已提交
4067
				 * change because each write-back erases
4068 4069 4070 4071 4072 4073
				 * 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;
4074 4075 4076 4077
		}

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

4078 4079
		if (unlikely(!skb)) {
			adapter->alloc_rx_buff_failed++;
4080
			break;
4081
		}
4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098

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

		skb->dev = netdev;

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

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

J
Jesse Brandeburg 已提交
4099
		if (unlikely(++i == rx_ring->count)) i = 0;
4100 4101 4102 4103 4104 4105
		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:
4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120
	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);
	}
4121 4122
}

L
Linus Torvalds 已提交
4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133
/**
 * 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 已提交
4134
	if ((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
L
Linus Torvalds 已提交
4135 4136 4137
	   !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
		return;

J
Jesse Brandeburg 已提交
4138
	if (adapter->smartspeed == 0) {
L
Linus Torvalds 已提交
4139 4140 4141
		/* 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 已提交
4142
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4143
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
J
Jesse Brandeburg 已提交
4144
		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
L
Linus Torvalds 已提交
4145
		e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
J
Jesse Brandeburg 已提交
4146
		if (phy_ctrl & CR_1000T_MS_ENABLE) {
L
Linus Torvalds 已提交
4147 4148 4149 4150
			phy_ctrl &= ~CR_1000T_MS_ENABLE;
			e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
					    phy_ctrl);
			adapter->smartspeed++;
J
Jesse Brandeburg 已提交
4151
			if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4152 4153 4154 4155 4156 4157 4158 4159 4160
			   !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 已提交
4161
	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
L
Linus Torvalds 已提交
4162 4163 4164 4165
		/* 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 已提交
4166
		if (!e1000_phy_setup_autoneg(&adapter->hw) &&
L
Linus Torvalds 已提交
4167 4168 4169 4170 4171 4172 4173
		   !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 已提交
4174
	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
L
Linus Torvalds 已提交
4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207
		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)
{
4208
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4209 4210 4211 4212
	struct mii_ioctl_data *data = if_mii(ifr);
	int retval;
	uint16_t mii_reg;
	uint16_t spddplx;
4213
	unsigned long flags;
L
Linus Torvalds 已提交
4214

J
Jesse Brandeburg 已提交
4215
	if (adapter->hw.media_type != e1000_media_type_copper)
L
Linus Torvalds 已提交
4216 4217 4218 4219 4220 4221 4222
		return -EOPNOTSUPP;

	switch (cmd) {
	case SIOCGMIIPHY:
		data->phy_id = adapter->hw.phy_addr;
		break;
	case SIOCGMIIREG:
J
Jesse Brandeburg 已提交
4223
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4224
			return -EPERM;
4225
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4226
		if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
4227 4228
				   &data->val_out)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4229
			return -EIO;
4230 4231
		}
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4232 4233
		break;
	case SIOCSMIIREG:
J
Jesse Brandeburg 已提交
4234
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
4235
			return -EPERM;
J
Jesse Brandeburg 已提交
4236
		if (data->reg_num & ~(0x1F))
L
Linus Torvalds 已提交
4237 4238
			return -EFAULT;
		mii_reg = data->val_in;
4239
		spin_lock_irqsave(&adapter->stats_lock, flags);
J
Jesse Brandeburg 已提交
4240
		if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
4241 4242
					mii_reg)) {
			spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4243
			return -EIO;
4244
		}
J
Jesse Brandeburg 已提交
4245
		if (adapter->hw.phy_type == e1000_phy_m88) {
L
Linus Torvalds 已提交
4246 4247
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4248
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4249
					break;
J
Jesse Brandeburg 已提交
4250
				if (mii_reg & MII_CR_AUTO_NEG_EN) {
L
Linus Torvalds 已提交
4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264
					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)
						   ? FULL_DUPLEX :
						   HALF_DUPLEX;
					retval = e1000_set_spd_dplx(adapter,
								    spddplx);
J
Jesse Brandeburg 已提交
4265
					if (retval) {
4266
						spin_unlock_irqrestore(
J
Jesse Brandeburg 已提交
4267
							&adapter->stats_lock,
4268
							flags);
L
Linus Torvalds 已提交
4269
						return retval;
4270
					}
L
Linus Torvalds 已提交
4271
				}
J
Jesse Brandeburg 已提交
4272
				if (netif_running(adapter->netdev)) {
L
Linus Torvalds 已提交
4273 4274 4275 4276 4277 4278 4279
					e1000_down(adapter);
					e1000_up(adapter);
				} else
					e1000_reset(adapter);
				break;
			case M88E1000_PHY_SPEC_CTRL:
			case M88E1000_EXT_PHY_SPEC_CTRL:
J
Jesse Brandeburg 已提交
4280
				if (e1000_phy_reset(&adapter->hw)) {
4281 4282
					spin_unlock_irqrestore(
						&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4283
					return -EIO;
4284
				}
L
Linus Torvalds 已提交
4285 4286 4287 4288 4289
				break;
			}
		} else {
			switch (data->reg_num) {
			case PHY_CTRL:
J
Jesse Brandeburg 已提交
4290
				if (mii_reg & MII_CR_POWER_DOWN)
L
Linus Torvalds 已提交
4291
					break;
J
Jesse Brandeburg 已提交
4292
				if (netif_running(adapter->netdev)) {
L
Linus Torvalds 已提交
4293 4294 4295 4296 4297 4298 4299
					e1000_down(adapter);
					e1000_up(adapter);
				} else
					e1000_reset(adapter);
				break;
			}
		}
4300
		spin_unlock_irqrestore(&adapter->stats_lock, flags);
L
Linus Torvalds 已提交
4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311
		break;
	default:
		return -EOPNOTSUPP;
	}
	return E1000_SUCCESS;
}

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

J
Jesse Brandeburg 已提交
4314
	if (ret_val)
4315
		DPRINTK(PROBE, ERR, "Error in setting MWI\n");
L
Linus Torvalds 已提交
4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356
}

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

	pci_clear_mwi(adapter->pdev);
}

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

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

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

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

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

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

static void
e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
{
4357
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4358 4359 4360 4361 4362
	uint32_t ctrl, rctl;

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

J
Jesse Brandeburg 已提交
4363
	if (grp) {
L
Linus Torvalds 已提交
4364 4365 4366 4367 4368 4369 4370 4371 4372 4373
		/* enable VLAN tag insert/strip */
		ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		ctrl |= E1000_CTRL_VME;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);

		/* enable VLAN receive filtering */
		rctl = E1000_READ_REG(&adapter->hw, RCTL);
		rctl |= E1000_RCTL_VFE;
		rctl &= ~E1000_RCTL_CFIEN;
		E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
4374
		e1000_update_mng_vlan(adapter);
L
Linus Torvalds 已提交
4375 4376 4377 4378 4379 4380 4381 4382 4383 4384
	} else {
		/* disable VLAN tag insert/strip */
		ctrl = E1000_READ_REG(&adapter->hw, CTRL);
		ctrl &= ~E1000_CTRL_VME;
		E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);

		/* disable VLAN filtering */
		rctl = E1000_READ_REG(&adapter->hw, RCTL);
		rctl &= ~E1000_RCTL_VFE;
		E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
J
Jesse Brandeburg 已提交
4385
		if (adapter->mng_vlan_id != (uint16_t)E1000_MNG_VLAN_NONE) {
4386 4387 4388
			e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
		}
L
Linus Torvalds 已提交
4389 4390 4391 4392 4393 4394 4395 4396
	}

	e1000_irq_enable(adapter);
}

static void
e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
{
4397
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4398
	uint32_t vfta, index;
J
Jesse Brandeburg 已提交
4399 4400 4401 4402

	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
	    (vid == adapter->mng_vlan_id))
4403
		return;
L
Linus Torvalds 已提交
4404 4405 4406 4407 4408 4409 4410 4411 4412 4413
	/* 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)
{
4414
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4415 4416 4417 4418
	uint32_t vfta, index;

	e1000_irq_disable(adapter);

J
Jesse Brandeburg 已提交
4419
	if (adapter->vlgrp)
L
Linus Torvalds 已提交
4420 4421 4422 4423
		adapter->vlgrp->vlan_devices[vid] = NULL;

	e1000_irq_enable(adapter);

J
Jesse Brandeburg 已提交
4424 4425
	if ((adapter->hw.mng_cookie.status &
	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
J
Jeff Kirsher 已提交
4426 4427 4428
	    (vid == adapter->mng_vlan_id)) {
		/* release control to f/w */
		e1000_release_hw_control(adapter);
4429
		return;
J
Jeff Kirsher 已提交
4430 4431
	}

L
Linus Torvalds 已提交
4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
	/* 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 已提交
4444
	if (adapter->vlgrp) {
L
Linus Torvalds 已提交
4445
		uint16_t vid;
J
Jesse Brandeburg 已提交
4446 4447
		for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
			if (!adapter->vlgrp->vlan_devices[vid])
L
Linus Torvalds 已提交
4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458
				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;

4459
	/* Fiber NICs only allow 1000 gbps Full duplex */
J
Jesse Brandeburg 已提交
4460
	if ((adapter->hw.media_type == e1000_media_type_fiber) &&
4461 4462 4463 4464 4465
		spddplx != (SPEED_1000 + DUPLEX_FULL)) {
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
		return -EINVAL;
	}

J
Jesse Brandeburg 已提交
4466
	switch (spddplx) {
L
Linus Torvalds 已提交
4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484
	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:
4485
		DPRINTK(PROBE, ERR, "Unsupported Speed/Duplex configuration\n");
L
Linus Torvalds 已提交
4486 4487 4488 4489 4490
		return -EINVAL;
	}
	return 0;
}

4491
#ifdef CONFIG_PM
4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539
/* these functions save and restore 16 or 64 dwords (64-256 bytes) of config
 * space versus the 64 bytes that pci_[save|restore]_state handle
 */
#define PCIE_CONFIG_SPACE_LEN 256
#define PCI_CONFIG_SPACE_LEN 64
static int
e1000_pci_save_state(struct e1000_adapter *adapter)
{
	struct pci_dev *dev = adapter->pdev;
	int size;
	int i;
	if (adapter->hw.mac_type >= e1000_82571)
		size = PCIE_CONFIG_SPACE_LEN;
	else
		size = PCI_CONFIG_SPACE_LEN;

	WARN_ON(adapter->config_space != NULL);

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

static void
e1000_pci_restore_state(struct e1000_adapter *adapter)
{
	struct pci_dev *dev = adapter->pdev;
	int size;
	int i;
	if (adapter->config_space == NULL)
		return;
	if (adapter->hw.mac_type >= e1000_82571)
		size = PCIE_CONFIG_SPACE_LEN;
	else
		size = PCI_CONFIG_SPACE_LEN;
	for (i = 0; i < (size / 4); i++)
		pci_write_config_dword(dev, i * 4, adapter->config_space[i]);
	kfree(adapter->config_space);
	adapter->config_space = NULL;
	return;
}
#endif /* CONFIG_PM */

L
Linus Torvalds 已提交
4540
static int
4541
e1000_suspend(struct pci_dev *pdev, pm_message_t state)
L
Linus Torvalds 已提交
4542 4543
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4544
	struct e1000_adapter *adapter = netdev_priv(netdev);
4545
	uint32_t ctrl, ctrl_ext, rctl, manc, status;
L
Linus Torvalds 已提交
4546
	uint32_t wufc = adapter->wol;
4547
	int retval = 0;
L
Linus Torvalds 已提交
4548 4549 4550

	netif_device_detach(netdev);

J
Jesse Brandeburg 已提交
4551
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4552 4553
		e1000_down(adapter);

4554 4555 4556 4557 4558 4559 4560 4561
#ifdef CONFIG_PM
	/* implement our own version of pci_save_state(pdev) because pci 
	 * express adapters have larger 256 byte config spaces */
	retval = e1000_pci_save_state(adapter);
	if (retval)
		return retval;
#endif

L
Linus Torvalds 已提交
4562
	status = E1000_READ_REG(&adapter->hw, STATUS);
J
Jesse Brandeburg 已提交
4563
	if (status & E1000_STATUS_LU)
L
Linus Torvalds 已提交
4564 4565
		wufc &= ~E1000_WUFC_LNKC;

J
Jesse Brandeburg 已提交
4566
	if (wufc) {
L
Linus Torvalds 已提交
4567 4568 4569 4570
		e1000_setup_rctl(adapter);
		e1000_set_multi(netdev);

		/* turn on all-multi mode if wake on multicast is enabled */
J
Jesse Brandeburg 已提交
4571
		if (adapter->wol & E1000_WUFC_MC) {
L
Linus Torvalds 已提交
4572 4573 4574 4575 4576
			rctl = E1000_READ_REG(&adapter->hw, RCTL);
			rctl |= E1000_RCTL_MPE;
			E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
		}

J
Jesse Brandeburg 已提交
4577
		if (adapter->hw.mac_type >= e1000_82540) {
L
Linus Torvalds 已提交
4578 4579 4580 4581 4582 4583 4584 4585 4586 4587
			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 已提交
4588
		if (adapter->hw.media_type == e1000_media_type_fiber ||
L
Linus Torvalds 已提交
4589 4590 4591 4592 4593 4594 4595
		   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);
		}

4596 4597 4598
		/* Allow time for pending master requests to run */
		e1000_disable_pciex_master(&adapter->hw);

L
Linus Torvalds 已提交
4599 4600
		E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
		E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
4601 4602 4603 4604 4605 4606
		retval = pci_enable_wake(pdev, PCI_D3hot, 1);
		if (retval)
			DPRINTK(PROBE, ERR, "Error enabling D3 wake\n");
		retval = pci_enable_wake(pdev, PCI_D3cold, 1);
		if (retval)
			DPRINTK(PROBE, ERR, "Error enabling D3 cold wake\n");
L
Linus Torvalds 已提交
4607 4608 4609
	} else {
		E1000_WRITE_REG(&adapter->hw, WUC, 0);
		E1000_WRITE_REG(&adapter->hw, WUFC, 0);
4610 4611 4612 4613 4614 4615
		retval = pci_enable_wake(pdev, PCI_D3hot, 0);
		if (retval)
			DPRINTK(PROBE, ERR, "Error enabling D3 wake\n");
		retval = pci_enable_wake(pdev, PCI_D3cold, 0); /* 4 == D3 cold */
		if (retval)
			DPRINTK(PROBE, ERR, "Error enabling D3 cold wake\n");
L
Linus Torvalds 已提交
4616 4617
	}

J
Jesse Brandeburg 已提交
4618
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
4619 4620
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
J
Jesse Brandeburg 已提交
4621
		if (manc & E1000_MANC_SMBUS_EN) {
L
Linus Torvalds 已提交
4622 4623
			manc |= E1000_MANC_ARP_EN;
			E1000_WRITE_REG(&adapter->hw, MANC, manc);
4624 4625 4626 4627 4628 4629
			retval = pci_enable_wake(pdev, PCI_D3hot, 1);
			if (retval)
				DPRINTK(PROBE, ERR, "Error enabling D3 wake\n");
			retval = pci_enable_wake(pdev, PCI_D3cold, 1);
			if (retval)
				DPRINTK(PROBE, ERR, "Error enabling D3 cold wake\n");
L
Linus Torvalds 已提交
4630 4631 4632
		}
	}

4633 4634 4635
	/* 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);
4636

L
Linus Torvalds 已提交
4637
	pci_disable_device(pdev);
4638 4639 4640 4641

	retval = pci_set_power_state(pdev, pci_choose_state(pdev, state));
	if (retval)
		DPRINTK(PROBE, ERR, "Error in setting power state\n");
L
Linus Torvalds 已提交
4642 4643 4644 4645

	return 0;
}

4646
#ifdef CONFIG_PM
L
Linus Torvalds 已提交
4647 4648 4649 4650
static int
e1000_resume(struct pci_dev *pdev)
{
	struct net_device *netdev = pci_get_drvdata(pdev);
4651
	struct e1000_adapter *adapter = netdev_priv(netdev);
4652
	int retval;
4653
	uint32_t manc, ret_val;
L
Linus Torvalds 已提交
4654

4655 4656 4657
	retval = pci_set_power_state(pdev, PCI_D0);
	if (retval)
		DPRINTK(PROBE, ERR, "Error in setting power state\n");
4658
	e1000_pci_restore_state(adapter);
4659
	ret_val = pci_enable_device(pdev);
4660
	pci_set_master(pdev);
L
Linus Torvalds 已提交
4661

4662 4663 4664 4665 4666 4667
	retval = pci_enable_wake(pdev, PCI_D3hot, 0);
	if (retval)
		DPRINTK(PROBE, ERR, "Error enabling D3 wake\n");
	retval = pci_enable_wake(pdev, PCI_D3cold, 0);
	if (retval)
		DPRINTK(PROBE, ERR, "Error enabling D3 cold wake\n");
L
Linus Torvalds 已提交
4668 4669 4670 4671

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

J
Jesse Brandeburg 已提交
4672
	if (netif_running(netdev))
L
Linus Torvalds 已提交
4673 4674 4675 4676
		e1000_up(adapter);

	netif_device_attach(netdev);

J
Jesse Brandeburg 已提交
4677
	if (adapter->hw.mac_type >= e1000_82540 &&
L
Linus Torvalds 已提交
4678 4679 4680 4681 4682 4683
	   adapter->hw.media_type == e1000_media_type_copper) {
		manc = E1000_READ_REG(&adapter->hw, MANC);
		manc &= ~(E1000_MANC_ARP_EN);
		E1000_WRITE_REG(&adapter->hw, MANC, manc);
	}

4684 4685 4686 4687 4688 4689 4690
	/* 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);
4691

L
Linus Torvalds 已提交
4692 4693 4694 4695 4696 4697 4698 4699 4700 4701
	return 0;
}
#endif
#ifdef CONFIG_NET_POLL_CONTROLLER
/*
 * Polling 'interrupt' - used by things like netconsole to send skbs
 * without having to re-enable interrupts. It's not called while
 * the interrupt routine is executing.
 */
static void
4702
e1000_netpoll(struct net_device *netdev)
L
Linus Torvalds 已提交
4703
{
4704
	struct e1000_adapter *adapter = netdev_priv(netdev);
L
Linus Torvalds 已提交
4705 4706
	disable_irq(adapter->pdev->irq);
	e1000_intr(adapter->pdev->irq, netdev, NULL);
A
Andrew Morton 已提交
4707
	e1000_clean_tx_irq(adapter, adapter->tx_ring);
J
Jeff Kirsher 已提交
4708 4709 4710
#ifndef CONFIG_E1000_NAPI
	adapter->clean_rx(adapter, adapter->rx_ring);
#endif
L
Linus Torvalds 已提交
4711 4712 4713 4714 4715
	enable_irq(adapter->pdev->irq);
}
#endif

/* e1000_main.c */