hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

e1000: Use hw, er32, and ew32 

Use struct e1000_hw *hw = adapter->hw; where necessary
Change macros E1000_READ_REG and E1000_WRITE_REG to er32 and ew32

Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
This commit is contained in:
Joe Perches 2008-07-11 15:17:08 -07:00 committed by Jeff Garzik
parent 6479884509
commit 1dc329180f
4 changed files with 1020 additions and 961 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

313
drivers/net/e1000/e1000_ethtool.c
View File

@ -162,7 +162,7 @@ static int e1000_get_settings(struct net_device *netdev,
ecmd->transceiver = XCVR_EXTERNAL; ecmd->transceiver = XCVR_EXTERNAL;
} }
if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { if (er32(STATUS) & E1000_STATUS_LU) {
e1000_get_speed_and_duplex(hw, &adapter->link_speed, e1000_get_speed_and_duplex(hw, &adapter->link_speed,
&adapter->link_duplex); &adapter->link_duplex);
@ -313,8 +313,9 @@ static u32 e1000_get_tx_csum(struct net_device *netdev)
static int e1000_set_tx_csum(struct net_device *netdev, u32 data) static int e1000_set_tx_csum(struct net_device *netdev, u32 data)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
if (adapter->hw.mac_type < e1000_82543) { if (hw->mac_type < e1000_82543) {
if (!data) if (!data)
return -EINVAL; return -EINVAL;
return 0; return 0;
@ -331,8 +332,10 @@ static int e1000_set_tx_csum(struct net_device *netdev, u32 data)
static int e1000_set_tso(struct net_device *netdev, u32 data) static int e1000_set_tso(struct net_device *netdev, u32 data)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
if ((adapter->hw.mac_type < e1000_82544) || struct e1000_hw *hw = &adapter->hw;
(adapter->hw.mac_type == e1000_82547))
if ((hw->mac_type < e1000_82544) ||
(hw->mac_type == e1000_82547))
return data ? -EINVAL : 0; return data ? -EINVAL : 0;
if (data) if (data)
@ -380,22 +383,22 @@ static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id; regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
regs_buff[0] = E1000_READ_REG(hw, CTRL); regs_buff[0] = er32(CTRL);
regs_buff[1] = E1000_READ_REG(hw, STATUS); regs_buff[1] = er32(STATUS);
regs_buff[2] = E1000_READ_REG(hw, RCTL); regs_buff[2] = er32(RCTL);
regs_buff[3] = E1000_READ_REG(hw, RDLEN); regs_buff[3] = er32(RDLEN);
regs_buff[4] = E1000_READ_REG(hw, RDH); regs_buff[4] = er32(RDH);
regs_buff[5] = E1000_READ_REG(hw, RDT); regs_buff[5] = er32(RDT);
regs_buff[6] = E1000_READ_REG(hw, RDTR); regs_buff[6] = er32(RDTR);
regs_buff[7] = E1000_READ_REG(hw, TCTL); regs_buff[7] = er32(TCTL);
regs_buff[8] = E1000_READ_REG(hw, TDLEN); regs_buff[8] = er32(TDLEN);
regs_buff[9] = E1000_READ_REG(hw, TDH); regs_buff[9] = er32(TDH);
regs_buff[10] = E1000_READ_REG(hw, TDT); regs_buff[10] = er32(TDT);
regs_buff[11] = E1000_READ_REG(hw, TIDV); regs_buff[11] = er32(TIDV);
regs_buff[12] = adapter->hw.phy_type; /* PHY type (IGP=1, M88=0) */ regs_buff[12] = hw->phy_type; /* PHY type (IGP=1, M88=0) */
if (hw->phy_type == e1000_phy_igp) { if (hw->phy_type == e1000_phy_igp) {
e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
IGP01E1000_PHY_AGC_A); IGP01E1000_PHY_AGC_A);
@ -453,14 +456,16 @@ static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
if (hw->mac_type >= e1000_82540 && if (hw->mac_type >= e1000_82540 &&
hw->mac_type < e1000_82571 && hw->mac_type < e1000_82571 &&
hw->media_type == e1000_media_type_copper) { hw->media_type == e1000_media_type_copper) {
regs_buff[26] = E1000_READ_REG(hw, MANC); regs_buff[26] = er32(MANC);
} }
} }
static int e1000_get_eeprom_len(struct net_device *netdev) static int e1000_get_eeprom_len(struct net_device *netdev)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
return adapter->hw.eeprom.word_size * 2; struct e1000_hw *hw = &adapter->hw;
return hw->eeprom.word_size * 2;
} }
static int e1000_get_eeprom(struct net_device *netdev, static int e1000_get_eeprom(struct net_device *netdev,
@ -574,6 +579,7 @@ static void e1000_get_drvinfo(struct net_device *netdev,
struct ethtool_drvinfo *drvinfo) struct ethtool_drvinfo *drvinfo)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
char firmware_version[32]; char firmware_version[32];
u16 eeprom_data; u16 eeprom_data;
@ -582,8 +588,8 @@ static void e1000_get_drvinfo(struct net_device *netdev,
/* EEPROM image version # is reported as firmware version # for /* EEPROM image version # is reported as firmware version # for
* 8257{1|2|3} controllers */ * 8257{1|2|3} controllers */
e1000_read_eeprom(&adapter->hw, 5, 1, &eeprom_data); e1000_read_eeprom(hw, 5, 1, &eeprom_data);
switch (adapter->hw.mac_type) { switch (hw->mac_type) {
case e1000_82571: case e1000_82571:
case e1000_82572: case e1000_82572:
case e1000_82573: case e1000_82573:
@ -608,7 +614,8 @@ static void e1000_get_ringparam(struct net_device *netdev,
struct ethtool_ringparam *ring) struct ethtool_ringparam *ring)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
e1000_mac_type mac_type = adapter->hw.mac_type; struct e1000_hw *hw = &adapter->hw;
e1000_mac_type mac_type = hw->mac_type;
struct e1000_tx_ring *txdr = adapter->tx_ring; struct e1000_tx_ring *txdr = adapter->tx_ring;
struct e1000_rx_ring *rxdr = adapter->rx_ring; struct e1000_rx_ring *rxdr = adapter->rx_ring;
@ -628,7 +635,8 @@ static int e1000_set_ringparam(struct net_device *netdev,
struct ethtool_ringparam *ring) struct ethtool_ringparam *ring)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
e1000_mac_type mac_type = adapter->hw.mac_type; struct e1000_hw *hw = &adapter->hw;
e1000_mac_type mac_type = hw->mac_type;
struct e1000_tx_ring *txdr, *tx_old; struct e1000_tx_ring *txdr, *tx_old;
struct e1000_rx_ring *rxdr, *rx_old; struct e1000_rx_ring *rxdr, *rx_old;
int i, err; int i, err;
@ -714,9 +722,10 @@ err_setup:
static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg, static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg,
u32 mask, u32 write) u32 mask, u32 write)
{ {
struct e1000_hw *hw = &adapter->hw;
static const u32 test[] = static const u32 test[] =
{0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
u8 __iomem *address = adapter->hw.hw_addr + reg; u8 __iomem *address = hw->hw_addr + reg;
u32 read; u32 read;
int i; int i;
@ -737,7 +746,8 @@ static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg,
static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg, static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg,
u32 mask, u32 write) u32 mask, u32 write)
{ {
u8 __iomem *address = adapter->hw.hw_addr + reg; struct e1000_hw *hw = &adapter->hw;
u8 __iomem *address = hw->hw_addr + reg;
u32 read; u32 read;
writel(write & mask, address); writel(write & mask, address);
@ -755,7 +765,7 @@ static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg,
#define REG_PATTERN_TEST(reg, mask, write) \ #define REG_PATTERN_TEST(reg, mask, write) \
do { \ do { \
if (reg_pattern_test(adapter, data, \ if (reg_pattern_test(adapter, data, \
(adapter->hw.mac_type >= e1000_82543) \ (hw->mac_type >= e1000_82543) \
? E1000_##reg : E1000_82542_##reg, \ ? E1000_##reg : E1000_82542_##reg, \
mask, write)) \ mask, write)) \
return 1; \ return 1; \
@ -764,7 +774,7 @@ static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg,
#define REG_SET_AND_CHECK(reg, mask, write) \ #define REG_SET_AND_CHECK(reg, mask, write) \
do { \ do { \
if (reg_set_and_check(adapter, data, \ if (reg_set_and_check(adapter, data, \
(adapter->hw.mac_type >= e1000_82543) \ (hw->mac_type >= e1000_82543) \
? E1000_##reg : E1000_82542_##reg, \ ? E1000_##reg : E1000_82542_##reg, \
mask, write)) \ mask, write)) \
return 1; \ return 1; \
@ -774,11 +784,12 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
{ {
u32 value, before, after; u32 value, before, after;
u32 i, toggle; u32 i, toggle;
struct e1000_hw *hw = &adapter->hw;
/* The status register is Read Only, so a write should fail. /* The status register is Read Only, so a write should fail.
* Some bits that get toggled are ignored. * Some bits that get toggled are ignored.
*/ */
switch (adapter->hw.mac_type) { switch (hw->mac_type) {
/* there are several bits on newer hardware that are r/w */ /* there are several bits on newer hardware that are r/w */
case e1000_82571: case e1000_82571:
case e1000_82572: case e1000_82572:
@ -794,10 +805,10 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
break; break;
} }
before = E1000_READ_REG(&adapter->hw, STATUS); before = er32(STATUS);
value = (E1000_READ_REG(&adapter->hw, STATUS) & toggle); value = (er32(STATUS) & toggle);
E1000_WRITE_REG(&adapter->hw, STATUS, toggle); ew32(STATUS, toggle);
after = E1000_READ_REG(&adapter->hw, STATUS) & toggle; after = er32(STATUS) & toggle;
if (value != after) { if (value != after) {
DPRINTK(DRV, ERR, "failed STATUS register test got: " DPRINTK(DRV, ERR, "failed STATUS register test got: "
"0x%08X expected: 0x%08X\n", after, value); "0x%08X expected: 0x%08X\n", after, value);
@ -805,9 +816,9 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
return 1; return 1;
} }
/* restore previous status */ /* restore previous status */
E1000_WRITE_REG(&adapter->hw, STATUS, before); ew32(STATUS, before);
if (adapter->hw.mac_type != e1000_ich8lan) { if (hw->mac_type != e1000_ich8lan) {
REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF); REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF); REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF);
REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF); REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF);
@ -827,20 +838,20 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000); REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000);
before = (adapter->hw.mac_type == e1000_ich8lan ? before = (hw->mac_type == e1000_ich8lan ?
0x06C3B33E : 0x06DFB3FE); 0x06C3B33E : 0x06DFB3FE);
REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB); REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB);
REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000); REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000);
if (adapter->hw.mac_type >= e1000_82543) { if (hw->mac_type >= e1000_82543) {
REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF); REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF);
REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF); REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
if (adapter->hw.mac_type != e1000_ich8lan) if (hw->mac_type != e1000_ich8lan)
REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF); REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF);
REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF); REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF); REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF);
value = (adapter->hw.mac_type == e1000_ich8lan ? value = (hw->mac_type == e1000_ich8lan ?
E1000_RAR_ENTRIES_ICH8LAN : E1000_RAR_ENTRIES); E1000_RAR_ENTRIES_ICH8LAN : E1000_RAR_ENTRIES);
for (i = 0; i < value; i++) { for (i = 0; i < value; i++) {
REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2), 0x8003FFFF, REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2), 0x8003FFFF,
@ -856,7 +867,7 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
} }
value = (adapter->hw.mac_type == e1000_ich8lan ? value = (hw->mac_type == e1000_ich8lan ?
E1000_MC_TBL_SIZE_ICH8LAN : E1000_MC_TBL_SIZE); E1000_MC_TBL_SIZE_ICH8LAN : E1000_MC_TBL_SIZE);
for (i = 0; i < value; i++) for (i = 0; i < value; i++)
REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF); REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF);
@ -867,6 +878,7 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data) static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
{ {
struct e1000_hw *hw = &adapter->hw;
u16 temp; u16 temp;
u16 checksum = 0; u16 checksum = 0;
u16 i; u16 i;
@ -874,7 +886,7 @@ static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
*data = 0; *data = 0;
/* Read and add up the contents of the EEPROM */ /* Read and add up the contents of the EEPROM */
for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) { for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
if ((e1000_read_eeprom(&adapter->hw, i, 1, &temp)) < 0) { if ((e1000_read_eeprom(hw, i, 1, &temp)) < 0) {
*data = 1; *data = 1;
break; break;
} }
@ -892,8 +904,9 @@ static irqreturn_t e1000_test_intr(int irq, void *data)
{ {
struct net_device *netdev = (struct net_device *) data; struct net_device *netdev = (struct net_device *) data;
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
adapter->test_icr |= E1000_READ_REG(&adapter->hw, ICR); adapter->test_icr |= er32(ICR);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -904,6 +917,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
u32 mask, i = 0; u32 mask, i = 0;
bool shared_int = true; bool shared_int = true;
u32 irq = adapter->pdev->irq; u32 irq = adapter->pdev->irq;
struct e1000_hw *hw = &adapter->hw;
*data = 0; *data = 0;
@ -921,13 +935,13 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
(shared_int ? "shared" : "unshared")); (shared_int ? "shared" : "unshared"));
/* Disable all the interrupts */ /* Disable all the interrupts */
E1000_WRITE_REG(&adapter->hw, IMC, 0xFFFFFFFF); ew32(IMC, 0xFFFFFFFF);
msleep(10); msleep(10);
/* Test each interrupt */ /* Test each interrupt */
for (; i < 10; i++) { for (; i < 10; i++) {
if (adapter->hw.mac_type == e1000_ich8lan && i == 8) if (hw->mac_type == e1000_ich8lan && i == 8)
continue; continue;
/* Interrupt to test */ /* Interrupt to test */
@ -941,8 +955,8 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
* test failed. * test failed.
*/ */
adapter->test_icr = 0; adapter->test_icr = 0;
E1000_WRITE_REG(&adapter->hw, IMC, mask); ew32(IMC, mask);
E1000_WRITE_REG(&adapter->hw, ICS, mask); ew32(ICS, mask);
msleep(10); msleep(10);
if (adapter->test_icr & mask) { if (adapter->test_icr & mask) {
@ -958,8 +972,8 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
* test failed. * test failed.
*/ */
adapter->test_icr = 0; adapter->test_icr = 0;
E1000_WRITE_REG(&adapter->hw, IMS, mask); ew32(IMS, mask);
E1000_WRITE_REG(&adapter->hw, ICS, mask); ew32(ICS, mask);
msleep(10); msleep(10);
if (!(adapter->test_icr & mask)) { if (!(adapter->test_icr & mask)) {
@ -975,8 +989,8 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
* test failed. * test failed.
*/ */
adapter->test_icr = 0; adapter->test_icr = 0;
E1000_WRITE_REG(&adapter->hw, IMC, ~mask & 0x00007FFF); ew32(IMC, ~mask & 0x00007FFF);
E1000_WRITE_REG(&adapter->hw, ICS, ~mask & 0x00007FFF); ew32(ICS, ~mask & 0x00007FFF);
msleep(10); msleep(10);
if (adapter->test_icr) { if (adapter->test_icr) {
@ -987,7 +1001,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
} }
/* Disable all the interrupts */ /* Disable all the interrupts */
E1000_WRITE_REG(&adapter->hw, IMC, 0xFFFFFFFF); ew32(IMC, 0xFFFFFFFF);
msleep(10); msleep(10);
/* Unhook test interrupt handler */ /* Unhook test interrupt handler */
@ -1044,6 +1058,7 @@ static void e1000_free_desc_rings(struct e1000_adapter *adapter)
static int e1000_setup_desc_rings(struct e1000_adapter *adapter) static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
struct e1000_tx_ring *txdr = &adapter->test_tx_ring; struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
struct e1000_rx_ring *rxdr = &adapter->test_rx_ring; struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
@ -1072,17 +1087,14 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
memset(txdr->desc, 0, txdr->size); memset(txdr->desc, 0, txdr->size);
txdr->next_to_use = txdr->next_to_clean = 0; txdr->next_to_use = txdr->next_to_clean = 0;
E1000_WRITE_REG(&adapter->hw, TDBAL, ew32(TDBAL, ((u64) txdr->dma & 0x00000000FFFFFFFF));
((u64) txdr->dma & 0x00000000FFFFFFFF)); ew32(TDBAH, ((u64) txdr->dma >> 32));
E1000_WRITE_REG(&adapter->hw, TDBAH, ((u64) txdr->dma >> 32)); ew32(TDLEN, txdr->count * sizeof(struct e1000_tx_desc));
E1000_WRITE_REG(&adapter->hw, TDLEN, ew32(TDH, 0);
txdr->count * sizeof(struct e1000_tx_desc)); ew32(TDT, 0);
E1000_WRITE_REG(&adapter->hw, TDH, 0); ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN |
E1000_WRITE_REG(&adapter->hw, TDT, 0); E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
E1000_WRITE_REG(&adapter->hw, TCTL, E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
E1000_TCTL_PSP | E1000_TCTL_EN |
E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
for (i = 0; i < txdr->count; i++) { for (i = 0; i < txdr->count; i++) {
struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i); struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i);
@ -1127,18 +1139,17 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
memset(rxdr->desc, 0, rxdr->size); memset(rxdr->desc, 0, rxdr->size);
rxdr->next_to_use = rxdr->next_to_clean = 0; rxdr->next_to_use = rxdr->next_to_clean = 0;
rctl = E1000_READ_REG(&adapter->hw, RCTL); rctl = er32(RCTL);
E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN); ew32(RCTL, rctl & ~E1000_RCTL_EN);
E1000_WRITE_REG(&adapter->hw, RDBAL, ew32(RDBAL, ((u64) rxdr->dma & 0xFFFFFFFF));
((u64) rxdr->dma & 0xFFFFFFFF)); ew32(RDBAH, ((u64) rxdr->dma >> 32));
E1000_WRITE_REG(&adapter->hw, RDBAH, ((u64) rxdr->dma >> 32)); ew32(RDLEN, rxdr->size);
E1000_WRITE_REG(&adapter->hw, RDLEN, rxdr->size); ew32(RDH, 0);
E1000_WRITE_REG(&adapter->hw, RDH, 0); ew32(RDT, 0);
E1000_WRITE_REG(&adapter->hw, RDT, 0);
rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 | rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF | E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
(adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); (hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
E1000_WRITE_REG(&adapter->hw, RCTL, rctl); ew32(RCTL, rctl);
for (i = 0; i < rxdr->count; i++) { for (i = 0; i < rxdr->count; i++) {
struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i); struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i);
@ -1168,68 +1179,72 @@ err_nomem:
static void e1000_phy_disable_receiver(struct e1000_adapter *adapter) static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
/* Write out to PHY registers 29 and 30 to disable the Receiver. */ /* Write out to PHY registers 29 and 30 to disable the Receiver. */
e1000_write_phy_reg(&adapter->hw, 29, 0x001F); e1000_write_phy_reg(hw, 29, 0x001F);
e1000_write_phy_reg(&adapter->hw, 30, 0x8FFC); e1000_write_phy_reg(hw, 30, 0x8FFC);
e1000_write_phy_reg(&adapter->hw, 29, 0x001A); e1000_write_phy_reg(hw, 29, 0x001A);
e1000_write_phy_reg(&adapter->hw, 30, 0x8FF0); e1000_write_phy_reg(hw, 30, 0x8FF0);
} }
static void e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter) static void e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
u16 phy_reg; u16 phy_reg;
/* Because we reset the PHY above, we need to re-force TX_CLK in the /* Because we reset the PHY above, we need to re-force TX_CLK in the
* Extended PHY Specific Control Register to 25MHz clock. This * Extended PHY Specific Control Register to 25MHz clock. This
* value defaults back to a 2.5MHz clock when the PHY is reset. * value defaults back to a 2.5MHz clock when the PHY is reset.
*/ */
e1000_read_phy_reg(&adapter->hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg); e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
phy_reg |= M88E1000_EPSCR_TX_CLK_25; phy_reg |= M88E1000_EPSCR_TX_CLK_25;
e1000_write_phy_reg(&adapter->hw, e1000_write_phy_reg(hw,
M88E1000_EXT_PHY_SPEC_CTRL, phy_reg); M88E1000_EXT_PHY_SPEC_CTRL, phy_reg);
/* In addition, because of the s/w reset above, we need to enable /* In addition, because of the s/w reset above, we need to enable
* CRS on TX. This must be set for both full and half duplex * CRS on TX. This must be set for both full and half duplex
* operation. * operation.
*/ */
e1000_read_phy_reg(&adapter->hw, M88E1000_PHY_SPEC_CTRL, &phy_reg); e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
phy_reg |= M88E1000_PSCR_ASSERT_CRS_ON_TX; phy_reg |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
e1000_write_phy_reg(&adapter->hw, e1000_write_phy_reg(hw,
M88E1000_PHY_SPEC_CTRL, phy_reg); M88E1000_PHY_SPEC_CTRL, phy_reg);
} }
static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter) static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
u32 ctrl_reg; u32 ctrl_reg;
u16 phy_reg; u16 phy_reg;
/* Setup the Device Control Register for PHY loopback test. */ /* Setup the Device Control Register for PHY loopback test. */
ctrl_reg = E1000_READ_REG(&adapter->hw, CTRL); ctrl_reg = er32(CTRL);
ctrl_reg |= (E1000_CTRL_ILOS | /* Invert Loss-Of-Signal */ ctrl_reg |= (E1000_CTRL_ILOS | /* Invert Loss-Of-Signal */
E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */ E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */ E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
E1000_CTRL_SPD_1000 | /* Force Speed to 1000 */ E1000_CTRL_SPD_1000 | /* Force Speed to 1000 */
E1000_CTRL_FD); /* Force Duplex to FULL */ E1000_CTRL_FD); /* Force Duplex to FULL */
E1000_WRITE_REG(&adapter->hw, CTRL, ctrl_reg); ew32(CTRL, ctrl_reg);
/* Read the PHY Specific Control Register (0x10) */ /* Read the PHY Specific Control Register (0x10) */
e1000_read_phy_reg(&adapter->hw, M88E1000_PHY_SPEC_CTRL, &phy_reg); e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
/* Clear Auto-Crossover bits in PHY Specific Control Register /* Clear Auto-Crossover bits in PHY Specific Control Register
* (bits 6:5). * (bits 6:5).
*/ */
phy_reg &= ~M88E1000_PSCR_AUTO_X_MODE; phy_reg &= ~M88E1000_PSCR_AUTO_X_MODE;
e1000_write_phy_reg(&adapter->hw, M88E1000_PHY_SPEC_CTRL, phy_reg); e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
/* Perform software reset on the PHY */ /* Perform software reset on the PHY */
e1000_phy_reset(&adapter->hw); e1000_phy_reset(hw);
/* Have to setup TX_CLK and TX_CRS after software reset */ /* Have to setup TX_CLK and TX_CRS after software reset */
e1000_phy_reset_clk_and_crs(adapter); e1000_phy_reset_clk_and_crs(adapter);
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, 0x8100); e1000_write_phy_reg(hw, PHY_CTRL, 0x8100);
/* Wait for reset to complete. */ /* Wait for reset to complete. */
udelay(500); udelay(500);
@ -1241,23 +1256,23 @@ static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
e1000_phy_disable_receiver(adapter); e1000_phy_disable_receiver(adapter);
/* Set the loopback bit in the PHY control register. */ /* Set the loopback bit in the PHY control register. */
e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_reg); e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
phy_reg |= MII_CR_LOOPBACK; phy_reg |= MII_CR_LOOPBACK;
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_reg); e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
/* Setup TX_CLK and TX_CRS one more time. */ /* Setup TX_CLK and TX_CRS one more time. */
e1000_phy_reset_clk_and_crs(adapter); e1000_phy_reset_clk_and_crs(adapter);
/* Check Phy Configuration */ /* Check Phy Configuration */
e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_reg); e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
if (phy_reg != 0x4100) if (phy_reg != 0x4100)
return 9; return 9;
e1000_read_phy_reg(&adapter->hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg); e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
if (phy_reg != 0x0070) if (phy_reg != 0x0070)
return 10; return 10;
e1000_read_phy_reg(&adapter->hw, 29, &phy_reg); e1000_read_phy_reg(hw, 29, &phy_reg);
if (phy_reg != 0x001A) if (phy_reg != 0x001A)
return 11; return 11;
@ -1266,29 +1281,30 @@ static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter) static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
u32 ctrl_reg = 0; u32 ctrl_reg = 0;
u32 stat_reg = 0; u32 stat_reg = 0;
adapter->hw.autoneg = false; hw->autoneg = false;
if (adapter->hw.phy_type == e1000_phy_m88) { if (hw->phy_type == e1000_phy_m88) {
/* Auto-MDI/MDIX Off */ /* Auto-MDI/MDIX Off */
e1000_write_phy_reg(&adapter->hw, e1000_write_phy_reg(hw,
M88E1000_PHY_SPEC_CTRL, 0x0808); M88E1000_PHY_SPEC_CTRL, 0x0808);
/* reset to update Auto-MDI/MDIX */ /* reset to update Auto-MDI/MDIX */
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, 0x9140); e1000_write_phy_reg(hw, PHY_CTRL, 0x9140);
/* autoneg off */ /* autoneg off */
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, 0x8140); e1000_write_phy_reg(hw, PHY_CTRL, 0x8140);
} else if (adapter->hw.phy_type == e1000_phy_gg82563) } else if (hw->phy_type == e1000_phy_gg82563)
e1000_write_phy_reg(&adapter->hw, e1000_write_phy_reg(hw,
GG82563_PHY_KMRN_MODE_CTRL, GG82563_PHY_KMRN_MODE_CTRL,
0x1CC); 0x1CC);
ctrl_reg = E1000_READ_REG(&adapter->hw, 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 */
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, 0x6100); e1000_write_phy_reg(hw, PHY_CTRL, 0x6100);
/* Now set up the MAC to the same speed/duplex as the PHY. */ /* Now set up the MAC to the same speed/duplex as the PHY. */
ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */ ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
@ -1298,10 +1314,10 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
E1000_CTRL_FD); /* Force Duplex to FULL */ E1000_CTRL_FD); /* Force Duplex to FULL */
} else { } else {
/* force 1000, set loopback */ /* force 1000, set loopback */
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, 0x4140); e1000_write_phy_reg(hw, PHY_CTRL, 0x4140);
/* Now set up the MAC to the same speed/duplex as the PHY. */ /* Now set up the MAC to the same speed/duplex as the PHY. */
ctrl_reg = E1000_READ_REG(&adapter->hw, CTRL); ctrl_reg = er32(CTRL);
ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */ ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */ ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */ E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
@ -1309,23 +1325,23 @@ 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->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 {
/* Set the ILOS bit on the fiber Nic is half /* Set the ILOS bit on the fiber Nic is half
* duplex link is detected. */ * duplex link is detected. */
stat_reg = E1000_READ_REG(&adapter->hw, STATUS); stat_reg = er32(STATUS);
if ((stat_reg & E1000_STATUS_FD) == 0) if ((stat_reg & E1000_STATUS_FD) == 0)
ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU); ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
} }
E1000_WRITE_REG(&adapter->hw, CTRL, ctrl_reg); ew32(CTRL, ctrl_reg);
/* 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);
@ -1335,12 +1351,13 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
static int e1000_set_phy_loopback(struct e1000_adapter *adapter) static int e1000_set_phy_loopback(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
u16 phy_reg = 0; u16 phy_reg = 0;
u16 count = 0; u16 count = 0;
switch (adapter->hw.mac_type) { switch (hw->mac_type) {
case e1000_82543: case e1000_82543:
if (adapter->hw.media_type == e1000_media_type_copper) { if (hw->media_type == e1000_media_type_copper) {
/* Attempt to setup Loopback mode on Non-integrated PHY. /* Attempt to setup Loopback mode on Non-integrated PHY.
* Some PHY registers get corrupted at random, so * Some PHY registers get corrupted at random, so
* attempt this 10 times. * attempt this 10 times.
@ -1374,9 +1391,9 @@ static int e1000_set_phy_loopback(struct e1000_adapter *adapter)
/* Default PHY loopback work is to read the MII /* Default PHY loopback work is to read the MII
* control register and assert bit 14 (loopback mode). * control register and assert bit 14 (loopback mode).
*/ */
e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_reg); e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
phy_reg |= MII_CR_LOOPBACK; phy_reg |= MII_CR_LOOPBACK;
e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_reg); e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
return 0; return 0;
break; break;
} }
@ -1402,14 +1419,14 @@ static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
case e1000_82572: case e1000_82572:
#define E1000_SERDES_LB_ON 0x410 #define E1000_SERDES_LB_ON 0x410
e1000_set_phy_loopback(adapter); e1000_set_phy_loopback(adapter);
E1000_WRITE_REG(hw, SCTL, E1000_SERDES_LB_ON); ew32(SCTL, E1000_SERDES_LB_ON);
msleep(10); msleep(10);
return 0; return 0;
break; break;
default: default:
rctl = E1000_READ_REG(hw, RCTL); rctl = er32(RCTL);
rctl |= E1000_RCTL_LBM_TCVR; rctl |= E1000_RCTL_LBM_TCVR;
E1000_WRITE_REG(hw, RCTL, rctl); ew32(RCTL, rctl);
return 0; return 0;
} }
} else if (hw->media_type == e1000_media_type_copper) } else if (hw->media_type == e1000_media_type_copper)
@ -1424,9 +1441,9 @@ static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
u32 rctl; u32 rctl;
u16 phy_reg; u16 phy_reg;
rctl = E1000_READ_REG(hw, RCTL); rctl = er32(RCTL);
rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC); rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
E1000_WRITE_REG(hw, RCTL, rctl); ew32(RCTL, rctl);
switch (hw->mac_type) { switch (hw->mac_type) {
case e1000_82571: case e1000_82571:
@ -1434,7 +1451,7 @@ static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
if (hw->media_type == e1000_media_type_fiber || if (hw->media_type == e1000_media_type_fiber ||
hw->media_type == e1000_media_type_internal_serdes) { hw->media_type == e1000_media_type_internal_serdes) {
#define E1000_SERDES_LB_OFF 0x400 #define E1000_SERDES_LB_OFF 0x400
E1000_WRITE_REG(hw, SCTL, E1000_SERDES_LB_OFF); ew32(SCTL, E1000_SERDES_LB_OFF);
msleep(10); msleep(10);
break; break;
} }
@ -1484,13 +1501,14 @@ static int e1000_check_lbtest_frame(struct sk_buff *skb,
static int e1000_run_loopback_test(struct e1000_adapter *adapter) static int e1000_run_loopback_test(struct e1000_adapter *adapter)
{ {
struct e1000_hw *hw = &adapter->hw;
struct e1000_tx_ring *txdr = &adapter->test_tx_ring; struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
struct e1000_rx_ring *rxdr = &adapter->test_rx_ring; struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
struct pci_dev *pdev = adapter->pdev; struct pci_dev *pdev = adapter->pdev;
int i, j, k, l, lc, good_cnt, ret_val=0; int i, j, k, l, lc, good_cnt, ret_val=0;
unsigned long time; unsigned long time;
E1000_WRITE_REG(&adapter->hw, RDT, rxdr->count - 1); ew32(RDT, rxdr->count - 1);
/* Calculate the loop count based on the largest descriptor ring /* Calculate the loop count based on the largest descriptor ring
* The idea is to wrap the largest ring a number of times using 64 * The idea is to wrap the largest ring a number of times using 64
@ -1513,7 +1531,7 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
PCI_DMA_TODEVICE); PCI_DMA_TODEVICE);
if (unlikely(++k == txdr->count)) k = 0; if (unlikely(++k == txdr->count)) k = 0;
} }
E1000_WRITE_REG(&adapter->hw, TDT, k); ew32(TDT, k);
msleep(200); msleep(200);
time = jiffies; /* set the start time for the receive */ time = jiffies; /* set the start time for the receive */
good_cnt = 0; good_cnt = 0;
@ -1548,9 +1566,11 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data) static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
{ {
struct e1000_hw *hw = &adapter->hw;
/* PHY loopback cannot be performed if SoL/IDER /* PHY loopback cannot be performed if SoL/IDER
* sessions are active */ * sessions are active */
if (e1000_check_phy_reset_block(&adapter->hw)) { if (e1000_check_phy_reset_block(hw)) {
DPRINTK(DRV, ERR, "Cannot do PHY loopback test " DPRINTK(DRV, ERR, "Cannot do PHY loopback test "
"when SoL/IDER is active.\n"); "when SoL/IDER is active.\n");
*data = 0; *data = 0;
@ -1572,27 +1592,28 @@ out:
static int e1000_link_test(struct e1000_adapter *adapter, u64 *data) static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
{ {
struct e1000_hw *hw = &adapter->hw;
*data = 0; *data = 0;
if (adapter->hw.media_type == e1000_media_type_internal_serdes) { if (hw->media_type == e1000_media_type_internal_serdes) {
int i = 0; int i = 0;
adapter->hw.serdes_link_down = true; hw->serdes_link_down = true;
/* On some blade server designs, link establishment /* On some blade server designs, link establishment
* could take as long as 2-3 minutes */ * could take as long as 2-3 minutes */
do { do {
e1000_check_for_link(&adapter->hw); e1000_check_for_link(hw);
if (!adapter->hw.serdes_link_down) if (!hw->serdes_link_down)
return *data; return *data;
msleep(20); msleep(20);
} while (i++ < 3750); } while (i++ < 3750);
*data = 1; *data = 1;
} else { } else {
e1000_check_for_link(&adapter->hw); e1000_check_for_link(hw);
if (adapter->hw.autoneg) /* if auto_neg is set wait for it */ if (hw->autoneg) /* if auto_neg is set wait for it */
msleep(4000); msleep(4000);
if (!(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) { if (!(er32(STATUS) & E1000_STATUS_LU)) {
*data = 1; *data = 1;
} }
} }
@ -1615,6 +1636,7 @@ static void e1000_diag_test(struct net_device *netdev,
struct ethtool_test *eth_test, u64 *data) struct ethtool_test *eth_test, u64 *data)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
bool if_running = netif_running(netdev); bool if_running = netif_running(netdev);
set_bit(__E1000_TESTING, &adapter->flags); set_bit(__E1000_TESTING, &adapter->flags);
@ -1622,9 +1644,9 @@ static void e1000_diag_test(struct net_device *netdev,
/* Offline tests */ /* Offline tests */
/* save speed, duplex, autoneg settings */ /* save speed, duplex, autoneg settings */
u16 autoneg_advertised = adapter->hw.autoneg_advertised; u16 autoneg_advertised = hw->autoneg_advertised;
u8 forced_speed_duplex = adapter->hw.forced_speed_duplex; u8 forced_speed_duplex = hw->forced_speed_duplex;
u8 autoneg = adapter->hw.autoneg; u8 autoneg = hw->autoneg;
DPRINTK(HW, INFO, "offline testing starting\n"); DPRINTK(HW, INFO, "offline testing starting\n");
@ -1657,9 +1679,9 @@ static void e1000_diag_test(struct net_device *netdev,
eth_test->flags |= ETH_TEST_FL_FAILED; eth_test->flags |= ETH_TEST_FL_FAILED;
/* restore speed, duplex, autoneg settings */ /* restore speed, duplex, autoneg settings */
adapter->hw.autoneg_advertised = autoneg_advertised; hw->autoneg_advertised = autoneg_advertised;
adapter->hw.forced_speed_duplex = forced_speed_duplex; hw->forced_speed_duplex = forced_speed_duplex;
adapter->hw.autoneg = autoneg; hw->autoneg = autoneg;
e1000_reset(adapter); e1000_reset(adapter);
clear_bit(__E1000_TESTING, &adapter->flags); clear_bit(__E1000_TESTING, &adapter->flags);
@ -1708,7 +1730,7 @@ static int e1000_wol_exclusion(struct e1000_adapter *adapter,
case E1000_DEV_ID_82571EB_SERDES: case E1000_DEV_ID_82571EB_SERDES:
case E1000_DEV_ID_82571EB_COPPER: case E1000_DEV_ID_82571EB_COPPER:
/* Wake events not supported on port B */ /* Wake events not supported on port B */
if (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1) { if (er32(STATUS) & E1000_STATUS_FUNC_1) {
wol->supported = 0; wol->supported = 0;
break; break;
} }
@ -1732,7 +1754,7 @@ static int e1000_wol_exclusion(struct e1000_adapter *adapter,
/* dual port cards only support WoL on port A from now on /* dual port cards only support WoL on port A from now on
* unless it was enabled in the eeprom for port B * unless it was enabled in the eeprom for port B
* so exclude FUNC_1 ports from having WoL enabled */ * so exclude FUNC_1 ports from having WoL enabled */
if (E1000_READ_REG(hw, STATUS) & E1000_STATUS_FUNC_1 && if (er32(STATUS) & E1000_STATUS_FUNC_1 &&
!adapter->eeprom_wol) { !adapter->eeprom_wol) {
wol->supported = 0; wol->supported = 0;
break; break;
@ -1748,6 +1770,7 @@ static void e1000_get_wol(struct net_device *netdev,
struct ethtool_wolinfo *wol) struct ethtool_wolinfo *wol)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
wol->supported = WAKE_UCAST | WAKE_MCAST | wol->supported = WAKE_UCAST | WAKE_MCAST |
WAKE_BCAST | WAKE_MAGIC; WAKE_BCAST | WAKE_MAGIC;
@ -1759,7 +1782,7 @@ static void e1000_get_wol(struct net_device *netdev,
return; return;
/* apply any specific unsupported masks here */ /* apply any specific unsupported masks here */
switch (adapter->hw.device_id) { switch (hw->device_id) {
case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
/* KSP3 does not suppport UCAST wake-ups */ /* KSP3 does not suppport UCAST wake-ups */
wol->supported &= ~WAKE_UCAST; wol->supported &= ~WAKE_UCAST;
@ -1831,11 +1854,12 @@ static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
static void e1000_led_blink_callback(unsigned long data) static void e1000_led_blink_callback(unsigned long data)
{ {
struct e1000_adapter *adapter = (struct e1000_adapter *) data; struct e1000_adapter *adapter = (struct e1000_adapter *) data;
struct e1000_hw *hw = &adapter->hw;
if (test_and_change_bit(E1000_LED_ON, &adapter->led_status)) if (test_and_change_bit(E1000_LED_ON, &adapter->led_status))
e1000_led_off(&adapter->hw); e1000_led_off(hw);
else else
e1000_led_on(&adapter->hw); e1000_led_on(hw);
mod_timer(&adapter->blink_timer, jiffies + E1000_ID_INTERVAL); mod_timer(&adapter->blink_timer, jiffies + E1000_ID_INTERVAL);
} }
@ -1843,21 +1867,22 @@ static void e1000_led_blink_callback(unsigned long data)
static int e1000_phys_id(struct net_device *netdev, u32 data) static int e1000_phys_id(struct net_device *netdev, u32 data)
{ {
struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
if (!data) if (!data)
data = INT_MAX; data = INT_MAX;
if (adapter->hw.mac_type < e1000_82571) { if (hw->mac_type < e1000_82571) {
if (!adapter->blink_timer.function) { if (!adapter->blink_timer.function) {
init_timer(&adapter->blink_timer); init_timer(&adapter->blink_timer);
adapter->blink_timer.function = e1000_led_blink_callback; adapter->blink_timer.function = e1000_led_blink_callback;
adapter->blink_timer.data = (unsigned long) adapter; adapter->blink_timer.data = (unsigned long) adapter;
} }
e1000_setup_led(&adapter->hw); e1000_setup_led(hw);
mod_timer(&adapter->blink_timer, jiffies); mod_timer(&adapter->blink_timer, jiffies);
msleep_interruptible(data * 1000); msleep_interruptible(data * 1000);
del_timer_sync(&adapter->blink_timer); del_timer_sync(&adapter->blink_timer);
} else if (adapter->hw.phy_type == e1000_phy_ife) { } else if (hw->phy_type == e1000_phy_ife) {
if (!adapter->blink_timer.function) { if (!adapter->blink_timer.function) {
init_timer(&adapter->blink_timer); init_timer(&adapter->blink_timer);
adapter->blink_timer.function = e1000_led_blink_callback; adapter->blink_timer.function = e1000_led_blink_callback;
@ -1868,13 +1893,13 @@ static int e1000_phys_id(struct net_device *netdev, u32 data)
del_timer_sync(&adapter->blink_timer); del_timer_sync(&adapter->blink_timer);
e1000_write_phy_reg(&(adapter->hw), IFE_PHY_SPECIAL_CONTROL_LED, 0); e1000_write_phy_reg(&(adapter->hw), IFE_PHY_SPECIAL_CONTROL_LED, 0);
} else { } else {
e1000_blink_led_start(&adapter->hw); e1000_blink_led_start(hw);
msleep_interruptible(data * 1000); msleep_interruptible(data * 1000);
} }
e1000_led_off(&adapter->hw); e1000_led_off(hw);
clear_bit(E1000_LED_ON, &adapter->led_status); clear_bit(E1000_LED_ON, &adapter->led_status);
e1000_cleanup_led(&adapter->hw); e1000_cleanup_led(hw);
return 0; return 0;
} }

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

File diff suppressed because it is too large Load Diff

896
drivers/net/e1000/e1000_main.c
View File

File diff suppressed because it is too large Load Diff

14
drivers/net/e1000/e1000_osdep.h
View File

@ -55,13 +55,13 @@
#define DEBUGOUT7 DEBUGOUT3 #define DEBUGOUT7 DEBUGOUT3
#define E1000_WRITE_REG(a, reg, value) ( \ #define er32(reg)\
writel((value), ((a)->hw_addr + \ (readl(hw->hw_addr + ((hw->mac_type >= e1000_82543) \
(((a)->mac_type >= e1000_82543) ? E1000_##reg : E1000_82542_##reg)))) ? E1000_##reg : E1000_82542_##reg)))
#define E1000_READ_REG(a, reg) ( \ #define ew32(reg, value) \
readl((a)->hw_addr + \ (writel((value), (hw->hw_addr + ((hw->mac_type >= e1000_82543) \
(((a)->mac_type >= e1000_82543) ? E1000_##reg : E1000_82542_##reg))) ? E1000_##reg : E1000_82542_##reg))))
#define E1000_WRITE_REG_ARRAY(a, reg, offset, value) ( \ #define E1000_WRITE_REG_ARRAY(a, reg, offset, value) ( \
writel((value), ((a)->hw_addr + \ writel((value), ((a)->hw_addr + \
@ -96,7 +96,7 @@
(((a)->mac_type >= e1000_82543) ? E1000_##reg : E1000_82542_##reg) + \ (((a)->mac_type >= e1000_82543) ? E1000_##reg : E1000_82542_##reg) + \
(offset))) (offset)))
#define E1000_WRITE_FLUSH(a) E1000_READ_REG(a, STATUS) #define E1000_WRITE_FLUSH() er32(STATUS)
#define E1000_WRITE_ICH_FLASH_REG(a, reg, value) ( \ #define E1000_WRITE_ICH_FLASH_REG(a, reg, value) ( \
writel((value), ((a)->flash_address + reg))) writel((value), ((a)->flash_address + reg)))