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