microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

e1000e: reorganize PHY and flow control interface 

This reorganization moves the PHY status into a separate
struct. Flow Control setup is moved into this struct as well
and frame size away from here into the adapter struct where its
inly use is.

The post-link-up code is now a separate function and moved out
of the watchdog function itself. This allows us to track the
es2lan restart issue a bit easier.

Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Signed-off-by: Bruce Allan <bruce.w.allan@intel.com>
Signed-off-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
This commit is contained in:
Jeff Kirsher 2008-03-28 09:15:16 -07:00 коммит произвёл Jeff Garzik
Родитель e2de3eb69c
Коммит 318a94d689
9 изменённых файлов: 205 добавлений и 159 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

12
drivers/net/e1000e/82571.c
Просмотреть файл

@ -75,7 +75,7 @@ static s32 e1000_init_phy_params_82571(struct e1000_hw *hw)
struct e1000_phy_info *phy = &hw->phy; struct e1000_phy_info *phy = &hw->phy;
s32 ret_val; s32 ret_val;
if (hw->media_type != e1000_media_type_copper) { if (hw->phy.media_type != e1000_media_type_copper) {
phy->type = e1000_phy_none; phy->type = e1000_phy_none;
return 0; return 0;
} }
@ -195,16 +195,16 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
case E1000_DEV_ID_82571EB_FIBER: case E1000_DEV_ID_82571EB_FIBER:
case E1000_DEV_ID_82572EI_FIBER: case E1000_DEV_ID_82572EI_FIBER:
case E1000_DEV_ID_82571EB_QUAD_FIBER: case E1000_DEV_ID_82571EB_QUAD_FIBER:
hw->media_type = e1000_media_type_fiber; hw->phy.media_type = e1000_media_type_fiber;
break; break;
case E1000_DEV_ID_82571EB_SERDES: case E1000_DEV_ID_82571EB_SERDES:
case E1000_DEV_ID_82572EI_SERDES: case E1000_DEV_ID_82572EI_SERDES:
case E1000_DEV_ID_82571EB_SERDES_DUAL: case E1000_DEV_ID_82571EB_SERDES_DUAL:
case E1000_DEV_ID_82571EB_SERDES_QUAD: case E1000_DEV_ID_82571EB_SERDES_QUAD:
hw->media_type = e1000_media_type_internal_serdes; hw->phy.media_type = e1000_media_type_internal_serdes;
break; break;
default: default:
hw->media_type = e1000_media_type_copper; hw->phy.media_type = e1000_media_type_copper;
break; break;
} }
@ -216,7 +216,7 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
mac->arc_subsystem_valid = (er32(FWSM) & E1000_FWSM_MODE_MASK) ? 1 : 0; mac->arc_subsystem_valid = (er32(FWSM) & E1000_FWSM_MODE_MASK) ? 1 : 0;
/* check for link */ /* check for link */
switch (hw->media_type) { switch (hw->phy.media_type) {
case e1000_media_type_copper: case e1000_media_type_copper:
func->setup_physical_interface = e1000_setup_copper_link_82571; func->setup_physical_interface = e1000_setup_copper_link_82571;
func->check_for_link = e1000e_check_for_copper_link; func->check_for_link = e1000e_check_for_copper_link;
@ -1015,7 +1015,7 @@ static s32 e1000_setup_link_82571(struct e1000_hw *hw)
* set it to full. * set it to full.
*/ */
if (hw->mac.type == e1000_82573) if (hw->mac.type == e1000_82573)
hw->mac.fc = e1000_fc_full; hw->fc.type = e1000_fc_full;
return e1000e_setup_link(hw); return e1000e_setup_link(hw);
} }

5
drivers/net/e1000e/e1000.h
Просмотреть файл

