12 files changed, 171 insertions, 60 deletions

diff --git a/drivers/net/ethernet/intel/e1000e/80003es2lan.c b/drivers/net/ethernet/intel/e1000e/80003es2lan.c
index a5f6b11d6992..08f22f348800 100644
--- a/drivers/net/ethernet/intel/e1000e/80003es2lan.c
+++ b/drivers/net/ethernet/intel/e1000e/80003es2lan.c
@@ -1365,6 +1365,7 @@ static const struct e1000_mac_operations es2_mac_ops = {
         .setup_led              = e1000e_setup_led_generic,
         .config_collision_dist  = e1000e_config_collision_dist_generic,
         .rar_set                = e1000e_rar_set_generic,
+        .rar_get_count          = e1000e_rar_get_count_generic,
 };
 
 static const struct e1000_phy_operations es2_phy_ops = {
diff --git a/drivers/net/ethernet/intel/e1000e/82571.c b/drivers/net/ethernet/intel/e1000e/82571.c
index e0aa7f1efb08..218481e509f9 100644
--- a/drivers/net/ethernet/intel/e1000e/82571.c
+++ b/drivers/net/ethernet/intel/e1000e/82571.c
@@ -1896,6 +1896,7 @@ static const struct e1000_mac_operations e82571_mac_ops = {
         .config_collision_dist  = e1000e_config_collision_dist_generic,
         .read_mac_addr          = e1000_read_mac_addr_82571,
         .rar_set                = e1000e_rar_set_generic,
+        .rar_get_count          = e1000e_rar_get_count_generic,
 };
 
 static const struct e1000_phy_operations e82_phy_ops_igp = {
diff --git a/drivers/net/ethernet/intel/e1000e/e1000.h b/drivers/net/ethernet/intel/e1000e/e1000.h
index 1471c5464a89..7785240a0da1 100644
--- a/drivers/net/ethernet/intel/e1000e/e1000.h
+++ b/drivers/net/ethernet/intel/e1000e/e1000.h
@@ -265,10 +265,10 @@ struct e1000_adapter {
         u32 tx_hwtstamp_timeouts;
 
         /* Rx */
-        bool (*clean_rx) (struct e1000_ring *ring, int *work_done,
-                          int work_to_do) ____cacheline_aligned_in_smp;
-        void (*alloc_rx_buf) (struct e1000_ring *ring, int cleaned_count,
-                              gfp_t gfp);
+        bool (*clean_rx)(struct e1000_ring *ring, int *work_done,
+                         int work_to_do) ____cacheline_aligned_in_smp;
+        void (*alloc_rx_buf)(struct e1000_ring *ring, int cleaned_count,
+                             gfp_t gfp);
         struct e1000_ring *rx_ring;
 
         u32 rx_int_delay;
@@ -391,6 +391,8 @@ s32 e1000e_get_base_timinca(struct e1000_adapter *adapter, u32 *timinca);
  * 25MHz        46-bit  2^46 / 10^9 / 3600 = 19.55 hours
  */
 #define E1000_SYSTIM_OVERFLOW_PERIOD    (HZ * 60 * 60 * 4)
+#define E1000_MAX_82574_SYSTIM_REREADS  50
+#define E1000_82574_SYSTIM_EPSILON      (1ULL << 35ULL)
 
 /* hardware capability, feature, and workaround flags */
 #define FLAG_HAS_AMT                      (1 << 0)
@@ -573,35 +575,8 @@ static inline u32 __er32(struct e1000_hw *hw, unsigned long reg)
 
 #define er32(reg)       __er32(hw, E1000_##reg)
 
-/**
- * __ew32_prepare - prepare to write to MAC CSR register on certain parts
- * @hw: pointer to the HW structure
- *
- * When updating the MAC CSR registers, the Manageability Engine (ME) could
- * be accessing the registers at the same time.  Normally, this is handled in
- * h/w by an arbiter but on some parts there is a bug that acknowledges Host
- * accesses later than it should which could result in the register to have
- * an incorrect value.  Workaround this by checking the FWSM register which
- * has bit 24 set while ME is accessing MAC CSR registers, wait if it is set
- * and try again a number of times.
- **/
-static inline s32 __ew32_prepare(struct e1000_hw *hw)
-{
-        s32 i = E1000_ICH_FWSM_PCIM2PCI_COUNT;
-
-        while ((er32(FWSM) & E1000_ICH_FWSM_PCIM2PCI) && --i)
-                udelay(50);
-
-        return i;
-}
-
-static inline void __ew32(struct e1000_hw *hw, unsigned long reg, u32 val)
-{
-        if (hw->adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
-                __ew32_prepare(hw);
-
-        writel(val, hw->hw_addr + reg);
-}
+s32 __ew32_prepare(struct e1000_hw *hw);
+void __ew32(struct e1000_hw *hw, unsigned long reg, u32 val);
 
 #define ew32(reg, val)  __ew32(hw, E1000_##reg, (val))
 
diff --git a/drivers/net/ethernet/intel/e1000e/ethtool.c b/drivers/net/ethernet/intel/e1000e/ethtool.c
index cad250bc1b99..815e26c6d34b 100644
--- a/drivers/net/ethernet/intel/e1000e/ethtool.c
+++ b/drivers/net/ethernet/intel/e1000e/ethtool.c
@@ -159,8 +159,8 @@ static int e1000_get_settings(struct net_device *netdev,
                 ecmd->transceiver = XCVR_EXTERNAL;
         }
 
-        speed = -1;
-        ecmd->duplex = -1;
+        speed = SPEED_UNKNOWN;
+        ecmd->duplex = DUPLEX_UNKNOWN;
 
         if (netif_running(netdev)) {
                 if (netif_carrier_ok(netdev)) {
@@ -169,6 +169,7 @@ static int e1000_get_settings(struct net_device *netdev,
                 }
         } else if (!pm_runtime_suspended(netdev->dev.parent)) {
                 u32 status = er32(STATUS);
+
                 if (status & E1000_STATUS_LU) {
                         if (status & E1000_STATUS_SPEED_1000)
                                 speed = SPEED_1000;
@@ -783,25 +784,26 @@ static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
                               reg + (offset << 2), val,
                               (test[pat] & write & mask));
                         *data = reg;
-                        return 1;
+                        return true;
                 }
         }
-        return 0;
+        return false;
 }
 
 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
                               int reg, u32 mask, u32 write)
 {
         u32 val;
+
         __ew32(&adapter->hw, reg, write & mask);
         val = __er32(&adapter->hw, reg);
         if ((write & mask) != (val & mask)) {
                 e_err("set/check test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
                       reg, (val & mask), (write & mask));
                 *data = reg;
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 #define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write)                       \
@@ -1717,6 +1719,7 @@ static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
         *data = 0;
         if (hw->phy.media_type == e1000_media_type_internal_serdes) {
                 int i = 0;
+
                 hw->mac.serdes_has_link = false;
 
                 /* On some blade server designs, link establishment
@@ -2315,5 +2318,5 @@ static const struct ethtool_ops e1000_ethtool_ops = {
 
 void e1000e_set_ethtool_ops(struct net_device *netdev)
 {
-        SET_ETHTOOL_OPS(netdev, &e1000_ethtool_ops);
+        netdev->ethtool_ops = &e1000_ethtool_ops;
 }
diff --git a/drivers/net/ethernet/intel/e1000e/hw.h b/drivers/net/ethernet/intel/e1000e/hw.h
index 6b3de5f39a97..72f5475c4b90 100644
--- a/drivers/net/ethernet/intel/e1000e/hw.h
+++ b/drivers/net/ethernet/intel/e1000e/hw.h
@@ -469,8 +469,9 @@ struct e1000_mac_operations {
         s32  (*setup_led)(struct e1000_hw *);
         void (*write_vfta)(struct e1000_hw *, u32, u32);
         void (*config_collision_dist)(struct e1000_hw *);
-        void (*rar_set)(struct e1000_hw *, u8 *, u32);
+        int  (*rar_set)(struct e1000_hw *, u8 *, u32);
         s32  (*read_mac_addr)(struct e1000_hw *);
+        u32  (*rar_get_count)(struct e1000_hw *);
 };
 
 /* When to use various PHY register access functions:
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index f0bbd4246d71..8894ab8ed6bd 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -139,8 +139,9 @@ static s32 e1000_k1_gig_workaround_hv(struct e1000_hw *hw, bool link);
 static s32 e1000_set_mdio_slow_mode_hv(struct e1000_hw *hw);
 static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw);
 static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw);
-static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index);
-static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index);
+static int e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index);
+static int e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index);
+static u32 e1000_rar_get_count_pch_lpt(struct e1000_hw *hw);
 static s32 e1000_k1_workaround_lv(struct e1000_hw *hw);
 static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate);
 static s32 e1000_disable_ulp_lpt_lp(struct e1000_hw *hw, bool force);
@@ -704,6 +705,7 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_hw *hw)
                 mac->ops.rar_set = e1000_rar_set_pch_lpt;
                 mac->ops.setup_physical_interface =
                     e1000_setup_copper_link_pch_lpt;
+                mac->ops.rar_get_count = e1000_rar_get_count_pch_lpt;
         }
 
         /* Enable PCS Lock-loss workaround for ICH8 */
@@ -1334,6 +1336,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
         if (((hw->mac.type == e1000_pch2lan) ||
              (hw->mac.type == e1000_pch_lpt)) && link) {
                 u32 reg;
+
                 reg = er32(STATUS);
                 if (!(reg & (E1000_STATUS_FD | E1000_STATUS_SPEED_MASK))) {
                         u16 emi_addr;
@@ -1634,9 +1637,9 @@ static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw)
         u32 fwsm;
 
         fwsm = er32(FWSM);
-        return ((fwsm & E1000_ICH_FWSM_FW_VALID) &&
+        return (fwsm & E1000_ICH_FWSM_FW_VALID) &&
                 ((fwsm & E1000_FWSM_MODE_MASK) ==
-                 (E1000_ICH_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT)));
+                 (E1000_ICH_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT));
 }
 
 /**
@@ -1667,7 +1670,7 @@ static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw)
  *  contain the MAC address but RAR[1-6] are reserved for manageability (ME).
  *  Use SHRA[0-3] in place of those reserved for ME.
  **/
-static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
+static int e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
 {
         u32 rar_low, rar_high;
 
@@ -1689,7 +1692,7 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
                 e1e_flush();
                 ew32(RAH(index), rar_high);
                 e1e_flush();
-                return;
+                return 0;
         }
 
         /* RAR[1-6] are owned by manageability.  Skip those and program the
@@ -1712,7 +1715,7 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
                 /* verify the register updates */
                 if ((er32(SHRAL(index - 1)) == rar_low) &&
                     (er32(SHRAH(index - 1)) == rar_high))
-                        return;
+                        return 0;
 
                 e_dbg("SHRA[%d] might be locked by ME - FWSM=0x%8.8x\n",
                       (index - 1), er32(FWSM));
@@ -1720,6 +1723,43 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
 
 out:
         e_dbg("Failed to write receive address at index %d\n", index);
+        return -E1000_ERR_CONFIG;
+}
+
+/**
+ *  e1000_rar_get_count_pch_lpt - Get the number of available SHRA
+ *  @hw: pointer to the HW structure
+ *
+ *  Get the number of available receive registers that the Host can
+ *  program. SHRA[0-10] are the shared receive address registers
+ *  that are shared between the Host and manageability engine (ME).
+ *  ME can reserve any number of addresses and the host needs to be
+ *  able to tell how many available registers it has access to.
+ **/
+static u32 e1000_rar_get_count_pch_lpt(struct e1000_hw *hw)
+{
+        u32 wlock_mac;
+        u32 num_entries;
+
+        wlock_mac = er32(FWSM) & E1000_FWSM_WLOCK_MAC_MASK;
+        wlock_mac >>= E1000_FWSM_WLOCK_MAC_SHIFT;
+
+        switch (wlock_mac) {
+        case 0:
+                /* All SHRA[0..10] and RAR[0] available */
+                num_entries = hw->mac.rar_entry_count;
+                break;
+        case 1:
+                /* Only RAR[0] available */
+                num_entries = 1;
+                break;
+        default:
+                /* SHRA[0..(wlock_mac - 1)] available + RAR[0] */
+                num_entries = wlock_mac + 1;
+                break;
+        }
+
+        return num_entries;
 }
 
 /**
@@ -1733,7 +1773,7 @@ out:
  *  contain the MAC address. SHRA[0-10] are the shared receive address
  *  registers that are shared between the Host and manageability engine (ME).
  **/
-static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
+static int e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
 {
         u32 rar_low, rar_high;
         u32 wlock_mac;
@@ -1755,7 +1795,7 @@ static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
                 e1e_flush();
                 ew32(RAH(index), rar_high);
                 e1e_flush();
-                return;
+                return 0;
         }
 
         /* The manageability engine (ME) can lock certain SHRAR registers that
@@ -1787,12 +1827,13 @@ static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
                         /* verify the register updates */
                         if ((er32(SHRAL_PCH_LPT(index - 1)) == rar_low) &&
                             (er32(SHRAH_PCH_LPT(index - 1)) == rar_high))
-                                return;
+                                return 0;
                 }
         }
 
 out:
         e_dbg("Failed to write receive address at index %d\n", index);
+        return -E1000_ERR_CONFIG;
 }
 
 /**
@@ -4976,6 +5017,7 @@ static const struct e1000_mac_operations ich8_mac_ops = {
         /* id_led_init dependent on mac type */
         .config_collision_dist  = e1000e_config_collision_dist_generic,
         .rar_set                = e1000e_rar_set_generic,
