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