1 /*******************************************************************************
4 Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2 of the License, or (at your option)
11 This program is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 You should have received a copy of the GNU General Public License along with
17 this program; if not, write to the Free Software Foundation, Inc., 59
18 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 The full GNU General Public License is included in this distribution in the
24 Linux NICS <linux.nics@intel.com>
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *******************************************************************************/
33 * - kcompat NETIF_MSG for older kernels (2.4.9) <sean.p.mcdermott@intel.com>
34 * - if_mii support and associated kcompat for older kernels
35 * - More errlogging support from Jon Mason <jonmason@us.ibm.com>
36 * - Fix TSO issues on PPC64 machines -- Jon Mason <jonmason@us.ibm.com>
39 * - ethtool register dump reads MANC register conditionally.
44 char e1000_driver_name[] = "e1000";
45 char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
46 #ifndef CONFIG_E1000_NAPI
49 #define DRIVERNAPI "-NAPI"
51 #define DRV_VERSION "5.3.19-k2"DRIVERNAPI
52 char e1000_driver_version[] = DRV_VERSION;
53 char e1000_copyright[] = "Copyright (c) 1999-2004 Intel Corporation.";
55 /* e1000_pci_tbl - PCI Device ID Table
57 * Last entry must be all 0s
60 * {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
62 static struct pci_device_id e1000_pci_tbl[] = {
63 INTEL_E1000_ETHERNET_DEVICE(0x1000),
64 INTEL_E1000_ETHERNET_DEVICE(0x1001),
65 INTEL_E1000_ETHERNET_DEVICE(0x1004),
66 INTEL_E1000_ETHERNET_DEVICE(0x1008),
67 INTEL_E1000_ETHERNET_DEVICE(0x1009),
68 INTEL_E1000_ETHERNET_DEVICE(0x100C),
69 INTEL_E1000_ETHERNET_DEVICE(0x100D),
70 INTEL_E1000_ETHERNET_DEVICE(0x100E),
71 INTEL_E1000_ETHERNET_DEVICE(0x100F),
72 INTEL_E1000_ETHERNET_DEVICE(0x1010),
73 INTEL_E1000_ETHERNET_DEVICE(0x1011),
74 INTEL_E1000_ETHERNET_DEVICE(0x1012),
75 INTEL_E1000_ETHERNET_DEVICE(0x1013),
76 INTEL_E1000_ETHERNET_DEVICE(0x1015),
77 INTEL_E1000_ETHERNET_DEVICE(0x1016),
78 INTEL_E1000_ETHERNET_DEVICE(0x1017),
79 INTEL_E1000_ETHERNET_DEVICE(0x1018),
80 INTEL_E1000_ETHERNET_DEVICE(0x1019),
81 INTEL_E1000_ETHERNET_DEVICE(0x101D),
82 INTEL_E1000_ETHERNET_DEVICE(0x101E),
83 INTEL_E1000_ETHERNET_DEVICE(0x1026),
84 INTEL_E1000_ETHERNET_DEVICE(0x1027),
85 INTEL_E1000_ETHERNET_DEVICE(0x1028),
86 INTEL_E1000_ETHERNET_DEVICE(0x1075),
87 INTEL_E1000_ETHERNET_DEVICE(0x1076),
88 INTEL_E1000_ETHERNET_DEVICE(0x1077),
89 INTEL_E1000_ETHERNET_DEVICE(0x1078),
90 INTEL_E1000_ETHERNET_DEVICE(0x1079),
91 INTEL_E1000_ETHERNET_DEVICE(0x107A),
92 INTEL_E1000_ETHERNET_DEVICE(0x107B),
93 INTEL_E1000_ETHERNET_DEVICE(0x107C),
94 /* required last entry */
98 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
100 int e1000_up(struct e1000_adapter *adapter);
101 void e1000_down(struct e1000_adapter *adapter);
102 void e1000_reset(struct e1000_adapter *adapter);
103 int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
104 int e1000_setup_tx_resources(struct e1000_adapter *adapter);
105 int e1000_setup_rx_resources(struct e1000_adapter *adapter);
106 void e1000_free_tx_resources(struct e1000_adapter *adapter);
107 void e1000_free_rx_resources(struct e1000_adapter *adapter);
108 void e1000_update_stats(struct e1000_adapter *adapter);
110 /* Local Function Prototypes */
112 static int e1000_init_module(void);
113 static void e1000_exit_module(void);
114 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
115 static void __devexit e1000_remove(struct pci_dev *pdev);
116 static int e1000_sw_init(struct e1000_adapter *adapter);
117 static int e1000_open(struct net_device *netdev);
118 static int e1000_close(struct net_device *netdev);
119 static void e1000_configure_tx(struct e1000_adapter *adapter);
120 static void e1000_configure_rx(struct e1000_adapter *adapter);
121 static void e1000_setup_rctl(struct e1000_adapter *adapter);
122 static void e1000_clean_tx_ring(struct e1000_adapter *adapter);
123 static void e1000_clean_rx_ring(struct e1000_adapter *adapter);
124 static void e1000_set_multi(struct net_device *netdev);
125 static void e1000_update_phy_info(unsigned long data);
126 static void e1000_watchdog(unsigned long data);
127 static void e1000_82547_tx_fifo_stall(unsigned long data);
128 static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
129 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
130 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
131 static int e1000_set_mac(struct net_device *netdev, void *p);
132 static void e1000_irq_disable(struct e1000_adapter *adapter);
133 static void e1000_irq_enable(struct e1000_adapter *adapter);
134 static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
135 static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter);
136 #ifdef CONFIG_E1000_NAPI
137 static int e1000_clean(struct net_device *netdev, int *budget);
138 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
139 int *work_done, int work_to_do);
141 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter);
143 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);
144 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
145 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
147 void set_ethtool_ops(struct net_device *netdev);
148 static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
149 static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
150 static void e1000_rx_checksum(struct e1000_adapter *adapter,
151 struct e1000_rx_desc *rx_desc,
152 struct sk_buff *skb);
153 static void e1000_tx_timeout(struct net_device *dev);
154 static void e1000_tx_timeout_task(struct net_device *dev);
155 static void e1000_smartspeed(struct e1000_adapter *adapter);
156 static inline int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
157 struct sk_buff *skb);
159 static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
160 static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
161 static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
162 static void e1000_restore_vlan(struct e1000_adapter *adapter);
164 static int e1000_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
165 static int e1000_suspend(struct pci_dev *pdev, uint32_t state);
167 static int e1000_resume(struct pci_dev *pdev);
170 #ifdef CONFIG_NET_POLL_CONTROLLER
171 /* for netdump / net console */
172 static void e1000_netpoll (struct net_device *netdev);
175 struct notifier_block e1000_notifier_reboot = {
176 .notifier_call = e1000_notify_reboot,
181 /* Exported from other modules */
183 extern void e1000_check_options(struct e1000_adapter *adapter);
185 static struct pci_driver e1000_driver = {
186 .name = e1000_driver_name,
187 .id_table = e1000_pci_tbl,
188 .probe = e1000_probe,
189 .remove = __devexit_p(e1000_remove),
190 /* Power Managment Hooks */
192 .suspend = e1000_suspend,
193 .resume = e1000_resume
197 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
198 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
199 MODULE_LICENSE("GPL");
200 MODULE_VERSION(DRV_VERSION);
202 static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
203 module_param(debug, int, 0);
204 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
207 * e1000_init_module - Driver Registration Routine
209 * e1000_init_module is the first routine called when the driver is
210 * loaded. All it does is register with the PCI subsystem.
214 e1000_init_module(void)
217 printk(KERN_INFO "%s - version %s\n",
218 e1000_driver_string, e1000_driver_version);
220 printk(KERN_INFO "%s\n", e1000_copyright);
222 ret = pci_module_init(&e1000_driver);
224 register_reboot_notifier(&e1000_notifier_reboot);
229 module_init(e1000_init_module);
232 * e1000_exit_module - Driver Exit Cleanup Routine
234 * e1000_exit_module is called just before the driver is removed
239 e1000_exit_module(void)
241 unregister_reboot_notifier(&e1000_notifier_reboot);
242 pci_unregister_driver(&e1000_driver);
245 module_exit(e1000_exit_module);
249 e1000_up(struct e1000_adapter *adapter)
251 struct net_device *netdev = adapter->netdev;
254 /* hardware has been reset, we need to reload some things */
256 /* Reset the PHY if it was previously powered down */
257 if(adapter->hw.media_type == e1000_media_type_copper) {
259 e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
260 if(mii_reg & MII_CR_POWER_DOWN)
261 e1000_phy_reset(&adapter->hw);
264 e1000_set_multi(netdev);
266 e1000_restore_vlan(adapter);
268 e1000_configure_tx(adapter);
269 e1000_setup_rctl(adapter);
270 e1000_configure_rx(adapter);
271 e1000_alloc_rx_buffers(adapter);
273 if((err = request_irq(adapter->pdev->irq, &e1000_intr,
274 SA_SHIRQ | SA_SAMPLE_RANDOM,
275 netdev->name, netdev)))
278 mod_timer(&adapter->watchdog_timer, jiffies);
279 e1000_irq_enable(adapter);
285 e1000_down(struct e1000_adapter *adapter)
287 struct net_device *netdev = adapter->netdev;
289 e1000_irq_disable(adapter);
290 free_irq(adapter->pdev->irq, netdev);
291 del_timer_sync(&adapter->tx_fifo_stall_timer);
292 del_timer_sync(&adapter->watchdog_timer);
293 del_timer_sync(&adapter->phy_info_timer);
294 adapter->link_speed = 0;
295 adapter->link_duplex = 0;
296 netif_carrier_off(netdev);
297 netif_stop_queue(netdev);
299 e1000_reset(adapter);
300 e1000_clean_tx_ring(adapter);
301 e1000_clean_rx_ring(adapter);
303 /* If WoL is not enabled
304 * Power down the PHY so no link is implied when interface is down */
305 if(!adapter->wol && adapter->hw.media_type == e1000_media_type_copper) {
307 e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
308 mii_reg |= MII_CR_POWER_DOWN;
309 e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);
314 e1000_reset(struct e1000_adapter *adapter)
317 /* Repartition Pba for greater than 9k mtu
318 * To take effect CTRL.RST is required.
321 if(adapter->hw.mac_type < e1000_82547) {
322 if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
327 if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
331 adapter->tx_fifo_head = 0;
332 adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
333 adapter->tx_fifo_size =
334 (E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
335 atomic_set(&adapter->tx_fifo_stall, 0);
337 E1000_WRITE_REG(&adapter->hw, PBA, pba);
339 /* flow control settings */
340 adapter->hw.fc_high_water = (pba << E1000_PBA_BYTES_SHIFT) -
342 adapter->hw.fc_low_water = (pba << E1000_PBA_BYTES_SHIFT) -
344 adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
345 adapter->hw.fc_send_xon = 1;
346 adapter->hw.fc = adapter->hw.original_fc;
348 e1000_reset_hw(&adapter->hw);
349 if(adapter->hw.mac_type >= e1000_82544)
350 E1000_WRITE_REG(&adapter->hw, WUC, 0);
351 if(e1000_init_hw(&adapter->hw))
352 DPRINTK(PROBE, ERR, "Hardware Error\n");
354 /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
355 E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);
357 e1000_reset_adaptive(&adapter->hw);
358 e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
360 if(adapter->en_mng_pt) {
361 manc = E1000_READ_REG(&adapter->hw, MANC);
362 manc |= (E1000_MANC_ARP_EN | E1000_MANC_EN_MNG2HOST);
363 E1000_WRITE_REG(&adapter->hw, MANC, manc);
368 * e1000_probe - Device Initialization Routine
369 * @pdev: PCI device information struct
370 * @ent: entry in e1000_pci_tbl
372 * Returns 0 on success, negative on failure
374 * e1000_probe initializes an adapter identified by a pci_dev structure.
375 * The OS initialization, configuring of the adapter private structure,
376 * and a hardware reset occur.
380 e1000_probe(struct pci_dev *pdev,
381 const struct pci_device_id *ent)
383 struct net_device *netdev;
384 struct e1000_adapter *adapter;
385 static int cards_found = 0;
386 unsigned long mmio_start;
391 uint16_t eeprom_data;
393 if((err = pci_enable_device(pdev)))
396 if(!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
399 if((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
400 E1000_ERR("No usable DMA configuration, aborting\n");
406 if((err = pci_request_regions(pdev, e1000_driver_name)))
409 pci_set_master(pdev);
411 netdev = alloc_etherdev(sizeof(struct e1000_adapter));
414 goto err_alloc_etherdev;
417 SET_MODULE_OWNER(netdev);
418 SET_NETDEV_DEV(netdev, &pdev->dev);
420 pci_set_drvdata(pdev, netdev);
421 adapter = netdev->priv;
422 adapter->netdev = netdev;
423 adapter->pdev = pdev;
424 adapter->hw.back = adapter;
425 adapter->msg_enable = (1 << debug) - 1;
428 /* we need to set the name early for the DPRINTK macro */
429 if(dev_alloc_name(netdev, netdev->name) < 0)
430 goto err_free_unlock;
432 mmio_start = pci_resource_start(pdev, BAR_0);
433 mmio_len = pci_resource_len(pdev, BAR_0);
435 adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
436 if(!adapter->hw.hw_addr) {
441 for(i = BAR_1; i <= BAR_5; i++) {
442 if(pci_resource_len(pdev, i) == 0)
444 if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {
445 adapter->hw.io_base = pci_resource_start(pdev, i);
450 netdev->open = &e1000_open;
451 netdev->stop = &e1000_close;
452 netdev->hard_start_xmit = &e1000_xmit_frame;
453 netdev->get_stats = &e1000_get_stats;
454 netdev->set_multicast_list = &e1000_set_multi;
455 netdev->set_mac_address = &e1000_set_mac;
456 netdev->change_mtu = &e1000_change_mtu;
457 netdev->do_ioctl = &e1000_ioctl;
458 set_ethtool_ops(netdev);
459 netdev->tx_timeout = &e1000_tx_timeout;
460 netdev->watchdog_timeo = 5 * HZ;
461 #ifdef CONFIG_E1000_NAPI
462 netdev->poll = &e1000_clean;
465 netdev->vlan_rx_register = e1000_vlan_rx_register;
466 netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
467 netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
468 #ifdef CONFIG_NET_POLL_CONTROLLER
469 netdev->poll_controller = e1000_netpoll;
472 netdev->mem_start = mmio_start;
473 netdev->mem_end = mmio_start + mmio_len;
474 netdev->base_addr = adapter->hw.io_base;
476 adapter->bd_number = cards_found;
478 /* setup the private structure */
480 if((err = e1000_sw_init(adapter)))
483 if(adapter->hw.mac_type >= e1000_82543) {
484 netdev->features = NETIF_F_SG |
488 NETIF_F_HW_VLAN_FILTER;
490 netdev->features = NETIF_F_SG;
494 /* Disbaled for now until root-cause is found for
495 * hangs reported against non-IA archs. TSO can be
496 * enabled using ethtool -K eth<x> tso on */
497 if((adapter->hw.mac_type >= e1000_82544) &&
498 (adapter->hw.mac_type != e1000_82547))
499 netdev->features |= NETIF_F_TSO;
502 netdev->features |= NETIF_F_HIGHDMA;
504 /* hard_start_xmit is safe against parallel locking */
505 netdev->features |= NETIF_F_LLTX;
507 adapter->en_mng_pt = e1000_enable_mng_pass_thru(&adapter->hw);
509 /* before reading the EEPROM, reset the controller to
510 * put the device in a known good starting state */
512 e1000_reset_hw(&adapter->hw);
514 /* make sure the EEPROM is good */
516 if(e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
517 DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
522 /* copy the MAC address out of the EEPROM */
524 if (e1000_read_mac_addr(&adapter->hw))
525 DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
526 memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
528 if(!is_valid_ether_addr(netdev->dev_addr)) {
529 DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
534 e1000_read_part_num(&adapter->hw, &(adapter->part_num));
536 e1000_get_bus_info(&adapter->hw);
538 init_timer(&adapter->tx_fifo_stall_timer);
539 adapter->tx_fifo_stall_timer.function = &e1000_82547_tx_fifo_stall;
540 adapter->tx_fifo_stall_timer.data = (unsigned long) adapter;
542 init_timer(&adapter->watchdog_timer);
543 adapter->watchdog_timer.function = &e1000_watchdog;
544 adapter->watchdog_timer.data = (unsigned long) adapter;
546 init_timer(&adapter->phy_info_timer);
547 adapter->phy_info_timer.function = &e1000_update_phy_info;
548 adapter->phy_info_timer.data = (unsigned long) adapter;
550 INIT_WORK(&adapter->tx_timeout_task,
551 (void (*)(void *))e1000_tx_timeout_task, netdev);
553 /* we're going to reset, so assume we have no link for now */
555 netif_carrier_off(netdev);
556 netif_stop_queue(netdev);
558 DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");
559 e1000_check_options(adapter);
561 /* Initial Wake on LAN setting
562 * If APM wake is enabled in the EEPROM,
563 * enable the ACPI Magic Packet filter
566 switch(adapter->hw.mac_type) {
567 case e1000_82542_rev2_0:
568 case e1000_82542_rev2_1:
572 case e1000_82546_rev_3:
573 if((E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1)
574 && (adapter->hw.media_type == e1000_media_type_copper)) {
575 e1000_read_eeprom(&adapter->hw,
576 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
581 e1000_read_eeprom(&adapter->hw,
582 EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
585 if(eeprom_data & E1000_EEPROM_APME)
586 adapter->wol |= E1000_WUFC_MAG;
588 /* reset the hardware with the new settings */
589 e1000_reset(adapter);
591 /* We're already holding the rtnl lock; call the no-lock version */
592 if((err = register_netdevice(netdev)))
602 iounmap(adapter->hw.hw_addr);
608 pci_release_regions(pdev);
613 * e1000_remove - Device Removal Routine
614 * @pdev: PCI device information struct
616 * e1000_remove is called by the PCI subsystem to alert the driver
617 * that it should release a PCI device. The could be caused by a
618 * Hot-Plug event, or because the driver is going to be removed from
622 static void __devexit
623 e1000_remove(struct pci_dev *pdev)
625 struct net_device *netdev = pci_get_drvdata(pdev);
626 struct e1000_adapter *adapter = netdev->priv;
629 if(adapter->hw.mac_type >= e1000_82540 &&
630 adapter->hw.media_type == e1000_media_type_copper) {
631 manc = E1000_READ_REG(&adapter->hw, MANC);
632 if(manc & E1000_MANC_SMBUS_EN) {
633 manc |= E1000_MANC_ARP_EN;
634 E1000_WRITE_REG(&adapter->hw, MANC, manc);
638 unregister_netdev(netdev);
640 e1000_phy_hw_reset(&adapter->hw);
642 iounmap(adapter->hw.hw_addr);
643 pci_release_regions(pdev);
649 * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
650 * @adapter: board private structure to initialize
652 * e1000_sw_init initializes the Adapter private data structure.
653 * Fields are initialized based on PCI device information and
654 * OS network device settings (MTU size).
658 e1000_sw_init(struct e1000_adapter *adapter)
660 struct e1000_hw *hw = &adapter->hw;
661 struct net_device *netdev = adapter->netdev;
662 struct pci_dev *pdev = adapter->pdev;
664 /* PCI config space info */
666 hw->vendor_id = pdev->vendor;
667 hw->device_id = pdev->device;
668 hw->subsystem_vendor_id = pdev->subsystem_vendor;
669 hw->subsystem_id = pdev->subsystem_device;
671 pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
673 pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
675 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
676 hw->max_frame_size = netdev->mtu +
677 ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
678 hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
680 /* identify the MAC */
682 if(e1000_set_mac_type(hw)) {
683 DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
687 /* initialize eeprom parameters */
689 e1000_init_eeprom_params(hw);
691 switch(hw->mac_type) {
696 case e1000_82541_rev_2:
697 case e1000_82547_rev_2:
698 hw->phy_init_script = 1;
702 e1000_set_media_type(hw);
704 hw->wait_autoneg_complete = FALSE;
705 hw->tbi_compatibility_en = TRUE;
706 hw->adaptive_ifs = TRUE;
710 if(hw->media_type == e1000_media_type_copper) {
711 hw->mdix = AUTO_ALL_MODES;
712 hw->disable_polarity_correction = FALSE;
713 hw->master_slave = E1000_MASTER_SLAVE;
716 atomic_set(&adapter->irq_sem, 1);
717 spin_lock_init(&adapter->stats_lock);
718 spin_lock_init(&adapter->tx_lock);
724 * e1000_open - Called when a network interface is made active
725 * @netdev: network interface device structure
727 * Returns 0 on success, negative value on failure
729 * The open entry point is called when a network interface is made
730 * active by the system (IFF_UP). At this point all resources needed
731 * for transmit and receive operations are allocated, the interrupt
732 * handler is registered with the OS, the watchdog timer is started,
733 * and the stack is notified that the interface is ready.
737 e1000_open(struct net_device *netdev)
739 struct e1000_adapter *adapter = netdev->priv;
742 /* allocate transmit descriptors */
744 if((err = e1000_setup_tx_resources(adapter)))
747 /* allocate receive descriptors */
749 if((err = e1000_setup_rx_resources(adapter)))
752 if((err = e1000_up(adapter)))
755 return E1000_SUCCESS;
758 e1000_free_rx_resources(adapter);
760 e1000_free_tx_resources(adapter);
762 e1000_reset(adapter);
768 * e1000_close - Disables a network interface
769 * @netdev: network interface device structure
771 * Returns 0, this is not allowed to fail
773 * The close entry point is called when an interface is de-activated
774 * by the OS. The hardware is still under the drivers control, but
775 * needs to be disabled. A global MAC reset is issued to stop the
776 * hardware, and all transmit and receive resources are freed.
780 e1000_close(struct net_device *netdev)
782 struct e1000_adapter *adapter = netdev->priv;
786 e1000_free_tx_resources(adapter);
787 e1000_free_rx_resources(adapter);
793 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
794 * @adapter: address of board private structure
795 * @begin: address of beginning of memory
796 * @end: address of end of memory
798 static inline boolean_t
799 e1000_check_64k_bound(struct e1000_adapter *adapter,
800 void *start, unsigned long len)
802 unsigned long begin = (unsigned long) start;
803 unsigned long end = begin + len;
805 /* first rev 82545 and 82546 need to not allow any memory
806 * write location to cross a 64k boundary due to errata 23 */
807 if (adapter->hw.mac_type == e1000_82545 ||
808 adapter->hw.mac_type == e1000_82546
810 /* check buffer doesn't cross 64kB */
811 return ((begin ^ (end - 1)) >> 16) != 0 ? FALSE : TRUE;
818 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
819 * @adapter: board private structure
821 * Return 0 on success, negative on failure
825 e1000_setup_tx_resources(struct e1000_adapter *adapter)
827 struct e1000_desc_ring *txdr = &adapter->tx_ring;
828 struct pci_dev *pdev = adapter->pdev;
831 size = sizeof(struct e1000_buffer) * txdr->count;
832 txdr->buffer_info = vmalloc(size);
833 if(!txdr->buffer_info) {
835 "Unable to Allocate Memory for the Transmit descriptor ring\n");
838 memset(txdr->buffer_info, 0, size);
840 /* round up to nearest 4K */
842 txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
843 E1000_ROUNDUP(txdr->size, 4096);
845 txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
849 "Unable to Allocate Memory for the Transmit descriptor ring\n");
850 vfree(txdr->buffer_info);
854 /* fix for errata 23, cant cross 64kB boundary */
855 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
856 void *olddesc = txdr->desc;
857 dma_addr_t olddma = txdr->dma;
858 DPRINTK(TX_ERR,ERR,"txdr align check failed: %u bytes at %p\n",
859 txdr->size, txdr->desc);
860 /* try again, without freeing the previous */
861 txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
862 /* failed allocation, critial failure */
864 pci_free_consistent(pdev, txdr->size, olddesc, olddma);
865 goto setup_tx_desc_die;
868 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
870 pci_free_consistent(pdev, txdr->size,
871 txdr->desc, txdr->dma);
872 pci_free_consistent(pdev, txdr->size, olddesc, olddma);
874 "Unable to Allocate aligned Memory for the Transmit"
875 " descriptor ring\n");
876 vfree(txdr->buffer_info);
879 /* free old, move on with the new one since its okay */
880 pci_free_consistent(pdev, txdr->size, olddesc, olddma);
883 memset(txdr->desc, 0, txdr->size);
885 txdr->next_to_use = 0;
886 txdr->next_to_clean = 0;
892 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
893 * @adapter: board private structure
895 * Configure the Tx unit of the MAC after a reset.
899 e1000_configure_tx(struct e1000_adapter *adapter)
901 uint64_t tdba = adapter->tx_ring.dma;
902 uint32_t tdlen = adapter->tx_ring.count * sizeof(struct e1000_tx_desc);
905 E1000_WRITE_REG(&adapter->hw, TDBAL, (tdba & 0x00000000ffffffffULL));
906 E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
908 E1000_WRITE_REG(&adapter->hw, TDLEN, tdlen);
910 /* Setup the HW Tx Head and Tail descriptor pointers */
912 E1000_WRITE_REG(&adapter->hw, TDH, 0);
913 E1000_WRITE_REG(&adapter->hw, TDT, 0);
915 /* Set the default values for the Tx Inter Packet Gap timer */
917 switch (adapter->hw.mac_type) {
918 case e1000_82542_rev2_0:
919 case e1000_82542_rev2_1:
920 tipg = DEFAULT_82542_TIPG_IPGT;
921 tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
922 tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
925 if(adapter->hw.media_type == e1000_media_type_fiber ||
926 adapter->hw.media_type == e1000_media_type_internal_serdes)
927 tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
929 tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
930 tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
931 tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
933 E1000_WRITE_REG(&adapter->hw, TIPG, tipg);
935 /* Set the Tx Interrupt Delay register */
937 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
938 if(adapter->hw.mac_type >= e1000_82540)
939 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
941 /* Program the Transmit Control Register */
943 tctl = E1000_READ_REG(&adapter->hw, TCTL);
945 tctl &= ~E1000_TCTL_CT;
946 tctl |= E1000_TCTL_EN | E1000_TCTL_PSP |
947 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
949 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
951 e1000_config_collision_dist(&adapter->hw);
953 /* Setup Transmit Descriptor Settings for eop descriptor */
954 adapter->txd_cmd = E1000_TXD_CMD_IDE | E1000_TXD_CMD_EOP |
957 if(adapter->hw.mac_type < e1000_82543)
958 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
960 adapter->txd_cmd |= E1000_TXD_CMD_RS;
962 /* Cache if we're 82544 running in PCI-X because we'll
963 * need this to apply a workaround later in the send path. */
964 if(adapter->hw.mac_type == e1000_82544 &&
965 adapter->hw.bus_type == e1000_bus_type_pcix)
966 adapter->pcix_82544 = 1;
970 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
971 * @adapter: board private structure
973 * Returns 0 on success, negative on failure
977 e1000_setup_rx_resources(struct e1000_adapter *adapter)
979 struct e1000_desc_ring *rxdr = &adapter->rx_ring;
980 struct pci_dev *pdev = adapter->pdev;
983 size = sizeof(struct e1000_buffer) * rxdr->count;
984 rxdr->buffer_info = vmalloc(size);
985 if(!rxdr->buffer_info) {
987 "Unable to Allocate Memory for the Recieve descriptor ring\n");
990 memset(rxdr->buffer_info, 0, size);
992 /* Round up to nearest 4K */
994 rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
995 E1000_ROUNDUP(rxdr->size, 4096);
997 rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
1002 "Unable to Allocate Memory for the Recieve descriptor ring\n");
1003 vfree(rxdr->buffer_info);
1006 /* fix for errata 23, cant cross 64kB boundary */
1007 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
1008 void *olddesc = rxdr->desc;
1009 dma_addr_t olddma = rxdr->dma;
1011 "rxdr align check failed: %u bytes at %p\n",
1012 rxdr->size, rxdr->desc);
1013 /* try again, without freeing the previous */
1014 rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
1015 /* failed allocation, critial failure */
1017 pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1018 goto setup_rx_desc_die;
1021 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
1023 pci_free_consistent(pdev, rxdr->size,
1024 rxdr->desc, rxdr->dma);
1025 pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1027 "Unable to Allocate aligned Memory for the"
1028 " Receive descriptor ring\n");
1029 vfree(rxdr->buffer_info);
1032 /* free old, move on with the new one since its okay */
1033 pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
1036 memset(rxdr->desc, 0, rxdr->size);
1038 rxdr->next_to_clean = 0;
1039 rxdr->next_to_use = 0;
1045 * e1000_setup_rctl - configure the receive control register
1046 * @adapter: Board private structure
1050 e1000_setup_rctl(struct e1000_adapter *adapter)
1054 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1056 rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
1058 rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
1059 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1060 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
1062 if(adapter->hw.tbi_compatibility_on == 1)
1063 rctl |= E1000_RCTL_SBP;
1065 rctl &= ~E1000_RCTL_SBP;
1067 /* Setup buffer sizes */
1068 rctl &= ~(E1000_RCTL_SZ_4096);
1069 rctl |= (E1000_RCTL_BSEX | E1000_RCTL_LPE);
1070 switch (adapter->rx_buffer_len) {
1071 case E1000_RXBUFFER_2048:
1073 rctl |= E1000_RCTL_SZ_2048;
1074 rctl &= ~(E1000_RCTL_BSEX | E1000_RCTL_LPE);
1076 case E1000_RXBUFFER_4096:
1077 rctl |= E1000_RCTL_SZ_4096;
1079 case E1000_RXBUFFER_8192:
1080 rctl |= E1000_RCTL_SZ_8192;
1082 case E1000_RXBUFFER_16384:
1083 rctl |= E1000_RCTL_SZ_16384;
1087 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1091 * e1000_configure_rx - Configure 8254x Receive Unit after Reset
1092 * @adapter: board private structure
1094 * Configure the Rx unit of the MAC after a reset.
1098 e1000_configure_rx(struct e1000_adapter *adapter)
1100 uint64_t rdba = adapter->rx_ring.dma;
1101 uint32_t rdlen = adapter->rx_ring.count * sizeof(struct e1000_rx_desc);
1105 /* disable receives while setting up the descriptors */
1106 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1107 E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
1109 /* set the Receive Delay Timer Register */
1110 E1000_WRITE_REG(&adapter->hw, RDTR, adapter->rx_int_delay);
1112 if(adapter->hw.mac_type >= e1000_82540) {
1113 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
1114 if(adapter->itr > 1)
1115 E1000_WRITE_REG(&adapter->hw, ITR,
1116 1000000000 / (adapter->itr * 256));
1119 /* Setup the Base and Length of the Rx Descriptor Ring */
1120 E1000_WRITE_REG(&adapter->hw, RDBAL, (rdba & 0x00000000ffffffffULL));
1121 E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
1123 E1000_WRITE_REG(&adapter->hw, RDLEN, rdlen);
1125 /* Setup the HW Rx Head and Tail Descriptor Pointers */
1126 E1000_WRITE_REG(&adapter->hw, RDH, 0);
1127 E1000_WRITE_REG(&adapter->hw, RDT, 0);
1129 /* Enable 82543 Receive Checksum Offload for TCP and UDP */
1130 if((adapter->hw.mac_type >= e1000_82543) &&
1131 (adapter->rx_csum == TRUE)) {
1132 rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
1133 rxcsum |= E1000_RXCSUM_TUOFL;
1134 E1000_WRITE_REG(&adapter->hw, RXCSUM, rxcsum);
1137 /* Enable Receives */
1138 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1142 * e1000_free_tx_resources - Free Tx Resources
1143 * @adapter: board private structure
1145 * Free all transmit software resources
1149 e1000_free_tx_resources(struct e1000_adapter *adapter)
1151 struct pci_dev *pdev = adapter->pdev;
1153 e1000_clean_tx_ring(adapter);
1155 vfree(adapter->tx_ring.buffer_info);
1156 adapter->tx_ring.buffer_info = NULL;
1158 pci_free_consistent(pdev, adapter->tx_ring.size,
1159 adapter->tx_ring.desc, adapter->tx_ring.dma);
1161 adapter->tx_ring.desc = NULL;
1165 e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
1166 struct e1000_buffer *buffer_info)
1168 struct pci_dev *pdev = adapter->pdev;
1170 if(buffer_info->dma) {
1171 pci_unmap_page(pdev,
1173 buffer_info->length,
1175 buffer_info->dma = 0;
1177 if(buffer_info->skb) {
1178 dev_kfree_skb_any(buffer_info->skb);
1179 buffer_info->skb = NULL;
1184 * e1000_clean_tx_ring - Free Tx Buffers
1185 * @adapter: board private structure
1189 e1000_clean_tx_ring(struct e1000_adapter *adapter)
1191 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1192 struct e1000_buffer *buffer_info;
1196 /* Free all the Tx ring sk_buffs */
1198 if (likely(adapter->previous_buffer_info.skb != NULL)) {
1199 e1000_unmap_and_free_tx_resource(adapter,
1200 &adapter->previous_buffer_info);
1203 for(i = 0; i < tx_ring->count; i++) {
1204 buffer_info = &tx_ring->buffer_info[i];
1205 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
1208 size = sizeof(struct e1000_buffer) * tx_ring->count;
1209 memset(tx_ring->buffer_info, 0, size);
1211 /* Zero out the descriptor ring */
1213 memset(tx_ring->desc, 0, tx_ring->size);
1215 tx_ring->next_to_use = 0;
1216 tx_ring->next_to_clean = 0;
1218 E1000_WRITE_REG(&adapter->hw, TDH, 0);
1219 E1000_WRITE_REG(&adapter->hw, TDT, 0);
1223 * e1000_free_rx_resources - Free Rx Resources
1224 * @adapter: board private structure
1226 * Free all receive software resources
1230 e1000_free_rx_resources(struct e1000_adapter *adapter)
1232 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1233 struct pci_dev *pdev = adapter->pdev;
1235 e1000_clean_rx_ring(adapter);
1237 vfree(rx_ring->buffer_info);
1238 rx_ring->buffer_info = NULL;
1240 pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);
1242 rx_ring->desc = NULL;
1246 * e1000_clean_rx_ring - Free Rx Buffers
1247 * @adapter: board private structure
1251 e1000_clean_rx_ring(struct e1000_adapter *adapter)
1253 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1254 struct e1000_buffer *buffer_info;
1255 struct pci_dev *pdev = adapter->pdev;
1259 /* Free all the Rx ring sk_buffs */
1261 for(i = 0; i < rx_ring->count; i++) {
1262 buffer_info = &rx_ring->buffer_info[i];
1263 if(buffer_info->skb) {
1265 pci_unmap_single(pdev,
1267 buffer_info->length,
1268 PCI_DMA_FROMDEVICE);
1270 dev_kfree_skb(buffer_info->skb);
1271 buffer_info->skb = NULL;
1275 size = sizeof(struct e1000_buffer) * rx_ring->count;
1276 memset(rx_ring->buffer_info, 0, size);
1278 /* Zero out the descriptor ring */
1280 memset(rx_ring->desc, 0, rx_ring->size);
1282 rx_ring->next_to_clean = 0;
1283 rx_ring->next_to_use = 0;
1285 E1000_WRITE_REG(&adapter->hw, RDH, 0);
1286 E1000_WRITE_REG(&adapter->hw, RDT, 0);
1289 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
1290 * and memory write and invalidate disabled for certain operations
1293 e1000_enter_82542_rst(struct e1000_adapter *adapter)
1295 struct net_device *netdev = adapter->netdev;
1298 e1000_pci_clear_mwi(&adapter->hw);
1300 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1301 rctl |= E1000_RCTL_RST;
1302 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1303 E1000_WRITE_FLUSH(&adapter->hw);
1306 if(netif_running(netdev))
1307 e1000_clean_rx_ring(adapter);
1311 e1000_leave_82542_rst(struct e1000_adapter *adapter)
1313 struct net_device *netdev = adapter->netdev;
1316 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1317 rctl &= ~E1000_RCTL_RST;
1318 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1319 E1000_WRITE_FLUSH(&adapter->hw);
1322 if(adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
1323 e1000_pci_set_mwi(&adapter->hw);
1325 if(netif_running(netdev)) {
1326 e1000_configure_rx(adapter);
1327 e1000_alloc_rx_buffers(adapter);
1332 * e1000_set_mac - Change the Ethernet Address of the NIC
1333 * @netdev: network interface device structure
1334 * @p: pointer to an address structure
1336 * Returns 0 on success, negative on failure
1340 e1000_set_mac(struct net_device *netdev, void *p)
1342 struct e1000_adapter *adapter = netdev->priv;
1343 struct sockaddr *addr = p;
1345 if(!is_valid_ether_addr(addr->sa_data))
1346 return -EADDRNOTAVAIL;
1348 /* 82542 2.0 needs to be in reset to write receive address registers */
1350 if(adapter->hw.mac_type == e1000_82542_rev2_0)
1351 e1000_enter_82542_rst(adapter);
1353 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
1354 memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
1356 e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
1358 if(adapter->hw.mac_type == e1000_82542_rev2_0)
1359 e1000_leave_82542_rst(adapter);
1365 * e1000_set_multi - Multicast and Promiscuous mode set
1366 * @netdev: network interface device structure
1368 * The set_multi entry point is called whenever the multicast address
1369 * list or the network interface flags are updated. This routine is
1370 * responsible for configuring the hardware for proper multicast,
1371 * promiscuous mode, and all-multi behavior.
1375 e1000_set_multi(struct net_device *netdev)
1377 struct e1000_adapter *adapter = netdev->priv;
1378 struct e1000_hw *hw = &adapter->hw;
1379 struct dev_mc_list *mc_ptr;
1381 uint32_t hash_value;
1383 unsigned long flags;
1385 /* Check for Promiscuous and All Multicast modes */
1387 spin_lock_irqsave(&adapter->tx_lock, flags);
1389 rctl = E1000_READ_REG(hw, RCTL);
1391 if(netdev->flags & IFF_PROMISC) {
1392 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1393 } else if(netdev->flags & IFF_ALLMULTI) {
1394 rctl |= E1000_RCTL_MPE;
1395 rctl &= ~E1000_RCTL_UPE;
1397 rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
1400 E1000_WRITE_REG(hw, RCTL, rctl);
1402 /* 82542 2.0 needs to be in reset to write receive address registers */
1404 if(hw->mac_type == e1000_82542_rev2_0)
1405 e1000_enter_82542_rst(adapter);
1407 /* load the first 14 multicast address into the exact filters 1-14
1408 * RAR 0 is used for the station MAC adddress
1409 * if there are not 14 addresses, go ahead and clear the filters
1411 mc_ptr = netdev->mc_list;
1413 for(i = 1; i < E1000_RAR_ENTRIES; i++) {
1415 e1000_rar_set(hw, mc_ptr->dmi_addr, i);
1416 mc_ptr = mc_ptr->next;
1418 E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
1419 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
1423 /* clear the old settings from the multicast hash table */
1425 for(i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
1426 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
1428 /* load any remaining addresses into the hash table */
1430 for(; mc_ptr; mc_ptr = mc_ptr->next) {
1431 hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
1432 e1000_mta_set(hw, hash_value);
1435 if(hw->mac_type == e1000_82542_rev2_0)
1436 e1000_leave_82542_rst(adapter);
1438 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1441 /* Need to wait a few seconds after link up to get diagnostic information from
1445 e1000_update_phy_info(unsigned long data)
1447 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1448 e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
1452 * e1000_82547_tx_fifo_stall - Timer Call-back
1453 * @data: pointer to adapter cast into an unsigned long
1457 e1000_82547_tx_fifo_stall(unsigned long data)
1459 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1460 struct net_device *netdev = adapter->netdev;
1463 if(atomic_read(&adapter->tx_fifo_stall)) {
1464 if((E1000_READ_REG(&adapter->hw, TDT) ==
1465 E1000_READ_REG(&adapter->hw, TDH)) &&
1466 (E1000_READ_REG(&adapter->hw, TDFT) ==
1467 E1000_READ_REG(&adapter->hw, TDFH)) &&
1468 (E1000_READ_REG(&adapter->hw, TDFTS) ==
1469 E1000_READ_REG(&adapter->hw, TDFHS))) {
1470 tctl = E1000_READ_REG(&adapter->hw, TCTL);
1471 E1000_WRITE_REG(&adapter->hw, TCTL,
1472 tctl & ~E1000_TCTL_EN);
1473 E1000_WRITE_REG(&adapter->hw, TDFT,
1474 adapter->tx_head_addr);
1475 E1000_WRITE_REG(&adapter->hw, TDFH,
1476 adapter->tx_head_addr);
1477 E1000_WRITE_REG(&adapter->hw, TDFTS,
1478 adapter->tx_head_addr);
1479 E1000_WRITE_REG(&adapter->hw, TDFHS,
1480 adapter->tx_head_addr);
1481 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1482 E1000_WRITE_FLUSH(&adapter->hw);
1484 adapter->tx_fifo_head = 0;
1485 atomic_set(&adapter->tx_fifo_stall, 0);
1486 netif_wake_queue(netdev);
1488 mod_timer(&adapter->tx_fifo_stall_timer, jiffies + 1);
1494 * e1000_watchdog - Timer Call-back
1495 * @data: pointer to netdev cast into an unsigned long
1499 e1000_watchdog(unsigned long data)
1501 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1502 struct net_device *netdev = adapter->netdev;
1503 struct e1000_desc_ring *txdr = &adapter->tx_ring;
1507 e1000_check_for_link(&adapter->hw);
1509 if((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
1510 !(E1000_READ_REG(&adapter->hw, TXCW) & E1000_TXCW_ANE))
1511 link = !adapter->hw.serdes_link_down;
1513 link = E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU;
1516 if(!netif_carrier_ok(netdev)) {
1517 e1000_get_speed_and_duplex(&adapter->hw,
1518 &adapter->link_speed,
1519 &adapter->link_duplex);
1521 DPRINTK(LINK, INFO, "NIC Link is Up %d Mbps %s\n",
1522 adapter->link_speed,
1523 adapter->link_duplex == FULL_DUPLEX ?
1524 "Full Duplex" : "Half Duplex");
1526 netif_carrier_on(netdev);
1527 netif_wake_queue(netdev);
1528 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1529 adapter->smartspeed = 0;
1532 if(netif_carrier_ok(netdev)) {
1533 adapter->link_speed = 0;
1534 adapter->link_duplex = 0;
1535 DPRINTK(LINK, INFO, "NIC Link is Down\n");
1536 netif_carrier_off(netdev);
1537 netif_stop_queue(netdev);
1538 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1541 e1000_smartspeed(adapter);
1544 e1000_update_stats(adapter);
1546 adapter->hw.tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
1547 adapter->tpt_old = adapter->stats.tpt;
1548 adapter->hw.collision_delta = adapter->stats.colc - adapter->colc_old;
1549 adapter->colc_old = adapter->stats.colc;
1551 adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
1552 adapter->gorcl_old = adapter->stats.gorcl;
1553 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
1554 adapter->gotcl_old = adapter->stats.gotcl;
1556 e1000_update_adaptive(&adapter->hw);
1558 if(!netif_carrier_ok(netdev)) {
1559 if(E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
1560 /* We've lost link, so the controller stops DMA,
1561 * but we've got queued Tx work that's never going
1562 * to get done, so reset controller to flush Tx.
1563 * (Do the reset outside of interrupt context). */
1564 schedule_work(&adapter->tx_timeout_task);
1568 /* Dynamic mode for Interrupt Throttle Rate (ITR) */
1569 if(adapter->hw.mac_type >= e1000_82540 && adapter->itr == 1) {
1570 /* Symmetric Tx/Rx gets a reduced ITR=2000; Total
1571 * asymmetrical Tx or Rx gets ITR=8000; everyone
1572 * else is between 2000-8000. */
1573 uint32_t goc = (adapter->gotcl + adapter->gorcl) / 10000;
1574 uint32_t dif = (adapter->gotcl > adapter->gorcl ?
1575 adapter->gotcl - adapter->gorcl :
1576 adapter->gorcl - adapter->gotcl) / 10000;
1577 uint32_t itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
1578 E1000_WRITE_REG(&adapter->hw, ITR, 1000000000 / (itr * 256));
1581 /* Cause software interrupt to ensure rx ring is cleaned */
1582 E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0);
1584 /* Early detection of hung controller */
1585 i = txdr->next_to_clean;
1586 if(txdr->buffer_info[i].dma &&
1587 time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) &&
1588 !(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF))
1589 netif_stop_queue(netdev);
1591 /* Reset the timer */
1592 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1595 #define E1000_TX_FLAGS_CSUM 0x00000001
1596 #define E1000_TX_FLAGS_VLAN 0x00000002
1597 #define E1000_TX_FLAGS_TSO 0x00000004
1598 #define E1000_TX_FLAGS_VLAN_MASK 0xffff0000
1599 #define E1000_TX_FLAGS_VLAN_SHIFT 16
1601 static inline boolean_t
1602 e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
1605 struct e1000_context_desc *context_desc;
1607 uint32_t cmd_length = 0;
1608 uint16_t ipcse, tucse, mss;
1609 uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
1611 if(skb_shinfo(skb)->tso_size) {
1612 hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
1613 mss = skb_shinfo(skb)->tso_size;
1614 skb->nh.iph->tot_len = 0;
1615 skb->nh.iph->check = 0;
1616 skb->h.th->check = ~csum_tcpudp_magic(skb->nh.iph->saddr,
1621 ipcss = skb->nh.raw - skb->data;
1622 ipcso = (void *)&(skb->nh.iph->check) - (void *)skb->data;
1623 ipcse = skb->h.raw - skb->data - 1;
1624 tucss = skb->h.raw - skb->data;
1625 tucso = (void *)&(skb->h.th->check) - (void *)skb->data;
1628 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
1629 E1000_TXD_CMD_IP | E1000_TXD_CMD_TCP |
1630 (skb->len - (hdr_len)));
1632 i = adapter->tx_ring.next_to_use;
1633 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1635 context_desc->lower_setup.ip_fields.ipcss = ipcss;
1636 context_desc->lower_setup.ip_fields.ipcso = ipcso;
1637 context_desc->lower_setup.ip_fields.ipcse = cpu_to_le16(ipcse);
1638 context_desc->upper_setup.tcp_fields.tucss = tucss;
1639 context_desc->upper_setup.tcp_fields.tucso = tucso;
1640 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
1641 context_desc->tcp_seg_setup.fields.mss = cpu_to_le16(mss);
1642 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
1643 context_desc->cmd_and_length = cpu_to_le32(cmd_length);
1645 if(++i == adapter->tx_ring.count) i = 0;
1646 adapter->tx_ring.next_to_use = i;
1655 static inline boolean_t
1656 e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
1658 struct e1000_context_desc *context_desc;
1662 if(likely(skb->ip_summed == CHECKSUM_HW)) {
1663 css = skb->h.raw - skb->data;
1665 i = adapter->tx_ring.next_to_use;
1666 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1668 context_desc->upper_setup.tcp_fields.tucss = css;
1669 context_desc->upper_setup.tcp_fields.tucso = css + skb->csum;
1670 context_desc->upper_setup.tcp_fields.tucse = 0;
1671 context_desc->tcp_seg_setup.data = 0;
1672 context_desc->cmd_and_length = cpu_to_le32(E1000_TXD_CMD_DEXT);
1674 if(unlikely(++i == adapter->tx_ring.count)) i = 0;
1675 adapter->tx_ring.next_to_use = i;
1683 #define E1000_MAX_TXD_PWR 12
1684 #define E1000_MAX_DATA_PER_TXD (1<<E1000_MAX_TXD_PWR)
1687 e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb,
1688 unsigned int first, unsigned int max_per_txd,
1689 unsigned int nr_frags, unsigned int mss)
1691 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1692 struct e1000_buffer *buffer_info;
1693 unsigned int len = skb->len;
1694 unsigned int offset = 0, size, count = 0, i;
1696 len -= skb->data_len;
1698 i = tx_ring->next_to_use;
1701 buffer_info = &tx_ring->buffer_info[i];
1702 size = min(len, max_per_txd);
1704 /* Workaround for premature desc write-backs
1705 * in TSO mode. Append 4-byte sentinel desc */
1706 if(unlikely(mss && !nr_frags && size == len && size > 8))
1709 /* Workaround for potential 82544 hang in PCI-X. Avoid
1710 * terminating buffers within evenly-aligned dwords. */
1711 if(unlikely(adapter->pcix_82544 &&
1712 !((unsigned long)(skb->data + offset + size - 1) & 4) &&
1716 buffer_info->length = size;
1718 pci_map_single(adapter->pdev,
1722 buffer_info->time_stamp = jiffies;
1727 if(unlikely(++i == tx_ring->count)) i = 0;
1730 for(f = 0; f < nr_frags; f++) {
1731 struct skb_frag_struct *frag;
1733 frag = &skb_shinfo(skb)->frags[f];
1735 offset = frag->page_offset;
1738 buffer_info = &tx_ring->buffer_info[i];
1739 size = min(len, max_per_txd);
1741 /* Workaround for premature desc write-backs
1742 * in TSO mode. Append 4-byte sentinel desc */
1743 if(unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
1746 /* Workaround for potential 82544 hang in PCI-X.
1747 * Avoid terminating buffers within evenly-aligned
1749 if(unlikely(adapter->pcix_82544 &&
1750 !((unsigned long)(frag->page+offset+size-1) & 4) &&
1754 buffer_info->length = size;
1756 pci_map_page(adapter->pdev,
1761 buffer_info->time_stamp = jiffies;
1766 if(unlikely(++i == tx_ring->count)) i = 0;
1770 i = (i == 0) ? tx_ring->count - 1 : i - 1;
1771 tx_ring->buffer_info[i].skb = skb;
1772 tx_ring->buffer_info[first].next_to_watch = i;
1778 e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
1780 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1781 struct e1000_tx_desc *tx_desc = NULL;
1782 struct e1000_buffer *buffer_info;
1783 uint32_t txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
1786 if(likely(tx_flags & E1000_TX_FLAGS_TSO)) {
1787 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
1789 txd_upper |= (E1000_TXD_POPTS_IXSM | E1000_TXD_POPTS_TXSM) << 8;
1792 if(likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
1793 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1794 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
1797 if(unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
1798 txd_lower |= E1000_TXD_CMD_VLE;
1799 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
1802 i = tx_ring->next_to_use;
1805 buffer_info = &tx_ring->buffer_info[i];
1806 tx_desc = E1000_TX_DESC(*tx_ring, i);
1807 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
1808 tx_desc->lower.data =
1809 cpu_to_le32(txd_lower | buffer_info->length);
1810 tx_desc->upper.data = cpu_to_le32(txd_upper);
1811 if(unlikely(++i == tx_ring->count)) i = 0;
1814 tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
1816 /* Force memory writes to complete before letting h/w
1817 * know there are new descriptors to fetch. (Only
1818 * applicable for weak-ordered memory model archs,
1819 * such as IA-64). */
1822 tx_ring->next_to_use = i;
1823 E1000_WRITE_REG(&adapter->hw, TDT, i);
1827 * 82547 workaround to avoid controller hang in half-duplex environment.
1828 * The workaround is to avoid queuing a large packet that would span
1829 * the internal Tx FIFO ring boundary by notifying the stack to resend
1830 * the packet at a later time. This gives the Tx FIFO an opportunity to
1831 * flush all packets. When that occurs, we reset the Tx FIFO pointers
1832 * to the beginning of the Tx FIFO.
1835 #define E1000_FIFO_HDR 0x10
1836 #define E1000_82547_PAD_LEN 0x3E0
1839 e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
1841 uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
1842 uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;
1844 E1000_ROUNDUP(skb_fifo_len, E1000_FIFO_HDR);
1846 if(adapter->link_duplex != HALF_DUPLEX)
1847 goto no_fifo_stall_required;
1849 if(atomic_read(&adapter->tx_fifo_stall))
1852 if(skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
1853 atomic_set(&adapter->tx_fifo_stall, 1);
1857 no_fifo_stall_required:
1858 adapter->tx_fifo_head += skb_fifo_len;
1859 if(adapter->tx_fifo_head >= adapter->tx_fifo_size)
1860 adapter->tx_fifo_head -= adapter->tx_fifo_size;
1864 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
1866 e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1868 struct e1000_adapter *adapter = netdev->priv;
1869 unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
1870 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
1871 unsigned int tx_flags = 0;
1872 unsigned int len = skb->len;
1873 unsigned long flags;
1874 unsigned int nr_frags = 0;
1875 unsigned int mss = 0;
1878 nr_frags = skb_shinfo(skb)->nr_frags;
1879 len -= skb->data_len;
1881 if(unlikely(skb->len <= 0)) {
1882 dev_kfree_skb_any(skb);
1883 return NETDEV_TX_OK;
1887 mss = skb_shinfo(skb)->tso_size;
1888 /* The controller does a simple calculation to
1889 * make sure there is enough room in the FIFO before
1890 * initiating the DMA for each buffer. The calc is:
1891 * 4 = ceil(buffer len/mss). To make sure we don't
1892 * overrun the FIFO, adjust the max buffer len if mss
1895 max_per_txd = min(mss << 2, max_per_txd);
1896 max_txd_pwr = fls(max_per_txd) - 1;
1899 if((mss) || (skb->ip_summed == CHECKSUM_HW))
1901 count++; /* for sentinel desc */
1903 if(skb->ip_summed == CHECKSUM_HW)
1906 count += TXD_USE_COUNT(len, max_txd_pwr);
1908 if(adapter->pcix_82544)
1911 nr_frags = skb_shinfo(skb)->nr_frags;
1912 for(f = 0; f < nr_frags; f++)
1913 count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
1915 if(adapter->pcix_82544)
1918 local_irq_save(flags);
1919 if (!spin_trylock(&adapter->tx_lock)) {
1920 /* Collision - tell upper layer to requeue */
1921 local_irq_restore(flags);
1922 return NETDEV_TX_LOCKED;
1925 /* need: count + 2 desc gap to keep tail from touching
1926 * head, otherwise try next time */
1927 if(E1000_DESC_UNUSED(&adapter->tx_ring) < count + 2) {
1928 netif_stop_queue(netdev);
1929 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1930 return NETDEV_TX_BUSY;
1933 if(unlikely(adapter->hw.mac_type == e1000_82547)) {
1934 if(unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
1935 netif_stop_queue(netdev);
1936 mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
1937 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1938 return NETDEV_TX_BUSY;
1942 if(unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
1943 tx_flags |= E1000_TX_FLAGS_VLAN;
1944 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
1947 first = adapter->tx_ring.next_to_use;
1949 if(likely(e1000_tso(adapter, skb)))
1950 tx_flags |= E1000_TX_FLAGS_TSO;
1951 else if(likely(e1000_tx_csum(adapter, skb)))
1952 tx_flags |= E1000_TX_FLAGS_CSUM;
1954 e1000_tx_queue(adapter,
1955 e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss),
1958 netdev->trans_start = jiffies;
1960 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1961 return NETDEV_TX_OK;
1965 * e1000_tx_timeout - Respond to a Tx Hang
1966 * @netdev: network interface device structure
1970 e1000_tx_timeout(struct net_device *netdev)
1972 struct e1000_adapter *adapter = netdev->priv;
1974 /* Do the reset outside of interrupt context */
1975 schedule_work(&adapter->tx_timeout_task);
1979 e1000_tx_timeout_task(struct net_device *netdev)
1981 struct e1000_adapter *adapter = netdev->priv;
1983 e1000_down(adapter);
1988 * e1000_get_stats - Get System Network Statistics
1989 * @netdev: network interface device structure
1991 * Returns the address of the device statistics structure.
1992 * The statistics are actually updated from the timer callback.
1995 static struct net_device_stats *
1996 e1000_get_stats(struct net_device *netdev)
1998 struct e1000_adapter *adapter = netdev->priv;
2000 e1000_update_stats(adapter);
2001 return &adapter->net_stats;
2005 * e1000_change_mtu - Change the Maximum Transfer Unit
2006 * @netdev: network interface device structure
2007 * @new_mtu: new value for maximum frame size
2009 * Returns 0 on success, negative on failure
2013 e1000_change_mtu(struct net_device *netdev, int new_mtu)
2015 struct e1000_adapter *adapter = netdev->priv;
2016 int old_mtu = adapter->rx_buffer_len;
2017 int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
2019 if((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
2020 (max_frame > MAX_JUMBO_FRAME_SIZE)) {
2021 DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
2025 if(max_frame <= MAXIMUM_ETHERNET_FRAME_SIZE) {
2026 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
2028 } else if(adapter->hw.mac_type < e1000_82543) {
2029 DPRINTK(PROBE, ERR, "Jumbo Frames not supported on 82542\n");
2032 } else if(max_frame <= E1000_RXBUFFER_4096) {
2033 adapter->rx_buffer_len = E1000_RXBUFFER_4096;
2035 } else if(max_frame <= E1000_RXBUFFER_8192) {
2036 adapter->rx_buffer_len = E1000_RXBUFFER_8192;
2039 adapter->rx_buffer_len = E1000_RXBUFFER_16384;
2042 if(old_mtu != adapter->rx_buffer_len && netif_running(netdev)) {
2043 e1000_down(adapter);
2047 netdev->mtu = new_mtu;
2048 adapter->hw.max_frame_size = max_frame;
2054 * e1000_update_stats - Update the board statistics counters
2055 * @adapter: board private structure
2059 e1000_update_stats(struct e1000_adapter *adapter)
2061 struct e1000_hw *hw = &adapter->hw;
2062 unsigned long flags;
2065 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
2067 spin_lock_irqsave(&adapter->stats_lock, flags);
2069 /* these counters are modified from e1000_adjust_tbi_stats,
2070 * called from the interrupt context, so they must only
2071 * be written while holding adapter->stats_lock
2074 adapter->stats.crcerrs += E1000_READ_REG(hw, CRCERRS);
2075 adapter->stats.gprc += E1000_READ_REG(hw, GPRC);
2076 adapter->stats.gorcl += E1000_READ_REG(hw, GORCL);
2077 adapter->stats.gorch += E1000_READ_REG(hw, GORCH);
2078 adapter->stats.bprc += E1000_READ_REG(hw, BPRC);
2079 adapter->stats.mprc += E1000_READ_REG(hw, MPRC);
2080 adapter->stats.roc += E1000_READ_REG(hw, ROC);
2081 adapter->stats.prc64 += E1000_READ_REG(hw, PRC64);
2082 adapter->stats.prc127 += E1000_READ_REG(hw, PRC127);
2083 adapter->stats.prc255 += E1000_READ_REG(hw, PRC255);
2084 adapter->stats.prc511 += E1000_READ_REG(hw, PRC511);
2085 adapter->stats.prc1023 += E1000_READ_REG(hw, PRC1023);
2086 adapter->stats.prc1522 += E1000_READ_REG(hw, PRC1522);
2088 adapter->stats.symerrs += E1000_READ_REG(hw, SYMERRS);
2089 adapter->stats.mpc += E1000_READ_REG(hw, MPC);
2090 adapter->stats.scc += E1000_READ_REG(hw, SCC);
2091 adapter->stats.ecol += E1000_READ_REG(hw, ECOL);
2092 adapter->stats.mcc += E1000_READ_REG(hw, MCC);
2093 adapter->stats.latecol += E1000_READ_REG(hw, LATECOL);
2094 adapter->stats.dc += E1000_READ_REG(hw, DC);
2095 adapter->stats.sec += E1000_READ_REG(hw, SEC);
2096 adapter->stats.rlec += E1000_READ_REG(hw, RLEC);
2097 adapter->stats.xonrxc += E1000_READ_REG(hw, XONRXC);
2098 adapter->stats.xontxc += E1000_READ_REG(hw, XONTXC);
2099 adapter->stats.xoffrxc += E1000_READ_REG(hw, XOFFRXC);
2100 adapter->stats.xofftxc += E1000_READ_REG(hw, XOFFTXC);
2101 adapter->stats.fcruc += E1000_READ_REG(hw, FCRUC);
2102 adapter->stats.gptc += E1000_READ_REG(hw, GPTC);
2103 adapter->stats.gotcl += E1000_READ_REG(hw, GOTCL);
2104 adapter->stats.gotch += E1000_READ_REG(hw, GOTCH);
2105 adapter->stats.rnbc += E1000_READ_REG(hw, RNBC);
2106 adapter->stats.ruc += E1000_READ_REG(hw, RUC);
2107 adapter->stats.rfc += E1000_READ_REG(hw, RFC);
2108 adapter->stats.rjc += E1000_READ_REG(hw, RJC);
2109 adapter->stats.torl += E1000_READ_REG(hw, TORL);
2110 adapter->stats.torh += E1000_READ_REG(hw, TORH);
2111 adapter->stats.totl += E1000_READ_REG(hw, TOTL);
2112 adapter->stats.toth += E1000_READ_REG(hw, TOTH);
2113 adapter->stats.tpr += E1000_READ_REG(hw, TPR);
2114 adapter->stats.ptc64 += E1000_READ_REG(hw, PTC64);
2115 adapter->stats.ptc127 += E1000_READ_REG(hw, PTC127);
2116 adapter->stats.ptc255 += E1000_READ_REG(hw, PTC255);
2117 adapter->stats.ptc511 += E1000_READ_REG(hw, PTC511);
2118 adapter->stats.ptc1023 += E1000_READ_REG(hw, PTC1023);
2119 adapter->stats.ptc1522 += E1000_READ_REG(hw, PTC1522);
2120 adapter->stats.mptc += E1000_READ_REG(hw, MPTC);
2121 adapter->stats.bptc += E1000_READ_REG(hw, BPTC);
2123 /* used for adaptive IFS */
2125 hw->tx_packet_delta = E1000_READ_REG(hw, TPT);
2126 adapter->stats.tpt += hw->tx_packet_delta;
2127 hw->collision_delta = E1000_READ_REG(hw, COLC);
2128 adapter->stats.colc += hw->collision_delta;
2130 if(hw->mac_type >= e1000_82543) {
2131 adapter->stats.algnerrc += E1000_READ_REG(hw, ALGNERRC);
2132 adapter->stats.rxerrc += E1000_READ_REG(hw, RXERRC);
2133 adapter->stats.tncrs += E1000_READ_REG(hw, TNCRS);
2134 adapter->stats.cexterr += E1000_READ_REG(hw, CEXTERR);
2135 adapter->stats.tsctc += E1000_READ_REG(hw, TSCTC);
2136 adapter->stats.tsctfc += E1000_READ_REG(hw, TSCTFC);
2139 /* Fill out the OS statistics structure */
2141 adapter->net_stats.rx_packets = adapter->stats.gprc;
2142 adapter->net_stats.tx_packets = adapter->stats.gptc;
2143 adapter->net_stats.rx_bytes = adapter->stats.gorcl;
2144 adapter->net_stats.tx_bytes = adapter->stats.gotcl;
2145 adapter->net_stats.multicast = adapter->stats.mprc;
2146 adapter->net_stats.collisions = adapter->stats.colc;
2150 adapter->net_stats.rx_errors = adapter->stats.rxerrc +
2151 adapter->stats.crcerrs + adapter->stats.algnerrc +
2152 adapter->stats.rlec + adapter->stats.rnbc +
2153 adapter->stats.mpc + adapter->stats.cexterr;
2154 adapter->net_stats.rx_dropped = adapter->stats.rnbc;
2155 adapter->net_stats.rx_length_errors = adapter->stats.rlec;
2156 adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
2157 adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
2158 adapter->net_stats.rx_fifo_errors = adapter->stats.mpc;
2159 adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
2163 adapter->net_stats.tx_errors = adapter->stats.ecol +
2164 adapter->stats.latecol;
2165 adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
2166 adapter->net_stats.tx_window_errors = adapter->stats.latecol;
2167 adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;
2169 /* Tx Dropped needs to be maintained elsewhere */
2173 if(hw->media_type == e1000_media_type_copper) {
2174 if((adapter->link_speed == SPEED_1000) &&
2175 (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
2176 phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
2177 adapter->phy_stats.idle_errors += phy_tmp;
2180 if((hw->mac_type <= e1000_82546) &&
2181 (hw->phy_type == e1000_phy_m88) &&
2182 !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
2183 adapter->phy_stats.receive_errors += phy_tmp;
2186 spin_unlock_irqrestore(&adapter->stats_lock, flags);
2190 * e1000_irq_disable - Mask off interrupt generation on the NIC
2191 * @adapter: board private structure
2195 e1000_irq_disable(struct e1000_adapter *adapter)
2197 atomic_inc(&adapter->irq_sem);
2198 E1000_WRITE_REG(&adapter->hw, IMC, ~0);
2199 E1000_WRITE_FLUSH(&adapter->hw);
2200 synchronize_irq(adapter->pdev->irq);
2204 * e1000_irq_enable - Enable default interrupt generation settings
2205 * @adapter: board private structure
2209 e1000_irq_enable(struct e1000_adapter *adapter)
2211 if(likely(atomic_dec_and_test(&adapter->irq_sem))) {
2212 E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
2213 E1000_WRITE_FLUSH(&adapter->hw);
2218 * e1000_intr - Interrupt Handler
2219 * @irq: interrupt number
2220 * @data: pointer to a network interface device structure
2221 * @pt_regs: CPU registers structure
2225 e1000_intr(int irq, void *data, struct pt_regs *regs)
2227 struct net_device *netdev = data;
2228 struct e1000_adapter *adapter = netdev->priv;
2229 struct e1000_hw *hw = &adapter->hw;
2230 uint32_t icr = E1000_READ_REG(hw, ICR);
2231 #ifndef CONFIG_E1000_NAPI
2236 return IRQ_NONE; /* Not our interrupt */
2238 if(unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
2239 hw->get_link_status = 1;
2240 mod_timer(&adapter->watchdog_timer, jiffies);
2243 #ifdef CONFIG_E1000_NAPI
2244 if(likely(netif_rx_schedule_prep(netdev))) {
2246 /* Disable interrupts and register for poll. The flush
2247 of the posted write is intentionally left out.
2250 atomic_inc(&adapter->irq_sem);
2251 E1000_WRITE_REG(hw, IMC, ~0);
2252 __netif_rx_schedule(netdev);
2255 for(i = 0; i < E1000_MAX_INTR; i++)
2256 if(unlikely(!e1000_clean_rx_irq(adapter) &
2257 !e1000_clean_tx_irq(adapter)))
2264 #ifdef CONFIG_E1000_NAPI
2266 * e1000_clean - NAPI Rx polling callback
2267 * @adapter: board private structure
2271 e1000_clean(struct net_device *netdev, int *budget)
2273 struct e1000_adapter *adapter = netdev->priv;
2274 int work_to_do = min(*budget, netdev->quota);
2278 tx_cleaned = e1000_clean_tx_irq(adapter);
2279 e1000_clean_rx_irq(adapter, &work_done, work_to_do);
2281 *budget -= work_done;
2282 netdev->quota -= work_done;
2284 /* if no Rx and Tx cleanup work was done, exit the polling mode */
2285 if(!tx_cleaned || (work_done < work_to_do) ||
2286 !netif_running(netdev)) {
2287 netif_rx_complete(netdev);
2288 e1000_irq_enable(adapter);
2292 return (work_done >= work_to_do);
2297 * e1000_clean_tx_irq - Reclaim resources after transmit completes
2298 * @adapter: board private structure
2302 e1000_clean_tx_irq(struct e1000_adapter *adapter)
2304 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
2305 struct net_device *netdev = adapter->netdev;
2306 struct e1000_tx_desc *tx_desc, *eop_desc;
2307 struct e1000_buffer *buffer_info;
2308 unsigned int i, eop;
2309 boolean_t cleaned = FALSE;
2311 i = tx_ring->next_to_clean;
2312 eop = tx_ring->buffer_info[i].next_to_watch;
2313 eop_desc = E1000_TX_DESC(*tx_ring, eop);
2315 while(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
2316 /* pre-mature writeback of Tx descriptors */
2317 /* clear (free buffers and unmap pci_mapping) */
2318 /* previous_buffer_info */
2319 if (likely(adapter->previous_buffer_info.skb != NULL)) {
2320 e1000_unmap_and_free_tx_resource(adapter,
2321 &adapter->previous_buffer_info);
2324 for(cleaned = FALSE; !cleaned; ) {
2325 tx_desc = E1000_TX_DESC(*tx_ring, i);
2326 buffer_info = &tx_ring->buffer_info[i];
2328 cleaned = (i == eop);
2330 /* pre-mature writeback of Tx descriptors */
2331 /* save the cleaning of the this for the */
2332 /* next iteration */
2334 memcpy(&adapter->previous_buffer_info,
2336 sizeof(struct e1000_buffer));
2339 sizeof(struct e1000_buffer));
2341 e1000_unmap_and_free_tx_resource(adapter,
2344 tx_desc->buffer_addr = 0;
2345 tx_desc->lower.data = 0;
2346 tx_desc->upper.data = 0;
2348 cleaned = (i == eop);
2349 if(unlikely(++i == tx_ring->count)) i = 0;
2352 eop = tx_ring->buffer_info[i].next_to_watch;
2353 eop_desc = E1000_TX_DESC(*tx_ring, eop);
2356 tx_ring->next_to_clean = i;
2358 spin_lock(&adapter->tx_lock);
2360 if(unlikely(cleaned && netif_queue_stopped(netdev) &&
2361 netif_carrier_ok(netdev)))
2362 netif_wake_queue(netdev);
2364 spin_unlock(&adapter->tx_lock);
2370 * e1000_clean_rx_irq - Send received data up the network stack
2371 * @adapter: board private structure
2375 #ifdef CONFIG_E1000_NAPI
2376 e1000_clean_rx_irq(struct e1000_adapter *adapter, int *work_done,
2379 e1000_clean_rx_irq(struct e1000_adapter *adapter)
2382 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
2383 struct net_device *netdev = adapter->netdev;
2384 struct pci_dev *pdev = adapter->pdev;
2385 struct e1000_rx_desc *rx_desc;
2386 struct e1000_buffer *buffer_info;
2387 struct sk_buff *skb;
2388 unsigned long flags;
2392 boolean_t cleaned = FALSE;
2394 i = rx_ring->next_to_clean;
2395 rx_desc = E1000_RX_DESC(*rx_ring, i);
2397 while(rx_desc->status & E1000_RXD_STAT_DD) {
2398 buffer_info = &rx_ring->buffer_info[i];
2399 #ifdef CONFIG_E1000_NAPI
2400 if(*work_done >= work_to_do)
2406 pci_unmap_single(pdev,
2408 buffer_info->length,
2409 PCI_DMA_FROMDEVICE);
2411 skb = buffer_info->skb;
2412 length = le16_to_cpu(rx_desc->length);
2414 if(unlikely(!(rx_desc->status & E1000_RXD_STAT_EOP))) {
2415 /* All receives must fit into a single buffer */
2416 E1000_DBG("%s: Receive packet consumed multiple"
2417 " buffers\n", netdev->name);
2418 dev_kfree_skb_irq(skb);
2422 if(unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
2423 last_byte = *(skb->data + length - 1);
2424 if(TBI_ACCEPT(&adapter->hw, rx_desc->status,
2425 rx_desc->errors, length, last_byte)) {
2426 spin_lock_irqsave(&adapter->stats_lock, flags);
2427 e1000_tbi_adjust_stats(&adapter->hw,
2430 spin_unlock_irqrestore(&adapter->stats_lock,
2434 dev_kfree_skb_irq(skb);
2440 skb_put(skb, length - ETHERNET_FCS_SIZE);
2442 /* Receive Checksum Offload */
2443 e1000_rx_checksum(adapter, rx_desc, skb);
2445 skb->protocol = eth_type_trans(skb, netdev);
2446 #ifdef CONFIG_E1000_NAPI
2447 if(unlikely(adapter->vlgrp &&
2448 (rx_desc->status & E1000_RXD_STAT_VP))) {
2449 vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
2450 le16_to_cpu(rx_desc->special &
2451 E1000_RXD_SPC_VLAN_MASK));
2453 netif_receive_skb(skb);
2455 #else /* CONFIG_E1000_NAPI */
2456 if(unlikely(adapter->vlgrp &&
2457 (rx_desc->status & E1000_RXD_STAT_VP))) {
2458 vlan_hwaccel_rx(skb, adapter->vlgrp,
2459 le16_to_cpu(rx_desc->special &
2460 E1000_RXD_SPC_VLAN_MASK));
2464 #endif /* CONFIG_E1000_NAPI */
2465 netdev->last_rx = jiffies;
2468 rx_desc->status = 0;
2469 buffer_info->skb = NULL;
2470 if(unlikely(++i == rx_ring->count)) i = 0;
2472 rx_desc = E1000_RX_DESC(*rx_ring, i);
2475 rx_ring->next_to_clean = i;
2477 e1000_alloc_rx_buffers(adapter);
2483 * e1000_alloc_rx_buffers - Replace used receive buffers
2484 * @adapter: address of board private structure
2488 e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
2490 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
2491 struct net_device *netdev = adapter->netdev;
2492 struct pci_dev *pdev = adapter->pdev;
2493 struct e1000_rx_desc *rx_desc;
2494 struct e1000_buffer *buffer_info;
2495 struct sk_buff *skb;
2496 unsigned int i, bufsz;
2498 i = rx_ring->next_to_use;
2499 buffer_info = &rx_ring->buffer_info[i];
2501 while(!buffer_info->skb) {
2502 bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
2504 skb = dev_alloc_skb(bufsz);
2505 if(unlikely(!skb)) {
2506 /* Better luck next round */
2510 /* fix for errata 23, cant cross 64kB boundary */
2511 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
2512 struct sk_buff *oldskb = skb;
2514 "skb align check failed: %u bytes at %p\n",
2516 /* try again, without freeing the previous */
2517 skb = dev_alloc_skb(bufsz);
2519 dev_kfree_skb(oldskb);
2522 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
2525 dev_kfree_skb(oldskb);
2526 break; /* while !buffer_info->skb */
2528 /* move on with the new one */
2529 dev_kfree_skb(oldskb);
2533 /* Make buffer alignment 2 beyond a 16 byte boundary
2534 * this will result in a 16 byte aligned IP header after
2535 * the 14 byte MAC header is removed
2537 skb_reserve(skb, NET_IP_ALIGN);
2541 buffer_info->skb = skb;
2542 buffer_info->length = adapter->rx_buffer_len;
2543 buffer_info->dma = pci_map_single(pdev,
2545 adapter->rx_buffer_len,
2546 PCI_DMA_FROMDEVICE);
2548 /* fix for errata 23, cant cross 64kB boundary */
2549 if (!e1000_check_64k_bound(adapter, (void *)buffer_info->dma, adapter->rx_buffer_len)) {
2551 "dma align check failed: %u bytes at %ld\n",
2552 adapter->rx_buffer_len, buffer_info->dma);
2555 buffer_info->skb = NULL;
2557 pci_unmap_single(pdev,
2559 adapter->rx_buffer_len,
2560 PCI_DMA_FROMDEVICE);
2562 break; /* while !buffer_info->skb */
2565 rx_desc = E1000_RX_DESC(*rx_ring, i);
2566 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
2568 if(unlikely((i & ~(E1000_RX_BUFFER_WRITE - 1)) == i)) {
2569 /* Force memory writes to complete before letting h/w
2570 * know there are new descriptors to fetch. (Only
2571 * applicable for weak-ordered memory model archs,
2572 * such as IA-64). */
2575 E1000_WRITE_REG(&adapter->hw, RDT, i);
2578 if(unlikely(++i == rx_ring->count)) i = 0;
2579 buffer_info = &rx_ring->buffer_info[i];
2582 rx_ring->next_to_use = i;
2586 * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
2591 e1000_smartspeed(struct e1000_adapter *adapter)
2593 uint16_t phy_status;
2596 if((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
2597 !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
2600 if(adapter->smartspeed == 0) {
2601 /* If Master/Slave config fault is asserted twice,
2602 * we assume back-to-back */
2603 e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
2604 if(!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
2605 e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
2606 if(!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
2607 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
2608 if(phy_ctrl & CR_1000T_MS_ENABLE) {
2609 phy_ctrl &= ~CR_1000T_MS_ENABLE;
2610 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
2612 adapter->smartspeed++;
2613 if(!e1000_phy_setup_autoneg(&adapter->hw) &&
2614 !e1000_read_phy_reg(&adapter->hw, PHY_CTRL,
2616 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
2617 MII_CR_RESTART_AUTO_NEG);
2618 e1000_write_phy_reg(&adapter->hw, PHY_CTRL,
2623 } else if(adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
2624 /* If still no link, perhaps using 2/3 pair cable */
2625 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
2626 phy_ctrl |= CR_1000T_MS_ENABLE;
2627 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_ctrl);
2628 if(!e1000_phy_setup_autoneg(&adapter->hw) &&
2629 !e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_ctrl)) {
2630 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
2631 MII_CR_RESTART_AUTO_NEG);
2632 e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_ctrl);
2635 /* Restart process after E1000_SMARTSPEED_MAX iterations */
2636 if(adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
2637 adapter->smartspeed = 0;
2648 e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
2654 return e1000_mii_ioctl(netdev, ifr, cmd);
2668 e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
2670 struct e1000_adapter *adapter = netdev->priv;
2671 struct mii_ioctl_data *data = if_mii(ifr);
2676 if(adapter->hw.media_type != e1000_media_type_copper)
2681 data->phy_id = adapter->hw.phy_addr;
2684 if (!capable(CAP_NET_ADMIN))
2686 if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
2691 if (!capable(CAP_NET_ADMIN))
2693 if (data->reg_num & ~(0x1F))
2695 mii_reg = data->val_in;
2696 if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
2699 if (adapter->hw.phy_type == e1000_phy_m88) {
2700 switch (data->reg_num) {
2702 if(mii_reg & MII_CR_POWER_DOWN)
2704 if(mii_reg & MII_CR_AUTO_NEG_EN) {
2705 adapter->hw.autoneg = 1;
2706 adapter->hw.autoneg_advertised = 0x2F;
2709 spddplx = SPEED_1000;
2710 else if (mii_reg & 0x2000)
2711 spddplx = SPEED_100;
2714 spddplx += (mii_reg & 0x100)
2717 retval = e1000_set_spd_dplx(adapter,
2722 if(netif_running(adapter->netdev)) {
2723 e1000_down(adapter);
2726 e1000_reset(adapter);
2728 case M88E1000_PHY_SPEC_CTRL:
2729 case M88E1000_EXT_PHY_SPEC_CTRL:
2730 if (e1000_phy_reset(&adapter->hw))
2735 switch (data->reg_num) {
2737 if(mii_reg & MII_CR_POWER_DOWN)
2739 if(netif_running(adapter->netdev)) {
2740 e1000_down(adapter);
2743 e1000_reset(adapter);
2751 return E1000_SUCCESS;
2755 * e1000_rx_checksum - Receive Checksum Offload for 82543
2756 * @adapter: board private structure
2757 * @rx_desc: receive descriptor
2758 * @sk_buff: socket buffer with received data
2762 e1000_rx_checksum(struct e1000_adapter *adapter,
2763 struct e1000_rx_desc *rx_desc,
2764 struct sk_buff *skb)
2766 /* 82543 or newer only */
2767 if(unlikely((adapter->hw.mac_type < e1000_82543) ||
2768 /* Ignore Checksum bit is set */
2769 (rx_desc->status & E1000_RXD_STAT_IXSM) ||
2770 /* TCP Checksum has not been calculated */
2771 (!(rx_desc->status & E1000_RXD_STAT_TCPCS)))) {
2772 skb->ip_summed = CHECKSUM_NONE;
2776 /* At this point we know the hardware did the TCP checksum */
2777 /* now look at the TCP checksum error bit */
2778 if(rx_desc->errors & E1000_RXD_ERR_TCPE) {
2779 /* let the stack verify checksum errors */
2780 skb->ip_summed = CHECKSUM_NONE;
2781 adapter->hw_csum_err++;
2783 /* TCP checksum is good */
2784 skb->ip_summed = CHECKSUM_UNNECESSARY;
2785 adapter->hw_csum_good++;
2790 e1000_pci_set_mwi(struct e1000_hw *hw)
2792 struct e1000_adapter *adapter = hw->back;
2795 ret = pci_set_mwi(adapter->pdev);
2799 e1000_pci_clear_mwi(struct e1000_hw *hw)
2801 struct e1000_adapter *adapter = hw->back;
2803 pci_clear_mwi(adapter->pdev);
2807 e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2809 struct e1000_adapter *adapter = hw->back;
2811 pci_read_config_word(adapter->pdev, reg, value);
2815 e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2817 struct e1000_adapter *adapter = hw->back;
2819 pci_write_config_word(adapter->pdev, reg, *value);
2823 e1000_io_read(struct e1000_hw *hw, unsigned long port)
2829 e1000_io_write(struct e1000_hw *hw, unsigned long port, uint32_t value)
2835 e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
2837 struct e1000_adapter *adapter = netdev->priv;
2838 uint32_t ctrl, rctl;
2840 e1000_irq_disable(adapter);
2841 adapter->vlgrp = grp;
2844 /* enable VLAN tag insert/strip */
2845 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2846 ctrl |= E1000_CTRL_VME;
2847 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2849 /* enable VLAN receive filtering */
2850 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2851 rctl |= E1000_RCTL_VFE;
2852 rctl &= ~E1000_RCTL_CFIEN;
2853 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2855 /* disable VLAN tag insert/strip */
2856 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2857 ctrl &= ~E1000_CTRL_VME;
2858 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2860 /* disable VLAN filtering */
2861 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2862 rctl &= ~E1000_RCTL_VFE;
2863 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2866 e1000_irq_enable(adapter);
2870 e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
2872 struct e1000_adapter *adapter = netdev->priv;
2873 uint32_t vfta, index;
2875 /* add VID to filter table */
2876 index = (vid >> 5) & 0x7F;
2877 vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2878 vfta |= (1 << (vid & 0x1F));
2879 e1000_write_vfta(&adapter->hw, index, vfta);
2883 e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
2885 struct e1000_adapter *adapter = netdev->priv;
2886 uint32_t vfta, index;
2888 e1000_irq_disable(adapter);
2891 adapter->vlgrp->vlan_devices[vid] = NULL;
2893 e1000_irq_enable(adapter);
2895 /* remove VID from filter table */
2896 index = (vid >> 5) & 0x7F;
2897 vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2898 vfta &= ~(1 << (vid & 0x1F));
2899 e1000_write_vfta(&adapter->hw, index, vfta);
2903 e1000_restore_vlan(struct e1000_adapter *adapter)
2905 e1000_vlan_rx_register(adapter->netdev, adapter->vlgrp);
2907 if(adapter->vlgrp) {
2909 for(vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
2910 if(!adapter->vlgrp->vlan_devices[vid])
2912 e1000_vlan_rx_add_vid(adapter->netdev, vid);
2918 e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
2920 adapter->hw.autoneg = 0;
2923 case SPEED_10 + DUPLEX_HALF:
2924 adapter->hw.forced_speed_duplex = e1000_10_half;
2926 case SPEED_10 + DUPLEX_FULL:
2927 adapter->hw.forced_speed_duplex = e1000_10_full;
2929 case SPEED_100 + DUPLEX_HALF:
2930 adapter->hw.forced_speed_duplex = e1000_100_half;
2932 case SPEED_100 + DUPLEX_FULL:
2933 adapter->hw.forced_speed_duplex = e1000_100_full;
2935 case SPEED_1000 + DUPLEX_FULL:
2936 adapter->hw.autoneg = 1;
2937 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
2939 case SPEED_1000 + DUPLEX_HALF: /* not supported */
2942 "Unsupported Speed/Duplexity configuration\n");
2949 e1000_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
2951 struct pci_dev *pdev = NULL;
2957 while((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev))) {
2958 if(pci_dev_driver(pdev) == &e1000_driver)
2959 e1000_suspend(pdev, 3);
2966 e1000_suspend(struct pci_dev *pdev, uint32_t state)
2968 struct net_device *netdev = pci_get_drvdata(pdev);
2969 struct e1000_adapter *adapter = netdev->priv;
2970 uint32_t ctrl, ctrl_ext, rctl, manc, status;
2971 uint32_t wufc = adapter->wol;
2973 netif_device_detach(netdev);
2975 if(netif_running(netdev))
2976 e1000_down(adapter);
2978 status = E1000_READ_REG(&adapter->hw, STATUS);
2979 if(status & E1000_STATUS_LU)
2980 wufc &= ~E1000_WUFC_LNKC;
2983 e1000_setup_rctl(adapter);
2984 e1000_set_multi(netdev);
2986 /* turn on all-multi mode if wake on multicast is enabled */
2987 if(adapter->wol & E1000_WUFC_MC) {
2988 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2989 rctl |= E1000_RCTL_MPE;
2990 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2993 if(adapter->hw.mac_type >= e1000_82540) {
2994 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2995 /* advertise wake from D3Cold */
2996 #define E1000_CTRL_ADVD3WUC 0x00100000
2997 /* phy power management enable */
2998 #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
2999 ctrl |= E1000_CTRL_ADVD3WUC |
3000 E1000_CTRL_EN_PHY_PWR_MGMT;
3001 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
3004 if(adapter->hw.media_type == e1000_media_type_fiber ||
3005 adapter->hw.media_type == e1000_media_type_internal_serdes) {
3006 /* keep the laser running in D3 */
3007 ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
3008 ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
3009 E1000_WRITE_REG(&adapter->hw, CTRL_EXT, ctrl_ext);
3012 E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
3013 E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
3014 pci_enable_wake(pdev, 3, 1);
3015 pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
3017 E1000_WRITE_REG(&adapter->hw, WUC, 0);
3018 E1000_WRITE_REG(&adapter->hw, WUFC, 0);
3019 pci_enable_wake(pdev, 3, 0);
3020 pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
3023 pci_save_state(pdev, adapter->pci_state);
3025 if(adapter->hw.mac_type >= e1000_82540 &&
3026 adapter->hw.media_type == e1000_media_type_copper) {
3027 manc = E1000_READ_REG(&adapter->hw, MANC);
3028 if(manc & E1000_MANC_SMBUS_EN) {
3029 manc |= E1000_MANC_ARP_EN;
3030 E1000_WRITE_REG(&adapter->hw, MANC, manc);
3031 pci_enable_wake(pdev, 3, 1);
3032 pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
3036 pci_disable_device(pdev);
3038 state = (state > 0) ? 3 : 0;
3039 pci_set_power_state(pdev, state);
3046 e1000_resume(struct pci_dev *pdev)
3048 struct net_device *netdev = pci_get_drvdata(pdev);
3049 struct e1000_adapter *adapter = netdev->priv;
3052 pci_enable_device(pdev);
3053 pci_set_power_state(pdev, 0);
3054 pci_restore_state(pdev, adapter->pci_state);
3056 pci_enable_wake(pdev, 3, 0);
3057 pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
3059 e1000_reset(adapter);
3060 E1000_WRITE_REG(&adapter->hw, WUS, ~0);
3062 if(netif_running(netdev))
3065 netif_device_attach(netdev);
3067 if(adapter->hw.mac_type >= e1000_82540 &&
3068 adapter->hw.media_type == e1000_media_type_copper) {
3069 manc = E1000_READ_REG(&adapter->hw, MANC);
3070 manc &= ~(E1000_MANC_ARP_EN);
3071 E1000_WRITE_REG(&adapter->hw, MANC, manc);
3078 #ifdef CONFIG_NET_POLL_CONTROLLER
3080 * Polling 'interrupt' - used by things like netconsole to send skbs
3081 * without having to re-enable interrupts. It's not called while
3082 * the interrupt routine is executing.
3085 e1000_netpoll (struct net_device *netdev)
3087 struct e1000_adapter *adapter = netdev->priv;
3088 disable_irq(adapter->pdev->irq);
3089 e1000_intr(adapter->pdev->irq, netdev, NULL);
3090 enable_irq(adapter->pdev->irq);