Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/net-queue

Jeff Kirsher says:

====================
Intel Wired LAN Driver Updates 2015-06-26

This series contains fixes for igb, e1000e and i40evf.

Todd disables IPv6 extension header processing due to a hardware errata
and bumps the driver version.

Yanir provides six fixes for e1000e.  First is a fix for a locking issue
where we were not always taking the pci_bus_sem semaphore all the time
when calling pci_disable_link_state_locked(), so fix the code to only call
pci_disable_link_state_locked() when the semaphore has been acquired,
otherwise call pci_disable_link_state().  A previous fix for i219 where
the hardware prevented ULP entry caused EEE in Sx not the be enabled, so
modify the code flow that allows both ULP and EEE in Sx.  Fix an issue
when running 10/100 full duplex on i219 where CRC errors were occurring
by increasing the IPG from 8 to 0xC as per the hardware developers.
Fix a data corruption issue found on some platforms by increasing the
minimum gap between the PHY FIFO read and write pointers.  Fix i219,
which does not require the K1 workaround for LPT devices.

Mitch provides a i40evf fix for a panic when changing MTU.  Down was
requesting queue disables, but then exited immediately without waiting
for the queues to actually be disabled.  This could allow any function
called after i40evf_down() to run immediately, including i40evf_up(),
and causes a memory leak.  Fixed the issue by removing the whole
reinit_locked function which allows for the driver to handle the state
changes by requesting reset from the periodic timer.  The second fix
resolves an issue where RSS was being configured as though it is using
the maximum number of queue.  This can cause the device to drop a lot
of receive traffic, as the packets get assigned to non-functional queues.
This is resolved by only configuring RSS with the number of active queues.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

9 files changed, 198 insertions, 104 deletions

diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index b074b9a667b3..91a5a0ae9cd7 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -237,17 +237,19 @@ static bool e1000_phy_is_accessible_pchlan(struct e1000_hw *hw)
         if (ret_val)
                 return false;
 out:
-        if ((hw->mac.type == e1000_pch_lpt) ||
-            (hw->mac.type == e1000_pch_spt)) {
-                /* Unforce SMBus mode in PHY */
-                e1e_rphy_locked(hw, CV_SMB_CTRL, &phy_reg);
-                phy_reg &= ~CV_SMB_CTRL_FORCE_SMBUS;
-                e1e_wphy_locked(hw, CV_SMB_CTRL, phy_reg);
+        if ((hw->mac.type == e1000_pch_lpt) || (hw->mac.type == e1000_pch_spt)) {
+                /* Only unforce SMBus if ME is not active */
+                if (!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
+                        /* Unforce SMBus mode in PHY */
+                        e1e_rphy_locked(hw, CV_SMB_CTRL, &phy_reg);
+                        phy_reg &= ~CV_SMB_CTRL_FORCE_SMBUS;
+                        e1e_wphy_locked(hw, CV_SMB_CTRL, phy_reg);
 
-                /* Unforce SMBus mode in MAC */
-                mac_reg = er32(CTRL_EXT);
-                mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
-                ew32(CTRL_EXT, mac_reg);
+                        /* Unforce SMBus mode in MAC */
+                        mac_reg = er32(CTRL_EXT);
+                        mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
+                        ew32(CTRL_EXT, mac_reg);
+                }
         }
 
         return true;
@@ -1087,6 +1089,7 @@ s32 e1000_enable_ulp_lpt_lp(struct e1000_hw *hw, bool to_sx)
         u32 mac_reg;
         s32 ret_val = 0;
         u16 phy_reg;
+        u16 oem_reg = 0;
 
         if ((hw->mac.type < e1000_pch_lpt) ||
             (hw->adapter->pdev->device == E1000_DEV_ID_PCH_LPT_I217_LM) ||
@@ -1128,33 +1131,37 @@ s32 e1000_enable_ulp_lpt_lp(struct e1000_hw *hw, bool to_sx)
         if (ret_val)
                 goto out;
 
+        /* Force SMBus mode in PHY */
+        ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL, &phy_reg);
+        if (ret_val)
+                goto release;
+        phy_reg |= CV_SMB_CTRL_FORCE_SMBUS;
+        e1000_write_phy_reg_hv_locked(hw, CV_SMB_CTRL, phy_reg);
+
+        /* Force SMBus mode in MAC */
+        mac_reg = er32(CTRL_EXT);
+        mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
+        ew32(CTRL_EXT, mac_reg);
+
         /* Si workaround for ULP entry flow on i127/rev6 h/w.  Enable
          * LPLU and disable Gig speed when entering ULP
          */
         if ((hw->phy.type == e1000_phy_i217) && (hw->phy.revision == 6)) {
                 ret_val = e1000_read_phy_reg_hv_locked(hw, HV_OEM_BITS,
-                                                       &phy_reg);
+                                                       &oem_reg);
                 if (ret_val)
                         goto release;
+
+                phy_reg = oem_reg;
                 phy_reg |= HV_OEM_BITS_LPLU | HV_OEM_BITS_GBE_DIS;
+
                 ret_val = e1000_write_phy_reg_hv_locked(hw, HV_OEM_BITS,
                                                         phy_reg);
+
                 if (ret_val)
                         goto release;
         }
 
