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

e1000: remove unused functions

Browse Source 
after removal of pcie, need to remove some unnecessary functions

Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Signed-off-by: Don Skidmore <donald.c.skidmore@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Jesse Brandeburg 2009-09-25 12:16:39 +00:00 committed by David S. Miller
parent 1532ecea1d
commit 282b177782
2 changed files with 2 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
drivers/net/e1000/e1000_hw.c
View File

@ -33,9 +33,6 @@
#include "e1000_hw.h" #include "e1000_hw.h"
static s32 e1000_swfw_sync_acquire(struct e1000_hw *hw, u16 mask);
static void e1000_swfw_sync_release(struct e1000_hw *hw, u16 mask);
static s32 e1000_check_downshift(struct e1000_hw *hw); static s32 e1000_check_downshift(struct e1000_hw *hw);
static s32 e1000_check_polarity(struct e1000_hw *hw, static s32 e1000_check_polarity(struct e1000_hw *hw,
e1000_rev_polarity *polarity); e1000_rev_polarity *polarity);
@ -48,7 +45,6 @@ static s32 e1000_detect_gig_phy(struct e1000_hw *hw);
static s32 e1000_get_auto_rd_done(struct e1000_hw *hw); static s32 e1000_get_auto_rd_done(struct e1000_hw *hw);
static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length, static s32 e1000_get_cable_length(struct e1000_hw *hw, u16 *min_length,
u16 *max_length); u16 *max_length);
static s32 e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw);
static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw); static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);
static s32 e1000_id_led_init(struct e1000_hw *hw); static s32 e1000_id_led_init(struct e1000_hw *hw);
static void e1000_init_rx_addrs(struct e1000_hw *hw); static void e1000_init_rx_addrs(struct e1000_hw *hw);
@ -61,7 +57,6 @@ static s32 e1000_write_eeprom_eewr(struct e1000_hw *hw, u16 offset, u16 words,
static s32 e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd); static s32 e1000_poll_eerd_eewr_done(struct e1000_hw *hw, int eerd);
static s32 e1000_phy_m88_get_info(struct e1000_hw *hw, static s32 e1000_phy_m88_get_info(struct e1000_hw *hw,
struct e1000_phy_info *phy_info); struct e1000_phy_info *phy_info);
static void e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw);
static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active); static s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active);
static s32 e1000_wait_autoneg(struct e1000_hw *hw); static s32 e1000_wait_autoneg(struct e1000_hw *hw);
static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value); static void e1000_write_reg_io(struct e1000_hw *hw, u32 offset, u32 value);
@ -2607,70 +2602,6 @@ static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
return data; return data;
} }
static s32 e1000_swfw_sync_acquire(struct e1000_hw *hw, u16 mask)
{
u32 swfw_sync = 0;
u32 swmask = mask;
u32 fwmask = mask << 16;
s32 timeout = 200;
DEBUGFUNC("e1000_swfw_sync_acquire");
if (!hw->swfw_sync_present)
return e1000_get_hw_eeprom_semaphore(hw);
while (timeout) {
if (e1000_get_hw_eeprom_semaphore(hw))
return -E1000_ERR_SWFW_SYNC;
swfw_sync = er32(SW_FW_SYNC);
if (!(swfw_sync & (fwmask | swmask))) {
break;
}
/* firmware currently using resource (fwmask) */
/* or other software thread currently using resource (swmask) */
e1000_put_hw_eeprom_semaphore(hw);
mdelay(5);
timeout--;
}
if (!timeout) {
DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
return -E1000_ERR_SWFW_SYNC;
}
swfw_sync |= swmask;
ew32(SW_FW_SYNC, swfw_sync);
e1000_put_hw_eeprom_semaphore(hw);
return E1000_SUCCESS;
}
static void e1000_swfw_sync_release(struct e1000_hw *hw, u16 mask)
{
u32 swfw_sync;
u32 swmask = mask;
DEBUGFUNC("e1000_swfw_sync_release");
if (!hw->swfw_sync_present) {
e1000_put_hw_eeprom_semaphore(hw);
return;
}
/* if (e1000_get_hw_eeprom_semaphore(hw))
* return -E1000_ERR_SWFW_SYNC; */
while (e1000_get_hw_eeprom_semaphore(hw) != E1000_SUCCESS);
/* empty */
swfw_sync = er32(SW_FW_SYNC);
swfw_sync &= ~swmask;
ew32(SW_FW_SYNC, swfw_sync);
e1000_put_hw_eeprom_semaphore(hw);
}
/***************************************************************************** /*****************************************************************************
* Reads the value from a PHY register, if the value is on a specific non zero * Reads the value from a PHY register, if the value is on a specific non zero
* page, sets the page first. * page, sets the page first.
@ -2680,28 +2611,19 @@ static void e1000_swfw_sync_release(struct e1000_hw *hw, u16 mask)
s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data) s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data)
{ {
u32 ret_val; u32 ret_val;
u16 swfw;
DEBUGFUNC("e1000_read_phy_reg"); DEBUGFUNC("e1000_read_phy_reg");
swfw = E1000_SWFW_PHY0_SM;
if (e1000_swfw_sync_acquire(hw, swfw))
return -E1000_ERR_SWFW_SYNC;
if ((hw->phy_type == e1000_phy_igp) && if ((hw->phy_type == e1000_phy_igp) &&
(reg_addr > MAX_PHY_MULTI_PAGE_REG)) { (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT, ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
(u16)reg_addr); (u16)reg_addr);
if (ret_val) { if (ret_val)
e1000_swfw_sync_release(hw, swfw);
return ret_val; return ret_val;
} }
}
ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr, ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
phy_data); phy_data);
e1000_swfw_sync_release(hw, swfw);
return ret_val; return ret_val;
} }
@ -2787,28 +2709,20 @@ static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data) s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data)
{ {
u32 ret_val; u32 ret_val;
u16 swfw;
DEBUGFUNC("e1000_write_phy_reg"); DEBUGFUNC("e1000_write_phy_reg");
swfw = E1000_SWFW_PHY0_SM;
if (e1000_swfw_sync_acquire(hw, swfw))
return -E1000_ERR_SWFW_SYNC;
if ((hw->phy_type == e1000_phy_igp) && if ((hw->phy_type == e1000_phy_igp) &&
(reg_addr > MAX_PHY_MULTI_PAGE_REG)) { (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT, ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
(u16)reg_addr); (u16)reg_addr);
if (ret_val) { if (ret_val)
e1000_swfw_sync_release(hw, swfw);
return ret_val; return ret_val;
} }
}
ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr, ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
phy_data); phy_data);
e1000_swfw_sync_release(hw, swfw);
return ret_val; return ret_val;
} }
@ -2883,18 +2797,12 @@ s32 e1000_phy_hw_reset(struct e1000_hw *hw)
u32 ctrl, ctrl_ext; u32 ctrl, ctrl_ext;
u32 led_ctrl; u32 led_ctrl;
s32 ret_val; s32 ret_val;
u16 swfw;
DEBUGFUNC("e1000_phy_hw_reset"); DEBUGFUNC("e1000_phy_hw_reset");
DEBUGOUT("Resetting Phy...\n"); DEBUGOUT("Resetting Phy...\n");
if (hw->mac_type > e1000_82543) { if (hw->mac_type > e1000_82543) {
swfw = E1000_SWFW_PHY0_SM;
if (e1000_swfw_sync_acquire(hw, swfw)) {
DEBUGOUT("Unable to acquire swfw sync\n");
return -E1000_ERR_SWFW_SYNC;
}
/* Read the device control register and assert the E1000_CTRL_PHY_RST /* Read the device control register and assert the E1000_CTRL_PHY_RST
* bit. Then, take it out of reset. * bit. Then, take it out of reset.
* For e1000 hardware, we delay for 10ms between the assert * For e1000 hardware, we delay for 10ms between the assert
@ -2908,8 +2816,6 @@ s32 e1000_phy_hw_reset(struct e1000_hw *hw)
ew32(CTRL, ctrl); ew32(CTRL, ctrl);
E1000_WRITE_FLUSH(); E1000_WRITE_FLUSH();
e1000_swfw_sync_release(hw, swfw);
} else { } else {
/* Read the Extended Device Control Register, assert the PHY_RESET_DIR /* Read the Extended Device Control Register, assert the PHY_RESET_DIR
* bit to put the PHY into reset. Then, take it out of reset. * bit to put the PHY into reset. Then, take it out of reset.
@ -3515,8 +3421,6 @@ static s32 e1000_acquire_eeprom(struct e1000_hw *hw)
DEBUGFUNC("e1000_acquire_eeprom"); DEBUGFUNC("e1000_acquire_eeprom");
if (e1000_swfw_sync_acquire(hw, E1000_SWFW_EEP_SM))
return -E1000_ERR_SWFW_SYNC;
eecd = er32(EECD); eecd = er32(EECD);
/* Request EEPROM Access */ /* Request EEPROM Access */
@ -3534,7 +3438,6 @@ static s32 e1000_acquire_eeprom(struct e1000_hw *hw)
eecd &= ~E1000_EECD_REQ; eecd &= ~E1000_EECD_REQ;
ew32(EECD, eecd); ew32(EECD, eecd);
DEBUGOUT("Could not acquire EEPROM grant\n"); DEBUGOUT("Could not acquire EEPROM grant\n");
e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
return -E1000_ERR_EEPROM; return -E1000_ERR_EEPROM;
} }
} }
@ -3653,8 +3556,6 @@ static void e1000_release_eeprom(struct e1000_hw *hw)
eecd &= ~E1000_EECD_REQ; eecd &= ~E1000_EECD_REQ;
ew32(EECD, eecd); ew32(EECD, eecd);
} }
e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
} }
/****************************************************************************** /******************************************************************************
@ -3847,8 +3748,6 @@ static s32 e1000_write_eeprom_eewr(struct e1000_hw *hw, u16 offset, u16 words,
u32 i = 0; u32 i = 0;
s32 error = 0; s32 error = 0;
if (e1000_swfw_sync_acquire(hw, E1000_SWFW_EEP_SM))
return -E1000_ERR_SWFW_SYNC;
for (i = 0; i < words; i++) { for (i = 0; i < words; i++) {
register_value = (data[i] << E1000_EEPROM_RW_REG_DATA) | register_value = (data[i] << E1000_EEPROM_RW_REG_DATA) |
@ -3869,7 +3768,6 @@ static s32 e1000_write_eeprom_eewr(struct e1000_hw *hw, u16 offset, u16 words,
} }
} }
e1000_swfw_sync_release(hw, E1000_SWFW_EEP_SM);
return error; return error;
} }
@ -5681,71 +5579,3 @@ static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw)
mdelay(10); mdelay(10);
return E1000_SUCCESS; return E1000_SUCCESS;
} }
/***************************************************************************
*
* Using the combination of SMBI and SWESMBI semaphore bits when resetting
* adapter or Eeprom access.
*
* hw: Struct containing variables accessed by shared code
*
* returns: - E1000_ERR_EEPROM if fail to access EEPROM.
* E1000_SUCCESS at any other case.
*
***************************************************************************/
static s32 e1000_get_hw_eeprom_semaphore(struct e1000_hw *hw)
{
s32 timeout;
u32 swsm;
DEBUGFUNC("e1000_get_hw_eeprom_semaphore");
if (!hw->eeprom_semaphore_present)
return E1000_SUCCESS;
/* Get the FW semaphore. */
timeout = hw->eeprom.word_size + 1;
while (timeout) {
swsm = er32(SWSM);
swsm |= E1000_SWSM_SWESMBI;
ew32(SWSM, swsm);
/* if we managed to set the bit we got the semaphore. */
swsm = er32(SWSM);
if (swsm & E1000_SWSM_SWESMBI)
break;
udelay(50);
timeout--;
}
if (!timeout) {
/* Release semaphores */
e1000_put_hw_eeprom_semaphore(hw);
DEBUGOUT("Driver can't access the Eeprom - SWESMBI bit is set.\n");
return -E1000_ERR_EEPROM;
}
return E1000_SUCCESS;
}
/***************************************************************************
* This function clears HW semaphore bits.
*
* hw: Struct containing variables accessed by shared code
*
* returns: - None.
*
***************************************************************************/
static void e1000_put_hw_eeprom_semaphore(struct e1000_hw *hw)
{
u32 swsm;
DEBUGFUNC("e1000_put_hw_eeprom_semaphore");
if (!hw->eeprom_semaphore_present)
return;
swsm = er32(SWSM);
swsm &= ~(E1000_SWSM_SWESMBI);
ew32(SWSM, swsm);
}

