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