-        /* Force SMBus mode in PHY */
-        ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL, &phy_reg);
-        if (ret_val)
-                goto release;
-        phy_reg |= CV_SMB_CTRL_FORCE_SMBUS;
-        e1000_write_phy_reg_hv_locked(hw, CV_SMB_CTRL, phy_reg);
-
-        /* Force SMBus mode in MAC */
-        mac_reg = er32(CTRL_EXT);
-        mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
-        ew32(CTRL_EXT, mac_reg);
-
         /* Set Inband ULP Exit, Reset to SMBus mode and
          * Disable SMBus Release on PERST# in PHY
          */
@@ -1166,10 +1173,15 @@ s32 e1000_enable_ulp_lpt_lp(struct e1000_hw *hw, bool to_sx)
         if (to_sx) {
                 if (er32(WUFC) & E1000_WUFC_LNKC)
                         phy_reg |= I218_ULP_CONFIG1_WOL_HOST;
+                else
+                        phy_reg &= ~I218_ULP_CONFIG1_WOL_HOST;
 
                 phy_reg |= I218_ULP_CONFIG1_STICKY_ULP;
+                phy_reg &= ~I218_ULP_CONFIG1_INBAND_EXIT;
         } else {
                 phy_reg |= I218_ULP_CONFIG1_INBAND_EXIT;
+                phy_reg &= ~I218_ULP_CONFIG1_STICKY_ULP;
+                phy_reg &= ~I218_ULP_CONFIG1_WOL_HOST;
         }
         e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
 
@@ -1181,6 +1193,15 @@ s32 e1000_enable_ulp_lpt_lp(struct e1000_hw *hw, bool to_sx)
         /* Commit ULP changes in PHY by starting auto ULP configuration */
         phy_reg |= I218_ULP_CONFIG1_START;
         e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
+
+        if ((hw->phy.type == e1000_phy_i217) && (hw->phy.revision == 6) &&
+            to_sx && (er32(STATUS) & E1000_STATUS_LU)) {
+                ret_val = e1000_write_phy_reg_hv_locked(hw, HV_OEM_BITS,
+                                                        oem_reg);
+                if (ret_val)
+                        goto release;
+        }
+
 release:
         hw->phy.ops.release(hw);
 out:
