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

Jeff Kirsher says:

====================
This series contains updates to e1000e only.

v2- updates patch 09/15 "e1000e: resolve checkpatch PREFER_PR_LEVEL warning"
    based on feedback from Joe Perches.
====================

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

9 files changed, 339 insertions, 111 deletions

diff --git a/drivers/net/ethernet/intel/e1000e/defines.h b/drivers/net/ethernet/intel/e1000e/defines.h
index 02a12b69555f..7326ea2fef8f 100644
--- a/drivers/net/ethernet/intel/e1000e/defines.h
+++ b/drivers/net/ethernet/intel/e1000e/defines.h
@@ -241,9 +241,9 @@
 #define E1000_CTRL_VME      0x40000000  /* IEEE VLAN mode enable */
 #define E1000_CTRL_PHY_RST  0x80000000  /* PHY Reset */
 
-/* Bit definitions for the Management Data IO (MDIO) and Management Data
- * Clock (MDC) pins in the Device Control Register.
- */
+#define E1000_PCS_LCTL_FORCE_FCTRL      0x80
+
+#define E1000_PCS_LSTS_AN_COMPLETE      0x10000
 
 /* Device Status */
 #define E1000_STATUS_FD         0x00000001      /* Full duplex.0=half,1=full */
@@ -639,6 +639,10 @@
 /* NVM Word Offsets */
 #define NVM_COMPAT                 0x0003
 #define NVM_ID_LED_SETTINGS        0x0004
+#define NVM_FUTURE_INIT_WORD1      0x0019
+#define NVM_COMPAT_VALID_CSUM      0x0001
+#define NVM_FUTURE_INIT_WORD1_VALID_CSUM        0x0040
+
 #define NVM_INIT_CONTROL2_REG      0x000F
 #define NVM_INIT_CONTROL3_PORT_B   0x0014
 #define NVM_INIT_3GIO_3            0x001A
