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

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