1 files changed, 189 insertions, 262 deletions

diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index a50db5398fa..f8c2919bcec 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel(R) Gigabit Ethernet Linux driver
-  Copyright(c) 2007 Intel Corporation.
+  Copyright(c) 2007-2009 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -48,12 +48,12 @@
 #endif
 #include "igb.h"
 
-#define DRV_VERSION "1.2.45-k2"
+#define DRV_VERSION "1.3.16-k2"
 char igb_driver_name[] = "igb";
 char igb_driver_version[] = DRV_VERSION;
 static const char igb_driver_string[] =
                                 "Intel(R) Gigabit Ethernet Network Driver";
-static const char igb_copyright[] = "Copyright (c) 2008 Intel Corporation.";
+static const char igb_copyright[] = "Copyright (c) 2007-2009 Intel Corporation.";
 
 static const struct e1000_info *igb_info_tbl[] = {
         [board_82575] = &e1000_82575_info,
@@ -115,9 +115,6 @@ static bool igb_clean_tx_irq(struct igb_ring *);
 static int igb_poll(struct napi_struct *, int);
 static bool igb_clean_rx_irq_adv(struct igb_ring *, int *, int);
 static void igb_alloc_rx_buffers_adv(struct igb_ring *, int);
-#ifdef CONFIG_IGB_LRO
-static int igb_get_skb_hdr(struct sk_buff *skb, void **, void **, u64 *, void *);
-#endif
 static int igb_ioctl(struct net_device *, struct ifreq *, int cmd);
 static void igb_tx_timeout(struct net_device *);
 static void igb_reset_task(struct work_struct *);
@@ -407,7 +404,7 @@ static void igb_configure_msix(struct igb_adapter *adapter)
                 /* Turn on MSI-X capability first, or our settings
                  * won't stick.  And it will take days to debug. */
                 wr32(E1000_GPIE, E1000_GPIE_MSIX_MODE |
-                                   E1000_GPIE_PBA | E1000_GPIE_EIAME | 
+                                   E1000_GPIE_PBA | E1000_GPIE_EIAME |
                                    E1000_GPIE_NSICR);
 
         for (i = 0; i < adapter->num_tx_queues; i++) {
@@ -546,6 +543,11 @@ static void igb_set_interrupt_capability(struct igb_adapter *adapter)
         int err;
         int numvecs, i;
 
+        /* Number of supported queues. */
+        /* Having more queues than CPUs doesn't make sense. */
+        adapter->num_rx_queues = min_t(u32, IGB_MAX_RX_QUEUES, num_online_cpus());
+        adapter->num_tx_queues = min_t(u32, IGB_MAX_TX_QUEUES, num_online_cpus());
+
         numvecs = adapter->num_tx_queues + adapter->num_rx_queues + 1;
         adapter->msix_entries = kcalloc(numvecs, sizeof(struct msix_entry),
                                         GFP_KERNEL);
@@ -687,7 +689,7 @@ static void igb_irq_enable(struct igb_adapter *adapter)
                 wr32(E1000_EIAC, adapter->eims_enable_mask);
                 wr32(E1000_EIAM, adapter->eims_enable_mask);
                 wr32(E1000_EIMS, adapter->eims_enable_mask);
-                wr32(E1000_IMS, E1000_IMS_LSC);
+                wr32(E1000_IMS, E1000_IMS_LSC | E1000_IMS_DOUTSYNC);
         } else {
                 wr32(E1000_IMS, IMS_ENABLE_MASK);
                 wr32(E1000_IAM, IMS_ENABLE_MASK);
@@ -856,6 +858,10 @@ void igb_down(struct igb_adapter *adapter)
 
         netdev->tx_queue_len = adapter->tx_queue_len;
         netif_carrier_off(netdev);
+
+        /* record the stats before reset*/
+        igb_update_stats(adapter);
+
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
 
@@ -886,11 +892,14 @@ void igb_reset(struct igb_adapter *adapter)
         /* Repartition Pba for greater than 9k mtu
          * To take effect CTRL.RST is required.
          */
-        if (mac->type != e1000_82576) {
-        pba = E1000_PBA_34K;
-        }
-        else {
+        switch (mac->type) {
+        case e1000_82576:
                 pba = E1000_PBA_64K;
+                break;
+        case e1000_82575:
+        default:
+                pba = E1000_PBA_34K;
+                break;
         }
 
         if ((adapter->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN) &&
@@ -972,21 +981,6 @@ void igb_reset(struct igb_adapter *adapter)
         igb_get_phy_info(&adapter->hw);
 }
 
-/**
- * igb_is_need_ioport - determine if an adapter needs ioport resources or not
- * @pdev: PCI device information struct
- *
- * Returns true if an adapter needs ioport resources
- **/
-static int igb_is_need_ioport(struct pci_dev *pdev)
-{
-        switch (pdev->device) {
-        /* Currently there are no adapters that need ioport resources */
-        default:
-                return false;
-        }
-}
-
 static const struct net_device_ops igb_netdev_ops = {
         .ndo_open               = igb_open,
         .ndo_stop               = igb_close,
@@ -1026,21 +1020,12 @@ static int __devinit igb_probe(struct pci_dev *pdev,
         struct pci_dev *us_dev;
         const struct e1000_info *ei = igb_info_tbl[ent->driver_data];
         unsigned long mmio_start, mmio_len;
-        int i, err, pci_using_dac, pos;
+        int err, pci_using_dac, pos;
         u16 eeprom_data = 0, state = 0;
         u16 eeprom_apme_mask = IGB_EEPROM_APME;
         u32 part_num;
-        int bars, need_ioport;
 
-        /* do not allocate ioport bars when not needed */
-        need_ioport = igb_is_need_ioport(pdev);
-        if (need_ioport) {
-                bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
-                err = pci_enable_device(pdev);
-        } else {
-                bars = pci_select_bars(pdev, IORESOURCE_MEM);
-                err = pci_enable_device_mem(pdev);
-        }
+        err = pci_enable_device_mem(pdev);
         if (err)
                 return err;
 
@@ -1083,7 +1068,9 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                 break;
         }
 
-        err = pci_request_selected_regions(pdev, bars, igb_driver_name);
+        err = pci_request_selected_regions(pdev, pci_select_bars(pdev,
+                                           IORESOURCE_MEM),
+                                           igb_driver_name);
         if (err)
                 goto err_pci_reg;
 
@@ -1111,15 +1098,13 @@ static int __devinit igb_probe(struct pci_dev *pdev,
         hw = &adapter->hw;
         hw->back = adapter;
         adapter->msg_enable = NETIF_MSG_DRV | NETIF_MSG_PROBE;
-        adapter->bars = bars;
-        adapter->need_ioport = need_ioport;
 
         mmio_start = pci_resource_start(pdev, 0);
         mmio_len = pci_resource_len(pdev, 0);
 
         err = -EIO;
-        adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
-        if (!adapter->hw.hw_addr)
+        hw->hw_addr = ioremap(mmio_start, mmio_len);
+        if (!hw->hw_addr)
                 goto err_ioremap;
 
         netdev->netdev_ops = &igb_netdev_ops;
@@ -1147,8 +1132,9 @@ static int __devinit igb_probe(struct pci_dev *pdev,
         /* Initialize skew-specific constants */
         err = ei->get_invariants(hw);
         if (err)
-                goto err_hw_init;
+                goto err_sw_init;
 
+        /* setup the private structure */
         err = igb_sw_init(adapter);
         if (err)
                 goto err_sw_init;
@@ -1180,27 +1166,27 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                         "PHY reset is blocked due to SOL/IDER session.\n");
 
         netdev->features = NETIF_F_SG |
-                           NETIF_F_HW_CSUM |
+                           NETIF_F_IP_CSUM |
                            NETIF_F_HW_VLAN_TX |
                            NETIF_F_HW_VLAN_RX |
                            NETIF_F_HW_VLAN_FILTER;
 
+        netdev->features |= NETIF_F_IPV6_CSUM;
         netdev->features |= NETIF_F_TSO;
         netdev->features |= NETIF_F_TSO6;
 
 #ifdef CONFIG_IGB_LRO
-        netdev->features |= NETIF_F_LRO;
+        netdev->features |= NETIF_F_GRO;
 #endif
 
         netdev->vlan_features |= NETIF_F_TSO;
         netdev->vlan_features |= NETIF_F_TSO6;
-        netdev->vlan_features |= NETIF_F_HW_CSUM;
+        netdev->vlan_features |= NETIF_F_IP_CSUM;
         netdev->vlan_features |= NETIF_F_SG;
 
         if (pci_using_dac)
                 netdev->features |= NETIF_F_HIGHDMA;
 
-        netdev->features |= NETIF_F_LLTX;
         adapter->en_mng_pt = igb_enable_mng_pass_thru(&adapter->hw);
 
         /* before reading the NVM, reset the controller to put the device in a
@@ -1238,14 +1224,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
         INIT_WORK(&adapter->reset_task, igb_reset_task);
         INIT_WORK(&adapter->watchdog_task, igb_watchdog_task);
 
-        /* Initialize link & ring properties that are user-changeable */
-        adapter->tx_ring->count = 256;
-        for (i = 0; i < adapter->num_tx_queues; i++)
-                adapter->tx_ring[i].count = adapter->tx_ring->count;
-        adapter->rx_ring->count = 256;
-        for (i = 0; i < adapter->num_rx_queues; i++)
-                adapter->rx_ring[i].count = adapter->rx_ring->count;
-
+        /* Initialize link properties that are user-changeable */
         adapter->fc_autoneg = true;
         hw->mac.autoneg = true;
         hw->phy.autoneg_advertised = 0x2f;
@@ -1266,8 +1245,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
 
         if (hw->bus.func == 0 ||
             hw->device_id == E1000_DEV_ID_82575EB_COPPER)
-                hw->nvm.ops.read_nvm(hw, NVM_INIT_CONTROL3_PORT_A, 1,
-                                     &eeprom_data);
+                hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
 
         if (eeprom_data & eeprom_apme_mask)
                 adapter->eeprom_wol |= E1000_WUFC_MAG;
@@ -1352,15 +1330,14 @@ err_eeprom:
         if (hw->flash_address)
                 iounmap(hw->flash_address);
 
-        igb_remove_device(hw);
         igb_free_queues(adapter);
 err_sw_init:
-err_hw_init:
         iounmap(hw->hw_addr);
 err_ioremap:
         free_netdev(netdev);
 err_alloc_etherdev:
-        pci_release_selected_regions(pdev, bars);
+        pci_release_selected_regions(pdev, pci_select_bars(pdev,
+                                     IORESOURCE_MEM));
 err_pci_reg:
 err_dma:
         pci_disable_device(pdev);
@@ -1380,9 +1357,7 @@ static void __devexit igb_remove(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct igb_adapter *adapter = netdev_priv(netdev);
-#ifdef CONFIG_IGB_DCA
         struct e1000_hw *hw = &adapter->hw;
-#endif
         int err;
 
         /* flush_scheduled work may reschedule our watchdog task, so
@@ -1411,15 +1386,15 @@ static void __devexit igb_remove(struct pci_dev *pdev)
         if (!igb_check_reset_block(&adapter->hw))
                 igb_reset_phy(&adapter->hw);
 
-        igb_remove_device(&adapter->hw);
         igb_reset_interrupt_capability(adapter);
 
         igb_free_queues(adapter);
 
-        iounmap(adapter->hw.hw_addr);
-        if (adapter->hw.flash_address)
-                iounmap(adapter->hw.flash_address);
-        pci_release_selected_regions(pdev, adapter->bars);
+        iounmap(hw->hw_addr);
+        if (hw->flash_address)
+                iounmap(hw->flash_address);
+        pci_release_selected_regions(pdev, pci_select_bars(pdev,
+                                     IORESOURCE_MEM));
 
         free_netdev(netdev);
 
@@ -1454,11 +1429,6 @@ static int __devinit igb_sw_init(struct igb_adapter *adapter)
         adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
         adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
 
-        /* Number of supported queues. */
-        /* Having more queues than CPUs doesn't make sense. */
-        adapter->num_rx_queues = min_t(u32, IGB_MAX_RX_QUEUES, num_online_cpus());
-        adapter->num_tx_queues = min_t(u32, IGB_MAX_TX_QUEUES, num_online_cpus());
-
         /* This call may decrease the number of queues depending on
          * interrupt mode. */
         igb_set_interrupt_capability(adapter);
@@ -1657,7 +1627,7 @@ static int igb_setup_all_tx_resources(struct igb_adapter *adapter)
         for (i = 0; i < IGB_MAX_TX_QUEUES; i++) {
                 r_idx = i % adapter->num_tx_queues;
                 adapter->multi_tx_table[i] = &adapter->tx_ring[r_idx];
-        }       
+        }
         return err;
 }
 
@@ -1738,14 +1708,6 @@ int igb_setup_rx_resources(struct igb_adapter *adapter,
         struct pci_dev *pdev = adapter->pdev;
         int size, desc_len;
 
-#ifdef CONFIG_IGB_LRO
-        size = sizeof(struct net_lro_desc) * MAX_LRO_DESCRIPTORS;
-        rx_ring->lro_mgr.lro_arr = vmalloc(size);
-        if (!rx_ring->lro_mgr.lro_arr)
-                goto err;
-        memset(rx_ring->lro_mgr.lro_arr, 0, size);
-#endif
-
         size = sizeof(struct igb_buffer) * rx_ring->count;
         rx_ring->buffer_info = vmalloc(size);
         if (!rx_ring->buffer_info)
@@ -1772,10 +1734,6 @@ int igb_setup_rx_resources(struct igb_adapter *adapter,
         return 0;
 
 err:
-#ifdef CONFIG_IGB_LRO
-        vfree(rx_ring->lro_mgr.lro_arr);
-        rx_ring->lro_mgr.lro_arr = NULL;
-#endif
         vfree(rx_ring->buffer_info);
         dev_err(&adapter->pdev->dev, "Unable to allocate memory for "
                 "the receive descriptor ring\n");
@@ -1824,7 +1782,7 @@ static void igb_setup_rctl(struct igb_adapter *adapter)
         rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
 
         rctl |= E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_RDMTS_HALF |
-                (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
+                (hw->mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
 
         /*
          * enable stripping of CRC. It's unlikely this will break BMC
@@ -1929,16 +1887,6 @@ static void igb_configure_rx(struct igb_adapter *adapter)
                 rxdctl |= IGB_RX_HTHRESH << 8;
                 rxdctl |= IGB_RX_WTHRESH << 16;
                 wr32(E1000_RXDCTL(j), rxdctl);
-#ifdef CONFIG_IGB_LRO
-                /* Intitial LRO Settings */
-                ring->lro_mgr.max_aggr = MAX_LRO_AGGR;
-                ring->lro_mgr.max_desc = MAX_LRO_DESCRIPTORS;
-                ring->lro_mgr.get_skb_header = igb_get_skb_hdr;
-                ring->lro_mgr.features = LRO_F_NAPI | LRO_F_EXTRACT_VLAN_ID;
-                ring->lro_mgr.dev = adapter->netdev;
-                ring->lro_mgr.ip_summed = CHECKSUM_UNNECESSARY;
-                ring->lro_mgr.ip_summed_aggr = CHECKSUM_UNNECESSARY;
-#endif
         }
 
         if (adapter->num_rx_queues > 1) {
@@ -2127,11 +2075,6 @@ void igb_free_rx_resources(struct igb_ring *rx_ring)
         vfree(rx_ring->buffer_info);
         rx_ring->buffer_info = NULL;
 
-#ifdef CONFIG_IGB_LRO
-        vfree(rx_ring->lro_mgr.lro_arr);
-        rx_ring->lro_mgr.lro_arr = NULL;
-#endif 
-
         pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);
 
         rx_ring->desc = NULL;
@@ -2231,15 +2174,16 @@ static void igb_clean_all_rx_rings(struct igb_adapter *adapter)
 static int igb_set_mac(struct net_device *netdev, void *p)
 {
         struct igb_adapter *adapter = netdev_priv(netdev);
+        struct e1000_hw *hw = &adapter->hw;
         struct sockaddr *addr = p;
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
-        memcpy(adapter->hw.mac.addr, addr->sa_data, netdev->addr_len);
+        memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);
 
-        adapter->hw.mac.ops.rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
+        hw->mac.ops.rar_set(hw, hw->mac.addr, 0);
 
         return 0;
 }
@@ -2282,8 +2226,8 @@ static void igb_set_multi(struct net_device *netdev)
 
         if (!netdev->mc_count) {
                 /* nothing to program, so clear mc list */
-                igb_update_mc_addr_list_82575(hw, NULL, 0, 1,
-                                          mac->rar_entry_count);
+                igb_update_mc_addr_list(hw, NULL, 0, 1,
+                                        mac->rar_entry_count);
                 return;
         }
 
@@ -2300,8 +2244,7 @@ static void igb_set_multi(struct net_device *netdev)
                 memcpy(mta_list + (i*ETH_ALEN), mc_ptr->dmi_addr, ETH_ALEN);
                 mc_ptr = mc_ptr->next;
         }
-        igb_update_mc_addr_list_82575(hw, mta_list, i, 1,
-                                      mac->rar_entry_count);
+        igb_update_mc_addr_list(hw, mta_list, i, 1, mac->rar_entry_count);
         kfree(mta_list);
 }
 
@@ -2314,6 +2257,46 @@ static void igb_update_phy_info(unsigned long data)
 }
 
 /**
+ * igb_has_link - check shared code for link and determine up/down
+ * @adapter: pointer to driver private info
+ **/
+static bool igb_has_link(struct igb_adapter *adapter)
+{
+        struct e1000_hw *hw = &adapter->hw;
+        bool link_active = false;
+        s32 ret_val = 0;
+
+        /* get_link_status is set on LSC (link status) interrupt or
+         * rx sequence error interrupt.  get_link_status will stay
+         * false until the e1000_check_for_link establishes link
+         * for copper adapters ONLY
+         */
+        switch (hw->phy.media_type) {
+        case e1000_media_type_copper:
+                if (hw->mac.get_link_status) {
+                        ret_val = hw->mac.ops.check_for_link(hw);
+                        link_active = !hw->mac.get_link_status;
+                } else {
+                        link_active = true;
+                }
+                break;
+        case e1000_media_type_fiber:
+                ret_val = hw->mac.ops.check_for_link(hw);
+                link_active = !!(rd32(E1000_STATUS) & E1000_STATUS_LU);
+                break;
+        case e1000_media_type_internal_serdes:
+                ret_val = hw->mac.ops.check_for_link(hw);
+                link_active = hw->mac.serdes_has_link;
+                break;
+        default:
+        case e1000_media_type_unknown:
+                break;
+        }
+
+        return link_active;
+}
+
+/**
  * igb_watchdog - Timer Call-back
  * @data: pointer to adapter cast into an unsigned long
  **/
@@ -2329,34 +2312,16 @@ static void igb_watchdog_task(struct work_struct *work)
         struct igb_adapter *adapter = container_of(work,
                                         struct igb_adapter, watchdog_task);
         struct e1000_hw *hw = &adapter->hw;
-
         struct net_device *netdev = adapter->netdev;
         struct igb_ring *tx_ring = adapter->tx_ring;
-        struct e1000_mac_info *mac = &adapter->hw.mac;
         u32 link;
         u32 eics = 0;
-        s32 ret_val;
         int i;
 
-        if ((netif_carrier_ok(netdev)) &&
-            (rd32(E1000_STATUS) & E1000_STATUS_LU))
+        link = igb_has_link(adapter);
+        if ((netif_carrier_ok(netdev)) && link)
                 goto link_up;
 
-        ret_val = hw->mac.ops.check_for_link(&adapter->hw);
-        if ((ret_val == E1000_ERR_PHY) &&
-            (hw->phy.type == e1000_phy_igp_3) &&
-            (rd32(E1000_CTRL) &
-             E1000_PHY_CTRL_GBE_DISABLE))
-                dev_info(&adapter->pdev->dev,
-                         "Gigabit has been disabled, downgrading speed\n");
-
-        if ((hw->phy.media_type == e1000_media_type_internal_serdes) &&
-            !(rd32(E1000_TXCW) & E1000_TXCW_ANE))
-                link = mac->serdes_has_link;
-        else
-                link = rd32(E1000_STATUS) &
-                                      E1000_STATUS_LU;
-
         if (link) {
                 if (!netif_carrier_ok(netdev)) {
                         u32 ctrl;
@@ -2395,6 +2360,7 @@ static void igb_watchdog_task(struct work_struct *work)
                         netif_carrier_on(netdev);
                         netif_tx_wake_all_queues(netdev);
 
+                        /* link state has changed, schedule phy info update */
                         if (!test_bit(__IGB_DOWN, &adapter->state))
                                 mod_timer(&adapter->phy_info_timer,
                                           round_jiffies(jiffies + 2 * HZ));
@@ -2408,6 +2374,8 @@ static void igb_watchdog_task(struct work_struct *work)
                                netdev->name);
                         netif_carrier_off(netdev);
                         netif_tx_stop_all_queues(netdev);
+
+                        /* link state has changed, schedule phy info update */
                         if (!test_bit(__IGB_DOWN, &adapter->state))
                                 mod_timer(&adapter->phy_info_timer,
                                           round_jiffies(jiffies + 2 * HZ));
@@ -2417,9 +2385,9 @@ static void igb_watchdog_task(struct work_struct *work)
 link_up:
         igb_update_stats(adapter);
 
-        mac->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
+        hw->mac.tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
         adapter->tpt_old = adapter->stats.tpt;
-        mac->collision_delta = adapter->stats.colc - adapter->colc_old;
+        hw->mac.collision_delta = adapter->stats.colc - adapter->colc_old;
         adapter->colc_old = adapter->stats.colc;
 
         adapter->gorc = adapter->stats.gorc - adapter->gorc_old;
@@ -2779,12 +2747,12 @@ static inline bool igb_tx_csum_adv(struct igb_adapter *adapter,
 
                 if (skb->ip_summed == CHECKSUM_PARTIAL) {
                         switch (skb->protocol) {
-                        case __constant_htons(ETH_P_IP):
+                        case cpu_to_be16(ETH_P_IP):
                                 tu_cmd |= E1000_ADVTXD_TUCMD_IPV4;
                                 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
                                         tu_cmd |= E1000_ADVTXD_TUCMD_L4T_TCP;
                                 break;
-                        case __constant_htons(ETH_P_IPV6):
+                        case cpu_to_be16(ETH_P_IPV6):
                                 /* XXX what about other V6 headers?? */
                                 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
                                         tu_cmd |= E1000_ADVTXD_TUCMD_L4T_TCP;
@@ -2803,6 +2771,8 @@ static inline bool igb_tx_csum_adv(struct igb_adapter *adapter,
                 if (adapter->flags & IGB_FLAG_NEED_CTX_IDX)
                         context_desc->mss_l4len_idx =
                                 cpu_to_le32(tx_ring->queue_index << 4);
+                else
+                        context_desc->mss_l4len_idx = 0;
 
                 buffer_info->time_stamp = jiffies;
                 buffer_info->next_to_watch = i;
@@ -2981,12 +2951,9 @@ static int igb_xmit_frame_ring_adv(struct sk_buff *skb,
         struct igb_adapter *adapter = netdev_priv(netdev);
         unsigned int first;
         unsigned int tx_flags = 0;
-        unsigned int len;
         u8 hdr_len = 0;
         int tso = 0;
 
-        len = skb_headlen(skb);
-
         if (test_bit(__IGB_DOWN, &adapter->state)) {
                 dev_kfree_skb_any(skb);
                 return NETDEV_TX_OK;
@@ -3072,8 +3039,8 @@ static void igb_tx_timeout(struct net_device *netdev)
         /* Do the reset outside of interrupt context */
         adapter->tx_timeout_count++;
         schedule_work(&adapter->reset_task);
-        wr32(E1000_EICS, adapter->eims_enable_mask &
-                ~(E1000_EIMS_TCP_TIMER | E1000_EIMS_OTHER));
+        wr32(E1000_EICS,
+             (adapter->eims_enable_mask & ~adapter->eims_other));
 }
 
 static void igb_reset_task(struct work_struct *work)
@@ -3317,15 +3284,20 @@ static irqreturn_t igb_msix_other(int irq, void *data)
         u32 icr = rd32(E1000_ICR);
 
         /* reading ICR causes bit 31 of EICR to be cleared */
+
+        if(icr & E1000_ICR_DOUTSYNC) {
+                /* HW is reporting DMA is out of sync */
+                adapter->stats.doosync++;
+        }
         if (!(icr & E1000_ICR_LSC))
                 goto no_link_interrupt;
         hw->mac.get_link_status = 1;
         /* guard against interrupt when we're going down */
         if (!test_bit(__IGB_DOWN, &adapter->state))
                 mod_timer(&adapter->watchdog_timer, jiffies + 1);
-        
+
 no_link_interrupt:
-        wr32(E1000_IMS, E1000_IMS_LSC);
+        wr32(E1000_IMS, E1000_IMS_LSC | E1000_IMS_DOUTSYNC);
         wr32(E1000_EIMS, adapter->eims_other);
 
         return IRQ_HANDLED;
@@ -3385,8 +3357,8 @@ static irqreturn_t igb_msix_rx(int irq, void *data)
 
         igb_write_itr(rx_ring);
 
-        if (netif_rx_schedule_prep(&rx_ring->napi))
-                __netif_rx_schedule(&rx_ring->napi);
+        if (napi_schedule_prep(&rx_ring->napi))
+                __napi_schedule(&rx_ring->napi);
 
 #ifdef CONFIG_IGB_DCA
         if (rx_ring->adapter->flags & IGB_FLAG_DCA_ENABLED)
@@ -3529,19 +3501,24 @@ static irqreturn_t igb_intr_msi(int irq, void *data)
 
         igb_write_itr(adapter->rx_ring);
 
+        if(icr & E1000_ICR_DOUTSYNC) {
+                /* HW is reporting DMA is out of sync */
+                adapter->stats.doosync++;
+        }
+
         if (icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
                 hw->mac.get_link_status = 1;
                 if (!test_bit(__IGB_DOWN, &adapter->state))
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        netif_rx_schedule(&adapter->rx_ring[0].napi);
+        napi_schedule(&adapter->rx_ring[0].napi);
 
         return IRQ_HANDLED;
 }
 
 /**
- * igb_intr - Interrupt Handler
+ * igb_intr - Legacy Interrupt Handler
  * @irq: interrupt number
  * @data: pointer to a network interface device structure
  **/
@@ -3553,7 +3530,6 @@ static irqreturn_t igb_intr(int irq, void *data)
         /* Interrupt Auto-Mask...upon reading ICR, interrupts are masked.  No
          * need for the IMC write */
         u32 icr = rd32(E1000_ICR);
-        u32 eicr = 0;
         if (!icr)
                 return IRQ_NONE;  /* Not our interrupt */
 
@@ -3564,7 +3540,10 @@ static irqreturn_t igb_intr(int irq, void *data)
         if (!(icr & E1000_ICR_INT_ASSERTED))
                 return IRQ_NONE;
 
-        eicr = rd32(E1000_EICR);
+        if(icr & E1000_ICR_DOUTSYNC) {
+                /* HW is reporting DMA is out of sync */
+                adapter->stats.doosync++;
+        }
 
         if (icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
                 hw->mac.get_link_status = 1;
@@ -3573,7 +3552,7 @@ static irqreturn_t igb_intr(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-        netif_rx_schedule(&adapter->rx_ring[0].napi);
+        napi_schedule(&adapter->rx_ring[0].napi);
 
         return IRQ_HANDLED;
 }
@@ -3608,7 +3587,7 @@ static int igb_poll(struct napi_struct *napi, int budget)
             !netif_running(netdev)) {
                 if (adapter->itr_setting & 3)
                         igb_set_itr(adapter);
-                netif_rx_complete(napi);
+                napi_complete(napi);
                 if (!test_bit(__IGB_DOWN, &adapter->state))
                         igb_irq_enable(adapter);
                 return 0;
@@ -3634,7 +3613,7 @@ static int igb_clean_rx_ring_msix(struct napi_struct *napi, int budget)
 
         /* If not enough Rx work done, exit the polling mode */
         if ((work_done == 0) || !netif_running(netdev)) {
-                netif_rx_complete(napi);
+                napi_complete(napi);
 
                 if (adapter->itr_setting & 3) {
                         if (adapter->num_rx_queues == 1)
@@ -3764,42 +3743,9 @@ static bool igb_clean_tx_irq(struct igb_ring *tx_ring)
         return (count < tx_ring->count);
 }
 
-#ifdef CONFIG_IGB_LRO
- /**
- * igb_get_skb_hdr - helper function for LRO header processing
- * @skb: pointer to sk_buff to be added to LRO packet
- * @iphdr: pointer to ip header structure
- * @tcph: pointer to tcp header structure
- * @hdr_flags: pointer to header flags
- * @priv: pointer to the receive descriptor for the current sk_buff
- **/
-static int igb_get_skb_hdr(struct sk_buff *skb, void **iphdr, void **tcph,
-                           u64 *hdr_flags, void *priv)
-{
-        union e1000_adv_rx_desc *rx_desc = priv;
-        u16 pkt_type = rx_desc->wb.lower.lo_dword.pkt_info &
-                       (E1000_RXDADV_PKTTYPE_IPV4 | E1000_RXDADV_PKTTYPE_TCP);
-
-        /* Verify that this is a valid IPv4 TCP packet */
-        if (pkt_type != (E1000_RXDADV_PKTTYPE_IPV4 |
-                          E1000_RXDADV_PKTTYPE_TCP))
-                return -1;
-
-        /* Set network headers */
-        skb_reset_network_header(skb);
-        skb_set_transport_header(skb, ip_hdrlen(skb));
-        *iphdr = ip_hdr(skb);
-        *tcph = tcp_hdr(skb);
-        *hdr_flags = LRO_IPV4 | LRO_TCP;
-
-        return 0;
-
-}
-#endif /* CONFIG_IGB_LRO */
-
 /**
  * igb_receive_skb - helper function to handle rx indications
- * @ring: pointer to receive ring receving this packet 
+ * @ring: pointer to receive ring receving this packet
  * @status: descriptor status field as written by hardware
  * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
  * @skb: pointer to sk_buff to be indicated to stack
@@ -3811,28 +3757,21 @@ static void igb_receive_skb(struct igb_ring *ring, u8 status,
         struct igb_adapter * adapter = ring->adapter;
         bool vlan_extracted = (adapter->vlgrp && (status & E1000_RXD_STAT_VP));
 
-#ifdef CONFIG_IGB_LRO
-        if (adapter->netdev->features & NETIF_F_LRO &&
-            skb->ip_summed == CHECKSUM_UNNECESSARY) {
+        skb_record_rx_queue(skb, ring->queue_index);
+        if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
                 if (vlan_extracted)
-                        lro_vlan_hwaccel_receive_skb(&ring->lro_mgr, skb,
-                                           adapter->vlgrp,
-                                           le16_to_cpu(rx_desc->wb.upper.vlan),
-                                           rx_desc);
+                        vlan_gro_receive(&ring->napi, adapter->vlgrp,
+                                         le16_to_cpu(rx_desc->wb.upper.vlan),
+                                         skb);
                 else
-                        lro_receive_skb(&ring->lro_mgr,skb, rx_desc);
-                ring->lro_used = 1;
+                        napi_gro_receive(&ring->napi, skb);
         } else {
-#endif
                 if (vlan_extracted)
                         vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
                                           le16_to_cpu(rx_desc->wb.upper.vlan));
                 else
-
                         netif_receive_skb(skb);
-#ifdef CONFIG_IGB_LRO
         }
-#endif
 }
 
 
@@ -3874,6 +3813,7 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
         unsigned int total_bytes = 0, total_packets = 0;
 
         i = rx_ring->next_to_clean;
+        buffer_info = &rx_ring->buffer_info[i];
         rx_desc = E1000_RX_DESC_ADV(*rx_ring, i);
         staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
 
@@ -3881,25 +3821,22 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
                 if (*work_done >= budget)
                         break;
                 (*work_done)++;
-                buffer_info = &rx_ring->buffer_info[i];
 
-                /* HW will not DMA in data larger than the given buffer, even
-                 * if it parses the (NFS, of course) header to be larger.  In
-                 * that case, it fills the header buffer and spills the rest
-                 * into the page.
-                 */
-                hlen = (le16_to_cpu(rx_desc->wb.lower.lo_dword.hdr_info) &
-                  E1000_RXDADV_HDRBUFLEN_MASK) >> E1000_RXDADV_HDRBUFLEN_SHIFT;
-                if (hlen > adapter->rx_ps_hdr_size)
-                        hlen = adapter->rx_ps_hdr_size;
+                skb = buffer_info->skb;
+                prefetch(skb->data - NET_IP_ALIGN);
+                buffer_info->skb = NULL;
+
+                i++;
+                if (i == rx_ring->count)
+                        i = 0;
+                next_rxd = E1000_RX_DESC_ADV(*rx_ring, i);
+                prefetch(next_rxd);
+                next_buffer = &rx_ring->buffer_info[i];
 
                 length = le16_to_cpu(rx_desc->wb.upper.length);
                 cleaned = true;
                 cleaned_count++;
 
-                skb = buffer_info->skb;
-                prefetch(skb->data - NET_IP_ALIGN);
-                buffer_info->skb = NULL;
                 if (!adapter->rx_ps_hdr_size) {
                         pci_unmap_single(pdev, buffer_info->dma,
                                          adapter->rx_buffer_len +
@@ -3909,6 +3846,16 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
                         goto send_up;
                 }
 
+                /* HW will not DMA in data larger than the given buffer, even
+                 * if it parses the (NFS, of course) header to be larger.  In
+                 * that case, it fills the header buffer and spills the rest
+                 * into the page.
+                 */
+                hlen = (le16_to_cpu(rx_desc->wb.lower.lo_dword.hdr_info) &
+                  E1000_RXDADV_HDRBUFLEN_MASK) >> E1000_RXDADV_HDRBUFLEN_SHIFT;
+                if (hlen > adapter->rx_ps_hdr_size)
+                        hlen = adapter->rx_ps_hdr_size;
+
                 if (!skb_shinfo(skb)->nr_frags) {
                         pci_unmap_single(pdev, buffer_info->dma,
                                          adapter->rx_ps_hdr_size +
@@ -3938,13 +3885,6 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
 
                         skb->truesize += length;
                 }
-send_up:
-                i++;
-                if (i == rx_ring->count)
-                        i = 0;
-                next_rxd = E1000_RX_DESC_ADV(*rx_ring, i);
-                prefetch(next_rxd);
-                next_buffer = &rx_ring->buffer_info[i];
 
                 if (!(staterr & E1000_RXD_STAT_EOP)) {
                         buffer_info->skb = next_buffer->skb;
@@ -3953,7 +3893,7 @@ send_up:
                         next_buffer->dma = 0;
                         goto next_desc;
                 }
-
+send_up:
                 if (staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) {
                         dev_kfree_skb_irq(skb);
                         goto next_desc;
@@ -3980,20 +3920,12 @@ next_desc:
                 /* use prefetched values */
                 rx_desc = next_rxd;
                 buffer_info = next_buffer;
-
                 staterr = le32_to_cpu(rx_desc->wb.upper.status_error);
         }
 
         rx_ring->next_to_clean = i;
         cleaned_count = IGB_DESC_UNUSED(rx_ring);
 
-#ifdef CONFIG_IGB_LRO
-        if (rx_ring->lro_used) {
-                lro_flush_all(&rx_ring->lro_mgr);
-                rx_ring->lro_used = 0;
-        }
-#endif
-
         if (cleaned_count)
                 igb_alloc_rx_buffers_adv(rx_ring, cleaned_count);
 
@@ -4021,10 +3953,17 @@ static void igb_alloc_rx_buffers_adv(struct igb_ring *rx_ring,
         struct igb_buffer *buffer_info;
         struct sk_buff *skb;
         unsigned int i;
+        int bufsz;
 
         i = rx_ring->next_to_use;
         buffer_info = &rx_ring->buffer_info[i];
 
+        if (adapter->rx_ps_hdr_size)
+                bufsz = adapter->rx_ps_hdr_size;
+        else
+                bufsz = adapter->rx_buffer_len;
+        bufsz += NET_IP_ALIGN;
+
         while (cleaned_count--) {
                 rx_desc = E1000_RX_DESC_ADV(*rx_ring, i);
 
@@ -4040,23 +3979,14 @@ static void igb_alloc_rx_buffers_adv(struct igb_ring *rx_ring,
                                 buffer_info->page_offset ^= PAGE_SIZE / 2;
                         }
                         buffer_info->page_dma =
-                                pci_map_page(pdev,
-                                             buffer_info->page,
+                                pci_map_page(pdev, buffer_info->page,
                                              buffer_info->page_offset,
                                              PAGE_SIZE / 2,
                                              PCI_DMA_FROMDEVICE);
                 }
 
                 if (!buffer_info->skb) {
-                        int bufsz;
-
-                        if (adapter->rx_ps_hdr_size)
-                                bufsz = adapter->rx_ps_hdr_size;
-                        else
-                                bufsz = adapter->rx_buffer_len;
-                        bufsz += NET_IP_ALIGN;
                         skb = netdev_alloc_skb(netdev, bufsz);
-
                         if (!skb) {
                                 adapter->alloc_rx_buff_failed++;
                                 goto no_buffers;
@@ -4072,7 +4002,6 @@ static void igb_alloc_rx_buffers_adv(struct igb_ring *rx_ring,
                         buffer_info->dma = pci_map_single(pdev, skb->data,
                                                           bufsz,
                                                           PCI_DMA_FROMDEVICE);
-
                 }
                 /* Refresh the desc even if buffer_addrs didn't change because
                  * each write-back erases this info. */
@@ -4206,7 +4135,7 @@ static void igb_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
         struct e1000_hw *hw = &adapter->hw;
         u32 vfta, index;
 
-        if ((adapter->hw.mng_cookie.status &
+        if ((hw->mng_cookie.status &
              E1000_MNG_DHCP_COOKIE_STATUS_VLAN) &&
             (vid == adapter->mng_vlan_id))
                 return;
@@ -4390,10 +4319,7 @@ static int igb_resume(struct pci_dev *pdev)
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
 
-        if (adapter->need_ioport)
-                err = pci_enable_device(pdev);
-        else
-                err = pci_enable_device_mem(pdev);
+        err = pci_enable_device_mem(pdev);
         if (err) {
                 dev_err(&pdev->dev,
                         "igb: Cannot enable PCI device from suspend\n");
@@ -4414,6 +4340,11 @@ static int igb_resume(struct pci_dev *pdev)
         /* e1000_power_up_phy(adapter); */
 
         igb_reset(adapter);
+
+        /* let the f/w know that the h/w is now under the control of the
+         * driver. */
+        igb_get_hw_control(adapter);
+
         wr32(E1000_WUS, ~0);
 
         if (netif_running(netdev)) {
@@ -4424,10 +4355,6 @@ static int igb_resume(struct pci_dev *pdev)
 
         netif_device_attach(netdev);
 
-        /* let the f/w know that the h/w is now under the control of the
-         * driver. */
-        igb_get_hw_control(adapter);
-
         return 0;
 }
 #endif
@@ -4446,22 +4373,27 @@ static void igb_shutdown(struct pci_dev *pdev)
 static void igb_netpoll(struct net_device *netdev)
 {
         struct igb_adapter *adapter = netdev_priv(netdev);
+        struct e1000_hw *hw = &adapter->hw;
         int i;
-        int work_done = 0;
 
-        igb_irq_disable(adapter);
-        adapter->flags |= IGB_FLAG_IN_NETPOLL;
-
-        for (i = 0; i < adapter->num_tx_queues; i++)
-                igb_clean_tx_irq(&adapter->tx_ring[i]);
+        if (!adapter->msix_entries) {
+                igb_irq_disable(adapter);
+                napi_schedule(&adapter->rx_ring[0].napi);
+                return;
+        }
 
-        for (i = 0; i < adapter->num_rx_queues; i++)
-                igb_clean_rx_irq_adv(&adapter->rx_ring[i],
-                                     &work_done,
-                                     adapter->rx_ring[i].napi.weight);
+        for (i = 0; i < adapter->num_tx_queues; i++) {
+                struct igb_ring *tx_ring = &adapter->tx_ring[i];
+                wr32(E1000_EIMC, tx_ring->eims_value);
+                igb_clean_tx_irq(tx_ring);
+                wr32(E1000_EIMS, tx_ring->eims_value);
+        }
 
-        adapter->flags &= ~IGB_FLAG_IN_NETPOLL;
-        igb_irq_enable(adapter);
+        for (i = 0; i < adapter->num_rx_queues; i++) {
+                struct igb_ring *rx_ring = &adapter->rx_ring[i];
+                wr32(E1000_EIMC, rx_ring->eims_value);
+                napi_schedule(&rx_ring->napi);
+        }
 }
 #endif /* CONFIG_NET_POLL_CONTROLLER */
 
@@ -4504,12 +4436,7 @@ static pci_ers_result_t igb_io_slot_reset(struct pci_dev *pdev)
         pci_ers_result_t result;
         int err;
 
-        if (adapter->need_ioport)
-                err = pci_enable_device(pdev);
-        else
-                err = pci_enable_device_mem(pdev);
-
-        if (err) {
+        if (pci_enable_device_mem(pdev)) {
                 dev_err(&pdev->dev,
                         "Cannot re-enable PCI device after reset.\n");
                 result = PCI_ERS_RESULT_DISCONNECT;