@@ -1379,16 +1400,20 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
         if (((hw->mac.type == e1000_pch2lan) ||
              (hw->mac.type == e1000_pch_lpt) ||
              (hw->mac.type == e1000_pch_spt)) && link) {
-                u32 reg;
+                u16 speed, duplex;
 
-                reg = er32(STATUS);
+                e1000e_get_speed_and_duplex_copper(hw, &speed, &duplex);
                 tipg_reg = er32(TIPG);
                 tipg_reg &= ~E1000_TIPG_IPGT_MASK;
 
-                if (!(reg & (E1000_STATUS_FD | E1000_STATUS_SPEED_MASK))) {
+                if (duplex == HALF_DUPLEX && speed == SPEED_10) {
                         tipg_reg |= 0xFF;
                         /* Reduce Rx latency in analog PHY */
                         emi_val = 0;
+                } else if (hw->mac.type == e1000_pch_spt &&
+                           duplex == FULL_DUPLEX && speed != SPEED_1000) {
+                        tipg_reg |= 0xC;
+                        emi_val = 1;
                 } else {
 
                         /* Roll back the default values */
@@ -1412,14 +1437,59 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
 
                 if (ret_val)
                         return ret_val;
+
+                if (hw->mac.type == e1000_pch_spt) {
+                        u16 data;
+                        u16 ptr_gap;
+
+                        if (speed == SPEED_1000) {
+                                ret_val = hw->phy.ops.acquire(hw);
+                                if (ret_val)
+                                        return ret_val;
+
+                                ret_val = e1e_rphy_locked(hw,
+                                                          PHY_REG(776, 20),
+                                                          &data);
+                                if (ret_val) {
+                                        hw->phy.ops.release(hw);
+                                        return ret_val;
+                                }
+
+                                ptr_gap = (data & (0x3FF << 2)) >> 2;
+                                if (ptr_gap < 0x18) {
+                                        data &= ~(0x3FF << 2);
+                                        data |= (0x18 << 2);
+                                        ret_val =
+                                            e1e_wphy_locked(hw,
+                                                            PHY_REG(776, 20),
+                                                            data);
+                                }
+                                hw->phy.ops.release(hw);
+                                if (ret_val)
+                                        return ret_val;
+                        }
+                }
+        }
+
+        /* I217 Packet Loss issue:
+         * ensure that FEXTNVM4 Beacon Duration is set correctly
+         * on power up.
+         * Set the Beacon Duration for I217 to 8 usec
+         */
+        if ((hw->mac.type == e1000_pch_lpt) || (hw->mac.type == e1000_pch_spt)) {
+                u32 mac_reg;
+
+                mac_reg = er32(FEXTNVM4);
+                mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
+                mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
+                ew32(FEXTNVM4, mac_reg);
         }
 
         /* Work-around I218 hang issue */
         if ((hw->adapter->pdev->device == E1000_DEV_ID_PCH_LPTLP_I218_LM) ||
             (hw->adapter->pdev->device == E1000_DEV_ID_PCH_LPTLP_I218_V) ||
             (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_LM3) ||
-            (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_V3) ||
-            (hw->mac.type == e1000_pch_spt)) {
+            (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_V3)) {
                 ret_val = e1000_k1_workaround_lpt_lp(hw, link);
                 if (ret_val)
                         return ret_val;
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index e62b9dcb91fe..89d788d8f263 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -6354,13 +6354,14 @@ static int __e1000_shutdown(struct pci_dev *pdev, bool runtime)
 }
 
 /**
- * e1000e_disable_aspm - Disable ASPM states
+ * __e1000e_disable_aspm - Disable ASPM states
  * @pdev: pointer to PCI device struct
  * @state: bit-mask of ASPM states to disable
+ * @locked: indication if this context holds pci_bus_sem locked.
  *
  * Some devices *must* have certain ASPM states disabled per hardware errata.
  **/
-static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
+static void __e1000e_disable_aspm(struct pci_dev *pdev, u16 state, int locked)
 {
         struct pci_dev *parent = pdev->bus->self;
         u16 aspm_dis_mask = 0;
@@ -6399,7 +6400,10 @@ static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
                  "L1" : "");
 
 #ifdef CONFIG_PCIEASPM
-        pci_disable_link_state_locked(pdev, state);
+        if (locked)
+                pci_disable_link_state_locked(pdev, state);
+        else
+                pci_disable_link_state(pdev, state);
 
         /* Double-check ASPM control.  If not disabled by the above, the
          * BIOS is preventing that from happening (or CONFIG_PCIEASPM is
@@ -6422,6 +6426,32 @@ static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
                                            aspm_dis_mask);
 }
 
+/**
+ * e1000e_disable_aspm - Disable ASPM states.
+ * @pdev: pointer to PCI device struct
+ * @state: bit-mask of ASPM states to disable
+ *
+ * This function acquires the pci_bus_sem!
+ * Some devices *must* have certain ASPM states disabled per hardware errata.
+ **/
+static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
+{
+        __e1000e_disable_aspm(pdev, state, 0);
+}
+
+/**
+ * e1000e_disable_aspm_locked   Disable ASPM states.
+ * @pdev: pointer to PCI device struct
+ * @state: bit-mask of ASPM states to disable
+ *
+ * This function must be called with pci_bus_sem acquired!
+ * Some devices *must* have certain ASPM states disabled per hardware errata.
+ **/
+static void e1000e_disable_aspm_locked(struct pci_dev *pdev, u16 state)
+{
+        __e1000e_disable_aspm(pdev, state, 1);
+}
+
 #ifdef CONFIG_PM
 static int __e1000_resume(struct pci_dev *pdev)
 {
@@ -6435,7 +6465,7 @@ static int __e1000_resume(struct pci_dev *pdev)
         if (adapter->flags2 & FLAG2_DISABLE_ASPM_L1)
                 aspm_disable_flag |= PCIE_LINK_STATE_L1;
         if (aspm_disable_flag)
-                e1000e_disable_aspm(pdev, aspm_disable_flag);
+                e1000e_disable_aspm_locked(pdev, aspm_disable_flag);
 
         pci_set_master(pdev);
 
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
index f54996f19629..395f32f226c0 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
@@ -484,6 +484,8 @@ int i40evf_setup_tx_descriptors(struct i40e_ring *tx_ring)
         if (!dev)
                 return -ENOMEM;
 
+        /* warn if we are about to overwrite the pointer */
+        WARN_ON(tx_ring->tx_bi);
         bi_size = sizeof(struct i40e_tx_buffer) * tx_ring->count;
         tx_ring->tx_bi = kzalloc(bi_size, GFP_KERNEL);
         if (!tx_ring->tx_bi)
@@ -644,6 +646,8 @@ int i40evf_setup_rx_descriptors(struct i40e_ring *rx_ring)
         struct device *dev = rx_ring->dev;
         int bi_size;
 
+        /* warn if we are about to overwrite the pointer */
+        WARN_ON(rx_ring->rx_bi);
         bi_size = sizeof(struct i40e_rx_buffer) * rx_ring->count;
         rx_ring->rx_bi = kzalloc(bi_size, GFP_KERNEL);
         if (!rx_ring->rx_bi)
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf.h b/drivers/net/ethernet/intel/i40evf/i40evf.h
index 1b98c25b3092..fea3b75a9a35 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf.h
+++ b/drivers/net/ethernet/intel/i40evf/i40evf.h
@@ -264,7 +264,6 @@ extern const char i40evf_driver_version[];
 
 int i40evf_up(struct i40evf_adapter *adapter);
 void i40evf_down(struct i40evf_adapter *adapter);
-void i40evf_reinit_locked(struct i40evf_adapter *adapter);
 void i40evf_reset(struct i40evf_adapter *adapter);
 void i40evf_set_ethtool_ops(struct net_device *netdev);
 void i40evf_update_stats(struct i40evf_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c b/drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c
index f4e77665bc54..2b53c870e7f1 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c
@@ -267,8 +267,10 @@ static int i40evf_set_ringparam(struct net_device *netdev,
         adapter->tx_desc_count = new_tx_count;
         adapter->rx_desc_count = new_rx_count;
 
-        if (netif_running(netdev))
-                i40evf_reinit_locked(adapter);
+        if (netif_running(netdev)) {
+                adapter->flags |= I40EVF_FLAG_RESET_NEEDED;
+                schedule_work(&adapter->reset_task);
+        }
 
         return 0;
 }
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_main.c b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
index 7c53aca4b5a6..4ab4ebba07a1 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_main.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
@@ -170,7 +170,8 @@ static void i40evf_tx_timeout(struct net_device *netdev)
         struct i40evf_adapter *adapter = netdev_priv(netdev);
 
         adapter->tx_timeout_count++;
-        if (!(adapter->flags & I40EVF_FLAG_RESET_PENDING)) {
+        if (!(adapter->flags & (I40EVF_FLAG_RESET_PENDING |
+                                I40EVF_FLAG_RESET_NEEDED))) {
                 adapter->flags |= I40EVF_FLAG_RESET_NEEDED;
                 schedule_work(&adapter->reset_task);
         }
@@ -1460,7 +1461,7 @@ static void i40evf_configure_rss(struct i40evf_adapter *adapter)
         for (i = 0; i <= I40E_VFQF_HLUT_MAX_INDEX; i++) {
                 lut = 0;
                 for (j = 0; j < 4; j++) {
-                        if (cqueue == adapter->vsi_res->num_queue_pairs)
+                        if (cqueue == adapter->num_active_queues)
                                 cqueue = 0;
                         lut |= ((cqueue) << (8 * j));
                         cqueue++;
@@ -1470,8 +1471,8 @@ static void i40evf_configure_rss(struct i40evf_adapter *adapter)
         i40e_flush(hw);
 }
 
-#define I40EVF_RESET_WAIT_MS 100
-#define I40EVF_RESET_WAIT_COUNT 200
+#define I40EVF_RESET_WAIT_MS 10
+#define I40EVF_RESET_WAIT_COUNT 500
 /**
  * i40evf_reset_task - Call-back task to handle hardware reset
  * @work: pointer to work_struct
@@ -1495,10 +1496,17 @@ static void i40evf_reset_task(struct work_struct *work)
                                 &adapter->crit_section))
                 usleep_range(500, 1000);
 
+        i40evf_misc_irq_disable(adapter);
         if (adapter->flags & I40EVF_FLAG_RESET_NEEDED) {
-                dev_info(&adapter->pdev->dev, "Requesting reset from PF\n");
+                adapter->flags &= ~I40EVF_FLAG_RESET_NEEDED;
+                /* Restart the AQ here. If we have been reset but didn't
+                 * detect it, or if the PF had to reinit, our AQ will be hosed.
+                 */
+                i40evf_shutdown_adminq(hw);
+                i40evf_init_adminq(hw);
                 i40evf_request_reset(adapter);
         }
+        adapter->flags |= I40EVF_FLAG_RESET_PENDING;
 
         /* poll until we see the reset actually happen */
         for (i = 0; i < I40EVF_RESET_WAIT_COUNT; i++) {
@@ -1507,10 +1515,10 @@ static void i40evf_reset_task(struct work_struct *work)
                 if ((rstat_val != I40E_VFR_VFACTIVE) &&
                     (rstat_val != I40E_VFR_COMPLETED))
                         break;
-                msleep(I40EVF_RESET_WAIT_MS);
+                usleep_range(500, 1000);
         }
         if (i == I40EVF_RESET_WAIT_COUNT) {
-                adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
+                dev_info(&adapter->pdev->dev, "Never saw reset\n");
                 goto continue_reset; /* act like the reset happened */
         }
 
@@ -1518,11 +1526,12 @@ static void i40evf_reset_task(struct work_struct *work)
         for (i = 0; i < I40EVF_RESET_WAIT_COUNT; i++) {
                 rstat_val = rd32(hw, I40E_VFGEN_RSTAT) &
                             I40E_VFGEN_RSTAT_VFR_STATE_MASK;
-                if ((rstat_val == I40E_VFR_VFACTIVE) ||
-                    (rstat_val == I40E_VFR_COMPLETED))
+                if (rstat_val == I40E_VFR_VFACTIVE)
                         break;
                 msleep(I40EVF_RESET_WAIT_MS);
         }
+        /* extra wait to make sure minimum wait is met */
+        msleep(I40EVF_RESET_WAIT_MS);
         if (i == I40EVF_RESET_WAIT_COUNT) {
                 struct i40evf_mac_filter *f, *ftmp;
                 struct i40evf_vlan_filter *fv, *fvtmp;
@@ -1534,11 +1543,10 @@ static void i40evf_reset_task(struct work_struct *work)
 
                 if (netif_running(adapter->netdev)) {
                         set_bit(__I40E_DOWN, &adapter->vsi.state);
-                        i40evf_irq_disable(adapter);
-                        i40evf_napi_disable_all(adapter);
-                        netif_tx_disable(netdev);
-                        netif_tx_stop_all_queues(netdev);
                         netif_carrier_off(netdev);
+                        netif_tx_disable(netdev);
+                        i40evf_napi_disable_all(adapter);
+                        i40evf_irq_disable(adapter);
                         i40evf_free_traffic_irqs(adapter);
                         i40evf_free_all_tx_resources(adapter);
                         i40evf_free_all_rx_resources(adapter);
@@ -1550,6 +1558,7 @@ static void i40evf_reset_task(struct work_struct *work)
                         list_del(&f->list);
                         kfree(f);
                 }
+
                 list_for_each_entry_safe(fv, fvtmp, &adapter->vlan_filter_list,
                                          list) {
                         list_del(&fv->list);
@@ -1564,22 +1573,27 @@ static void i40evf_reset_task(struct work_struct *work)
                 i40evf_shutdown_adminq(hw);
                 adapter->netdev->flags &= ~IFF_UP;
                 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section);
+                adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
+                dev_info(&adapter->pdev->dev, "Reset task did not complete, VF disabled\n");
                 return; /* Do not attempt to reinit. It's dead, Jim. */
         }
 
 continue_reset:
-        adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
-
-        i40evf_irq_disable(adapter);
-
         if (netif_running(adapter->netdev)) {
-                i40evf_napi_disable_all(adapter);
-                netif_tx_disable(netdev);
-                netif_tx_stop_all_queues(netdev);
                 netif_carrier_off(netdev);
+                netif_tx_stop_all_queues(netdev);
+                i40evf_napi_disable_all(adapter);
         }
+        i40evf_irq_disable(adapter);
 
         adapter->state = __I40EVF_RESETTING;
+        adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
+
+        /* free the Tx/Rx rings and descriptors, might be better to just
+         * re-use them sometime in the future
+         */
+        i40evf_free_all_rx_resources(adapter);
+        i40evf_free_all_tx_resources(adapter);
 
         /* kill and reinit the admin queue */
         if (i40evf_shutdown_adminq(hw))
@@ -1603,6 +1617,7 @@ continue_reset:
         adapter->aq_required = I40EVF_FLAG_AQ_ADD_MAC_FILTER;
         adapter->aq_required |= I40EVF_FLAG_AQ_ADD_VLAN_FILTER;
         clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section);
+        i40evf_misc_irq_enable(adapter);
 
         mod_timer(&adapter->watchdog_timer, jiffies + 2);
 
@@ -1624,7 +1639,10 @@ continue_reset:
                         goto reset_err;
 
                 i40evf_irq_enable(adapter, true);
+        } else {
+                adapter->state = __I40EVF_DOWN;
         }
+
         return;
 reset_err:
         dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n");
@@ -1667,6 +1685,11 @@ static void i40evf_adminq_task(struct work_struct *work)
                         memset(event.msg_buf, 0, I40EVF_MAX_AQ_BUF_SIZE);
         } while (pending);
 
+        if ((adapter->flags &
+             (I40EVF_FLAG_RESET_PENDING | I40EVF_FLAG_RESET_NEEDED)) ||
+            adapter->state == __I40EVF_RESETTING)
+                goto freedom;
+
         /* check for error indications */
         val = rd32(hw, hw->aq.arq.len);
         oldval = val;
@@ -1702,6 +1725,7 @@ static void i40evf_adminq_task(struct work_struct *work)
         if (oldval != val)
                 wr32(hw, hw->aq.asq.len, val);
 
+freedom:
         kfree(event.msg_buf);
 out:
         /* re-enable Admin queue interrupt cause */
@@ -1897,47 +1921,6 @@ static struct net_device_stats *i40evf_get_stats(struct net_device *netdev)
 }
 
 /**
- * i40evf_reinit_locked - Software reinit
- * @adapter: board private structure
- *
- * Reinititalizes the ring structures in response to a software configuration
- * change. Roughly the same as close followed by open, but skips releasing
- * and reallocating the interrupts.
- **/
-void i40evf_reinit_locked(struct i40evf_adapter *adapter)
-{
-        struct net_device *netdev = adapter->netdev;
-        int err;
-
-        WARN_ON(in_interrupt());
-
-        i40evf_down(adapter);
-
-        /* allocate transmit descriptors */
-        err = i40evf_setup_all_tx_resources(adapter);
-        if (err)
-                goto err_reinit;
-
-        /* allocate receive descriptors */
-        err = i40evf_setup_all_rx_resources(adapter);
-        if (err)
-                goto err_reinit;
-
-        i40evf_configure(adapter);
-
-        err = i40evf_up_complete(adapter);
-        if (err)
-                goto err_reinit;
-
-        i40evf_irq_enable(adapter, true);
-        return;
-
-err_reinit:
-        dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n");
-        i40evf_close(netdev);
-}
-
-/**
  * i40evf_change_mtu - Change the Maximum Transfer Unit
  * @netdev: network interface device structure
  * @new_mtu: new value for maximum frame size
@@ -1952,9 +1935,10 @@ static int i40evf_change_mtu(struct net_device *netdev, int new_mtu)
         if ((new_mtu < 68) || (max_frame > I40E_MAX_RXBUFFER))
                 return -EINVAL;
 
-        /* must set new MTU before calling down or up */
         netdev->mtu = new_mtu;
-        i40evf_reinit_locked(adapter);
+        adapter->flags |= I40EVF_FLAG_RESET_NEEDED;
+        schedule_work(&adapter->reset_task);
+
         return 0;
 }
 
