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