diff --git a/drivers/net/ethernet/intel/e1000e/e1000.h b/drivers/net/ethernet/intel/e1000e/e1000.h
index 6782a2eea1bc..3f8bbc31795c 100644
--- a/drivers/net/ethernet/intel/e1000e/e1000.h
+++ b/drivers/net/ethernet/intel/e1000e/e1000.h
@@ -447,7 +447,7 @@ struct e1000_info {
 #define FLAG_MSI_ENABLED                  (1 << 27)
 /* reserved (1 << 28) */
 #define FLAG_TSO_FORCE                    (1 << 29)
-#define FLAG_RX_RESTART_NOW               (1 << 30)
+#define FLAG_RESTART_NOW                  (1 << 30)
 #define FLAG_MSI_TEST_FAILED              (1 << 31)
 
 #define FLAG2_CRC_STRIPPING               (1 << 0)
diff --git a/drivers/net/ethernet/intel/e1000e/ethtool.c b/drivers/net/ethernet/intel/e1000e/ethtool.c
index f95bc6ee1c22..2225603a8a28 100644
--- a/drivers/net/ethernet/intel/e1000e/ethtool.c
+++ b/drivers/net/ethernet/intel/e1000e/ethtool.c
@@ -98,7 +98,6 @@ static const struct e1000_stats e1000_gstrings_stats[] = {
         E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),
         E1000_STAT("tx_flow_control_xon", stats.xontxc),
         E1000_STAT("tx_flow_control_xoff", stats.xofftxc),
-        E1000_STAT("rx_long_byte_count", stats.gorc),
         E1000_STAT("rx_csum_offload_good", hw_csum_good),
         E1000_STAT("rx_csum_offload_errors", hw_csum_err),
         E1000_STAT("rx_header_split", rx_hdr_split),
diff --git a/drivers/net/ethernet/intel/e1000e/hw.h b/drivers/net/ethernet/intel/e1000e/hw.h
index cf217777586c..06239fe47db1 100644
--- a/drivers/net/ethernet/intel/e1000e/hw.h
+++ b/drivers/net/ethernet/intel/e1000e/hw.h
@@ -191,6 +191,10 @@ enum e1e_registers {
         E1000_ICTXQMTC = 0x0411C, /* Irq Cause Tx Queue MinThreshold Count */
         E1000_ICRXDMTC = 0x04120, /* Irq Cause Rx Desc MinThreshold Count */
         E1000_ICRXOC   = 0x04124, /* Irq Cause Receiver Overrun Count */
+        E1000_PCS_LCTL = 0x04208, /* PCS Link Control - RW */
+        E1000_PCS_LSTAT = 0x0420C, /* PCS Link Status - RO */
+        E1000_PCS_ANADV = 0x04218, /* AN advertisement - RW */
+        E1000_PCS_LPAB = 0x0421C, /* Link Partner Ability - RW */
         E1000_RXCSUM   = 0x05000, /* Rx Checksum Control - RW */
         E1000_RFCTL    = 0x05008, /* Receive Filter Control */
         E1000_MTA      = 0x05200, /* Multicast Table Array - RW Array */
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index 976336547607..051dfda75fc0 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -150,18 +150,25 @@
 
 /* PHY Low Power Idle Control */
 #define I82579_LPI_CTRL                         PHY_REG(772, 20)
+#define I82579_LPI_CTRL_100_ENABLE              0x2000
+#define I82579_LPI_CTRL_1000_ENABLE             0x4000
 #define I82579_LPI_CTRL_ENABLE_MASK             0x6000
 #define I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT    0x80
 
-/* EMI Registers */
+/* Extended Management Interface (EMI) Registers */
 #define I82579_EMI_ADDR         0x10
 #define I82579_EMI_DATA         0x11
 #define I82579_LPI_UPDATE_TIMER 0x4805  /* in 40ns units + 40 ns base value */
-#define I82579_MSE_THRESHOLD    0x084F  /* Mean Square Error Threshold */
+#define I82579_MSE_THRESHOLD    0x084F  /* 82579 Mean Square Error Threshold */
+#define I82577_MSE_THRESHOLD    0x0887  /* 82577 Mean Square Error Threshold */
 #define I82579_MSE_LINK_DOWN    0x2411  /* MSE count before dropping link */
+#define I82579_EEE_PCS_STATUS   0x182D  /* IEEE MMD Register 3.1 >> 8 */
+#define I82579_EEE_LP_ABILITY   0x040F  /* IEEE MMD Register 7.61 */
+#define I82579_EEE_100_SUPPORTED        (1 << 1) /* 100BaseTx EEE supported */
+#define I82579_EEE_1000_SUPPORTED       (1 << 2) /* 1000BaseTx EEE supported */
+#define I217_EEE_PCS_STATUS     0x9401  /* IEEE MMD Register 3.1 */
 #define I217_EEE_ADVERTISEMENT  0x8001  /* IEEE MMD Register 7.60 */
 #define I217_EEE_LP_ABILITY     0x8002  /* IEEE MMD Register 7.61 */
-#define I217_EEE_100_SUPPORTED  (1 << 1)        /* 100BaseTx EEE supported */
 
 /* Intel Rapid Start Technology Support */
 #define I217_PROXY_CTRL                 BM_PHY_REG(BM_WUC_PAGE, 70)
@@ -789,57 +796,139 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_hw *hw)
 }
 
 /**
+ *  __e1000_access_emi_reg_locked - Read/write EMI register
+ *  @hw: pointer to the HW structure
+ *  @addr: EMI address to program
+ *  @data: pointer to value to read/write from/to the EMI address
+ *  @read: boolean flag to indicate read or write
+ *
+ *  This helper function assumes the SW/FW/HW Semaphore is already acquired.
+ **/
+static s32 __e1000_access_emi_reg_locked(struct e1000_hw *hw, u16 address,
+                                         u16 *data, bool read)
+{
+        s32 ret_val = 0;
+
+        ret_val = e1e_wphy_locked(hw, I82579_EMI_ADDR, address);
+        if (ret_val)
+                return ret_val;
+
+        if (read)
+                ret_val = e1e_rphy_locked(hw, I82579_EMI_DATA, data);
+        else
+                ret_val = e1e_wphy_locked(hw, I82579_EMI_DATA, *data);
+
+        return ret_val;
+}
+
+/**
+ *  e1000_read_emi_reg_locked - Read Extended Management Interface register
+ *  @hw: pointer to the HW structure
+ *  @addr: EMI address to program
+ *  @data: value to be read from the EMI address
+ *
+ *  Assumes the SW/FW/HW Semaphore is already acquired.
+ **/
+static s32 e1000_read_emi_reg_locked(struct e1000_hw *hw, u16 addr, u16 *data)
+{
+        return __e1000_access_emi_reg_locked(hw, addr, data, true);
+}
+
+/**
+ *  e1000_write_emi_reg_locked - Write Extended Management Interface register
+ *  @hw: pointer to the HW structure
+ *  @addr: EMI address to program
+ *  @data: value to be written to the EMI address
+ *
+ *  Assumes the SW/FW/HW Semaphore is already acquired.
+ **/
+static s32 e1000_write_emi_reg_locked(struct e1000_hw *hw, u16 addr, u16 data)
+{
+        return __e1000_access_emi_reg_locked(hw, addr, &data, false);
+}
+
+/**
  *  e1000_set_eee_pchlan - Enable/disable EEE support
  *  @hw: pointer to the HW structure
  *
- *  Enable/disable EEE based on setting in dev_spec structure.  The bits in
- *  the LPI Control register will remain set only if/when link is up.
+ *  Enable/disable EEE based on setting in dev_spec structure, the duplex of
+ *  the link and the EEE capabilities of the link partner.  The LPI Control
+ *  register bits will remain set only if/when link is up.
  **/
 static s32 e1000_set_eee_pchlan(struct e1000_hw *hw)
 {
         struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan;
-        s32 ret_val = 0;
-        u16 phy_reg;
+        s32 ret_val;
+        u16 lpi_ctrl;
 
         if ((hw->phy.type != e1000_phy_82579) &&
             (hw->phy.type != e1000_phy_i217))
                 return 0;
 
-        ret_val = e1e_rphy(hw, I82579_LPI_CTRL, &phy_reg);
+        ret_val = hw->phy.ops.acquire(hw);
         if (ret_val)
                 return ret_val;
 
-        if (dev_spec->eee_disable)
-                phy_reg &= ~I82579_LPI_CTRL_ENABLE_MASK;
-        else
-                phy_reg |= I82579_LPI_CTRL_ENABLE_MASK;
-
-        ret_val = e1e_wphy(hw, I82579_LPI_CTRL, phy_reg);
+        ret_val = e1e_rphy_locked(hw, I82579_LPI_CTRL, &lpi_ctrl);
         if (ret_val)
-                return ret_val;
+                goto release;
+
+        /* Clear bits that enable EEE in various speeds */
+        lpi_ctrl &= ~I82579_LPI_CTRL_ENABLE_MASK;
+
+        /* Enable EEE if not disabled by user */
+        if (!dev_spec->eee_disable) {
+                u16 lpa, pcs_status, data;
 
-        if ((hw->phy.type == e1000_phy_i217) && !dev_spec->eee_disable) {
                 /* Save off link partner's EEE ability */
-                ret_val = hw->phy.ops.acquire(hw);
-                if (ret_val)
-                        return ret_val;
-                ret_val = e1e_wphy_locked(hw, I82579_EMI_ADDR,
-                                          I217_EEE_LP_ABILITY);
+                switch (hw->phy.type) {
+                case e1000_phy_82579:
+                        lpa = I82579_EEE_LP_ABILITY;
+                        pcs_status = I82579_EEE_PCS_STATUS;
+                        break;
+                case e1000_phy_i217:
+                        lpa = I217_EEE_LP_ABILITY;
+                        pcs_status = I217_EEE_PCS_STATUS;
+                        break;
+                default:
+                        ret_val = -E1000_ERR_PHY;
+                        goto release;
+                }
+                ret_val = e1000_read_emi_reg_locked(hw, lpa,
+                                                    &dev_spec->eee_lp_ability);
                 if (ret_val)
                         goto release;
-                e1e_rphy_locked(hw, I82579_EMI_DATA, &dev_spec->eee_lp_ability);
 
-                /* EEE is not supported in 100Half, so ignore partner's EEE
-                 * in 100 ability if full-duplex is not advertised.
+                /* Enable EEE only for speeds in which the link partner is
+                 * EEE capable.
                  */
-                e1e_rphy_locked(hw, PHY_LP_ABILITY, &phy_reg);
-                if (!(phy_reg & NWAY_LPAR_100TX_FD_CAPS))
-                        dev_spec->eee_lp_ability &= ~I217_EEE_100_SUPPORTED;
-release:
-                hw->phy.ops.release(hw);
+                if (dev_spec->eee_lp_ability & I82579_EEE_1000_SUPPORTED)
+                        lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE;
+
+                if (dev_spec->eee_lp_ability & I82579_EEE_100_SUPPORTED) {
+                        e1e_rphy_locked(hw, PHY_LP_ABILITY, &data);
+                        if (data & NWAY_LPAR_100TX_FD_CAPS)
+                                lpi_ctrl |= I82579_LPI_CTRL_100_ENABLE;
+                        else
+                                /* EEE is not supported in 100Half, so ignore
+                                 * partner's EEE in 100 ability if full-duplex
+                                 * is not advertised.
+                                 */
+                                dev_spec->eee_lp_ability &=
+                                    ~I82579_EEE_100_SUPPORTED;
+                }
+
+                /* R/Clr IEEE MMD 3.1 bits 11:10 - Tx/Rx LPI Received */
+                ret_val = e1000_read_emi_reg_locked(hw, pcs_status, &data);
+                if (ret_val)
+                        goto release;
         }
 
-        return 0;
+        ret_val = e1e_wphy_locked(hw, I82579_LPI_CTRL, lpi_ctrl);
+release:
+        hw->phy.ops.release(hw);
+
+        return ret_val;
 }
 
 /**
@@ -1757,6 +1846,11 @@ static s32 e1000_hv_phy_workarounds_ich8lan(struct e1000_hw *hw)
         if (ret_val)
                 goto release;
         ret_val = e1e_wphy_locked(hw, BM_PORT_GEN_CFG, phy_data & 0x00FF);
+        if (ret_val)
+                goto release;
+
+        /* set MSE higher to enable link to stay up when noise is high */
+        ret_val = e1000_write_emi_reg_locked(hw, I82577_MSE_THRESHOLD, 0x0034);
 release:
         hw->phy.ops.release(hw);
 
@@ -1983,22 +2077,18 @@ static s32 e1000_lv_phy_workarounds_ich8lan(struct e1000_hw *hw)
 
         /* Set MDIO slow mode before any other MDIO access */
         ret_val = e1000_set_mdio_slow_mode_hv(hw);
+        if (ret_val)
+                return ret_val;
 
         ret_val = hw->phy.ops.acquire(hw);
         if (ret_val)
                 return ret_val;
-        ret_val = e1e_wphy_locked(hw, I82579_EMI_ADDR, I82579_MSE_THRESHOLD);
-        if (ret_val)
-                goto release;
         /* set MSE higher to enable link to stay up when noise is high */
-        ret_val = e1e_wphy_locked(hw, I82579_EMI_DATA, 0x0034);
-        if (ret_val)
-                goto release;
-        ret_val = e1e_wphy_locked(hw, I82579_EMI_ADDR, I82579_MSE_LINK_DOWN);
+        ret_val = e1000_write_emi_reg_locked(hw, I82579_MSE_THRESHOLD, 0x0034);
         if (ret_val)
                 goto release;
         /* drop link after 5 times MSE threshold was reached */
-        ret_val = e1e_wphy_locked(hw, I82579_EMI_DATA, 0x0005);
+        ret_val = e1000_write_emi_reg_locked(hw, I82579_MSE_LINK_DOWN, 0x0005);
 release:
         hw->phy.ops.release(hw);
 
@@ -2172,10 +2262,9 @@ static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw)
                 ret_val = hw->phy.ops.acquire(hw);
                 if (ret_val)
                         return ret_val;
