renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-20 11:13:58 +08:00
Code

Merge branch '1GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue

Browse Source 
Jeff Kirsher says:

====================
1GbE Intel Wired LAN Driver Updates 2015-12-12

This series contains updates to e1000, e1000e and igb.

Joern Engel fixes up the e1000 driver to reduce scheduler latencies by
making the eeprom read/write functions scheduler friendly by using a mutex
lock instead of a spin lock.

Todd adds code for igb to initialize the 88E1543 PHY properly.  Then fixed
igb to use the correct i210 register for EEMNGCTL, since the i210 has two
EEPROM access registers (EEARBC and EEMNGCTL).

Dmitry Vyukov provides a fix for e1000 to resolve a data race found with
KernelThreadSanitizer (KTSAN), where no memory barriers were being used
when buffers get recycled, so the recycled buffers can be corrupted.  So
use smp_store_release() to update tx_ring->next_to_clean and
smp_load_acquire() to read tx_ring->next_to_clean to properly hand off
buffers from e1000_clean_tx_irq() to e1000_xmit_frame().

Jarod Wilson fixes igb so that we do not try to unmap a NULL hw_addr.  Then
cleaned up array_rd32() so that it uses igb_rd32() the same as rd32() and
use io_addr() in more places so that we do not have to call E1000_REMOVED().

Janusz Wolak cleans up the e1000 driver by correcting warnings produced
by checkpatch.pl for the driver.

Jean Sacren provides several patches with general cleanups for e1000 and
e1000e, which include code comment fix-ups and cleanup of local variables
not needed.

Dmitry Fleytman fixes a possible division by zero in the receive interrupt
handler for e1000e when working without adaptive interrupt moderation,
which is typically disabled on jumbo MTUs.

Raanan increases the timeout of the polling bit due to timing changes to
the ME firmware on a platform, so increase the timeout to 300ms.  Added
initial support for i219-LM, which is a LOM that will be available on
systems with the Lewisburg Platform Controller HUB (PCH) chipset.

Jan Beulich fixes a NULL dereference in igb, due to the adapter->vf _data
being NULL while adapter->vfs_allocated_count is non-zero.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2015-12-13 17:06:00 -05:00
commit f68766d884
15 changed files with 379 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
drivers/net/ethernet/intel/e1000/e1000.h
View File

@ -213,8 +213,11 @@ struct e1000_rx_ring {
}; };
#define E1000_DESC_UNUSED(R) \ #define E1000_DESC_UNUSED(R) \
((((R)->next_to_clean > (R)->next_to_use) \ ({ \
? 0 : (R)->count) + (R)->next_to_clean - (R)->next_to_use - 1) unsigned int clean = smp_load_acquire(&(R)->next_to_clean); \
unsigned int use = READ_ONCE((R)->next_to_use); \
(clean > use ? 0 : (R)->count) + clean - use - 1; \
})
#define E1000_RX_DESC_EXT(R, i) \ #define E1000_RX_DESC_EXT(R, i) \
(&(((union e1000_rx_desc_extended *)((R).desc))[i])) (&(((union e1000_rx_desc_extended *)((R).desc))[i]))

216
drivers/net/ethernet/intel/e1000/e1000_hw.c
View File