+        .rar_get_count          = e1000e_rar_get_count_generic,
 };
 
 static const struct e1000_phy_operations ich8_phy_ops = {
diff --git a/drivers/net/ethernet/intel/e1000e/mac.c b/drivers/net/ethernet/intel/e1000e/mac.c
index baa0a466d1d0..8c386f3a15eb 100644
--- a/drivers/net/ethernet/intel/e1000e/mac.c
+++ b/drivers/net/ethernet/intel/e1000e/mac.c
@@ -211,6 +211,11 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
         return 0;
 }
 
+u32 e1000e_rar_get_count_generic(struct e1000_hw *hw)
+{
+        return hw->mac.rar_entry_count;
+}
+
 /**
  *  e1000e_rar_set_generic - Set receive address register
  *  @hw: pointer to the HW structure
@@ -220,7 +225,7 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
  *  Sets the receive address array register at index to the address passed
  *  in by addr.
  **/
-void e1000e_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
+int e1000e_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
 {
         u32 rar_low, rar_high;
 
@@ -244,6 +249,8 @@ void e1000e_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
         e1e_flush();
         ew32(RAH(index), rar_high);
         e1e_flush();
+
+        return 0;
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/e1000e/mac.h b/drivers/net/ethernet/intel/e1000e/mac.h
index 4e81c2825b7a..0513d90cdeea 100644
--- a/drivers/net/ethernet/intel/e1000e/mac.h
+++ b/drivers/net/ethernet/intel/e1000e/mac.h
@@ -61,7 +61,8 @@ void e1000e_update_adaptive(struct e1000_hw *hw);
 void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value);
 
 void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
