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