1 /*******************************************************************************
2 
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2006 Intel Corporation.
5 
6   This program is free software; you can redistribute it and/or modify it
7   under the terms and conditions of the GNU General Public License,
8   version 2, as published by the Free Software Foundation.
9 
10   This program is distributed in the hope it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13   more details.
14 
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21 
22   Contact Information:
23   Linux NICS <linux.nics@intel.com>
24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 
27 *******************************************************************************/
28 
29 #include "e1000.h"
30 #include <net/ip6_checksum.h>
31 #include <linux/io.h>
32 #include <linux/prefetch.h>
33 #include <linux/bitops.h>
34 #include <linux/if_vlan.h>
35 
36 char e1000_driver_name[] = "e1000";
37 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
38 #define DRV_VERSION "7.3.21-k8-NAPI"
39 const char e1000_driver_version[] = DRV_VERSION;
40 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
41 
42 /* e1000_pci_tbl - PCI Device ID Table
43  *
44  * Last entry must be all 0s
45  *
46  * Macro expands to...
47  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
48  */
49 static const struct pci_device_id e1000_pci_tbl[] = {
50 	INTEL_E1000_ETHERNET_DEVICE(0x1000),
51 	INTEL_E1000_ETHERNET_DEVICE(0x1001),
52 	INTEL_E1000_ETHERNET_DEVICE(0x1004),
53 	INTEL_E1000_ETHERNET_DEVICE(0x1008),
54 	INTEL_E1000_ETHERNET_DEVICE(0x1009),
55 	INTEL_E1000_ETHERNET_DEVICE(0x100C),
56 	INTEL_E1000_ETHERNET_DEVICE(0x100D),
57 	INTEL_E1000_ETHERNET_DEVICE(0x100E),
58 	INTEL_E1000_ETHERNET_DEVICE(0x100F),
59 	INTEL_E1000_ETHERNET_DEVICE(0x1010),
60 	INTEL_E1000_ETHERNET_DEVICE(0x1011),
61 	INTEL_E1000_ETHERNET_DEVICE(0x1012),
62 	INTEL_E1000_ETHERNET_DEVICE(0x1013),
63 	INTEL_E1000_ETHERNET_DEVICE(0x1014),
64 	INTEL_E1000_ETHERNET_DEVICE(0x1015),
65 	INTEL_E1000_ETHERNET_DEVICE(0x1016),
66 	INTEL_E1000_ETHERNET_DEVICE(0x1017),
67 	INTEL_E1000_ETHERNET_DEVICE(0x1018),
68 	INTEL_E1000_ETHERNET_DEVICE(0x1019),
69 	INTEL_E1000_ETHERNET_DEVICE(0x101A),
70 	INTEL_E1000_ETHERNET_DEVICE(0x101D),
71 	INTEL_E1000_ETHERNET_DEVICE(0x101E),
72 	INTEL_E1000_ETHERNET_DEVICE(0x1026),
73 	INTEL_E1000_ETHERNET_DEVICE(0x1027),
74 	INTEL_E1000_ETHERNET_DEVICE(0x1028),
75 	INTEL_E1000_ETHERNET_DEVICE(0x1075),
76 	INTEL_E1000_ETHERNET_DEVICE(0x1076),
77 	INTEL_E1000_ETHERNET_DEVICE(0x1077),
78 	INTEL_E1000_ETHERNET_DEVICE(0x1078),
79 	INTEL_E1000_ETHERNET_DEVICE(0x1079),
80 	INTEL_E1000_ETHERNET_DEVICE(0x107A),
81 	INTEL_E1000_ETHERNET_DEVICE(0x107B),
82 	INTEL_E1000_ETHERNET_DEVICE(0x107C),
83 	INTEL_E1000_ETHERNET_DEVICE(0x108A),
84 	INTEL_E1000_ETHERNET_DEVICE(0x1099),
85 	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
86 	INTEL_E1000_ETHERNET_DEVICE(0x2E6E),
87 	/* required last entry */
88 	{0,}
89 };
90 
91 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
92 
93 int e1000_up(struct e1000_adapter *adapter);
94 void e1000_down(struct e1000_adapter *adapter);
95 void e1000_reinit_locked(struct e1000_adapter *adapter);
96 void e1000_reset(struct e1000_adapter *adapter);
97 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
98 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
99 void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
100 void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
101 static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
102                              struct e1000_tx_ring *txdr);
103 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
104                              struct e1000_rx_ring *rxdr);
105 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
106                              struct e1000_tx_ring *tx_ring);
107 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
108                              struct e1000_rx_ring *rx_ring);
109 void e1000_update_stats(struct e1000_adapter *adapter);
110 
111 static int e1000_init_module(void);
112 static void e1000_exit_module(void);
113 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
114 static void e1000_remove(struct pci_dev *pdev);
115 static int e1000_alloc_queues(struct e1000_adapter *adapter);
116 static int e1000_sw_init(struct e1000_adapter *adapter);
117 static int e1000_open(struct net_device *netdev);
118 static int e1000_close(struct net_device *netdev);
119 static void e1000_configure_tx(struct e1000_adapter *adapter);
120 static void e1000_configure_rx(struct e1000_adapter *adapter);
121 static void e1000_setup_rctl(struct e1000_adapter *adapter);
122 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
123 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
124 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
125                                 struct e1000_tx_ring *tx_ring);
126 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
127                                 struct e1000_rx_ring *rx_ring);
128 static void e1000_set_rx_mode(struct net_device *netdev);
129 static void e1000_update_phy_info_task(struct work_struct *work);
130 static void e1000_watchdog(struct work_struct *work);
131 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);
132 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
133 				    struct net_device *netdev);
134 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
135 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
136 static int e1000_set_mac(struct net_device *netdev, void *p);
137 static irqreturn_t e1000_intr(int irq, void *data);
138 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
139 			       struct e1000_tx_ring *tx_ring);
140 static int e1000_clean(struct napi_struct *napi, int budget);
141 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
142 			       struct e1000_rx_ring *rx_ring,
143 			       int *work_done, int work_to_do);
144 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
145 				     struct e1000_rx_ring *rx_ring,
146 				     int *work_done, int work_to_do);
147 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
148 				   struct e1000_rx_ring *rx_ring,
149 				   int cleaned_count);
150 static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
151 					 struct e1000_rx_ring *rx_ring,
152 					 int cleaned_count);
153 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
154 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
155 			   int cmd);
156 static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
157 static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
158 static void e1000_tx_timeout(struct net_device *dev);
159 static void e1000_reset_task(struct work_struct *work);
160 static void e1000_smartspeed(struct e1000_adapter *adapter);
161 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
162                                        struct sk_buff *skb);
163 
164 static bool e1000_vlan_used(struct e1000_adapter *adapter);
165 static void e1000_vlan_mode(struct net_device *netdev,
166 			    netdev_features_t features);
167 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
168 				     bool filter_on);
169 static int e1000_vlan_rx_add_vid(struct net_device *netdev,
170 				 __be16 proto, u16 vid);
171 static int e1000_vlan_rx_kill_vid(struct net_device *netdev,
172 				  __be16 proto, u16 vid);
173 static void e1000_restore_vlan(struct e1000_adapter *adapter);
174 
175 #ifdef CONFIG_PM
176 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
177 static int e1000_resume(struct pci_dev *pdev);
178 #endif
179 static void e1000_shutdown(struct pci_dev *pdev);
180 
181 #ifdef CONFIG_NET_POLL_CONTROLLER
182 /* for netdump / net console */
183 static void e1000_netpoll (struct net_device *netdev);
184 #endif
185 
186 #define COPYBREAK_DEFAULT 256
187 static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;
188 module_param(copybreak, uint, 0644);
189 MODULE_PARM_DESC(copybreak,
190 	"Maximum size of packet that is copied to a new buffer on receive");
191 
192 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
193                      pci_channel_state_t state);
194 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
195 static void e1000_io_resume(struct pci_dev *pdev);
196 
197 static const struct pci_error_handlers e1000_err_handler = {
198 	.error_detected = e1000_io_error_detected,
199 	.slot_reset = e1000_io_slot_reset,
200 	.resume = e1000_io_resume,
201 };
202 
203 static struct pci_driver e1000_driver = {
204 	.name     = e1000_driver_name,
205 	.id_table = e1000_pci_tbl,
206 	.probe    = e1000_probe,
207 	.remove   = e1000_remove,
208 #ifdef CONFIG_PM
209 	/* Power Management Hooks */
210 	.suspend  = e1000_suspend,
211 	.resume   = e1000_resume,
212 #endif
213 	.shutdown = e1000_shutdown,
214 	.err_handler = &e1000_err_handler
215 };
216 
217 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
218 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
219 MODULE_LICENSE("GPL");
220 MODULE_VERSION(DRV_VERSION);
221 
222 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
223 static int debug = -1;
224 module_param(debug, int, 0);
225 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
226 
227 /**
228  * e1000_get_hw_dev - return device
229  * used by hardware layer to print debugging information
230  *
231  **/
232 struct net_device *e1000_get_hw_dev(struct e1000_hw *hw)
233 {
234 	struct e1000_adapter *adapter = hw->back;
235 	return adapter->netdev;
236 }
237 
238 /**
239  * e1000_init_module - Driver Registration Routine
240  *
241  * e1000_init_module is the first routine called when the driver is
242  * loaded. All it does is register with the PCI subsystem.
243  **/
244 static int __init e1000_init_module(void)
245 {
246 	int ret;
247 	pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);
248 
249 	pr_info("%s\n", e1000_copyright);
250 
251 	ret = pci_register_driver(&e1000_driver);
252 	if (copybreak != COPYBREAK_DEFAULT) {
253 		if (copybreak == 0)
254 			pr_info("copybreak disabled\n");
255 		else
256 			pr_info("copybreak enabled for "
257 				   "packets <= %u bytes\n", copybreak);
258 	}
259 	return ret;
260 }
261 
262 module_init(e1000_init_module);
263 
264 /**
265  * e1000_exit_module - Driver Exit Cleanup Routine
266  *
267  * e1000_exit_module is called just before the driver is removed
268  * from memory.
269  **/
270 static void __exit e1000_exit_module(void)
271 {
272 	pci_unregister_driver(&e1000_driver);
273 }
274 
275 module_exit(e1000_exit_module);
276 
277 static int e1000_request_irq(struct e1000_adapter *adapter)
278 {
279 	struct net_device *netdev = adapter->netdev;
280 	irq_handler_t handler = e1000_intr;
281 	int irq_flags = IRQF_SHARED;
282 	int err;
283 
284 	err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
285 	                  netdev);
286 	if (err) {
287 		e_err(probe, "Unable to allocate interrupt Error: %d\n", err);
288 	}
289 
290 	return err;
291 }
292 
293 static void e1000_free_irq(struct e1000_adapter *adapter)
294 {
295 	struct net_device *netdev = adapter->netdev;
296 
297 	free_irq(adapter->pdev->irq, netdev);
298 }
299 
300 /**
301  * e1000_irq_disable - Mask off interrupt generation on the NIC
302  * @adapter: board private structure
303  **/
304 static void e1000_irq_disable(struct e1000_adapter *adapter)
305 {
306 	struct e1000_hw *hw = &adapter->hw;
307 
308 	ew32(IMC, ~0);
309 	E1000_WRITE_FLUSH();
310 	synchronize_irq(adapter->pdev->irq);
311 }
312 
313 /**
314  * e1000_irq_enable - Enable default interrupt generation settings
315  * @adapter: board private structure
316  **/
317 static void e1000_irq_enable(struct e1000_adapter *adapter)
318 {
319 	struct e1000_hw *hw = &adapter->hw;
320 
321 	ew32(IMS, IMS_ENABLE_MASK);
322 	E1000_WRITE_FLUSH();
323 }
324 
325 static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
326 {
327 	struct e1000_hw *hw = &adapter->hw;
328 	struct net_device *netdev = adapter->netdev;
329 	u16 vid = hw->mng_cookie.vlan_id;
330 	u16 old_vid = adapter->mng_vlan_id;
331 
332 	if (!e1000_vlan_used(adapter))
333 		return;
334 
335 	if (!test_bit(vid, adapter->active_vlans)) {
336 		if (hw->mng_cookie.status &
337 		    E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
338 			e1000_vlan_rx_add_vid(netdev, htons(ETH_P_8021Q), vid);
339 			adapter->mng_vlan_id = vid;
340 		} else {
341 			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
342 		}
343 		if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&
344 		    (vid != old_vid) &&
345 		    !test_bit(old_vid, adapter->active_vlans))
346 			e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q),
347 					       old_vid);
348 	} else {
349 		adapter->mng_vlan_id = vid;
350 	}
351 }
352 
353 static void e1000_init_manageability(struct e1000_adapter *adapter)
354 {
355 	struct e1000_hw *hw = &adapter->hw;
356 
357 	if (adapter->en_mng_pt) {
358 		u32 manc = er32(MANC);
359 
360 		/* disable hardware interception of ARP */
361 		manc &= ~(E1000_MANC_ARP_EN);
362 
363 		ew32(MANC, manc);
364 	}
365 }
366 
367 static void e1000_release_manageability(struct e1000_adapter *adapter)
368 {
369 	struct e1000_hw *hw = &adapter->hw;
370 
371 	if (adapter->en_mng_pt) {
372 		u32 manc = er32(MANC);
373 
374 		/* re-enable hardware interception of ARP */
375 		manc |= E1000_MANC_ARP_EN;
376 
377 		ew32(MANC, manc);
378 	}
379 }
380 
381 /**
382  * e1000_configure - configure the hardware for RX and TX
383  * @adapter = private board structure
384  **/
385 static void e1000_configure(struct e1000_adapter *adapter)
386 {
387 	struct net_device *netdev = adapter->netdev;
388 	int i;
389 
390 	e1000_set_rx_mode(netdev);
391 
392 	e1000_restore_vlan(adapter);
393 	e1000_init_manageability(adapter);
394 
395 	e1000_configure_tx(adapter);
396 	e1000_setup_rctl(adapter);
397 	e1000_configure_rx(adapter);
398 	/* call E1000_DESC_UNUSED which always leaves
399 	 * at least 1 descriptor unused to make sure
400 	 * next_to_use != next_to_clean
401 	 */
402 	for (i = 0; i < adapter->num_rx_queues; i++) {
403 		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
404 		adapter->alloc_rx_buf(adapter, ring,
405 				      E1000_DESC_UNUSED(ring));
406 	}
407 }
408 
409 int e1000_up(struct e1000_adapter *adapter)
410 {
411 	struct e1000_hw *hw = &adapter->hw;
412 
413 	/* hardware has been reset, we need to reload some things */
414 	e1000_configure(adapter);
415 
416 	clear_bit(__E1000_DOWN, &adapter->flags);
417 
418 	napi_enable(&adapter->napi);
419 
420 	e1000_irq_enable(adapter);
421 
422 	netif_wake_queue(adapter->netdev);
423 
424 	/* fire a link change interrupt to start the watchdog */
425 	ew32(ICS, E1000_ICS_LSC);
426 	return 0;
427 }
428 
429 /**
430  * e1000_power_up_phy - restore link in case the phy was powered down
431  * @adapter: address of board private structure
432  *
433  * The phy may be powered down to save power and turn off link when the
434  * driver is unloaded and wake on lan is not enabled (among others)
435  * *** this routine MUST be followed by a call to e1000_reset ***
436  **/
437 void e1000_power_up_phy(struct e1000_adapter *adapter)
438 {
439 	struct e1000_hw *hw = &adapter->hw;
440 	u16 mii_reg = 0;
441 
442 	/* Just clear the power down bit to wake the phy back up */
443 	if (hw->media_type == e1000_media_type_copper) {
444 		/* according to the manual, the phy will retain its
445 		 * settings across a power-down/up cycle
446 		 */
447 		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
448 		mii_reg &= ~MII_CR_POWER_DOWN;
449 		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
450 	}
451 }
452 
453 static void e1000_power_down_phy(struct e1000_adapter *adapter)
454 {
455 	struct e1000_hw *hw = &adapter->hw;
456 
457 	/* Power down the PHY so no link is implied when interface is down *
458 	 * The PHY cannot be powered down if any of the following is true *
459 	 * (a) WoL is enabled
460 	 * (b) AMT is active
461 	 * (c) SoL/IDER session is active
462 	 */
463 	if (!adapter->wol && hw->mac_type >= e1000_82540 &&
464 	   hw->media_type == e1000_media_type_copper) {
465 		u16 mii_reg = 0;
466 
467 		switch (hw->mac_type) {
468 		case e1000_82540:
469 		case e1000_82545:
470 		case e1000_82545_rev_3:
471 		case e1000_82546:
472 		case e1000_ce4100:
473 		case e1000_82546_rev_3:
474 		case e1000_82541:
475 		case e1000_82541_rev_2:
476 		case e1000_82547:
477 		case e1000_82547_rev_2:
478 			if (er32(MANC) & E1000_MANC_SMBUS_EN)
479 				goto out;
480 			break;
481 		default:
482 			goto out;
483 		}
484 		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
485 		mii_reg |= MII_CR_POWER_DOWN;
486 		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
487 		msleep(1);
488 	}
489 out:
490 	return;
491 }
492 
493 static void e1000_down_and_stop(struct e1000_adapter *adapter)
494 {
495 	set_bit(__E1000_DOWN, &adapter->flags);
496 
497 	cancel_delayed_work_sync(&adapter->watchdog_task);
498 
499 	/*
500 	 * Since the watchdog task can reschedule other tasks, we should cancel
501 	 * it first, otherwise we can run into the situation when a work is
502 	 * still running after the adapter has been turned down.
503 	 */
504 
505 	cancel_delayed_work_sync(&adapter->phy_info_task);
506 	cancel_delayed_work_sync(&adapter->fifo_stall_task);
507 
508 	/* Only kill reset task if adapter is not resetting */
509 	if (!test_bit(__E1000_RESETTING, &adapter->flags))
510 		cancel_work_sync(&adapter->reset_task);
511 }
512 
513 void e1000_down(struct e1000_adapter *adapter)
514 {
515 	struct e1000_hw *hw = &adapter->hw;
516 	struct net_device *netdev = adapter->netdev;
517 	u32 rctl, tctl;
518 
519 
520 	/* disable receives in the hardware */
521 	rctl = er32(RCTL);
522 	ew32(RCTL, rctl & ~E1000_RCTL_EN);
523 	/* flush and sleep below */
524 
525 	netif_tx_disable(netdev);
526 
527 	/* disable transmits in the hardware */
528 	tctl = er32(TCTL);
529 	tctl &= ~E1000_TCTL_EN;
530 	ew32(TCTL, tctl);
531 	/* flush both disables and wait for them to finish */
532 	E1000_WRITE_FLUSH();
533 	msleep(10);
534 
535 	napi_disable(&adapter->napi);
536 
537 	e1000_irq_disable(adapter);
538 
539 	/* Setting DOWN must be after irq_disable to prevent
540 	 * a screaming interrupt.  Setting DOWN also prevents
541 	 * tasks from rescheduling.
542 	 */
543 	e1000_down_and_stop(adapter);
544 
545 	adapter->link_speed = 0;
546 	adapter->link_duplex = 0;
547 	netif_carrier_off(netdev);
548 
549 	e1000_reset(adapter);
550 	e1000_clean_all_tx_rings(adapter);
551 	e1000_clean_all_rx_rings(adapter);
552 }
553 
554 void e1000_reinit_locked(struct e1000_adapter *adapter)
555 {
556 	WARN_ON(in_interrupt());
557 	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
558 		msleep(1);
559 	e1000_down(adapter);
560 	e1000_up(adapter);
561 	clear_bit(__E1000_RESETTING, &adapter->flags);
562 }
563 
564 void e1000_reset(struct e1000_adapter *adapter)
565 {
566 	struct e1000_hw *hw = &adapter->hw;
567 	u32 pba = 0, tx_space, min_tx_space, min_rx_space;
568 	bool legacy_pba_adjust = false;
569 	u16 hwm;
570 
571 	/* Repartition Pba for greater than 9k mtu
572 	 * To take effect CTRL.RST is required.
573 	 */
574 
575 	switch (hw->mac_type) {
576 	case e1000_82542_rev2_0:
577 	case e1000_82542_rev2_1:
578 	case e1000_82543:
579 	case e1000_82544:
580 	case e1000_82540:
581 	case e1000_82541:
582 	case e1000_82541_rev_2:
583 		legacy_pba_adjust = true;
584 		pba = E1000_PBA_48K;
585 		break;
586 	case e1000_82545:
587 	case e1000_82545_rev_3:
588 	case e1000_82546:
589 	case e1000_ce4100:
590 	case e1000_82546_rev_3:
591 		pba = E1000_PBA_48K;
592 		break;
593 	case e1000_82547:
594 	case e1000_82547_rev_2:
595 		legacy_pba_adjust = true;
596 		pba = E1000_PBA_30K;
597 		break;
598 	case e1000_undefined:
599 	case e1000_num_macs:
600 		break;
601 	}
602 
603 	if (legacy_pba_adjust) {
604 		if (hw->max_frame_size > E1000_RXBUFFER_8192)
605 			pba -= 8; /* allocate more FIFO for Tx */
606 
607 		if (hw->mac_type == e1000_82547) {
608 			adapter->tx_fifo_head = 0;
609 			adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
610 			adapter->tx_fifo_size =
611 				(E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
612 			atomic_set(&adapter->tx_fifo_stall, 0);
613 		}
614 	} else if (hw->max_frame_size >  ETH_FRAME_LEN + ETH_FCS_LEN) {
615 		/* adjust PBA for jumbo frames */
616 		ew32(PBA, pba);
617 
618 		/* To maintain wire speed transmits, the Tx FIFO should be
619 		 * large enough to accommodate two full transmit packets,
620 		 * rounded up to the next 1KB and expressed in KB.  Likewise,
621 		 * the Rx FIFO should be large enough to accommodate at least
622 		 * one full receive packet and is similarly rounded up and
623 		 * expressed in KB.
624 		 */
625 		pba = er32(PBA);
626 		/* upper 16 bits has Tx packet buffer allocation size in KB */
627 		tx_space = pba >> 16;
628 		/* lower 16 bits has Rx packet buffer allocation size in KB */
629 		pba &= 0xffff;
630 		/* the Tx fifo also stores 16 bytes of information about the Tx
631 		 * but don't include ethernet FCS because hardware appends it
632 		 */
633 		min_tx_space = (hw->max_frame_size +
634 		                sizeof(struct e1000_tx_desc) -
635 		                ETH_FCS_LEN) * 2;
636 		min_tx_space = ALIGN(min_tx_space, 1024);
637 		min_tx_space >>= 10;
638 		/* software strips receive CRC, so leave room for it */
639 		min_rx_space = hw->max_frame_size;
640 		min_rx_space = ALIGN(min_rx_space, 1024);
641 		min_rx_space >>= 10;
642 
643 		/* If current Tx allocation is less than the min Tx FIFO size,
644 		 * and the min Tx FIFO size is less than the current Rx FIFO
645 		 * allocation, take space away from current Rx allocation
646 		 */
647 		if (tx_space < min_tx_space &&
648 		    ((min_tx_space - tx_space) < pba)) {
649 			pba = pba - (min_tx_space - tx_space);
650 
651 			/* PCI/PCIx hardware has PBA alignment constraints */
652 			switch (hw->mac_type) {
653 			case e1000_82545 ... e1000_82546_rev_3:
654 				pba &= ~(E1000_PBA_8K - 1);
655 				break;
656 			default:
657 				break;
658 			}
659 
660 			/* if short on Rx space, Rx wins and must trump Tx
661 			 * adjustment or use Early Receive if available
662 			 */
663 			if (pba < min_rx_space)
664 				pba = min_rx_space;
665 		}
666 	}
667 
668 	ew32(PBA, pba);
669 
670 	/* flow control settings:
671 	 * The high water mark must be low enough to fit one full frame
672 	 * (or the size used for early receive) above it in the Rx FIFO.
673 	 * Set it to the lower of:
674 	 * - 90% of the Rx FIFO size, and
675 	 * - the full Rx FIFO size minus the early receive size (for parts
676 	 *   with ERT support assuming ERT set to E1000_ERT_2048), or
677 	 * - the full Rx FIFO size minus one full frame
678 	 */
679 	hwm = min(((pba << 10) * 9 / 10),
680 		  ((pba << 10) - hw->max_frame_size));
681 
682 	hw->fc_high_water = hwm & 0xFFF8;	/* 8-byte granularity */
683 	hw->fc_low_water = hw->fc_high_water - 8;
684 	hw->fc_pause_time = E1000_FC_PAUSE_TIME;
685 	hw->fc_send_xon = 1;
686 	hw->fc = hw->original_fc;
687 
688 	/* Allow time for pending master requests to run */
689 	e1000_reset_hw(hw);
690 	if (hw->mac_type >= e1000_82544)
691 		ew32(WUC, 0);
692 
693 	if (e1000_init_hw(hw))
694 		e_dev_err("Hardware Error\n");
695 	e1000_update_mng_vlan(adapter);
696 
697 	/* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
698 	if (hw->mac_type >= e1000_82544 &&
699 	    hw->autoneg == 1 &&
700 	    hw->autoneg_advertised == ADVERTISE_1000_FULL) {
701 		u32 ctrl = er32(CTRL);
702 		/* clear phy power management bit if we are in gig only mode,
703 		 * which if enabled will attempt negotiation to 100Mb, which
704 		 * can cause a loss of link at power off or driver unload
705 		 */
706 		ctrl &= ~E1000_CTRL_SWDPIN3;
707 		ew32(CTRL, ctrl);
708 	}
709 
710 	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
711 	ew32(VET, ETHERNET_IEEE_VLAN_TYPE);
712 
713 	e1000_reset_adaptive(hw);
714 	e1000_phy_get_info(hw, &adapter->phy_info);
715 
716 	e1000_release_manageability(adapter);
717 }
718 
719 /* Dump the eeprom for users having checksum issues */
720 static void e1000_dump_eeprom(struct e1000_adapter *adapter)
721 {
722 	struct net_device *netdev = adapter->netdev;
723 	struct ethtool_eeprom eeprom;
724 	const struct ethtool_ops *ops = netdev->ethtool_ops;
725 	u8 *data;
726 	int i;
727 	u16 csum_old, csum_new = 0;
728 
729 	eeprom.len = ops->get_eeprom_len(netdev);
730 	eeprom.offset = 0;
731 
732 	data = kmalloc(eeprom.len, GFP_KERNEL);
733 	if (!data)
734 		return;
735 
736 	ops->get_eeprom(netdev, &eeprom, data);
737 
738 	csum_old = (data[EEPROM_CHECKSUM_REG * 2]) +
739 		   (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8);
740 	for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2)
741 		csum_new += data[i] + (data[i + 1] << 8);
742 	csum_new = EEPROM_SUM - csum_new;
743 
744 	pr_err("/*********************/\n");
745 	pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old);
746 	pr_err("Calculated              : 0x%04x\n", csum_new);
747 
748 	pr_err("Offset    Values\n");
749 	pr_err("========  ======\n");
750 	print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0);
751 
752 	pr_err("Include this output when contacting your support provider.\n");
753 	pr_err("This is not a software error! Something bad happened to\n");
754 	pr_err("your hardware or EEPROM image. Ignoring this problem could\n");
755 	pr_err("result in further problems, possibly loss of data,\n");
756 	pr_err("corruption or system hangs!\n");
757 	pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n");
758 	pr_err("which is invalid and requires you to set the proper MAC\n");
759 	pr_err("address manually before continuing to enable this network\n");
760 	pr_err("device. Please inspect the EEPROM dump and report the\n");
761 	pr_err("issue to your hardware vendor or Intel Customer Support.\n");
762 	pr_err("/*********************/\n");
763 
764 	kfree(data);
765 }
766 
767 /**
768  * e1000_is_need_ioport - determine if an adapter needs ioport resources or not
769  * @pdev: PCI device information struct
770  *
771  * Return true if an adapter needs ioport resources
772  **/
773 static int e1000_is_need_ioport(struct pci_dev *pdev)
774 {
775 	switch (pdev->device) {
776 	case E1000_DEV_ID_82540EM:
777 	case E1000_DEV_ID_82540EM_LOM:
778 	case E1000_DEV_ID_82540EP:
779 	case E1000_DEV_ID_82540EP_LOM:
780 	case E1000_DEV_ID_82540EP_LP:
781 	case E1000_DEV_ID_82541EI:
782 	case E1000_DEV_ID_82541EI_MOBILE:
783 	case E1000_DEV_ID_82541ER:
784 	case E1000_DEV_ID_82541ER_LOM:
785 	case E1000_DEV_ID_82541GI:
786 	case E1000_DEV_ID_82541GI_LF:
787 	case E1000_DEV_ID_82541GI_MOBILE:
788 	case E1000_DEV_ID_82544EI_COPPER:
789 	case E1000_DEV_ID_82544EI_FIBER:
790 	case E1000_DEV_ID_82544GC_COPPER:
791 	case E1000_DEV_ID_82544GC_LOM:
792 	case E1000_DEV_ID_82545EM_COPPER:
793 	case E1000_DEV_ID_82545EM_FIBER:
794 	case E1000_DEV_ID_82546EB_COPPER:
795 	case E1000_DEV_ID_82546EB_FIBER:
796 	case E1000_DEV_ID_82546EB_QUAD_COPPER:
797 		return true;
798 	default:
799 		return false;
800 	}
801 }
802 
803 static netdev_features_t e1000_fix_features(struct net_device *netdev,
804 	netdev_features_t features)
805 {
806 	/* Since there is no support for separate Rx/Tx vlan accel
807 	 * enable/disable make sure Tx flag is always in same state as Rx.
808 	 */
809 	if (features & NETIF_F_HW_VLAN_CTAG_RX)
810 		features |= NETIF_F_HW_VLAN_CTAG_TX;
811 	else
812 		features &= ~NETIF_F_HW_VLAN_CTAG_TX;
813 
814 	return features;
815 }
816 
817 static int e1000_set_features(struct net_device *netdev,
818 	netdev_features_t features)
819 {
820 	struct e1000_adapter *adapter = netdev_priv(netdev);
821 	netdev_features_t changed = features ^ netdev->features;
822 
823 	if (changed & NETIF_F_HW_VLAN_CTAG_RX)
824 		e1000_vlan_mode(netdev, features);
825 
826 	if (!(changed & (NETIF_F_RXCSUM | NETIF_F_RXALL)))
827 		return 0;
828 
829 	netdev->features = features;
830 	adapter->rx_csum = !!(features & NETIF_F_RXCSUM);
831 
832 	if (netif_running(netdev))
833 		e1000_reinit_locked(adapter);
834 	else
835 		e1000_reset(adapter);
836 
837 	return 0;
838 }
839 
840 static const struct net_device_ops e1000_netdev_ops = {
841 	.ndo_open		= e1000_open,
842 	.ndo_stop		= e1000_close,
843 	.ndo_start_xmit		= e1000_xmit_frame,
844 	.ndo_get_stats		= e1000_get_stats,
845 	.ndo_set_rx_mode	= e1000_set_rx_mode,
846 	.ndo_set_mac_address	= e1000_set_mac,
847 	.ndo_tx_timeout		= e1000_tx_timeout,
848 	.ndo_change_mtu		= e1000_change_mtu,
849 	.ndo_do_ioctl		= e1000_ioctl,
850 	.ndo_validate_addr	= eth_validate_addr,
851 	.ndo_vlan_rx_add_vid	= e1000_vlan_rx_add_vid,
852 	.ndo_vlan_rx_kill_vid	= e1000_vlan_rx_kill_vid,
853 #ifdef CONFIG_NET_POLL_CONTROLLER
854 	.ndo_poll_controller	= e1000_netpoll,
855 #endif
856 	.ndo_fix_features	= e1000_fix_features,
857 	.ndo_set_features	= e1000_set_features,
858 };
859 
860 /**
861  * e1000_init_hw_struct - initialize members of hw struct
862  * @adapter: board private struct
863  * @hw: structure used by e1000_hw.c
864  *
865  * Factors out initialization of the e1000_hw struct to its own function
866  * that can be called very early at init (just after struct allocation).
867  * Fields are initialized based on PCI device information and
868  * OS network device settings (MTU size).
869  * Returns negative error codes if MAC type setup fails.
870  */
871 static int e1000_init_hw_struct(struct e1000_adapter *adapter,
872 				struct e1000_hw *hw)
873 {
874 	struct pci_dev *pdev = adapter->pdev;
875 
876 	/* PCI config space info */
877 	hw->vendor_id = pdev->vendor;
878 	hw->device_id = pdev->device;
879 	hw->subsystem_vendor_id = pdev->subsystem_vendor;
880 	hw->subsystem_id = pdev->subsystem_device;
881 	hw->revision_id = pdev->revision;
882 
883 	pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
884 
885 	hw->max_frame_size = adapter->netdev->mtu +
886 			     ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
887 	hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
888 
889 	/* identify the MAC */
890 	if (e1000_set_mac_type(hw)) {
891 		e_err(probe, "Unknown MAC Type\n");
892 		return -EIO;
893 	}
894 
895 	switch (hw->mac_type) {
896 	default:
897 		break;
898 	case e1000_82541:
899 	case e1000_82547:
900 	case e1000_82541_rev_2:
901 	case e1000_82547_rev_2:
902 		hw->phy_init_script = 1;
903 		break;
904 	}
905 
906 	e1000_set_media_type(hw);
907 	e1000_get_bus_info(hw);
908 
909 	hw->wait_autoneg_complete = false;
910 	hw->tbi_compatibility_en = true;
911 	hw->adaptive_ifs = true;
912 
913 	/* Copper options */
914 
915 	if (hw->media_type == e1000_media_type_copper) {
916 		hw->mdix = AUTO_ALL_MODES;
917 		hw->disable_polarity_correction = false;
918 		hw->master_slave = E1000_MASTER_SLAVE;
919 	}
920 
921 	return 0;
922 }
923 
924 /**
925  * e1000_probe - Device Initialization Routine
926  * @pdev: PCI device information struct
927  * @ent: entry in e1000_pci_tbl
928  *
929  * Returns 0 on success, negative on failure
930  *
931  * e1000_probe initializes an adapter identified by a pci_dev structure.
932  * The OS initialization, configuring of the adapter private structure,
933  * and a hardware reset occur.
934  **/
935 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
936 {
937 	struct net_device *netdev;
938 	struct e1000_adapter *adapter;
939 	struct e1000_hw *hw;
940 
941 	static int cards_found = 0;
942 	static int global_quad_port_a = 0; /* global ksp3 port a indication */
943 	int i, err, pci_using_dac;
944 	u16 eeprom_data = 0;
945 	u16 tmp = 0;
946 	u16 eeprom_apme_mask = E1000_EEPROM_APME;
947 	int bars, need_ioport;
948 
949 	/* do not allocate ioport bars when not needed */
950 	need_ioport = e1000_is_need_ioport(pdev);
951 	if (need_ioport) {
952 		bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
953 		err = pci_enable_device(pdev);
954 	} else {
955 		bars = pci_select_bars(pdev, IORESOURCE_MEM);
956 		err = pci_enable_device_mem(pdev);
957 	}
958 	if (err)
959 		return err;
960 
961 	err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
962 	if (err)
963 		goto err_pci_reg;
964 
965 	pci_set_master(pdev);
966 	err = pci_save_state(pdev);
967 	if (err)
968 		goto err_alloc_etherdev;
969 
970 	err = -ENOMEM;
971 	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
972 	if (!netdev)
973 		goto err_alloc_etherdev;
974 
975 	SET_NETDEV_DEV(netdev, &pdev->dev);
976 
977 	pci_set_drvdata(pdev, netdev);
978 	adapter = netdev_priv(netdev);
979 	adapter->netdev = netdev;
980 	adapter->pdev = pdev;
981 	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
982 	adapter->bars = bars;
983 	adapter->need_ioport = need_ioport;
984 
985 	hw = &adapter->hw;
986 	hw->back = adapter;
987 
988 	err = -EIO;
989 	hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
990 	if (!hw->hw_addr)
991 		goto err_ioremap;
992 
993 	if (adapter->need_ioport) {
994 		for (i = BAR_1; i <= BAR_5; i++) {
995 			if (pci_resource_len(pdev, i) == 0)
996 				continue;
997 			if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
998 				hw->io_base = pci_resource_start(pdev, i);
999 				break;
1000 			}
1001 		}
1002 	}
1003 
1004 	/* make ready for any if (hw->...) below */
1005 	err = e1000_init_hw_struct(adapter, hw);
1006 	if (err)
1007 		goto err_sw_init;
1008 
1009 	/* there is a workaround being applied below that limits
1010 	 * 64-bit DMA addresses to 64-bit hardware.  There are some
1011 	 * 32-bit adapters that Tx hang when given 64-bit DMA addresses
1012 	 */
1013 	pci_using_dac = 0;
1014 	if ((hw->bus_type == e1000_bus_type_pcix) &&
1015 	    !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) {
1016 		pci_using_dac = 1;
1017 	} else {
1018 		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1019 		if (err) {
1020 			pr_err("No usable DMA config, aborting\n");
1021 			goto err_dma;
1022 		}
1023 	}
1024 
1025 	netdev->netdev_ops = &e1000_netdev_ops;
1026 	e1000_set_ethtool_ops(netdev);
1027 	netdev->watchdog_timeo = 5 * HZ;
1028 	netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
1029 
1030 	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
1031 
1032 	adapter->bd_number = cards_found;
1033 
1034 	/* setup the private structure */
1035 
1036 	err = e1000_sw_init(adapter);
1037 	if (err)
1038 		goto err_sw_init;
1039 
1040 	err = -EIO;
1041 	if (hw->mac_type == e1000_ce4100) {
1042 		hw->ce4100_gbe_mdio_base_virt =
1043 					ioremap(pci_resource_start(pdev, BAR_1),
1044 		                                pci_resource_len(pdev, BAR_1));
1045 
1046 		if (!hw->ce4100_gbe_mdio_base_virt)
1047 			goto err_mdio_ioremap;
1048 	}
1049 
1050 	if (hw->mac_type >= e1000_82543) {
1051 		netdev->hw_features = NETIF_F_SG |
1052 				   NETIF_F_HW_CSUM |
1053 				   NETIF_F_HW_VLAN_CTAG_RX;
1054 		netdev->features = NETIF_F_HW_VLAN_CTAG_TX |
1055 				   NETIF_F_HW_VLAN_CTAG_FILTER;
1056 	}
1057 
1058 	if ((hw->mac_type >= e1000_82544) &&
1059 	   (hw->mac_type != e1000_82547))
1060 		netdev->hw_features |= NETIF_F_TSO;
1061 
1062 	netdev->priv_flags |= IFF_SUPP_NOFCS;
1063 
1064 	netdev->features |= netdev->hw_features;
1065 	netdev->hw_features |= (NETIF_F_RXCSUM |
1066 				NETIF_F_RXALL |
1067 				NETIF_F_RXFCS);
1068 
1069 	if (pci_using_dac) {
1070 		netdev->features |= NETIF_F_HIGHDMA;
1071 		netdev->vlan_features |= NETIF_F_HIGHDMA;
1072 	}
1073 
1074 	netdev->vlan_features |= (NETIF_F_TSO |
1075 				  NETIF_F_HW_CSUM |
1076 				  NETIF_F_SG);
1077 
1078 	/* Do not set IFF_UNICAST_FLT for VMWare's 82545EM */
1079 	if (hw->device_id != E1000_DEV_ID_82545EM_COPPER ||
1080 	    hw->subsystem_vendor_id != PCI_VENDOR_ID_VMWARE)
1081 		netdev->priv_flags |= IFF_UNICAST_FLT;
1082 
1083 	adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw);
1084 
1085 	/* initialize eeprom parameters */
1086 	if (e1000_init_eeprom_params(hw)) {
1087 		e_err(probe, "EEPROM initialization failed\n");
1088 		goto err_eeprom;
1089 	}
1090 
1091 	/* before reading the EEPROM, reset the controller to
1092 	 * put the device in a known good starting state
1093 	 */
1094 
1095 	e1000_reset_hw(hw);
1096 
1097 	/* make sure the EEPROM is good */
1098 	if (e1000_validate_eeprom_checksum(hw) < 0) {
1099 		e_err(probe, "The EEPROM Checksum Is Not Valid\n");
1100 		e1000_dump_eeprom(adapter);
1101 		/* set MAC address to all zeroes to invalidate and temporary
1102 		 * disable this device for the user. This blocks regular
1103 		 * traffic while still permitting ethtool ioctls from reaching
1104 		 * the hardware as well as allowing the user to run the
1105 		 * interface after manually setting a hw addr using
1106 		 * `ip set address`
1107 		 */
1108 		memset(hw->mac_addr, 0, netdev->addr_len);
1109 	} else {
1110 		/* copy the MAC address out of the EEPROM */
1111 		if (e1000_read_mac_addr(hw))
1112 			e_err(probe, "EEPROM Read Error\n");
1113 	}
1114 	/* don't block initalization here due to bad MAC address */
1115 	memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);
1116 
1117 	if (!is_valid_ether_addr(netdev->dev_addr))
1118 		e_err(probe, "Invalid MAC Address\n");
1119 
1120 
1121 	INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog);
1122 	INIT_DELAYED_WORK(&adapter->fifo_stall_task,
1123 			  e1000_82547_tx_fifo_stall_task);
1124 	INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);
1125 	INIT_WORK(&adapter->reset_task, e1000_reset_task);
1126 
1127 	e1000_check_options(adapter);
1128 
1129 	/* Initial Wake on LAN setting
1130 	 * If APM wake is enabled in the EEPROM,
1131 	 * enable the ACPI Magic Packet filter
1132 	 */
1133 
1134 	switch (hw->mac_type) {
1135 	case e1000_82542_rev2_0:
1136 	case e1000_82542_rev2_1:
1137 	case e1000_82543:
1138 		break;
1139 	case e1000_82544:
1140 		e1000_read_eeprom(hw,
1141 			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
1142 		eeprom_apme_mask = E1000_EEPROM_82544_APM;
1143 		break;
1144 	case e1000_82546:
1145 	case e1000_82546_rev_3:
1146 		if (er32(STATUS) & E1000_STATUS_FUNC_1){
1147 			e1000_read_eeprom(hw,
1148 				EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
1149 			break;
1150 		}
1151 		/* Fall Through */
1152 	default:
1153 		e1000_read_eeprom(hw,
1154 			EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
1155 		break;
1156 	}
1157 	if (eeprom_data & eeprom_apme_mask)
1158 		adapter->eeprom_wol |= E1000_WUFC_MAG;
1159 
1160 	/* now that we have the eeprom settings, apply the special cases
1161 	 * where the eeprom may be wrong or the board simply won't support
1162 	 * wake on lan on a particular port
1163 	 */
1164 	switch (pdev->device) {
1165 	case E1000_DEV_ID_82546GB_PCIE:
1166 		adapter->eeprom_wol = 0;
1167 		break;
1168 	case E1000_DEV_ID_82546EB_FIBER:
1169 	case E1000_DEV_ID_82546GB_FIBER:
1170 		/* Wake events only supported on port A for dual fiber
1171 		 * regardless of eeprom setting
1172 		 */
1173 		if (er32(STATUS) & E1000_STATUS_FUNC_1)
1174 			adapter->eeprom_wol = 0;
1175 		break;
1176 	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1177 		/* if quad port adapter, disable WoL on all but port A */
1178 		if (global_quad_port_a != 0)
1179 			adapter->eeprom_wol = 0;
1180 		else
1181 			adapter->quad_port_a = true;
1182 		/* Reset for multiple quad port adapters */
1183 		if (++global_quad_port_a == 4)
1184 			global_quad_port_a = 0;
1185 		break;
1186 	}
1187 
1188 	/* initialize the wol settings based on the eeprom settings */
1189 	adapter->wol = adapter->eeprom_wol;
1190 	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1191 
1192 	/* Auto detect PHY address */
1193 	if (hw->mac_type == e1000_ce4100) {
1194 		for (i = 0; i < 32; i++) {
1195 			hw->phy_addr = i;
1196 			e1000_read_phy_reg(hw, PHY_ID2, &tmp);
1197 			if (tmp == 0 || tmp == 0xFF) {
1198 				if (i == 31)
1199 					goto err_eeprom;
1200 				continue;
1201 			} else
1202 				break;
1203 		}
1204 	}
1205 
1206 	/* reset the hardware with the new settings */
1207 	e1000_reset(adapter);
1208 
1209 	strcpy(netdev->name, "eth%d");
1210 	err = register_netdev(netdev);
1211 	if (err)
1212 		goto err_register;
1213 
1214 	e1000_vlan_filter_on_off(adapter, false);
1215 
1216 	/* print bus type/speed/width info */
1217 	e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",
1218 	       ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),
1219 	       ((hw->bus_speed == e1000_bus_speed_133) ? 133 :
1220 		(hw->bus_speed == e1000_bus_speed_120) ? 120 :
1221 		(hw->bus_speed == e1000_bus_speed_100) ? 100 :
1222 		(hw->bus_speed == e1000_bus_speed_66) ? 66 : 33),
1223 	       ((hw->bus_width == e1000_bus_width_64) ? 64 : 32),
1224 	       netdev->dev_addr);
1225 
1226 	/* carrier off reporting is important to ethtool even BEFORE open */
1227 	netif_carrier_off(netdev);
1228 
1229 	e_info(probe, "Intel(R) PRO/1000 Network Connection\n");
1230 
1231 	cards_found++;
1232 	return 0;
1233 
1234 err_register:
1235 err_eeprom:
1236 	e1000_phy_hw_reset(hw);
1237 
1238 	if (hw->flash_address)
1239 		iounmap(hw->flash_address);
1240 	kfree(adapter->tx_ring);
1241 	kfree(adapter->rx_ring);
1242 err_dma:
1243 err_sw_init:
1244 err_mdio_ioremap:
1245 	iounmap(hw->ce4100_gbe_mdio_base_virt);
1246 	iounmap(hw->hw_addr);
1247 err_ioremap:
1248 	free_netdev(netdev);
1249 err_alloc_etherdev:
1250 	pci_release_selected_regions(pdev, bars);
1251 err_pci_reg:
1252 	pci_disable_device(pdev);
1253 	return err;
1254 }
1255 
1256 /**
1257  * e1000_remove - Device Removal Routine
1258  * @pdev: PCI device information struct
1259  *
1260  * e1000_remove is called by the PCI subsystem to alert the driver
1261  * that it should release a PCI device.  The could be caused by a
1262  * Hot-Plug event, or because the driver is going to be removed from
1263  * memory.
1264  **/
1265 static void e1000_remove(struct pci_dev *pdev)
1266 {
1267 	struct net_device *netdev = pci_get_drvdata(pdev);
1268 	struct e1000_adapter *adapter = netdev_priv(netdev);
1269 	struct e1000_hw *hw = &adapter->hw;
1270 
1271 	e1000_down_and_stop(adapter);
1272 	e1000_release_manageability(adapter);
1273 
1274 	unregister_netdev(netdev);
1275 
1276 	e1000_phy_hw_reset(hw);
1277 
1278 	kfree(adapter->tx_ring);
1279 	kfree(adapter->rx_ring);
1280 
1281 	if (hw->mac_type == e1000_ce4100)
1282 		iounmap(hw->ce4100_gbe_mdio_base_virt);
1283 	iounmap(hw->hw_addr);
1284 	if (hw->flash_address)
1285 		iounmap(hw->flash_address);
1286 	pci_release_selected_regions(pdev, adapter->bars);
1287 
1288 	free_netdev(netdev);
1289 
1290 	pci_disable_device(pdev);
1291 }
1292 
1293 /**
1294  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
1295  * @adapter: board private structure to initialize
1296  *
1297  * e1000_sw_init initializes the Adapter private data structure.
1298  * e1000_init_hw_struct MUST be called before this function
1299  **/
1300 static int e1000_sw_init(struct e1000_adapter *adapter)
1301 {
1302 	adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
1303 
1304 	adapter->num_tx_queues = 1;
1305 	adapter->num_rx_queues = 1;
1306 
1307 	if (e1000_alloc_queues(adapter)) {
1308 		e_err(probe, "Unable to allocate memory for queues\n");
1309 		return -ENOMEM;
1310 	}
1311 
1312 	/* Explicitly disable IRQ since the NIC can be in any state. */
1313 	e1000_irq_disable(adapter);
1314 
1315 	spin_lock_init(&adapter->stats_lock);
1316 
1317 	set_bit(__E1000_DOWN, &adapter->flags);
1318 
1319 	return 0;
1320 }
1321 
1322 /**
1323  * e1000_alloc_queues - Allocate memory for all rings
1324  * @adapter: board private structure to initialize
1325  *
1326  * We allocate one ring per queue at run-time since we don't know the
1327  * number of queues at compile-time.
1328  **/
1329 static int e1000_alloc_queues(struct e1000_adapter *adapter)
1330 {
1331 	adapter->tx_ring = kcalloc(adapter->num_tx_queues,
1332 	                           sizeof(struct e1000_tx_ring), GFP_KERNEL);
1333 	if (!adapter->tx_ring)
1334 		return -ENOMEM;
1335 
1336 	adapter->rx_ring = kcalloc(adapter->num_rx_queues,
1337 	                           sizeof(struct e1000_rx_ring), GFP_KERNEL);
1338 	if (!adapter->rx_ring) {
1339 		kfree(adapter->tx_ring);
1340 		return -ENOMEM;
1341 	}
1342 
1343 	return E1000_SUCCESS;
1344 }
1345 
1346 /**
1347  * e1000_open - Called when a network interface is made active
1348  * @netdev: network interface device structure
1349  *
1350  * Returns 0 on success, negative value on failure
1351  *
1352  * The open entry point is called when a network interface is made
1353  * active by the system (IFF_UP).  At this point all resources needed
1354  * for transmit and receive operations are allocated, the interrupt
1355  * handler is registered with the OS, the watchdog task is started,
1356  * and the stack is notified that the interface is ready.
1357  **/
1358 static int e1000_open(struct net_device *netdev)
1359 {
1360 	struct e1000_adapter *adapter = netdev_priv(netdev);
1361 	struct e1000_hw *hw = &adapter->hw;
1362 	int err;
1363 
1364 	/* disallow open during test */
1365 	if (test_bit(__E1000_TESTING, &adapter->flags))
1366 		return -EBUSY;
1367 
1368 	netif_carrier_off(netdev);
1369 
1370 	/* allocate transmit descriptors */
1371 	err = e1000_setup_all_tx_resources(adapter);
1372 	if (err)
1373 		goto err_setup_tx;
1374 
1375 	/* allocate receive descriptors */
1376 	err = e1000_setup_all_rx_resources(adapter);
1377 	if (err)
1378 		goto err_setup_rx;
1379 
1380 	e1000_power_up_phy(adapter);
1381 
1382 	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
1383 	if ((hw->mng_cookie.status &
1384 			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
1385 		e1000_update_mng_vlan(adapter);
1386 	}
1387 
1388 	/* before we allocate an interrupt, we must be ready to handle it.
1389 	 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
1390 	 * as soon as we call pci_request_irq, so we have to setup our
1391 	 * clean_rx handler before we do so.
1392 	 */
1393 	e1000_configure(adapter);
1394 
1395 	err = e1000_request_irq(adapter);
1396 	if (err)
1397 		goto err_req_irq;
1398 
1399 	/* From here on the code is the same as e1000_up() */
1400 	clear_bit(__E1000_DOWN, &adapter->flags);
1401 
1402 	napi_enable(&adapter->napi);
1403 
1404 	e1000_irq_enable(adapter);
1405 
1406 	netif_start_queue(netdev);
1407 
1408 	/* fire a link status change interrupt to start the watchdog */
1409 	ew32(ICS, E1000_ICS_LSC);
1410 
1411 	return E1000_SUCCESS;
1412 
1413 err_req_irq:
1414 	e1000_power_down_phy(adapter);
1415 	e1000_free_all_rx_resources(adapter);
1416 err_setup_rx:
1417 	e1000_free_all_tx_resources(adapter);
1418 err_setup_tx:
1419 	e1000_reset(adapter);
1420 
1421 	return err;
1422 }
1423 
1424 /**
1425  * e1000_close - Disables a network interface
1426  * @netdev: network interface device structure
1427  *
1428  * Returns 0, this is not allowed to fail
1429  *
1430  * The close entry point is called when an interface is de-activated
1431  * by the OS.  The hardware is still under the drivers control, but
1432  * needs to be disabled.  A global MAC reset is issued to stop the
1433  * hardware, and all transmit and receive resources are freed.
1434  **/
1435 static int e1000_close(struct net_device *netdev)
1436 {
1437 	struct e1000_adapter *adapter = netdev_priv(netdev);
1438 	struct e1000_hw *hw = &adapter->hw;
1439 	int count = E1000_CHECK_RESET_COUNT;
1440 
1441 	while (test_bit(__E1000_RESETTING, &adapter->flags) && count--)
1442 		usleep_range(10000, 20000);
1443 
1444 	WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
1445 	e1000_down(adapter);
1446 	e1000_power_down_phy(adapter);
1447 	e1000_free_irq(adapter);
1448 
1449 	e1000_free_all_tx_resources(adapter);
1450 	e1000_free_all_rx_resources(adapter);
1451 
1452 	/* kill manageability vlan ID if supported, but not if a vlan with
1453 	 * the same ID is registered on the host OS (let 8021q kill it)
1454 	 */
1455 	if ((hw->mng_cookie.status &
1456 	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
1457 	    !test_bit(adapter->mng_vlan_id, adapter->active_vlans)) {
1458 		e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q),
1459 				       adapter->mng_vlan_id);
1460 	}
1461 
1462 	return 0;
1463 }
1464 
1465 /**
1466  * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
1467  * @adapter: address of board private structure
1468  * @start: address of beginning of memory
1469  * @len: length of memory
1470  **/
1471 static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start,
1472 				  unsigned long len)
1473 {
1474 	struct e1000_hw *hw = &adapter->hw;
1475 	unsigned long begin = (unsigned long)start;
1476 	unsigned long end = begin + len;
1477 
1478 	/* First rev 82545 and 82546 need to not allow any memory
1479 	 * write location to cross 64k boundary due to errata 23
1480 	 */
1481 	if (hw->mac_type == e1000_82545 ||
1482 	    hw->mac_type == e1000_ce4100 ||
1483 	    hw->mac_type == e1000_82546) {
1484 		return ((begin ^ (end - 1)) >> 16) != 0 ? false : true;
1485 	}
1486 
1487 	return true;
1488 }
1489 
1490 /**
1491  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
1492  * @adapter: board private structure
1493  * @txdr:    tx descriptor ring (for a specific queue) to setup
1494  *
1495  * Return 0 on success, negative on failure
1496  **/
1497 static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
1498 				    struct e1000_tx_ring *txdr)
1499 {
1500 	struct pci_dev *pdev = adapter->pdev;
1501 	int size;
1502 
1503 	size = sizeof(struct e1000_tx_buffer) * txdr->count;
1504 	txdr->buffer_info = vzalloc(size);
1505 	if (!txdr->buffer_info)
1506 		return -ENOMEM;
1507 
1508 	/* round up to nearest 4K */
1509 
1510 	txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
1511 	txdr->size = ALIGN(txdr->size, 4096);
1512 
1513 	txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
1514 					GFP_KERNEL);
1515 	if (!txdr->desc) {
1516 setup_tx_desc_die:
1517 		vfree(txdr->buffer_info);
1518 		return -ENOMEM;
1519 	}
1520 
1521 	/* Fix for errata 23, can't cross 64kB boundary */
1522 	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
1523 		void *olddesc = txdr->desc;
1524 		dma_addr_t olddma = txdr->dma;
1525 		e_err(tx_err, "txdr align check failed: %u bytes at %p\n",
1526 		      txdr->size, txdr->desc);
1527 		/* Try again, without freeing the previous */
1528 		txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size,
1529 						&txdr->dma, GFP_KERNEL);
1530 		/* Failed allocation, critical failure */
1531 		if (!txdr->desc) {
1532 			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
1533 					  olddma);
1534 			goto setup_tx_desc_die;
1535 		}
1536 
1537 		if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
1538 			/* give up */
1539 			dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
1540 					  txdr->dma);
1541 			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
1542 					  olddma);
1543 			e_err(probe, "Unable to allocate aligned memory "
1544 			      "for the transmit descriptor ring\n");
1545 			vfree(txdr->buffer_info);
1546 			return -ENOMEM;
1547 		} else {
1548 			/* Free old allocation, new allocation was successful */
1549 			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
1550 					  olddma);
1551 		}
1552 	}
1553 	memset(txdr->desc, 0, txdr->size);
1554 
1555 	txdr->next_to_use = 0;
1556 	txdr->next_to_clean = 0;
1557 
1558 	return 0;
1559 }
1560 
1561 /**
1562  * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
1563  * 				  (Descriptors) for all queues
1564  * @adapter: board private structure
1565  *
1566  * Return 0 on success, negative on failure
1567  **/
1568 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
1569 {
1570 	int i, err = 0;
1571 
1572 	for (i = 0; i < adapter->num_tx_queues; i++) {
1573 		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
1574 		if (err) {
1575 			e_err(probe, "Allocation for Tx Queue %u failed\n", i);
1576 			for (i-- ; i >= 0; i--)
1577 				e1000_free_tx_resources(adapter,
1578 							&adapter->tx_ring[i]);
1579 			break;
1580 		}
1581 	}
1582 
1583 	return err;
1584 }
1585 
1586 /**
1587  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
1588  * @adapter: board private structure
1589  *
1590  * Configure the Tx unit of the MAC after a reset.
1591  **/
1592 static void e1000_configure_tx(struct e1000_adapter *adapter)
1593 {
1594 	u64 tdba;
1595 	struct e1000_hw *hw = &adapter->hw;
1596 	u32 tdlen, tctl, tipg;
1597 	u32 ipgr1, ipgr2;
1598 
1599 	/* Setup the HW Tx Head and Tail descriptor pointers */
1600 
1601 	switch (adapter->num_tx_queues) {
1602 	case 1:
1603 	default:
1604 		tdba = adapter->tx_ring[0].dma;
1605 		tdlen = adapter->tx_ring[0].count *
1606 			sizeof(struct e1000_tx_desc);
1607 		ew32(TDLEN, tdlen);
1608 		ew32(TDBAH, (tdba >> 32));
1609 		ew32(TDBAL, (tdba & 0x00000000ffffffffULL));
1610 		ew32(TDT, 0);
1611 		ew32(TDH, 0);
1612 		adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ?
1613 					   E1000_TDH : E1000_82542_TDH);
1614 		adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ?
1615 					   E1000_TDT : E1000_82542_TDT);
1616 		break;
1617 	}
1618 
1619 	/* Set the default values for the Tx Inter Packet Gap timer */
1620 	if ((hw->media_type == e1000_media_type_fiber ||
1621 	     hw->media_type == e1000_media_type_internal_serdes))
1622 		tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
1623 	else
1624 		tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
1625 
1626 	switch (hw->mac_type) {
1627 	case e1000_82542_rev2_0:
1628 	case e1000_82542_rev2_1:
1629 		tipg = DEFAULT_82542_TIPG_IPGT;
1630 		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
1631 		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
1632 		break;
1633 	default:
1634 		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
1635 		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
1636 		break;
1637 	}
1638 	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
1639 	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
1640 	ew32(TIPG, tipg);
1641 
1642 	/* Set the Tx Interrupt Delay register */
1643 
1644 	ew32(TIDV, adapter->tx_int_delay);
1645 	if (hw->mac_type >= e1000_82540)
1646 		ew32(TADV, adapter->tx_abs_int_delay);
1647 
1648 	/* Program the Transmit Control Register */
1649 
1650 	tctl = er32(TCTL);
1651 	tctl &= ~E1000_TCTL_CT;
1652 	tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
1653 		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
1654 
1655 	e1000_config_collision_dist(hw);
1656 
1657 	/* Setup Transmit Descriptor Settings for eop descriptor */
1658 	adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;
1659 
1660 	/* only set IDE if we are delaying interrupts using the timers */
1661 	if (adapter->tx_int_delay)
1662 		adapter->txd_cmd |= E1000_TXD_CMD_IDE;
1663 
1664 	if (hw->mac_type < e1000_82543)
1665 		adapter->txd_cmd |= E1000_TXD_CMD_RPS;
1666 	else
1667 		adapter->txd_cmd |= E1000_TXD_CMD_RS;
1668 
1669 	/* Cache if we're 82544 running in PCI-X because we'll
1670 	 * need this to apply a workaround later in the send path.
1671 	 */
1672 	if (hw->mac_type == e1000_82544 &&
1673 	    hw->bus_type == e1000_bus_type_pcix)
1674 		adapter->pcix_82544 = true;
1675 
1676 	ew32(TCTL, tctl);
1677 
1678 }
1679 
1680 /**
1681  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
1682  * @adapter: board private structure
1683  * @rxdr:    rx descriptor ring (for a specific queue) to setup
1684  *
1685  * Returns 0 on success, negative on failure
1686  **/
1687 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
1688 				    struct e1000_rx_ring *rxdr)
1689 {
1690 	struct pci_dev *pdev = adapter->pdev;
1691 	int size, desc_len;
1692 
1693 	size = sizeof(struct e1000_rx_buffer) * rxdr->count;
1694 	rxdr->buffer_info = vzalloc(size);
1695 	if (!rxdr->buffer_info)
1696 		return -ENOMEM;
1697 
1698 	desc_len = sizeof(struct e1000_rx_desc);
1699 
1700 	/* Round up to nearest 4K */
1701 
1702 	rxdr->size = rxdr->count * desc_len;
1703 	rxdr->size = ALIGN(rxdr->size, 4096);
1704 
1705 	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
1706 					GFP_KERNEL);
1707 	if (!rxdr->desc) {
1708 setup_rx_desc_die:
1709 		vfree(rxdr->buffer_info);
1710 		return -ENOMEM;
1711 	}
1712 
1713 	/* Fix for errata 23, can't cross 64kB boundary */
1714 	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
1715 		void *olddesc = rxdr->desc;
1716 		dma_addr_t olddma = rxdr->dma;
1717 		e_err(rx_err, "rxdr align check failed: %u bytes at %p\n",
1718 		      rxdr->size, rxdr->desc);
1719 		/* Try again, without freeing the previous */
1720 		rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size,
1721 						&rxdr->dma, GFP_KERNEL);
1722 		/* Failed allocation, critical failure */
1723 		if (!rxdr->desc) {
1724 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
1725 					  olddma);
1726 			goto setup_rx_desc_die;
1727 		}
1728 
1729 		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
1730 			/* give up */
1731 			dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
1732 					  rxdr->dma);
1733 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
1734 					  olddma);
1735 			e_err(probe, "Unable to allocate aligned memory for "
1736 			      "the Rx descriptor ring\n");
1737 			goto setup_rx_desc_die;
1738 		} else {
1739 			/* Free old allocation, new allocation was successful */
1740 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
1741 					  olddma);
1742 		}
1743 	}
1744 	memset(rxdr->desc, 0, rxdr->size);
1745 
1746 	rxdr->next_to_clean = 0;
1747 	rxdr->next_to_use = 0;
1748 	rxdr->rx_skb_top = NULL;
1749 
1750 	return 0;
1751 }
1752 
1753 /**
1754  * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
1755  * 				  (Descriptors) for all queues
1756  * @adapter: board private structure
1757  *
1758  * Return 0 on success, negative on failure
1759  **/
1760 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
1761 {
1762 	int i, err = 0;
1763 
1764 	for (i = 0; i < adapter->num_rx_queues; i++) {
1765 		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
1766 		if (err) {
1767 			e_err(probe, "Allocation for Rx Queue %u failed\n", i);
1768 			for (i-- ; i >= 0; i--)
1769 				e1000_free_rx_resources(adapter,
1770 							&adapter->rx_ring[i]);
1771 			break;
1772 		}
1773 	}
1774 
1775 	return err;
1776 }
1777 
1778 /**
1779  * e1000_setup_rctl - configure the receive control registers
1780  * @adapter: Board private structure
1781  **/
1782 static void e1000_setup_rctl(struct e1000_adapter *adapter)
1783 {
1784 	struct e1000_hw *hw = &adapter->hw;
1785 	u32 rctl;
1786 
1787 	rctl = er32(RCTL);
1788 
1789 	rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
1790 
1791 	rctl |= E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
1792 		E1000_RCTL_RDMTS_HALF |
1793 		(hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
1794 
1795 	if (hw->tbi_compatibility_on == 1)
1796 		rctl |= E1000_RCTL_SBP;
1797 	else
1798 		rctl &= ~E1000_RCTL_SBP;
1799 
1800 	if (adapter->netdev->mtu <= ETH_DATA_LEN)
1801 		rctl &= ~E1000_RCTL_LPE;
1802 	else
1803 		rctl |= E1000_RCTL_LPE;
1804 
1805 	/* Setup buffer sizes */
1806 	rctl &= ~E1000_RCTL_SZ_4096;
1807 	rctl |= E1000_RCTL_BSEX;
1808 	switch (adapter->rx_buffer_len) {
1809 		case E1000_RXBUFFER_2048:
1810 		default:
1811 			rctl |= E1000_RCTL_SZ_2048;
1812 			rctl &= ~E1000_RCTL_BSEX;
1813 			break;
1814 		case E1000_RXBUFFER_4096:
1815 			rctl |= E1000_RCTL_SZ_4096;
1816 			break;
1817 		case E1000_RXBUFFER_8192:
1818 			rctl |= E1000_RCTL_SZ_8192;
1819 			break;
1820 		case E1000_RXBUFFER_16384:
1821 			rctl |= E1000_RCTL_SZ_16384;
1822 			break;
1823 	}
1824 
1825 	/* This is useful for sniffing bad packets. */
1826 	if (adapter->netdev->features & NETIF_F_RXALL) {
1827 		/* UPE and MPE will be handled by normal PROMISC logic
1828 		 * in e1000e_set_rx_mode
1829 		 */
1830 		rctl |= (E1000_RCTL_SBP | /* Receive bad packets */
1831 			 E1000_RCTL_BAM | /* RX All Bcast Pkts */
1832 			 E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */
1833 
1834 		rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */
1835 			  E1000_RCTL_DPF | /* Allow filtered pause */
1836 			  E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */
1837 		/* Do not mess with E1000_CTRL_VME, it affects transmit as well,
1838 		 * and that breaks VLANs.
1839 		 */
1840 	}
1841 
1842 	ew32(RCTL, rctl);
1843 }
1844 
1845 /**
1846  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
1847  * @adapter: board private structure
1848  *
1849  * Configure the Rx unit of the MAC after a reset.
1850  **/
1851 static void e1000_configure_rx(struct e1000_adapter *adapter)
1852 {
1853 	u64 rdba;
1854 	struct e1000_hw *hw = &adapter->hw;
1855 	u32 rdlen, rctl, rxcsum;
1856 
1857 	if (adapter->netdev->mtu > ETH_DATA_LEN) {
1858 		rdlen = adapter->rx_ring[0].count *
1859 		        sizeof(struct e1000_rx_desc);
1860 		adapter->clean_rx = e1000_clean_jumbo_rx_irq;
1861 		adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
1862 	} else {
1863 		rdlen = adapter->rx_ring[0].count *
1864 		        sizeof(struct e1000_rx_desc);
1865 		adapter->clean_rx = e1000_clean_rx_irq;
1866 		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
1867 	}
1868 
1869 	/* disable receives while setting up the descriptors */
1870 	rctl = er32(RCTL);
1871 	ew32(RCTL, rctl & ~E1000_RCTL_EN);
1872 
1873 	/* set the Receive Delay Timer Register */
1874 	ew32(RDTR, adapter->rx_int_delay);
1875 
1876 	if (hw->mac_type >= e1000_82540) {
1877 		ew32(RADV, adapter->rx_abs_int_delay);
1878 		if (adapter->itr_setting != 0)
1879 			ew32(ITR, 1000000000 / (adapter->itr * 256));
1880 	}
1881 
1882 	/* Setup the HW Rx Head and Tail Descriptor Pointers and
1883 	 * the Base and Length of the Rx Descriptor Ring
1884 	 */
1885 	switch (adapter->num_rx_queues) {
1886 	case 1:
1887 	default:
1888 		rdba = adapter->rx_ring[0].dma;
1889 		ew32(RDLEN, rdlen);
1890 		ew32(RDBAH, (rdba >> 32));
1891 		ew32(RDBAL, (rdba & 0x00000000ffffffffULL));
1892 		ew32(RDT, 0);
1893 		ew32(RDH, 0);
1894 		adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ?
1895 					   E1000_RDH : E1000_82542_RDH);
1896 		adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ?
1897 					   E1000_RDT : E1000_82542_RDT);
1898 		break;
1899 	}
1900 
1901 	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
1902 	if (hw->mac_type >= e1000_82543) {
1903 		rxcsum = er32(RXCSUM);
1904 		if (adapter->rx_csum)
1905 			rxcsum |= E1000_RXCSUM_TUOFL;
1906 		else
1907 			/* don't need to clear IPPCSE as it defaults to 0 */
1908 			rxcsum &= ~E1000_RXCSUM_TUOFL;
1909 		ew32(RXCSUM, rxcsum);
1910 	}
1911 
1912 	/* Enable Receives */
1913 	ew32(RCTL, rctl | E1000_RCTL_EN);
1914 }
1915 
1916 /**
1917  * e1000_free_tx_resources - Free Tx Resources per Queue
1918  * @adapter: board private structure
1919  * @tx_ring: Tx descriptor ring for a specific queue
1920  *
1921  * Free all transmit software resources
1922  **/
1923 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
1924 				    struct e1000_tx_ring *tx_ring)
1925 {
1926 	struct pci_dev *pdev = adapter->pdev;
1927 
1928 	e1000_clean_tx_ring(adapter, tx_ring);
1929 
1930 	vfree(tx_ring->buffer_info);
1931 	tx_ring->buffer_info = NULL;
1932 
1933 	dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
1934 			  tx_ring->dma);
1935 
1936 	tx_ring->desc = NULL;
1937 }
1938 
1939 /**
1940  * e1000_free_all_tx_resources - Free Tx Resources for All Queues
1941  * @adapter: board private structure
1942  *
1943  * Free all transmit software resources
1944  **/
1945 void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
1946 {
1947 	int i;
1948 
1949 	for (i = 0; i < adapter->num_tx_queues; i++)
1950 		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
1951 }
1952 
1953 static void
1954 e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
1955 				 struct e1000_tx_buffer *buffer_info)
1956 {
1957 	if (buffer_info->dma) {
1958 		if (buffer_info->mapped_as_page)
1959 			dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
1960 				       buffer_info->length, DMA_TO_DEVICE);
1961 		else
1962 			dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
1963 					 buffer_info->length,
1964 					 DMA_TO_DEVICE);
1965 		buffer_info->dma = 0;
1966 	}
1967 	if (buffer_info->skb) {
1968 		dev_kfree_skb_any(buffer_info->skb);
1969 		buffer_info->skb = NULL;
1970 	}
1971 	buffer_info->time_stamp = 0;
1972 	/* buffer_info must be completely set up in the transmit path */
1973 }
1974 
1975 /**
1976  * e1000_clean_tx_ring - Free Tx Buffers
1977  * @adapter: board private structure
1978  * @tx_ring: ring to be cleaned
1979  **/
1980 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
1981 				struct e1000_tx_ring *tx_ring)
1982 {
1983 	struct e1000_hw *hw = &adapter->hw;
1984 	struct e1000_tx_buffer *buffer_info;
1985 	unsigned long size;
1986 	unsigned int i;
1987 
1988 	/* Free all the Tx ring sk_buffs */
1989 
1990 	for (i = 0; i < tx_ring->count; i++) {
1991 		buffer_info = &tx_ring->buffer_info[i];
1992 		e1000_unmap_and_free_tx_resource(adapter, buffer_info);
1993 	}
1994 
1995 	netdev_reset_queue(adapter->netdev);
1996 	size = sizeof(struct e1000_tx_buffer) * tx_ring->count;
1997 	memset(tx_ring->buffer_info, 0, size);
1998 
1999 	/* Zero out the descriptor ring */
2000 
2001 	memset(tx_ring->desc, 0, tx_ring->size);
2002 
2003 	tx_ring->next_to_use = 0;
2004 	tx_ring->next_to_clean = 0;
2005 	tx_ring->last_tx_tso = false;
2006 
2007 	writel(0, hw->hw_addr + tx_ring->tdh);
2008 	writel(0, hw->hw_addr + tx_ring->tdt);
2009 }
2010 
2011 /**
2012  * e1000_clean_all_tx_rings - Free Tx Buffers for all queues
2013  * @adapter: board private structure
2014  **/
2015 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
2016 {
2017 	int i;
2018 
2019 	for (i = 0; i < adapter->num_tx_queues; i++)
2020 		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
2021 }
2022 
2023 /**
2024  * e1000_free_rx_resources - Free Rx Resources
2025  * @adapter: board private structure
2026  * @rx_ring: ring to clean the resources from
2027  *
2028  * Free all receive software resources
2029  **/
2030 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
2031 				    struct e1000_rx_ring *rx_ring)
2032 {
2033 	struct pci_dev *pdev = adapter->pdev;
2034 
2035 	e1000_clean_rx_ring(adapter, rx_ring);
2036 
2037 	vfree(rx_ring->buffer_info);
2038 	rx_ring->buffer_info = NULL;
2039 
2040 	dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
2041 			  rx_ring->dma);
2042 
2043 	rx_ring->desc = NULL;
2044 }
2045 
2046 /**
2047  * e1000_free_all_rx_resources - Free Rx Resources for All Queues
2048  * @adapter: board private structure
2049  *
2050  * Free all receive software resources
2051  **/
2052 void e1000_free_all_rx_resources(struct e1000_adapter *adapter)
2053 {
2054 	int i;
2055 
2056 	for (i = 0; i < adapter->num_rx_queues; i++)
2057 		e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
2058 }
2059 
2060 #define E1000_HEADROOM (NET_SKB_PAD + NET_IP_ALIGN)
2061 static unsigned int e1000_frag_len(const struct e1000_adapter *a)
2062 {
2063 	return SKB_DATA_ALIGN(a->rx_buffer_len + E1000_HEADROOM) +
2064 		SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
2065 }
2066 
2067 static void *e1000_alloc_frag(const struct e1000_adapter *a)
2068 {
2069 	unsigned int len = e1000_frag_len(a);
2070 	u8 *data = netdev_alloc_frag(len);
2071 
2072 	if (likely(data))
2073 		data += E1000_HEADROOM;
2074 	return data;
2075 }
2076 
2077 static void e1000_free_frag(const void *data)
2078 {
2079 	put_page(virt_to_head_page(data));
2080 }
2081 
2082 /**
2083  * e1000_clean_rx_ring - Free Rx Buffers per Queue
2084  * @adapter: board private structure
2085  * @rx_ring: ring to free buffers from
2086  **/
2087 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
2088 				struct e1000_rx_ring *rx_ring)
2089 {
2090 	struct e1000_hw *hw = &adapter->hw;
2091 	struct e1000_rx_buffer *buffer_info;
2092 	struct pci_dev *pdev = adapter->pdev;
2093 	unsigned long size;
2094 	unsigned int i;
2095 
2096 	/* Free all the Rx netfrags */
2097 	for (i = 0; i < rx_ring->count; i++) {
2098 		buffer_info = &rx_ring->buffer_info[i];
2099 		if (adapter->clean_rx == e1000_clean_rx_irq) {
2100 			if (buffer_info->dma)
2101 				dma_unmap_single(&pdev->dev, buffer_info->dma,
2102 						 adapter->rx_buffer_len,
2103 						 DMA_FROM_DEVICE);
2104 			if (buffer_info->rxbuf.data) {
2105 				e1000_free_frag(buffer_info->rxbuf.data);
2106 				buffer_info->rxbuf.data = NULL;
2107 			}
2108 		} else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq) {
2109 			if (buffer_info->dma)
2110 				dma_unmap_page(&pdev->dev, buffer_info->dma,
2111 					       adapter->rx_buffer_len,
2112 					       DMA_FROM_DEVICE);
2113 			if (buffer_info->rxbuf.page) {
2114 				put_page(buffer_info->rxbuf.page);
2115 				buffer_info->rxbuf.page = NULL;
2116 			}
2117 		}
2118 
2119 		buffer_info->dma = 0;
2120 	}
2121 
2122 	/* there also may be some cached data from a chained receive */
2123 	napi_free_frags(&adapter->napi);
2124 	rx_ring->rx_skb_top = NULL;
2125 
2126 	size = sizeof(struct e1000_rx_buffer) * rx_ring->count;
2127 	memset(rx_ring->buffer_info, 0, size);
2128 
2129 	/* Zero out the descriptor ring */
2130 	memset(rx_ring->desc, 0, rx_ring->size);
2131 
2132 	rx_ring->next_to_clean = 0;
2133 	rx_ring->next_to_use = 0;
2134 
2135 	writel(0, hw->hw_addr + rx_ring->rdh);
2136 	writel(0, hw->hw_addr + rx_ring->rdt);
2137 }
2138 
2139 /**
2140  * e1000_clean_all_rx_rings - Free Rx Buffers for all queues
2141  * @adapter: board private structure
2142  **/
2143 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
2144 {
2145 	int i;
2146 
2147 	for (i = 0; i < adapter->num_rx_queues; i++)
2148 		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
2149 }
2150 
2151 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
2152  * and memory write and invalidate disabled for certain operations
2153  */
2154 static void e1000_enter_82542_rst(struct e1000_adapter *adapter)
2155 {
2156 	struct e1000_hw *hw = &adapter->hw;
2157 	struct net_device *netdev = adapter->netdev;
2158 	u32 rctl;
2159 
2160 	e1000_pci_clear_mwi(hw);
2161 
2162 	rctl = er32(RCTL);
2163 	rctl |= E1000_RCTL_RST;
2164 	ew32(RCTL, rctl);
2165 	E1000_WRITE_FLUSH();
2166 	mdelay(5);
2167 
2168 	if (netif_running(netdev))
2169 		e1000_clean_all_rx_rings(adapter);
2170 }
2171 
2172 static void e1000_leave_82542_rst(struct e1000_adapter *adapter)
2173 {
2174 	struct e1000_hw *hw = &adapter->hw;
2175 	struct net_device *netdev = adapter->netdev;
2176 	u32 rctl;
2177 
2178 	rctl = er32(RCTL);
2179 	rctl &= ~E1000_RCTL_RST;
2180 	ew32(RCTL, rctl);
2181 	E1000_WRITE_FLUSH();
2182 	mdelay(5);
2183 
2184 	if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
2185 		e1000_pci_set_mwi(hw);
2186 
2187 	if (netif_running(netdev)) {
2188 		/* No need to loop, because 82542 supports only 1 queue */
2189 		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2190 		e1000_configure_rx(adapter);
2191 		adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
2192 	}
2193 }
2194 
2195 /**
2196  * e1000_set_mac - Change the Ethernet Address of the NIC
2197  * @netdev: network interface device structure
2198  * @p: pointer to an address structure
2199  *
2200  * Returns 0 on success, negative on failure
2201  **/
2202 static int e1000_set_mac(struct net_device *netdev, void *p)
2203 {
2204 	struct e1000_adapter *adapter = netdev_priv(netdev);
2205 	struct e1000_hw *hw = &adapter->hw;
2206 	struct sockaddr *addr = p;
2207 
2208 	if (!is_valid_ether_addr(addr->sa_data))
2209 		return -EADDRNOTAVAIL;
2210 
2211 	/* 82542 2.0 needs to be in reset to write receive address registers */
2212 
2213 	if (hw->mac_type == e1000_82542_rev2_0)
2214 		e1000_enter_82542_rst(adapter);
2215 
2216 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
2217 	memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
2218 
2219 	e1000_rar_set(hw, hw->mac_addr, 0);
2220 
2221 	if (hw->mac_type == e1000_82542_rev2_0)
2222 		e1000_leave_82542_rst(adapter);
2223 
2224 	return 0;
2225 }
2226 
2227 /**
2228  * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
2229  * @netdev: network interface device structure
2230  *
2231  * The set_rx_mode entry point is called whenever the unicast or multicast
2232  * address lists or the network interface flags are updated. This routine is
2233  * responsible for configuring the hardware for proper unicast, multicast,
2234  * promiscuous mode, and all-multi behavior.
2235  **/
2236 static void e1000_set_rx_mode(struct net_device *netdev)
2237 {
2238 	struct e1000_adapter *adapter = netdev_priv(netdev);
2239 	struct e1000_hw *hw = &adapter->hw;
2240 	struct netdev_hw_addr *ha;
2241 	bool use_uc = false;
2242 	u32 rctl;
2243 	u32 hash_value;
2244 	int i, rar_entries = E1000_RAR_ENTRIES;
2245 	int mta_reg_count = E1000_NUM_MTA_REGISTERS;
2246 	u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);
2247 
2248 	if (!mcarray)
2249 		return;
2250 
2251 	/* Check for Promiscuous and All Multicast modes */
2252 
2253 	rctl = er32(RCTL);
2254 
2255 	if (netdev->flags & IFF_PROMISC) {
2256 		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
2257 		rctl &= ~E1000_RCTL_VFE;
2258 	} else {
2259 		if (netdev->flags & IFF_ALLMULTI)
2260 			rctl |= E1000_RCTL_MPE;
2261 		else
2262 			rctl &= ~E1000_RCTL_MPE;
2263 		/* Enable VLAN filter if there is a VLAN */
2264 		if (e1000_vlan_used(adapter))
2265 			rctl |= E1000_RCTL_VFE;
2266 	}
2267 
2268 	if (netdev_uc_count(netdev) > rar_entries - 1) {
2269 		rctl |= E1000_RCTL_UPE;
2270 	} else if (!(netdev->flags & IFF_PROMISC)) {
2271 		rctl &= ~E1000_RCTL_UPE;
2272 		use_uc = true;
2273 	}
2274 
2275 	ew32(RCTL, rctl);
2276 
2277 	/* 82542 2.0 needs to be in reset to write receive address registers */
2278 
2279 	if (hw->mac_type == e1000_82542_rev2_0)
2280 		e1000_enter_82542_rst(adapter);
2281 
2282 	/* load the first 14 addresses into the exact filters 1-14. Unicast
2283 	 * addresses take precedence to avoid disabling unicast filtering
2284 	 * when possible.
2285 	 *
2286 	 * RAR 0 is used for the station MAC address
2287 	 * if there are not 14 addresses, go ahead and clear the filters
2288 	 */
2289 	i = 1;
2290 	if (use_uc)
2291 		netdev_for_each_uc_addr(ha, netdev) {
2292 			if (i == rar_entries)
2293 				break;
2294 			e1000_rar_set(hw, ha->addr, i++);
2295 		}
2296 
2297 	netdev_for_each_mc_addr(ha, netdev) {
2298 		if (i == rar_entries) {
2299 			/* load any remaining addresses into the hash table */
2300 			u32 hash_reg, hash_bit, mta;
2301 			hash_value = e1000_hash_mc_addr(hw, ha->addr);
2302 			hash_reg = (hash_value >> 5) & 0x7F;
2303 			hash_bit = hash_value & 0x1F;
2304 			mta = (1 << hash_bit);
2305 			mcarray[hash_reg] |= mta;
2306 		} else {
2307 			e1000_rar_set(hw, ha->addr, i++);
2308 		}
2309 	}
2310 
2311 	for (; i < rar_entries; i++) {
2312 		E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
2313 		E1000_WRITE_FLUSH();
2314 		E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
2315 		E1000_WRITE_FLUSH();
2316 	}
2317 
2318 	/* write the hash table completely, write from bottom to avoid
2319 	 * both stupid write combining chipsets, and flushing each write
2320 	 */
2321 	for (i = mta_reg_count - 1; i >= 0 ; i--) {
2322 		/* If we are on an 82544 has an errata where writing odd
2323 		 * offsets overwrites the previous even offset, but writing
2324 		 * backwards over the range solves the issue by always
2325 		 * writing the odd offset first
2326 		 */
2327 		E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]);
2328 	}
2329 	E1000_WRITE_FLUSH();
2330 
2331 	if (hw->mac_type == e1000_82542_rev2_0)
2332 		e1000_leave_82542_rst(adapter);
2333 
2334 	kfree(mcarray);
2335 }
2336 
2337 /**
2338  * e1000_update_phy_info_task - get phy info
2339  * @work: work struct contained inside adapter struct
2340  *
2341  * Need to wait a few seconds after link up to get diagnostic information from
2342  * the phy
2343  */
2344 static void e1000_update_phy_info_task(struct work_struct *work)
2345 {
2346 	struct e1000_adapter *adapter = container_of(work,
2347 						     struct e1000_adapter,
2348 						     phy_info_task.work);
2349 
2350 	e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
2351 }
2352 
2353 /**
2354  * e1000_82547_tx_fifo_stall_task - task to complete work
2355  * @work: work struct contained inside adapter struct
2356  **/
2357 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work)
2358 {
2359 	struct e1000_adapter *adapter = container_of(work,
2360 						     struct e1000_adapter,
2361 						     fifo_stall_task.work);
2362 	struct e1000_hw *hw = &adapter->hw;
2363 	struct net_device *netdev = adapter->netdev;
2364 	u32 tctl;
2365 
2366 	if (atomic_read(&adapter->tx_fifo_stall)) {
2367 		if ((er32(TDT) == er32(TDH)) &&
2368 		   (er32(TDFT) == er32(TDFH)) &&
2369 		   (er32(TDFTS) == er32(TDFHS))) {
2370 			tctl = er32(TCTL);
2371 			ew32(TCTL, tctl & ~E1000_TCTL_EN);
2372 			ew32(TDFT, adapter->tx_head_addr);
2373 			ew32(TDFH, adapter->tx_head_addr);
2374 			ew32(TDFTS, adapter->tx_head_addr);
2375 			ew32(TDFHS, adapter->tx_head_addr);
2376 			ew32(TCTL, tctl);
2377 			E1000_WRITE_FLUSH();
2378 
2379 			adapter->tx_fifo_head = 0;
2380 			atomic_set(&adapter->tx_fifo_stall, 0);
2381 			netif_wake_queue(netdev);
2382 		} else if (!test_bit(__E1000_DOWN, &adapter->flags)) {
2383 			schedule_delayed_work(&adapter->fifo_stall_task, 1);
2384 		}
2385 	}
2386 }
2387 
2388 bool e1000_has_link(struct e1000_adapter *adapter)
2389 {
2390 	struct e1000_hw *hw = &adapter->hw;
2391 	bool link_active = false;
2392 
2393 	/* get_link_status is set on LSC (link status) interrupt or rx
2394 	 * sequence error interrupt (except on intel ce4100).
2395 	 * get_link_status will stay false until the
2396 	 * e1000_check_for_link establishes link for copper adapters
2397 	 * ONLY
2398 	 */
2399 	switch (hw->media_type) {
2400 	case e1000_media_type_copper:
2401 		if (hw->mac_type == e1000_ce4100)
2402 			hw->get_link_status = 1;
2403 		if (hw->get_link_status) {
2404 			e1000_check_for_link(hw);
2405 			link_active = !hw->get_link_status;
2406 		} else {
2407 			link_active = true;
2408 		}
2409 		break;
2410 	case e1000_media_type_fiber:
2411 		e1000_check_for_link(hw);
2412 		link_active = !!(er32(STATUS) & E1000_STATUS_LU);
2413 		break;
2414 	case e1000_media_type_internal_serdes:
2415 		e1000_check_for_link(hw);
2416 		link_active = hw->serdes_has_link;
2417 		break;
2418 	default:
2419 		break;
2420 	}
2421 
2422 	return link_active;
2423 }
2424 
2425 /**
2426  * e1000_watchdog - work function
2427  * @work: work struct contained inside adapter struct
2428  **/
2429 static void e1000_watchdog(struct work_struct *work)
2430 {
2431 	struct e1000_adapter *adapter = container_of(work,
2432 						     struct e1000_adapter,
2433 						     watchdog_task.work);
2434 	struct e1000_hw *hw = &adapter->hw;
2435 	struct net_device *netdev = adapter->netdev;
2436 	struct e1000_tx_ring *txdr = adapter->tx_ring;
2437 	u32 link, tctl;
2438 
2439 	link = e1000_has_link(adapter);
2440 	if ((netif_carrier_ok(netdev)) && link)
2441 		goto link_up;
2442 
2443 	if (link) {
2444 		if (!netif_carrier_ok(netdev)) {
2445 			u32 ctrl;
2446 			bool txb2b = true;
2447 			/* update snapshot of PHY registers on LSC */
2448 			e1000_get_speed_and_duplex(hw,
2449 						   &adapter->link_speed,
2450 						   &adapter->link_duplex);
2451 
2452 			ctrl = er32(CTRL);
2453 			pr_info("%s NIC Link is Up %d Mbps %s, "
2454 				"Flow Control: %s\n",
2455 				netdev->name,
2456 				adapter->link_speed,
2457 				adapter->link_duplex == FULL_DUPLEX ?
2458 				"Full Duplex" : "Half Duplex",
2459 				((ctrl & E1000_CTRL_TFCE) && (ctrl &
2460 				E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
2461 				E1000_CTRL_RFCE) ? "RX" : ((ctrl &
2462 				E1000_CTRL_TFCE) ? "TX" : "None")));
2463 
2464 			/* adjust timeout factor according to speed/duplex */
2465 			adapter->tx_timeout_factor = 1;
2466 			switch (adapter->link_speed) {
2467 			case SPEED_10:
2468 				txb2b = false;
2469 				adapter->tx_timeout_factor = 16;
2470 				break;
2471 			case SPEED_100:
2472 				txb2b = false;
2473 				/* maybe add some timeout factor ? */
2474 				break;
2475 			}
2476 
2477 			/* enable transmits in the hardware */
2478 			tctl = er32(TCTL);
2479 			tctl |= E1000_TCTL_EN;
2480 			ew32(TCTL, tctl);
2481 
2482 			netif_carrier_on(netdev);
2483 			if (!test_bit(__E1000_DOWN, &adapter->flags))
2484 				schedule_delayed_work(&adapter->phy_info_task,
2485 						      2 * HZ);
2486 			adapter->smartspeed = 0;
2487 		}
2488 	} else {
2489 		if (netif_carrier_ok(netdev)) {
2490 			adapter->link_speed = 0;
2491 			adapter->link_duplex = 0;
2492 			pr_info("%s NIC Link is Down\n",
2493 				netdev->name);
2494 			netif_carrier_off(netdev);
2495 
2496 			if (!test_bit(__E1000_DOWN, &adapter->flags))
2497 				schedule_delayed_work(&adapter->phy_info_task,
2498 						      2 * HZ);
2499 		}
2500 
2501 		e1000_smartspeed(adapter);
2502 	}
2503 
2504 link_up:
2505 	e1000_update_stats(adapter);
2506 
2507 	hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
2508 	adapter->tpt_old = adapter->stats.tpt;
2509 	hw->collision_delta = adapter->stats.colc - adapter->colc_old;
2510 	adapter->colc_old = adapter->stats.colc;
2511 
2512 	adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
2513 	adapter->gorcl_old = adapter->stats.gorcl;
2514 	adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
2515 	adapter->gotcl_old = adapter->stats.gotcl;
2516 
2517 	e1000_update_adaptive(hw);
2518 
2519 	if (!netif_carrier_ok(netdev)) {
2520 		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
2521 			/* We've lost link, so the controller stops DMA,
2522 			 * but we've got queued Tx work that's never going
2523 			 * to get done, so reset controller to flush Tx.
2524 			 * (Do the reset outside of interrupt context).
2525 			 */
2526 			adapter->tx_timeout_count++;
2527 			schedule_work(&adapter->reset_task);
2528 			/* exit immediately since reset is imminent */
2529 			return;
2530 		}
2531 	}
2532 
2533 	/* Simple mode for Interrupt Throttle Rate (ITR) */
2534 	if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
2535 		/* Symmetric Tx/Rx gets a reduced ITR=2000;
2536 		 * Total asymmetrical Tx or Rx gets ITR=8000;
2537 		 * everyone else is between 2000-8000.
2538 		 */
2539 		u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
2540 		u32 dif = (adapter->gotcl > adapter->gorcl ?
2541 			    adapter->gotcl - adapter->gorcl :
2542 			    adapter->gorcl - adapter->gotcl) / 10000;
2543 		u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
2544 
2545 		ew32(ITR, 1000000000 / (itr * 256));
2546 	}
2547 
2548 	/* Cause software interrupt to ensure rx ring is cleaned */
2549 	ew32(ICS, E1000_ICS_RXDMT0);
2550 
2551 	/* Force detection of hung controller every watchdog period */
2552 	adapter->detect_tx_hung = true;
2553 
2554 	/* Reschedule the task */
2555 	if (!test_bit(__E1000_DOWN, &adapter->flags))
2556 		schedule_delayed_work(&adapter->watchdog_task, 2 * HZ);
2557 }
2558 
2559 enum latency_range {
2560 	lowest_latency = 0,
2561 	low_latency = 1,
2562 	bulk_latency = 2,
2563 	latency_invalid = 255
2564 };
2565 
2566 /**
2567  * e1000_update_itr - update the dynamic ITR value based on statistics
2568  * @adapter: pointer to adapter
2569  * @itr_setting: current adapter->itr
2570  * @packets: the number of packets during this measurement interval
2571  * @bytes: the number of bytes during this measurement interval
2572  *
2573  *      Stores a new ITR value based on packets and byte
2574  *      counts during the last interrupt.  The advantage of per interrupt
2575  *      computation is faster updates and more accurate ITR for the current
2576  *      traffic pattern.  Constants in this function were computed
2577  *      based on theoretical maximum wire speed and thresholds were set based
2578  *      on testing data as well as attempting to minimize response time
2579  *      while increasing bulk throughput.
2580  *      this functionality is controlled by the InterruptThrottleRate module
2581  *      parameter (see e1000_param.c)
2582  **/
2583 static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
2584 				     u16 itr_setting, int packets, int bytes)
2585 {
2586 	unsigned int retval = itr_setting;
2587 	struct e1000_hw *hw = &adapter->hw;
2588 
2589 	if (unlikely(hw->mac_type < e1000_82540))
2590 		goto update_itr_done;
2591 
2592 	if (packets == 0)
2593 		goto update_itr_done;
2594 
2595 	switch (itr_setting) {
2596 	case lowest_latency:
2597 		/* jumbo frames get bulk treatment*/
2598 		if (bytes/packets > 8000)
2599 			retval = bulk_latency;
2600 		else if ((packets < 5) && (bytes > 512))
2601 			retval = low_latency;
2602 		break;
2603 	case low_latency:  /* 50 usec aka 20000 ints/s */
2604 		if (bytes > 10000) {
2605 			/* jumbo frames need bulk latency setting */
2606 			if (bytes/packets > 8000)
2607 				retval = bulk_latency;
2608 			else if ((packets < 10) || ((bytes/packets) > 1200))
2609 				retval = bulk_latency;
2610 			else if ((packets > 35))
2611 				retval = lowest_latency;
2612 		} else if (bytes/packets > 2000)
2613 			retval = bulk_latency;
2614 		else if (packets <= 2 && bytes < 512)
2615 			retval = lowest_latency;
2616 		break;
2617 	case bulk_latency: /* 250 usec aka 4000 ints/s */
2618 		if (bytes > 25000) {
2619 			if (packets > 35)
2620 				retval = low_latency;
2621 		} else if (bytes < 6000) {
2622 			retval = low_latency;
2623 		}
2624 		break;
2625 	}
2626 
2627 update_itr_done:
2628 	return retval;
2629 }
2630 
2631 static void e1000_set_itr(struct e1000_adapter *adapter)
2632 {
2633 	struct e1000_hw *hw = &adapter->hw;
2634 	u16 current_itr;
2635 	u32 new_itr = adapter->itr;
2636 
2637 	if (unlikely(hw->mac_type < e1000_82540))
2638 		return;
2639 
2640 	/* for non-gigabit speeds, just fix the interrupt rate at 4000 */
2641 	if (unlikely(adapter->link_speed != SPEED_1000)) {
2642 		current_itr = 0;
2643 		new_itr = 4000;
2644 		goto set_itr_now;
2645 	}
2646 
2647 	adapter->tx_itr = e1000_update_itr(adapter, adapter->tx_itr,
2648 					   adapter->total_tx_packets,
2649 					   adapter->total_tx_bytes);
2650 	/* conservative mode (itr 3) eliminates the lowest_latency setting */
2651 	if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
2652 		adapter->tx_itr = low_latency;
2653 
2654 	adapter->rx_itr = e1000_update_itr(adapter, adapter->rx_itr,
2655 					   adapter->total_rx_packets,
2656 					   adapter->total_rx_bytes);
2657 	/* conservative mode (itr 3) eliminates the lowest_latency setting */
2658 	if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
2659 		adapter->rx_itr = low_latency;
2660 
2661 	current_itr = max(adapter->rx_itr, adapter->tx_itr);
2662 
2663 	switch (current_itr) {
2664 	/* counts and packets in update_itr are dependent on these numbers */
2665 	case lowest_latency:
2666 		new_itr = 70000;
2667 		break;
2668 	case low_latency:
2669 		new_itr = 20000; /* aka hwitr = ~200 */
2670 		break;
2671 	case bulk_latency:
2672 		new_itr = 4000;
2673 		break;
2674 	default:
2675 		break;
2676 	}
2677 
2678 set_itr_now:
2679 	if (new_itr != adapter->itr) {
2680 		/* this attempts to bias the interrupt rate towards Bulk
2681 		 * by adding intermediate steps when interrupt rate is
2682 		 * increasing
2683 		 */
2684 		new_itr = new_itr > adapter->itr ?
2685 			  min(adapter->itr + (new_itr >> 2), new_itr) :
2686 			  new_itr;
2687 		adapter->itr = new_itr;
2688 		ew32(ITR, 1000000000 / (new_itr * 256));
2689 	}
2690 }
2691 
2692 #define E1000_TX_FLAGS_CSUM		0x00000001
2693 #define E1000_TX_FLAGS_VLAN		0x00000002
2694 #define E1000_TX_FLAGS_TSO		0x00000004
2695 #define E1000_TX_FLAGS_IPV4		0x00000008
2696 #define E1000_TX_FLAGS_NO_FCS		0x00000010
2697 #define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
2698 #define E1000_TX_FLAGS_VLAN_SHIFT	16
2699 
2700 static int e1000_tso(struct e1000_adapter *adapter,
2701 		     struct e1000_tx_ring *tx_ring, struct sk_buff *skb,
2702 		     __be16 protocol)
2703 {
2704 	struct e1000_context_desc *context_desc;
2705 	struct e1000_tx_buffer *buffer_info;
2706 	unsigned int i;
2707 	u32 cmd_length = 0;
2708 	u16 ipcse = 0, tucse, mss;
2709 	u8 ipcss, ipcso, tucss, tucso, hdr_len;
2710 
2711 	if (skb_is_gso(skb)) {
2712 		int err;
2713 
2714 		err = skb_cow_head(skb, 0);
2715 		if (err < 0)
2716 			return err;
2717 
2718 		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
2719 		mss = skb_shinfo(skb)->gso_size;
2720 		if (protocol == htons(ETH_P_IP)) {
2721 			struct iphdr *iph = ip_hdr(skb);
2722 			iph->tot_len = 0;
2723 			iph->check = 0;
2724 			tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
2725 								 iph->daddr, 0,
2726 								 IPPROTO_TCP,
2727 								 0);
2728 			cmd_length = E1000_TXD_CMD_IP;
2729 			ipcse = skb_transport_offset(skb) - 1;
2730 		} else if (skb_is_gso_v6(skb)) {
2731 			ipv6_hdr(skb)->payload_len = 0;
2732 			tcp_hdr(skb)->check =
2733 				~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
2734 						 &ipv6_hdr(skb)->daddr,
2735 						 0, IPPROTO_TCP, 0);
2736 			ipcse = 0;
2737 		}
2738 		ipcss = skb_network_offset(skb);
2739 		ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
2740 		tucss = skb_transport_offset(skb);
2741 		tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
2742 		tucse = 0;
2743 
2744 		cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
2745 			       E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
2746 
2747 		i = tx_ring->next_to_use;
2748 		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
2749 		buffer_info = &tx_ring->buffer_info[i];
2750 
2751 		context_desc->lower_setup.ip_fields.ipcss  = ipcss;
2752 		context_desc->lower_setup.ip_fields.ipcso  = ipcso;
2753 		context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
2754 		context_desc->upper_setup.tcp_fields.tucss = tucss;
2755 		context_desc->upper_setup.tcp_fields.tucso = tucso;
2756 		context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
2757 		context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
2758 		context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
2759 		context_desc->cmd_and_length = cpu_to_le32(cmd_length);
2760 
2761 		buffer_info->time_stamp = jiffies;
2762 		buffer_info->next_to_watch = i;
2763 
2764 		if (++i == tx_ring->count) i = 0;
2765 		tx_ring->next_to_use = i;
2766 
2767 		return true;
2768 	}
2769 	return false;
2770 }
2771 
2772 static bool e1000_tx_csum(struct e1000_adapter *adapter,
2773 			  struct e1000_tx_ring *tx_ring, struct sk_buff *skb,
2774 			  __be16 protocol)
2775 {
2776 	struct e1000_context_desc *context_desc;
2777 	struct e1000_tx_buffer *buffer_info;
2778 	unsigned int i;
2779 	u8 css;
2780 	u32 cmd_len = E1000_TXD_CMD_DEXT;
2781 
2782 	if (skb->ip_summed != CHECKSUM_PARTIAL)
2783 		return false;
2784 
2785 	switch (protocol) {
2786 	case cpu_to_be16(ETH_P_IP):
2787 		if (ip_hdr(skb)->protocol == IPPROTO_TCP)
2788 			cmd_len |= E1000_TXD_CMD_TCP;
2789 		break;
2790 	case cpu_to_be16(ETH_P_IPV6):
2791 		/* XXX not handling all IPV6 headers */
2792 		if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
2793 			cmd_len |= E1000_TXD_CMD_TCP;
2794 		break;
2795 	default:
2796 		if (unlikely(net_ratelimit()))
2797 			e_warn(drv, "checksum_partial proto=%x!\n",
2798 			       skb->protocol);
2799 		break;
2800 	}
2801 
2802 	css = skb_checksum_start_offset(skb);
2803 
2804 	i = tx_ring->next_to_use;
2805 	buffer_info = &tx_ring->buffer_info[i];
2806 	context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
2807 
2808 	context_desc->lower_setup.ip_config = 0;
2809 	context_desc->upper_setup.tcp_fields.tucss = css;
2810 	context_desc->upper_setup.tcp_fields.tucso =
2811 		css + skb->csum_offset;
2812 	context_desc->upper_setup.tcp_fields.tucse = 0;
2813 	context_desc->tcp_seg_setup.data = 0;
2814 	context_desc->cmd_and_length = cpu_to_le32(cmd_len);
2815 
2816 	buffer_info->time_stamp = jiffies;
2817 	buffer_info->next_to_watch = i;
2818 
2819 	if (unlikely(++i == tx_ring->count)) i = 0;
2820 	tx_ring->next_to_use = i;
2821 
2822 	return true;
2823 }
2824 
2825 #define E1000_MAX_TXD_PWR	12
2826 #define E1000_MAX_DATA_PER_TXD	(1<<E1000_MAX_TXD_PWR)
2827 
2828 static int e1000_tx_map(struct e1000_adapter *adapter,
2829 			struct e1000_tx_ring *tx_ring,
2830 			struct sk_buff *skb, unsigned int first,
2831 			unsigned int max_per_txd, unsigned int nr_frags,
2832 			unsigned int mss)
2833 {
2834 	struct e1000_hw *hw = &adapter->hw;
2835 	struct pci_dev *pdev = adapter->pdev;
2836 	struct e1000_tx_buffer *buffer_info;
2837 	unsigned int len = skb_headlen(skb);
2838 	unsigned int offset = 0, size, count = 0, i;
2839 	unsigned int f, bytecount, segs;
2840 
2841 	i = tx_ring->next_to_use;
2842 
2843 	while (len) {
2844 		buffer_info = &tx_ring->buffer_info[i];
2845 		size = min(len, max_per_txd);
2846 		/* Workaround for Controller erratum --
2847 		 * descriptor for non-tso packet in a linear SKB that follows a
2848 		 * tso gets written back prematurely before the data is fully
2849 		 * DMA'd to the controller
2850 		 */
2851 		if (!skb->data_len && tx_ring->last_tx_tso &&
2852 		    !skb_is_gso(skb)) {
2853 			tx_ring->last_tx_tso = false;
2854 			size -= 4;
2855 		}
2856 
2857 		/* Workaround for premature desc write-backs
2858 		 * in TSO mode.  Append 4-byte sentinel desc
2859 		 */
2860 		if (unlikely(mss && !nr_frags && size == len && size > 8))
2861 			size -= 4;
2862 		/* work-around for errata 10 and it applies
2863 		 * to all controllers in PCI-X mode
2864 		 * The fix is to make sure that the first descriptor of a
2865 		 * packet is smaller than 2048 - 16 - 16 (or 2016) bytes
2866 		 */
2867 		if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
2868 		                (size > 2015) && count == 0))
2869 		        size = 2015;
2870 
2871 		/* Workaround for potential 82544 hang in PCI-X.  Avoid
2872 		 * terminating buffers within evenly-aligned dwords.
2873 		 */
2874 		if (unlikely(adapter->pcix_82544 &&
2875 		   !((unsigned long)(skb->data + offset + size - 1) & 4) &&
2876 		   size > 4))
2877 			size -= 4;
2878 
2879 		buffer_info->length = size;
2880 		/* set time_stamp *before* dma to help avoid a possible race */
2881 		buffer_info->time_stamp = jiffies;
2882 		buffer_info->mapped_as_page = false;
2883 		buffer_info->dma = dma_map_single(&pdev->dev,
2884 						  skb->data + offset,
2885 						  size, DMA_TO_DEVICE);
2886 		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2887 			goto dma_error;
2888 		buffer_info->next_to_watch = i;
2889 
2890 		len -= size;
2891 		offset += size;
2892 		count++;
2893 		if (len) {
2894 			i++;
2895 			if (unlikely(i == tx_ring->count))
2896 				i = 0;
2897 		}
2898 	}
2899 
2900 	for (f = 0; f < nr_frags; f++) {
2901 		const struct skb_frag_struct *frag;
2902 
2903 		frag = &skb_shinfo(skb)->frags[f];
2904 		len = skb_frag_size(frag);
2905 		offset = 0;
2906 
2907 		while (len) {
2908 			unsigned long bufend;
2909 			i++;
2910 			if (unlikely(i == tx_ring->count))
2911 				i = 0;
2912 
2913 			buffer_info = &tx_ring->buffer_info[i];
2914 			size = min(len, max_per_txd);
2915 			/* Workaround for premature desc write-backs
2916 			 * in TSO mode.  Append 4-byte sentinel desc
2917 			 */
2918 			if (unlikely(mss && f == (nr_frags-1) &&
2919 			    size == len && size > 8))
2920 				size -= 4;
2921 			/* Workaround for potential 82544 hang in PCI-X.
2922 			 * Avoid terminating buffers within evenly-aligned
2923 			 * dwords.
2924 			 */
2925 			bufend = (unsigned long)
2926 				page_to_phys(skb_frag_page(frag));
2927 			bufend += offset + size - 1;
2928 			if (unlikely(adapter->pcix_82544 &&
2929 				     !(bufend & 4) &&
2930 				     size > 4))
2931 				size -= 4;
2932 
2933 			buffer_info->length = size;
2934 			buffer_info->time_stamp = jiffies;
2935 			buffer_info->mapped_as_page = true;
2936 			buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
2937 						offset, size, DMA_TO_DEVICE);
2938 			if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2939 				goto dma_error;
2940 			buffer_info->next_to_watch = i;
2941 
2942 			len -= size;
2943 			offset += size;
2944 			count++;
2945 		}
2946 	}
2947 
2948 	segs = skb_shinfo(skb)->gso_segs ?: 1;
2949 	/* multiply data chunks by size of headers */
2950 	bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len;
2951 
2952 	tx_ring->buffer_info[i].skb = skb;
2953 	tx_ring->buffer_info[i].segs = segs;
2954 	tx_ring->buffer_info[i].bytecount = bytecount;
2955 	tx_ring->buffer_info[first].next_to_watch = i;
2956 
2957 	return count;
2958 
2959 dma_error:
2960 	dev_err(&pdev->dev, "TX DMA map failed\n");
2961 	buffer_info->dma = 0;
2962 	if (count)
2963 		count--;
2964 
2965 	while (count--) {
2966 		if (i==0)
2967 			i += tx_ring->count;
2968 		i--;
2969 		buffer_info = &tx_ring->buffer_info[i];
2970 		e1000_unmap_and_free_tx_resource(adapter, buffer_info);
2971 	}
2972 
2973 	return 0;
2974 }
2975 
2976 static void e1000_tx_queue(struct e1000_adapter *adapter,
2977 			   struct e1000_tx_ring *tx_ring, int tx_flags,
2978 			   int count)
2979 {
2980 	struct e1000_hw *hw = &adapter->hw;
2981 	struct e1000_tx_desc *tx_desc = NULL;
2982 	struct e1000_tx_buffer *buffer_info;
2983 	u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
2984 	unsigned int i;
2985 
2986 	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
2987 		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
2988 			     E1000_TXD_CMD_TSE;
2989 		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2990 
2991 		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2992 			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
2993 	}
2994 
2995 	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
2996 		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2997 		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2998 	}
2999 
3000 	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
3001 		txd_lower |= E1000_TXD_CMD_VLE;
3002 		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
3003 	}
3004 
3005 	if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
3006 		txd_lower &= ~(E1000_TXD_CMD_IFCS);
3007 
3008 	i = tx_ring->next_to_use;
3009 
3010 	while (count--) {
3011 		buffer_info = &tx_ring->buffer_info[i];
3012 		tx_desc = E1000_TX_DESC(*tx_ring, i);
3013 		tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
3014 		tx_desc->lower.data =
3015 			cpu_to_le32(txd_lower | buffer_info->length);
3016 		tx_desc->upper.data = cpu_to_le32(txd_upper);
3017 		if (unlikely(++i == tx_ring->count)) i = 0;
3018 	}
3019 
3020 	tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
3021 
3022 	/* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */
3023 	if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
3024 		tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS));
3025 
3026 	/* Force memory writes to complete before letting h/w
3027 	 * know there are new descriptors to fetch.  (Only
3028 	 * applicable for weak-ordered memory model archs,
3029 	 * such as IA-64).
3030 	 */
3031 	wmb();
3032 
3033 	tx_ring->next_to_use = i;
3034 	writel(i, hw->hw_addr + tx_ring->tdt);
3035 	/* we need this if more than one processor can write to our tail
3036 	 * at a time, it synchronizes IO on IA64/Altix systems
3037 	 */
3038 	mmiowb();
3039 }
3040 
3041 /* 82547 workaround to avoid controller hang in half-duplex environment.
3042  * The workaround is to avoid queuing a large packet that would span
3043  * the internal Tx FIFO ring boundary by notifying the stack to resend
3044  * the packet at a later time.  This gives the Tx FIFO an opportunity to
3045  * flush all packets.  When that occurs, we reset the Tx FIFO pointers
3046  * to the beginning of the Tx FIFO.
3047  */
3048 
3049 #define E1000_FIFO_HDR			0x10
3050 #define E1000_82547_PAD_LEN		0x3E0
3051 
3052 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
3053 				       struct sk_buff *skb)
3054 {
3055 	u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
3056 	u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
3057 
3058 	skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
3059 
3060 	if (adapter->link_duplex != HALF_DUPLEX)
3061 		goto no_fifo_stall_required;
3062 
3063 	if (atomic_read(&adapter->tx_fifo_stall))
3064 		return 1;
3065 
3066 	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
3067 		atomic_set(&adapter->tx_fifo_stall, 1);
3068 		return 1;
3069 	}
3070 
3071 no_fifo_stall_required:
3072 	adapter->tx_fifo_head += skb_fifo_len;
3073 	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
3074 		adapter->tx_fifo_head -= adapter->tx_fifo_size;
3075 	return 0;
3076 }
3077 
3078 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
3079 {
3080 	struct e1000_adapter *adapter = netdev_priv(netdev);
3081 	struct e1000_tx_ring *tx_ring = adapter->tx_ring;
3082 
3083 	netif_stop_queue(netdev);
3084 	/* Herbert's original patch had:
3085 	 *  smp_mb__after_netif_stop_queue();
3086 	 * but since that doesn't exist yet, just open code it.
3087 	 */
3088 	smp_mb();
3089 
3090 	/* We need to check again in a case another CPU has just
3091 	 * made room available.
3092 	 */
3093 	if (likely(E1000_DESC_UNUSED(tx_ring) < size))
3094 		return -EBUSY;
3095 
3096 	/* A reprieve! */
3097 	netif_start_queue(netdev);
3098 	++adapter->restart_queue;
3099 	return 0;
3100 }
3101 
3102 static int e1000_maybe_stop_tx(struct net_device *netdev,
3103 			       struct e1000_tx_ring *tx_ring, int size)
3104 {
3105 	if (likely(E1000_DESC_UNUSED(tx_ring) >= size))
3106 		return 0;
3107 	return __e1000_maybe_stop_tx(netdev, size);
3108 }
3109 
3110 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
3111 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
3112 				    struct net_device *netdev)
3113 {
3114 	struct e1000_adapter *adapter = netdev_priv(netdev);
3115 	struct e1000_hw *hw = &adapter->hw;
3116 	struct e1000_tx_ring *tx_ring;
3117 	unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
3118 	unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
3119 	unsigned int tx_flags = 0;
3120 	unsigned int len = skb_headlen(skb);
3121 	unsigned int nr_frags;
3122 	unsigned int mss;
3123 	int count = 0;
3124 	int tso;
3125 	unsigned int f;
3126 	__be16 protocol = vlan_get_protocol(skb);
3127 
3128 	/* This goes back to the question of how to logically map a Tx queue
3129 	 * to a flow.  Right now, performance is impacted slightly negatively
3130 	 * if using multiple Tx queues.  If the stack breaks away from a
3131 	 * single qdisc implementation, we can look at this again.
3132 	 */
3133 	tx_ring = adapter->tx_ring;
3134 
3135 	/* On PCI/PCI-X HW, if packet size is less than ETH_ZLEN,
3136 	 * packets may get corrupted during padding by HW.
3137 	 * To WA this issue, pad all small packets manually.
3138 	 */
3139 	if (skb->len < ETH_ZLEN) {
3140 		if (skb_pad(skb, ETH_ZLEN - skb->len))
3141 			return NETDEV_TX_OK;
3142 		skb->len = ETH_ZLEN;
3143 		skb_set_tail_pointer(skb, ETH_ZLEN);
3144 	}
3145 
3146 	mss = skb_shinfo(skb)->gso_size;
3147 	/* The controller does a simple calculation to
3148 	 * make sure there is enough room in the FIFO before
3149 	 * initiating the DMA for each buffer.  The calc is:
3150 	 * 4 = ceil(buffer len/mss).  To make sure we don't
3151 	 * overrun the FIFO, adjust the max buffer len if mss
3152 	 * drops.
3153 	 */
3154 	if (mss) {
3155 		u8 hdr_len;
3156 		max_per_txd = min(mss << 2, max_per_txd);
3157 		max_txd_pwr = fls(max_per_txd) - 1;
3158 
3159 		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
3160 		if (skb->data_len && hdr_len == len) {
3161 			switch (hw->mac_type) {
3162 				unsigned int pull_size;
3163 			case e1000_82544:
3164 				/* Make sure we have room to chop off 4 bytes,
3165 				 * and that the end alignment will work out to
3166 				 * this hardware's requirements
3167 				 * NOTE: this is a TSO only workaround
3168 				 * if end byte alignment not correct move us
3169 				 * into the next dword
3170 				 */
3171 				if ((unsigned long)(skb_tail_pointer(skb) - 1)
3172 				    & 4)
3173 					break;
3174 				/* fall through */
3175 				pull_size = min((unsigned int)4, skb->data_len);
3176 				if (!__pskb_pull_tail(skb, pull_size)) {
3177 					e_err(drv, "__pskb_pull_tail "
3178 					      "failed.\n");
3179 					dev_kfree_skb_any(skb);
3180 					return NETDEV_TX_OK;
3181 				}
3182 				len = skb_headlen(skb);
3183 				break;
3184 			default:
3185 				/* do nothing */
3186 				break;
3187 			}
3188 		}
3189 	}
3190 
3191 	/* reserve a descriptor for the offload context */
3192 	if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
3193 		count++;
3194 	count++;
3195 
3196 	/* Controller Erratum workaround */
3197 	if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb))
3198 		count++;
3199 
3200 	count += TXD_USE_COUNT(len, max_txd_pwr);
3201 
3202 	if (adapter->pcix_82544)
3203 		count++;
3204 
3205 	/* work-around for errata 10 and it applies to all controllers
3206 	 * in PCI-X mode, so add one more descriptor to the count
3207 	 */
3208 	if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
3209 			(len > 2015)))
3210 		count++;
3211 
3212 	nr_frags = skb_shinfo(skb)->nr_frags;
3213 	for (f = 0; f < nr_frags; f++)
3214 		count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]),
3215 				       max_txd_pwr);
3216 	if (adapter->pcix_82544)
3217 		count += nr_frags;
3218 
3219 	/* need: count + 2 desc gap to keep tail from touching
3220 	 * head, otherwise try next time
3221 	 */
3222 	if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
3223 		return NETDEV_TX_BUSY;
3224 
3225 	if (unlikely((hw->mac_type == e1000_82547) &&
3226 		     (e1000_82547_fifo_workaround(adapter, skb)))) {
3227 		netif_stop_queue(netdev);
3228 		if (!test_bit(__E1000_DOWN, &adapter->flags))
3229 			schedule_delayed_work(&adapter->fifo_stall_task, 1);
3230 		return NETDEV_TX_BUSY;
3231 	}
3232 
3233 	if (vlan_tx_tag_present(skb)) {
3234 		tx_flags |= E1000_TX_FLAGS_VLAN;
3235 		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
3236 	}
3237 
3238 	first = tx_ring->next_to_use;
3239 
3240 	tso = e1000_tso(adapter, tx_ring, skb, protocol);
3241 	if (tso < 0) {
3242 		dev_kfree_skb_any(skb);
3243 		return NETDEV_TX_OK;
3244 	}
3245 
3246 	if (likely(tso)) {
3247 		if (likely(hw->mac_type != e1000_82544))
3248 			tx_ring->last_tx_tso = true;
3249 		tx_flags |= E1000_TX_FLAGS_TSO;
3250 	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb, protocol)))
3251 		tx_flags |= E1000_TX_FLAGS_CSUM;
3252 
3253 	if (protocol == htons(ETH_P_IP))
3254 		tx_flags |= E1000_TX_FLAGS_IPV4;
3255 
3256 	if (unlikely(skb->no_fcs))
3257 		tx_flags |= E1000_TX_FLAGS_NO_FCS;
3258 
3259 	count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd,
3260 			     nr_frags, mss);
3261 
3262 	if (count) {
3263 		netdev_sent_queue(netdev, skb->len);
3264 		skb_tx_timestamp(skb);
3265 
3266 		e1000_tx_queue(adapter, tx_ring, tx_flags, count);
3267 		/* Make sure there is space in the ring for the next send. */
3268 		e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
3269 
3270 	} else {
3271 		dev_kfree_skb_any(skb);
3272 		tx_ring->buffer_info[first].time_stamp = 0;
3273 		tx_ring->next_to_use = first;
3274 	}
3275 
3276 	return NETDEV_TX_OK;
3277 }
3278 
3279 #define NUM_REGS 38 /* 1 based count */
3280 static void e1000_regdump(struct e1000_adapter *adapter)
3281 {
3282 	struct e1000_hw *hw = &adapter->hw;
3283 	u32 regs[NUM_REGS];
3284 	u32 *regs_buff = regs;
3285 	int i = 0;
3286 
3287 	static const char * const reg_name[] = {
3288 		"CTRL",  "STATUS",
3289 		"RCTL", "RDLEN", "RDH", "RDT", "RDTR",
3290 		"TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT",
3291 		"TIDV", "TXDCTL", "TADV", "TARC0",
3292 		"TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1",
3293 		"TXDCTL1", "TARC1",
3294 		"CTRL_EXT", "ERT", "RDBAL", "RDBAH",
3295 		"TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC",
3296 		"RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC"
3297 	};
3298 
3299 	regs_buff[0]  = er32(CTRL);
3300 	regs_buff[1]  = er32(STATUS);
3301 
3302 	regs_buff[2]  = er32(RCTL);
3303 	regs_buff[3]  = er32(RDLEN);
3304 	regs_buff[4]  = er32(RDH);
3305 	regs_buff[5]  = er32(RDT);
3306 	regs_buff[6]  = er32(RDTR);
3307 
3308 	regs_buff[7]  = er32(TCTL);
3309 	regs_buff[8]  = er32(TDBAL);
3310 	regs_buff[9]  = er32(TDBAH);
3311 	regs_buff[10] = er32(TDLEN);
3312 	regs_buff[11] = er32(TDH);
3313 	regs_buff[12] = er32(TDT);
3314 	regs_buff[13] = er32(TIDV);
3315 	regs_buff[14] = er32(TXDCTL);
3316 	regs_buff[15] = er32(TADV);
3317 	regs_buff[16] = er32(TARC0);
3318 
3319 	regs_buff[17] = er32(TDBAL1);
3320 	regs_buff[18] = er32(TDBAH1);
3321 	regs_buff[19] = er32(TDLEN1);
3322 	regs_buff[20] = er32(TDH1);
3323 	regs_buff[21] = er32(TDT1);
3324 	regs_buff[22] = er32(TXDCTL1);
3325 	regs_buff[23] = er32(TARC1);
3326 	regs_buff[24] = er32(CTRL_EXT);
3327 	regs_buff[25] = er32(ERT);
3328 	regs_buff[26] = er32(RDBAL0);
3329 	regs_buff[27] = er32(RDBAH0);
3330 	regs_buff[28] = er32(TDFH);
3331 	regs_buff[29] = er32(TDFT);
3332 	regs_buff[30] = er32(TDFHS);
3333 	regs_buff[31] = er32(TDFTS);
3334 	regs_buff[32] = er32(TDFPC);
3335 	regs_buff[33] = er32(RDFH);
3336 	regs_buff[34] = er32(RDFT);
3337 	regs_buff[35] = er32(RDFHS);
3338 	regs_buff[36] = er32(RDFTS);
3339 	regs_buff[37] = er32(RDFPC);
3340 
3341 	pr_info("Register dump\n");
3342 	for (i = 0; i < NUM_REGS; i++)
3343 		pr_info("%-15s  %08x\n", reg_name[i], regs_buff[i]);
3344 }
3345 
3346 /*
3347  * e1000_dump: Print registers, tx ring and rx ring
3348  */
3349 static void e1000_dump(struct e1000_adapter *adapter)
3350 {
3351 	/* this code doesn't handle multiple rings */
3352 	struct e1000_tx_ring *tx_ring = adapter->tx_ring;
3353 	struct e1000_rx_ring *rx_ring = adapter->rx_ring;
3354 	int i;
3355 
3356 	if (!netif_msg_hw(adapter))
3357 		return;
3358 
3359 	/* Print Registers */
3360 	e1000_regdump(adapter);
3361 
3362 	/* transmit dump */
3363 	pr_info("TX Desc ring0 dump\n");
3364 
3365 	/* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)
3366 	 *
3367 	 * Legacy Transmit Descriptor
3368 	 *   +--------------------------------------------------------------+
3369 	 * 0 |         Buffer Address [63:0] (Reserved on Write Back)       |
3370 	 *   +--------------------------------------------------------------+
3371 	 * 8 | Special  |    CSS     | Status |  CMD    |  CSO   |  Length  |
3372 	 *   +--------------------------------------------------------------+
3373 	 *   63       48 47        36 35    32 31     24 23    16 15        0
3374 	 *
3375 	 * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload
3376 	 *   63      48 47    40 39       32 31             16 15    8 7      0
3377 	 *   +----------------------------------------------------------------+
3378 	 * 0 |  TUCSE  | TUCS0  |   TUCSS   |     IPCSE       | IPCS0 | IPCSS |
3379 	 *   +----------------------------------------------------------------+
3380 	 * 8 |   MSS   | HDRLEN | RSV | STA | TUCMD | DTYP |      PAYLEN      |
3381 	 *   +----------------------------------------------------------------+
3382 	 *   63      48 47    40 39 36 35 32 31   24 23  20 19                0
3383 	 *
3384 	 * Extended Data Descriptor (DTYP=0x1)
3385 	 *   +----------------------------------------------------------------+
3386 	 * 0 |                     Buffer Address [63:0]                      |
3387 	 *   +----------------------------------------------------------------+
3388 	 * 8 | VLAN tag |  POPTS  | Rsvd | Status | Command | DTYP |  DTALEN  |
3389 	 *   +----------------------------------------------------------------+
3390 	 *   63       48 47     40 39  36 35    32 31     24 23  20 19        0
3391 	 */
3392 	pr_info("Tc[desc]     [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
3393 	pr_info("Td[desc]     [address 63:0  ] [VlaPoRSCm1Dlen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
3394 
3395 	if (!netif_msg_tx_done(adapter))
3396 		goto rx_ring_summary;
3397 
3398 	for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {
3399 		struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
3400 		struct e1000_tx_buffer *buffer_info = &tx_ring->buffer_info[i];
3401 		struct my_u { __le64 a; __le64 b; };
3402 		struct my_u *u = (struct my_u *)tx_desc;
3403 		const char *type;
3404 
3405 		if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)
3406 			type = "NTC/U";
3407 		else if (i == tx_ring->next_to_use)
3408 			type = "NTU";
3409 		else if (i == tx_ring->next_to_clean)
3410 			type = "NTC";
3411 		else
3412 			type = "";
3413 
3414 		pr_info("T%c[0x%03X]    %016llX %016llX %016llX %04X  %3X %016llX %p %s\n",
3415 			((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i,
3416 			le64_to_cpu(u->a), le64_to_cpu(u->b),
3417 			(u64)buffer_info->dma, buffer_info->length,
3418 			buffer_info->next_to_watch,
3419 			(u64)buffer_info->time_stamp, buffer_info->skb, type);
3420 	}
3421 
3422 rx_ring_summary:
3423 	/* receive dump */
3424 	pr_info("\nRX Desc ring dump\n");
3425 
3426 	/* Legacy Receive Descriptor Format
3427 	 *
3428 	 * +-----------------------------------------------------+
3429 	 * |                Buffer Address [63:0]                |
3430 	 * +-----------------------------------------------------+
3431 	 * | VLAN Tag | Errors | Status 0 | Packet csum | Length |
3432 	 * +-----------------------------------------------------+
3433 	 * 63       48 47    40 39      32 31         16 15      0
3434 	 */
3435 	pr_info("R[desc]      [address 63:0  ] [vl er S cks ln] [bi->dma       ] [bi->skb]\n");
3436 
3437 	if (!netif_msg_rx_status(adapter))
3438 		goto exit;
3439 
3440 	for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) {
3441 		struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i);
3442 		struct e1000_rx_buffer *buffer_info = &rx_ring->buffer_info[i];
3443 		struct my_u { __le64 a; __le64 b; };
3444 		struct my_u *u = (struct my_u *)rx_desc;
3445 		const char *type;
3446 
3447 		if (i == rx_ring->next_to_use)
3448 			type = "NTU";
3449 		else if (i == rx_ring->next_to_clean)
3450 			type = "NTC";
3451 		else
3452 			type = "";
3453 
3454 		pr_info("R[0x%03X]     %016llX %016llX %016llX %p %s\n",
3455 			i, le64_to_cpu(u->a), le64_to_cpu(u->b),
3456 			(u64)buffer_info->dma, buffer_info->rxbuf.data, type);
3457 	} /* for */
3458 
3459 	/* dump the descriptor caches */
3460 	/* rx */
3461 	pr_info("Rx descriptor cache in 64bit format\n");
3462 	for (i = 0x6000; i <= 0x63FF ; i += 0x10) {
3463 		pr_info("R%04X: %08X|%08X %08X|%08X\n",
3464 			i,
3465 			readl(adapter->hw.hw_addr + i+4),
3466 			readl(adapter->hw.hw_addr + i),
3467 			readl(adapter->hw.hw_addr + i+12),
3468 			readl(adapter->hw.hw_addr + i+8));
3469 	}
3470 	/* tx */
3471 	pr_info("Tx descriptor cache in 64bit format\n");
3472 	for (i = 0x7000; i <= 0x73FF ; i += 0x10) {
3473 		pr_info("T%04X: %08X|%08X %08X|%08X\n",
3474 			i,
3475 			readl(adapter->hw.hw_addr + i+4),
3476 			readl(adapter->hw.hw_addr + i),
3477 			readl(adapter->hw.hw_addr + i+12),
3478 			readl(adapter->hw.hw_addr + i+8));
3479 	}
3480 exit:
3481 	return;
3482 }
3483 
3484 /**
3485  * e1000_tx_timeout - Respond to a Tx Hang
3486  * @netdev: network interface device structure
3487  **/
3488 static void e1000_tx_timeout(struct net_device *netdev)
3489 {
3490 	struct e1000_adapter *adapter = netdev_priv(netdev);
3491 
3492 	/* Do the reset outside of interrupt context */
3493 	adapter->tx_timeout_count++;
3494 	schedule_work(&adapter->reset_task);
3495 }
3496 
3497 static void e1000_reset_task(struct work_struct *work)
3498 {
3499 	struct e1000_adapter *adapter =
3500 		container_of(work, struct e1000_adapter, reset_task);
3501 
3502 	e_err(drv, "Reset adapter\n");
3503 	e1000_reinit_locked(adapter);
3504 }
3505 
3506 /**
3507  * e1000_get_stats - Get System Network Statistics
3508  * @netdev: network interface device structure
3509  *
3510  * Returns the address of the device statistics structure.
3511  * The statistics are actually updated from the watchdog.
3512  **/
3513 static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
3514 {
3515 	/* only return the current stats */
3516 	return &netdev->stats;
3517 }
3518 
3519 /**
3520  * e1000_change_mtu - Change the Maximum Transfer Unit
3521  * @netdev: network interface device structure
3522  * @new_mtu: new value for maximum frame size
3523  *
3524  * Returns 0 on success, negative on failure
3525  **/
3526 static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
3527 {
3528 	struct e1000_adapter *adapter = netdev_priv(netdev);
3529 	struct e1000_hw *hw = &adapter->hw;
3530 	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
3531 
3532 	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
3533 	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
3534 		e_err(probe, "Invalid MTU setting\n");
3535 		return -EINVAL;
3536 	}
3537 
3538 	/* Adapter-specific max frame size limits. */
3539 	switch (hw->mac_type) {
3540 	case e1000_undefined ... e1000_82542_rev2_1:
3541 		if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
3542 			e_err(probe, "Jumbo Frames not supported.\n");
3543 			return -EINVAL;
3544 		}
3545 		break;
3546 	default:
3547 		/* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
3548 		break;
3549 	}
3550 
3551 	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
3552 		msleep(1);
3553 	/* e1000_down has a dependency on max_frame_size */
3554 	hw->max_frame_size = max_frame;
3555 	if (netif_running(netdev))
3556 		e1000_down(adapter);
3557 
3558 	/* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
3559 	 * means we reserve 2 more, this pushes us to allocate from the next
3560 	 * larger slab size.
3561 	 * i.e. RXBUFFER_2048 --> size-4096 slab
3562 	 * however with the new *_jumbo_rx* routines, jumbo receives will use
3563 	 * fragmented skbs
3564 	 */
3565 
3566 	if (max_frame <= E1000_RXBUFFER_2048)
3567 		adapter->rx_buffer_len = E1000_RXBUFFER_2048;
3568 	else
3569 #if (PAGE_SIZE >= E1000_RXBUFFER_16384)
3570 		adapter->rx_buffer_len = E1000_RXBUFFER_16384;
3571 #elif (PAGE_SIZE >= E1000_RXBUFFER_4096)
3572 		adapter->rx_buffer_len = PAGE_SIZE;
3573 #endif
3574 
3575 	/* adjust allocation if LPE protects us, and we aren't using SBP */
3576 	if (!hw->tbi_compatibility_on &&
3577 	    ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) ||
3578 	     (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
3579 		adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
3580 
3581 	pr_info("%s changing MTU from %d to %d\n",
3582 		netdev->name, netdev->mtu, new_mtu);
3583 	netdev->mtu = new_mtu;
3584 
3585 	if (netif_running(netdev))
3586 		e1000_up(adapter);
3587 	else
3588 		e1000_reset(adapter);
3589 
3590 	clear_bit(__E1000_RESETTING, &adapter->flags);
3591 
3592 	return 0;
3593 }
3594 
3595 /**
3596  * e1000_update_stats - Update the board statistics counters
3597  * @adapter: board private structure
3598  **/
3599 void e1000_update_stats(struct e1000_adapter *adapter)
3600 {
3601 	struct net_device *netdev = adapter->netdev;
3602 	struct e1000_hw *hw = &adapter->hw;
3603 	struct pci_dev *pdev = adapter->pdev;
3604 	unsigned long flags;
3605 	u16 phy_tmp;
3606 
3607 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
3608 
3609 	/* Prevent stats update while adapter is being reset, or if the pci
3610 	 * connection is down.
3611 	 */
3612 	if (adapter->link_speed == 0)
3613 		return;
3614 	if (pci_channel_offline(pdev))
3615 		return;
3616 
3617 	spin_lock_irqsave(&adapter->stats_lock, flags);
3618 
3619 	/* these counters are modified from e1000_tbi_adjust_stats,
3620 	 * called from the interrupt context, so they must only
3621 	 * be written while holding adapter->stats_lock
3622 	 */
3623 
3624 	adapter->stats.crcerrs += er32(CRCERRS);
3625 	adapter->stats.gprc += er32(GPRC);
3626 	adapter->stats.gorcl += er32(GORCL);
3627 	adapter->stats.gorch += er32(GORCH);
3628 	adapter->stats.bprc += er32(BPRC);
3629 	adapter->stats.mprc += er32(MPRC);
3630 	adapter->stats.roc += er32(ROC);
3631 
3632 	adapter->stats.prc64 += er32(PRC64);
3633 	adapter->stats.prc127 += er32(PRC127);
3634 	adapter->stats.prc255 += er32(PRC255);
3635 	adapter->stats.prc511 += er32(PRC511);
3636 	adapter->stats.prc1023 += er32(PRC1023);
3637 	adapter->stats.prc1522 += er32(PRC1522);
3638 
3639 	adapter->stats.symerrs += er32(SYMERRS);
3640 	adapter->stats.mpc += er32(MPC);
3641 	adapter->stats.scc += er32(SCC);
3642 	adapter->stats.ecol += er32(ECOL);
3643 	adapter->stats.mcc += er32(MCC);
3644 	adapter->stats.latecol += er32(LATECOL);
3645 	adapter->stats.dc += er32(DC);
3646 	adapter->stats.sec += er32(SEC);
3647 	adapter->stats.rlec += er32(RLEC);
3648 	adapter->stats.xonrxc += er32(XONRXC);
3649 	adapter->stats.xontxc += er32(XONTXC);
3650 	adapter->stats.xoffrxc += er32(XOFFRXC);
3651 	adapter->stats.xofftxc += er32(XOFFTXC);
3652 	adapter->stats.fcruc += er32(FCRUC);
3653 	adapter->stats.gptc += er32(GPTC);
3654 	adapter->stats.gotcl += er32(GOTCL);
3655 	adapter->stats.gotch += er32(GOTCH);
3656 	adapter->stats.rnbc += er32(RNBC);
3657 	adapter->stats.ruc += er32(RUC);
3658 	adapter->stats.rfc += er32(RFC);
3659 	adapter->stats.rjc += er32(RJC);
3660 	adapter->stats.torl += er32(TORL);
3661 	adapter->stats.torh += er32(TORH);
3662 	adapter->stats.totl += er32(TOTL);
3663 	adapter->stats.toth += er32(TOTH);
3664 	adapter->stats.tpr += er32(TPR);
3665 
3666 	adapter->stats.ptc64 += er32(PTC64);
3667 	adapter->stats.ptc127 += er32(PTC127);
3668 	adapter->stats.ptc255 += er32(PTC255);
3669 	adapter->stats.ptc511 += er32(PTC511);
3670 	adapter->stats.ptc1023 += er32(PTC1023);
3671 	adapter->stats.ptc1522 += er32(PTC1522);
3672 
3673 	adapter->stats.mptc += er32(MPTC);
3674 	adapter->stats.bptc += er32(BPTC);
3675 
3676 	/* used for adaptive IFS */
3677 
3678 	hw->tx_packet_delta = er32(TPT);
3679 	adapter->stats.tpt += hw->tx_packet_delta;
3680 	hw->collision_delta = er32(COLC);
3681 	adapter->stats.colc += hw->collision_delta;
3682 
3683 	if (hw->mac_type >= e1000_82543) {
3684 		adapter->stats.algnerrc += er32(ALGNERRC);
3685 		adapter->stats.rxerrc += er32(RXERRC);
3686 		adapter->stats.tncrs += er32(TNCRS);
3687 		adapter->stats.cexterr += er32(CEXTERR);
3688 		adapter->stats.tsctc += er32(TSCTC);
3689 		adapter->stats.tsctfc += er32(TSCTFC);
3690 	}
3691 
3692 	/* Fill out the OS statistics structure */
3693 	netdev->stats.multicast = adapter->stats.mprc;
3694 	netdev->stats.collisions = adapter->stats.colc;
3695 
3696 	/* Rx Errors */
3697 
3698 	/* RLEC on some newer hardware can be incorrect so build
3699 	 * our own version based on RUC and ROC
3700 	 */
3701 	netdev->stats.rx_errors = adapter->stats.rxerrc +
3702 		adapter->stats.crcerrs + adapter->stats.algnerrc +
3703 		adapter->stats.ruc + adapter->stats.roc +
3704 		adapter->stats.cexterr;
3705 	adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
3706 	netdev->stats.rx_length_errors = adapter->stats.rlerrc;
3707 	netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
3708 	netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
3709 	netdev->stats.rx_missed_errors = adapter->stats.mpc;
3710 
3711 	/* Tx Errors */
3712 	adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
3713 	netdev->stats.tx_errors = adapter->stats.txerrc;
3714 	netdev->stats.tx_aborted_errors = adapter->stats.ecol;
3715 	netdev->stats.tx_window_errors = adapter->stats.latecol;
3716 	netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
3717 	if (hw->bad_tx_carr_stats_fd &&
3718 	    adapter->link_duplex == FULL_DUPLEX) {
3719 		netdev->stats.tx_carrier_errors = 0;
3720 		adapter->stats.tncrs = 0;
3721 	}
3722 
3723 	/* Tx Dropped needs to be maintained elsewhere */
3724 
3725 	/* Phy Stats */
3726 	if (hw->media_type == e1000_media_type_copper) {
3727 		if ((adapter->link_speed == SPEED_1000) &&
3728 		   (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
3729 			phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
3730 			adapter->phy_stats.idle_errors += phy_tmp;
3731 		}
3732 
3733 		if ((hw->mac_type <= e1000_82546) &&
3734 		   (hw->phy_type == e1000_phy_m88) &&
3735 		   !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
3736 			adapter->phy_stats.receive_errors += phy_tmp;
3737 	}
3738 
3739 	/* Management Stats */
3740 	if (hw->has_smbus) {
3741 		adapter->stats.mgptc += er32(MGTPTC);
3742 		adapter->stats.mgprc += er32(MGTPRC);
3743 		adapter->stats.mgpdc += er32(MGTPDC);
3744 	}
3745 
3746 	spin_unlock_irqrestore(&adapter->stats_lock, flags);
3747 }
3748 
3749 /**
3750  * e1000_intr - Interrupt Handler
3751  * @irq: interrupt number
3752  * @data: pointer to a network interface device structure
3753  **/
3754 static irqreturn_t e1000_intr(int irq, void *data)
3755 {
3756 	struct net_device *netdev = data;
3757 	struct e1000_adapter *adapter = netdev_priv(netdev);
3758 	struct e1000_hw *hw = &adapter->hw;
3759 	u32 icr = er32(ICR);
3760 
3761 	if (unlikely((!icr)))
3762 		return IRQ_NONE;  /* Not our interrupt */
3763 
3764 	/* we might have caused the interrupt, but the above
3765 	 * read cleared it, and just in case the driver is
3766 	 * down there is nothing to do so return handled
3767 	 */
3768 	if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
3769 		return IRQ_HANDLED;
3770 
3771 	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
3772 		hw->get_link_status = 1;
3773 		/* guard against interrupt when we're going down */
3774 		if (!test_bit(__E1000_DOWN, &adapter->flags))
3775 			schedule_delayed_work(&adapter->watchdog_task, 1);
3776 	}
3777 
3778 	/* disable interrupts, without the synchronize_irq bit */
3779 	ew32(IMC, ~0);
3780 	E1000_WRITE_FLUSH();
3781 
3782 	if (likely(napi_schedule_prep(&adapter->napi))) {
3783 		adapter->total_tx_bytes = 0;
3784 		adapter->total_tx_packets = 0;
3785 		adapter->total_rx_bytes = 0;
3786 		adapter->total_rx_packets = 0;
3787 		__napi_schedule(&adapter->napi);
3788 	} else {
3789 		/* this really should not happen! if it does it is basically a
3790 		 * bug, but not a hard error, so enable ints and continue
3791 		 */
3792 		if (!test_bit(__E1000_DOWN, &adapter->flags))
3793 			e1000_irq_enable(adapter);
3794 	}
3795 
3796 	return IRQ_HANDLED;
3797 }
3798 
3799 /**
3800  * e1000_clean - NAPI Rx polling callback
3801  * @adapter: board private structure
3802  **/
3803 static int e1000_clean(struct napi_struct *napi, int budget)
3804 {
3805 	struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter,
3806 						     napi);
3807 	int tx_clean_complete = 0, work_done = 0;
3808 
3809 	tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
3810 
3811 	adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
3812 
3813 	if (!tx_clean_complete)
3814 		work_done = budget;
3815 
3816 	/* If budget not fully consumed, exit the polling mode */
3817 	if (work_done < budget) {
3818 		if (likely(adapter->itr_setting & 3))
3819 			e1000_set_itr(adapter);
3820 		napi_complete(napi);
3821 		if (!test_bit(__E1000_DOWN, &adapter->flags))
3822 			e1000_irq_enable(adapter);
3823 	}
3824 
3825 	return work_done;
3826 }
3827 
3828 /**
3829  * e1000_clean_tx_irq - Reclaim resources after transmit completes
3830  * @adapter: board private structure
3831  **/
3832 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
3833 			       struct e1000_tx_ring *tx_ring)
3834 {
3835 	struct e1000_hw *hw = &adapter->hw;
3836 	struct net_device *netdev = adapter->netdev;
3837 	struct e1000_tx_desc *tx_desc, *eop_desc;
3838 	struct e1000_tx_buffer *buffer_info;
3839 	unsigned int i, eop;
3840 	unsigned int count = 0;
3841 	unsigned int total_tx_bytes=0, total_tx_packets=0;
3842 	unsigned int bytes_compl = 0, pkts_compl = 0;
3843 
3844 	i = tx_ring->next_to_clean;
3845 	eop = tx_ring->buffer_info[i].next_to_watch;
3846 	eop_desc = E1000_TX_DESC(*tx_ring, eop);
3847 
3848 	while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
3849 	       (count < tx_ring->count)) {
3850 		bool cleaned = false;
3851 		rmb();	/* read buffer_info after eop_desc */
3852 		for ( ; !cleaned; count++) {
3853 			tx_desc = E1000_TX_DESC(*tx_ring, i);
3854 			buffer_info = &tx_ring->buffer_info[i];
3855 			cleaned = (i == eop);
3856 
3857 			if (cleaned) {
3858 				total_tx_packets += buffer_info->segs;
3859 				total_tx_bytes += buffer_info->bytecount;
3860 				if (buffer_info->skb) {
3861 					bytes_compl += buffer_info->skb->len;
3862 					pkts_compl++;
3863 				}
3864 
3865 			}
3866 			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3867 			tx_desc->upper.data = 0;
3868 
3869 			if (unlikely(++i == tx_ring->count)) i = 0;
3870 		}
3871 
3872 		eop = tx_ring->buffer_info[i].next_to_watch;
3873 		eop_desc = E1000_TX_DESC(*tx_ring, eop);
3874 	}
3875 
3876 	tx_ring->next_to_clean = i;
3877 
3878 	netdev_completed_queue(netdev, pkts_compl, bytes_compl);
3879 
3880 #define TX_WAKE_THRESHOLD 32
3881 	if (unlikely(count && netif_carrier_ok(netdev) &&
3882 		     E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
3883 		/* Make sure that anybody stopping the queue after this
3884 		 * sees the new next_to_clean.
3885 		 */
3886 		smp_mb();
3887 
3888 		if (netif_queue_stopped(netdev) &&
3889 		    !(test_bit(__E1000_DOWN, &adapter->flags))) {
3890 			netif_wake_queue(netdev);
3891 			++adapter->restart_queue;
3892 		}
3893 	}
3894 
3895 	if (adapter->detect_tx_hung) {
3896 		/* Detect a transmit hang in hardware, this serializes the
3897 		 * check with the clearing of time_stamp and movement of i
3898 		 */
3899 		adapter->detect_tx_hung = false;
3900 		if (tx_ring->buffer_info[eop].time_stamp &&
3901 		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
3902 			       (adapter->tx_timeout_factor * HZ)) &&
3903 		    !(er32(STATUS) & E1000_STATUS_TXOFF)) {
3904 
3905 			/* detected Tx unit hang */
3906 			e_err(drv, "Detected Tx Unit Hang\n"
3907 			      "  Tx Queue             <%lu>\n"
3908 			      "  TDH                  <%x>\n"
3909 			      "  TDT                  <%x>\n"
3910 			      "  next_to_use          <%x>\n"
3911 			      "  next_to_clean        <%x>\n"
3912 			      "buffer_info[next_to_clean]\n"
3913 			      "  time_stamp           <%lx>\n"
3914 			      "  next_to_watch        <%x>\n"
3915 			      "  jiffies              <%lx>\n"
3916 			      "  next_to_watch.status <%x>\n",
3917 				(unsigned long)(tx_ring - adapter->tx_ring),
3918 				readl(hw->hw_addr + tx_ring->tdh),
3919 				readl(hw->hw_addr + tx_ring->tdt),
3920 				tx_ring->next_to_use,
3921 				tx_ring->next_to_clean,
3922 				tx_ring->buffer_info[eop].time_stamp,
3923 				eop,
3924 				jiffies,
3925 				eop_desc->upper.fields.status);
3926 			e1000_dump(adapter);
3927 			netif_stop_queue(netdev);
3928 		}
3929 	}
3930 	adapter->total_tx_bytes += total_tx_bytes;
3931 	adapter->total_tx_packets += total_tx_packets;
3932 	netdev->stats.tx_bytes += total_tx_bytes;
3933 	netdev->stats.tx_packets += total_tx_packets;
3934 	return count < tx_ring->count;
3935 }
3936 
3937 /**
3938  * e1000_rx_checksum - Receive Checksum Offload for 82543
3939  * @adapter:     board private structure
3940  * @status_err:  receive descriptor status and error fields
3941  * @csum:        receive descriptor csum field
3942  * @sk_buff:     socket buffer with received data
3943  **/
3944 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
3945 			      u32 csum, struct sk_buff *skb)
3946 {
3947 	struct e1000_hw *hw = &adapter->hw;
3948 	u16 status = (u16)status_err;
3949 	u8 errors = (u8)(status_err >> 24);
3950 
3951 	skb_checksum_none_assert(skb);
3952 
3953 	/* 82543 or newer only */
3954 	if (unlikely(hw->mac_type < e1000_82543)) return;
3955 	/* Ignore Checksum bit is set */
3956 	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3957 	/* TCP/UDP checksum error bit is set */
3958 	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
3959 		/* let the stack verify checksum errors */
3960 		adapter->hw_csum_err++;
3961 		return;
3962 	}
3963 	/* TCP/UDP Checksum has not been calculated */
3964 	if (!(status & E1000_RXD_STAT_TCPCS))
3965 		return;
3966 
3967 	/* It must be a TCP or UDP packet with a valid checksum */
3968 	if (likely(status & E1000_RXD_STAT_TCPCS)) {
3969 		/* TCP checksum is good */
3970 		skb->ip_summed = CHECKSUM_UNNECESSARY;
3971 	}
3972 	adapter->hw_csum_good++;
3973 }
3974 
3975 /**
3976  * e1000_consume_page - helper function for jumbo Rx path
3977  **/
3978 static void e1000_consume_page(struct e1000_rx_buffer *bi, struct sk_buff *skb,
3979 			       u16 length)
3980 {
3981 	bi->rxbuf.page = NULL;
3982 	skb->len += length;
3983 	skb->data_len += length;
3984 	skb->truesize += PAGE_SIZE;
3985 }
3986 
3987 /**
3988  * e1000_receive_skb - helper function to handle rx indications
3989  * @adapter: board private structure
3990  * @status: descriptor status field as written by hardware
3991  * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
3992  * @skb: pointer to sk_buff to be indicated to stack
3993  */
3994 static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status,
3995 			      __le16 vlan, struct sk_buff *skb)
3996 {
3997 	skb->protocol = eth_type_trans(skb, adapter->netdev);
3998 
3999 	if (status & E1000_RXD_STAT_VP) {
4000 		u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
4001 
4002 		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
4003 	}
4004 	napi_gro_receive(&adapter->napi, skb);
4005 }
4006 
4007 /**
4008  * e1000_tbi_adjust_stats
4009  * @hw: Struct containing variables accessed by shared code
4010  * @frame_len: The length of the frame in question
4011  * @mac_addr: The Ethernet destination address of the frame in question
4012  *
4013  * Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT
4014  */
4015 static void e1000_tbi_adjust_stats(struct e1000_hw *hw,
4016 				   struct e1000_hw_stats *stats,
4017 				   u32 frame_len, const u8 *mac_addr)
4018 {
4019 	u64 carry_bit;
4020 
4021 	/* First adjust the frame length. */
4022 	frame_len--;
4023 	/* We need to adjust the statistics counters, since the hardware
4024 	 * counters overcount this packet as a CRC error and undercount
4025 	 * the packet as a good packet
4026 	 */
4027 	/* This packet should not be counted as a CRC error. */
4028 	stats->crcerrs--;
4029 	/* This packet does count as a Good Packet Received. */
4030 	stats->gprc++;
4031 
4032 	/* Adjust the Good Octets received counters */
4033 	carry_bit = 0x80000000 & stats->gorcl;
4034 	stats->gorcl += frame_len;
4035 	/* If the high bit of Gorcl (the low 32 bits of the Good Octets
4036 	 * Received Count) was one before the addition,
4037 	 * AND it is zero after, then we lost the carry out,
4038 	 * need to add one to Gorch (Good Octets Received Count High).
4039 	 * This could be simplified if all environments supported
4040 	 * 64-bit integers.
4041 	 */
4042 	if (carry_bit && ((stats->gorcl & 0x80000000) == 0))
4043 		stats->gorch++;
4044 	/* Is this a broadcast or multicast?  Check broadcast first,
4045 	 * since the test for a multicast frame will test positive on
4046 	 * a broadcast frame.
4047 	 */
4048 	if (is_broadcast_ether_addr(mac_addr))
4049 		stats->bprc++;
4050 	else if (is_multicast_ether_addr(mac_addr))
4051 		stats->mprc++;
4052 
4053 	if (frame_len == hw->max_frame_size) {
4054 		/* In this case, the hardware has overcounted the number of
4055 		 * oversize frames.
4056 		 */
4057 		if (stats->roc > 0)
4058 			stats->roc--;
4059 	}
4060 
4061 	/* Adjust the bin counters when the extra byte put the frame in the
4062 	 * wrong bin. Remember that the frame_len was adjusted above.
4063 	 */
4064 	if (frame_len == 64) {
4065 		stats->prc64++;
4066 		stats->prc127--;
4067 	} else if (frame_len == 127) {
4068 		stats->prc127++;
4069 		stats->prc255--;
4070 	} else if (frame_len == 255) {
4071 		stats->prc255++;
4072 		stats->prc511--;
4073 	} else if (frame_len == 511) {
4074 		stats->prc511++;
4075 		stats->prc1023--;
4076 	} else if (frame_len == 1023) {
4077 		stats->prc1023++;
4078 		stats->prc1522--;
4079 	} else if (frame_len == 1522) {
4080 		stats->prc1522++;
4081 	}
4082 }
4083 
4084 static bool e1000_tbi_should_accept(struct e1000_adapter *adapter,
4085 				    u8 status, u8 errors,
4086 				    u32 length, const u8 *data)
4087 {
4088 	struct e1000_hw *hw = &adapter->hw;
4089 	u8 last_byte = *(data + length - 1);
4090 
4091 	if (TBI_ACCEPT(hw, status, errors, length, last_byte)) {
4092 		unsigned long irq_flags;
4093 
4094 		spin_lock_irqsave(&adapter->stats_lock, irq_flags);
4095 		e1000_tbi_adjust_stats(hw, &adapter->stats, length, data);
4096 		spin_unlock_irqrestore(&adapter->stats_lock, irq_flags);
4097 
4098 		return true;
4099 	}
4100 
4101 	return false;
4102 }
4103 
4104 static struct sk_buff *e1000_alloc_rx_skb(struct e1000_adapter *adapter,
4105 					  unsigned int bufsz)
4106 {
4107 	struct sk_buff *skb = netdev_alloc_skb_ip_align(adapter->netdev, bufsz);
4108 
4109 	if (unlikely(!skb))
4110 		adapter->alloc_rx_buff_failed++;
4111 	return skb;
4112 }
4113 
4114 /**
4115  * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
4116  * @adapter: board private structure
4117  * @rx_ring: ring to clean
4118  * @work_done: amount of napi work completed this call
4119  * @work_to_do: max amount of work allowed for this call to do
4120  *
4121  * the return value indicates whether actual cleaning was done, there
4122  * is no guarantee that everything was cleaned
4123  */
4124 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
4125 				     struct e1000_rx_ring *rx_ring,
4126 				     int *work_done, int work_to_do)
4127 {
4128 	struct net_device *netdev = adapter->netdev;
4129 	struct pci_dev *pdev = adapter->pdev;
4130 	struct e1000_rx_desc *rx_desc, *next_rxd;
4131 	struct e1000_rx_buffer *buffer_info, *next_buffer;
4132 	u32 length;
4133 	unsigned int i;
4134 	int cleaned_count = 0;
4135 	bool cleaned = false;
4136 	unsigned int total_rx_bytes=0, total_rx_packets=0;
4137 
4138 	i = rx_ring->next_to_clean;
4139 	rx_desc = E1000_RX_DESC(*rx_ring, i);
4140 	buffer_info = &rx_ring->buffer_info[i];
4141 
4142 	while (rx_desc->status & E1000_RXD_STAT_DD) {
4143 		struct sk_buff *skb;
4144 		u8 status;
4145 
4146 		if (*work_done >= work_to_do)
4147 			break;
4148 		(*work_done)++;
4149 		rmb(); /* read descriptor and rx_buffer_info after status DD */
4150 
4151 		status = rx_desc->status;
4152 
4153 		if (++i == rx_ring->count) i = 0;
4154 		next_rxd = E1000_RX_DESC(*rx_ring, i);
4155 		prefetch(next_rxd);
4156 
4157 		next_buffer = &rx_ring->buffer_info[i];
4158 
4159 		cleaned = true;
4160 		cleaned_count++;
4161 		dma_unmap_page(&pdev->dev, buffer_info->dma,
4162 			       adapter->rx_buffer_len, DMA_FROM_DEVICE);
4163 		buffer_info->dma = 0;
4164 
4165 		length = le16_to_cpu(rx_desc->length);
4166 
4167 		/* errors is only valid for DD + EOP descriptors */
4168 		if (unlikely((status & E1000_RXD_STAT_EOP) &&
4169 		    (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
4170 			u8 *mapped = page_address(buffer_info->rxbuf.page);
4171 
4172 			if (e1000_tbi_should_accept(adapter, status,
4173 						    rx_desc->errors,
4174 						    length, mapped)) {
4175 				length--;
4176 			} else if (netdev->features & NETIF_F_RXALL) {
4177 				goto process_skb;
4178 			} else {
4179 				/* an error means any chain goes out the window
4180 				 * too
4181 				 */
4182 				if (rx_ring->rx_skb_top)
4183 					dev_kfree_skb(rx_ring->rx_skb_top);
4184 				rx_ring->rx_skb_top = NULL;
4185 				goto next_desc;
4186 			}
4187 		}
4188 
4189 #define rxtop rx_ring->rx_skb_top
4190 process_skb:
4191 		if (!(status & E1000_RXD_STAT_EOP)) {
4192 			/* this descriptor is only the beginning (or middle) */
4193 			if (!rxtop) {
4194 				/* this is the beginning of a chain */
4195 				rxtop = napi_get_frags(&adapter->napi);
4196 				if (!rxtop)
4197 					break;
4198 
4199 				skb_fill_page_desc(rxtop, 0,
4200 						   buffer_info->rxbuf.page,
4201 						   0, length);
4202 			} else {
4203 				/* this is the middle of a chain */
4204 				skb_fill_page_desc(rxtop,
4205 				    skb_shinfo(rxtop)->nr_frags,
4206 				    buffer_info->rxbuf.page, 0, length);
4207 			}
4208 			e1000_consume_page(buffer_info, rxtop, length);
4209 			goto next_desc;
4210 		} else {
4211 			if (rxtop) {
4212 				/* end of the chain */
4213 				skb_fill_page_desc(rxtop,
4214 				    skb_shinfo(rxtop)->nr_frags,
4215 				    buffer_info->rxbuf.page, 0, length);
4216 				skb = rxtop;
4217 				rxtop = NULL;
4218 				e1000_consume_page(buffer_info, skb, length);
4219 			} else {
4220 				struct page *p;
4221 				/* no chain, got EOP, this buf is the packet
4222 				 * copybreak to save the put_page/alloc_page
4223 				 */
4224 				p = buffer_info->rxbuf.page;
4225 				if (length <= copybreak) {
4226 					u8 *vaddr;
4227 
4228 					if (likely(!(netdev->features & NETIF_F_RXFCS)))
4229 						length -= 4;
4230 					skb = e1000_alloc_rx_skb(adapter,
4231 								 length);
4232 					if (!skb)
4233 						break;
4234 
4235 					vaddr = kmap_atomic(p);
4236 					memcpy(skb_tail_pointer(skb), vaddr,
4237 					       length);
4238 					kunmap_atomic(vaddr);
4239 					/* re-use the page, so don't erase
4240 					 * buffer_info->rxbuf.page
4241 					 */
4242 					skb_put(skb, length);
4243 					e1000_rx_checksum(adapter,
4244 							  status | rx_desc->errors << 24,
4245 							  le16_to_cpu(rx_desc->csum), skb);
4246 
4247 					total_rx_bytes += skb->len;
4248 					total_rx_packets++;
4249 
4250 					e1000_receive_skb(adapter, status,
4251 							  rx_desc->special, skb);
4252 					goto next_desc;
4253 				} else {
4254 					skb = napi_get_frags(&adapter->napi);
4255 					if (!skb) {
4256 						adapter->alloc_rx_buff_failed++;
4257 						break;
4258 					}
4259 					skb_fill_page_desc(skb, 0, p, 0,
4260 							   length);
4261 					e1000_consume_page(buffer_info, skb,
4262 							   length);
4263 				}
4264 			}
4265 		}
4266 
4267 		/* Receive Checksum Offload XXX recompute due to CRC strip? */
4268 		e1000_rx_checksum(adapter,
4269 				  (u32)(status) |
4270 				  ((u32)(rx_desc->errors) << 24),
4271 				  le16_to_cpu(rx_desc->csum), skb);
4272 
4273 		total_rx_bytes += (skb->len - 4); /* don't count FCS */
4274 		if (likely(!(netdev->features & NETIF_F_RXFCS)))
4275 			pskb_trim(skb, skb->len - 4);
4276 		total_rx_packets++;
4277 
4278 		if (status & E1000_RXD_STAT_VP) {
4279 			__le16 vlan = rx_desc->special;
4280 			u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
4281 
4282 			__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
4283 		}
4284 
4285 		napi_gro_frags(&adapter->napi);
4286 
4287 next_desc:
4288 		rx_desc->status = 0;
4289 
4290 		/* return some buffers to hardware, one at a time is too slow */
4291 		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
4292 			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4293 			cleaned_count = 0;
4294 		}
4295 
4296 		/* use prefetched values */
4297 		rx_desc = next_rxd;
4298 		buffer_info = next_buffer;
4299 	}
4300 	rx_ring->next_to_clean = i;
4301 
4302 	cleaned_count = E1000_DESC_UNUSED(rx_ring);
4303 	if (cleaned_count)
4304 		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4305 
4306 	adapter->total_rx_packets += total_rx_packets;
4307 	adapter->total_rx_bytes += total_rx_bytes;
4308 	netdev->stats.rx_bytes += total_rx_bytes;
4309 	netdev->stats.rx_packets += total_rx_packets;
4310 	return cleaned;
4311 }
4312 
4313 /* this should improve performance for small packets with large amounts
4314  * of reassembly being done in the stack
4315  */
4316 static struct sk_buff *e1000_copybreak(struct e1000_adapter *adapter,
4317 				       struct e1000_rx_buffer *buffer_info,
4318 				       u32 length, const void *data)
4319 {
4320 	struct sk_buff *skb;
4321 
4322 	if (length > copybreak)
4323 		return NULL;
4324 
4325 	skb = e1000_alloc_rx_skb(adapter, length);
4326 	if (!skb)
4327 		return NULL;
4328 
4329 	dma_sync_single_for_cpu(&adapter->pdev->dev, buffer_info->dma,
4330 				length, DMA_FROM_DEVICE);
4331 
4332 	memcpy(skb_put(skb, length), data, length);
4333 
4334 	return skb;
4335 }
4336 
4337 /**
4338  * e1000_clean_rx_irq - Send received data up the network stack; legacy
4339  * @adapter: board private structure
4340  * @rx_ring: ring to clean
4341  * @work_done: amount of napi work completed this call
4342  * @work_to_do: max amount of work allowed for this call to do
4343  */
4344 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
4345 			       struct e1000_rx_ring *rx_ring,
4346 			       int *work_done, int work_to_do)
4347 {
4348 	struct net_device *netdev = adapter->netdev;
4349 	struct pci_dev *pdev = adapter->pdev;
4350 	struct e1000_rx_desc *rx_desc, *next_rxd;
4351 	struct e1000_rx_buffer *buffer_info, *next_buffer;
4352 	u32 length;
4353 	unsigned int i;
4354 	int cleaned_count = 0;
4355 	bool cleaned = false;
4356 	unsigned int total_rx_bytes=0, total_rx_packets=0;
4357 
4358 	i = rx_ring->next_to_clean;
4359 	rx_desc = E1000_RX_DESC(*rx_ring, i);
4360 	buffer_info = &rx_ring->buffer_info[i];
4361 
4362 	while (rx_desc->status & E1000_RXD_STAT_DD) {
4363 		struct sk_buff *skb;
4364 		u8 *data;
4365 		u8 status;
4366 
4367 		if (*work_done >= work_to_do)
4368 			break;
4369 		(*work_done)++;
4370 		rmb(); /* read descriptor and rx_buffer_info after status DD */
4371 
4372 		status = rx_desc->status;
4373 		length = le16_to_cpu(rx_desc->length);
4374 
4375 		data = buffer_info->rxbuf.data;
4376 		prefetch(data);
4377 		skb = e1000_copybreak(adapter, buffer_info, length, data);
4378 		if (!skb) {
4379 			unsigned int frag_len = e1000_frag_len(adapter);
4380 
4381 			skb = build_skb(data - E1000_HEADROOM, frag_len);
4382 			if (!skb) {
4383 				adapter->alloc_rx_buff_failed++;
4384 				break;
4385 			}
4386 
4387 			skb_reserve(skb, E1000_HEADROOM);
4388 			dma_unmap_single(&pdev->dev, buffer_info->dma,
4389 					 adapter->rx_buffer_len,
4390 					 DMA_FROM_DEVICE);
4391 			buffer_info->dma = 0;
4392 			buffer_info->rxbuf.data = NULL;
4393 		}
4394 
4395 		if (++i == rx_ring->count) i = 0;
4396 		next_rxd = E1000_RX_DESC(*rx_ring, i);
4397 		prefetch(next_rxd);
4398 
4399 		next_buffer = &rx_ring->buffer_info[i];
4400 
4401 		cleaned = true;
4402 		cleaned_count++;
4403 
4404 		/* !EOP means multiple descriptors were used to store a single
4405 		 * packet, if thats the case we need to toss it.  In fact, we
4406 		 * to toss every packet with the EOP bit clear and the next
4407 		 * frame that _does_ have the EOP bit set, as it is by
4408 		 * definition only a frame fragment
4409 		 */
4410 		if (unlikely(!(status & E1000_RXD_STAT_EOP)))
4411 			adapter->discarding = true;
4412 
4413 		if (adapter->discarding) {
4414 			/* All receives must fit into a single buffer */
4415 			netdev_dbg(netdev, "Receive packet consumed multiple buffers\n");
4416 			dev_kfree_skb(skb);
4417 			if (status & E1000_RXD_STAT_EOP)
4418 				adapter->discarding = false;
4419 			goto next_desc;
4420 		}
4421 
4422 		if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
4423 			if (e1000_tbi_should_accept(adapter, status,
4424 						    rx_desc->errors,
4425 						    length, data)) {
4426 				length--;
4427 			} else if (netdev->features & NETIF_F_RXALL) {
4428 				goto process_skb;
4429 			} else {
4430 				dev_kfree_skb(skb);
4431 				goto next_desc;
4432 			}
4433 		}
4434 
4435 process_skb:
4436 		total_rx_bytes += (length - 4); /* don't count FCS */
4437 		total_rx_packets++;
4438 
4439 		if (likely(!(netdev->features & NETIF_F_RXFCS)))
4440 			/* adjust length to remove Ethernet CRC, this must be
4441 			 * done after the TBI_ACCEPT workaround above
4442 			 */
4443 			length -= 4;
4444 
4445 		if (buffer_info->rxbuf.data == NULL)
4446 			skb_put(skb, length);
4447 		else /* copybreak skb */
4448 			skb_trim(skb, length);
4449 
4450 		/* Receive Checksum Offload */
4451 		e1000_rx_checksum(adapter,
4452 				  (u32)(status) |
4453 				  ((u32)(rx_desc->errors) << 24),
4454 				  le16_to_cpu(rx_desc->csum), skb);
4455 
4456 		e1000_receive_skb(adapter, status, rx_desc->special, skb);
4457 
4458 next_desc:
4459 		rx_desc->status = 0;
4460 
4461 		/* return some buffers to hardware, one at a time is too slow */
4462 		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
4463 			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4464 			cleaned_count = 0;
4465 		}
4466 
4467 		/* use prefetched values */
4468 		rx_desc = next_rxd;
4469 		buffer_info = next_buffer;
4470 	}
4471 	rx_ring->next_to_clean = i;
4472 
4473 	cleaned_count = E1000_DESC_UNUSED(rx_ring);
4474 	if (cleaned_count)
4475 		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4476 
4477 	adapter->total_rx_packets += total_rx_packets;
4478 	adapter->total_rx_bytes += total_rx_bytes;
4479 	netdev->stats.rx_bytes += total_rx_bytes;
4480 	netdev->stats.rx_packets += total_rx_packets;
4481 	return cleaned;
4482 }
4483 
4484 /**
4485  * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
4486  * @adapter: address of board private structure
4487  * @rx_ring: pointer to receive ring structure
4488  * @cleaned_count: number of buffers to allocate this pass
4489  **/
4490 static void
4491 e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
4492 			     struct e1000_rx_ring *rx_ring, int cleaned_count)
4493 {
4494 	struct pci_dev *pdev = adapter->pdev;
4495 	struct e1000_rx_desc *rx_desc;
4496 	struct e1000_rx_buffer *buffer_info;
4497 	unsigned int i;
4498 
4499 	i = rx_ring->next_to_use;
4500 	buffer_info = &rx_ring->buffer_info[i];
4501 
4502 	while (cleaned_count--) {
4503 		/* allocate a new page if necessary */
4504 		if (!buffer_info->rxbuf.page) {
4505 			buffer_info->rxbuf.page = alloc_page(GFP_ATOMIC);
4506 			if (unlikely(!buffer_info->rxbuf.page)) {
4507 				adapter->alloc_rx_buff_failed++;
4508 				break;
4509 			}
4510 		}
4511 
4512 		if (!buffer_info->dma) {
4513 			buffer_info->dma = dma_map_page(&pdev->dev,
4514 							buffer_info->rxbuf.page, 0,
4515 							adapter->rx_buffer_len,
4516 							DMA_FROM_DEVICE);
4517 			if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4518 				put_page(buffer_info->rxbuf.page);
4519 				buffer_info->rxbuf.page = NULL;
4520 				buffer_info->dma = 0;
4521 				adapter->alloc_rx_buff_failed++;
4522 				break;
4523 			}
4524 		}
4525 
4526 		rx_desc = E1000_RX_DESC(*rx_ring, i);
4527 		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
4528 
4529 		if (unlikely(++i == rx_ring->count))
4530 			i = 0;
4531 		buffer_info = &rx_ring->buffer_info[i];
4532 	}
4533 
4534 	if (likely(rx_ring->next_to_use != i)) {
4535 		rx_ring->next_to_use = i;
4536 		if (unlikely(i-- == 0))
4537 			i = (rx_ring->count - 1);
4538 
4539 		/* Force memory writes to complete before letting h/w
4540 		 * know there are new descriptors to fetch.  (Only
4541 		 * applicable for weak-ordered memory model archs,
4542 		 * such as IA-64).
4543 		 */
4544 		wmb();
4545 		writel(i, adapter->hw.hw_addr + rx_ring->rdt);
4546 	}
4547 }
4548 
4549 /**
4550  * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
4551  * @adapter: address of board private structure
4552  **/
4553 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
4554 				   struct e1000_rx_ring *rx_ring,
4555 				   int cleaned_count)
4556 {
4557 	struct e1000_hw *hw = &adapter->hw;
4558 	struct pci_dev *pdev = adapter->pdev;
4559 	struct e1000_rx_desc *rx_desc;
4560 	struct e1000_rx_buffer *buffer_info;
4561 	unsigned int i;
4562 	unsigned int bufsz = adapter->rx_buffer_len;
4563 
4564 	i = rx_ring->next_to_use;
4565 	buffer_info = &rx_ring->buffer_info[i];
4566 
4567 	while (cleaned_count--) {
4568 		void *data;
4569 
4570 		if (buffer_info->rxbuf.data)
4571 			goto skip;
4572 
4573 		data = e1000_alloc_frag(adapter);
4574 		if (!data) {
4575 			/* Better luck next round */
4576 			adapter->alloc_rx_buff_failed++;
4577 			break;
4578 		}
4579 
4580 		/* Fix for errata 23, can't cross 64kB boundary */
4581 		if (!e1000_check_64k_bound(adapter, data, bufsz)) {
4582 			void *olddata = data;
4583 			e_err(rx_err, "skb align check failed: %u bytes at "
4584 			      "%p\n", bufsz, data);
4585 			/* Try again, without freeing the previous */
4586 			data = e1000_alloc_frag(adapter);
4587 			/* Failed allocation, critical failure */
4588 			if (!data) {
4589 				e1000_free_frag(olddata);
4590 				adapter->alloc_rx_buff_failed++;
4591 				break;
4592 			}
4593 
4594 			if (!e1000_check_64k_bound(adapter, data, bufsz)) {
4595 				/* give up */
4596 				e1000_free_frag(data);
4597 				e1000_free_frag(olddata);
4598 				adapter->alloc_rx_buff_failed++;
4599 				break;
4600 			}
4601 
4602 			/* Use new allocation */
4603 			e1000_free_frag(olddata);
4604 		}
4605 		buffer_info->dma = dma_map_single(&pdev->dev,
4606 						  data,
4607 						  adapter->rx_buffer_len,
4608 						  DMA_FROM_DEVICE);
4609 		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4610 			e1000_free_frag(data);
4611 			buffer_info->dma = 0;
4612 			adapter->alloc_rx_buff_failed++;
4613 			break;
4614 		}
4615 
4616 		/* XXX if it was allocated cleanly it will never map to a
4617 		 * boundary crossing
4618 		 */
4619 
4620 		/* Fix for errata 23, can't cross 64kB boundary */
4621 		if (!e1000_check_64k_bound(adapter,
4622 					(void *)(unsigned long)buffer_info->dma,
4623 					adapter->rx_buffer_len)) {
4624 			e_err(rx_err, "dma align check failed: %u bytes at "
4625 			      "%p\n", adapter->rx_buffer_len,
4626 			      (void *)(unsigned long)buffer_info->dma);
4627 
4628 			dma_unmap_single(&pdev->dev, buffer_info->dma,
4629 					 adapter->rx_buffer_len,
4630 					 DMA_FROM_DEVICE);
4631 
4632 			e1000_free_frag(data);
4633 			buffer_info->rxbuf.data = NULL;
4634 			buffer_info->dma = 0;
4635 
4636 			adapter->alloc_rx_buff_failed++;
4637 			break;
4638 		}
4639 		buffer_info->rxbuf.data = data;
4640  skip:
4641 		rx_desc = E1000_RX_DESC(*rx_ring, i);
4642 		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
4643 
4644 		if (unlikely(++i == rx_ring->count))
4645 			i = 0;
4646 		buffer_info = &rx_ring->buffer_info[i];
4647 	}
4648 
4649 	if (likely(rx_ring->next_to_use != i)) {
4650 		rx_ring->next_to_use = i;
4651 		if (unlikely(i-- == 0))
4652 			i = (rx_ring->count - 1);
4653 
4654 		/* Force memory writes to complete before letting h/w
4655 		 * know there are new descriptors to fetch.  (Only
4656 		 * applicable for weak-ordered memory model archs,
4657 		 * such as IA-64).
4658 		 */
4659 		wmb();
4660 		writel(i, hw->hw_addr + rx_ring->rdt);
4661 	}
4662 }
4663 
4664 /**
4665  * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
4666  * @adapter:
4667  **/
4668 static void e1000_smartspeed(struct e1000_adapter *adapter)
4669 {
4670 	struct e1000_hw *hw = &adapter->hw;
4671 	u16 phy_status;
4672 	u16 phy_ctrl;
4673 
4674 	if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg ||
4675 	   !(hw->autoneg_advertised & ADVERTISE_1000_FULL))
4676 		return;
4677 
4678 	if (adapter->smartspeed == 0) {
4679 		/* If Master/Slave config fault is asserted twice,
4680 		 * we assume back-to-back
4681 		 */
4682 		e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
4683 		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
4684 		e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
4685 		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
4686 		e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
4687 		if (phy_ctrl & CR_1000T_MS_ENABLE) {
4688 			phy_ctrl &= ~CR_1000T_MS_ENABLE;
4689 			e1000_write_phy_reg(hw, PHY_1000T_CTRL,
4690 					    phy_ctrl);
4691 			adapter->smartspeed++;
4692 			if (!e1000_phy_setup_autoneg(hw) &&
4693 			   !e1000_read_phy_reg(hw, PHY_CTRL,
4694 					       &phy_ctrl)) {
4695 				phy_ctrl |= (MII_CR_AUTO_NEG_EN |
4696 					     MII_CR_RESTART_AUTO_NEG);
4697 				e1000_write_phy_reg(hw, PHY_CTRL,
4698 						    phy_ctrl);
4699 			}
4700 		}
4701 		return;
4702 	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
4703 		/* If still no link, perhaps using 2/3 pair cable */
4704 		e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
4705 		phy_ctrl |= CR_1000T_MS_ENABLE;
4706 		e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl);
4707 		if (!e1000_phy_setup_autoneg(hw) &&
4708 		   !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) {
4709 			phy_ctrl |= (MII_CR_AUTO_NEG_EN |
4710 				     MII_CR_RESTART_AUTO_NEG);
4711 			e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl);
4712 		}
4713 	}
4714 	/* Restart process after E1000_SMARTSPEED_MAX iterations */
4715 	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
4716 		adapter->smartspeed = 0;
4717 }
4718 
4719 /**
4720  * e1000_ioctl -
4721  * @netdev:
4722  * @ifreq:
4723  * @cmd:
4724  **/
4725 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
4726 {
4727 	switch (cmd) {
4728 	case SIOCGMIIPHY:
4729 	case SIOCGMIIREG:
4730 	case SIOCSMIIREG:
4731 		return e1000_mii_ioctl(netdev, ifr, cmd);
4732 	default:
4733 		return -EOPNOTSUPP;
4734 	}
4735 }
4736 
4737 /**
4738  * e1000_mii_ioctl -
4739  * @netdev:
4740  * @ifreq:
4741  * @cmd:
4742  **/
4743 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
4744 			   int cmd)
4745 {
4746 	struct e1000_adapter *adapter = netdev_priv(netdev);
4747 	struct e1000_hw *hw = &adapter->hw;
4748 	struct mii_ioctl_data *data = if_mii(ifr);
4749 	int retval;
4750 	u16 mii_reg;
4751 	unsigned long flags;
4752 
4753 	if (hw->media_type != e1000_media_type_copper)
4754 		return -EOPNOTSUPP;
4755 
4756 	switch (cmd) {
4757 	case SIOCGMIIPHY:
4758 		data->phy_id = hw->phy_addr;
4759 		break;
4760 	case SIOCGMIIREG:
4761 		spin_lock_irqsave(&adapter->stats_lock, flags);
4762 		if (e1000_read_phy_reg(hw, data->reg_num & 0x1F,
4763 				   &data->val_out)) {
4764 			spin_unlock_irqrestore(&adapter->stats_lock, flags);
4765 			return -EIO;
4766 		}
4767 		spin_unlock_irqrestore(&adapter->stats_lock, flags);
4768 		break;
4769 	case SIOCSMIIREG:
4770 		if (data->reg_num & ~(0x1F))
4771 			return -EFAULT;
4772 		mii_reg = data->val_in;
4773 		spin_lock_irqsave(&adapter->stats_lock, flags);
4774 		if (e1000_write_phy_reg(hw, data->reg_num,
4775 					mii_reg)) {
4776 			spin_unlock_irqrestore(&adapter->stats_lock, flags);
4777 			return -EIO;
4778 		}
4779 		spin_unlock_irqrestore(&adapter->stats_lock, flags);
4780 		if (hw->media_type == e1000_media_type_copper) {
4781 			switch (data->reg_num) {
4782 			case PHY_CTRL:
4783 				if (mii_reg & MII_CR_POWER_DOWN)
4784 					break;
4785 				if (mii_reg & MII_CR_AUTO_NEG_EN) {
4786 					hw->autoneg = 1;
4787 					hw->autoneg_advertised = 0x2F;
4788 				} else {
4789 					u32 speed;
4790 					if (mii_reg & 0x40)
4791 						speed = SPEED_1000;
4792 					else if (mii_reg & 0x2000)
4793 						speed = SPEED_100;
4794 					else
4795 						speed = SPEED_10;
4796 					retval = e1000_set_spd_dplx(
4797 						adapter, speed,
4798 						((mii_reg & 0x100)
4799 						 ? DUPLEX_FULL :
4800 						 DUPLEX_HALF));
4801 					if (retval)
4802 						return retval;
4803 				}
4804 				if (netif_running(adapter->netdev))
4805 					e1000_reinit_locked(adapter);
4806 				else
4807 					e1000_reset(adapter);
4808 				break;
4809 			case M88E1000_PHY_SPEC_CTRL:
4810 			case M88E1000_EXT_PHY_SPEC_CTRL:
4811 				if (e1000_phy_reset(hw))
4812 					return -EIO;
4813 				break;
4814 			}
4815 		} else {
4816 			switch (data->reg_num) {
4817 			case PHY_CTRL:
4818 				if (mii_reg & MII_CR_POWER_DOWN)
4819 					break;
4820 				if (netif_running(adapter->netdev))
4821 					e1000_reinit_locked(adapter);
4822 				else
4823 					e1000_reset(adapter);
4824 				break;
4825 			}
4826 		}
4827 		break;
4828 	default:
4829 		return -EOPNOTSUPP;
4830 	}
4831 	return E1000_SUCCESS;
4832 }
4833 
4834 void e1000_pci_set_mwi(struct e1000_hw *hw)
4835 {
4836 	struct e1000_adapter *adapter = hw->back;
4837 	int ret_val = pci_set_mwi(adapter->pdev);
4838 
4839 	if (ret_val)
4840 		e_err(probe, "Error in setting MWI\n");
4841 }
4842 
4843 void e1000_pci_clear_mwi(struct e1000_hw *hw)
4844 {
4845 	struct e1000_adapter *adapter = hw->back;
4846 
4847 	pci_clear_mwi(adapter->pdev);
4848 }
4849 
4850 int e1000_pcix_get_mmrbc(struct e1000_hw *hw)
4851 {
4852 	struct e1000_adapter *adapter = hw->back;
4853 	return pcix_get_mmrbc(adapter->pdev);
4854 }
4855 
4856 void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
4857 {
4858 	struct e1000_adapter *adapter = hw->back;
4859 	pcix_set_mmrbc(adapter->pdev, mmrbc);
4860 }
4861 
4862 void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
4863 {
4864 	outl(value, port);
4865 }
4866 
4867 static bool e1000_vlan_used(struct e1000_adapter *adapter)
4868 {
4869 	u16 vid;
4870 
4871 	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
4872 		return true;
4873 	return false;
4874 }
4875 
4876 static void __e1000_vlan_mode(struct e1000_adapter *adapter,
4877 			      netdev_features_t features)
4878 {
4879 	struct e1000_hw *hw = &adapter->hw;
4880 	u32 ctrl;
4881 
4882 	ctrl = er32(CTRL);
4883 	if (features & NETIF_F_HW_VLAN_CTAG_RX) {
4884 		/* enable VLAN tag insert/strip */
4885 		ctrl |= E1000_CTRL_VME;
4886 	} else {
4887 		/* disable VLAN tag insert/strip */
4888 		ctrl &= ~E1000_CTRL_VME;
4889 	}
4890 	ew32(CTRL, ctrl);
4891 }
4892 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
4893 				     bool filter_on)
4894 {
4895 	struct e1000_hw *hw = &adapter->hw;
4896 	u32 rctl;
4897 
4898 	if (!test_bit(__E1000_DOWN, &adapter->flags))
4899 		e1000_irq_disable(adapter);
4900 
4901 	__e1000_vlan_mode(adapter, adapter->netdev->features);
4902 	if (filter_on) {
4903 		/* enable VLAN receive filtering */
4904 		rctl = er32(RCTL);
4905 		rctl &= ~E1000_RCTL_CFIEN;
4906 		if (!(adapter->netdev->flags & IFF_PROMISC))
4907 			rctl |= E1000_RCTL_VFE;
4908 		ew32(RCTL, rctl);
4909 		e1000_update_mng_vlan(adapter);
4910 	} else {
4911 		/* disable VLAN receive filtering */
4912 		rctl = er32(RCTL);
4913 		rctl &= ~E1000_RCTL_VFE;
4914 		ew32(RCTL, rctl);
4915 	}
4916 
4917 	if (!test_bit(__E1000_DOWN, &adapter->flags))
4918 		e1000_irq_enable(adapter);
4919 }
4920 
4921 static void e1000_vlan_mode(struct net_device *netdev,
4922 			    netdev_features_t features)
4923 {
4924 	struct e1000_adapter *adapter = netdev_priv(netdev);
4925 
4926 	if (!test_bit(__E1000_DOWN, &adapter->flags))
4927 		e1000_irq_disable(adapter);
4928 
4929 	__e1000_vlan_mode(adapter, features);
4930 
4931 	if (!test_bit(__E1000_DOWN, &adapter->flags))
4932 		e1000_irq_enable(adapter);
4933 }
4934 
4935 static int e1000_vlan_rx_add_vid(struct net_device *netdev,
4936 				 __be16 proto, u16 vid)
4937 {
4938 	struct e1000_adapter *adapter = netdev_priv(netdev);
4939 	struct e1000_hw *hw = &adapter->hw;
4940 	u32 vfta, index;
4941 
4942 	if ((hw->mng_cookie.status &
4943 	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
4944 	    (vid == adapter->mng_vlan_id))
4945 		return 0;
4946 
4947 	if (!e1000_vlan_used(adapter))
4948 		e1000_vlan_filter_on_off(adapter, true);
4949 
4950 	/* add VID to filter table */
4951 	index = (vid >> 5) & 0x7F;
4952 	vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
4953 	vfta |= (1 << (vid & 0x1F));
4954 	e1000_write_vfta(hw, index, vfta);
4955 
4956 	set_bit(vid, adapter->active_vlans);
4957 
4958 	return 0;
4959 }
4960 
4961 static int e1000_vlan_rx_kill_vid(struct net_device *netdev,
4962 				  __be16 proto, u16 vid)
4963 {
4964 	struct e1000_adapter *adapter = netdev_priv(netdev);
4965 	struct e1000_hw *hw = &adapter->hw;
4966 	u32 vfta, index;
4967 
4968 	if (!test_bit(__E1000_DOWN, &adapter->flags))
4969 		e1000_irq_disable(adapter);
4970 	if (!test_bit(__E1000_DOWN, &adapter->flags))
4971 		e1000_irq_enable(adapter);
4972 
4973 	/* remove VID from filter table */
4974 	index = (vid >> 5) & 0x7F;
4975 	vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
4976 	vfta &= ~(1 << (vid & 0x1F));
4977 	e1000_write_vfta(hw, index, vfta);
4978 
4979 	clear_bit(vid, adapter->active_vlans);
4980 
4981 	if (!e1000_vlan_used(adapter))
4982 		e1000_vlan_filter_on_off(adapter, false);
4983 
4984 	return 0;
4985 }
4986 
4987 static void e1000_restore_vlan(struct e1000_adapter *adapter)
4988 {
4989 	u16 vid;
4990 
4991 	if (!e1000_vlan_used(adapter))
4992 		return;
4993 
4994 	e1000_vlan_filter_on_off(adapter, true);
4995 	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
4996 		e1000_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid);
4997 }
4998 
4999 int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
5000 {
5001 	struct e1000_hw *hw = &adapter->hw;
5002 
5003 	hw->autoneg = 0;
5004 
5005 	/* Make sure dplx is at most 1 bit and lsb of speed is not set
5006 	 * for the switch() below to work
5007 	 */
5008 	if ((spd & 1) || (dplx & ~1))
5009 		goto err_inval;
5010 
5011 	/* Fiber NICs only allow 1000 gbps Full duplex */
5012 	if ((hw->media_type == e1000_media_type_fiber) &&
5013 	    spd != SPEED_1000 &&
5014 	    dplx != DUPLEX_FULL)
5015 		goto err_inval;
5016 
5017 	switch (spd + dplx) {
5018 	case SPEED_10 + DUPLEX_HALF:
5019 		hw->forced_speed_duplex = e1000_10_half;
5020 		break;
5021 	case SPEED_10 + DUPLEX_FULL:
5022 		hw->forced_speed_duplex = e1000_10_full;
5023 		break;
5024 	case SPEED_100 + DUPLEX_HALF:
5025 		hw->forced_speed_duplex = e1000_100_half;
5026 		break;
5027 	case SPEED_100 + DUPLEX_FULL:
5028 		hw->forced_speed_duplex = e1000_100_full;
5029 		break;
5030 	case SPEED_1000 + DUPLEX_FULL:
5031 		hw->autoneg = 1;
5032 		hw->autoneg_advertised = ADVERTISE_1000_FULL;
5033 		break;
5034 	case SPEED_1000 + DUPLEX_HALF: /* not supported */
5035 	default:
5036 		goto err_inval;
5037 	}
5038 
5039 	/* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
5040 	hw->mdix = AUTO_ALL_MODES;
5041 
5042 	return 0;
5043 
5044 err_inval:
5045 	e_err(probe, "Unsupported Speed/Duplex configuration\n");
5046 	return -EINVAL;
5047 }
5048 
5049 static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
5050 {
5051 	struct net_device *netdev = pci_get_drvdata(pdev);
5052 	struct e1000_adapter *adapter = netdev_priv(netdev);
5053 	struct e1000_hw *hw = &adapter->hw;
5054 	u32 ctrl, ctrl_ext, rctl, status;
5055 	u32 wufc = adapter->wol;
5056 #ifdef CONFIG_PM
5057 	int retval = 0;
5058 #endif
5059 
5060 	netif_device_detach(netdev);
5061 
5062 	if (netif_running(netdev)) {
5063 		int count = E1000_CHECK_RESET_COUNT;
5064 
5065 		while (test_bit(__E1000_RESETTING, &adapter->flags) && count--)
5066 			usleep_range(10000, 20000);
5067 
5068 		WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
5069 		e1000_down(adapter);
5070 	}
5071 
5072 #ifdef CONFIG_PM
5073 	retval = pci_save_state(pdev);
5074 	if (retval)
5075 		return retval;
5076 #endif
5077 
5078 	status = er32(STATUS);
5079 	if (status & E1000_STATUS_LU)
5080 		wufc &= ~E1000_WUFC_LNKC;
5081 
5082 	if (wufc) {
5083 		e1000_setup_rctl(adapter);
5084 		e1000_set_rx_mode(netdev);
5085 
5086 		rctl = er32(RCTL);
5087 
5088 		/* turn on all-multi mode if wake on multicast is enabled */
5089 		if (wufc & E1000_WUFC_MC)
5090 			rctl |= E1000_RCTL_MPE;
5091 
5092 		/* enable receives in the hardware */
5093 		ew32(RCTL, rctl | E1000_RCTL_EN);
5094 
5095 		if (hw->mac_type >= e1000_82540) {
5096 			ctrl = er32(CTRL);
5097 			/* advertise wake from D3Cold */
5098 			#define E1000_CTRL_ADVD3WUC 0x00100000
5099 			/* phy power management enable */
5100 			#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
5101 			ctrl |= E1000_CTRL_ADVD3WUC |
5102 				E1000_CTRL_EN_PHY_PWR_MGMT;
5103 			ew32(CTRL, ctrl);
5104 		}
5105 
5106 		if (hw->media_type == e1000_media_type_fiber ||
5107 		    hw->media_type == e1000_media_type_internal_serdes) {
5108 			/* keep the laser running in D3 */
5109 			ctrl_ext = er32(CTRL_EXT);
5110 			ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
5111 			ew32(CTRL_EXT, ctrl_ext);
5112 		}
5113 
5114 		ew32(WUC, E1000_WUC_PME_EN);
5115 		ew32(WUFC, wufc);
5116 	} else {
5117 		ew32(WUC, 0);
5118 		ew32(WUFC, 0);
5119 	}
5120 
5121 	e1000_release_manageability(adapter);
5122 
5123 	*enable_wake = !!wufc;
5124 
5125 	/* make sure adapter isn't asleep if manageability is enabled */
5126 	if (adapter->en_mng_pt)
5127 		*enable_wake = true;
5128 
5129 	if (netif_running(netdev))
5130 		e1000_free_irq(adapter);
5131 
5132 	pci_disable_device(pdev);
5133 
5134 	return 0;
5135 }
5136 
5137 #ifdef CONFIG_PM
5138 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
5139 {
5140 	int retval;
5141 	bool wake;
5142 
5143 	retval = __e1000_shutdown(pdev, &wake);
5144 	if (retval)
5145 		return retval;
5146 
5147 	if (wake) {
5148 		pci_prepare_to_sleep(pdev);
5149 	} else {
5150 		pci_wake_from_d3(pdev, false);
5151 		pci_set_power_state(pdev, PCI_D3hot);
5152 	}
5153 
5154 	return 0;
5155 }
5156 
5157 static int e1000_resume(struct pci_dev *pdev)
5158 {
5159 	struct net_device *netdev = pci_get_drvdata(pdev);
5160 	struct e1000_adapter *adapter = netdev_priv(netdev);
5161 	struct e1000_hw *hw = &adapter->hw;
5162 	u32 err;
5163 
5164 	pci_set_power_state(pdev, PCI_D0);
5165 	pci_restore_state(pdev);
5166 	pci_save_state(pdev);
5167 
5168 	if (adapter->need_ioport)
5169 		err = pci_enable_device(pdev);
5170 	else
5171 		err = pci_enable_device_mem(pdev);
5172 	if (err) {
5173 		pr_err("Cannot enable PCI device from suspend\n");
5174 		return err;
5175 	}
5176 	pci_set_master(pdev);
5177 
5178 	pci_enable_wake(pdev, PCI_D3hot, 0);
5179 	pci_enable_wake(pdev, PCI_D3cold, 0);
5180 
5181 	if (netif_running(netdev)) {
5182 		err = e1000_request_irq(adapter);
5183 		if (err)
5184 			return err;
5185 	}
5186 
5187 	e1000_power_up_phy(adapter);
5188 	e1000_reset(adapter);
5189 	ew32(WUS, ~0);
5190 
5191 	e1000_init_manageability(adapter);
5192 
5193 	if (netif_running(netdev))
5194 		e1000_up(adapter);
5195 
5196 	netif_device_attach(netdev);
5197 
5198 	return 0;
5199 }
5200 #endif
5201 
5202 static void e1000_shutdown(struct pci_dev *pdev)
5203 {
5204 	bool wake;
5205 
5206 	__e1000_shutdown(pdev, &wake);
5207 
5208 	if (system_state == SYSTEM_POWER_OFF) {
5209 		pci_wake_from_d3(pdev, wake);
5210 		pci_set_power_state(pdev, PCI_D3hot);
5211 	}
5212 }
5213 
5214 #ifdef CONFIG_NET_POLL_CONTROLLER
5215 /* Polling 'interrupt' - used by things like netconsole to send skbs
5216  * without having to re-enable interrupts. It's not called while
5217  * the interrupt routine is executing.
5218  */
5219 static void e1000_netpoll(struct net_device *netdev)
5220 {
5221 	struct e1000_adapter *adapter = netdev_priv(netdev);
5222 
5223 	disable_irq(adapter->pdev->irq);
5224 	e1000_intr(adapter->pdev->irq, netdev);
5225 	enable_irq(adapter->pdev->irq);
5226 }
5227 #endif
5228 
5229 /**
5230  * e1000_io_error_detected - called when PCI error is detected
5231  * @pdev: Pointer to PCI device
5232  * @state: The current pci connection state
5233  *
5234  * This function is called after a PCI bus error affecting
5235  * this device has been detected.
5236  */
5237 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
5238 						pci_channel_state_t state)
5239 {
5240 	struct net_device *netdev = pci_get_drvdata(pdev);
5241 	struct e1000_adapter *adapter = netdev_priv(netdev);
5242 
5243 	netif_device_detach(netdev);
5244 
5245 	if (state == pci_channel_io_perm_failure)
5246 		return PCI_ERS_RESULT_DISCONNECT;
5247 
5248 	if (netif_running(netdev))
5249 		e1000_down(adapter);
5250 	pci_disable_device(pdev);
5251 
5252 	/* Request a slot slot reset. */
5253 	return PCI_ERS_RESULT_NEED_RESET;
5254 }
5255 
5256 /**
5257  * e1000_io_slot_reset - called after the pci bus has been reset.
5258  * @pdev: Pointer to PCI device
5259  *
5260  * Restart the card from scratch, as if from a cold-boot. Implementation
5261  * resembles the first-half of the e1000_resume routine.
5262  */
5263 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
5264 {
5265 	struct net_device *netdev = pci_get_drvdata(pdev);
5266 	struct e1000_adapter *adapter = netdev_priv(netdev);
5267 	struct e1000_hw *hw = &adapter->hw;
5268 	int err;
5269 
5270 	if (adapter->need_ioport)
5271 		err = pci_enable_device(pdev);
5272 	else
5273 		err = pci_enable_device_mem(pdev);
5274 	if (err) {
5275 		pr_err("Cannot re-enable PCI device after reset.\n");
5276 		return PCI_ERS_RESULT_DISCONNECT;
5277 	}
5278 	pci_set_master(pdev);
5279 
5280 	pci_enable_wake(pdev, PCI_D3hot, 0);
5281 	pci_enable_wake(pdev, PCI_D3cold, 0);
5282 
5283 	e1000_reset(adapter);
5284 	ew32(WUS, ~0);
5285 
5286 	return PCI_ERS_RESULT_RECOVERED;
5287 }
5288 
5289 /**
5290  * e1000_io_resume - called when traffic can start flowing again.
5291  * @pdev: Pointer to PCI device
5292  *
5293  * This callback is called when the error recovery driver tells us that
5294  * its OK to resume normal operation. Implementation resembles the
5295  * second-half of the e1000_resume routine.
5296  */
5297 static void e1000_io_resume(struct pci_dev *pdev)
5298 {
5299 	struct net_device *netdev = pci_get_drvdata(pdev);
5300 	struct e1000_adapter *adapter = netdev_priv(netdev);
5301 
5302 	e1000_init_manageability(adapter);
5303 
5304 	if (netif_running(netdev)) {
5305 		if (e1000_up(adapter)) {
5306 			pr_info("can't bring device back up after reset\n");
5307 			return;
5308 		}
5309 	}
5310 
5311 	netif_device_attach(netdev);
5312 }
5313 
5314 /* e1000_main.c */
5315