-void e1000e_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index);
+u32 e1000e_rar_get_count_generic(struct e1000_hw *hw);
+int e1000e_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index);
 void e1000e_config_collision_dist_generic(struct e1000_hw *hw);
 
 #endif
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 3e69386add04..201cc93f3625 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -124,6 +124,36 @@ static const struct e1000_reg_info e1000_reg_info_tbl[] = {
 };
 
 /**
+ * __ew32_prepare - prepare to write to MAC CSR register on certain parts
+ * @hw: pointer to the HW structure
+ *
+ * When updating the MAC CSR registers, the Manageability Engine (ME) could
+ * be accessing the registers at the same time.  Normally, this is handled in
+ * h/w by an arbiter but on some parts there is a bug that acknowledges Host
+ * accesses later than it should which could result in the register to have
+ * an incorrect value.  Workaround this by checking the FWSM register which
+ * has bit 24 set while ME is accessing MAC CSR registers, wait if it is set
+ * and try again a number of times.
+ **/
+s32 __ew32_prepare(struct e1000_hw *hw)
+{
+        s32 i = E1000_ICH_FWSM_PCIM2PCI_COUNT;
+
+        while ((er32(FWSM) & E1000_ICH_FWSM_PCIM2PCI) && --i)
+                udelay(50);
+
+        return i;
+}
+
+void __ew32(struct e1000_hw *hw, unsigned long reg, u32 val)
+{
+        if (hw->adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                __ew32_prepare(hw);
+
+        writel(val, hw->hw_addr + reg);
+}
+
+/**
  * e1000_regdump - register printout routine
  * @hw: pointer to the HW structure
  * @reginfo: pointer to the register info table
@@ -599,6 +629,7 @@ static void e1000e_update_rdt_wa(struct e1000_ring *rx_ring, unsigned int i)
 
         if (unlikely(!ret_val && (i != readl(rx_ring->tail)))) {
                 u32 rctl = er32(RCTL);
+
                 ew32(RCTL, rctl & ~E1000_RCTL_EN);
                 e_err("ME firmware caused invalid RDT - resetting\n");
                 schedule_work(&adapter->reset_task);
@@ -615,6 +646,7 @@ static void e1000e_update_tdt_wa(struct e1000_ring *tx_ring, unsigned int i)
 
         if (unlikely(!ret_val && (i != readl(tx_ring->tail)))) {
                 u32 tctl = er32(TCTL);
+
                 ew32(TCTL, tctl & ~E1000_TCTL_EN);
                 e_err("ME firmware caused invalid TDT - resetting\n");
                 schedule_work(&adapter->reset_task);
@@ -1198,6 +1230,7 @@ static bool e1000_clean_tx_irq(struct e1000_ring *tx_ring)
         while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
                (count < tx_ring->count)) {
                 bool cleaned = false;
+
                 rmb();          /* read buffer_info after eop_desc */
                 for (; !cleaned; count++) {
                         tx_desc = E1000_TX_DESC(*tx_ring, i);
@@ -1753,6 +1786,7 @@ static irqreturn_t e1000_intr_msi(int __always_unused irq, void *data)
                     adapter->flags & FLAG_RX_NEEDS_RESTART) {
                         /* disable receives */
                         u32 rctl = er32(RCTL);
+
                         ew32(RCTL, rctl & ~E1000_RCTL_EN);
                         adapter->flags |= FLAG_RESTART_NOW;
                 }
@@ -1960,6 +1994,7 @@ static void e1000_configure_msix(struct e1000_adapter *adapter)
         /* Workaround issue with spurious interrupts on 82574 in MSI-X mode */
         if (hw->mac.type == e1000_82574) {
                 u32 rfctl = er32(RFCTL);
+
                 rfctl |= E1000_RFCTL_ACK_DIS;
                 ew32(RFCTL, rfctl);
         }
@@ -2204,6 +2239,7 @@ static void e1000_irq_disable(struct e1000_adapter *adapter)
 
         if (adapter->msix_entries) {
                 int i;
+
                 for (i = 0; i < adapter->num_vectors; i++)
                         synchronize_irq(adapter->msix_entries[i].vector);
         } else {
@@ -2921,6 +2957,7 @@ static void e1000_configure_tx(struct e1000_adapter *adapter)
 
         if (adapter->flags2 & FLAG2_DMA_BURST) {
                 u32 txdctl = er32(TXDCTL(0));
+
                 txdctl &= ~(E1000_TXDCTL_PTHRESH | E1000_TXDCTL_HTHRESH |
                             E1000_TXDCTL_WTHRESH);
                 /* set up some performance related parameters to encourage the
@@ -3239,6 +3276,7 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
 
                 if (adapter->flags & FLAG_IS_ICH) {
                         u32 rxdctl = er32(RXDCTL(0));
+
                         ew32(RXDCTL(0), rxdctl | 0x3);
                 }
 
@@ -3303,9 +3341,11 @@ static int e1000e_write_uc_addr_list(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        unsigned int rar_entries = hw->mac.rar_entry_count;
+        unsigned int rar_entries;
         int count = 0;
 
+        rar_entries = hw->mac.ops.rar_get_count(hw);
+
         /* save a rar entry for our hardware address */
         rar_entries--;
 
@@ -3324,9 +3364,13 @@ static int e1000e_write_uc_addr_list(struct net_device *netdev)
                  * combining
                  */
                 netdev_for_each_uc_addr(ha, netdev) {
+                        int rval;
+
                         if (!rar_entries)
                                 break;
-                        hw->mac.ops.rar_set(hw, ha->addr, rar_entries--);
+                        rval = hw->mac.ops.rar_set(hw, ha->addr, rar_entries--);
+                        if (rval < 0)
+                                return -ENOMEM;
                         count++;
                 }
         }
@@ -4085,12 +4129,37 @@ static cycle_t e1000e_cyclecounter_read(const struct cyclecounter *cc)
         struct e1000_adapter *adapter = container_of(cc, struct e1000_adapter,
                                                      cc);
         struct e1000_hw *hw = &adapter->hw;
-        cycle_t systim;
+        cycle_t systim, systim_next;
 
         /* latch SYSTIMH on read of SYSTIML */
         systim = (cycle_t)er32(SYSTIML);
         systim |= (cycle_t)er32(SYSTIMH) << 32;
 
+        if ((hw->mac.type == e1000_82574) || (hw->mac.type == e1000_82583)) {
+                u64 incvalue, time_delta, rem, temp;
+                int i;
+
+                /* errata for 82574/82583 possible bad bits read from SYSTIMH/L
+                 * check to see that the time is incrementing at a reasonable
+                 * rate and is a multiple of incvalue
+                 */
+                incvalue = er32(TIMINCA) & E1000_TIMINCA_INCVALUE_MASK;
+                for (i = 0; i < E1000_MAX_82574_SYSTIM_REREADS; i++) {
+                        /* latch SYSTIMH on read of SYSTIML */
+                        systim_next = (cycle_t)er32(SYSTIML);
+                        systim_next |= (cycle_t)er32(SYSTIMH) << 32;
+
+                        time_delta = systim_next - systim;
+                        temp = time_delta;
+                        rem = do_div(temp, incvalue);
+
+                        systim = systim_next;
+
+                        if ((time_delta < E1000_82574_SYSTIM_EPSILON) &&
+                            (rem == 0))
+                                break;
+                }
+        }
         return systim;
 }
 
@@ -4491,7 +4560,7 @@ static void e1000e_update_phy_task(struct work_struct *work)
         e1000_get_phy_info(hw);
 
         /* Enable EEE on 82579 after link up */
-        if (hw->phy.type == e1000_phy_82579)
+        if (hw->phy.type >= e1000_phy_82579)
                 e1000_set_eee_pchlan(hw);
 }
 
