8 files changed, 217 insertions, 101 deletions

diff --git a/drivers/net/ethernet/intel/e100.c b/drivers/net/ethernet/intel/e100.c
index 5115ae76a5d1..ada6e210279f 100644
--- a/drivers/net/ethernet/intel/e100.c
+++ b/drivers/net/ethernet/intel/e100.c
@@ -1175,15 +1175,12 @@ static int e100_configure(struct nic *nic, struct cb *cb, struct sk_buff *skb)
                 config->rx_discard_short_frames = 0x0;  /* 1=discard, 0=save */
         }
 
-        netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
-                     "[00-07]=%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
-                     c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);
-        netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
-                     "[08-15]=%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
-                     c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15]);
-        netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
-                     "[16-23]=%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
-                     c[16], c[17], c[18], c[19], c[20], c[21], c[22], c[23]);
+        netif_printk(nic, hw, KERN_DEBUG, nic->netdev, "[00-07]=%8ph\n",
+                     c + 0);
+        netif_printk(nic, hw, KERN_DEBUG, nic->netdev, "[08-15]=%8ph\n",
+                     c + 8);
+        netif_printk(nic, hw, KERN_DEBUG, nic->netdev, "[16-23]=%8ph\n",
+                     c + 16);
         return 0;
 }
 
