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@thinguin.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 <io.h>
  70 #include <errno.h>
  71 #include <vsprintf.h>
  72 #include <timer.h>
  73 #include <malloc.h>
  74 #include <byteswap.h>
  75 #include <gpxe/pci.h>
  76 #include <gpxe/if_ether.h>
  77 #include <gpxe/ethernet.h>
  78 #include <gpxe/pkbuff.h>
  79 #include <gpxe/netdevice.h>
  80 #include <gpxe/spi_bit.h>
  81 #include <gpxe/threewire.h>
  82
  83 #define TX_RING_SIZE 4
  84
  85 struct rtl8139_tx {
  86         unsigned int next;
  87         struct pk_buff *pkb[TX_RING_SIZE];
  88 };
  89
  90 struct rtl8139_rx {
  91         void *ring;
  92         unsigned int offset;
  93 };
  94
  95 struct rtl8139_nic {
  96         unsigned short ioaddr;
  97         struct rtl8139_tx tx;
  98         struct rtl8139_rx rx;
  99         struct spi_bit_basher spibit;
 100         struct spi_device eeprom;
 101 };
 102
 103 /* Tuning Parameters */
 104 #define TX_FIFO_THRESH  256     /* In bytes, rounded down to 32 byte units. */
 105 #define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
 106 #define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
 107 #define TX_DMA_BURST    4       /* Calculate as 16<<val. */
 108 #define TX_IPG          3       /* This is the only valid value */
 109 #define RX_BUF_LEN_IDX  0       /* 0, 1, 2 is allowed - 8,16,32K rx buffer */
 110 #define RX_BUF_LEN ( (8192 << RX_BUF_LEN_IDX) )
 111 #define RX_BUF_PAD 4
 112
 113 /* Symbolic offsets to registers. */
 114 enum RTL8139_registers {
 115         MAC0=0,                 /* Ethernet hardware address. */
 116         MAR0=8,                 /* Multicast filter. */
 117         TxStatus0=0x10,         /* Transmit status (four 32bit registers). */
 118         TxAddr0=0x20,           /* Tx descriptors (also four 32bit). */
 119         RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36,
 120         ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A,
 121         IntrMask=0x3C, IntrStatus=0x3E,
 122         TxConfig=0x40, RxConfig=0x44,
 123         Timer=0x48,             /* general-purpose counter. */
 124         RxMissed=0x4C,          /* 24 bits valid, write clears. */
 125         Cfg9346=0x50, Config0=0x51, Config1=0x52,
 126         TimerIntrReg=0x54,      /* intr if gp counter reaches this value */
 127         MediaStatus=0x58,
 128         Config3=0x59,
 129         MultiIntr=0x5C,
 130         RevisionID=0x5E,        /* revision of the RTL8139 chip */
 131         TxSummary=0x60,
 132         MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68,
 133         NWayExpansion=0x6A,
 134         DisconnectCnt=0x6C, FalseCarrierCnt=0x6E,
 135         NWayTestReg=0x70,
 136         RxCnt=0x72,             /* packet received counter */
 137         CSCR=0x74,              /* chip status and configuration register */
 138         PhyParm1=0x78,TwisterParm=0x7c,PhyParm2=0x80,   /* undocumented */
 139         /* from 0x84 onwards are a number of power management/wakeup frame
 140          * definitions we will probably never need to know about.  */
 141 };
 142
 143 enum RxEarlyStatusBits {
 144         ERGood=0x08, ERBad=0x04, EROVW=0x02, EROK=0x01
 145 };
 146
 147 enum ChipCmdBits {
 148         CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, };
 149
 150 enum IntrMaskBits {
 151         SERR=0x8000, TimeOut=0x4000, LenChg=0x2000,
 152         FOVW=0x40, PUN_LinkChg=0x20, RXOVW=0x10,
 153         TER=0x08, TOK=0x04, RER=0x02, ROK=0x01
 154 };
 155
 156 /* Interrupt register bits, using my own meaningful names. */
 157 enum IntrStatusBits {
 158         PCIErr=0x8000, PCSTimeout=0x4000, CableLenChange= 0x2000,
 159         RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10,
 160         TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01,
 161 };
 162 enum TxStatusBits {
 163         TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000,
 164         TxOutOfWindow=0x20000000, TxAborted=0x40000000,
 165         TxCarrierLost=0x80000000,
 166 };
 167 enum RxStatusBits {
 168         RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000,
 169         RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004,
 170         RxBadAlign=0x0002, RxStatusOK=0x0001,
 171 };
 172
 173 enum MediaStatusBits {
 174         MSRTxFlowEnable=0x80, MSRRxFlowEnable=0x40, MSRSpeed10=0x08,
 175         MSRLinkFail=0x04, MSRRxPauseFlag=0x02, MSRTxPauseFlag=0x01,
 176 };
 177
 178 enum MIIBMCRBits {
 179         BMCRReset=0x8000, BMCRSpeed100=0x2000, BMCRNWayEnable=0x1000,
 180         BMCRRestartNWay=0x0200, BMCRDuplex=0x0100,
 181 };
 182
 183 enum CSCRBits {
 184         CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800,
 185         CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0,
 186         CSCR_LinkDownCmd=0x0f3c0,
 187 };
 188
 189 enum RxConfigBits {
 190         RxCfgWrap=0x80,
 191         Eeprom9356=0x40,
 192         AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
 193         AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
 194 };
 195
 196 /*  EEPROM access */
 197 #define EE_M1           0x80    /* Mode select bit 1 */
 198 #define EE_M0           0x40    /* Mode select bit 0 */
 199 #define EE_CS           0x08    /* EEPROM chip select */
 200 #define EE_SK           0x04    /* EEPROM shift clock */
 201 #define EE_DI           0x02    /* Data in */
 202 #define EE_DO           0x01    /* Data out */
 203
 204 /* Offsets within EEPROM (these are word offsets) */
 205 #define EE_MAC 7
 206
 207 static const uint8_t rtl_ee_bits[] = {
 208         [SPI_BIT_SCLK]  = EE_SK,
 209         [SPI_BIT_MOSI]  = EE_DI,
 210         [SPI_BIT_MISO]  = EE_DO,
 211         [SPI_BIT_SS(0)] = ( EE_CS | EE_M1 ),
 212 };
 213
 214 static int rtl_spi_read_bit ( struct bit_basher *basher,
 215                               unsigned int bit_id ) {
 216         struct rtl8139_nic *rtl = container_of ( basher, struct rtl8139_nic,
 217                                                  spibit.basher );
 218         uint8_t mask = rtl_ee_bits[bit_id];
 219         uint8_t eereg;
 220
 221         eereg = inb ( rtl->ioaddr + Cfg9346 );
 222         return ( eereg & mask );
 223 }
 224
 225 static void rtl_spi_write_bit ( struct bit_basher *basher,
 226                                 unsigned int bit_id, unsigned long data ) {
 227         struct rtl8139_nic *rtl = container_of ( basher, struct rtl8139_nic,
 228                                                  spibit.basher );
 229         uint8_t mask = rtl_ee_bits[bit_id];
 230         uint8_t eereg;
 231
 232         eereg = inb ( rtl->ioaddr + Cfg9346 );
 233         eereg &= ~mask;
 234         eereg |= ( data & mask );
 235         outb ( eereg, rtl->ioaddr + Cfg9346 );
 236 }
 237
 238 static struct bit_basher_operations rtl_basher_ops = {
 239         .read = rtl_spi_read_bit,
 240         .write = rtl_spi_write_bit,
 241 };
 242
 243 /**
 244  * Set up for EEPROM access
 245  *
 246  * @v rtl               RTL8139 NIC
 247  */
 248  void rtl_init_eeprom ( struct rtl8139_nic *rtl ) {
 249         int ee9356;
 250
 251         /* Initialise three-wire bus */
 252         rtl->spibit.basher.op = &rtl_basher_ops;
 253         rtl->spibit.bus.mode = SPI_MODE_THREEWIRE;
 254         init_spi_bit_basher ( &rtl->spibit );
 255
 256         /* Detect EEPROM type and initialise three-wire device */
 257         ee9356 = ( inw ( rtl->ioaddr + RxConfig ) & Eeprom9356 );
 258         if ( ee9356 ) {
 259                 DBG ( "EEPROM is an AT93C56\n" );
 260                 init_at93c56 ( &rtl->eeprom, 16 );
 261         } else {
 262                 DBG ( "EEPROM is an AT93C46\n" );
 263                 init_at93c46 ( &rtl->eeprom, 16 );
 264         }
 265         rtl->eeprom.bus = &rtl->spibit.bus;
 266 }
 267
 268 /**
 269  * Reset NIC
 270  *
 271  * @v rtl               RTL8139 NIC
 272  *
 273  * Issues a hardware reset and waits for the reset to complete.
 274  */
 275 static void rtl_reset ( struct rtl8139_nic *rtl ) {
 276
 277         /* Reset chip */
 278         outb ( CmdReset, rtl->ioaddr + ChipCmd );
 279         mdelay ( 10 );
 280         rtl->tx.next = 0;
 281         rtl->rx.offset = 0;
 282 }
 283
 284 /**
 285  * Open NIC
 286  *
 287  * @v netdev            Net device
 288  * @ret rc              Return status code
 289  */
 290 static int rtl_open ( struct net_device *netdev ) {
 291         struct rtl8139_nic *rtl = netdev->priv;
 292         int i;
 293
 294         /* Program the MAC address */
 295         for ( i = 0 ; i < ETH_ALEN ; i++ )
 296                 outb ( netdev->ll_addr[i], rtl->ioaddr + MAC0 + i );
 297
 298         /* Set up RX ring */
 299         rtl->rx.ring = malloc ( RX_BUF_LEN + RX_BUF_PAD );
 300         if ( ! rtl->rx.ring )
 301                 return -ENOMEM;
 302         outl ( virt_to_bus ( rtl->rx.ring ), rtl->ioaddr + RxBuf );
 303         DBG ( "RX ring at %lx\n", virt_to_bus ( rtl->rx.ring ) );
 304
 305         /* Enable TX and RX */
 306         outb ( ( CmdRxEnb | CmdTxEnb ), rtl->ioaddr + ChipCmd );
 307         outl ( ( ( RX_FIFO_THRESH << 13 ) | ( RX_BUF_LEN_IDX << 11 ) |
 308                  ( RX_DMA_BURST << 8 ) | AcceptBroadcast | AcceptMulticast |
 309                  AcceptMyPhys ), rtl->ioaddr + RxConfig );
 310         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 0 );
 311         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 4 );
 312         outl ( ( ( TX_DMA_BURST << 8 ) | ( TX_IPG << 24 ) ),
 313                rtl->ioaddr + TxConfig );
 314
 315         return 0;
 316 }
 317
 318 /**
 319  * Close NIC
 320  *
 321  * @v netdev            Net device
 322  */
 323 static void rtl_close ( struct net_device *netdev ) {
 324         struct rtl8139_nic *rtl = netdev->priv;
 325         int i;
 326
 327         /* Reset the hardware to disable everything in one go */
 328         rtl_reset ( rtl );
 329
 330         /* Free RX ring */
 331         free ( rtl->rx.ring );
 332         rtl->rx.ring = NULL;
 333
 334         /* Free any old TX buffers that hadn't yet completed */
 335         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 336                 if ( rtl->tx.pkb[i] ) {
 337                         free_pkb ( rtl->tx.pkb[i] );
 338                         rtl->tx.pkb[i] = NULL;
 339                         DBG ( "TX id %d discarded\n", i );
 340                 }
 341         }
 342 }
 343
 344 /**
 345  * Transmit packet
 346  *
 347  * @v netdev    Network device
 348  * @v pkb       Packet buffer
 349  * @ret rc      Return status code
 350  */
 351 static int rtl_transmit ( struct net_device *netdev, struct pk_buff *pkb ) {
 352         struct rtl8139_nic *rtl = netdev->priv;
 353         int align;
 354         int pad_len;
 355
 356         /* Check for space in TX ring */
 357         if ( rtl->tx.pkb[rtl->tx.next] != NULL ) {
 358                 printf ( "TX overflow\n" );
 359                 free_pkb ( pkb );
 360                 return -ENOBUFS;
 361         }
 362
 363         /* Align packet data */
 364         align = ( virt_to_bus ( pkb->data ) & 0x3 );
 365         pkb_push ( pkb, align );
 366         memmove ( pkb->data, pkb->data + align, pkb_len ( pkb ) - align );
 367         pkb_unput ( pkb, align );
 368
 369         /* Pad to minimum packet length */
 370         pad_len = ( ETH_ZLEN - pkb_len ( pkb ) );
 371         if ( pad_len > 0 )
 372                 memset ( pkb_put ( pkb, pad_len ), 0, pad_len );
 373
 374         /* Add to TX ring */
 375         DBG ( "TX id %d at %lx+%x\n", rtl->tx.next,
 376               virt_to_bus ( pkb->data ), pkb_len ( pkb ) );
 377         rtl->tx.pkb[rtl->tx.next] = pkb;
 378         outl ( virt_to_bus ( pkb->data ),
 379                rtl->ioaddr + TxAddr0 + 4 * rtl->tx.next );
 380         outl ( ( ( ( TX_FIFO_THRESH & 0x7e0 ) << 11 ) | pkb_len ( pkb ) ),
 381                rtl->ioaddr + TxStatus0 + 4 * rtl->tx.next );
 382         rtl->tx.next = ( rtl->tx.next + 1 ) % TX_RING_SIZE;
 383
 384         return 0;
 385 }
 386
 387 /**
 388  * Poll for received packets
 389  *
 390  * @v netdev    Network device
 391  */
 392 static void rtl_poll ( struct net_device *netdev ) {
 393         struct rtl8139_nic *rtl = netdev->priv;
 394         unsigned int status;
 395         unsigned int tsad;
 396         unsigned int rx_status;
 397         unsigned int rx_len;
 398         struct pk_buff *rx_pkb;
 399         int wrapped_len;
 400         int i;
 401
 402         /* Acknowledge interrupts */
 403         status = inw ( rtl->ioaddr + IntrStatus );
 404         if ( ! status )
 405                 return;
 406         outw ( status, rtl->ioaddr + IntrStatus );
 407
 408         /* Handle TX completions */
 409         tsad = inw ( rtl->ioaddr + TxSummary );
 410         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 411                 if ( ( rtl->tx.pkb[i] != NULL ) && ( tsad & ( 1 << i ) ) ) {
 412                         DBG ( "TX id %d complete\n", i );
 413                         free_pkb ( rtl->tx.pkb[i] );
 414                         rtl->tx.pkb[i] = NULL;
 415                 }
 416         }
 417
 418         /* Handle received packets */
 419         while ( ! ( inw ( rtl->ioaddr + ChipCmd ) & RxBufEmpty ) ) {
 420                 rx_status = * ( ( uint16_t * )
 421                                 ( rtl->rx.ring + rtl->rx.offset ) );
 422                 rx_len = * ( ( uint16_t * )
 423                              ( rtl->rx.ring + rtl->rx.offset + 2 ) );
 424                 if ( rx_status & RxOK ) {
 425                         DBG ( "RX packet at offset %x+%x\n", rtl->rx.offset,
 426                               rx_len );
 427
 428                         rx_pkb = alloc_pkb ( rx_len );
 429                         if ( ! rx_pkb ) {
 430                                 /* Leave packet for next call to poll() */
 431                                 break;
 432                         }
 433
 434                         wrapped_len = ( ( rtl->rx.offset + 4 + rx_len )
 435                                         - RX_BUF_LEN );
 436                         if ( wrapped_len < 0 )
 437                                 wrapped_len = 0;
 438
 439                         memcpy ( pkb_put ( rx_pkb, rx_len - wrapped_len ),
 440                                  rtl->rx.ring + rtl->rx.offset + 4,
 441                                  rx_len - wrapped_len );
 442                         memcpy ( pkb_put ( rx_pkb, wrapped_len ),
 443                                  rtl->rx.ring, wrapped_len );
 444
 445                         netdev_rx ( netdev, rx_pkb );
 446                 } else {
 447                         DBG ( "RX bad packet (status %#04x len %d)\n",
 448                               rx_status, rx_len );
 449                 }
 450                 rtl->rx.offset = ( ( ( rtl->rx.offset + 4 + rx_len + 3 ) & ~3 )
 451                                    % RX_BUF_LEN );
 452                 outw ( rtl->rx.offset - 16, rtl->ioaddr + RxBufPtr );
 453         }
 454 }
 455
 456 #if 0
 457 static void rtl_irq(struct nic *nic, irq_action_t action)
 458 {
 459         unsigned int mask;
 460         /* Bit of a guess as to which interrupts we should allow */
 461         unsigned int interested = ROK | RER | RXOVW | FOVW | SERR;
 462
 463         switch ( action ) {
 464         case DISABLE :
 465         case ENABLE :
 466                 mask = inw(rtl->ioaddr + IntrMask);
 467                 mask = mask & ~interested;
 468                 if ( action == ENABLE ) mask = mask | interested;
 469                 outw(mask, rtl->ioaddr + IntrMask);
 470                 break;
 471         case FORCE :
 472                 /* Apparently writing a 1 to this read-only bit of a
 473                  * read-only and otherwise unrelated register will
 474                  * force an interrupt.  If you ever want to see how
 475                  * not to write a datasheet, read the one for the
 476                  * RTL8139...
 477                  */
 478                 outb(EROK, rtl->ioaddr + RxEarlyStatus);
 479                 break;
 480         }
 481 }
 482 #endif
 483
 484 /**
 485  * Probe PCI device
 486  *
 487  * @v pci       PCI device
 488  * @v id        PCI ID
 489  * @ret rc      Return status code
 490  */
 491 static int rtl_probe ( struct pci_device *pci,
 492                        const struct pci_device_id *id __unused ) {
 493         struct net_device *netdev;
 494         struct rtl8139_nic *rtl = NULL;
 495         int rc;
 496
 497         /* Fix up PCI device */
 498         adjust_pci_device ( pci );
 499
 500         /* Allocate net device */
 501         netdev = alloc_etherdev ( sizeof ( *rtl ) );
 502         if ( ! netdev ) {
 503                 rc = -ENOMEM;
 504                 goto err;
 505         }
 506         rtl = netdev->priv;
 507         pci_set_drvdata ( pci, netdev );
 508         memset ( rtl, 0, sizeof ( *rtl ) );
 509         rtl->ioaddr = pci->ioaddr;
 510
 511         /* Reset the NIC, set up EEPROM access and read MAC address */
 512         rtl_reset ( rtl );
 513         rtl_init_eeprom ( rtl );
 514         nvs_read ( &rtl->eeprom.nvs, EE_MAC, netdev->ll_addr, ETH_ALEN );
 515
 516         /* Point to NIC specific routines */
 517         //      netdev->open     = rtl_open;
 518         //      netdev->close    = rtl_close;
 519         netdev->transmit = rtl_transmit;
 520         netdev->poll     = rtl_poll;
 521
 522         /* Register network device */
 523         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 524                 goto err;
 525
 526
 527 #warning "Hack alert"
 528         rtl_open ( netdev );
 529
 530
 531         return 0;
 532
 533  err:
 534         /* Disable NIC */
 535         if ( rtl )
 536                 rtl_reset ( rtl );
 537         /* Free net device */
 538         free_netdev ( netdev );
 539         return rc;
 540 }
 541
 542 /**
 543  * Remove PCI device
 544  *
 545  * @v pci       PCI device
 546  */
 547 static void rtl_remove ( struct pci_device *pci ) {
 548         struct net_device *netdev = pci_get_drvdata ( pci );
 549         struct rtl8139_nic *rtl = netdev->priv;
 550
 551
 552 #warning "Hack alert"
 553         rtl_close ( netdev );
 554
 555
 556         unregister_netdev ( netdev );
 557         rtl_reset ( rtl );
 558         free_netdev ( netdev );
 559 }
 560
 561 static struct pci_device_id rtl8139_nics[] = {
 562 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
 563 PCI_ROM(0x10ec, 0x8139, "rtl8139",       "Realtek 8139"),
 564 PCI_ROM(0x10ec, 0x8138, "rtl8139b",      "Realtek 8139B"),
 565 PCI_ROM(0x1186, 0x1300, "dfe538",        "DFE530TX+/DFE538TX"),
 566 PCI_ROM(0x1113, 0x1211, "smc1211-1",     "SMC EZ10/100"),
 567 PCI_ROM(0x1112, 0x1211, "smc1211",       "SMC EZ10/100"),
 568 PCI_ROM(0x1500, 0x1360, "delta8139",     "Delta Electronics 8139"),
 569 PCI_ROM(0x4033, 0x1360, "addtron8139",   "Addtron Technology 8139"),
 570 PCI_ROM(0x1186, 0x1340, "dfe690txd",     "D-Link DFE690TXD"),
 571 PCI_ROM(0x13d1, 0xab06, "fe2000vx",      "AboCom FE2000VX"),
 572 PCI_ROM(0x1259, 0xa117, "allied8139",    "Allied Telesyn 8139"),
 573 PCI_ROM(0x14ea, 0xab06, "fnw3603tx",     "Planex FNW-3603-TX"),
 574 PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
 575 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
 576 };
 577
 578 struct pci_driver rtl8139_driver __pci_driver = {
 579         .ids = rtl8139_nics,
 580         .id_count = ( sizeof ( rtl8139_nics ) / sizeof ( rtl8139_nics[0] ) ),
 581         .probe = rtl_probe,
 582         .remove = rtl_remove,
 583 };