/*
* Copyright (C) 2012 Adrian Jamróz <adrian.jamroz@gmail.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
FILE_LICENCE ( GPL2_OR_LATER );
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
#include <ipxe/malloc.h>
#include <ipxe/pci.h>
#include <ipxe/mii.h>
#include "velocity.h"
#define velocity_setbit(_reg, _mask) writeb ( readb ( _reg ) | _mask, _reg )
#define virt_to_le32bus(x) ( cpu_to_le32 ( virt_to_bus ( x ) ) )
/** @file
*
* VIA Velocity network driver
*
*/
/******************************************************************************
*
* MII interface
*
******************************************************************************
*/
/**
* Stop MII auto-polling
*
* @v vlc Velocity device
* @ret rc Return status code
*/
static int velocity_autopoll_stop ( struct velocity_nic *vlc ) {
int timeout = VELOCITY_TIMEOUT_US;
/* Disable MII auto polling */
writeb ( 0, vlc->regs + VELOCITY_MIICR );
/* Wait for disabling to take effect */
while ( timeout-- ) {
udelay ( 1 );
if ( readb ( vlc->regs + VELOCITY_MIISR ) &
VELOCITY_MIISR_IDLE )
return 0;
}
DBGC ( vlc, "MII autopoll stop timeout\n" );
return -ETIMEDOUT;
}
/**
* Start MII auto-polling
*
* @v vlc Velocity device
* @ret rc Return status code
*/
static int velocity_autopoll_start ( struct velocity_nic *vlc ) {
int timeout = VELOCITY_TIMEOUT_US;
/* Enable MII auto polling */
writeb ( VELOCITY_MIICR_MAUTO, vlc->regs + VELOCITY_MIICR );
/* Wait for enabling to take effect */
while ( timeout-- ) {
udelay ( 1 );
if ( ( readb ( vlc->regs + VELOCITY_MIISR ) &
VELOCITY_MIISR_IDLE ) == 0 )
return 0;
}
DBGC ( vlc, "MII autopoll start timeout\n" );
return -ETIMEDOUT;
}
/**
* Read from MII register
*
* @v mdio MII interface
* @v phy PHY address
* @v reg Register address
* @ret value Data read, or negative error
*/
static int velocity_mii_read ( struct mii_interface *mdio,
unsigned int phy __unused, unsigned int reg ) {
struct velocity_nic *vlc =
container_of ( mdio, struct velocity_nic, mdio );
int timeout = VELOCITY_TIMEOUT_US;
int result;
DBGC2 ( vlc, "VELOCITY %p MII read reg %d\n", vlc, reg );
/* Disable autopolling before we can access MII */
velocity_autopoll_stop ( vlc );
/* Send read command and address */
writeb ( reg, vlc->regs + VELOCITY_MIIADDR );
velocity_setbit ( vlc->regs + VELOCITY_MIICR, VELOCITY_MIICR_RCMD );
/* Wait for read to complete */
while ( timeout-- ) {
udelay ( 1 );
if ( ( readb ( vlc->regs + VELOCITY_MIICR ) &
VELOCITY_MIICR_RCMD ) == 0 ) {
result = readw ( vlc->regs + VELOCITY_MIIDATA );
velocity_autopoll_start ( vlc );
return result;
}
}
/* Restart autopolling */
velocity_autopoll_start ( vlc );
DBGC ( vlc, "MII read timeout\n" );
return -ETIMEDOUT;
}
/**
* Write to MII register
*
* @v mdio MII interface
* @v phy PHY address
* @v reg Register address
* @v data Data to write
* @ret rc Return status code
*/
static int velocity_mii_write ( struct mii_interface *mdio,
unsigned int phy __unused, unsigned int reg,
unsigned int data) {
struct velocity_nic *vlc =
container_of ( mdio, struct velocity_nic, mdio );
int timeout = VELOCITY_TIMEOUT_US;
DBGC2 ( vlc, "VELOCITY %p MII write reg %d data 0x%04x\n",
vlc, reg, data );
/* Disable autopolling before we can access MII */
velocity_autopoll_stop ( vlc );
/* Send write command, data and destination register */
writeb ( reg, vlc->regs + VELOCITY_MIIADDR );
writew ( data, vlc->regs + VELOCITY_MIIDATA );
velocity_setbit ( vlc->regs + VELOCITY_MIICR, VELOCITY_MIICR_WCMD );
/* Wait for write to complete */
while ( timeout-- ) {
udelay ( 1 );
if ( ( readb ( vlc->regs + VELOCITY_MIICR ) &
VELOCITY_MIICR_WCMD ) == 0 ) {
velocity_autopoll_start ( vlc );
return 0;
}
}
/* Restart autopolling */
velocity_autopoll_start ( vlc );
DBGC ( vlc, "MII write timeout\n" );
return -ETIMEDOUT;
}
/** Velocity MII operations */
static struct mii_operations velocity_mii_operations = {
.read = velocity_mii_read,
.write = velocity_mii_write,
};
/**
* Set Link speed
*
* @v vlc Velocity device
*/
static void velocity_set_link ( struct velocity_nic *vlc ) {
int tmp;
/* Advertise 1000MBit */
tmp = mii_read ( &vlc->mii, MII_CTRL1000 );
tmp |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
mii_write ( &vlc->mii, MII_CTRL1000, tmp );
/* Enable GBit operation in MII Control Register */
tmp = mii_read ( &vlc->mii, MII_BMCR );
tmp |= BMCR_SPEED1000;
mii_write ( &vlc->mii, MII_BMCR, tmp );
}
/******************************************************************************
*
* Device reset
*
******************************************************************************
*/
/**
* Reload eeprom contents
*
* @v vlc Velocity device
*/
static int velocity_reload_eeprom ( struct velocity_nic *vlc ) {
int timeout = VELOCITY_TIMEOUT_US;
/* Initiate reload */
velocity_setbit ( vlc->regs + VELOCITY_EECSR, VELOCITY_EECSR_RELOAD );
/* Wait for reload to complete */
while ( timeout-- ) {
udelay ( 1 );
if ( ( readb ( vlc->regs + VELOCITY_EECSR ) &
VELOCITY_EECSR_RELOAD ) == 0 )
return 0;
}
DBGC ( vlc, "VELOCITY %p EEPROM reload timeout\n", vlc );
return -ETIMEDOUT;
}
/**
* Reset hardware
*
* @v vlc Velocity device
* @ret rc Return status code
*/
static int velocity_reset ( struct velocity_nic *vlc ) {
int timeout = VELOCITY_TIMEOUT_US;
uint8_t tmp;
DBGC ( vlc, "VELOCITY %p reset\n", vlc );
/* clear sticky Power state bits */
tmp = readb ( vlc->regs + VELOCITY_STICKY );
tmp &= ~( VELOCITY_STICKY_DS0 | VELOCITY_STICKY_DS1 );
writeb ( tmp, vlc->regs + VELOCITY_STICKY );
/* clear PACPI, which might have been enabled by the EEPROM reload */
tmp = readb ( vlc->regs + VELOCITY_CFGA );
tmp &= ~VELOCITY_CFGA_PACPI;
writeb ( tmp, vlc->regs + VELOCITY_CFGA );
velocity_setbit ( vlc->regs + VELOCITY_CRS1, VELOCITY_CR1_SFRST );
/* Wait for reset to complete */
while ( timeout-- ) {
udelay ( 1 );
if ( ( readb ( vlc->regs + VELOCITY_CRS1 ) &
VELOCITY_CR1_SFRST ) == 0 )
return 0;
}
return -EINVAL;
}
/******************************************************************************
*
* Link state
*
******************************************************************************
*/
/**
* Check link state
*
* @v netdev Network device
*/
static void velocity_check_link ( struct net_device *netdev ) {
struct velocity_nic *vlc = netdev->priv;
if ( readb ( vlc->regs + VELOCITY_PHYSTS0 ) & VELOCITY_PHYSTS0_LINK ) {
netdev_link_up ( netdev );
DBGC ( vlc, "VELOCITY %p link up\n", vlc );
} else {
netdev_link_down ( netdev );
DBGC ( vlc, "VELOCITY %p link down\n", vlc );
}
/* The card disables auto-poll after a link change */
velocity_autopoll_start ( vlc );
}
/******************************************************************************
*
* Network device interface
*
******************************************************************************
*/
/**
* Allocate descriptor rings
*
* @v vlc Velocity device
* @ret rc Return status code
*/
static int velocity_alloc_rings ( struct velocity_nic *vlc ) {
int rc = 0;
/* Allocate RX descriptor ring */
vlc->rx_prod = 0;
vlc->rx_cons = 0;
vlc->rx_commit = 0;
vlc->rx_ring = malloc_phys ( VELOCITY_RXDESC_SIZE,
VELOCITY_RING_ALIGN );
if ( ! vlc->rx_ring )
return -ENOMEM;
memset ( vlc->rx_ring, 0, VELOCITY_RXDESC_SIZE );
DBGC2 ( vlc, "VELOCITY %p RX ring start address: %p(phys: %#08lx)\n",
vlc, vlc->rx_ring, virt_to_bus ( vlc->rx_ring ) );
/* Allocate TX descriptor ring */
vlc->tx_prod = 0;
vlc->tx_cons = 0;
vlc->tx_ring = malloc_phys ( VELOCITY_TXDESC_SIZE,
VELOCITY_RING_ALIGN );
if ( ! vlc->tx_ring ) {
rc = -ENOMEM;
goto err_tx_alloc;
}
memset ( vlc->tx_ring, 0, VELOCITY_TXDESC_SIZE );
/* Send RX ring to the card */
writel ( virt_to_bus ( vlc->rx_ring ),
vlc->regs + VELOCITY_RXDESC_ADDR_LO );
writew ( VELOCITY_RXDESC_NUM - 1, vlc->regs + VELOCITY_RXDESCNUM );
/* Send TX ring to the card */
writel ( virt_to_bus ( vlc->tx_ring ),
vlc->regs + VELOCITY_TXDESC_ADDR_LO0 );
writew ( VELOCITY_TXDESC_NUM - 1, vlc->regs + VELOCITY_TXDESCNUM );
DBGC2 ( vlc, "VELOCITY %p TX ring start address: %p(phys: %#08lx)\n",
vlc, vlc->tx_ring, virt_to_bus ( vlc->tx_ring ) );
return 0;
err_tx_alloc:
free_phys ( vlc->rx_ring, VELOCITY_RXDESC_SIZE );
return rc;
}
/**
* Refill receive descriptor ring
*
* @v vlc Velocity device
*/
static void velocity_refill_rx ( struct velocity_nic *vlc ) {
struct velocity_rx_descriptor *desc;
struct io_buffer *iobuf;
int rx_idx, i = 0;
/* Check for new packets */
while ( ( vlc->rx_prod - vlc->rx_cons ) < VELOCITY_RXDESC_NUM ) {
iobuf = alloc_iob ( VELOCITY_RX_MAX_LEN );
/* Memory pressure: try again next poll */
if ( ! iobuf )
break;
rx_idx = ( vlc->rx_prod++ % VELOCITY_RXDESC_NUM );
desc = &vlc->rx_ring[rx_idx];
/* Set descrptor fields */
desc->des1 = 0;
desc->addr = virt_to_le32bus ( iobuf-> data );
desc->des2 = cpu_to_le32 (
VELOCITY_DES2_SIZE ( VELOCITY_RX_MAX_LEN - 1 ) |
VELOCITY_DES2_IC );
vlc->rx_buffs[rx_idx] = iobuf;
i++;
/* Return RX descriptors in blocks of 4 (hw requirement) */
if ( rx_idx % 4 == 3 ) {
int j;
for (j = 0; j < 4; j++) {
desc = &vlc->rx_ring[rx_idx - j];
desc->des0 = cpu_to_le32 ( VELOCITY_DES0_OWN );
}
vlc->rx_commit += 4;
}
}
wmb();
if ( vlc->rx_commit ) {
writew ( vlc->rx_commit,
vlc->regs + VELOCITY_RXDESC_RESIDUECNT );
vlc->rx_commit = 0;
}
if ( i > 0 )
DBGC2 ( vlc, "VELOCITY %p refilled %d RX descriptors\n",
vlc, i );
}
/**
* Open network device
*
* @v netdev Network device
* @ret rc Return status code
*/
static int velocity_open ( struct net_device *netdev ) {
struct velocity_nic *vlc = netdev->priv;
int rc;
DBGC ( vlc, "VELOCITY %p open\n", vlc );
DBGC ( vlc, "VELOCITY %p regs at: %p\n", vlc, vlc->regs );
/* Allocate descriptor rings */
if ( ( rc = velocity_alloc_rings ( vlc ) ) != 0 )
return rc;
velocity_refill_rx ( vlc );
/* Enable TX/RX queue */
writew ( VELOCITY_TXQCSRS_RUN0, vlc->regs + VELOCITY_TXQCSRS );
writew ( VELOCITY_RXQCSR_RUN | VELOCITY_RXQCSR_WAK,
vlc->regs + VELOCITY_RXQCSRS );
/* Enable interrupts */
writeb ( 0xff, vlc->regs + VELOCITY_IMR0 );
writeb ( 0xff, vlc->regs + VELOCITY_IMR1 );
/* Start MAC */
writeb ( VELOCITY_CR0_STOP, vlc->regs + VELOCITY_CRC0 );
writeb ( VELOCITY_CR1_DPOLL, vlc->regs + VELOCITY_CRC0 );
writeb ( VELOCITY_CR0_START | VELOCITY_CR0_TXON | VELOCITY_CR0_RXON,
vlc->regs + VELOCITY_CRS0 );
/* Receive all packets */
writeb ( 0xff, vlc->regs + VELOCITY_RCR );
/* Set initial link state */
velocity_check_link ( netdev );
velocity_autopoll_start ( vlc );
DBGC2 ( vlc, "VELOCITY %p CR3 %02x\n",
vlc, readb ( vlc->regs + 0x0B ) );
return 0;
}
/**
* Close network device
*
* @v netdev Network device
*/
static void velocity_close ( struct net_device *netdev ) {
struct velocity_nic *vlc = netdev->priv;
int i;
/* Stop NIC */
writeb ( VELOCITY_CR0_TXON | VELOCITY_CR0_RXON,
vlc->regs + VELOCITY_CRC0 );
writeb ( VELOCITY_CR0_STOP, vlc->regs + VELOCITY_CRS0 );
/* Clear RX ring information */
writel ( 0, vlc->regs + VELOCITY_RXDESC_ADDR_LO );
writew ( 0, vlc->regs + VELOCITY_RXDESCNUM );
/* Destroy RX ring */
free_phys ( vlc->rx_ring, VELOCITY_RXDESC_SIZE );
vlc->rx_ring = NULL;
vlc->rx_prod = 0;
vlc->rx_cons = 0;
/* Discard receive buffers */
for ( i = 0 ; i < VELOCITY_RXDESC_NUM ; i++ ) {
if ( vlc->rx_buffs[i] )
free_iob ( vlc->rx_buffs[i] );
vlc->rx_buffs[i] = NULL;
}
/* Clear TX ring information */
writel ( 0, vlc->regs + VELOCITY_TXDESC_ADDR_LO0 );
writew ( 0, vlc->regs + VELOCITY_TXDESCNUM );
/* Destroy TX ring */
free_phys ( vlc->tx_ring, VELOCITY_TXDESC_SIZE );
vlc->tx_ring = NULL;
vlc->tx_prod = 0;
vlc->tx_cons = 0;
}
/**
* Transmit packet
*
* @v netdev Network device
* @v iobuf I/O buffer
* @ret rc Return status code
*/
static int velocity_transmit ( struct net_device *netdev,
struct io_buffer *iobuf ) {
struct velocity_nic *vlc = netdev->priv;
struct velocity_tx_descriptor *desc;
unsigned int tx_idx;
/* Pad packet to minimum length */
iob_pad ( iobuf, ETH_ZLEN );
tx_idx = ( vlc->tx_prod++ % VELOCITY_TXDESC_NUM );
desc = &vlc->tx_ring[tx_idx];
/* Set packet size and transfer ownership to NIC */
desc->des0 = cpu_to_le32 ( VELOCITY_DES0_OWN |
VELOCITY_DES2_SIZE ( iob_len ( iobuf ) ) );
/* Data in first desc fragment, only desc for packet, generate INT */
desc->des1 = cpu_to_le32 ( VELOCITY_DES1_FRAG ( 1 ) |
VELOCITY_DES1_TCPLS |
VELOCITY_DES1_INTR );
desc->frags[0].addr = virt_to_le32bus ( iobuf->data );
desc->frags[0].des2 = cpu_to_le32 (
VELOCITY_DES2_SIZE ( iob_len ( iobuf ) ) );
wmb();
/* Initiate TX */
velocity_setbit ( vlc->regs + VELOCITY_TXQCSRS, VELOCITY_TXQCSRS_WAK0 );
DBGC2 ( vlc, "VELOCITY %p tx_prod=%d desc=%p iobuf=%p len=%zd\n",
vlc, tx_idx, desc, iobuf->data, iob_len ( iobuf ) );
return 0;
}
/**
* Poll for received packets.
*
* @v vlc Velocity device
*/
static void velocity_poll_rx ( struct velocity_nic *vlc ) {
struct velocity_rx_descriptor *desc;
struct io_buffer *iobuf;
int rx_idx;
size_t len;
uint32_t des0;
/* Check for packets */
while ( vlc->rx_cons != vlc->rx_prod ) {
rx_idx = ( vlc->rx_cons % VELOCITY_RXDESC_NUM );
desc = &vlc->rx_ring[rx_idx];
des0 = cpu_to_le32 ( desc->des0 );
/* Return if descriptor still in use */
if ( des0 & VELOCITY_DES0_OWN )
return;
iobuf = vlc->rx_buffs[rx_idx];
/* Get length, strip CRC */
len = VELOCITY_DES0_RMBC ( des0 ) - 4;
iob_put ( iobuf, len );
DBGC2 ( vlc, "VELOCITY %p got packet on idx=%d (prod=%d), len %zd\n",
vlc, rx_idx, vlc->rx_prod % VELOCITY_RXDESC_NUM, len );
if ( des0 & VELOCITY_DES0_RX_ERR ) {
/* Report receive error */
netdev_rx_err ( vlc->netdev, iobuf, -EINVAL );
DBGC ( vlc, "VELOCITY %p receive error, status: %02x\n",
vlc, des0 );
} else if ( des0 & VELOCITY_DES0_RXOK ) {
/* Report receive success */
netdev_rx( vlc->netdev, iobuf );
} else {
/* Card indicated neither success nor failure
* Technically this shouldn't happen, but we saw it
* in debugging once. */
DBGC ( vlc, "VELOCITY %p RX neither ERR nor OK: %04x\n",
vlc, des0 );
DBGC ( vlc, "packet len: %zd\n", len );
DBGC_HD ( vlc, iobuf->data, 64 );
/* we don't know what it is, treat is as an error */
netdev_rx_err ( vlc->netdev, iobuf, -EINVAL );
}
vlc->rx_cons++;
}
}
/**
* Poll for completed packets.
*
* @v vlc Velocity device
*/
static void velocity_poll_tx ( struct velocity_nic *vlc ) {
struct velocity_tx_descriptor *desc;
int tx_idx;
/* Check for packets */
while ( vlc->tx_cons != vlc->tx_prod ) {
tx_idx = ( vlc->tx_cons % VELOCITY_TXDESC_NUM );
desc = &vlc->tx_ring[tx_idx];
/* Return if descriptor still in use */
if ( le32_to_cpu ( desc->des0 ) & VELOCITY_DES0_OWN )
return;
/* Report errors */
if ( le32_to_cpu ( desc->des0 ) & VELOCITY_DES0_TERR ) {
netdev_tx_complete_next_err ( vlc->netdev, -EINVAL );
return;
}
netdev_tx_complete_next ( vlc->netdev );
DBGC2 ( vlc, "VELOCITY %p poll_tx cons=%d prod=%d tsr=%04x\n",
vlc, tx_idx, vlc->tx_prod % VELOCITY_TXDESC_NUM,
( desc->des0 & 0xffff ) );
vlc->tx_cons++;
}
}
/**
* Poll for completed and received packets
*
* @v netdev Network device
*/
static void velocity_poll ( struct net_device *netdev ) {
struct velocity_nic *vlc = netdev->priv;
uint8_t isr1;
isr1 = readb ( vlc->regs + VELOCITY_ISR1 );
/* ACK interrupts */
writew ( 0xFFFF, vlc->regs + VELOCITY_ISR0 );
/* Check for competed packets */
velocity_poll_rx ( vlc );
velocity_poll_tx ( vlc );
if ( isr1 & VELOCITY_ISR1_SRCI ) {
/* Update linkstate */
DBGC2 ( vlc, "VELOCITY %p link status interrupt\n", vlc );
velocity_check_link ( netdev );
}
velocity_refill_rx ( vlc );
/* deal with potential RX stall caused by RX ring underrun */
writew ( VELOCITY_RXQCSR_RUN | VELOCITY_RXQCSR_WAK,
vlc->regs + VELOCITY_RXQCSRS );
}
/**
* Enable or disable interrupts
*
* @v netdev Network device
* @v enable Interrupts should be enabled
*/
static void velocity_irq ( struct net_device *netdev, int enable ) {
struct velocity_nic *vlc = netdev->priv;
DBGC ( vlc, "VELOCITY %p interrupts %s\n", vlc,
enable ? "enable" : "disable" );
if (enable) {
/* Enable interrupts */
writeb ( VELOCITY_CR3_GINTMSK1, vlc->regs + VELOCITY_CRS3 );
} else {
/* Disable interrupts */
writeb ( VELOCITY_CR3_GINTMSK1, vlc->regs + VELOCITY_CRC3 );
}
}
/** Velocity network device operations */
static struct net_device_operations velocity_operations = {
.open = velocity_open,
.close = velocity_close,
.transmit = velocity_transmit,
.poll = velocity_poll,
.irq = velocity_irq,
};
/******************************************************************************
*
* PCI interface
*
******************************************************************************
*/
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int velocity_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct velocity_nic *vlc;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *vlc ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &velocity_operations );
vlc = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
vlc->regs = pci_ioremap ( pci, pci->membase, VELOCITY_BAR_SIZE );
vlc->netdev = netdev;
/* Reset the NIC */
if ( ( rc = velocity_reset ( vlc ) ) != 0 )
goto err_reset;
/* Reload EEPROM */
if ( ( rc = velocity_reload_eeprom ( vlc ) ) != 0 )
goto err_reset;
/* Get MAC address */
netdev->hw_addr[0] = readb ( vlc->regs + VELOCITY_MAC0 );
netdev->hw_addr[1] = readb ( vlc->regs + VELOCITY_MAC1 );
netdev->hw_addr[2] = readb ( vlc->regs + VELOCITY_MAC2 );
netdev->hw_addr[3] = readb ( vlc->regs + VELOCITY_MAC3 );
netdev->hw_addr[4] = readb ( vlc->regs + VELOCITY_MAC4 );
netdev->hw_addr[5] = readb ( vlc->regs + VELOCITY_MAC5 );
/* Initialise and reset MII interface */
mdio_init ( &vlc->mdio, &velocity_mii_operations );
mii_init ( &vlc->mii, &vlc->mdio, 0 );
if ( ( rc = mii_reset ( &vlc->mii ) ) != 0 ) {
DBGC ( vlc, "VELOCITY %p could not reset MII: %s\n",
vlc, strerror ( rc ) );
goto err_mii_reset;
}
/* Enable proper link advertising */
velocity_set_link ( vlc );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
return 0;
err_register_netdev:
err_mii_reset:
velocity_reset ( vlc );
err_reset:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void velocity_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct velocity_nic *vlc = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset card */
velocity_reset ( vlc );
/* Free network device */
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/** Velocity PCI device IDs */
static struct pci_device_id velocity_nics[] = {
PCI_ROM ( 0x1106, 0x3119, "vt6122", "VIA Velocity", 0 ),
};
/** Velocity PCI driver */
struct pci_driver velocity_driver __pci_driver = {
.ids = velocity_nics,
.id_count = ( sizeof ( velocity_nics ) / sizeof ( velocity_nics[0] ) ),
.probe = velocity_probe,
.remove = velocity_remove,
};
