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 /**
 725  *  Dump the eeprom for users having checksum issues
 726  **/
 727 static void e1000_dump_eeprom(struct e1000_adapter *adapter)
 728 {
 729         struct net_device *netdev = adapter->netdev;
 730         struct ethtool_eeprom eeprom;
 731         const struct ethtool_ops *ops = netdev->ethtool_ops;
 732         u8 *data;
 733         int i;
 734         u16 csum_old, csum_new = 0;
 735
 736         eeprom.len = ops->get_eeprom_len(netdev);
 737         eeprom.offset = 0;
 738
 739         data = kmalloc(eeprom.len, GFP_KERNEL);
 740         if (!data)
 741                 return;
 742
 743         ops->get_eeprom(netdev, &eeprom, data);
 744
 745         csum_old = (data[EEPROM_CHECKSUM_REG * 2]) +
 746                    (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8);
 747         for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2)
 748                 csum_new += data[i] + (data[i + 1] << 8);
 749         csum_new = EEPROM_SUM - csum_new;
 750
 751         pr_err("/*********************/\n");
 752         pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old);
 753         pr_err("Calculated              : 0x%04x\n", csum_new);
 754
 755         pr_err("Offset    Values\n");
 756         pr_err("========  ======\n");
 757         print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0);
 758
 759         pr_err("Include this output when contacting your support provider.\n");
 760         pr_err("This is not a software error! Something bad happened to\n");
 761         pr_err("your hardware or EEPROM image. Ignoring this problem could\n");
 762         pr_err("result in further problems, possibly loss of data,\n");
 763         pr_err("corruption or system hangs!\n");
 764         pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n");
 765         pr_err("which is invalid and requires you to set the proper MAC\n");
 766         pr_err("address manually before continuing to enable this network\n");
 767         pr_err("device. Please inspect the EEPROM dump and report the\n");
 768         pr_err("issue to your hardware vendor or Intel Customer Support.\n");
 769         pr_err("/*********************/\n");
 770
 771         kfree(data);
 772 }
 773
 774 /**
 775  * e1000_is_need_ioport - determine if an adapter needs ioport resources or not
 776  * @pdev: PCI device information struct
 777  *
 778  * Return true if an adapter needs ioport resources
 779  **/
 780 static int e1000_is_need_ioport(struct pci_dev *pdev)
 781 {
 782         switch (pdev->device) {
 783         case E1000_DEV_ID_82540EM:
 784         case E1000_DEV_ID_82540EM_LOM:
 785         case E1000_DEV_ID_82540EP:
 786         case E1000_DEV_ID_82540EP_LOM:
 787         case E1000_DEV_ID_82540EP_LP:
 788         case E1000_DEV_ID_82541EI:
 789         case E1000_DEV_ID_82541EI_MOBILE:
 790         case E1000_DEV_ID_82541ER:
 791         case E1000_DEV_ID_82541ER_LOM:
 792         case E1000_DEV_ID_82541GI:
 793         case E1000_DEV_ID_82541GI_LF:
 794         case E1000_DEV_ID_82541GI_MOBILE:
 795         case E1000_DEV_ID_82544EI_COPPER:
 796         case E1000_DEV_ID_82544EI_FIBER:
 797         case E1000_DEV_ID_82544GC_COPPER:
 798         case E1000_DEV_ID_82544GC_LOM:
 799         case E1000_DEV_ID_82545EM_COPPER:
 800         case E1000_DEV_ID_82545EM_FIBER:
 801         case E1000_DEV_ID_82546EB_COPPER:
 802         case E1000_DEV_ID_82546EB_FIBER:
 803         case E1000_DEV_ID_82546EB_QUAD_COPPER:
 804                 return true;
 805         default:
 806                 return false;
 807         }
 808 }
 809
 810 static netdev_features_t e1000_fix_features(struct net_device *netdev,
 811         netdev_features_t features)
 812 {
 813         /*
 814          * Since there is no support for separate rx/tx vlan accel
 815          * enable/disable make sure tx flag is always in same state as rx.
 816          */
 817         if (features & NETIF_F_HW_VLAN_RX)
 818                 features |= NETIF_F_HW_VLAN_TX;
 819         else
 820                 features &= ~NETIF_F_HW_VLAN_TX;
 821
 822         return features;
 823 }
 824
 825 static int e1000_set_features(struct net_device *netdev,
 826         netdev_features_t features)
 827 {
 828         struct e1000_adapter *adapter = netdev_priv(netdev);
 829         netdev_features_t changed = features ^ netdev->features;
 830
 831         if (changed & NETIF_F_HW_VLAN_RX)
 832                 e1000_vlan_mode(netdev, features);
 833
 834         if (!(changed & NETIF_F_RXCSUM))
 835                 return 0;
 836
 837         adapter->rx_csum = !!(features & NETIF_F_RXCSUM);
 838
 839         if (netif_running(netdev))
 840                 e1000_reinit_locked(adapter);
 841         else
 842                 e1000_reset(adapter);
 843
 844         return 0;
 845 }
 846
 847 static const struct net_device_ops e1000_netdev_ops = {
 848         .ndo_open               = e1000_open,
 849         .ndo_stop               = e1000_close,
 850         .ndo_start_xmit         = e1000_xmit_frame,
 851         .ndo_get_stats          = e1000_get_stats,
 852         .ndo_set_rx_mode        = e1000_set_rx_mode,
 853         .ndo_set_mac_address    = e1000_set_mac,
 854         .ndo_tx_timeout         = e1000_tx_timeout,
 855         .ndo_change_mtu         = e1000_change_mtu,
 856         .ndo_do_ioctl           = e1000_ioctl,
 857         .ndo_validate_addr      = eth_validate_addr,
 858         .ndo_vlan_rx_add_vid    = e1000_vlan_rx_add_vid,
 859         .ndo_vlan_rx_kill_vid   = e1000_vlan_rx_kill_vid,
 860 #ifdef CONFIG_NET_POLL_CONTROLLER
 861         .ndo_poll_controller    = e1000_netpoll,
 862 #endif
 863         .ndo_fix_features       = e1000_fix_features,
 864         .ndo_set_features       = e1000_set_features,
 865 };
 866
 867 /**
 868  * e1000_init_hw_struct - initialize members of hw struct
 869  * @adapter: board private struct
 870  * @hw: structure used by e1000_hw.c
 871  *
 872  * Factors out initialization of the e1000_hw struct to its own function
 873  * that can be called very early at init (just after struct allocation).
 874  * Fields are initialized based on PCI device information and
 875  * OS network device settings (MTU size).
 876  * Returns negative error codes if MAC type setup fails.
 877  */
 878 static int e1000_init_hw_struct(struct e1000_adapter *adapter,
 879                                 struct e1000_hw *hw)
 880 {
 881         struct pci_dev *pdev = adapter->pdev;
 882
 883         /* PCI config space info */
 884         hw->vendor_id = pdev->vendor;
 885         hw->device_id = pdev->device;
 886         hw->subsystem_vendor_id = pdev->subsystem_vendor;
 887         hw->subsystem_id = pdev->subsystem_device;
 888         hw->revision_id = pdev->revision;
 889
 890         pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
 891
 892         hw->max_frame_size = adapter->netdev->mtu +
 893                              ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
 894         hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
 895
 896         /* identify the MAC */
 897         if (e1000_set_mac_type(hw)) {
 898                 e_err(probe, "Unknown MAC Type\n");
 899                 return -EIO;
 900         }
 901
 902         switch (hw->mac_type) {
 903         default:
 904                 break;
 905         case e1000_82541:
 906         case e1000_82547:
 907         case e1000_82541_rev_2:
 908         case e1000_82547_rev_2:
 909                 hw->phy_init_script = 1;
 910                 break;
 911         }
 912
 913         e1000_set_media_type(hw);
 914         e1000_get_bus_info(hw);
 915
 916         hw->wait_autoneg_complete = false;
 917         hw->tbi_compatibility_en = true;
 918         hw->adaptive_ifs = true;
 919
 920         /* Copper options */
 921
 922         if (hw->media_type == e1000_media_type_copper) {
 923                 hw->mdix = AUTO_ALL_MODES;
 924                 hw->disable_polarity_correction = false;
 925                 hw->master_slave = E1000_MASTER_SLAVE;
 926         }
 927
 928         return 0;
 929 }
 930
 931 /**
 932  * e1000_probe - Device Initialization Routine
 933  * @pdev: PCI device information struct
 934  * @ent: entry in e1000_pci_tbl
 935  *
 936  * Returns 0 on success, negative on failure
 937  *
 938  * e1000_probe initializes an adapter identified by a pci_dev structure.
 939  * The OS initialization, configuring of the adapter private structure,
 940  * and a hardware reset occur.
 941  **/
 942 static int __devinit e1000_probe(struct pci_dev *pdev,
 943                                  const struct pci_device_id *ent)
 944 {
 945         struct net_device *netdev;
 946         struct e1000_adapter *adapter;
 947         struct e1000_hw *hw;
 948
 949         static int cards_found = 0;
 950         static int global_quad_port_a = 0; /* global ksp3 port a indication */
 951         int i, err, pci_using_dac;
 952         u16 eeprom_data = 0;
 953         u16 tmp = 0;
 954         u16 eeprom_apme_mask = E1000_EEPROM_APME;
 955         int bars, need_ioport;
 956
 957         /* do not allocate ioport bars when not needed */
 958         need_ioport = e1000_is_need_ioport(pdev);
 959         if (need_ioport) {
 960                 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
 961                 err = pci_enable_device(pdev);
 962         } else {
 963                 bars = pci_select_bars(pdev, IORESOURCE_MEM);
 964                 err = pci_enable_device_mem(pdev);
 965         }
 966         if (err)
 967                 return err;
 968
 969         err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
 970         if (err)
 971                 goto err_pci_reg;
 972
 973         pci_set_master(pdev);
 974         err = pci_save_state(pdev);
 975         if (err)
 976                 goto err_alloc_etherdev;
 977
 978         err = -ENOMEM;
 979         netdev = alloc_etherdev(sizeof(struct e1000_adapter));
 980         if (!netdev)
 981                 goto err_alloc_etherdev;
 982
 983         SET_NETDEV_DEV(netdev, &pdev->dev);
 984
 985         pci_set_drvdata(pdev, netdev);
 986         adapter = netdev_priv(netdev);
 987         adapter->netdev = netdev;
 988         adapter->pdev = pdev;
 989         adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 990         adapter->bars = bars;
 991         adapter->need_ioport = need_ioport;
 992
 993         hw = &adapter->hw;
 994         hw->back = adapter;
 995
 996         err = -EIO;
 997         hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
 998         if (!hw->hw_addr)
 999                 goto err_ioremap;
1000
1001         if (adapter->need_ioport) {
1002                 for (i = BAR_1; i <= BAR_5; i++) {
1003                         if (pci_resource_len(pdev, i) == 0)
1004                                 continue;
1005                         if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
1006                                 hw->io_base = pci_resource_start(pdev, i);
1007                                 break;
1008                         }
1009                 }
1010         }
1011
1012         /* make ready for any if (hw->...) below */
1013         err = e1000_init_hw_struct(adapter, hw);
1014         if (err)
1015                 goto err_sw_init;
1016
1017         /*
1018          * there is a workaround being applied below that limits
1019          * 64-bit DMA addresses to 64-bit hardware.  There are some
1020          * 32-bit adapters that Tx hang when given 64-bit DMA addresses
1021          */
1022         pci_using_dac = 0;
1023         if ((hw->bus_type == e1000_bus_type_pcix) &&
1024             !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
1025                 /*
1026                  * according to DMA-API-HOWTO, coherent calls will always
1027                  * succeed if the set call did
1028                  */
1029                 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
1030                 pci_using_dac = 1;
1031         } else {
1032                 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
1033                 if (err) {
1034                         pr_err("No usable DMA config, aborting\n");
1035                         goto err_dma;
1036                 }
1037                 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
1038         }
1039
1040         netdev->netdev_ops = &e1000_netdev_ops;
1041         e1000_set_ethtool_ops(netdev);
1042         netdev->watchdog_timeo = 5 * HZ;
1043         netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
1044
1045         strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
1046
1047         adapter->bd_number = cards_found;
1048
1049         /* setup the private structure */
1050
1051         err = e1000_sw_init(adapter);
1052         if (err)
1053                 goto err_sw_init;
1054
1055         err = -EIO;
1056         if (hw->mac_type == e1000_ce4100) {
1057                 hw->ce4100_gbe_mdio_base_virt =
1058                                         ioremap(pci_resource_start(pdev, BAR_1),
1059                                                 pci_resource_len(pdev, BAR_1));
1060
1061                 if (!hw->ce4100_gbe_mdio_base_virt)
1062                         goto err_mdio_ioremap;
1063         }
1064
1065         if (hw->mac_type >= e1000_82543) {
1066                 netdev->hw_features = NETIF_F_SG |
1067                                    NETIF_F_HW_CSUM |
1068                                    NETIF_F_HW_VLAN_RX;
1069                 netdev->features = NETIF_F_HW_VLAN_TX |
1070                                    NETIF_F_HW_VLAN_FILTER;
1071         }
1072
1073         if ((hw->mac_type >= e1000_82544) &&
1074            (hw->mac_type != e1000_82547))
1075                 netdev->hw_features |= NETIF_F_TSO;
1076
1077         netdev->priv_flags |= IFF_SUPP_NOFCS;
1078
1079         netdev->features |= netdev->hw_features;
1080         netdev->hw_features |= NETIF_F_RXCSUM;
1081         netdev->hw_features |= 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         netdev->vlan_features |= NETIF_F_HW_CSUM;
1090         netdev->vlan_features |= 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         ew32(RCTL, rctl);
1849 }
1850
1851 /**
1852  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
1853  * @adapter: board private structure
1854  *
1855  * Configure the Rx unit of the MAC after a reset.
1856  **/
1857
1858 static void e1000_configure_rx(struct e1000_adapter *adapter)
1859 {
1860         u64 rdba;
1861         struct e1000_hw *hw = &adapter->hw;
1862         u32 rdlen, rctl, rxcsum;
1863
1864         if (adapter->netdev->mtu > ETH_DATA_LEN) {
1865                 rdlen = adapter->rx_ring[0].count *
1866                         sizeof(struct e1000_rx_desc);
1867                 adapter->clean_rx = e1000_clean_jumbo_rx_irq;
1868                 adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
1869         } else {
1870                 rdlen = adapter->rx_ring[0].count *
1871                         sizeof(struct e1000_rx_desc);
1872                 adapter->clean_rx = e1000_clean_rx_irq;
1873                 adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
1874         }
1875
1876         /* disable receives while setting up the descriptors */
1877         rctl = er32(RCTL);
1878         ew32(RCTL, rctl & ~E1000_RCTL_EN);
1879
1880         /* set the Receive Delay Timer Register */
1881         ew32(RDTR, adapter->rx_int_delay);
1882
1883         if (hw->mac_type >= e1000_82540) {
1884                 ew32(RADV, adapter->rx_abs_int_delay);
1885                 if (adapter->itr_setting != 0)
1886                         ew32(ITR, 1000000000 / (adapter->itr * 256));
1887         }
1888
1889         /* Setup the HW Rx Head and Tail Descriptor Pointers and
1890          * the Base and Length of the Rx Descriptor Ring */
1891         switch (adapter->num_rx_queues) {
1892         case 1:
1893         default:
1894                 rdba = adapter->rx_ring[0].dma;
1895                 ew32(RDLEN, rdlen);
1896                 ew32(RDBAH, (rdba >> 32));
1897                 ew32(RDBAL, (rdba & 0x00000000ffffffffULL));
1898                 ew32(RDT, 0);
1899                 ew32(RDH, 0);
1900                 adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? E1000_RDH : E1000_82542_RDH);
1901                 adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? E1000_RDT : E1000_82542_RDT);
1902                 break;
1903         }
1904
1905         /* Enable 82543 Receive Checksum Offload for TCP and UDP */
1906         if (hw->mac_type >= e1000_82543) {
1907                 rxcsum = er32(RXCSUM);
1908                 if (adapter->rx_csum)
1909                         rxcsum |= E1000_RXCSUM_TUOFL;
1910                 else
1911                         /* don't need to clear IPPCSE as it defaults to 0 */
1912                         rxcsum &= ~E1000_RXCSUM_TUOFL;
1913                 ew32(RXCSUM, rxcsum);
1914         }
1915
1916         /* Enable Receives */
1917         ew32(RCTL, rctl | E1000_RCTL_EN);
1918 }
1919
1920 /**
1921  * e1000_free_tx_resources - Free Tx Resources per Queue
1922  * @adapter: board private structure
1923  * @tx_ring: Tx descriptor ring for a specific queue
1924  *
1925  * Free all transmit software resources
1926  **/
1927
1928 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
1929                                     struct e1000_tx_ring *tx_ring)
1930 {
1931         struct pci_dev *pdev = adapter->pdev;
1932
1933         e1000_clean_tx_ring(adapter, tx_ring);
1934
1935         vfree(tx_ring->buffer_info);
1936         tx_ring->buffer_info = NULL;
1937
1938         dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
1939                           tx_ring->dma);
1940
1941         tx_ring->desc = NULL;
1942 }
1943
1944 /**
1945  * e1000_free_all_tx_resources - Free Tx Resources for All Queues
1946  * @adapter: board private structure
1947  *
1948  * Free all transmit software resources
1949  **/
1950
1951 void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
1952 {
1953         int i;
1954
1955         for (i = 0; i < adapter->num_tx_queues; i++)
1956                 e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
1957 }
1958
1959 static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
1960                                              struct e1000_buffer *buffer_info)
1961 {
1962         if (buffer_info->dma) {
1963                 if (buffer_info->mapped_as_page)
1964                         dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
1965                                        buffer_info->length, DMA_TO_DEVICE);
1966                 else
1967                         dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
1968                                          buffer_info->length,
1969                                          DMA_TO_DEVICE);
1970                 buffer_info->dma = 0;
1971         }
1972         if (buffer_info->skb) {
1973                 dev_kfree_skb_any(buffer_info->skb);
1974                 buffer_info->skb = NULL;
1975         }
1976         buffer_info->time_stamp = 0;
1977         /* buffer_info must be completely set up in the transmit path */
1978 }
1979
1980 /**
1981  * e1000_clean_tx_ring - Free Tx Buffers
1982  * @adapter: board private structure
1983  * @tx_ring: ring to be cleaned
1984  **/
1985
1986 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
1987                                 struct e1000_tx_ring *tx_ring)
1988 {
1989         struct e1000_hw *hw = &adapter->hw;
1990         struct e1000_buffer *buffer_info;
1991         unsigned long size;
1992         unsigned int i;
1993
1994         /* Free all the Tx ring sk_buffs */
1995
1996         for (i = 0; i < tx_ring->count; i++) {
1997                 buffer_info = &tx_ring->buffer_info[i];
1998                 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
1999         }
2000
2001         size = sizeof(struct e1000_buffer) * tx_ring->count;
2002         memset(tx_ring->buffer_info, 0, size);
2003
2004         /* Zero out the descriptor ring */
2005
2006         memset(tx_ring->desc, 0, tx_ring->size);
2007
2008         tx_ring->next_to_use = 0;
2009         tx_ring->next_to_clean = 0;
2010         tx_ring->last_tx_tso = false;
2011
2012         writel(0, hw->hw_addr + tx_ring->tdh);
2013         writel(0, hw->hw_addr + tx_ring->tdt);
2014 }
2015
2016 /**
2017  * e1000_clean_all_tx_rings - Free Tx Buffers for all queues
2018  * @adapter: board private structure
2019  **/
2020
2021 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
2022 {
2023         int i;
2024
2025         for (i = 0; i < adapter->num_tx_queues; i++)
2026                 e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
2027 }
2028
2029 /**
2030  * e1000_free_rx_resources - Free Rx Resources
2031  * @adapter: board private structure
2032  * @rx_ring: ring to clean the resources from
2033  *
2034  * Free all receive software resources
2035  **/
2036
2037 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
2038                                     struct e1000_rx_ring *rx_ring)
2039 {
2040         struct pci_dev *pdev = adapter->pdev;
2041
2042         e1000_clean_rx_ring(adapter, rx_ring);
2043
2044         vfree(rx_ring->buffer_info);
2045         rx_ring->buffer_info = NULL;
2046
2047         dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
2048                           rx_ring->dma);
2049
2050         rx_ring->desc = NULL;
2051 }
2052
2053 /**
2054  * e1000_free_all_rx_resources - Free Rx Resources for All Queues
2055  * @adapter: board private structure
2056  *
2057  * Free all receive software resources
2058  **/
2059
2060 void e1000_free_all_rx_resources(struct e1000_adapter *adapter)
2061 {
2062         int i;
2063
2064         for (i = 0; i < adapter->num_rx_queues; i++)
2065                 e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
2066 }
2067
2068 /**
2069  * e1000_clean_rx_ring - Free Rx Buffers per Queue
2070  * @adapter: board private structure
2071  * @rx_ring: ring to free buffers from
2072  **/
2073
2074 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
2075                                 struct e1000_rx_ring *rx_ring)
2076 {
2077         struct e1000_hw *hw = &adapter->hw;
2078         struct e1000_buffer *buffer_info;
2079         struct pci_dev *pdev = adapter->pdev;
2080         unsigned long size;
2081         unsigned int i;
2082
2083         /* Free all the Rx ring sk_buffs */
2084         for (i = 0; i < rx_ring->count; i++) {
2085                 buffer_info = &rx_ring->buffer_info[i];
2086                 if (buffer_info->dma &&
2087                     adapter->clean_rx == e1000_clean_rx_irq) {
2088                         dma_unmap_single(&pdev->dev, buffer_info->dma,
2089                                          buffer_info->length,
2090                                          DMA_FROM_DEVICE);
2091                 } else if (buffer_info->dma &&
2092                            adapter->clean_rx == e1000_clean_jumbo_rx_irq) {
2093                         dma_unmap_page(&pdev->dev, buffer_info->dma,
2094                                        buffer_info->length,
2095                                        DMA_FROM_DEVICE);
2096                 }
2097
2098                 buffer_info->dma = 0;
2099                 if (buffer_info->page) {
2100                         put_page(buffer_info->page);
2101                         buffer_info->page = NULL;
2102                 }
2103                 if (buffer_info->skb) {
2104                         dev_kfree_skb(buffer_info->skb);
2105                         buffer_info->skb = NULL;
2106                 }
2107         }
2108
2109         /* there also may be some cached data from a chained receive */
2110         if (rx_ring->rx_skb_top) {
2111                 dev_kfree_skb(rx_ring->rx_skb_top);
2112                 rx_ring->rx_skb_top = NULL;
2113         }
2114
2115         size = sizeof(struct e1000_buffer) * rx_ring->count;
2116         memset(rx_ring->buffer_info, 0, size);
2117
2118         /* Zero out the descriptor ring */
2119         memset(rx_ring->desc, 0, rx_ring->size);
2120
2121         rx_ring->next_to_clean = 0;
2122         rx_ring->next_to_use = 0;
2123
2124         writel(0, hw->hw_addr + rx_ring->rdh);
2125         writel(0, hw->hw_addr + rx_ring->rdt);
2126 }
2127
2128 /**
2129  * e1000_clean_all_rx_rings - Free Rx Buffers for all queues
2130  * @adapter: board private structure
2131  **/
2132
2133 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
2134 {
2135         int i;
2136
2137         for (i = 0; i < adapter->num_rx_queues; i++)
2138                 e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
2139 }
2140
2141 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
2142  * and memory write and invalidate disabled for certain operations
2143  */
2144 static void e1000_enter_82542_rst(struct e1000_adapter *adapter)
2145 {
2146         struct e1000_hw *hw = &adapter->hw;
2147         struct net_device *netdev = adapter->netdev;
2148         u32 rctl;
2149
2150         e1000_pci_clear_mwi(hw);
2151
2152         rctl = er32(RCTL);
2153         rctl |= E1000_RCTL_RST;
2154         ew32(RCTL, rctl);
2155         E1000_WRITE_FLUSH();
2156         mdelay(5);
2157
2158         if (netif_running(netdev))
2159                 e1000_clean_all_rx_rings(adapter);
2160 }
2161
2162 static void e1000_leave_82542_rst(struct e1000_adapter *adapter)
2163 {
2164         struct e1000_hw *hw = &adapter->hw;
2165         struct net_device *netdev = adapter->netdev;
2166         u32 rctl;
2167
2168         rctl = er32(RCTL);
2169         rctl &= ~E1000_RCTL_RST;
2170         ew32(RCTL, rctl);
2171         E1000_WRITE_FLUSH();
2172         mdelay(5);
2173
2174         if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
2175                 e1000_pci_set_mwi(hw);
2176
2177         if (netif_running(netdev)) {
2178                 /* No need to loop, because 82542 supports only 1 queue */
2179                 struct e1000_rx_ring *ring = &adapter->rx_ring[0];
2180                 e1000_configure_rx(adapter);
2181                 adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
2182         }
2183 }
2184
2185 /**
2186  * e1000_set_mac - Change the Ethernet Address of the NIC
2187  * @netdev: network interface device structure
2188  * @p: pointer to an address structure
2189  *
2190  * Returns 0 on success, negative on failure
2191  **/
2192
2193 static int e1000_set_mac(struct net_device *netdev, void *p)
2194 {
2195         struct e1000_adapter *adapter = netdev_priv(netdev);
2196         struct e1000_hw *hw = &adapter->hw;
2197         struct sockaddr *addr = p;
2198
2199         if (!is_valid_ether_addr(addr->sa_data))
2200                 return -EADDRNOTAVAIL;
2201
2202         /* 82542 2.0 needs to be in reset to write receive address registers */
2203
2204         if (hw->mac_type == e1000_82542_rev2_0)
2205                 e1000_enter_82542_rst(adapter);
2206
2207         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
2208         memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
2209
2210         e1000_rar_set(hw, hw->mac_addr, 0);
2211
2212         if (hw->mac_type == e1000_82542_rev2_0)
2213                 e1000_leave_82542_rst(adapter);
2214
2215         return 0;
2216 }
2217
2218 /**
2219  * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
2220  * @netdev: network interface device structure
2221  *
2222  * The set_rx_mode entry point is called whenever the unicast or multicast
2223  * address lists or the network interface flags are updated. This routine is
2224  * responsible for configuring the hardware for proper unicast, multicast,
2225  * promiscuous mode, and all-multi behavior.
2226  **/
2227
2228 static void e1000_set_rx_mode(struct net_device *netdev)
2229 {
2230         struct e1000_adapter *adapter = netdev_priv(netdev);
2231         struct e1000_hw *hw = &adapter->hw;
2232         struct netdev_hw_addr *ha;
2233         bool use_uc = false;
2234         u32 rctl;
2235         u32 hash_value;
2236         int i, rar_entries = E1000_RAR_ENTRIES;
2237         int mta_reg_count = E1000_NUM_MTA_REGISTERS;
2238         u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);
2239
2240         if (!mcarray) {
2241                 e_err(probe, "memory allocation failed\n");
2242                 return;
2243         }
2244
2245         /* Check for Promiscuous and All Multicast modes */
2246
2247         rctl = er32(RCTL);
2248
2249         if (netdev->flags & IFF_PROMISC) {
2250                 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
2251                 rctl &= ~E1000_RCTL_VFE;
2252         } else {
2253                 if (netdev->flags & IFF_ALLMULTI)
2254                         rctl |= E1000_RCTL_MPE;
2255                 else
2256                         rctl &= ~E1000_RCTL_MPE;
2257                 /* Enable VLAN filter if there is a VLAN */
2258                 if (e1000_vlan_used(adapter))
2259                         rctl |= E1000_RCTL_VFE;
2260         }
2261
2262         if (netdev_uc_count(netdev) > rar_entries - 1) {
2263                 rctl |= E1000_RCTL_UPE;
2264         } else if (!(netdev->flags & IFF_PROMISC)) {
2265                 rctl &= ~E1000_RCTL_UPE;
2266                 use_uc = true;
2267         }
2268
2269         ew32(RCTL, rctl);
2270
2271         /* 82542 2.0 needs to be in reset to write receive address registers */
2272
2273         if (hw->mac_type == e1000_82542_rev2_0)
2274                 e1000_enter_82542_rst(adapter);
2275
2276         /* load the first 14 addresses into the exact filters 1-14. Unicast
2277          * addresses take precedence to avoid disabling unicast filtering
2278          * when possible.
2279          *
2280          * RAR 0 is used for the station MAC address
2281          * if there are not 14 addresses, go ahead and clear the filters
2282          */
2283         i = 1;
2284         if (use_uc)
2285                 netdev_for_each_uc_addr(ha, netdev) {
2286                         if (i == rar_entries)
2287                                 break;
2288                         e1000_rar_set(hw, ha->addr, i++);
2289                 }
2290
2291         netdev_for_each_mc_addr(ha, netdev) {
2292                 if (i == rar_entries) {
2293                         /* load any remaining addresses into the hash table */
2294                         u32 hash_reg, hash_bit, mta;
2295                         hash_value = e1000_hash_mc_addr(hw, ha->addr);
2296                         hash_reg = (hash_value >> 5) & 0x7F;
2297                         hash_bit = hash_value & 0x1F;
2298                         mta = (1 << hash_bit);
2299                         mcarray[hash_reg] |= mta;
2300                 } else {
2301                         e1000_rar_set(hw, ha->addr, i++);
2302                 }
2303         }
2304
2305         for (; i < rar_entries; i++) {
2306                 E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
2307                 E1000_WRITE_FLUSH();
2308                 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
2309                 E1000_WRITE_FLUSH();
2310         }
2311
2312         /* write the hash table completely, write from bottom to avoid
2313          * both stupid write combining chipsets, and flushing each write */
2314         for (i = mta_reg_count - 1; i >= 0 ; i--) {
2315                 /*
2316                  * If we are on an 82544 has an errata where writing odd
2317                  * offsets overwrites the previous even offset, but writing
2318                  * backwards over the range solves the issue by always
2319                  * writing the odd offset first
2320                  */
2321                 E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]);
2322         }
2323         E1000_WRITE_FLUSH();
2324
2325         if (hw->mac_type == e1000_82542_rev2_0)
2326                 e1000_leave_82542_rst(adapter);
2327
2328         kfree(mcarray);
2329 }
2330
2331 /**
2332  * e1000_update_phy_info_task - get phy info
2333  * @work: work struct contained inside adapter struct
2334  *
2335  * Need to wait a few seconds after link up to get diagnostic information from
2336  * the phy
2337  */
2338 static void e1000_update_phy_info_task(struct work_struct *work)
2339 {
2340         struct e1000_adapter *adapter = container_of(work,
2341                                                      struct e1000_adapter,
2342                                                      phy_info_task.work);
2343         if (test_bit(__E1000_DOWN, &adapter->flags))
2344                 return;
2345         mutex_lock(&adapter->mutex);
2346         e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
2347         mutex_unlock(&adapter->mutex);
2348 }
2349
2350 /**
2351  * e1000_82547_tx_fifo_stall_task - task to complete work
2352  * @work: work struct contained inside adapter struct
2353  **/
2354 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work)
2355 {
2356         struct e1000_adapter *adapter = container_of(work,
2357                                                      struct e1000_adapter,
2358                                                      fifo_stall_task.work);
2359         struct e1000_hw *hw = &adapter->hw;
2360         struct net_device *netdev = adapter->netdev;
2361         u32 tctl;
2362
2363         if (test_bit(__E1000_DOWN, &adapter->flags))
2364                 return;
2365         mutex_lock(&adapter->mutex);
2366         if (atomic_read(&adapter->tx_fifo_stall)) {
2367                 if ((er32(TDT) == er32(TDH)) &&
2368                    (er32(TDFT) == er32(TDFH)) &&
2369                    (er32(TDFTS) == er32(TDFHS))) {
2370                         tctl = er32(TCTL);
2371                         ew32(TCTL, tctl & ~E1000_TCTL_EN);
2372                         ew32(TDFT, adapter->tx_head_addr);
2373                         ew32(TDFH, adapter->tx_head_addr);
2374                         ew32(TDFTS, adapter->tx_head_addr);
2375                         ew32(TDFHS, adapter->tx_head_addr);
2376                         ew32(TCTL, tctl);
2377                         E1000_WRITE_FLUSH();
2378
2379                         adapter->tx_fifo_head = 0;
2380                         atomic_set(&adapter->tx_fifo_stall, 0);
2381                         netif_wake_queue(netdev);
2382                 } else if (!test_bit(__E1000_DOWN, &adapter->flags)) {
2383                         schedule_delayed_work(&adapter->fifo_stall_task, 1);
2384                 }
2385         }
2386         mutex_unlock(&adapter->mutex);
2387 }
2388
2389 bool e1000_has_link(struct e1000_adapter *adapter)
2390 {
2391         struct e1000_hw *hw = &adapter->hw;
2392         bool link_active = false;
2393
2394         /* get_link_status is set on LSC (link status) interrupt or rx
2395          * sequence error interrupt (except on intel ce4100).
2396          * get_link_status will stay false until the
2397          * e1000_check_for_link establishes link for copper adapters
2398          * ONLY
2399          */
2400         switch (hw->media_type) {
2401         case e1000_media_type_copper:
2402                 if (hw->mac_type == e1000_ce4100)
2403                         hw->get_link_status = 1;
2404                 if (hw->get_link_status) {
2405                         e1000_check_for_link(hw);
2406                         link_active = !hw->get_link_status;
2407                 } else {
2408                         link_active = true;
2409                 }
2410                 break;
2411         case e1000_media_type_fiber:
2412                 e1000_check_for_link(hw);
2413                 link_active = !!(er32(STATUS) & E1000_STATUS_LU);
2414                 break;
2415         case e1000_media_type_internal_serdes:
2416                 e1000_check_for_link(hw);
2417                 link_active = hw->serdes_has_link;
2418                 break;
2419         default:
2420                 break;
2421         }
2422
2423         return link_active;
2424 }
2425
2426 /**
2427  * e1000_watchdog - work function
2428  * @work: work struct contained inside adapter struct
2429  **/
2430 static void e1000_watchdog(struct work_struct *work)
2431 {
2432         struct e1000_adapter *adapter = container_of(work,
2433                                                      struct e1000_adapter,
2434                                                      watchdog_task.work);
2435         struct e1000_hw *hw = &adapter->hw;
2436         struct net_device *netdev = adapter->netdev;
2437         struct e1000_tx_ring *txdr = adapter->tx_ring;
2438         u32 link, tctl;
2439
2440         if (test_bit(__E1000_DOWN, &adapter->flags))
2441                 return;
2442
2443         mutex_lock(&adapter->mutex);
2444         link = e1000_has_link(adapter);
2445         if ((netif_carrier_ok(netdev)) && link)
2446                 goto link_up;
2447
2448         if (link) {
2449                 if (!netif_carrier_ok(netdev)) {
2450                         u32 ctrl;
2451                         bool txb2b = true;
2452                         /* update snapshot of PHY registers on LSC */
2453                         e1000_get_speed_and_duplex(hw,
2454                                                    &adapter->link_speed,
2455                                                    &adapter->link_duplex);
2456
2457                         ctrl = er32(CTRL);
2458                         pr_info("%s NIC Link is Up %d Mbps %s, "
2459                                 "Flow Control: %s\n",
2460                                 netdev->name,
2461                                 adapter->link_speed,
2462                                 adapter->link_duplex == FULL_DUPLEX ?
2463                                 "Full Duplex" : "Half Duplex",
2464                                 ((ctrl & E1000_CTRL_TFCE) && (ctrl &
2465                                 E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
2466                                 E1000_CTRL_RFCE) ? "RX" : ((ctrl &
2467                                 E1000_CTRL_TFCE) ? "TX" : "None")));
2468
2469                         /* adjust timeout factor according to speed/duplex */
2470                         adapter->tx_timeout_factor = 1;
2471                         switch (adapter->link_speed) {
2472                         case SPEED_10:
2473                                 txb2b = false;
2474                                 adapter->tx_timeout_factor = 16;
2475                                 break;
2476                         case SPEED_100:
2477                                 txb2b = false;
2478                                 /* maybe add some timeout factor ? */
2479                                 break;
2480                         }
2481
2482                         /* enable transmits in the hardware */
2483                         tctl = er32(TCTL);
2484                         tctl |= E1000_TCTL_EN;
2485                         ew32(TCTL, tctl);
2486
2487                         netif_carrier_on(netdev);
2488                         if (!test_bit(__E1000_DOWN, &adapter->flags))
2489                                 schedule_delayed_work(&adapter->phy_info_task,
2490                                                       2 * HZ);
2491                         adapter->smartspeed = 0;
2492                 }
2493         } else {
2494                 if (netif_carrier_ok(netdev)) {
2495                         adapter->link_speed = 0;
2496                         adapter->link_duplex = 0;
2497                         pr_info("%s NIC Link is Down\n",
2498                                 netdev->name);
2499                         netif_carrier_off(netdev);
2500
2501                         if (!test_bit(__E1000_DOWN, &adapter->flags))
2502                                 schedule_delayed_work(&adapter->phy_info_task,
2503                                                       2 * HZ);
2504                 }
2505
2506                 e1000_smartspeed(adapter);
2507         }
2508
2509 link_up:
2510         e1000_update_stats(adapter);
2511
2512         hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
2513         adapter->tpt_old = adapter->stats.tpt;
2514         hw->collision_delta = adapter->stats.colc - adapter->colc_old;
2515         adapter->colc_old = adapter->stats.colc;
2516
2517         adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
2518         adapter->gorcl_old = adapter->stats.gorcl;
2519         adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
2520         adapter->gotcl_old = adapter->stats.gotcl;
2521
2522         e1000_update_adaptive(hw);
2523
2524         if (!netif_carrier_ok(netdev)) {
2525                 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
2526                         /* We've lost link, so the controller stops DMA,
2527                          * but we've got queued Tx work that's never going
2528                          * to get done, so reset controller to flush Tx.
2529                          * (Do the reset outside of interrupt context). */
2530                         adapter->tx_timeout_count++;
2531                         schedule_work(&adapter->reset_task);
2532                         /* exit immediately since reset is imminent */
2533                         goto unlock;
2534                 }
2535         }
2536
2537         /* Simple mode for Interrupt Throttle Rate (ITR) */
2538         if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
2539                 /*
2540                  * Symmetric Tx/Rx gets a reduced ITR=2000;
2541                  * Total asymmetrical Tx or Rx gets ITR=8000;
2542                  * everyone else is between 2000-8000.
2543                  */
2544                 u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
2545                 u32 dif = (adapter->gotcl > adapter->gorcl ?
2546                             adapter->gotcl - adapter->gorcl :
2547                             adapter->gorcl - adapter->gotcl) / 10000;
2548                 u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
2549
2550                 ew32(ITR, 1000000000 / (itr * 256));
2551         }
2552
2553         /* Cause software interrupt to ensure rx ring is cleaned */
2554         ew32(ICS, E1000_ICS_RXDMT0);
2555
2556         /* Force detection of hung controller every watchdog period */
2557         adapter->detect_tx_hung = true;
2558
2559         /* Reschedule the task */
2560         if (!test_bit(__E1000_DOWN, &adapter->flags))
2561                 schedule_delayed_work(&adapter->watchdog_task, 2 * HZ);
2562
2563 unlock:
2564         mutex_unlock(&adapter->mutex);
2565 }
2566
2567 enum latency_range {
2568         lowest_latency = 0,
2569         low_latency = 1,
2570         bulk_latency = 2,
2571         latency_invalid = 255
2572 };
2573
2574 /**
2575  * e1000_update_itr - update the dynamic ITR value based on statistics
2576  * @adapter: pointer to adapter
2577  * @itr_setting: current adapter->itr
2578  * @packets: the number of packets during this measurement interval
2579  * @bytes: the number of bytes during this measurement interval
2580  *
2581  *      Stores a new ITR value based on packets and byte
2582  *      counts during the last interrupt.  The advantage of per interrupt
2583  *      computation is faster updates and more accurate ITR for the current
2584  *      traffic pattern.  Constants in this function were computed
2585  *      based on theoretical maximum wire speed and thresholds were set based
2586  *      on testing data as well as attempting to minimize response time
2587  *      while increasing bulk throughput.
2588  *      this functionality is controlled by the InterruptThrottleRate module
2589  *      parameter (see e1000_param.c)
2590  **/
2591 static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
2592                                      u16 itr_setting, int packets, int bytes)
2593 {
2594         unsigned int retval = itr_setting;
2595         struct e1000_hw *hw = &adapter->hw;
2596
2597         if (unlikely(hw->mac_type < e1000_82540))
2598                 goto update_itr_done;
2599
2600         if (packets == 0)
2601                 goto update_itr_done;
2602
2603         switch (itr_setting) {
2604         case lowest_latency:
2605                 /* jumbo frames get bulk treatment*/
2606                 if (bytes/packets > 8000)
2607                         retval = bulk_latency;
2608                 else if ((packets < 5) && (bytes > 512))
2609                         retval = low_latency;
2610                 break;
2611         case low_latency:  /* 50 usec aka 20000 ints/s */
2612                 if (bytes > 10000) {
2613                         /* jumbo frames need bulk latency setting */
2614                         if (bytes/packets > 8000)
2615                                 retval = bulk_latency;
2616                         else if ((packets < 10) || ((bytes/packets) > 1200))
2617                                 retval = bulk_latency;
2618                         else if ((packets > 35))
2619                                 retval = lowest_latency;
2620                 } else if (bytes/packets > 2000)
2621                         retval = bulk_latency;
2622                 else if (packets <= 2 && bytes < 512)
2623                         retval = lowest_latency;
2624                 break;
2625         case bulk_latency: /* 250 usec aka 4000 ints/s */
2626                 if (bytes > 25000) {
2627                         if (packets > 35)
2628                                 retval = low_latency;
2629                 } else if (bytes < 6000) {
2630                         retval = low_latency;
2631                 }
2632                 break;
2633         }
2634
2635 update_itr_done:
2636         return retval;
2637 }
2638
2639 static void e1000_set_itr(struct e1000_adapter *adapter)
2640 {
2641         struct e1000_hw *hw = &adapter->hw;
2642         u16 current_itr;
2643         u32 new_itr = adapter->itr;
2644
2645         if (unlikely(hw->mac_type < e1000_82540))
2646                 return;
2647
2648         /* for non-gigabit speeds, just fix the interrupt rate at 4000 */
2649         if (unlikely(adapter->link_speed != SPEED_1000)) {
2650                 current_itr = 0;
2651                 new_itr = 4000;
2652                 goto set_itr_now;
2653         }
2654
2655         adapter->tx_itr = e1000_update_itr(adapter,
2656                                     adapter->tx_itr,
2657                                     adapter->total_tx_packets,
2658                                     adapter->total_tx_bytes);
2659         /* conservative mode (itr 3) eliminates the lowest_latency setting */
2660         if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
2661                 adapter->tx_itr = low_latency;
2662
2663         adapter->rx_itr = e1000_update_itr(adapter,
2664                                     adapter->rx_itr,
2665                                     adapter->total_rx_packets,
2666                                     adapter->total_rx_bytes);
2667         /* conservative mode (itr 3) eliminates the lowest_latency setting */
2668         if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
2669                 adapter->rx_itr = low_latency;
2670
2671         current_itr = max(adapter->rx_itr, adapter->tx_itr);
2672
2673         switch (current_itr) {
2674         /* counts and packets in update_itr are dependent on these numbers */
2675         case lowest_latency:
2676                 new_itr = 70000;
2677                 break;
2678         case low_latency:
2679                 new_itr = 20000; /* aka hwitr = ~200 */
2680                 break;
2681         case bulk_latency:
2682                 new_itr = 4000;
2683                 break;
2684         default:
2685                 break;
2686         }
2687
2688 set_itr_now:
2689         if (new_itr != adapter->itr) {
2690                 /* this attempts to bias the interrupt rate towards Bulk
2691                  * by adding intermediate steps when interrupt rate is
2692                  * increasing */
2693                 new_itr = new_itr > adapter->itr ?
2694                              min(adapter->itr + (new_itr >> 2), new_itr) :
2695                              new_itr;
2696                 adapter->itr = new_itr;
2697                 ew32(ITR, 1000000000 / (new_itr * 256));
2698         }
2699 }
2700
2701 #define E1000_TX_FLAGS_CSUM             0x00000001
2702 #define E1000_TX_FLAGS_VLAN             0x00000002
2703 #define E1000_TX_FLAGS_TSO              0x00000004
2704 #define E1000_TX_FLAGS_IPV4             0x00000008
2705 #define E1000_TX_FLAGS_NO_FCS           0x00000010
2706 #define E1000_TX_FLAGS_VLAN_MASK        0xffff0000
2707 #define E1000_TX_FLAGS_VLAN_SHIFT       16
2708
2709 static int e1000_tso(struct e1000_adapter *adapter,
2710                      struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
2711 {
2712         struct e1000_context_desc *context_desc;
2713         struct e1000_buffer *buffer_info;
2714         unsigned int i;
2715         u32 cmd_length = 0;
2716         u16 ipcse = 0, tucse, mss;
2717         u8 ipcss, ipcso, tucss, tucso, hdr_len;
2718         int err;
2719
2720         if (skb_is_gso(skb)) {
2721                 if (skb_header_cloned(skb)) {
2722                         err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2723                         if (err)
2724                                 return err;
2725                 }
2726
2727                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
2728                 mss = skb_shinfo(skb)->gso_size;
2729                 if (skb->protocol == htons(ETH_P_IP)) {
2730                         struct iphdr *iph = ip_hdr(skb);
2731                         iph->tot_len = 0;
2732                         iph->check = 0;
2733                         tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
2734                                                                  iph->daddr, 0,
2735                                                                  IPPROTO_TCP,
2736                                                                  0);
2737                         cmd_length = E1000_TXD_CMD_IP;
2738                         ipcse = skb_transport_offset(skb) - 1;
2739                 } else if (skb->protocol == htons(ETH_P_IPV6)) {
2740                         ipv6_hdr(skb)->payload_len = 0;
2741                         tcp_hdr(skb)->check =
2742                                 ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
2743                                                  &ipv6_hdr(skb)->daddr,
2744                                                  0, IPPROTO_TCP, 0);
2745                         ipcse = 0;
2746                 }
2747                 ipcss = skb_network_offset(skb);
2748                 ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
2749                 tucss = skb_transport_offset(skb);
2750                 tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
2751                 tucse = 0;
2752
2753                 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
2754                                E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
2755
2756                 i = tx_ring->next_to_use;
2757                 context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
2758                 buffer_info = &tx_ring->buffer_info[i];
2759
2760                 context_desc->lower_setup.ip_fields.ipcss  = ipcss;
2761                 context_desc->lower_setup.ip_fields.ipcso  = ipcso;
2762                 context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
2763                 context_desc->upper_setup.tcp_fields.tucss = tucss;
2764                 context_desc->upper_setup.tcp_fields.tucso = tucso;
2765                 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
2766                 context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
2767                 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
2768                 context_desc->cmd_and_length = cpu_to_le32(cmd_length);
2769
2770                 buffer_info->time_stamp = jiffies;
2771                 buffer_info->next_to_watch = i;
2772
2773                 if (++i == tx_ring->count) i = 0;
2774                 tx_ring->next_to_use = i;
2775
2776                 return true;
2777         }
2778         return false;
2779 }
2780
2781 static bool e1000_tx_csum(struct e1000_adapter *adapter,
2782                           struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
2783 {
2784         struct e1000_context_desc *context_desc;
2785         struct e1000_buffer *buffer_info;
2786         unsigned int i;
2787         u8 css;
2788         u32 cmd_len = E1000_TXD_CMD_DEXT;
2789
2790         if (skb->ip_summed != CHECKSUM_PARTIAL)
2791                 return false;
2792
2793         switch (skb->protocol) {
2794         case cpu_to_be16(ETH_P_IP):
2795                 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
2796                         cmd_len |= E1000_TXD_CMD_TCP;
2797                 break;
2798         case cpu_to_be16(ETH_P_IPV6):
2799                 /* XXX not handling all IPV6 headers */
2800                 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
2801                         cmd_len |= E1000_TXD_CMD_TCP;
2802                 break;
2803         default:
2804                 if (unlikely(net_ratelimit()))
2805                         e_warn(drv, "checksum_partial proto=%x!\n",
2806                                skb->protocol);
2807                 break;
2808         }
2809
2810         css = skb_checksum_start_offset(skb);
2811
2812         i = tx_ring->next_to_use;
2813         buffer_info = &tx_ring->buffer_info[i];
2814         context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
2815
2816         context_desc->lower_setup.ip_config = 0;
2817         context_desc->upper_setup.tcp_fields.tucss = css;
2818         context_desc->upper_setup.tcp_fields.tucso =
2819                 css + skb->csum_offset;
2820         context_desc->upper_setup.tcp_fields.tucse = 0;
2821         context_desc->tcp_seg_setup.data = 0;
2822         context_desc->cmd_and_length = cpu_to_le32(cmd_len);
2823
2824         buffer_info->time_stamp = jiffies;
2825         buffer_info->next_to_watch = i;
2826
2827         if (unlikely(++i == tx_ring->count)) i = 0;
2828         tx_ring->next_to_use = i;
2829
2830         return true;
2831 }
2832
2833 #define E1000_MAX_TXD_PWR       12
2834 #define E1000_MAX_DATA_PER_TXD  (1<<E1000_MAX_TXD_PWR)
2835
2836 static int e1000_tx_map(struct e1000_adapter *adapter,
2837                         struct e1000_tx_ring *tx_ring,
2838                         struct sk_buff *skb, unsigned int first,
2839                         unsigned int max_per_txd, unsigned int nr_frags,
2840                         unsigned int mss)
2841 {
2842         struct e1000_hw *hw = &adapter->hw;
2843         struct pci_dev *pdev = adapter->pdev;
2844         struct e1000_buffer *buffer_info;
2845         unsigned int len = skb_headlen(skb);
2846         unsigned int offset = 0, size, count = 0, i;
2847         unsigned int f, bytecount, segs;
2848
2849         i = tx_ring->next_to_use;
2850
2851         while (len) {
2852                 buffer_info = &tx_ring->buffer_info[i];
2853                 size = min(len, max_per_txd);
2854                 /* Workaround for Controller erratum --
2855                  * descriptor for non-tso packet in a linear SKB that follows a
2856                  * tso gets written back prematurely before the data is fully
2857                  * DMA'd to the controller */
2858                 if (!skb->data_len && tx_ring->last_tx_tso &&
2859                     !skb_is_gso(skb)) {
2860                         tx_ring->last_tx_tso = false;
2861                         size -= 4;
2862                 }
2863
2864                 /* Workaround for premature desc write-backs
2865                  * in TSO mode.  Append 4-byte sentinel desc */
2866                 if (unlikely(mss && !nr_frags && size == len && size > 8))
2867                         size -= 4;
2868                 /* work-around for errata 10 and it applies
2869                  * to all controllers in PCI-X mode
2870                  * The fix is to make sure that the first descriptor of a
2871                  * packet is smaller than 2048 - 16 - 16 (or 2016) bytes
2872                  */
2873                 if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
2874                                 (size > 2015) && count == 0))
2875                         size = 2015;
2876
2877                 /* Workaround for potential 82544 hang in PCI-X.  Avoid
2878                  * terminating buffers within evenly-aligned dwords. */
2879                 if (unlikely(adapter->pcix_82544 &&
2880                    !((unsigned long)(skb->data + offset + size - 1) & 4) &&
2881                    size > 4))
2882                         size -= 4;
2883
2884                 buffer_info->length = size;
2885                 /* set time_stamp *before* dma to help avoid a possible race */
2886                 buffer_info->time_stamp = jiffies;
2887                 buffer_info->mapped_as_page = false;
2888                 buffer_info->dma = dma_map_single(&pdev->dev,
2889                                                   skb->data + offset,
2890                                                   size, DMA_TO_DEVICE);
2891                 if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2892                         goto dma_error;
2893                 buffer_info->next_to_watch = i;
2894
2895                 len -= size;
2896                 offset += size;
2897                 count++;
2898                 if (len) {
2899                         i++;
2900                         if (unlikely(i == tx_ring->count))
2901                                 i = 0;
2902                 }
2903         }
2904
2905         for (f = 0; f < nr_frags; f++) {
2906                 const struct skb_frag_struct *frag;
2907
2908                 frag = &skb_shinfo(skb)->frags[f];
2909                 len = skb_frag_size(frag);
2910                 offset = 0;
2911
2912                 while (len) {
2913                         unsigned long bufend;
2914                         i++;
2915                         if (unlikely(i == tx_ring->count))
2916                                 i = 0;
2917
2918                         buffer_info = &tx_ring->buffer_info[i];
2919                         size = min(len, max_per_txd);
2920                         /* Workaround for premature desc write-backs
2921                          * in TSO mode.  Append 4-byte sentinel desc */
2922                         if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
2923                                 size -= 4;
2924                         /* Workaround for potential 82544 hang in PCI-X.
2925                          * Avoid terminating buffers within evenly-aligned
2926                          * dwords. */
2927                         bufend = (unsigned long)
2928                                 page_to_phys(skb_frag_page(frag));
2929                         bufend += offset + size - 1;
2930                         if (unlikely(adapter->pcix_82544 &&
2931                                      !(bufend & 4) &&
2932                                      size > 4))
2933                                 size -= 4;
2934
2935                         buffer_info->length = size;
2936                         buffer_info->time_stamp = jiffies;
2937                         buffer_info->mapped_as_page = true;
2938                         buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
2939                                                 offset, size, DMA_TO_DEVICE);
2940                         if (dma_mapping_error(&pdev->dev, buffer_info->dma))
2941                                 goto dma_error;
2942                         buffer_info->next_to_watch = i;
2943
2944                         len -= size;
2945                         offset += size;
2946                         count++;
2947                 }
2948         }
2949
2950         segs = skb_shinfo(skb)->gso_segs ?: 1;
2951         /* multiply data chunks by size of headers */
2952         bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len;
2953
2954         tx_ring->buffer_info[i].skb = skb;
2955         tx_ring->buffer_info[i].segs = segs;
2956         tx_ring->buffer_info[i].bytecount = bytecount;
2957         tx_ring->buffer_info[first].next_to_watch = i;
2958
2959         return count;
2960
2961 dma_error:
2962         dev_err(&pdev->dev, "TX DMA map failed\n");
2963         buffer_info->dma = 0;
2964         if (count)
2965                 count--;
2966
2967         while (count--) {
2968                 if (i==0)
2969                         i += tx_ring->count;
2970                 i--;
2971                 buffer_info = &tx_ring->buffer_info[i];
2972                 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
2973         }
2974
2975         return 0;
2976 }
2977
2978 static void e1000_tx_queue(struct e1000_adapter *adapter,
2979                            struct e1000_tx_ring *tx_ring, int tx_flags,
2980                            int count)
2981 {
2982         struct e1000_hw *hw = &adapter->hw;
2983         struct e1000_tx_desc *tx_desc = NULL;
2984         struct e1000_buffer *buffer_info;
2985         u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
2986         unsigned int i;
2987
2988         if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
2989                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
2990                              E1000_TXD_CMD_TSE;
2991                 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
2992
2993                 if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
2994                         txd_upper |= E1000_TXD_POPTS_IXSM << 8;
2995         }
2996
2997         if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
2998                 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
2999                 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
3000         }
3001
3002         if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
3003                 txd_lower |= E1000_TXD_CMD_VLE;
3004                 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
3005         }
3006
3007         if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
3008                 txd_lower &= ~(E1000_TXD_CMD_IFCS);
3009
3010         i = tx_ring->next_to_use;
3011
3012         while (count--) {
3013                 buffer_info = &tx_ring->buffer_info[i];
3014                 tx_desc = E1000_TX_DESC(*tx_ring, i);
3015                 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
3016                 tx_desc->lower.data =
3017                         cpu_to_le32(txd_lower | buffer_info->length);
3018                 tx_desc->upper.data = cpu_to_le32(txd_upper);
3019                 if (unlikely(++i == tx_ring->count)) i = 0;
3020         }
3021
3022         tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
3023
3024         /* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */
3025         if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
3026                 tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS));
3027
3028         /* Force memory writes to complete before letting h/w
3029          * know there are new descriptors to fetch.  (Only
3030          * applicable for weak-ordered memory model archs,
3031          * such as IA-64). */
3032         wmb();
3033
3034         tx_ring->next_to_use = i;
3035         writel(i, hw->hw_addr + tx_ring->tdt);
3036         /* we need this if more than one processor can write to our tail
3037          * at a time, it syncronizes IO on IA64/Altix systems */
3038         mmiowb();
3039 }
3040
3041 /**
3042  * 82547 workaround to avoid controller hang in half-duplex environment.
3043  * The workaround is to avoid queuing a large packet that would span
3044  * the internal Tx FIFO ring boundary by notifying the stack to resend
3045  * the packet at a later time.  This gives the Tx FIFO an opportunity to
3046  * flush all packets.  When that occurs, we reset the Tx FIFO pointers
3047  * to the beginning of the Tx FIFO.
3048  **/
3049
3050 #define E1000_FIFO_HDR                  0x10
3051 #define E1000_82547_PAD_LEN             0x3E0
3052
3053 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
3054                                        struct sk_buff *skb)
3055 {
3056         u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
3057         u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
3058
3059         skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
3060
3061         if (adapter->link_duplex != HALF_DUPLEX)
3062                 goto no_fifo_stall_required;
3063
3064         if (atomic_read(&adapter->tx_fifo_stall))
3065                 return 1;
3066
3067         if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
3068                 atomic_set(&adapter->tx_fifo_stall, 1);
3069                 return 1;
3070         }
3071
3072 no_fifo_stall_required:
3073         adapter->tx_fifo_head += skb_fifo_len;
3074         if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
3075                 adapter->tx_fifo_head -= adapter->tx_fifo_size;
3076         return 0;
3077 }
3078
3079 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
3080 {
3081         struct e1000_adapter *adapter = netdev_priv(netdev);
3082         struct e1000_tx_ring *tx_ring = adapter->tx_ring;
3083
3084         netif_stop_queue(netdev);
3085         /* Herbert's original patch had:
3086          *  smp_mb__after_netif_stop_queue();
3087          * but since that doesn't exist yet, just open code it. */
3088         smp_mb();
3089
3090         /* We need to check again in a case another CPU has just
3091          * made room available. */
3092         if (likely(E1000_DESC_UNUSED(tx_ring) < size))
3093                 return -EBUSY;
3094
3095         /* A reprieve! */
3096         netif_start_queue(netdev);
3097         ++adapter->restart_queue;
3098         return 0;
3099 }
3100
3101 static int e1000_maybe_stop_tx(struct net_device *netdev,
3102                                struct e1000_tx_ring *tx_ring, int size)
3103 {
3104         if (likely(E1000_DESC_UNUSED(tx_ring) >= size))
3105                 return 0;
3106         return __e1000_maybe_stop_tx(netdev, size);
3107 }
3108
3109 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
3110 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
3111                                     struct net_device *netdev)
3112 {
3113         struct e1000_adapter *adapter = netdev_priv(netdev);
3114         struct e1000_hw *hw = &adapter->hw;
3115         struct e1000_tx_ring *tx_ring;
3116         unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
3117         unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
3118         unsigned int tx_flags = 0;
3119         unsigned int len = skb_headlen(skb);
3120         unsigned int nr_frags;
3121         unsigned int mss;
3122         int count = 0;
3123         int tso;
3124         unsigned int f;
3125
3126         /* This goes back to the question of how to logically map a tx queue
3127          * to a flow.  Right now, performance is impacted slightly negatively
3128          * if using multiple tx queues.  If the stack breaks away from a
3129          * single qdisc implementation, we can look at this again. */
3130         tx_ring = adapter->tx_ring;
3131
3132         if (unlikely(skb->len <= 0)) {
3133                 dev_kfree_skb_any(skb);
3134                 return NETDEV_TX_OK;
3135         }
3136
3137         mss = skb_shinfo(skb)->gso_size;
3138         /* The controller does a simple calculation to
3139          * make sure there is enough room in the FIFO before
3140          * initiating the DMA for each buffer.  The calc is:
3141          * 4 = ceil(buffer len/mss).  To make sure we don't
3142          * overrun the FIFO, adjust the max buffer len if mss
3143          * drops. */
3144         if (mss) {
3145                 u8 hdr_len;
3146                 max_per_txd = min(mss << 2, max_per_txd);
3147                 max_txd_pwr = fls(max_per_txd) - 1;
3148
3149                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
3150                 if (skb->data_len && hdr_len == len) {
3151                         switch (hw->mac_type) {
3152                                 unsigned int pull_size;
3153                         case e1000_82544:
3154                                 /* Make sure we have room to chop off 4 bytes,
3155                                  * and that the end alignment will work out to
3156                                  * this hardware's requirements
3157                                  * NOTE: this is a TSO only workaround
3158                                  * if end byte alignment not correct move us
3159                                  * into the next dword */
3160                                 if ((unsigned long)(skb_tail_pointer(skb) - 1) & 4)
3161                                         break;
3162                                 /* fall through */
3163                                 pull_size = min((unsigned int)4, skb->data_len);
3164                                 if (!__pskb_pull_tail(skb, pull_size)) {
3165                                         e_err(drv, "__pskb_pull_tail "
3166                                               "failed.\n");
3167                                         dev_kfree_skb_any(skb);
3168                                         return NETDEV_TX_OK;
3169                                 }
3170                                 len = skb_headlen(skb);
3171                                 break;
3172                         default:
3173                                 /* do nothing */
3174                                 break;
3175                         }
3176                 }
3177         }
3178
3179         /* reserve a descriptor for the offload context */
3180         if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
3181                 count++;
3182         count++;
3183
3184         /* Controller Erratum workaround */
3185         if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb))
3186                 count++;
3187
3188         count += TXD_USE_COUNT(len, max_txd_pwr);
3189
3190         if (adapter->pcix_82544)
3191                 count++;
3192
3193         /* work-around for errata 10 and it applies to all controllers
3194          * in PCI-X mode, so add one more descriptor to the count
3195          */
3196         if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
3197                         (len > 2015)))
3198                 count++;
3199
3200         nr_frags = skb_shinfo(skb)->nr_frags;
3201         for (f = 0; f < nr_frags; f++)
3202                 count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]),
3203                                        max_txd_pwr);
3204         if (adapter->pcix_82544)
3205                 count += nr_frags;
3206
3207         /* need: count + 2 desc gap to keep tail from touching
3208          * head, otherwise try next time */
3209         if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
3210                 return NETDEV_TX_BUSY;
3211
3212         if (unlikely((hw->mac_type == e1000_82547) &&
3213                      (e1000_82547_fifo_workaround(adapter, skb)))) {
3214                 netif_stop_queue(netdev);
3215                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3216                         schedule_delayed_work(&adapter->fifo_stall_task, 1);
3217                 return NETDEV_TX_BUSY;
3218         }
3219
3220         if (vlan_tx_tag_present(skb)) {
3221                 tx_flags |= E1000_TX_FLAGS_VLAN;
3222                 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
3223         }
3224
3225         first = tx_ring->next_to_use;
3226
3227         tso = e1000_tso(adapter, tx_ring, skb);
3228         if (tso < 0) {
3229                 dev_kfree_skb_any(skb);
3230                 return NETDEV_TX_OK;
3231         }
3232
3233         if (likely(tso)) {
3234                 if (likely(hw->mac_type != e1000_82544))
3235                         tx_ring->last_tx_tso = true;
3236                 tx_flags |= E1000_TX_FLAGS_TSO;
3237         } else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
3238                 tx_flags |= E1000_TX_FLAGS_CSUM;
3239
3240         if (likely(skb->protocol == htons(ETH_P_IP)))
3241                 tx_flags |= E1000_TX_FLAGS_IPV4;
3242
3243         if (unlikely(skb->no_fcs))
3244                 tx_flags |= E1000_TX_FLAGS_NO_FCS;
3245
3246         count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd,
3247                              nr_frags, mss);
3248
3249         if (count) {
3250                 e1000_tx_queue(adapter, tx_ring, tx_flags, count);
3251                 /* Make sure there is space in the ring for the next send. */
3252                 e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
3253
3254         } else {
3255                 dev_kfree_skb_any(skb);
3256                 tx_ring->buffer_info[first].time_stamp = 0;
3257                 tx_ring->next_to_use = first;
3258         }
3259
3260         return NETDEV_TX_OK;
3261 }
3262
3263 #define NUM_REGS 38 /* 1 based count */
3264 static void e1000_regdump(struct e1000_adapter *adapter)
3265 {
3266         struct e1000_hw *hw = &adapter->hw;
3267         u32 regs[NUM_REGS];
3268         u32 *regs_buff = regs;
3269         int i = 0;
3270
3271         static const char * const reg_name[] = {
3272                 "CTRL",  "STATUS",
3273                 "RCTL", "RDLEN", "RDH", "RDT", "RDTR",
3274                 "TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT",
3275                 "TIDV", "TXDCTL", "TADV", "TARC0",
3276                 "TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1",
3277                 "TXDCTL1", "TARC1",
3278                 "CTRL_EXT", "ERT", "RDBAL", "RDBAH",
3279                 "TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC",
3280                 "RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC"
3281         };
3282
3283         regs_buff[0]  = er32(CTRL);
3284         regs_buff[1]  = er32(STATUS);
3285
3286         regs_buff[2]  = er32(RCTL);
3287         regs_buff[3]  = er32(RDLEN);
3288         regs_buff[4]  = er32(RDH);
3289         regs_buff[5]  = er32(RDT);
3290         regs_buff[6]  = er32(RDTR);
3291
3292         regs_buff[7]  = er32(TCTL);
3293         regs_buff[8]  = er32(TDBAL);
3294         regs_buff[9]  = er32(TDBAH);
3295         regs_buff[10] = er32(TDLEN);
3296         regs_buff[11] = er32(TDH);
3297         regs_buff[12] = er32(TDT);
3298         regs_buff[13] = er32(TIDV);
3299         regs_buff[14] = er32(TXDCTL);
3300         regs_buff[15] = er32(TADV);
3301         regs_buff[16] = er32(TARC0);
3302
3303         regs_buff[17] = er32(TDBAL1);
3304         regs_buff[18] = er32(TDBAH1);
3305         regs_buff[19] = er32(TDLEN1);
3306         regs_buff[20] = er32(TDH1);
3307         regs_buff[21] = er32(TDT1);
3308         regs_buff[22] = er32(TXDCTL1);
3309         regs_buff[23] = er32(TARC1);
3310         regs_buff[24] = er32(CTRL_EXT);
3311         regs_buff[25] = er32(ERT);
3312         regs_buff[26] = er32(RDBAL0);
3313         regs_buff[27] = er32(RDBAH0);
3314         regs_buff[28] = er32(TDFH);
3315         regs_buff[29] = er32(TDFT);
3316         regs_buff[30] = er32(TDFHS);
3317         regs_buff[31] = er32(TDFTS);
3318         regs_buff[32] = er32(TDFPC);
3319         regs_buff[33] = er32(RDFH);
3320         regs_buff[34] = er32(RDFT);
3321         regs_buff[35] = er32(RDFHS);
3322         regs_buff[36] = er32(RDFTS);
3323         regs_buff[37] = er32(RDFPC);
3324
3325         pr_info("Register dump\n");
3326         for (i = 0; i < NUM_REGS; i++)
3327                 pr_info("%-15s  %08x\n", reg_name[i], regs_buff[i]);
3328 }
3329
3330 /*
3331  * e1000_dump: Print registers, tx ring and rx ring
3332  */
3333 static void e1000_dump(struct e1000_adapter *adapter)
3334 {
3335         /* this code doesn't handle multiple rings */
3336         struct e1000_tx_ring *tx_ring = adapter->tx_ring;
3337         struct e1000_rx_ring *rx_ring = adapter->rx_ring;
3338         int i;
3339
3340         if (!netif_msg_hw(adapter))
3341                 return;
3342
3343         /* Print Registers */
3344         e1000_regdump(adapter);
3345
3346         /*
3347          * transmit dump
3348          */
3349         pr_info("TX Desc ring0 dump\n");
3350
3351         /* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)
3352          *
3353          * Legacy Transmit Descriptor
3354          *   +--------------------------------------------------------------+
3355          * 0 |         Buffer Address [63:0] (Reserved on Write Back)       |
3356          *   +--------------------------------------------------------------+
3357          * 8 | Special  |    CSS     | Status |  CMD    |  CSO   |  Length  |
3358          *   +--------------------------------------------------------------+
3359          *   63       48 47        36 35    32 31     24 23    16 15        0
3360          *
3361          * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload
3362          *   63      48 47    40 39       32 31             16 15    8 7      0
3363          *   +----------------------------------------------------------------+
3364          * 0 |  TUCSE  | TUCS0  |   TUCSS   |     IPCSE       | IPCS0 | IPCSS |
3365          *   +----------------------------------------------------------------+
3366          * 8 |   MSS   | HDRLEN | RSV | STA | TUCMD | DTYP |      PAYLEN      |
3367          *   +----------------------------------------------------------------+
3368          *   63      48 47    40 39 36 35 32 31   24 23  20 19                0
3369          *
3370          * Extended Data Descriptor (DTYP=0x1)
3371          *   +----------------------------------------------------------------+
3372          * 0 |                     Buffer Address [63:0]                      |
3373          *   +----------------------------------------------------------------+
3374          * 8 | VLAN tag |  POPTS  | Rsvd | Status | Command | DTYP |  DTALEN  |
3375          *   +----------------------------------------------------------------+
3376          *   63       48 47     40 39  36 35    32 31     24 23  20 19        0
3377          */
3378         pr_info("Tc[desc]     [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
3379         pr_info("Td[desc]     [address 63:0  ] [VlaPoRSCm1Dlen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
3380
3381         if (!netif_msg_tx_done(adapter))
3382                 goto rx_ring_summary;
3383
3384         for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {
3385                 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
3386                 struct e1000_buffer *buffer_info = &tx_ring->buffer_info[i];
3387                 struct my_u { __le64 a; __le64 b; };
3388                 struct my_u *u = (struct my_u *)tx_desc;
3389                 const char *type;
3390
3391                 if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)
3392                         type = "NTC/U";
3393                 else if (i == tx_ring->next_to_use)
3394                         type = "NTU";
3395                 else if (i == tx_ring->next_to_clean)
3396                         type = "NTC";
3397                 else
3398                         type = "";
3399
3400                 pr_info("T%c[0x%03X]    %016llX %016llX %016llX %04X  %3X %016llX %p %s\n",
3401                         ((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i,
3402                         le64_to_cpu(u->a), le64_to_cpu(u->b),
3403                         (u64)buffer_info->dma, buffer_info->length,
3404                         buffer_info->next_to_watch,
3405                         (u64)buffer_info->time_stamp, buffer_info->skb, type);
3406         }
3407
3408 rx_ring_summary:
3409         /*
3410          * receive dump
3411          */
3412         pr_info("\nRX Desc ring dump\n");
3413
3414         /* Legacy Receive Descriptor Format
3415          *
3416          * +-----------------------------------------------------+
3417          * |                Buffer Address [63:0]                |
3418          * +-----------------------------------------------------+
3419          * | VLAN Tag | Errors | Status 0 | Packet csum | Length |
3420          * +-----------------------------------------------------+
3421          * 63       48 47    40 39      32 31         16 15      0
3422          */
3423         pr_info("R[desc]      [address 63:0  ] [vl er S cks ln] [bi->dma       ] [bi->skb]\n");
3424
3425         if (!netif_msg_rx_status(adapter))
3426                 goto exit;
3427
3428         for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) {
3429                 struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i);
3430                 struct e1000_buffer *buffer_info = &rx_ring->buffer_info[i];
3431                 struct my_u { __le64 a; __le64 b; };
3432                 struct my_u *u = (struct my_u *)rx_desc;
3433                 const char *type;
3434
3435                 if (i == rx_ring->next_to_use)
3436                         type = "NTU";
3437                 else if (i == rx_ring->next_to_clean)
3438                         type = "NTC";
3439                 else
3440                         type = "";
3441
3442                 pr_info("R[0x%03X]     %016llX %016llX %016llX %p %s\n",
3443                         i, le64_to_cpu(u->a), le64_to_cpu(u->b),
3444                         (u64)buffer_info->dma, buffer_info->skb, type);
3445         } /* for */
3446
3447         /* dump the descriptor caches */
3448         /* rx */
3449         pr_info("Rx descriptor cache in 64bit format\n");
3450         for (i = 0x6000; i <= 0x63FF ; i += 0x10) {
3451                 pr_info("R%04X: %08X|%08X %08X|%08X\n",
3452                         i,
3453                         readl(adapter->hw.hw_addr + i+4),
3454                         readl(adapter->hw.hw_addr + i),
3455                         readl(adapter->hw.hw_addr + i+12),
3456                         readl(adapter->hw.hw_addr + i+8));
3457         }
3458         /* tx */
3459         pr_info("Tx descriptor cache in 64bit format\n");
3460         for (i = 0x7000; i <= 0x73FF ; i += 0x10) {
3461                 pr_info("T%04X: %08X|%08X %08X|%08X\n",
3462                         i,
3463                         readl(adapter->hw.hw_addr + i+4),
3464                         readl(adapter->hw.hw_addr + i),
3465                         readl(adapter->hw.hw_addr + i+12),
3466                         readl(adapter->hw.hw_addr + i+8));
3467         }
3468 exit:
3469         return;
3470 }
3471
3472 /**
3473  * e1000_tx_timeout - Respond to a Tx Hang
3474  * @netdev: network interface device structure
3475  **/
3476
3477 static void e1000_tx_timeout(struct net_device *netdev)
3478 {
3479         struct e1000_adapter *adapter = netdev_priv(netdev);
3480
3481         /* Do the reset outside of interrupt context */
3482         adapter->tx_timeout_count++;
3483         schedule_work(&adapter->reset_task);
3484 }
3485
3486 static void e1000_reset_task(struct work_struct *work)
3487 {
3488         struct e1000_adapter *adapter =
3489                 container_of(work, struct e1000_adapter, reset_task);
3490
3491         if (test_bit(__E1000_DOWN, &adapter->flags))
3492                 return;
3493         e_err(drv, "Reset adapter\n");
3494         e1000_reinit_safe(adapter);
3495 }
3496
3497 /**
3498  * e1000_get_stats - Get System Network Statistics
3499  * @netdev: network interface device structure
3500  *
3501  * Returns the address of the device statistics structure.
3502  * The statistics are actually updated from the watchdog.
3503  **/
3504
3505 static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
3506 {
3507         /* only return the current stats */
3508         return &netdev->stats;
3509 }
3510
3511 /**
3512  * e1000_change_mtu - Change the Maximum Transfer Unit
3513  * @netdev: network interface device structure
3514  * @new_mtu: new value for maximum frame size
3515  *
3516  * Returns 0 on success, negative on failure
3517  **/
3518
3519 static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
3520 {
3521         struct e1000_adapter *adapter = netdev_priv(netdev);
3522         struct e1000_hw *hw = &adapter->hw;
3523         int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
3524
3525         if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
3526             (max_frame > MAX_JUMBO_FRAME_SIZE)) {
3527                 e_err(probe, "Invalid MTU setting\n");
3528                 return -EINVAL;
3529         }
3530
3531         /* Adapter-specific max frame size limits. */
3532         switch (hw->mac_type) {
3533         case e1000_undefined ... e1000_82542_rev2_1:
3534                 if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
3535                         e_err(probe, "Jumbo Frames not supported.\n");
3536                         return -EINVAL;
3537                 }
3538                 break;
3539         default:
3540                 /* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
3541                 break;
3542         }
3543
3544         while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
3545                 msleep(1);
3546         /* e1000_down has a dependency on max_frame_size */
3547         hw->max_frame_size = max_frame;
3548         if (netif_running(netdev))
3549                 e1000_down(adapter);
3550
3551         /* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
3552          * means we reserve 2 more, this pushes us to allocate from the next
3553          * larger slab size.
3554          * i.e. RXBUFFER_2048 --> size-4096 slab
3555          *  however with the new *_jumbo_rx* routines, jumbo receives will use
3556          *  fragmented skbs */
3557
3558         if (max_frame <= E1000_RXBUFFER_2048)
3559                 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
3560         else
3561 #if (PAGE_SIZE >= E1000_RXBUFFER_16384)
3562                 adapter->rx_buffer_len = E1000_RXBUFFER_16384;
3563 #elif (PAGE_SIZE >= E1000_RXBUFFER_4096)
3564                 adapter->rx_buffer_len = PAGE_SIZE;
3565 #endif
3566
3567         /* adjust allocation if LPE protects us, and we aren't using SBP */
3568         if (!hw->tbi_compatibility_on &&
3569             ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) ||
3570              (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
3571                 adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
3572
3573         pr_info("%s changing MTU from %d to %d\n",
3574                 netdev->name, netdev->mtu, new_mtu);
3575         netdev->mtu = new_mtu;
3576
3577         if (netif_running(netdev))
3578                 e1000_up(adapter);
3579         else
3580                 e1000_reset(adapter);
3581
3582         clear_bit(__E1000_RESETTING, &adapter->flags);
3583
3584         return 0;
3585 }
3586
3587 /**
3588  * e1000_update_stats - Update the board statistics counters
3589  * @adapter: board private structure
3590  **/
3591
3592 void e1000_update_stats(struct e1000_adapter *adapter)
3593 {
3594         struct net_device *netdev = adapter->netdev;
3595         struct e1000_hw *hw = &adapter->hw;
3596         struct pci_dev *pdev = adapter->pdev;
3597         unsigned long flags;
3598         u16 phy_tmp;
3599
3600 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
3601
3602         /*
3603          * Prevent stats update while adapter is being reset, or if the pci
3604          * connection is down.
3605          */
3606         if (adapter->link_speed == 0)
3607                 return;
3608         if (pci_channel_offline(pdev))
3609                 return;
3610
3611         spin_lock_irqsave(&adapter->stats_lock, flags);
3612
3613         /* these counters are modified from e1000_tbi_adjust_stats,
3614          * called from the interrupt context, so they must only
3615          * be written while holding adapter->stats_lock
3616          */
3617
3618         adapter->stats.crcerrs += er32(CRCERRS);
3619         adapter->stats.gprc += er32(GPRC);
3620         adapter->stats.gorcl += er32(GORCL);
3621         adapter->stats.gorch += er32(GORCH);
3622         adapter->stats.bprc += er32(BPRC);
3623         adapter->stats.mprc += er32(MPRC);
3624         adapter->stats.roc += er32(ROC);
3625
3626         adapter->stats.prc64 += er32(PRC64);
3627         adapter->stats.prc127 += er32(PRC127);
3628         adapter->stats.prc255 += er32(PRC255);
3629         adapter->stats.prc511 += er32(PRC511);
3630         adapter->stats.prc1023 += er32(PRC1023);
3631         adapter->stats.prc1522 += er32(PRC1522);
3632
3633         adapter->stats.symerrs += er32(SYMERRS);
3634         adapter->stats.mpc += er32(MPC);
3635         adapter->stats.scc += er32(SCC);
3636         adapter->stats.ecol += er32(ECOL);
3637         adapter->stats.mcc += er32(MCC);
3638         adapter->stats.latecol += er32(LATECOL);
3639         adapter->stats.dc += er32(DC);
3640         adapter->stats.sec += er32(SEC);
3641         adapter->stats.rlec += er32(RLEC);
3642         adapter->stats.xonrxc += er32(XONRXC);
3643         adapter->stats.xontxc += er32(XONTXC);
3644         adapter->stats.xoffrxc += er32(XOFFRXC);
3645         adapter->stats.xofftxc += er32(XOFFTXC);
3646         adapter->stats.fcruc += er32(FCRUC);
3647         adapter->stats.gptc += er32(GPTC);
3648         adapter->stats.gotcl += er32(GOTCL);
3649         adapter->stats.gotch += er32(GOTCH);
3650         adapter->stats.rnbc += er32(RNBC);
3651         adapter->stats.ruc += er32(RUC);
3652         adapter->stats.rfc += er32(RFC);
3653         adapter->stats.rjc += er32(RJC);
3654         adapter->stats.torl += er32(TORL);
3655         adapter->stats.torh += er32(TORH);
3656         adapter->stats.totl += er32(TOTL);
3657         adapter->stats.toth += er32(TOTH);
3658         adapter->stats.tpr += er32(TPR);
3659
3660         adapter->stats.ptc64 += er32(PTC64);
3661         adapter->stats.ptc127 += er32(PTC127);
3662         adapter->stats.ptc255 += er32(PTC255);
3663         adapter->stats.ptc511 += er32(PTC511);
3664         adapter->stats.ptc1023 += er32(PTC1023);
3665         adapter->stats.ptc1522 += er32(PTC1522);
3666
3667         adapter->stats.mptc += er32(MPTC);
3668         adapter->stats.bptc += er32(BPTC);
3669
3670         /* used for adaptive IFS */
3671
3672         hw->tx_packet_delta = er32(TPT);
3673         adapter->stats.tpt += hw->tx_packet_delta;
3674         hw->collision_delta = er32(COLC);
3675         adapter->stats.colc += hw->collision_delta;
3676
3677         if (hw->mac_type >= e1000_82543) {
3678                 adapter->stats.algnerrc += er32(ALGNERRC);
3679                 adapter->stats.rxerrc += er32(RXERRC);
3680                 adapter->stats.tncrs += er32(TNCRS);
3681                 adapter->stats.cexterr += er32(CEXTERR);
3682                 adapter->stats.tsctc += er32(TSCTC);
3683                 adapter->stats.tsctfc += er32(TSCTFC);
3684         }
3685
3686         /* Fill out the OS statistics structure */
3687         netdev->stats.multicast = adapter->stats.mprc;
3688         netdev->stats.collisions = adapter->stats.colc;
3689
3690         /* Rx Errors */
3691
3692         /* RLEC on some newer hardware can be incorrect so build
3693         * our own version based on RUC and ROC */
3694         netdev->stats.rx_errors = adapter->stats.rxerrc +
3695                 adapter->stats.crcerrs + adapter->stats.algnerrc +
3696                 adapter->stats.ruc + adapter->stats.roc +
3697                 adapter->stats.cexterr;
3698         adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
3699         netdev->stats.rx_length_errors = adapter->stats.rlerrc;
3700         netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
3701         netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
3702         netdev->stats.rx_missed_errors = adapter->stats.mpc;
3703
3704         /* Tx Errors */
3705         adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
3706         netdev->stats.tx_errors = adapter->stats.txerrc;
3707         netdev->stats.tx_aborted_errors = adapter->stats.ecol;
3708         netdev->stats.tx_window_errors = adapter->stats.latecol;
3709         netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
3710         if (hw->bad_tx_carr_stats_fd &&
3711             adapter->link_duplex == FULL_DUPLEX) {
3712                 netdev->stats.tx_carrier_errors = 0;
3713                 adapter->stats.tncrs = 0;
3714         }
3715
3716         /* Tx Dropped needs to be maintained elsewhere */
3717
3718         /* Phy Stats */
3719         if (hw->media_type == e1000_media_type_copper) {
3720                 if ((adapter->link_speed == SPEED_1000) &&
3721                    (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
3722                         phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
3723                         adapter->phy_stats.idle_errors += phy_tmp;
3724                 }
3725
3726                 if ((hw->mac_type <= e1000_82546) &&
3727                    (hw->phy_type == e1000_phy_m88) &&
3728                    !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
3729                         adapter->phy_stats.receive_errors += phy_tmp;
3730         }
3731
3732         /* Management Stats */
3733         if (hw->has_smbus) {
3734                 adapter->stats.mgptc += er32(MGTPTC);
3735                 adapter->stats.mgprc += er32(MGTPRC);
3736                 adapter->stats.mgpdc += er32(MGTPDC);
3737         }
3738
3739         spin_unlock_irqrestore(&adapter->stats_lock, flags);
3740 }
3741
3742 /**
3743  * e1000_intr - Interrupt Handler
3744  * @irq: interrupt number
3745  * @data: pointer to a network interface device structure
3746  **/
3747
3748 static irqreturn_t e1000_intr(int irq, void *data)
3749 {
3750         struct net_device *netdev = data;
3751         struct e1000_adapter *adapter = netdev_priv(netdev);
3752         struct e1000_hw *hw = &adapter->hw;
3753         u32 icr = er32(ICR);
3754
3755         if (unlikely((!icr)))
3756                 return IRQ_NONE;  /* Not our interrupt */
3757
3758         /*
3759          * we might have caused the interrupt, but the above
3760          * read cleared it, and just in case the driver is
3761          * down there is nothing to do so return handled
3762          */
3763         if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
3764                 return IRQ_HANDLED;
3765
3766         if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
3767                 hw->get_link_status = 1;
3768                 /* guard against interrupt when we're going down */
3769                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3770                         schedule_delayed_work(&adapter->watchdog_task, 1);
3771         }
3772
3773         /* disable interrupts, without the synchronize_irq bit */
3774         ew32(IMC, ~0);
3775         E1000_WRITE_FLUSH();
3776
3777         if (likely(napi_schedule_prep(&adapter->napi))) {
3778                 adapter->total_tx_bytes = 0;
3779                 adapter->total_tx_packets = 0;
3780                 adapter->total_rx_bytes = 0;
3781                 adapter->total_rx_packets = 0;
3782                 __napi_schedule(&adapter->napi);
3783         } else {
3784                 /* this really should not happen! if it does it is basically a
3785                  * bug, but not a hard error, so enable ints and continue */
3786                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3787                         e1000_irq_enable(adapter);
3788         }
3789
3790         return IRQ_HANDLED;
3791 }
3792
3793 /**
3794  * e1000_clean - NAPI Rx polling callback
3795  * @adapter: board private structure
3796  **/
3797 static int e1000_clean(struct napi_struct *napi, int budget)
3798 {
3799         struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, napi);
3800         int tx_clean_complete = 0, work_done = 0;
3801
3802         tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
3803
3804         adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
3805
3806         if (!tx_clean_complete)
3807                 work_done = budget;
3808
3809         /* If budget not fully consumed, exit the polling mode */
3810         if (work_done < budget) {
3811                 if (likely(adapter->itr_setting & 3))
3812                         e1000_set_itr(adapter);
3813                 napi_complete(napi);
3814                 if (!test_bit(__E1000_DOWN, &adapter->flags))
3815                         e1000_irq_enable(adapter);
3816         }
3817
3818         return work_done;
3819 }
3820
3821 /**
3822  * e1000_clean_tx_irq - Reclaim resources after transmit completes
3823  * @adapter: board private structure
3824  **/
3825 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
3826                                struct e1000_tx_ring *tx_ring)
3827 {
3828         struct e1000_hw *hw = &adapter->hw;
3829         struct net_device *netdev = adapter->netdev;
3830         struct e1000_tx_desc *tx_desc, *eop_desc;
3831         struct e1000_buffer *buffer_info;
3832         unsigned int i, eop;
3833         unsigned int count = 0;
3834         unsigned int total_tx_bytes=0, total_tx_packets=0;
3835
3836         i = tx_ring->next_to_clean;
3837         eop = tx_ring->buffer_info[i].next_to_watch;
3838         eop_desc = E1000_TX_DESC(*tx_ring, eop);
3839
3840         while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
3841                (count < tx_ring->count)) {
3842                 bool cleaned = false;
3843                 rmb();  /* read buffer_info after eop_desc */
3844                 for ( ; !cleaned; count++) {
3845                         tx_desc = E1000_TX_DESC(*tx_ring, i);
3846                         buffer_info = &tx_ring->buffer_info[i];
3847                         cleaned = (i == eop);
3848
3849                         if (cleaned) {
3850                                 total_tx_packets += buffer_info->segs;
3851                                 total_tx_bytes += buffer_info->bytecount;
3852                         }
3853                         e1000_unmap_and_free_tx_resource(adapter, buffer_info);
3854                         tx_desc->upper.data = 0;
3855
3856                         if (unlikely(++i == tx_ring->count)) i = 0;
3857                 }
3858
3859                 eop = tx_ring->buffer_info[i].next_to_watch;
3860                 eop_desc = E1000_TX_DESC(*tx_ring, eop);
3861         }
3862
3863         tx_ring->next_to_clean = i;
3864
3865 #define TX_WAKE_THRESHOLD 32
3866         if (unlikely(count && netif_carrier_ok(netdev) &&
3867                      E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
3868                 /* Make sure that anybody stopping the queue after this
3869                  * sees the new next_to_clean.
3870                  */
3871                 smp_mb();
3872
3873                 if (netif_queue_stopped(netdev) &&
3874                     !(test_bit(__E1000_DOWN, &adapter->flags))) {
3875                         netif_wake_queue(netdev);
3876                         ++adapter->restart_queue;
3877                 }
3878         }
3879
3880         if (adapter->detect_tx_hung) {
3881                 /* Detect a transmit hang in hardware, this serializes the
3882                  * check with the clearing of time_stamp and movement of i */
3883                 adapter->detect_tx_hung = false;
3884                 if (tx_ring->buffer_info[eop].time_stamp &&
3885                     time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
3886                                (adapter->tx_timeout_factor * HZ)) &&
3887                     !(er32(STATUS) & E1000_STATUS_TXOFF)) {
3888
3889                         /* detected Tx unit hang */
3890                         e_err(drv, "Detected Tx Unit Hang\n"
3891                               "  Tx Queue             <%lu>\n"
3892                               "  TDH                  <%x>\n"
3893                               "  TDT                  <%x>\n"
3894                               "  next_to_use          <%x>\n"
3895                               "  next_to_clean        <%x>\n"
3896                               "buffer_info[next_to_clean]\n"
3897                               "  time_stamp           <%lx>\n"
3898                               "  next_to_watch        <%x>\n"
3899                               "  jiffies              <%lx>\n"
3900                               "  next_to_watch.status <%x>\n",
3901                                 (unsigned long)((tx_ring - adapter->tx_ring) /
3902                                         sizeof(struct e1000_tx_ring)),
3903                                 readl(hw->hw_addr + tx_ring->tdh),
3904                                 readl(hw->hw_addr + tx_ring->tdt),
3905                                 tx_ring->next_to_use,
3906                                 tx_ring->next_to_clean,
3907                                 tx_ring->buffer_info[eop].time_stamp,
3908                                 eop,
3909                                 jiffies,
3910                                 eop_desc->upper.fields.status);
3911                         e1000_dump(adapter);
3912                         netif_stop_queue(netdev);
3913                 }
3914         }
3915         adapter->total_tx_bytes += total_tx_bytes;
3916         adapter->total_tx_packets += total_tx_packets;
3917         netdev->stats.tx_bytes += total_tx_bytes;
3918         netdev->stats.tx_packets += total_tx_packets;
3919         return count < tx_ring->count;
3920 }
3921
3922 /**
3923  * e1000_rx_checksum - Receive Checksum Offload for 82543
3924  * @adapter:     board private structure
3925  * @status_err:  receive descriptor status and error fields
3926  * @csum:        receive descriptor csum field
3927  * @sk_buff:     socket buffer with received data
3928  **/
3929
3930 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
3931                               u32 csum, struct sk_buff *skb)
3932 {
3933         struct e1000_hw *hw = &adapter->hw;
3934         u16 status = (u16)status_err;
3935         u8 errors = (u8)(status_err >> 24);
3936
3937         skb_checksum_none_assert(skb);
3938
3939         /* 82543 or newer only */
3940         if (unlikely(hw->mac_type < e1000_82543)) return;
3941         /* Ignore Checksum bit is set */
3942         if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
3943         /* TCP/UDP checksum error bit is set */
3944         if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
3945                 /* let the stack verify checksum errors */
3946                 adapter->hw_csum_err++;
3947                 return;
3948         }
3949         /* TCP/UDP Checksum has not been calculated */
3950         if (!(status & E1000_RXD_STAT_TCPCS))
3951                 return;
3952
3953         /* It must be a TCP or UDP packet with a valid checksum */
3954         if (likely(status & E1000_RXD_STAT_TCPCS)) {
3955                 /* TCP checksum is good */
3956                 skb->ip_summed = CHECKSUM_UNNECESSARY;
3957         }
3958         adapter->hw_csum_good++;
3959 }
3960
3961 /**
3962  * e1000_consume_page - helper function
3963  **/
3964 static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
3965                                u16 length)
3966 {
3967         bi->page = NULL;
3968         skb->len += length;
3969         skb->data_len += length;
3970         skb->truesize += PAGE_SIZE;
3971 }
3972
3973 /**
3974  * e1000_receive_skb - helper function to handle rx indications
3975  * @adapter: board private structure
3976  * @status: descriptor status field as written by hardware
3977  * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
3978  * @skb: pointer to sk_buff to be indicated to stack
3979  */
3980 static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status,
3981                               __le16 vlan, struct sk_buff *skb)
3982 {
3983         skb->protocol = eth_type_trans(skb, adapter->netdev);
3984
3985         if (status & E1000_RXD_STAT_VP) {
3986                 u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
3987
3988                 __vlan_hwaccel_put_tag(skb, vid);
3989         }
3990         napi_gro_receive(&adapter->napi, skb);
3991 }
3992
3993 /**
3994  * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
3995  * @adapter: board private structure
3996  * @rx_ring: ring to clean
3997  * @work_done: amount of napi work completed this call
3998  * @work_to_do: max amount of work allowed for this call to do
3999  *
4000  * the return value indicates whether actual cleaning was done, there
4001  * is no guarantee that everything was cleaned
4002  */
4003 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
4004                                      struct e1000_rx_ring *rx_ring,
4005                                      int *work_done, int work_to_do)
4006 {
4007         struct e1000_hw *hw = &adapter->hw;
4008         struct net_device *netdev = adapter->netdev;
4009         struct pci_dev *pdev = adapter->pdev;
4010         struct e1000_rx_desc *rx_desc, *next_rxd;
4011         struct e1000_buffer *buffer_info, *next_buffer;
4012         unsigned long irq_flags;
4013         u32 length;
4014         unsigned int i;
4015         int cleaned_count = 0;
4016         bool cleaned = false;
4017         unsigned int total_rx_bytes=0, total_rx_packets=0;
4018
4019         i = rx_ring->next_to_clean;
4020         rx_desc = E1000_RX_DESC(*rx_ring, i);
4021         buffer_info = &rx_ring->buffer_info[i];
4022
4023         while (rx_desc->status & E1000_RXD_STAT_DD) {
4024                 struct sk_buff *skb;
4025                 u8 status;
4026
4027                 if (*work_done >= work_to_do)
4028                         break;
4029                 (*work_done)++;
4030                 rmb(); /* read descriptor and rx_buffer_info after status DD */
4031
4032                 status = rx_desc->status;
4033                 skb = buffer_info->skb;
4034                 buffer_info->skb = NULL;
4035
4036                 if (++i == rx_ring->count) i = 0;
4037                 next_rxd = E1000_RX_DESC(*rx_ring, i);
4038                 prefetch(next_rxd);
4039
4040                 next_buffer = &rx_ring->buffer_info[i];
4041
4042                 cleaned = true;
4043                 cleaned_count++;
4044                 dma_unmap_page(&pdev->dev, buffer_info->dma,
4045                                buffer_info->length, DMA_FROM_DEVICE);
4046                 buffer_info->dma = 0;
4047
4048                 length = le16_to_cpu(rx_desc->length);
4049
4050                 /* errors is only valid for DD + EOP descriptors */
4051                 if (unlikely((status & E1000_RXD_STAT_EOP) &&
4052                     (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
4053                         u8 last_byte = *(skb->data + length - 1);
4054                         if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
4055                                        last_byte)) {
4056                                 spin_lock_irqsave(&adapter->stats_lock,
4057                                                   irq_flags);
4058                                 e1000_tbi_adjust_stats(hw, &adapter->stats,
4059                                                        length, skb->data);
4060                                 spin_unlock_irqrestore(&adapter->stats_lock,
4061                                                        irq_flags);
4062                                 length--;
4063                         } else {
4064                                 /* recycle both page and skb */
4065                                 buffer_info->skb = skb;
4066                                 /* an error means any chain goes out the window
4067                                  * too */
4068                                 if (rx_ring->rx_skb_top)
4069                                         dev_kfree_skb(rx_ring->rx_skb_top);
4070                                 rx_ring->rx_skb_top = NULL;
4071                                 goto next_desc;
4072                         }
4073                 }
4074
4075 #define rxtop rx_ring->rx_skb_top
4076                 if (!(status & E1000_RXD_STAT_EOP)) {
4077                         /* this descriptor is only the beginning (or middle) */
4078                         if (!rxtop) {
4079                                 /* this is the beginning of a chain */
4080                                 rxtop = skb;
4081                                 skb_fill_page_desc(rxtop, 0, buffer_info->page,
4082                                                    0, length);
4083                         } else {
4084                                 /* this is the middle of a chain */
4085                                 skb_fill_page_desc(rxtop,
4086                                     skb_shinfo(rxtop)->nr_frags,
4087                                     buffer_info->page, 0, length);
4088                                 /* re-use the skb, only consumed the page */
4089                                 buffer_info->skb = skb;
4090                         }
4091                         e1000_consume_page(buffer_info, rxtop, length);
4092                         goto next_desc;
4093                 } else {
4094                         if (rxtop) {
4095                                 /* end of the chain */
4096                                 skb_fill_page_desc(rxtop,
4097                                     skb_shinfo(rxtop)->nr_frags,
4098                                     buffer_info->page, 0, length);
4099                                 /* re-use the current skb, we only consumed the
4100                                  * page */
4101                                 buffer_info->skb = skb;
4102                                 skb = rxtop;
4103                                 rxtop = NULL;
4104                                 e1000_consume_page(buffer_info, skb, length);
4105                         } else {
4106                                 /* no chain, got EOP, this buf is the packet
4107                                  * copybreak to save the put_page/alloc_page */
4108                                 if (length <= copybreak &&
4109                                     skb_tailroom(skb) >= length) {
4110                                         u8 *vaddr;
4111                                         vaddr = kmap_atomic(buffer_info->page);
4112                                         memcpy(skb_tail_pointer(skb), vaddr, length);
4113                                         kunmap_atomic(vaddr);
4114                                         /* re-use the page, so don't erase
4115                                          * buffer_info->page */
4116                                         skb_put(skb, length);
4117                                 } else {
4118                                         skb_fill_page_desc(skb, 0,
4119                                                            buffer_info->page, 0,
4120                                                            length);
4121                                         e1000_consume_page(buffer_info, skb,
4122                                                            length);
4123                                 }
4124                         }
4125                 }
4126
4127                 /* Receive Checksum Offload XXX recompute due to CRC strip? */
4128                 e1000_rx_checksum(adapter,
4129                                   (u32)(status) |
4130                                   ((u32)(rx_desc->errors) << 24),
4131                                   le16_to_cpu(rx_desc->csum), skb);
4132
4133                 total_rx_bytes += (skb->len - 4); /* don't count FCS */
4134                 if (likely(!(netdev->features & NETIF_F_RXFCS)))
4135                         pskb_trim(skb, skb->len - 4);
4136                 total_rx_packets++;
4137
4138                 /* eth type trans needs skb->data to point to something */
4139                 if (!pskb_may_pull(skb, ETH_HLEN)) {
4140                         e_err(drv, "pskb_may_pull failed.\n");
4141                         dev_kfree_skb(skb);
4142                         goto next_desc;
4143                 }
4144
4145                 e1000_receive_skb(adapter, status, rx_desc->special, skb);
4146
4147 next_desc:
4148                 rx_desc->status = 0;
4149
4150                 /* return some buffers to hardware, one at a time is too slow */
4151                 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
4152                         adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4153                         cleaned_count = 0;
4154                 }
4155
4156                 /* use prefetched values */
4157                 rx_desc = next_rxd;
4158                 buffer_info = next_buffer;
4159         }
4160         rx_ring->next_to_clean = i;
4161
4162         cleaned_count = E1000_DESC_UNUSED(rx_ring);
4163         if (cleaned_count)
4164                 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4165
4166         adapter->total_rx_packets += total_rx_packets;
4167         adapter->total_rx_bytes += total_rx_bytes;
4168         netdev->stats.rx_bytes += total_rx_bytes;
4169         netdev->stats.rx_packets += total_rx_packets;
4170         return cleaned;
4171 }
4172
4173 /*
4174  * this should improve performance for small packets with large amounts
4175  * of reassembly being done in the stack
4176  */
4177 static void e1000_check_copybreak(struct net_device *netdev,
4178                                  struct e1000_buffer *buffer_info,
4179                                  u32 length, struct sk_buff **skb)
4180 {
4181         struct sk_buff *new_skb;
4182
4183         if (length > copybreak)
4184                 return;
4185
4186         new_skb = netdev_alloc_skb_ip_align(netdev, length);
4187         if (!new_skb)
4188                 return;
4189
4190         skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
4191                                        (*skb)->data - NET_IP_ALIGN,
4192                                        length + NET_IP_ALIGN);
4193         /* save the skb in buffer_info as good */
4194         buffer_info->skb = *skb;
4195         *skb = new_skb;
4196 }
4197
4198 /**
4199  * e1000_clean_rx_irq - Send received data up the network stack; legacy
4200  * @adapter: board private structure
4201  * @rx_ring: ring to clean
4202  * @work_done: amount of napi work completed this call
4203  * @work_to_do: max amount of work allowed for this call to do
4204  */
4205 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
4206                                struct e1000_rx_ring *rx_ring,
4207                                int *work_done, int work_to_do)
4208 {
4209         struct e1000_hw *hw = &adapter->hw;
4210         struct net_device *netdev = adapter->netdev;
4211         struct pci_dev *pdev = adapter->pdev;
4212         struct e1000_rx_desc *rx_desc, *next_rxd;
4213         struct e1000_buffer *buffer_info, *next_buffer;
4214         unsigned long flags;
4215         u32 length;
4216         unsigned int i;
4217         int cleaned_count = 0;
4218         bool cleaned = false;
4219         unsigned int total_rx_bytes=0, total_rx_packets=0;
4220
4221         i = rx_ring->next_to_clean;
4222         rx_desc = E1000_RX_DESC(*rx_ring, i);
4223         buffer_info = &rx_ring->buffer_info[i];
4224
4225         while (rx_desc->status & E1000_RXD_STAT_DD) {
4226                 struct sk_buff *skb;
4227                 u8 status;
4228
4229                 if (*work_done >= work_to_do)
4230                         break;
4231                 (*work_done)++;
4232                 rmb(); /* read descriptor and rx_buffer_info after status DD */
4233
4234                 status = rx_desc->status;
4235                 skb = buffer_info->skb;
4236                 buffer_info->skb = NULL;
4237
4238                 prefetch(skb->data - NET_IP_ALIGN);
4239
4240                 if (++i == rx_ring->count) i = 0;
4241                 next_rxd = E1000_RX_DESC(*rx_ring, i);
4242                 prefetch(next_rxd);
4243
4244                 next_buffer = &rx_ring->buffer_info[i];
4245
4246                 cleaned = true;
4247                 cleaned_count++;
4248                 dma_unmap_single(&pdev->dev, buffer_info->dma,
4249                                  buffer_info->length, DMA_FROM_DEVICE);
4250                 buffer_info->dma = 0;
4251
4252                 length = le16_to_cpu(rx_desc->length);
4253                 /* !EOP means multiple descriptors were used to store a single
4254                  * packet, if thats the case we need to toss it.  In fact, we
4255                  * to toss every packet with the EOP bit clear and the next
4256                  * frame that _does_ have the EOP bit set, as it is by
4257                  * definition only a frame fragment
4258                  */
4259                 if (unlikely(!(status & E1000_RXD_STAT_EOP)))
4260                         adapter->discarding = true;
4261
4262                 if (adapter->discarding) {
4263                         /* All receives must fit into a single buffer */
4264                         e_dbg("Receive packet consumed multiple buffers\n");
4265                         /* recycle */
4266                         buffer_info->skb = skb;
4267                         if (status & E1000_RXD_STAT_EOP)
4268                                 adapter->discarding = false;
4269                         goto next_desc;
4270                 }
4271
4272                 if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
4273                         u8 last_byte = *(skb->data + length - 1);
4274                         if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
4275                                        last_byte)) {
4276                                 spin_lock_irqsave(&adapter->stats_lock, flags);
4277                                 e1000_tbi_adjust_stats(hw, &adapter->stats,
4278                                                        length, skb->data);
4279                                 spin_unlock_irqrestore(&adapter->stats_lock,
4280                                                        flags);
4281                                 length--;
4282                         } else {
4283                                 /* recycle */
4284                                 buffer_info->skb = skb;
4285                                 goto next_desc;
4286                         }
4287                 }
4288
4289                 total_rx_bytes += (length - 4); /* don't count FCS */
4290                 total_rx_packets++;
4291
4292                 if (likely(!(netdev->features & NETIF_F_RXFCS)))
4293                         /* adjust length to remove Ethernet CRC, this must be
4294                          * done after the TBI_ACCEPT workaround above
4295                          */
4296                         length -= 4;
4297
4298                 e1000_check_copybreak(netdev, buffer_info, length, &skb);
4299
4300                 skb_put(skb, length);
4301
4302                 /* Receive Checksum Offload */
4303                 e1000_rx_checksum(adapter,
4304                                   (u32)(status) |
4305                                   ((u32)(rx_desc->errors) << 24),
4306                                   le16_to_cpu(rx_desc->csum), skb);
4307
4308                 e1000_receive_skb(adapter, status, rx_desc->special, skb);
4309
4310 next_desc:
4311                 rx_desc->status = 0;
4312
4313                 /* return some buffers to hardware, one at a time is too slow */
4314                 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
4315                         adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4316                         cleaned_count = 0;
4317                 }
4318
4319                 /* use prefetched values */
4320                 rx_desc = next_rxd;
4321                 buffer_info = next_buffer;
4322         }
4323         rx_ring->next_to_clean = i;
4324
4325         cleaned_count = E1000_DESC_UNUSED(rx_ring);
4326         if (cleaned_count)
4327                 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
4328
4329         adapter->total_rx_packets += total_rx_packets;
4330         adapter->total_rx_bytes += total_rx_bytes;
4331         netdev->stats.rx_bytes += total_rx_bytes;
4332         netdev->stats.rx_packets += total_rx_packets;
4333         return cleaned;
4334 }
4335
4336 /**
4337  * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
4338  * @adapter: address of board private structure
4339  * @rx_ring: pointer to receive ring structure
4340  * @cleaned_count: number of buffers to allocate this pass
4341  **/
4342
4343 static void
4344 e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
4345                              struct e1000_rx_ring *rx_ring, int cleaned_count)
4346 {
4347         struct net_device *netdev = adapter->netdev;
4348         struct pci_dev *pdev = adapter->pdev;
4349         struct e1000_rx_desc *rx_desc;
4350         struct e1000_buffer *buffer_info;
4351         struct sk_buff *skb;
4352         unsigned int i;
4353         unsigned int bufsz = 256 - 16 /*for skb_reserve */ ;
4354
4355         i = rx_ring->next_to_use;
4356         buffer_info = &rx_ring->buffer_info[i];
4357
4358         while (cleaned_count--) {
4359                 skb = buffer_info->skb;
4360                 if (skb) {
4361                         skb_trim(skb, 0);
4362                         goto check_page;
4363                 }
4364
4365                 skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4366                 if (unlikely(!skb)) {
4367                         /* Better luck next round */
4368                         adapter->alloc_rx_buff_failed++;
4369                         break;
4370                 }
4371
4372                 /* Fix for errata 23, can't cross 64kB boundary */
4373                 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4374                         struct sk_buff *oldskb = skb;
4375                         e_err(rx_err, "skb align check failed: %u bytes at "
4376                               "%p\n", bufsz, skb->data);
4377                         /* Try again, without freeing the previous */
4378                         skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4379                         /* Failed allocation, critical failure */
4380                         if (!skb) {
4381                                 dev_kfree_skb(oldskb);
4382                                 adapter->alloc_rx_buff_failed++;
4383                                 break;
4384                         }
4385
4386                         if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4387                                 /* give up */
4388                                 dev_kfree_skb(skb);
4389                                 dev_kfree_skb(oldskb);
4390                                 break; /* while (cleaned_count--) */
4391                         }
4392
4393                         /* Use new allocation */
4394                         dev_kfree_skb(oldskb);
4395                 }
4396                 buffer_info->skb = skb;
4397                 buffer_info->length = adapter->rx_buffer_len;
4398 check_page:
4399                 /* allocate a new page if necessary */
4400                 if (!buffer_info->page) {
4401                         buffer_info->page = alloc_page(GFP_ATOMIC);
4402                         if (unlikely(!buffer_info->page)) {
4403                                 adapter->alloc_rx_buff_failed++;
4404                                 break;
4405                         }
4406                 }
4407
4408                 if (!buffer_info->dma) {
4409                         buffer_info->dma = dma_map_page(&pdev->dev,
4410                                                         buffer_info->page, 0,
4411                                                         buffer_info->length,
4412                                                         DMA_FROM_DEVICE);
4413                         if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4414                                 put_page(buffer_info->page);
4415                                 dev_kfree_skb(skb);
4416                                 buffer_info->page = NULL;
4417                                 buffer_info->skb = NULL;
4418                                 buffer_info->dma = 0;
4419                                 adapter->alloc_rx_buff_failed++;
4420                                 break; /* while !buffer_info->skb */
4421                         }
4422                 }
4423
4424                 rx_desc = E1000_RX_DESC(*rx_ring, i);
4425                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
4426
4427                 if (unlikely(++i == rx_ring->count))
4428                         i = 0;
4429                 buffer_info = &rx_ring->buffer_info[i];
4430         }
4431
4432         if (likely(rx_ring->next_to_use != i)) {
4433                 rx_ring->next_to_use = i;
4434                 if (unlikely(i-- == 0))
4435                         i = (rx_ring->count - 1);
4436
4437                 /* Force memory writes to complete before letting h/w
4438                  * know there are new descriptors to fetch.  (Only
4439                  * applicable for weak-ordered memory model archs,
4440                  * such as IA-64). */
4441                 wmb();
4442                 writel(i, adapter->hw.hw_addr + rx_ring->rdt);
4443         }
4444 }
4445
4446 /**
4447  * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
4448  * @adapter: address of board private structure
4449  **/
4450
4451 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
4452                                    struct e1000_rx_ring *rx_ring,
4453                                    int cleaned_count)
4454 {
4455         struct e1000_hw *hw = &adapter->hw;
4456         struct net_device *netdev = adapter->netdev;
4457         struct pci_dev *pdev = adapter->pdev;
4458         struct e1000_rx_desc *rx_desc;
4459         struct e1000_buffer *buffer_info;
4460         struct sk_buff *skb;
4461         unsigned int i;
4462         unsigned int bufsz = adapter->rx_buffer_len;
4463
4464         i = rx_ring->next_to_use;
4465         buffer_info = &rx_ring->buffer_info[i];
4466
4467         while (cleaned_count--) {
4468                 skb = buffer_info->skb;
4469                 if (skb) {
4470                         skb_trim(skb, 0);
4471                         goto map_skb;
4472                 }
4473
4474                 skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4475                 if (unlikely(!skb)) {
4476                         /* Better luck next round */
4477                         adapter->alloc_rx_buff_failed++;
4478                         break;
4479                 }
4480
4481                 /* Fix for errata 23, can't cross 64kB boundary */
4482                 if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4483                         struct sk_buff *oldskb = skb;
4484                         e_err(rx_err, "skb align check failed: %u bytes at "
4485                               "%p\n", bufsz, skb->data);
4486                         /* Try again, without freeing the previous */
4487                         skb = netdev_alloc_skb_ip_align(netdev, bufsz);
4488                         /* Failed allocation, critical failure */
4489                         if (!skb) {
4490                                 dev_kfree_skb(oldskb);
4491                                 adapter->alloc_rx_buff_failed++;
4492                                 break;
4493                         }
4494
4495                         if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
4496                                 /* give up */
4497                                 dev_kfree_skb(skb);
4498                                 dev_kfree_skb(oldskb);
4499                                 adapter->alloc_rx_buff_failed++;
4500                                 break; /* while !buffer_info->skb */
4501                         }
4502
4503                         /* Use new allocation */
4504                         dev_kfree_skb(oldskb);
4505                 }
4506                 buffer_info->skb = skb;
4507                 buffer_info->length = adapter->rx_buffer_len;
4508 map_skb:
4509                 buffer_info->dma = dma_map_single(&pdev->dev,
4510                                                   skb->data,
4511                                                   buffer_info->length,
4512                                                   DMA_FROM_DEVICE);
4513                 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
4514                         dev_kfree_skb(skb);
4515                         buffer_info->skb = NULL;
4516                         buffer_info->dma = 0;
4517                         adapter->alloc_rx_buff_failed++;
4518                         break; /* while !buffer_info->skb */
4519                 }
4520
4521                 /*
4522                  * XXX if it was allocated cleanly it will never map to a
4523                  * boundary crossing
4524                  */
4525
4526                 /* Fix for errata 23, can't cross 64kB boundary */
4527                 if (!e1000_check_64k_bound(adapter,
4528                                         (void *)(unsigned long)buffer_info->dma,
4529                                         adapter->rx_buffer_len)) {
4530                         e_err(rx_err, "dma align check failed: %u bytes at "
4531                               "%p\n", adapter->rx_buffer_len,
4532                               (void *)(unsigned long)buffer_info->dma);
4533                         dev_kfree_skb(skb);
4534                         buffer_info->skb = NULL;
4535
4536                         dma_unmap_single(&pdev->dev, buffer_info->dma,
4537                                          adapter->rx_buffer_len,
4538                                          DMA_FROM_DEVICE);
4539                         buffer_info->dma = 0;
4540
4541                         adapter->alloc_rx_buff_failed++;
4542                         break; /* while !buffer_info->skb */
4543                 }
4544                 rx_desc = E1000_RX_DESC(*rx_ring, i);
4545                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
4546
4547                 if (unlikely(++i == rx_ring->count))
4548                         i = 0;
4549                 buffer_info = &rx_ring->buffer_info[i];
4550         }
4551
4552         if (likely(rx_ring->next_to_use != i)) {
4553                 rx_ring->next_to_use = i;
4554                 if (unlikely(i-- == 0))
4555                         i = (rx_ring->count - 1);
4556
4557                 /* Force memory writes to complete before letting h/w
4558                  * know there are new descriptors to fetch.  (Only
4559                  * applicable for weak-ordered memory model archs,
4560                  * such as IA-64). */
4561                 wmb();
4562                 writel(i, hw->hw_addr + rx_ring->rdt);
4563         }
4564 }
4565
4566 /**
4567  * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
4568  * @adapter:
4569  **/
4570
4571 static void e1000_smartspeed(struct e1000_adapter *adapter)
4572 {
4573         struct e1000_hw *hw = &adapter->hw;
4574         u16 phy_status;
4575         u16 phy_ctrl;
4576
4577         if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg ||
4578            !(hw->autoneg_advertised & ADVERTISE_1000_FULL))
4579                 return;
4580
4581         if (adapter->smartspeed == 0) {
4582                 /* If Master/Slave config fault is asserted twice,
4583                  * we assume back-to-back */
4584                 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
4585                 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
4586                 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
4587                 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
4588                 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
4589                 if (phy_ctrl & CR_1000T_MS_ENABLE) {
4590                         phy_ctrl &= ~CR_1000T_MS_ENABLE;
4591                         e1000_write_phy_reg(hw, PHY_1000T_CTRL,
4592                                             phy_ctrl);
4593                         adapter->smartspeed++;
4594                         if (!e1000_phy_setup_autoneg(hw) &&
4595                            !e1000_read_phy_reg(hw, PHY_CTRL,
4596                                                &phy_ctrl)) {
4597                                 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
4598                                              MII_CR_RESTART_AUTO_NEG);
4599                                 e1000_write_phy_reg(hw, PHY_CTRL,
4600                                                     phy_ctrl);
4601                         }
4602                 }
4603                 return;
4604         } else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
4605                 /* If still no link, perhaps using 2/3 pair cable */
4606                 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
4607                 phy_ctrl |= CR_1000T_MS_ENABLE;
4608                 e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl);
4609                 if (!e1000_phy_setup_autoneg(hw) &&
4610                    !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) {
4611                         phy_ctrl |= (MII_CR_AUTO_NEG_EN |
4612                                      MII_CR_RESTART_AUTO_NEG);
4613                         e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl);
4614                 }
4615         }
4616         /* Restart process after E1000_SMARTSPEED_MAX iterations */
4617         if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
4618                 adapter->smartspeed = 0;
4619 }
4620
4621 /**
4622  * e1000_ioctl -
4623  * @netdev:
4624  * @ifreq:
4625  * @cmd:
4626  **/
4627
4628 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
4629 {
4630         switch (cmd) {
4631         case SIOCGMIIPHY:
4632         case SIOCGMIIREG:
4633         case SIOCSMIIREG:
4634                 return e1000_mii_ioctl(netdev, ifr, cmd);
4635         default:
4636                 return -EOPNOTSUPP;
4637         }
4638 }
4639
4640 /**
4641  * e1000_mii_ioctl -
4642  * @netdev:
4643  * @ifreq:
4644  * @cmd:
4645  **/
4646
4647 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
4648                            int cmd)
4649 {
4650         struct e1000_adapter *adapter = netdev_priv(netdev);
4651         struct e1000_hw *hw = &adapter->hw;
4652         struct mii_ioctl_data *data = if_mii(ifr);
4653         int retval;
4654         u16 mii_reg;
4655         unsigned long flags;
4656
4657         if (hw->media_type != e1000_media_type_copper)
4658                 return -EOPNOTSUPP;
4659
4660         switch (cmd) {
4661         case SIOCGMIIPHY:
4662                 data->phy_id = hw->phy_addr;
4663                 break;
4664         case SIOCGMIIREG:
4665                 spin_lock_irqsave(&adapter->stats_lock, flags);
4666                 if (e1000_read_phy_reg(hw, data->reg_num & 0x1F,
4667                                    &data->val_out)) {
4668                         spin_unlock_irqrestore(&adapter->stats_lock, flags);
4669                         return -EIO;
4670                 }
4671                 spin_unlock_irqrestore(&adapter->stats_lock, flags);
4672                 break;
4673         case SIOCSMIIREG:
4674                 if (data->reg_num & ~(0x1F))
4675                         return -EFAULT;
4676                 mii_reg = data->val_in;
4677                 spin_lock_irqsave(&adapter->stats_lock, flags);
4678                 if (e1000_write_phy_reg(hw, data->reg_num,
4679                                         mii_reg)) {
4680                         spin_unlock_irqrestore(&adapter->stats_lock, flags);
4681                         return -EIO;
4682                 }
4683                 spin_unlock_irqrestore(&adapter->stats_lock, flags);
4684                 if (hw->media_type == e1000_media_type_copper) {
4685                         switch (data->reg_num) {
4686                         case PHY_CTRL:
4687                                 if (mii_reg & MII_CR_POWER_DOWN)
4688                                         break;
4689                                 if (mii_reg & MII_CR_AUTO_NEG_EN) {
4690                                         hw->autoneg = 1;
4691                                         hw->autoneg_advertised = 0x2F;
4692                                 } else {
4693                                         u32 speed;
4694                                         if (mii_reg & 0x40)
4695                                                 speed = SPEED_1000;
4696                                         else if (mii_reg & 0x2000)
4697                                                 speed = SPEED_100;
4698                                         else
4699                                                 speed = SPEED_10;
4700                                         retval = e1000_set_spd_dplx(
4701                                                 adapter, speed,
4702                                                 ((mii_reg & 0x100)
4703                                                  ? DUPLEX_FULL :
4704                                                  DUPLEX_HALF));
4705                                         if (retval)
4706                                                 return retval;
4707                                 }
4708                                 if (netif_running(adapter->netdev))
4709                                         e1000_reinit_locked(adapter);
4710                                 else
4711                                         e1000_reset(adapter);
4712                                 break;
4713                         case M88E1000_PHY_SPEC_CTRL:
4714                         case M88E1000_EXT_PHY_SPEC_CTRL:
4715                                 if (e1000_phy_reset(hw))
4716                                         return -EIO;
4717                                 break;
4718                         }
4719                 } else {
4720                         switch (data->reg_num) {
4721                         case PHY_CTRL:
4722                                 if (mii_reg & MII_CR_POWER_DOWN)
4723                                         break;
4724                                 if (netif_running(adapter->netdev))
4725                                         e1000_reinit_locked(adapter);
4726                                 else
4727                                         e1000_reset(adapter);
4728                                 break;
4729                         }
4730                 }
4731                 break;
4732         default:
4733                 return -EOPNOTSUPP;
4734         }
4735         return E1000_SUCCESS;
4736 }
4737
4738 void e1000_pci_set_mwi(struct e1000_hw *hw)
4739 {
4740         struct e1000_adapter *adapter = hw->back;
4741         int ret_val = pci_set_mwi(adapter->pdev);
4742
4743         if (ret_val)
4744                 e_err(probe, "Error in setting MWI\n");
4745 }
4746
4747 void e1000_pci_clear_mwi(struct e1000_hw *hw)
4748 {
4749         struct e1000_adapter *adapter = hw->back;
4750
4751         pci_clear_mwi(adapter->pdev);
4752 }
4753
4754 int e1000_pcix_get_mmrbc(struct e1000_hw *hw)
4755 {
4756         struct e1000_adapter *adapter = hw->back;
4757         return pcix_get_mmrbc(adapter->pdev);
4758 }
4759
4760 void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
4761 {
4762         struct e1000_adapter *adapter = hw->back;
4763         pcix_set_mmrbc(adapter->pdev, mmrbc);
4764 }
4765
4766 void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
4767 {
4768         outl(value, port);
4769 }
4770
4771 static bool e1000_vlan_used(struct e1000_adapter *adapter)
4772 {
4773         u16 vid;
4774
4775         for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
4776                 return true;
4777         return false;
4778 }
4779
4780 static void __e1000_vlan_mode(struct e1000_adapter *adapter,
4781                               netdev_features_t features)
4782 {
4783         struct e1000_hw *hw = &adapter->hw;
4784         u32 ctrl;
4785
4786         ctrl = er32(CTRL);
4787         if (features & NETIF_F_HW_VLAN_RX) {
4788                 /* enable VLAN tag insert/strip */
4789                 ctrl |= E1000_CTRL_VME;
4790         } else {
4791                 /* disable VLAN tag insert/strip */
4792                 ctrl &= ~E1000_CTRL_VME;
4793         }
4794         ew32(CTRL, ctrl);
4795 }
4796 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
4797                                      bool filter_on)
4798 {
4799         struct e1000_hw *hw = &adapter->hw;
4800         u32 rctl;
4801
4802         if (!test_bit(__E1000_DOWN, &adapter->flags))
4803                 e1000_irq_disable(adapter);
4804
4805         __e1000_vlan_mode(adapter, adapter->netdev->features);
4806         if (filter_on) {
4807                 /* enable VLAN receive filtering */
4808                 rctl = er32(RCTL);
4809                 rctl &= ~E1000_RCTL_CFIEN;
4810                 if (!(adapter->netdev->flags & IFF_PROMISC))
4811                         rctl |= E1000_RCTL_VFE;
4812                 ew32(RCTL, rctl);
4813                 e1000_update_mng_vlan(adapter);
4814         } else {
4815                 /* disable VLAN receive filtering */
4816                 rctl = er32(RCTL);
4817                 rctl &= ~E1000_RCTL_VFE;
4818                 ew32(RCTL, rctl);
4819         }
4820
4821         if (!test_bit(__E1000_DOWN, &adapter->flags))
4822                 e1000_irq_enable(adapter);
4823 }
4824
4825 static void e1000_vlan_mode(struct net_device *netdev,
4826                             netdev_features_t features)
4827 {
4828         struct e1000_adapter *adapter = netdev_priv(netdev);
4829
4830         if (!test_bit(__E1000_DOWN, &adapter->flags))
4831                 e1000_irq_disable(adapter);
4832
4833         __e1000_vlan_mode(adapter, features);
4834
4835         if (!test_bit(__E1000_DOWN, &adapter->flags))
4836                 e1000_irq_enable(adapter);
4837 }
4838
4839 static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
4840 {
4841         struct e1000_adapter *adapter = netdev_priv(netdev);
4842         struct e1000_hw *hw = &adapter->hw;
4843         u32 vfta, index;
4844
4845         if ((hw->mng_cookie.status &
4846              E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
4847             (vid == adapter->mng_vlan_id))
4848                 return 0;
4849
4850         if (!e1000_vlan_used(adapter))
4851                 e1000_vlan_filter_on_off(adapter, true);
4852
4853         /* add VID to filter table */
4854         index = (vid >> 5) & 0x7F;
4855         vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
4856         vfta |= (1 << (vid & 0x1F));
4857         e1000_write_vfta(hw, index, vfta);
4858
4859         set_bit(vid, adapter->active_vlans);
4860
4861         return 0;
4862 }
4863
4864 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
4865 {
4866         struct e1000_adapter *adapter = netdev_priv(netdev);
4867         struct e1000_hw *hw = &adapter->hw;
4868         u32 vfta, index;
4869
4870         if (!test_bit(__E1000_DOWN, &adapter->flags))
4871                 e1000_irq_disable(adapter);
4872         if (!test_bit(__E1000_DOWN, &adapter->flags))
4873                 e1000_irq_enable(adapter);
4874
4875         /* remove VID from filter table */
4876         index = (vid >> 5) & 0x7F;
4877         vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
4878         vfta &= ~(1 << (vid & 0x1F));
4879         e1000_write_vfta(hw, index, vfta);
4880
4881         clear_bit(vid, adapter->active_vlans);
4882
4883         if (!e1000_vlan_used(adapter))
4884                 e1000_vlan_filter_on_off(adapter, false);
4885
4886         return 0;
4887 }
4888
4889 static void e1000_restore_vlan(struct e1000_adapter *adapter)
4890 {
4891         u16 vid;
4892
4893         if (!e1000_vlan_used(adapter))
4894                 return;
4895
4896         e1000_vlan_filter_on_off(adapter, true);
4897         for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
4898                 e1000_vlan_rx_add_vid(adapter->netdev, vid);
4899 }
4900
4901 int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
4902 {
4903         struct e1000_hw *hw = &adapter->hw;
4904
4905         hw->autoneg = 0;
4906
4907         /* Make sure dplx is at most 1 bit and lsb of speed is not set
4908          * for the switch() below to work */
4909         if ((spd & 1) || (dplx & ~1))
4910                 goto err_inval;
4911
4912         /* Fiber NICs only allow 1000 gbps Full duplex */
4913         if ((hw->media_type == e1000_media_type_fiber) &&
4914             spd != SPEED_1000 &&
4915             dplx != DUPLEX_FULL)
4916                 goto err_inval;
4917
4918         switch (spd + dplx) {
4919         case SPEED_10 + DUPLEX_HALF:
4920                 hw->forced_speed_duplex = e1000_10_half;
4921                 break;
4922         case SPEED_10 + DUPLEX_FULL:
4923                 hw->forced_speed_duplex = e1000_10_full;
4924                 break;
4925         case SPEED_100 + DUPLEX_HALF:
4926                 hw->forced_speed_duplex = e1000_100_half;
4927                 break;
4928         case SPEED_100 + DUPLEX_FULL:
4929                 hw->forced_speed_duplex = e1000_100_full;
4930                 break;
4931         case SPEED_1000 + DUPLEX_FULL:
4932                 hw->autoneg = 1;
4933                 hw->autoneg_advertised = ADVERTISE_1000_FULL;
4934                 break;
4935         case SPEED_1000 + DUPLEX_HALF: /* not supported */
4936         default:
4937                 goto err_inval;
4938         }
4939         return 0;
4940
4941 err_inval:
4942         e_err(probe, "Unsupported Speed/Duplex configuration\n");
4943         return -EINVAL;
4944 }
4945
4946 static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
4947 {
4948         struct net_device *netdev = pci_get_drvdata(pdev);
4949         struct e1000_adapter *adapter = netdev_priv(netdev);
4950         struct e1000_hw *hw = &adapter->hw;
4951         u32 ctrl, ctrl_ext, rctl, status;
4952         u32 wufc = adapter->wol;
4953 #ifdef CONFIG_PM
4954         int retval = 0;
4955 #endif
4956
4957         netif_device_detach(netdev);
4958
4959         if (netif_running(netdev)) {
4960                 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
4961                 e1000_down(adapter);
4962         }
4963
4964 #ifdef CONFIG_PM
4965         retval = pci_save_state(pdev);
4966         if (retval)
4967                 return retval;
4968 #endif
4969
4970         status = er32(STATUS);
4971         if (status & E1000_STATUS_LU)
4972                 wufc &= ~E1000_WUFC_LNKC;
4973
4974         if (wufc) {
4975                 e1000_setup_rctl(adapter);
4976                 e1000_set_rx_mode(netdev);
4977
4978                 rctl = er32(RCTL);
4979
4980                 /* turn on all-multi mode if wake on multicast is enabled */
4981                 if (wufc & E1000_WUFC_MC)
4982                         rctl |= E1000_RCTL_MPE;
4983
4984                 /* enable receives in the hardware */
4985                 ew32(RCTL, rctl | E1000_RCTL_EN);
4986
4987                 if (hw->mac_type >= e1000_82540) {
4988                         ctrl = er32(CTRL);
4989                         /* advertise wake from D3Cold */
4990                         #define E1000_CTRL_ADVD3WUC 0x00100000
4991                         /* phy power management enable */
4992                         #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
4993                         ctrl |= E1000_CTRL_ADVD3WUC |
4994                                 E1000_CTRL_EN_PHY_PWR_MGMT;
4995                         ew32(CTRL, ctrl);
4996                 }
4997
4998                 if (hw->media_type == e1000_media_type_fiber ||
4999                     hw->media_type == e1000_media_type_internal_serdes) {
5000                         /* keep the laser running in D3 */
5001                         ctrl_ext = er32(CTRL_EXT);
5002                         ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
5003                         ew32(CTRL_EXT, ctrl_ext);
5004                 }
5005
5006                 ew32(WUC, E1000_WUC_PME_EN);
5007                 ew32(WUFC, wufc);
5008         } else {
5009                 ew32(WUC, 0);
5010                 ew32(WUFC, 0);
5011         }
5012
5013         e1000_release_manageability(adapter);
5014
5015         *enable_wake = !!wufc;
5016
5017         /* make sure adapter isn't asleep if manageability is enabled */
5018         if (adapter->en_mng_pt)
5019                 *enable_wake = true;
5020
5021         if (netif_running(netdev))
5022                 e1000_free_irq(adapter);
5023
5024         pci_disable_device(pdev);
5025
5026         return 0;
5027 }
5028
5029 #ifdef CONFIG_PM
5030 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
5031 {
5032         int retval;
5033         bool wake;
5034
5035         retval = __e1000_shutdown(pdev, &wake);
5036         if (retval)
5037                 return retval;
5038
5039         if (wake) {
5040                 pci_prepare_to_sleep(pdev);
5041         } else {
5042                 pci_wake_from_d3(pdev, false);
5043                 pci_set_power_state(pdev, PCI_D3hot);
5044         }
5045
5046         return 0;
5047 }
5048
5049 static int e1000_resume(struct pci_dev *pdev)
5050 {
5051         struct net_device *netdev = pci_get_drvdata(pdev);
5052         struct e1000_adapter *adapter = netdev_priv(netdev);
5053         struct e1000_hw *hw = &adapter->hw;
5054         u32 err;
5055
5056         pci_set_power_state(pdev, PCI_D0);
5057         pci_restore_state(pdev);
5058         pci_save_state(pdev);
5059
5060         if (adapter->need_ioport)
5061                 err = pci_enable_device(pdev);
5062         else
5063                 err = pci_enable_device_mem(pdev);
5064         if (err) {
5065                 pr_err("Cannot enable PCI device from suspend\n");
5066                 return err;
5067         }
5068         pci_set_master(pdev);
5069
5070         pci_enable_wake(pdev, PCI_D3hot, 0);
5071         pci_enable_wake(pdev, PCI_D3cold, 0);
5072
5073         if (netif_running(netdev)) {
5074                 err = e1000_request_irq(adapter);
5075                 if (err)
5076                         return err;
5077         }
5078
5079         e1000_power_up_phy(adapter);
5080         e1000_reset(adapter);
5081         ew32(WUS, ~0);
5082
5083         e1000_init_manageability(adapter);
5084
5085         if (netif_running(netdev))
5086                 e1000_up(adapter);
5087
5088         netif_device_attach(netdev);
5089
5090         return 0;
5091 }
5092 #endif
5093
5094 static void e1000_shutdown(struct pci_dev *pdev)
5095 {
5096         bool wake;
5097
5098         __e1000_shutdown(pdev, &wake);
5099
5100         if (system_state == SYSTEM_POWER_OFF) {
5101                 pci_wake_from_d3(pdev, wake);
5102                 pci_set_power_state(pdev, PCI_D3hot);
5103         }
5104 }
5105
5106 #ifdef CONFIG_NET_POLL_CONTROLLER
5107 /*
5108  * Polling 'interrupt' - used by things like netconsole to send skbs
5109  * without having to re-enable interrupts. It's not called while
5110  * the interrupt routine is executing.
5111  */
5112 static void e1000_netpoll(struct net_device *netdev)
5113 {
5114         struct e1000_adapter *adapter = netdev_priv(netdev);
5115
5116         disable_irq(adapter->pdev->irq);
5117         e1000_intr(adapter->pdev->irq, netdev);
5118         enable_irq(adapter->pdev->irq);
5119 }
5120 #endif
5121
5122 /**
5123  * e1000_io_error_detected - called when PCI error is detected
5124  * @pdev: Pointer to PCI device
5125  * @state: The current pci connection state
5126  *
5127  * This function is called after a PCI bus error affecting
5128  * this device has been detected.
5129  */
5130 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
5131                                                 pci_channel_state_t state)
5132 {
5133         struct net_device *netdev = pci_get_drvdata(pdev);
5134         struct e1000_adapter *adapter = netdev_priv(netdev);
5135
5136         netif_device_detach(netdev);
5137
5138         if (state == pci_channel_io_perm_failure)
5139                 return PCI_ERS_RESULT_DISCONNECT;
5140
5141         if (netif_running(netdev))
5142                 e1000_down(adapter);
5143         pci_disable_device(pdev);
5144
5145         /* Request a slot slot reset. */
5146         return PCI_ERS_RESULT_NEED_RESET;
5147 }
5148
5149 /**
5150  * e1000_io_slot_reset - called after the pci bus has been reset.
5151  * @pdev: Pointer to PCI device
5152  *
5153  * Restart the card from scratch, as if from a cold-boot. Implementation
5154  * resembles the first-half of the e1000_resume routine.
5155  */
5156 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
5157 {
5158         struct net_device *netdev = pci_get_drvdata(pdev);
5159         struct e1000_adapter *adapter = netdev_priv(netdev);
5160         struct e1000_hw *hw = &adapter->hw;
5161         int err;
5162
5163         if (adapter->need_ioport)
5164                 err = pci_enable_device(pdev);
5165         else
5166                 err = pci_enable_device_mem(pdev);
5167         if (err) {
5168                 pr_err("Cannot re-enable PCI device after reset.\n");
5169                 return PCI_ERS_RESULT_DISCONNECT;
5170         }
5171         pci_set_master(pdev);
5172
5173         pci_enable_wake(pdev, PCI_D3hot, 0);
5174         pci_enable_wake(pdev, PCI_D3cold, 0);
5175
5176         e1000_reset(adapter);
5177         ew32(WUS, ~0);
5178
5179         return PCI_ERS_RESULT_RECOVERED;
5180 }
5181
5182 /**
5183  * e1000_io_resume - called when traffic can start flowing again.
5184  * @pdev: Pointer to PCI device
5185  *
5186  * This callback is called when the error recovery driver tells us that
5187  * its OK to resume normal operation. Implementation resembles the
5188  * second-half of the e1000_resume routine.
5189  */
5190 static void e1000_io_resume(struct pci_dev *pdev)
5191 {
5192         struct net_device *netdev = pci_get_drvdata(pdev);
5193         struct e1000_adapter *adapter = netdev_priv(netdev);
5194
5195         e1000_init_manageability(adapter);
5196
5197         if (netif_running(netdev)) {
5198                 if (e1000_up(adapter)) {
5199                         pr_info("can't bring device back up after reset\n");
5200                         return;
5201                 }
5202         }
5203
5204         netif_device_attach(netdev);
5205 }
5206
5207 /* e1000_main.c */