projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


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