@ -1,5 +1,5 @@
/******************************************************************************* /*******************************************************************************
*
Intel PRO/1000 Linux driver Intel PRO/1000 Linux driver
Copyright(c) 1999 - 2006 Intel Corporation. Copyright(c) 1999 - 2006 Intel Corporation.
@ -106,7 +106,7 @@ u16 e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] = {
120, 120 120, 120
}; };
static DEFINE_SPINLOCK(e1000_eeprom_lock); static DEFINE_MUTEX(e1000_eeprom_lock);
static DEFINE_SPINLOCK(e1000_phy_lock); static DEFINE_SPINLOCK(e1000_phy_lock);
/** /**
@ -624,8 +624,8 @@ s32 e1000_init_hw(struct e1000_hw *hw)
/* Workaround for PCI-X problem when BIOS sets MMRBC /* Workaround for PCI-X problem when BIOS sets MMRBC
* incorrectly. * incorrectly.
*/ */
if (hw->bus_type == e1000_bus_type_pcix if (hw->bus_type == e1000_bus_type_pcix &&
&& e1000_pcix_get_mmrbc(hw) > 2048) e1000_pcix_get_mmrbc(hw) > 2048)
e1000_pcix_set_mmrbc(hw, 2048); e1000_pcix_set_mmrbc(hw, 2048);
break; break;
} }
@ -683,10 +683,9 @@ static s32 e1000_adjust_serdes_amplitude(struct e1000_hw *hw)
} }
ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1, ret_val = e1000_read_eeprom(hw, EEPROM_SERDES_AMPLITUDE, 1,
&eeprom_data); &eeprom_data);
if (ret_val) { if (ret_val)
return ret_val; return ret_val;
}
if (eeprom_data != EEPROM_RESERVED_WORD) { if (eeprom_data != EEPROM_RESERVED_WORD) {
/* Adjust SERDES output amplitude only. */ /* Adjust SERDES output amplitude only. */
@ -1074,8 +1073,8 @@ static s32 e1000_copper_link_preconfig(struct e1000_hw *hw)
if (hw->mac_type <= e1000_82543 || if (hw->mac_type <= e1000_82543 ||
hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 || hw->mac_type == e1000_82541 || hw->mac_type == e1000_82547 ||
hw->mac_type == e1000_82541_rev_2 hw->mac_type == e1000_82541_rev_2 ||
|| hw->mac_type == e1000_82547_rev_2) hw->mac_type == e1000_82547_rev_2)
hw->phy_reset_disable = false; hw->phy_reset_disable = false;
return E1000_SUCCESS; return E1000_SUCCESS;
@ -1652,7 +1651,7 @@ s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
mii_1000t_ctrl_reg = 0; mii_1000t_ctrl_reg = 0;
} else { } else {
ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL,
mii_1000t_ctrl_reg); mii_1000t_ctrl_reg);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
} }
@ -1881,10 +1880,11 @@ static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw)
if (ret_val) if (ret_val)
return ret_val; return ret_val;
if ((hw->mac_type == e1000_82544 || hw->mac_type == e1000_82543) if ((hw->mac_type == e1000_82544 ||
&& (!hw->autoneg) hw->mac_type == e1000_82543) &&
&& (hw->forced_speed_duplex == e1000_10_full (!hw->autoneg) &&
|| hw->forced_speed_duplex == e1000_10_half)) { (hw->forced_speed_duplex == e1000_10_full ||
hw->forced_speed_duplex == e1000_10_half)) {
ret_val = e1000_polarity_reversal_workaround(hw); ret_val = e1000_polarity_reversal_workaround(hw);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
@ -2084,11 +2084,12 @@ static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
* so we had to force link. In this case, we need to force the * so we had to force link. In this case, we need to force the
* configuration of the MAC to match the "fc" parameter. * configuration of the MAC to match the "fc" parameter.
*/ */
if (((hw->media_type == e1000_media_type_fiber) && (hw->autoneg_failed)) if (((hw->media_type == e1000_media_type_fiber) &&
|| ((hw->media_type == e1000_media_type_internal_serdes) (hw->autoneg_failed)) ||
&& (hw->autoneg_failed)) ((hw->media_type == e1000_media_type_internal_serdes) &&
|| ((hw->media_type == e1000_media_type_copper) (hw->autoneg_failed)) ||
&& (!hw->autoneg))) { ((hw->media_type == e1000_media_type_copper) &&
(!hw->autoneg))) {
ret_val = e1000_force_mac_fc(hw); ret_val = e1000_force_mac_fc(hw);
if (ret_val) { if (ret_val) {
e_dbg("Error forcing flow control settings\n"); e_dbg("Error forcing flow control settings\n");
@ -2193,8 +2194,7 @@ static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) && else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
(mii_nway_adv_reg & NWAY_AR_ASM_DIR) && (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
(mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
{
hw->fc = E1000_FC_TX_PAUSE; hw->fc = E1000_FC_TX_PAUSE;
e_dbg e_dbg
("Flow Control = TX PAUSE frames only.\n"); ("Flow Control = TX PAUSE frames only.\n");
@ -2210,8 +2210,7 @@ static s32 e1000_config_fc_after_link_up(struct e1000_hw *hw)
else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) && else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
(mii_nway_adv_reg & NWAY_AR_ASM_DIR) && (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
!(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
(mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
{
hw->fc = E1000_FC_RX_PAUSE; hw->fc = E1000_FC_RX_PAUSE;
e_dbg e_dbg
("Flow Control = RX PAUSE frames only.\n"); ("Flow Control = RX PAUSE frames only.\n");
@ -2460,10 +2459,11 @@ s32 e1000_check_for_link(struct e1000_hw *hw)
* happen due to the execution of this workaround. * happen due to the execution of this workaround.
*/ */
if ((hw->mac_type == e1000_82544 if ((hw->mac_type == e1000_82544 ||
|| hw->mac_type == e1000_82543) && (!hw->autoneg) hw->mac_type == e1000_82543) &&
&& (hw->forced_speed_duplex == e1000_10_full (!hw->autoneg) &&
|| hw->forced_speed_duplex == e1000_10_half)) { (hw->forced_speed_duplex == e1000_10_full ||
hw->forced_speed_duplex == e1000_10_half)) {
ew32(IMC, 0xffffffff); ew32(IMC, 0xffffffff);
ret_val = ret_val =
e1000_polarity_reversal_workaround(hw); e1000_polarity_reversal_workaround(hw);
@ -2528,8 +2528,10 @@ s32 e1000_check_for_link(struct e1000_hw *hw)
*/ */
if (hw->tbi_compatibility_en) { if (hw->tbi_compatibility_en) {
u16 speed, duplex; u16 speed, duplex;
ret_val = ret_val =
e1000_get_speed_and_duplex(hw, &speed, &duplex); e1000_get_speed_and_duplex(hw, &speed, &duplex);
if (ret_val) { if (ret_val) {
e_dbg e_dbg
("Error getting link speed and duplex\n"); ("Error getting link speed and duplex\n");
@ -2628,10 +2630,10 @@ s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex)
e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data); e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_data);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
if ((*speed == SPEED_100 if ((*speed == SPEED_100 &&
&& !(phy_data & NWAY_LPAR_100TX_FD_CAPS)) !(phy_data & NWAY_LPAR_100TX_FD_CAPS)) ||
|| (*speed == SPEED_10 (*speed == SPEED_10 &&
&& !(phy_data & NWAY_LPAR_10T_FD_CAPS))) !(phy_data & NWAY_LPAR_10T_FD_CAPS)))
*duplex = HALF_DUPLEX; *duplex = HALF_DUPLEX;
} }
} }
@ -2664,9 +2666,9 @@ static s32 e1000_wait_autoneg(struct e1000_hw *hw)
ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data); ret_val = e1000_read_phy_reg(hw, PHY_STATUS, &phy_data);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
if (phy_data & MII_SR_AUTONEG_COMPLETE) { if (phy_data & MII_SR_AUTONEG_COMPLETE)
return E1000_SUCCESS; return E1000_SUCCESS;
}
msleep(100); msleep(100);
} }
return E1000_SUCCESS; return E1000_SUCCESS;
@ -2803,11 +2805,11 @@ static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
return data; return data;
} }
/** /**
* e1000_read_phy_reg - read a phy register * e1000_read_phy_reg - read a phy register
* @hw: Struct containing variables accessed by shared code * @hw: Struct containing variables accessed by shared code
* @reg_addr: address of the PHY register to read * @reg_addr: address of the PHY register to read
* @phy_data: pointer to the value on the PHY register
* *
* Reads the value from a PHY register, if the value is on a specific non zero * Reads the value from a PHY register, if the value is on a specific non zero
* page, sets the page first. * page, sets the page first.
@ -2823,14 +2825,13 @@ s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data)
(reg_addr > MAX_PHY_MULTI_PAGE_REG)) { (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT, ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
(u16) reg_addr); (u16) reg_addr);
if (ret_val) { if (ret_val)
spin_unlock_irqrestore(&e1000_phy_lock, flags); goto out;
return ret_val;
}
} }
ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr, ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
phy_data); phy_data);
out:
spin_unlock_irqrestore(&e1000_phy_lock, flags); spin_unlock_irqrestore(&e1000_phy_lock, flags);
return ret_val; return ret_val;
@ -2881,7 +2882,7 @@ static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
e_dbg("MDI Read Error\n"); e_dbg("MDI Read Error\n");
return -E1000_ERR_PHY; return -E1000_ERR_PHY;
} }
*phy_data = (u16) mdic; *phy_data = (u16)mdic;
} else { } else {
mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) | mdic = ((reg_addr << E1000_MDIC_REG_SHIFT) |
(phy_addr << E1000_MDIC_PHY_SHIFT) | (phy_addr << E1000_MDIC_PHY_SHIFT) |
@ -2906,7 +2907,7 @@ static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
e_dbg("MDI Error\n"); e_dbg("MDI Error\n");
return -E1000_ERR_PHY; return -E1000_ERR_PHY;
} }
*phy_data = (u16) mdic; *phy_data = (u16)mdic;
} }
} else { } else {
/* We must first send a preamble through the MDIO pin to signal /* We must first send a preamble through the MDIO pin to signal
@ -2960,7 +2961,7 @@ s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data)
if ((hw->phy_type == e1000_phy_igp) && if ((hw->phy_type == e1000_phy_igp) &&
(reg_addr > MAX_PHY_MULTI_PAGE_REG)) { (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT, ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
(u16) reg_addr); (u16)reg_addr);
if (ret_val) { if (ret_val) {
spin_unlock_irqrestore(&e1000_phy_lock, flags); spin_unlock_irqrestore(&e1000_phy_lock, flags);
return ret_val; return ret_val;
@ -2993,7 +2994,7 @@ static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
* the desired data. * the desired data.
*/ */
if (hw->mac_type == e1000_ce4100) { if (hw->mac_type == e1000_ce4100) {
mdic = (((u32) phy_data) | mdic = (((u32)phy_data) |
(reg_addr << E1000_MDIC_REG_SHIFT) | (reg_addr << E1000_MDIC_REG_SHIFT) |
(phy_addr << E1000_MDIC_PHY_SHIFT) | (phy_addr << E1000_MDIC_PHY_SHIFT) |
(INTEL_CE_GBE_MDIC_OP_WRITE) | (INTEL_CE_GBE_MDIC_OP_WRITE) |
@ -3015,7 +3016,7 @@ static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
return -E1000_ERR_PHY; return -E1000_ERR_PHY;
} }
} else { } else {
mdic = (((u32) phy_data) | mdic = (((u32)phy_data) |
(reg_addr << E1000_MDIC_REG_SHIFT) | (reg_addr << E1000_MDIC_REG_SHIFT) |
(phy_addr << E1000_MDIC_PHY_SHIFT) | (phy_addr << E1000_MDIC_PHY_SHIFT) |
(E1000_MDIC_OP_WRITE)); (E1000_MDIC_OP_WRITE));
@ -3053,7 +3054,7 @@ static s32 e1000_write_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
mdic = ((PHY_TURNAROUND) | (reg_addr << 2) | (phy_addr << 7) | mdic = ((PHY_TURNAROUND) | (reg_addr << 2) | (phy_addr << 7) |
(PHY_OP_WRITE << 12) | (PHY_SOF << 14)); (PHY_OP_WRITE << 12) | (PHY_SOF << 14));
mdic <<= 16; mdic <<= 16;
mdic |= (u32) phy_data; mdic |= (u32)phy_data;
e1000_shift_out_mdi_bits(hw, mdic, 32); e1000_shift_out_mdi_bits(hw, mdic, 32);
} }
@ -3176,14 +3177,14 @@ static s32 e1000_detect_gig_phy(struct e1000_hw *hw)
if (ret_val) if (ret_val)
return ret_val; return ret_val;
hw->phy_id = (u32) (phy_id_high << 16); hw->phy_id = (u32)(phy_id_high << 16);
udelay(20); udelay(20);
ret_val = e1000_read_phy_reg(hw, PHY_ID2, &phy_id_low); ret_val = e1000_read_phy_reg(hw, PHY_ID2, &phy_id_low);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
hw->phy_id |= (u32) (phy_id_low & PHY_REVISION_MASK); hw->phy_id |= (u32)(phy_id_low & PHY_REVISION_MASK);
hw->phy_revision = (u32) phy_id_low & ~PHY_REVISION_MASK; hw->phy_revision = (u32)phy_id_low & ~PHY_REVISION_MASK;
switch (hw->mac_type) { switch (hw->mac_type) {
case e1000_82543: case e1000_82543:
@ -3401,7 +3402,6 @@ static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >> phy_info->remote_rx = ((phy_data & SR_1000T_REMOTE_RX_STATUS) >>
SR_1000T_REMOTE_RX_STATUS_SHIFT) ? SR_1000T_REMOTE_RX_STATUS_SHIFT) ?
e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok; e1000_1000t_rx_status_ok : e1000_1000t_rx_status_not_ok;
} }
return E1000_SUCCESS; return E1000_SUCCESS;
@ -3449,7 +3449,7 @@ s32 e1000_phy_get_info(struct e1000_hw *hw, struct e1000_phy_info *phy_info)
if (hw->phy_type == e1000_phy_igp) if (hw->phy_type == e1000_phy_igp)
return e1000_phy_igp_get_info(hw, phy_info); return e1000_phy_igp_get_info(hw, phy_info);
else if ((hw->phy_type == e1000_phy_8211) || else if ((hw->phy_type == e1000_phy_8211) ||
(hw->phy_type == e1000_phy_8201)) (hw->phy_type == e1000_phy_8201))
return E1000_SUCCESS; return E1000_SUCCESS;
else else
return e1000_phy_m88_get_info(hw, phy_info); return e1000_phy_m88_get_info(hw, phy_info);
@ -3611,11 +3611,11 @@ static void e1000_shift_out_ee_bits(struct e1000_hw *hw, u16 data, u16 count)
*/ */
mask = 0x01 << (count - 1); mask = 0x01 << (count - 1);
eecd = er32(EECD); eecd = er32(EECD);
if (eeprom->type == e1000_eeprom_microwire) { if (eeprom->type == e1000_eeprom_microwire)
eecd &= ~E1000_EECD_DO; eecd &= ~E1000_EECD_DO;
} else if (eeprom->type == e1000_eeprom_spi) { else if (eeprom->type == e1000_eeprom_spi)
eecd |= E1000_EECD_DO; eecd |= E1000_EECD_DO;
}
do { do {
/* A "1" is shifted out to the EEPROM by setting bit "DI" to a /* A "1" is shifted out to the EEPROM by setting bit "DI" to a
* "1", and then raising and then lowering the clock (the SK bit * "1", and then raising and then lowering the clock (the SK bit
@ -3851,7 +3851,7 @@ static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw)
do { do {
e1000_shift_out_ee_bits(hw, EEPROM_RDSR_OPCODE_SPI, e1000_shift_out_ee_bits(hw, EEPROM_RDSR_OPCODE_SPI,
hw->eeprom.opcode_bits); hw->eeprom.opcode_bits);
spi_stat_reg = (u8) e1000_shift_in_ee_bits(hw, 8); spi_stat_reg = (u8)e1000_shift_in_ee_bits(hw, 8);
if (!(spi_stat_reg & EEPROM_STATUS_RDY_SPI)) if (!(spi_stat_reg & EEPROM_STATUS_RDY_SPI))
break; break;
@ -3882,9 +3882,10 @@ static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw)
s32 e1000_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) s32 e1000_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
{ {
s32 ret; s32 ret;
spin_lock(&e1000_eeprom_lock);
mutex_lock(&e1000_eeprom_lock);
ret = e1000_do_read_eeprom(hw, offset, words, data); ret = e1000_do_read_eeprom(hw, offset, words, data);
spin_unlock(&e1000_eeprom_lock); mutex_unlock(&e1000_eeprom_lock);
return ret; return ret;
} }
@ -3896,15 +3897,16 @@ static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
if (hw->mac_type == e1000_ce4100) { if (hw->mac_type == e1000_ce4100) {
GBE_CONFIG_FLASH_READ(GBE_CONFIG_BASE_VIRT, offset, words, GBE_CONFIG_FLASH_READ(GBE_CONFIG_BASE_VIRT, offset, words,
data); data);
return E1000_SUCCESS; return E1000_SUCCESS;
} }
/* A check for invalid values: offset too large, too many words, and /* A check for invalid values: offset too large, too many words, and
* not enough words. * not enough words.
*/ */
if ((offset >= eeprom->word_size) if ((offset >= eeprom->word_size) ||
|| (words > eeprom->word_size - offset) || (words == 0)) { (words > eeprom->word_size - offset) ||
(words == 0)) {
e_dbg("\"words\" parameter out of bounds. Words = %d," e_dbg("\"words\" parameter out of bounds. Words = %d,"
"size = %d\n", offset, eeprom->word_size); "size = %d\n", offset, eeprom->word_size);
return -E1000_ERR_EEPROM; return -E1000_ERR_EEPROM;
@ -3940,7 +3942,7 @@ static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
/* Send the READ command (opcode + addr) */ /* Send the READ command (opcode + addr) */
e1000_shift_out_ee_bits(hw, read_opcode, eeprom->opcode_bits); e1000_shift_out_ee_bits(hw, read_opcode, eeprom->opcode_bits);
e1000_shift_out_ee_bits(hw, (u16) (offset * 2), e1000_shift_out_ee_bits(hw, (u16)(offset * 2),
eeprom->address_bits); eeprom->address_bits);
/* Read the data. The address of the eeprom internally /* Read the data. The address of the eeprom internally
@ -3960,7 +3962,7 @@ static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
e1000_shift_out_ee_bits(hw, e1000_shift_out_ee_bits(hw,
EEPROM_READ_OPCODE_MICROWIRE, EEPROM_READ_OPCODE_MICROWIRE,
eeprom->opcode_bits); eeprom->opcode_bits);
e1000_shift_out_ee_bits(hw, (u16) (offset + i), e1000_shift_out_ee_bits(hw, (u16)(offset + i),
eeprom->address_bits); eeprom->address_bits);
/* Read the data. For microwire, each word requires the /* Read the data. For microwire, each word requires the
@ -3968,6 +3970,7 @@ static s32 e1000_do_read_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
*/ */
data[i] = e1000_shift_in_ee_bits(hw, 16); data[i] = e1000_shift_in_ee_bits(hw, 16);
e1000_standby_eeprom(hw); e1000_standby_eeprom(hw);
cond_resched();
} }
} }
@ -4004,7 +4007,7 @@ s32 e1000_validate_eeprom_checksum(struct e1000_hw *hw)
return E1000_SUCCESS; return E1000_SUCCESS;
#endif #endif
if (checksum == (u16) EEPROM_SUM) if (checksum == (u16)EEPROM_SUM)
return E1000_SUCCESS; return E1000_SUCCESS;
else { else {
e_dbg("EEPROM Checksum Invalid\n"); e_dbg("EEPROM Checksum Invalid\n");
@ -4031,7 +4034,7 @@ s32 e1000_update_eeprom_checksum(struct e1000_hw *hw)
} }
checksum += eeprom_data; checksum += eeprom_data;
} }
checksum = (u16) EEPROM_SUM - checksum; checksum = (u16)EEPROM_SUM - checksum;
if (e1000_write_eeprom(hw, EEPROM_CHECKSUM_REG, 1, &checksum) < 0) { if (e1000_write_eeprom(hw, EEPROM_CHECKSUM_REG, 1, &checksum) < 0) {
e_dbg("EEPROM Write Error\n"); e_dbg("EEPROM Write Error\n");
return -E1000_ERR_EEPROM; return -E1000_ERR_EEPROM;
@ -4052,9 +4055,10 @@ s32 e1000_update_eeprom_checksum(struct e1000_hw *hw)
s32 e1000_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) s32 e1000_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
{ {
s32 ret; s32 ret;
spin_lock(&e1000_eeprom_lock);
mutex_lock(&e1000_eeprom_lock);
ret = e1000_do_write_eeprom(hw, offset, words, data); ret = e1000_do_write_eeprom(hw, offset, words, data);
spin_unlock(&e1000_eeprom_lock); mutex_unlock(&e1000_eeprom_lock);
return ret; return ret;
} }
@ -4066,15 +4070,16 @@ static s32 e1000_do_write_eeprom(struct e1000_hw *hw, u16 offset, u16 words,
if (hw->mac_type == e1000_ce4100) { if (hw->mac_type == e1000_ce4100) {
GBE_CONFIG_FLASH_WRITE(GBE_CONFIG_BASE_VIRT, offset, words, GBE_CONFIG_FLASH_WRITE(GBE_CONFIG_BASE_VIRT, offset, words,
data); data);
return E1000_SUCCESS; return E1000_SUCCESS;
} }
/* A check for invalid values: offset too large, too many words, and /* A check for invalid values: offset too large, too many words, and
* not enough words. * not enough words.
*/ */
if ((offset >= eeprom->word_size) if ((offset >= eeprom->word_size) ||
|| (words > eeprom->word_size - offset) || (words == 0)) { (words > eeprom->word_size - offset) ||
(words == 0)) {
e_dbg("\"words\" parameter out of bounds\n"); e_dbg("\"words\" parameter out of bounds\n");
return -E1000_ERR_EEPROM; return -E1000_ERR_EEPROM;
} }
@ -4116,6 +4121,7 @@ static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset, u16 words,
return -E1000_ERR_EEPROM; return -E1000_ERR_EEPROM;
e1000_standby_eeprom(hw); e1000_standby_eeprom(hw);
cond_resched();
/* Send the WRITE ENABLE command (8 bit opcode ) */ /* Send the WRITE ENABLE command (8 bit opcode ) */
e1000_shift_out_ee_bits(hw, EEPROM_WREN_OPCODE_SPI, e1000_shift_out_ee_bits(hw, EEPROM_WREN_OPCODE_SPI,
@ -4132,7 +4138,7 @@ static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset, u16 words,
/* Send the Write command (8-bit opcode + addr) */ /* Send the Write command (8-bit opcode + addr) */
e1000_shift_out_ee_bits(hw, write_opcode, eeprom->opcode_bits); e1000_shift_out_ee_bits(hw, write_opcode, eeprom->opcode_bits);
e1000_shift_out_ee_bits(hw, (u16) ((offset + widx) * 2), e1000_shift_out_ee_bits(hw, (u16)((offset + widx) * 2),
eeprom->address_bits); eeprom->address_bits);
/* Send the data */ /* Send the data */
@ -4142,6 +4148,7 @@ static s32 e1000_write_eeprom_spi(struct e1000_hw *hw, u16 offset, u16 words,
*/ */
while (widx < words) { while (widx < words) {
u16 word_out = data[widx]; u16 word_out = data[widx];
word_out = (word_out >> 8) | (word_out << 8); word_out = (word_out >> 8) | (word_out << 8);
e1000_shift_out_ee_bits(hw, word_out, 16); e1000_shift_out_ee_bits(hw, word_out, 16);
widx++; widx++;
@ -4183,9 +4190,9 @@ static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
* EEPROM into write/erase mode. * EEPROM into write/erase mode.
*/ */
e1000_shift_out_ee_bits(hw, EEPROM_EWEN_OPCODE_MICROWIRE, e1000_shift_out_ee_bits(hw, EEPROM_EWEN_OPCODE_MICROWIRE,
(u16) (eeprom->opcode_bits + 2)); (u16)(eeprom->opcode_bits + 2));
e1000_shift_out_ee_bits(hw, 0, (u16) (eeprom->address_bits - 2)); e1000_shift_out_ee_bits(hw, 0, (u16)(eeprom->address_bits - 2));
/* Prepare the EEPROM */ /* Prepare the EEPROM */
e1000_standby_eeprom(hw); e1000_standby_eeprom(hw);
@ -4195,7 +4202,7 @@ static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
e1000_shift_out_ee_bits(hw, EEPROM_WRITE_OPCODE_MICROWIRE, e1000_shift_out_ee_bits(hw, EEPROM_WRITE_OPCODE_MICROWIRE,
eeprom->opcode_bits); eeprom->opcode_bits);
e1000_shift_out_ee_bits(hw, (u16) (offset + words_written), e1000_shift_out_ee_bits(hw, (u16)(offset + words_written),
eeprom->address_bits); eeprom->address_bits);
/* Send the data */ /* Send the data */
@ -4224,6 +4231,7 @@ static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
/* Recover from write */ /* Recover from write */
e1000_standby_eeprom(hw); e1000_standby_eeprom(hw);
cond_resched();
words_written++; words_written++;
} }
@ -4235,9 +4243,9 @@ static s32 e1000_write_eeprom_microwire(struct e1000_hw *hw, u16 offset,
* EEPROM out of write/erase mode. * EEPROM out of write/erase mode.
*/ */
e1000_shift_out_ee_bits(hw, EEPROM_EWDS_OPCODE_MICROWIRE, e1000_shift_out_ee_bits(hw, EEPROM_EWDS_OPCODE_MICROWIRE,
(u16) (eeprom->opcode_bits + 2)); (u16)(eeprom->opcode_bits + 2));
e1000_shift_out_ee_bits(hw, 0, (u16) (eeprom->address_bits - 2)); e1000_shift_out_ee_bits(hw, 0, (u16)(eeprom->address_bits - 2));
return E1000_SUCCESS; return E1000_SUCCESS;
} }
@ -4260,8 +4268,8 @@ s32 e1000_read_mac_addr(struct e1000_hw *hw)
e_dbg("EEPROM Read Error\n"); e_dbg("EEPROM Read Error\n");
return -E1000_ERR_EEPROM; return -E1000_ERR_EEPROM;
} }
hw->perm_mac_addr[i] = (u8) (eeprom_data & 0x00FF); hw->perm_mac_addr[i] = (u8)(eeprom_data & 0x00FF);
hw->perm_mac_addr[i + 1] = (u8) (eeprom_data >> 8); hw->perm_mac_addr[i + 1] = (u8)(eeprom_data >> 8);
} }
switch (hw->mac_type) { switch (hw->mac_type) {
@ -4328,19 +4336,19 @@ u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
*/ */
case 0: case 0:
/* [47:36] i.e. 0x563 for above example address */ /* [47:36] i.e. 0x563 for above example address */
hash_value = ((mc_addr[4] >> 4) | (((u16) mc_addr[5]) << 4)); hash_value = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
break; break;
case 1: case 1:
/* [46:35] i.e. 0xAC6 for above example address */ /* [46:35] i.e. 0xAC6 for above example address */
hash_value = ((mc_addr[4] >> 3) | (((u16) mc_addr[5]) << 5)); hash_value = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5));
break; break;
case 2: case 2:
/* [45:34] i.e. 0x5D8 for above example address */ /* [45:34] i.e. 0x5D8 for above example address */
hash_value = ((mc_addr[4] >> 2) | (((u16) mc_addr[5]) << 6)); hash_value = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
break; break;
case 3: case 3:
/* [43:32] i.e. 0x634 for above example address */ /* [43:32] i.e. 0x634 for above example address */
hash_value = ((mc_addr[4]) | (((u16) mc_addr[5]) << 8)); hash_value = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8));
break; break;
} }
@ -4361,9 +4369,9 @@ void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
/* HW expects these in little endian so we reverse the byte order /* HW expects these in little endian so we reverse the byte order
* from network order (big endian) to little endian * from network order (big endian) to little endian
*/ */
rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) | rar_low = ((u32)addr[0] | ((u32)addr[1] << 8) |
((u32) addr[2] << 16) | ((u32) addr[3] << 24)); ((u32)addr[2] << 16) | ((u32)addr[3] << 24));
rar_high = ((u32) addr[4] | ((u32) addr[5] << 8)); rar_high = ((u32)addr[4] | ((u32)addr[5] << 8));
/* Disable Rx and flush all Rx frames before enabling RSS to avoid Rx /* Disable Rx and flush all Rx frames before enabling RSS to avoid Rx
* unit hang. * unit hang.
@ -4537,7 +4545,7 @@ s32 e1000_setup_led(struct e1000_hw *hw)
if (ret_val) if (ret_val)
return ret_val; return ret_val;
ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO, ret_val = e1000_write_phy_reg(hw, IGP01E1000_GMII_FIFO,
(u16) (hw->phy_spd_default & (u16)(hw->phy_spd_default &
~IGP01E1000_GMII_SPD)); ~IGP01E1000_GMII_SPD));
if (ret_val) if (ret_val)
return ret_val; return ret_val;
@ -4802,7 +4810,7 @@ void e1000_reset_adaptive(struct e1000_hw *hw)
void e1000_update_adaptive(struct e1000_hw *hw) void e1000_update_adaptive(struct e1000_hw *hw)
{ {
if (hw->adaptive_ifs) { if (hw->adaptive_ifs) {
if ((hw->collision_delta *hw->ifs_ratio) > hw->tx_packet_delta) { if ((hw->collision_delta * hw->ifs_ratio) > hw->tx_packet_delta) {
if (hw->tx_packet_delta > MIN_NUM_XMITS) { if (hw->tx_packet_delta > MIN_NUM_XMITS) {
hw->in_ifs_mode = true; hw->in_ifs_mode = true;
if (hw->current_ifs_val < hw->ifs_max_val) { if (hw->current_ifs_val < hw->ifs_max_val) {
@ -4816,8 +4824,8 @@ void e1000_update_adaptive(struct e1000_hw *hw)
} }
} }
} else { } else {
if (hw->in_ifs_mode if (hw->in_ifs_mode &&
&& (hw->tx_packet_delta <= MIN_NUM_XMITS)) { (hw->tx_packet_delta <= MIN_NUM_XMITS)) {
hw->current_ifs_val = 0; hw->current_ifs_val = 0;
hw->in_ifs_mode = false; hw->in_ifs_mode = false;
ew32(AIT, 0); ew32(AIT, 0);
@ -4922,7 +4930,6 @@ static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
/* Use old method for Phy older than IGP */ /* Use old method for Phy older than IGP */
if (hw->phy_type == e1000_phy_m88) { if (hw->phy_type == e1000_phy_m88) {
ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, ret_val = e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS,
&phy_data); &phy_data);
if (ret_val) if (ret_val)
@ -4966,7 +4973,6 @@ static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
}; };
/* Read the AGC registers for all channels */ /* Read the AGC registers for all channels */
for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) { for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
ret_val = ret_val =
e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data); e1000_read_phy_reg(hw, agc_reg_array[i], &phy_data);
if (ret_val) if (ret_val)
@ -4976,8 +4982,8 @@ static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
/* Value bound check. */ /* Value bound check. */
if ((cur_agc_value >= if ((cur_agc_value >=
IGP01E1000_AGC_LENGTH_TABLE_SIZE - 1) IGP01E1000_AGC_LENGTH_TABLE_SIZE - 1) ||
|| (cur_agc_value == 0)) (cur_agc_value == 0))
return -E1000_ERR_PHY; return -E1000_ERR_PHY;
agc_value += cur_agc_value; agc_value += cur_agc_value;
@ -5054,7 +5060,6 @@ static s32 e1000_check_polarity(struct e1000_hw *hw,
*/ */
if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) == if ((phy_data & IGP01E1000_PSSR_SPEED_MASK) ==
IGP01E1000_PSSR_SPEED_1000MBPS) { IGP01E1000_PSSR_SPEED_1000MBPS) {
/* Read the GIG initialization PCS register (0x00B4) */ /* Read the GIG initialization PCS register (0x00B4) */
ret_val = ret_val =
e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG, e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG,
@ -5175,8 +5180,8 @@ static s32 e1000_1000Mb_check_cable_length(struct e1000_hw *hw)
hw->ffe_config_state = e1000_ffe_config_active; hw->ffe_config_state = e1000_ffe_config_active;
ret_val = e1000_write_phy_reg(hw, ret_val = e1000_write_phy_reg(hw,
IGP01E1000_PHY_DSP_FFE, IGP01E1000_PHY_DSP_FFE,
IGP01E1000_PHY_DSP_FFE_CM_CP); IGP01E1000_PHY_DSP_FFE_CM_CP);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
break; break;
@ -5243,7 +5248,7 @@ static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
msleep(20); msleep(20);
ret_val = e1000_write_phy_reg(hw, 0x0000, ret_val = e1000_write_phy_reg(hw, 0x0000,
IGP01E1000_IEEE_FORCE_GIGA); IGP01E1000_IEEE_FORCE_GIGA);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) { for (i = 0; i < IGP01E1000_PHY_CHANNEL_NUM; i++) {
@ -5264,7 +5269,7 @@ static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
} }
ret_val = e1000_write_phy_reg(hw, 0x0000, ret_val = e1000_write_phy_reg(hw, 0x0000,
IGP01E1000_IEEE_RESTART_AUTONEG); IGP01E1000_IEEE_RESTART_AUTONEG);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
@ -5299,7 +5304,7 @@ static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
msleep(20); msleep(20);
ret_val = e1000_write_phy_reg(hw, 0x0000, ret_val = e1000_write_phy_reg(hw, 0x0000,
IGP01E1000_IEEE_FORCE_GIGA); IGP01E1000_IEEE_FORCE_GIGA);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
ret_val = ret_val =
@ -5309,7 +5314,7 @@ static s32 e1000_config_dsp_after_link_change(struct e1000_hw *hw, bool link_up)
return ret_val; return ret_val;
ret_val = e1000_write_phy_reg(hw, 0x0000, ret_val = e1000_write_phy_reg(hw, 0x0000,
IGP01E1000_IEEE_RESTART_AUTONEG); IGP01E1000_IEEE_RESTART_AUTONEG);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
@ -5346,9 +5351,8 @@ static s32 e1000_set_phy_mode(struct e1000_hw *hw)
ret_val = ret_val =
e1000_read_eeprom(hw, EEPROM_PHY_CLASS_WORD, 1, e1000_read_eeprom(hw, EEPROM_PHY_CLASS_WORD, 1,
&eeprom_data); &eeprom_data);
if (ret_val) { if (ret_val)
return ret_val; return ret_val;
}
if ((eeprom_data != EEPROM_RESERVED_WORD) && if ((eeprom_data != EEPROM_RESERVED_WORD) &&
(eeprom_data & EEPROM_PHY_CLASS_A)) { (eeprom_data & EEPROM_PHY_CLASS_A)) {
@ -5395,8 +5399,8 @@ static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
* from the lowest speeds starting from 10Mbps. The capability is used * from the lowest speeds starting from 10Mbps. The capability is used
* for Dx transitions and states * for Dx transitions and states
*/ */
if (hw->mac_type == e1000_82541_rev_2 if (hw->mac_type == e1000_82541_rev_2 ||
|| hw->mac_type == e1000_82547_rev_2) { hw->mac_type == e1000_82547_rev_2) {
ret_val = ret_val =
e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO, &phy_data); e1000_read_phy_reg(hw, IGP01E1000_GMII_FIFO, &phy_data);
if (ret_val) if (ret_val)
@ -5446,11 +5450,9 @@ static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
if (ret_val) if (ret_val)
return ret_val; return ret_val;
} }
} else if ((hw->autoneg_advertised == AUTONEG_ADVERTISE_SPEED_DEFAULT) } else if ((hw->autoneg_advertised == AUTONEG_ADVERTISE_SPEED_DEFAULT) ||
|| (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_ALL) (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_ALL) ||
|| (hw->autoneg_advertised == (hw->autoneg_advertised == AUTONEG_ADVERTISE_10_100_ALL)) {
AUTONEG_ADVERTISE_10_100_ALL)) {
if (hw->mac_type == e1000_82541_rev_2 || if (hw->mac_type == e1000_82541_rev_2 ||
hw->mac_type == e1000_82547_rev_2) { hw->mac_type == e1000_82547_rev_2) {
phy_data |= IGP01E1000_GMII_FLEX_SPD; phy_data |= IGP01E1000_GMII_FLEX_SPD;
@ -5474,7 +5476,6 @@ static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active)
phy_data); phy_data);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
} }
return E1000_SUCCESS; return E1000_SUCCESS;
} }
@ -5542,7 +5543,6 @@ static s32 e1000_set_vco_speed(struct e1000_hw *hw)
return E1000_SUCCESS; return E1000_SUCCESS;
} }
/** /**
* e1000_enable_mng_pass_thru - check for bmc pass through * e1000_enable_mng_pass_thru - check for bmc pass through
* @hw: Struct containing variables accessed by shared code * @hw: Struct containing variables accessed by shared code

133
drivers/net/ethernet/intel/e1000/e1000_main.c
View File

@ -99,13 +99,13 @@ int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
void e1000_free_all_tx_resources(struct e1000_adapter *adapter); void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
void e1000_free_all_rx_resources(struct e1000_adapter *adapter); void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
static int e1000_setup_tx_resources(struct e1000_adapter *adapter, static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
struct e1000_tx_ring *txdr); struct e1000_tx_ring *txdr);
static int e1000_setup_rx_resources(struct e1000_adapter *adapter, static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
struct e1000_rx_ring *rxdr); struct e1000_rx_ring *rxdr);
static void e1000_free_tx_resources(struct e1000_adapter *adapter, static void e1000_free_tx_resources(struct e1000_adapter *adapter,
struct e1000_tx_ring *tx_ring); struct e1000_tx_ring *tx_ring);
static void e1000_free_rx_resources(struct e1000_adapter *adapter, static void e1000_free_rx_resources(struct e1000_adapter *adapter,
struct e1000_rx_ring *rx_ring); struct e1000_rx_ring *rx_ring);
void e1000_update_stats(struct e1000_adapter *adapter); void e1000_update_stats(struct e1000_adapter *adapter);
static int e1000_init_module(void); static int e1000_init_module(void);
@ -122,16 +122,16 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter);
static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter); static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter); static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
static void e1000_clean_tx_ring(struct e1000_adapter *adapter, static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
struct e1000_tx_ring *tx_ring); struct e1000_tx_ring *tx_ring);
static void e1000_clean_rx_ring(struct e1000_adapter *adapter, static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
struct e1000_rx_ring *rx_ring); struct e1000_rx_ring *rx_ring);
static void e1000_set_rx_mode(struct net_device *netdev); static void e1000_set_rx_mode(struct net_device *netdev);
static void e1000_update_phy_info_task(struct work_struct *work); static void e1000_update_phy_info_task(struct work_struct *work);
static void e1000_watchdog(struct work_struct *work); static void e1000_watchdog(struct work_struct *work);
static void e1000_82547_tx_fifo_stall_task(struct work_struct *work); static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb, static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
struct net_device *netdev); struct net_device *netdev);
static struct net_device_stats * e1000_get_stats(struct net_device *netdev); static struct net_device_stats *e1000_get_stats(struct net_device *netdev);
static int e1000_change_mtu(struct net_device *netdev, int new_mtu); static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
static int e1000_set_mac(struct net_device *netdev, void *p); static int e1000_set_mac(struct net_device *netdev, void *p);
static irqreturn_t e1000_intr(int irq, void *data); static irqreturn_t e1000_intr(int irq, void *data);
@ -164,7 +164,7 @@ static void e1000_tx_timeout(struct net_device *dev);
static void e1000_reset_task(struct work_struct *work); static void e1000_reset_task(struct work_struct *work);
static void e1000_smartspeed(struct e1000_adapter *adapter); static void e1000_smartspeed(struct e1000_adapter *adapter);
static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter, static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
struct sk_buff *skb); struct sk_buff *skb);
static bool e1000_vlan_used(struct e1000_adapter *adapter); static bool e1000_vlan_used(struct e1000_adapter *adapter);
static void e1000_vlan_mode(struct net_device *netdev, static void e1000_vlan_mode(struct net_device *netdev,
@ -195,7 +195,7 @@ MODULE_PARM_DESC(copybreak,
"Maximum size of packet that is copied to a new buffer on receive"); "Maximum size of packet that is copied to a new buffer on receive");
static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
pci_channel_state_t state); pci_channel_state_t state);
static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev); static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
static void e1000_io_resume(struct pci_dev *pdev); static void e1000_io_resume(struct pci_dev *pdev);
@ -287,7 +287,7 @@ static int e1000_request_irq(struct e1000_adapter *adapter)
int err; int err;
err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name, err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
netdev); netdev);
if (err) { if (err) {
e_err(probe, "Unable to allocate interrupt Error: %d\n", err); e_err(probe, "Unable to allocate interrupt Error: %d\n", err);
} }
@ -636,8 +636,8 @@ void e1000_reset(struct e1000_adapter *adapter)
* but don't include ethernet FCS because hardware appends it * but don't include ethernet FCS because hardware appends it
*/ */
min_tx_space = (hw->max_frame_size + min_tx_space = (hw->max_frame_size +
sizeof(struct e1000_tx_desc) - sizeof(struct e1000_tx_desc) -
ETH_FCS_LEN) * 2; ETH_FCS_LEN) * 2;
min_tx_space = ALIGN(min_tx_space, 1024); min_tx_space = ALIGN(min_tx_space, 1024);
min_tx_space >>= 10; min_tx_space >>= 10;
/* software strips receive CRC, so leave room for it */ /* software strips receive CRC, so leave room for it */
@ -943,8 +943,8 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
struct e1000_adapter *adapter; struct e1000_adapter *adapter;
struct e1000_hw *hw; struct e1000_hw *hw;
static int cards_found = 0; static int cards_found;
static int global_quad_port_a = 0; /* global ksp3 port a indication */ static int global_quad_port_a; /* global ksp3 port a indication */
int i, err, pci_using_dac; int i, err, pci_using_dac;
u16 eeprom_data = 0; u16 eeprom_data = 0;
u16 tmp = 0; u16 tmp = 0;
@ -1046,7 +1046,7 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
if (hw->mac_type == e1000_ce4100) { if (hw->mac_type == e1000_ce4100) {
hw->ce4100_gbe_mdio_base_virt = hw->ce4100_gbe_mdio_base_virt =
ioremap(pci_resource_start(pdev, BAR_1), ioremap(pci_resource_start(pdev, BAR_1),
pci_resource_len(pdev, BAR_1)); pci_resource_len(pdev, BAR_1));
if (!hw->ce4100_gbe_mdio_base_virt) if (!hw->ce4100_gbe_mdio_base_virt)
goto err_mdio_ioremap; goto err_mdio_ioremap;
@ -1148,7 +1148,7 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
break; break;
case e1000_82546: case e1000_82546:
case e1000_82546_rev_3: case e1000_82546_rev_3:
if (er32(STATUS) & E1000_STATUS_FUNC_1){ if (er32(STATUS) & E1000_STATUS_FUNC_1) {
e1000_read_eeprom(hw, e1000_read_eeprom(hw,
EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data); EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
break; break;
@ -1199,13 +1199,13 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
hw->phy_addr = i; hw->phy_addr = i;
e1000_read_phy_reg(hw, PHY_ID2, &tmp); e1000_read_phy_reg(hw, PHY_ID2, &tmp);
if (tmp == 0 || tmp == 0xFF) {
if (i == 31) if (tmp != 0 && tmp != 0xFF)
goto err_eeprom;
continue;
} else
break; break;
} }
if (i >= 32)
goto err_eeprom;
} }
/* reset the hardware with the new settings */ /* reset the hardware with the new settings */
@ -1263,7 +1263,7 @@ err_pci_reg:
* @pdev: PCI device information struct * @pdev: PCI device information struct
* *
* e1000_remove is called by the PCI subsystem to alert the driver * e1000_remove is called by the PCI subsystem to alert the driver
* that it should release a PCI device. The could be caused by a * that it should release a PCI device. That could be caused by a
* Hot-Plug event, or because the driver is going to be removed from * Hot-Plug event, or because the driver is going to be removed from
* memory. * memory.
**/ **/
@ -1334,12 +1334,12 @@ static int e1000_sw_init(struct e1000_adapter *adapter)
static int e1000_alloc_queues(struct e1000_adapter *adapter) static int e1000_alloc_queues(struct e1000_adapter *adapter)
{ {
adapter->tx_ring = kcalloc(adapter->num_tx_queues, adapter->tx_ring = kcalloc(adapter->num_tx_queues,
sizeof(struct e1000_tx_ring), GFP_KERNEL); sizeof(struct e1000_tx_ring), GFP_KERNEL);
if (!adapter->tx_ring) if (!adapter->tx_ring)
return -ENOMEM; return -ENOMEM;
adapter->rx_ring = kcalloc(adapter->num_rx_queues, adapter->rx_ring = kcalloc(adapter->num_rx_queues,
sizeof(struct e1000_rx_ring), GFP_KERNEL); sizeof(struct e1000_rx_ring), GFP_KERNEL);
if (!adapter->rx_ring) { if (!adapter->rx_ring) {
kfree(adapter->tx_ring); kfree(adapter->tx_ring);
return -ENOMEM; return -ENOMEM;
@ -1811,20 +1811,20 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
rctl &= ~E1000_RCTL_SZ_4096; rctl &= ~E1000_RCTL_SZ_4096;
rctl |= E1000_RCTL_BSEX; rctl |= E1000_RCTL_BSEX;
switch (adapter->rx_buffer_len) { switch (adapter->rx_buffer_len) {
case E1000_RXBUFFER_2048: case E1000_RXBUFFER_2048:
default: default:
rctl |= E1000_RCTL_SZ_2048; rctl |= E1000_RCTL_SZ_2048;
rctl &= ~E1000_RCTL_BSEX; rctl &= ~E1000_RCTL_BSEX;
break; break;
case E1000_RXBUFFER_4096: case E1000_RXBUFFER_4096:
rctl |= E1000_RCTL_SZ_4096; rctl |= E1000_RCTL_SZ_4096;
break; break;
case E1000_RXBUFFER_8192: case E1000_RXBUFFER_8192:
rctl |= E1000_RCTL_SZ_8192; rctl |= E1000_RCTL_SZ_8192;
break; break;
case E1000_RXBUFFER_16384: case E1000_RXBUFFER_16384:
rctl |= E1000_RCTL_SZ_16384; rctl |= E1000_RCTL_SZ_16384;
break; break;
} }
/* This is useful for sniffing bad packets. */ /* This is useful for sniffing bad packets. */
@ -1861,12 +1861,12 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
if (adapter->netdev->mtu > ETH_DATA_LEN) { if (adapter->netdev->mtu > ETH_DATA_LEN) {
rdlen = adapter->rx_ring[0].count * rdlen = adapter->rx_ring[0].count *
sizeof(struct e1000_rx_desc); sizeof(struct e1000_rx_desc);
adapter->clean_rx = e1000_clean_jumbo_rx_irq; adapter->clean_rx = e1000_clean_jumbo_rx_irq;
adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers; adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
} else { } else {
rdlen = adapter->rx_ring[0].count * rdlen = adapter->rx_ring[0].count *
sizeof(struct e1000_rx_desc); sizeof(struct e1000_rx_desc);
adapter->clean_rx = e1000_clean_rx_irq; adapter->clean_rx = e1000_clean_rx_irq;
adapter->alloc_rx_buf = e1000_alloc_rx_buffers; adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
} }
@ -2761,7 +2761,9 @@ static int e1000_tso(struct e1000_adapter *adapter,
buffer_info->time_stamp = jiffies; buffer_info->time_stamp = jiffies;
buffer_info->next_to_watch = i; buffer_info->next_to_watch = i;
if (++i == tx_ring->count) i = 0; if (++i == tx_ring->count)
i = 0;
tx_ring->next_to_use = i; tx_ring->next_to_use = i;
return true; return true;
@ -2816,7 +2818,9 @@ static bool e1000_tx_csum(struct e1000_adapter *adapter,
buffer_info->time_stamp = jiffies; buffer_info->time_stamp = jiffies;
buffer_info->next_to_watch = i; buffer_info->next_to_watch = i;
if (unlikely(++i == tx_ring->count)) i = 0; if (unlikely(++i == tx_ring->count))
i = 0;
tx_ring->next_to_use = i; tx_ring->next_to_use = i;
return true; return true;
@ -2865,8 +2869,8 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
* packet is smaller than 2048 - 16 - 16 (or 2016) bytes * packet is smaller than 2048 - 16 - 16 (or 2016) bytes
*/ */
if (unlikely((hw->bus_type == e1000_bus_type_pcix) && if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
(size > 2015) && count == 0)) (size > 2015) && count == 0))
size = 2015; size = 2015;
/* Workaround for potential 82544 hang in PCI-X. Avoid /* Workaround for potential 82544 hang in PCI-X. Avoid
* terminating buffers within evenly-aligned dwords. * terminating buffers within evenly-aligned dwords.
@ -2963,7 +2967,7 @@ dma_error:
count--; count--;
while (count--) { while (count--) {
if (i==0) if (i == 0)
i += tx_ring->count; i += tx_ring->count;
i--; i--;
buffer_info = &tx_ring->buffer_info[i]; buffer_info = &tx_ring->buffer_info[i];
@ -3013,7 +3017,8 @@ static void e1000_tx_queue(struct e1000_adapter *adapter,
tx_desc->lower.data = tx_desc->lower.data =
cpu_to_le32(txd_lower | buffer_info->length); cpu_to_le32(txd_lower | buffer_info->length);
tx_desc->upper.data = cpu_to_le32(txd_upper); tx_desc->upper.data = cpu_to_le32(txd_upper);
if (unlikely(++i == tx_ring->count)) i = 0; if (unlikely(++i == tx_ring->count))
i = 0;
} }
tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd); tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
@ -3101,7 +3106,7 @@ static int e1000_maybe_stop_tx(struct net_device *netdev,
return __e1000_maybe_stop_tx(netdev, size); return __e1000_maybe_stop_tx(netdev, size);
} }
#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 ) #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1)
static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb, static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
struct net_device *netdev) struct net_device *netdev)
{ {
@ -3841,7 +3846,7 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
struct e1000_tx_buffer *buffer_info; struct e1000_tx_buffer *buffer_info;
unsigned int i, eop; unsigned int i, eop;
unsigned int count = 0; unsigned int count = 0;
unsigned int total_tx_bytes=0, total_tx_packets=0; unsigned int total_tx_bytes = 0, total_tx_packets = 0;
unsigned int bytes_compl = 0, pkts_compl = 0; unsigned int bytes_compl = 0, pkts_compl = 0;
i = tx_ring->next_to_clean; i = tx_ring->next_to_clean;
@ -3869,14 +3874,18 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
e1000_unmap_and_free_tx_resource(adapter, buffer_info); e1000_unmap_and_free_tx_resource(adapter, buffer_info);
tx_desc->upper.data = 0; tx_desc->upper.data = 0;
if (unlikely(++i == tx_ring->count)) i = 0; if (unlikely(++i == tx_ring->count))
i = 0;
} }
eop = tx_ring->buffer_info[i].next_to_watch; eop = tx_ring->buffer_info[i].next_to_watch;
eop_desc = E1000_TX_DESC(*tx_ring, eop); eop_desc = E1000_TX_DESC(*tx_ring, eop);
} }
tx_ring->next_to_clean = i; /* Synchronize with E1000_DESC_UNUSED called from e1000_xmit_frame,
* which will reuse the cleaned buffers.
*/
smp_store_release(&tx_ring->next_to_clean, i);
netdev_completed_queue(netdev, pkts_compl, bytes_compl); netdev_completed_queue(netdev, pkts_compl, bytes_compl);
@ -3954,9 +3963,11 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
skb_checksum_none_assert(skb); skb_checksum_none_assert(skb);
/* 82543 or newer only */ /* 82543 or newer only */
if (unlikely(hw->mac_type < e1000_82543)) return; if (unlikely(hw->mac_type < e1000_82543))
return;
/* Ignore Checksum bit is set */ /* Ignore Checksum bit is set */
if (unlikely(status & E1000_RXD_STAT_IXSM)) return; if (unlikely(status & E1000_RXD_STAT_IXSM))
return;
/* TCP/UDP checksum error bit is set */ /* TCP/UDP checksum error bit is set */
if (unlikely(errors & E1000_RXD_ERR_TCPE)) { if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
/* let the stack verify checksum errors */ /* let the stack verify checksum errors */
@ -4136,7 +4147,7 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
unsigned int i; unsigned int i;
int cleaned_count = 0; int cleaned_count = 0;
bool cleaned = false; bool cleaned = false;
unsigned int total_rx_bytes=0, total_rx_packets=0; unsigned int total_rx_bytes = 0, total_rx_packets = 0;
i = rx_ring->next_to_clean; i = rx_ring->next_to_clean;
rx_desc = E1000_RX_DESC(*rx_ring, i); rx_desc = E1000_RX_DESC(*rx_ring, i);
@ -4153,7 +4164,9 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
status = rx_desc->status; status = rx_desc->status;
if (++i == rx_ring->count) i = 0; if (++i == rx_ring->count)
i = 0;
next_rxd = E1000_RX_DESC(*rx_ring, i); next_rxd = E1000_RX_DESC(*rx_ring, i);
prefetch(next_rxd); prefetch(next_rxd);
@ -4356,7 +4369,7 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
unsigned int i; unsigned int i;
int cleaned_count = 0; int cleaned_count = 0;
bool cleaned = false; bool cleaned = false;
unsigned int total_rx_bytes=0, total_rx_packets=0; unsigned int total_rx_bytes = 0, total_rx_packets = 0;
i = rx_ring->next_to_clean; i = rx_ring->next_to_clean;
rx_desc = E1000_RX_DESC(*rx_ring, i); rx_desc = E1000_RX_DESC(*rx_ring, i);
@ -4395,7 +4408,9 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
buffer_info->rxbuf.data = NULL; buffer_info->rxbuf.data = NULL;
} }
if (++i == rx_ring->count) i = 0; if (++i == rx_ring->count)
i = 0;
next_rxd = E1000_RX_DESC(*rx_ring, i); next_rxd = E1000_RX_DESC(*rx_ring, i);
prefetch(next_rxd); prefetch(next_rxd);
@ -4683,9 +4698,11 @@ static void e1000_smartspeed(struct e1000_adapter *adapter)
* we assume back-to-back * we assume back-to-back
*/ */
e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status); e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return; if (!(phy_status & SR_1000T_MS_CONFIG_FAULT))
return;
e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status); e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return; if (!(phy_status & SR_1000T_MS_CONFIG_FAULT))
return;
e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl); e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
if (phy_ctrl & CR_1000T_MS_ENABLE) { if (phy_ctrl & CR_1000T_MS_ENABLE) {
phy_ctrl &= ~CR_1000T_MS_ENABLE; phy_ctrl &= ~CR_1000T_MS_ENABLE;

1
drivers/net/ethernet/intel/e1000e/hw.h
View File

@ -91,6 +91,7 @@ struct e1000_hw;
#define E1000_DEV_ID_PCH_SPT_I219_V 0x1570 /* SPT PCH */ #define E1000_DEV_ID_PCH_SPT_I219_V 0x1570 /* SPT PCH */
#define E1000_DEV_ID_PCH_SPT_I219_LM2 0x15B7 /* SPT-H PCH */ #define E1000_DEV_ID_PCH_SPT_I219_LM2 0x15B7 /* SPT-H PCH */
#define E1000_DEV_ID_PCH_SPT_I219_V2 0x15B8 /* SPT-H PCH */ #define E1000_DEV_ID_PCH_SPT_I219_V2 0x15B8 /* SPT-H PCH */
#define E1000_DEV_ID_PCH_LBG_I219_LM3 0x15B9 /* LBG PCH */
#define E1000_REVISION_4 4 #define E1000_REVISION_4 4

45
drivers/net/ethernet/intel/e1000e/ich8lan.c
View File

@ -1984,7 +1984,7 @@ static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw)
int i = 0; int i = 0;
while ((blocked = !(er32(FWSM) & E1000_ICH_FWSM_RSPCIPHY)) && while ((blocked = !(er32(FWSM) & E1000_ICH_FWSM_RSPCIPHY)) &&
(i++ < 10)) (i++ < 30))
usleep_range(10000, 20000); usleep_range(10000, 20000);
return blocked ? E1000_BLK_PHY_RESET : 0; return blocked ? E1000_BLK_PHY_RESET : 0;
} }
@ -3093,24 +3093,45 @@ static s32 e1000_valid_nvm_bank_detect_ich8lan(struct e1000_hw *hw, u32 *bank)
struct e1000_nvm_info *nvm = &hw->nvm; struct e1000_nvm_info *nvm = &hw->nvm;
u32 bank1_offset = nvm->flash_bank_size * sizeof(u16); u32 bank1_offset = nvm->flash_bank_size * sizeof(u16);
u32 act_offset = E1000_ICH_NVM_SIG_WORD * 2 + 1; u32 act_offset = E1000_ICH_NVM_SIG_WORD * 2 + 1;
u32 nvm_dword = 0;
u8 sig_byte = 0; u8 sig_byte = 0;
s32 ret_val; s32 ret_val;
switch (hw->mac.type) { switch (hw->mac.type) {
/* In SPT, read from the CTRL_EXT reg instead of
* accessing the sector valid bits from the nvm
*/
case e1000_pch_spt: case e1000_pch_spt:
*bank = er32(CTRL_EXT) bank1_offset = nvm->flash_bank_size;
& E1000_CTRL_EXT_NVMVS; act_offset = E1000_ICH_NVM_SIG_WORD;
if ((*bank == 0) || (*bank == 1)) {
e_dbg("ERROR: No valid NVM bank present\n"); /* set bank to 0 in case flash read fails */
return -E1000_ERR_NVM; *bank = 0;
} else {
*bank = *bank - 2; /* Check bank 0 */
ret_val = e1000_read_flash_dword_ich8lan(hw, act_offset,
&nvm_dword);
if (ret_val)
return ret_val;
sig_byte = (u8)((nvm_dword & 0xFF00) >> 8);
if ((sig_byte & E1000_ICH_NVM_VALID_SIG_MASK) ==
E1000_ICH_NVM_SIG_VALUE) {
*bank = 0;
return 0; return 0;
} }
break;
/* Check bank 1 */
ret_val = e1000_read_flash_dword_ich8lan(hw, act_offset +
bank1_offset,
&nvm_dword);
if (ret_val)
return ret_val;
sig_byte = (u8)((nvm_dword & 0xFF00) >> 8);
if ((sig_byte & E1000_ICH_NVM_VALID_SIG_MASK) ==
E1000_ICH_NVM_SIG_VALUE) {
*bank = 1;
return 0;
}
e_dbg("ERROR: No valid NVM bank present\n");
return -E1000_ERR_NVM;
case e1000_ich8lan: case e1000_ich8lan:
case e1000_ich9lan: case e1000_ich9lan:
eecd = er32(EECD); eecd = er32(EECD);

12
drivers/net/ethernet/intel/e1000e/netdev.c
View File

@ -1959,8 +1959,10 @@ static irqreturn_t e1000_intr_msix_rx(int __always_unused irq, void *data)
* previous interrupt. * previous interrupt.
*/ */
if (rx_ring->set_itr) { if (rx_ring->set_itr) {
writel(1000000000 / (rx_ring->itr_val * 256), u32 itr = rx_ring->itr_val ?
rx_ring->itr_register); 1000000000 / (rx_ring->itr_val * 256) : 0;
writel(itr, rx_ring->itr_register);
rx_ring->set_itr = 0; rx_ring->set_itr = 0;
} }
@ -7465,6 +7467,7 @@ static const struct pci_device_id e1000_pci_tbl[] = {
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V), board_pch_spt }, { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V), board_pch_spt },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM2), board_pch_spt }, { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM2), board_pch_spt },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V2), board_pch_spt }, { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V2), board_pch_spt },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LBG_I219_LM3), board_pch_spt },
{ 0, 0, 0, 0, 0, 0, 0 } /* terminate list */ { 0, 0, 0, 0, 0, 0, 0 } /* terminate list */
}; };
@ -7504,14 +7507,11 @@ static struct pci_driver e1000_driver = {
**/ **/
static int __init e1000_init_module(void) static int __init e1000_init_module(void)
{ {
int ret;
pr_info("Intel(R) PRO/1000 Network Driver - %s\n", pr_info("Intel(R) PRO/1000 Network Driver - %s\n",
e1000e_driver_version); e1000e_driver_version);
pr_info("Copyright(c) 1999 - 2015 Intel Corporation.\n"); pr_info("Copyright(c) 1999 - 2015 Intel Corporation.\n");
ret = pci_register_driver(&e1000_driver);
return ret; return pci_register_driver(&e1000_driver);
} }
module_init(e1000_init_module); module_init(e1000_init_module);

8
drivers/net/ethernet/intel/igb/e1000_82575.c
View File

@ -272,6 +272,11 @@ static s32 igb_init_phy_params_82575(struct e1000_hw *hw)
if (ret_val) if (ret_val)
goto out; goto out;
} }
if (phy->id == M88E1543_E_PHY_ID) {
ret_val = igb_initialize_M88E1543_phy(hw);
if (ret_val)
goto out;
}
break; break;
case IGP03E1000_E_PHY_ID: case IGP03E1000_E_PHY_ID:
phy->type = e1000_phy_igp_3; phy->type = e1000_phy_igp_3;
@ -294,6 +299,7 @@ static s32 igb_init_phy_params_82575(struct e1000_hw *hw)
case I210_I_PHY_ID: case I210_I_PHY_ID:
phy->type = e1000_phy_i210; phy->type = e1000_phy_i210;
phy->ops.check_polarity = igb_check_polarity_m88; phy->ops.check_polarity = igb_check_polarity_m88;
phy->ops.get_cfg_done = igb_get_cfg_done_i210;
phy->ops.get_phy_info = igb_get_phy_info_m88; phy->ops.get_phy_info = igb_get_phy_info_m88;
phy->ops.get_cable_length = igb_get_cable_length_m88_gen2; phy->ops.get_cable_length = igb_get_cable_length_m88_gen2;
phy->ops.set_d0_lplu_state = igb_set_d0_lplu_state_82580; phy->ops.set_d0_lplu_state = igb_set_d0_lplu_state_82580;
@ -925,6 +931,8 @@ static s32 igb_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
if (phy->id == M88E1512_E_PHY_ID) if (phy->id == M88E1512_E_PHY_ID)
ret_val = igb_initialize_M88E1512_phy(hw); ret_val = igb_initialize_M88E1512_phy(hw);
if (phy->id == M88E1543_E_PHY_ID)
ret_val = igb_initialize_M88E1543_phy(hw);
out: out:
return ret_val; return ret_val;
} }