@@ -4695,6 +4764,7 @@ static void e1000e_update_stats(struct e1000_adapter *adapter)
         /* Correctable ECC Errors */
         if (hw->mac.type == e1000_pch_lpt) {
                 u32 pbeccsts = er32(PBECCSTS);
+
                 adapter->corr_errors +=
                     pbeccsts & E1000_PBECCSTS_CORR_ERR_CNT_MASK;
                 adapter->uncorr_errors +=
@@ -4808,6 +4878,7 @@ static void e1000e_enable_receives(struct e1000_adapter *adapter)
             (adapter->flags & FLAG_RESTART_NOW)) {
                 struct e1000_hw *hw = &adapter->hw;
                 u32 rctl = er32(RCTL);
+
                 ew32(RCTL, rctl | E1000_RCTL_EN);
                 adapter->flags &= ~FLAG_RESTART_NOW;
         }
@@ -4930,6 +5001,7 @@ static void e1000_watchdog_task(struct work_struct *work)
                         if ((adapter->flags & FLAG_TARC_SPEED_MODE_BIT) &&
                             !txb2b) {
                                 u32 tarc0;
+
                                 tarc0 = er32(TARC(0));
                                 tarc0 &= ~SPEED_MODE_BIT;
                                 ew32(TARC(0), tarc0);
@@ -5170,7 +5242,7 @@ static bool e1000_tx_csum(struct e1000_ring *tx_ring, struct sk_buff *skb)
         __be16 protocol;
 
         if (skb->ip_summed != CHECKSUM_PARTIAL)
-                return 0;
+                return false;
 
         if (skb->protocol == cpu_to_be16(ETH_P_8021Q))
                 protocol = vlan_eth_hdr(skb)->h_vlan_encapsulated_proto;
@@ -5215,7 +5287,7 @@ static bool e1000_tx_csum(struct e1000_ring *tx_ring, struct sk_buff *skb)
                 i = 0;
         tx_ring->next_to_use = i;
 
-        return 1;
+        return true;
 }
 
 static int e1000_tx_map(struct e1000_ring *tx_ring, struct sk_buff *skb,
@@ -6209,6 +6281,7 @@ static int __e1000_resume(struct pci_dev *pdev)
                 e1e_wphy(&adapter->hw, BM_WUS, ~0);
         } else {
                 u32 wus = er32(WUS);
+
                 if (wus) {
                         e_info("MAC Wakeup cause - %s\n",
                                wus & E1000_WUS_EX ? "Unicast Packet" :
@@ -7027,7 +7100,7 @@ static const struct pci_error_handlers e1000_err_handler = {
         .resume = e1000_io_resume,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
+static const struct pci_device_id e1000_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_COPPER), board_82571 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_FIBER), board_82571 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER), board_82571 },
@@ -7144,6 +7217,7 @@ static struct pci_driver e1000_driver = {
 static int __init e1000_init_module(void)
 {
         int ret;
+
         pr_info("Intel(R) PRO/1000 Network Driver - %s\n",
                 e1000e_driver_version);
         pr_info("Copyright(c) 1999 - 2014 Intel Corporation.\n");
diff --git a/drivers/net/ethernet/intel/e1000e/nvm.c b/drivers/net/ethernet/intel/e1000e/nvm.c
index a9a976f04bff..b1f212b7baf7 100644
--- a/drivers/net/ethernet/intel/e1000e/nvm.c
+++ b/drivers/net/ethernet/intel/e1000e/nvm.c
@@ -398,6 +398,7 @@ s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
                 /* Loop to allow for up to whole page write of eeprom */
                 while (widx < words) {
                         u16 word_out = data[widx];
+
                         word_out = (word_out >> 8) | (word_out << 8);
                         e1000_shift_out_eec_bits(hw, word_out, 16);
                         widx++;
diff --git a/drivers/net/ethernet/intel/e1000e/param.c b/drivers/net/ethernet/intel/e1000e/param.c
index d0ac0f3249c8..aa1923f7ebdd 100644
--- a/drivers/net/ethernet/intel/e1000e/param.c
+++ b/drivers/net/ethernet/intel/e1000e/param.c
@@ -436,6 +436,7 @@ void e1000e_check_options(struct e1000_adapter *adapter)
 
                 if (num_IntMode > bd) {
                         unsigned int int_mode = IntMode[bd];
+
                         e1000_validate_option(&int_mode, &opt, adapter);
                         adapter->int_mode = int_mode;
                 } else {
@@ -457,6 +458,7 @@ void e1000e_check_options(struct e1000_adapter *adapter)
 
                 if (num_SmartPowerDownEnable > bd) {
                         unsigned int spd = SmartPowerDownEnable[bd];
+
                         e1000_validate_option(&spd, &opt, adapter);
                         if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) && spd)
                                 adapter->flags |= FLAG_SMART_POWER_DOWN;
@@ -473,6 +475,7 @@ void e1000e_check_options(struct e1000_adapter *adapter)
 
                 if (num_CrcStripping > bd) {
                         unsigned int crc_stripping = CrcStripping[bd];
+
                         e1000_validate_option(&crc_stripping, &opt, adapter);
                         if (crc_stripping == OPTION_ENABLED) {
                                 adapter->flags2 |= FLAG2_CRC_STRIPPING;
@@ -495,6 +498,7 @@ void e1000e_check_options(struct e1000_adapter *adapter)
 
                 if (num_KumeranLockLoss > bd) {
                         unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
+
                         e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
                         enabled = kmrn_lock_loss;
                 }
diff --git a/drivers/net/ethernet/intel/e1000e/phy.c b/drivers/net/ethernet/intel/e1000e/phy.c
index 00b3fc98bf30..b2005e13fb01 100644
--- a/drivers/net/ethernet/intel/e1000e/phy.c
+++ b/drivers/net/ethernet/intel/e1000e/phy.c
@@ -2896,6 +2896,7 @@ static s32 __e1000_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data,
                     (hw->phy.addr == 2) &&
                     !(MAX_PHY_REG_ADDRESS & reg) && (data & (1 << 11))) {
                         u16 data2 = 0x7EFF;
+
                         ret_val = e1000_access_phy_debug_regs_hv(hw,
                                                                  (1 << 6) | 0x3,
                                                                  &data2, false);