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