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

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