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>
This commit is contained in:
commit
8c174e6f77
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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),
|
||||
|
|
|
@ -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 */
|
||||
|
|
|
@ -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)
|
||||
|
@ -788,58 +795,140 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_hw *hw)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* __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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue