Sync the E1000 shared code with Intel internal, this adds fixes,
and more importantly, new I218 adapter support to the em driver. MFC after: 1 week
This commit is contained in:
parent
5749449d9b
commit
8cc64f1e21
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=267935
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2010, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -47,7 +47,7 @@ static s32 e1000_init_hw_82542(struct e1000_hw *hw);
|
||||
static s32 e1000_setup_link_82542(struct e1000_hw *hw);
|
||||
static s32 e1000_led_on_82542(struct e1000_hw *hw);
|
||||
static s32 e1000_led_off_82542(struct e1000_hw *hw);
|
||||
static void e1000_rar_set_82542(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static int e1000_rar_set_82542(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static void e1000_clear_hw_cntrs_82542(struct e1000_hw *hw);
|
||||
static s32 e1000_read_mac_addr_82542(struct e1000_hw *hw);
|
||||
|
||||
@ -409,7 +409,7 @@ static s32 e1000_led_off_82542(struct e1000_hw *hw)
|
||||
* Sets the receive address array register at index to the address passed
|
||||
* in by addr.
|
||||
**/
|
||||
static void e1000_rar_set_82542(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
static int e1000_rar_set_82542(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
{
|
||||
u32 rar_low, rar_high;
|
||||
|
||||
@ -431,6 +431,7 @@ static void e1000_rar_set_82542(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
|
||||
E1000_WRITE_REG_ARRAY(hw, E1000_RA, (index << 1), rar_low);
|
||||
E1000_WRITE_REG_ARRAY(hw, E1000_RA, ((index << 1) + 1), rar_high);
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -1453,10 +1453,14 @@ static void e1000_clear_vfta_82571(struct e1000_hw *hw)
|
||||
static bool e1000_check_mng_mode_82574(struct e1000_hw *hw)
|
||||
{
|
||||
u16 data;
|
||||
s32 ret_val;
|
||||
|
||||
DEBUGFUNC("e1000_check_mng_mode_82574");
|
||||
|
||||
hw->nvm.ops.read(hw, NVM_INIT_CONTROL2_REG, 1, &data);
|
||||
ret_val = hw->nvm.ops.read(hw, NVM_INIT_CONTROL2_REG, 1, &data);
|
||||
if (ret_val)
|
||||
return FALSE;
|
||||
|
||||
return (data & E1000_NVM_INIT_CTRL2_MNGM) != 0;
|
||||
}
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -56,7 +56,6 @@ static s32 e1000_check_for_link_media_swap(struct e1000_hw *hw);
|
||||
static s32 e1000_get_cfg_done_82575(struct e1000_hw *hw);
|
||||
static s32 e1000_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
|
||||
u16 *duplex);
|
||||
static s32 e1000_init_hw_82575(struct e1000_hw *hw);
|
||||
static s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw);
|
||||
static s32 e1000_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
|
||||
u16 *data);
|
||||
@ -120,7 +119,8 @@ static bool e1000_get_i2c_data(u32 *i2cctl);
|
||||
static const u16 e1000_82580_rxpbs_table[] = {
|
||||
36, 72, 144, 1, 2, 4, 8, 16, 35, 70, 140 };
|
||||
#define E1000_82580_RXPBS_TABLE_SIZE \
|
||||
(sizeof(e1000_82580_rxpbs_table)/sizeof(u16))
|
||||
(sizeof(e1000_82580_rxpbs_table) / \
|
||||
sizeof(e1000_82580_rxpbs_table[0]))
|
||||
|
||||
|
||||
/**
|
||||
@ -273,6 +273,11 @@ static s32 e1000_init_phy_params_82575(struct e1000_hw *hw)
|
||||
hw->mac.ops.check_for_link =
|
||||
e1000_check_for_link_media_swap;
|
||||
}
|
||||
if (phy->id == M88E1512_E_PHY_ID) {
|
||||
ret_val = e1000_initialize_M88E1512_phy(hw);
|
||||
if (ret_val)
|
||||
goto out;
|
||||
}
|
||||
break;
|
||||
case IGP03E1000_E_PHY_ID:
|
||||
case IGP04E1000_E_PHY_ID:
|
||||
@ -450,6 +455,9 @@ static s32 e1000_init_mac_params_82575(struct e1000_hw *hw)
|
||||
else
|
||||
mac->ops.reset_hw = e1000_reset_hw_82575;
|
||||
/* hw initialization */
|
||||
if ((mac->type == e1000_i210) || (mac->type == e1000_i211))
|
||||
mac->ops.init_hw = e1000_init_hw_i210;
|
||||
else
|
||||
mac->ops.init_hw = e1000_init_hw_82575;
|
||||
/* link setup */
|
||||
mac->ops.setup_link = e1000_setup_link_generic;
|
||||
@ -750,6 +758,7 @@ static s32 e1000_get_phy_id_82575(struct e1000_hw *hw)
|
||||
static s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
struct e1000_phy_info *phy = &hw->phy;
|
||||
|
||||
DEBUGFUNC("e1000_phy_hw_reset_sgmii_82575");
|
||||
|
||||
@ -772,7 +781,11 @@ static s32 e1000_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
|
||||
goto out;
|
||||
|
||||
ret_val = hw->phy.ops.commit(hw);
|
||||
if (ret_val)
|
||||
goto out;
|
||||
|
||||
if (phy->id == M88E1512_E_PHY_ID)
|
||||
ret_val = e1000_initialize_M88E1512_phy(hw);
|
||||
out:
|
||||
return ret_val;
|
||||
}
|
||||
@ -879,7 +892,6 @@ static s32 e1000_set_d0_lplu_state_82575(struct e1000_hw *hw, bool active)
|
||||
static s32 e1000_set_d0_lplu_state_82580(struct e1000_hw *hw, bool active)
|
||||
{
|
||||
struct e1000_phy_info *phy = &hw->phy;
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u32 data;
|
||||
|
||||
DEBUGFUNC("e1000_set_d0_lplu_state_82580");
|
||||
@ -907,7 +919,7 @@ static s32 e1000_set_d0_lplu_state_82580(struct e1000_hw *hw, bool active)
|
||||
}
|
||||
|
||||
E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, data);
|
||||
return ret_val;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -927,7 +939,6 @@ static s32 e1000_set_d0_lplu_state_82580(struct e1000_hw *hw, bool active)
|
||||
s32 e1000_set_d3_lplu_state_82580(struct e1000_hw *hw, bool active)
|
||||
{
|
||||
struct e1000_phy_info *phy = &hw->phy;
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u32 data;
|
||||
|
||||
DEBUGFUNC("e1000_set_d3_lplu_state_82580");
|
||||
@ -955,7 +966,7 @@ s32 e1000_set_d3_lplu_state_82580(struct e1000_hw *hw, bool active)
|
||||
}
|
||||
|
||||
E1000_WRITE_REG(hw, E1000_82580_PHY_POWER_MGMT, data);
|
||||
return ret_val;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -969,7 +980,7 @@ s32 e1000_set_d3_lplu_state_82580(struct e1000_hw *hw, bool active)
|
||||
**/
|
||||
static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val;
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
|
||||
DEBUGFUNC("e1000_acquire_nvm_82575");
|
||||
|
||||
@ -991,6 +1002,7 @@ static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw)
|
||||
DEBUGOUT("Nvm bit banging access error detected and cleared.\n");
|
||||
}
|
||||
}
|
||||
|
||||
if (hw->mac.type == e1000_82580) {
|
||||
u32 eecd = E1000_READ_REG(hw, E1000_EECD);
|
||||
if (eecd & E1000_EECD_BLOCKED) {
|
||||
@ -1001,7 +1013,6 @@ static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ret_val = e1000_acquire_nvm_generic(hw);
|
||||
if (ret_val)
|
||||
e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
|
||||
@ -1115,7 +1126,6 @@ static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
|
||||
static s32 e1000_get_cfg_done_82575(struct e1000_hw *hw)
|
||||
{
|
||||
s32 timeout = PHY_CFG_TIMEOUT;
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u32 mask = E1000_NVM_CFG_DONE_PORT_0;
|
||||
|
||||
DEBUGFUNC("e1000_get_cfg_done_82575");
|
||||
@ -1140,7 +1150,7 @@ static s32 e1000_get_cfg_done_82575(struct e1000_hw *hw)
|
||||
(hw->phy.type == e1000_phy_igp_3))
|
||||
e1000_phy_init_script_igp3(hw);
|
||||
|
||||
return ret_val;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1466,7 +1476,7 @@ static s32 e1000_reset_hw_82575(struct e1000_hw *hw)
|
||||
*
|
||||
* This inits the hardware readying it for operation.
|
||||
**/
|
||||
static s32 e1000_init_hw_82575(struct e1000_hw *hw)
|
||||
s32 e1000_init_hw_82575(struct e1000_hw *hw)
|
||||
{
|
||||
struct e1000_mac_info *mac = &hw->mac;
|
||||
s32 ret_val;
|
||||
@ -1985,7 +1995,7 @@ static s32 e1000_reset_init_script_82575(struct e1000_hw *hw)
|
||||
**/
|
||||
static s32 e1000_read_mac_addr_82575(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
|
||||
DEBUGFUNC("e1000_read_mac_addr_82575");
|
||||
|
||||
@ -2478,11 +2488,17 @@ static s32 e1000_reset_hw_82580(struct e1000_hw *hw)
|
||||
ctrl |= E1000_CTRL_RST;
|
||||
|
||||
E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
|
||||
/* Add delay to insure DEV_RST has time to complete */
|
||||
if (global_device_reset)
|
||||
msec_delay(5);
|
||||
switch (hw->device_id) {
|
||||
case E1000_DEV_ID_DH89XXCC_SGMII:
|
||||
break;
|
||||
default:
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Add delay to insure DEV_RST or RST has time to complete */
|
||||
msec_delay(5);
|
||||
|
||||
ret_val = e1000_get_auto_rd_done_generic(hw);
|
||||
if (ret_val) {
|
||||
@ -2617,7 +2633,7 @@ s32 e1000_update_nvm_checksum_with_offset(struct e1000_hw *hw, u16 offset)
|
||||
**/
|
||||
static s32 e1000_validate_nvm_checksum_82580(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
u16 eeprom_regions_count = 1;
|
||||
u16 j, nvm_data;
|
||||
u16 nvm_offset;
|
||||
@ -2757,7 +2773,7 @@ static s32 e1000_update_nvm_checksum_i350(struct e1000_hw *hw)
|
||||
static s32 __e1000_access_emi_reg(struct e1000_hw *hw, u16 address,
|
||||
u16 *data, bool read)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
|
||||
DEBUGFUNC("__e1000_access_emi_reg");
|
||||
|
||||
@ -2786,6 +2802,95 @@ s32 e1000_read_emi_reg(struct e1000_hw *hw, u16 addr, u16 *data)
|
||||
return __e1000_access_emi_reg(hw, addr, data, TRUE);
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_initialize_M88E1512_phy - Initialize M88E1512 PHY
|
||||
* @hw: pointer to the HW structure
|
||||
*
|
||||
* Initialize Marverl 1512 to work correctly with Avoton.
|
||||
**/
|
||||
s32 e1000_initialize_M88E1512_phy(struct e1000_hw *hw)
|
||||
{
|
||||
struct e1000_phy_info *phy = &hw->phy;
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
|
||||
DEBUGFUNC("e1000_initialize_M88E1512_phy");
|
||||
|
||||
/* Check if this is correct PHY. */
|
||||
if (phy->id != M88E1512_E_PHY_ID)
|
||||
goto out;
|
||||
|
||||
/* 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, 0xCC0C);
|
||||
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, 0x000D);
|
||||
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;
|
||||
|
||||
/* 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 = phy->ops.commit(hw);
|
||||
if (ret_val) {
|
||||
DEBUGOUT("Error committing the PHY changes\n");
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
msec_delay(1000);
|
||||
out:
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_set_eee_i350 - Enable/disable EEE support
|
||||
* @hw: pointer to the HW structure
|
||||
@ -2795,7 +2900,6 @@ s32 e1000_read_emi_reg(struct e1000_hw *hw, u16 addr, u16 *data)
|
||||
**/
|
||||
s32 e1000_set_eee_i350(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u32 ipcnfg, eeer;
|
||||
|
||||
DEBUGFUNC("e1000_set_eee_i350");
|
||||
@ -2828,7 +2932,7 @@ s32 e1000_set_eee_i350(struct e1000_hw *hw)
|
||||
E1000_READ_REG(hw, E1000_EEER);
|
||||
out:
|
||||
|
||||
return ret_val;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -384,7 +384,7 @@ struct e1000_adv_tx_context_desc {
|
||||
#define E1000_ETQF_FILTER_ENABLE (1 << 26)
|
||||
#define E1000_ETQF_IMM_INT (1 << 29)
|
||||
#define E1000_ETQF_1588 (1 << 30)
|
||||
#define E1000_ETQF_QUEUE_ENABLE (1U << 31)
|
||||
#define E1000_ETQF_QUEUE_ENABLE (1 << 31)
|
||||
/*
|
||||
* ETQF filter list: one static filter per filter consumer. This is
|
||||
* to avoid filter collisions later. Add new filters
|
||||
@ -411,7 +411,7 @@ struct e1000_adv_tx_context_desc {
|
||||
#define E1000_DTXSWC_LLE_MASK 0x00FF0000 /* Per VF Local LB enables */
|
||||
#define E1000_DTXSWC_VLAN_SPOOF_SHIFT 8
|
||||
#define E1000_DTXSWC_LLE_SHIFT 16
|
||||
#define E1000_DTXSWC_VMDQ_LOOPBACK_EN (1U << 31) /* global VF LB enable */
|
||||
#define E1000_DTXSWC_VMDQ_LOOPBACK_EN (1 << 31) /* global VF LB enable */
|
||||
|
||||
/* Easy defines for setting default pool, would normally be left a zero */
|
||||
#define E1000_VT_CTL_DEFAULT_POOL_SHIFT 7
|
||||
@ -480,6 +480,7 @@ void e1000_vmdq_set_loopback_pf(struct e1000_hw *hw, bool enable);
|
||||
void e1000_vmdq_set_anti_spoofing_pf(struct e1000_hw *hw, bool enable, int pf);
|
||||
void e1000_vmdq_set_replication_pf(struct e1000_hw *hw, bool enable);
|
||||
s32 e1000_init_nvm_params_82575(struct e1000_hw *hw);
|
||||
s32 e1000_init_hw_82575(struct e1000_hw *hw);
|
||||
|
||||
enum e1000_promisc_type {
|
||||
e1000_promisc_disabled = 0, /* all promisc modes disabled */
|
||||
@ -497,6 +498,7 @@ s32 e1000_read_emi_reg(struct e1000_hw *hw, u16 addr, u16 *data);
|
||||
s32 e1000_set_eee_i350(struct e1000_hw *);
|
||||
s32 e1000_set_eee_i354(struct e1000_hw *);
|
||||
s32 e1000_get_eee_status_i354(struct e1000_hw *, bool *);
|
||||
s32 e1000_initialize_M88E1512_phy(struct e1000_hw *hw);
|
||||
|
||||
/* I2C SDA and SCL timing parameters for standard mode */
|
||||
#define E1000_I2C_T_HD_STA 4
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -293,6 +293,10 @@ s32 e1000_set_mac_type(struct e1000_hw *hw)
|
||||
case E1000_DEV_ID_PCH_LPT_I217_V:
|
||||
case E1000_DEV_ID_PCH_LPTLP_I218_LM:
|
||||
case E1000_DEV_ID_PCH_LPTLP_I218_V:
|
||||
case E1000_DEV_ID_PCH_I218_LM2:
|
||||
case E1000_DEV_ID_PCH_I218_V2:
|
||||
case E1000_DEV_ID_PCH_I218_LM3:
|
||||
case E1000_DEV_ID_PCH_I218_V3:
|
||||
mac->type = e1000_pch_lpt;
|
||||
break;
|
||||
case E1000_DEV_ID_82575EB_COPPER:
|
||||
@ -828,10 +832,12 @@ void e1000_config_collision_dist(struct e1000_hw *hw)
|
||||
*
|
||||
* Sets a Receive Address Register (RAR) to the specified address.
|
||||
**/
|
||||
void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
int e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
{
|
||||
if (hw->mac.ops.rar_set)
|
||||
hw->mac.ops.rar_set(hw, addr, index);
|
||||
return hw->mac.ops.rar_set(hw, addr, index);
|
||||
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -69,7 +69,7 @@ s32 e1000_setup_link(struct e1000_hw *hw);
|
||||
s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex);
|
||||
s32 e1000_disable_pcie_master(struct e1000_hw *hw);
|
||||
void e1000_config_collision_dist(struct e1000_hw *hw);
|
||||
void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
int e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr);
|
||||
void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list,
|
||||
u32 mc_addr_count);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -77,6 +77,7 @@
|
||||
#define E1000_CTRL_EXT_EE_RST 0x00002000 /* Reinitialize from EEPROM */
|
||||
/* Physical Func Reset Done Indication */
|
||||
#define E1000_CTRL_EXT_PFRSTD 0x00004000
|
||||
#define E1000_CTRL_EXT_SDLPE 0X00040000 /* SerDes Low Power Enable */
|
||||
#define E1000_CTRL_EXT_SPD_BYPS 0x00008000 /* Speed Select Bypass */
|
||||
#define E1000_CTRL_EXT_RO_DIS 0x00020000 /* Relaxed Ordering disable */
|
||||
#define E1000_CTRL_EXT_DMA_DYN_CLK_EN 0x00080000 /* DMA Dynamic Clk Gating */
|
||||
@ -131,7 +132,7 @@
|
||||
#define E1000_RXD_ERR_RXE 0x80 /* Rx Data Error */
|
||||
#define E1000_RXD_SPC_VLAN_MASK 0x0FFF /* VLAN ID is in lower 12 bits */
|
||||
|
||||
#define E1000_RXDEXT_STATERR_TST 0x00010000 /* Time Stamp taken */
|
||||
#define E1000_RXDEXT_STATERR_TST 0x00000100 /* Time Stamp taken */
|
||||
#define E1000_RXDEXT_STATERR_LB 0x00040000
|
||||
#define E1000_RXDEXT_STATERR_CE 0x01000000
|
||||
#define E1000_RXDEXT_STATERR_SE 0x02000000
|
||||
@ -464,6 +465,7 @@
|
||||
|
||||
#define ETHERNET_FCS_SIZE 4
|
||||
#define MAX_JUMBO_FRAME_SIZE 0x3F00
|
||||
#define E1000_TX_PTR_GAP 0x1F
|
||||
|
||||
/* Extended Configuration Control and Size */
|
||||
#define E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP 0x00000020
|
||||
@ -853,6 +855,10 @@
|
||||
#define E1000_PCS_STATUS_ADDR_I354 1
|
||||
#define E1000_PCS_STATUS_RX_LPI_RCVD 0x0400
|
||||
#define E1000_PCS_STATUS_TX_LPI_RCVD 0x0800
|
||||
#define E1000_M88E1512_CFG_REG_1 0x0010
|
||||
#define E1000_M88E1512_CFG_REG_2 0x0011
|
||||
#define E1000_M88E1512_CFG_REG_3 0x0007
|
||||
#define E1000_M88E1512_MODE 0x0014
|
||||
#define E1000_EEE_SU_LPI_CLK_STP 0x00800000 /* EEE LPI Clock Stop */
|
||||
#define E1000_EEE_LP_ADV_DEV_I210 7 /* EEE LP Adv Device */
|
||||
#define E1000_EEE_LP_ADV_ADDR_I210 61 /* EEE LP Adv Register */
|
||||
@ -1429,6 +1435,9 @@
|
||||
#define E1000_RXPBS_CFG_TS_EN 0x80000000 /* Timestamp in Rx buffer */
|
||||
#define E1000_RXPBS_SIZE_I210_MASK 0x0000003F /* Rx packet buffer size */
|
||||
#define E1000_TXPB0S_SIZE_I210_MASK 0x0000003F /* Tx packet buffer 0 size */
|
||||
#define I210_RXPBSIZE_DEFAULT 0x000000A2 /* RXPBSIZE default */
|
||||
#define I210_TXPBSIZE_DEFAULT 0x04000014 /* TXPBSIZE default */
|
||||
|
||||
#define E1000_DOBFFCTL_OBFFTHR_MASK 0x000000FF /* OBFF threshold */
|
||||
#define E1000_DOBFFCTL_EXIT_ACT_MASK 0x01000000 /* Exit active CB */
|
||||
|
||||
@ -1455,5 +1464,7 @@
|
||||
#define E1000_STATUS_LAN_ID_OFFSET 2
|
||||
#define E1000_VFTA_ENTRIES 128
|
||||
#define E1000_UNUSEDARG
|
||||
#ifndef ERROR_REPORT
|
||||
#define ERROR_REPORT(fmt) do { } while (0)
|
||||
#endif /* ERROR_REPORT */
|
||||
#endif /* _E1000_DEFINES_H_ */
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -133,6 +133,10 @@ struct e1000_hw;
|
||||
#define E1000_DEV_ID_PCH_LPT_I217_V 0x153B
|
||||
#define E1000_DEV_ID_PCH_LPTLP_I218_LM 0x155A
|
||||
#define E1000_DEV_ID_PCH_LPTLP_I218_V 0x1559
|
||||
#define E1000_DEV_ID_PCH_I218_LM2 0x15A0
|
||||
#define E1000_DEV_ID_PCH_I218_V2 0x15A1
|
||||
#define E1000_DEV_ID_PCH_I218_LM3 0x15A2 /* Wildcat Point PCH */
|
||||
#define E1000_DEV_ID_PCH_I218_V3 0x15A3 /* Wildcat Point PCH */
|
||||
#define E1000_DEV_ID_82576 0x10C9
|
||||
#define E1000_DEV_ID_82576_FIBER 0x10E6
|
||||
#define E1000_DEV_ID_82576_SERDES 0x10E7
|
||||
@ -696,7 +700,7 @@ struct e1000_mac_operations {
|
||||
s32 (*setup_led)(struct e1000_hw *);
|
||||
void (*write_vfta)(struct e1000_hw *, u32, u32);
|
||||
void (*config_collision_dist)(struct e1000_hw *);
|
||||
void (*rar_set)(struct e1000_hw *, u8*, u32);
|
||||
int (*rar_set)(struct e1000_hw *, u8*, u32);
|
||||
s32 (*read_mac_addr)(struct e1000_hw *);
|
||||
s32 (*validate_mdi_setting)(struct e1000_hw *);
|
||||
s32 (*set_obff_timer)(struct e1000_hw *, u32);
|
||||
@ -934,6 +938,13 @@ struct e1000_shadow_ram {
|
||||
|
||||
#define E1000_SHADOW_RAM_WORDS 2048
|
||||
|
||||
/* I218 PHY Ultra Low Power (ULP) states */
|
||||
enum e1000_ulp_state {
|
||||
e1000_ulp_state_unknown,
|
||||
e1000_ulp_state_off,
|
||||
e1000_ulp_state_on,
|
||||
};
|
||||
|
||||
struct e1000_dev_spec_ich8lan {
|
||||
bool kmrn_lock_loss_workaround_enabled;
|
||||
struct e1000_shadow_ram shadow_ram[E1000_SHADOW_RAM_WORDS];
|
||||
@ -942,6 +953,7 @@ struct e1000_dev_spec_ich8lan {
|
||||
bool nvm_k1_enabled;
|
||||
bool eee_disable;
|
||||
u16 eee_lp_ability;
|
||||
enum e1000_ulp_state ulp_state;
|
||||
};
|
||||
|
||||
struct e1000_dev_spec_82575 {
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -536,7 +536,7 @@ s32 e1000_validate_nvm_checksum_i210(struct e1000_hw *hw)
|
||||
**/
|
||||
s32 e1000_update_nvm_checksum_i210(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
u16 checksum = 0;
|
||||
u16 i, nvm_data;
|
||||
|
||||
@ -615,7 +615,7 @@ bool e1000_get_flash_presence_i210(struct e1000_hw *hw)
|
||||
**/
|
||||
s32 e1000_update_flash_i210(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
u32 flup;
|
||||
|
||||
DEBUGFUNC("e1000_update_flash_i210");
|
||||
@ -671,7 +671,7 @@ s32 e1000_pool_flash_update_done_i210(struct e1000_hw *hw)
|
||||
**/
|
||||
static s32 e1000_init_nvm_params_i210(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
struct e1000_nvm_info *nvm = &hw->nvm;
|
||||
|
||||
DEBUGFUNC("e1000_init_nvm_params_i210");
|
||||
@ -756,7 +756,7 @@ static s32 e1000_valid_led_default_i210(struct e1000_hw *hw, u16 *data)
|
||||
static s32 __e1000_access_xmdio_reg(struct e1000_hw *hw, u16 address,
|
||||
u8 dev_addr, u16 *data, bool read)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
s32 ret_val;
|
||||
|
||||
DEBUGFUNC("__e1000_access_xmdio_reg");
|
||||
|
||||
@ -815,3 +815,90 @@ s32 e1000_write_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr, u16 data)
|
||||
|
||||
return __e1000_access_xmdio_reg(hw, addr, dev_addr, &data, FALSE);
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_pll_workaround_i210
|
||||
* @hw: pointer to the HW structure
|
||||
*
|
||||
* Works around an errata in the PLL circuit where it occasionally
|
||||
* provides the wrong clock frequency after power up.
|
||||
**/
|
||||
static s32 e1000_pll_workaround_i210(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val;
|
||||
u32 wuc, mdicnfg, ctrl, ctrl_ext, reg_val;
|
||||
u16 nvm_word, phy_word, pci_word, tmp_nvm;
|
||||
int i;
|
||||
|
||||
/* Get and set needed register values */
|
||||
wuc = E1000_READ_REG(hw, E1000_WUC);
|
||||
mdicnfg = E1000_READ_REG(hw, E1000_MDICNFG);
|
||||
reg_val = mdicnfg & ~E1000_MDICNFG_EXT_MDIO;
|
||||
E1000_WRITE_REG(hw, E1000_MDICNFG, reg_val);
|
||||
|
||||
/* Get data from NVM, or set default */
|
||||
ret_val = e1000_read_invm_word_i210(hw, E1000_INVM_AUTOLOAD,
|
||||
&nvm_word);
|
||||
if (ret_val != E1000_SUCCESS)
|
||||
nvm_word = E1000_INVM_DEFAULT_AL;
|
||||
tmp_nvm = nvm_word | E1000_INVM_PLL_WO_VAL;
|
||||
for (i = 0; i < E1000_MAX_PLL_TRIES; i++) {
|
||||
/* check current state directly from internal PHY */
|
||||
e1000_read_phy_reg_gs40g(hw, (E1000_PHY_PLL_FREQ_PAGE |
|
||||
E1000_PHY_PLL_FREQ_REG), &phy_word);
|
||||
if ((phy_word & E1000_PHY_PLL_UNCONF)
|
||||
!= E1000_PHY_PLL_UNCONF) {
|
||||
ret_val = E1000_SUCCESS;
|
||||
break;
|
||||
} else {
|
||||
ret_val = -E1000_ERR_PHY;
|
||||
}
|
||||
/* directly reset the internal PHY */
|
||||
ctrl = E1000_READ_REG(hw, E1000_CTRL);
|
||||
E1000_WRITE_REG(hw, E1000_CTRL, ctrl|E1000_CTRL_PHY_RST);
|
||||
|
||||
ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
|
||||
ctrl_ext |= (E1000_CTRL_EXT_PHYPDEN | E1000_CTRL_EXT_SDLPE);
|
||||
E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
|
||||
|
||||
E1000_WRITE_REG(hw, E1000_WUC, 0);
|
||||
reg_val = (E1000_INVM_AUTOLOAD << 4) | (tmp_nvm << 16);
|
||||
E1000_WRITE_REG(hw, E1000_EEARBC_I210, reg_val);
|
||||
|
||||
e1000_read_pci_cfg(hw, E1000_PCI_PMCSR, &pci_word);
|
||||
pci_word |= E1000_PCI_PMCSR_D3;
|
||||
e1000_write_pci_cfg(hw, E1000_PCI_PMCSR, &pci_word);
|
||||
msec_delay(1);
|
||||
pci_word &= ~E1000_PCI_PMCSR_D3;
|
||||
e1000_write_pci_cfg(hw, E1000_PCI_PMCSR, &pci_word);
|
||||
reg_val = (E1000_INVM_AUTOLOAD << 4) | (nvm_word << 16);
|
||||
E1000_WRITE_REG(hw, E1000_EEARBC_I210, reg_val);
|
||||
|
||||
/* restore WUC register */
|
||||
E1000_WRITE_REG(hw, E1000_WUC, wuc);
|
||||
}
|
||||
/* restore MDICNFG setting */
|
||||
E1000_WRITE_REG(hw, E1000_MDICNFG, mdicnfg);
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_init_hw_i210 - Init hw for I210/I211
|
||||
* @hw: pointer to the HW structure
|
||||
*
|
||||
* Called to initialize hw for i210 hw family.
|
||||
**/
|
||||
s32 e1000_init_hw_i210(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val;
|
||||
|
||||
DEBUGFUNC("e1000_init_hw_i210");
|
||||
if ((hw->mac.type >= e1000_i210) &&
|
||||
!(e1000_get_flash_presence_i210(hw))) {
|
||||
ret_val = e1000_pll_workaround_i210(hw);
|
||||
if (ret_val != E1000_SUCCESS)
|
||||
return ret_val;
|
||||
}
|
||||
ret_val = e1000_init_hw_82575(hw);
|
||||
return ret_val;
|
||||
}
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -49,6 +49,7 @@ s32 e1000_read_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr,
|
||||
u16 *data);
|
||||
s32 e1000_write_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr,
|
||||
u16 data);
|
||||
s32 e1000_init_hw_i210(struct e1000_hw *hw);
|
||||
|
||||
#define E1000_STM_OPCODE 0xDB00
|
||||
#define E1000_EEPROM_FLASH_SIZE_WORD 0x11
|
||||
@ -93,4 +94,16 @@ enum E1000_INVM_STRUCTURE_TYPE {
|
||||
#define NVM_INIT_CTRL_4_DEFAULT_I211 0x00C1
|
||||
#define NVM_LED_1_CFG_DEFAULT_I211 0x0184
|
||||
#define NVM_LED_0_2_CFG_DEFAULT_I211 0x200C
|
||||
|
||||
/* PLL Defines */
|
||||
#define E1000_PCI_PMCSR 0x44
|
||||
#define E1000_PCI_PMCSR_D3 0x03
|
||||
#define E1000_MAX_PLL_TRIES 5
|
||||
#define E1000_PHY_PLL_UNCONF 0xFF
|
||||
#define E1000_PHY_PLL_FREQ_PAGE 0xFC0000
|
||||
#define E1000_PHY_PLL_FREQ_REG 0x000E
|
||||
#define E1000_INVM_DEFAULT_AL 0x202F
|
||||
#define E1000_INVM_AUTOLOAD 0x0A
|
||||
#define E1000_INVM_PLL_WO_VAL 0x0010
|
||||
|
||||
#endif
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -63,6 +63,10 @@
|
||||
* Ethernet Connection I217-V
|
||||
* Ethernet Connection I218-V
|
||||
* Ethernet Connection I218-LM
|
||||
* Ethernet Connection (2) I218-LM
|
||||
* Ethernet Connection (2) I218-V
|
||||
* Ethernet Connection (3) I218-LM
|
||||
* Ethernet Connection (3) I218-V
|
||||
*/
|
||||
|
||||
#include "e1000_api.h"
|
||||
@ -73,8 +77,8 @@ static s32 e1000_acquire_nvm_ich8lan(struct e1000_hw *hw);
|
||||
static void e1000_release_nvm_ich8lan(struct e1000_hw *hw);
|
||||
static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw);
|
||||
static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw);
|
||||
static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static int e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static int e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw);
|
||||
static void e1000_update_mc_addr_list_pch2lan(struct e1000_hw *hw,
|
||||
u8 *mc_addr_list,
|
||||
@ -250,7 +254,7 @@ static bool e1000_phy_is_accessible_pchlan(struct e1000_hw *hw)
|
||||
* Toggling the LANPHYPC pin value fully power-cycles the PHY and is
|
||||
* used to reset the PHY to a quiescent state when necessary.
|
||||
**/
|
||||
void e1000_toggle_lanphypc_pch_lpt(struct e1000_hw *hw)
|
||||
static void e1000_toggle_lanphypc_pch_lpt(struct e1000_hw *hw)
|
||||
{
|
||||
u32 mac_reg;
|
||||
|
||||
@ -306,6 +310,12 @@ static s32 e1000_init_phy_workarounds_pchlan(struct e1000_hw *hw)
|
||||
*/
|
||||
e1000_gate_hw_phy_config_ich8lan(hw, TRUE);
|
||||
|
||||
/* It is not possible to be certain of the current state of ULP
|
||||
* so forcibly disable it.
|
||||
*/
|
||||
hw->dev_spec.ich8lan.ulp_state = e1000_ulp_state_unknown;
|
||||
e1000_disable_ulp_lpt_lp(hw, TRUE);
|
||||
|
||||
ret_val = hw->phy.ops.acquire(hw);
|
||||
if (ret_val) {
|
||||
DEBUGOUT("Failed to initialize PHY flow\n");
|
||||
@ -611,13 +621,12 @@ static s32 e1000_init_nvm_params_ich8lan(struct e1000_hw *hw)
|
||||
DEBUGFUNC("e1000_init_nvm_params_ich8lan");
|
||||
|
||||
/* Can't read flash registers if the register set isn't mapped. */
|
||||
nvm->type = e1000_nvm_flash_sw;
|
||||
if (!hw->flash_address) {
|
||||
DEBUGOUT("ERROR: Flash registers not mapped\n");
|
||||
return -E1000_ERR_CONFIG;
|
||||
}
|
||||
|
||||
nvm->type = e1000_nvm_flash_sw;
|
||||
|
||||
gfpreg = E1000_READ_FLASH_REG(hw, ICH_FLASH_GFPREG);
|
||||
|
||||
/* sector_X_addr is a "sector"-aligned address (4096 bytes)
|
||||
@ -672,6 +681,9 @@ static s32 e1000_init_nvm_params_ich8lan(struct e1000_hw *hw)
|
||||
static s32 e1000_init_mac_params_ich8lan(struct e1000_hw *hw)
|
||||
{
|
||||
struct e1000_mac_info *mac = &hw->mac;
|
||||
#if defined(QV_RELEASE) || !defined(NO_PCH_LPT_B0_SUPPORT)
|
||||
u16 pci_cfg;
|
||||
#endif /* QV_RELEASE || !defined(NO_PCH_LPT_B0_SUPPORT) */
|
||||
|
||||
DEBUGFUNC("e1000_init_mac_params_ich8lan");
|
||||
|
||||
@ -744,6 +756,11 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_hw *hw)
|
||||
mac->ops.update_mc_addr_list =
|
||||
e1000_update_mc_addr_list_pch2lan;
|
||||
case e1000_pchlan:
|
||||
#if defined(QV_RELEASE) || !defined(NO_PCH_LPT_B0_SUPPORT)
|
||||
/* save PCH revision_id */
|
||||
e1000_read_pci_cfg(hw, E1000_PCI_REVISION_ID_REG, &pci_cfg);
|
||||
hw->revision_id = (u8)(pci_cfg &= 0x000F);
|
||||
#endif /* QV_RELEASE || !defined(NO_PCH_LPT_B0_SUPPORT) */
|
||||
/* check management mode */
|
||||
mac->ops.check_mng_mode = e1000_check_mng_mode_pchlan;
|
||||
/* ID LED init */
|
||||
@ -915,6 +932,17 @@ s32 e1000_set_eee_pchlan(struct e1000_hw *hw)
|
||||
}
|
||||
}
|
||||
|
||||
if (hw->phy.type == e1000_phy_82579) {
|
||||
ret_val = e1000_read_emi_reg_locked(hw, I82579_LPI_PLL_SHUT,
|
||||
&data);
|
||||
if (ret_val)
|
||||
goto release;
|
||||
|
||||
data &= ~I82579_LPI_100_PLL_SHUT;
|
||||
ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT,
|
||||
data);
|
||||
}
|
||||
|
||||
/* 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)
|
||||
@ -1178,6 +1206,256 @@ static s32 e1000_set_obff_timer_pch_lpt(struct e1000_hw *hw, u32 itr)
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_enable_ulp_lpt_lp - configure Ultra Low Power mode for LynxPoint-LP
|
||||
* @hw: pointer to the HW structure
|
||||
* @to_sx: boolean indicating a system power state transition to Sx
|
||||
*
|
||||
* When link is down, configure ULP mode to significantly reduce the power
|
||||
* to the PHY. If on a Manageability Engine (ME) enabled system, tell the
|
||||
* ME firmware to start the ULP configuration. If not on an ME enabled
|
||||
* system, configure the ULP mode by software.
|
||||
*/
|
||||
s32 e1000_enable_ulp_lpt_lp(struct e1000_hw *hw, bool to_sx)
|
||||
{
|
||||
u32 mac_reg;
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u16 phy_reg;
|
||||
|
||||
if ((hw->mac.type < e1000_pch_lpt) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_LPT_I217_LM) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_LPT_I217_V) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_I218_LM2) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_I218_V2) ||
|
||||
(hw->dev_spec.ich8lan.ulp_state == e1000_ulp_state_on))
|
||||
return 0;
|
||||
|
||||
if (E1000_READ_REG(hw, E1000_FWSM) & E1000_ICH_FWSM_FW_VALID) {
|
||||
/* Request ME configure ULP mode in the PHY */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_H2ME);
|
||||
mac_reg |= E1000_H2ME_ULP | E1000_H2ME_ENFORCE_SETTINGS;
|
||||
E1000_WRITE_REG(hw, E1000_H2ME, mac_reg);
|
||||
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!to_sx) {
|
||||
int i = 0;
|
||||
|
||||
/* Poll up to 5 seconds for Cable Disconnected indication */
|
||||
while (!(E1000_READ_REG(hw, E1000_FEXT) &
|
||||
E1000_FEXT_PHY_CABLE_DISCONNECTED)) {
|
||||
/* Bail if link is re-acquired */
|
||||
if (E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU)
|
||||
return -E1000_ERR_PHY;
|
||||
|
||||
if (i++ == 100)
|
||||
break;
|
||||
|
||||
msec_delay(50);
|
||||
}
|
||||
DEBUGOUT2("CABLE_DISCONNECTED %s set after %dmsec\n",
|
||||
(E1000_READ_REG(hw, E1000_FEXT) &
|
||||
E1000_FEXT_PHY_CABLE_DISCONNECTED) ? "" : "not",
|
||||
i * 50);
|
||||
}
|
||||
|
||||
ret_val = hw->phy.ops.acquire(hw);
|
||||
if (ret_val)
|
||||
goto out;
|
||||
|
||||
/* Force SMBus mode in PHY */
|
||||
ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL, &phy_reg);
|
||||
if (ret_val)
|
||||
goto release;
|
||||
phy_reg |= CV_SMB_CTRL_FORCE_SMBUS;
|
||||
e1000_write_phy_reg_hv_locked(hw, CV_SMB_CTRL, phy_reg);
|
||||
|
||||
/* Force SMBus mode in MAC */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
|
||||
mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
|
||||
E1000_WRITE_REG(hw, E1000_CTRL_EXT, mac_reg);
|
||||
|
||||
/* Set Inband ULP Exit, Reset to SMBus mode and
|
||||
* Disable SMBus Release on PERST# in PHY
|
||||
*/
|
||||
ret_val = e1000_read_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, &phy_reg);
|
||||
if (ret_val)
|
||||
goto release;
|
||||
phy_reg |= (I218_ULP_CONFIG1_RESET_TO_SMBUS |
|
||||
I218_ULP_CONFIG1_DISABLE_SMB_PERST);
|
||||
if (to_sx) {
|
||||
if (E1000_READ_REG(hw, E1000_WUFC) & E1000_WUFC_LNKC)
|
||||
phy_reg |= I218_ULP_CONFIG1_WOL_HOST;
|
||||
|
||||
phy_reg |= I218_ULP_CONFIG1_STICKY_ULP;
|
||||
} else {
|
||||
phy_reg |= I218_ULP_CONFIG1_INBAND_EXIT;
|
||||
}
|
||||
e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
|
||||
|
||||
/* Set Disable SMBus Release on PERST# in MAC */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_FEXTNVM7);
|
||||
mac_reg |= E1000_FEXTNVM7_DISABLE_SMB_PERST;
|
||||
E1000_WRITE_REG(hw, E1000_FEXTNVM7, mac_reg);
|
||||
|
||||
/* Commit ULP changes in PHY by starting auto ULP configuration */
|
||||
phy_reg |= I218_ULP_CONFIG1_START;
|
||||
e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
|
||||
release:
|
||||
hw->phy.ops.release(hw);
|
||||
out:
|
||||
if (ret_val)
|
||||
DEBUGOUT1("Error in ULP enable flow: %d\n", ret_val);
|
||||
else
|
||||
hw->dev_spec.ich8lan.ulp_state = e1000_ulp_state_on;
|
||||
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_disable_ulp_lpt_lp - unconfigure Ultra Low Power mode for LynxPoint-LP
|
||||
* @hw: pointer to the HW structure
|
||||
* @force: boolean indicating whether or not to force disabling ULP
|
||||
*
|
||||
* Un-configure ULP mode when link is up, the system is transitioned from
|
||||
* Sx or the driver is unloaded. If on a Manageability Engine (ME) enabled
|
||||
* system, poll for an indication from ME that ULP has been un-configured.
|
||||
* If not on an ME enabled system, un-configure the ULP mode by software.
|
||||
*
|
||||
* During nominal operation, this function is called when link is acquired
|
||||
* to disable ULP mode (force=FALSE); otherwise, for example when unloading
|
||||
* the driver or during Sx->S0 transitions, this is called with force=TRUE
|
||||
* to forcibly disable ULP.
|
||||
*/
|
||||
s32 e1000_disable_ulp_lpt_lp(struct e1000_hw *hw, bool force)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u32 mac_reg;
|
||||
u16 phy_reg;
|
||||
int i = 0;
|
||||
|
||||
if ((hw->mac.type < e1000_pch_lpt) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_LPT_I217_LM) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_LPT_I217_V) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_I218_LM2) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_I218_V2) ||
|
||||
(hw->dev_spec.ich8lan.ulp_state == e1000_ulp_state_off))
|
||||
return 0;
|
||||
|
||||
if (E1000_READ_REG(hw, E1000_FWSM) & E1000_ICH_FWSM_FW_VALID) {
|
||||
if (force) {
|
||||
/* Request ME un-configure ULP mode in the PHY */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_H2ME);
|
||||
mac_reg &= ~E1000_H2ME_ULP;
|
||||
mac_reg |= E1000_H2ME_ENFORCE_SETTINGS;
|
||||
E1000_WRITE_REG(hw, E1000_H2ME, mac_reg);
|
||||
}
|
||||
|
||||
/* Poll up to 100msec for ME to clear ULP_CFG_DONE */
|
||||
while (E1000_READ_REG(hw, E1000_FWSM) &
|
||||
E1000_FWSM_ULP_CFG_DONE) {
|
||||
if (i++ == 10) {
|
||||
ret_val = -E1000_ERR_PHY;
|
||||
goto out;
|
||||
}
|
||||
|
||||
msec_delay(10);
|
||||
}
|
||||
DEBUGOUT1("ULP_CONFIG_DONE cleared after %dmsec\n", i * 10);
|
||||
|
||||
if (force) {
|
||||
mac_reg = E1000_READ_REG(hw, E1000_H2ME);
|
||||
mac_reg &= ~E1000_H2ME_ENFORCE_SETTINGS;
|
||||
E1000_WRITE_REG(hw, E1000_H2ME, mac_reg);
|
||||
} else {
|
||||
/* Clear H2ME.ULP after ME ULP configuration */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_H2ME);
|
||||
mac_reg &= ~E1000_H2ME_ULP;
|
||||
E1000_WRITE_REG(hw, E1000_H2ME, mac_reg);
|
||||
}
|
||||
|
||||
goto out;
|
||||
}
|
||||
|
||||
ret_val = hw->phy.ops.acquire(hw);
|
||||
if (ret_val)
|
||||
goto out;
|
||||
|
||||
if (force)
|
||||
/* Toggle LANPHYPC Value bit */
|
||||
e1000_toggle_lanphypc_pch_lpt(hw);
|
||||
|
||||
/* Unforce SMBus mode in PHY */
|
||||
ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL, &phy_reg);
|
||||
if (ret_val) {
|
||||
/* The MAC might be in PCIe mode, so temporarily force to
|
||||
* SMBus mode in order to access the PHY.
|
||||
*/
|
||||
mac_reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
|
||||
mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
|
||||
E1000_WRITE_REG(hw, E1000_CTRL_EXT, mac_reg);
|
||||
|
||||
msec_delay(50);
|
||||
|
||||
ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL,
|
||||
&phy_reg);
|
||||
if (ret_val)
|
||||
goto release;
|
||||
}
|
||||
phy_reg &= ~CV_SMB_CTRL_FORCE_SMBUS;
|
||||
e1000_write_phy_reg_hv_locked(hw, CV_SMB_CTRL, phy_reg);
|
||||
|
||||
/* Unforce SMBus mode in MAC */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
|
||||
mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
|
||||
E1000_WRITE_REG(hw, E1000_CTRL_EXT, mac_reg);
|
||||
|
||||
/* When ULP mode was previously entered, K1 was disabled by the
|
||||
* hardware. Re-Enable K1 in the PHY when exiting ULP.
|
||||
*/
|
||||
ret_val = e1000_read_phy_reg_hv_locked(hw, HV_PM_CTRL, &phy_reg);
|
||||
if (ret_val)
|
||||
goto release;
|
||||
phy_reg |= HV_PM_CTRL_K1_ENABLE;
|
||||
e1000_write_phy_reg_hv_locked(hw, HV_PM_CTRL, phy_reg);
|
||||
|
||||
/* Clear ULP enabled configuration */
|
||||
ret_val = e1000_read_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, &phy_reg);
|
||||
if (ret_val)
|
||||
goto release;
|
||||
phy_reg &= ~(I218_ULP_CONFIG1_IND |
|
||||
I218_ULP_CONFIG1_STICKY_ULP |
|
||||
I218_ULP_CONFIG1_RESET_TO_SMBUS |
|
||||
I218_ULP_CONFIG1_WOL_HOST |
|
||||
I218_ULP_CONFIG1_INBAND_EXIT |
|
||||
I218_ULP_CONFIG1_DISABLE_SMB_PERST);
|
||||
e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
|
||||
|
||||
/* Commit ULP changes by starting auto ULP configuration */
|
||||
phy_reg |= I218_ULP_CONFIG1_START;
|
||||
e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
|
||||
|
||||
/* Clear Disable SMBus Release on PERST# in MAC */
|
||||
mac_reg = E1000_READ_REG(hw, E1000_FEXTNVM7);
|
||||
mac_reg &= ~E1000_FEXTNVM7_DISABLE_SMB_PERST;
|
||||
E1000_WRITE_REG(hw, E1000_FEXTNVM7, mac_reg);
|
||||
|
||||
release:
|
||||
hw->phy.ops.release(hw);
|
||||
if (force) {
|
||||
hw->phy.ops.reset(hw);
|
||||
msec_delay(50);
|
||||
}
|
||||
out:
|
||||
if (ret_val)
|
||||
DEBUGOUT1("Error in ULP disable flow: %d\n", ret_val);
|
||||
else
|
||||
hw->dev_spec.ich8lan.ulp_state = e1000_ulp_state_off;
|
||||
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_check_for_copper_link_ich8lan - Check for link (Copper)
|
||||
* @hw: pointer to the HW structure
|
||||
@ -1217,14 +1495,17 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
/* When connected at 10Mbps half-duplex, 82579 parts are excessively
|
||||
/* When connected at 10Mbps half-duplex, some parts are excessively
|
||||
* aggressive resulting in many collisions. To avoid this, increase
|
||||
* the IPG and reduce Rx latency in the PHY.
|
||||
*/
|
||||
if ((hw->mac.type == e1000_pch2lan) && link) {
|
||||
if (((hw->mac.type == e1000_pch2lan) ||
|
||||
(hw->mac.type == e1000_pch_lpt)) && link) {
|
||||
u32 reg;
|
||||
reg = E1000_READ_REG(hw, E1000_STATUS);
|
||||
if (!(reg & (E1000_STATUS_FD | E1000_STATUS_SPEED_MASK))) {
|
||||
u16 emi_addr;
|
||||
|
||||
reg = E1000_READ_REG(hw, E1000_TIPG);
|
||||
reg &= ~E1000_TIPG_IPGT_MASK;
|
||||
reg |= 0xFF;
|
||||
@ -1235,7 +1516,11 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
|
||||
ret_val = e1000_write_emi_reg_locked(hw, I82579_RX_CONFIG, 0);
|
||||
if (hw->mac.type == e1000_pch2lan)
|
||||
emi_addr = I82579_RX_CONFIG;
|
||||
else
|
||||
emi_addr = I217_RX_CONFIG;
|
||||
ret_val = e1000_write_emi_reg_locked(hw, emi_addr, 0);
|
||||
|
||||
hw->phy.ops.release(hw);
|
||||
|
||||
@ -1246,12 +1531,13 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
|
||||
|
||||
/* Work-around I218 hang issue */
|
||||
if ((hw->device_id == E1000_DEV_ID_PCH_LPTLP_I218_LM) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_LPTLP_I218_V)) {
|
||||
(hw->device_id == E1000_DEV_ID_PCH_LPTLP_I218_V) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_I218_LM3) ||
|
||||
(hw->device_id == E1000_DEV_ID_PCH_I218_V3)) {
|
||||
ret_val = e1000_k1_workaround_lpt_lp(hw, link);
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
if (hw->mac.type == e1000_pch_lpt) {
|
||||
/* Set platform power management values for
|
||||
* Latency Tolerance Reporting (LTR)
|
||||
@ -1499,9 +1785,9 @@ static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw)
|
||||
|
||||
fwsm = E1000_READ_REG(hw, E1000_FWSM);
|
||||
|
||||
return ((fwsm & E1000_ICH_FWSM_FW_VALID) &&
|
||||
((fwsm & E1000_FWSM_MODE_MASK) ==
|
||||
(E1000_ICH_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT)));
|
||||
return (fwsm & E1000_ICH_FWSM_FW_VALID) &&
|
||||
((fwsm & E1000_FWSM_MODE_MASK) ==
|
||||
(E1000_ICH_MNG_IAMT_MODE << E1000_FWSM_MODE_SHIFT));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1535,7 +1821,7 @@ static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw)
|
||||
* contain the MAC address but RAR[1-6] are reserved for manageability (ME).
|
||||
* Use SHRA[0-3] in place of those reserved for ME.
|
||||
**/
|
||||
static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
static int e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
{
|
||||
u32 rar_low, rar_high;
|
||||
|
||||
@ -1559,13 +1845,13 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
E1000_WRITE_REG(hw, E1000_RAH(index), rar_high);
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
return;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/* RAR[1-6] are owned by manageability. Skip those and program the
|
||||
* next address into the SHRA register array.
|
||||
*/
|
||||
if (index < (u32) (hw->mac.rar_entry_count - 6)) {
|
||||
if (index < (u32) (hw->mac.rar_entry_count)) {
|
||||
s32 ret_val;
|
||||
|
||||
ret_val = e1000_acquire_swflag_ich8lan(hw);
|
||||
@ -1582,7 +1868,7 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
/* verify the register updates */
|
||||
if ((E1000_READ_REG(hw, E1000_SHRAL(index - 1)) == rar_low) &&
|
||||
(E1000_READ_REG(hw, E1000_SHRAH(index - 1)) == rar_high))
|
||||
return;
|
||||
return E1000_SUCCESS;
|
||||
|
||||
DEBUGOUT2("SHRA[%d] might be locked by ME - FWSM=0x%8.8x\n",
|
||||
(index - 1), E1000_READ_REG(hw, E1000_FWSM));
|
||||
@ -1590,6 +1876,7 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
|
||||
out:
|
||||
DEBUGOUT1("Failed to write receive address at index %d\n", index);
|
||||
return -E1000_ERR_CONFIG;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1603,7 +1890,7 @@ static void e1000_rar_set_pch2lan(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
* contain the MAC address. SHRA[0-10] are the shared receive address
|
||||
* registers that are shared between the Host and manageability engine (ME).
|
||||
**/
|
||||
static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
static int e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
{
|
||||
u32 rar_low, rar_high;
|
||||
u32 wlock_mac;
|
||||
@ -1627,7 +1914,7 @@ static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
E1000_WRITE_REG(hw, E1000_RAH(index), rar_high);
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
return;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/* The manageability engine (ME) can lock certain SHRAR registers that
|
||||
@ -1662,12 +1949,13 @@ static void e1000_rar_set_pch_lpt(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
/* verify the register updates */
|
||||
if ((E1000_READ_REG(hw, E1000_SHRAL_PCH_LPT(index - 1)) == rar_low) &&
|
||||
(E1000_READ_REG(hw, E1000_SHRAH_PCH_LPT(index - 1)) == rar_high))
|
||||
return;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
DEBUGOUT1("Failed to write receive address at index %d\n", index);
|
||||
return -E1000_ERR_CONFIG;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -2377,7 +2665,7 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
|
||||
return ret_val;
|
||||
hw->phy.ops.read_reg(hw, PHY_REG(776, 20), &data);
|
||||
data &= ~(0x3FF << 2);
|
||||
data |= (0x1A << 2);
|
||||
data |= (E1000_TX_PTR_GAP << 2);
|
||||
ret_val = hw->phy.ops.write_reg(hw, PHY_REG(776, 20), data);
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
@ -2491,55 +2779,47 @@ static s32 e1000_lv_phy_workarounds_ich8lan(struct e1000_hw *hw)
|
||||
* e1000_k1_gig_workaround_lv - K1 Si workaround
|
||||
* @hw: pointer to the HW structure
|
||||
*
|
||||
* Workaround to set the K1 beacon duration for 82579 parts
|
||||
* Workaround to set the K1 beacon duration for 82579 parts in 10Mbps
|
||||
* Disable K1 for 1000 and 100 speeds
|
||||
**/
|
||||
static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u16 status_reg = 0;
|
||||
u32 mac_reg;
|
||||
u16 phy_reg;
|
||||
|
||||
DEBUGFUNC("e1000_k1_workaround_lv");
|
||||
|
||||
if (hw->mac.type != e1000_pch2lan)
|
||||
return E1000_SUCCESS;
|
||||
|
||||
/* Set K1 beacon duration based on 1Gbps speed or otherwise */
|
||||
/* Set K1 beacon duration based on 10Mbs speed */
|
||||
ret_val = hw->phy.ops.read_reg(hw, HV_M_STATUS, &status_reg);
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
|
||||
if ((status_reg & (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE))
|
||||
== (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE)) {
|
||||
mac_reg = E1000_READ_REG(hw, E1000_FEXTNVM4);
|
||||
mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
|
||||
|
||||
ret_val = hw->phy.ops.read_reg(hw, I82579_LPI_CTRL, &phy_reg);
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
|
||||
if (status_reg & HV_M_STATUS_SPEED_1000) {
|
||||
if (status_reg &
|
||||
(HV_M_STATUS_SPEED_1000 | HV_M_STATUS_SPEED_100)) {
|
||||
u16 pm_phy_reg;
|
||||
|
||||
mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
|
||||
phy_reg &= ~I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT;
|
||||
/* LV 1G Packet drop issue wa */
|
||||
/* LV 1G/100 Packet drop issue wa */
|
||||
ret_val = hw->phy.ops.read_reg(hw, HV_PM_CTRL,
|
||||
&pm_phy_reg);
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
pm_phy_reg &= ~HV_PM_CTRL_PLL_STOP_IN_K1_GIGA;
|
||||
pm_phy_reg &= ~HV_PM_CTRL_K1_ENABLE;
|
||||
ret_val = hw->phy.ops.write_reg(hw, HV_PM_CTRL,
|
||||
pm_phy_reg);
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
} else {
|
||||
u32 mac_reg;
|
||||
mac_reg = E1000_READ_REG(hw, E1000_FEXTNVM4);
|
||||
mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
|
||||
mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_16USEC;
|
||||
phy_reg |= I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT;
|
||||
E1000_WRITE_REG(hw, E1000_FEXTNVM4, mac_reg);
|
||||
}
|
||||
E1000_WRITE_REG(hw, E1000_FEXTNVM4, mac_reg);
|
||||
ret_val = hw->phy.ops.write_reg(hw, I82579_LPI_CTRL, phy_reg);
|
||||
}
|
||||
|
||||
return ret_val;
|
||||
@ -3076,7 +3356,6 @@ static s32 e1000_flash_cycle_init_ich8lan(struct e1000_hw *hw)
|
||||
/* Clear FCERR and DAEL in hw status by writing 1 */
|
||||
hsfsts.hsf_status.flcerr = 1;
|
||||
hsfsts.hsf_status.dael = 1;
|
||||
|
||||
E1000_WRITE_FLASH_REG16(hw, ICH_FLASH_HSFSTS, hsfsts.regval);
|
||||
|
||||
/* Either we should have a hardware SPI cycle in progress
|
||||
@ -3143,6 +3422,7 @@ static s32 e1000_flash_cycle_ich8lan(struct e1000_hw *hw, u32 timeout)
|
||||
/* Start a cycle by writing 1 in Flash Cycle Go in Hw Flash Control */
|
||||
hsflctl.regval = E1000_READ_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
|
||||
hsflctl.hsf_ctrl.flcgo = 1;
|
||||
|
||||
E1000_WRITE_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
|
||||
|
||||
/* wait till FDONE bit is set to 1 */
|
||||
@ -3197,6 +3477,7 @@ static s32 e1000_read_flash_byte_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
u16 word = 0;
|
||||
|
||||
ret_val = e1000_read_flash_data_ich8lan(hw, offset, 1, &word);
|
||||
|
||||
if (ret_val)
|
||||
return ret_val;
|
||||
|
||||
@ -3228,7 +3509,6 @@ static s32 e1000_read_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
|
||||
if (size < 1 || size > 2 || offset > ICH_FLASH_LINEAR_ADDR_MASK)
|
||||
return -E1000_ERR_NVM;
|
||||
|
||||
flash_linear_addr = ((ICH_FLASH_LINEAR_ADDR_MASK & offset) +
|
||||
hw->nvm.flash_base_addr);
|
||||
|
||||
@ -3238,18 +3518,16 @@ static s32 e1000_read_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
ret_val = e1000_flash_cycle_init_ich8lan(hw);
|
||||
if (ret_val != E1000_SUCCESS)
|
||||
break;
|
||||
|
||||
hsflctl.regval = E1000_READ_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
|
||||
|
||||
/* 0b/1b corresponds to 1 or 2 byte size, respectively. */
|
||||
hsflctl.hsf_ctrl.fldbcount = size - 1;
|
||||
hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_READ;
|
||||
E1000_WRITE_FLASH_REG16(hw, ICH_FLASH_HSFCTL, hsflctl.regval);
|
||||
|
||||
E1000_WRITE_FLASH_REG(hw, ICH_FLASH_FADDR, flash_linear_addr);
|
||||
|
||||
ret_val =
|
||||
e1000_flash_cycle_ich8lan(hw,
|
||||
ICH_FLASH_READ_COMMAND_TIMEOUT);
|
||||
ret_val = e1000_flash_cycle_ich8lan(hw,
|
||||
ICH_FLASH_READ_COMMAND_TIMEOUT);
|
||||
|
||||
/* Check if FCERR is set to 1, if set to 1, clear it
|
||||
* and try the whole sequence a few more times, else
|
||||
@ -3284,6 +3562,7 @@ static s32 e1000_read_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* e1000_write_nvm_ich8lan - Write word(s) to the NVM
|
||||
* @hw: pointer to the HW structure
|
||||
@ -3337,7 +3616,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan;
|
||||
u32 i, act_offset, new_bank_offset, old_bank_offset, bank;
|
||||
s32 ret_val;
|
||||
u16 data;
|
||||
u16 data = 0;
|
||||
|
||||
DEBUGFUNC("e1000_update_nvm_checksum_ich8lan");
|
||||
|
||||
@ -3373,12 +3652,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
if (ret_val)
|
||||
goto release;
|
||||
}
|
||||
|
||||
for (i = 0; i < E1000_SHADOW_RAM_WORDS; i++) {
|
||||
/* Determine whether to write the value stored
|
||||
* in the other NVM bank or a modified value stored
|
||||
* in the shadow RAM
|
||||
*/
|
||||
if (dev_spec->shadow_ram[i].modified) {
|
||||
data = dev_spec->shadow_ram[i].value;
|
||||
} else {
|
||||
@ -3388,7 +3662,6 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
if (ret_val)
|
||||
break;
|
||||
}
|
||||
|
||||
/* If the word is 0x13, then make sure the signature bits
|
||||
* (15:14) are 11b until the commit has completed.
|
||||
* This will allow us to write 10b which indicates the
|
||||
@ -3403,6 +3676,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
act_offset = (i + new_bank_offset) << 1;
|
||||
|
||||
usec_delay(100);
|
||||
|
||||
/* Write the bytes to the new bank. */
|
||||
ret_val = e1000_retry_write_flash_byte_ich8lan(hw,
|
||||
act_offset,
|
||||
@ -3416,7 +3690,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
(u8)(data >> 8));
|
||||
if (ret_val)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Don't bother writing the segment valid bits if sector
|
||||
* programming failed.
|
||||
@ -3437,8 +3711,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
goto release;
|
||||
|
||||
data &= 0xBFFF;
|
||||
ret_val = e1000_retry_write_flash_byte_ich8lan(hw,
|
||||
act_offset * 2 + 1,
|
||||
ret_val = e1000_retry_write_flash_byte_ich8lan(hw, act_offset * 2 + 1,
|
||||
(u8)(data >> 8));
|
||||
if (ret_val)
|
||||
goto release;
|
||||
@ -3449,7 +3722,9 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
|
||||
* to 1's. We can write 1's to 0's without an erase
|
||||
*/
|
||||
act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1;
|
||||
|
||||
ret_val = e1000_retry_write_flash_byte_ich8lan(hw, act_offset, 0);
|
||||
|
||||
if (ret_val)
|
||||
goto release;
|
||||
|
||||
@ -3548,8 +3823,7 @@ static s32 e1000_write_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
|
||||
DEBUGFUNC("e1000_write_ich8_data");
|
||||
|
||||
if (size < 1 || size > 2 || data > size * 0xff ||
|
||||
offset > ICH_FLASH_LINEAR_ADDR_MASK)
|
||||
if (size < 1 || size > 2 || offset > ICH_FLASH_LINEAR_ADDR_MASK)
|
||||
return -E1000_ERR_NVM;
|
||||
|
||||
flash_linear_addr = ((ICH_FLASH_LINEAR_ADDR_MASK & offset) +
|
||||
@ -3561,8 +3835,8 @@ static s32 e1000_write_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
ret_val = e1000_flash_cycle_init_ich8lan(hw);
|
||||
if (ret_val != E1000_SUCCESS)
|
||||
break;
|
||||
|
||||
hsflctl.regval = E1000_READ_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
|
||||
|
||||
/* 0b/1b corresponds to 1 or 2 byte size, respectively. */
|
||||
hsflctl.hsf_ctrl.fldbcount = size - 1;
|
||||
hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_WRITE;
|
||||
@ -3604,6 +3878,7 @@ static s32 e1000_write_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* e1000_write_flash_byte_ich8lan - Write a single byte to NVM
|
||||
* @hw: pointer to the HW structure
|
||||
@ -3622,6 +3897,8 @@ static s32 e1000_write_flash_byte_ich8lan(struct e1000_hw *hw, u32 offset,
|
||||
return e1000_write_flash_data_ich8lan(hw, offset, 1, word);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* e1000_retry_write_flash_byte_ich8lan - Writes a single byte to NVM
|
||||
* @hw: pointer to the HW structure
|
||||
@ -3730,8 +4007,9 @@ static s32 e1000_erase_flash_bank_ich8lan(struct e1000_hw *hw, u32 bank)
|
||||
/* Write a value 11 (block Erase) in Flash
|
||||
* Cycle field in hw flash control
|
||||
*/
|
||||
hsflctl.regval = E1000_READ_FLASH_REG16(hw,
|
||||
ICH_FLASH_HSFCTL);
|
||||
hsflctl.regval =
|
||||
E1000_READ_FLASH_REG16(hw, ICH_FLASH_HSFCTL);
|
||||
|
||||
hsflctl.hsf_ctrl.flcycle = ICH_CYCLE_ERASE;
|
||||
E1000_WRITE_FLASH_REG16(hw, ICH_FLASH_HSFCTL,
|
||||
hsflctl.regval);
|
||||
@ -4149,7 +4427,7 @@ static void e1000_initialize_hw_bits_ich8lan(struct e1000_hw *hw)
|
||||
/* Device Status */
|
||||
if (hw->mac.type == e1000_ich8lan) {
|
||||
reg = E1000_READ_REG(hw, E1000_STATUS);
|
||||
reg &= ~(1U << 31);
|
||||
reg &= ~(1 << 31);
|
||||
E1000_WRITE_REG(hw, E1000_STATUS, reg);
|
||||
}
|
||||
|
||||
@ -4597,7 +4875,9 @@ void e1000_suspend_workarounds_ich8lan(struct e1000_hw *hw)
|
||||
u16 phy_reg, device_id = hw->device_id;
|
||||
|
||||
if ((device_id == E1000_DEV_ID_PCH_LPTLP_I218_LM) ||
|
||||
(device_id == E1000_DEV_ID_PCH_LPTLP_I218_V)) {
|
||||
(device_id == E1000_DEV_ID_PCH_LPTLP_I218_V) ||
|
||||
(device_id == E1000_DEV_ID_PCH_I218_LM3) ||
|
||||
(device_id == E1000_DEV_ID_PCH_I218_V3)) {
|
||||
u32 fextnvm6 = E1000_READ_REG(hw, E1000_FEXTNVM6);
|
||||
|
||||
E1000_WRITE_REG(hw, E1000_FEXTNVM6,
|
||||
@ -4649,7 +4929,7 @@ void e1000_suspend_workarounds_ich8lan(struct e1000_hw *hw)
|
||||
* The SMBus release must also be disabled on LCD reset.
|
||||
*/
|
||||
if (!(E1000_READ_REG(hw, E1000_FWSM) &
|
||||
E1000_ICH_FWSM_FW_VALID)) {
|
||||
E1000_ICH_FWSM_FW_VALID)) {
|
||||
/* Enable proxy to reset only on power good. */
|
||||
hw->phy.ops.read_reg_locked(hw, I217_PROXY_CTRL,
|
||||
&phy_reg);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -70,11 +70,16 @@
|
||||
|
||||
#define E1000_FWSM_WLOCK_MAC_MASK 0x0380
|
||||
#define E1000_FWSM_WLOCK_MAC_SHIFT 7
|
||||
#define E1000_FWSM_ULP_CFG_DONE 0x00000400 /* Low power cfg done */
|
||||
|
||||
/* Shared Receive Address Registers */
|
||||
#define E1000_SHRAL_PCH_LPT(_i) (0x05408 + ((_i) * 8))
|
||||
#define E1000_SHRAH_PCH_LPT(_i) (0x0540C + ((_i) * 8))
|
||||
|
||||
#define E1000_H2ME 0x05B50 /* Host to ME */
|
||||
#define E1000_H2ME_ULP 0x00000800 /* ULP Indication Bit */
|
||||
#define E1000_H2ME_ENFORCE_SETTINGS 0x00001000 /* Enforce Settings */
|
||||
|
||||
#define ID_LED_DEFAULT_ICH8LAN ((ID_LED_DEF1_DEF2 << 12) | \
|
||||
(ID_LED_OFF1_OFF2 << 8) | \
|
||||
(ID_LED_OFF1_ON2 << 4) | \
|
||||
@ -87,6 +92,9 @@
|
||||
|
||||
#define E1000_ICH8_LAN_INIT_TIMEOUT 1500
|
||||
|
||||
/* FEXT register bit definition */
|
||||
#define E1000_FEXT_PHY_CABLE_DISCONNECTED 0x00000004
|
||||
|
||||
#define E1000_FEXTNVM_SW_CONFIG 1
|
||||
#define E1000_FEXTNVM_SW_CONFIG_ICH8M (1 << 27) /* different on ICH8M */
|
||||
|
||||
@ -100,10 +108,12 @@
|
||||
#define E1000_FEXTNVM6_REQ_PLL_CLK 0x00000100
|
||||
#define E1000_FEXTNVM6_ENABLE_K1_ENTRY_CONDITION 0x00000200
|
||||
|
||||
#define E1000_FEXTNVM7_DISABLE_SMB_PERST 0x00000020
|
||||
|
||||
#define PCIE_ICH8_SNOOP_ALL PCIE_NO_SNOOP_ALL
|
||||
|
||||
#define E1000_ICH_RAR_ENTRIES 7
|
||||
#define E1000_PCH2_RAR_ENTRIES 11 /* RAR[0-6], SHRA[0-3] */
|
||||
#define E1000_PCH2_RAR_ENTRIES 5 /* RAR[0], SHRA[0-3] */
|
||||
#define E1000_PCH_LPT_RAR_ENTRIES 12 /* RAR[0], SHRA[0-10] */
|
||||
|
||||
#define PHY_PAGE_SHIFT 5
|
||||
@ -166,6 +176,16 @@
|
||||
#define CV_SMB_CTRL PHY_REG(769, 23)
|
||||
#define CV_SMB_CTRL_FORCE_SMBUS 0x0001
|
||||
|
||||
/* I218 Ultra Low Power Configuration 1 Register */
|
||||
#define I218_ULP_CONFIG1 PHY_REG(779, 16)
|
||||
#define I218_ULP_CONFIG1_START 0x0001 /* Start auto ULP config */
|
||||
#define I218_ULP_CONFIG1_IND 0x0004 /* Pwr up from ULP indication */
|
||||
#define I218_ULP_CONFIG1_STICKY_ULP 0x0010 /* Set sticky ULP mode */
|
||||
#define I218_ULP_CONFIG1_INBAND_EXIT 0x0020 /* Inband on ULP exit */
|
||||
#define I218_ULP_CONFIG1_WOL_HOST 0x0040 /* WoL Host on ULP exit */
|
||||
#define I218_ULP_CONFIG1_RESET_TO_SMBUS 0x0100 /* Reset to SMBus mode */
|
||||
#define I218_ULP_CONFIG1_DISABLE_SMB_PERST 0x1000 /* Disable on PERST# */
|
||||
|
||||
/* SMBus Address Phy Register */
|
||||
#define HV_SMB_ADDR PHY_REG(768, 26)
|
||||
#define HV_SMB_ADDR_MASK 0x007F
|
||||
@ -200,6 +220,7 @@
|
||||
/* PHY Power Management Control */
|
||||
#define HV_PM_CTRL PHY_REG(770, 17)
|
||||
#define HV_PM_CTRL_PLL_STOP_IN_K1_GIGA 0x100
|
||||
#define HV_PM_CTRL_K1_ENABLE 0x4000
|
||||
|
||||
#define SW_FLAG_TIMEOUT 1000 /* SW Semaphore flag timeout in ms */
|
||||
|
||||
@ -217,7 +238,6 @@
|
||||
#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
|
||||
|
||||
/* 82579 DFT Control */
|
||||
#define I82579_DFT_CTRL PHY_REG(769, 20)
|
||||
@ -231,16 +251,19 @@
|
||||
#define I82577_MSE_THRESHOLD 0x0887 /* 82577 Mean Square Error Threshold */
|
||||
#define I82579_MSE_LINK_DOWN 0x2411 /* MSE count before dropping link */
|
||||
#define I82579_RX_CONFIG 0x3412 /* Receive configuration */
|
||||
#define I82579_LPI_PLL_SHUT 0x4412 /* LPI PLL Shut Enable */
|
||||
#define I82579_EEE_PCS_STATUS 0x182E /* IEEE MMD Register 3.1 >> 8 */
|
||||
#define I82579_EEE_CAPABILITY 0x0410 /* IEEE MMD Register 3.20 */
|
||||
#define I82579_EEE_ADVERTISEMENT 0x040E /* IEEE MMD Register 7.60 */
|
||||
#define I82579_EEE_LP_ABILITY 0x040F /* IEEE MMD Register 7.61 */
|
||||
#define I82579_EEE_100_SUPPORTED (1 << 1) /* 100BaseTx EEE */
|
||||
#define I82579_EEE_1000_SUPPORTED (1 << 2) /* 1000BaseTx EEE */
|
||||
#define I82579_LPI_100_PLL_SHUT (1 << 2) /* 100M LPI PLL Shut Enabled */
|
||||
#define I217_EEE_PCS_STATUS 0x9401 /* IEEE MMD Register 3.1 */
|
||||
#define I217_EEE_CAPABILITY 0x8000 /* IEEE MMD Register 3.20 */
|
||||
#define I217_EEE_ADVERTISEMENT 0x8001 /* IEEE MMD Register 7.60 */
|
||||
#define I217_EEE_LP_ABILITY 0x8002 /* IEEE MMD Register 7.61 */
|
||||
#define I217_RX_CONFIG 0xB20C /* Receive configuration */
|
||||
|
||||
#define E1000_EEE_RX_LPI_RCVD 0x0400 /* Tx LP idle received */
|
||||
#define E1000_EEE_TX_LPI_RCVD 0x0800 /* Rx LP idle received */
|
||||
@ -279,6 +302,9 @@
|
||||
#define E1000_SVCR_OFF_TIMER_SHIFT 16
|
||||
#define E1000_SVT_OFF_HWM_MASK 0x0000001F
|
||||
|
||||
#if defined(QV_RELEASE) || !defined(NO_PCH_LPT_B0_SUPPORT)
|
||||
#define E1000_PCI_REVISION_ID_REG 0x08
|
||||
#endif /* defined(QV_RELEASE) || !defined(NO_PCH_LPT_B0_SUPPORT) */
|
||||
void e1000_set_kmrn_lock_loss_workaround_ich8lan(struct e1000_hw *hw,
|
||||
bool state);
|
||||
void e1000_igp3_phy_powerdown_workaround_ich8lan(struct e1000_hw *hw);
|
||||
@ -291,5 +317,6 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable);
|
||||
s32 e1000_read_emi_reg_locked(struct e1000_hw *hw, u16 addr, u16 *data);
|
||||
s32 e1000_write_emi_reg_locked(struct e1000_hw *hw, u16 addr, u16 data);
|
||||
s32 e1000_set_eee_pchlan(struct e1000_hw *hw);
|
||||
void e1000_toggle_lanphypc_pch_lpt(struct e1000_hw *hw);
|
||||
s32 e1000_enable_ulp_lpt_lp(struct e1000_hw *hw, bool to_sx);
|
||||
s32 e1000_disable_ulp_lpt_lp(struct e1000_hw *hw, bool force);
|
||||
#endif /* _E1000_ICH8LAN_H_ */
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -37,7 +37,7 @@
|
||||
static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw);
|
||||
static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
|
||||
static void e1000_config_collision_dist_generic(struct e1000_hw *hw);
|
||||
static void e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
static int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index);
|
||||
|
||||
/**
|
||||
* e1000_init_mac_ops_generic - Initialize MAC function pointers
|
||||
@ -145,14 +145,14 @@ void e1000_null_write_vfta(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_null_rar_set - No-op function, return void
|
||||
* e1000_null_rar_set - No-op function, return 0
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
void e1000_null_rar_set(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
int e1000_null_rar_set(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_rar_set");
|
||||
return;
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -475,7 +475,7 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
|
||||
* Sets the receive address array register at index to the address passed
|
||||
* in by addr.
|
||||
**/
|
||||
static void e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
static int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
{
|
||||
u32 rar_low, rar_high;
|
||||
|
||||
@ -501,6 +501,8 @@ static void e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index)
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
E1000_WRITE_REG(hw, E1000_RAH(index), rar_high);
|
||||
E1000_WRITE_FLUSH(hw);
|
||||
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -2096,7 +2098,8 @@ s32 e1000_disable_pcie_master_generic(struct e1000_hw *hw)
|
||||
|
||||
while (timeout) {
|
||||
if (!(E1000_READ_REG(hw, E1000_STATUS) &
|
||||
E1000_STATUS_GIO_MASTER_ENABLE))
|
||||
E1000_STATUS_GIO_MASTER_ENABLE) ||
|
||||
E1000_REMOVED(hw->hw_addr))
|
||||
break;
|
||||
usec_delay(100);
|
||||
timeout--;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -36,13 +36,16 @@
|
||||
#define _E1000_MAC_H_
|
||||
|
||||
void e1000_init_mac_ops_generic(struct e1000_hw *hw);
|
||||
#ifndef E1000_REMOVED
|
||||
#define E1000_REMOVED(a) (0)
|
||||
#endif /* E1000_REMOVED */
|
||||
void e1000_null_mac_generic(struct e1000_hw *hw);
|
||||
s32 e1000_null_ops_generic(struct e1000_hw *hw);
|
||||
s32 e1000_null_link_info(struct e1000_hw *hw, u16 *s, u16 *d);
|
||||
bool e1000_null_mng_mode(struct e1000_hw *hw);
|
||||
void e1000_null_update_mc(struct e1000_hw *hw, u8 *h, u32 a);
|
||||
void e1000_null_write_vfta(struct e1000_hw *hw, u32 a, u32 b);
|
||||
void e1000_null_rar_set(struct e1000_hw *hw, u8 *h, u32 a);
|
||||
int e1000_null_rar_set(struct e1000_hw *hw, u8 *h, u32 a);
|
||||
s32 e1000_null_set_obff_timer(struct e1000_hw *hw, u32 a);
|
||||
s32 e1000_blink_led_generic(struct e1000_hw *hw);
|
||||
s32 e1000_check_for_copper_link_generic(struct e1000_hw *hw);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -364,9 +364,12 @@ bool e1000_enable_mng_pass_thru(struct e1000_hw *hw)
|
||||
} else if ((hw->mac.type == e1000_82574) ||
|
||||
(hw->mac.type == e1000_82583)) {
|
||||
u16 data;
|
||||
s32 ret_val;
|
||||
|
||||
factps = E1000_READ_REG(hw, E1000_FACTPS);
|
||||
e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &data);
|
||||
ret_val = e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &data);
|
||||
if (ret_val)
|
||||
return FALSE;
|
||||
|
||||
if (!(factps & E1000_FACTPS_MNGCG) &&
|
||||
((data & E1000_NVM_INIT_CTRL2_MNGM) ==
|
||||
@ -374,7 +377,7 @@ bool e1000_enable_mng_pass_thru(struct e1000_hw *hw)
|
||||
return TRUE;
|
||||
} else if ((manc & E1000_MANC_SMBUS_EN) &&
|
||||
!(manc & E1000_MANC_ASF_EN)) {
|
||||
return TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2010, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -38,7 +38,8 @@
|
||||
* e1000_null_mbx_check_for_flag - No-op function, return 0
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
static s32 e1000_null_mbx_check_for_flag(struct e1000_hw *hw, u16 mbx_id)
|
||||
static s32 e1000_null_mbx_check_for_flag(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_mbx_check_flag");
|
||||
|
||||
@ -49,8 +50,10 @@ static s32 e1000_null_mbx_check_for_flag(struct e1000_hw *hw, u16 mbx_id)
|
||||
* e1000_null_mbx_transact - No-op function, return 0
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
static s32 e1000_null_mbx_transact(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
u16 mbx_id)
|
||||
static s32 e1000_null_mbx_transact(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
u32 E1000_UNUSEDARG *msg,
|
||||
u16 E1000_UNUSEDARG size,
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_mbx_rw_msg");
|
||||
|
||||
@ -354,7 +357,8 @@ static s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
|
||||
*
|
||||
* returns SUCCESS if the PF has set the Status bit or else ERR_MBX
|
||||
**/
|
||||
static s32 e1000_check_for_msg_vf(struct e1000_hw *hw, u16 mbx_id)
|
||||
static s32 e1000_check_for_msg_vf(struct e1000_hw *hw,
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
s32 ret_val = -E1000_ERR_MBX;
|
||||
|
||||
@ -375,7 +379,8 @@ static s32 e1000_check_for_msg_vf(struct e1000_hw *hw, u16 mbx_id)
|
||||
*
|
||||
* returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
|
||||
**/
|
||||
static s32 e1000_check_for_ack_vf(struct e1000_hw *hw, u16 mbx_id)
|
||||
static s32 e1000_check_for_ack_vf(struct e1000_hw *hw,
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
s32 ret_val = -E1000_ERR_MBX;
|
||||
|
||||
@ -396,14 +401,15 @@ static s32 e1000_check_for_ack_vf(struct e1000_hw *hw, u16 mbx_id)
|
||||
*
|
||||
* returns TRUE if the PF has set the reset done bit or else FALSE
|
||||
**/
|
||||
static s32 e1000_check_for_rst_vf(struct e1000_hw *hw, u16 mbx_id)
|
||||
static s32 e1000_check_for_rst_vf(struct e1000_hw *hw,
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
s32 ret_val = -E1000_ERR_MBX;
|
||||
|
||||
DEBUGFUNC("e1000_check_for_rst_vf");
|
||||
|
||||
if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD |
|
||||
E1000_V2PMAILBOX_RSTI))) {
|
||||
E1000_V2PMAILBOX_RSTI))) {
|
||||
ret_val = E1000_SUCCESS;
|
||||
hw->mbx.stats.rsts++;
|
||||
}
|
||||
@ -443,7 +449,7 @@ static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
|
||||
* returns SUCCESS if it successfully copied message into the buffer
|
||||
**/
|
||||
static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
u16 mbx_id)
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
s32 ret_val;
|
||||
u16 i;
|
||||
@ -484,7 +490,7 @@ static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
* returns SUCCESS if it successfuly read message from buffer
|
||||
**/
|
||||
static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
u16 mbx_id)
|
||||
u16 E1000_UNUSEDARG mbx_id)
|
||||
{
|
||||
s32 ret_val = E1000_SUCCESS;
|
||||
u16 i;
|
||||
@ -657,7 +663,7 @@ static s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
|
||||
* returns SUCCESS if it successfully copied message into the buffer
|
||||
**/
|
||||
static s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
u16 vf_number)
|
||||
u16 vf_number)
|
||||
{
|
||||
s32 ret_val;
|
||||
u16 i;
|
||||
@ -700,7 +706,7 @@ static s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
* a message due to a VF request so no polling for message is needed.
|
||||
**/
|
||||
static s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
|
||||
u16 vf_number)
|
||||
u16 vf_number)
|
||||
{
|
||||
s32 ret_val;
|
||||
u16 i;
|
||||
@ -739,6 +745,7 @@ s32 e1000_init_mbx_params_pf(struct e1000_hw *hw)
|
||||
switch (hw->mac.type) {
|
||||
case e1000_82576:
|
||||
case e1000_i350:
|
||||
case e1000_i354:
|
||||
mbx->timeout = 0;
|
||||
mbx->usec_delay = 0;
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2010, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -38,59 +38,59 @@
|
||||
#include "e1000_api.h"
|
||||
|
||||
/* Define mailbox register bits */
|
||||
#define E1000_V2PMAILBOX_REQ 0x00000001 /* Request for PF Ready bit */
|
||||
#define E1000_V2PMAILBOX_ACK 0x00000002 /* Ack PF message received */
|
||||
#define E1000_V2PMAILBOX_VFU 0x00000004 /* VF owns the mailbox buffer */
|
||||
#define E1000_V2PMAILBOX_PFU 0x00000008 /* PF owns the mailbox buffer */
|
||||
#define E1000_V2PMAILBOX_PFSTS 0x00000010 /* PF wrote a message in the MB */
|
||||
#define E1000_V2PMAILBOX_PFACK 0x00000020 /* PF ack the previous VF msg */
|
||||
#define E1000_V2PMAILBOX_RSTI 0x00000040 /* PF has reset indication */
|
||||
#define E1000_V2PMAILBOX_RSTD 0x00000080 /* PF has indicated reset done */
|
||||
#define E1000_V2PMAILBOX_REQ 0x00000001 /* Request for PF Ready bit */
|
||||
#define E1000_V2PMAILBOX_ACK 0x00000002 /* Ack PF message received */
|
||||
#define E1000_V2PMAILBOX_VFU 0x00000004 /* VF owns the mailbox buffer */
|
||||
#define E1000_V2PMAILBOX_PFU 0x00000008 /* PF owns the mailbox buffer */
|
||||
#define E1000_V2PMAILBOX_PFSTS 0x00000010 /* PF wrote a message in the MB */
|
||||
#define E1000_V2PMAILBOX_PFACK 0x00000020 /* PF ack the previous VF msg */
|
||||
#define E1000_V2PMAILBOX_RSTI 0x00000040 /* PF has reset indication */
|
||||
#define E1000_V2PMAILBOX_RSTD 0x00000080 /* PF has indicated reset done */
|
||||
#define E1000_V2PMAILBOX_R2C_BITS 0x000000B0 /* All read to clear bits */
|
||||
|
||||
#define E1000_P2VMAILBOX_STS 0x00000001 /* Initiate message send to VF */
|
||||
#define E1000_P2VMAILBOX_ACK 0x00000002 /* Ack message recv'd from VF */
|
||||
#define E1000_P2VMAILBOX_VFU 0x00000004 /* VF owns the mailbox buffer */
|
||||
#define E1000_P2VMAILBOX_PFU 0x00000008 /* PF owns the mailbox buffer */
|
||||
#define E1000_P2VMAILBOX_RVFU 0x00000010 /* Reset VFU - used when VF stuck */
|
||||
#define E1000_P2VMAILBOX_STS 0x00000001 /* Initiate message send to VF */
|
||||
#define E1000_P2VMAILBOX_ACK 0x00000002 /* Ack message recv'd from VF */
|
||||
#define E1000_P2VMAILBOX_VFU 0x00000004 /* VF owns the mailbox buffer */
|
||||
#define E1000_P2VMAILBOX_PFU 0x00000008 /* PF owns the mailbox buffer */
|
||||
#define E1000_P2VMAILBOX_RVFU 0x00000010 /* Reset VFU - used when VF stuck */
|
||||
|
||||
#define E1000_MBVFICR_VFREQ_MASK 0x000000FF /* bits for VF messages */
|
||||
#define E1000_MBVFICR_VFREQ_VF1 0x00000001 /* bit for VF 1 message */
|
||||
#define E1000_MBVFICR_VFREQ_VF1 0x00000001 /* bit for VF 1 message */
|
||||
#define E1000_MBVFICR_VFACK_MASK 0x00FF0000 /* bits for VF acks */
|
||||
#define E1000_MBVFICR_VFACK_VF1 0x00010000 /* bit for VF 1 ack */
|
||||
#define E1000_MBVFICR_VFACK_VF1 0x00010000 /* bit for VF 1 ack */
|
||||
|
||||
#define E1000_VFMAILBOX_SIZE 16 /* 16 32 bit words - 64 bytes */
|
||||
#define E1000_VFMAILBOX_SIZE 16 /* 16 32 bit words - 64 bytes */
|
||||
|
||||
/* If it's a E1000_VF_* msg then it originates in the VF and is sent to the
|
||||
* PF. The reverse is TRUE if it is E1000_PF_*.
|
||||
* Message ACK's are the value or'd with 0xF0000000
|
||||
*/
|
||||
#define E1000_VT_MSGTYPE_ACK 0x80000000 /* Messages below or'd with
|
||||
* this are the ACK */
|
||||
#define E1000_VT_MSGTYPE_NACK 0x40000000 /* Messages below or'd with
|
||||
* this are the NACK */
|
||||
#define E1000_VT_MSGTYPE_CTS 0x20000000 /* Indicates that VF is still
|
||||
clear to send requests */
|
||||
#define E1000_VT_MSGINFO_SHIFT 16
|
||||
/* bits 23:16 are used for exra info for certain messages */
|
||||
#define E1000_VT_MSGINFO_MASK (0xFF << E1000_VT_MSGINFO_SHIFT)
|
||||
/* Msgs below or'd with this are the ACK */
|
||||
#define E1000_VT_MSGTYPE_ACK 0x80000000
|
||||
/* Msgs below or'd with this are the NACK */
|
||||
#define E1000_VT_MSGTYPE_NACK 0x40000000
|
||||
/* Indicates that VF is still clear to send requests */
|
||||
#define E1000_VT_MSGTYPE_CTS 0x20000000
|
||||
#define E1000_VT_MSGINFO_SHIFT 16
|
||||
/* bits 23:16 are used for extra info for certain messages */
|
||||
#define E1000_VT_MSGINFO_MASK (0xFF << E1000_VT_MSGINFO_SHIFT)
|
||||
|
||||
#define E1000_VF_RESET 0x01 /* VF requests reset */
|
||||
#define E1000_VF_SET_MAC_ADDR 0x02 /* VF requests to set MAC addr */
|
||||
#define E1000_VF_SET_MULTICAST 0x03 /* VF requests to set MC addr */
|
||||
#define E1000_VF_RESET 0x01 /* VF requests reset */
|
||||
#define E1000_VF_SET_MAC_ADDR 0x02 /* VF requests to set MAC addr */
|
||||
#define E1000_VF_SET_MULTICAST 0x03 /* VF requests to set MC addr */
|
||||
#define E1000_VF_SET_MULTICAST_COUNT_MASK (0x1F << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_MULTICAST_OVERFLOW (0x80 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_VLAN 0x04 /* VF requests to set VLAN */
|
||||
#define E1000_VF_SET_VLAN_ADD (0x01 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_LPE 0x05 /* VF requests to set VMOLR.LPE */
|
||||
#define E1000_VF_SET_PROMISC 0x06 /*VF requests to clear VMOLR.ROPE/MPME*/
|
||||
#define E1000_VF_SET_PROMISC_UNICAST (0x01 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_PROMISC_MULTICAST (0x02 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_MULTICAST_OVERFLOW (0x80 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_VLAN 0x04 /* VF requests to set VLAN */
|
||||
#define E1000_VF_SET_VLAN_ADD (0x01 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_LPE 0x05 /* reqs to set VMOLR.LPE */
|
||||
#define E1000_VF_SET_PROMISC 0x06 /* reqs to clear VMOLR.ROPE/MPME*/
|
||||
#define E1000_VF_SET_PROMISC_UNICAST (0x01 << E1000_VT_MSGINFO_SHIFT)
|
||||
#define E1000_VF_SET_PROMISC_MULTICAST (0x02 << E1000_VT_MSGINFO_SHIFT)
|
||||
|
||||
#define E1000_PF_CONTROL_MSG 0x0100 /* PF control message */
|
||||
#define E1000_PF_CONTROL_MSG 0x0100 /* PF control message */
|
||||
|
||||
#define E1000_VF_MBX_INIT_TIMEOUT 2000 /* number of retries on mailbox */
|
||||
#define E1000_VF_MBX_INIT_DELAY 500 /* microseconds between retries */
|
||||
#define E1000_VF_MBX_INIT_TIMEOUT 2000 /* number of retries on mailbox */
|
||||
#define E1000_VF_MBX_INIT_DELAY 500 /* microseconds between retries */
|
||||
|
||||
s32 e1000_read_mbx(struct e1000_hw *, u32 *, u16, u16);
|
||||
s32 e1000_write_mbx(struct e1000_hw *, u32 *, u16, u16);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -63,7 +63,9 @@ void e1000_init_nvm_ops_generic(struct e1000_hw *hw)
|
||||
* e1000_null_nvm_read - No-op function, return 0
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
s32 e1000_null_read_nvm(struct e1000_hw *hw, u16 a, u16 b, u16 *c)
|
||||
s32 e1000_null_read_nvm(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
u16 E1000_UNUSEDARG a, u16 E1000_UNUSEDARG b,
|
||||
u16 E1000_UNUSEDARG *c)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_read_nvm");
|
||||
return E1000_SUCCESS;
|
||||
@ -73,7 +75,7 @@ s32 e1000_null_read_nvm(struct e1000_hw *hw, u16 a, u16 b, u16 *c)
|
||||
* e1000_null_nvm_generic - No-op function, return void
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
void e1000_null_nvm_generic(struct e1000_hw *hw)
|
||||
void e1000_null_nvm_generic(struct e1000_hw E1000_UNUSEDARG *hw)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_nvm_generic");
|
||||
return;
|
||||
@ -83,7 +85,8 @@ void e1000_null_nvm_generic(struct e1000_hw *hw)
|
||||
* e1000_null_led_default - No-op function, return 0
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
s32 e1000_null_led_default(struct e1000_hw *hw, u16 *data)
|
||||
s32 e1000_null_led_default(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
u16 E1000_UNUSEDARG *data)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_led_default");
|
||||
return E1000_SUCCESS;
|
||||
@ -93,7 +96,9 @@ s32 e1000_null_led_default(struct e1000_hw *hw, u16 *data)
|
||||
* e1000_null_write_nvm - No-op function, return 0
|
||||
* @hw: pointer to the HW structure
|
||||
**/
|
||||
s32 e1000_null_write_nvm(struct e1000_hw *hw, u16 a, u16 b, u16 *c)
|
||||
s32 e1000_null_write_nvm(struct e1000_hw E1000_UNUSEDARG *hw,
|
||||
u16 E1000_UNUSEDARG a, u16 E1000_UNUSEDARG b,
|
||||
u16 E1000_UNUSEDARG *c)
|
||||
{
|
||||
DEBUGFUNC("e1000_null_write_nvm");
|
||||
return E1000_SUCCESS;
|
||||
@ -577,6 +582,9 @@ s32 e1000_read_nvm_eerd(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
|
||||
E1000_NVM_RW_REG_DATA);
|
||||
}
|
||||
|
||||
if (ret_val)
|
||||
DEBUGOUT1("NVM read error: %d\n", ret_val);
|
||||
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
@ -767,6 +775,12 @@ s32 e1000_read_pba_string_generic(struct e1000_hw *hw, u8 *pba_num,
|
||||
|
||||
DEBUGFUNC("e1000_read_pba_string_generic");
|
||||
|
||||
if ((hw->mac.type >= e1000_i210) &&
|
||||
!e1000_get_flash_presence_i210(hw)) {
|
||||
DEBUGOUT("Flashless no PBA string\n");
|
||||
return -E1000_ERR_NVM_PBA_SECTION;
|
||||
}
|
||||
|
||||
if (pba_num == NULL) {
|
||||
DEBUGOUT("PBA string buffer was null\n");
|
||||
return -E1000_ERR_INVALID_ARGUMENT;
|
||||
@ -974,7 +988,7 @@ s32 e1000_read_pba_raw(struct e1000_hw *hw, u16 *eeprom_buf,
|
||||
return ret_val;
|
||||
} else {
|
||||
if (eeprom_buf_size > (u32)(pba->word[1] +
|
||||
pba->pba_block[0])) {
|
||||
pba_block_size)) {
|
||||
memcpy(pba->pba_block,
|
||||
&eeprom_buf[pba->word[1]],
|
||||
pba_block_size * sizeof(u16));
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -64,11 +64,9 @@
|
||||
#define msec_delay(x) DELAY(1000*(x))
|
||||
#define msec_delay_irq(x) DELAY(1000*(x))
|
||||
|
||||
#define MSGOUT(S, A, B) printf(S "\n", A, B)
|
||||
#define DEBUGFUNC(F) DEBUGOUT(F);
|
||||
#define DEBUGOUT(S) do {} while (0)
|
||||
/* This define is needed or shared code will not build */
|
||||
#define DEBUGOUT1(S,A) if (0) printf(S,A);
|
||||
#define DEBUGOUT1(S,A) do {} while (0)
|
||||
#define DEBUGOUT2(S,A,B) do {} while (0)
|
||||
#define DEBUGOUT3(S,A,B,C) do {} while (0)
|
||||
#define DEBUGOUT7(S,A,B,C,D,E,F,G) do {} while (0)
|
||||
@ -77,7 +75,7 @@
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
#ifndef __bool_true_false_are_defined
|
||||
#define false FALSE
|
||||
#define false FALSE
|
||||
#define true TRUE
|
||||
#endif
|
||||
#define CMD_MEM_WRT_INVALIDATE 0x0010 /* BIT_4 */
|
||||
@ -87,7 +85,7 @@
|
||||
#define E1000_MUTEX struct mtx
|
||||
#define E1000_MUTEX_INIT(mutex) mtx_init((mutex), #mutex, \
|
||||
MTX_NETWORK_LOCK, \
|
||||
MTX_DEF | MTX_DUPOK)
|
||||
MTX_DEF | MTX_DUPOK)
|
||||
#define E1000_MUTEX_DESTROY(mutex) mtx_destroy(mutex)
|
||||
#define E1000_MUTEX_LOCK(mutex) mtx_lock(mutex)
|
||||
#define E1000_MUTEX_TRYLOCK(mutex) mtx_trylock(mutex)
|
||||
@ -109,7 +107,7 @@ typedef boolean_t bool;
|
||||
#define __le32 u32
|
||||
#define __le64 u64
|
||||
|
||||
#if __FreeBSD_version < 800000 /* Now in HEAD */
|
||||
#if __FreeBSD_version < 800000
|
||||
#if defined(__i386__) || defined(__amd64__)
|
||||
#define mb() __asm volatile("mfence" ::: "memory")
|
||||
#define wmb() __asm volatile("sfence" ::: "memory")
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -2362,19 +2362,23 @@ s32 e1000_phy_has_link_generic(struct e1000_hw *hw, u32 iterations,
|
||||
* it across the board.
|
||||
*/
|
||||
ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status);
|
||||
if (ret_val)
|
||||
if (ret_val) {
|
||||
/* If the first read fails, another entity may have
|
||||
* ownership of the resources, wait and try again to
|
||||
* see if they have relinquished the resources yet.
|
||||
*/
|
||||
usec_delay(usec_interval);
|
||||
if (usec_interval >= 1000)
|
||||
msec_delay(usec_interval/1000);
|
||||
else
|
||||
usec_delay(usec_interval);
|
||||
}
|
||||
ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &phy_status);
|
||||
if (ret_val)
|
||||
break;
|
||||
if (phy_status & MII_SR_LINK_STATUS)
|
||||
break;
|
||||
if (usec_interval >= 1000)
|
||||
msec_delay_irq(usec_interval/1000);
|
||||
msec_delay(usec_interval/1000);
|
||||
else
|
||||
usec_delay(usec_interval);
|
||||
}
|
||||
@ -3425,11 +3429,12 @@ static s32 e1000_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,
|
||||
u16 *data, bool read, bool page_set)
|
||||
{
|
||||
s32 ret_val;
|
||||
u16 reg = BM_PHY_REG_NUM(offset);
|
||||
u16 page = BM_PHY_REG_PAGE(offset);
|
||||
u16 reg, page;
|
||||
u16 phy_reg = 0;
|
||||
|
||||
DEBUGFUNC("e1000_access_phy_wakeup_reg_bm");
|
||||
reg = BM_PHY_REG_NUM(offset);
|
||||
page = BM_PHY_REG_PAGE(offset);
|
||||
|
||||
/* Gig must be disabled for MDIO accesses to Host Wakeup reg page */
|
||||
if ((hw->mac.type == e1000_pchlan) &&
|
||||
@ -3487,16 +3492,10 @@ static s32 e1000_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,
|
||||
void e1000_power_up_phy_copper(struct e1000_hw *hw)
|
||||
{
|
||||
u16 mii_reg = 0;
|
||||
u16 power_reg = 0;
|
||||
|
||||
/* The PHY will retain its settings across a power down/up cycle */
|
||||
hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
|
||||
mii_reg &= ~MII_CR_POWER_DOWN;
|
||||
if (hw->phy.type == e1000_phy_i210) {
|
||||
hw->phy.ops.read_reg(hw, GS40G_COPPER_SPEC, &power_reg);
|
||||
power_reg &= ~GS40G_CS_POWER_DOWN;
|
||||
hw->phy.ops.write_reg(hw, GS40G_COPPER_SPEC, power_reg);
|
||||
}
|
||||
hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg);
|
||||
}
|
||||
|
||||
@ -3511,17 +3510,10 @@ void e1000_power_up_phy_copper(struct e1000_hw *hw)
|
||||
void e1000_power_down_phy_copper(struct e1000_hw *hw)
|
||||
{
|
||||
u16 mii_reg = 0;
|
||||
u16 power_reg = 0;
|
||||
|
||||
/* The PHY will retain its settings across a power down/up cycle */
|
||||
hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
|
||||
mii_reg |= MII_CR_POWER_DOWN;
|
||||
/* i210 Phy requires an additional bit for power up/down */
|
||||
if (hw->phy.type == e1000_phy_i210) {
|
||||
hw->phy.ops.read_reg(hw, GS40G_COPPER_SPEC, &power_reg);
|
||||
power_reg |= GS40G_CS_POWER_DOWN;
|
||||
hw->phy.ops.write_reg(hw, GS40G_COPPER_SPEC, power_reg);
|
||||
}
|
||||
hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg);
|
||||
msec_delay(1);
|
||||
}
|
||||
@ -4119,7 +4111,7 @@ s32 e1000_read_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 *data)
|
||||
{
|
||||
u32 mphy_ctrl = 0;
|
||||
bool locked = FALSE;
|
||||
bool ready = FALSE;
|
||||
bool ready;
|
||||
|
||||
DEBUGFUNC("e1000_read_phy_reg_mphy");
|
||||
|
||||
@ -4157,13 +4149,12 @@ s32 e1000_read_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 *data)
|
||||
*data = E1000_READ_REG(hw, E1000_MPHY_DATA);
|
||||
|
||||
/* Disable access to mPHY if it was originally disabled */
|
||||
if (locked) {
|
||||
if (locked)
|
||||
ready = e1000_is_mphy_ready(hw);
|
||||
if (!ready)
|
||||
return -E1000_ERR_PHY;
|
||||
E1000_WRITE_REG(hw, E1000_MPHY_ADDR_CTRL,
|
||||
E1000_MPHY_DIS_ACCESS);
|
||||
}
|
||||
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
@ -4182,7 +4173,7 @@ s32 e1000_write_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 data,
|
||||
{
|
||||
u32 mphy_ctrl = 0;
|
||||
bool locked = FALSE;
|
||||
bool ready = FALSE;
|
||||
bool ready;
|
||||
|
||||
DEBUGFUNC("e1000_write_phy_reg_mphy");
|
||||
|
||||
@ -4223,13 +4214,12 @@ s32 e1000_write_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 data,
|
||||
E1000_WRITE_REG(hw, E1000_MPHY_DATA, data);
|
||||
|
||||
/* Disable access to mPHY if it was originally disabled */
|
||||
if (locked) {
|
||||
if (locked)
|
||||
ready = e1000_is_mphy_ready(hw);
|
||||
if (!ready)
|
||||
return -E1000_ERR_PHY;
|
||||
E1000_WRITE_REG(hw, E1000_MPHY_ADDR_CTRL,
|
||||
E1000_MPHY_DIS_ACCESS);
|
||||
}
|
||||
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -144,7 +144,6 @@ bool e1000_is_mphy_ready(struct e1000_hw *hw);
|
||||
#define GS40G_MAC_LB 0x4140
|
||||
#define GS40G_MAC_SPEED_1G 0X0006
|
||||
#define GS40G_COPPER_SPEC 0x0010
|
||||
#define GS40G_CS_POWER_DOWN 0x0002
|
||||
|
||||
/* BM/HV Specific Registers */
|
||||
#define BM_PORT_CTRL_PAGE 769
|
||||
@ -226,6 +225,7 @@ bool e1000_is_mphy_ready(struct e1000_hw *hw);
|
||||
#define HV_M_STATUS_AUTONEG_COMPLETE 0x1000
|
||||
#define HV_M_STATUS_SPEED_MASK 0x0300
|
||||
#define HV_M_STATUS_SPEED_1000 0x0200
|
||||
#define HV_M_STATUS_SPEED_100 0x0100
|
||||
#define HV_M_STATUS_LINK_UP 0x0040
|
||||
|
||||
#define IGP01E1000_PHY_PCS_INIT_REG 0x00B4
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -59,6 +59,7 @@
|
||||
#define E1000_SCTL 0x00024 /* SerDes Control - RW */
|
||||
#define E1000_FCAL 0x00028 /* Flow Control Address Low - RW */
|
||||
#define E1000_FCAH 0x0002C /* Flow Control Address High -RW */
|
||||
#define E1000_FEXT 0x0002C /* Future Extended - RW */
|
||||
#define E1000_FEXTNVM 0x00028 /* Future Extended NVM - RW */
|
||||
#define E1000_FEXTNVM3 0x0003C /* Future Extended NVM 3 - RW */
|
||||
#define E1000_FEXTNVM4 0x00024 /* Future Extended NVM 4 - RW */
|
||||
@ -108,6 +109,7 @@
|
||||
#define E1000_PBECCSTS 0x0100C /* Packet Buffer ECC Status - RW */
|
||||
#define E1000_EEMNGCTL 0x01010 /* MNG EEprom Control */
|
||||
#define E1000_EEARBC 0x01024 /* EEPROM Auto Read Bus Control */
|
||||
#define E1000_EEARBC_I210 0x12024 /* EEPROM Auto Read Bus Control */
|
||||
#define E1000_FLASHT 0x01028 /* FLASH Timer Register */
|
||||
#define E1000_EEWR 0x0102C /* EEPROM Write Register - RW */
|
||||
#define E1000_FLSWCTL 0x01030 /* FLASH control register */
|
||||
@ -207,7 +209,7 @@
|
||||
/* QAV Tx mode control register bitfields masks */
|
||||
#define E1000_TQAVCC_IDLE_SLOPE 0xFFFF /* Idle slope */
|
||||
#define E1000_TQAVCC_KEEP_CREDITS (1 << 30) /* Keep credits opt enable */
|
||||
#define E1000_TQAVCC_QUEUE_MODE (1U << 31) /* SP vs. SR Tx mode */
|
||||
#define E1000_TQAVCC_QUEUE_MODE (1 << 31) /* SP vs. SR Tx mode */
|
||||
|
||||
/* Good transmitted packets counter registers */
|
||||
#define E1000_PQGPTC(_n) (0x010014 + (0x100 * (_n)))
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2011, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -49,7 +49,7 @@ static s32 e1000_get_link_up_info_vf(struct e1000_hw *hw, u16 *speed,
|
||||
static s32 e1000_init_hw_vf(struct e1000_hw *hw);
|
||||
static s32 e1000_reset_hw_vf(struct e1000_hw *hw);
|
||||
static void e1000_update_mc_addr_list_vf(struct e1000_hw *hw, u8 *, u32);
|
||||
static void e1000_rar_set_vf(struct e1000_hw *, u8 *, u32);
|
||||
static int e1000_rar_set_vf(struct e1000_hw *, u8 *, u32);
|
||||
static s32 e1000_read_mac_addr_vf(struct e1000_hw *);
|
||||
|
||||
/**
|
||||
@ -159,7 +159,7 @@ void e1000_init_function_pointers_vf(struct e1000_hw *hw)
|
||||
* In addition, the MAC registers to access PHY/NVM don't exist so we don't
|
||||
* even want any SW to attempt to use them.
|
||||
**/
|
||||
static s32 e1000_acquire_vf(struct e1000_hw *hw)
|
||||
static s32 e1000_acquire_vf(struct e1000_hw E1000_UNUSEDARG *hw)
|
||||
{
|
||||
return -E1000_ERR_PHY;
|
||||
}
|
||||
@ -172,7 +172,7 @@ static s32 e1000_acquire_vf(struct e1000_hw *hw)
|
||||
* In addition, the MAC registers to access PHY/NVM don't exist so we don't
|
||||
* even want any SW to attempt to use them.
|
||||
**/
|
||||
static void e1000_release_vf(struct e1000_hw *hw)
|
||||
static void e1000_release_vf(struct e1000_hw E1000_UNUSEDARG *hw)
|
||||
{
|
||||
return;
|
||||
}
|
||||
@ -183,7 +183,7 @@ static void e1000_release_vf(struct e1000_hw *hw)
|
||||
*
|
||||
* Virtual functions cannot change link.
|
||||
**/
|
||||
static s32 e1000_setup_link_vf(struct e1000_hw *hw)
|
||||
static s32 e1000_setup_link_vf(struct e1000_hw E1000_UNUSEDARG *hw)
|
||||
{
|
||||
DEBUGFUNC("e1000_setup_link_vf");
|
||||
|
||||
@ -320,7 +320,8 @@ static s32 e1000_init_hw_vf(struct e1000_hw *hw)
|
||||
* @addr: pointer to the receive address
|
||||
* @index receive address array register
|
||||
**/
|
||||
static void e1000_rar_set_vf(struct e1000_hw *hw, u8 * addr, u32 index)
|
||||
static int e1000_rar_set_vf(struct e1000_hw *hw, u8 *addr,
|
||||
u32 E1000_UNUSEDARG index)
|
||||
{
|
||||
struct e1000_mbx_info *mbx = &hw->mbx;
|
||||
u32 msgbuf[3];
|
||||
@ -341,6 +342,8 @@ static void e1000_rar_set_vf(struct e1000_hw *hw, u8 * addr, u32 index)
|
||||
if (!ret_val &&
|
||||
(msgbuf[0] == (E1000_VF_SET_MAC_ADDR | E1000_VT_MSGTYPE_NACK)))
|
||||
e1000_read_mac_addr_vf(hw);
|
||||
|
||||
return E1000_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -208,7 +208,7 @@ struct e1000_mac_operations {
|
||||
s32 (*init_hw)(struct e1000_hw *);
|
||||
s32 (*setup_link)(struct e1000_hw *);
|
||||
void (*write_vfta)(struct e1000_hw *, u32, u32);
|
||||
void (*rar_set)(struct e1000_hw *, u8*, u32);
|
||||
int (*rar_set)(struct e1000_hw *, u8*, u32);
|
||||
s32 (*read_mac_addr)(struct e1000_hw *);
|
||||
};
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
/******************************************************************************
|
||||
|
||||
Copyright (c) 2001-2013, Intel Corporation
|
||||
Copyright (c) 2001-2014, Intel Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -96,7 +96,7 @@ int em_display_debug_stats = 0;
|
||||
/*********************************************************************
|
||||
* Driver version:
|
||||
*********************************************************************/
|
||||
char em_driver_version[] = "7.3.8";
|
||||
char em_driver_version[] = "7.4.2";
|
||||
|
||||
/*********************************************************************
|
||||
* PCI Device ID Table
|
||||
@ -180,6 +180,10 @@ static em_vendor_info_t em_vendor_info_array[] =
|
||||
PCI_ANY_ID, PCI_ANY_ID, 0},
|
||||
{ 0x8086, E1000_DEV_ID_PCH_LPTLP_I218_V,
|
||||
PCI_ANY_ID, PCI_ANY_ID, 0},
|
||||
{ 0x8086, E1000_DEV_ID_PCH_I218_LM2, PCI_ANY_ID, PCI_ANY_ID, 0},
|
||||
{ 0x8086, E1000_DEV_ID_PCH_I218_V2, PCI_ANY_ID, PCI_ANY_ID, 0},
|
||||
{ 0x8086, E1000_DEV_ID_PCH_I218_LM3, PCI_ANY_ID, PCI_ANY_ID, 0},
|
||||
{ 0x8086, E1000_DEV_ID_PCH_I218_V3, PCI_ANY_ID, PCI_ANY_ID, 0},
|
||||
/* required last entry */
|
||||
{ 0, 0, 0, 0, 0}
|
||||
};
|
||||
@ -698,6 +702,9 @@ em_attach(device_t dev)
|
||||
goto err_late;
|
||||
}
|
||||
|
||||
/* Disable ULP support */
|
||||
e1000_disable_ulp_lpt_lp(hw, TRUE);
|
||||
|
||||
/*
|
||||
** Do interrupt configuration
|
||||
*/
|
||||
|
Loading…
Reference in New Issue
Block a user