diff --git a/drivers/net/ethernet/intel/igb/e1000_82575.c b/drivers/net/ethernet/intel/igb/e1000_82575.c
index 0f69ef81751a..b0182dd31346 100644
--- a/drivers/net/ethernet/intel/igb/e1000_82575.c
+++ b/drivers/net/ethernet/intel/igb/e1000_82575.c
@@ -1,5 +1,5 @@
 /* Intel(R) Gigabit Ethernet Linux driver
- * Copyright(c) 2007-2014 Intel Corporation.
+ * Copyright(c) 2007-2015 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,
@@ -1900,8 +1900,8 @@ static void igb_clear_hw_cntrs_82575(struct e1000_hw *hw)
  *  igb_rx_fifo_flush_82575 - Clean rx fifo after RX enable
  *  @hw: pointer to the HW structure
  *
- *  After rx enable if managability is enabled then there is likely some
- *  bad data at the start of the fifo and possibly in the DMA fifo.  This
+ *  After rx enable if manageability is enabled then there is likely some
+ *  bad data at the start of the fifo and possibly in the DMA fifo. This
  *  function clears the fifos and flushes any packets that came in as rx was
  *  being enabled.
  **/
@@ -1910,6 +1910,11 @@ void igb_rx_fifo_flush_82575(struct e1000_hw *hw)
         u32 rctl, rlpml, rxdctl[4], rfctl, temp_rctl, rx_enabled;
         int i, ms_wait;
 