-                ret_val = e1e_wphy_locked(hw, I82579_EMI_ADDR,
-                                          I82579_LPI_UPDATE_TIMER);
-                if (!ret_val)
-                        ret_val = e1e_wphy_locked(hw, I82579_EMI_DATA, 0x1387);
+                ret_val = e1000_write_emi_reg_locked(hw,
+                                                     I82579_LPI_UPDATE_TIMER,
+                                                     0x1387);
                 hw->phy.ops.release(hw);
         }
 
@@ -2949,19 +3038,32 @@ static s32 e1000_validate_nvm_checksum_ich8lan(struct e1000_hw *hw)
 {
         s32 ret_val;
         u16 data;
+        u16 word;
+        u16 valid_csum_mask;
 
-        /* Read 0x19 and check bit 6.  If this bit is 0, the checksum
-         * needs to be fixed.  This bit is an indication that the NVM
-         * was prepared by OEM software and did not calculate the
-         * checksum...a likely scenario.
+        /* Read NVM and check Invalid Image CSUM bit.  If this bit is 0,
+         * the checksum needs to be fixed.  This bit is an indication that
+         * the NVM was prepared by OEM software and did not calculate
+         * the checksum...a likely scenario.
          */
-        ret_val = e1000_read_nvm(hw, 0x19, 1, &data);
+        switch (hw->mac.type) {
+        case e1000_pch_lpt:
+                word = NVM_COMPAT;
+                valid_csum_mask = NVM_COMPAT_VALID_CSUM;
+                break;
+        default:
+                word = NVM_FUTURE_INIT_WORD1;
+                valid_csum_mask = NVM_FUTURE_INIT_WORD1_VALID_CSUM;
+                break;
+        }
+
+        ret_val = e1000_read_nvm(hw, word, 1, &data);
         if (ret_val)
                 return ret_val;
 
-        if (!(data & 0x40)) {
-                data |= 0x40;
-                ret_val = e1000_write_nvm(hw, 0x19, 1, &data);
+        if (!(data & valid_csum_mask)) {
+                data |= valid_csum_mask;
+                ret_val = e1000_write_nvm(hw, word, 1, &data);
                 if (ret_val)
                         return ret_val;
                 ret_val = e1000e_update_nvm_checksum(hw);
@@ -4000,19 +4102,20 @@ void e1000_suspend_workarounds_ich8lan(struct e1000_hw *hw)
                 if (!dev_spec->eee_disable) {
                         u16 eee_advert;
 
-                        ret_val = e1e_wphy_locked(hw, I82579_EMI_ADDR,
-                                                  I217_EEE_ADVERTISEMENT);
+                        ret_val =
+                            e1000_read_emi_reg_locked(hw,
+                                                      I217_EEE_ADVERTISEMENT,
+                                                      &eee_advert);
                         if (ret_val)
                                 goto release;
-                        e1e_rphy_locked(hw, I82579_EMI_DATA, &eee_advert);
 
                         /* Disable LPLU if both link partners support 100BaseT
                          * EEE and 100Full is advertised on both ends of the
                          * link.
                          */
-                        if ((eee_advert & I217_EEE_100_SUPPORTED) &&
+                        if ((eee_advert & I82579_EEE_100_SUPPORTED) &&
                             (dev_spec->eee_lp_ability &
-                             I217_EEE_100_SUPPORTED) &&
+                             I82579_EEE_100_SUPPORTED) &&
                             (hw->phy.autoneg_advertised & ADVERTISE_100_FULL))
                                 phy_ctrl &= ~(E1000_PHY_CTRL_D0A_LPLU |
                                               E1000_PHY_CTRL_NOND0A_LPLU);
diff --git a/drivers/net/ethernet/intel/e1000e/mac.c b/drivers/net/ethernet/intel/e1000e/mac.c
index 54d9dafaf126..0fa4c0656e09 100644
--- a/drivers/net/ethernet/intel/e1000e/mac.c
+++ b/drivers/net/ethernet/intel/e1000e/mac.c
@@ -1021,6 +1021,7 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
 {
         struct e1000_mac_info *mac = &hw->mac;
         s32 ret_val = 0;
+        u32 pcs_status_reg, pcs_adv_reg, pcs_lp_ability_reg, pcs_ctrl_reg;
         u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
         u16 speed, duplex;
 
@@ -1185,6 +1186,130 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
                 }
         }
 
+        /* Check for the case where we have SerDes media and auto-neg is
+         * enabled.  In this case, we need to check and see if Auto-Neg
+         * has completed, and if so, how the PHY and link partner has
+         * flow control configured.
+         */
+        if ((hw->phy.media_type == e1000_media_type_internal_serdes) &&
+            mac->autoneg) {
+                /* Read the PCS_LSTS and check to see if AutoNeg
+                 * has completed.
+                 */
+                pcs_status_reg = er32(PCS_LSTAT);
+
+                if (!(pcs_status_reg & E1000_PCS_LSTS_AN_COMPLETE)) {
+                        e_dbg("PCS Auto Neg has not completed.\n");
+                        return ret_val;
+                }
+
+                /* The AutoNeg process has completed, so we now need to
+                 * read both the Auto Negotiation Advertisement
+                 * Register (PCS_ANADV) and the Auto_Negotiation Base
+                 * Page Ability Register (PCS_LPAB) to determine how
+                 * flow control was negotiated.
+                 */
+                pcs_adv_reg = er32(PCS_ANADV);
+                pcs_lp_ability_reg = er32(PCS_LPAB);
+
+                /* Two bits in the Auto Negotiation Advertisement Register
+                 * (PCS_ANADV) and two bits in the Auto Negotiation Base
+                 * Page Ability Register (PCS_LPAB) determine flow control
+                 * for both the PHY and the link partner.  The following
+                 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
+                 * 1999, describes these PAUSE resolution bits and how flow
+                 * control is determined based upon these settings.
+                 * NOTE:  DC = Don't Care
+                 *
+                 *   LOCAL DEVICE  |   LINK PARTNER
+                 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
+                 *-------|---------|-------|---------|--------------------
+                 *   0   |    0    |  DC   |   DC    | e1000_fc_none
+                 *   0   |    1    |   0   |   DC    | e1000_fc_none
+                 *   0   |    1    |   1   |    0    | e1000_fc_none
+                 *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
+                 *   1   |    0    |   0   |   DC    | e1000_fc_none
+                 *   1   |   DC    |   1   |   DC    | e1000_fc_full
+                 *   1   |    1    |   0   |    0    | e1000_fc_none
+                 *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
+                 *
+                 * Are both PAUSE bits set to 1?  If so, this implies
+                 * Symmetric Flow Control is enabled at both ends.  The
+                 * ASM_DIR bits are irrelevant per the spec.
+                 *
+                 * For Symmetric Flow Control:
+                 *
+                 *   LOCAL DEVICE  |   LINK PARTNER
+                 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
+                 *-------|---------|-------|---------|--------------------
+                 *   1   |   DC    |   1   |   DC    | e1000_fc_full
+                 *
+                 */
+                if ((pcs_adv_reg & E1000_TXCW_PAUSE) &&
+                    (pcs_lp_ability_reg & E1000_TXCW_PAUSE)) {
+                        /* Now we need to check if the user selected Rx ONLY
+                         * of pause frames.  In this case, we had to advertise
+                         * FULL flow control because we could not advertise Rx
+                         * ONLY. Hence, we must now check to see if we need to
+                         * turn OFF the TRANSMISSION of PAUSE frames.
+                         */
+                        if (hw->fc.requested_mode == e1000_fc_full) {
+                                hw->fc.current_mode = e1000_fc_full;
+                                e_dbg("Flow Control = FULL.\n");
+                        } else {
+                                hw->fc.current_mode = e1000_fc_rx_pause;
+                                e_dbg("Flow Control = Rx PAUSE frames only.\n");
+                        }
+                }
+                /* For receiving PAUSE frames ONLY.
+                 *
+                 *   LOCAL DEVICE  |   LINK PARTNER
+                 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
+                 *-------|---------|-------|---------|--------------------
+                 *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
+                 */
+                else if (!(pcs_adv_reg & E1000_TXCW_PAUSE) &&
+                         (pcs_adv_reg & E1000_TXCW_ASM_DIR) &&
+                         (pcs_lp_ability_reg & E1000_TXCW_PAUSE) &&
+                         (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) {
+                        hw->fc.current_mode = e1000_fc_tx_pause;
+                        e_dbg("Flow Control = Tx PAUSE frames only.\n");
+                }
+                /* For transmitting PAUSE frames ONLY.
+                 *
+                 *   LOCAL DEVICE  |   LINK PARTNER
+                 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
+                 *-------|---------|-------|---------|--------------------
+                 *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
+                 */
+                else if ((pcs_adv_reg & E1000_TXCW_PAUSE) &&
+                         (pcs_adv_reg & E1000_TXCW_ASM_DIR) &&
+                         !(pcs_lp_ability_reg & E1000_TXCW_PAUSE) &&
+                         (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) {
+                        hw->fc.current_mode = e1000_fc_rx_pause;
+                        e_dbg("Flow Control = Rx PAUSE frames only.\n");
+                } else {
+                        /* Per the IEEE spec, at this point flow control
+                         * should be disabled.
+                         */
+                        hw->fc.current_mode = e1000_fc_none;
+                        e_dbg("Flow Control = NONE.\n");
+                }
+
+                /* Now we call a subroutine to actually force the MAC
+                 * controller to use the correct flow control settings.
+                 */
+                pcs_ctrl_reg = er32(PCS_LCTL);
+                pcs_ctrl_reg |= E1000_PCS_LCTL_FORCE_FCTRL;
+                ew32(PCS_LCTL, pcs_ctrl_reg);
+
+                ret_val = e1000e_force_mac_fc(hw);
+                if (ret_val) {
+                        e_dbg("Error forcing flow control settings\n");
+                        return ret_val;
+                }
+        }
+
         return 0;
 }
 
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 337644dda14d..05538e66c809 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -765,7 +765,7 @@ static void e1000_alloc_jumbo_rx_buffers(struct e1000_ring *rx_ring,
         struct e1000_buffer *buffer_info;
         struct sk_buff *skb;
         unsigned int i;
-        unsigned int bufsz = 256 - 16 /* for skb_reserve */;
+        unsigned int bufsz = 256 - 16;  /* for skb_reserve */
 
         i = rx_ring->next_to_use;
         buffer_info = &rx_ring->buffer_info[i];
@@ -1671,7 +1671,7 @@ static irqreturn_t e1000_intr_msi(int irq, void *data)
                         /* disable receives */
                         u32 rctl = er32(RCTL);
                         ew32(RCTL, rctl & ~E1000_RCTL_EN);
-                        adapter->flags |= FLAG_RX_RESTART_NOW;
+                        adapter->flags |= FLAG_RESTART_NOW;
                 }
                 /* guard against interrupt when we're going down */
                 if (!test_bit(__E1000_DOWN, &adapter->state))
@@ -1734,7 +1734,7 @@ static irqreturn_t e1000_intr(int irq, void *data)
                         /* disable receives */
                         rctl = er32(RCTL);
                         ew32(RCTL, rctl & ~E1000_RCTL_EN);
-                        adapter->flags |= FLAG_RX_RESTART_NOW;
+                        adapter->flags |= FLAG_RESTART_NOW;
                 }
                 /* guard against interrupt when we're going down */
                 if (!test_bit(__E1000_DOWN, &adapter->state))
@@ -2405,7 +2405,6 @@ static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
 
 static void e1000_set_itr(struct e1000_adapter *adapter)
 {
-        struct e1000_hw *hw = &adapter->hw;
         u16 current_itr;
         u32 new_itr = adapter->itr;
 
@@ -2468,10 +2467,7 @@ set_itr_now:
                 if (adapter->msix_entries)
                         adapter->rx_ring->set_itr = 1;
                 else
-                        if (new_itr)
-                                ew32(ITR, 1000000000 / (new_itr * 256));
-                        else
-                                ew32(ITR, 0);
+                        e1000e_write_itr(adapter, new_itr);
         }
 }
 
@@ -3013,7 +3009,7 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
 
         ew32(RCTL, rctl);
         /* just started the receive unit, no need to restart */
-        adapter->flags &= ~FLAG_RX_RESTART_NOW;
+        adapter->flags &= ~FLAG_RESTART_NOW;
 }
 
 /**
@@ -4300,9 +4296,8 @@ static void e1000_print_link_info(struct e1000_adapter *adapter)
         u32 ctrl = er32(CTRL);
 
         /* Link status message must follow this format for user tools */
-        printk(KERN_INFO "e1000e: %s NIC Link is Up %d Mbps %s Duplex, Flow Control: %s\n",
-                adapter->netdev->name,
-                adapter->link_speed,
+        pr_info("%s NIC Link is Up %d Mbps %s Duplex, Flow Control: %s\n",
+                adapter->netdev->name, adapter->link_speed,
                 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half",
                 (ctrl & E1000_CTRL_TFCE) && (ctrl & E1000_CTRL_RFCE) ? "Rx/Tx" :
                 (ctrl & E1000_CTRL_RFCE) ? "Rx" :
@@ -4355,11 +4350,11 @@ static void e1000e_enable_receives(struct e1000_adapter *adapter)
 {
         /* make sure the receive unit is started */
         if ((adapter->flags & FLAG_RX_NEEDS_RESTART) &&
-            (adapter->flags & FLAG_RX_RESTART_NOW)) {
+            (adapter->flags & FLAG_RESTART_NOW)) {
                 struct e1000_hw *hw = &adapter->hw;
                 u32 rctl = er32(RCTL);
                 ew32(RCTL, rctl | E1000_RCTL_EN);
-                adapter->flags &= ~FLAG_RX_RESTART_NOW;
+                adapter->flags &= ~FLAG_RESTART_NOW;
         }
 }
 
@@ -4521,15 +4516,22 @@ static void e1000_watchdog_task(struct work_struct *work)
                         adapter->link_speed = 0;
                         adapter->link_duplex = 0;
                         /* Link status message must follow this format */
-                        printk(KERN_INFO "e1000e: %s NIC Link is Down\n",
-                               adapter->netdev->name);
+                        pr_info("%s NIC Link is Down\n", adapter->netdev->name);
                         netif_carrier_off(netdev);
                         if (!test_bit(__E1000_DOWN, &adapter->state))
                                 mod_timer(&adapter->phy_info_timer,
                                           round_jiffies(jiffies + 2 * HZ));
 
-                        if (adapter->flags & FLAG_RX_NEEDS_RESTART)
-                                schedule_work(&adapter->reset_task);
+                        /* The link is lost so the controller stops DMA.
+                         * If there is queued Tx work that cannot be done
+                         * or if on an 8000ES2LAN which requires a Rx packet
+                         * buffer work-around on link down event, reset the
+                         * controller to flush the Tx/Rx packet buffers.
+                         * (Do the reset outside of interrupt context).
+                         */
+                        if ((adapter->flags & FLAG_RX_NEEDS_RESTART) ||
+                            (e1000_desc_unused(tx_ring) + 1 < tx_ring->count))
+                                adapter->flags |= FLAG_RESTART_NOW;
                         else
                                 pm_schedule_suspend(netdev->dev.parent,
                                                         LINK_TIMEOUT);
@@ -4551,20 +4553,14 @@ link_up:
         adapter->gotc_old = adapter->stats.gotc;
         spin_unlock(&adapter->stats64_lock);
 
-        e1000e_update_adaptive(&adapter->hw);
-
-        if (!netif_carrier_ok(netdev) &&
-            (e1000_desc_unused(tx_ring) + 1 < tx_ring->count)) {
-                /* We've lost link, so the controller stops DMA,
-                 * but we've got queued Tx work that's never going
-                 * to get done, so reset controller to flush Tx.
-                 * (Do the reset outside of interrupt context).
-                 */
+        if (adapter->flags & FLAG_RESTART_NOW) {
                 schedule_work(&adapter->reset_task);
                 /* return immediately since reset is imminent */
                 return;
         }
 
+        e1000e_update_adaptive(&adapter->hw);
+
         /* Simple mode for Interrupt Throttle Rate (ITR) */
         if (adapter->itr_setting == 4) {
                 /* Symmetric Tx/Rx gets a reduced ITR=2000;
@@ -4918,12 +4914,11 @@ static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
         struct e1000_hw *hw =  &adapter->hw;
         u16 length, offset;
 
-        if (vlan_tx_tag_present(skb)) {
-                if (!((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
-                    (adapter->hw.mng_cookie.status &
-                        E1000_MNG_DHCP_COOKIE_STATUS_VLAN)))
-                        return 0;
-        }
+        if (vlan_tx_tag_present(skb) &&
+            !((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
+              (adapter->hw.mng_cookie.status &
+               E1000_MNG_DHCP_COOKIE_STATUS_VLAN)))
+                return 0;
 
         if (skb->len <= MINIMUM_DHCP_PACKET_SIZE)
                 return 0;
@@ -5134,10 +5129,9 @@ static void e1000_reset_task(struct work_struct *work)
         if (test_bit(__E1000_DOWN, &adapter->state))
                 return;
 
-        if (!((adapter->flags & FLAG_RX_NEEDS_RESTART) &&
-              (adapter->flags & FLAG_RX_RESTART_NOW))) {
+        if (!(adapter->flags & FLAG_RESTART_NOW)) {
                 e1000e_dump(adapter);
-                e_err("Reset adapter\n");
+                e_err("Reset adapter unexpectedly\n");
         }
         e1000e_reinit_locked(adapter);
 }
diff --git a/drivers/net/ethernet/intel/e1000e/nvm.c b/drivers/net/ethernet/intel/e1000e/nvm.c
index b6468804cb2e..1e7882c7d6d4 100644
--- a/drivers/net/ethernet/intel/e1000e/nvm.c
+++ b/drivers/net/ethernet/intel/e1000e/nvm.c
@@ -359,7 +359,7 @@ s32 e1000e_read_nvm_eerd(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
 s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
 {
         struct e1000_nvm_info *nvm = &hw->nvm;
-        s32 ret_val;
+        s32 ret_val = -E1000_ERR_NVM;
         u16 widx = 0;
 
         /* A check for invalid values:  offset too large, too many words,
@@ -371,16 +371,18 @@ s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
                 return -E1000_ERR_NVM;
         }
 
-        ret_val = nvm->ops.acquire(hw);
-        if (ret_val)
-                return ret_val;
-
         while (widx < words) {
                 u8 write_opcode = NVM_WRITE_OPCODE_SPI;
 
-                ret_val = e1000_ready_nvm_eeprom(hw);
+                ret_val = nvm->ops.acquire(hw);
                 if (ret_val)
-                        goto release;
+                        return ret_val;
+
+                ret_val = e1000_ready_nvm_eeprom(hw);
+                if (ret_val) {
+                        nvm->ops.release(hw);
+                        return ret_val;
+                }
 
                 e1000_standby_nvm(hw);
 
@@ -413,12 +415,10 @@ s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
                                 break;
                         }
                 }
+                usleep_range(10000, 20000);
+                nvm->ops.release(hw);
         }
 
-        usleep_range(10000, 20000);
-release:
-        nvm->ops.release(hw);
-
         return ret_val;
 }
 
@@ -464,8 +464,8 @@ s32 e1000_read_pba_string_generic(struct e1000_hw *hw, u8 *pba_num,
         if (nvm_data != NVM_PBA_PTR_GUARD) {
                 e_dbg("NVM PBA number is not stored as string\n");
 
-                /* we will need 11 characters to store the PBA */
-                if (pba_num_size < 11) {
+                /* make sure callers buffer is big enough to store the PBA */
+                if (pba_num_size < E1000_PBANUM_LENGTH) {
                         e_dbg("PBA string buffer too small\n");
                         return E1000_ERR_NO_SPACE;
                 }
diff --git a/drivers/net/ethernet/intel/e1000e/param.c b/drivers/net/ethernet/intel/e1000e/param.c
index 89d536dd7ff5..b29a8a5116a8 100644
--- a/drivers/net/ethernet/intel/e1000e/param.c
+++ b/drivers/net/ethernet/intel/e1000e/param.c
@@ -447,8 +447,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)
+                        if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) && spd)
                                 adapter->flags |= FLAG_SMART_POWER_DOWN;
                 }
         }