2
drivers/net/e1000/e1000_hw.h
View File

@ -284,7 +284,6 @@ typedef enum {
#define E1000_ERR_MASTER_REQUESTS_PENDING 10 #define E1000_ERR_MASTER_REQUESTS_PENDING 10
#define E1000_ERR_HOST_INTERFACE_COMMAND 11 #define E1000_ERR_HOST_INTERFACE_COMMAND 11
#define E1000_BLK_PHY_RESET 12 #define E1000_BLK_PHY_RESET 12
#define E1000_ERR_SWFW_SYNC 13
#define E1000_BYTE_SWAP_WORD(_value) ((((_value) & 0x00ff) << 8) | \ #define E1000_BYTE_SWAP_WORD(_value) ((((_value) & 0x00ff) << 8) | \
(((_value) & 0xff00) >> 8)) (((_value) & 0xff00) >> 8))
@ -1327,7 +1326,6 @@ struct e1000_hw {
e1000_ffe_config ffe_config_state; e1000_ffe_config ffe_config_state;
u32 asf_firmware_present; u32 asf_firmware_present;
u32 eeprom_semaphore_present; u32 eeprom_semaphore_present;
u32 swfw_sync_present;
unsigned long io_base; unsigned long io_base;
u32 phy_id; u32 phy_id;
u32 phy_revision; u32 phy_revision;