+        /* disable IPv6 options as per hardware errata */
+        rfctl = rd32(E1000_RFCTL);
+        rfctl |= E1000_RFCTL_IPV6_EX_DIS;
+        wr32(E1000_RFCTL, rfctl);
+
         if (hw->mac.type != e1000_82575 ||
             !(rd32(E1000_MANC) & E1000_MANC_RCV_TCO_EN))
                 return;
@@ -1937,7 +1942,6 @@ void igb_rx_fifo_flush_82575(struct e1000_hw *hw)
          * incoming packets are rejected.  Set enable and wait 2ms so that
          * any packet that was coming in as RCTL.EN was set is flushed
          */
-        rfctl = rd32(E1000_RFCTL);
         wr32(E1000_RFCTL, rfctl & ~E1000_RFCTL_LEF);
 
         rlpml = rd32(E1000_RLPML);
diff --git a/drivers/net/ethernet/intel/igb/e1000_defines.h b/drivers/net/ethernet/intel/igb/e1000_defines.h
index 217f8138851b..f8684aa285be 100644
--- a/drivers/net/ethernet/intel/igb/e1000_defines.h
+++ b/drivers/net/ethernet/intel/igb/e1000_defines.h
@@ -344,7 +344,8 @@
 #define E1000_RXCSUM_PCSD      0x00002000   /* packet checksum disabled */
 
 /* Header split receive */
-#define E1000_RFCTL_LEF        0x00040000
+#define E1000_RFCTL_IPV6_EX_DIS         0x00010000
+#define E1000_RFCTL_LEF                 0x00040000
 
 /* Collision related configuration parameters */
 #define E1000_COLLISION_THRESHOLD       15
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index f287186192bb..2f70a9b152bd 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -58,7 +58,7 @@
 
 #define MAJ 5
 #define MIN 2
-#define BUILD 15
+#define BUILD 18
 #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
 __stringify(BUILD) "-k"
 char igb_driver_name[] = "igb";