1
drivers/net/ethernet/intel/igb/e1000_defines.h
View File

@ -990,6 +990,7 @@
#define E1000_M88E1543_PAGE_ADDR 0x16 /* Page Offset Register */ #define E1000_M88E1543_PAGE_ADDR 0x16 /* Page Offset Register */
#define E1000_M88E1543_EEE_CTRL_1 0x0 #define E1000_M88E1543_EEE_CTRL_1 0x0
#define E1000_M88E1543_EEE_CTRL_1_MS 0x0001 /* EEE Master/Slave */ #define E1000_M88E1543_EEE_CTRL_1_MS 0x0001 /* EEE Master/Slave */
#define E1000_M88E1543_FIBER_CTRL 0x0
#define E1000_EEE_ADV_DEV_I354 7 #define E1000_EEE_ADV_DEV_I354 7
#define E1000_EEE_ADV_ADDR_I354 60 #define E1000_EEE_ADV_ADDR_I354 60
#define E1000_EEE_ADV_100_SUPPORTED (1 << 1) /* 100BaseTx EEE Supported */ #define E1000_EEE_ADV_100_SUPPORTED (1 << 1) /* 100BaseTx EEE Supported */

27
drivers/net/ethernet/intel/igb/e1000_i210.c
View File

@ -900,3 +900,30 @@ s32 igb_pll_workaround_i210(struct e1000_hw *hw)
wr32(E1000_MDICNFG, mdicnfg); wr32(E1000_MDICNFG, mdicnfg);
return ret_val; return ret_val;
} }
/**
* igb_get_cfg_done_i210 - Read config done bit
* @hw: pointer to the HW structure
*
* Read the management control register for the config done bit for
* completion status. NOTE: silicon which is EEPROM-less will fail trying
* to read the config done bit, so an error is *ONLY* logged and returns
* 0. If we were to return with error, EEPROM-less silicon
* would not be able to be reset or change link.
**/
s32 igb_get_cfg_done_i210(struct e1000_hw *hw)
{
s32 timeout = PHY_CFG_TIMEOUT;
u32 mask = E1000_NVM_CFG_DONE_PORT_0;
while (timeout) {
if (rd32(E1000_EEMNGCTL_I210) & mask)
break;
usleep_range(1000, 2000);
timeout--;
}
if (!timeout)
hw_dbg("MNG configuration cycle has not completed.\n");
return 0;
}

