mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-23 09:56:00 +00:00
netxen: cleanup unused code
Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com> Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Dhananjay Phadke
David S. Miller
parent
4da129421f
commit
dbf64b10fa
@ -473,78 +473,6 @@ netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static int
|
||||
netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
|
||||
u8 * bytes)
|
||||
{
|
||||
struct netxen_adapter *adapter = netdev_priv(dev);
|
||||
int offset = eeprom->offset;
|
||||
static int flash_start;
|
||||
static int ready_to_flash;
|
||||
int ret;
|
||||
|
||||
if (flash_start == 0) {
|
||||
netxen_halt_pegs(adapter);
|
||||
ret = netxen_flash_unlock(adapter);
|
||||
if (ret < 0) {
|
||||
printk(KERN_ERR "%s: Flash unlock failed.\n",
|
||||
netxen_nic_driver_name);
|
||||
return ret;
|
||||
}
|
||||
printk(KERN_INFO "%s: flash unlocked. \n",
|
||||
netxen_nic_driver_name);
|
||||
ret = netxen_flash_erase_secondary(adapter);
|
||||
if (ret != FLASH_SUCCESS) {
|
||||
printk(KERN_ERR "%s: Flash erase failed.\n",
|
||||
netxen_nic_driver_name);
|
||||
return ret;
|
||||
}
|
||||
printk(KERN_INFO "%s: secondary flash erased successfully.\n",
|
||||
netxen_nic_driver_name);
|
||||
flash_start = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (offset == NETXEN_BOOTLD_START) {
|
||||
ret = netxen_flash_erase_primary(adapter);
|
||||
if (ret != FLASH_SUCCESS) {
|
||||
printk(KERN_ERR "%s: Flash erase failed.\n",
|
||||
netxen_nic_driver_name);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = netxen_rom_se(adapter, NETXEN_USER_START);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
return ret;
|
||||
ret = netxen_rom_se(adapter, NETXEN_FIXED_START);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
return ret;
|
||||
|
||||
printk(KERN_INFO "%s: primary flash erased successfully\n",
|
||||
netxen_nic_driver_name);
|
||||
|
||||
ret = netxen_backup_crbinit(adapter);
|
||||
if (ret != FLASH_SUCCESS) {
|
||||
printk(KERN_ERR "%s: CRBinit backup failed.\n",
|
||||
netxen_nic_driver_name);
|
||||
return ret;
|
||||
}
|
||||
printk(KERN_INFO "%s: CRBinit backup done.\n",
|
||||
netxen_nic_driver_name);
|
||||
ready_to_flash = 1;
|
||||
}
|
||||
|
||||
if (!ready_to_flash) {
|
||||
printk(KERN_ERR "%s: Invalid write sequence, returning...\n",
|
||||
netxen_nic_driver_name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return netxen_rom_fast_write_words(adapter, offset, bytes, eeprom->len);
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
static void
|
||||
netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
|
||||
{
|
||||
@ -953,9 +881,6 @@ struct ethtool_ops netxen_nic_ethtool_ops = {
|
||||
.get_link = ethtool_op_get_link,
|
||||
.get_eeprom_len = netxen_nic_get_eeprom_len,
|
||||
.get_eeprom = netxen_nic_get_eeprom,
|
||||
#if 0
|
||||
.set_eeprom = netxen_nic_set_eeprom,
|
||||
#endif
|
||||
.get_ringparam = netxen_nic_get_ringparam,
|
||||
.get_pauseparam = netxen_nic_get_pauseparam,
|
||||
.set_pauseparam = netxen_nic_set_pauseparam,
|
||||
|
||||
@ -2077,19 +2077,6 @@ u32 netxen_nic_pci_read_normalize_2M(struct netxen_adapter *adapter, u64 off)
|
||||
return temp;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int
|
||||
netxen_nic_erase_pxe(struct netxen_adapter *adapter)
|
||||
{
|
||||
if (netxen_rom_fast_write(adapter, NETXEN_PXE_START, 0) == -1) {
|
||||
printk(KERN_ERR "%s: erase pxe failed\n",
|
||||
netxen_nic_driver_name);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
int netxen_nic_get_board_info(struct netxen_adapter *adapter)
|
||||
{
|
||||
int rv = 0;
|
||||
|
||||
@ -124,33 +124,6 @@ typedef enum {
|
||||
#define netxen_gb_get_soft_reset(config_word) \
|
||||
_netxen_crb_get_bit((config_word), 31)
|
||||
|
||||
/*
|
||||
* NIU GB MAC Config Register 1 (applies to GB0, GB1, GB2, GB3)
|
||||
*
|
||||
* Bit 0 : duplex => 1:full duplex mode, 0:half duplex
|
||||
* Bit 1 : crc_enable => 1:append CRC to xmit frames, 0:dont append
|
||||
* Bit 2 : padshort => 1:pad short frames and add CRC, 0:dont pad
|
||||
* Bit 4 : checklength => 1:check framelen with actual,0:dont check
|
||||
* Bit 5 : hugeframes => 1:allow oversize xmit frames, 0:dont allow
|
||||
* Bits 8-9 : intfmode => 01:nibble (10/100), 10:byte (1000)
|
||||
* Bits 12-15 : preamblelen => preamble field length in bytes, default 7
|
||||
*/
|
||||
|
||||
#define netxen_gb_set_duplex(config_word) \
|
||||
((config_word) |= 1 << 0)
|
||||
#define netxen_gb_set_crc_enable(config_word) \
|
||||
((config_word) |= 1 << 1)
|
||||
#define netxen_gb_set_padshort(config_word) \
|
||||
((config_word) |= 1 << 2)
|
||||
#define netxen_gb_set_checklength(config_word) \
|
||||
((config_word) |= 1 << 4)
|
||||
#define netxen_gb_set_hugeframes(config_word) \
|
||||
((config_word) |= 1 << 5)
|
||||
#define netxen_gb_set_preamblelen(config_word, val) \
|
||||
((config_word) |= ((val) << 12) & 0xF000)
|
||||
#define netxen_gb_set_intfmode(config_word, val) \
|
||||
((config_word) |= ((val) << 8) & 0x300)
|
||||
|
||||
#define netxen_gb_get_stationaddress_low(config_word) ((config_word) >> 16)
|
||||
|
||||
#define netxen_gb_set_mii_mgmt_clockselect(config_word, val) \
|
||||
|
||||
@ -55,15 +55,6 @@ static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
|
||||
static void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
|
||||
uint32_t ctx, uint32_t ringid);
|
||||
|
||||
#if 0
|
||||
static void netxen_nic_locked_write_reg(struct netxen_adapter *adapter,
|
||||
unsigned long off, int *data)
|
||||
{
|
||||
void __iomem *addr = pci_base_offset(adapter, off);
|
||||
writel(*data, addr);
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
static void crb_addr_transform_setup(void)
|
||||
{
|
||||
crb_addr_transform(XDMA);
|
||||
@ -399,9 +390,6 @@ static u32 netxen_decode_crb_addr(u32 addr)
|
||||
|
||||
static long rom_max_timeout = 100;
|
||||
static long rom_lock_timeout = 10000;
|
||||
#if 0
|
||||
static long rom_write_timeout = 700;
|
||||
#endif
|
||||
|
||||
static int rom_lock(struct netxen_adapter *adapter)
|
||||
{
|
||||
@ -452,38 +440,6 @@ static int netxen_wait_rom_done(struct netxen_adapter *adapter)
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static int netxen_rom_wren(struct netxen_adapter *adapter)
|
||||
{
|
||||
/* Set write enable latch in ROM status register */
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
|
||||
M25P_INSTR_WREN);
|
||||
if (netxen_wait_rom_done(adapter)) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static unsigned int netxen_rdcrbreg(struct netxen_adapter *adapter,
|
||||
unsigned int addr)
|
||||
{
|
||||
unsigned int data = 0xdeaddead;
|
||||
data = netxen_nic_reg_read(adapter, addr);
|
||||
return data;
|
||||
}
|
||||
|
||||
static int netxen_do_rom_rdsr(struct netxen_adapter *adapter)
|
||||
{
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
|
||||
M25P_INSTR_RDSR);
|
||||
if (netxen_wait_rom_done(adapter)) {
|
||||
return -1;
|
||||
}
|
||||
return netxen_rdcrbreg(adapter, NETXEN_ROMUSB_ROM_RDATA);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void netxen_rom_unlock(struct netxen_adapter *adapter)
|
||||
{
|
||||
u32 val;
|
||||
@ -493,44 +449,6 @@ static void netxen_rom_unlock(struct netxen_adapter *adapter)
|
||||
|
||||
}
|
||||
|
||||
#if 0
|
||||
static int netxen_rom_wip_poll(struct netxen_adapter *adapter)
|
||||
{
|
||||
long timeout = 0;
|
||||
long wip = 1;
|
||||
int val;
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
|
||||
while (wip != 0) {
|
||||
val = netxen_do_rom_rdsr(adapter);
|
||||
wip = val & 1;
|
||||
timeout++;
|
||||
if (timeout > rom_max_timeout) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
|
||||
int data)
|
||||
{
|
||||
if (netxen_rom_wren(adapter)) {
|
||||
return -1;
|
||||
}
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_WDATA, data);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
|
||||
M25P_INSTR_PP);
|
||||
if (netxen_wait_rom_done(adapter)) {
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return netxen_rom_wip_poll(adapter);
|
||||
}
|
||||
#endif
|
||||
|
||||
static int do_rom_fast_read(struct netxen_adapter *adapter,
|
||||
int addr, int *valp)
|
||||
{
|
||||
@ -597,284 +515,6 @@ int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int netxen_rom_fast_write(struct netxen_adapter *adapter, int addr, int data)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
if (rom_lock(adapter) != 0) {
|
||||
return -1;
|
||||
}
|
||||
ret = do_rom_fast_write(adapter, addr, data);
|
||||
netxen_rom_unlock(adapter);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int do_rom_fast_write_words(struct netxen_adapter *adapter,
|
||||
int addr, u8 *bytes, size_t size)
|
||||
{
|
||||
int addridx = addr;
|
||||
int ret = 0;
|
||||
|
||||
while (addridx < (addr + size)) {
|
||||
int last_attempt = 0;
|
||||
int timeout = 0;
|
||||
int data;
|
||||
|
||||
data = le32_to_cpu((*(__le32*)bytes));
|
||||
ret = do_rom_fast_write(adapter, addridx, data);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
while(1) {
|
||||
int data1;
|
||||
|
||||
ret = do_rom_fast_read(adapter, addridx, &data1);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (data1 == data)
|
||||
break;
|
||||
|
||||
if (timeout++ >= rom_write_timeout) {
|
||||
if (last_attempt++ < 4) {
|
||||
ret = do_rom_fast_write(adapter,
|
||||
addridx, data);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
else {
|
||||
printk(KERN_INFO "Data write did not "
|
||||
"succeed at address 0x%x\n", addridx);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bytes += 4;
|
||||
addridx += 4;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int netxen_rom_fast_write_words(struct netxen_adapter *adapter, int addr,
|
||||
u8 *bytes, size_t size)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
ret = rom_lock(adapter);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = do_rom_fast_write_words(adapter, addr, bytes, size);
|
||||
netxen_rom_unlock(adapter);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int netxen_rom_wrsr(struct netxen_adapter *adapter, int data)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = netxen_rom_wren(adapter);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_ROM_WDATA, data);
|
||||
netxen_crb_writelit_adapter(adapter,
|
||||
NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0x1);
|
||||
|
||||
ret = netxen_wait_rom_done(adapter);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return netxen_rom_wip_poll(adapter);
|
||||
}
|
||||
|
||||
static int netxen_rom_rdsr(struct netxen_adapter *adapter)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = rom_lock(adapter);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = netxen_do_rom_rdsr(adapter);
|
||||
netxen_rom_unlock(adapter);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int netxen_backup_crbinit(struct netxen_adapter *adapter)
|
||||
{
|
||||
int ret = FLASH_SUCCESS;
|
||||
int val;
|
||||
char *buffer = kmalloc(NETXEN_FLASH_SECTOR_SIZE, GFP_KERNEL);
|
||||
|
||||
if (!buffer)
|
||||
return -ENOMEM;
|
||||
/* unlock sector 63 */
|
||||
val = netxen_rom_rdsr(adapter);
|
||||
val = val & 0xe3;
|
||||
ret = netxen_rom_wrsr(adapter, val);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
goto out_kfree;
|
||||
|
||||
ret = netxen_rom_wip_poll(adapter);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
goto out_kfree;
|
||||
|
||||
/* copy sector 0 to sector 63 */
|
||||
ret = netxen_rom_fast_read_words(adapter, NETXEN_CRBINIT_START,
|
||||
buffer, NETXEN_FLASH_SECTOR_SIZE);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
goto out_kfree;
|
||||
|
||||
ret = netxen_rom_fast_write_words(adapter, NETXEN_FIXED_START,
|
||||
buffer, NETXEN_FLASH_SECTOR_SIZE);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
goto out_kfree;
|
||||
|
||||
/* lock sector 63 */
|
||||
val = netxen_rom_rdsr(adapter);
|
||||
if (!(val & 0x8)) {
|
||||
val |= (0x1 << 2);
|
||||
/* lock sector 63 */
|
||||
if (netxen_rom_wrsr(adapter, val) == 0) {
|
||||
ret = netxen_rom_wip_poll(adapter);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
goto out_kfree;
|
||||
|
||||
/* lock SR writes */
|
||||
ret = netxen_rom_wip_poll(adapter);
|
||||
if (ret != FLASH_SUCCESS)
|
||||
goto out_kfree;
|
||||
}
|
||||
}
|
||||
|
||||
out_kfree:
|
||||
kfree(buffer);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int netxen_do_rom_se(struct netxen_adapter *adapter, int addr)
|
||||
{
|
||||
netxen_rom_wren(adapter);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE,
|
||||
M25P_INSTR_SE);
|
||||
if (netxen_wait_rom_done(adapter)) {
|
||||
netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
|
||||
return -1;
|
||||
}
|
||||
return netxen_rom_wip_poll(adapter);
|
||||
}
|
||||
|
||||
static void check_erased_flash(struct netxen_adapter *adapter, int addr)
|
||||
{
|
||||
int i;
|
||||
int val;
|
||||
int count = 0, erased_errors = 0;
|
||||
int range;
|
||||
|
||||
range = (addr == NETXEN_USER_START) ?
|
||||
NETXEN_FIXED_START : addr + NETXEN_FLASH_SECTOR_SIZE;
|
||||
|
||||
for (i = addr; i < range; i += 4) {
|
||||
netxen_rom_fast_read(adapter, i, &val);
|
||||
if (val != 0xffffffff)
|
||||
erased_errors++;
|
||||
count++;
|
||||
}
|
||||
|
||||
if (erased_errors)
|
||||
printk(KERN_INFO "0x%x out of 0x%x words fail to be erased "
|
||||
"for sector address: %x\n", erased_errors, count, addr);
|
||||
}
|
||||
|
||||
int netxen_rom_se(struct netxen_adapter *adapter, int addr)
|
||||
{
|
||||
int ret = 0;
|
||||
if (rom_lock(adapter) != 0) {
|
||||
return -1;
|
||||
}
|
||||
ret = netxen_do_rom_se(adapter, addr);
|
||||
netxen_rom_unlock(adapter);
|
||||
msleep(30);
|
||||
check_erased_flash(adapter, addr);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int netxen_flash_erase_sections(struct netxen_adapter *adapter,
|
||||
int start, int end)
|
||||
{
|
||||
int ret = FLASH_SUCCESS;
|
||||
int i;
|
||||
|
||||
for (i = start; i < end; i++) {
|
||||
ret = netxen_rom_se(adapter, i * NETXEN_FLASH_SECTOR_SIZE);
|
||||
if (ret)
|
||||
break;
|
||||
ret = netxen_rom_wip_poll(adapter);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int
|
||||
netxen_flash_erase_secondary(struct netxen_adapter *adapter)
|
||||
{
|
||||
int ret = FLASH_SUCCESS;
|
||||
int start, end;
|
||||
|
||||
start = NETXEN_SECONDARY_START / NETXEN_FLASH_SECTOR_SIZE;
|
||||
end = NETXEN_USER_START / NETXEN_FLASH_SECTOR_SIZE;
|
||||
ret = netxen_flash_erase_sections(adapter, start, end);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int
|
||||
netxen_flash_erase_primary(struct netxen_adapter *adapter)
|
||||
{
|
||||
int ret = FLASH_SUCCESS;
|
||||
int start, end;
|
||||
|
||||
start = NETXEN_PRIMARY_START / NETXEN_FLASH_SECTOR_SIZE;
|
||||
end = NETXEN_SECONDARY_START / NETXEN_FLASH_SECTOR_SIZE;
|
||||
ret = netxen_flash_erase_sections(adapter, start, end);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void netxen_halt_pegs(struct netxen_adapter *adapter)
|
||||
{
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0x3c, 1);
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0x3c, 1);
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0x3c, 1);
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0x3c, 1);
|
||||
}
|
||||
|
||||
int netxen_flash_unlock(struct netxen_adapter *adapter)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
ret = netxen_rom_wrsr(adapter, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = netxen_rom_wren(adapter);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
#define NETXEN_BOARDTYPE 0x4008
|
||||
#define NETXEN_BOARDNUM 0x400c
|
||||
#define NETXEN_CHIPNUM 0x4010
|
||||
|
||||
@ -299,14 +299,6 @@ int netxen_niu_gbe_disable_phy_interrupts(struct netxen_adapter *adapter)
|
||||
return result;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int netxen_niu_xgbe_clear_phy_interrupts(struct netxen_adapter *adapter)
|
||||
{
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_NIU_ACTIVE_INT, -1);
|
||||
return 0;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
static int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
|
||||
{
|
||||
int result = 0;
|
||||
@ -467,104 +459,6 @@ int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/*
|
||||
* netxen_niu_gbe_handle_phy_interrupt - Handles GbE PHY interrupts
|
||||
* @param enable 0 means don't enable the port
|
||||
* 1 means enable (or re-enable) the port
|
||||
*/
|
||||
int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
|
||||
int port, long enable)
|
||||
{
|
||||
int result = 0;
|
||||
__u32 int_src;
|
||||
|
||||
printk(KERN_INFO PFX "NETXEN: Handling PHY interrupt on port %d"
|
||||
" (device enable = %d)\n", (int)port, (int)enable);
|
||||
|
||||
/*
|
||||
* The read of the PHY INT status will clear the pending
|
||||
* interrupt status
|
||||
*/
|
||||
if (netxen_niu_gbe_phy_read(adapter,
|
||||
NETXEN_NIU_GB_MII_MGMT_ADDR_INT_STATUS,
|
||||
&int_src) != 0)
|
||||
result = -EINVAL;
|
||||
else {
|
||||
printk(KERN_INFO PFX "PHY Interrupt source = 0x%x \n", int_src);
|
||||
if (netxen_get_phy_int_jabber(int_src))
|
||||
printk(KERN_INFO PFX "jabber Interrupt ");
|
||||
if (netxen_get_phy_int_polarity_changed(int_src))
|
||||
printk(KERN_INFO PFX "polarity changed ");
|
||||
if (netxen_get_phy_int_energy_detect(int_src))
|
||||
printk(KERN_INFO PFX "energy detect \n");
|
||||
if (netxen_get_phy_int_downshift(int_src))
|
||||
printk(KERN_INFO PFX "downshift \n");
|
||||
if (netxen_get_phy_int_mdi_xover_changed(int_src))
|
||||
printk(KERN_INFO PFX "mdi_xover_changed ");
|
||||
if (netxen_get_phy_int_fifo_over_underflow(int_src))
|
||||
printk(KERN_INFO PFX "fifo_over_underflow ");
|
||||
if (netxen_get_phy_int_false_carrier(int_src))
|
||||
printk(KERN_INFO PFX "false_carrier ");
|
||||
if (netxen_get_phy_int_symbol_error(int_src))
|
||||
printk(KERN_INFO PFX "symbol_error ");
|
||||
if (netxen_get_phy_int_autoneg_completed(int_src))
|
||||
printk(KERN_INFO PFX "autoneg_completed ");
|
||||
if (netxen_get_phy_int_page_received(int_src))
|
||||
printk(KERN_INFO PFX "page_received ");
|
||||
if (netxen_get_phy_int_duplex_changed(int_src))
|
||||
printk(KERN_INFO PFX "duplex_changed ");
|
||||
if (netxen_get_phy_int_autoneg_error(int_src))
|
||||
printk(KERN_INFO PFX "autoneg_error ");
|
||||
if ((netxen_get_phy_int_speed_changed(int_src))
|
||||
|| (netxen_get_phy_int_link_status_changed(int_src))) {
|
||||
__u32 status;
|
||||
|
||||
printk(KERN_INFO PFX
|
||||
"speed_changed or link status changed");
|
||||
if (netxen_niu_gbe_phy_read
|
||||
(adapter,
|
||||
NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
|
||||
&status) == 0) {
|
||||
if (netxen_get_phy_speed(status) == 2) {
|
||||
printk
|
||||
(KERN_INFO PFX "Link speed changed"
|
||||
" to 1000 Mbps\n");
|
||||
netxen_niu_gbe_set_gmii_mode(adapter,
|
||||
port,
|
||||
enable);
|
||||
} else if (netxen_get_phy_speed(status) == 1) {
|
||||
printk
|
||||
(KERN_INFO PFX "Link speed changed"
|
||||
" to 100 Mbps\n");
|
||||
netxen_niu_gbe_set_mii_mode(adapter,
|
||||
port,
|
||||
enable);
|
||||
} else if (netxen_get_phy_speed(status) == 0) {
|
||||
printk
|
||||
(KERN_INFO PFX "Link speed changed"
|
||||
" to 10 Mbps\n");
|
||||
netxen_niu_gbe_set_mii_mode(adapter,
|
||||
port,
|
||||
enable);
|
||||
} else {
|
||||
printk(KERN_ERR PFX "ERROR reading "
|
||||
"PHY status. Invalid speed.\n");
|
||||
result = -1;
|
||||
}
|
||||
} else {
|
||||
printk(KERN_ERR PFX
|
||||
"ERROR reading PHY status.\n");
|
||||
result = -1;
|
||||
}
|
||||
|
||||
}
|
||||
printk(KERN_INFO "\n");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
/*
|
||||
* Return the current station MAC address.
|
||||
* Note that the passed-in value must already be in network byte order.
|
||||
@ -641,86 +535,6 @@ int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* Enable a GbE interface */
|
||||
int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
|
||||
int port, netxen_niu_gbe_ifmode_t mode)
|
||||
{
|
||||
__u32 mac_cfg0;
|
||||
__u32 mac_cfg1;
|
||||
__u32 mii_cfg;
|
||||
|
||||
if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
|
||||
return -EINVAL;
|
||||
|
||||
mac_cfg0 = 0;
|
||||
netxen_gb_soft_reset(mac_cfg0);
|
||||
if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
|
||||
&mac_cfg0, 4))
|
||||
return -EIO;
|
||||
mac_cfg0 = 0;
|
||||
netxen_gb_enable_tx(mac_cfg0);
|
||||
netxen_gb_enable_rx(mac_cfg0);
|
||||
netxen_gb_unset_rx_flowctl(mac_cfg0);
|
||||
netxen_gb_tx_reset_pb(mac_cfg0);
|
||||
netxen_gb_rx_reset_pb(mac_cfg0);
|
||||
netxen_gb_tx_reset_mac(mac_cfg0);
|
||||
netxen_gb_rx_reset_mac(mac_cfg0);
|
||||
|
||||
if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
|
||||
&mac_cfg0, 4))
|
||||
return -EIO;
|
||||
mac_cfg1 = 0;
|
||||
netxen_gb_set_preamblelen(mac_cfg1, 0xf);
|
||||
netxen_gb_set_duplex(mac_cfg1);
|
||||
netxen_gb_set_crc_enable(mac_cfg1);
|
||||
netxen_gb_set_padshort(mac_cfg1);
|
||||
netxen_gb_set_checklength(mac_cfg1);
|
||||
netxen_gb_set_hugeframes(mac_cfg1);
|
||||
|
||||
if (mode == NETXEN_NIU_10_100_MB) {
|
||||
netxen_gb_set_intfmode(mac_cfg1, 1);
|
||||
if (adapter->hw_write_wx(adapter,
|
||||
NETXEN_NIU_GB_MAC_CONFIG_1(port),
|
||||
&mac_cfg1, 4))
|
||||
return -EIO;
|
||||
|
||||
/* set mii mode */
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_GMII_MODE +
|
||||
(port << 3), 0);
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_MII_MODE +
|
||||
(port << 3), 1);
|
||||
|
||||
} else if (mode == NETXEN_NIU_1000_MB) {
|
||||
netxen_gb_set_intfmode(mac_cfg1, 2);
|
||||
if (adapter->hw_write_wx(adapter,
|
||||
NETXEN_NIU_GB_MAC_CONFIG_1(port),
|
||||
&mac_cfg1, 4))
|
||||
return -EIO;
|
||||
/* set gmii mode */
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_MII_MODE +
|
||||
(port << 3), 0);
|
||||
netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB0_GMII_MODE +
|
||||
(port << 3), 1);
|
||||
}
|
||||
mii_cfg = 0;
|
||||
netxen_gb_set_mii_mgmt_clockselect(mii_cfg, 7);
|
||||
if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port),
|
||||
&mii_cfg, 4))
|
||||
return -EIO;
|
||||
mac_cfg0 = 0;
|
||||
netxen_gb_enable_tx(mac_cfg0);
|
||||
netxen_gb_enable_rx(mac_cfg0);
|
||||
netxen_gb_unset_rx_flowctl(mac_cfg0);
|
||||
netxen_gb_unset_tx_flowctl(mac_cfg0);
|
||||
|
||||
if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
|
||||
&mac_cfg0, 4))
|
||||
return -EIO;
|
||||
return 0;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
/* Disable a GbE interface */
|
||||
int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
|
||||
{
|
||||
@ -869,39 +683,6 @@ int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/*
|
||||
* Return the current station MAC address.
|
||||
* Note that the passed-in value must already be in network byte order.
|
||||
*/
|
||||
int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter,
|
||||
netxen_ethernet_macaddr_t * addr)
|
||||
{
|
||||
int phy = adapter->physical_port;
|
||||
u32 stationhigh;
|
||||
u32 stationlow;
|
||||
u8 val[8];
|
||||
|
||||
if (addr == NULL)
|
||||
return -EINVAL;
|
||||
if (phy != 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (adapter->hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
|
||||
&stationhigh, 4))
|
||||
return -EIO;
|
||||
if (adapter->hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
|
||||
&stationlow, 4))
|
||||
return -EIO;
|
||||
((__le32 *)val)[1] = cpu_to_le32(stationhigh);
|
||||
((__le32 *)val)[0] = cpu_to_le32(stationlow);
|
||||
|
||||
memcpy(addr, val + 2, 6);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
|
||||
u32 mode)
|
||||
{
|
||||
|
||||
Loading…
Reference in New Issue
Block a user