drivers/net/ethernet/intel/e1000/e1000_main.c

   1 /*******************************************************************************
   2
   3   Intel PRO/1000 Linux driver
   4   Copyright(c) 1999 - 2006 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   Linux NICS <linux.nics@intel.com>
  24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28
  29 #include "e1000.h"
  30 #include <net/ip6_checksum.h>
  31 #include <linux/io.h>
  32 #include <linux/prefetch.h>
  33 #include <linux/bitops.h>
  34 #include <linux/if_vlan.h>
  35
  36 char e1000_driver_name[] = "e1000";
  37 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
  38 #define DRV_VERSION "7.3.21-k8-NAPI"
  39 const char e1000_driver_version[] = DRV_VERSION;
  40 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
  41
  42 /* e1000_pci_tbl - PCI Device ID Table
  43  *
  44  * Last entry must be all 0s
  45  *
  46  * Macro expands to...
  47  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
  48  */
  49 static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
  50         INTEL_E1000_ETHERNET_DEVICE(0x1000),
  51         INTEL_E1000_ETHERNET_DEVICE(0x1001),
  52         INTEL_E1000_ETHERNET_DEVICE(0x1004),
  53         INTEL_E1000_ETHERNET_DEVICE(0x1008),
  54         INTEL_E1000_ETHERNET_DEVICE(0x1009),
  55         INTEL_E1000_ETHERNET_DEVICE(0x100C),
  56         INTEL_E1000_ETHERNET_DEVICE(0x100D),
  57         INTEL_E1000_ETHERNET_DEVICE(0x100E),
  58         INTEL_E1000_ETHERNET_DEVICE(0x100F),
  59         INTEL_E1000_ETHERNET_DEVICE(0x1010),
  60         INTEL_E1000_ETHERNET_DEVICE(0x1011),
  61         INTEL_E1000_ETHERNET_DEVICE(0x1012),
  62         INTEL_E1000_ETHERNET_DEVICE(0x1013),
  63         INTEL_E1000_ETHERNET_DEVICE(0x1014),
  64         INTEL_E1000_ETHERNET_DEVICE(0x1015),
  65         INTEL_E1000_ETHERNET_DEVICE(0x1016),
  66         INTEL_E1000_ETHERNET_DEVICE(0x1017),
  67         INTEL_E1000_ETHERNET_DEVICE(0x1018),
  68         INTEL_E1000_ETHERNET_DEVICE(0x1019),
  69         INTEL_E1000_ETHERNET_DEVICE(0x101A),
  70         INTEL_E1000_ETHERNET_DEVICE(0x101D),
  71         INTEL_E1000_ETHERNET_DEVICE(0x101E),
  72         INTEL_E1000_ETHERNET_DEVICE(0x1026),
  73         INTEL_E1000_ETHERNET_DEVICE(0x1027),
  74         INTEL_E1000_ETHERNET_DEVICE(0x1028),
  75         INTEL_E1000_ETHERNET_DEVICE(0x1075),
  76         INTEL_E1000_ETHERNET_DEVICE(0x1076),
  77         INTEL_E1000_ETHERNET_DEVICE(0x1077),
  78         INTEL_E1000_ETHERNET_DEVICE(0x1078),
  79         INTEL_E1000_ETHERNET_DEVICE(0x1079),
  80         INTEL_E1000_ETHERNET_DEVICE(0x107A),
  81         INTEL_E1000_ETHERNET_DEVICE(0x107B),
  82         INTEL_E1000_ETHERNET_DEVICE(0x107C),
  83         INTEL_E1000_ETHERNET_DEVICE(0x108A),
  84         INTEL_E1000_ETHERNET_DEVICE(0x1099),
  85         INTEL_E1000_ETHERNET_DEVICE(0x10B5),
  86         INTEL_E1000_ETHERNET_DEVICE(0x2E6E),
  87         /* required last entry */
  88         {0,}
  89 };
  90
  91 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
  92
  93 int e1000_up(struct e1000_adapter *adapter);
  94 void e1000_down(struct e1000_adapter *adapter);
  95 void e1000_reinit_locked(struct e1000_adapter *adapter);
  96 void e1000_reset(struct e1000_adapter *adapter);
  97 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
  98 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
  99 void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
 100 void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
 101 static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
 102                              struct e1000_tx_ring *txdr);
 103 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
 104                              struct e1000_rx_ring *rxdr);
 105 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
 106                              struct e1000_tx_ring *tx_ring);
 107 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
 108                              struct e1000_rx_ring *rx_ring);
 109 void e1000_update_stats(struct e1000_adapter *adapter);
 110
 111 static int e1000_init_module(void);
 112 static void e1000_exit_module(void);
 113 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 114 static void __devexit e1000_remove(struct pci_dev *pdev);
 115 static int e1000_alloc_queues(struct e1000_adapter *adapter);
 116 static int e1000_sw_init(struct e1000_adapter *adapter);
 117 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_all_tx_rings(struct e1000_adapter *adapter);
 123 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
 124 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
 125                                 struct e1000_tx_ring *tx_ring);
 126 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
 127                                 struct e1000_rx_ring *rx_ring);
 128 static void e1000_set_rx_mode(struct net_device *netdev);
 129 static void e1000_update_phy_info_task(struct work_struct *work);
 130 static void e1000_watchdog(struct work_struct *work);
 131 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);
 132 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
 133                                     struct net_device *netdev);
 134 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
 135 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
 136 static int e1000_set_mac(struct net_device *netdev, void *p);
 137 static irqreturn_t e1000_intr(int irq, void *data);
 138 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
 139                                struct e1000_tx_ring *tx_ring);
 140 static int e1000_clean(struct napi_struct *napi, int budget);
 141 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
 142                                struct e1000_rx_ring *rx_ring,
 143                                int *work_done, int work_to_do);
 144 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
 145                                      struct e1000_rx_ring *rx_ring,
 146                                      int *work_done, int work_to_do);
 147 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
 148                                    struct e1000_rx_ring *rx_ring,
 149                                    int cleaned_count);
 150 static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
 151                                          struct e1000_rx_ring *rx_ring,
 152                                          int cleaned_count);
 153 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
 154 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
 155                            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 void e1000_tx_timeout(struct net_device *dev);
 159 static void e1000_reset_task(struct work_struct *work);
 160 static void e1000_smartspeed(struct e1000_adapter *adapter);
 161 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
 162                                        struct sk_buff *skb);
 163
 164 static bool e1000_vlan_used(struct e1000_adapter *adapter);
 165 static void e1000_vlan_mode(struct net_device *netdev,
 166                             netdev_features_t features);
 167 static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
 168 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
 169 static void e1000_restore_vlan(struct e1000_adapter *adapter);
 170
 171 #ifdef CONFIG_PM
 172 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
 173 static int e1000_resume(struct pci_dev *pdev);
 174 #endif
 175 static void e1000_shutdown(struct pci_dev *pdev);
 176
 177 #ifdef CONFIG_NET_POLL_CONTROLLER
 178 /* for netdump / net console */
 179 static void e1000_netpoll (struct net_device *netdev);
 180 #endif
 181
 182 #define COPYBREAK_DEFAULT 256
 183 static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;
 184 module_param(copybreak, uint, 0644);
 185 MODULE_PARM_DESC(copybreak,
 186         "Maximum size of packet that is copied to a new buffer on receive");
 187
 188 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
 189                      pci_channel_state_t state);
 190 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
 191 static void e1000_io_resume(struct pci_dev *pdev);
 192
 193 static struct pci_error_handlers e1000_err_handler = {
 194         .error_detected = e1000_io_error_detected,
 195         .slot_reset = e1000_io_slot_reset,
 196         .resume = e1000_io_resume,
 197 };
 198
 199 static struct pci_driver e1000_driver = {
 200         .name     = e1000_driver_name,
 201         .id_table = e1000_pci_tbl,
 202         .probe    = e1000_probe,
 203         .remove   = __devexit_p(e1000_remove),
 204 #ifdef CONFIG_PM
 205         /* Power Management Hooks */
 206         .suspend  = e1000_suspend,
 207         .resume   = e1000_resume,
 208 #endif
 209         .shutdown = e1000_shutdown,
 210         .err_handler = &e1000_err_handler
 211 };
 212
 213 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
 214 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
 215 MODULE_LICENSE("GPL");
 216 MODULE_VERSION(DRV_VERSION);
 217
 218 static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
 219 module_param(debug, int, 0);
 220 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 221
 222 /**
 223  * e1000_get_hw_dev - return device
 224  * used by hardware layer to print debugging information
 225  *
 226  **/
 227 struct net_device *e1000_get_hw_dev(struct e1000_hw *hw)
 228 {
 229         struct e1000_adapter *adapter = hw->back;
 230         return adapter->netdev;
 231 }
 232
 233 /**
 234  * e1000_init_module - Driver Registration Routine
 235  *
 236  * e1000_init_module is the first routine called when the driver is
 237  * loaded. All it does is register with the PCI subsystem.
 238  **/
 239
 240 static int __init e1000_init_module(void)
 241 {
 242         int ret;
 243         pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);
 244
 245         pr_info("%s\n", e1000_copyright);
 246
 247         ret = pci_register_driver(&e1000_driver);
 248         if (copybreak != COPYBREAK_DEFAULT) {
 249                 if (copybreak == 0)
 250                         pr_info("copybreak disabled\n");
 251                 else
 252                         pr_info("copybreak enabled for "
 253                                    "packets <= %u bytes\n", copybreak);
 254         }
 255         return ret;
 256 }
 257
 258 module_init(e1000_init_module);
 259
 260 /**
 261  * e1000_exit_module - Driver Exit Cleanup Routine
 262  *
 263  * e1000_exit_module is called just before the driver is removed
 264  * from memory.
 265  **/
 266
 267 static void __exit e1000_exit_module(void)
 268 {
 269         pci_unregister_driver(&e1000_driver);
 270 }
 271
 272 module_exit(e1000_exit_module);
 273
 274 static int e1000_request_irq(struct e1000_adapter *adapter)
 275 {
 276         struct net_device *netdev = adapter->netdev;
 277         irq_handler_t handler = e1000_intr;
 278         int irq_flags = IRQF_SHARED;
 279         int err;
 280
 281         err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
 282                           netdev);
 283         if (err) {
 284                 e_err(probe, "Unable to allocate interrupt Error: %d\n", err);
 285         }
 286
 287         return err;
 288 }
 289
 290 static void e1000_free_irq(struct e1000_adapter *adapter)
 291 {
 292         struct net_device *netdev = adapter->netdev;
 293
 294         free_irq(adapter->pdev->irq, netdev);
 295 }
 296
 297 /**
 298  * e1000_irq_disable - Mask off interrupt generation on the NIC
 299  * @adapter: board private structure
 300  **/
 301
 302 static void e1000_irq_disable(struct e1000_adapter *adapter)
 303 {
 304         struct e1000_hw *hw = &adapter->hw;
 305
 306         ew32(IMC, ~0);
 307         E1000_WRITE_FLUSH();
 308         synchronize_irq(adapter->pdev->irq);
 309 }
 310
 311 /**
 312  * e1000_irq_enable - Enable default interrupt generation settings
 313  * @adapter: board private structure
 314  **/
 315
 316 static void e1000_irq_enable(struct e1000_adapter *adapter)
 317 {
 318         struct e1000_hw *hw = &adapter->hw;
 319
 320         ew32(IMS, IMS_ENABLE_MASK);
 321         E1000_WRITE_FLUSH();
 322 }
 323
 324 static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
 325 {
 326         struct e1000_hw *hw = &adapter->hw;
 327         struct net_device *netdev = adapter->netdev;
 328         u16 vid = hw->mng_cookie.vlan_id;
 329         u16 old_vid = adapter->mng_vlan_id;
 330
 331         if (!e1000_vlan_used(adapter))
 332                 return;
 333
 334         if (!test_bit(vid, adapter->active_vlans)) {
 335                 if (hw->mng_cookie.status &
 336                     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
 337                         e1000_vlan_rx_add_vid(netdev, vid);
 338                         adapter->mng_vlan_id = vid;
 339                 } else {
 340                         adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
 341                 }
 342                 if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&
 343                     (vid != old_vid) &&
 344                     !test_bit(old_vid, adapter->active_vlans))
 345                         e1000_vlan_rx_kill_vid(netdev, old_vid);
 346         } else {
 347                 adapter->mng_vlan_id = vid;
 348         }
 349 }
 350
 351 static void e1000_init_manageability(struct e1000_adapter *adapter)
 352 {
 353         struct e1000_hw *hw = &adapter->hw;
 354
 355         if (adapter->en_mng_pt) {
 356                 u32 manc = er32(MANC);
 357
 358                 /* disable hardware interception of ARP */
 359                 manc &= ~(E1000_MANC_ARP_EN);
 360
 361                 ew32(MANC, manc);
 362         }
 363 }
 364
 365 static void e1000_release_manageability(struct e1000_adapter *adapter)
 366 {
 367         struct e1000_hw *hw = &adapter->hw;
 368
 369         if (adapter->en_mng_pt) {
 370                 u32 manc = er32(MANC);
 371
 372                 /* re-enable hardware interception of ARP */
 373                 manc |= E1000_MANC_ARP_EN;
 374
 375                 ew32(MANC, manc);
 376         }
 377 }
 378
 379 /**
 380  * e1000_configure - configure the hardware for RX and TX
 381  * @adapter = private board structure
 382  **/
 383 static void e1000_configure(struct e1000_adapter *adapter)
 384 {
 385         struct net_device *netdev = adapter->netdev;
 386         int i;
 387
 388         e1000_set_rx_mode(netdev);
 389
 390         e1000_restore_vlan(adapter);
 391         e1000_init_manageability(adapter);
 392
 393         e1000_configure_tx(adapter);
 394         e1000_setup_rctl(adapter);
 395         e1000_configure_rx(adapter);
 396         /* call E1000_DESC_UNUSED which always leaves
 397          * at least 1 descriptor unused to make sure
 398          * next_to_use != next_to_clean */
 399         for (i = 0; i < adapter->num_rx_queues; i++) {
 400                 struct e1000_rx_ring *ring = &adapter->rx_ring[i];
 401                 adapter->alloc_rx_buf(adapter, ring,
 402                                       E1000_DESC_UNUSED(ring));
 403         }
 404 }
 405
 406 int e1000_up(struct e1000_adapter *adapter)
 407 {
 408         struct e1000_hw *hw = &adapter->hw;
 409
 410         /* hardware has been reset, we need to reload some things */
 411         e1000_configure(adapter);
 412
 413         clear_bit(__E1000_DOWN, &adapter->flags);
 414
 415         napi_enable(&adapter->napi);
 416
 417         e1000_irq_enable(adapter);
 418
 419         netif_wake_queue(adapter->netdev);
 420
 421         /* fire a link change interrupt to start the watchdog */
 422         ew32(ICS, E1000_ICS_LSC);
 423         return 0;
 424 }
 425
 426 /**
 427  * e1000_power_up_phy - restore link in case the phy was powered down
 428  * @adapter: address of board private structure
 429  *
 430  * The phy may be powered down to save power and turn off link when the
 431  * driver is unloaded and wake on lan is not enabled (among others)
 432  * *** this routine MUST be followed by a call to e1000_reset ***
 433  *
 434  **/
 435
 436 void e1000_power_up_phy(struct e1000_adapter *adapter)
 437 {
 438         struct e1000_hw *hw = &adapter->hw;
 439         u16 mii_reg = 0;
 440
 441         /* Just clear the power down bit to wake the phy back up */
 442         if (hw->media_type == e1000_media_type_copper) {
 443                 /* according to the manual, the phy will retain its
 444                  * settings across a power-down/up cycle */
 445                 e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
 446                 mii_reg &= ~MII_CR_POWER_DOWN;
 447                 e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
 448         }
 449 }
 450
 451 static void e1000_power_down_phy(struct e1000_adapter *adapter)
 452 {
 453         struct e1000_hw *hw = &adapter->hw;
 454
 455         /* Power down the PHY so no link is implied when interface is down *
 456          * The PHY cannot be powered down if any of the following is true *
 457          * (a) WoL is enabled
 458          * (b) AMT is active
 459          * (c) SoL/IDER session is active */
 460         if (!adapter->wol && hw->mac_type >= e1000_82540 &&
 461            hw->media_type == e1000_media_type_copper) {
 462                 u16 mii_reg = 0;
 463
 464                 switch (hw->mac_type) {
 465                 case e1000_82540:
 466                 case e1000_82545:
 467                 case e1000_82545_rev_3:
 468                 case e1000_82546:
 469                 case e1000_ce4100:
 470                 case e1000_82546_rev_3:
 471                 case e1000_82541:
 472                 case e1000_82541_rev_2:
 473                 case e1000_82547:
 474                 case e1000_82547_rev_2:
 475                         if (er32(MANC) & E1000_MANC_SMBUS_EN)
 476                                 goto out;
 477                         break;
 478                 default:
 479                         goto out;
 480                 }
 481                 e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
 482                 mii_reg |= MII_CR_POWER_DOWN;
 483                 e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
 484                 msleep(1);
 485         }
 486 out:
 487         return;
 488 }
 489
 490 static void e1000_down_and_stop(struct e1000_adapter *adapter)
 491 {
 492         set_bit(__E1000_DOWN, &adapter->flags);
 493         cancel_work_sync(&adapter->reset_task);
 494         cancel_delayed_work_sync(&adapter->watchdog_task);
 495         cancel_delayed_work_sync(&adapter->phy_info_task);
 496         cancel_delayed_work_sync(&adapter->fifo_stall_task);
 497 }
 498
 499 void e1000_down(struct e1000_adapter *adapter)
 500 {
 501         struct e1000_hw *hw = &adapter->hw;
 502         struct net_device *netdev = adapter->netdev;
 503         u32 rctl, tctl;
 504
 505
 506         /* disable receives in the hardware */
 507         rctl = er32(RCTL);
 508         ew32(RCTL, rctl & ~E1000_RCTL_EN);
 509         /* flush and sleep below */
 510
 511         netif_tx_disable(netdev);
 512
 513         /* disable transmits in the hardware */
 514         tctl = er32(TCTL);
 515         tctl &= ~E1000_TCTL_EN;
 516         ew32(TCTL, tctl);
 517         /* flush both disables and wait for them to finish */
 518         E1000_WRITE_FLUSH();
 519         msleep(10);
 520
 521         napi_disable(&adapter->napi);
 522
 523         e1000_irq_disable(adapter);
 524
 525         /*
 526          * Setting DOWN must be after irq_disable to prevent
 527          * a screaming interrupt.  Setting DOWN also prevents
 528          * tasks from rescheduling.
 529          */
 530         e1000_down_and_stop(adapter);
 531
 532         adapter->link_speed = 0;
 533         adapter->link_duplex = 0;
 534         netif_carrier_off(netdev);
 535
 536         e1000_reset(adapter);
 537         e1000_clean_all_tx_rings(adapter);
 538         e1000_clean_all_rx_rings(adapter);
 539 }
 540
 541 static void e1000_reinit_safe(struct e1000_adapter *adapter)
 542 {
 543         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 544                 msleep(1);
 545         mutex_lock(&adapter->mutex);
 546         e1000_down(adapter);
 547         e1000_up(adapter);
 548         mutex_unlock(&adapter->mutex);
 549         clear_bit(__E1000_RESETTING, &adapter->flags);
 550 }
 551
 552 void e1000_reinit_locked(struct e1000_adapter *adapter)
 553 {
 554         /* if rtnl_lock is not held the call path is bogus */
 555         ASSERT_RTNL();
 556         WARN_ON(in_interrupt());
 557         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
 558                 msleep(1);
 559         e1000_down(adapter);
 560         e1000_up(adapter);
 561         clear_bit(__E1000_RESETTING, &adapter->flags);
 562 }
 563
 564 void e1000_reset(struct e1000_adapter *adapter)
 565 {
 566         struct e1000_hw *hw = &adapter->hw;
 567         u32 pba = 0, tx_space, min_tx_space, min_rx_space;
 568         bool legacy_pba_adjust = false;
 569         u16 hwm;
 570
 571         /* Repartition Pba for greater than 9k mtu
 572          * To take effect CTRL.RST is required.
 573          */
 574
 575         switch (hw->mac_type) {
 576         case e1000_82542_rev2_0:
 577         case e1000_82542_rev2_1:
 578         case e1000_82543:
 579         case e1000_82544:
 580         case e1000_82540:
 581         case e1000_82541:
 582         case e1000_82541_rev_2:
 583                 legacy_pba_adjust = true;
 584                 pba = E1000_PBA_48K;
 585                 break;
 586         case e1000_82545:
 587         case e1000_82545_rev_3:
 588         case e1000_82546:
 589         case e1000_ce4100:
 590         case e1000_82546_rev_3:
 591                 pba = E1000_PBA_48K;
 592                 break;
 593         case e1000_82547:
 594         case e1000_82547_rev_2:
 595                 legacy_pba_adjust = true;
 596                 pba = E1000_PBA_30K;
 597                 break;
 598         case e1000_undefined:
 599         case e1000_num_macs:
 600                 break;
 601         }
 602
 603         if (legacy_pba_adjust) {
 604                 if (hw->max_frame_size > E1000_RXBUFFER_8192)
 605                         pba -= 8; /* allocate more FIFO for Tx */
 606
 607                 if (hw->mac_type == e1000_82547) {
 608                         adapter->tx_fifo_head = 0;
 609                         adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
 610                         adapter->tx_fifo_size =
 611                                 (E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
 612                         atomic_set(&adapter->tx_fifo_stall, 0);
 613                 }
 614         } else if (hw->max_frame_size >  ETH_FRAME_LEN + ETH_FCS_LEN) {
 615                 /* adjust PBA for jumbo frames */
 616                 ew32(PBA, pba);
 617
 618                 /* To maintain wire speed transmits, the Tx FIFO should be
 619                  * large enough to accommodate two full transmit packets,
 620                  * rounded up to the next 1KB and expressed in KB.  Likewise,
 621                  * the Rx FIFO should be large enough to accommodate at least
 622                  * one full receive packet and is similarly rounded up and
 623                  * expressed in KB. */
 624                 pba = er32(PBA);
 625                 /* upper 16 bits has Tx packet buffer allocation size in KB */
 626                 tx_space = pba >> 16;
 627                 /* lower 16 bits has Rx packet buffer allocation size in KB */
 628                 pba &= 0xffff;
 629                 /*
 630                  * the tx fifo also stores 16 bytes of information about the tx
 631                  * but don't include ethernet FCS because hardware appends it
 632                  */
 633                 min_tx_space = (hw->max_frame_size +
 634                                 sizeof(struct e1000_tx_desc) -
 635                                 ETH_FCS_LEN) * 2;
 636                 min_tx_space = ALIGN(min_tx_space, 1024);
 637                 min_tx_space >>= 10;
 638                 /* software strips receive CRC, so leave room for it */
 639                 min_rx_space = hw->max_frame_size;
 640                 min_rx_space = ALIGN(min_rx_space, 1024);
 641                 min_rx_space >>= 10;
 642
 643                 /* If current Tx allocation is less than the min Tx FIFO size,
 644                  * and the min Tx FIFO size is less than the current Rx FIFO
 645                  * allocation, take space away from current Rx allocation */
 646                 if (tx_space < min_tx_space &&
 647                     ((min_tx_space - tx_space) < pba)) {
 648                         pba = pba - (min_tx_space - tx_space);
 649
 650                         /* PCI/PCIx hardware has PBA alignment constraints */
 651                         switch (hw->mac_type) {
 652                         case e1000_82545 ... e1000_82546_rev_3:
 653                                 pba &= ~(E1000_PBA_8K - 1);
 654                                 break;
 655                         default:
 656                                 break;
 657                         }
 658
 659                         /* if short on rx space, rx wins and must trump tx
 660                          * adjustment or use Early Receive if available */
 661                         if (pba < min_rx_space)
 662                                 pba = min_rx_space;
 663                 }
 664         }
 665
 666         ew32(PBA, pba);
 667
 668         /*
 669          * flow control settings:
 670          * The high water mark must be low enough to fit one full frame
 671          * (or the size used for early receive) above it in the Rx FIFO.
 672          * Set it to the lower of:
 673          * - 90% of the Rx FIFO size, and
 674          * - the full Rx FIFO size minus the early receive size (for parts
 675          *   with ERT support assuming ERT set to E1000_ERT_2048), or
 676          * - the full Rx FIFO size minus one full frame
 677          */
 678         hwm = min(((pba << 10) * 9 / 10),
 679                   ((pba << 10) - hw->max_frame_size));
 680
 681         hw->fc_high_water = hwm & 0xFFF8;       /* 8-byte granularity */
 682         hw->fc_low_water = hw->fc_high_water - 8;
 683         hw->fc_pause_time = E1000_FC_PAUSE_TIME;
 684         hw->fc_send_xon = 1;
 685         hw->fc = hw->original_fc;
 686
 687         /* Allow time for pending master requests to run */
 688         e1000_reset_hw(hw);
 689         if (hw->mac_type >= e1000_82544)
 690                 ew32(WUC, 0);
 691
 692         if (e1000_init_hw(hw))
 693                 e_dev_err("Hardware Error\n");
 694         e1000_update_mng_vlan(adapter);
 695
 696         /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
 697         if (hw->mac_type >= e1000_82544 &&
 698             hw->autoneg == 1 &&
 699             hw->autoneg_advertised == ADVERTISE_1000_FULL) {
 700                 u32 ctrl = er32(CTRL);
 701                 /* clear phy power management bit if we are in gig only mode,
 702                  * which if enabled will attempt negotiation to 100Mb, which
 703                  * can cause a loss of link at power off or driver unload */
 704                 ctrl &= ~E1000_CTRL_SWDPIN3;
 705                 ew32(CTRL, ctrl);
 706         }
 707
 708         /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
 709         ew32(VET, ETHERNET_IEEE_VLAN_TYPE);
 710
 711         e1000_reset_adaptive(hw);
 712         e1000_phy_get_info(hw, &adapter->phy_info);
 713
 714         e1000_release_manageability(adapter);
 715 }
 716
 717 /**
 718  *  Dump the eeprom for users having checksum issues
 719  **/
 720 static void e1000_dump_eeprom(struct e1000_adapter *adapter)
 721 {
 722         struct net_device *netdev = adapter->netdev;
 723         struct ethtool_eeprom eeprom;
 724         const struct ethtool_ops *ops = netdev->ethtool_ops;
 725         u8 *data;
 726         int i;
 727         u16 csum_old, csum_new = 0;
 728
 729         eeprom.len = ops->get_eeprom_len(netdev);
 730         eeprom.offset = 0;
 731
 732         data = kmalloc(eeprom.len, GFP_KERNEL);
 733         if (!data)
 734                 return;
 735
 736         ops->get_eeprom(netdev, &eeprom, data);
 737
 738         csum_old = (data[EEPROM_CHECKSUM_REG * 2]) +
 739                    (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8);
 740         for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2)
 741                 csum_new += data[i] + (data[i + 1] << 8);
 742         csum_new = EEPROM_SUM - csum_new;
 743
 744         pr_err("/*********************/\n");
 745         pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old);
 746         pr_err("Calculated              : 0x%04x\n", csum_new);
 747
 748         pr_err("Offset    Values\n");
 749         pr_err("========  ======\n");
 750         print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0);
 751
 752         pr_err("Include this output when contacting your support provider.\n");
 753         pr_err("This is not a software error! Something bad happened to\n");
 754         pr_err("your hardware or EEPROM image. Ignoring this problem could\n");
 755         pr_err("result in further problems, possibly loss of data,\n");
 756         pr_err("corruption or system hangs!\n");
 757         pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n");
 758         pr_err("which is invalid and requires you to set the proper MAC\n");
 759         pr_err("address manually before continuing to enable this network\n");
 760         pr_err("device. Please inspect the EEPROM dump and report the\n");
 761         pr_err("issue to your hardware vendor or Intel Customer Support.\n");
 762         pr_err("/*********************/\n");
 763
 764         kfree(data);
 765 }
 766
 767 /**
 768  * e1000_is_need_ioport - determine if an adapter needs ioport resources or not
 769  * @pdev: PCI device information struct
 770  *
 771  * Return true if an adapter needs ioport resources
 772  **/
 773 static int e1000_is_need_ioport(struct pci_dev *pdev)
 774 {
 775         switch (pdev->device) {
 776         case E1000_DEV_ID_82540EM:
 777         case E1000_DEV_ID_82540EM_LOM:
 778         case E1000_DEV_ID_82540EP:
 779         case E1000_DEV_ID_82540EP_LOM:
 780         case E1000_DEV_ID_82540EP_LP:
 781         case E1000_DEV_ID_82541EI:
 782         case E1000_DEV_ID_82541EI_MOBILE:
 783         case E1000_DEV_ID_82541ER:
 784         case E1000_DEV_ID_82541ER_LOM:
 785         case E1000_DEV_ID_82541GI:
 786         case E1000_DEV_ID_82541GI_LF:
 787         case E1000_DEV_ID_82541GI_MOBILE:
 788         case E1000_DEV_ID_82544EI_COPPER:
 789         case E1000_DEV_ID_82544EI_FIBER:
 790         case E1000_DEV_ID_82544GC_COPPER:
 791         case E1000_DEV_ID_82544GC_LOM:
 792         case E1000_DEV_ID_82545EM_COPPER:
 793         case E1000_DEV_ID_82545EM_FIBER:
 794         case E1000_DEV_ID_82546EB_COPPER:
 795         case E1000_DEV_ID_82546EB_FIBER:
 796         case E1000_DEV_ID_82546EB_QUAD_COPPER:
 797                 return true;
 798         default:
 799                 return false;
 800         }
 801 }
 802
 803 static netdev_features_t e1000_fix_features(struct net_device *netdev,
 804         netdev_features_t features)
 805 {
 806         /*
 807          * Since there is no support for separate rx/tx vlan accel
 808          * enable/disable make sure tx flag is always in same state as rx.
 809          */
 810         if (features & NETIF_F_HW_VLAN_RX)
 811                 features |= NETIF_F_HW_VLAN_TX;
 812         else
 813                 features &= ~NETIF_F_HW_VLAN_TX;
 814
 815         return features;
 816 }
 817
 818 static int e1000_set_features(struct net_device *netdev,
 819         netdev_features_t features)
 820 {
 821         struct e1000_adapter *adapter = netdev_priv(netdev);
 822         netdev_features_t changed = features ^ netdev->features;
 823
 824         if (changed & NETIF_F_HW_VLAN_RX)
 825                 e1000_vlan_mode(netdev, features);
 826
 827         if (!(changed & NETIF_F_RXCSUM))
 828                 return 0;
 829
 830         adapter->rx_csum = !!(features & NETIF_F_RXCSUM);
 831
 832         if (netif_running(netdev))
 833                 e1000_reinit_locked(adapter);
 834         else
 835                 e1000_reset(adapter);
 836
 837         return 0;
 838 }
 839
 840 static const struct net_device_ops e1000_netdev_ops = {
 841         .ndo_open               = e1000_open,
 842         .ndo_stop               = e1000_close,
 843         .ndo_start_xmit         = e1000_xmit_frame,
 844         .ndo_get_stats          = e1000_get_stats,
 845         .ndo_set_rx_mode        = e1000_set_rx_mode,
 846         .ndo_set_mac_address    = e1000_set_mac,
 847         .ndo_tx_timeout         = e1000_tx_timeout,
 848         .ndo_change_mtu         = e1000_change_mtu,
 849         .ndo_do_ioctl           = e1000_ioctl,
 850         .ndo_validate_addr      = eth_validate_addr,
 851         .ndo_vlan_rx_add_vid    = e1000_vlan_rx_add_vid,
 852         .ndo_vlan_rx_kill_vid   = e1000_vlan_rx_kill_vid,
 853 #ifdef CONFIG_NET_POLL_CONTROLLER
 854         .ndo_poll_controller    = e1000_netpoll,
 855 #endif
 856         .ndo_fix_features       = e1000_fix_features,
 857         .ndo_set_features       = e1000_set_features,
 858 };
 859
 860 /**
 861  * e1000_init_hw_struct - initialize members of hw struct
 862  * @adapter: board private struct
 863  * @hw: structure used by e1000_hw.c
 864  *
 865  * Factors out initialization of the e1000_hw struct to its own function
 866  * that can be called very early at init (just after struct allocation).
 867  * Fields are initialized based on PCI device information and
 868  * OS network device settings (MTU size).
 869  * Returns negative error codes if MAC type setup fails.
 870  */
 871 static int e1000_init_hw_struct(struct e1000_adapter *adapter,
 872                                 struct e1000_hw *hw)
 873 {
 874         struct pci_dev *pdev = adapter->pdev;
 875
 876         /* PCI config space info */
 877         hw->vendor_id = pdev->vendor;
 878         hw->device_id = pdev->device;
 879         hw->subsystem_vendor_id = pdev->subsystem_vendor;
 880         hw->subsystem_id = pdev->subsystem_device;
 881         hw->revision_id = pdev->revision;
 882
 883         pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
 884
 885         hw->max_frame_size = adapter->netdev->mtu +
 886                              ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
 887         hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
 888
 889         /* identify the MAC */
 890         if (e1000_set_mac_type(hw)) {
 891                 e_err(probe, "Unknown MAC Type\n");
 892                 return -EIO;
 893         }
 894
 895         switch (hw->mac_type) {
 896         default:
 897                 break;
 898         case e1000_82541:
 899         case e1000_82547:
 900         case e1000_82541_rev_2:
 901         case e1000_82547_rev_2:
 902                 hw->phy_init_script = 1;
 903                 break;
 904         }
 905
 906         e1000_set_media_type(hw);
 907         e1000_get_bus_info(hw);
 908
 909         hw->wait_autoneg_complete = false;
 910         hw->tbi_compatibility_en = true;
 911         hw->adaptive_ifs = true;
 912
 913         /* Copper options */
 914
 915         if (hw->media_type == e1000_media_type_copper) {
 916                 hw->mdix = AUTO_ALL_MODES;
 917                 hw->disable_polarity_correction = false;
 918                 hw->master_slave = E1000_MASTER_SLAVE;
 919         }
 920
 921         return 0;
 922 }
 923
 924 /**
 925  * e1000_probe - Device Initialization Routine
 926  * @pdev: PCI device information struct
 927  * @ent: entry in e1000_pci_tbl
 928  *
 929  * Returns 0 on success, negative on failure
 930  *
 931  * e1000_probe initializes an adapter identified by a pci_dev structure.
 932  * The OS initialization, configuring of the adapter private structure,
 933  * and a hardware reset occur.
 934  **/
 935 static int __devinit e1000_probe(struct pci_dev *pdev,
 936                                  const struct pci_device_id *ent)
 937 {
 938         struct net_device *netdev;
 939         struct e1000_adapter *adapter;
 940         struct e1000_hw *hw;
 941
 942         static int cards_found = 0;
 943         static int global_quad_port_a = 0; /* global ksp3 port a indication */
 944         int i, err, pci_using_dac;
 945         u16 eeprom_data = 0;
 946         u16 tmp = 0;
 947         u16 eeprom_apme_mask = E1000_EEPROM_APME;
 948         int bars, need_ioport;
 949
 950         /* do not allocate ioport bars when not needed */
 951         need_ioport = e1000_is_need_ioport(pdev);
 952         if (need_ioport) {
 953                 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
 954                 err = pci_enable_device(pdev);
 955         } else {
 956                 bars = pci_select_bars(pdev, IORESOURCE_MEM);
 957                 err = pci_enable_device_mem(pdev);
 958         }
 959         if (err)
 960                 return err;
 961
 962         err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
 963         if (err)
 964                 goto err_pci_reg;
 965
 966         pci_set_master(pdev);
 967         err = pci_save_state(pdev);
 968         if (err)
 969                 goto err_alloc_etherdev;
 970
 971         err = -ENOMEM;
 972         netdev = alloc_etherdev(sizeof(struct e1000_adapter));
 973         if (!netdev)
 974                 goto err_alloc_etherdev;
 975
 976         SET_NETDEV_DEV(netdev, &pdev->dev);
 977
 978         pci_set_drvdata(pdev, netdev);
 979         adapter = netdev_priv(netdev);
 980         adapter->netdev = netdev;
 981         adapter->pdev = pdev;
 982         adapter->msg_enable = (1 << debug) - 1;
 983         adapter->bars = bars;
 984         adapter->need_ioport = need_ioport;
 985
 986         hw = &adapter->hw;
 987         hw->back = adapter;
 988
 989         err = -EIO;
 990         hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
 991         if (!hw->hw_addr)
 992                 goto err_ioremap;
 993
 994         if (adapter->need_ioport) {
 995                 for (i = BAR_1; i <= BAR_5; i++) {
 996                         if (pci_resource_len(pdev, i) == 0)
 997                                 continue;
 998                         if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
 999                                 hw->io_base = pci_resource_start(pdev, i);
1000                                 break;
1001                         }
1002                 }
1003         }
1004
1005         /* make ready for any if (hw->...) below */
1006         err = e1000_init_hw_struct(adapter, hw);
1007         if (err)
1008                 goto err_sw_init;
1009
1010         /*
1011          * there is a workaround being applied below that limits
1012          * 64-bit DMA addresses to 64-bit hardware.  There are some
1013          * 32-bit adapters that Tx hang when given 64-bit DMA addresses
1014          */
1015         pci_using_dac = 0;
1016         if ((hw->bus_type == e1000_bus_type_pcix) &&
1017             !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
1018                 /*
1019                  * according to DMA-API-HOWTO, coherent calls will always
1020                  * succeed if the set call did
1021                  */
1022                 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
1023                 pci_using_dac = 1;
1024         } else {
1025                 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
1026                 if (err) {
1027                         pr_err("No usable DMA config, aborting\n");
1028                         goto err_dma;
1029                 }
1030                 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
1031         }
1032
1033         netdev->netdev_ops = &e1000_netdev_ops;
1034         e1000_set_ethtool_ops(netdev);
1035         netdev->watchdog_timeo = 5 * HZ;
1036         netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
1037
1038         strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
1039
1040         adapter->bd_number = cards_found;
1041
1042         /* setup the private structure */
1043
1044         err = e1000_sw_init(adapter);
1045         if (err)
1046                 goto err_sw_init;
1047
1048         err = -EIO;
1049         if (hw->mac_type == e1000_ce4100) {
1050                 hw->ce4100_gbe_mdio_base_virt =
1051                                         ioremap(pci_resource_start(pdev, BAR_1),
1052                                                 pci_resource_len(pdev, BAR_1));
1053
1054                 if (!hw->ce4100_gbe_mdio_base_virt)
1055                         goto err_mdio_ioremap;
1056         }
1057
1058         if (hw->mac_type >= e1000_82543) {
1059                 netdev->hw_features = NETIF_F_SG |
1060                                    NETIF_F_HW_CSUM |
1061                                    NETIF_F_HW_VLAN_RX;
1062                 netdev->features = NETIF_F_HW_VLAN_TX |
1063                                    NETIF_F_HW_VLAN_FILTER;
1064         }
1065
1066         if ((hw->mac_type >= e1000_82544) &&
1067            (hw->mac_type != e1000_82547))
1068                 netdev->hw_features |= NETIF_F_TSO;
1069
1070         netdev->priv_flags |= IFF_SUPP_NOFCS;
1071
1072         netdev->features |= netdev->hw_features;
1073         netdev->hw_features |= NETIF_F_RXCSUM;
1074         netdev->hw_features |= NETIF_F_RXFCS;
1075
1076         if (pci_using_dac) {
1077                 netdev->features |= NETIF_F_HIGHDMA;
1078                 netdev->vlan_features |= NETIF_F_HIGHDMA;
1079         }
1080
1081         netdev->vlan_features |= NETIF_F_TSO;
1082         netdev->vlan_features |= NETIF_F_HW_CSUM;
1083         netdev->vlan_features |= NETIF_F_SG;
1084
1085         netdev->priv_flags |= IFF_UNICAST_FLT;
1086
1087         adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw);
1088
1089         /* initialize eeprom parameters */
1090         if (e1000_init_eeprom_params(hw)) {
1091                 e_err(probe, "EEPROM initialization failed\n");
1092                 goto err_eeprom;
1093         }
1094
1095         /* before reading the EEPROM, reset the controller to
1096          * put the device in a known good starting state */
1097
1098         e1000_reset_hw(hw);
1099
1100         /* make sure the EEPROM is good */
1101         if (e1000_validate_eeprom_checksum(hw) < 0) {
1102                 e_err(probe, "The EEPROM Checksum Is Not Valid\n");
1103                 e1000_dump_eeprom(adapter);
1104                 /*
1105                  * set MAC address to all zeroes to invalidate and temporary
1106                  * disable this device for the user. This blocks regular
1107                  * traffic while still permitting ethtool ioctls from reaching
1108                  * the hardware as well as allowing the user to run the
1109                  * interface after manually setting a hw addr using
1110                  * `ip set address`
1111                  */
1112                 memset(hw->mac_addr, 0, netdev->addr_len);
1113         } else {
1114                 /* copy the MAC address out of the EEPROM */
1115                 if (e1000_read_mac_addr(hw))
1116                         e_err(probe, "EEPROM Read Error\n");
1117         }
1118         /* don't block initalization here due to bad MAC address */
1119         memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);
1120         memcpy(netdev->perm_addr, hw->mac_addr, netdev->addr_len);
1121
1122         if (!is_valid_ether_addr(netdev->perm_addr))
1123                 e_err(probe, "Invalid MAC Address\n");
1124
1125
1126         INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog);
1127         INIT_DELAYED_WORK(&adapter->fifo_stall_task,
1128                           e1000_82547_tx_fifo_stall_task);
1129         INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);
1130         INIT_WORK(&adapter->reset_task, e1000_reset_task);
1131
1132         e1000_check_options(adapter);
1133
1134         /* Initial Wake on LAN setting
1135          * If APM wake is enabled in the EEPROM,
1136          * enable the ACPI Magic Packet filter
1137          */
1138
1139         switch (hw->mac_type) {
1140         case e1000_82542_rev2_0:
1141         case e1000_82542_rev2_1:
1142         case e1000_82543:
1143                 break;
1144         case e1000_82544:
1145                 e1000_read_eeprom(hw,
1146                         EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
1147                 eeprom_apme_mask = E1000_EEPROM_82544_APM;
1148                 break;
1149         case e1000_82546:
1150         case e1000_82546_rev_3:
1151                 if (er32(STATUS) & E1000_STATUS_FUNC_1){
1152                         e1000_read_eeprom(hw,
1153                                 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
1154                         break;
1155                 }
1156                 /* Fall Through */
1157         default:
1158                 e1000_read_eeprom(hw,
1159                         EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
1160                 break;
1161         }
1162         if (eeprom_data & eeprom_apme_mask)
1163                 adapter->eeprom_wol |= E1000_WUFC_MAG;
1164
1165         /* now that we have the eeprom settings, apply the special cases
1166          * where the eeprom may be wrong or the board simply won't support
1167          * wake on lan on a particular port */
1168         switch (pdev->device) {
1169         case E1000_DEV_ID_82546GB_PCIE:
1170                 adapter->eeprom_wol = 0;
1171                 break;
1172         case E1000_DEV_ID_82546EB_FIBER:
1173         case E1000_DEV_ID_82546GB_FIBER:
1174                 /* Wake events only supported on port A for dual fiber
1175                  * regardless of eeprom setting */
1176                 if (er32(STATUS) & E1000_STATUS_FUNC_1)
1177                         adapter->eeprom_wol = 0;
1178                 break;
1179         case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1180                 /* if quad port adapter, disable WoL on all but port A */
1181                 if (global_quad_port_a != 0)
1182                         adapter->eeprom_wol = 0;
1183                 else
1184                         adapter->quad_port_a = true;
1185                 /* Reset for multiple quad port adapters */
1186                 if (++global_quad_port_a == 4)
1187                         global_quad_port_a = 0;
1188                 break;
1189         }
1190
1191         /* initialize the wol settings based on the eeprom settings */
1192         adapter->wol = adapter->eeprom_wol;
1193         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1194
1195         /* Auto detect PHY address */
1196         if (hw->mac_type == e1000_ce4100) {
1197                 for (i = 0; i < 32; i++) {
1198                         hw->phy_addr = i;
1199                         e1000_read_phy_reg(hw, PHY_ID2, &tmp);
1200                         if (tmp == 0 || tmp == 0xFF) {
1201                                 if (i == 31)
1202                                         goto err_eeprom;
1203                                 continue;
1204                         } else
1205                                 break;
1206                 }
1207         }
1208
1209         /* reset the hardware with the new settings */
1210         e1000_reset(adapter);
1211
1212         strcpy(netdev->name, "eth%d");
1213         err = register_netdev(netdev);
1214         if (err)
1215                 goto err_register;
1216
1217         e1000_vlan_mode(netdev, netdev->features);
1218
1219         /* print bus type/speed/width info */
1220         e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",
1221                ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),
1222                ((hw->bus_speed == e1000_bus_speed_133) ? 133 :
1223                 (hw->bus_speed == e1000_bus_speed_120) ? 120 :
1224                 (hw->bus_speed == e1000_bus_speed_100) ? 100 :
1225                 (hw->bus_speed == e1000_bus_speed_66) ? 66 : 33),
1226                ((hw->bus_width == e1000_bus_width_64) ? 64 : 32),
1227                netdev->dev_addr);
1228
1229         /* carrier off reporting is important to ethtool even BEFORE open */
1230         netif_carrier_off(netdev);
1231
1232         e_info(probe, "Intel(R) PRO/1000 Network Connection\n");
1233
1234         cards_found++;
1235         return 0;
1236
1237 err_register:
1238 err_eeprom:
1239         e1000_phy_hw_reset(hw);
1240
1241         if (hw->flash_address)
1242                 iounmap(hw->flash_address);
1243         kfree(adapter->tx_ring);
1244         kfree(adapter->rx_ring);
1245 err_dma:
1246 err_sw_init:
1247 err_mdio_ioremap:
1248         iounmap(hw->ce4100_gbe_mdio_base_virt);
1249         iounmap(hw->hw_addr);
1250 err_ioremap:
1251         free_netdev(netdev);
1252 err_alloc_etherdev:
1253         pci_release_selected_regions(pdev, bars);
1254 err_pci_reg:
1255         pci_disable_device(pdev);
1256         return err;
1257 }
1258
1259 /**
1260  * e1000_remove - Device Removal Routine
1261  * @pdev: PCI device information struct
1262  *
1263  * e1000_remove is called by the PCI subsystem to alert the driver
1264  * that it should release a PCI device.  The could be caused by a
1265  * Hot-Plug event, or because the driver is going to be removed from
1266  * memory.
1267  **/
1268
1269 static void __devexit e1000_remove(struct pci_dev *pdev)
1270 {
1271         struct net_device *netdev = pci_get_drvdata(pdev);
1272         struct e1000_adapter *adapter = netdev_priv(netdev);
1273         struct e1000_hw *hw = &adapter->hw;
1274
1275         e1000_down_and_stop(adapter);
1276         e1000_release_manageability(adapter);
1277
1278         unregister_netdev(netdev);
1279
1280         e1000_phy_hw_reset(hw);
1281
1282         kfree(adapter->tx_ring);
1283         kfree(adapter->rx_ring);
1284
1285         if (hw->mac_type == e1000_ce4100)
1286                 iounmap(hw->ce4100_gbe_mdio_base_virt);
1287         iounmap(hw->hw_addr);
1288         if (hw->flash_address)
1289                 iounmap(hw->flash_address);
1290         pci_release_selected_regions(pdev, adapter->bars);
1291
1292         free_netdev(netdev);
1293
1294         pci_disable_device(pdev);
1295 }
1296
1297 /**
1298  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
1299  * @adapter: board private structure to initialize
1300  *
1301  * e1000_sw_init initializes the Adapter private data structure.
1302  * e1000_init_hw_struct MUST be called before this function
1303  **/
1304
1305 static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
1306 {
1307         adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
1308
1309         adapter->num_tx_queues = 1;
1310         adapter->num_rx_queues = 1;
1311
1312         if (e1000_alloc_queues(adapter)) {
1313                 e_err(probe, "Unable to allocate memory for queues\n");
1314                 return -ENOMEM;
1315         }
1316
1317         /* Explicitly disable IRQ since the NIC can be in any state. */
1318         e1000_irq_disable(adapter);
1319
1320         spin_lock_init(&adapter->stats_lock);
1321         mutex_init(&adapter->mutex);
1322
1323         set_bit(__E1000_DOWN, &adapter->flags);
1324
1325         return 0;
1326 }
1327
1328 /**
1329  * e1000_alloc_queues - Allocate memory for all rings
1330  * @adapter: board private structure to initialize
1331  *
1332  * We allocate one ring per queue at run-time since we don't know the
1333  * number of queues at compile-time.
1334  **/
1335
1336 static int __devinit e1000_alloc_queues(struct e1000_adapter *adapter)
1337 {
1338         adapter->tx_ring = kcalloc(adapter->num_tx_queues,
1339                                    sizeof(struct e1000_tx_ring), GFP_KERNEL);
1340         if (!adapter->tx_ring)
1341                 return -ENOMEM;
1342
1343         adapter->rx_ring = kcalloc(adapter->num_rx_queues,
1344                                    sizeof(struct e1000_rx_ring), GFP_KERNEL);
1345         if (!adapter->rx_ring) {
1346                 kfree(adapter->tx_ring);
1347                 return -ENOMEM;
1348         }
1349
1350         return E1000_SUCCESS;
1351 }
1352
1353 /**
1354  * e1000_open - Called when a network interface is made active
1355  * @netdev: network interface device structure
1356  *
1357  * Returns 0 on success, negative value on failure
1358  *
1359  * The open entry point is called when a network interface is made
1360  * active by the system (IFF_UP).  At this point all resources needed
1361  * for transmit and receive operations are allocated, the interrupt
1362  * handler is registered with the OS, the watchdog task is started,
1363  * and the stack is notified that the interface is ready.
1364  **/
1365
1366 static int e1000_open(struct net_device *netdev)
1367 {
1368         struct e1000_adapter *adapter = netdev_priv(netdev);
1369         struct e1000_hw *hw = &adapter->hw;
1370         int err;
1371
1372         /* disallow open during test */
1373         if (test_bit(__E1000_TESTING, &adapter->flags))
1374                 return -EBUSY;
1375
1376         netif_carrier_off(netdev);
1377
1378         /* allocate transmit descriptors */
1379         err = e1000_setup_all_tx_resources(adapter);
1380         if (err)
1381                 goto err_setup_tx;
1382
1383         /* allocate receive descriptors */
1384         err = e1000_setup_all_rx_resources(adapter);
1385         if (err)
1386                 goto err_setup_rx;
1387
1388         e1000_power_up_phy(adapter);
1389
1390         adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
1391         if ((hw->mng_cookie.status &
1392                           E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
1393                 e1000_update_mng_vlan(adapter);
1394         }
1395
1396         /* before we allocate an interrupt, we must be ready to handle it.
1397          * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
1398          * as soon as we call pci_request_irq, so we have to setup our
1399          * clean_rx handler before we do so.  */
1400         e1000_configure(adapter);
1401
1402         err = e1000_request_irq(adapter);
1403         if (err)
1404                 goto err_req_irq;
1405
1406         /* From here on the code is the same as e1000_up() */
1407         clear_bit(__E1000_DOWN, &adapter->flags);
1408
1409         napi_enable(&adapter->napi);
1410
1411         e1000_irq_enable(adapter);
1412
1413         netif_start_queue(netdev);
1414
1415         /* fire a link status change interrupt to start the watchdog */
1416         ew32(ICS, E1000_ICS_LSC);
1417
1418         return E1000_SUCCESS;
1419
1420 err_req_irq:
1421         e1000_power_down_phy(adapter);
1422         e1000_free_all_rx_resources(adapter);
1423 err_setup_rx:
1424         e1000_free_all_tx_resources(adapter);
1425 err_setup_tx:
1426         e1000_reset(adapter);
1427
1428         return err;
1429 }
1430
1431 /**
1432  * e1000_close - Disables a network interface
1433  * @netdev: network interface device structure
1434  *
1435  * Returns 0, this is not allowed to fail
1436  *
1437  * The close entry point is called when an interface is de-activated
1438  * by the OS.  The hardware is still under the drivers control, but
1439  * needs to be disabled.  A global MAC reset is issued to stop the
1440  * hardware, and all transmit and receive resources are freed.
1441  **/
1442
1443 static int e1000_close(struct net_device *netdev)
1444 {
1445         struct e1000_adapter *adapter = netdev_priv(netdev);
1446         struct e1000_hw *hw = &adapter->hw;
1447
1448         WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
1449         e1000_down(adapter);
1450         e1000_power_down_phy(adapter);
1451         e1000_free_irq(adapter);
1452
1453         e1000_free_all_tx_resources(adapter);
1454         e1000_free_all_rx_resources(adapter);
1455
1456         /* kill manageability vlan ID if supported, but not if a vlan with
1457          * the same ID is registered on the host OS (let 8021q kill it) */
1458         if ((hw->mng_cookie.status &
1459                           E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
1460              !test_bit(adapter->mng_vlan_id, adapter->active_vlans)) {
1461                 e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
1462         }
1463
1464         return 0;
1465 }
1466
1467 /**
1468  * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
1469  * @adapter: address of board private structure
1470  * @start: address of beginning of memory
1471  * @len: length of memory
1472  **/
1473 static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start,
1474                                   unsigned long len)
1475 {
1476         struct e1000_hw *hw = &adapter->hw;
1477         unsigned long begin = (unsigned long)start;
1478         unsigned long end = begin + len;
1479
1480         /* First rev 82545 and 82546 need to not allow any memory
1481          * write location to cross 64k boundary due to errata 23 */
1482         if (hw->mac_type == e1000_82545 ||
1483             hw->mac_type == e1000_ce4100 ||
1484             hw->mac_type == e1000_82546) {
1485                 return ((begin ^ (end - 1)) >> 16) != 0 ? false : true;
1486         }
1487
1488         return true;
1489 }
1490
1491 /**
1492  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
1493  * @adapter: board private structure
1494  * @txdr:    tx descriptor ring (for a specific queue) to setup
1495  *
1496  * Return 0 on success, negative on failure
1497  **/
1498
1499 static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
1500                                     struct e1000_tx_ring *txdr)
1501 {
1502         struct pci_dev *pdev = adapter->pdev;
1503         int size;
1504
1505         size = sizeof(struct e1000_buffer) * txdr->count;
1506         txdr->buffer_info = vzalloc(size);
1507         if (!txdr->buffer_info) {
1508                 e_err(probe, "Unable to allocate memory for the Tx descriptor "
1509                       "ring\n");
1510                 return -ENOMEM;
1511         }
1512
1513         /* round up to nearest 4K */
1514
1515         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
1516         txdr->size = ALIGN(txdr->size, 4096);
1517
1518         txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
1519                                         GFP_KERNEL);
1520         if (!txdr->desc) {
1521 setup_tx_desc_die:
1522                 vfree(txdr->buffer_info);
1523                 e_err(probe, "Unable to allocate memory for the Tx descriptor "
1524                       "ring\n");
1525                 return -ENOMEM;
1526         }
1527
1528         /* Fix for errata 23, can't cross 64kB boundary */
1529         if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
1530                 void *olddesc = txdr->desc;
1531                 dma_addr_t olddma = txdr->dma;
1532                 e_err(tx_err, "txdr align check failed: %u bytes at %p\n",
1533                       txdr->size, txdr->desc);
1534                 /* Try again, without freeing the previous */
1535                 txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size,
1536                                                 &txdr->dma, GFP_KERNEL);
1537                 /* Failed allocation, critical failure */
1538                 if (!txdr->desc) {
1539                         dma_free_coherent(&pdev->dev, txdr->size, olddesc,
1540                                           olddma);
1541                         goto setup_tx_desc_die;
1542                 }
1543
1544                 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
1545                         /* give up */
1546                         dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
1547                                           txdr->dma);
1548                         dma_free_coherent(&pdev->dev, txdr->size, olddesc,
1549                                           olddma);
1550                         e_err(probe, "Unable to allocate aligned memory "
1551                               "for the transmit descriptor ring\n");
1552                         vfree(txdr->buffer_info);
1553                         return -ENOMEM;
1554                 } else {
1555                         /* Free old allocation, new allocation was successful */
1556                         dma_free_coherent(&pdev->dev, txdr->size, olddesc,
1557                                           olddma);
1558                 }
1559         }
1560         memset(txdr->desc, 0, txdr->size);
1561
1562         txdr->next_to_use = 0;
1563         txdr->next_to_clean = 0;
1564
1565         return 0;
1566 }
1567
1568 /**
1569  * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
1570  *                                (Descriptors) for all queues
1571  * @adapter: board private structure
1572  *
1573  * Return 0 on success, negative on failure
1574  **/
1575
1576 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
1577 {
1578         int i, err = 0;
1579
1580         for (i = 0; i < adapter->num_tx_queues; i++) {
1581                 err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
1582                 if (err) {
1583                         e_err(probe, "Allocation for Tx Queue %u failed\n", i);
1584                         for (i-- ; i >= 0; i--)
1585                                 e1000_free_tx_resources(adapter,
1586                                                         &adapter->tx_ring[i]);
1587                         break;
1588                 }
1589         }
1590
1591         return err;
1592 }
1593
1594 /**
1595  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
1596  * @adapter: board private structure
1597  *
1598  * Configure the Tx unit of the MAC after a reset.
1599  **/
1600
1601 static void e1000_configure_tx(struct e1000_adapter *adapter)
1602 {
1603         u64 tdba;
1604         struct e1000_hw *hw = &adapter->hw;
1605         u32 tdlen, tctl, tipg;
1606         u32 ipgr1, ipgr2;
1607
1608         /* Setup the HW Tx Head and Tail descriptor pointers */
1609
1610         switch (adapter->num_tx_queues) {
1611         case 1:
1612         default:
1613                 tdba = adapter->tx_ring[0].dma;
1614                 tdlen = adapter->tx_ring[0].count *
1615                         sizeof(struct e1000_tx_desc);
1616                 ew32(TDLEN, tdlen);
1617                 ew32(TDBAH, (tdba >> 32));
1618                 ew32(TDBAL, (tdba & 0x00000000ffffffffULL));
1619                 ew32(TDT, 0);
1620                 ew32(TDH, 0);
1621                 adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ? E1000_TDH : E1000_82542_TDH);
1622                 adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ? E1000_TDT : E1000_82542_TDT);
1623                 break;
1624         }
1625
1626         /* Set the default values for the Tx Inter Packet Gap timer */
1627         if ((hw->media_type == e1000_media_type_fiber ||
1628              hw->media_type == e1000_media_type_internal_serdes))
1629                 tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
1630         else
1631                 tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
1632
1633         switch (hw->mac_type) {
1634         case e1000_82542_rev2_0:
1635         case e1000_82542_rev2_1:
1636                 tipg = DEFAULT_82542_TIPG_IPGT;
1637                 ipgr1 = DEFAULT_82542_TIPG_IPGR1;
1638                 ipgr2 = DEFAULT_82542_TIPG_IPGR2;
1639                 break;
1640         default:
1641                 ipgr1 = DEFAULT_82543_TIPG_IPGR1;
1642                 ipgr2 = DEFAULT_82543_TIPG_IPGR2;
1643                 break;
1644         }
1645         tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
1646         tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
1647         ew32(TIPG, tipg);
1648
1649         /* Set the Tx Interrupt Delay register */
1650
1651         ew32(TIDV, adapter->tx_int_delay);
1652         if (hw->mac_type >= e1000_82540)
1653                 ew32(TADV, adapter->tx_abs_int_delay);
1654
1655         /* Program the Transmit Control Register */
1656
1657         tctl = er32(TCTL);
1658         tctl &= ~E1000_TCTL_CT;
1659         tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
1660                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
1661
1662         e1000_config_collision_dist(hw);
1663
1664         /* Setup Transmit Descriptor Settings for eop descriptor */
1665         adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;
1666
1667         /* only set IDE if we are delaying interrupts using the timers */
1668         if (adapter->tx_int_delay)
1669                 adapter->txd_cmd |= E1000_TXD_CMD_IDE;
1670
1671         if (hw->mac_type < e1000_82543)
1672                 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
1673         else
1674                 adapter->txd_cmd |= E1000_TXD_CMD_RS;
1675
1676         /* Cache if we're 82544 running in PCI-X because we'll
1677          * need this to apply a workaround later in the send path. */
1678         if (hw->mac_type == e1000_82544 &&
1679             hw->bus_type == e1000_bus_type_pcix)
1680                 adapter->pcix_82544 = true;
1681
1682         ew32(TCTL, tctl);
1683
1684 }
1685
1686 /**
1687  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
1688  * @adapter: board private structure
1689  * @rxdr:    rx descriptor ring (for a specific queue) to setup
1690  *
1691  * Returns 0 on success, negative on failure
1692  **/
1693
1694 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
1695                                     struct e1000_rx_ring *rxdr)
1696 {
1697         struct pci_dev *pdev = adapter->pdev;
1698         int size, desc_len;
1699
1700         size = sizeof(struct e1000_buffer) * rxdr->count;
1701         rxdr->buffer_info = vzalloc(size);
1702         if (!rxdr->buffer_info) {
1703                 e_err(probe, "Unable to allocate memory for the Rx descriptor "
1704                       "ring\n");
1705                 return -ENOMEM;
1706         }
1707
1708         desc_len = sizeof(struct e1000_rx_desc);
1709
1710         /* Round up to nearest 4K */
1711
1712         rxdr->size = rxdr->count * desc_len;
1713         rxdr->size = ALIGN(rxdr->size, 4096);
1714
1715         rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
1716                                         GFP_KERNEL);
1717
1718         if (!rxdr->desc) {
1719                 e_err(probe, "Unable to allocate memory for the Rx descriptor "
1720                       "ring\n");
1721 setup_rx_desc_die:
1722                 vfree(rxdr->buffer_info);
1723                 return -ENOMEM;
1724         }
1725
1726         /* Fix for errata 23, can't cross 64kB boundary */
1727         if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
1728                 void *olddesc = rxdr->desc;
1729                 dma_addr_t olddma = rxdr->dma;
1730                 e_err(rx_err, "rxdr align check failed: %u bytes at %p\n",
1731                       rxdr->size, rxdr->desc);
1732                 /* Try again, without freeing the previous */
1733                 rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size,
1734                                                 &rxdr->dma, GFP_KERNEL);
1735                 /* Failed allocation, critical failure */
1736                 if (!rxdr->desc) {
1737                         dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
1738                                           olddma);
1739                         e_err(probe, "Unable to allocate memory for the Rx "
1740                               "descriptor ring\n");
1741                         goto setup_rx_desc_die;
1742                 }
1743
1744                 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
1745                         /* give up */
1746                         dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
1747                                           rxdr->dma);
1748                         dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
1749                                           olddma);
1750                         e_err(probe, "Unable to allocate aligned memory for "
1751                               "the Rx descriptor ring\n");
1752                         goto setup_rx_desc_die;
1753                 } else {
1754                         /* Free old allocation, new allocation was successful */
1755                         dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
1756                                           olddma);
1757                 }
1758         }
1759         memset(rxdr->desc, 0, rxdr->size);
1760
1761         rxdr->next_to_clean = 0;
1762         rxdr->next_to_use = 0;
1763         rxdr->rx_skb_top = NULL;
1764
1765         return 0;
1766 }
1767
1768 /**
1769  * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
1770  *                                (Descriptors) for all queues
1771  * @adapter: board private structure
1772  *
1773  * Return 0 on success, negative on failure
1774  **/
1775
1776 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
1777 {
1778         int i, err = 0;
1779
1780         for (i = 0; i < adapter->num_rx_queues; i++) {
1781                 err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
1782                 if (err) {
1783                         e_err(probe, "Allocation for Rx Queue %u failed\n", i);
1784                         for (i-- ; i >= 0; i--)
1785                                 e1000_free_rx_resources(adapter,
1786                                                         &adapter->rx_ring[i]);
1787                         break;
1788                 }
1789         }
1790
1791         return err;
1792 }
1793
1794 /**
1795  * e1000_setup_rctl - configure the receive control registers
1796  * @adapter: Board private structure
1797  **/
1798 static void e1000_setup_rctl(struct e1000_adapter *adapter)
1799 {
1800         struct e1000_hw *hw = &adapter->hw;
1801         u32 rctl;
1802
1803         rctl = er32(RCTL);
1804
1805         rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
1806
1807         rctl |= E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
1808                 E1000_RCTL_RDMTS_HALF |
1809                 (hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
1810
1811         if (hw->tbi_compatibility_on == 1)
1812                 rctl |= E1000_RCTL_SBP;
1813         else
1814                 rctl &= ~E1000_RCTL_SBP;
1815
1816         if (adapter->netdev->mtu <= ETH_DATA_LEN)
1817                 rctl &= ~E1000_RCTL_LPE;
1818         else
1819                 rctl |= E1000_RCTL_LPE;
1820
1821         /* Setup buffer sizes */
1822         rctl &= ~E1000_RCTL_SZ_4096;
1823         rctl |= E1000_RCTL_BSEX;
1824         switch (adapter->rx_buffer_len) {
1825                 case E1000_RXBUFFER_2048:
1826                 default:
1827                         rctl |= E1000_RCTL_SZ_2048;
1828                         rctl &= ~E1000_RCTL_BSEX;
1829                         break;
1830                 case E1000_RXBUFFER_4096:
1831                         rctl |= E1000_RCTL_SZ_4096;
1832                         break;
1833                 case E1000_RXBUFFER_8192:
1834                         rctl |= E1000_RCTL_SZ_8192;
1835                         break;
1836                 case E1000_RXBUFFER_16384:
1837                         rctl |= E1000_RCTL_SZ_16384;
1838                         break;
1839         }
1840
1841         ew32(RCTL, rctl);
1842 }
1843
1844 /**
1845  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
1846  * @adapter: board private structure
1847  *
1848  * Configure the Rx unit of the MAC after a reset.
1849  **/
1850
1851 static void e1000_configure_rx(struct e1000_adapter *adapter)
1852 {
1853         u64 rdba;
1854         struct e1000_hw *hw = &adapter->hw;
1855         u32 rdlen, rctl, rxcsum;
1856
1857         if (adapter->netdev->mtu > ETH_DATA_LEN) {
1858                 rdlen = adapter->rx_ring[0].count *
1859                         sizeof(struct e1000_rx_desc);
1860                 adapter->clean_rx = e1000_clean_jumbo_rx_irq;
1861                 adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
1862         } else {
1863                 rdlen = adapter->rx_ring[0].count *
1864                         sizeof(struct e1000_rx_desc);
1865                 adapter->clean_rx = e1000_clean_rx_irq;
1866                 adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
1867         }
1868
1869         /* disable receives while setting up the descriptors */
1870         rctl = er32(RCTL);
1871         ew32(RCTL, rctl & ~E1000_RCTL_EN);
1872
1873         /* set the Receive Delay Timer Register */
1874         ew32(RDTR, adapter->rx_int_delay);
1875
1876         if (hw->mac_type >= e1000_82540) {
1877                 ew32(RADV, adapter->rx_abs_int_delay);
1878                 if (adapter->itr_setting != 0)
1879                         ew32(ITR, 1000000000 / (adapter->itr * 256));
1880         }
1881
1882         /* Setup the HW Rx Head and Tail Descriptor Pointers and
1883          * the Base and Length of the Rx Descriptor Ring */
1884         switch (adapter->num_rx_queues) {
1885         case 1:
1886         default:
1887                 rdba = adapter->rx_ring[0].dma;
1888                 ew32(RDLEN, rdlen);
1889                 ew32(RDBAH, (rdba >> 32));
1890                 ew32(RDBAL, (rdba & 0x00000000ffffffffULL));
1891                 ew32(RDT, 0);
1892                 ew32(RDH, 0);
1893                 adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? E1000_RDH : E1000_82542_RDH);
1894                 adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? E1000_RDT : E1000_82542_RDT);
1895                 break;
1896         }
1897
1898         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
1899         if (hw->mac_type >= e1000_82543) {
1900                 rxcsum = er32(RXCSUM);
1901                 if (adapter->rx_csum)
1902                         rxcsum |= E1000_RXCSUM_TUOFL;
1903                 else
1904                         /* don't need to clear IPPCSE as it defaults to 0 */
1905                         rxcsum &= ~E1000_RXCSUM_TUOFL;
1906                 ew32(RXCSUM, rxcsum);
1907         }
1908
1909         /* Enable Receives */
1910         ew32(RCTL, rctl | E1000_RCTL_EN);
1911 }
1912
1913 /**
1914  * e1000_free_tx_resources - Free Tx Resources per Queue
1915  * @adapter: board private structure
1916  * @tx_ring: Tx descriptor ring for a specific queue
1917  *
1918  * Free all transmit software resources
1919  **/
1920
1921 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
1922                                     struct e1000_tx_ring *tx_ring)
1923 {
1924         struct pci_dev *pdev = adapter->pdev;
1925
1926         e1000_clean_tx_ring(adapter, tx_ring);
1927
1928         vfree(tx_ring->buffer_info);
1929         tx_ring->buffer_info = NULL;
1930
1931         dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
1932                           tx_ring->dma);
1933
1934         tx_ring->desc = NULL;
1935 }
1936
1937 /**
1938  * e1000_free_all_tx_resources - Free Tx Resources for All Queues
1939  * @adapter: board private structure
1940  *
1941  * Free all transmit software resources
1942  **/
1943
1944 void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
1945 {
1946         int i;
1947
1948         for (i = 0; i < adapter->num_tx_queues; i++)
1949                 e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
1950 }
1951
1952 static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
1953                                              struct e1000_buffer *buffer_info)
1954 {
1955         if (buffer_info->dma) {
1956                 if (buffer_info->mapped_as_page)
1957                         dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
1958                                        buffer_info->length, DMA_TO_DEVICE);
1959                 else
1960                         dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
1961                                          buffer_info->length,
1962                                          DMA_TO_DEVICE);
1963                 buffer_info->dma = 0;
1964         }
1965         if (buffer_info->skb) {
1966                 dev_kfree_skb_any(buffer_info->skb);
1967                 buffer_info->skb = NULL;
1968         }
1969         buffer_info->time_stamp = 0;
1970         /* buffer_info must be completely set up in the transmit path */
1971 }
1972
1973 /**
1974  * e1000_clean_tx_ring - Free Tx Buffers
1975  * @adapter: board private structure
1976  * @tx_ring: ring to be cleaned
1977  **/
1978
1979 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
1980                                 struct e1000_tx_ring *tx_ring)
1981 {
1982         struct e1000_hw *hw = &adapter->hw;
1983         struct e1000_buffer *buffer_info;
1984         unsigned long size;
1985         unsigned int i;
1986
1987         /* Free all the Tx ring sk_buffs */
1988
1989         for (i = 0; i < tx_ring->count; i++) {
1990                 buffer_info = &tx_ring->buffer_info[i];
1991                 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
1992         }
1993
1994         size = sizeof(struct e1000_buffer) * tx_ring->count;
1995         memset(tx_ring->buffer_info, 0, size);
1996
1997         /* Zero out the descriptor ring */
1998
1999         memset(tx_ring->desc, 0, tx_ring->size);
2000
2001         tx_ring->next_to_use = 0;
2002         tx_ring->next_to_clean = 0;
2003         tx_ring->last_tx_tso = false;
2004
2005         writel(0, hw->hw_addr + tx_ring->tdh);
2006         writel(0, hw->hw_addr + tx_ring->tdt);
2007 }
2008
2009 /**
2010  * e1000_clean_all_tx_rings - Free Tx Buffers for all queues
2011  * @adapter: board private structure
2012  **/
2013
2014 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
2015 {
2016         int i;
2017
2018         for (i = 0; i < adapter->num_tx_queues; i++)
2019                 e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
2020 }
2021
2022 /**
2023  * e1000_free_rx_resources - Free Rx Resources
2024  * @adapter: board private structure
2025  * @rx_ring: ring to clean the resources from
2026  *
2027  * Free all receive software resources
2028  **/
2029
2030 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
2031                                     struct e1000_rx_ring *rx_ring)
2032 {
2033         struct pci_dev *pdev = adapter->pdev;
2034
2035         e1000_clean_rx_ring(adapter, rx_ring);
2036
2037         vfree(rx_ring->buffer_info);
2038         rx_ring->buffer_info = NULL;
2039
2040         dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
2041                           rx_ring->dma);
2042
2043         rx_ring->desc = NULL;
2044 }
2045
2046 /**
2047  * e1000_free_all_rx_resources - Free Rx Resources for All Queues
2048  * @adapter: board private structure
2049  *
2050  * Free all receive software resources
2051  **/
2052
2053 void e1000_free_all_rx_resources(struct e1000_adapter *adapter)
2054 {
2055         int i;
2056
2057         for (i = 0; i < adapter->num_rx_queues; i++)
2058                 e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
2059 }
2060
2061 /**
2062  * e1000_clean_rx_ring - Free Rx Buffers per Queue
2063  * @adapter: board private structure
2064  * @rx_ring: ring to free buffers from
2065  **/
2066
2067 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
2068                                 struct e1000_rx_ring *rx_ring)
2069 {
2070         struct e1000_hw *hw = &adapter->hw;
2071         struct e1000_buffer *buffer_info;
2072         struct pci_dev *pdev = adapter->pdev;
2073         unsigned long size;
2074         unsigned int i;
2075
2076         /* Free all the Rx ring sk_buffs */
2077         for (i = 0; i < rx_ring->count; i++) {
2078                 buffer_info = &rx_ring->buffer_info[i];
2079                 if (buffer_info->dma &&
2080                     adapter->clean_rx == e1000_clean_rx_irq) {
2081                         dma_unmap_single(&pdev->dev, buffer_info->dma,
2082                                          buffer_info->length,
2083                                          DMA_FROM_DEVICE);
2084                 } else if (buffer_info->dma &&
2085                            adapter->clean_rx == e1000_clean_jumbo_rx_irq) {
2086                         dma_unmap_page(&pdev->dev, buffer_info->dma,
2087                                        buffer_info->length,
2088                                        DMA_FROM_DEVICE);
2089                 }
2090
2091                 buffer_info->dma = 0;
2092                 if (buffer_info->page) {
2093                         put_page(buffer_info->page);
2094                         buffer_info->page = NULL;
2095                 }
2096                 if (buffer_info->skb) {
2097                         dev_kfree_skb(buffer_info->skb);
2098                         buffer_info->skb = NULL;
2099                 }
2100         }
2101
2102         /* there also may be some cached data from a chained receive */
2103         if (rx_ring->rx_skb_top) {
2104                 dev_kfree_skb(rx_ring->rx_skb_top);
2105                 rx_ring->rx_skb_top = NULL;
2106         }
2107
2108         size = sizeof(struct e1000_buffer) * rx_ring->count;
2109         memset(rx_ring->buffer_info, 0, size);
2110
2111         /* Zero out the descriptor ring */
2112         memset(rx_ring->desc, 0, rx_ring->size);
2113
2114         rx_ring->next_to_clean = 0;
2115         rx_ring->next_to_use = 0;
2116
2117         writel(0, hw->hw_addr + rx_ring->rdh);
2118         writel(0, hw->hw_addr + rx_ring->rdt);
2119 }
2120
2121 /**
2122  * e1000_clean_all_rx_rings - Free Rx Buffers for all queues
2123  * @adapter: board private structure
2124  **/
2125
2126 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
2127 {
2128         int i;
2129
2130         for (i = 0; i < adapter->num_rx_queues; i++)
2131                 e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
2132 }
2133
2134 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
2135  * and memory write and invalidate disabled for certain operations
2136  */
2137 static void e1000_enter_82542_rst(struct e1000_adapter *adapter)
2138 {
2139         struct e1000_hw *hw = &adapter->hw;
2140         struct net_device *netdev = adapter->netdev;
2141         u32 rctl;
2142
2143         e1000_pci_clear_mwi(hw);
2144
2145         rctl = er32(RCTL);
2146         rctl |= E1000_RCTL_RST;
2147         ew32(RCTL, rctl);
2148         E1000_WRITE_FLUSH();
2149         mdelay(5);
2150
2151         if (netif_running(netdev))
2152                 e1000_clean_all_rx_rings(adapter);
2153 }
2154
2155 static void e1000_leave_82542_rst(struct e1000_adapter *adapter)
2156 {
2157         struct e1000_hw *hw = &adapter->hw;
2158         struct net_device *netdev = adapter->netdev;
2159         u32 rctl;
2160
2161         rctl = er32(RCTL);
2162         rctl &= ~E1000_RCTL_RST;
2163         ew32(RCTL, rctl);
2164         E1000_WRITE_FLUSH();
2165         mdelay(5);
2166
2167         if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
2168                 e1000_pci_set_mwi(hw);
2169
2170         if (netif_running(netdev)) {
2171                 /* No need to loop, because 82542 supports only 1 queue */
2172                 struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2173                 e1000_configure_rx(adapter);
2174                 adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
2175         }
2176 }
2177
2178 /**
2179  * e1000_set_mac - Change the Ethernet Address of the NIC
2180  * @netdev: network interface device structure
2181  * @p: pointer to an address structure
2182  *
2183  * Returns 0 on success, negative on failure
2184  **/
2185
2186 static int e1000_set_mac(struct net_device *netdev, void *p)
2187 {
2188         struct e1000_adapter *adapter = netdev_priv(netdev);
2189         struct e1000_hw *hw = &adapter->hw;
2190         struct sockaddr *addr = p;
2191
2192         if (!is_valid_ether_addr(addr->sa_data))
2193                 return -EADDRNOTAVAIL;
2194
2195         /* 82542 2.0 needs to be in reset to write receive address registers */
2196
2197         if (hw->mac_type == e1000_82542_rev2_0)
2198                 e1000_enter_82542_rst(adapter);
2199
2200         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
2201         memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
2202
2203         e1000_rar_set(hw, hw->mac_addr, 0);
2204
2205         if (hw->mac_type == e1000_82542_rev2_0)
2206                 e1000_leave_82542_rst(adapter);
2207
2208         return 0;
2209 }
2210
2211 /**
2212  * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
2213  * @netdev: network interface device structure
2214  *
2215  * The set_rx_mode entry point is called whenever the unicast or multicast
2216  * address lists or the network interface flags are updated. This routine is
2217  * responsible for configuring the hardware for proper unicast, multicast,
2218  * promiscuous mode, and all-multi behavior.
2219  **/
2220
2221 static void e1000_set_rx_mode(struct net_device *netdev)
2222 {
2223         struct e1000_adapter *adapter = netdev_priv(netdev);
2224         struct e1000_hw *hw = &adapter->hw;
2225         struct netdev_hw_addr *ha;
2226         bool use_uc = false;
2227         u32 rctl;
2228         u32 hash_value;
2229         int i, rar_entries = E1000_RAR_ENTRIES;
2230         int mta_reg_count = E1000_NUM_MTA_REGISTERS;
2231         u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);
2232
2233         if (!mcarray) {
2234                 e_err(probe, "memory allocation failed\n");
2235                 return;
2236         }
2237
2238         /* Check for Promiscuous and All Multicast modes */
2239
2240         rctl = er32(RCTL);
2241
2242         if (netdev->flags & IFF_PROMISC) {
2243                 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
2244                 rctl &= ~E1000_RCTL_VFE;
2245         } else {
2246                 if (netdev->flags & IFF_ALLMULTI)
2247                         rctl |= E1000_RCTL_MPE;
2248                 else
2249                         rctl &= ~E1000_RCTL_MPE;
2250                 /* Enable VLAN filter if there is a VLAN */
2251                 if (e1000_vlan_used(adapter))
2252                         rctl |= E1000_RCTL_VFE;
2253         }
2254
2255         if (netdev_uc_count(netdev) > rar_entries - 1) {
2256                 rctl |= E1000_RCTL_UPE;
2257         } else if (!(netdev->flags & IFF_PROMISC)) {
2258                 rctl &= ~E1000_RCTL_UPE;
2259                 use_uc = true;
2260         }
2261
2262         ew32(RCTL, rctl);
2263
2264         /* 82542 2.0 needs to be in reset to write receive address registers */
2265
2266         if (hw->mac_type == e1000_82542_rev2_0)
2267                 e1000_enter_82542_rst(adapter);
2268
2269         /* load the first 14 addresses into the exact filters 1-14. Unicast
2270          * addresses take precedence to avoid disabling unicast filtering
2271          * when possible.
2272          *
2273          * RAR 0 is used for the station MAC address
2274          * if there are not 14 addresses, go ahead and clear the filters
2275          */
2276         i = 1;
2277         if (use_uc)
2278                 netdev_for_each_uc_addr(ha, netdev) {
2279                         if (i == rar_entries)
2280                                 break;
2281                         e1000_rar_set(hw, ha->addr, i++);
2282                 }
2283
2284         netdev_for_each_mc_addr(ha, netdev) {
2285                 if (i == rar_entries) {
2286                         /* load any remaining addresses into the hash table */
2287                         u32 hash_reg, hash_bit, mta;
2288                         hash_value = e1000_hash_mc_addr(hw, ha->addr);
2289                         hash_reg = (hash_value >> 5) & 0x7F;
2290                         hash_bit = hash_value & 0x1F;
2291                         mta = (1 << hash_bit);
2292                         mcarray[hash_reg] |= mta;
2293                 } else {
2294                         e1000_rar_set(hw, ha->addr, i++);
2295                 }
2296         }
2297
2298         for (; i < rar_entries; i++) {
2299                 E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
2300                 E1000_WRITE_FLUSH();
2301                 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
2302                 E1000_WRITE_FLUSH();
2303         }
2304
2305         /* write the hash table completely, write from bottom to avoid
2306          * both stupid write combining chipsets, and flushing each write */
2307         for (i = mta_reg_count - 1; i >= 0 ; i--) {
2308                 /*
2309                  * If we are on an 82544 has an errata where writing odd
2310                  * offsets overwrites the previous even offset, but writing
2311                  * backwards over the range solves the issue by always
2312                  * writing the odd offset first
2313                  */
2314                 E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]);
2315         }
2316         E1000_WRITE_FLUSH();
2317
2318         if (hw->mac_type == e1000_82542_rev2_0)
2319                 e1000_leave_82542_rst(adapter);
2320
2321         kfree(mcarray);
2322 }
2323
2324 /**
2325  * e1000_update_phy_info_task - get phy info
2326  * @work: work struct contained inside adapter struct
2327  *
2328  * Need to wait a few seconds after link up to get diagnostic information from
2329  * the phy
2330  */
2331 static void e1000_update_phy_info_task(struct work_struct *work)
2332 {
2333         struct e1000_adapter *adapter = container_of(work,
2334                                                      struct e1000_adapter,
2335                                                      phy_info_task.work);
2336         if (test_bit(__E1000_DOWN, &adapter->flags))
2337                 return;
2338         mutex_lock(&adapter->mutex);
2339         e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
2340         mutex_unlock(&adapter->mutex);
2341 }
2342
2343 /**
2344  * e1000_82547_tx_fifo_stall_task - task to complete work
2345  * @work: work struct contained inside adapter struct
2346  **/
2347 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work)
2348 {
2349         struct e1000_adapter *adapter = container_of(work,
2350                                                      struct e1000_adapter,
2351                                                      fifo_stall_task.work);
2352         struct e1000_hw *hw = &adapter->hw;
2353         struct net_device *netdev = adapter->netdev;
2354         u32 tctl;
2355
2356         if (test_bit(__E1000_DOWN, &adapter->flags))
2357                 return;
2358         mutex_lock(&adapter->mutex);
2359         if (atomic_read(&adapter->tx_fifo_stall)) {
2360                 if ((er32(TDT) == er32(TDH)) &&
2361                    (er32(TDFT) == er32(TDFH)) &&
2362                    (er32(TDFTS) == er32(TDFHS))) {
2363                         tctl = er32(TCTL);
2364                         ew32(TCTL, tctl & ~E1000_TCTL_EN);
2365                         ew32(TDFT, adapter->tx_head_addr);
2366                         ew32(TDFH, adapter->tx_head_addr);
2367                         ew32(TDFTS, adapter->tx_head_addr);
2368                         ew32(TDFHS, adapter->tx_head_addr);
2369                         ew32(TCTL, tctl);
2370                         E1000_WRITE_FLUSH();
2371
2372                         adapter->tx_fifo_head = 0;
2373                         atomic_set(&adapter->tx_fifo_stall, 0);
2374                         netif_wake_queue(netdev);
2375                 } else if (!test_bit(__E1000_DOWN, &adapter->flags)) {
2376                         schedule_delayed_work(&adapter->fifo_stall_task, 1);
2377                 }
2378         }
2379         mutex_unlock(&adapter->mutex);
2380 }
2381
2382 bool e1000_has_link(struct e1000_adapter *adapter)
2383 {
2384         struct e1000_hw *hw = &adapter->hw;
2385         bool link_active = false;
2386
2387         /* get_link_status is set on LSC (link status) interrupt or rx
2388          * sequence error interrupt (except on intel ce4100).
2389          * get_link_status will stay false until the
2390          * e1000_check_for_link establishes link for copper adapters
2391          * ONLY
2392          */
2393         switch (hw->media_type) {
2394         case e1000_media_type_copper:
2395                 if (hw->mac_type == e1000_ce4100)
2396                         hw->get_link_status = 1;
2397                 if (hw->get_link_status) {
2398                         e1000_check_for_link(hw);
2399                         link_active = !hw->get_link_status;
2400                 } else {
2401                         link_active = true;
2402                 }
2403                 break;
2404         case e1000_media_type_fiber:
2405                 e1000_check_for_link(hw);
2406                 link_active = !!(er32(STATUS) & E1000_STATUS_LU);
2407                 break;
2408         case e1000_media_type_internal_serdes:
2409                 e1000_check_for_link(hw);
2410                 link_active = hw->serdes_has_link;
2411                 break;
2412         default:
2413                 break;
2414         }
2415
2416         return link_active;
2417 }
2418
2419 /**
2420  * e1000_watchdog - work function
2421  * @work: work struct contained inside adapter struct
2422  **/
2423 static void e1000_watchdog(struct work_struct *work)
2424 {
2425         struct e1000_adapter *adapter = container_of(work,
2426                                                      struct e1000_adapter,
2427                                                      watchdog_task.work);
2428         struct e1000_hw *hw = &adapter->hw;
2429         struct net_device *netdev = adapter->netdev;
2430         struct e1000_tx_ring *txdr = adapter->tx_ring;
2431         u32 link, tctl;
2432
2433         if (test_bit(__E1000_DOWN, &adapter->flags))
2434                 return;
2435
2436         mutex_lock(&adapter->mutex);
2437         link = e1000_has_link(adapter);
2438         if ((netif_carrier_ok(netdev)) && link)
2439                 goto link_up;
2440
2441         if (link) {
2442                 if (!netif_carrier_ok(netdev)) {
2443                         u32 ctrl;
2444                         bool txb2b = true;
2445                         /* update snapshot of PHY registers on LSC */
2446                         e1000_get_speed_and_duplex(hw,
2447                                                    &adapter->link_speed,
2448                                                    &adapter->link_duplex);
2449
2450                         ctrl = er32(CTRL);
2451                         pr_info("%s NIC Link is Up %d Mbps %s, "
2452                                 "Flow Control: %s\n",
2453                                 netdev->name,
2454                                 adapter->link_speed,
2455                                 adapter->link_duplex == FULL_DUPLEX ?
2456                                 "Full Duplex" : "Half Duplex",
2457                                 ((ctrl & E1000_CTRL_TFCE) && (ctrl &
2458                                 E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
2459                                 E1000_CTRL_RFCE) ? "RX" : ((ctrl &
2460                                 E1000_CTRL_TFCE) ? "TX" : "None")));
2461
2462                         /* adjust timeout factor according to speed/duplex */
2463                         adapter->tx_timeout_factor = 1;
2464                         switch (adapter->link_speed) {
2465                         case SPEED_10:
2466                                 txb2b = false;
2467                                 adapter->tx_timeout_factor = 16;
2468                                 break;
2469                         case SPEED_100:
2470                                 txb2b = false;
2471                                 /* maybe add some timeout factor ? */
2472                                 break;
2473                         }
2474
2475                         /* enable transmits in the hardware */
2476                         tctl = er32(TCTL);
2477                         tctl |= E1000_TCTL_EN;
2478                         ew32(TCTL, tctl);
2479
2480                         netif_carrier_on(netdev);
2481                         if (!test_bit(__E1000_DOWN, &adapter->flags))
2482                                 schedule_delayed_work(&adapter->phy_info_task,
2483                                                       2 * HZ);
2484                         adapter->smartspeed = 0;
2485                 }
2486         } else {
2487                 if (netif_carrier_ok(netdev)) {
2488                         adapter->link_speed = 0;
2489                         adapter->link_duplex = 0;
2490                         pr_info("%s NIC Link is Down\n",
2491                                 netdev->name);
2492                         netif_carrier_off(netdev);
2493
2494                         if (!test_bit(__E1000_DOWN, &adapter->flags))
2495                                 schedule_delayed_work(&adapter->phy_info_task,
2496                                                       2 * HZ);
2497                 }
2498
2499                 e1000_smartspeed(adapter);
2500         }
2501
2502 link_up:
2503         e1000_update_stats(adapter);
2504
2505         hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
2506         adapter->tpt_old = adapter->stats.tpt;
2507         hw->collision_delta = adapter->stats.colc - adapter->colc_old;
2508         adapter->colc_old = adapter->stats.colc;
2509
2510         adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
2511         adapter->gorcl_old = adapter->stats.gorcl;
2512         adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
2513         adapter->gotcl_old = adapter->stats.gotcl;
2514
2515         e1000_update_adaptive(hw);
2516
2517         if (!netif_carrier_ok(netdev)) {
2518                 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
2519                         /* We've lost link, so the controller stops DMA,
2520                          * but we've got queued Tx work that's never going
2521                          * to get done, so reset controller to flush Tx.
2522                          * (Do the reset outside of interrupt context). */
2523                         adapter->tx_timeout_count++;
2524                         schedule_work(&adapter->reset_task);
2525                         /* exit immediately since reset is imminent */
2526                         goto unlock;
2527                 }
2528         }
2529
2530         /* Simple mode for Interrupt Throttle Rate (ITR) */
2531         if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
2532                 /*
2533                  * Symmetric Tx/Rx gets a reduced ITR=2000;
2534                  * Total asymmetrical Tx or Rx gets ITR=8000;
2535                  * everyone else is between 2000-8000.
2536                  */
2537                 u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
2538                 u32 dif = (adapter->gotcl > adapter->gorcl ?
2539                             adapter->gotcl - adapter->gorcl :
2540                             adapter->gorcl - adapter->gotcl) / 10000;
2541                 u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
2542
2543                 ew32(ITR, 1000000000 / (itr * 256));
2544         }
2545
2546         /* Cause software interrupt to ensure rx ring is cleaned */
2547         ew32(ICS, E1000_ICS_RXDMT0);
2548
2549         /* Force detection of hung controller every watchdog period */
2550         adapter->detect_tx_hung = true;
2551
2552         /* Reschedule the task */
2553         if (!test_bit(__E1000_DOWN, &adapter->flags))
2554                 schedule_delayed_work(&adapter->watchdog_task, 2 * HZ);
2555
2556 unlock:
2557         mutex_unlock(&adapter->mutex);
2558 }
2559
2560 enum latency_range {
2561         lowest_latency = 0,
2562         low_latency = 1,
2563         bulk_latency = 2,
2564         latency_invalid = 255
2565 };
2566
2567 /**
2568  * e1000_update_itr - update the dynamic ITR value based on statistics
2569  * @adapter: pointer to adapter
2570  * @itr_setting: current adapter->itr
2571  * @packets: the number of packets during this measurement interval
2572  * @bytes: the number of bytes during this measurement interval
2573  *
2574  *      Stores a new ITR value based on packets and byte
2575  *      counts during the last interrupt.  The advantage of per interrupt
2576  *      computation is faster updates and more accurate ITR for the current
2577  *      traffic pattern.  Constants in this function were computed
2578  *      based on theoretical maximum wire speed and thresholds were set based
2579  *      on testing data as well as attempting to minimize response time
2580  *      while increasing bulk throughput.
2581  *      this functionality is controlled by the InterruptThrottleRate module
2582  *      parameter (see e1000_param.c)
2583  **/
2584 static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
2585                                      u16 itr_setting, int packets, int bytes)
2586 {
2587         unsigned int retval = itr_setting;
2588         struct e1000_hw *hw = &adapter->hw;
2589
2590         if (unlikely(hw->mac_type < e1000_82540))
2591                 goto update_itr_done;
2592
2593         if (packets == 0)
2594                 goto update_itr_done;
2595
2596         switch (itr_setting) {
2597         case lowest_latency:
2598                 /* jumbo frames get bulk treatment*/
2599                 if (bytes/packets > 8000)
2600                         retval = bulk_latency;
2601                 else if ((packets < 5) && (bytes > 512))
2602                         retval = low_latency;
2603                 break;
2604         case low_latency:  /* 50 usec aka 20000 ints/s */
2605                 if (bytes > 10000) {
2606                         /* jumbo frames need bulk latency setting */
2607                         if (bytes/packets > 8000)
2608                                 retval = bulk_latency;
2609                         else if ((packets < 10) || ((bytes/packets) > 1200))
2610                                 retval = bulk_latency;
2611                         else if ((packets > 35))
2612                                 retval = lowest_latency;
2613                 } else if (bytes/packets > 2000)
2614                         retval = bulk_latency;
2615                 else if (packets <= 2 && bytes < 512)
2616                         retval = lowest_latency;
2617                 break;
2618         case bulk_latency: /* 250 usec aka 4000 ints/s */
2619                 if (bytes > 25000) {
2620                         if (packets > 35)
2621                                 retval = low_latency;
2622                 } else if (bytes < 6000) {
2623                         retval = low_latency;
2624                 }
2625                 break;
2626         }
2627
2628 update_itr_done:
2629         return retval;
2630 }
2631
2632 static void e1000_set_itr(struct e1000_adapter *adapter)
2633 {
2634         struct e1000_hw *hw = &adapter->hw;
2635         u16 current_itr;
2636         u32 new_itr = adapter->itr;
2637
2638         if (unlikely(hw->mac_type < e1000_82540))
2639                 return;
2640
2641         /* for non-gigabit speeds, just fix the interrupt rate at 4000 */
2642         if (unlikely(adapter->link_speed != SPEED_1000)) {
2643                 current_itr = 0;
2644                 new_itr = 4000;
2645                 goto set_itr_now;
2646         }
2647
2648         adapter->tx_itr = e1000_update_itr(adapter,
2649                                     adapter->tx_itr,
2650                                     adapter->total_tx_packets,
2651                                     adapter->total_tx_bytes);
2652         /* conservative mode (itr 3) eliminates the lowest_latency setting */
2653         if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
2654                 adapter->tx_itr = low_latency;
2655
2656         adapter->rx_itr = e1000_update_itr(adapter,
2657                                     adapter->rx_itr,
2658                                     adapter->total_rx_packets,
2659                                     adapter->total_rx_bytes);
2660         /* conservative mode (itr 3) eliminates the lowest_latency setting */
2661         if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
2662                 adapter->rx_itr = low_latency;
2663
2664         current_itr = max(adapter->rx_itr, adapter->tx_itr);
2665
2666         switch (current_itr) {
2667         /* counts and packets in update_itr are dependent on these numbers */
2668         case lowest_latency:
2669                 new_itr = 70000;
2670                 break;
2671         case low_latency:
2672                 new_itr = 20000; /* aka hwitr = ~200 */
2673                 break;
2674         case bulk_latency:
2675                 new_itr = 4000;
2676                 break;
2677         default:
2678                 break;
2679         }
2680
2681 set_itr_now:
2682         if (new_itr != adapter->itr) {
2683                 /* this attempts to bias the interrupt rate towards Bulk
2684                  * by adding intermediate steps when interrupt rate is
2685                  * increasing */
2686                 new_itr = new_itr > adapter->itr ?
2687                              min(adapter->itr + (new_itr >> 2), new_itr) :
2688                              new_itr;
2689                 adapter->itr = new_itr;
2690                 ew32(ITR, 1000000000 / (new_itr * 256));
2691         }
2692 }
2693
2694 #define E1000_TX_FLAGS_CSUM             0x00000001
2695 #define E1000_TX_FLAGS_VLAN             0x00000002
2696 #define E1000_TX_FLAGS_TSO              0x00000004
2697 #define E1000_TX_FLAGS_IPV4             0x00000008
2698 #define E1000_TX_FLAGS_NO_FCS           0x00000010
2699 #define E1000_TX_FLAGS_VLAN_MASK        0xffff0000
2700 #define E1000_TX_FLAGS_VLAN_SHIFT       16
2701
2702 static int e1000_tso(struct e1000_adapter *adapter,
2703                      struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
2704 {
2705         struct e1000_context_desc *context_desc;
2706         struct e1000_buffer *buffer_info;
2707         unsigned int i;
2708         u32 cmd_length = 0;
2709         u16 ipcse = 0, tucse, mss;
2710         u8 ipcss, ipcso, tucss, tucso, hdr_len;
2711         int err;
2712
2713         if (skb_is_gso(skb)) {
2714                 if (skb_header_cloned(skb)) {
2715                         err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2716                         if (err)
2717                                 return err;
2718                 }
2719
2720                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
2721                 mss = skb_shinfo(skb)->gso_size;
2722                 if (skb->protocol == htons(ETH_P_IP)) {
2723                         struct iphdr *iph = ip_hdr(skb);
2724                         iph->tot_len = 0;
2725                         iph->check = 0;
2726                         tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
2727                                                                  iph->daddr, 0,
2728                                                                  IPPROTO_TCP,
2729                                                                  0);
2730                         cmd_length = E1000_TXD_CMD_IP;
2731                         ipcse = skb_transport_offset(skb) - 1;
2732                 } else if (skb->protocol == htons(ETH_P_IPV6)) {
2733                         ipv6_hdr(skb)->payload_len = 0;
2734                         tcp_hdr(skb)->check =
2735                                 ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
2736                                                  &ipv6_hdr(skb)->daddr,
2737                                                  0, IPPROTO_TCP, 0);
2738                         ipcse = 0;
2739                 }
2740                 ipcss = skb_network_offset(skb);
2741                 ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
2742                 tucss = skb_transport_offset(skb);
2743                 tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
2744                 tucse = 0;
2745
2746                 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
2747                                E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
2748
2749                 i = tx_ring->next_to_use;
2750                 context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
2751                 buffer_info = &tx_ring->buffer_info[i];
2752
2753                 context_desc->lower_setup.ip_fields.ipcss  = ipcss;
2754                 context_desc->lower_setup.ip_fields.ipcso  = ipcso;
2755                 context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
2756                 context_desc->upper_setup.tcp_fields.tucss = tucss;
2757                 context_desc->upper_setup.tcp_fields.tucso = tucso;
2758                 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
2759                 context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
2760                 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
2761                 context_desc->cmd_and_length = cpu_to_le32(cmd_length);
2762
2763                 buffer_info->time_stamp = jiffies;
2764                 buffer_info->next_to_watch = i;
2765
2766                 if (++i == tx_ring->count) i = 0;
2767                 tx_ring->next_to_use = i;
2768
2769                 return true;
2770         }
2771         return false;
2772 }
2773
2774 static bool e1000_tx_csum(struct e1000_adapter *adapter,
2775                           struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
2776 {
2777         struct e1000_context_desc *context_desc;
2778         struct e1000_buffer *buffer_info;
2779         unsigned int i;
2780         u8 css;
2781         u32 cmd_len = E1000_TXD_CMD_DEXT;
2782
2783         if (skb->ip_summed != CHECKSUM_PARTIAL)
2784                 return false;
2785
2786         switch (skb->protocol) {
2787         case cpu_to_be16(ETH_P_IP):
2788                 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
2789                         cmd_len |= E1000_TXD_CMD_TCP;
2790                 break;
2791         case cpu_to_be16(ETH_P_IPV6):
2792                 /* XXX not handling all IPV6 headers */
2793                 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
2794                         cmd_len |= E1000_TXD_CMD_TCP;
2795                 break;
2796         default:
2797                 if (unlikely(net_ratelimit()))
2798                         e_warn(drv, "checksum_partial proto=%x!\n",
2799                                skb->protocol);
2800                 break;
2801         }
2802
2803         css = skb_checksum_start_offset(skb);
2804
2805         i = tx_ring->next_to_use;
2806         buffer_info = &tx_ring->buffer_info[i];
2807         context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
2808
2809         context_desc->lower_setup.ip_config = 0;
2810         context_desc->upper_setup.tcp_fields.tucss = css;
2811         context_desc->upper_setup.tcp_fields.tucso =
2812                 css + skb->csum_offset;
2813         context_desc->upper_setup.tcp_fields.tucse = 0;
2814         context_desc->tcp_seg_setup.data = 0;
2815         context_desc->cmd_and_length = cpu_to_le32(cmd_len);
2816
2817         buffer_info->time_stamp = jiffies;
2818         buffer_info->next_to_watch = i;
2819
2820         if (unlikely(++i == tx_ring->count)) i = 0;
2821         tx_ring->next_to_use = i;
2822
2823         return true;
2824 }
2825
2826 #define E1000_MAX_TXD_PWR       12
2827 #define E1000_MAX_DATA_PER_TXD  (1<<E1000_MAX_TXD_PWR)
2828
2829 static int e1000_tx_map(struct e1000_adapter *adapter,
2830                         struct e1000_tx_ring *tx_ring,
2831                         struct sk_buff *skb, unsigned int first,
2832                         unsigned int max_per_txd, unsigned int nr_frags,
2833                         unsigned int mss)
2834 {
2835         struct e1000_hw *hw = &adapter->hw;
2836         struct pci_dev *pdev = adapter->pdev;
2837         struct e1000_buffer *buffer_info;
2838         unsigned int len = skb_headlen(skb);
2839         unsigned int offset = 0, size, count = 0, i;
2840         unsigned int f, bytecount, segs;
2841
2842         i = tx_ring->next_to_use;
2843
2844         while (len) {
2845                 buffer_info = &tx_ring->buffer_info[i];
2846                 size = min(len, max_per_txd);
2847                 /* Workaround for Controller erratum --
2848                  * descriptor for non-tso packet in a linear SKB that follows a
2849                  * tso gets written back prematurely before the data is fully
2850                  * DMA'd to the controller */
2851                 if (!skb->data_len && tx_ring->last_tx_tso &&
2852                     !skb_is_gso(skb)) {
2853                         tx_ring->last_tx_tso = false;
2854                         size -= 4;
2855                 }
2856
2857                 /* Workaround for premature desc write-backs
2858                  * in TSO mode.  Append 4-byte sentinel desc */
2859                 if (unlikely(mss && !nr_frags && size == len && size > 8))
2860                         size -= 4;
2861                 /* work-around for errata 10 and it applies
2862                  * to all controllers in PCI-X mode
2863                  * The fix is to make sure that the first descriptor of a
2864                  * packet is smaller than 2048 - 16 - 16 (or 2016) bytes
2865                  */
2866                 if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
2867                                 (size > 2015) && count == 0))
2868                         size = 2015;
2869
2870                 /* Workaround for potential 82544 hang in PCI-X.  Avoid
2871                  * terminating buffers within evenly-aligned dwords. */
2872                 if (unlikely(adapter->pcix_82544 &&
2873                    !((unsigned long)(skb->data + offset + size - 1) & 4) &&
2874                    size > 4))
2875                         size -= 4;
2876
2877                 buffer_info->length = size;
2878                 /* set time_stamp *before* dma to help avoid a possible race */
2879                 buffer_info->time_stamp = jiffies;
2880                 buffer_info->mapped_as_page = false;
2881                 buffer_info->dma = dma_map_single(&pdev->dev,
2882                                                   skb->data + offset,
2883                                                   size, DMA_TO_DEVICE);
2884                 if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2885                         goto dma_error;
2886                 buffer_info->next_to_watch = i;
2887
2888                 len -= size;
2889                 offset += size;
2890                 count++;
2891                 if (len) {
2892                         i++;
2893                         if (unlikely(i == tx_ring->count))
2894                                 i = 0;
2895                 }
2896         }
2897
2898         for (f = 0; f < nr_frags; f++) {
2899                 const struct skb_frag_struct *frag;
2900
2901                 frag = &skb_shinfo(skb)->frags[f];
2902                 len = skb_frag_size(frag);
2903                 offset = 0;
2904
2905                 while (len) {
2906                         unsigned long bufend;
2907                         i++;
2908                         if (unlikely(i == tx_ring->count))
2909                                 i = 0;
2910
2911                         buffer_info = &tx_ring->buffer_info[i];
2912                         size = min(len, max_per_txd);
2913                         /* Workaround for premature desc write-backs
2914                          * in TSO mode.  Append 4-byte sentinel desc */
2915                         if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
2916                                 size -= 4;
2917                         /* Workaround for potential 82544 hang in PCI-X.
2918                          * Avoid terminating buffers within evenly-aligned
2919                          * dwords. */
2920                         bufend = (unsigned long)
2921                                 page_to_phys(skb_frag_page(frag));
2922                         bufend += offset + size - 1;
2923                         if (unlikely(adapter->pcix_82544 &&
2924                                      !(bufend & 4) &&
2925                                      size > 4))
2926                                 size -= 4;
2927
2928                         buffer_info->length = size;
2929                         buffer_info->time_stamp = jiffies;
2930                         buffer_info->mapped_as_page = true;
2931                         buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
2932                                                 offset, size, DMA_TO_DEVICE);
2933                         if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2934                                 goto dma_error;
2935                         buffer_info->next_to_watch = i;
2936
2937                         len -= size;
2938                         offset += size;
2939                         count++;
2940                 }
2941         }
2942
2943         segs = skb_shinfo(skb)->gso_segs ?: 1;
2944         /* multiply data chunks by size of headers */
2945         bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len;
2946
2947         tx_ring->buffer_info[i].skb = skb;
2948         tx_ring->buffer_info[i].segs = segs;
2949         tx_ring->buffer_info[i].bytecount = bytecount;
2950         tx_ring->buffer_info[first].next_to_watch = i;
2951
2952         return count;
2953
2954 dma_error:
2955         dev_err(&pdev->dev, "TX DMA map failed\n");
2956         buffer_info->dma = 0;
2957         if (count)
2958                 count--;
2959
2960         while (count--) {
2961                 if (i==0)
2962                         i += tx_ring->count;
2963                 i--;
2964                 buffer_info = &tx_ring->buffer_info[i];
2965                 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
2966         }
2967
2968         return 0;
2969 }
2970
2971 static void e1000_tx_queue(struct e1000_adapter *adapter,
2972                            struct e1000_tx_ring *tx_ring, int tx_flags,
2973                            int count)
2974 {
2975         struct e1000_hw *hw = &adapter->hw;
2976         struct e1000_tx_desc *tx_desc = NULL;
2977         struct e1000_buffer *buffer_info;
2978         u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
2979         unsigned int i;
2980
2981         if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
2982                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
2983                              E1000_TXD_CMD_TSE;
2984                 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2985
2986                 if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2987                         txd_upper |= E1000_TXD_POPTS_IXSM << 8;
2988         }
2989
2990         if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
2991                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2992                 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2993         }
2994
2995         if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
2996                 txd_lower |= E1000_TXD_CMD_VLE;
2997                 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
2998         }
2999
3000         if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
3001                 txd_lower &= ~(E1000_TXD_CMD_IFCS);
3002
3003         i = tx_ring->next_to_use;
3004
3005         while (count--) {
3006                 buffer_info = &tx_ring->buffer_info[i];
3007                 tx_desc = E1000_TX_DESC(*tx_ring, i);
3008                 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
3009                 tx_desc->lower.data =
3010                         cpu_to_le32(txd_lower | buffer_info->length);
3011                 tx_desc->upper.data = cpu_to_le32(txd_upper);
3012                 if (unlikely(++i == tx_ring->count)) i = 0;
3013         }
3014
3015         tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
3016
3017         /* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */
3018         if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
3019                 tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS));
3020
3021         /* Force memory writes to complete before letting h/w
3022          * know there are new descriptors to fetch.  (Only
3023          * applicable for weak-ordered memory model archs,
3024          * such as IA-64). */
3025         wmb();
3026
3027         tx_ring->next_to_use = i;
3028         writel(i, hw->hw_addr + tx_ring->tdt);
3029         /* we need this if more than one processor can write to our tail
3030          * at a time, it syncronizes IO on IA64/Altix systems */
3031         mmiowb();
3032 }
3033
3034 /**
3035  * 82547 workaround to avoid controller hang in half-duplex environment.
3036  * The workaround is to avoid queuing a large packet that would span
3037  * the internal Tx FIFO ring boundary by notifying the stack to resend
3038  * the packet at a later time.  This gives the Tx FIFO an opportunity to
3039  * flush all packets.  When that occurs, we reset the Tx FIFO pointers
3040  * to the beginning of the Tx FIFO.
3041  **/
3042
3043 #define E1000_FIFO_HDR                  0x10
3044 #define E1000_82547_PAD_LEN             0x3E0
3045
3046 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
3047                                        struct sk_buff *skb)
3048 {
3049         u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
3050         u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
3051
3052         skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
3053
3054         if (adapter->link_duplex != HALF_DUPLEX)
3055                 goto no_fifo_stall_required;
3056
3057         if (atomic_read(&adapter->tx_fifo_stall))
3058                 return 1;
3059
3060         if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
3061                 atomic_set(&adapter->tx_fifo_stall, 1);
3062                 return 1;
3063         }
3064
3065 no_fifo_stall_required:
3066         adapter->tx_fifo_head += skb_fifo_len;
3067         if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
3068                 adapter->tx_fifo_head -= adapter->tx_fifo_size;
3069         return 0;
3070 }
3071
3072 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
3073 {
3074         struct e1000_adapter *adapter = netdev_priv(netdev);
3075         struct e1000_tx_ring *tx_ring = adapter->tx_ring;
3076
3077         netif_stop_queue(netdev);
3078         /* Herbert's original patch had:
3079          *  smp_mb__after_netif_stop_queue();
3080          * but since that doesn't exist yet, just open code it. */
3081         smp_mb();
3082
3083         /* We need to check again in a case another CPU has just
3084          * made room available. */
3085         if (likely(E1000_DESC_UNUSED(tx_ring) < size))
3086                 return -EBUSY;
3087
3088         /* A reprieve! */
3089         netif_start_queue(netdev);
3090         ++adapter->restart_queue;
3091         return 0;
3092 }
3093
3094 static int e1000_maybe_stop_tx(struct net_device *netdev,
3095                                struct e1000_tx_ring *tx_ring, int size)
3096 {
3097         if (likely(E1000_DESC_UNUSED(tx_ring) >= size))
3098                 return 0;
3099         return __e1000_maybe_stop_tx(netdev, size);
3100 }
3101
3102 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
3103 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
3104                                     struct net_device *netdev)
3105 {
3106         struct e1000_adapter *adapter = netdev_priv(netdev);
3107         struct e1000_hw *hw = &adapter->hw;
3108         struct e1000_tx_ring *tx_ring;
3109         unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
3110         unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
3111         unsigned int tx_flags = 0;
3112         unsigned int len = skb_headlen(skb);
3113         unsigned int nr_frags;
3114         unsigned int mss;
3115         int count = 0;
3116         int tso;
3117         unsigned int f;
3118
3119         /* This goes back to the question of how to logically map a tx queue
3120          * to a flow.  Right now, performance is impacted slightly negatively
3121          * if using multiple tx queues.  If the stack breaks away from a
3122          * single qdisc implementation, we can look at this again. */
3123         tx_ring = adapter->tx_ring;
3124
3125         if (unlikely(skb->len <= 0)) {
3126                 dev_kfree_skb_any(skb);
3127                 return NETDEV_TX_OK;
3128         }
3129
3130         mss = skb_shinfo(skb)->gso_size;
3131         /* The controller does a simple calculation to
3132          * make sure there is enough room in the FIFO before
3133          * initiating the DMA for each buffer.  The calc is:
3134          * 4 = ceil(buffer len/mss).  To make sure we don't
3135          * overrun the FIFO, adjust the max buffer len if mss
3136          * drops. */
3137         if (mss) {
3138                 u8 hdr_len;
3139                 max_per_txd = min(mss << 2, max_per_txd);
3140                 max_txd_pwr = fls(max_per_txd) - 1;
3141
3142                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
3143                 if (skb->data_len && hdr_len == len) {
3144                         switch (hw->mac_type) {
3145                                 unsigned int pull_size;
3146                         case e1000_82544:
3147                                 /* Make sure we have room to chop off 4 bytes,
3148                                  * and that the end alignment will work out to
3149                                  * this hardware's requirements
3150                                  * NOTE: this is a TSO only workaround
3151                                  * if end byte alignment not correct move us
3152                                  * into the next dword */
3153                                 if ((unsigned long)(skb_tail_pointer(skb) - 1) & 4)
3154                                         break;
3155                                 /* fall through */
3156                                 pull_size = min((unsigned int)4, skb->data_len);
3157                                 if (!__pskb_pull_tail(skb, pull_size)) {
3158                                         e_err(drv, "__pskb_pull_tail "
3159                                               "failed.\n");
3160                                         dev_kfree_skb_any(skb);
3161                                         return NETDEV_TX_OK;
3162                                 }
3163                                 len = skb_headlen(skb);
3164                                 break;
3165                         default:
3166                                 /* do nothing */
3167                                 break;
3168                         }
3169                 }
3170         }
3171
3172         /* reserve a descriptor for the offload context */
3173         if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
3174                 count++;
3175         count++;
3176
3177         /* Controller Erratum workaround */
3178         if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb))
3179                 count++;
3180
3181         count += TXD_USE_COUNT(len, max_txd_pwr);
3182
3183         if (adapter->pcix_82544)
3184                 count++;
3185
3186         /* work-around for errata 10 and it applies to all controllers
3187          * in PCI-X mode, so add one more descriptor to the count
3188          */
3189         if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
3190                         (len > 2015)))
3191                 count++;
3192
3193         nr_frags = skb_shinfo(skb)->nr_frags;
3194         for (f = 0; f < nr_frags; f++)
3195                 count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]),
3196                                        max_txd_pwr);
3197         if (adapter->pcix_82544)
3198                 count += nr_frags;
3199
3200         /* need: count + 2 desc gap to keep tail from touching
3201          * head, otherwise try next time */
3202         if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
3203                 return NETDEV_TX_BUSY;
3204
3205         if (unlikely((hw->mac_type == e1000_82547) &&
3206                      (e1000_82547_fifo_workaround(adapter, skb)))) {
3207                 netif_stop_queue(netdev);
3208                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3209                         schedule_delayed_work(&adapter->fifo_stall_task, 1);
3210                 return NETDEV_TX_BUSY;
3211         }
3212
3213         if (vlan_tx_tag_present(skb)) {
3214                 tx_flags |= E1000_TX_FLAGS_VLAN;
3215                 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
3216         }
3217
3218         first = tx_ring->next_to_use;
3219
3220         tso = e1000_tso(adapter, tx_ring, skb);
3221         if (tso < 0) {
3222                 dev_kfree_skb_any(skb);
3223                 return NETDEV_TX_OK;
3224         }
3225
3226         if (likely(tso)) {
3227                 if (likely(hw->mac_type != e1000_82544))
3228                         tx_ring->last_tx_tso = true;
3229                 tx_flags |= E1000_TX_FLAGS_TSO;
3230         } else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
3231                 tx_flags |= E1000_TX_FLAGS_CSUM;
3232
3233         if (likely(skb->protocol == htons(ETH_P_IP)))
3234                 tx_flags |= E1000_TX_FLAGS_IPV4;
3235
3236         if (unlikely(skb->no_fcs))
3237                 tx_flags |= E1000_TX_FLAGS_NO_FCS;
3238
3239         count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd,
3240                              nr_frags, mss);
3241
3242         if (count) {
3243                 e1000_tx_queue(adapter, tx_ring, tx_flags, count);
3244                 /* Make sure there is space in the ring for the next send. */
3245                 e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
3246
3247         } else {
3248                 dev_kfree_skb_any(skb);
3249                 tx_ring->buffer_info[first].time_stamp = 0;
3250                 tx_ring->next_to_use = first;
3251         }
3252
3253         return NETDEV_TX_OK;
3254 }
3255
3256 #define NUM_REGS 38 /* 1 based count */
3257 static void e1000_regdump(struct e1000_adapter *adapter)
3258 {
3259         struct e1000_hw *hw = &adapter->hw;
3260         u32 regs[NUM_REGS];
3261         u32 *regs_buff = regs;
3262         int i = 0;
3263
3264         static const char * const reg_name[] = {
3265                 "CTRL",  "STATUS",
3266                 "RCTL", "RDLEN", "RDH", "RDT", "RDTR",
3267                 "TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT",
3268                 "TIDV", "TXDCTL", "TADV", "TARC0",
3269                 "TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1",
3270                 "TXDCTL1", "TARC1",
3271                 "CTRL_EXT", "ERT", "RDBAL", "RDBAH",
3272                 "TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC",
3273                 "RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC"
3274         };
3275
3276         regs_buff[0]  = er32(CTRL);
3277         regs_buff[1]  = er32(STATUS);
3278
3279         regs_buff[2]  = er32(RCTL);
3280         regs_buff[3]  = er32(RDLEN);
3281         regs_buff[4]  = er32(RDH);
3282         regs_buff[5]  = er32(RDT);
3283         regs_buff[6]  = er32(RDTR);
3284
3285         regs_buff[7]  = er32(TCTL);
3286         regs_buff[8]  = er32(TDBAL);
3287         regs_buff[9]  = er32(TDBAH);
3288         regs_buff[10] = er32(TDLEN);
3289         regs_buff[11] = er32(TDH);
3290         regs_buff[12] = er32(TDT);
3291         regs_buff[13] = er32(TIDV);
3292         regs_buff[14] = er32(TXDCTL);
3293         regs_buff[15] = er32(TADV);
3294         regs_buff[16] = er32(TARC0);
3295
3296         regs_buff[17] = er32(TDBAL1);
3297         regs_buff[18] = er32(TDBAH1);
3298         regs_buff[19] = er32(TDLEN1);
3299         regs_buff[20] = er32(TDH1);
3300         regs_buff[21] = er32(TDT1);
3301         regs_buff[22] = er32(TXDCTL1);
3302         regs_buff[23] = er32(TARC1);
3303         regs_buff[24] = er32(CTRL_EXT);
3304         regs_buff[25] = er32(ERT);
3305         regs_buff[26] = er32(RDBAL0);
3306         regs_buff[27] = er32(RDBAH0);
3307         regs_buff[28] = er32(TDFH);
3308         regs_buff[29] = er32(TDFT);
3309         regs_buff[30] = er32(TDFHS);
3310         regs_buff[31] = er32(TDFTS);
3311         regs_buff[32] = er32(TDFPC);
3312         regs_buff[33] = er32(RDFH);
3313         regs_buff[34] = er32(RDFT);
3314         regs_buff[35] = er32(RDFHS);
3315         regs_buff[36] = er32(RDFTS);
3316         regs_buff[37] = er32(RDFPC);
3317
3318         pr_info("Register dump\n");
3319         for (i = 0; i < NUM_REGS; i++)
3320                 pr_info("%-15s  %08x\n", reg_name[i], regs_buff[i]);
3321 }
3322
3323 /*
3324  * e1000_dump: Print registers, tx ring and rx ring
3325  */
3326 static void e1000_dump(struct e1000_adapter *adapter)
3327 {
3328         /* this code doesn't handle multiple rings */
3329         struct e1000_tx_ring *tx_ring = adapter->tx_ring;
3330         struct e1000_rx_ring *rx_ring = adapter->rx_ring;
3331         int i;
3332
3333         if (!netif_msg_hw(adapter))
3334                 return;
3335
3336         /* Print Registers */
3337         e1000_regdump(adapter);
3338
3339         /*
3340          * transmit dump
3341          */
3342         pr_info("TX Desc ring0 dump\n");
3343
3344         /* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)
3345          *
3346          * Legacy Transmit Descriptor
3347          *   +--------------------------------------------------------------+
3348          * 0 |         Buffer Address [63:0] (Reserved on Write Back)       |
3349          *   +--------------------------------------------------------------+
3350          * 8 | Special  |    CSS     | Status |  CMD    |  CSO   |  Length  |
3351          *   +--------------------------------------------------------------+
3352          *   63       48 47        36 35    32 31     24 23    16 15        0
3353          *
3354          * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload
3355          *   63      48 47    40 39       32 31             16 15    8 7      0
3356          *   +----------------------------------------------------------------+
3357          * 0 |  TUCSE  | TUCS0  |   TUCSS   |     IPCSE       | IPCS0 | IPCSS |
3358          *   +----------------------------------------------------------------+
3359          * 8 |   MSS   | HDRLEN | RSV | STA | TUCMD | DTYP |      PAYLEN      |
3360          *   +----------------------------------------------------------------+
3361          *   63      48 47    40 39 36 35 32 31   24 23  20 19                0
3362          *
3363          * Extended Data Descriptor (DTYP=0x1)
3364          *   +----------------------------------------------------------------+
3365          * 0 |                     Buffer Address [63:0]                      |
3366          *   +----------------------------------------------------------------+
3367          * 8 | VLAN tag |  POPTS  | Rsvd | Status | Command | DTYP |  DTALEN  |
3368          *   +----------------------------------------------------------------+
3369          *   63       48 47     40 39  36 35    32 31     24 23  20 19        0
3370          */
3371         pr_info("Tc[desc]     [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
3372         pr_info("Td[desc]     [address 63:0  ] [VlaPoRSCm1Dlen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
3373
3374         if (!netif_msg_tx_done(adapter))
3375                 goto rx_ring_summary;
3376
3377         for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {
3378                 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
3379                 struct e1000_buffer *buffer_info = &tx_ring->buffer_info[i];
3380                 struct my_u { u64 a; u64 b; };
3381                 struct my_u *u = (struct my_u *)tx_desc;
3382                 const char *type;
3383
3384                 if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)
3385                         type = "NTC/U";
3386                 else if (i == tx_ring->next_to_use)
3387                         type = "NTU";
3388                 else if (i == tx_ring->next_to_clean)
3389                         type = "NTC";
3390                 else
3391                         type = "";
3392
3393                 pr_info("T%c[0x%03X]    %016llX %016llX %016llX %04X  %3X %016llX %p %s\n",
3394                         ((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i,
3395                         le64_to_cpu(u->a), le64_to_cpu(u->b),
3396                         (u64)buffer_info->dma, buffer_info->length,
3397                         buffer_info->next_to_watch,
3398                         (u64)buffer_info->time_stamp, buffer_info->skb, type);
3399         }
3400
3401 rx_ring_summary:
3402         /*
3403          * receive dump
3404          */
3405         pr_info("\nRX Desc ring dump\n");
3406
3407         /* Legacy Receive Descriptor Format
3408          *
3409          * +-----------------------------------------------------+
3410          * |                Buffer Address [63:0]                |
3411          * +-----------------------------------------------------+
3412          * | VLAN Tag | Errors | Status 0 | Packet csum | Length |
3413          * +-----------------------------------------------------+
3414          * 63       48 47    40 39      32 31         16 15      0
3415          */
3416         pr_info("R[desc]      [address 63:0  ] [vl er S cks ln] [bi->dma       ] [bi->skb]\n");
3417
3418         if (!netif_msg_rx_status(adapter))
3419                 goto exit;
3420
3421         for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) {
3422                 struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i);
3423                 struct e1000_buffer *buffer_info = &rx_ring->buffer_info[i];
3424                 struct my_u { u64 a; u64 b; };
3425                 struct my_u *u = (struct my_u *)rx_desc;
3426                 const char *type;
3427
3428                 if (i == rx_ring->next_to_use)
3429                         type = "NTU";
3430                 else if (i == rx_ring->next_to_clean)
3431                         type = "NTC";
3432                 else
3433                         type = "";
3434
3435                 pr_info("R[0x%03X]     %016llX %016llX %016llX %p %s\n",
3436                         i, le64_to_cpu(u->a), le64_to_cpu(u->b),
3437                         (u64)buffer_info->dma, buffer_info->skb, type);
3438         } /* for */
3439
3440         /* dump the descriptor caches */
3441         /* rx */
3442         pr_info("Rx descriptor cache in 64bit format\n");
3443         for (i = 0x6000; i <= 0x63FF ; i += 0x10) {
3444                 pr_info("R%04X: %08X|%08X %08X|%08X\n",
3445                         i,
3446                         readl(adapter->hw.hw_addr + i+4),
3447                         readl(adapter->hw.hw_addr + i),
3448                         readl(adapter->hw.hw_addr + i+12),
3449                         readl(adapter->hw.hw_addr + i+8));
3450         }
3451         /* tx */
3452         pr_info("Tx descriptor cache in 64bit format\n");
3453         for (i = 0x7000; i <= 0x73FF ; i += 0x10) {
3454                 pr_info("T%04X: %08X|%08X %08X|%08X\n",
3455                         i,
3456                         readl(adapter->hw.hw_addr + i+4),
3457                         readl(adapter->hw.hw_addr + i),
3458                         readl(adapter->hw.hw_addr + i+12),
3459                         readl(adapter->hw.hw_addr + i+8));
3460         }
3461 exit:
3462         return;
3463 }
3464
3465 /**
3466  * e1000_tx_timeout - Respond to a Tx Hang
3467  * @netdev: network interface device structure
3468  **/
3469
3470 static void e1000_tx_timeout(struct net_device *netdev)
3471 {
3472         struct e1000_adapter *adapter = netdev_priv(netdev);
3473
3474         /* Do the reset outside of interrupt context */
3475         adapter->tx_timeout_count++;
3476         schedule_work(&adapter->reset_task);
3477 }
3478
3479 static void e1000_reset_task(struct work_struct *work)
3480 {
3481         struct e1000_adapter *adapter =
3482                 container_of(work, struct e1000_adapter, reset_task);
3483
3484         if (test_bit(__E1000_DOWN, &adapter->flags))
3485                 return;
3486         e_err(drv, "Reset adapter\n");
3487         e1000_reinit_safe(adapter);
3488 }
3489
3490 /**
3491  * e1000_get_stats - Get System Network Statistics
3492  * @netdev: network interface device structure
3493  *
3494  * Returns the address of the device statistics structure.
3495  * The statistics are actually updated from the watchdog.
3496  **/
3497
3498 static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
3499 {
3500         /* only return the current stats */
3501         return &netdev->stats;
3502 }
3503
3504 /**
3505  * e1000_change_mtu - Change the Maximum Transfer Unit
3506  * @netdev: network interface device structure
3507  * @new_mtu: new value for maximum frame size
3508  *
3509  * Returns 0 on success, negative on failure
3510  **/
3511
3512 static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
3513 {
3514         struct e1000_adapter *adapter = netdev_priv(netdev);
3515         struct e1000_hw *hw = &adapter->hw;
3516         int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
3517
3518         if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
3519             (max_frame > MAX_JUMBO_FRAME_SIZE)) {
3520                 e_err(probe, "Invalid MTU setting\n");
3521                 return -EINVAL;
3522         }
3523
3524         /* Adapter-specific max frame size limits. */
3525         switch (hw->mac_type) {
3526         case e1000_undefined ... e1000_82542_rev2_1:
3527                 if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
3528                         e_err(probe, "Jumbo Frames not supported.\n");
3529                         return -EINVAL;
3530                 }
3531                 break;
3532         default:
3533                 /* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
3534                 break;
3535         }
3536
3537         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
3538                 msleep(1);
3539         /* e1000_down has a dependency on max_frame_size */
3540         hw->max_frame_size = max_frame;
3541         if (netif_running(netdev))
3542                 e1000_down(adapter);
3543
3544         /* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
3545          * means we reserve 2 more, this pushes us to allocate from the next
3546          * larger slab size.
3547          * i.e. RXBUFFER_2048 --> size-4096 slab
3548          *  however with the new *_jumbo_rx* routines, jumbo receives will use
3549          *  fragmented skbs */
3550
3551         if (max_frame <= E1000_RXBUFFER_2048)
3552                 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
3553         else
3554 #if (PAGE_SIZE >= E1000_RXBUFFER_16384)
3555                 adapter->rx_buffer_len = E1000_RXBUFFER_16384;
3556 #elif (PAGE_SIZE >= E1000_RXBUFFER_4096)
3557                 adapter->rx_buffer_len = PAGE_SIZE;
3558 #endif
3559
3560         /* adjust allocation if LPE protects us, and we aren't using SBP */
3561         if (!hw->tbi_compatibility_on &&
3562             ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) ||
3563              (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
3564                 adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
3565
3566         pr_info("%s changing MTU from %d to %d\n",
3567                 netdev->name, netdev->mtu, new_mtu);
3568         netdev->mtu = new_mtu;
3569
3570         if (netif_running(netdev))
3571                 e1000_up(adapter);
3572         else
3573                 e1000_reset(adapter);
3574
3575         clear_bit(__E1000_RESETTING, &adapter->flags);
3576
3577         return 0;
3578 }
3579
3580 /**
3581  * e1000_update_stats - Update the board statistics counters
3582  * @adapter: board private structure
3583  **/
3584
3585 void e1000_update_stats(struct e1000_adapter *adapter)
3586 {
3587         struct net_device *netdev = adapter->netdev;
3588         struct e1000_hw *hw = &adapter->hw;
3589         struct pci_dev *pdev = adapter->pdev;
3590         unsigned long flags;
3591         u16 phy_tmp;
3592
3593 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
3594
3595         /*
3596          * Prevent stats update while adapter is being reset, or if the pci
3597          * connection is down.
3598          */
3599         if (adapter->link_speed == 0)
3600                 return;
3601         if (pci_channel_offline(pdev))
3602                 return;
3603
3604         spin_lock_irqsave(&adapter->stats_lock, flags);
3605
3606         /* these counters are modified from e1000_tbi_adjust_stats,
3607          * called from the interrupt context, so they must only
3608          * be written while holding adapter->stats_lock
3609          */
3610
3611         adapter->stats.crcerrs += er32(CRCERRS);
3612         adapter->stats.gprc += er32(GPRC);
3613         adapter->stats.gorcl += er32(GORCL);
3614         adapter->stats.gorch += er32(GORCH);
3615         adapter->stats.bprc += er32(BPRC);
3616         adapter->stats.mprc += er32(MPRC);
3617         adapter->stats.roc += er32(ROC);
3618
3619         adapter->stats.prc64 += er32(PRC64);
3620         adapter->stats.prc127 += er32(PRC127);
3621         adapter->stats.prc255 += er32(PRC255);
3622         adapter->stats.prc511 += er32(PRC511);
3623         adapter->stats.prc1023 += er32(PRC1023);
3624         adapter->stats.prc1522 += er32(PRC1522);
3625
3626         adapter->stats.symerrs += er32(SYMERRS);
3627         adapter->stats.mpc += er32(MPC);
3628         adapter->stats.scc += er32(SCC);
3629         adapter->stats.ecol += er32(ECOL);
3630         adapter->stats.mcc += er32(MCC);
3631         adapter->stats.latecol += er32(LATECOL);
3632         adapter->stats.dc += er32(DC);
3633         adapter->stats.sec += er32(SEC);
3634         adapter->stats.rlec += er32(RLEC);
3635         adapter->stats.xonrxc += er32(XONRXC);
3636         adapter->stats.xontxc += er32(XONTXC);
3637         adapter->stats.xoffrxc += er32(XOFFRXC);
3638         adapter->stats.xofftxc += er32(XOFFTXC);
3639         adapter->stats.fcruc += er32(FCRUC);
3640         adapter->stats.gptc += er32(GPTC);
3641         adapter->stats.gotcl += er32(GOTCL);
3642         adapter->stats.gotch += er32(GOTCH);
3643         adapter->stats.rnbc += er32(RNBC);
3644         adapter->stats.ruc += er32(RUC);
3645         adapter->stats.rfc += er32(RFC);
3646         adapter->stats.rjc += er32(RJC);
3647         adapter->stats.torl += er32(TORL);
3648         adapter->stats.torh += er32(TORH);
3649         adapter->stats.totl += er32(TOTL);
3650         adapter->stats.toth += er32(TOTH);
3651         adapter->stats.tpr += er32(TPR);
3652
3653         adapter->stats.ptc64 += er32(PTC64);
3654         adapter->stats.ptc127 += er32(PTC127);
3655         adapter->stats.ptc255 += er32(PTC255);
3656         adapter->stats.ptc511 += er32(PTC511);
3657         adapter->stats.ptc1023 += er32(PTC1023);
3658         adapter->stats.ptc1522 += er32(PTC1522);
3659
3660         adapter->stats.mptc += er32(MPTC);
3661         adapter->stats.bptc += er32(BPTC);
3662
3663         /* used for adaptive IFS */
3664
3665         hw->tx_packet_delta = er32(TPT);
3666         adapter->stats.tpt += hw->tx_packet_delta;
3667         hw->collision_delta = er32(COLC);
3668         adapter->stats.colc += hw->collision_delta;
3669
3670         if (hw->mac_type >= e1000_82543) {
3671                 adapter->stats.algnerrc += er32(ALGNERRC);
3672                 adapter->stats.rxerrc += er32(RXERRC);
3673                 adapter->stats.tncrs += er32(TNCRS);
3674                 adapter->stats.cexterr += er32(CEXTERR);
3675                 adapter->stats.tsctc += er32(TSCTC);
3676                 adapter->stats.tsctfc += er32(TSCTFC);
3677         }
3678
3679         /* Fill out the OS statistics structure */
3680         netdev->stats.multicast = adapter->stats.mprc;
3681         netdev->stats.collisions = adapter->stats.colc;
3682
3683         /* Rx Errors */
3684
3685         /* RLEC on some newer hardware can be incorrect so build
3686         * our own version based on RUC and ROC */
3687         netdev->stats.rx_errors = adapter->stats.rxerrc +
3688                 adapter->stats.crcerrs + adapter->stats.algnerrc +
3689                 adapter->stats.ruc + adapter->stats.roc +
3690                 adapter->stats.cexterr;
3691         adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
3692         netdev->stats.rx_length_errors = adapter->stats.rlerrc;
3693         netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
3694         netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
3695         netdev->stats.rx_missed_errors = adapter->stats.mpc;
3696
3697         /* Tx Errors */
3698         adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
3699         netdev->stats.tx_errors = adapter->stats.txerrc;
3700         netdev->stats.tx_aborted_errors = adapter->stats.ecol;
3701         netdev->stats.tx_window_errors = adapter->stats.latecol;
3702         netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
3703         if (hw->bad_tx_carr_stats_fd &&
3704             adapter->link_duplex == FULL_DUPLEX) {
3705                 netdev->stats.tx_carrier_errors = 0;
3706                 adapter->stats.tncrs = 0;
3707         }
3708
3709         /* Tx Dropped needs to be maintained elsewhere */
3710
3711         /* Phy Stats */
3712         if (hw->media_type == e1000_media_type_copper) {
3713                 if ((adapter->link_speed == SPEED_1000) &&
3714                    (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
3715                         phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
3716                         adapter->phy_stats.idle_errors += phy_tmp;
3717                 }
3718
3719                 if ((hw->mac_type <= e1000_82546) &&
3720                    (hw->phy_type == e1000_phy_m88) &&
3721                    !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
3722                         adapter->phy_stats.receive_errors += phy_tmp;
3723         }
3724
3725         /* Management Stats */
3726         if (hw->has_smbus) {
3727                 adapter->stats.mgptc += er32(MGTPTC);
3728                 adapter->stats.mgprc += er32(MGTPRC);
3729                 adapter->stats.mgpdc += er32(MGTPDC);
3730         }
3731
3732         spin_unlock_irqrestore(&adapter->stats_lock, flags);
3733 }
3734
3735 /**
3736  * e1000_intr - Interrupt Handler
3737  * @irq: interrupt number
3738  * @data: pointer to a network interface device structure
3739  **/
3740
3741 static irqreturn_t e1000_intr(int irq, void *data)
3742 {
3743         struct net_device *netdev = data;
3744         struct e1000_adapter *adapter = netdev_priv(netdev);
3745         struct e1000_hw *hw = &adapter->hw;
3746         u32 icr = er32(ICR);
3747
3748         if (unlikely((!icr)))
3749                 return IRQ_NONE;  /* Not our interrupt */
3750
3751         /*
3752          * we might have caused the interrupt, but the above
3753          * read cleared it, and just in case the driver is
3754          * down there is nothing to do so return handled
3755          */
3756         if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
3757                 return IRQ_HANDLED;
3758
3759         if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
3760                 hw->get_link_status = 1;
3761                 /* guard against interrupt when we're going down */
3762                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3763                         schedule_delayed_work(&adapter->watchdog_task, 1);
3764         }
3765
3766         /* disable interrupts, without the synchronize_irq bit */
3767         ew32(IMC, ~0);
3768         E1000_WRITE_FLUSH();
3769
3770         if (likely(napi_schedule_prep(&adapter->napi))) {
3771                 adapter->total_tx_bytes = 0;
3772                 adapter->total_tx_packets = 0;
3773                 adapter->total_rx_bytes = 0;
3774                 adapter->total_rx_packets = 0;
3775                 __napi_schedule(&adapter->napi);
3776         } else {
3777                 /* this really should not happen! if it does it is basically a
3778                  * bug, but not a hard error, so enable ints and continue */
3779                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3780                         e1000_irq_enable(adapter);
3781         }
3782
3783         return IRQ_HANDLED;
3784 }
3785
3786 /**
3787  * e1000_clean - NAPI Rx polling callback
3788  * @adapter: board private structure
3789  **/
3790 static int e1000_clean(struct napi_struct *napi, int budget)
3791 {
3792         struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, napi);
3793         int tx_clean_complete = 0, work_done = 0;
3794
3795         tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
3796
3797         adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
3798
3799         if (!tx_clean_complete)
3800                 work_done = budget;
3801
3802         /* If budget not fully consumed, exit the polling mode */
3803         if (work_done < budget) {
3804                 if (likely(adapter->itr_setting & 3))
3805                         e1000_set_itr(adapter);
3806                 napi_complete(napi);
3807                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3808                         e1000_irq_enable(adapter);
3809         }
3810
3811         return work_done;
3812 }
3813
3814 /**
3815  * e1000_clean_tx_irq - Reclaim resources after transmit completes
3816  * @adapter: board private structure
3817  **/
3818 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
3819                                struct e1000_tx_ring *tx_ring)
3820 {
3821         struct e1000_hw *hw = &adapter->hw;
3822         struct net_device *netdev = adapter->netdev;
3823         struct e1000_tx_desc *tx_desc, *eop_desc;
3824         struct e1000_buffer *buffer_info;
3825         unsigned int i, eop;
3826         unsigned int count = 0;
3827         unsigned int total_tx_bytes=0, total_tx_packets=0;
3828
3829         i = tx_ring->next_to_clean;
3830         eop = tx_ring->buffer_info[i].next_to_watch;
3831         eop_desc = E1000_TX_DESC(*tx_ring, eop);
3832
3833         while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
3834                (count < tx_ring->count)) {
3835                 bool cleaned = false;
3836                 rmb();  /* read buffer_info after eop_desc */
3837                 for ( ; !cleaned; count++) {
3838                         tx_desc = E1000_TX_DESC(*tx_ring, i);
3839                         buffer_info = &tx_ring->buffer_info[i];
3840                         cleaned = (i == eop);
3841
3842                         if (cleaned) {
3843                                 total_tx_packets += buffer_info->segs;
3844                                 total_tx_bytes += buffer_info->bytecount;
3845                         }
3846                         e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3847                         tx_desc->upper.data = 0;
3848
3849                         if (unlikely(++i == tx_ring->count)) i = 0;
3850                 }
3851
3852                 eop = tx_ring->buffer_info[i].next_to_watch;
3853                 eop_desc = E1000_TX_DESC(*tx_ring, eop);
3854         }
3855
3856         tx_ring->next_to_clean = i;
3857
3858 #define TX_WAKE_THRESHOLD 32
3859         if (unlikely(count && netif_carrier_ok(netdev) &&
3860                      E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
3861                 /* Make sure that anybody stopping the queue after this
3862                  * sees the new next_to_clean.
3863                  */
3864                 smp_mb();
3865
3866                 if (netif_queue_stopped(netdev) &&
3867                     !(test_bit(__E1000_DOWN, &adapter->flags))) {
3868                         netif_wake_queue(netdev);
3869                         ++adapter->restart_queue;
3870                 }
3871         }
3872
3873         if (adapter->detect_tx_hung) {
3874                 /* Detect a transmit hang in hardware, this serializes the
3875                  * check with the clearing of time_stamp and movement of i */
3876                 adapter->detect_tx_hung = false;
3877                 if (tx_ring->buffer_info[eop].time_stamp &&
3878                     time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
3879                                (adapter->tx_timeout_factor * HZ)) &&
3880                     !(er32(STATUS) & E1000_STATUS_TXOFF)) {
3881
3882                         /* detected Tx unit hang */
3883                         e_err(drv, "Detected Tx Unit Hang\n"
3884                               "  Tx Queue             <%lu>\n"
3885                               "  TDH                  <%x>\n"
3886                               "  TDT                  <%x>\n"
3887                               "  next_to_use          <%x>\n"
3888                               "  next_to_clean        <%x>\n"
3889                               "buffer_info[next_to_clean]\n"
3890                               "  time_stamp           <%lx>\n"
3891                               "  next_to_watch        <%x>\n"
3892                               "  jiffies              <%lx>\n"
3893                               "  next_to_watch.status <%x>\n",
3894                                 (unsigned long)((tx_ring - adapter->tx_ring) /
3895                                         sizeof(struct e1000_tx_ring)),
3896                                 readl(hw->hw_addr + tx_ring->tdh),
3897                                 readl(hw->hw_addr + tx_ring->tdt),
3898                                 tx_ring->next_to_use,
3899                                 tx_ring->next_to_clean,
3900                                 tx_ring->buffer_info[eop].time_stamp,
3901                                 eop,
3902                                 jiffies,
3903                                 eop_desc->upper.fields.status);
3904                         e1000_dump(adapter);
3905                         netif_stop_queue(netdev);
3906                 }
3907         }
3908         adapter->total_tx_bytes += total_tx_bytes;
3909         adapter->total_tx_packets += total_tx_packets;
3910         netdev->stats.tx_bytes += total_tx_bytes;
3911         netdev->stats.tx_packets += total_tx_packets;
3912         return count < tx_ring->count;
3913 }
3914
3915 /**
3916  * e1000_rx_checksum - Receive Checksum Offload for 82543
3917  * @adapter:     board private structure
3918  * @status_err:  receive descriptor status and error fields
3919  * @csum:        receive descriptor csum field
3920  * @sk_buff:     socket buffer with received data
3921  **/
3922
3923 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
3924                               u32 csum, struct sk_buff *skb)
3925 {
3926         struct e1000_hw *hw = &adapter->hw;
3927         u16 status = (u16)status_err;
3928         u8 errors = (u8)(status_err >> 24);
3929
3930         skb_checksum_none_assert(skb);
3931
3932         /* 82543 or newer only */
3933         if (unlikely(hw->mac_type < e1000_82543)) return;
3934         /* Ignore Checksum bit is set */
3935         if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3936         /* TCP/UDP checksum error bit is set */
3937         if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
3938                 /* let the stack verify checksum errors */
3939                 adapter->hw_csum_err++;
3940                 return;
3941         }
3942         /* TCP/UDP Checksum has not been calculated */
3943         if (!(status & E1000_RXD_STAT_TCPCS))
3944                 return;
3945
3946         /* It must be a TCP or UDP packet with a valid checksum */
3947         if (likely(status & E1000_RXD_STAT_TCPCS)) {
3948                 /* TCP checksum is good */
3949                 skb->ip_summed = CHECKSUM_UNNECESSARY;
3950         }
3951         adapter->hw_csum_good++;
3952 }
3953
3954 /**
3955  * e1000_consume_page - helper function
3956  **/
3957 static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
3958                                u16 length)
3959 {
3960         bi->page = NULL;
3961         skb->len += length;
3962         skb->data_len += length;
3963         skb->truesize += PAGE_SIZE;
3964 }
3965
3966 /**
3967  * e1000_receive_skb - helper function to handle rx indications
3968  * @adapter: board private structure
3969  * @status: descriptor status field as written by hardware
3970  * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
3971  * @skb: pointer to sk_buff to be indicated to stack
3972  */
3973 static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status,
3974                               __le16 vlan, struct sk_buff *skb)
3975 {
3976         skb->protocol = eth_type_trans(skb, adapter->netdev);
3977
3978         if (status & E1000_RXD_STAT_VP) {
3979                 u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
3980
3981                 __vlan_hwaccel_put_tag(skb, vid);
3982         }
3983         napi_gro_receive(&adapter->napi, skb);
3984 }
3985
3986 /**
3987  * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
3988  * @adapter: board private structure
3989  * @rx_ring: ring to clean
3990  * @work_done: amount of napi work completed this call
3991  * @work_to_do: max amount of work allowed for this call to do
3992  *
3993  * the return value indicates whether actual cleaning was done, there
3994  * is no guarantee that everything was cleaned
3995  */
3996 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
3997                                      struct e1000_rx_ring *rx_ring,
3998                                      int *work_done, int work_to_do)
3999 {
4000         struct e1000_hw *hw = &adapter->hw;
4001         struct net_device *netdev = adapter->netdev;
4002         struct pci_dev *pdev = adapter->pdev;
4003         struct e1000_rx_desc *rx_desc, *next_rxd;
4004         struct e1000_buffer *buffer_info, *next_buffer;
4005         unsigned long irq_flags;
4006         u32 length;
4007         unsigned int i;
4008         int cleaned_count = 0;
4009         bool cleaned = false;
4010         unsigned int total_rx_bytes=0, total_rx_packets=0;
4011
4012         i = rx_ring->next_to_clean;
4013         rx_desc = E1000_RX_DESC(*rx_ring, i);
4014         buffer_info = &rx_ring->buffer_info[i];
4015
4016         while (rx_desc->status & E1000_RXD_STAT_DD) {
4017                 struct sk_buff *skb;
4018                 u8 status;
4019
4020                 if (*work_done >= work_to_do)
4021                         break;
4022                 (*work_done)++;
4023                 rmb(); /* read descriptor and rx_buffer_info after status DD */
4024
4025                 status = rx_desc->status;
4026                 skb = buffer_info->skb;
4027                 buffer_info->skb = NULL;
4028
4029                 if (++i == rx_ring->count) i = 0;
4030                 next_rxd = E1000_RX_DESC(*rx_ring, i);
4031                 prefetch(next_rxd);
4032
4033                 next_buffer = &rx_ring->buffer_info[i];
4034
4035                 cleaned = true;
4036                 cleaned_count++;
4037                 dma_unmap_page(&pdev->dev, buffer_info->dma,
4038                                buffer_info->length, DMA_FROM_DEVICE);
4039                 buffer_info->dma = 0;
4040
4041                 length = le16_to_cpu(rx_desc->length);
4042
4043                 /* errors is only valid for DD + EOP descriptors */
4044                 if (unlikely((status & E1000_RXD_STAT_EOP) &&
4045                     (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
4046                         u8 last_byte = *(skb->data + length - 1);
4047                         if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
4048                                        last_byte)) {
4049                                 spin_lock_irqsave(&adapter->stats_lock,
4050                                                   irq_flags);
4051                                 e1000_tbi_adjust_stats(hw, &adapter->stats,
4052                                                        length, skb->data);
4053                                 spin_unlock_irqrestore(&adapter->stats_lock,
4054                                                        irq_flags);
4055                                 length--;
4056                         } else {
4057                                 /* recycle both page and skb */
4058                                 buffer_info->skb = skb;
4059                                 /* an error means any chain goes out the window
4060                                  * too */
4061                                 if (rx_ring->rx_skb_top)
4062                                         dev_kfree_skb(rx_ring->rx_skb_top);
4063                                 rx_ring->rx_skb_top = NULL;
4064                                 goto next_desc;
4065                         }
4066                 }
4067
4068 #define rxtop rx_ring->rx_skb_top
4069                 if (!(status & E1000_RXD_STAT_EOP)) {
4070                         /* this descriptor is only the beginning (or middle) */
4071                         if (!rxtop) {
4072                                 /* this is the beginning of a chain */
4073                                 rxtop = skb;
4074                                 skb_fill_page_desc(rxtop, 0, buffer_info->page,
4075                                                    0, length);
4076                         } else {
4077                                 /* this is the middle of a chain */
4078                                 skb_fill_page_desc(rxtop,
4079                                     skb_shinfo(rxtop)->nr_frags,
4080                                     buffer_info->page, 0, length);
4081                                 /* re-use the skb, only consumed the page */
4082                                 buffer_info->skb = skb;
4083                         }
4084                         e1000_consume_page(buffer_info, rxtop, length);
4085                         goto next_desc;
4086                 } else {
4087                         if (rxtop) {
4088                                 /* end of the chain */
4089                                 skb_fill_page_desc(rxtop,
4090                                     skb_shinfo(rxtop)->nr_frags,
4091                                     buffer_info->page, 0, length);
4092                                 /* re-use the current skb, we only consumed the
4093                                  * page */
4094                                 buffer_info->skb = skb;
4095                                 skb = rxtop;
4096                                 rxtop = NULL;
4097                                 e1000_consume_page(buffer_info, skb, length);
4098                         } else {
4099                                 /* no chain, got EOP, this buf is the packet
4100                                  * copybreak to save the put_page/alloc_page */
4101                                 if (length <= copybreak &&
4102                                     skb_tailroom(skb) >= length) {
4103                                         u8 *vaddr;
4104                                         vaddr = kmap_atomic(buffer_info->page);
4105                                         memcpy(skb_tail_pointer(skb), vaddr, length);
4106                                         kunmap_atomic(vaddr);
4107                                         /* re-use the page, so don't erase
4108                                          * buffer_info->page */
4109                                         skb_put(skb, length);
4110                                 } else {
4111                                         skb_fill_page_desc(skb, 0,
4112                                                            buffer_info->page, 0,
4113                                                            length);
4114                                         e1000_consume_page(buffer_info, skb,
4115                                                            length);
4116                                 }
4117                         }
4118                 }
4119
4120                 /* Receive Checksum Offload XXX recompute due to CRC strip? */
4121                 e1000_rx_checksum(adapter,
4122                                   (u32)(status) |
4123                                   ((u32)(rx_desc->errors) << 24),
4124                                   le16_to_cpu(rx_desc->csum), skb);
4125
4126                 total_rx_bytes += (skb->len - 4); /* don't count FCS */
4127                 if (likely(!(netdev->features & NETIF_F_RXFCS)))
4128                         pskb_trim(skb, skb->len - 4);
4129                 total_rx_packets++;
4130
4131                 /* eth type trans needs skb->data to point to something */
4132                 if (!pskb_may_pull(skb, ETH_HLEN)) {
4133                         e_err(drv, "pskb_may_pull failed.\n");
4134                         dev_kfree_skb(skb);
4135                         goto next_desc;
4136                 }
4137
4138                 e1000_receive_skb(adapter, status, rx_desc->special, skb);
4139
4140 next_desc:
4141                 rx_desc->status = 0;
4142
4143                 /* return some buffers to hardware, one at a time is too slow */
4144                 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
4145                         adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4146                         cleaned_count = 0;
4147                 }
4148
4149                 /* use prefetched values */
4150                 rx_desc = next_rxd;
4151                 buffer_info = next_buffer;
4152         }
4153         rx_ring->next_to_clean = i;
4154
4155         cleaned_count = E1000_DESC_UNUSED(rx_ring);
4156         if (cleaned_count)
4157                 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4158
4159         adapter->total_rx_packets += total_rx_packets;
4160         adapter->total_rx_bytes += total_rx_bytes;
4161         netdev->stats.rx_bytes += total_rx_bytes;
4162         netdev->stats.rx_packets += total_rx_packets;
4163         return cleaned;
4164 }
4165
4166 /*
4167  * this should improve performance for small packets with large amounts
4168  * of reassembly being done in the stack
4169  */
4170 static void e1000_check_copybreak(struct net_device *netdev,
4171                                  struct e1000_buffer *buffer_info,
4172                                  u32 length, struct sk_buff **skb)
4173 {
4174         struct sk_buff *new_skb;
4175
4176         if (length > copybreak)
4177                 return;
4178
4179         new_skb = netdev_alloc_skb_ip_align(netdev, length);
4180         if (!new_skb)
4181                 return;
4182
4183         skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
4184                                        (*skb)->data - NET_IP_ALIGN,
4185                                        length + NET_IP_ALIGN);
4186         /* save the skb in buffer_info as good */
4187         buffer_info->skb = *skb;
4188         *skb = new_skb;
4189 }
4190
4191 /**
4192  * e1000_clean_rx_irq - Send received data up the network stack; legacy
4193  * @adapter: board private structure
4194  * @rx_ring: ring to clean
4195  * @work_done: amount of napi work completed this call
4196  * @work_to_do: max amount of work allowed for this call to do
4197  */
4198 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
4199                                struct e1000_rx_ring *rx_ring,
4200                                int *work_done, int work_to_do)
4201 {
4202         struct e1000_hw *hw = &adapter->hw;
4203         struct net_device *netdev = adapter->netdev;
4204         struct pci_dev *pdev = adapter->pdev;
4205         struct e1000_rx_desc *rx_desc, *next_rxd;
4206         struct e1000_buffer *buffer_info, *next_buffer;
4207         unsigned long flags;
4208         u32 length;
4209         unsigned int i;
4210         int cleaned_count = 0;
4211         bool cleaned = false;
4212         unsigned int total_rx_bytes=0, total_rx_packets=0;
4213
4214         i = rx_ring->next_to_clean;
4215         rx_desc = E1000_RX_DESC(*rx_ring, i);
4216         buffer_info = &rx_ring->buffer_info[i];
4217
4218         while (rx_desc->status & E1000_RXD_STAT_DD) {
4219                 struct sk_buff *skb;
4220                 u8 status;
4221
4222                 if (*work_done >= work_to_do)
4223                         break;
4224                 (*work_done)++;
4225                 rmb(); /* read descriptor and rx_buffer_info after status DD */
4226
4227                 status = rx_desc->status;
4228                 skb = buffer_info->skb;
4229                 buffer_info->skb = NULL;
4230
4231                 prefetch(skb->data - NET_IP_ALIGN);
4232
4233                 if (++i == rx_ring->count) i = 0;
4234                 next_rxd = E1000_RX_DESC(*rx_ring, i);
4235                 prefetch(next_rxd);
4236
4237                 next_buffer = &rx_ring->buffer_info[i];
4238
4239                 cleaned = true;
4240                 cleaned_count++;
4241                 dma_unmap_single(&pdev->dev, buffer_info->dma,
4242                                  buffer_info->length, DMA_FROM_DEVICE);
4243                 buffer_info->dma = 0;
4244
4245                 length = le16_to_cpu(rx_desc->length);
4246                 /* !EOP means multiple descriptors were used to store a single
4247                  * packet, if thats the case we need to toss it.  In fact, we
4248                  * to toss every packet with the EOP bit clear and the next
4249                  * frame that _does_ have the EOP bit set, as it is by
4250                  * definition only a frame fragment
4251                  */
4252                 if (unlikely(!(status & E1000_RXD_STAT_EOP)))
4253                         adapter->discarding = true;
4254
4255                 if (adapter->discarding) {
4256                         /* All receives must fit into a single buffer */
4257                         e_dbg("Receive packet consumed multiple buffers\n");
4258                         /* recycle */
4259                         buffer_info->skb = skb;
4260                         if (status & E1000_RXD_STAT_EOP)
4261                                 adapter->discarding = false;
4262                         goto next_desc;
4263                 }
4264
4265                 if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
4266                         u8 last_byte = *(skb->data + length - 1);
4267                         if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
4268                                        last_byte)) {
4269                                 spin_lock_irqsave(&adapter->stats_lock, flags);
4270                                 e1000_tbi_adjust_stats(hw, &adapter->stats,
4271                                                        length, skb->data);
4272                                 spin_unlock_irqrestore(&adapter->stats_lock,
4273                                                        flags);
4274                                 length--;
4275                         } else {
4276                                 /* recycle */
4277                                 buffer_info->skb = skb;
4278                                 goto next_desc;
4279                         }
4280                 }
4281
4282                 total_rx_bytes += (length - 4); /* don't count FCS */
4283                 total_rx_packets++;
4284
4285                 if (likely(!(netdev->features & NETIF_F_RXFCS)))
4286                         /* adjust length to remove Ethernet CRC, this must be
4287                          * done after the TBI_ACCEPT workaround above
4288                          */
4289                         length -= 4;
4290
4291                 e1000_check_copybreak(netdev, buffer_info, length, &skb);
4292
4293                 skb_put(skb, length);
4294
4295                 /* Receive Checksum Offload */
4296                 e1000_rx_checksum(adapter,
4297                                   (u32)(status) |
4298                                   ((u32)(rx_desc->errors) << 24),
4299                                   le16_to_cpu(rx_desc->csum), skb);
4300
4301                 e1000_receive_skb(adapter, status, rx_desc->special, skb);
4302
4303 next_desc:
4304                 rx_desc->status = 0;
4305
4306                 /* return some buffers to hardware, one at a time is too slow */
4307                 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
4308                         adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4309                         cleaned_count = 0;
4310                 }
4311
4312                 /* use prefetched values */
4313                 rx_desc = next_rxd;
4314                 buffer_info = next_buffer;
4315         }
4316         rx_ring->next_to_clean = i;
4317
4318         cleaned_count = E1000_DESC_UNUSED(rx_ring);
4319         if (cleaned_count)
4320                 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4321
4322         adapter->total_rx_packets += total_rx_packets;
4323         adapter->total_rx_bytes += total_rx_bytes;
4324         netdev->stats.rx_bytes += total_rx_bytes;
4325         netdev->stats.rx_packets += total_rx_packets;
4326         return cleaned;
4327 }
4328
4329 /**
4330  * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
4331  * @adapter: address of board private structure
4332  * @rx_ring: pointer to receive ring structure
4333  * @cleaned_count: number of buffers to allocate this pass
4334  **/
4335
4336 static void
4337 e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
4338                              struct e1000_rx_ring *rx_ring, int cleaned_count)
4339 {
4340         struct net_device *netdev = adapter->netdev;
4341         struct pci_dev *pdev = adapter->pdev;
4342         struct e1000_rx_desc *rx_desc;
4343         struct e1000_buffer *buffer_info;
4344         struct sk_buff *skb;
4345         unsigned int i;
4346         unsigned int bufsz = 256 - 16 /*for skb_reserve */ ;
4347
4348         i = rx_ring->next_to_use;
4349         buffer_info = &rx_ring->buffer_info[i];
4350
4351         while (cleaned_count--) {
4352                 skb = buffer_info->skb;
4353                 if (skb) {
4354                         skb_trim(skb, 0);
4355                         goto check_page;
4356                 }
4357
4358                 skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4359                 if (unlikely(!skb)) {
4360                         /* Better luck next round */
4361                         adapter->alloc_rx_buff_failed++;
4362                         break;
4363                 }
4364
4365                 /* Fix for errata 23, can't cross 64kB boundary */
4366                 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4367                         struct sk_buff *oldskb = skb;
4368                         e_err(rx_err, "skb align check failed: %u bytes at "
4369                               "%p\n", bufsz, skb->data);
4370                         /* Try again, without freeing the previous */
4371                         skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4372                         /* Failed allocation, critical failure */
4373                         if (!skb) {
4374                                 dev_kfree_skb(oldskb);
4375                                 adapter->alloc_rx_buff_failed++;
4376                                 break;
4377                         }
4378
4379                         if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4380                                 /* give up */
4381                                 dev_kfree_skb(skb);
4382                                 dev_kfree_skb(oldskb);
4383                                 break; /* while (cleaned_count--) */
4384                         }
4385
4386                         /* Use new allocation */
4387                         dev_kfree_skb(oldskb);
4388                 }
4389                 buffer_info->skb = skb;
4390                 buffer_info->length = adapter->rx_buffer_len;
4391 check_page:
4392                 /* allocate a new page if necessary */
4393                 if (!buffer_info->page) {
4394                         buffer_info->page = alloc_page(GFP_ATOMIC);
4395                         if (unlikely(!buffer_info->page)) {
4396                                 adapter->alloc_rx_buff_failed++;
4397                                 break;
4398                         }
4399                 }
4400
4401                 if (!buffer_info->dma) {
4402                         buffer_info->dma = dma_map_page(&pdev->dev,
4403                                                         buffer_info->page, 0,
4404                                                         buffer_info->length,
4405                                                         DMA_FROM_DEVICE);
4406                         if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4407                                 put_page(buffer_info->page);
4408                                 dev_kfree_skb(skb);
4409                                 buffer_info->page = NULL;
4410                                 buffer_info->skb = NULL;
4411                                 buffer_info->dma = 0;
4412                                 adapter->alloc_rx_buff_failed++;
4413                                 break; /* while !buffer_info->skb */
4414                         }
4415                 }
4416
4417                 rx_desc = E1000_RX_DESC(*rx_ring, i);
4418                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
4419
4420                 if (unlikely(++i == rx_ring->count))
4421                         i = 0;
4422                 buffer_info = &rx_ring->buffer_info[i];
4423         }
4424
4425         if (likely(rx_ring->next_to_use != i)) {
4426                 rx_ring->next_to_use = i;
4427                 if (unlikely(i-- == 0))
4428                         i = (rx_ring->count - 1);
4429
4430                 /* Force memory writes to complete before letting h/w
4431                  * know there are new descriptors to fetch.  (Only
4432                  * applicable for weak-ordered memory model archs,
4433                  * such as IA-64). */
4434                 wmb();
4435                 writel(i, adapter->hw.hw_addr + rx_ring->rdt);
4436         }
4437 }
4438
4439 /**
4440  * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
4441  * @adapter: address of board private structure
4442  **/
4443
4444 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
4445                                    struct e1000_rx_ring *rx_ring,
4446                                    int cleaned_count)
4447 {
4448         struct e1000_hw *hw = &adapter->hw;
4449         struct net_device *netdev = adapter->netdev;
4450         struct pci_dev *pdev = adapter->pdev;
4451         struct e1000_rx_desc *rx_desc;
4452         struct e1000_buffer *buffer_info;
4453         struct sk_buff *skb;
4454         unsigned int i;
4455         unsigned int bufsz = adapter->rx_buffer_len;
4456
4457         i = rx_ring->next_to_use;
4458         buffer_info = &rx_ring->buffer_info[i];
4459
4460         while (cleaned_count--) {
4461                 skb = buffer_info->skb;
4462                 if (skb) {
4463                         skb_trim(skb, 0);
4464                         goto map_skb;
4465                 }
4466
4467                 skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4468                 if (unlikely(!skb)) {
4469                         /* Better luck next round */
4470                         adapter->alloc_rx_buff_failed++;
4471                         break;
4472                 }
4473
4474                 /* Fix for errata 23, can't cross 64kB boundary */
4475                 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4476                         struct sk_buff *oldskb = skb;
4477                         e_err(rx_err, "skb align check failed: %u bytes at "
4478                               "%p\n", bufsz, skb->data);
4479                         /* Try again, without freeing the previous */
4480                         skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4481                         /* Failed allocation, critical failure */
4482                         if (!skb) {
4483                                 dev_kfree_skb(oldskb);
4484                                 adapter->alloc_rx_buff_failed++;
4485                                 break;
4486                         }
4487
4488                         if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4489                                 /* give up */
4490                                 dev_kfree_skb(skb);
4491                                 dev_kfree_skb(oldskb);
4492                                 adapter->alloc_rx_buff_failed++;
4493                                 break; /* while !buffer_info->skb */
4494                         }
4495
4496                         /* Use new allocation */
4497                         dev_kfree_skb(oldskb);
4498                 }
4499                 buffer_info->skb = skb;
4500                 buffer_info->length = adapter->rx_buffer_len;
4501 map_skb:
4502                 buffer_info->dma = dma_map_single(&pdev->dev,
4503                                                   skb->data,
4504                                                   buffer_info->length,
4505                                                   DMA_FROM_DEVICE);
4506                 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4507                         dev_kfree_skb(skb);
4508                         buffer_info->skb = NULL;
4509                         buffer_info->dma = 0;
4510                         adapter->alloc_rx_buff_failed++;
4511                         break; /* while !buffer_info->skb */
4512                 }
4513
4514                 /*
4515                  * XXX if it was allocated cleanly it will never map to a
4516                  * boundary crossing
4517                  */
4518
4519                 /* Fix for errata 23, can't cross 64kB boundary */
4520                 if (!e1000_check_64k_bound(adapter,
4521                                         (void *)(unsigned long)buffer_info->dma,
4522                                         adapter->rx_buffer_len)) {
4523                         e_err(rx_err, "dma align check failed: %u bytes at "
4524                               "%p\n", adapter->rx_buffer_len,
4525                               (void *)(unsigned long)buffer_info->dma);
4526                         dev_kfree_skb(skb);
4527                         buffer_info->skb = NULL;
4528
4529                         dma_unmap_single(&pdev->dev, buffer_info->dma,
4530                                          adapter->rx_buffer_len,
4531                                          DMA_FROM_DEVICE);
4532                         buffer_info->dma = 0;
4533
4534                         adapter->alloc_rx_buff_failed++;
4535                         break; /* while !buffer_info->skb */
4536                 }
4537                 rx_desc = E1000_RX_DESC(*rx_ring, i);
4538                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
4539
4540                 if (unlikely(++i == rx_ring->count))
4541                         i = 0;
4542                 buffer_info = &rx_ring->buffer_info[i];
4543         }
4544
4545         if (likely(rx_ring->next_to_use != i)) {
4546                 rx_ring->next_to_use = i;
4547                 if (unlikely(i-- == 0))
4548                         i = (rx_ring->count - 1);
4549
4550                 /* Force memory writes to complete before letting h/w
4551                  * know there are new descriptors to fetch.  (Only
4552                  * applicable for weak-ordered memory model archs,
4553                  * such as IA-64). */
4554                 wmb();
4555                 writel(i, hw->hw_addr + rx_ring->rdt);
4556         }
4557 }
4558
4559 /**
4560  * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
4561  * @adapter:
4562  **/
4563
4564 static void e1000_smartspeed(struct e1000_adapter *adapter)
4565 {
4566         struct e1000_hw *hw = &adapter->hw;
4567         u16 phy_status;
4568         u16 phy_ctrl;
4569
4570         if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg ||
4571            !(hw->autoneg_advertised & ADVERTISE_1000_FULL))
4572                 return;
4573
4574         if (adapter->smartspeed == 0) {
4575                 /* If Master/Slave config fault is asserted twice,
4576                  * we assume back-to-back */
4577                 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
4578                 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
4579                 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
4580                 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
4581                 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
4582                 if (phy_ctrl & CR_1000T_MS_ENABLE) {
4583                         phy_ctrl &= ~CR_1000T_MS_ENABLE;
4584                         e1000_write_phy_reg(hw, PHY_1000T_CTRL,
4585                                             phy_ctrl);
4586                         adapter->smartspeed++;
4587                         if (!e1000_phy_setup_autoneg(hw) &&
4588                            !e1000_read_phy_reg(hw, PHY_CTRL,
4589                                                &phy_ctrl)) {
4590                                 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
4591                                              MII_CR_RESTART_AUTO_NEG);
4592                                 e1000_write_phy_reg(hw, PHY_CTRL,
4593                                                     phy_ctrl);
4594                         }
4595                 }
4596                 return;
4597         } else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
4598                 /* If still no link, perhaps using 2/3 pair cable */
4599                 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
4600                 phy_ctrl |= CR_1000T_MS_ENABLE;
4601                 e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl);
4602                 if (!e1000_phy_setup_autoneg(hw) &&
4603                    !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) {
4604                         phy_ctrl |= (MII_CR_AUTO_NEG_EN |
4605                                      MII_CR_RESTART_AUTO_NEG);
4606                         e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl);
4607                 }
4608         }
4609         /* Restart process after E1000_SMARTSPEED_MAX iterations */
4610         if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
4611                 adapter->smartspeed = 0;
4612 }
4613
4614 /**
4615  * e1000_ioctl -
4616  * @netdev:
4617  * @ifreq:
4618  * @cmd:
4619  **/
4620
4621 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
4622 {
4623         switch (cmd) {
4624         case SIOCGMIIPHY:
4625         case SIOCGMIIREG:
4626         case SIOCSMIIREG:
4627                 return e1000_mii_ioctl(netdev, ifr, cmd);
4628         default:
4629                 return -EOPNOTSUPP;
4630         }
4631 }
4632
4633 /**
4634  * e1000_mii_ioctl -
4635  * @netdev:
4636  * @ifreq:
4637  * @cmd:
4638  **/
4639
4640 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
4641                            int cmd)
4642 {
4643         struct e1000_adapter *adapter = netdev_priv(netdev);
4644         struct e1000_hw *hw = &adapter->hw;
4645         struct mii_ioctl_data *data = if_mii(ifr);
4646         int retval;
4647         u16 mii_reg;
4648         unsigned long flags;
4649
4650         if (hw->media_type != e1000_media_type_copper)
4651                 return -EOPNOTSUPP;
4652
4653         switch (cmd) {
4654         case SIOCGMIIPHY:
4655                 data->phy_id = hw->phy_addr;
4656                 break;
4657         case SIOCGMIIREG:
4658                 spin_lock_irqsave(&adapter->stats_lock, flags);
4659                 if (e1000_read_phy_reg(hw, data->reg_num & 0x1F,
4660                                    &data->val_out)) {
4661                         spin_unlock_irqrestore(&adapter->stats_lock, flags);
4662                         return -EIO;
4663                 }
4664                 spin_unlock_irqrestore(&adapter->stats_lock, flags);
4665                 break;
4666         case SIOCSMIIREG:
4667                 if (data->reg_num & ~(0x1F))
4668                         return -EFAULT;
4669                 mii_reg = data->val_in;
4670                 spin_lock_irqsave(&adapter->stats_lock, flags);
4671                 if (e1000_write_phy_reg(hw, data->reg_num,
4672                                         mii_reg)) {
4673                         spin_unlock_irqrestore(&adapter->stats_lock, flags);
4674                         return -EIO;
4675                 }
4676                 spin_unlock_irqrestore(&adapter->stats_lock, flags);
4677                 if (hw->media_type == e1000_media_type_copper) {
4678                         switch (data->reg_num) {
4679                         case PHY_CTRL:
4680                                 if (mii_reg & MII_CR_POWER_DOWN)
4681                                         break;
4682                                 if (mii_reg & MII_CR_AUTO_NEG_EN) {
4683                                         hw->autoneg = 1;
4684                                         hw->autoneg_advertised = 0x2F;
4685                                 } else {
4686                                         u32 speed;
4687                                         if (mii_reg & 0x40)
4688                                                 speed = SPEED_1000;
4689                                         else if (mii_reg & 0x2000)
4690                                                 speed = SPEED_100;
4691                                         else
4692                                                 speed = SPEED_10;
4693                                         retval = e1000_set_spd_dplx(
4694                                                 adapter, speed,
4695                                                 ((mii_reg & 0x100)
4696                                                  ? DUPLEX_FULL :
4697                                                  DUPLEX_HALF));
4698                                         if (retval)
4699                                                 return retval;
4700                                 }
4701                                 if (netif_running(adapter->netdev))
4702                                         e1000_reinit_locked(adapter);
4703                                 else
4704                                         e1000_reset(adapter);
4705                                 break;
4706                         case M88E1000_PHY_SPEC_CTRL:
4707                         case M88E1000_EXT_PHY_SPEC_CTRL:
4708                                 if (e1000_phy_reset(hw))
4709                                         return -EIO;
4710                                 break;
4711                         }
4712                 } else {
4713                         switch (data->reg_num) {
4714                         case PHY_CTRL:
4715                                 if (mii_reg & MII_CR_POWER_DOWN)
4716                                         break;
4717                                 if (netif_running(adapter->netdev))
4718                                         e1000_reinit_locked(adapter);
4719                                 else
4720                                         e1000_reset(adapter);
4721                                 break;
4722                         }
4723                 }
4724                 break;
4725         default:
4726                 return -EOPNOTSUPP;
4727         }
4728         return E1000_SUCCESS;
4729 }
4730
4731 void e1000_pci_set_mwi(struct e1000_hw *hw)
4732 {
4733         struct e1000_adapter *adapter = hw->back;
4734         int ret_val = pci_set_mwi(adapter->pdev);
4735
4736         if (ret_val)
4737                 e_err(probe, "Error in setting MWI\n");
4738 }
4739
4740 void e1000_pci_clear_mwi(struct e1000_hw *hw)
4741 {
4742         struct e1000_adapter *adapter = hw->back;
4743
4744         pci_clear_mwi(adapter->pdev);
4745 }
4746
4747 int e1000_pcix_get_mmrbc(struct e1000_hw *hw)
4748 {
4749         struct e1000_adapter *adapter = hw->back;
4750         return pcix_get_mmrbc(adapter->pdev);
4751 }
4752
4753 void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
4754 {
4755         struct e1000_adapter *adapter = hw->back;
4756         pcix_set_mmrbc(adapter->pdev, mmrbc);
4757 }
4758
4759 void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
4760 {
4761         outl(value, port);
4762 }
4763
4764 static bool e1000_vlan_used(struct e1000_adapter *adapter)
4765 {
4766         u16 vid;
4767
4768         for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
4769                 return true;
4770         return false;
4771 }
4772
4773 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
4774                                      bool filter_on)
4775 {
4776         struct e1000_hw *hw = &adapter->hw;
4777         u32 rctl;
4778
4779         if (!test_bit(__E1000_DOWN, &adapter->flags))
4780                 e1000_irq_disable(adapter);
4781
4782         if (filter_on) {
4783                 /* enable VLAN receive filtering */
4784                 rctl = er32(RCTL);
4785                 rctl &= ~E1000_RCTL_CFIEN;
4786                 if (!(adapter->netdev->flags & IFF_PROMISC))
4787                         rctl |= E1000_RCTL_VFE;
4788                 ew32(RCTL, rctl);
4789                 e1000_update_mng_vlan(adapter);
4790         } else {
4791                 /* disable VLAN receive filtering */
4792                 rctl = er32(RCTL);
4793                 rctl &= ~E1000_RCTL_VFE;
4794                 ew32(RCTL, rctl);
4795         }
4796
4797         if (!test_bit(__E1000_DOWN, &adapter->flags))
4798                 e1000_irq_enable(adapter);
4799 }
4800
4801 static void e1000_vlan_mode(struct net_device *netdev,
4802         netdev_features_t features)
4803 {
4804         struct e1000_adapter *adapter = netdev_priv(netdev);
4805         struct e1000_hw *hw = &adapter->hw;
4806         u32 ctrl;
4807
4808         if (!test_bit(__E1000_DOWN, &adapter->flags))
4809                 e1000_irq_disable(adapter);
4810
4811         ctrl = er32(CTRL);
4812         if (features & NETIF_F_HW_VLAN_RX) {
4813                 /* enable VLAN tag insert/strip */
4814                 ctrl |= E1000_CTRL_VME;
4815         } else {
4816                 /* disable VLAN tag insert/strip */
4817                 ctrl &= ~E1000_CTRL_VME;
4818         }
4819         ew32(CTRL, ctrl);
4820
4821         if (!test_bit(__E1000_DOWN, &adapter->flags))
4822                 e1000_irq_enable(adapter);
4823 }
4824
4825 static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
4826 {
4827         struct e1000_adapter *adapter = netdev_priv(netdev);
4828         struct e1000_hw *hw = &adapter->hw;
4829         u32 vfta, index;
4830
4831         if ((hw->mng_cookie.status &
4832              E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
4833             (vid == adapter->mng_vlan_id))
4834                 return 0;
4835
4836         if (!e1000_vlan_used(adapter))
4837                 e1000_vlan_filter_on_off(adapter, true);
4838
4839         /* add VID to filter table */
4840         index = (vid >> 5) & 0x7F;
4841         vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
4842         vfta |= (1 << (vid & 0x1F));
4843         e1000_write_vfta(hw, index, vfta);
4844
4845         set_bit(vid, adapter->active_vlans);
4846
4847         return 0;
4848 }
4849
4850 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
4851 {
4852         struct e1000_adapter *adapter = netdev_priv(netdev);
4853         struct e1000_hw *hw = &adapter->hw;
4854         u32 vfta, index;
4855
4856         if (!test_bit(__E1000_DOWN, &adapter->flags))
4857                 e1000_irq_disable(adapter);
4858         if (!test_bit(__E1000_DOWN, &adapter->flags))
4859                 e1000_irq_enable(adapter);
4860
4861         /* remove VID from filter table */
4862         index = (vid >> 5) & 0x7F;
4863         vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
4864         vfta &= ~(1 << (vid & 0x1F));
4865         e1000_write_vfta(hw, index, vfta);
4866
4867         clear_bit(vid, adapter->active_vlans);
4868
4869         if (!e1000_vlan_used(adapter))
4870                 e1000_vlan_filter_on_off(adapter, false);
4871
4872         return 0;
4873 }
4874
4875 static void e1000_restore_vlan(struct e1000_adapter *adapter)
4876 {
4877         u16 vid;
4878
4879         if (!e1000_vlan_used(adapter))
4880                 return;
4881
4882         e1000_vlan_filter_on_off(adapter, true);
4883         for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
4884                 e1000_vlan_rx_add_vid(adapter->netdev, vid);
4885 }
4886
4887 int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
4888 {
4889         struct e1000_hw *hw = &adapter->hw;
4890
4891         hw->autoneg = 0;
4892
4893         /* Make sure dplx is at most 1 bit and lsb of speed is not set
4894          * for the switch() below to work */
4895         if ((spd & 1) || (dplx & ~1))
4896                 goto err_inval;
4897
4898         /* Fiber NICs only allow 1000 gbps Full duplex */
4899         if ((hw->media_type == e1000_media_type_fiber) &&
4900             spd != SPEED_1000 &&
4901             dplx != DUPLEX_FULL)
4902                 goto err_inval;
4903
4904         switch (spd + dplx) {
4905         case SPEED_10 + DUPLEX_HALF:
4906                 hw->forced_speed_duplex = e1000_10_half;
4907                 break;
4908         case SPEED_10 + DUPLEX_FULL:
4909                 hw->forced_speed_duplex = e1000_10_full;
4910                 break;
4911         case SPEED_100 + DUPLEX_HALF:
4912                 hw->forced_speed_duplex = e1000_100_half;
4913                 break;
4914         case SPEED_100 + DUPLEX_FULL:
4915                 hw->forced_speed_duplex = e1000_100_full;
4916                 break;
4917         case SPEED_1000 + DUPLEX_FULL:
4918                 hw->autoneg = 1;
4919                 hw->autoneg_advertised = ADVERTISE_1000_FULL;
4920                 break;
4921         case SPEED_1000 + DUPLEX_HALF: /* not supported */
4922         default:
4923                 goto err_inval;
4924         }
4925         return 0;
4926
4927 err_inval:
4928         e_err(probe, "Unsupported Speed/Duplex configuration\n");
4929         return -EINVAL;
4930 }
4931
4932 static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
4933 {
4934         struct net_device *netdev = pci_get_drvdata(pdev);
4935         struct e1000_adapter *adapter = netdev_priv(netdev);
4936         struct e1000_hw *hw = &adapter->hw;
4937         u32 ctrl, ctrl_ext, rctl, status;
4938         u32 wufc = adapter->wol;
4939 #ifdef CONFIG_PM
4940         int retval = 0;
4941 #endif
4942
4943         netif_device_detach(netdev);
4944
4945         if (netif_running(netdev)) {
4946                 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
4947                 e1000_down(adapter);
4948         }
4949
4950 #ifdef CONFIG_PM
4951         retval = pci_save_state(pdev);
4952         if (retval)
4953                 return retval;
4954 #endif
4955
4956         status = er32(STATUS);
4957         if (status & E1000_STATUS_LU)
4958                 wufc &= ~E1000_WUFC_LNKC;
4959
4960         if (wufc) {
4961                 e1000_setup_rctl(adapter);
4962                 e1000_set_rx_mode(netdev);
4963
4964                 rctl = er32(RCTL);
4965
4966                 /* turn on all-multi mode if wake on multicast is enabled */
4967                 if (wufc & E1000_WUFC_MC)
4968                         rctl |= E1000_RCTL_MPE;
4969
4970                 /* enable receives in the hardware */
4971                 ew32(RCTL, rctl | E1000_RCTL_EN);
4972
4973                 if (hw->mac_type >= e1000_82540) {
4974                         ctrl = er32(CTRL);
4975                         /* advertise wake from D3Cold */
4976                         #define E1000_CTRL_ADVD3WUC 0x00100000
4977                         /* phy power management enable */
4978                         #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
4979                         ctrl |= E1000_CTRL_ADVD3WUC |
4980                                 E1000_CTRL_EN_PHY_PWR_MGMT;
4981                         ew32(CTRL, ctrl);
4982                 }
4983
4984                 if (hw->media_type == e1000_media_type_fiber ||
4985                     hw->media_type == e1000_media_type_internal_serdes) {
4986                         /* keep the laser running in D3 */
4987                         ctrl_ext = er32(CTRL_EXT);
4988                         ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
4989                         ew32(CTRL_EXT, ctrl_ext);
4990                 }
4991
4992                 ew32(WUC, E1000_WUC_PME_EN);
4993                 ew32(WUFC, wufc);
4994         } else {
4995                 ew32(WUC, 0);
4996                 ew32(WUFC, 0);
4997         }
4998
4999         e1000_release_manageability(adapter);
5000
5001         *enable_wake = !!wufc;
5002
5003         /* make sure adapter isn't asleep if manageability is enabled */
5004         if (adapter->en_mng_pt)
5005                 *enable_wake = true;
5006
5007         if (netif_running(netdev))
5008                 e1000_free_irq(adapter);
5009
5010         pci_disable_device(pdev);
5011
5012         return 0;
5013 }
5014
5015 #ifdef CONFIG_PM
5016 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
5017 {
5018         int retval;
5019         bool wake;
5020
5021         retval = __e1000_shutdown(pdev, &wake);
5022         if (retval)
5023                 return retval;
5024
5025         if (wake) {
5026                 pci_prepare_to_sleep(pdev);
5027         } else {
5028                 pci_wake_from_d3(pdev, false);
5029                 pci_set_power_state(pdev, PCI_D3hot);
5030         }
5031
5032         return 0;
5033 }
5034
5035 static int e1000_resume(struct pci_dev *pdev)
5036 {
5037         struct net_device *netdev = pci_get_drvdata(pdev);
5038         struct e1000_adapter *adapter = netdev_priv(netdev);
5039         struct e1000_hw *hw = &adapter->hw;
5040         u32 err;
5041
5042         pci_set_power_state(pdev, PCI_D0);
5043         pci_restore_state(pdev);
5044         pci_save_state(pdev);
5045
5046         if (adapter->need_ioport)
5047                 err = pci_enable_device(pdev);
5048         else
5049                 err = pci_enable_device_mem(pdev);
5050         if (err) {
5051                 pr_err("Cannot enable PCI device from suspend\n");
5052                 return err;
5053         }
5054         pci_set_master(pdev);
5055
5056         pci_enable_wake(pdev, PCI_D3hot, 0);
5057         pci_enable_wake(pdev, PCI_D3cold, 0);
5058
5059         if (netif_running(netdev)) {
5060                 err = e1000_request_irq(adapter);
5061                 if (err)
5062                         return err;
5063         }
5064
5065         e1000_power_up_phy(adapter);
5066         e1000_reset(adapter);
5067         ew32(WUS, ~0);
5068
5069         e1000_init_manageability(adapter);
5070
5071         if (netif_running(netdev))
5072                 e1000_up(adapter);
5073
5074         netif_device_attach(netdev);
5075
5076         return 0;
5077 }
5078 #endif
5079
5080 static void e1000_shutdown(struct pci_dev *pdev)
5081 {
5082         bool wake;
5083
5084         __e1000_shutdown(pdev, &wake);
5085
5086         if (system_state == SYSTEM_POWER_OFF) {
5087                 pci_wake_from_d3(pdev, wake);
5088                 pci_set_power_state(pdev, PCI_D3hot);
5089         }
5090 }
5091
5092 #ifdef CONFIG_NET_POLL_CONTROLLER
5093 /*
5094  * Polling 'interrupt' - used by things like netconsole to send skbs
5095  * without having to re-enable interrupts. It's not called while
5096  * the interrupt routine is executing.
5097  */
5098 static void e1000_netpoll(struct net_device *netdev)
5099 {
5100         struct e1000_adapter *adapter = netdev_priv(netdev);
5101
5102         disable_irq(adapter->pdev->irq);
5103         e1000_intr(adapter->pdev->irq, netdev);
5104         enable_irq(adapter->pdev->irq);
5105 }
5106 #endif
5107
5108 /**
5109  * e1000_io_error_detected - called when PCI error is detected
5110  * @pdev: Pointer to PCI device
5111  * @state: The current pci connection state
5112  *
5113  * This function is called after a PCI bus error affecting
5114  * this device has been detected.
5115  */
5116 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
5117                                                 pci_channel_state_t state)
5118 {
5119         struct net_device *netdev = pci_get_drvdata(pdev);
5120         struct e1000_adapter *adapter = netdev_priv(netdev);
5121
5122         netif_device_detach(netdev);
5123
5124         if (state == pci_channel_io_perm_failure)
5125                 return PCI_ERS_RESULT_DISCONNECT;
5126
5127         if (netif_running(netdev))
5128                 e1000_down(adapter);
5129         pci_disable_device(pdev);
5130
5131         /* Request a slot slot reset. */
5132         return PCI_ERS_RESULT_NEED_RESET;
5133 }
5134
5135 /**
5136  * e1000_io_slot_reset - called after the pci bus has been reset.
5137  * @pdev: Pointer to PCI device
5138  *
5139  * Restart the card from scratch, as if from a cold-boot. Implementation
5140  * resembles the first-half of the e1000_resume routine.
5141  */
5142 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
5143 {
5144         struct net_device *netdev = pci_get_drvdata(pdev);
5145         struct e1000_adapter *adapter = netdev_priv(netdev);
5146         struct e1000_hw *hw = &adapter->hw;
5147         int err;
5148
5149         if (adapter->need_ioport)
5150                 err = pci_enable_device(pdev);
5151         else
5152                 err = pci_enable_device_mem(pdev);
5153         if (err) {
5154                 pr_err("Cannot re-enable PCI device after reset.\n");
5155                 return PCI_ERS_RESULT_DISCONNECT;
5156         }
5157         pci_set_master(pdev);
5158
5159         pci_enable_wake(pdev, PCI_D3hot, 0);
5160         pci_enable_wake(pdev, PCI_D3cold, 0);
5161
5162         e1000_reset(adapter);
5163         ew32(WUS, ~0);
5164
5165         return PCI_ERS_RESULT_RECOVERED;
5166 }
5167
5168 /**
5169  * e1000_io_resume - called when traffic can start flowing again.
5170  * @pdev: Pointer to PCI device
5171  *
5172  * This callback is called when the error recovery driver tells us that
5173  * its OK to resume normal operation. Implementation resembles the
5174  * second-half of the e1000_resume routine.
5175  */
5176 static void e1000_io_resume(struct pci_dev *pdev)
5177 {
5178         struct net_device *netdev = pci_get_drvdata(pdev);
5179         struct e1000_adapter *adapter = netdev_priv(netdev);
5180
5181         e1000_init_manageability(adapter);
5182
5183         if (netif_running(netdev)) {
5184                 if (e1000_up(adapter)) {
5185                         pr_info("can't bring device back up after reset\n");
5186                         return;
5187                 }
5188         }
5189
5190         netif_device_attach(netdev);
5191 }
5192
5193 /* e1000_main.c */