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