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

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