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

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