diff --git a/drivers/net/ethernet/intel/e1000e/82571.c b/drivers/net/ethernet/intel/e1000e/82571.c
index 4c303e2a7cb3..104fcec86af3 100644
--- a/drivers/net/ethernet/intel/e1000e/82571.c
+++ b/drivers/net/ethernet/intel/e1000e/82571.c
@@ -2057,6 +2057,7 @@ const struct e1000_info e1000_82583_info = {
                                   | FLAG_HAS_JUMBO_FRAMES
                                   | FLAG_HAS_CTRLEXT_ON_LOAD,
         .flags2                 = FLAG2_DISABLE_ASPM_L0S
+                                  | FLAG2_DISABLE_ASPM_L1
                                   | FLAG2_NO_DISABLE_RX,
         .pba                    = 32,
         .max_hw_frame_size      = DEFAULT_JUMBO,
diff --git a/drivers/net/ethernet/intel/e1000e/e1000.h b/drivers/net/ethernet/intel/e1000e/e1000.h
index ffbc08f56c40..ad0edd11015d 100644
--- a/drivers/net/ethernet/intel/e1000e/e1000.h
+++ b/drivers/net/ethernet/intel/e1000e/e1000.h
@@ -90,9 +90,6 @@ struct e1000_info;
 
 #define E1000_MNG_VLAN_NONE             (-1)
 
-/* Number of packet split data buffers (not including the header buffer) */
-#define PS_PAGE_BUFFERS                 (MAX_PS_BUFFERS - 1)
-
 #define DEFAULT_JUMBO                   9234
 
 /* Time to wait before putting the device into D3 if there's no link (in ms). */
diff --git a/drivers/net/ethernet/intel/e1000e/ethtool.c b/drivers/net/ethernet/intel/e1000e/ethtool.c
index 59c22bf18701..e4ebd7ddf5f2 100644
--- a/drivers/net/ethernet/intel/e1000e/ethtool.c
+++ b/drivers/net/ethernet/intel/e1000e/ethtool.c
@@ -173,7 +173,7 @@ static int e1000_get_settings(struct net_device *netdev,
                         speed = adapter->link_speed;
                         ecmd->duplex = adapter->link_duplex - 1;
                 }
-        } else {
+        } else if (!pm_runtime_suspended(netdev->dev.parent)) {
                 u32 status = er32(STATUS);
                 if (status & E1000_STATUS_LU) {
                         if (status & E1000_STATUS_SPEED_1000)
@@ -264,6 +264,9 @@ static int e1000_set_settings(struct net_device *netdev,
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
+        int ret_val = 0;
+
+        pm_runtime_get_sync(netdev->dev.parent);
 
         /* When SoL/IDER sessions are active, autoneg/speed/duplex
          * cannot be changed
@@ -271,7 +274,8 @@ static int e1000_set_settings(struct net_device *netdev,
         if (hw->phy.ops.check_reset_block &&
             hw->phy.ops.check_reset_block(hw)) {
                 e_err("Cannot change link characteristics when SoL/IDER is active.\n");
-                return -EINVAL;
+                ret_val = -EINVAL;
+                goto out;
         }
 
         /* MDI setting is only allowed when autoneg enabled because
@@ -279,13 +283,16 @@ static int e1000_set_settings(struct net_device *netdev,
          * duplex is forced.
          */
         if (ecmd->eth_tp_mdix_ctrl) {
-                if (hw->phy.media_type != e1000_media_type_copper)
-                        return -EOPNOTSUPP;
+                if (hw->phy.media_type != e1000_media_type_copper) {
+                        ret_val = -EOPNOTSUPP;
+                        goto out;
+                }
 
                 if ((ecmd->eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
                     (ecmd->autoneg != AUTONEG_ENABLE)) {
                         e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
-                        return -EINVAL;
+                        ret_val = -EINVAL;
+                        goto out;
                 }
         }
 
@@ -307,8 +314,8 @@ static int e1000_set_settings(struct net_device *netdev,
                 u32 speed = ethtool_cmd_speed(ecmd);
                 /* calling this overrides forced MDI setting */
                 if (e1000_set_spd_dplx(adapter, speed, ecmd->duplex)) {
-                        clear_bit(__E1000_RESETTING, &adapter->state);
-                        return -EINVAL;
+                        ret_val = -EINVAL;
+                        goto out;
                 }
         }
 
@@ -331,8 +338,10 @@ static int e1000_set_settings(struct net_device *netdev,
                 e1000e_reset(adapter);
         }
 
+out:
+        pm_runtime_put_sync(netdev->dev.parent);
         clear_bit(__E1000_RESETTING, &adapter->state);
-        return 0;
+        return ret_val;
 }
 
 static void e1000_get_pauseparam(struct net_device *netdev,
@@ -366,6 +375,8 @@ static int e1000_set_pauseparam(struct net_device *netdev,
         while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
                 usleep_range(1000, 2000);
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         if (adapter->fc_autoneg == AUTONEG_ENABLE) {
                 hw->fc.requested_mode = e1000_fc_default;
                 if (netif_running(adapter->netdev)) {
@@ -398,6 +409,7 @@ static int e1000_set_pauseparam(struct net_device *netdev,
         }
 
 out:
+        pm_runtime_put_sync(netdev->dev.parent);
         clear_bit(__E1000_RESETTING, &adapter->state);
         return retval;
 }
@@ -428,6 +440,8 @@ static void e1000_get_regs(struct net_device *netdev,
         u32 *regs_buff = p;
         u16 phy_data;
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         memset(p, 0, E1000_REGS_LEN * sizeof(u32));
 
         regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
@@ -472,6 +486,8 @@ static void e1000_get_regs(struct net_device *netdev,
         e1e_rphy(hw, MII_STAT1000, &phy_data);
         regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
         regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
+
+        pm_runtime_put_sync(netdev->dev.parent);
 }
 
 static int e1000_get_eeprom_len(struct net_device *netdev)
@@ -504,6 +520,8 @@ static int e1000_get_eeprom(struct net_device *netdev,
         if (!eeprom_buff)
                 return -ENOMEM;
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         if (hw->nvm.type == e1000_nvm_eeprom_spi) {
                 ret_val = e1000_read_nvm(hw, first_word,
                                          last_word - first_word + 1,
@@ -517,6 +535,8 @@ static int e1000_get_eeprom(struct net_device *netdev,
                 }
         }
 
+        pm_runtime_put_sync(netdev->dev.parent);
+
         if (ret_val) {
                 /* a read error occurred, throw away the result */
                 memset(eeprom_buff, 0xff, sizeof(u16) *
@@ -566,6 +586,8 @@ static int e1000_set_eeprom(struct net_device *netdev,
 
         ptr = (void *)eeprom_buff;
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         if (eeprom->offset & 1) {
                 /* need read/modify/write of first changed EEPROM word */
                 /* only the second byte of the word is being modified */
@@ -606,6 +628,7 @@ static int e1000_set_eeprom(struct net_device *netdev,
                 ret_val = e1000e_update_nvm_checksum(hw);
 
 out:
+        pm_runtime_put_sync(netdev->dev.parent);
         kfree(eeprom_buff);
         return ret_val;
 }
@@ -701,6 +724,8 @@ static int e1000_set_ringparam(struct net_device *netdev,
                 }
         }
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         e1000e_down(adapter);
 
         /* We can't just free everything and then setup again, because the
@@ -739,6 +764,7 @@ err_setup_rx:
                 e1000e_free_tx_resources(temp_tx);
 err_setup:
         e1000e_up(adapter);
+        pm_runtime_put_sync(netdev->dev.parent);
 free_temp:
         vfree(temp_tx);
         vfree(temp_rx);
@@ -1732,6 +1758,8 @@ static void e1000_diag_test(struct net_device *netdev,
         u8 autoneg;
         bool if_running = netif_running(netdev);
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         set_bit(__E1000_TESTING, &adapter->state);
 
         if (!if_running) {
@@ -1817,6 +1845,8 @@ static void e1000_diag_test(struct net_device *netdev,
         }
 
         msleep_interruptible(4 * 1000);
+
+        pm_runtime_put_sync(netdev->dev.parent);
 }
 
 static void e1000_get_wol(struct net_device *netdev,
@@ -1891,6 +1921,8 @@ static int e1000_set_phys_id(struct net_device *netdev,
 
         switch (state) {
         case ETHTOOL_ID_ACTIVE:
+                pm_runtime_get_sync(netdev->dev.parent);
+
                 if (!hw->mac.ops.blink_led)
                         return 2;       /* cycle on/off twice per second */
 
@@ -1902,6 +1934,7 @@ static int e1000_set_phys_id(struct net_device *netdev,
                         e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
                 hw->mac.ops.led_off(hw);
                 hw->mac.ops.cleanup_led(hw);
+                pm_runtime_put_sync(netdev->dev.parent);
                 break;
 
         case ETHTOOL_ID_ON:
@@ -1912,6 +1945,7 @@ static int e1000_set_phys_id(struct net_device *netdev,
                 hw->mac.ops.led_off(hw);
                 break;
         }
+
         return 0;
 }
 
@@ -1950,11 +1984,15 @@ static int e1000_set_coalesce(struct net_device *netdev,
                 adapter->itr_setting = adapter->itr & ~3;
         }
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         if (adapter->itr_setting != 0)
                 e1000e_write_itr(adapter, adapter->itr);
         else
                 e1000e_write_itr(adapter, 0);
 
+        pm_runtime_put_sync(netdev->dev.parent);
+
         return 0;
 }
 
@@ -1968,7 +2006,9 @@ static int e1000_nway_reset(struct net_device *netdev)
         if (!adapter->hw.mac.autoneg)
                 return -EINVAL;
 
+        pm_runtime_get_sync(netdev->dev.parent);
         e1000e_reinit_locked(adapter);
+        pm_runtime_put_sync(netdev->dev.parent);
 
         return 0;
 }
@@ -1982,7 +2022,12 @@ static void e1000_get_ethtool_stats(struct net_device *netdev,
         int i;
         char *p = NULL;
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         e1000e_get_stats64(netdev, &net_stats);
+
+        pm_runtime_put_sync(netdev->dev.parent);
+
         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
                 switch (e1000_gstrings_stats[i].type) {
                 case NETDEV_STATS:
@@ -2033,7 +2078,11 @@ static int e1000_get_rxnfc(struct net_device *netdev,
         case ETHTOOL_GRXFH: {
                 struct e1000_adapter *adapter = netdev_priv(netdev);
                 struct e1000_hw *hw = &adapter->hw;
-                u32 mrqc = er32(MRQC);
+                u32 mrqc;
+
+                pm_runtime_get_sync(netdev->dev.parent);
+                mrqc = er32(MRQC);
+                pm_runtime_put_sync(netdev->dev.parent);
 
                 if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))
                         return 0;
@@ -2096,9 +2145,13 @@ static int e1000e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
                 return -EOPNOTSUPP;
         }
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         ret_val = hw->phy.ops.acquire(hw);
-        if (ret_val)
+        if (ret_val) {
+                pm_runtime_put_sync(netdev->dev.parent);
                 return -EBUSY;
+        }
 
         /* EEE Capability */
         ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);
@@ -2117,14 +2170,11 @@ static int e1000e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
 
         /* EEE PCS Status */
         ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &phy_data);
+        if (ret_val)
+                goto release;
         if (hw->phy.type == e1000_phy_82579)
                 phy_data <<= 8;
 
-release:
-        hw->phy.ops.release(hw);
-        if (ret_val)
-                return -ENODATA;
-
         /* Result of the EEE auto negotiation - there is no register that
          * has the status of the EEE negotiation so do a best-guess based
          * on whether Tx or Rx LPI indications have been received.
@@ -2136,7 +2186,14 @@ release:
         edata->tx_lpi_enabled = true;
         edata->tx_lpi_timer = er32(LPIC) >> E1000_LPIC_LPIET_SHIFT;
 
-        return 0;
+release:
+        hw->phy.ops.release(hw);
+        if (ret_val)
+                ret_val = -ENODATA;
+
+        pm_runtime_put_sync(netdev->dev.parent);
+
+        return ret_val;
 }
 
 static int e1000e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
@@ -2169,12 +2226,16 @@ static int e1000e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
 
         hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;
 
+        pm_runtime_get_sync(netdev->dev.parent);
+
         /* reset the link */
         if (netif_running(netdev))
                 e1000e_reinit_locked(adapter);
         else
                 e1000e_reset(adapter);
 
+        pm_runtime_put_sync(netdev->dev.parent);
+
         return 0;
 }
 
@@ -2212,19 +2273,7 @@ static int e1000e_get_ts_info(struct net_device *netdev,
         return 0;
 }
 
-static int e1000e_ethtool_begin(struct net_device *netdev)
-{
-        return pm_runtime_get_sync(netdev->dev.parent);
-}
-
-static void e1000e_ethtool_complete(struct net_device *netdev)
-{
-        pm_runtime_put_sync(netdev->dev.parent);
-}
-
 static const struct ethtool_ops e1000_ethtool_ops = {
-        .begin                  = e1000e_ethtool_begin,
-        .complete               = e1000e_ethtool_complete,
         .get_settings           = e1000_get_settings,
         .set_settings           = e1000_set_settings,
         .get_drvinfo            = e1000_get_drvinfo,
diff --git a/drivers/net/ethernet/intel/e1000e/hw.h b/drivers/net/ethernet/intel/e1000e/hw.h
index a6f903a9b773..b799fd9b6aa9 100644
--- a/drivers/net/ethernet/intel/e1000e/hw.h
+++ b/drivers/net/ethernet/intel/e1000e/hw.h
@@ -90,6 +90,10 @@ struct e1000_hw;
 #define E1000_DEV_ID_PCH_LPT_I217_V             0x153B
 #define E1000_DEV_ID_PCH_LPTLP_I218_LM          0x155A
 #define E1000_DEV_ID_PCH_LPTLP_I218_V           0x1559
+#define E1000_DEV_ID_PCH_I218_LM2               0x15A0
+#define E1000_DEV_ID_PCH_I218_V2                0x15A1
+#define E1000_DEV_ID_PCH_I218_LM3               0x15A2  /* Wildcat Point PCH */
+#define E1000_DEV_ID_PCH_I218_V3                0x15A3  /* Wildcat Point PCH */
 
 #define E1000_REVISION_4        4
 
@@ -227,6 +231,9 @@ union e1000_rx_desc_extended {
 };
 
 #define MAX_PS_BUFFERS 4
+
+/* Number of packet split data buffers (not including the header buffer) */
+#define PS_PAGE_BUFFERS                 (MAX_PS_BUFFERS - 1)
 /* Receive Descriptor - Packet Split */
 union e1000_rx_desc_packet_split {
         struct {
@@ -251,7 +258,8 @@ union e1000_rx_desc_packet_split {
                 } middle;
                 struct {
                         __le16 header_status;
-                        __le16 length[3];       /* length of buffers 1-3 */
+                        /* length of buffers 1-3 */
+                        __le16 length[PS_PAGE_BUFFERS];
                 } upper;
                 __le64 reserved;
         } wb; /* writeback */
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index 9dde390f7e71..af08188d7e62 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -185,6 +185,7 @@ static bool e1000_phy_is_accessible_pchlan(struct e1000_hw *hw)
         u32 phy_id = 0;
         s32 ret_val;
         u16 retry_count;
+        u32 mac_reg = 0;
 
         for (retry_count = 0; retry_count < 2; retry_count++) {
                 ret_val = e1e_rphy_locked(hw, MII_PHYSID1, &phy_reg);
@@ -203,11 +204,11 @@ static bool e1000_phy_is_accessible_pchlan(struct e1000_hw *hw)
 
         if (hw->phy.id) {
                 if (hw->phy.id == phy_id)
-                        return true;
+                        goto out;
         } else if (phy_id) {
                 hw->phy.id = phy_id;
                 hw->phy.revision = (u32)(phy_reg & ~PHY_REVISION_MASK);
-                return true;
+                goto out;
         }
 
         /* In case the PHY needs to be in mdio slow mode,
@@ -219,7 +220,22 @@ static bool e1000_phy_is_accessible_pchlan(struct e1000_hw *hw)
                 ret_val = e1000e_get_phy_id(hw);
         hw->phy.ops.acquire(hw);
 
-        return !ret_val;
+        if (ret_val)
+                return false;
+out:
+        if (hw->mac.type == e1000_pch_lpt) {
+                /* 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);
+        }
+
+        return true;
 }
 
 /**
@@ -233,7 +249,6 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
 {
         u32 mac_reg, fwsm = er32(FWSM);
         s32 ret_val;
-        u16 phy_reg;
 
         /* Gate automatic PHY configuration by hardware on managed and
          * non-managed 82579 and newer adapters.
@@ -262,22 +277,16 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
                 mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
                 ew32(CTRL_EXT, mac_reg);
 
+                /* Wait 50 milliseconds for MAC to finish any retries
+                 * that it might be trying to perform from previous
+                 * attempts to acknowledge any phy read requests.
+                 */
+                msleep(50);
+
                 /* fall-through */
         case e1000_pch2lan:
-                if (e1000_phy_is_accessible_pchlan(hw)) {
-                        if (hw->mac.type == e1000_pch_lpt) {
-                                /* 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);
-                        }
+                if (e1000_phy_is_accessible_pchlan(hw))
                         break;
-                }
 
                 /* fall-through */
         case e1000_pchlan:
@@ -287,6 +296,7 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
 
                 if (hw->phy.ops.check_reset_block(hw)) {
                         e_dbg("Required LANPHYPC toggle blocked by ME\n");
+                        ret_val = -E1000_ERR_PHY;
                         break;
                 }
 
@@ -298,15 +308,6 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
                 mac_reg |= E1000_FEXTNVM3_PHY_CFG_COUNTER_50MSEC;
                 ew32(FEXTNVM3, mac_reg);
 
-                if (hw->mac.type == e1000_pch_lpt) {
-                        /* Toggling LANPHYPC brings the PHY out of SMBus mode
-                         * So ensure that the MAC is also out of SMBus mode
-                         */
-                        mac_reg = er32(CTRL_EXT);
-                        mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
-                        ew32(CTRL_EXT, mac_reg);
-                }
-
                 /* Toggle LANPHYPC Value bit */
                 mac_reg = er32(CTRL);
                 mac_reg |= E1000_CTRL_LANPHYPC_OVERRIDE;
@@ -325,6 +326,21 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
                                 usleep_range(5000, 10000);
                         } while (!(er32(CTRL_EXT) &
                                    E1000_CTRL_EXT_LPCD) && count--);
+                        usleep_range(30000, 60000);
+                        if (e1000_phy_is_accessible_pchlan(hw))
+                                break;
+
+                        /* Toggling LANPHYPC brings the PHY out of SMBus mode
+                         * so ensure that the MAC is also out of SMBus mode
+                         */
+                        mac_reg = er32(CTRL_EXT);
+                        mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
+                        ew32(CTRL_EXT, mac_reg);
+
+                        if (e1000_phy_is_accessible_pchlan(hw))
+                                break;
+
+                        ret_val = -E1000_ERR_PHY;
                 }
                 break;
         default:
@@ -332,13 +348,14 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
         }
 
         hw->phy.ops.release(hw);
-
-        /* Reset the PHY before any access to it.  Doing so, ensures
-         * that the PHY is in a known good state before we read/write
-         * PHY registers.  The generic reset is sufficient here,
-         * because we haven't determined the PHY type yet.
-         */
-        ret_val = e1000e_phy_hw_reset_generic(hw);
+        if (!ret_val) {
+                /* Reset the PHY before any access to it.  Doing so, ensures
+                 * that the PHY is in a known good state before we read/write
+                 * PHY registers.  The generic reset is sufficient here,
+                 * because we haven't determined the PHY type yet.
+                 */
+                ret_val = e1000e_phy_hw_reset_generic(hw);
+        }
 
 out:
         /* Ungate automatic PHY configuration on non-managed 82579 */
@@ -793,29 +810,31 @@ release:
  *  When K1 is enabled for 1Gbps, the MAC can miss 2 DMA completion indications
  *  preventing further DMA write requests.  Workaround the issue by disabling
  *  the de-assertion of the clock request when in 1Gpbs mode.
+ *  Also, set appropriate Tx re-transmission timeouts for 10 and 100Half link
+ *  speeds in order to avoid Tx hangs.
  **/
 static s32 e1000_k1_workaround_lpt_lp(struct e1000_hw *hw, bool link)
 {
         u32 fextnvm6 = er32(FEXTNVM6);
+        u32 status = er32(STATUS);
         s32 ret_val = 0;
+        u16 reg;
 
-        if (link && (er32(STATUS) & E1000_STATUS_SPEED_1000)) {
-                u16 kmrn_reg;
-
+        if (link && (status & E1000_STATUS_SPEED_1000)) {
                 ret_val = hw->phy.ops.acquire(hw);
                 if (ret_val)
                         return ret_val;
 
                 ret_val =
                     e1000e_read_kmrn_reg_locked(hw, E1000_KMRNCTRLSTA_K1_CONFIG,
-                                                &kmrn_reg);
+                                                &reg);
                 if (ret_val)
                         goto release;
 
                 ret_val =
                     e1000e_write_kmrn_reg_locked(hw,
                                                  E1000_KMRNCTRLSTA_K1_CONFIG,
-                                                 kmrn_reg &
+                                                 reg &
                                                  ~E1000_KMRNCTRLSTA_K1_ENABLE);
                 if (ret_val)
                         goto release;
@@ -827,12 +846,45 @@ static s32 e1000_k1_workaround_lpt_lp(struct e1000_hw *hw, bool link)
                 ret_val =
                     e1000e_write_kmrn_reg_locked(hw,
                                                  E1000_KMRNCTRLSTA_K1_CONFIG,
-                                                 kmrn_reg);
+                                                 reg);
 release:
                 hw->phy.ops.release(hw);
         } else {
                 /* clear FEXTNVM6 bit 8 on link down or 10/100 */
-                ew32(FEXTNVM6, fextnvm6 & ~E1000_FEXTNVM6_REQ_PLL_CLK);
+                fextnvm6 &= ~E1000_FEXTNVM6_REQ_PLL_CLK;
+
+                if (!link || ((status & E1000_STATUS_SPEED_100) &&
+                              (status & E1000_STATUS_FD)))
+                        goto update_fextnvm6;
+
+                ret_val = e1e_rphy(hw, I217_INBAND_CTRL, &reg);
+                if (ret_val)
+                        return ret_val;
+
+                /* Clear link status transmit timeout */
+                reg &= ~I217_INBAND_CTRL_LINK_STAT_TX_TIMEOUT_MASK;
+
+                if (status & E1000_STATUS_SPEED_100) {
+                        /* Set inband Tx timeout to 5x10us for 100Half */
+                        reg |= 5 << I217_INBAND_CTRL_LINK_STAT_TX_TIMEOUT_SHIFT;
+
+                        /* Do not extend the K1 entry latency for 100Half */
+                        fextnvm6 &= ~E1000_FEXTNVM6_ENABLE_K1_ENTRY_CONDITION;
+                } else {
+                        /* Set inband Tx timeout to 50x10us for 10Full/Half */
+                        reg |= 50 <<
+                            I217_INBAND_CTRL_LINK_STAT_TX_TIMEOUT_SHIFT;
+
+                        /* Extend the K1 entry latency for 10 Mbps */
+                        fextnvm6 |= E1000_FEXTNVM6_ENABLE_K1_ENTRY_CONDITION;
+                }
+
+                ret_val = e1e_wphy(hw, I217_INBAND_CTRL, reg);
+                if (ret_val)
+                        return ret_val;
+
+update_fextnvm6:
+                ew32(FEXTNVM6, fextnvm6);
         }
 
         return ret_val;
@@ -993,7 +1045,9 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
 
         /* 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_LPTLP_I218_V) ||
+            (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_LM3) ||
+            (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;
@@ -4168,7 +4222,9 @@ void e1000_suspend_workarounds_ich8lan(struct e1000_hw *hw)
                 u16 phy_reg, device_id = hw->adapter->pdev->device;
 
                 if ((device_id == E1000_DEV_ID_PCH_LPTLP_I218_LM) ||
-                    (device_id == E1000_DEV_ID_PCH_LPTLP_I218_V)) {
+                    (device_id == E1000_DEV_ID_PCH_LPTLP_I218_V) ||
+                    (device_id == E1000_DEV_ID_PCH_I218_LM3) ||
+                    (device_id == E1000_DEV_ID_PCH_I218_V3)) {
                         u32 fextnvm6 = er32(FEXTNVM6);
 
                         ew32(FEXTNVM6, fextnvm6 & ~E1000_FEXTNVM6_REQ_PLL_CLK);
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.h b/drivers/net/ethernet/intel/e1000e/ich8lan.h
index 80034a2b297c..59865695b282 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.h
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.h
@@ -93,6 +93,7 @@
 #define E1000_FEXTNVM4_BEACON_DURATION_16USEC   0x3
 
 #define E1000_FEXTNVM6_REQ_PLL_CLK      0x00000100
+#define E1000_FEXTNVM6_ENABLE_K1_ENTRY_CONDITION        0x00000200
 
 #define PCIE_ICH8_SNOOP_ALL     PCIE_NO_SNOOP_ALL
 
@@ -197,6 +198,11 @@
 
 #define SW_FLAG_TIMEOUT         1000    /* SW Semaphore flag timeout in ms */
 
+/* Inband Control */
+#define I217_INBAND_CTRL                                PHY_REG(770, 18)
+#define I217_INBAND_CTRL_LINK_STAT_TX_TIMEOUT_MASK      0x3F00
+#define I217_INBAND_CTRL_LINK_STAT_TX_TIMEOUT_SHIFT     8
+
 /* PHY Low Power Idle Control */
 #define I82579_LPI_CTRL                         PHY_REG(772, 20)
 #define I82579_LPI_CTRL_100_ENABLE              0x2000
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 77f81cbb601a..e6d2c0f8f76a 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -2979,17 +2979,10 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
         u32 pages = 0;
 
         /* Workaround Si errata on PCHx - configure jumbo frame flow */
-        if (hw->mac.type >= e1000_pch2lan) {
-                s32 ret_val;
-
-                if (adapter->netdev->mtu > ETH_DATA_LEN)
-                        ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
-                else
-                        ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
-
-                if (ret_val)
-                        e_dbg("failed to enable jumbo frame workaround mode\n");
-        }
+        if ((hw->mac.type >= e1000_pch2lan) &&
+            (adapter->netdev->mtu > ETH_DATA_LEN) &&
+            e1000_lv_jumbo_workaround_ich8lan(hw, true))
+                e_dbg("failed to enable jumbo frame workaround mode\n");
 
         /* Program MC offset vector base */
         rctl = er32(RCTL);
@@ -3826,6 +3819,8 @@ void e1000e_reset(struct e1000_adapter *adapter)
                         break;
                 }
 
+                pba = 14;
+                ew32(PBA, pba);
                 fc->high_water = ((pba << 10) * 9 / 10) & E1000_FCRTH_RTH;
                 fc->low_water = ((pba << 10) * 8 / 10) & E1000_FCRTL_RTL;
                 break;
@@ -4034,6 +4029,12 @@ void e1000e_down(struct e1000_adapter *adapter)
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
 
+        /* Disable Si errata workaround on PCHx for jumbo frame flow */
+        if ((hw->mac.type >= e1000_pch2lan) &&
+            (adapter->netdev->mtu > ETH_DATA_LEN) &&
+            e1000_lv_jumbo_workaround_ich8lan(hw, false))
+                e_dbg("failed to disable jumbo frame workaround mode\n");
+
         if (!pci_channel_offline(adapter->pdev))
                 e1000e_reset(adapter);
 
@@ -4683,11 +4684,11 @@ static void e1000_phy_read_status(struct e1000_adapter *adapter)
         struct e1000_hw *hw = &adapter->hw;
         struct e1000_phy_regs *phy = &adapter->phy_regs;
 
-        if ((er32(STATUS) & E1000_STATUS_LU) &&
+        if (!pm_runtime_suspended((&adapter->pdev->dev)->parent) &&
+            (er32(STATUS) & E1000_STATUS_LU) &&
             (adapter->hw.phy.media_type == e1000_media_type_copper)) {
                 int ret_val;
 
-                pm_runtime_get_sync(&adapter->pdev->dev);
                 ret_val = e1e_rphy(hw, MII_BMCR, &phy->bmcr);
                 ret_val |= e1e_rphy(hw, MII_BMSR, &phy->bmsr);
                 ret_val |= e1e_rphy(hw, MII_ADVERTISE, &phy->advertise);
@@ -4698,7 +4699,6 @@ static void e1000_phy_read_status(struct e1000_adapter *adapter)
                 ret_val |= e1e_rphy(hw, MII_ESTATUS, &phy->estatus);
                 if (ret_val)
                         e_warn("Error reading PHY register\n");
-                pm_runtime_put_sync(&adapter->pdev->dev);
         } else {
                 /* Do not read PHY registers if link is not up
                  * Set values to typical power-on defaults
@@ -5995,6 +5995,8 @@ static int __e1000_shutdown(struct pci_dev *pdev, bool runtime)
          */
         e1000e_release_hw_control(adapter);
 
+        pci_clear_master(pdev);
+
         /* The pci-e switch on some quad port adapters will report a
          * correctable error when the MAC transitions from D0 to D3.  To
          * prevent this we need to mask off the correctable errors on the
@@ -6723,10 +6725,6 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         adapter->hw.fc.current_mode = e1000_fc_default;
         adapter->hw.phy.autoneg_advertised = 0x2f;
 
-        /* ring size defaults */
-        adapter->rx_ring->count = E1000_DEFAULT_RXD;
-        adapter->tx_ring->count = E1000_DEFAULT_TXD;
-
         /* Initial Wake on LAN setting - If APM wake is enabled in
          * the EEPROM, enable the ACPI Magic Packet filter
          */
@@ -6976,6 +6974,10 @@ static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_V), board_pch_lpt },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_LM), board_pch_lpt },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_V), board_pch_lpt },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_LM2), board_pch_lpt },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_V2), board_pch_lpt },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_LM3), board_pch_lpt },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_V3), board_pch_lpt },
 
         { 0, 0, 0, 0, 0, 0, 0 } /* terminate list */
 };