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

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