src/drivers/net/rtl8139.c

   1 /* rtl8139.c - etherboot driver for the Realtek 8139 chipset
   2
   3   ported from the linux driver written by Donald Becker
   4   by Rainer Bawidamann (Rainer.Bawidamann@informatik.uni-ulm.de) 1999
   5
   6   This software may be used and distributed according to the terms
   7   of the GNU Public License, incorporated herein by reference.
   8
   9   changes to the original driver:
  10   - removed support for interrupts, switching to polling mode (yuck!)
  11   - removed support for the 8129 chip (external MII)
  12
  13 */
  14
  15 /*********************************************************************/
  16 /* Revision History                                                  */
  17 /*********************************************************************/
  18
  19 /*
  20   27 May 2006   mcb30@users.sourceforge.net (Michael Brown)
  21      Rewrote to use the new net driver API, the updated PCI API, and
  22      the generic three-wire serial device support for EEPROM access.
  23
  24   28 Dec 2002   ken_yap@users.sourceforge.net (Ken Yap)
  25      Put in virt_to_bus calls to allow Etherboot relocation.
  26
  27   06 Apr 2001   ken_yap@users.sourceforge.net (Ken Yap)
  28      Following email from Hyun-Joon Cha, added a disable routine, otherwise
  29      NIC remains live and can crash the kernel later.
  30
  31   4 Feb 2000    espenlaub@informatik.uni-ulm.de (Klaus Espenlaub)
  32      Shuffled things around, removed the leftovers from the 8129 support
  33      that was in the Linux driver and added a bit more 8139 definitions.
  34      Moved the 8K receive buffer to a fixed, available address outside the
  35      0x98000-0x9ffff range.  This is a bit of a hack, but currently the only
  36      way to make room for the Etherboot features that need substantial amounts
  37      of code like the ANSI console support.  Currently the buffer is just below
  38      0x10000, so this even conforms to the tagged boot image specification,
  39      which reserves the ranges 0x00000-0x10000 and 0x98000-0xA0000.  My
  40      interpretation of this "reserved" is that Etherboot may do whatever it
  41      likes, as long as its environment is kept intact (like the BIOS
  42      variables).  Hopefully fixed rtl_poll() once and for all.  The symptoms
  43      were that if Etherboot was left at the boot menu for several minutes, the
  44      first eth_poll failed.  Seems like I am the only person who does this.
  45      First of all I fixed the debugging code and then set out for a long bug
  46      hunting session.  It took me about a week full time work - poking around
  47      various places in the driver, reading Don Becker's and Jeff Garzik's Linux
  48      driver and even the FreeBSD driver (what a piece of crap!) - and
  49      eventually spotted the nasty thing: the transmit routine was acknowledging
  50      each and every interrupt pending, including the RxOverrun and RxFIFIOver
  51      interrupts.  This confused the RTL8139 thoroughly.  It destroyed the
  52      Rx ring contents by dumping the 2K FIFO contents right where we wanted to
  53      get the next packet.  Oh well, what fun.
  54
  55   18 Jan 2000   mdc@etherboot.org (Marty Connor)
  56      Drastically simplified error handling.  Basically, if any error
  57      in transmission or reception occurs, the card is reset.
  58      Also, pointed all transmit descriptors to the same buffer to
  59      save buffer space.  This should decrease driver size and avoid
  60      corruption because of exceeding 32K during runtime.
  61
  62   28 Jul 1999   (Matthias Meixner - meixner@rbg.informatik.tu-darmstadt.de)
  63      rtl_poll was quite broken: it used the RxOK interrupt flag instead
  64      of the RxBufferEmpty flag which often resulted in very bad
  65      transmission performace - below 1kBytes/s.
  66
  67 */
  68
  69 #include <stdint.h>
  70 #include <stdlib.h>
  71 #include <stdio.h>
  72 #include <io.h>
  73 #include <errno.h>
  74 #include <timer.h>
  75 #include <byteswap.h>
  76 #include <gpxe/pci.h>
  77 #include <gpxe/if_ether.h>
  78 #include <gpxe/ethernet.h>
  79 #include <gpxe/iobuf.h>
  80 #include <gpxe/netdevice.h>
  81 #include <gpxe/spi_bit.h>
  82 #include <gpxe/threewire.h>
  83 #include <gpxe/nvo.h>
  84
  85 #define TX_RING_SIZE 4
  86
  87 struct rtl8139_tx {
  88         unsigned int next;
  89         struct io_buffer *iobuf[TX_RING_SIZE];
  90 };
  91
  92 struct rtl8139_rx {
  93         void *ring;
  94         unsigned int offset;
  95 };
  96
  97 struct rtl8139_nic {
  98         unsigned short ioaddr;
  99         struct rtl8139_tx tx;
 100         struct rtl8139_rx rx;
 101         struct spi_bit_basher spibit;
 102         struct spi_device eeprom;
 103         struct nvo_block nvo;
 104 };
 105
 106 /* Tuning Parameters */
 107 #define TX_FIFO_THRESH  256     /* In bytes, rounded down to 32 byte units. */
 108 #define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
 109 #define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
 110 #define TX_DMA_BURST    4       /* Calculate as 16<<val. */
 111 #define TX_IPG          3       /* This is the only valid value */
 112 #define RX_BUF_LEN_IDX  0       /* 0, 1, 2 is allowed - 8,16,32K rx buffer */
 113 #define RX_BUF_LEN ( (8192 << RX_BUF_LEN_IDX) )
 114 #define RX_BUF_PAD 4
 115
 116 /* Symbolic offsets to registers. */
 117 enum RTL8139_registers {
 118         MAC0=0,                 /* Ethernet hardware address. */
 119         MAR0=8,                 /* Multicast filter. */
 120         TxStatus0=0x10,         /* Transmit status (four 32bit registers). */
 121         TxAddr0=0x20,           /* Tx descriptors (also four 32bit). */
 122         RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36,
 123         ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A,
 124         IntrMask=0x3C, IntrStatus=0x3E,
 125         TxConfig=0x40, RxConfig=0x44,
 126         Timer=0x48,             /* general-purpose counter. */
 127         RxMissed=0x4C,          /* 24 bits valid, write clears. */
 128         Cfg9346=0x50, Config0=0x51, Config1=0x52,
 129         TimerIntrReg=0x54,      /* intr if gp counter reaches this value */
 130         MediaStatus=0x58,
 131         Config3=0x59,
 132         MultiIntr=0x5C,
 133         RevisionID=0x5E,        /* revision of the RTL8139 chip */
 134         TxSummary=0x60,
 135         MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68,
 136         NWayExpansion=0x6A,
 137         DisconnectCnt=0x6C, FalseCarrierCnt=0x6E,
 138         NWayTestReg=0x70,
 139         RxCnt=0x72,             /* packet received counter */
 140         CSCR=0x74,              /* chip status and configuration register */
 141         PhyParm1=0x78,TwisterParm=0x7c,PhyParm2=0x80,   /* undocumented */
 142         /* from 0x84 onwards are a number of power management/wakeup frame
 143          * definitions we will probably never need to know about.  */
 144 };
 145
 146 enum RxEarlyStatusBits {
 147         ERGood=0x08, ERBad=0x04, EROVW=0x02, EROK=0x01
 148 };
 149
 150 enum ChipCmdBits {
 151         CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, };
 152
 153 enum IntrMaskBits {
 154         SERR=0x8000, TimeOut=0x4000, LenChg=0x2000,
 155         FOVW=0x40, PUN_LinkChg=0x20, RXOVW=0x10,
 156         TER=0x08, TOK=0x04, RER=0x02, ROK=0x01
 157 };
 158
 159 /* Interrupt register bits, using my own meaningful names. */
 160 enum IntrStatusBits {
 161         PCIErr=0x8000, PCSTimeout=0x4000, CableLenChange= 0x2000,
 162         RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10,
 163         TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01,
 164 };
 165 enum TxStatusBits {
 166         TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000,
 167         TxOutOfWindow=0x20000000, TxAborted=0x40000000,
 168         TxCarrierLost=0x80000000,
 169 };
 170 enum RxStatusBits {
 171         RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000,
 172         RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004,
 173         RxBadAlign=0x0002, RxStatusOK=0x0001,
 174 };
 175
 176 enum MediaStatusBits {
 177         MSRTxFlowEnable=0x80, MSRRxFlowEnable=0x40, MSRSpeed10=0x08,
 178         MSRLinkFail=0x04, MSRRxPauseFlag=0x02, MSRTxPauseFlag=0x01,
 179 };
 180
 181 enum MIIBMCRBits {
 182         BMCRReset=0x8000, BMCRSpeed100=0x2000, BMCRNWayEnable=0x1000,
 183         BMCRRestartNWay=0x0200, BMCRDuplex=0x0100,
 184 };
 185
 186 enum CSCRBits {
 187         CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800,
 188         CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0,
 189         CSCR_LinkDownCmd=0x0f3c0,
 190 };
 191
 192 enum RxConfigBits {
 193         RxCfgWrap=0x80,
 194         Eeprom9356=0x40,
 195         AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
 196         AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
 197 };
 198
 199 enum Config1Bits {
 200         VPDEnable=0x02,
 201 };
 202
 203 /*  EEPROM access */
 204 #define EE_M1           0x80    /* Mode select bit 1 */
 205 #define EE_M0           0x40    /* Mode select bit 0 */
 206 #define EE_CS           0x08    /* EEPROM chip select */
 207 #define EE_SK           0x04    /* EEPROM shift clock */
 208 #define EE_DI           0x02    /* Data in */
 209 #define EE_DO           0x01    /* Data out */
 210
 211 /* Offsets within EEPROM (these are word offsets) */
 212 #define EE_MAC 7
 213
 214 static const uint8_t rtl_ee_bits[] = {
 215         [SPI_BIT_SCLK]  = EE_SK,
 216         [SPI_BIT_MOSI]  = EE_DI,
 217         [SPI_BIT_MISO]  = EE_DO,
 218         [SPI_BIT_SS(0)] = ( EE_CS | EE_M1 ),
 219 };
 220
 221 static int rtl_spi_read_bit ( struct bit_basher *basher,
 222                               unsigned int bit_id ) {
 223         struct rtl8139_nic *rtl = container_of ( basher, struct rtl8139_nic,
 224                                                  spibit.basher );
 225         uint8_t mask = rtl_ee_bits[bit_id];
 226         uint8_t eereg;
 227
 228         eereg = inb ( rtl->ioaddr + Cfg9346 );
 229         return ( eereg & mask );
 230 }
 231
 232 static void rtl_spi_write_bit ( struct bit_basher *basher,
 233                                 unsigned int bit_id, unsigned long data ) {
 234         struct rtl8139_nic *rtl = container_of ( basher, struct rtl8139_nic,
 235                                                  spibit.basher );
 236         uint8_t mask = rtl_ee_bits[bit_id];
 237         uint8_t eereg;
 238
 239         eereg = inb ( rtl->ioaddr + Cfg9346 );
 240         eereg &= ~mask;
 241         eereg |= ( data & mask );
 242         outb ( eereg, rtl->ioaddr + Cfg9346 );
 243 }
 244
 245 static struct bit_basher_operations rtl_basher_ops = {
 246         .read = rtl_spi_read_bit,
 247         .write = rtl_spi_write_bit,
 248 };
 249
 250 /** Portion of EEPROM available for non-volatile stored options
 251  *
 252  * We use offset 0x40 (i.e. address 0x20), length 0x40.  This block is
 253  * marked as VPD in the rtl8139 datasheets, so we use it only if we
 254  * detect that the card is not supporting VPD.
 255  */
 256 static struct nvo_fragment rtl_nvo_fragments[] = {
 257         { 0x20, 0x40 },
 258         { 0, 0 }
 259 };
 260
 261 /**
 262  * Set up for EEPROM access
 263  *
 264  * @v rtl               RTL8139 NIC
 265  */
 266  void rtl_init_eeprom ( struct rtl8139_nic *rtl ) {
 267         int ee9356;
 268         int vpd;
 269
 270         /* Initialise three-wire bus */
 271         rtl->spibit.basher.op = &rtl_basher_ops;
 272         rtl->spibit.bus.mode = SPI_MODE_THREEWIRE;
 273         init_spi_bit_basher ( &rtl->spibit );
 274
 275         /* Detect EEPROM type and initialise three-wire device */
 276         ee9356 = ( inw ( rtl->ioaddr + RxConfig ) & Eeprom9356 );
 277         if ( ee9356 ) {
 278                 DBG ( "EEPROM is an AT93C56\n" );
 279                 init_at93c56 ( &rtl->eeprom, 16 );
 280         } else {
 281                 DBG ( "EEPROM is an AT93C46\n" );
 282                 init_at93c46 ( &rtl->eeprom, 16 );
 283         }
 284         rtl->eeprom.bus = &rtl->spibit.bus;
 285
 286         /* Initialise space for non-volatile options, if available */
 287         vpd = ( inw ( rtl->ioaddr + Config1 ) & VPDEnable );
 288         if ( vpd ) {
 289                 DBG ( "EEPROM in use for VPD; cannot use for options\n" );
 290         } else {
 291                 rtl->nvo.nvs = &rtl->eeprom.nvs;
 292                 rtl->nvo.fragments = rtl_nvo_fragments;
 293         }
 294 }
 295
 296 /**
 297  * Reset NIC
 298  *
 299  * @v rtl               RTL8139 NIC
 300  *
 301  * Issues a hardware reset and waits for the reset to complete.
 302  */
 303 static void rtl_reset ( struct rtl8139_nic *rtl ) {
 304
 305         /* Reset chip */
 306         outb ( CmdReset, rtl->ioaddr + ChipCmd );
 307         mdelay ( 10 );
 308         memset ( &rtl->tx, 0, sizeof ( rtl->tx ) );
 309         rtl->rx.offset = 0;
 310 }
 311
 312 /**
 313  * Open NIC
 314  *
 315  * @v netdev            Net device
 316  * @ret rc              Return status code
 317  */
 318 static int rtl_open ( struct net_device *netdev ) {
 319         struct rtl8139_nic *rtl = netdev->priv;
 320         int i;
 321
 322         /* Program the MAC address */
 323         for ( i = 0 ; i < ETH_ALEN ; i++ )
 324                 outb ( netdev->ll_addr[i], rtl->ioaddr + MAC0 + i );
 325
 326         /* Set up RX ring */
 327         rtl->rx.ring = malloc ( RX_BUF_LEN + RX_BUF_PAD );
 328         if ( ! rtl->rx.ring )
 329                 return -ENOMEM;
 330         outl ( virt_to_bus ( rtl->rx.ring ), rtl->ioaddr + RxBuf );
 331         DBG ( "RX ring at %lx\n", virt_to_bus ( rtl->rx.ring ) );
 332
 333         /* Enable TX and RX */
 334         outb ( ( CmdRxEnb | CmdTxEnb ), rtl->ioaddr + ChipCmd );
 335         outl ( ( ( RX_FIFO_THRESH << 13 ) | ( RX_BUF_LEN_IDX << 11 ) |
 336                  ( RX_DMA_BURST << 8 ) | AcceptBroadcast | AcceptMulticast |
 337                  AcceptMyPhys ), rtl->ioaddr + RxConfig );
 338         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 0 );
 339         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 4 );
 340         outl ( ( ( TX_DMA_BURST << 8 ) | ( TX_IPG << 24 ) ),
 341                rtl->ioaddr + TxConfig );
 342
 343         return 0;
 344 }
 345
 346 /**
 347  * Close NIC
 348  *
 349  * @v netdev            Net device
 350  */
 351 static void rtl_close ( struct net_device *netdev ) {
 352         struct rtl8139_nic *rtl = netdev->priv;
 353
 354         /* Reset the hardware to disable everything in one go */
 355         rtl_reset ( rtl );
 356
 357         /* Free RX ring */
 358         free ( rtl->rx.ring );
 359         rtl->rx.ring = NULL;
 360 }
 361
 362 /**
 363  * Transmit packet
 364  *
 365  * @v netdev    Network device
 366  * @v iobuf     I/O buffer
 367  * @ret rc      Return status code
 368  */
 369 static int rtl_transmit ( struct net_device *netdev, struct io_buffer *iobuf ) {
 370         struct rtl8139_nic *rtl = netdev->priv;
 371
 372         /* Check for space in TX ring */
 373         if ( rtl->tx.iobuf[rtl->tx.next] != NULL ) {
 374                 DBG ( "TX overflow\n" );
 375                 return -ENOBUFS;
 376         }
 377
 378         /* Pad and align packet */
 379         iob_pad ( iobuf, ETH_ZLEN );
 380
 381         /* Add to TX ring */
 382         DBG ( "TX id %d at %lx+%x\n", rtl->tx.next,
 383               virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
 384         rtl->tx.iobuf[rtl->tx.next] = iobuf;
 385         outl ( virt_to_bus ( iobuf->data ),
 386                rtl->ioaddr + TxAddr0 + 4 * rtl->tx.next );
 387         outl ( ( ( ( TX_FIFO_THRESH & 0x7e0 ) << 11 ) | iob_len ( iobuf ) ),
 388                rtl->ioaddr + TxStatus0 + 4 * rtl->tx.next );
 389         rtl->tx.next = ( rtl->tx.next + 1 ) % TX_RING_SIZE;
 390
 391         return 0;
 392 }
 393
 394 /**
 395  * Poll for received packets
 396  *
 397  * @v netdev    Network device
 398  */
 399 static void rtl_poll ( struct net_device *netdev ) {
 400         struct rtl8139_nic *rtl = netdev->priv;
 401         unsigned int status;
 402         unsigned int tsad;
 403         unsigned int rx_status;
 404         unsigned int rx_len;
 405         struct io_buffer *rx_iob;
 406         int wrapped_len;
 407         int i;
 408
 409         /* Acknowledge interrupts */
 410         status = inw ( rtl->ioaddr + IntrStatus );
 411         if ( ! status )
 412                 return;
 413         outw ( status, rtl->ioaddr + IntrStatus );
 414
 415         /* Handle TX completions */
 416         tsad = inw ( rtl->ioaddr + TxSummary );
 417         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 418                 if ( ( rtl->tx.iobuf[i] != NULL ) && ( tsad & ( 1 << i ) ) ) {
 419                         DBG ( "TX id %d complete\n", i );
 420                         netdev_tx_complete ( netdev, rtl->tx.iobuf[i] );
 421                         rtl->tx.iobuf[i] = NULL;
 422                 }
 423         }
 424
 425         /* Handle received packets */
 426         while ( ! ( inw ( rtl->ioaddr + ChipCmd ) & RxBufEmpty ) ) {
 427                 rx_status = * ( ( uint16_t * )
 428                                 ( rtl->rx.ring + rtl->rx.offset ) );
 429                 rx_len = * ( ( uint16_t * )
 430                              ( rtl->rx.ring + rtl->rx.offset + 2 ) );
 431                 if ( rx_status & RxOK ) {
 432                         DBG ( "RX packet at offset %x+%x\n", rtl->rx.offset,
 433                               rx_len );
 434
 435                         rx_iob = alloc_iob ( rx_len );
 436                         if ( ! rx_iob ) {
 437                                 netdev_rx_err ( netdev, NULL, -ENOMEM );
 438                                 /* Leave packet for next call to poll() */
 439                                 break;
 440                         }
 441
 442                         wrapped_len = ( ( rtl->rx.offset + 4 + rx_len )
 443                                         - RX_BUF_LEN );
 444                         if ( wrapped_len < 0 )
 445                                 wrapped_len = 0;
 446
 447                         memcpy ( iob_put ( rx_iob, rx_len - wrapped_len ),
 448                                  rtl->rx.ring + rtl->rx.offset + 4,
 449                                  rx_len - wrapped_len );
 450                         memcpy ( iob_put ( rx_iob, wrapped_len ),
 451                                  rtl->rx.ring, wrapped_len );
 452
 453                         netdev_rx ( netdev, rx_iob );
 454                 } else {
 455                         DBG ( "RX bad packet (status %#04x len %d)\n",
 456                               rx_status, rx_len );
 457                         netdev_rx_err ( netdev, NULL, -EINVAL );
 458                 }
 459                 rtl->rx.offset = ( ( ( rtl->rx.offset + 4 + rx_len + 3 ) & ~3 )
 460                                    % RX_BUF_LEN );
 461                 outw ( rtl->rx.offset - 16, rtl->ioaddr + RxBufPtr );
 462         }
 463 }
 464
 465 /**
 466  * Enable/disable interrupts
 467  *
 468  * @v netdev    Network device
 469  * @v enable    Interrupts should be enabled
 470  */
 471 static void rtl_irq ( struct net_device *netdev, int enable ) {
 472         struct rtl8139_nic *rtl = netdev->priv;
 473
 474         outw ( ( enable ? ( ROK | RER | TOK | TER ) : 0 ),
 475                rtl->ioaddr + IntrMask );
 476 }
 477
 478 /** RTL8139 net device operations */
 479 static struct net_device_operations rtl_operations = {
 480         .open           = rtl_open,
 481         .close          = rtl_close,
 482         .transmit       = rtl_transmit,
 483         .poll           = rtl_poll,
 484         .irq            = rtl_irq,
 485 };
 486
 487 /**
 488  * Probe PCI device
 489  *
 490  * @v pci       PCI device
 491  * @v id        PCI ID
 492  * @ret rc      Return status code
 493  */
 494 static int rtl_probe ( struct pci_device *pci,
 495                        const struct pci_device_id *id __unused ) {
 496         struct net_device *netdev;
 497         struct rtl8139_nic *rtl;
 498         int rc;
 499
 500         /* Allocate net device */
 501         netdev = alloc_etherdev ( sizeof ( *rtl ) );
 502         if ( ! netdev )
 503                 return -ENOMEM;
 504         netdev_init ( netdev, &rtl_operations );
 505         rtl = netdev->priv;
 506         pci_set_drvdata ( pci, netdev );
 507         netdev->dev = &pci->dev;
 508         memset ( rtl, 0, sizeof ( *rtl ) );
 509         rtl->ioaddr = pci->ioaddr;
 510
 511         /* Fix up PCI device */
 512         adjust_pci_device ( pci );
 513
 514         /* Reset the NIC, set up EEPROM access and read MAC address */
 515         rtl_reset ( rtl );
 516         rtl_init_eeprom ( rtl );
 517         nvs_read ( &rtl->eeprom.nvs, EE_MAC, netdev->ll_addr, ETH_ALEN );
 518
 519         /* Register network device */
 520         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 521                 goto err_register_netdev;
 522
 523         /* Register non-volatile storage */
 524         if ( rtl->nvo.nvs ) {
 525                 if ( ( rc = nvo_register ( &rtl->nvo ) ) != 0 )
 526                         goto err_register_nvo;
 527         }
 528
 529         return 0;
 530
 531  err_register_nvo:
 532         unregister_netdev ( netdev );
 533  err_register_netdev:
 534         rtl_reset ( rtl );
 535         netdev_nullify ( netdev );
 536         netdev_put ( netdev );
 537         return rc;
 538 }
 539
 540 /**
 541  * Remove PCI device
 542  *
 543  * @v pci       PCI device
 544  */
 545 static void rtl_remove ( struct pci_device *pci ) {
 546         struct net_device *netdev = pci_get_drvdata ( pci );
 547         struct rtl8139_nic *rtl = netdev->priv;
 548
 549         if ( rtl->nvo.nvs )
 550                 nvo_unregister ( &rtl->nvo );
 551         unregister_netdev ( netdev );
 552         rtl_reset ( rtl );
 553         netdev_nullify ( netdev );
 554         netdev_put ( netdev );
 555 }
 556
 557 static struct pci_device_id rtl8139_nics[] = {
 558 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
 559 PCI_ROM(0x10ec, 0x8139, "rtl8139",       "Realtek 8139"),
 560 PCI_ROM(0x10ec, 0x8138, "rtl8139b",      "Realtek 8139B"),
 561 PCI_ROM(0x1186, 0x1300, "dfe538",        "DFE530TX+/DFE538TX"),
 562 PCI_ROM(0x1113, 0x1211, "smc1211-1",     "SMC EZ10/100"),
 563 PCI_ROM(0x1112, 0x1211, "smc1211",       "SMC EZ10/100"),
 564 PCI_ROM(0x1500, 0x1360, "delta8139",     "Delta Electronics 8139"),
 565 PCI_ROM(0x4033, 0x1360, "addtron8139",   "Addtron Technology 8139"),
 566 PCI_ROM(0x1186, 0x1340, "dfe690txd",     "D-Link DFE690TXD"),
 567 PCI_ROM(0x13d1, 0xab06, "fe2000vx",      "AboCom FE2000VX"),
 568 PCI_ROM(0x1259, 0xa117, "allied8139",    "Allied Telesyn 8139"),
 569 PCI_ROM(0x14ea, 0xab06, "fnw3603tx",     "Planex FNW-3603-TX"),
 570 PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
 571 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
 572 };
 573
 574 struct pci_driver rtl8139_driver __pci_driver = {
 575         .ids = rtl8139_nics,
 576         .id_count = ( sizeof ( rtl8139_nics ) / sizeof ( rtl8139_nics[0] ) ),
 577         .probe = rtl_probe,
 578         .remove = rtl_remove,
 579 };