1
drivers/net/ethernet/intel/igb/e1000_i210.h
View File

@ -34,6 +34,7 @@ s32 igb_write_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr, u16 data);
s32 igb_init_nvm_params_i210(struct e1000_hw *hw); s32 igb_init_nvm_params_i210(struct e1000_hw *hw);
bool igb_get_flash_presence_i210(struct e1000_hw *hw); bool igb_get_flash_presence_i210(struct e1000_hw *hw);
s32 igb_pll_workaround_i210(struct e1000_hw *hw); s32 igb_pll_workaround_i210(struct e1000_hw *hw);
s32 igb_get_cfg_done_i210(struct e1000_hw *hw);
#define E1000_STM_OPCODE 0xDB00 #define E1000_STM_OPCODE 0xDB00
#define E1000_EEPROM_FLASH_SIZE_WORD 0x11 #define E1000_EEPROM_FLASH_SIZE_WORD 0x11

94
drivers/net/ethernet/intel/igb/e1000_phy.c
View File

@ -2277,6 +2277,100 @@ out:
return ret_val; return ret_val;
} }
/**
* igb_initialize_M88E1543_phy - Initialize M88E1512 PHY
* @hw: pointer to the HW structure
*
* Initialize Marvell 1543 to work correctly with Avoton.
**/
s32 igb_initialize_M88E1543_phy(struct e1000_hw *hw)
{
struct e1000_phy_info *phy = &hw->phy;
s32 ret_val = 0;
/* Switch to PHY page 0xFF. */
ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FF);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x214B);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2144);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0x0C28);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2146);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xB233);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x214D);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_2, 0xDC0C);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_1, 0x2159);
if (ret_val)
goto out;
/* Switch to PHY page 0xFB. */
ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x00FB);
if (ret_val)
goto out;
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_CFG_REG_3, 0x0C0D);
if (ret_val)
goto out;
/* Switch to PHY page 0x12. */
ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x12);
if (ret_val)
goto out;
/* Change mode to SGMII-to-Copper */
ret_val = phy->ops.write_reg(hw, E1000_M88E1512_MODE, 0x8001);
if (ret_val)
goto out;
/* Switch to PHY page 1. */
ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0x1);
if (ret_val)
goto out;
/* Change mode to 1000BASE-X/SGMII and autoneg enable */
ret_val = phy->ops.write_reg(hw, E1000_M88E1543_FIBER_CTRL, 0x9140);
if (ret_val)
goto out;
/* Return the PHY to page 0. */
ret_val = phy->ops.write_reg(hw, E1000_M88E1543_PAGE_ADDR, 0);
if (ret_val)
goto out;
ret_val = igb_phy_sw_reset(hw);
if (ret_val) {
hw_dbg("Error committing the PHY changes\n");
return ret_val;
}
/* msec_delay(1000); */
usleep_range(1000, 2000);
out:
return ret_val;
}
/** /**
* igb_power_up_phy_copper - Restore copper link in case of PHY power down * igb_power_up_phy_copper - Restore copper link in case of PHY power down
* @hw: pointer to the HW structure * @hw: pointer to the HW structure

1
drivers/net/ethernet/intel/igb/e1000_phy.h
View File

@ -62,6 +62,7 @@ void igb_power_up_phy_copper(struct e1000_hw *hw);
void igb_power_down_phy_copper(struct e1000_hw *hw); void igb_power_down_phy_copper(struct e1000_hw *hw);
s32 igb_phy_init_script_igp3(struct e1000_hw *hw); s32 igb_phy_init_script_igp3(struct e1000_hw *hw);
s32 igb_initialize_M88E1512_phy(struct e1000_hw *hw); s32 igb_initialize_M88E1512_phy(struct e1000_hw *hw);
s32 igb_initialize_M88E1543_phy(struct e1000_hw *hw);
s32 igb_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data); s32 igb_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data);
s32 igb_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data); s32 igb_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data);
s32 igb_read_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 *data); s32 igb_read_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 *data);

4
drivers/net/ethernet/intel/igb/e1000_regs.h
View File

@ -66,6 +66,7 @@
#define E1000_PBA 0x01000 /* Packet Buffer Allocation - RW */ #define E1000_PBA 0x01000 /* Packet Buffer Allocation - RW */
#define E1000_PBS 0x01008 /* Packet Buffer Size */ #define E1000_PBS 0x01008 /* Packet Buffer Size */
#define E1000_EEMNGCTL 0x01010 /* MNG EEprom Control */ #define E1000_EEMNGCTL 0x01010 /* MNG EEprom Control */
#define E1000_EEMNGCTL_I210 0x12030 /* MNG EEprom Control */
#define E1000_EEARBC_I210 0x12024 /* EEPROM Auto Read Bus Control */ #define E1000_EEARBC_I210 0x12024 /* EEPROM Auto Read Bus Control */
#define E1000_EEWR 0x0102C /* EEPROM Write Register - RW */ #define E1000_EEWR 0x0102C /* EEPROM Write Register - RW */
#define E1000_I2CCMD 0x01028 /* SFPI2C Command Register - RW */ #define E1000_I2CCMD 0x01028 /* SFPI2C Command Register - RW */
@ -385,8 +386,7 @@ do { \
#define array_wr32(reg, offset, value) \ #define array_wr32(reg, offset, value) \
wr32((reg) + ((offset) << 2), (value)) wr32((reg) + ((offset) << 2), (value))
#define array_rd32(reg, offset) \ #define array_rd32(reg, offset) (igb_rd32(hw, reg + ((offset) << 2)))
(readl(hw->hw_addr + reg + ((offset) << 2)))
/* DMA Coalescing registers */ /* DMA Coalescing registers */
#define E1000_PCIEMISC 0x05BB8 /* PCIE misc config register */ #define E1000_PCIEMISC 0x05BB8 /* PCIE misc config register */

2
drivers/net/ethernet/intel/igb/igb.h
View File

@ -389,6 +389,8 @@ struct igb_adapter {
u16 link_speed; u16 link_speed;
u16 link_duplex; u16 link_duplex;
u8 __iomem *io_addr; /* Mainly for iounmap use */
struct work_struct reset_task; struct work_struct reset_task;
struct work_struct watchdog_task; struct work_struct watchdog_task;
bool fc_autoneg; bool fc_autoneg;

22
drivers/net/ethernet/intel/igb/igb_main.c
View File

@ -946,7 +946,6 @@ static void igb_configure_msix(struct igb_adapter *adapter)
static int igb_request_msix(struct igb_adapter *adapter) static int igb_request_msix(struct igb_adapter *adapter)
{ {
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct e1000_hw *hw = &adapter->hw;
int i, err = 0, vector = 0, free_vector = 0; int i, err = 0, vector = 0, free_vector = 0;
err = request_irq(adapter->msix_entries[vector].vector, err = request_irq(adapter->msix_entries[vector].vector,
@ -959,7 +958,7 @@ static int igb_request_msix(struct igb_adapter *adapter)
vector++; vector++;
q_vector->itr_register = hw->hw_addr + E1000_EITR(vector); q_vector->itr_register = adapter->io_addr + E1000_EITR(vector);
if (q_vector->rx.ring && q_vector->tx.ring) if (q_vector->rx.ring && q_vector->tx.ring)
sprintf(q_vector->name, "%s-TxRx-%u", netdev->name, sprintf(q_vector->name, "%s-TxRx-%u", netdev->name,
@ -1230,7 +1229,7 @@ static int igb_alloc_q_vector(struct igb_adapter *adapter,
q_vector->tx.work_limit = adapter->tx_work_limit; q_vector->tx.work_limit = adapter->tx_work_limit;
/* initialize ITR configuration */ /* initialize ITR configuration */
q_vector->itr_register = adapter->hw.hw_addr + E1000_EITR(0); q_vector->itr_register = adapter->io_addr + E1000_EITR(0);
q_vector->itr_val = IGB_START_ITR; q_vector->itr_val = IGB_START_ITR;
/* initialize pointer to rings */ /* initialize pointer to rings */
@ -2294,9 +2293,11 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE); adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
err = -EIO; err = -EIO;
hw->hw_addr = pci_iomap(pdev, 0, 0); adapter->io_addr = pci_iomap(pdev, 0, 0);
if (!hw->hw_addr) if (!adapter->io_addr)
goto err_ioremap; goto err_ioremap;
/* hw->hw_addr can be altered, we'll use adapter->io_addr for unmap */
hw->hw_addr = adapter->io_addr;
netdev->netdev_ops = &igb_netdev_ops; netdev->netdev_ops = &igb_netdev_ops;
igb_set_ethtool_ops(netdev); igb_set_ethtool_ops(netdev);
@ -2656,7 +2657,7 @@ err_sw_init:
#ifdef CONFIG_PCI_IOV #ifdef CONFIG_PCI_IOV
igb_disable_sriov(pdev); igb_disable_sriov(pdev);
#endif #endif
pci_iounmap(pdev, hw->hw_addr); pci_iounmap(pdev, adapter->io_addr);
err_ioremap: err_ioremap:
free_netdev(netdev); free_netdev(netdev);
err_alloc_etherdev: err_alloc_etherdev:
@ -2823,7 +2824,7 @@ static void igb_remove(struct pci_dev *pdev)
igb_clear_interrupt_scheme(adapter); igb_clear_interrupt_scheme(adapter);
pci_iounmap(pdev, hw->hw_addr); pci_iounmap(pdev, adapter->io_addr);
if (hw->flash_address) if (hw->flash_address)
iounmap(hw->flash_address); iounmap(hw->flash_address);
pci_release_selected_regions(pdev, pci_release_selected_regions(pdev,
@ -2856,6 +2857,13 @@ static void igb_probe_vfs(struct igb_adapter *adapter)
if ((hw->mac.type == e1000_i210) || (hw->mac.type == e1000_i211)) if ((hw->mac.type == e1000_i210) || (hw->mac.type == e1000_i211))
return; return;
/* Of the below we really only want the effect of getting
* IGB_FLAG_HAS_MSIX set (if available), without which
* igb_enable_sriov() has no effect.
*/
igb_set_interrupt_capability(adapter, true);
igb_reset_interrupt_capability(adapter);
pci_sriov_set_totalvfs(pdev, 7); pci_sriov_set_totalvfs(pdev, 7);
igb_enable_sriov(pdev, max_vfs); igb_enable_sriov(pdev, max_vfs);