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