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";