/
githubmirror
/
ipxe
Обзор
Документация
Войти
/
githubmirror
/
ipxe
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
src/drivers/net/velocity.c
814 строк
20 KB
Michael Brown
[velocity] Correct direction of endianness conversion
04 авг 2026, 10:46
04 авг 2026, 10:46
897c87a
Код
Авторство
О чём код?
/* * 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 = le32_to_cpu ( 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, };