@ -234,6 +234,8 @@ struct e1000_adapter {
unsigned int rx_ps_pages; unsigned int rx_ps_pages;
u16 rx_ps_bsize0; u16 rx_ps_bsize0;
u32 max_frame_size;
u32 min_frame_size;
/* OS defined structs */ /* OS defined structs */
struct net_device *netdev; struct net_device *netdev;
@ -258,7 +260,7 @@ struct e1000_adapter {
u32 wol; u32 wol;
u32 pba; u32 pba;
u8 fc_autoneg; bool fc_autoneg;
unsigned long led_status; unsigned long led_status;
@ -305,6 +307,7 @@ struct e1000_info {
#define FLAG_MSI_ENABLED (1 << 27) #define FLAG_MSI_ENABLED (1 << 27)
#define FLAG_RX_CSUM_ENABLED (1 << 28) #define FLAG_RX_CSUM_ENABLED (1 << 28)
#define FLAG_TSO_FORCE (1 << 29) #define FLAG_TSO_FORCE (1 << 29)
#define FLAG_RX_RESTART_NOW (1 << 30)
#define E1000_RX_DESC_PS(R, i) \ #define E1000_RX_DESC_PS(R, i) \
(&(((union e1000_rx_desc_packet_split *)((R).desc))[i])) (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))

14
drivers/net/e1000e/es2lan.c
Просмотреть файл

@ -119,7 +119,7 @@ static s32 e1000_init_phy_params_80003es2lan(struct e1000_hw *hw)
struct e1000_phy_info *phy = &hw->phy; struct e1000_phy_info *phy = &hw->phy;
s32 ret_val; s32 ret_val;
if (hw->media_type != e1000_media_type_copper) { if (hw->phy.media_type != e1000_media_type_copper) {
phy->type = e1000_phy_none; phy->type = e1000_phy_none;
return 0; return 0;
} }
@ -198,10 +198,10 @@ static s32 e1000_init_mac_params_80003es2lan(struct e1000_adapter *adapter)
/* Set media type */ /* Set media type */
switch (adapter->pdev->device) { switch (adapter->pdev->device) {
case E1000_DEV_ID_80003ES2LAN_SERDES_DPT: case E1000_DEV_ID_80003ES2LAN_SERDES_DPT:
hw->media_type = e1000_media_type_internal_serdes; hw->phy.media_type = e1000_media_type_internal_serdes;
break; break;
default: default:
hw->media_type = e1000_media_type_copper; hw->phy.media_type = e1000_media_type_copper;
break; break;
} }
@ -213,7 +213,7 @@ static s32 e1000_init_mac_params_80003es2lan(struct e1000_adapter *adapter)
mac->arc_subsystem_valid = (er32(FWSM) & E1000_FWSM_MODE_MASK) ? 1 : 0; mac->arc_subsystem_valid = (er32(FWSM) & E1000_FWSM_MODE_MASK) ? 1 : 0;
/* check for link */ /* check for link */
switch (hw->media_type) { switch (hw->phy.media_type) {
case e1000_media_type_copper: case e1000_media_type_copper:
func->setup_physical_interface = e1000_setup_copper_link_80003es2lan; func->setup_physical_interface = e1000_setup_copper_link_80003es2lan;
func->check_for_link = e1000e_check_for_copper_link; func->check_for_link = e1000e_check_for_copper_link;
@ -591,7 +591,7 @@ static s32 e1000_phy_force_speed_duplex_80003es2lan(struct e1000_hw *hw)
udelay(1); udelay(1);
if (hw->phy.wait_for_link) { if (hw->phy.autoneg_wait_to_complete) {
hw_dbg(hw, "Waiting for forced speed/duplex link " hw_dbg(hw, "Waiting for forced speed/duplex link "
"on GG82563 phy.\n"); "on GG82563 phy.\n");
@ -682,7 +682,7 @@ static s32 e1000_get_link_up_info_80003es2lan(struct e1000_hw *hw, u16 *speed,
{ {
s32 ret_val; s32 ret_val;
if (hw->media_type == e1000_media_type_copper) { if (hw->phy.media_type == e1000_media_type_copper) {
ret_val = e1000e_get_speed_and_duplex_copper(hw, ret_val = e1000e_get_speed_and_duplex_copper(hw,
speed, speed,
duplex); duplex);
@ -854,7 +854,7 @@ static void e1000_initialize_hw_bits_80003es2lan(struct e1000_hw *hw)
/* Transmit Arbitration Control 0 */ /* Transmit Arbitration Control 0 */
reg = er32(TARC0); reg = er32(TARC0);
reg &= ~(0xF << 27); /* 30:27 */ reg &= ~(0xF << 27); /* 30:27 */
if (hw->media_type != e1000_media_type_copper) if (hw->phy.media_type != e1000_media_type_copper)
reg &= ~(1 << 20); reg &= ~(1 << 20);
ew32(TARC0, reg); ew32(TARC0, reg);

64
drivers/net/e1000e/ethtool.c
Просмотреть файл

@ -111,7 +111,7 @@ static int e1000_get_settings(struct net_device *netdev,
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
u32 status; u32 status;
if (hw->media_type == e1000_media_type_copper) { if (hw->phy.media_type == e1000_media_type_copper) {
ecmd->supported = (SUPPORTED_10baseT_Half | ecmd->supported = (SUPPORTED_10baseT_Half |
SUPPORTED_10baseT_Full | SUPPORTED_10baseT_Full |
@ -165,7 +165,7 @@ static int e1000_get_settings(struct net_device *netdev,
ecmd->duplex = -1; ecmd->duplex = -1;
} }
ecmd->autoneg = ((hw->media_type == e1000_media_type_fiber) || ecmd->autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE; hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
return 0; return 0;
} }
@ -187,7 +187,7 @@ static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)
mac->autoneg = 0; mac->autoneg = 0;
/* Fiber NICs only allow 1000 gbps Full duplex */ /* Fiber NICs only allow 1000 gbps Full duplex */
if ((adapter->hw.media_type == e1000_media_type_fiber) && if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
spddplx != (SPEED_1000 + DUPLEX_FULL)) { spddplx != (SPEED_1000 + DUPLEX_FULL)) {
ndev_err(adapter->netdev, "Unsupported Speed/Duplex " ndev_err(adapter->netdev, "Unsupported Speed/Duplex "
"configuration\n"); "configuration\n");
@ -241,7 +241,7 @@ static int e1000_set_settings(struct net_device *netdev,
if (ecmd->autoneg == AUTONEG_ENABLE) { if (ecmd->autoneg == AUTONEG_ENABLE) {
hw->mac.autoneg = 1; hw->mac.autoneg = 1;
if (hw->media_type == e1000_media_type_fiber) if (hw->phy.media_type == e1000_media_type_fiber)
hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full | hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
ADVERTISED_FIBRE | ADVERTISED_FIBRE |
ADVERTISED_Autoneg; ADVERTISED_Autoneg;
@ -250,6 +250,8 @@ static int e1000_set_settings(struct net_device *netdev,
ADVERTISED_TP | ADVERTISED_TP |
ADVERTISED_Autoneg; ADVERTISED_Autoneg;
ecmd->advertising = hw->phy.autoneg_advertised; ecmd->advertising = hw->phy.autoneg_advertised;
if (adapter->fc_autoneg)
hw->fc.original_type = e1000_fc_default;
} else { } else {
if (e1000_set_spd_dplx(adapter, ecmd->speed + ecmd->duplex)) { if (e1000_set_spd_dplx(adapter, ecmd->speed + ecmd->duplex)) {
clear_bit(__E1000_RESETTING, &adapter->state); clear_bit(__E1000_RESETTING, &adapter->state);
@ -279,11 +281,11 @@ static void e1000_get_pauseparam(struct net_device *netdev,
pause->autoneg = pause->autoneg =
(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
if (hw->mac.fc == e1000_fc_rx_pause) { if (hw->fc.type == e1000_fc_rx_pause) {
pause->rx_pause = 1; pause->rx_pause = 1;
} else if (hw->mac.fc == e1000_fc_tx_pause) { } else if (hw->fc.type == e1000_fc_tx_pause) {
pause->tx_pause = 1; pause->tx_pause = 1;
} else if (hw->mac.fc == e1000_fc_full) { } else if (hw->fc.type == e1000_fc_full) {
pause->rx_pause = 1; pause->rx_pause = 1;
pause->tx_pause = 1; pause->tx_pause = 1;
} }
@ -302,18 +304,18 @@ static int e1000_set_pauseparam(struct net_device *netdev,
msleep(1); msleep(1);
if (pause->rx_pause && pause->tx_pause) if (pause->rx_pause && pause->tx_pause)
hw->mac.fc = e1000_fc_full; hw->fc.type = e1000_fc_full;
else if (pause->rx_pause && !pause->tx_pause) else if (pause->rx_pause && !pause->tx_pause)
hw->mac.fc = e1000_fc_rx_pause; hw->fc.type = e1000_fc_rx_pause;
else if (!pause->rx_pause && pause->tx_pause) else if (!pause->rx_pause && pause->tx_pause)
hw->mac.fc = e1000_fc_tx_pause; hw->fc.type = e1000_fc_tx_pause;
else if (!pause->rx_pause && !pause->tx_pause) else if (!pause->rx_pause && !pause->tx_pause)
hw->mac.fc = e1000_fc_none; hw->fc.type = e1000_fc_none;
hw->mac.original_fc = hw->mac.fc; hw->fc.original_type = hw->fc.type;
if (adapter->fc_autoneg == AUTONEG_ENABLE) { if (adapter->fc_autoneg == AUTONEG_ENABLE) {
hw->mac.fc = e1000_fc_default; hw->fc.type = e1000_fc_default;
if (netif_running(adapter->netdev)) { if (netif_running(adapter->netdev)) {
e1000e_down(adapter); e1000e_down(adapter);
e1000e_up(adapter); e1000e_up(adapter);
@ -321,7 +323,7 @@ static int e1000_set_pauseparam(struct net_device *netdev,
e1000e_reset(adapter); e1000e_reset(adapter);
} }
} else { } else {
retval = ((hw->media_type == e1000_media_type_fiber) ? retval = ((hw->phy.media_type == e1000_media_type_fiber) ?
hw->mac.ops.setup_link(hw) : e1000e_force_mac_fc(hw)); hw->mac.ops.setup_link(hw) : e1000e_force_mac_fc(hw));
} }
@ -1187,21 +1189,21 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
u32 ctrl_reg = 0; u32 ctrl_reg = 0;
u32 stat_reg = 0; u32 stat_reg = 0;
adapter->hw.mac.autoneg = 0; hw->mac.autoneg = 0;
if (adapter->hw.phy.type == e1000_phy_m88) { if (hw->phy.type == e1000_phy_m88) {
/* Auto-MDI/MDIX Off */ /* Auto-MDI/MDIX Off */
e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808); e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);
/* reset to update Auto-MDI/MDIX */ /* reset to update Auto-MDI/MDIX */
e1e_wphy(hw, PHY_CONTROL, 0x9140); e1e_wphy(hw, PHY_CONTROL, 0x9140);
/* autoneg off */ /* autoneg off */
e1e_wphy(hw, PHY_CONTROL, 0x8140); e1e_wphy(hw, PHY_CONTROL, 0x8140);
} else if (adapter->hw.phy.type == e1000_phy_gg82563) } else if (hw->phy.type == e1000_phy_gg82563)
e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC); e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC);
ctrl_reg = er32(CTRL); ctrl_reg = er32(CTRL);
if (adapter->hw.phy.type == e1000_phy_ife) { if (hw->phy.type == e1000_phy_ife) {
/* force 100, set loopback */ /* force 100, set loopback */
e1e_wphy(hw, PHY_CONTROL, 0x6100); e1e_wphy(hw, PHY_CONTROL, 0x6100);
@ -1224,8 +1226,8 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
E1000_CTRL_FD); /* Force Duplex to FULL */ E1000_CTRL_FD); /* Force Duplex to FULL */
} }
if (adapter->hw.media_type == e1000_media_type_copper && if (hw->phy.media_type == e1000_media_type_copper &&
adapter->hw.phy.type == e1000_phy_m88) { hw->phy.type == e1000_phy_m88) {
ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */ ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
} else { } else {
/* /*
@ -1243,7 +1245,7 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
* Disable the receiver on the PHY so when a cable is plugged in, the * Disable the receiver on the PHY so when a cable is plugged in, the
* PHY does not begin to autoneg when a cable is reconnected to the NIC. * PHY does not begin to autoneg when a cable is reconnected to the NIC.
*/ */
if (adapter->hw.phy.type == e1000_phy_m88) if (hw->phy.type == e1000_phy_m88)
e1000_phy_disable_receiver(adapter); e1000_phy_disable_receiver(adapter);
udelay(500); udelay(500);
@ -1333,8 +1335,8 @@ static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
u32 rctl; u32 rctl;
if (hw->media_type == e1000_media_type_fiber || if (hw->phy.media_type == e1000_media_type_fiber ||
hw->media_type == e1000_media_type_internal_serdes) { hw->phy.media_type == e1000_media_type_internal_serdes) {
switch (hw->mac.type) { switch (hw->mac.type) {
case e1000_80003es2lan: case e1000_80003es2lan:
return e1000_set_es2lan_mac_loopback(adapter); return e1000_set_es2lan_mac_loopback(adapter);
@ -1349,7 +1351,7 @@ static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
ew32(RCTL, rctl); ew32(RCTL, rctl);
return 0; return 0;
} }
} else if (hw->media_type == e1000_media_type_copper) { } else if (hw->phy.media_type == e1000_media_type_copper) {
return e1000_integrated_phy_loopback(adapter); return e1000_integrated_phy_loopback(adapter);
} }
@ -1368,8 +1370,8 @@ static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
switch (hw->mac.type) { switch (hw->mac.type) {
case e1000_80003es2lan: case e1000_80003es2lan:
if (hw->media_type == e1000_media_type_fiber || if (hw->phy.media_type == e1000_media_type_fiber ||
hw->media_type == e1000_media_type_internal_serdes) { hw->phy.media_type == e1000_media_type_internal_serdes) {
/* restore CTRL_EXT, stealing space from tx_fifo_head */ /* restore CTRL_EXT, stealing space from tx_fifo_head */
ew32(CTRL_EXT, adapter->tx_fifo_head); ew32(CTRL_EXT, adapter->tx_fifo_head);
adapter->tx_fifo_head = 0; adapter->tx_fifo_head = 0;
@ -1377,8 +1379,8 @@ static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
/* fall through */ /* fall through */
case e1000_82571: case e1000_82571:
case e1000_82572: case e1000_82572:
if (hw->media_type == e1000_media_type_fiber || if (hw->phy.media_type == e1000_media_type_fiber ||
hw->media_type == e1000_media_type_internal_serdes) { hw->phy.media_type == e1000_media_type_internal_serdes) {
#define E1000_SERDES_LB_OFF 0x400 #define E1000_SERDES_LB_OFF 0x400
ew32(SCTL, E1000_SERDES_LB_OFF); ew32(SCTL, E1000_SERDES_LB_OFF);
msleep(10); msleep(10);
@ -1528,7 +1530,7 @@ static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
*data = 0; *data = 0;
if (hw->media_type == e1000_media_type_internal_serdes) { if (hw->phy.media_type == e1000_media_type_internal_serdes) {
int i = 0; int i = 0;
hw->mac.serdes_has_link = 0; hw->mac.serdes_has_link = 0;
@ -1624,9 +1626,9 @@ static void e1000_diag_test(struct net_device *netdev,
adapter->hw.mac.autoneg = autoneg; adapter->hw.mac.autoneg = autoneg;
/* force this routine to wait until autoneg complete/timeout */ /* force this routine to wait until autoneg complete/timeout */
adapter->hw.phy.wait_for_link = 1; adapter->hw.phy.autoneg_wait_to_complete = 1;
e1000e_reset(adapter); e1000e_reset(adapter);
adapter->hw.phy.wait_for_link = 0; adapter->hw.phy.autoneg_wait_to_complete = 0;
clear_bit(__E1000_TESTING, &adapter->state); clear_bit(__E1000_TESTING, &adapter->state);
if (if_running) if (if_running)

26
drivers/net/e1000e/hw.h
Просмотреть файл

@ -400,7 +400,7 @@ enum e1000_rev_polarity{
e1000_rev_polarity_undefined = 0xFF e1000_rev_polarity_undefined = 0xFF
}; };
enum e1000_fc_mode { enum e1000_fc_type {
e1000_fc_none = 0, e1000_fc_none = 0,
e1000_fc_rx_pause, e1000_fc_rx_pause,
e1000_fc_tx_pause, e1000_fc_tx_pause,
@ -727,16 +727,12 @@ struct e1000_mac_info {
u8 perm_addr[6]; u8 perm_addr[6];
enum e1000_mac_type type; enum e1000_mac_type type;
enum e1000_fc_mode fc;
enum e1000_fc_mode original_fc;
u32 collision_delta; u32 collision_delta;
u32 ledctl_default; u32 ledctl_default;
u32 ledctl_mode1; u32 ledctl_mode1;
u32 ledctl_mode2; u32 ledctl_mode2;
u32 max_frame_size;
u32 mc_filter_type; u32 mc_filter_type;
u32 min_frame_size;
u32 tx_packet_delta; u32 tx_packet_delta;
u32 txcw; u32 txcw;
@ -747,9 +743,6 @@ struct e1000_mac_info {
u16 ifs_step_size; u16 ifs_step_size;
u16 mta_reg_count; u16 mta_reg_count;
u16 rar_entry_count; u16 rar_entry_count;
u16 fc_high_water;
u16 fc_low_water;
u16 fc_pause_time;
u8 forced_speed_duplex; u8 forced_speed_duplex;
@ -779,6 +772,8 @@ struct e1000_phy_info {
u32 reset_delay_us; /* in usec */ u32 reset_delay_us; /* in usec */
u32 revision; u32 revision;
enum e1000_media_type media_type;
u16 autoneg_advertised; u16 autoneg_advertised;
u16 autoneg_mask; u16 autoneg_mask;
u16 cable_length; u16 cable_length;
@ -791,7 +786,7 @@ struct e1000_phy_info {
bool is_mdix; bool is_mdix;
bool polarity_correction; bool polarity_correction;
bool speed_downgraded; bool speed_downgraded;
bool wait_for_link; bool autoneg_wait_to_complete;
}; };
struct e1000_nvm_info { struct e1000_nvm_info {
@ -816,6 +811,16 @@ struct e1000_bus_info {
u16 func; u16 func;
}; };
struct e1000_fc_info {
u32 high_water; /* Flow control high-water mark */
u32 low_water; /* Flow control low-water mark */
u16 pause_time; /* Flow control pause timer */
bool send_xon; /* Flow control send XON */
bool strict_ieee; /* Strict IEEE mode */
enum e1000_fc_type type; /* Type of flow control */
enum e1000_fc_type original_type;
};
struct e1000_dev_spec_82571 { struct e1000_dev_spec_82571 {
bool laa_is_present; bool laa_is_present;
bool alt_mac_addr_is_present; bool alt_mac_addr_is_present;
@ -840,6 +845,7 @@ struct e1000_hw {
u8 __iomem *flash_address; u8 __iomem *flash_address;
struct e1000_mac_info mac; struct e1000_mac_info mac;
struct e1000_fc_info fc;
struct e1000_phy_info phy; struct e1000_phy_info phy;
struct e1000_nvm_info nvm; struct e1000_nvm_info nvm;
struct e1000_bus_info bus; struct e1000_bus_info bus;
@ -849,8 +855,6 @@ struct e1000_hw {
struct e1000_dev_spec_82571 e82571; struct e1000_dev_spec_82571 e82571;
struct e1000_dev_spec_ich8lan ich8lan; struct e1000_dev_spec_ich8lan ich8lan;
} dev_spec; } dev_spec;
enum e1000_media_type media_type;
}; };
#ifdef DEBUG #ifdef DEBUG

15
drivers/net/e1000e/ich8lan.c
Просмотреть файл

@ -298,7 +298,7 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_adapter *adapter)
struct e1000_mac_info *mac = &hw->mac; struct e1000_mac_info *mac = &hw->mac;
/* Set media type function pointer */ /* Set media type function pointer */
hw->media_type = e1000_media_type_copper; hw->phy.media_type = e1000_media_type_copper;
/* Set mta register count */ /* Set mta register count */
mac->mta_reg_count = 32; mac->mta_reg_count = 32;
@ -453,7 +453,7 @@ static s32 e1000_phy_force_speed_duplex_ich8lan(struct e1000_hw *hw)
udelay(1); udelay(1);
if (phy->wait_for_link) { if (phy->autoneg_wait_to_complete) {
hw_dbg(hw, "Waiting for forced speed/duplex link on IFE phy.\n"); hw_dbg(hw, "Waiting for forced speed/duplex link on IFE phy.\n");
ret_val = e1000e_phy_has_link_generic(hw, ret_val = e1000e_phy_has_link_generic(hw,
@ -1852,7 +1852,6 @@ static void e1000_initialize_hw_bits_ich8lan(struct e1000_hw *hw)
**/ **/
static s32 e1000_setup_link_ich8lan(struct e1000_hw *hw) static s32 e1000_setup_link_ich8lan(struct e1000_hw *hw)
{ {
struct e1000_mac_info *mac = &hw->mac;
s32 ret_val; s32 ret_val;
if (e1000_check_reset_block(hw)) if (e1000_check_reset_block(hw))
@ -1863,19 +1862,19 @@ static s32 e1000_setup_link_ich8lan(struct e1000_hw *hw)
* the default flow control setting, so we explicitly * the default flow control setting, so we explicitly
* set it to full. * set it to full.
*/ */
if (mac->fc == e1000_fc_default) if (hw->fc.type == e1000_fc_default)
mac->fc = e1000_fc_full; hw->fc.type = e1000_fc_full;
mac->original_fc = mac->fc; hw->fc.original_type = hw->fc.type;
hw_dbg(hw, "After fix-ups FlowControl is now = %x\n", mac->fc); hw_dbg(hw, "After fix-ups FlowControl is now = %x\n", hw->fc.type);
/* Continue to configure the copper link. */ /* Continue to configure the copper link. */
ret_val = e1000_setup_copper_link_ich8lan(hw); ret_val = e1000_setup_copper_link_ich8lan(hw);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
ew32(FCTTV, mac->fc_pause_time); ew32(FCTTV, hw->fc.pause_time);
return e1000e_set_fc_watermarks(hw); return e1000e_set_fc_watermarks(hw);
} }

65
drivers/net/e1000e/lib.c
Просмотреть файл

@ -603,7 +603,6 @@ s32 e1000e_check_for_serdes_link(struct e1000_hw *hw)
**/ **/
static s32 e1000_set_default_fc_generic(struct e1000_hw *hw) static s32 e1000_set_default_fc_generic(struct e1000_hw *hw)
{ {
struct e1000_mac_info *mac = &hw->mac;
s32 ret_val; s32 ret_val;
u16 nvm_data; u16 nvm_data;
@ -624,12 +623,12 @@ static s32 e1000_set_default_fc_generic(struct e1000_hw *hw)
} }
if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == 0) if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == 0)
mac->fc = e1000_fc_none; hw->fc.type = e1000_fc_none;
else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) ==
NVM_WORD0F_ASM_DIR) NVM_WORD0F_ASM_DIR)
mac->fc = e1000_fc_tx_pause; hw->fc.type = e1000_fc_tx_pause;
else else
mac->fc = e1000_fc_full; hw->fc.type = e1000_fc_full;
return 0; return 0;
} }
@ -660,7 +659,7 @@ s32 e1000e_setup_link(struct e1000_hw *hw)
* If flow control is set to default, set flow control based on * If flow control is set to default, set flow control based on
* the EEPROM flow control settings. * the EEPROM flow control settings.
*/ */
if (mac->fc == e1000_fc_default) { if (hw->fc.type == e1000_fc_default) {
ret_val = e1000_set_default_fc_generic(hw); ret_val = e1000_set_default_fc_generic(hw);
if (ret_val) if (ret_val)
return ret_val; return ret_val;
@ -671,9 +670,9 @@ s32 e1000e_setup_link(struct e1000_hw *hw)
* in case we get disconnected and then reconnected into a different * in case we get disconnected and then reconnected into a different
* hub or switch with different Flow Control capabilities. * hub or switch with different Flow Control capabilities.
*/ */
mac->original_fc = mac->fc; hw->fc.original_type = hw->fc.type;
hw_dbg(hw, "After fix-ups FlowControl is now = %x\n", mac->fc); hw_dbg(hw, "After fix-ups FlowControl is now = %x\n", hw->fc.type);
/* Call the necessary media_type subroutine to configure the link. */ /* Call the necessary media_type subroutine to configure the link. */
ret_val = mac->ops.setup_physical_interface(hw); ret_val = mac->ops.setup_physical_interface(hw);
@ -691,7 +690,7 @@ s32 e1000e_setup_link(struct e1000_hw *hw)
ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH); ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW); ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
ew32(FCTTV, mac->fc_pause_time); ew32(FCTTV, hw->fc.pause_time);
return e1000e_set_fc_watermarks(hw); return e1000e_set_fc_watermarks(hw);
} }
@ -725,7 +724,7 @@ static s32 e1000_commit_fc_settings_generic(struct e1000_hw *hw)
* do not support receiving pause frames). * do not support receiving pause frames).
* 3: Both Rx and Tx flow control (symmetric) are enabled. * 3: Both Rx and Tx flow control (symmetric) are enabled.
*/ */
switch (mac->fc) { switch (hw->fc.type) {
case e1000_fc_none: case e1000_fc_none:
/* Flow control completely disabled by a software over-ride. */ /* Flow control completely disabled by a software over-ride. */
txcw = (E1000_TXCW_ANE | E1000_TXCW_FD); txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
@ -857,7 +856,7 @@ s32 e1000e_setup_fiber_serdes_link(struct e1000_hw *hw)
* detect a signal. If we have a signal, then poll for a "Link-Up" * detect a signal. If we have a signal, then poll for a "Link-Up"
* indication. * indication.
*/ */
if (hw->media_type == e1000_media_type_internal_serdes || if (hw->phy.media_type == e1000_media_type_internal_serdes ||
(er32(CTRL) & E1000_CTRL_SWDPIN1)) { (er32(CTRL) & E1000_CTRL_SWDPIN1)) {
ret_val = e1000_poll_fiber_serdes_link_generic(hw); ret_val = e1000_poll_fiber_serdes_link_generic(hw);
} else { } else {
@ -898,7 +897,6 @@ void e1000e_config_collision_dist(struct e1000_hw *hw)
**/ **/
s32 e1000e_set_fc_watermarks(struct e1000_hw *hw) s32 e1000e_set_fc_watermarks(struct e1000_hw *hw)
{ {
struct e1000_mac_info *mac = &hw->mac;
u32 fcrtl = 0, fcrth = 0; u32 fcrtl = 0, fcrth = 0;
/* /*
@ -908,15 +906,15 @@ s32 e1000e_set_fc_watermarks(struct e1000_hw *hw)
* ability to transmit pause frames is not enabled, then these * ability to transmit pause frames is not enabled, then these
* registers will be set to 0. * registers will be set to 0.
*/ */
if (mac->fc & e1000_fc_tx_pause) { if (hw->fc.type & e1000_fc_tx_pause) {
/* /*
* We need to set up the Receive Threshold high and low water * We need to set up the Receive Threshold high and low water
* marks as well as (optionally) enabling the transmission of * marks as well as (optionally) enabling the transmission of
* XON frames. * XON frames.
*/ */
fcrtl = mac->fc_low_water; fcrtl = hw->fc.low_water;
fcrtl |= E1000_FCRTL_XONE; fcrtl |= E1000_FCRTL_XONE;
fcrth = mac->fc_high_water; fcrth = hw->fc.high_water;
} }
ew32(FCRTL, fcrtl); ew32(FCRTL, fcrtl);
ew32(FCRTH, fcrth); ew32(FCRTH, fcrth);
@ -936,7 +934,6 @@ s32 e1000e_set_fc_watermarks(struct e1000_hw *hw)
**/ **/
s32 e1000e_force_mac_fc(struct e1000_hw *hw) s32 e1000e_force_mac_fc(struct e1000_hw *hw)
{ {
struct e1000_mac_info *mac = &hw->mac;
u32 ctrl; u32 ctrl;
ctrl = er32(CTRL); ctrl = er32(CTRL);
@ -948,7 +945,7 @@ s32 e1000e_force_mac_fc(struct e1000_hw *hw)
* receive flow control. * receive flow control.
* *
* The "Case" statement below enables/disable flow control * The "Case" statement below enables/disable flow control
* according to the "mac->fc" parameter. * according to the "hw->fc.type" parameter.
* *
* The possible values of the "fc" parameter are: * The possible values of the "fc" parameter are:
* 0: Flow control is completely disabled * 0: Flow control is completely disabled
@ -959,9 +956,9 @@ s32 e1000e_force_mac_fc(struct e1000_hw *hw)
* 3: Both Rx and Tx flow control (symmetric) is enabled. * 3: Both Rx and Tx flow control (symmetric) is enabled.
* other: No other values should be possible at this point. * other: No other values should be possible at this point.
*/ */
hw_dbg(hw, "mac->fc = %u\n", mac->fc); hw_dbg(hw, "hw->fc.type = %u\n", hw->fc.type);
switch (mac->fc) { switch (hw->fc.type) {
case e1000_fc_none: case e1000_fc_none:
ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE)); ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
break; break;
@ -1009,11 +1006,11 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
* configuration of the MAC to match the "fc" parameter. * configuration of the MAC to match the "fc" parameter.
*/ */
if (mac->autoneg_failed) { if (mac->autoneg_failed) {
if (hw->media_type == e1000_media_type_fiber || if (hw->phy.media_type == e1000_media_type_fiber ||
hw->media_type == e1000_media_type_internal_serdes) hw->phy.media_type == e1000_media_type_internal_serdes)
ret_val = e1000e_force_mac_fc(hw); ret_val = e1000e_force_mac_fc(hw);
} else { } else {
if (hw->media_type == e1000_media_type_copper) if (hw->phy.media_type == e1000_media_type_copper)
ret_val = e1000e_force_mac_fc(hw); ret_val = e1000e_force_mac_fc(hw);
} }
@ -1028,7 +1025,7 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
* has completed, and if so, how the PHY and link partner has * has completed, and if so, how the PHY and link partner has
* flow control configured. * flow control configured.
*/ */
if ((hw->media_type == e1000_media_type_copper) && mac->autoneg) { if ((hw->phy.media_type == e1000_media_type_copper) && mac->autoneg) {
/* /*
* Read the MII Status Register and check to see if AutoNeg * Read the MII Status Register and check to see if AutoNeg
* has completed. We read this twice because this reg has * has completed. We read this twice because this reg has
@ -1105,11 +1102,11 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
* ONLY. Hence, we must now check to see if we need to * ONLY. Hence, we must now check to see if we need to
* turn OFF the TRANSMISSION of PAUSE frames. * turn OFF the TRANSMISSION of PAUSE frames.
*/ */
if (mac->original_fc == e1000_fc_full) { if (hw->fc.original_type == e1000_fc_full) {
mac->fc = e1000_fc_full; hw->fc.type = e1000_fc_full;
hw_dbg(hw, "Flow Control = FULL.\r\n"); hw_dbg(hw, "Flow Control = FULL.\r\n");
} else { } else {
mac->fc = e1000_fc_rx_pause; hw->fc.type = e1000_fc_rx_pause;
hw_dbg(hw, "Flow Control = " hw_dbg(hw, "Flow Control = "
"RX PAUSE frames only.\r\n"); "RX PAUSE frames only.\r\n");
} }
@ -1127,8 +1124,8 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
(mii_nway_adv_reg & NWAY_AR_ASM_DIR) && (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
(mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) { (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
mac->fc = e1000_fc_tx_pause; hw->fc.type = e1000_fc_tx_pause;
hw_dbg(hw, "Flow Control = TX PAUSE frames only.\r\n"); hw_dbg(hw, "Flow Control = Tx PAUSE frames only.\r\n");
} }
/* /*
* For transmitting PAUSE frames ONLY. * For transmitting PAUSE frames ONLY.
@ -1143,14 +1140,14 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
(mii_nway_adv_reg & NWAY_AR_ASM_DIR) && (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
!(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
(mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) { (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
mac->fc = e1000_fc_rx_pause; hw->fc.type = e1000_fc_rx_pause;
hw_dbg(hw, "Flow Control = RX PAUSE frames only.\r\n"); hw_dbg(hw, "Flow Control = Rx PAUSE frames only.\r\n");
} else { } else {
/* /*
* Per the IEEE spec, at this point flow control * Per the IEEE spec, at this point flow control
* should be disabled. * should be disabled.
*/ */
mac->fc = e1000_fc_none; hw->fc.type = e1000_fc_none;
hw_dbg(hw, "Flow Control = NONE.\r\n"); hw_dbg(hw, "Flow Control = NONE.\r\n");
} }
@ -1166,7 +1163,7 @@ s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
} }
if (duplex == HALF_DUPLEX) if (duplex == HALF_DUPLEX)
mac->fc = e1000_fc_none; hw->fc.type = e1000_fc_none;
/* /*
* Now we call a subroutine to actually force the MAC * Now we call a subroutine to actually force the MAC
@ -1436,7 +1433,7 @@ s32 e1000e_blink_led(struct e1000_hw *hw)
u32 ledctl_blink = 0; u32 ledctl_blink = 0;
u32 i; u32 i;
if (hw->media_type == e1000_media_type_fiber) { if (hw->phy.media_type == e1000_media_type_fiber) {
/* always blink LED0 for PCI-E fiber */ /* always blink LED0 for PCI-E fiber */
ledctl_blink = E1000_LEDCTL_LED0_BLINK | ledctl_blink = E1000_LEDCTL_LED0_BLINK |
(E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT); (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
@ -1468,7 +1465,7 @@ s32 e1000e_led_on_generic(struct e1000_hw *hw)
{ {
u32 ctrl; u32 ctrl;
switch (hw->media_type) { switch (hw->phy.media_type) {
case e1000_media_type_fiber: case e1000_media_type_fiber:
ctrl = er32(CTRL); ctrl = er32(CTRL);
ctrl &= ~E1000_CTRL_SWDPIN0; ctrl &= ~E1000_CTRL_SWDPIN0;
@ -1495,7 +1492,7 @@ s32 e1000e_led_off_generic(struct e1000_hw *hw)
{ {
u32 ctrl; u32 ctrl;
switch (hw->media_type) { switch (hw->phy.media_type) {
case e1000_media_type_fiber: case e1000_media_type_fiber:
ctrl = er32(CTRL); ctrl = er32(CTRL);
ctrl |= E1000_CTRL_SWDPIN0; ctrl |= E1000_CTRL_SWDPIN0;

151
drivers/net/e1000e/netdev.c
Просмотреть файл

@ -878,6 +878,7 @@ static irqreturn_t e1000_intr_msi(int irq, void *data)
/* disable receives */ /* disable receives */
u32 rctl = er32(RCTL); u32 rctl = er32(RCTL);
ew32(RCTL, rctl & ~E1000_RCTL_EN); ew32(RCTL, rctl & ~E1000_RCTL_EN);
adapter->flags |= FLAG_RX_RESTART_NOW;
} }
/* guard against interrupt when we're going down */ /* guard against interrupt when we're going down */
if (!test_bit(__E1000_DOWN, &adapter->state)) if (!test_bit(__E1000_DOWN, &adapter->state))
@ -944,6 +945,7 @@ static irqreturn_t e1000_intr(int irq, void *data)
/* disable receives */ /* disable receives */
rctl = er32(RCTL); rctl = er32(RCTL);
ew32(RCTL, rctl & ~E1000_RCTL_EN); ew32(RCTL, rctl & ~E1000_RCTL_EN);
adapter->flags |= FLAG_RX_RESTART_NOW;
} }
/* guard against interrupt when we're going down */ /* guard against interrupt when we're going down */
if (!test_bit(__E1000_DOWN, &adapter->state)) if (!test_bit(__E1000_DOWN, &adapter->state))
@ -1794,6 +1796,8 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
} }
ew32(RCTL, rctl); ew32(RCTL, rctl);
/* just started the receive unit, no need to restart */
adapter->flags &= ~FLAG_RX_RESTART_NOW;
} }
/** /**
@ -2003,7 +2007,7 @@ void e1000e_power_up_phy(struct e1000_adapter *adapter)
u16 mii_reg = 0; u16 mii_reg = 0;
/* Just clear the power down bit to wake the phy back up */ /* Just clear the power down bit to wake the phy back up */
if (adapter->hw.media_type == e1000_media_type_copper) { if (adapter->hw.phy.media_type == e1000_media_type_copper) {
/* /*
* According to the manual, the phy will retain its * According to the manual, the phy will retain its
* settings across a power-down/up cycle * settings across a power-down/up cycle
@ -2032,7 +2036,7 @@ static void e1000_power_down_phy(struct e1000_adapter *adapter)
return; return;
/* non-copper PHY? */ /* non-copper PHY? */
if (adapter->hw.media_type != e1000_media_type_copper) if (adapter->hw.phy.media_type != e1000_media_type_copper)
return; return;
/* reset is blocked because of a SoL/IDER session */ /* reset is blocked because of a SoL/IDER session */
@ -2061,15 +2065,16 @@ static void e1000_power_down_phy(struct e1000_adapter *adapter)
void e1000e_reset(struct e1000_adapter *adapter) void e1000e_reset(struct e1000_adapter *adapter)
{ {
struct e1000_mac_info *mac = &adapter->hw.mac; struct e1000_mac_info *mac = &adapter->hw.mac;
struct e1000_fc_info *fc = &adapter->hw.fc;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
u32 tx_space, min_tx_space, min_rx_space; u32 tx_space, min_tx_space, min_rx_space;
u32 pba; u32 pba = adapter->pba;
u16 hwm; u16 hwm;
/* reset Packet Buffer Allocation to default */ /* reset Packet Buffer Allocation to default */
ew32(PBA, adapter->pba); ew32(PBA, pba);
if (mac->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN ) { if (adapter->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN) {
/* /*
* To maintain wire speed transmits, the Tx FIFO should be * To maintain wire speed transmits, the Tx FIFO should be
* large enough to accommodate two full transmit packets, * large enough to accommodate two full transmit packets,
@ -2086,13 +2091,14 @@ void e1000e_reset(struct e1000_adapter *adapter)
/* /*
* the Tx fifo also stores 16 bytes of information about the tx * the Tx fifo also stores 16 bytes of information about the tx
* but don't include ethernet FCS because hardware appends it * but don't include ethernet FCS because hardware appends it
*/ min_tx_space = (mac->max_frame_size + */
min_tx_space = (adapter->max_frame_size +
sizeof(struct e1000_tx_desc) - sizeof(struct e1000_tx_desc) -
ETH_FCS_LEN) * 2; ETH_FCS_LEN) * 2;
min_tx_space = ALIGN(min_tx_space, 1024); min_tx_space = ALIGN(min_tx_space, 1024);
min_tx_space >>= 10; min_tx_space >>= 10;
/* software strips receive CRC, so leave room for it */ /* software strips receive CRC, so leave room for it */
min_rx_space = mac->max_frame_size; min_rx_space = adapter->max_frame_size;
min_rx_space = ALIGN(min_rx_space, 1024); min_rx_space = ALIGN(min_rx_space, 1024);
min_rx_space >>= 10; min_rx_space >>= 10;
@ -2131,20 +2137,21 @@ void e1000e_reset(struct e1000_adapter *adapter)
* - the full Rx FIFO size minus one full frame * - the full Rx FIFO size minus one full frame
*/ */
if (adapter->flags & FLAG_HAS_ERT) if (adapter->flags & FLAG_HAS_ERT)
hwm = min(((adapter->pba << 10) * 9 / 10), hwm = min(((pba << 10) * 9 / 10),
((adapter->pba << 10) - (E1000_ERT_2048 << 3))); ((pba << 10) - (E1000_ERT_2048 << 3)));
else else
hwm = min(((adapter->pba << 10) * 9 / 10), hwm = min(((pba << 10) * 9 / 10),
((adapter->pba << 10) - mac->max_frame_size)); ((pba << 10) - adapter->max_frame_size));
mac->fc_high_water = hwm & 0xFFF8; /* 8-byte granularity */ fc->high_water = hwm & 0xFFF8; /* 8-byte granularity */
mac->fc_low_water = mac->fc_high_water - 8; fc->low_water = fc->high_water - 8;
if (adapter->flags & FLAG_DISABLE_FC_PAUSE_TIME) if (adapter->flags & FLAG_DISABLE_FC_PAUSE_TIME)
mac->fc_pause_time = 0xFFFF; fc->pause_time = 0xFFFF;
else else
mac->fc_pause_time = E1000_FC_PAUSE_TIME; fc->pause_time = E1000_FC_PAUSE_TIME;
mac->fc = mac->original_fc; fc->send_xon = 1;
fc->type = fc->original_type;
/* Allow time for pending master requests to run */ /* Allow time for pending master requests to run */
mac->ops.reset_hw(hw); mac->ops.reset_hw(hw);
@ -2259,13 +2266,12 @@ void e1000e_reinit_locked(struct e1000_adapter *adapter)
**/ **/
static int __devinit e1000_sw_init(struct e1000_adapter *adapter) static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN; adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN;
adapter->rx_ps_bsize0 = 128; adapter->rx_ps_bsize0 = 128;
hw->mac.max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN; adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
hw->mac.min_frame_size = ETH_ZLEN + ETH_FCS_LEN; adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
adapter->tx_ring = kzalloc(sizeof(struct e1000_ring), GFP_KERNEL); adapter->tx_ring = kzalloc(sizeof(struct e1000_ring), GFP_KERNEL);
if (!adapter->tx_ring) if (!adapter->tx_ring)
@ -2611,7 +2617,7 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
/* Tx Dropped needs to be maintained elsewhere */ /* Tx Dropped needs to be maintained elsewhere */
/* Phy Stats */ /* Phy Stats */
if (hw->media_type == e1000_media_type_copper) { if (hw->phy.media_type == e1000_media_type_copper) {
if ((adapter->link_speed == SPEED_1000) && if ((adapter->link_speed == SPEED_1000) &&
(!e1e_rphy(hw, PHY_1000T_STATUS, &phy_tmp))) { (!e1e_rphy(hw, PHY_1000T_STATUS, &phy_tmp))) {
phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK; phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
@ -2629,8 +2635,8 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
static void e1000_print_link_info(struct e1000_adapter *adapter) static void e1000_print_link_info(struct e1000_adapter *adapter)
{ {
struct net_device *netdev = adapter->netdev;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
struct net_device *netdev = adapter->netdev;
u32 ctrl = er32(CTRL); u32 ctrl = er32(CTRL);
ndev_info(netdev, ndev_info(netdev,
@ -2644,6 +2650,62 @@ static void e1000_print_link_info(struct e1000_adapter *adapter)
((ctrl & E1000_CTRL_TFCE) ? "TX" : "None" ))); ((ctrl & E1000_CTRL_TFCE) ? "TX" : "None" )));
} }
static bool e1000_has_link(struct e1000_adapter *adapter)
{
struct e1000_hw *hw = &adapter->hw;
bool link_active = 0;
s32 ret_val = 0;
/*
* get_link_status is set on LSC (link status) interrupt or
* Rx sequence error interrupt. get_link_status will stay
* false until the check_for_link establishes link
* for copper adapters ONLY
*/
switch (hw->phy.media_type) {
case e1000_media_type_copper:
if (hw->mac.get_link_status) {
ret_val = hw->mac.ops.check_for_link(hw);
link_active = !hw->mac.get_link_status;
} else {
link_active = 1;
}
break;
case e1000_media_type_fiber:
ret_val = hw->mac.ops.check_for_link(hw);
link_active = !!(er32(STATUS) & E1000_STATUS_LU);
break;
case e1000_media_type_internal_serdes:
ret_val = hw->mac.ops.check_for_link(hw);
link_active = adapter->hw.mac.serdes_has_link;
break;
default:
case e1000_media_type_unknown:
break;
}
if ((ret_val == E1000_ERR_PHY) && (hw->phy.type == e1000_phy_igp_3) &&
(er32(CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) {
/* See e1000_kmrn_lock_loss_workaround_ich8lan() */
ndev_info(adapter->netdev,
"Gigabit has been disabled, downgrading speed\n");
}
return link_active;
}
static void e1000e_enable_receives(struct e1000_adapter *adapter)
{
/* make sure the receive unit is started */
if ((adapter->flags & FLAG_RX_NEEDS_RESTART) &&
(adapter->flags & FLAG_RX_RESTART_NOW)) {
struct e1000_hw *hw = &adapter->hw;
u32 rctl = er32(RCTL);
ew32(RCTL, rctl | E1000_RCTL_EN);
adapter->flags &= ~FLAG_RX_RESTART_NOW;
}
}
/** /**
* e1000_watchdog - Timer Call-back * e1000_watchdog - Timer Call-back
* @data: pointer to adapter cast into an unsigned long * @data: pointer to adapter cast into an unsigned long
@ -2662,42 +2724,27 @@ static void e1000_watchdog_task(struct work_struct *work)
{ {
struct e1000_adapter *adapter = container_of(work, struct e1000_adapter *adapter = container_of(work,
struct e1000_adapter, watchdog_task); struct e1000_adapter, watchdog_task);
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct e1000_mac_info *mac = &adapter->hw.mac; struct e1000_mac_info *mac = &adapter->hw.mac;
struct e1000_ring *tx_ring = adapter->tx_ring; struct e1000_ring *tx_ring = adapter->tx_ring;
struct e1000_hw *hw = &adapter->hw; struct e1000_hw *hw = &adapter->hw;
u32 link, tctl; u32 link, tctl;
s32 ret_val;
int tx_pending = 0; int tx_pending = 0;
if ((netif_carrier_ok(netdev)) && link = e1000_has_link(adapter);
(er32(STATUS) & E1000_STATUS_LU)) if ((netif_carrier_ok(netdev)) && link) {
e1000e_enable_receives(adapter);
goto link_up; goto link_up;
ret_val = mac->ops.check_for_link(hw);
if ((ret_val == E1000_ERR_PHY) &&
(adapter->hw.phy.type == e1000_phy_igp_3) &&
(er32(CTRL) &
E1000_PHY_CTRL_GBE_DISABLE)) {
/* See e1000_kmrn_lock_loss_workaround_ich8lan() */
ndev_info(netdev,
"Gigabit has been disabled, downgrading speed\n");
} }
if ((e1000e_enable_tx_pkt_filtering(hw)) && if ((e1000e_enable_tx_pkt_filtering(hw)) &&
(adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id)) (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id))
e1000_update_mng_vlan(adapter); e1000_update_mng_vlan(adapter);
if ((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
!(er32(TXCW) & E1000_TXCW_ANE))
link = adapter->hw.mac.serdes_has_link;
else
link = er32(STATUS) & E1000_STATUS_LU;
if (link) { if (link) {
if (!netif_carrier_ok(netdev)) { if (!netif_carrier_ok(netdev)) {
bool txb2b = 1; bool txb2b = 1;
/* update snapshot of PHY registers on LSC */
mac->ops.get_link_up_info(&adapter->hw, mac->ops.get_link_up_info(&adapter->hw,
&adapter->link_speed, &adapter->link_speed,
&adapter->link_duplex); &adapter->link_duplex);
@ -2770,13 +2817,6 @@ static void e1000_watchdog_task(struct work_struct *work)
if (!test_bit(__E1000_DOWN, &adapter->state)) if (!test_bit(__E1000_DOWN, &adapter->state))
mod_timer(&adapter->phy_info_timer, mod_timer(&adapter->phy_info_timer,
round_jiffies(jiffies + 2 * HZ)); round_jiffies(jiffies + 2 * HZ));
} else {
/* make sure the receive unit is started */
if (adapter->flags & FLAG_RX_NEEDS_RESTART) {
u32 rctl = er32(RCTL);
ew32(RCTL, rctl |
E1000_RCTL_EN);
}
} }
} else { } else {
if (netif_carrier_ok(netdev)) { if (netif_carrier_ok(netdev)) {
@ -3413,7 +3453,7 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
while (test_and_set_bit(__E1000_RESETTING, &adapter->state)) while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
msleep(1); msleep(1);
/* e1000e_down has a dependency on max_frame_size */ /* e1000e_down has a dependency on max_frame_size */
adapter->hw.mac.max_frame_size = max_frame; adapter->max_frame_size = max_frame;
if (netif_running(netdev)) if (netif_running(netdev))
e1000e_down(adapter); e1000e_down(adapter);
@ -3462,7 +3502,7 @@ static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
struct mii_ioctl_data *data = if_mii(ifr); struct mii_ioctl_data *data = if_mii(ifr);
unsigned long irq_flags; unsigned long irq_flags;
if (adapter->hw.media_type != e1000_media_type_copper) if (adapter->hw.phy.media_type != e1000_media_type_copper)
return -EOPNOTSUPP; return -EOPNOTSUPP;
switch (cmd) { switch (cmd) {
@ -3544,8 +3584,9 @@ static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
E1000_CTRL_EN_PHY_PWR_MGMT; E1000_CTRL_EN_PHY_PWR_MGMT;
ew32(CTRL, ctrl); ew32(CTRL, ctrl);
if (adapter->hw.media_type == e1000_media_type_fiber || if (adapter->hw.phy.media_type == e1000_media_type_fiber ||
adapter->hw.media_type == e1000_media_type_internal_serdes) { adapter->hw.phy.media_type ==
e1000_media_type_internal_serdes) {
/* keep the laser running in D3 */ /* keep the laser running in D3 */
ctrl_ext = er32(CTRL_EXT); ctrl_ext = er32(CTRL_EXT);
ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA; ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
@ -3939,10 +3980,10 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
hw->mac.ops.get_bus_info(&adapter->hw); hw->mac.ops.get_bus_info(&adapter->hw);
adapter->hw.phy.wait_for_link = 0; adapter->hw.phy.autoneg_wait_to_complete = 0;
/* Copper options */ /* Copper options */
if (adapter->hw.media_type == e1000_media_type_copper) { if (adapter->hw.phy.media_type == e1000_media_type_copper) {
adapter->hw.phy.mdix = AUTO_ALL_MODES; adapter->hw.phy.mdix = AUTO_ALL_MODES;
adapter->hw.phy.disable_polarity_correction = 0; adapter->hw.phy.disable_polarity_correction = 0;
adapter->hw.phy.ms_type = e1000_ms_hw_default; adapter->hw.phy.ms_type = e1000_ms_hw_default;
@ -4028,8 +4069,8 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
/* Initialize link parameters. User can change them with ethtool */ /* Initialize link parameters. User can change them with ethtool */
adapter->hw.mac.autoneg = 1; adapter->hw.mac.autoneg = 1;
adapter->fc_autoneg = 1; adapter->fc_autoneg = 1;
adapter->hw.mac.original_fc = e1000_fc_default; adapter->hw.fc.original_type = e1000_fc_default;
adapter->hw.mac.fc = e1000_fc_default; adapter->hw.fc.type = e1000_fc_default;
adapter->hw.phy.autoneg_advertised = 0x2f; adapter->hw.phy.autoneg_advertised = 0x2f;
/* ring size defaults */ /* ring size defaults */

12
drivers/net/e1000e/phy.c
Просмотреть файл

@ -714,7 +714,7 @@ static s32 e1000_phy_setup_autoneg(struct e1000_hw *hw)
* other: No software override. The flow control configuration * other: No software override. The flow control configuration
* in the EEPROM is used. * in the EEPROM is used.
*/ */
switch (hw->mac.fc) { switch (hw->fc.type) {
case e1000_fc_none: case e1000_fc_none:
/* /*
* Flow control (Rx & Tx) is completely disabled by a * Flow control (Rx & Tx) is completely disabled by a
@ -822,7 +822,7 @@ static s32 e1000_copper_link_autoneg(struct e1000_hw *hw)
* Does the user want to wait for Auto-Neg to complete here, or * Does the user want to wait for Auto-Neg to complete here, or
* check at a later time (for example, callback routine). * check at a later time (for example, callback routine).
*/ */
if (phy->wait_for_link) { if (phy->autoneg_wait_to_complete) {
ret_val = e1000_wait_autoneg(hw); ret_val = e1000_wait_autoneg(hw);
if (ret_val) { if (ret_val) {
hw_dbg(hw, "Error while waiting for " hw_dbg(hw, "Error while waiting for "
@ -937,7 +937,7 @@ s32 e1000e_phy_force_speed_duplex_igp(struct e1000_hw *hw)
udelay(1); udelay(1);
if (phy->wait_for_link) { if (phy->autoneg_wait_to_complete) {
hw_dbg(hw, "Waiting for forced speed/duplex link on IGP phy.\n"); hw_dbg(hw, "Waiting for forced speed/duplex link on IGP phy.\n");
ret_val = e1000e_phy_has_link_generic(hw, ret_val = e1000e_phy_has_link_generic(hw,
@ -1009,7 +1009,7 @@ s32 e1000e_phy_force_speed_duplex_m88(struct e1000_hw *hw)
udelay(1); udelay(1);
if (phy->wait_for_link) { if (phy->autoneg_wait_to_complete) {
hw_dbg(hw, "Waiting for forced speed/duplex link on M88 phy.\n"); hw_dbg(hw, "Waiting for forced speed/duplex link on M88 phy.\n");
ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT, ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
@ -1084,7 +1084,7 @@ void e1000e_phy_force_speed_duplex_setup(struct e1000_hw *hw, u16 *phy_ctrl)
u32 ctrl; u32 ctrl;
/* Turn off flow control when forcing speed/duplex */ /* Turn off flow control when forcing speed/duplex */
mac->fc = e1000_fc_none; hw->fc.type = e1000_fc_none;
/* Force speed/duplex on the mac */ /* Force speed/duplex on the mac */
ctrl = er32(CTRL); ctrl = er32(CTRL);
@ -1508,7 +1508,7 @@ s32 e1000e_get_phy_info_m88(struct e1000_hw *hw)
u16 phy_data; u16 phy_data;
bool link; bool link;
if (hw->media_type != e1000_media_type_copper) { if (hw->phy.media_type != e1000_media_type_copper) {
hw_dbg(hw, "Phy info is only valid for copper media\n"); hw_dbg(hw, "Phy info is only valid for copper media\n");
return -E1000_ERR_CONFIG; return -E1000_ERR_CONFIG;
} }