drivers/net/e1000/e1000_main.c

   1 /*******************************************************************************
   2
   3
   4   Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
   5
   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)
   9   any later version.
  10
  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
  14   more details.
  15
  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.
  19
  20   The full GNU General Public License is included in this distribution in the
  21   file called LICENSE.
  22
  23   Contact Information:
  24   Linux NICS <linux.nics@intel.com>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28
  29 #include "e1000.h"
  30
  31 /* Change Log
  32  * 5.3.12       6/7/04
  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>
  37  *
  38  * 5.3.11       6/4/04
  39  * - ethtool register dump reads MANC register conditionally.
  40  *
  41  * 5.3.10       6/1/04
  42  */
  43
  44 char e1000_driver_name[] = "e1000";
  45 char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
  46 #ifndef CONFIG_E1000_NAPI
  47 #define DRIVERNAPI
  48 #else
  49 #define DRIVERNAPI "-NAPI"
  50 #endif
  51 char e1000_driver_version[] = "5.3.19-k2"DRIVERNAPI;
  52 char e1000_copyright[] = "Copyright (c) 1999-2004 Intel Corporation.";
  53
  54 /* e1000_pci_tbl - PCI Device ID Table
  55  *
  56  * Last entry must be all 0s
  57  *
  58  * Macro expands to...
  59  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
  60  */
  61 static struct pci_device_id e1000_pci_tbl[] = {
  62         INTEL_E1000_ETHERNET_DEVICE(0x1000),
  63         INTEL_E1000_ETHERNET_DEVICE(0x1001),
  64         INTEL_E1000_ETHERNET_DEVICE(0x1004),
  65         INTEL_E1000_ETHERNET_DEVICE(0x1008),
  66         INTEL_E1000_ETHERNET_DEVICE(0x1009),
  67         INTEL_E1000_ETHERNET_DEVICE(0x100C),
  68         INTEL_E1000_ETHERNET_DEVICE(0x100D),
  69         INTEL_E1000_ETHERNET_DEVICE(0x100E),
  70         INTEL_E1000_ETHERNET_DEVICE(0x100F),
  71         INTEL_E1000_ETHERNET_DEVICE(0x1010),
  72         INTEL_E1000_ETHERNET_DEVICE(0x1011),
  73         INTEL_E1000_ETHERNET_DEVICE(0x1012),
  74         INTEL_E1000_ETHERNET_DEVICE(0x1013),
  75         INTEL_E1000_ETHERNET_DEVICE(0x1015),
  76         INTEL_E1000_ETHERNET_DEVICE(0x1016),
  77         INTEL_E1000_ETHERNET_DEVICE(0x1017),
  78         INTEL_E1000_ETHERNET_DEVICE(0x1018),
  79         INTEL_E1000_ETHERNET_DEVICE(0x1019),
  80         INTEL_E1000_ETHERNET_DEVICE(0x101D),
  81         INTEL_E1000_ETHERNET_DEVICE(0x101E),
  82         INTEL_E1000_ETHERNET_DEVICE(0x1026),
  83         INTEL_E1000_ETHERNET_DEVICE(0x1027),
  84         INTEL_E1000_ETHERNET_DEVICE(0x1028),
  85         INTEL_E1000_ETHERNET_DEVICE(0x1075),
  86         INTEL_E1000_ETHERNET_DEVICE(0x1076),
  87         INTEL_E1000_ETHERNET_DEVICE(0x1077),
  88         INTEL_E1000_ETHERNET_DEVICE(0x1078),
  89         INTEL_E1000_ETHERNET_DEVICE(0x1079),
  90         INTEL_E1000_ETHERNET_DEVICE(0x107A),
  91         INTEL_E1000_ETHERNET_DEVICE(0x107B),
  92         INTEL_E1000_ETHERNET_DEVICE(0x107C),
  93         /* required last entry */
  94         {0,}
  95 };
  96
  97 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
  98
  99 int e1000_up(struct e1000_adapter *adapter);
 100 void e1000_down(struct e1000_adapter *adapter);
 101 void e1000_reset(struct e1000_adapter *adapter);
 102 int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
 103 int e1000_setup_tx_resources(struct e1000_adapter *adapter);
 104 int e1000_setup_rx_resources(struct e1000_adapter *adapter);
 105 void e1000_free_tx_resources(struct e1000_adapter *adapter);
 106 void e1000_free_rx_resources(struct e1000_adapter *adapter);
 107 void e1000_update_stats(struct e1000_adapter *adapter);
 108
 109 /* Local Function Prototypes */
 110
 111 static int e1000_init_module(void);
 112 static void e1000_exit_module(void);
 113 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 114 static void __devexit e1000_remove(struct pci_dev *pdev);
 115 static int e1000_sw_init(struct e1000_adapter *adapter);
 116 static int e1000_open(struct net_device *netdev);
 117 static int e1000_close(struct net_device *netdev);
 118 static void e1000_configure_tx(struct e1000_adapter *adapter);
 119 static void e1000_configure_rx(struct e1000_adapter *adapter);
 120 static void e1000_setup_rctl(struct e1000_adapter *adapter);
 121 static void e1000_clean_tx_ring(struct e1000_adapter *adapter);
 122 static void e1000_clean_rx_ring(struct e1000_adapter *adapter);
 123 static void e1000_set_multi(struct net_device *netdev);
 124 static void e1000_update_phy_info(unsigned long data);
 125 static void e1000_watchdog(unsigned long data);
 126 static void e1000_82547_tx_fifo_stall(unsigned long data);
 127 static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
 128 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
 129 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
 130 static int e1000_set_mac(struct net_device *netdev, void *p);
 131 static void e1000_irq_disable(struct e1000_adapter *adapter);
 132 static void e1000_irq_enable(struct e1000_adapter *adapter);
 133 static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
 134 static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter);
 135 #ifdef CONFIG_E1000_NAPI
 136 static int e1000_clean(struct net_device *netdev, int *budget);
 137 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
 138                                     int *work_done, int work_to_do);
 139 #else
 140 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter);
 141 #endif
 142 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);
 143 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
 144 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
 145                            int cmd);
 146 void set_ethtool_ops(struct net_device *netdev);
 147 static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
 148 static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
 149 static void e1000_rx_checksum(struct e1000_adapter *adapter,
 150                                 struct e1000_rx_desc *rx_desc,
 151                                 struct sk_buff *skb);
 152 static void e1000_tx_timeout(struct net_device *dev);
 153 static void e1000_tx_timeout_task(struct net_device *dev);
 154 static void e1000_smartspeed(struct e1000_adapter *adapter);
 155 static inline int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
 156                                               struct sk_buff *skb);
 157
 158 static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
 159 static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
 160 static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
 161 static void e1000_restore_vlan(struct e1000_adapter *adapter);
 162
 163 static int e1000_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
 164 static int e1000_suspend(struct pci_dev *pdev, uint32_t state);
 165 #ifdef CONFIG_PM
 166 static int e1000_resume(struct pci_dev *pdev);
 167 #endif
 168
 169 #ifdef CONFIG_NET_POLL_CONTROLLER
 170 /* for netdump / net console */
 171 static void e1000_netpoll (struct net_device *netdev);
 172 #endif
 173
 174 struct notifier_block e1000_notifier_reboot = {
 175         .notifier_call  = e1000_notify_reboot,
 176         .next           = NULL,
 177         .priority       = 0
 178 };
 179
 180 /* Exported from other modules */
 181
 182 extern void e1000_check_options(struct e1000_adapter *adapter);
 183
 184 static struct pci_driver e1000_driver = {
 185         .name     = e1000_driver_name,
 186         .id_table = e1000_pci_tbl,
 187         .probe    = e1000_probe,
 188         .remove   = __devexit_p(e1000_remove),
 189         /* Power Managment Hooks */
 190 #ifdef CONFIG_PM
 191         .suspend  = e1000_suspend,
 192         .resume   = e1000_resume
 193 #endif
 194 };
 195
 196 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
 197 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
 198 MODULE_LICENSE("GPL");
 199
 200 static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
 201 module_param(debug, int, 0);
 202 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 203
 204 /**
 205  * e1000_init_module - Driver Registration Routine
 206  *
 207  * e1000_init_module is the first routine called when the driver is
 208  * loaded. All it does is register with the PCI subsystem.
 209  **/
 210
 211 static int __init
 212 e1000_init_module(void)
 213 {
 214         int ret;
 215         printk(KERN_INFO "%s - version %s\n",
 216                e1000_driver_string, e1000_driver_version);
 217
 218         printk(KERN_INFO "%s\n", e1000_copyright);
 219
 220         ret = pci_module_init(&e1000_driver);
 221         if(ret >= 0) {
 222                 register_reboot_notifier(&e1000_notifier_reboot);
 223         }
 224         return ret;
 225 }
 226
 227 module_init(e1000_init_module);
 228
 229 /**
 230  * e1000_exit_module - Driver Exit Cleanup Routine
 231  *
 232  * e1000_exit_module is called just before the driver is removed
 233  * from memory.
 234  **/
 235
 236 static void __exit
 237 e1000_exit_module(void)
 238 {
 239         unregister_reboot_notifier(&e1000_notifier_reboot);
 240         pci_unregister_driver(&e1000_driver);
 241 }
 242
 243 module_exit(e1000_exit_module);
 244
 245
 246 int
 247 e1000_up(struct e1000_adapter *adapter)
 248 {
 249         struct net_device *netdev = adapter->netdev;
 250         int err;
 251
 252         /* hardware has been reset, we need to reload some things */
 253
 254         /* Reset the PHY if it was previously powered down */
 255         if(adapter->hw.media_type == e1000_media_type_copper) {
 256                 uint16_t mii_reg;
 257                 e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
 258                 if(mii_reg & MII_CR_POWER_DOWN)
 259                         e1000_phy_reset(&adapter->hw);
 260         }
 261
 262         e1000_set_multi(netdev);
 263
 264         e1000_restore_vlan(adapter);
 265
 266         e1000_configure_tx(adapter);
 267         e1000_setup_rctl(adapter);
 268         e1000_configure_rx(adapter);
 269         e1000_alloc_rx_buffers(adapter);
 270
 271         if((err = request_irq(adapter->pdev->irq, &e1000_intr,
 272                               SA_SHIRQ | SA_SAMPLE_RANDOM,
 273                               netdev->name, netdev)))
 274                 return err;
 275
 276         mod_timer(&adapter->watchdog_timer, jiffies);
 277         e1000_irq_enable(adapter);
 278
 279         return 0;
 280 }
 281
 282 void
 283 e1000_down(struct e1000_adapter *adapter)
 284 {
 285         struct net_device *netdev = adapter->netdev;
 286
 287         e1000_irq_disable(adapter);
 288         free_irq(adapter->pdev->irq, netdev);
 289         del_timer_sync(&adapter->tx_fifo_stall_timer);
 290         del_timer_sync(&adapter->watchdog_timer);
 291         del_timer_sync(&adapter->phy_info_timer);
 292         adapter->link_speed = 0;
 293         adapter->link_duplex = 0;
 294         netif_carrier_off(netdev);
 295         netif_stop_queue(netdev);
 296
 297         e1000_reset(adapter);
 298         e1000_clean_tx_ring(adapter);
 299         e1000_clean_rx_ring(adapter);
 300
 301         /* If WoL is not enabled
 302          * Power down the PHY so no link is implied when interface is down */
 303         if(!adapter->wol && adapter->hw.media_type == e1000_media_type_copper) {
 304                 uint16_t mii_reg;
 305                 e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
 306                 mii_reg |= MII_CR_POWER_DOWN;
 307                 e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);
 308         }
 309 }
 310
 311 void
 312 e1000_reset(struct e1000_adapter *adapter)
 313 {
 314         uint32_t pba, manc;
 315         /* Repartition Pba for greater than 9k mtu
 316          * To take effect CTRL.RST is required.
 317          */
 318
 319         if(adapter->hw.mac_type < e1000_82547) {
 320                 if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
 321                         pba = E1000_PBA_40K;
 322                 else
 323                         pba = E1000_PBA_48K;
 324         } else {
 325                 if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
 326                         pba = E1000_PBA_22K;
 327                 else
 328                         pba = E1000_PBA_30K;
 329                 adapter->tx_fifo_head = 0;
 330                 adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
 331                 adapter->tx_fifo_size =
 332                         (E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
 333                 atomic_set(&adapter->tx_fifo_stall, 0);
 334         }
 335         E1000_WRITE_REG(&adapter->hw, PBA, pba);
 336
 337         /* flow control settings */
 338         adapter->hw.fc_high_water = (pba << E1000_PBA_BYTES_SHIFT) -
 339                                     E1000_FC_HIGH_DIFF;
 340         adapter->hw.fc_low_water = (pba << E1000_PBA_BYTES_SHIFT) -
 341                                    E1000_FC_LOW_DIFF;
 342         adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
 343         adapter->hw.fc_send_xon = 1;
 344         adapter->hw.fc = adapter->hw.original_fc;
 345
 346         e1000_reset_hw(&adapter->hw);
 347         if(adapter->hw.mac_type >= e1000_82544)
 348                 E1000_WRITE_REG(&adapter->hw, WUC, 0);
 349         if(e1000_init_hw(&adapter->hw))
 350                 DPRINTK(PROBE, ERR, "Hardware Error\n");
 351
 352         /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
 353         E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);
 354
 355         e1000_reset_adaptive(&adapter->hw);
 356         e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
 357
 358         if(adapter->en_mng_pt) {
 359                 manc = E1000_READ_REG(&adapter->hw, MANC);
 360                 manc |= (E1000_MANC_ARP_EN | E1000_MANC_EN_MNG2HOST);
 361                 E1000_WRITE_REG(&adapter->hw, MANC, manc);
 362         }
 363 }
 364
 365 /**
 366  * e1000_probe - Device Initialization Routine
 367  * @pdev: PCI device information struct
 368  * @ent: entry in e1000_pci_tbl
 369  *
 370  * Returns 0 on success, negative on failure
 371  *
 372  * e1000_probe initializes an adapter identified by a pci_dev structure.
 373  * The OS initialization, configuring of the adapter private structure,
 374  * and a hardware reset occur.
 375  **/
 376
 377 static int __devinit
 378 e1000_probe(struct pci_dev *pdev,
 379             const struct pci_device_id *ent)
 380 {
 381         struct net_device *netdev;
 382         struct e1000_adapter *adapter;
 383         static int cards_found = 0;
 384         unsigned long mmio_start;
 385         int mmio_len;
 386         int pci_using_dac;
 387         int i;
 388         int err;
 389         uint16_t eeprom_data;
 390
 391         if((err = pci_enable_device(pdev)))
 392                 return err;
 393
 394         if(!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
 395                 pci_using_dac = 1;
 396         } else {
 397                 if((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
 398                         E1000_ERR("No usable DMA configuration, aborting\n");
 399                         return err;
 400                 }
 401                 pci_using_dac = 0;
 402         }
 403
 404         if((err = pci_request_regions(pdev, e1000_driver_name)))
 405                 return err;
 406
 407         pci_set_master(pdev);
 408
 409         netdev = alloc_etherdev(sizeof(struct e1000_adapter));
 410         if(!netdev) {
 411                 err = -ENOMEM;
 412                 goto err_alloc_etherdev;
 413         }
 414
 415         SET_MODULE_OWNER(netdev);
 416         SET_NETDEV_DEV(netdev, &pdev->dev);
 417
 418         pci_set_drvdata(pdev, netdev);
 419         adapter = netdev->priv;
 420         adapter->netdev = netdev;
 421         adapter->pdev = pdev;
 422         adapter->hw.back = adapter;
 423         adapter->msg_enable = (1 << debug) - 1;
 424
 425         rtnl_lock();
 426         /* we need to set the name early for the DPRINTK macro */
 427         if(dev_alloc_name(netdev, netdev->name) < 0)
 428                 goto err_free_unlock;
 429
 430         mmio_start = pci_resource_start(pdev, BAR_0);
 431         mmio_len = pci_resource_len(pdev, BAR_0);
 432
 433         adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
 434         if(!adapter->hw.hw_addr) {
 435                 err = -EIO;
 436                 goto err_ioremap;
 437         }
 438
 439         for(i = BAR_1; i <= BAR_5; i++) {
 440                 if(pci_resource_len(pdev, i) == 0)
 441                         continue;
 442                 if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {
 443                         adapter->hw.io_base = pci_resource_start(pdev, i);
 444                         break;
 445                 }
 446         }
 447
 448         netdev->open = &e1000_open;
 449         netdev->stop = &e1000_close;
 450         netdev->hard_start_xmit = &e1000_xmit_frame;
 451         netdev->get_stats = &e1000_get_stats;
 452         netdev->set_multicast_list = &e1000_set_multi;
 453         netdev->set_mac_address = &e1000_set_mac;
 454         netdev->change_mtu = &e1000_change_mtu;
 455         netdev->do_ioctl = &e1000_ioctl;
 456         set_ethtool_ops(netdev);
 457         netdev->tx_timeout = &e1000_tx_timeout;
 458         netdev->watchdog_timeo = 5 * HZ;
 459 #ifdef CONFIG_E1000_NAPI
 460         netdev->poll = &e1000_clean;
 461         netdev->weight = 64;
 462 #endif
 463         netdev->vlan_rx_register = e1000_vlan_rx_register;
 464         netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
 465         netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
 466 #ifdef CONFIG_NET_POLL_CONTROLLER
 467         netdev->poll_controller = e1000_netpoll;
 468 #endif
 469
 470         netdev->mem_start = mmio_start;
 471         netdev->mem_end = mmio_start + mmio_len;
 472         netdev->base_addr = adapter->hw.io_base;
 473
 474         adapter->bd_number = cards_found;
 475
 476         /* setup the private structure */
 477
 478         if((err = e1000_sw_init(adapter)))
 479                 goto err_sw_init;
 480
 481         if(adapter->hw.mac_type >= e1000_82543) {
 482                 netdev->features = NETIF_F_SG |
 483                                    NETIF_F_HW_CSUM |
 484                                    NETIF_F_HW_VLAN_TX |
 485                                    NETIF_F_HW_VLAN_RX |
 486                                    NETIF_F_HW_VLAN_FILTER;
 487         } else {
 488                 netdev->features = NETIF_F_SG;
 489         }
 490
 491 #ifdef NETIF_F_TSO
 492         /* Disbaled for now until root-cause is found for
 493          * hangs reported against non-IA archs.  TSO can be
 494          * enabled using ethtool -K eth<x> tso on */
 495         if((adapter->hw.mac_type >= e1000_82544) &&
 496            (adapter->hw.mac_type != e1000_82547))
 497                 netdev->features |= NETIF_F_TSO;
 498 #endif
 499         if(pci_using_dac)
 500                 netdev->features |= NETIF_F_HIGHDMA;
 501
 502         /* hard_start_xmit is safe against parallel locking */
 503         netdev->features |= NETIF_F_LLTX;
 504
 505         adapter->en_mng_pt = e1000_enable_mng_pass_thru(&adapter->hw);
 506
 507         /* before reading the EEPROM, reset the controller to
 508          * put the device in a known good starting state */
 509
 510         e1000_reset_hw(&adapter->hw);
 511
 512         /* make sure the EEPROM is good */
 513
 514         if(e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
 515                 DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
 516                 err = -EIO;
 517                 goto err_eeprom;
 518         }
 519
 520         /* copy the MAC address out of the EEPROM */
 521
 522         if (e1000_read_mac_addr(&adapter->hw))
 523                 DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
 524         memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
 525
 526         if(!is_valid_ether_addr(netdev->dev_addr)) {
 527                 DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
 528                 err = -EIO;
 529                 goto err_eeprom;
 530         }
 531
 532         e1000_read_part_num(&adapter->hw, &(adapter->part_num));
 533
 534         e1000_get_bus_info(&adapter->hw);
 535
 536         init_timer(&adapter->tx_fifo_stall_timer);
 537         adapter->tx_fifo_stall_timer.function = &e1000_82547_tx_fifo_stall;
 538         adapter->tx_fifo_stall_timer.data = (unsigned long) adapter;
 539
 540         init_timer(&adapter->watchdog_timer);
 541         adapter->watchdog_timer.function = &e1000_watchdog;
 542         adapter->watchdog_timer.data = (unsigned long) adapter;
 543
 544         init_timer(&adapter->phy_info_timer);
 545         adapter->phy_info_timer.function = &e1000_update_phy_info;
 546         adapter->phy_info_timer.data = (unsigned long) adapter;
 547
 548         INIT_WORK(&adapter->tx_timeout_task,
 549                 (void (*)(void *))e1000_tx_timeout_task, netdev);
 550
 551         /* we're going to reset, so assume we have no link for now */
 552
 553         netif_carrier_off(netdev);
 554         netif_stop_queue(netdev);
 555
 556         DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");
 557         e1000_check_options(adapter);
 558
 559         /* Initial Wake on LAN setting
 560          * If APM wake is enabled in the EEPROM,
 561          * enable the ACPI Magic Packet filter
 562          */
 563
 564         switch(adapter->hw.mac_type) {
 565         case e1000_82542_rev2_0:
 566         case e1000_82542_rev2_1:
 567         case e1000_82543:
 568                 break;
 569         case e1000_82546:
 570         case e1000_82546_rev_3:
 571                 if((E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1)
 572                    && (adapter->hw.media_type == e1000_media_type_copper)) {
 573                         e1000_read_eeprom(&adapter->hw,
 574                                 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
 575                         break;
 576                 }
 577                 /* Fall Through */
 578         default:
 579                 e1000_read_eeprom(&adapter->hw,
 580                         EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
 581                 break;
 582         }
 583         if(eeprom_data & E1000_EEPROM_APME)
 584                 adapter->wol |= E1000_WUFC_MAG;
 585
 586         /* reset the hardware with the new settings */
 587         e1000_reset(adapter);
 588
 589         /* We're already holding the rtnl lock; call the no-lock version */
 590         if((err = register_netdevice(netdev)))
 591                 goto err_register;
 592
 593         cards_found++;
 594         rtnl_unlock();
 595         return 0;
 596
 597 err_register:
 598 err_sw_init:
 599 err_eeprom:
 600         iounmap(adapter->hw.hw_addr);
 601 err_ioremap:
 602 err_free_unlock:
 603         rtnl_unlock();
 604         free_netdev(netdev);
 605 err_alloc_etherdev:
 606         pci_release_regions(pdev);
 607         return err;
 608 }
 609
 610 /**
 611  * e1000_remove - Device Removal Routine
 612  * @pdev: PCI device information struct
 613  *
 614  * e1000_remove is called by the PCI subsystem to alert the driver
 615  * that it should release a PCI device.  The could be caused by a
 616  * Hot-Plug event, or because the driver is going to be removed from
 617  * memory.
 618  **/
 619
 620 static void __devexit
 621 e1000_remove(struct pci_dev *pdev)
 622 {
 623         struct net_device *netdev = pci_get_drvdata(pdev);
 624         struct e1000_adapter *adapter = netdev->priv;
 625         uint32_t manc;
 626
 627         if(adapter->hw.mac_type >= e1000_82540 &&
 628            adapter->hw.media_type == e1000_media_type_copper) {
 629                 manc = E1000_READ_REG(&adapter->hw, MANC);
 630                 if(manc & E1000_MANC_SMBUS_EN) {
 631                         manc |= E1000_MANC_ARP_EN;
 632                         E1000_WRITE_REG(&adapter->hw, MANC, manc);
 633                 }
 634         }
 635
 636         unregister_netdev(netdev);
 637
 638         e1000_phy_hw_reset(&adapter->hw);
 639
 640         iounmap(adapter->hw.hw_addr);
 641         pci_release_regions(pdev);
 642
 643         free_netdev(netdev);
 644 }
 645
 646 /**
 647  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
 648  * @adapter: board private structure to initialize
 649  *
 650  * e1000_sw_init initializes the Adapter private data structure.
 651  * Fields are initialized based on PCI device information and
 652  * OS network device settings (MTU size).
 653  **/
 654
 655 static int __devinit
 656 e1000_sw_init(struct e1000_adapter *adapter)
 657 {
 658         struct e1000_hw *hw = &adapter->hw;
 659         struct net_device *netdev = adapter->netdev;
 660         struct pci_dev *pdev = adapter->pdev;
 661
 662         /* PCI config space info */
 663
 664         hw->vendor_id = pdev->vendor;
 665         hw->device_id = pdev->device;
 666         hw->subsystem_vendor_id = pdev->subsystem_vendor;
 667         hw->subsystem_id = pdev->subsystem_device;
 668
 669         pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
 670
 671         pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
 672
 673         adapter->rx_buffer_len = E1000_RXBUFFER_2048;
 674         hw->max_frame_size = netdev->mtu +
 675                              ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
 676         hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
 677
 678         /* identify the MAC */
 679
 680         if(e1000_set_mac_type(hw)) {
 681                 DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
 682                 return -EIO;
 683         }
 684
 685         /* initialize eeprom parameters */
 686
 687         e1000_init_eeprom_params(hw);
 688
 689         switch(hw->mac_type) {
 690         default:
 691                 break;
 692         case e1000_82541:
 693         case e1000_82547:
 694         case e1000_82541_rev_2:
 695         case e1000_82547_rev_2:
 696                 hw->phy_init_script = 1;
 697                 break;
 698         }
 699
 700         e1000_set_media_type(hw);
 701
 702         hw->wait_autoneg_complete = FALSE;
 703         hw->tbi_compatibility_en = TRUE;
 704         hw->adaptive_ifs = TRUE;
 705
 706         /* Copper options */
 707
 708         if(hw->media_type == e1000_media_type_copper) {
 709                 hw->mdix = AUTO_ALL_MODES;
 710                 hw->disable_polarity_correction = FALSE;
 711                 hw->master_slave = E1000_MASTER_SLAVE;
 712         }
 713
 714         atomic_set(&adapter->irq_sem, 1);
 715         spin_lock_init(&adapter->stats_lock);
 716         spin_lock_init(&adapter->tx_lock);
 717
 718         return 0;
 719 }
 720
 721 /**
 722  * e1000_open - Called when a network interface is made active
 723  * @netdev: network interface device structure
 724  *
 725  * Returns 0 on success, negative value on failure
 726  *
 727  * The open entry point is called when a network interface is made
 728  * active by the system (IFF_UP).  At this point all resources needed
 729  * for transmit and receive operations are allocated, the interrupt
 730  * handler is registered with the OS, the watchdog timer is started,
 731  * and the stack is notified that the interface is ready.
 732  **/
 733
 734 static int
 735 e1000_open(struct net_device *netdev)
 736 {
 737         struct e1000_adapter *adapter = netdev->priv;
 738         int err;
 739
 740         /* allocate transmit descriptors */
 741
 742         if((err = e1000_setup_tx_resources(adapter)))
 743                 goto err_setup_tx;
 744
 745         /* allocate receive descriptors */
 746
 747         if((err = e1000_setup_rx_resources(adapter)))
 748                 goto err_setup_rx;
 749
 750         if((err = e1000_up(adapter)))
 751                 goto err_up;
 752
 753         return E1000_SUCCESS;
 754
 755 err_up:
 756         e1000_free_rx_resources(adapter);
 757 err_setup_rx:
 758         e1000_free_tx_resources(adapter);
 759 err_setup_tx:
 760         e1000_reset(adapter);
 761
 762         return err;
 763 }
 764
 765 /**
 766  * e1000_close - Disables a network interface
 767  * @netdev: network interface device structure
 768  *
 769  * Returns 0, this is not allowed to fail
 770  *
 771  * The close entry point is called when an interface is de-activated
 772  * by the OS.  The hardware is still under the drivers control, but
 773  * needs to be disabled.  A global MAC reset is issued to stop the
 774  * hardware, and all transmit and receive resources are freed.
 775  **/
 776
 777 static int
 778 e1000_close(struct net_device *netdev)
 779 {
 780         struct e1000_adapter *adapter = netdev->priv;
 781
 782         e1000_down(adapter);
 783
 784         e1000_free_tx_resources(adapter);
 785         e1000_free_rx_resources(adapter);
 786
 787         return 0;
 788 }
 789
 790 /**
 791  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 792  * @adapter: board private structure
 793  *
 794  * Return 0 on success, negative on failure
 795  **/
 796
 797 int
 798 e1000_setup_tx_resources(struct e1000_adapter *adapter)
 799 {
 800         struct e1000_desc_ring *txdr = &adapter->tx_ring;
 801         struct pci_dev *pdev = adapter->pdev;
 802         int size;
 803
 804         size = sizeof(struct e1000_buffer) * txdr->count;
 805         txdr->buffer_info = vmalloc(size);
 806         if(!txdr->buffer_info) {
 807                 DPRINTK(PROBE, ERR,
 808                 "Unble to Allocate Memory for the Transmit descriptor ring\n");
 809                 return -ENOMEM;
 810         }
 811         memset(txdr->buffer_info, 0, size);
 812
 813         /* round up to nearest 4K */
 814
 815         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
 816         E1000_ROUNDUP(txdr->size, 4096);
 817
 818         txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
 819         if(!txdr->desc) {
 820                 DPRINTK(PROBE, ERR,
 821                 "Unble to Allocate Memory for the Transmit descriptor ring\n");
 822                 vfree(txdr->buffer_info);
 823                 return -ENOMEM;
 824         }
 825         memset(txdr->desc, 0, txdr->size);
 826
 827         txdr->next_to_use = 0;
 828         txdr->next_to_clean = 0;
 829
 830         return 0;
 831 }
 832
 833 /**
 834  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
 835  * @adapter: board private structure
 836  *
 837  * Configure the Tx unit of the MAC after a reset.
 838  **/
 839
 840 static void
 841 e1000_configure_tx(struct e1000_adapter *adapter)
 842 {
 843         uint64_t tdba = adapter->tx_ring.dma;
 844         uint32_t tdlen = adapter->tx_ring.count * sizeof(struct e1000_tx_desc);
 845         uint32_t tctl, tipg;
 846
 847         E1000_WRITE_REG(&adapter->hw, TDBAL, (tdba & 0x00000000ffffffffULL));
 848         E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
 849
 850         E1000_WRITE_REG(&adapter->hw, TDLEN, tdlen);
 851
 852         /* Setup the HW Tx Head and Tail descriptor pointers */
 853
 854         E1000_WRITE_REG(&adapter->hw, TDH, 0);
 855         E1000_WRITE_REG(&adapter->hw, TDT, 0);
 856
 857         /* Set the default values for the Tx Inter Packet Gap timer */
 858
 859         switch (adapter->hw.mac_type) {
 860         case e1000_82542_rev2_0:
 861         case e1000_82542_rev2_1:
 862                 tipg = DEFAULT_82542_TIPG_IPGT;
 863                 tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
 864                 tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
 865                 break;
 866         default:
 867                 if(adapter->hw.media_type == e1000_media_type_fiber ||
 868                    adapter->hw.media_type == e1000_media_type_internal_serdes)
 869                         tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
 870                 else
 871                         tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
 872                 tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
 873                 tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
 874         }
 875         E1000_WRITE_REG(&adapter->hw, TIPG, tipg);
 876
 877         /* Set the Tx Interrupt Delay register */
 878
 879         E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
 880         if(adapter->hw.mac_type >= e1000_82540)
 881                 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
 882
 883         /* Program the Transmit Control Register */
 884
 885         tctl = E1000_READ_REG(&adapter->hw, TCTL);
 886
 887         tctl &= ~E1000_TCTL_CT;
 888         tctl |= E1000_TCTL_EN | E1000_TCTL_PSP |
 889                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
 890
 891         E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
 892
 893         e1000_config_collision_dist(&adapter->hw);
 894
 895         /* Setup Transmit Descriptor Settings for eop descriptor */
 896         adapter->txd_cmd = E1000_TXD_CMD_IDE | E1000_TXD_CMD_EOP |
 897                 E1000_TXD_CMD_IFCS;
 898
 899         if(adapter->hw.mac_type < e1000_82543)
 900                 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
 901         else
 902                 adapter->txd_cmd |= E1000_TXD_CMD_RS;
 903
 904         /* Cache if we're 82544 running in PCI-X because we'll
 905          * need this to apply a workaround later in the send path. */
 906         if(adapter->hw.mac_type == e1000_82544 &&
 907            adapter->hw.bus_type == e1000_bus_type_pcix)
 908                 adapter->pcix_82544 = 1;
 909 }
 910
 911 /**
 912  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 913  * @adapter: board private structure
 914  *
 915  * Returns 0 on success, negative on failure
 916  **/
 917
 918 int
 919 e1000_setup_rx_resources(struct e1000_adapter *adapter)
 920 {
 921         struct e1000_desc_ring *rxdr = &adapter->rx_ring;
 922         struct pci_dev *pdev = adapter->pdev;
 923         int size;
 924
 925         size = sizeof(struct e1000_buffer) * rxdr->count;
 926         rxdr->buffer_info = vmalloc(size);
 927         if(!rxdr->buffer_info) {
 928                 DPRINTK(PROBE, ERR,
 929                 "Unble to Allocate Memory for the Recieve descriptor ring\n");
 930                 return -ENOMEM;
 931         }
 932         memset(rxdr->buffer_info, 0, size);
 933
 934         /* Round up to nearest 4K */
 935
 936         rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
 937         E1000_ROUNDUP(rxdr->size, 4096);
 938
 939         rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
 940
 941         if(!rxdr->desc) {
 942                 DPRINTK(PROBE, ERR,
 943                 "Unble to Allocate Memory for the Recieve descriptor ring\n");
 944                 vfree(rxdr->buffer_info);
 945                 return -ENOMEM;
 946         }
 947         memset(rxdr->desc, 0, rxdr->size);
 948
 949         rxdr->next_to_clean = 0;
 950         rxdr->next_to_use = 0;
 951
 952         return 0;
 953 }
 954
 955 /**
 956  * e1000_setup_rctl - configure the receive control register
 957  * @adapter: Board private structure
 958  **/
 959
 960 static void
 961 e1000_setup_rctl(struct e1000_adapter *adapter)
 962 {
 963         uint32_t rctl;
 964
 965         rctl = E1000_READ_REG(&adapter->hw, RCTL);
 966
 967         rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
 968
 969         rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
 970                 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
 971                 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
 972
 973         if(adapter->hw.tbi_compatibility_on == 1)
 974                 rctl |= E1000_RCTL_SBP;
 975         else
 976                 rctl &= ~E1000_RCTL_SBP;
 977
 978         /* Setup buffer sizes */
 979         rctl &= ~(E1000_RCTL_SZ_4096);
 980         rctl |= (E1000_RCTL_BSEX | E1000_RCTL_LPE);
 981         switch (adapter->rx_buffer_len) {
 982         case E1000_RXBUFFER_2048:
 983         default:
 984                 rctl |= E1000_RCTL_SZ_2048;
 985                 rctl &= ~(E1000_RCTL_BSEX | E1000_RCTL_LPE);
 986                 break;
 987         case E1000_RXBUFFER_4096:
 988                 rctl |= E1000_RCTL_SZ_4096;
 989                 break;
 990         case E1000_RXBUFFER_8192:
 991                 rctl |= E1000_RCTL_SZ_8192;
 992                 break;
 993         case E1000_RXBUFFER_16384:
 994                 rctl |= E1000_RCTL_SZ_16384;
 995                 break;
 996         }
 997
 998         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
 999 }
1000
1001 /**
1002  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
1003  * @adapter: board private structure
1004  *
1005  * Configure the Rx unit of the MAC after a reset.
1006  **/
1007
1008 static void
1009 e1000_configure_rx(struct e1000_adapter *adapter)
1010 {
1011         uint64_t rdba = adapter->rx_ring.dma;
1012         uint32_t rdlen = adapter->rx_ring.count * sizeof(struct e1000_rx_desc);
1013         uint32_t rctl;
1014         uint32_t rxcsum;
1015
1016         /* disable receives while setting up the descriptors */
1017         rctl = E1000_READ_REG(&adapter->hw, RCTL);
1018         E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
1019
1020         /* set the Receive Delay Timer Register */
1021         E1000_WRITE_REG(&adapter->hw, RDTR, adapter->rx_int_delay);
1022
1023         if(adapter->hw.mac_type >= e1000_82540) {
1024                 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
1025                 if(adapter->itr > 1)
1026                         E1000_WRITE_REG(&adapter->hw, ITR,
1027                                 1000000000 / (adapter->itr * 256));
1028         }
1029
1030         /* Setup the Base and Length of the Rx Descriptor Ring */
1031         E1000_WRITE_REG(&adapter->hw, RDBAL, (rdba & 0x00000000ffffffffULL));
1032         E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
1033
1034         E1000_WRITE_REG(&adapter->hw, RDLEN, rdlen);
1035
1036         /* Setup the HW Rx Head and Tail Descriptor Pointers */
1037         E1000_WRITE_REG(&adapter->hw, RDH, 0);
1038         E1000_WRITE_REG(&adapter->hw, RDT, 0);
1039
1040         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
1041         if((adapter->hw.mac_type >= e1000_82543) &&
1042            (adapter->rx_csum == TRUE)) {
1043                 rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
1044                 rxcsum |= E1000_RXCSUM_TUOFL;
1045                 E1000_WRITE_REG(&adapter->hw, RXCSUM, rxcsum);
1046         }
1047
1048         /* Enable Receives */
1049         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1050 }
1051
1052 /**
1053  * e1000_free_tx_resources - Free Tx Resources
1054  * @adapter: board private structure
1055  *
1056  * Free all transmit software resources
1057  **/
1058
1059 void
1060 e1000_free_tx_resources(struct e1000_adapter *adapter)
1061 {
1062         struct pci_dev *pdev = adapter->pdev;
1063
1064         e1000_clean_tx_ring(adapter);
1065
1066         vfree(adapter->tx_ring.buffer_info);
1067         adapter->tx_ring.buffer_info = NULL;
1068
1069         pci_free_consistent(pdev, adapter->tx_ring.size,
1070                             adapter->tx_ring.desc, adapter->tx_ring.dma);
1071
1072         adapter->tx_ring.desc = NULL;
1073 }
1074
1075 /**
1076  * e1000_clean_tx_ring - Free Tx Buffers
1077  * @adapter: board private structure
1078  **/
1079
1080 static void
1081 e1000_clean_tx_ring(struct e1000_adapter *adapter)
1082 {
1083         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1084         struct e1000_buffer *buffer_info;
1085         struct pci_dev *pdev = adapter->pdev;
1086         unsigned long size;
1087         unsigned int i;
1088
1089         /* Free all the Tx ring sk_buffs */
1090
1091         for(i = 0; i < tx_ring->count; i++) {
1092                 buffer_info = &tx_ring->buffer_info[i];
1093                 if(buffer_info->skb) {
1094
1095                         pci_unmap_page(pdev,
1096                                        buffer_info->dma,
1097                                        buffer_info->length,
1098                                        PCI_DMA_TODEVICE);
1099
1100                         dev_kfree_skb(buffer_info->skb);
1101
1102                         buffer_info->skb = NULL;
1103                 }
1104         }
1105
1106         size = sizeof(struct e1000_buffer) * tx_ring->count;
1107         memset(tx_ring->buffer_info, 0, size);
1108
1109         /* Zero out the descriptor ring */
1110
1111         memset(tx_ring->desc, 0, tx_ring->size);
1112
1113         tx_ring->next_to_use = 0;
1114         tx_ring->next_to_clean = 0;
1115
1116         E1000_WRITE_REG(&adapter->hw, TDH, 0);
1117         E1000_WRITE_REG(&adapter->hw, TDT, 0);
1118 }
1119
1120 /**
1121  * e1000_free_rx_resources - Free Rx Resources
1122  * @adapter: board private structure
1123  *
1124  * Free all receive software resources
1125  **/
1126
1127 void
1128 e1000_free_rx_resources(struct e1000_adapter *adapter)
1129 {
1130         struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1131         struct pci_dev *pdev = adapter->pdev;
1132
1133         e1000_clean_rx_ring(adapter);
1134
1135         vfree(rx_ring->buffer_info);
1136         rx_ring->buffer_info = NULL;
1137
1138         pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);
1139
1140         rx_ring->desc = NULL;
1141 }
1142
1143 /**
1144  * e1000_clean_rx_ring - Free Rx Buffers
1145  * @adapter: board private structure
1146  **/
1147
1148 static void
1149 e1000_clean_rx_ring(struct e1000_adapter *adapter)
1150 {
1151         struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1152         struct e1000_buffer *buffer_info;
1153         struct pci_dev *pdev = adapter->pdev;
1154         unsigned long size;
1155         unsigned int i;
1156
1157         /* Free all the Rx ring sk_buffs */
1158
1159         for(i = 0; i < rx_ring->count; i++) {
1160                 buffer_info = &rx_ring->buffer_info[i];
1161                 if(buffer_info->skb) {
1162
1163                         pci_unmap_single(pdev,
1164                                          buffer_info->dma,
1165                                          buffer_info->length,
1166                                          PCI_DMA_FROMDEVICE);
1167
1168                         dev_kfree_skb(buffer_info->skb);
1169                         buffer_info->skb = NULL;
1170                 }
1171         }
1172
1173         size = sizeof(struct e1000_buffer) * rx_ring->count;
1174         memset(rx_ring->buffer_info, 0, size);
1175
1176         /* Zero out the descriptor ring */
1177
1178         memset(rx_ring->desc, 0, rx_ring->size);
1179
1180         rx_ring->next_to_clean = 0;
1181         rx_ring->next_to_use = 0;
1182
1183         E1000_WRITE_REG(&adapter->hw, RDH, 0);
1184         E1000_WRITE_REG(&adapter->hw, RDT, 0);
1185 }
1186
1187 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
1188  * and memory write and invalidate disabled for certain operations
1189  */
1190 static void
1191 e1000_enter_82542_rst(struct e1000_adapter *adapter)
1192 {
1193         struct net_device *netdev = adapter->netdev;
1194         uint32_t rctl;
1195
1196         e1000_pci_clear_mwi(&adapter->hw);
1197
1198         rctl = E1000_READ_REG(&adapter->hw, RCTL);
1199         rctl |= E1000_RCTL_RST;
1200         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1201         E1000_WRITE_FLUSH(&adapter->hw);
1202         mdelay(5);
1203
1204         if(netif_running(netdev))
1205                 e1000_clean_rx_ring(adapter);
1206 }
1207
1208 static void
1209 e1000_leave_82542_rst(struct e1000_adapter *adapter)
1210 {
1211         struct net_device *netdev = adapter->netdev;
1212         uint32_t rctl;
1213
1214         rctl = E1000_READ_REG(&adapter->hw, RCTL);
1215         rctl &= ~E1000_RCTL_RST;
1216         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1217         E1000_WRITE_FLUSH(&adapter->hw);
1218         mdelay(5);
1219
1220         if(adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
1221                 e1000_pci_set_mwi(&adapter->hw);
1222
1223         if(netif_running(netdev)) {
1224                 e1000_configure_rx(adapter);
1225                 e1000_alloc_rx_buffers(adapter);
1226         }
1227 }
1228
1229 /**
1230  * e1000_set_mac - Change the Ethernet Address of the NIC
1231  * @netdev: network interface device structure
1232  * @p: pointer to an address structure
1233  *
1234  * Returns 0 on success, negative on failure
1235  **/
1236
1237 static int
1238 e1000_set_mac(struct net_device *netdev, void *p)
1239 {
1240         struct e1000_adapter *adapter = netdev->priv;
1241         struct sockaddr *addr = p;
1242
1243         if(!is_valid_ether_addr(addr->sa_data))
1244                 return -EADDRNOTAVAIL;
1245
1246         /* 82542 2.0 needs to be in reset to write receive address registers */
1247
1248         if(adapter->hw.mac_type == e1000_82542_rev2_0)
1249                 e1000_enter_82542_rst(adapter);
1250
1251         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
1252         memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
1253
1254         e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
1255
1256         if(adapter->hw.mac_type == e1000_82542_rev2_0)
1257                 e1000_leave_82542_rst(adapter);
1258
1259         return 0;
1260 }
1261
1262 /**
1263  * e1000_set_multi - Multicast and Promiscuous mode set
1264  * @netdev: network interface device structure
1265  *
1266  * The set_multi entry point is called whenever the multicast address
1267  * list or the network interface flags are updated.  This routine is
1268  * responsible for configuring the hardware for proper multicast,
1269  * promiscuous mode, and all-multi behavior.
1270  **/
1271
1272 static void
1273 e1000_set_multi(struct net_device *netdev)
1274 {
1275         struct e1000_adapter *adapter = netdev->priv;
1276         struct e1000_hw *hw = &adapter->hw;
1277         struct dev_mc_list *mc_ptr;
1278         uint32_t rctl;
1279         uint32_t hash_value;
1280         int i;
1281         unsigned long flags;
1282
1283         /* Check for Promiscuous and All Multicast modes */
1284
1285         spin_lock_irqsave(&adapter->tx_lock, flags);
1286
1287         rctl = E1000_READ_REG(hw, RCTL);
1288
1289         if(netdev->flags & IFF_PROMISC) {
1290                 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1291         } else if(netdev->flags & IFF_ALLMULTI) {
1292                 rctl |= E1000_RCTL_MPE;
1293                 rctl &= ~E1000_RCTL_UPE;
1294         } else {
1295                 rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
1296         }
1297
1298         E1000_WRITE_REG(hw, RCTL, rctl);
1299
1300         /* 82542 2.0 needs to be in reset to write receive address registers */
1301
1302         if(hw->mac_type == e1000_82542_rev2_0)
1303                 e1000_enter_82542_rst(adapter);
1304
1305         /* load the first 14 multicast address into the exact filters 1-14
1306          * RAR 0 is used for the station MAC adddress
1307          * if there are not 14 addresses, go ahead and clear the filters
1308          */
1309         mc_ptr = netdev->mc_list;
1310
1311         for(i = 1; i < E1000_RAR_ENTRIES; i++) {
1312                 if(mc_ptr) {
1313                         e1000_rar_set(hw, mc_ptr->dmi_addr, i);
1314                         mc_ptr = mc_ptr->next;
1315                 } else {
1316                         E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
1317                         E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
1318                 }
1319         }
1320
1321         /* clear the old settings from the multicast hash table */
1322
1323         for(i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
1324                 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
1325
1326         /* load any remaining addresses into the hash table */
1327
1328         for(; mc_ptr; mc_ptr = mc_ptr->next) {
1329                 hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
1330                 e1000_mta_set(hw, hash_value);
1331         }
1332
1333         if(hw->mac_type == e1000_82542_rev2_0)
1334                 e1000_leave_82542_rst(adapter);
1335
1336         spin_unlock_irqrestore(&adapter->tx_lock, flags);
1337 }
1338
1339 /* Need to wait a few seconds after link up to get diagnostic information from
1340  * the phy */
1341
1342 static void
1343 e1000_update_phy_info(unsigned long data)
1344 {
1345         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1346         e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
1347 }
1348
1349 /**
1350  * e1000_82547_tx_fifo_stall - Timer Call-back
1351  * @data: pointer to adapter cast into an unsigned long
1352  **/
1353
1354 static void
1355 e1000_82547_tx_fifo_stall(unsigned long data)
1356 {
1357         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1358         struct net_device *netdev = adapter->netdev;
1359         uint32_t tctl;
1360
1361         if(atomic_read(&adapter->tx_fifo_stall)) {
1362                 if((E1000_READ_REG(&adapter->hw, TDT) ==
1363                     E1000_READ_REG(&adapter->hw, TDH)) &&
1364                    (E1000_READ_REG(&adapter->hw, TDFT) ==
1365                     E1000_READ_REG(&adapter->hw, TDFH)) &&
1366                    (E1000_READ_REG(&adapter->hw, TDFTS) ==
1367                     E1000_READ_REG(&adapter->hw, TDFHS))) {
1368                         tctl = E1000_READ_REG(&adapter->hw, TCTL);
1369                         E1000_WRITE_REG(&adapter->hw, TCTL,
1370                                         tctl & ~E1000_TCTL_EN);
1371                         E1000_WRITE_REG(&adapter->hw, TDFT,
1372                                         adapter->tx_head_addr);
1373                         E1000_WRITE_REG(&adapter->hw, TDFH,
1374                                         adapter->tx_head_addr);
1375                         E1000_WRITE_REG(&adapter->hw, TDFTS,
1376                                         adapter->tx_head_addr);
1377                         E1000_WRITE_REG(&adapter->hw, TDFHS,
1378                                         adapter->tx_head_addr);
1379                         E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1380                         E1000_WRITE_FLUSH(&adapter->hw);
1381
1382                         adapter->tx_fifo_head = 0;
1383                         atomic_set(&adapter->tx_fifo_stall, 0);
1384                         netif_wake_queue(netdev);
1385                 } else {
1386                         mod_timer(&adapter->tx_fifo_stall_timer, jiffies + 1);
1387                 }
1388         }
1389 }
1390
1391 /**
1392  * e1000_watchdog - Timer Call-back
1393  * @data: pointer to netdev cast into an unsigned long
1394  **/
1395
1396 static void
1397 e1000_watchdog(unsigned long data)
1398 {
1399         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1400         struct net_device *netdev = adapter->netdev;
1401         struct e1000_desc_ring *txdr = &adapter->tx_ring;
1402         unsigned int i;
1403         uint32_t link;
1404
1405         e1000_check_for_link(&adapter->hw);
1406
1407         if((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
1408            !(E1000_READ_REG(&adapter->hw, TXCW) & E1000_TXCW_ANE))
1409                 link = !adapter->hw.serdes_link_down;
1410         else
1411                 link = E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU;
1412
1413         if(link) {
1414                 if(!netif_carrier_ok(netdev)) {
1415                         e1000_get_speed_and_duplex(&adapter->hw,
1416                                                    &adapter->link_speed,
1417                                                    &adapter->link_duplex);
1418
1419                         DPRINTK(LINK, INFO, "NIC Link is Up %d Mbps %s\n",
1420                                adapter->link_speed,
1421                                adapter->link_duplex == FULL_DUPLEX ?
1422                                "Full Duplex" : "Half Duplex");
1423
1424                         netif_carrier_on(netdev);
1425                         netif_wake_queue(netdev);
1426                         mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1427                         adapter->smartspeed = 0;
1428                 }
1429         } else {
1430                 if(netif_carrier_ok(netdev)) {
1431                         adapter->link_speed = 0;
1432                         adapter->link_duplex = 0;
1433                         DPRINTK(LINK, INFO, "NIC Link is Down\n");
1434                         netif_carrier_off(netdev);
1435                         netif_stop_queue(netdev);
1436                         mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1437                 }
1438
1439                 e1000_smartspeed(adapter);
1440         }
1441
1442         e1000_update_stats(adapter);
1443
1444         adapter->hw.tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
1445         adapter->tpt_old = adapter->stats.tpt;
1446         adapter->hw.collision_delta = adapter->stats.colc - adapter->colc_old;
1447         adapter->colc_old = adapter->stats.colc;
1448
1449         adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
1450         adapter->gorcl_old = adapter->stats.gorcl;
1451         adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
1452         adapter->gotcl_old = adapter->stats.gotcl;
1453
1454         e1000_update_adaptive(&adapter->hw);
1455
1456         if(!netif_carrier_ok(netdev)) {
1457                 if(E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
1458                         /* We've lost link, so the controller stops DMA,
1459                          * but we've got queued Tx work that's never going
1460                          * to get done, so reset controller to flush Tx.
1461                          * (Do the reset outside of interrupt context). */
1462                         schedule_work(&adapter->tx_timeout_task);
1463                 }
1464         }
1465
1466         /* Dynamic mode for Interrupt Throttle Rate (ITR) */
1467         if(adapter->hw.mac_type >= e1000_82540 && adapter->itr == 1) {
1468                 /* Symmetric Tx/Rx gets a reduced ITR=2000; Total
1469                  * asymmetrical Tx or Rx gets ITR=8000; everyone
1470                  * else is between 2000-8000. */
1471                 uint32_t goc = (adapter->gotcl + adapter->gorcl) / 10000;
1472                 uint32_t dif = (adapter->gotcl > adapter->gorcl ?
1473                         adapter->gotcl - adapter->gorcl :
1474                         adapter->gorcl - adapter->gotcl) / 10000;
1475                 uint32_t itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
1476                 E1000_WRITE_REG(&adapter->hw, ITR, 1000000000 / (itr * 256));
1477         }
1478
1479         /* Cause software interrupt to ensure rx ring is cleaned */
1480         E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0);
1481
1482         /* Early detection of hung controller */
1483         i = txdr->next_to_clean;
1484         if(txdr->buffer_info[i].dma &&
1485            time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) &&
1486            !(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF))
1487                 netif_stop_queue(netdev);
1488
1489         /* Reset the timer */
1490         mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1491 }
1492
1493 #define E1000_TX_FLAGS_CSUM             0x00000001
1494 #define E1000_TX_FLAGS_VLAN             0x00000002
1495 #define E1000_TX_FLAGS_TSO              0x00000004
1496 #define E1000_TX_FLAGS_VLAN_MASK        0xffff0000
1497 #define E1000_TX_FLAGS_VLAN_SHIFT       16
1498
1499 static inline boolean_t
1500 e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
1501 {
1502 #ifdef NETIF_F_TSO
1503         struct e1000_context_desc *context_desc;
1504         unsigned int i;
1505         uint32_t cmd_length = 0;
1506         uint16_t ipcse, tucse, mss;
1507         uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
1508
1509         if(skb_shinfo(skb)->tso_size) {
1510                 hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
1511                 mss = skb_shinfo(skb)->tso_size;
1512                 skb->nh.iph->tot_len = 0;
1513                 skb->nh.iph->check = 0;
1514                 skb->h.th->check = ~csum_tcpudp_magic(skb->nh.iph->saddr,
1515                                                       skb->nh.iph->daddr,
1516                                                       0,
1517                                                       IPPROTO_TCP,
1518                                                       0);
1519                 ipcss = skb->nh.raw - skb->data;
1520                 ipcso = (void *)&(skb->nh.iph->check) - (void *)skb->data;
1521                 ipcse = skb->h.raw - skb->data - 1;
1522                 tucss = skb->h.raw - skb->data;
1523                 tucso = (void *)&(skb->h.th->check) - (void *)skb->data;
1524                 tucse = 0;
1525
1526                 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
1527                                E1000_TXD_CMD_IP | E1000_TXD_CMD_TCP |
1528                                (skb->len - (hdr_len)));
1529
1530                 i = adapter->tx_ring.next_to_use;
1531                 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1532
1533                 context_desc->lower_setup.ip_fields.ipcss  = ipcss;
1534                 context_desc->lower_setup.ip_fields.ipcso  = ipcso;
1535                 context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
1536                 context_desc->upper_setup.tcp_fields.tucss = tucss;
1537                 context_desc->upper_setup.tcp_fields.tucso = tucso;
1538                 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
1539                 context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
1540                 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
1541                 context_desc->cmd_and_length = cpu_to_le32(cmd_length);
1542
1543                 if(++i == adapter->tx_ring.count) i = 0;
1544                 adapter->tx_ring.next_to_use = i;
1545
1546                 return TRUE;
1547         }
1548 #endif
1549
1550         return FALSE;
1551 }
1552
1553 static inline boolean_t
1554 e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
1555 {
1556         struct e1000_context_desc *context_desc;
1557         unsigned int i;
1558         uint8_t css;
1559
1560         if(likely(skb->ip_summed == CHECKSUM_HW)) {
1561                 css = skb->h.raw - skb->data;
1562
1563                 i = adapter->tx_ring.next_to_use;
1564                 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1565
1566                 context_desc->upper_setup.tcp_fields.tucss = css;
1567                 context_desc->upper_setup.tcp_fields.tucso = css + skb->csum;
1568                 context_desc->upper_setup.tcp_fields.tucse = 0;
1569                 context_desc->tcp_seg_setup.data = 0;
1570                 context_desc->cmd_and_length = cpu_to_le32(E1000_TXD_CMD_DEXT);
1571
1572                 if(unlikely(++i == adapter->tx_ring.count)) i = 0;
1573                 adapter->tx_ring.next_to_use = i;
1574
1575                 return TRUE;
1576         }
1577
1578         return FALSE;
1579 }
1580
1581 #define E1000_MAX_TXD_PWR       12
1582 #define E1000_MAX_DATA_PER_TXD  (1<<E1000_MAX_TXD_PWR)
1583
1584 static inline int
1585 e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb,
1586         unsigned int first, unsigned int max_per_txd,
1587         unsigned int nr_frags, unsigned int mss)
1588 {
1589         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1590         struct e1000_buffer *buffer_info;
1591         unsigned int len = skb->len;
1592         unsigned int offset = 0, size, count = 0, i;
1593         unsigned int f;
1594         len -= skb->data_len;
1595
1596         i = tx_ring->next_to_use;
1597
1598         while(len) {
1599                 buffer_info = &tx_ring->buffer_info[i];
1600                 size = min(len, max_per_txd);
1601 #ifdef NETIF_F_TSO
1602                 /* Workaround for premature desc write-backs
1603                  * in TSO mode.  Append 4-byte sentinel desc */
1604                 if(unlikely(mss && !nr_frags && size == len && size > 8))
1605                         size -= 4;
1606 #endif
1607                 /* Workaround for potential 82544 hang in PCI-X.  Avoid
1608                  * terminating buffers within evenly-aligned dwords. */
1609                 if(unlikely(adapter->pcix_82544 &&
1610                    !((unsigned long)(skb->data + offset + size - 1) & 4) &&
1611                    size > 4))
1612                         size -= 4;
1613
1614                 buffer_info->length = size;
1615                 buffer_info->dma =
1616                         pci_map_single(adapter->pdev,
1617                                 skb->data + offset,
1618                                 size,
1619                                 PCI_DMA_TODEVICE);
1620                 buffer_info->time_stamp = jiffies;
1621
1622                 len -= size;
1623                 offset += size;
1624                 count++;
1625                 if(unlikely(++i == tx_ring->count)) i = 0;
1626         }
1627
1628         for(f = 0; f < nr_frags; f++) {
1629                 struct skb_frag_struct *frag;
1630
1631                 frag = &skb_shinfo(skb)->frags[f];
1632                 len = frag->size;
1633                 offset = frag->page_offset;
1634
1635                 while(len) {
1636                         buffer_info = &tx_ring->buffer_info[i];
1637                         size = min(len, max_per_txd);
1638 #ifdef NETIF_F_TSO
1639                         /* Workaround for premature desc write-backs
1640                          * in TSO mode.  Append 4-byte sentinel desc */
1641                         if(unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
1642                                 size -= 4;
1643 #endif
1644                         /* Workaround for potential 82544 hang in PCI-X.
1645                          * Avoid terminating buffers within evenly-aligned
1646                          * dwords. */
1647                         if(unlikely(adapter->pcix_82544 &&
1648                            !((unsigned long)(frag->page+offset+size-1) & 4) &&
1649                            size > 4))
1650                                 size -= 4;
1651
1652                         buffer_info->length = size;
1653                         buffer_info->dma =
1654                                 pci_map_page(adapter->pdev,
1655                                         frag->page,
1656                                         offset,
1657                                         size,
1658                                         PCI_DMA_TODEVICE);
1659                         buffer_info->time_stamp = jiffies;
1660
1661                         len -= size;
1662                         offset += size;
1663                         count++;
1664                         if(unlikely(++i == tx_ring->count)) i = 0;
1665                 }
1666         }
1667
1668         i = (i == 0) ? tx_ring->count - 1 : i - 1;
1669         tx_ring->buffer_info[i].skb = skb;
1670         tx_ring->buffer_info[first].next_to_watch = i;
1671
1672         return count;
1673 }
1674
1675 static inline void
1676 e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
1677 {
1678         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1679         struct e1000_tx_desc *tx_desc = NULL;
1680         struct e1000_buffer *buffer_info;
1681         uint32_t txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
1682         unsigned int i;
1683
1684         if(likely(tx_flags & E1000_TX_FLAGS_TSO)) {
1685                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
1686                              E1000_TXD_CMD_TSE;
1687                 txd_upper |= (E1000_TXD_POPTS_IXSM | E1000_TXD_POPTS_TXSM) << 8;
1688         }
1689
1690         if(likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
1691                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1692                 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
1693         }
1694
1695         if(unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
1696                 txd_lower |= E1000_TXD_CMD_VLE;
1697                 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
1698         }
1699
1700         i = tx_ring->next_to_use;
1701
1702         while(count--) {
1703                 buffer_info = &tx_ring->buffer_info[i];
1704                 tx_desc = E1000_TX_DESC(*tx_ring, i);
1705                 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
1706                 tx_desc->lower.data =
1707                         cpu_to_le32(txd_lower | buffer_info->length);
1708                 tx_desc->upper.data = cpu_to_le32(txd_upper);
1709                 if(unlikely(++i == tx_ring->count)) i = 0;
1710         }
1711
1712         tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
1713
1714         /* Force memory writes to complete before letting h/w
1715          * know there are new descriptors to fetch.  (Only
1716          * applicable for weak-ordered memory model archs,
1717          * such as IA-64). */
1718         wmb();
1719
1720         tx_ring->next_to_use = i;
1721         E1000_WRITE_REG(&adapter->hw, TDT, i);
1722 }
1723
1724 /**
1725  * 82547 workaround to avoid controller hang in half-duplex environment.
1726  * The workaround is to avoid queuing a large packet that would span
1727  * the internal Tx FIFO ring boundary by notifying the stack to resend
1728  * the packet at a later time.  This gives the Tx FIFO an opportunity to
1729  * flush all packets.  When that occurs, we reset the Tx FIFO pointers
1730  * to the beginning of the Tx FIFO.
1731  **/
1732
1733 #define E1000_FIFO_HDR                  0x10
1734 #define E1000_82547_PAD_LEN             0x3E0
1735
1736 static inline int
1737 e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
1738 {
1739         uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
1740         uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;
1741
1742         E1000_ROUNDUP(skb_fifo_len, E1000_FIFO_HDR);
1743
1744         if(adapter->link_duplex != HALF_DUPLEX)
1745                 goto no_fifo_stall_required;
1746
1747         if(atomic_read(&adapter->tx_fifo_stall))
1748                 return 1;
1749
1750         if(skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
1751                 atomic_set(&adapter->tx_fifo_stall, 1);
1752                 return 1;
1753         }
1754
1755 no_fifo_stall_required:
1756         adapter->tx_fifo_head += skb_fifo_len;
1757         if(adapter->tx_fifo_head >= adapter->tx_fifo_size)
1758                 adapter->tx_fifo_head -= adapter->tx_fifo_size;
1759         return 0;
1760 }
1761
1762 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
1763 static int
1764 e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1765 {
1766         struct e1000_adapter *adapter = netdev->priv;
1767         unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
1768         unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
1769         unsigned int tx_flags = 0;
1770         unsigned int len = skb->len;
1771         unsigned long flags;
1772         unsigned int nr_frags = 0;
1773         unsigned int mss = 0;
1774         int count = 0;
1775         unsigned int f;
1776         nr_frags = skb_shinfo(skb)->nr_frags;
1777         len -= skb->data_len;
1778
1779         if(unlikely(skb->len <= 0)) {
1780                 dev_kfree_skb_any(skb);
1781                 return NETDEV_TX_OK;
1782         }
1783
1784 #ifdef NETIF_F_TSO
1785         mss = skb_shinfo(skb)->tso_size;
1786         /* The controller does a simple calculation to
1787          * make sure there is enough room in the FIFO before
1788          * initiating the DMA for each buffer.  The calc is:
1789          * 4 = ceil(buffer len/mss).  To make sure we don't
1790          * overrun the FIFO, adjust the max buffer len if mss
1791          * drops. */
1792         if(mss) {
1793                 max_per_txd = min(mss << 2, max_per_txd);
1794                 max_txd_pwr = fls(max_per_txd) - 1;
1795         }
1796
1797         if((mss) || (skb->ip_summed == CHECKSUM_HW))
1798                 count++;
1799         count++;        /* for sentinel desc */
1800 #else
1801         if(skb->ip_summed == CHECKSUM_HW)
1802                 count++;
1803 #endif
1804         count += TXD_USE_COUNT(len, max_txd_pwr);
1805
1806         if(adapter->pcix_82544)
1807                 count++;
1808
1809         nr_frags = skb_shinfo(skb)->nr_frags;
1810         for(f = 0; f < nr_frags; f++)
1811                 count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
1812                                        max_txd_pwr);
1813         if(adapter->pcix_82544)
1814                 count += nr_frags;
1815
1816         local_irq_save(flags);
1817         if (!spin_trylock(&adapter->tx_lock)) {
1818                 /* Collision - tell upper layer to requeue */
1819                 local_irq_restore(flags);
1820                 return NETDEV_TX_LOCKED;
1821         }
1822
1823         /* need: count + 2 desc gap to keep tail from touching
1824          * head, otherwise try next time */
1825         if(E1000_DESC_UNUSED(&adapter->tx_ring) < count + 2) {
1826                 netif_stop_queue(netdev);
1827                 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1828                 return NETDEV_TX_BUSY;
1829         }
1830
1831         if(unlikely(adapter->hw.mac_type == e1000_82547)) {
1832                 if(unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
1833                         netif_stop_queue(netdev);
1834                         mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
1835                         spin_unlock_irqrestore(&adapter->tx_lock, flags);
1836                         return NETDEV_TX_BUSY;
1837                 }
1838         }
1839
1840         if(unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
1841                 tx_flags |= E1000_TX_FLAGS_VLAN;
1842                 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
1843         }
1844
1845         first = adapter->tx_ring.next_to_use;
1846
1847         if(likely(e1000_tso(adapter, skb)))
1848                 tx_flags |= E1000_TX_FLAGS_TSO;
1849         else if(likely(e1000_tx_csum(adapter, skb)))
1850                 tx_flags |= E1000_TX_FLAGS_CSUM;
1851
1852         e1000_tx_queue(adapter,
1853                 e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss),
1854                 tx_flags);
1855
1856         netdev->trans_start = jiffies;
1857
1858         spin_unlock_irqrestore(&adapter->tx_lock, flags);
1859         return NETDEV_TX_OK;
1860 }
1861
1862 /**
1863  * e1000_tx_timeout - Respond to a Tx Hang
1864  * @netdev: network interface device structure
1865  **/
1866
1867 static void
1868 e1000_tx_timeout(struct net_device *netdev)
1869 {
1870         struct e1000_adapter *adapter = netdev->priv;
1871
1872         /* Do the reset outside of interrupt context */
1873         schedule_work(&adapter->tx_timeout_task);
1874 }
1875
1876 static void
1877 e1000_tx_timeout_task(struct net_device *netdev)
1878 {
1879         struct e1000_adapter *adapter = netdev->priv;
1880
1881         e1000_down(adapter);
1882         e1000_up(adapter);
1883 }
1884
1885 /**
1886  * e1000_get_stats - Get System Network Statistics
1887  * @netdev: network interface device structure
1888  *
1889  * Returns the address of the device statistics structure.
1890  * The statistics are actually updated from the timer callback.
1891  **/
1892
1893 static struct net_device_stats *
1894 e1000_get_stats(struct net_device *netdev)
1895 {
1896         struct e1000_adapter *adapter = netdev->priv;
1897
1898         e1000_update_stats(adapter);
1899         return &adapter->net_stats;
1900 }
1901
1902 /**
1903  * e1000_change_mtu - Change the Maximum Transfer Unit
1904  * @netdev: network interface device structure
1905  * @new_mtu: new value for maximum frame size
1906  *
1907  * Returns 0 on success, negative on failure
1908  **/
1909
1910 static int
1911 e1000_change_mtu(struct net_device *netdev, int new_mtu)
1912 {
1913         struct e1000_adapter *adapter = netdev->priv;
1914         int old_mtu = adapter->rx_buffer_len;
1915         int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
1916
1917         if((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
1918            (max_frame > MAX_JUMBO_FRAME_SIZE)) {
1919                 DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
1920                 return -EINVAL;
1921         }
1922
1923         if(max_frame <= MAXIMUM_ETHERNET_FRAME_SIZE) {
1924                 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
1925
1926         } else if(adapter->hw.mac_type < e1000_82543) {
1927                 DPRINTK(PROBE, ERR, "Jumbo Frames not supported on 82542\n");
1928                 return -EINVAL;
1929
1930         } else if(max_frame <= E1000_RXBUFFER_4096) {
1931                 adapter->rx_buffer_len = E1000_RXBUFFER_4096;
1932
1933         } else if(max_frame <= E1000_RXBUFFER_8192) {
1934                 adapter->rx_buffer_len = E1000_RXBUFFER_8192;
1935
1936         } else {
1937                 adapter->rx_buffer_len = E1000_RXBUFFER_16384;
1938         }
1939
1940         if(old_mtu != adapter->rx_buffer_len && netif_running(netdev)) {
1941                 e1000_down(adapter);
1942                 e1000_up(adapter);
1943         }
1944
1945         netdev->mtu = new_mtu;
1946         adapter->hw.max_frame_size = max_frame;
1947
1948         return 0;
1949 }
1950
1951 /**
1952  * e1000_update_stats - Update the board statistics counters
1953  * @adapter: board private structure
1954  **/
1955
1956 void
1957 e1000_update_stats(struct e1000_adapter *adapter)
1958 {
1959         struct e1000_hw *hw = &adapter->hw;
1960         unsigned long flags;
1961         uint16_t phy_tmp;
1962
1963 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
1964
1965         spin_lock_irqsave(&adapter->stats_lock, flags);
1966
1967         /* these counters are modified from e1000_adjust_tbi_stats,
1968          * called from the interrupt context, so they must only
1969          * be written while holding adapter->stats_lock
1970          */
1971
1972         adapter->stats.crcerrs += E1000_READ_REG(hw, CRCERRS);
1973         adapter->stats.gprc += E1000_READ_REG(hw, GPRC);
1974         adapter->stats.gorcl += E1000_READ_REG(hw, GORCL);
1975         adapter->stats.gorch += E1000_READ_REG(hw, GORCH);
1976         adapter->stats.bprc += E1000_READ_REG(hw, BPRC);
1977         adapter->stats.mprc += E1000_READ_REG(hw, MPRC);
1978         adapter->stats.roc += E1000_READ_REG(hw, ROC);
1979         adapter->stats.prc64 += E1000_READ_REG(hw, PRC64);
1980         adapter->stats.prc127 += E1000_READ_REG(hw, PRC127);
1981         adapter->stats.prc255 += E1000_READ_REG(hw, PRC255);
1982         adapter->stats.prc511 += E1000_READ_REG(hw, PRC511);
1983         adapter->stats.prc1023 += E1000_READ_REG(hw, PRC1023);
1984         adapter->stats.prc1522 += E1000_READ_REG(hw, PRC1522);
1985
1986         adapter->stats.symerrs += E1000_READ_REG(hw, SYMERRS);
1987         adapter->stats.mpc += E1000_READ_REG(hw, MPC);
1988         adapter->stats.scc += E1000_READ_REG(hw, SCC);
1989         adapter->stats.ecol += E1000_READ_REG(hw, ECOL);
1990         adapter->stats.mcc += E1000_READ_REG(hw, MCC);
1991         adapter->stats.latecol += E1000_READ_REG(hw, LATECOL);
1992         adapter->stats.dc += E1000_READ_REG(hw, DC);
1993         adapter->stats.sec += E1000_READ_REG(hw, SEC);
1994         adapter->stats.rlec += E1000_READ_REG(hw, RLEC);
1995         adapter->stats.xonrxc += E1000_READ_REG(hw, XONRXC);
1996         adapter->stats.xontxc += E1000_READ_REG(hw, XONTXC);
1997         adapter->stats.xoffrxc += E1000_READ_REG(hw, XOFFRXC);
1998         adapter->stats.xofftxc += E1000_READ_REG(hw, XOFFTXC);
1999         adapter->stats.fcruc += E1000_READ_REG(hw, FCRUC);
2000         adapter->stats.gptc += E1000_READ_REG(hw, GPTC);
2001         adapter->stats.gotcl += E1000_READ_REG(hw, GOTCL);
2002         adapter->stats.gotch += E1000_READ_REG(hw, GOTCH);
2003         adapter->stats.rnbc += E1000_READ_REG(hw, RNBC);
2004         adapter->stats.ruc += E1000_READ_REG(hw, RUC);
2005         adapter->stats.rfc += E1000_READ_REG(hw, RFC);
2006         adapter->stats.rjc += E1000_READ_REG(hw, RJC);
2007         adapter->stats.torl += E1000_READ_REG(hw, TORL);
2008         adapter->stats.torh += E1000_READ_REG(hw, TORH);
2009         adapter->stats.totl += E1000_READ_REG(hw, TOTL);
2010         adapter->stats.toth += E1000_READ_REG(hw, TOTH);
2011         adapter->stats.tpr += E1000_READ_REG(hw, TPR);
2012         adapter->stats.ptc64 += E1000_READ_REG(hw, PTC64);
2013         adapter->stats.ptc127 += E1000_READ_REG(hw, PTC127);
2014         adapter->stats.ptc255 += E1000_READ_REG(hw, PTC255);
2015         adapter->stats.ptc511 += E1000_READ_REG(hw, PTC511);
2016         adapter->stats.ptc1023 += E1000_READ_REG(hw, PTC1023);
2017         adapter->stats.ptc1522 += E1000_READ_REG(hw, PTC1522);
2018         adapter->stats.mptc += E1000_READ_REG(hw, MPTC);
2019         adapter->stats.bptc += E1000_READ_REG(hw, BPTC);
2020
2021         /* used for adaptive IFS */
2022
2023         hw->tx_packet_delta = E1000_READ_REG(hw, TPT);
2024         adapter->stats.tpt += hw->tx_packet_delta;
2025         hw->collision_delta = E1000_READ_REG(hw, COLC);
2026         adapter->stats.colc += hw->collision_delta;
2027
2028         if(hw->mac_type >= e1000_82543) {
2029                 adapter->stats.algnerrc += E1000_READ_REG(hw, ALGNERRC);
2030                 adapter->stats.rxerrc += E1000_READ_REG(hw, RXERRC);
2031                 adapter->stats.tncrs += E1000_READ_REG(hw, TNCRS);
2032                 adapter->stats.cexterr += E1000_READ_REG(hw, CEXTERR);
2033                 adapter->stats.tsctc += E1000_READ_REG(hw, TSCTC);
2034                 adapter->stats.tsctfc += E1000_READ_REG(hw, TSCTFC);
2035         }
2036
2037         /* Fill out the OS statistics structure */
2038
2039         adapter->net_stats.rx_packets = adapter->stats.gprc;
2040         adapter->net_stats.tx_packets = adapter->stats.gptc;
2041         adapter->net_stats.rx_bytes = adapter->stats.gorcl;
2042         adapter->net_stats.tx_bytes = adapter->stats.gotcl;
2043         adapter->net_stats.multicast = adapter->stats.mprc;
2044         adapter->net_stats.collisions = adapter->stats.colc;
2045
2046         /* Rx Errors */
2047
2048         adapter->net_stats.rx_errors = adapter->stats.rxerrc +
2049                 adapter->stats.crcerrs + adapter->stats.algnerrc +
2050                 adapter->stats.rlec + adapter->stats.rnbc +
2051                 adapter->stats.mpc + adapter->stats.cexterr;
2052         adapter->net_stats.rx_dropped = adapter->stats.rnbc;
2053         adapter->net_stats.rx_length_errors = adapter->stats.rlec;
2054         adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
2055         adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
2056         adapter->net_stats.rx_fifo_errors = adapter->stats.mpc;
2057         adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
2058
2059         /* Tx Errors */
2060
2061         adapter->net_stats.tx_errors = adapter->stats.ecol +
2062                                        adapter->stats.latecol;
2063         adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
2064         adapter->net_stats.tx_window_errors = adapter->stats.latecol;
2065         adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;
2066
2067         /* Tx Dropped needs to be maintained elsewhere */
2068
2069         /* Phy Stats */
2070
2071         if(hw->media_type == e1000_media_type_copper) {
2072                 if((adapter->link_speed == SPEED_1000) &&
2073                    (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
2074                         phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
2075                         adapter->phy_stats.idle_errors += phy_tmp;
2076                 }
2077
2078                 if((hw->mac_type <= e1000_82546) &&
2079                    (hw->phy_type == e1000_phy_m88) &&
2080                    !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
2081                         adapter->phy_stats.receive_errors += phy_tmp;
2082         }
2083
2084         spin_unlock_irqrestore(&adapter->stats_lock, flags);
2085 }
2086
2087 /**
2088  * e1000_irq_disable - Mask off interrupt generation on the NIC
2089  * @adapter: board private structure
2090  **/
2091
2092 static void
2093 e1000_irq_disable(struct e1000_adapter *adapter)
2094 {
2095         atomic_inc(&adapter->irq_sem);
2096         E1000_WRITE_REG(&adapter->hw, IMC, ~0);
2097         E1000_WRITE_FLUSH(&adapter->hw);
2098         synchronize_irq(adapter->pdev->irq);
2099 }
2100
2101 /**
2102  * e1000_irq_enable - Enable default interrupt generation settings
2103  * @adapter: board private structure
2104  **/
2105
2106 static void
2107 e1000_irq_enable(struct e1000_adapter *adapter)
2108 {
2109         if(likely(atomic_dec_and_test(&adapter->irq_sem))) {
2110                 E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
2111                 E1000_WRITE_FLUSH(&adapter->hw);
2112         }
2113 }
2114
2115 /**
2116  * e1000_intr - Interrupt Handler
2117  * @irq: interrupt number
2118  * @data: pointer to a network interface device structure
2119  * @pt_regs: CPU registers structure
2120  **/
2121
2122 static irqreturn_t
2123 e1000_intr(int irq, void *data, struct pt_regs *regs)
2124 {
2125         struct net_device *netdev = data;
2126         struct e1000_adapter *adapter = netdev->priv;
2127         struct e1000_hw *hw = &adapter->hw;
2128         uint32_t icr = E1000_READ_REG(hw, ICR);
2129 #ifndef CONFIG_E1000_NAPI
2130         unsigned int i;
2131 #endif
2132
2133         if(unlikely(!icr))
2134                 return IRQ_NONE;  /* Not our interrupt */
2135
2136         if(unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
2137                 hw->get_link_status = 1;
2138                 mod_timer(&adapter->watchdog_timer, jiffies);
2139         }
2140
2141 #ifdef CONFIG_E1000_NAPI
2142         if(likely(netif_rx_schedule_prep(netdev))) {
2143
2144                 /* Disable interrupts and register for poll. The flush
2145                   of the posted write is intentionally left out.
2146                 */
2147
2148                 atomic_inc(&adapter->irq_sem);
2149                 E1000_WRITE_REG(hw, IMC, ~0);
2150                 __netif_rx_schedule(netdev);
2151         }
2152 #else
2153         for(i = 0; i < E1000_MAX_INTR; i++)
2154                 if(unlikely(!e1000_clean_rx_irq(adapter) &
2155                    !e1000_clean_tx_irq(adapter)))
2156                         break;
2157 #endif
2158
2159         return IRQ_HANDLED;
2160 }
2161
2162 #ifdef CONFIG_E1000_NAPI
2163 /**
2164  * e1000_clean - NAPI Rx polling callback
2165  * @adapter: board private structure
2166  **/
2167
2168 static int
2169 e1000_clean(struct net_device *netdev, int *budget)
2170 {
2171         struct e1000_adapter *adapter = netdev->priv;
2172         int work_to_do = min(*budget, netdev->quota);
2173         int tx_cleaned;
2174         int work_done = 0;
2175
2176         tx_cleaned = e1000_clean_tx_irq(adapter);
2177         e1000_clean_rx_irq(adapter, &work_done, work_to_do);
2178
2179         *budget -= work_done;
2180         netdev->quota -= work_done;
2181
2182         /* if no Rx and Tx cleanup work was done, exit the polling mode */
2183         if(!tx_cleaned || (work_done < work_to_do) ||
2184                                 !netif_running(netdev)) {
2185                 netif_rx_complete(netdev);
2186                 e1000_irq_enable(adapter);
2187                 return 0;
2188         }
2189
2190         return (work_done >= work_to_do);
2191 }
2192
2193 #endif
2194 /**
2195  * e1000_clean_tx_irq - Reclaim resources after transmit completes
2196  * @adapter: board private structure
2197  **/
2198
2199 static boolean_t
2200 e1000_clean_tx_irq(struct e1000_adapter *adapter)
2201 {
2202         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
2203         struct net_device *netdev = adapter->netdev;
2204         struct pci_dev *pdev = adapter->pdev;
2205         struct e1000_tx_desc *tx_desc, *eop_desc;
2206         struct e1000_buffer *buffer_info;
2207         unsigned int i, eop;
2208         boolean_t cleaned = FALSE;
2209
2210         i = tx_ring->next_to_clean;
2211         eop = tx_ring->buffer_info[i].next_to_watch;
2212         eop_desc = E1000_TX_DESC(*tx_ring, eop);
2213
2214         while(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
2215                 for(cleaned = FALSE; !cleaned; ) {
2216                         tx_desc = E1000_TX_DESC(*tx_ring, i);
2217                         buffer_info = &tx_ring->buffer_info[i];
2218
2219                         if(likely(buffer_info->dma)) {
2220                                 pci_unmap_page(pdev,
2221                                                buffer_info->dma,
2222                                                buffer_info->length,
2223                                                PCI_DMA_TODEVICE);
2224                                 buffer_info->dma = 0;
2225                         }
2226
2227                         if(buffer_info->skb) {
2228                                 dev_kfree_skb_any(buffer_info->skb);
2229                                 buffer_info->skb = NULL;
2230                         }
2231
2232                         tx_desc->buffer_addr = 0;
2233                         tx_desc->lower.data = 0;
2234                         tx_desc->upper.data = 0;
2235
2236                         cleaned = (i == eop);
2237                         if(unlikely(++i == tx_ring->count)) i = 0;
2238                 }
2239
2240                 eop = tx_ring->buffer_info[i].next_to_watch;
2241                 eop_desc = E1000_TX_DESC(*tx_ring, eop);
2242         }
2243
2244         tx_ring->next_to_clean = i;
2245
2246         spin_lock(&adapter->tx_lock);
2247
2248         if(unlikely(cleaned && netif_queue_stopped(netdev) &&
2249                     netif_carrier_ok(netdev)))
2250                 netif_wake_queue(netdev);
2251
2252         spin_unlock(&adapter->tx_lock);
2253
2254         return cleaned;
2255 }
2256
2257 /**
2258  * e1000_clean_rx_irq - Send received data up the network stack
2259  * @adapter: board private structure
2260  **/
2261
2262 static boolean_t
2263 #ifdef CONFIG_E1000_NAPI
2264 e1000_clean_rx_irq(struct e1000_adapter *adapter, int *work_done,
2265                    int work_to_do)
2266 #else
2267 e1000_clean_rx_irq(struct e1000_adapter *adapter)
2268 #endif
2269 {
2270         struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
2271         struct net_device *netdev = adapter->netdev;
2272         struct pci_dev *pdev = adapter->pdev;
2273         struct e1000_rx_desc *rx_desc;
2274         struct e1000_buffer *buffer_info;
2275         struct sk_buff *skb;
2276         unsigned long flags;
2277         uint32_t length;
2278         uint8_t last_byte;
2279         unsigned int i;
2280         boolean_t cleaned = FALSE;
2281
2282         i = rx_ring->next_to_clean;
2283         rx_desc = E1000_RX_DESC(*rx_ring, i);
2284
2285         while(rx_desc->status & E1000_RXD_STAT_DD) {
2286                 buffer_info = &rx_ring->buffer_info[i];
2287 #ifdef CONFIG_E1000_NAPI
2288                 if(*work_done >= work_to_do)
2289                         break;
2290                 (*work_done)++;
2291 #endif
2292                 cleaned = TRUE;
2293
2294                 pci_unmap_single(pdev,
2295                                  buffer_info->dma,
2296                                  buffer_info->length,
2297                                  PCI_DMA_FROMDEVICE);
2298
2299                 skb = buffer_info->skb;
2300                 length = le16_to_cpu(rx_desc->length);
2301
2302                 if(unlikely(!(rx_desc->status & E1000_RXD_STAT_EOP))) {
2303                         /* All receives must fit into a single buffer */
2304                         E1000_DBG("%s: Receive packet consumed multiple"
2305                                   " buffers\n", netdev->name);
2306                         dev_kfree_skb_irq(skb);
2307                         goto next_desc;
2308                 }
2309
2310                 if(unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
2311                         last_byte = *(skb->data + length - 1);
2312                         if(TBI_ACCEPT(&adapter->hw, rx_desc->status,
2313                                       rx_desc->errors, length, last_byte)) {
2314                                 spin_lock_irqsave(&adapter->stats_lock, flags);
2315                                 e1000_tbi_adjust_stats(&adapter->hw,
2316                                                        &adapter->stats,
2317                                                        length, skb->data);
2318                                 spin_unlock_irqrestore(&adapter->stats_lock,
2319                                                        flags);
2320                                 length--;
2321                         } else {
2322                                 dev_kfree_skb_irq(skb);
2323                                 goto next_desc;
2324                         }
2325                 }
2326
2327                 /* Good Receive */
2328                 skb_put(skb, length - ETHERNET_FCS_SIZE);
2329
2330                 /* Receive Checksum Offload */
2331                 e1000_rx_checksum(adapter, rx_desc, skb);
2332
2333                 skb->protocol = eth_type_trans(skb, netdev);
2334 #ifdef CONFIG_E1000_NAPI
2335                 if(unlikely(adapter->vlgrp &&
2336                             (rx_desc->status & E1000_RXD_STAT_VP))) {
2337                         vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
2338                                                  le16_to_cpu(rx_desc->special &
2339                                                  E1000_RXD_SPC_VLAN_MASK));
2340                 } else {
2341                         netif_receive_skb(skb);
2342                 }
2343 #else /* CONFIG_E1000_NAPI */
2344                 if(unlikely(adapter->vlgrp &&
2345                             (rx_desc->status & E1000_RXD_STAT_VP))) {
2346                         vlan_hwaccel_rx(skb, adapter->vlgrp,
2347                                         le16_to_cpu(rx_desc->special &
2348                                         E1000_RXD_SPC_VLAN_MASK));
2349                 } else {
2350                         netif_rx(skb);
2351                 }
2352 #endif /* CONFIG_E1000_NAPI */
2353                 netdev->last_rx = jiffies;
2354
2355 next_desc:
2356                 rx_desc->status = 0;
2357                 buffer_info->skb = NULL;
2358                 if(unlikely(++i == rx_ring->count)) i = 0;
2359
2360                 rx_desc = E1000_RX_DESC(*rx_ring, i);
2361         }
2362
2363         rx_ring->next_to_clean = i;
2364
2365         e1000_alloc_rx_buffers(adapter);
2366
2367         return cleaned;
2368 }
2369
2370 /**
2371  * e1000_alloc_rx_buffers - Replace used receive buffers
2372  * @adapter: address of board private structure
2373  **/
2374
2375 static void
2376 e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
2377 {
2378         struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
2379         struct net_device *netdev = adapter->netdev;
2380         struct pci_dev *pdev = adapter->pdev;
2381         struct e1000_rx_desc *rx_desc;
2382         struct e1000_buffer *buffer_info;
2383         struct sk_buff *skb;
2384         unsigned int i;
2385
2386         i = rx_ring->next_to_use;
2387         buffer_info = &rx_ring->buffer_info[i];
2388
2389         while(!buffer_info->skb) {
2390
2391                 skb = dev_alloc_skb(adapter->rx_buffer_len + NET_IP_ALIGN);
2392                 if(unlikely(!skb)) {
2393                         /* Better luck next round */
2394                         break;
2395                 }
2396
2397                 /* Make buffer alignment 2 beyond a 16 byte boundary
2398                  * this will result in a 16 byte aligned IP header after
2399                  * the 14 byte MAC header is removed
2400                  */
2401                 skb_reserve(skb, NET_IP_ALIGN);
2402
2403                 skb->dev = netdev;
2404
2405                 buffer_info->skb = skb;
2406                 buffer_info->length = adapter->rx_buffer_len;
2407                 buffer_info->dma = pci_map_single(pdev,
2408                                                   skb->data,
2409                                                   adapter->rx_buffer_len,
2410                                                   PCI_DMA_FROMDEVICE);
2411
2412                 rx_desc = E1000_RX_DESC(*rx_ring, i);
2413                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
2414
2415                 if(unlikely((i & ~(E1000_RX_BUFFER_WRITE - 1)) == i)) {
2416                         /* Force memory writes to complete before letting h/w
2417                          * know there are new descriptors to fetch.  (Only
2418                          * applicable for weak-ordered memory model archs,
2419                          * such as IA-64). */
2420                         wmb();
2421
2422                         E1000_WRITE_REG(&adapter->hw, RDT, i);
2423                 }
2424
2425                 if(unlikely(++i == rx_ring->count)) i = 0;
2426                 buffer_info = &rx_ring->buffer_info[i];
2427         }
2428
2429         rx_ring->next_to_use = i;
2430 }
2431
2432 /**
2433  * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
2434  * @adapter:
2435  **/
2436
2437 static void
2438 e1000_smartspeed(struct e1000_adapter *adapter)
2439 {
2440         uint16_t phy_status;
2441         uint16_t phy_ctrl;
2442
2443         if((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
2444            !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
2445                 return;
2446
2447         if(adapter->smartspeed == 0) {
2448                 /* If Master/Slave config fault is asserted twice,
2449                  * we assume back-to-back */
2450                 e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
2451                 if(!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
2452                 e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
2453                 if(!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
2454                 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
2455                 if(phy_ctrl & CR_1000T_MS_ENABLE) {
2456                         phy_ctrl &= ~CR_1000T_MS_ENABLE;
2457                         e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
2458                                             phy_ctrl);
2459                         adapter->smartspeed++;
2460                         if(!e1000_phy_setup_autoneg(&adapter->hw) &&
2461                            !e1000_read_phy_reg(&adapter->hw, PHY_CTRL,
2462                                                &phy_ctrl)) {
2463                                 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
2464                                              MII_CR_RESTART_AUTO_NEG);
2465                                 e1000_write_phy_reg(&adapter->hw, PHY_CTRL,
2466                                                     phy_ctrl);
2467                         }
2468                 }
2469                 return;
2470         } else if(adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
2471                 /* If still no link, perhaps using 2/3 pair cable */
2472                 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
2473                 phy_ctrl |= CR_1000T_MS_ENABLE;
2474                 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_ctrl);
2475                 if(!e1000_phy_setup_autoneg(&adapter->hw) &&
2476                    !e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_ctrl)) {
2477                         phy_ctrl |= (MII_CR_AUTO_NEG_EN |
2478                                      MII_CR_RESTART_AUTO_NEG);
2479                         e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_ctrl);
2480                 }
2481         }
2482         /* Restart process after E1000_SMARTSPEED_MAX iterations */
2483         if(adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
2484                 adapter->smartspeed = 0;
2485 }
2486
2487 /**
2488  * e1000_ioctl -
2489  * @netdev:
2490  * @ifreq:
2491  * @cmd:
2492  **/
2493
2494 static int
2495 e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
2496 {
2497         switch (cmd) {
2498         case SIOCGMIIPHY:
2499         case SIOCGMIIREG:
2500         case SIOCSMIIREG:
2501                 return e1000_mii_ioctl(netdev, ifr, cmd);
2502         default:
2503                 return -EOPNOTSUPP;
2504         }
2505 }
2506
2507 /**
2508  * e1000_mii_ioctl -
2509  * @netdev:
2510  * @ifreq:
2511  * @cmd:
2512  **/
2513
2514 static int
2515 e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
2516 {
2517         struct e1000_adapter *adapter = netdev->priv;
2518         struct mii_ioctl_data *data = if_mii(ifr);
2519         int retval;
2520         uint16_t mii_reg;
2521         uint16_t spddplx;
2522
2523         if(adapter->hw.media_type != e1000_media_type_copper)
2524                 return -EOPNOTSUPP;
2525
2526         switch (cmd) {
2527         case SIOCGMIIPHY:
2528                 data->phy_id = adapter->hw.phy_addr;
2529                 break;
2530         case SIOCGMIIREG:
2531                 if (!capable(CAP_NET_ADMIN))
2532                         return -EPERM;
2533                 if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
2534                                    &data->val_out))
2535                         return -EIO;
2536                 break;
2537         case SIOCSMIIREG:
2538                 if (!capable(CAP_NET_ADMIN))
2539                         return -EPERM;
2540                 if (data->reg_num & ~(0x1F))
2541                         return -EFAULT;
2542                 mii_reg = data->val_in;
2543                 if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
2544                                         mii_reg))
2545                         return -EIO;
2546                 if (adapter->hw.phy_type == e1000_phy_m88) {
2547                         switch (data->reg_num) {
2548                         case PHY_CTRL:
2549                                 if(mii_reg & MII_CR_POWER_DOWN)
2550                                         break;
2551                                 if(mii_reg & MII_CR_AUTO_NEG_EN) {
2552                                         adapter->hw.autoneg = 1;
2553                                         adapter->hw.autoneg_advertised = 0x2F;
2554                                 } else {
2555                                         if (mii_reg & 0x40)
2556                                                 spddplx = SPEED_1000;
2557                                         else if (mii_reg & 0x2000)
2558                                                 spddplx = SPEED_100;
2559                                         else
2560                                                 spddplx = SPEED_10;
2561                                         spddplx += (mii_reg & 0x100)
2562                                                    ? FULL_DUPLEX :
2563                                                    HALF_DUPLEX;
2564                                         retval = e1000_set_spd_dplx(adapter,
2565                                                                     spddplx);
2566                                         if(retval)
2567                                                 return retval;
2568                                 }
2569                                 if(netif_running(adapter->netdev)) {
2570                                         e1000_down(adapter);
2571                                         e1000_up(adapter);
2572                                 } else
2573                                         e1000_reset(adapter);
2574                                 break;
2575                         case M88E1000_PHY_SPEC_CTRL:
2576                         case M88E1000_EXT_PHY_SPEC_CTRL:
2577                                 if (e1000_phy_reset(&adapter->hw))
2578                                         return -EIO;
2579                                 break;
2580                         }
2581                 } else {
2582                         switch (data->reg_num) {
2583                         case PHY_CTRL:
2584                                 if(mii_reg & MII_CR_POWER_DOWN)
2585                                         break;
2586                                 if(netif_running(adapter->netdev)) {
2587                                         e1000_down(adapter);
2588                                         e1000_up(adapter);
2589                                 } else
2590                                         e1000_reset(adapter);
2591                                 break;
2592                         }
2593                 }
2594                 break;
2595         default:
2596                 return -EOPNOTSUPP;
2597         }
2598         return E1000_SUCCESS;
2599 }
2600
2601 /**
2602  * e1000_rx_checksum - Receive Checksum Offload for 82543
2603  * @adapter: board private structure
2604  * @rx_desc: receive descriptor
2605  * @sk_buff: socket buffer with received data
2606  **/
2607
2608 static void
2609 e1000_rx_checksum(struct e1000_adapter *adapter,
2610                   struct e1000_rx_desc *rx_desc,
2611                   struct sk_buff *skb)
2612 {
2613         /* 82543 or newer only */
2614         if(unlikely((adapter->hw.mac_type < e1000_82543) ||
2615         /* Ignore Checksum bit is set */
2616         (rx_desc->status & E1000_RXD_STAT_IXSM) ||
2617         /* TCP Checksum has not been calculated */
2618         (!(rx_desc->status & E1000_RXD_STAT_TCPCS)))) {
2619                 skb->ip_summed = CHECKSUM_NONE;
2620                 return;
2621         }
2622
2623         /* At this point we know the hardware did the TCP checksum */
2624         /* now look at the TCP checksum error bit */
2625         if(rx_desc->errors & E1000_RXD_ERR_TCPE) {
2626                 /* let the stack verify checksum errors */
2627                 skb->ip_summed = CHECKSUM_NONE;
2628                 adapter->hw_csum_err++;
2629         } else {
2630                 /* TCP checksum is good */
2631                 skb->ip_summed = CHECKSUM_UNNECESSARY;
2632                 adapter->hw_csum_good++;
2633         }
2634 }
2635
2636 void
2637 e1000_pci_set_mwi(struct e1000_hw *hw)
2638 {
2639         struct e1000_adapter *adapter = hw->back;
2640
2641         int ret;
2642         ret = pci_set_mwi(adapter->pdev);
2643 }
2644
2645 void
2646 e1000_pci_clear_mwi(struct e1000_hw *hw)
2647 {
2648         struct e1000_adapter *adapter = hw->back;
2649
2650         pci_clear_mwi(adapter->pdev);
2651 }
2652
2653 void
2654 e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2655 {
2656         struct e1000_adapter *adapter = hw->back;
2657
2658         pci_read_config_word(adapter->pdev, reg, value);
2659 }
2660
2661 void
2662 e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2663 {
2664         struct e1000_adapter *adapter = hw->back;
2665
2666         pci_write_config_word(adapter->pdev, reg, *value);
2667 }
2668
2669 uint32_t
2670 e1000_io_read(struct e1000_hw *hw, unsigned long port)
2671 {
2672         return inl(port);
2673 }
2674
2675 void
2676 e1000_io_write(struct e1000_hw *hw, unsigned long port, uint32_t value)
2677 {
2678         outl(value, port);
2679 }
2680
2681 static void
2682 e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
2683 {
2684         struct e1000_adapter *adapter = netdev->priv;
2685         uint32_t ctrl, rctl;
2686
2687         e1000_irq_disable(adapter);
2688         adapter->vlgrp = grp;
2689
2690         if(grp) {
2691                 /* enable VLAN tag insert/strip */
2692                 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2693                 ctrl |= E1000_CTRL_VME;
2694                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2695
2696                 /* enable VLAN receive filtering */
2697                 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2698                 rctl |= E1000_RCTL_VFE;
2699                 rctl &= ~E1000_RCTL_CFIEN;
2700                 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2701         } else {
2702                 /* disable VLAN tag insert/strip */
2703                 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2704                 ctrl &= ~E1000_CTRL_VME;
2705                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2706
2707                 /* disable VLAN filtering */
2708                 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2709                 rctl &= ~E1000_RCTL_VFE;
2710                 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2711         }
2712
2713         e1000_irq_enable(adapter);
2714 }
2715
2716 static void
2717 e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
2718 {
2719         struct e1000_adapter *adapter = netdev->priv;
2720         uint32_t vfta, index;
2721
2722         /* add VID to filter table */
2723         index = (vid >> 5) & 0x7F;
2724         vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2725         vfta |= (1 << (vid & 0x1F));
2726         e1000_write_vfta(&adapter->hw, index, vfta);
2727 }
2728
2729 static void
2730 e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
2731 {
2732         struct e1000_adapter *adapter = netdev->priv;
2733         uint32_t vfta, index;
2734
2735         e1000_irq_disable(adapter);
2736
2737         if(adapter->vlgrp)
2738                 adapter->vlgrp->vlan_devices[vid] = NULL;
2739
2740         e1000_irq_enable(adapter);
2741
2742         /* remove VID from filter table */
2743         index = (vid >> 5) & 0x7F;
2744         vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2745         vfta &= ~(1 << (vid & 0x1F));
2746         e1000_write_vfta(&adapter->hw, index, vfta);
2747 }
2748
2749 static void
2750 e1000_restore_vlan(struct e1000_adapter *adapter)
2751 {
2752         e1000_vlan_rx_register(adapter->netdev, adapter->vlgrp);
2753
2754         if(adapter->vlgrp) {
2755                 uint16_t vid;
2756                 for(vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
2757                         if(!adapter->vlgrp->vlan_devices[vid])
2758                                 continue;
2759                         e1000_vlan_rx_add_vid(adapter->netdev, vid);
2760                 }
2761         }
2762 }
2763
2764 int
2765 e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
2766 {
2767         adapter->hw.autoneg = 0;
2768
2769         switch(spddplx) {
2770         case SPEED_10 + DUPLEX_HALF:
2771                 adapter->hw.forced_speed_duplex = e1000_10_half;
2772                 break;
2773         case SPEED_10 + DUPLEX_FULL:
2774                 adapter->hw.forced_speed_duplex = e1000_10_full;
2775                 break;
2776         case SPEED_100 + DUPLEX_HALF:
2777                 adapter->hw.forced_speed_duplex = e1000_100_half;
2778                 break;
2779         case SPEED_100 + DUPLEX_FULL:
2780                 adapter->hw.forced_speed_duplex = e1000_100_full;
2781                 break;
2782         case SPEED_1000 + DUPLEX_FULL:
2783                 adapter->hw.autoneg = 1;
2784                 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
2785                 break;
2786         case SPEED_1000 + DUPLEX_HALF: /* not supported */
2787         default:
2788                 DPRINTK(PROBE, ERR,
2789                         "Unsupported Speed/Duplexity configuration\n");
2790                 return -EINVAL;
2791         }
2792         return 0;
2793 }
2794
2795 static int
2796 e1000_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
2797 {
2798         struct pci_dev *pdev = NULL;
2799
2800         switch(event) {
2801         case SYS_DOWN:
2802         case SYS_HALT:
2803         case SYS_POWER_OFF:
2804                 while((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev))) {
2805                         if(pci_dev_driver(pdev) == &e1000_driver)
2806                                 e1000_suspend(pdev, 3);
2807                 }
2808         }
2809         return NOTIFY_DONE;
2810 }
2811
2812 static int
2813 e1000_suspend(struct pci_dev *pdev, uint32_t state)
2814 {
2815         struct net_device *netdev = pci_get_drvdata(pdev);
2816         struct e1000_adapter *adapter = netdev->priv;
2817         uint32_t ctrl, ctrl_ext, rctl, manc, status;
2818         uint32_t wufc = adapter->wol;
2819
2820         netif_device_detach(netdev);
2821
2822         if(netif_running(netdev))
2823                 e1000_down(adapter);
2824
2825         status = E1000_READ_REG(&adapter->hw, STATUS);
2826         if(status & E1000_STATUS_LU)
2827                 wufc &= ~E1000_WUFC_LNKC;
2828
2829         if(wufc) {
2830                 e1000_setup_rctl(adapter);
2831                 e1000_set_multi(netdev);
2832
2833                 /* turn on all-multi mode if wake on multicast is enabled */
2834                 if(adapter->wol & E1000_WUFC_MC) {
2835                         rctl = E1000_READ_REG(&adapter->hw, RCTL);
2836                         rctl |= E1000_RCTL_MPE;
2837                         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2838                 }
2839
2840                 if(adapter->hw.mac_type >= e1000_82540) {
2841                         ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2842                         /* advertise wake from D3Cold */
2843                         #define E1000_CTRL_ADVD3WUC 0x00100000
2844                         /* phy power management enable */
2845                         #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
2846                         ctrl |= E1000_CTRL_ADVD3WUC |
2847                                 E1000_CTRL_EN_PHY_PWR_MGMT;
2848                         E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2849                 }
2850
2851                 if(adapter->hw.media_type == e1000_media_type_fiber ||
2852                    adapter->hw.media_type == e1000_media_type_internal_serdes) {
2853                         /* keep the laser running in D3 */
2854                         ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
2855                         ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
2856                         E1000_WRITE_REG(&adapter->hw, CTRL_EXT, ctrl_ext);
2857                 }
2858
2859                 E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
2860                 E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
2861                 pci_enable_wake(pdev, 3, 1);
2862                 pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
2863         } else {
2864                 E1000_WRITE_REG(&adapter->hw, WUC, 0);
2865                 E1000_WRITE_REG(&adapter->hw, WUFC, 0);
2866                 pci_enable_wake(pdev, 3, 0);
2867                 pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
2868         }
2869
2870         pci_save_state(pdev, adapter->pci_state);
2871
2872         if(adapter->hw.mac_type >= e1000_82540 &&
2873            adapter->hw.media_type == e1000_media_type_copper) {
2874                 manc = E1000_READ_REG(&adapter->hw, MANC);
2875                 if(manc & E1000_MANC_SMBUS_EN) {
2876                         manc |= E1000_MANC_ARP_EN;
2877                         E1000_WRITE_REG(&adapter->hw, MANC, manc);
2878                         pci_enable_wake(pdev, 3, 1);
2879                         pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
2880                 }
2881         }
2882
2883         pci_disable_device(pdev);
2884
2885         state = (state > 0) ? 3 : 0;
2886         pci_set_power_state(pdev, state);
2887
2888         return 0;
2889 }
2890
2891 #ifdef CONFIG_PM
2892 static int
2893 e1000_resume(struct pci_dev *pdev)
2894 {
2895         struct net_device *netdev = pci_get_drvdata(pdev);
2896         struct e1000_adapter *adapter = netdev->priv;
2897         uint32_t manc;
2898
2899         pci_enable_device(pdev);
2900         pci_set_power_state(pdev, 0);
2901         pci_restore_state(pdev, adapter->pci_state);
2902
2903         pci_enable_wake(pdev, 3, 0);
2904         pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
2905
2906         e1000_reset(adapter);
2907         E1000_WRITE_REG(&adapter->hw, WUS, ~0);
2908
2909         if(netif_running(netdev))
2910                 e1000_up(adapter);
2911
2912         netif_device_attach(netdev);
2913
2914         if(adapter->hw.mac_type >= e1000_82540 &&
2915            adapter->hw.media_type == e1000_media_type_copper) {
2916                 manc = E1000_READ_REG(&adapter->hw, MANC);
2917                 manc &= ~(E1000_MANC_ARP_EN);
2918                 E1000_WRITE_REG(&adapter->hw, MANC, manc);
2919         }
2920
2921         return 0;
2922 }
2923 #endif
2924
2925 #ifdef CONFIG_NET_POLL_CONTROLLER
2926 /*
2927  * Polling 'interrupt' - used by things like netconsole to send skbs
2928  * without having to re-enable interrupts. It's not called while
2929  * the interrupt routine is executing.
2930  */
2931 static void
2932 e1000_netpoll (struct net_device *netdev)
2933 {
2934         struct e1000_adapter *adapter = netdev->priv;
2935         disable_irq(adapter->pdev->irq);
2936         e1000_intr(adapter->pdev->irq, netdev, NULL);
2937         enable_irq(adapter->pdev->irq);
2938 }
2939 #endif
2940
2941 /* e1000_main.c */