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