drivers/net/e1000/e1000_main.c

   1 /*******************************************************************************
   2
   3
   4   Copyright(c) 1999 - 2002 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  *
  33  * 4.4.19       11/27/02
  34  *   o Feature: Added user-settable knob for interrupt throttle rate (ITR).
  35  *   o Cleanup: removed large static array allocations.
  36  *   o Cleanup: C99 struct initializer format.
  37  *   o Bug fix: restore VLAN settings when interface is brought up.
  38  *   o Bug fix: return cleanly in probe if error in detecting MAC type.
  39  *   o Bug fix: Wake up on magic packet by default only if enabled in eeprom.
  40  *   o Bug fix: Validate MAC address in set_mac.
  41  *   o Bug fix: Throw away zero-length Tx skbs.
  42  *   o Bug fix: Make ethtool EEPROM acceses work on older versions of ethtool.
  43  *
  44  * 4.4.12       10/15/02
  45  *   o Clean up: use members of pci_device rather than direct calls to
  46  *     pci_read_config_word.
  47  *   o Bug fix: changed default flow control settings.
  48  *   o Clean up: ethtool file now has an inclusive list for adapters in the
  49  *     Wake-On-LAN capabilities instead of an exclusive list.
  50  *   o Bug fix: miscellaneous WoL bug fixes.
  51  *   o Added software interrupt for clearing rx ring
  52  *   o Bug fix: easier to undo "forcing" of 1000/fd using ethtool.
  53  *   o Now setting netdev->mem_end in e1000_probe.
  54  *   o Clean up: Moved tx_timeout from interrupt context to process context
  55  *     using schedule_task.
  56  *
  57  * 4.3.15       8/9/02
  58  */
  59
  60 char e1000_driver_name[] = "e1000";
  61 char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
  62 char e1000_driver_version[] = "4.4.19-k2";
  63 char e1000_copyright[] = "Copyright (c) 1999-2002 Intel Corporation.";
  64
  65 /* e1000_pci_tbl - PCI Device ID Table
  66  *
  67  * Private driver_data field (last one) stores an index into e1000_strings
  68  * Wildcard entries (PCI_ANY_ID) should come last
  69  * Last entry must be all 0s
  70  *
  71  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  72  *   Class, Class Mask, String Index }
  73  */
  74 static struct pci_device_id e1000_pci_tbl[] __devinitdata = {
  75         /* Intel(R) PRO/1000 Network Connection */
  76         {0x8086, 0x1000, 0x8086, 0x1000, 0, 0, 0},
  77         {0x8086, 0x1001, 0x8086, 0x1003, 0, 0, 0},
  78         {0x8086, 0x1004, 0x8086, 0x1004, 0, 0, 0},
  79         {0x8086, 0x1008, 0x8086, 0x1107, 0, 0, 0},
  80         {0x8086, 0x1009, 0x8086, 0x1109, 0, 0, 0},
  81         {0x8086, 0x100C, 0x8086, 0x1112, 0, 0, 0},
  82         {0x8086, 0x100E, 0x8086, 0x001E, 0, 0, 0},
  83         /* Compaq Gigabit Ethernet Server Adapter */
  84         {0x8086, 0x1000, 0x0E11, PCI_ANY_ID, 0, 0, 1},
  85         {0x8086, 0x1001, 0x0E11, PCI_ANY_ID, 0, 0, 1},
  86         {0x8086, 0x1004, 0x0E11, PCI_ANY_ID, 0, 0, 1},
  87         /* IBM Mobile, Desktop & Server Adapters */
  88         {0x8086, 0x1000, 0x1014, PCI_ANY_ID, 0, 0, 2},
  89         {0x8086, 0x1001, 0x1014, PCI_ANY_ID, 0, 0, 2},
  90         {0x8086, 0x1004, 0x1014, PCI_ANY_ID, 0, 0, 2},
  91         /* Generic */
  92         {0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  93         {0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  94         {0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  95         {0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  96         {0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  97         {0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  98         {0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  99         {0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 100         {0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 101         {0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 102         {0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 103         {0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 104         {0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 105         {0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 106         {0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 107         /* required last entry */
 108         {0,}
 109 };
 110
 111 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
 112
 113 static char *e1000_strings[] = {
 114         "Intel(R) PRO/1000 Network Connection",
 115         "Compaq Gigabit Ethernet Server Adapter",
 116         "IBM Mobile, Desktop & Server Adapters"
 117 };
 118
 119 /* Local Function Prototypes */
 120
 121 int e1000_up(struct e1000_adapter *adapter);
 122 void e1000_down(struct e1000_adapter *adapter);
 123 void e1000_reset(struct e1000_adapter *adapter);
 124
 125 static int e1000_init_module(void);
 126 static void e1000_exit_module(void);
 127 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 128 static void e1000_remove(struct pci_dev *pdev);
 129 static int e1000_sw_init(struct e1000_adapter *adapter);
 130 static int e1000_open(struct net_device *netdev);
 131 static int e1000_close(struct net_device *netdev);
 132 static int e1000_setup_tx_resources(struct e1000_adapter *adapter);
 133 static int e1000_setup_rx_resources(struct e1000_adapter *adapter);
 134 static void e1000_configure_tx(struct e1000_adapter *adapter);
 135 static void e1000_configure_rx(struct e1000_adapter *adapter);
 136 static void e1000_setup_rctl(struct e1000_adapter *adapter);
 137 static void e1000_clean_tx_ring(struct e1000_adapter *adapter);
 138 static void e1000_clean_rx_ring(struct e1000_adapter *adapter);
 139 static void e1000_free_tx_resources(struct e1000_adapter *adapter);
 140 static void e1000_free_rx_resources(struct e1000_adapter *adapter);
 141 static void e1000_set_multi(struct net_device *netdev);
 142 static void e1000_update_phy_info(unsigned long data);
 143 static void e1000_watchdog(unsigned long data);
 144 static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
 145 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
 146 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
 147 static int e1000_set_mac(struct net_device *netdev, void *p);
 148 static void e1000_update_stats(struct e1000_adapter *adapter);
 149 static inline void e1000_irq_disable(struct e1000_adapter *adapter);
 150 static inline void e1000_irq_enable(struct e1000_adapter *adapter);
 151 static void e1000_intr(int irq, void *data, struct pt_regs *regs);
 152 static void e1000_clean_tx_irq(struct e1000_adapter *adapter);
 153 static void e1000_clean_rx_irq(struct e1000_adapter *adapter);
 154 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);
 155 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
 156 static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
 157 static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
 158 static inline void e1000_rx_checksum(struct e1000_adapter *adapter,
 159                                      struct e1000_rx_desc *rx_desc,
 160                                      struct sk_buff *skb);
 161 static void e1000_tx_timeout(struct net_device *dev);
 162 static void e1000_tx_timeout_task(struct net_device *dev);
 163
 164 static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
 165 static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
 166 static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
 167 static void e1000_restore_vlan(struct e1000_adapter *adapter);
 168
 169 static int e1000_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
 170 static int e1000_suspend(struct pci_dev *pdev, uint32_t state);
 171 #ifdef CONFIG_PM
 172 static int e1000_resume(struct pci_dev *pdev);
 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 extern int e1000_ethtool_ioctl(struct net_device *netdev, struct ifreq *ifr);
 185
 186 static struct pci_driver e1000_driver = {
 187         .name     = e1000_driver_name,
 188         .id_table = e1000_pci_tbl,
 189         .probe    = e1000_probe,
 190         .remove   = __devexit_p(e1000_remove),
 191         /* Power Managment Hooks */
 192 #ifdef CONFIG_PM
 193         .suspend  = e1000_suspend,
 194         .resume   = e1000_resume
 195 #endif
 196 };
 197
 198 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
 199 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
 200 MODULE_LICENSE("GPL");
 201
 202 /**
 203  * e1000_init_module - Driver Registration Routine
 204  *
 205  * e1000_init_module is the first routine called when the driver is
 206  * loaded. All it does is register with the PCI subsystem.
 207  **/
 208
 209 static int __init
 210 e1000_init_module(void)
 211 {
 212         int ret;
 213         printk(KERN_INFO "%s - version %s\n",
 214                e1000_driver_string, e1000_driver_version);
 215
 216         printk(KERN_INFO "%s\n", e1000_copyright);
 217
 218         ret = pci_module_init(&e1000_driver);
 219         if(ret >= 0)
 220                 register_reboot_notifier(&e1000_notifier_reboot);
 221         return ret;
 222 }
 223
 224 module_init(e1000_init_module);
 225
 226 /**
 227  * e1000_exit_module - Driver Exit Cleanup Routine
 228  *
 229  * e1000_exit_module is called just before the driver is removed
 230  * from memory.
 231  **/
 232
 233 static void __exit
 234 e1000_exit_module(void)
 235 {
 236         unregister_reboot_notifier(&e1000_notifier_reboot);
 237         pci_unregister_driver(&e1000_driver);
 238 }
 239
 240 module_exit(e1000_exit_module);
 241
 242
 243 int
 244 e1000_up(struct e1000_adapter *adapter)
 245 {
 246         struct net_device *netdev = adapter->netdev;
 247
 248         if(request_irq(netdev->irq, &e1000_intr, SA_SHIRQ | SA_SAMPLE_RANDOM,
 249                        netdev->name, netdev))
 250                 return -1;
 251
 252         /* hardware has been reset, we need to reload some things */
 253
 254         e1000_set_multi(netdev);
 255         e1000_restore_vlan(adapter);
 256
 257         e1000_configure_tx(adapter);
 258         e1000_setup_rctl(adapter);
 259         e1000_configure_rx(adapter);
 260         e1000_alloc_rx_buffers(adapter);
 261
 262         mod_timer(&adapter->watchdog_timer, jiffies);
 263         e1000_irq_enable(adapter);
 264
 265         return 0;
 266 }
 267
 268 void
 269 e1000_down(struct e1000_adapter *adapter)
 270 {
 271         struct net_device *netdev = adapter->netdev;
 272
 273         e1000_irq_disable(adapter);
 274         free_irq(netdev->irq, netdev);
 275         del_timer_sync(&adapter->watchdog_timer);
 276         del_timer_sync(&adapter->phy_info_timer);
 277         adapter->link_speed = 0;
 278         adapter->link_duplex = 0;
 279         netif_carrier_off(netdev);
 280         netif_stop_queue(netdev);
 281
 282         e1000_reset(adapter);
 283         e1000_clean_tx_ring(adapter);
 284         e1000_clean_rx_ring(adapter);
 285 }
 286
 287 void
 288 e1000_reset(struct e1000_adapter *adapter)
 289 {
 290         /* Repartition Pba for greater than 9k mtu
 291          * To take effect CTRL.RST is required.
 292          */
 293
 294         if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
 295                 E1000_WRITE_REG(&adapter->hw, PBA, E1000_JUMBO_PBA);
 296         else
 297                 E1000_WRITE_REG(&adapter->hw, PBA, E1000_DEFAULT_PBA);
 298
 299         adapter->hw.fc = adapter->hw.original_fc;
 300         e1000_reset_hw(&adapter->hw);
 301         if(adapter->hw.mac_type >= e1000_82544)
 302                 E1000_WRITE_REG(&adapter->hw, WUC, 0);
 303         e1000_init_hw(&adapter->hw);
 304         e1000_reset_adaptive(&adapter->hw);
 305         e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
 306 }
 307
 308 /**
 309  * e1000_probe - Device Initialization Routine
 310  * @pdev: PCI device information struct
 311  * @ent: entry in e1000_pci_tbl
 312  *
 313  * Returns 0 on success, negative on failure
 314  *
 315  * e1000_probe initializes an adapter identified by a pci_dev structure.
 316  * The OS initialization, configuring of the adapter private structure,
 317  * and a hardware reset occur.
 318  **/
 319
 320 static int __devinit
 321 e1000_probe(struct pci_dev *pdev,
 322             const struct pci_device_id *ent)
 323 {
 324         struct net_device *netdev;
 325         struct e1000_adapter *adapter;
 326         static int cards_found = 0;
 327         unsigned long mmio_start;
 328         int mmio_len;
 329         int pci_using_dac;
 330         int i;
 331         uint16_t eeprom_data;
 332
 333         if((i = pci_enable_device(pdev)))
 334                 return i;
 335
 336         if(!(i = pci_set_dma_mask(pdev, PCI_DMA_64BIT))) {
 337                 pci_using_dac = 1;
 338         } else {
 339                 if((i = pci_set_dma_mask(pdev, PCI_DMA_32BIT))) {
 340                         E1000_ERR("No usable DMA configuration, aborting\n");
 341                         return i;
 342                 }
 343                 pci_using_dac = 0;
 344         }
 345
 346         if((i = pci_request_regions(pdev, e1000_driver_name)))
 347                 return i;
 348
 349         pci_set_master(pdev);
 350
 351         netdev = alloc_etherdev(sizeof(struct e1000_adapter));
 352         if(!netdev)
 353                 goto err_alloc_etherdev;
 354
 355         SET_MODULE_OWNER(netdev);
 356
 357         pci_set_drvdata(pdev, netdev);
 358         adapter = netdev->priv;
 359         adapter->netdev = netdev;
 360         adapter->pdev = pdev;
 361         adapter->hw.back = adapter;
 362
 363         mmio_start = pci_resource_start(pdev, BAR_0);
 364         mmio_len = pci_resource_len(pdev, BAR_0);
 365
 366         adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
 367         if(!adapter->hw.hw_addr)
 368                 goto err_ioremap;
 369
 370         for(i = BAR_1; i <= BAR_5; i++) {
 371                 if(pci_resource_len(pdev, i) == 0)
 372                         continue;
 373                 if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {
 374                         adapter->hw.io_base = pci_resource_start(pdev, i);
 375                         break;
 376                 }
 377         }
 378
 379         netdev->open = &e1000_open;
 380         netdev->stop = &e1000_close;
 381         netdev->hard_start_xmit = &e1000_xmit_frame;
 382         netdev->get_stats = &e1000_get_stats;
 383         netdev->set_multicast_list = &e1000_set_multi;
 384         netdev->set_mac_address = &e1000_set_mac;
 385         netdev->change_mtu = &e1000_change_mtu;
 386         netdev->do_ioctl = &e1000_ioctl;
 387         netdev->tx_timeout = &e1000_tx_timeout;
 388         netdev->watchdog_timeo = HZ;
 389         netdev->vlan_rx_register = e1000_vlan_rx_register;
 390         netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
 391         netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
 392
 393         netdev->irq = pdev->irq;
 394         netdev->mem_start = mmio_start;
 395         netdev->mem_end = mmio_start + mmio_len;
 396         netdev->base_addr = adapter->hw.io_base;
 397
 398         adapter->bd_number = cards_found;
 399         adapter->id_string = e1000_strings[ent->driver_data];
 400
 401         /* setup the private structure */
 402
 403         if(e1000_sw_init(adapter))
 404                 goto err_sw_init;
 405
 406         if(adapter->hw.mac_type >= e1000_82543) {
 407                 netdev->features = NETIF_F_SG |
 408                                    NETIF_F_HW_CSUM |
 409                                    NETIF_F_HW_VLAN_TX |
 410                                    NETIF_F_HW_VLAN_RX |
 411                                    NETIF_F_HW_VLAN_FILTER;
 412         } else {
 413                 netdev->features = NETIF_F_SG;
 414         }
 415
 416         if(pci_using_dac)
 417                 netdev->features |= NETIF_F_HIGHDMA;
 418
 419         /* make sure the EEPROM is good */
 420
 421         if(e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
 422                 printk(KERN_ERR "The EEPROM Checksum Is Not Valid\n");
 423                 goto err_eeprom;
 424         }
 425
 426         /* copy the MAC address out of the EEPROM */
 427
 428         e1000_read_mac_addr(&adapter->hw);
 429         memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
 430
 431         if(!is_valid_ether_addr(netdev->dev_addr))
 432                 goto err_eeprom;
 433
 434         e1000_read_part_num(&adapter->hw, &(adapter->part_num));
 435
 436         e1000_get_bus_info(&adapter->hw);
 437
 438         if((adapter->hw.mac_type == e1000_82544) &&
 439            (adapter->hw.bus_type == e1000_bus_type_pcix))
 440
 441                 adapter->max_data_per_txd = 4096;
 442         else
 443                 adapter->max_data_per_txd = MAX_JUMBO_FRAME_SIZE;
 444
 445
 446         init_timer(&adapter->watchdog_timer);
 447         adapter->watchdog_timer.function = &e1000_watchdog;
 448         adapter->watchdog_timer.data = (unsigned long) adapter;
 449
 450         init_timer(&adapter->phy_info_timer);
 451         adapter->phy_info_timer.function = &e1000_update_phy_info;
 452         adapter->phy_info_timer.data = (unsigned long) adapter;
 453
 454         INIT_TQUEUE(&adapter->tx_timeout_task,
 455                 (void (*)(void *))e1000_tx_timeout_task, netdev);
 456
 457         register_netdev(netdev);
 458         memcpy(adapter->ifname, netdev->name, IFNAMSIZ);
 459         adapter->ifname[IFNAMSIZ-1] = 0;
 460
 461         /* we're going to reset, so assume we have no link for now */
 462
 463         netif_carrier_off(netdev);
 464         netif_stop_queue(netdev);
 465
 466         printk(KERN_INFO "%s: %s\n", netdev->name, adapter->id_string);
 467         e1000_check_options(adapter);
 468
 469         /* Initial Wake on LAN setting
 470          * If APM wake is enabled in the EEPROM,
 471          * enable the ACPI Magic Packet filter
 472          */
 473
 474         e1000_read_eeprom(&adapter->hw, EEPROM_INIT_CONTROL2_REG, &eeprom_data);
 475         if((adapter->hw.mac_type >= e1000_82544) &&
 476            (eeprom_data & E1000_EEPROM_APME))
 477                 adapter->wol |= E1000_WUFC_MAG;
 478
 479         /* reset the hardware with the new settings */
 480
 481         e1000_reset(adapter);
 482
 483         cards_found++;
 484         return 0;
 485
 486 err_sw_init:
 487 err_eeprom:
 488         iounmap(adapter->hw.hw_addr);
 489 err_ioremap:
 490         pci_release_regions(pdev);
 491         kfree(netdev);
 492 err_alloc_etherdev:
 493         return -ENOMEM;
 494 }
 495
 496 /**
 497  * e1000_remove - Device Removal Routine
 498  * @pdev: PCI device information struct
 499  *
 500  * e1000_remove is called by the PCI subsystem to alert the driver
 501  * that it should release a PCI device.  The could be caused by a
 502  * Hot-Plug event, or because the driver is going to be removed from
 503  * memory.
 504  **/
 505
 506 static void __devexit
 507 e1000_remove(struct pci_dev *pdev)
 508 {
 509         struct net_device *netdev = pci_get_drvdata(pdev);
 510         struct e1000_adapter *adapter = netdev->priv;
 511         uint32_t manc;
 512
 513         if(adapter->hw.mac_type >= e1000_82540) {
 514                 manc = E1000_READ_REG(&adapter->hw, MANC);
 515                 if(manc & E1000_MANC_SMBUS_EN) {
 516                         manc |= E1000_MANC_ARP_EN;
 517                         E1000_WRITE_REG(&adapter->hw, MANC, manc);
 518                 }
 519         }
 520
 521         unregister_netdev(netdev);
 522
 523         e1000_phy_hw_reset(&adapter->hw);
 524
 525         iounmap(adapter->hw.hw_addr);
 526         pci_release_regions(pdev);
 527
 528         kfree(netdev);
 529 }
 530
 531 /**
 532  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
 533  * @adapter: board private structure to initialize
 534  *
 535  * e1000_sw_init initializes the Adapter private data structure.
 536  * Fields are initialized based on PCI device information and
 537  * OS network device settings (MTU size).
 538  **/
 539
 540 static int __devinit
 541 e1000_sw_init(struct e1000_adapter *adapter)
 542 {
 543         struct e1000_hw *hw = &adapter->hw;
 544         struct net_device *netdev = adapter->netdev;
 545         struct pci_dev *pdev = adapter->pdev;
 546
 547         /* PCI config space info */
 548
 549         hw->vendor_id = pdev->vendor;
 550         hw->device_id = pdev->device;
 551         hw->subsystem_vendor_id = pdev->subsystem_vendor;
 552         hw->subsystem_id = pdev->subsystem_device;
 553
 554         pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
 555
 556         pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
 557
 558         adapter->rx_buffer_len = E1000_RXBUFFER_2048;
 559         hw->max_frame_size = netdev->mtu +
 560                                  ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
 561         hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
 562
 563         /* identify the MAC */
 564
 565         if (e1000_set_mac_type(hw)) {
 566                 E1000_ERR("Unknown MAC Type\n");
 567                 return -1;
 568         }
 569
 570         /* flow control settings */
 571
 572         hw->fc_high_water = E1000_FC_HIGH_THRESH;
 573         hw->fc_low_water = E1000_FC_LOW_THRESH;
 574         hw->fc_pause_time = E1000_FC_PAUSE_TIME;
 575         hw->fc_send_xon = 1;
 576
 577         /* Media type - copper or fiber */
 578
 579         if(hw->mac_type >= e1000_82543) {
 580                 uint32_t status = E1000_READ_REG(hw, STATUS);
 581
 582                 if(status & E1000_STATUS_TBIMODE)
 583                         hw->media_type = e1000_media_type_fiber;
 584                 else
 585                         hw->media_type = e1000_media_type_copper;
 586         } else {
 587                 hw->media_type = e1000_media_type_fiber;
 588         }
 589
 590         if(hw->mac_type < e1000_82543)
 591                 hw->report_tx_early = 0;
 592         else
 593                 hw->report_tx_early = 1;
 594
 595         hw->wait_autoneg_complete = FALSE;
 596         hw->tbi_compatibility_en = TRUE;
 597         hw->adaptive_ifs = TRUE;
 598
 599         /* Copper options */
 600
 601         if(hw->media_type == e1000_media_type_copper) {
 602                 hw->mdix = AUTO_ALL_MODES;
 603                 hw->disable_polarity_correction = FALSE;
 604         }
 605
 606         atomic_set(&adapter->irq_sem, 1);
 607         spin_lock_init(&adapter->stats_lock);
 608
 609         return 0;
 610 }
 611
 612 /**
 613  * e1000_open - Called when a network interface is made active
 614  * @netdev: network interface device structure
 615  *
 616  * Returns 0 on success, negative value on failure
 617  *
 618  * The open entry point is called when a network interface is made
 619  * active by the system (IFF_UP).  At this point all resources needed
 620  * for transmit and receive operations are allocated, the interrupt
 621  * handler is registered with the OS, the watchdog timer is started,
 622  * and the stack is notified that the interface is ready.
 623  **/
 624
 625 static int
 626 e1000_open(struct net_device *netdev)
 627 {
 628         struct e1000_adapter *adapter = netdev->priv;
 629
 630         /* allocate transmit descriptors */
 631
 632         if(e1000_setup_tx_resources(adapter))
 633                 goto err_setup_tx;
 634
 635         /* allocate receive descriptors */
 636
 637         if(e1000_setup_rx_resources(adapter))
 638                 goto err_setup_rx;
 639
 640         if(e1000_up(adapter))
 641                 goto err_up;
 642
 643         return 0;
 644
 645 err_up:
 646         e1000_free_rx_resources(adapter);
 647 err_setup_rx:
 648         e1000_free_tx_resources(adapter);
 649 err_setup_tx:
 650         e1000_reset(adapter);
 651
 652         return -EBUSY;
 653 }
 654
 655 /**
 656  * e1000_close - Disables a network interface
 657  * @netdev: network interface device structure
 658  *
 659  * Returns 0, this is not allowed to fail
 660  *
 661  * The close entry point is called when an interface is de-activated
 662  * by the OS.  The hardware is still under the drivers control, but
 663  * needs to be disabled.  A global MAC reset is issued to stop the
 664  * hardware, and all transmit and receive resources are freed.
 665  **/
 666
 667 static int
 668 e1000_close(struct net_device *netdev)
 669 {
 670         struct e1000_adapter *adapter = netdev->priv;
 671
 672         e1000_down(adapter);
 673
 674         e1000_free_tx_resources(adapter);
 675         e1000_free_rx_resources(adapter);
 676
 677         return 0;
 678 }
 679
 680 /**
 681  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 682  * @adapter: board private structure
 683  *
 684  * Return 0 on success, negative on failure
 685  **/
 686
 687 static int
 688 e1000_setup_tx_resources(struct e1000_adapter *adapter)
 689 {
 690         struct e1000_desc_ring *txdr = &adapter->tx_ring;
 691         struct pci_dev *pdev = adapter->pdev;
 692         int size;
 693
 694         size = sizeof(struct e1000_buffer) * txdr->count;
 695         txdr->buffer_info = kmalloc(size, GFP_KERNEL);
 696         if(!txdr->buffer_info) {
 697                 return -ENOMEM;
 698         }
 699         memset(txdr->buffer_info, 0, size);
 700
 701         /* round up to nearest 4K */
 702
 703         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
 704         E1000_ROUNDUP(txdr->size, 4096);
 705
 706         txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
 707         if(!txdr->desc) {
 708                 kfree(txdr->buffer_info);
 709                 return -ENOMEM;
 710         }
 711         memset(txdr->desc, 0, txdr->size);
 712
 713         txdr->next_to_use = 0;
 714         txdr->next_to_clean = 0;
 715
 716         return 0;
 717 }
 718
 719 /**
 720  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
 721  * @adapter: board private structure
 722  *
 723  * Configure the Tx unit of the MAC after a reset.
 724  **/
 725
 726 static void
 727 e1000_configure_tx(struct e1000_adapter *adapter)
 728 {
 729         uint64_t tdba = adapter->tx_ring.dma;
 730         uint32_t tdlen = adapter->tx_ring.count * sizeof(struct e1000_tx_desc);
 731         uint32_t tctl, tipg;
 732
 733         E1000_WRITE_REG(&adapter->hw, TDBAL, (tdba & 0x00000000ffffffffULL));
 734         E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
 735
 736         E1000_WRITE_REG(&adapter->hw, TDLEN, tdlen);
 737
 738         /* Setup the HW Tx Head and Tail descriptor pointers */
 739
 740         E1000_WRITE_REG(&adapter->hw, TDH, 0);
 741         E1000_WRITE_REG(&adapter->hw, TDT, 0);
 742
 743         /* Set the default values for the Tx Inter Packet Gap timer */
 744
 745         switch (adapter->hw.mac_type) {
 746         case e1000_82542_rev2_0:
 747         case e1000_82542_rev2_1:
 748                 tipg = DEFAULT_82542_TIPG_IPGT;
 749                 tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
 750                 tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
 751                 break;
 752         default:
 753                 if(adapter->hw.media_type == e1000_media_type_fiber)
 754                         tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
 755                 else
 756                         tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
 757                 tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
 758                 tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
 759         }
 760         E1000_WRITE_REG(&adapter->hw, TIPG, tipg);
 761
 762         /* Set the Tx Interrupt Delay register */
 763
 764         E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
 765         if(adapter->hw.mac_type >= e1000_82540)
 766                 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
 767
 768         /* Program the Transmit Control Register */
 769
 770         tctl = E1000_READ_REG(&adapter->hw, TCTL);
 771
 772         tctl &= ~E1000_TCTL_CT;
 773         tctl |= E1000_TCTL_EN | E1000_TCTL_PSP |
 774                (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
 775
 776         E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
 777
 778         e1000_config_collision_dist(&adapter->hw);
 779
 780         /* Setup Transmit Descriptor Settings for this adapter */
 781         adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_IDE;
 782
 783         if(adapter->hw.report_tx_early == 1)
 784                 adapter->txd_cmd |= E1000_TXD_CMD_RS;
 785         else
 786                 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
 787 }
 788
 789 /**
 790  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 791  * @adapter: board private structure
 792  *
 793  * Returns 0 on success, negative on failure
 794  **/
 795
 796 static int
 797 e1000_setup_rx_resources(struct e1000_adapter *adapter)
 798 {
 799         struct e1000_desc_ring *rxdr = &adapter->rx_ring;
 800         struct pci_dev *pdev = adapter->pdev;
 801         int size;
 802
 803         size = sizeof(struct e1000_buffer) * rxdr->count;
 804         rxdr->buffer_info = kmalloc(size, GFP_KERNEL);
 805         if(!rxdr->buffer_info) {
 806                 return -ENOMEM;
 807         }
 808         memset(rxdr->buffer_info, 0, size);
 809
 810         /* Round up to nearest 4K */
 811
 812         rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
 813         E1000_ROUNDUP(rxdr->size, 4096);
 814
 815         rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
 816
 817         if(!rxdr->desc) {
 818                 kfree(rxdr->buffer_info);
 819                 return -ENOMEM;
 820         }
 821         memset(rxdr->desc, 0, rxdr->size);
 822
 823         rxdr->next_to_clean = 0;
 824         rxdr->next_to_use = 0;
 825
 826         return 0;
 827 }
 828
 829 /**
 830  * e1000_setup_rctl - configure the receive control register
 831  * @adapter: Board private structure
 832  **/
 833
 834 static void
 835 e1000_setup_rctl(struct e1000_adapter *adapter)
 836 {
 837         uint32_t rctl;
 838
 839         rctl = E1000_READ_REG(&adapter->hw, RCTL);
 840
 841         rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
 842
 843         rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
 844                 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
 845                 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
 846
 847         if(adapter->hw.tbi_compatibility_on == 1)
 848                 rctl |= E1000_RCTL_SBP;
 849         else
 850                 rctl &= ~E1000_RCTL_SBP;
 851
 852         rctl &= ~(E1000_RCTL_SZ_4096);
 853         switch (adapter->rx_buffer_len) {
 854         case E1000_RXBUFFER_2048:
 855         default:
 856                 rctl |= E1000_RCTL_SZ_2048;
 857                 rctl &= ~(E1000_RCTL_BSEX | E1000_RCTL_LPE);
 858                 break;
 859         case E1000_RXBUFFER_4096:
 860                 rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
 861                 break;
 862         case E1000_RXBUFFER_8192:
 863                 rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
 864                 break;
 865         case E1000_RXBUFFER_16384:
 866                 rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
 867                 break;
 868         }
 869
 870         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
 871 }
 872
 873 /**
 874  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
 875  * @adapter: board private structure
 876  *
 877  * Configure the Rx unit of the MAC after a reset.
 878  **/
 879
 880 static void
 881 e1000_configure_rx(struct e1000_adapter *adapter)
 882 {
 883         uint64_t rdba = adapter->rx_ring.dma;
 884         uint32_t rdlen = adapter->rx_ring.count * sizeof(struct e1000_rx_desc);
 885         uint32_t rctl;
 886         uint32_t rxcsum;
 887
 888         /* make sure receives are disabled while setting up the descriptors */
 889
 890         rctl = E1000_READ_REG(&adapter->hw, RCTL);
 891         E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
 892
 893         /* set the Receive Delay Timer Register */
 894
 895         E1000_WRITE_REG(&adapter->hw, RDTR, adapter->rx_int_delay);
 896
 897         if(adapter->hw.mac_type >= e1000_82540) {
 898                 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
 899
 900                 /* Set the interrupt throttling rate.  Value is calculated
 901                  * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
 902 #define MAX_INTS_PER_SEC        8000
 903 #define DEFAULT_ITR             1000000000/(MAX_INTS_PER_SEC * 256)
 904                 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
 905         }
 906
 907         /* Setup the Base and Length of the Rx Descriptor Ring */
 908
 909         E1000_WRITE_REG(&adapter->hw, RDBAL, (rdba & 0x00000000ffffffffULL));
 910         E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
 911
 912         E1000_WRITE_REG(&adapter->hw, RDLEN, rdlen);
 913
 914         /* Setup the HW Rx Head and Tail Descriptor Pointers */
 915         E1000_WRITE_REG(&adapter->hw, RDH, 0);
 916         E1000_WRITE_REG(&adapter->hw, RDT, 0);
 917
 918         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
 919         if((adapter->hw.mac_type >= e1000_82543) &&
 920            (adapter->rx_csum == TRUE)) {
 921                 rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
 922                 rxcsum |= E1000_RXCSUM_TUOFL;
 923                 E1000_WRITE_REG(&adapter->hw, RXCSUM, rxcsum);
 924         }
 925
 926         /* Enable Receives */
 927
 928         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
 929 }
 930
 931 /**
 932  * e1000_free_tx_resources - Free Tx Resources
 933  * @adapter: board private structure
 934  *
 935  * Free all transmit software resources
 936  **/
 937
 938 static void
 939 e1000_free_tx_resources(struct e1000_adapter *adapter)
 940 {
 941         struct pci_dev *pdev = adapter->pdev;
 942
 943         e1000_clean_tx_ring(adapter);
 944
 945         kfree(adapter->tx_ring.buffer_info);
 946         adapter->tx_ring.buffer_info = NULL;
 947
 948         pci_free_consistent(pdev, adapter->tx_ring.size,
 949                             adapter->tx_ring.desc, adapter->tx_ring.dma);
 950
 951         adapter->tx_ring.desc = NULL;
 952 }
 953
 954 /**
 955  * e1000_clean_tx_ring - Free Tx Buffers
 956  * @adapter: board private structure
 957  **/
 958
 959 static void
 960 e1000_clean_tx_ring(struct e1000_adapter *adapter)
 961 {
 962         struct pci_dev *pdev = adapter->pdev;
 963         unsigned long size;
 964         int i;
 965
 966         /* Free all the Tx ring sk_buffs */
 967
 968         for(i = 0; i < adapter->tx_ring.count; i++) {
 969                 if(adapter->tx_ring.buffer_info[i].skb) {
 970
 971                         pci_unmap_page(pdev,
 972                                        adapter->tx_ring.buffer_info[i].dma,
 973                                        adapter->tx_ring.buffer_info[i].length,
 974                                        PCI_DMA_TODEVICE);
 975
 976                         dev_kfree_skb(adapter->tx_ring.buffer_info[i].skb);
 977
 978                         adapter->tx_ring.buffer_info[i].skb = NULL;
 979                 }
 980         }
 981
 982         size = sizeof(struct e1000_buffer) * adapter->tx_ring.count;
 983         memset(adapter->tx_ring.buffer_info, 0, size);
 984
 985         /* Zero out the descriptor ring */
 986
 987         memset(adapter->tx_ring.desc, 0, adapter->tx_ring.size);
 988
 989         adapter->tx_ring.next_to_use = 0;
 990         adapter->tx_ring.next_to_clean = 0;
 991
 992         E1000_WRITE_REG(&adapter->hw, TDH, 0);
 993         E1000_WRITE_REG(&adapter->hw, TDT, 0);
 994 }
 995
 996 /**
 997  * e1000_free_rx_resources - Free Rx Resources
 998  * @adapter: board private structure
 999  *
1000  * Free all receive software resources
1001  **/
1002
1003 static void
1004 e1000_free_rx_resources(struct e1000_adapter *adapter)
1005 {
1006         struct pci_dev *pdev = adapter->pdev;
1007
1008         e1000_clean_rx_ring(adapter);
1009
1010         kfree(adapter->rx_ring.buffer_info);
1011         adapter->rx_ring.buffer_info = NULL;
1012
1013         pci_free_consistent(pdev, adapter->rx_ring.size,
1014                             adapter->rx_ring.desc, adapter->rx_ring.dma);
1015
1016         adapter->rx_ring.desc = NULL;
1017 }
1018
1019 /**
1020  * e1000_clean_rx_ring - Free Rx Buffers
1021  * @adapter: board private structure
1022  **/
1023
1024 static void
1025 e1000_clean_rx_ring(struct e1000_adapter *adapter)
1026 {
1027         struct pci_dev *pdev = adapter->pdev;
1028         unsigned long size;
1029         int i;
1030
1031         /* Free all the Rx ring sk_buffs */
1032
1033         for(i = 0; i < adapter->rx_ring.count; i++) {
1034                 if(adapter->rx_ring.buffer_info[i].skb) {
1035
1036                         pci_unmap_single(pdev,
1037                                          adapter->rx_ring.buffer_info[i].dma,
1038                                          adapter->rx_ring.buffer_info[i].length,
1039                                          PCI_DMA_FROMDEVICE);
1040
1041                         dev_kfree_skb(adapter->rx_ring.buffer_info[i].skb);
1042
1043                         adapter->rx_ring.buffer_info[i].skb = NULL;
1044                 }
1045         }
1046
1047         size = sizeof(struct e1000_buffer) * adapter->rx_ring.count;
1048         memset(adapter->rx_ring.buffer_info, 0, size);
1049
1050         /* Zero out the descriptor ring */
1051
1052         memset(adapter->rx_ring.desc, 0, adapter->rx_ring.size);
1053
1054         adapter->rx_ring.next_to_clean = 0;
1055         adapter->rx_ring.next_to_use = 0;
1056
1057         E1000_WRITE_REG(&adapter->hw, RDH, 0);
1058         E1000_WRITE_REG(&adapter->hw, RDT, 0);
1059 }
1060
1061 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
1062  * and memory write and invalidate disabled for certain operations
1063  */
1064 static void
1065 e1000_enter_82542_rst(struct e1000_adapter *adapter)
1066 {
1067         struct net_device *netdev = adapter->netdev;
1068         uint32_t rctl;
1069
1070         e1000_pci_clear_mwi(&adapter->hw);
1071
1072         rctl = E1000_READ_REG(&adapter->hw, RCTL);
1073         rctl |= E1000_RCTL_RST;
1074         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1075         E1000_WRITE_FLUSH(&adapter->hw);
1076         mdelay(5);
1077
1078         if(netif_running(netdev))
1079                 e1000_clean_rx_ring(adapter);
1080 }
1081
1082 static void
1083 e1000_leave_82542_rst(struct e1000_adapter *adapter)
1084 {
1085         struct net_device *netdev = adapter->netdev;
1086         uint32_t rctl;
1087
1088         rctl = E1000_READ_REG(&adapter->hw, RCTL);
1089         rctl &= ~E1000_RCTL_RST;
1090         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1091         E1000_WRITE_FLUSH(&adapter->hw);
1092         mdelay(5);
1093
1094         if(adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
1095                 e1000_pci_set_mwi(&adapter->hw);
1096
1097         if(netif_running(netdev)) {
1098                 e1000_configure_rx(adapter);
1099                 e1000_alloc_rx_buffers(adapter);
1100         }
1101 }
1102
1103 /**
1104  * e1000_set_mac - Change the Ethernet Address of the NIC
1105  * @netdev: network interface device structure
1106  * @p: pointer to an address structure
1107  *
1108  * Returns 0 on success, negative on failure
1109  **/
1110
1111 static int
1112 e1000_set_mac(struct net_device *netdev, void *p)
1113 {
1114         struct e1000_adapter *adapter = netdev->priv;
1115         struct sockaddr *addr = p;
1116
1117         if(!is_valid_ether_addr(addr->sa_data))
1118                 return -EADDRNOTAVAIL;
1119
1120         /* 82542 2.0 needs to be in reset to write receive address registers */
1121
1122         if(adapter->hw.mac_type == e1000_82542_rev2_0)
1123                 e1000_enter_82542_rst(adapter);
1124
1125         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
1126         memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
1127
1128         e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
1129
1130         if(adapter->hw.mac_type == e1000_82542_rev2_0)
1131                 e1000_leave_82542_rst(adapter);
1132
1133         return 0;
1134 }
1135
1136 /**
1137  * e1000_set_multi - Multicast and Promiscuous mode set
1138  * @netdev: network interface device structure
1139  *
1140  * The set_multi entry point is called whenever the multicast address
1141  * list or the network interface flags are updated.  This routine is
1142  * resposible for configuring the hardware for proper multicast,
1143  * promiscuous mode, and all-multi behavior.
1144  **/
1145
1146 static void
1147 e1000_set_multi(struct net_device *netdev)
1148 {
1149         struct e1000_adapter *adapter = netdev->priv;
1150         struct e1000_hw *hw = &adapter->hw;
1151         struct dev_mc_list *mc_ptr;
1152         uint32_t rctl;
1153         uint32_t hash_value;
1154         int i;
1155
1156         /* Check for Promiscuous and All Multicast modes */
1157
1158         rctl = E1000_READ_REG(hw, RCTL);
1159
1160         if(netdev->flags & IFF_PROMISC) {
1161                 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1162         } else if(netdev->flags & IFF_ALLMULTI) {
1163                 rctl |= E1000_RCTL_MPE;
1164                 rctl &= ~E1000_RCTL_UPE;
1165         } else {
1166                 rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
1167         }
1168
1169         E1000_WRITE_REG(hw, RCTL, rctl);
1170
1171         /* 82542 2.0 needs to be in reset to write receive address registers */
1172
1173         if(hw->mac_type == e1000_82542_rev2_0)
1174                 e1000_enter_82542_rst(adapter);
1175
1176         /* load the first 15 multicast address into the exact filters 1-15
1177          * RAR 0 is used for the station MAC adddress
1178          * if there are not 15 addresses, go ahead and clear the filters
1179          */
1180         mc_ptr = netdev->mc_list;
1181
1182         for(i = 1; i < E1000_RAR_ENTRIES; i++) {
1183                 if(mc_ptr) {
1184                         e1000_rar_set(hw, mc_ptr->dmi_addr, i);
1185                         mc_ptr = mc_ptr->next;
1186                 } else {
1187                         E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
1188                         E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
1189                 }
1190         }
1191
1192         /* clear the old settings from the multicast hash table */
1193
1194         for(i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
1195                 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
1196
1197         /* load any remaining addresses into the hash table */
1198
1199         for(; mc_ptr; mc_ptr = mc_ptr->next) {
1200                 hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
1201                 e1000_mta_set(hw, hash_value);
1202         }
1203
1204         if(hw->mac_type == e1000_82542_rev2_0)
1205                 e1000_leave_82542_rst(adapter);
1206 }
1207
1208
1209 /* need to wait a few seconds after link up to get diagnostic information from the phy */
1210
1211 static void
1212 e1000_update_phy_info(unsigned long data)
1213 {
1214         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1215         e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
1216 }
1217
1218 /**
1219  * e1000_watchdog - Timer Call-back
1220  * @data: pointer to netdev cast into an unsigned long
1221  **/
1222
1223 static void
1224 e1000_watchdog(unsigned long data)
1225 {
1226         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1227         struct net_device *netdev = adapter->netdev;
1228         struct e1000_desc_ring *txdr = &adapter->tx_ring;
1229         int i;
1230
1231         e1000_check_for_link(&adapter->hw);
1232
1233         if(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
1234                 if(!netif_carrier_ok(netdev)) {
1235                         e1000_get_speed_and_duplex(&adapter->hw,
1236                                                    &adapter->link_speed,
1237                                                    &adapter->link_duplex);
1238
1239                         printk(KERN_INFO
1240                                "e1000: %s NIC Link is Up %d Mbps %s\n",
1241                                netdev->name, adapter->link_speed,
1242                                adapter->link_duplex == FULL_DUPLEX ?
1243                                "Full Duplex" : "Half Duplex");
1244
1245                         netif_carrier_on(netdev);
1246                         netif_wake_queue(netdev);
1247                         mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1248                 }
1249         } else {
1250                 if(netif_carrier_ok(netdev)) {
1251                         adapter->link_speed = 0;
1252                         adapter->link_duplex = 0;
1253                         printk(KERN_INFO
1254                                "e1000: %s NIC Link is Down\n",
1255                                netdev->name);
1256                         netif_carrier_off(netdev);
1257                         netif_stop_queue(netdev);
1258                         mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1259                 }
1260         }
1261
1262         e1000_update_stats(adapter);
1263         e1000_update_adaptive(&adapter->hw);
1264
1265
1266         /* Cause software interrupt to ensure rx ring is cleaned */
1267         E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0);
1268
1269         /* Early detection of hung controller */
1270         i = txdr->next_to_clean;
1271         if(txdr->buffer_info[i].dma &&
1272            time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) &&
1273            !(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF))
1274                 netif_stop_queue(netdev);
1275
1276         /* Reset the timer */
1277         mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1278 }
1279
1280 #define E1000_TX_FLAGS_CSUM             0x00000001
1281 #define E1000_TX_FLAGS_VLAN             0x00000002
1282 #define E1000_TX_FLAGS_VLAN_MASK        0xffff0000
1283 #define E1000_TX_FLAGS_VLAN_SHIFT       16
1284
1285 static inline boolean_t
1286 e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
1287 {
1288         struct e1000_context_desc *context_desc;
1289         int i;
1290         uint8_t css, cso;
1291
1292         if(skb->ip_summed == CHECKSUM_HW) {
1293                 css = skb->h.raw - skb->data;
1294                 cso = (skb->h.raw + skb->csum) - skb->data;
1295
1296                 i = adapter->tx_ring.next_to_use;
1297                 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1298
1299                 context_desc->upper_setup.tcp_fields.tucss = css;
1300                 context_desc->upper_setup.tcp_fields.tucso = cso;
1301                 context_desc->upper_setup.tcp_fields.tucse = 0;
1302                 context_desc->tcp_seg_setup.data = 0;
1303                 context_desc->cmd_and_length =
1304                         cpu_to_le32(adapter->txd_cmd | E1000_TXD_CMD_DEXT);
1305
1306                 i = (i + 1) % adapter->tx_ring.count;
1307                 adapter->tx_ring.next_to_use = i;
1308
1309                 return TRUE;
1310         }
1311
1312         return FALSE;
1313 }
1314
1315 static inline int
1316 e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb)
1317 {
1318         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1319         int len, offset, size, count, i;
1320
1321         int f;
1322         len = skb->len - skb->data_len;
1323         i = (tx_ring->next_to_use + tx_ring->count - 1) % tx_ring->count;
1324         count = 0;
1325
1326         offset = 0;
1327
1328         while(len) {
1329                 i = (i + 1) % tx_ring->count;
1330                 size = min(len, adapter->max_data_per_txd);
1331                 tx_ring->buffer_info[i].length = size;
1332                 tx_ring->buffer_info[i].dma =
1333                         pci_map_single(adapter->pdev,
1334                                 skb->data + offset,
1335                                 size,
1336                                 PCI_DMA_TODEVICE);
1337                 tx_ring->buffer_info[i].time_stamp = jiffies;
1338
1339                 len -= size;
1340                 offset += size;
1341                 count++;
1342         }
1343
1344         for(f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
1345                 struct skb_frag_struct *frag;
1346
1347                 frag = &skb_shinfo(skb)->frags[f];
1348                 len = frag->size;
1349                 offset = 0;
1350
1351                 while(len) {
1352                         i = (i + 1) % tx_ring->count;
1353                         size = min(len, adapter->max_data_per_txd);
1354                         tx_ring->buffer_info[i].length = size;
1355                         tx_ring->buffer_info[i].dma =
1356                                 pci_map_page(adapter->pdev,
1357                                         frag->page,
1358                                         frag->page_offset + offset,
1359                                         size,
1360                                         PCI_DMA_TODEVICE);
1361
1362                         len -= size;
1363                         offset += size;
1364                         count++;
1365                 }
1366         }
1367         tx_ring->buffer_info[i].skb = skb;
1368
1369         return count;
1370 }
1371
1372 static inline void
1373 e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
1374 {
1375         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1376         struct e1000_tx_desc *tx_desc = NULL;
1377         uint32_t txd_upper, txd_lower;
1378         int i;
1379
1380         txd_upper = 0;
1381         txd_lower = adapter->txd_cmd;
1382
1383         if(tx_flags & E1000_TX_FLAGS_CSUM) {
1384                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1385                 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
1386         }
1387
1388         if(tx_flags & E1000_TX_FLAGS_VLAN) {
1389                 txd_lower |= E1000_TXD_CMD_VLE;
1390                 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
1391         }
1392
1393         i = tx_ring->next_to_use;
1394
1395         while(count--) {
1396                 tx_desc = E1000_TX_DESC(*tx_ring, i);
1397                 tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
1398                 tx_desc->lower.data =
1399                         cpu_to_le32(txd_lower | tx_ring->buffer_info[i].length);
1400                 tx_desc->upper.data = cpu_to_le32(txd_upper);
1401                 i = (i + 1) % tx_ring->count;
1402         }
1403
1404         tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP);
1405
1406         /* Force memory writes to complete before letting h/w
1407          * know there are new descriptors to fetch.  (Only
1408          * applicable for weak-ordered memory model archs,
1409          * such as IA-64). */
1410         wmb();
1411
1412         tx_ring->next_to_use = i;
1413         E1000_WRITE_REG(&adapter->hw, TDT, i);
1414 }
1415
1416 #define TXD_USE_COUNT(S, X) (((S) / (X)) + (((S) % (X)) ? 1 : 0))
1417
1418 static int
1419 e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1420 {
1421         struct e1000_adapter *adapter = netdev->priv;
1422         int tx_flags = 0, count;
1423         int f;
1424
1425         count = TXD_USE_COUNT(skb->len - skb->data_len,
1426                               adapter->max_data_per_txd);
1427
1428         if(count == 0) {
1429                 dev_kfree_skb_any(skb);
1430                 return 0;
1431         }
1432
1433         for(f = 0; f < skb_shinfo(skb)->nr_frags; f++)
1434                 count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
1435                                        adapter->max_data_per_txd);
1436
1437         if(skb->ip_summed == CHECKSUM_HW)
1438                 count++;
1439
1440         if(E1000_DESC_UNUSED(&adapter->tx_ring) < count) {
1441                 netif_stop_queue(netdev);
1442                 return 1;
1443         }
1444
1445         if(e1000_tx_csum(adapter, skb))
1446                 tx_flags |= E1000_TX_FLAGS_CSUM;
1447
1448         if(adapter->vlgrp && vlan_tx_tag_present(skb)) {
1449                 tx_flags |= E1000_TX_FLAGS_VLAN;
1450                 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
1451         }
1452
1453         count = e1000_tx_map(adapter, skb);
1454
1455         e1000_tx_queue(adapter, count, tx_flags);
1456
1457         netdev->trans_start = jiffies;
1458
1459         return 0;
1460 }
1461
1462 /**
1463  * e1000_tx_timeout - Respond to a Tx Hang
1464  * @netdev: network interface device structure
1465  **/
1466
1467 static void
1468 e1000_tx_timeout(struct net_device *netdev)
1469 {
1470         struct e1000_adapter *adapter = netdev->priv;
1471
1472         /* Do the reset outside of interrupt context */
1473         schedule_task(&adapter->tx_timeout_task);
1474 }
1475
1476 static void
1477 e1000_tx_timeout_task(struct net_device *netdev)
1478 {
1479         struct e1000_adapter *adapter = netdev->priv;
1480
1481         netif_device_detach(netdev);
1482         e1000_down(adapter);
1483         e1000_up(adapter);
1484         netif_device_attach(netdev);
1485 }
1486
1487 /**
1488  * e1000_get_stats - Get System Network Statistics
1489  * @netdev: network interface device structure
1490  *
1491  * Returns the address of the device statistics structure.
1492  * The statistics are actually updated from the timer callback.
1493  **/
1494
1495 static struct net_device_stats *
1496 e1000_get_stats(struct net_device *netdev)
1497 {
1498         struct e1000_adapter *adapter = netdev->priv;
1499
1500         return &adapter->net_stats;
1501 }
1502
1503 /**
1504  * e1000_change_mtu - Change the Maximum Transfer Unit
1505  * @netdev: network interface device structure
1506  * @new_mtu: new value for maximum frame size
1507  *
1508  * Returns 0 on success, negative on failure
1509  **/
1510
1511 static int
1512 e1000_change_mtu(struct net_device *netdev, int new_mtu)
1513 {
1514         struct e1000_adapter *adapter = netdev->priv;
1515         int old_mtu = adapter->rx_buffer_len;
1516         int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
1517
1518         if((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
1519            (max_frame > MAX_JUMBO_FRAME_SIZE)) {
1520                 E1000_ERR("Invalid MTU setting\n");
1521                 return -EINVAL;
1522         }
1523
1524         if(max_frame <= MAXIMUM_ETHERNET_FRAME_SIZE) {
1525                 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
1526
1527         } else if(adapter->hw.mac_type < e1000_82543) {
1528                 E1000_ERR("Jumbo Frames not supported on 82542\n");
1529                 return -EINVAL;
1530
1531         } else if(max_frame <= E1000_RXBUFFER_4096) {
1532                 adapter->rx_buffer_len = E1000_RXBUFFER_4096;
1533
1534         } else if(max_frame <= E1000_RXBUFFER_8192) {
1535                 adapter->rx_buffer_len = E1000_RXBUFFER_8192;
1536
1537         } else {
1538                 adapter->rx_buffer_len = E1000_RXBUFFER_16384;
1539         }
1540
1541         if(old_mtu != adapter->rx_buffer_len && netif_running(netdev)) {
1542
1543                 e1000_down(adapter);
1544                 e1000_up(adapter);
1545         }
1546
1547         netdev->mtu = new_mtu;
1548         adapter->hw.max_frame_size = max_frame;
1549
1550         return 0;
1551 }
1552
1553 /**
1554  * e1000_update_stats - Update the board statistics counters
1555  * @adapter: board private structure
1556  **/
1557
1558 static void
1559 e1000_update_stats(struct e1000_adapter *adapter)
1560 {
1561         struct e1000_hw *hw = &adapter->hw;
1562         unsigned long flags;
1563         uint16_t phy_tmp;
1564
1565 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
1566
1567         spin_lock_irqsave(&adapter->stats_lock, flags);
1568
1569         /* these counters are modified from e1000_adjust_tbi_stats,
1570          * called from the interrupt context, so they must only
1571          * be written while holding adapter->stats_lock
1572          */
1573
1574         adapter->stats.crcerrs += E1000_READ_REG(hw, CRCERRS);
1575         adapter->stats.gprc += E1000_READ_REG(hw, GPRC);
1576         adapter->stats.gorcl += E1000_READ_REG(hw, GORCL);
1577         adapter->stats.gorch += E1000_READ_REG(hw, GORCH);
1578         adapter->stats.bprc += E1000_READ_REG(hw, BPRC);
1579         adapter->stats.mprc += E1000_READ_REG(hw, MPRC);
1580         adapter->stats.roc += E1000_READ_REG(hw, ROC);
1581         adapter->stats.prc64 += E1000_READ_REG(hw, PRC64);
1582         adapter->stats.prc127 += E1000_READ_REG(hw, PRC127);
1583         adapter->stats.prc255 += E1000_READ_REG(hw, PRC255);
1584         adapter->stats.prc511 += E1000_READ_REG(hw, PRC511);
1585         adapter->stats.prc1023 += E1000_READ_REG(hw, PRC1023);
1586         adapter->stats.prc1522 += E1000_READ_REG(hw, PRC1522);
1587
1588         spin_unlock_irqrestore(&adapter->stats_lock, flags);
1589
1590         /* the rest of the counters are only modified here */
1591
1592         adapter->stats.symerrs += E1000_READ_REG(hw, SYMERRS);
1593         adapter->stats.mpc += E1000_READ_REG(hw, MPC);
1594         adapter->stats.scc += E1000_READ_REG(hw, SCC);
1595         adapter->stats.ecol += E1000_READ_REG(hw, ECOL);
1596         adapter->stats.mcc += E1000_READ_REG(hw, MCC);
1597         adapter->stats.latecol += E1000_READ_REG(hw, LATECOL);
1598         adapter->stats.dc += E1000_READ_REG(hw, DC);
1599         adapter->stats.sec += E1000_READ_REG(hw, SEC);
1600         adapter->stats.rlec += E1000_READ_REG(hw, RLEC);
1601         adapter->stats.xonrxc += E1000_READ_REG(hw, XONRXC);
1602         adapter->stats.xontxc += E1000_READ_REG(hw, XONTXC);
1603         adapter->stats.xoffrxc += E1000_READ_REG(hw, XOFFRXC);
1604         adapter->stats.xofftxc += E1000_READ_REG(hw, XOFFTXC);
1605         adapter->stats.fcruc += E1000_READ_REG(hw, FCRUC);
1606         adapter->stats.gptc += E1000_READ_REG(hw, GPTC);
1607         adapter->stats.gotcl += E1000_READ_REG(hw, GOTCL);
1608         adapter->stats.gotch += E1000_READ_REG(hw, GOTCH);
1609         adapter->stats.rnbc += E1000_READ_REG(hw, RNBC);
1610         adapter->stats.ruc += E1000_READ_REG(hw, RUC);
1611         adapter->stats.rfc += E1000_READ_REG(hw, RFC);
1612         adapter->stats.rjc += E1000_READ_REG(hw, RJC);
1613         adapter->stats.torl += E1000_READ_REG(hw, TORL);
1614         adapter->stats.torh += E1000_READ_REG(hw, TORH);
1615         adapter->stats.totl += E1000_READ_REG(hw, TOTL);
1616         adapter->stats.toth += E1000_READ_REG(hw, TOTH);
1617         adapter->stats.tpr += E1000_READ_REG(hw, TPR);
1618         adapter->stats.ptc64 += E1000_READ_REG(hw, PTC64);
1619         adapter->stats.ptc127 += E1000_READ_REG(hw, PTC127);
1620         adapter->stats.ptc255 += E1000_READ_REG(hw, PTC255);
1621         adapter->stats.ptc511 += E1000_READ_REG(hw, PTC511);
1622         adapter->stats.ptc1023 += E1000_READ_REG(hw, PTC1023);
1623         adapter->stats.ptc1522 += E1000_READ_REG(hw, PTC1522);
1624         adapter->stats.mptc += E1000_READ_REG(hw, MPTC);
1625         adapter->stats.bptc += E1000_READ_REG(hw, BPTC);
1626
1627         /* used for adaptive IFS */
1628
1629         hw->tx_packet_delta = E1000_READ_REG(hw, TPT);
1630         adapter->stats.tpt += hw->tx_packet_delta;
1631         hw->collision_delta = E1000_READ_REG(hw, COLC);
1632         adapter->stats.colc += hw->collision_delta;
1633
1634         if(hw->mac_type >= e1000_82543) {
1635                 adapter->stats.algnerrc += E1000_READ_REG(hw, ALGNERRC);
1636                 adapter->stats.rxerrc += E1000_READ_REG(hw, RXERRC);
1637                 adapter->stats.tncrs += E1000_READ_REG(hw, TNCRS);
1638                 adapter->stats.cexterr += E1000_READ_REG(hw, CEXTERR);
1639                 adapter->stats.tsctc += E1000_READ_REG(hw, TSCTC);
1640                 adapter->stats.tsctfc += E1000_READ_REG(hw, TSCTFC);
1641         }
1642
1643         /* Fill out the OS statistics structure */
1644
1645         adapter->net_stats.rx_packets = adapter->stats.gprc;
1646         adapter->net_stats.tx_packets = adapter->stats.gptc;
1647         adapter->net_stats.rx_bytes = adapter->stats.gorcl;
1648         adapter->net_stats.tx_bytes = adapter->stats.gotcl;
1649         adapter->net_stats.multicast = adapter->stats.mprc;
1650         adapter->net_stats.collisions = adapter->stats.colc;
1651
1652         /* Rx Errors */
1653
1654         adapter->net_stats.rx_errors = adapter->stats.rxerrc +
1655                 adapter->stats.crcerrs + adapter->stats.algnerrc +
1656                 adapter->stats.rlec + adapter->stats.rnbc +
1657                 adapter->stats.mpc + adapter->stats.cexterr;
1658         adapter->net_stats.rx_dropped = adapter->stats.rnbc;
1659         adapter->net_stats.rx_length_errors = adapter->stats.rlec;
1660         adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
1661         adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
1662         adapter->net_stats.rx_fifo_errors = adapter->stats.mpc;
1663         adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
1664
1665         /* Tx Errors */
1666
1667         adapter->net_stats.tx_errors = adapter->stats.ecol +
1668                                        adapter->stats.latecol;
1669         adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
1670         adapter->net_stats.tx_window_errors = adapter->stats.latecol;
1671         adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;
1672
1673         /* Tx Dropped needs to be maintained elsewhere */
1674
1675         /* Phy Stats */
1676
1677         if(hw->media_type == e1000_media_type_copper) {
1678                 if((adapter->link_speed == SPEED_1000) &&
1679                    (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
1680                         phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
1681                         adapter->phy_stats.idle_errors += phy_tmp;
1682                 }
1683
1684                 if((hw->mac_type <= e1000_82546) &&
1685                    !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
1686                         adapter->phy_stats.receive_errors += phy_tmp;
1687         }
1688 }
1689
1690 /**
1691  * e1000_irq_disable - Mask off interrupt generation on the NIC
1692  * @adapter: board private structure
1693  **/
1694
1695 static inline void
1696 e1000_irq_disable(struct e1000_adapter *adapter)
1697 {
1698         atomic_inc(&adapter->irq_sem);
1699         E1000_WRITE_REG(&adapter->hw, IMC, ~0);
1700         E1000_WRITE_FLUSH(&adapter->hw);
1701         synchronize_irq();
1702 }
1703
1704 /**
1705  * e1000_irq_enable - Enable default interrupt generation settings
1706  * @adapter: board private structure
1707  **/
1708
1709 static inline void
1710 e1000_irq_enable(struct e1000_adapter *adapter)
1711 {
1712         if(atomic_dec_and_test(&adapter->irq_sem)) {
1713                 E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
1714                 E1000_WRITE_FLUSH(&adapter->hw);
1715         }
1716 }
1717
1718 /**
1719  * e1000_intr - Interrupt Handler
1720  * @irq: interrupt number
1721  * @data: pointer to a network interface device structure
1722  * @pt_regs: CPU registers structure
1723  **/
1724
1725 static void
1726 e1000_intr(int irq, void *data, struct pt_regs *regs)
1727 {
1728         struct net_device *netdev = data;
1729         struct e1000_adapter *adapter = netdev->priv;
1730         uint32_t icr;
1731         int i = E1000_MAX_INTR;
1732
1733         while(i && (icr = E1000_READ_REG(&adapter->hw, ICR))) {
1734
1735                 if(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
1736                         adapter->hw.get_link_status = 1;
1737                         mod_timer(&adapter->watchdog_timer, jiffies);
1738                 }
1739
1740                 e1000_clean_rx_irq(adapter);
1741                 e1000_clean_tx_irq(adapter);
1742                 i--;
1743
1744         }
1745 }
1746
1747 /**
1748  * e1000_clean_tx_irq - Reclaim resources after transmit completes
1749  * @adapter: board private structure
1750  **/
1751
1752 static void
1753 e1000_clean_tx_irq(struct e1000_adapter *adapter)
1754 {
1755         struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1756         struct net_device *netdev = adapter->netdev;
1757         struct pci_dev *pdev = adapter->pdev;
1758         struct e1000_tx_desc *tx_desc;
1759         int i;
1760
1761         i = tx_ring->next_to_clean;
1762         tx_desc = E1000_TX_DESC(*tx_ring, i);
1763
1764         while(tx_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
1765
1766                 if(tx_ring->buffer_info[i].dma) {
1767
1768                         pci_unmap_page(pdev,
1769                                        tx_ring->buffer_info[i].dma,
1770                                        tx_ring->buffer_info[i].length,
1771                                        PCI_DMA_TODEVICE);
1772
1773                         tx_ring->buffer_info[i].dma = 0;
1774                 }
1775
1776                 if(tx_ring->buffer_info[i].skb) {
1777
1778                         dev_kfree_skb_any(tx_ring->buffer_info[i].skb);
1779
1780                         tx_ring->buffer_info[i].skb = NULL;
1781                 }
1782
1783                 tx_desc->upper.data = 0;
1784
1785                 i = (i + 1) % tx_ring->count;
1786                 tx_desc = E1000_TX_DESC(*tx_ring, i);
1787         }
1788
1789         tx_ring->next_to_clean = i;
1790
1791         if(netif_queue_stopped(netdev) && netif_carrier_ok(netdev) &&
1792            (E1000_DESC_UNUSED(tx_ring) > E1000_TX_QUEUE_WAKE)) {
1793
1794                 netif_wake_queue(netdev);
1795         }
1796 }
1797
1798 /**
1799  * e1000_clean_rx_irq - Send received data up the network stack,
1800  * @adapter: board private structure
1801  **/
1802
1803 static void
1804 e1000_clean_rx_irq(struct e1000_adapter *adapter)
1805 {
1806         struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1807         struct net_device *netdev = adapter->netdev;
1808         struct pci_dev *pdev = adapter->pdev;
1809         struct e1000_rx_desc *rx_desc;
1810         struct sk_buff *skb;
1811         unsigned long flags;
1812         uint32_t length;
1813         uint8_t last_byte;
1814         int i;
1815
1816         i = rx_ring->next_to_clean;
1817         rx_desc = E1000_RX_DESC(*rx_ring, i);
1818
1819         while(rx_desc->status & E1000_RXD_STAT_DD) {
1820
1821                 pci_unmap_single(pdev,
1822                                  rx_ring->buffer_info[i].dma,
1823                                  rx_ring->buffer_info[i].length,
1824                                  PCI_DMA_FROMDEVICE);
1825
1826                 skb = rx_ring->buffer_info[i].skb;
1827                 length = le16_to_cpu(rx_desc->length);
1828
1829                 if(!(rx_desc->status & E1000_RXD_STAT_EOP)) {
1830
1831                         /* All receives must fit into a single buffer */
1832
1833                         E1000_DBG("Receive packet consumed multiple buffers\n");
1834
1835                         dev_kfree_skb_irq(skb);
1836                         rx_desc->status = 0;
1837                         rx_ring->buffer_info[i].skb = NULL;
1838
1839                         i = (i + 1) % rx_ring->count;
1840
1841                         rx_desc = E1000_RX_DESC(*rx_ring, i);
1842                         continue;
1843                 }
1844
1845                 if(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
1846
1847                         last_byte = *(skb->data + length - 1);
1848
1849                         if(TBI_ACCEPT(&adapter->hw, rx_desc->status,
1850                                       rx_desc->errors, length, last_byte)) {
1851
1852                                 spin_lock_irqsave(&adapter->stats_lock, flags);
1853
1854                                 e1000_tbi_adjust_stats(&adapter->hw,
1855                                                        &adapter->stats,
1856                                                        length, skb->data);
1857
1858                                 spin_unlock_irqrestore(&adapter->stats_lock,
1859                                                        flags);
1860                                 length--;
1861                         } else {
1862
1863                                 dev_kfree_skb_irq(skb);
1864                                 rx_desc->status = 0;
1865                                 rx_ring->buffer_info[i].skb = NULL;
1866
1867                                 i = (i + 1) % rx_ring->count;
1868
1869                                 rx_desc = E1000_RX_DESC(*rx_ring, i);
1870                                 continue;
1871                         }
1872                 }
1873
1874                 /* Good Receive */
1875                 skb_put(skb, length - ETHERNET_FCS_SIZE);
1876
1877                 /* Receive Checksum Offload */
1878                 e1000_rx_checksum(adapter, rx_desc, skb);
1879
1880                 skb->protocol = eth_type_trans(skb, netdev);
1881                 if(adapter->vlgrp && (rx_desc->status & E1000_RXD_STAT_VP)) {
1882                         vlan_hwaccel_rx(skb, adapter->vlgrp,
1883                                 (rx_desc->special & E1000_RXD_SPC_VLAN_MASK));
1884                 } else {
1885                         netif_rx(skb);
1886                 }
1887                 netdev->last_rx = jiffies;
1888
1889                 rx_desc->status = 0;
1890                 rx_ring->buffer_info[i].skb = NULL;
1891
1892                 i = (i + 1) % rx_ring->count;
1893
1894                 rx_desc = E1000_RX_DESC(*rx_ring, i);
1895         }
1896
1897         rx_ring->next_to_clean = i;
1898
1899         e1000_alloc_rx_buffers(adapter);
1900 }
1901
1902 /**
1903  * e1000_alloc_rx_buffers - Replace used receive buffers
1904  * @data: address of board private structure
1905  **/
1906
1907 static void
1908 e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
1909 {
1910         struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1911         struct net_device *netdev = adapter->netdev;
1912         struct pci_dev *pdev = adapter->pdev;
1913         struct e1000_rx_desc *rx_desc;
1914         struct sk_buff *skb;
1915         int reserve_len;
1916         int i;
1917
1918         reserve_len = 2;
1919
1920         i = rx_ring->next_to_use;
1921
1922         while(!rx_ring->buffer_info[i].skb) {
1923                 rx_desc = E1000_RX_DESC(*rx_ring, i);
1924
1925                 skb = dev_alloc_skb(adapter->rx_buffer_len + reserve_len);
1926
1927                 if(!skb) {
1928                         /* Better luck next round */
1929                         break;
1930                 }
1931
1932                 /* Make buffer alignment 2 beyond a 16 byte boundary
1933                  * this will result in a 16 byte aligned IP header after
1934                  * the 14 byte MAC header is removed
1935                  */
1936                 skb_reserve(skb, reserve_len);
1937
1938                 skb->dev = netdev;
1939
1940                 rx_ring->buffer_info[i].skb = skb;
1941                 rx_ring->buffer_info[i].length = adapter->rx_buffer_len;
1942                 rx_ring->buffer_info[i].dma =
1943                         pci_map_single(pdev,
1944                                        skb->data,
1945                                        adapter->rx_buffer_len,
1946                                        PCI_DMA_FROMDEVICE);
1947
1948                 rx_desc->buffer_addr = cpu_to_le64(rx_ring->buffer_info[i].dma);
1949
1950                 if(!(i % E1000_RX_BUFFER_WRITE)) {
1951                         /* Force memory writes to complete before letting h/w
1952                          * know there are new descriptors to fetch.  (Only
1953                          * applicable for weak-ordered memory model archs,
1954                          * such as IA-64). */
1955                         wmb();
1956
1957                         E1000_WRITE_REG(&adapter->hw, RDT, i);
1958                 }
1959
1960                 i = (i + 1) % rx_ring->count;
1961         }
1962
1963         rx_ring->next_to_use = i;
1964 }
1965
1966 /**
1967  * e1000_ioctl -
1968  * @netdev:
1969  * @ifreq:
1970  * @cmd:
1971  **/
1972
1973 static int
1974 e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1975 {
1976         switch (cmd) {
1977         case SIOCETHTOOL:
1978                 return e1000_ethtool_ioctl(netdev, ifr);
1979         default:
1980                 return -EOPNOTSUPP;
1981         }
1982 }
1983
1984 /**
1985  * e1000_rx_checksum - Receive Checksum Offload for 82543
1986  * @adapter: board private structure
1987  * @rx_desc: receive descriptor
1988  * @sk_buff: socket buffer with received data
1989  **/
1990
1991 static inline void
1992 e1000_rx_checksum(struct e1000_adapter *adapter,
1993                   struct e1000_rx_desc *rx_desc,
1994                   struct sk_buff *skb)
1995 {
1996         /* 82543 or newer only */
1997         if((adapter->hw.mac_type < e1000_82543) ||
1998         /* Ignore Checksum bit is set */
1999         (rx_desc->status & E1000_RXD_STAT_IXSM) ||
2000         /* TCP Checksum has not been calculated */
2001         (!(rx_desc->status & E1000_RXD_STAT_TCPCS))) {
2002                 skb->ip_summed = CHECKSUM_NONE;
2003                 return;
2004         }
2005
2006         /* At this point we know the hardware did the TCP checksum */
2007         /* now look at the TCP checksum error bit */
2008         if(rx_desc->errors & E1000_RXD_ERR_TCPE) {
2009                 /* let the stack verify checksum errors */
2010                 skb->ip_summed = CHECKSUM_NONE;
2011                 adapter->hw_csum_err++;
2012         } else {
2013         /* TCP checksum is good */
2014                 skb->ip_summed = CHECKSUM_UNNECESSARY;
2015                 adapter->hw_csum_good++;
2016         }
2017 }
2018
2019 void
2020 e1000_pci_set_mwi(struct e1000_hw *hw)
2021 {
2022         struct e1000_adapter *adapter = hw->back;
2023
2024         pci_set_mwi(adapter->pdev);
2025 }
2026
2027 void
2028 e1000_pci_clear_mwi(struct e1000_hw *hw)
2029 {
2030         struct e1000_adapter *adapter = hw->back;
2031
2032         pci_clear_mwi(adapter->pdev);
2033 }
2034
2035 void
2036 e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2037 {
2038         struct e1000_adapter *adapter = hw->back;
2039
2040         pci_read_config_word(adapter->pdev, reg, value);
2041 }
2042
2043 void
2044 e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2045 {
2046         struct e1000_adapter *adapter = hw->back;
2047
2048         pci_write_config_word(adapter->pdev, reg, *value);
2049 }
2050
2051 uint32_t
2052 e1000_io_read(struct e1000_hw *hw, uint32_t port)
2053 {
2054         return inl(port);
2055 }
2056
2057 void
2058 e1000_io_write(struct e1000_hw *hw, uint32_t port, uint32_t value)
2059 {
2060         outl(value, port);
2061 }
2062
2063 static void
2064 e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
2065 {
2066         struct e1000_adapter *adapter = netdev->priv;
2067         uint32_t ctrl, rctl;
2068
2069         e1000_irq_disable(adapter);
2070         adapter->vlgrp = grp;
2071
2072         if(grp) {
2073                 /* enable VLAN tag insert/strip */
2074
2075                 E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);
2076
2077                 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2078                 ctrl |= E1000_CTRL_VME;
2079                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2080
2081                 /* enable VLAN receive filtering */
2082
2083                 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2084                 rctl |= E1000_RCTL_VFE;
2085                 rctl &= ~E1000_RCTL_CFIEN;
2086                 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2087         } else {
2088                 /* disable VLAN tag insert/strip */
2089
2090                 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2091                 ctrl &= ~E1000_CTRL_VME;
2092                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2093
2094                 /* disable VLAN filtering */
2095
2096                 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2097                 rctl &= ~E1000_RCTL_VFE;
2098                 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2099         }
2100
2101         e1000_irq_enable(adapter);
2102 }
2103
2104 static void
2105 e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
2106 {
2107         struct e1000_adapter *adapter = netdev->priv;
2108         uint32_t vfta, index;
2109
2110         /* add VID to filter table */
2111
2112         index = (vid >> 5) & 0x7F;
2113         vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2114         vfta |= (1 << (vid & 0x1F));
2115         e1000_write_vfta(&adapter->hw, index, vfta);
2116 }
2117
2118 static void
2119 e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
2120 {
2121         struct e1000_adapter *adapter = netdev->priv;
2122         uint32_t vfta, index;
2123
2124         e1000_irq_disable(adapter);
2125
2126         if(adapter->vlgrp)
2127                 adapter->vlgrp->vlan_devices[vid] = NULL;
2128
2129         e1000_irq_enable(adapter);
2130
2131         /* remove VID from filter table*/
2132
2133         index = (vid >> 5) & 0x7F;
2134         vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2135         vfta &= ~(1 << (vid & 0x1F));
2136         e1000_write_vfta(&adapter->hw, index, vfta);
2137 }
2138
2139 static void
2140 e1000_restore_vlan(struct e1000_adapter *adapter)
2141 {
2142         e1000_vlan_rx_register(adapter->netdev, adapter->vlgrp);
2143
2144         if(adapter->vlgrp) {
2145                 uint16_t vid;
2146                 for(vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
2147                         if(!adapter->vlgrp->vlan_devices[vid])
2148                                 continue;
2149                         e1000_vlan_rx_add_vid(adapter->netdev, vid);
2150                 }
2151         }
2152 }
2153
2154 static int
2155 e1000_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
2156 {
2157         struct pci_dev *pdev = NULL;
2158
2159         switch(event) {
2160         case SYS_DOWN:
2161         case SYS_HALT:
2162         case SYS_POWER_OFF:
2163                 pci_for_each_dev(pdev) {
2164                         if(pci_dev_driver(pdev) == &e1000_driver)
2165                                 e1000_suspend(pdev, 3);
2166                 }
2167         }
2168         return NOTIFY_DONE;
2169 }
2170
2171 static int
2172 e1000_suspend(struct pci_dev *pdev, uint32_t state)
2173 {
2174         struct net_device *netdev = pci_get_drvdata(pdev);
2175         struct e1000_adapter *adapter = netdev->priv;
2176         uint32_t ctrl, ctrl_ext, rctl, manc, status;
2177         uint32_t wufc = adapter->wol;
2178
2179         netif_device_detach(netdev);
2180
2181         if(netif_running(netdev))
2182                 e1000_down(adapter);
2183
2184         status = E1000_READ_REG(&adapter->hw, STATUS);
2185         if(status & E1000_STATUS_LU)
2186                 wufc &= ~E1000_WUFC_LNKC;
2187
2188         if(wufc) {
2189                 e1000_setup_rctl(adapter);
2190                 e1000_set_multi(netdev);
2191
2192                 /* turn on all-multi mode if wake on multicast is enabled */
2193                 if(adapter->wol & E1000_WUFC_MC) {
2194                         rctl = E1000_READ_REG(&adapter->hw, RCTL);
2195                         rctl |= E1000_RCTL_MPE;
2196                         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2197                 }
2198
2199                 if(adapter->hw.mac_type >= e1000_82540) {
2200                         ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2201                         /* advertise wake from D3Cold */
2202                         #define E1000_CTRL_ADVD3WUC 0x00100000
2203                         /* phy power management enable */
2204                         #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
2205                         ctrl |= E1000_CTRL_ADVD3WUC |
2206                                 E1000_CTRL_EN_PHY_PWR_MGMT;
2207                         E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2208                 }
2209
2210                 if(adapter->hw.media_type == e1000_media_type_fiber) {
2211                         /* keep the laser running in D3 */
2212                         ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
2213                         ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
2214                         E1000_WRITE_REG(&adapter->hw, CTRL_EXT, ctrl_ext);
2215                 }
2216
2217                 E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
2218                 E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
2219                 pci_enable_wake(pdev, 3, 1);
2220                 pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
2221         } else {
2222                 E1000_WRITE_REG(&adapter->hw, WUC, 0);
2223                 E1000_WRITE_REG(&adapter->hw, WUFC, 0);
2224                 pci_enable_wake(pdev, 3, 0);
2225                 pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
2226         }
2227
2228         pci_save_state(pdev, adapter->pci_state);
2229
2230         if(adapter->hw.mac_type >= e1000_82540) {
2231                 manc = E1000_READ_REG(&adapter->hw, MANC);
2232                 if(manc & E1000_MANC_SMBUS_EN) {
2233                         manc |= E1000_MANC_ARP_EN;
2234                         E1000_WRITE_REG(&adapter->hw, MANC, manc);
2235                         state = 0;
2236                 }
2237         }
2238
2239         state = (state > 0) ? 3 : 0;
2240         pci_set_power_state(pdev, state);
2241
2242         return 0;
2243 }
2244
2245 #ifdef CONFIG_PM
2246 static int
2247 e1000_resume(struct pci_dev *pdev)
2248 {
2249         struct net_device *netdev = pci_get_drvdata(pdev);
2250         struct e1000_adapter *adapter = netdev->priv;
2251         uint32_t manc;
2252
2253         pci_set_power_state(pdev, 0);
2254         pci_restore_state(pdev, adapter->pci_state);
2255
2256         pci_enable_wake(pdev, 3, 0);
2257         pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
2258
2259         e1000_reset(adapter);
2260         E1000_WRITE_REG(&adapter->hw, WUS, ~0);
2261
2262         if(netif_running(netdev))
2263                 e1000_up(adapter);
2264
2265         netif_device_attach(netdev);
2266
2267         if(adapter->hw.mac_type >= e1000_82540) {
2268                 manc = E1000_READ_REG(&adapter->hw, MANC);
2269                 manc &= ~(E1000_MANC_ARP_EN);
2270                 E1000_WRITE_REG(&adapter->hw, MANC, manc);
2271         }
2272
2273         return 0;
2274 }
2275 #endif
2276
2277 /* e1000_main.c */