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                 printf ( "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  * @v rx_quota  Maximum number of packets to receive
 399  */
 400 static void rtl_poll ( struct net_device *netdev, unsigned int rx_quota ) {
 401         struct rtl8139_nic *rtl = netdev->priv;
 402         unsigned int status;
 403         unsigned int tsad;
 404         unsigned int rx_status;
 405         unsigned int rx_len;
 406         struct io_buffer *rx_iob;
 407         int wrapped_len;
 408         int i;
 409
 410         /* Acknowledge interrupts */
 411         status = inw ( rtl->ioaddr + IntrStatus );
 412         if ( ! status )
 413                 return;
 414         outw ( status, rtl->ioaddr + IntrStatus );
 415
 416         /* Handle TX completions */
 417         tsad = inw ( rtl->ioaddr + TxSummary );
 418         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 419                 if ( ( rtl->tx.iobuf[i] != NULL ) && ( tsad & ( 1 << i ) ) ) {
 420                         DBG ( "TX id %d complete\n", i );
 421                         netdev_tx_complete ( netdev, rtl->tx.iobuf[i] );
 422                         rtl->tx.iobuf[i] = NULL;
 423                 }
 424         }
 425
 426         /* Handle received packets */
 427         while ( rx_quota && ! ( inw ( rtl->ioaddr + ChipCmd ) & RxBufEmpty ) ){
 428                 rx_status = * ( ( uint16_t * )
 429                                 ( rtl->rx.ring + rtl->rx.offset ) );
 430                 rx_len = * ( ( uint16_t * )
 431                              ( rtl->rx.ring + rtl->rx.offset + 2 ) );
 432                 if ( rx_status & RxOK ) {
 433                         DBG ( "RX packet at offset %x+%x\n", rtl->rx.offset,
 434                               rx_len );
 435
 436                         rx_iob = alloc_iob ( rx_len );
 437                         if ( ! rx_iob ) {
 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                         rx_quota--;
 455                 } else {
 456                         DBG ( "RX bad packet (status %#04x len %d)\n",
 457                               rx_status, rx_len );
 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 #if 0
 466 static void rtl_irq(struct nic *nic, irq_action_t action)
 467 {
 468         unsigned int mask;
 469         /* Bit of a guess as to which interrupts we should allow */
 470         unsigned int interested = ROK | RER | RXOVW | FOVW | SERR;
 471
 472         switch ( action ) {
 473         case DISABLE :
 474         case ENABLE :
 475                 mask = inw(rtl->ioaddr + IntrMask);
 476                 mask = mask & ~interested;
 477                 if ( action == ENABLE ) mask = mask | interested;
 478                 outw(mask, rtl->ioaddr + IntrMask);
 479                 break;
 480         case FORCE :
 481                 /* Apparently writing a 1 to this read-only bit of a
 482                  * read-only and otherwise unrelated register will
 483                  * force an interrupt.  If you ever want to see how
 484                  * not to write a datasheet, read the one for the
 485                  * RTL8139...
 486                  */
 487                 outb(EROK, rtl->ioaddr + RxEarlyStatus);
 488                 break;
 489         }
 490 }
 491 #endif
 492
 493 /**
 494  * Probe PCI device
 495  *
 496  * @v pci       PCI device
 497  * @v id        PCI ID
 498  * @ret rc      Return status code
 499  */
 500 static int rtl_probe ( struct pci_device *pci,
 501                        const struct pci_device_id *id __unused ) {
 502         struct net_device *netdev;
 503         struct rtl8139_nic *rtl = NULL;
 504         int registered_netdev = 0;
 505         int rc;
 506
 507         /* Fix up PCI device */
 508         adjust_pci_device ( pci );
 509
 510         /* Allocate net device */
 511         netdev = alloc_etherdev ( sizeof ( *rtl ) );
 512         if ( ! netdev ) {
 513                 rc = -ENOMEM;
 514                 goto err;
 515         }
 516         rtl = netdev->priv;
 517         pci_set_drvdata ( pci, netdev );
 518         netdev->dev = &pci->dev;
 519         memset ( rtl, 0, sizeof ( *rtl ) );
 520         rtl->ioaddr = pci->ioaddr;
 521
 522         /* Reset the NIC, set up EEPROM access and read MAC address */
 523         rtl_reset ( rtl );
 524         rtl_init_eeprom ( rtl );
 525         nvs_read ( &rtl->eeprom.nvs, EE_MAC, netdev->ll_addr, ETH_ALEN );
 526
 527         /* Point to NIC specific routines */
 528         netdev->open     = rtl_open;
 529         netdev->close    = rtl_close;
 530         netdev->transmit = rtl_transmit;
 531         netdev->poll     = rtl_poll;
 532
 533         /* Register network device */
 534         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 535                 goto err;
 536         registered_netdev = 1;
 537
 538         /* Register non-volatile storage */
 539         if ( rtl->nvo.nvs ) {
 540                 if ( ( rc = nvo_register ( &rtl->nvo ) ) != 0 )
 541                         goto err;
 542         }
 543
 544         return 0;
 545
 546  err:
 547         /* Disable NIC */
 548         if ( rtl )
 549                 rtl_reset ( rtl );
 550         if ( registered_netdev )
 551                 unregister_netdev ( netdev );
 552         /* Free net device */
 553         free_netdev ( netdev );
 554         return rc;
 555 }
 556
 557 /**
 558  * Remove PCI device
 559  *
 560  * @v pci       PCI device
 561  */
 562 static void rtl_remove ( struct pci_device *pci ) {
 563         struct net_device *netdev = pci_get_drvdata ( pci );
 564         struct rtl8139_nic *rtl = netdev->priv;
 565
 566         if ( rtl->nvo.nvs )
 567                 nvo_unregister ( &rtl->nvo );
 568         unregister_netdev ( netdev );
 569         rtl_reset ( rtl );
 570         free_netdev ( netdev );
 571 }
 572
 573 static struct pci_device_id rtl8139_nics[] = {
 574 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
 575 PCI_ROM(0x10ec, 0x8139, "rtl8139",       "Realtek 8139"),
 576 PCI_ROM(0x10ec, 0x8138, "rtl8139b",      "Realtek 8139B"),
 577 PCI_ROM(0x1186, 0x1300, "dfe538",        "DFE530TX+/DFE538TX"),
 578 PCI_ROM(0x1113, 0x1211, "smc1211-1",     "SMC EZ10/100"),
 579 PCI_ROM(0x1112, 0x1211, "smc1211",       "SMC EZ10/100"),
 580 PCI_ROM(0x1500, 0x1360, "delta8139",     "Delta Electronics 8139"),
 581 PCI_ROM(0x4033, 0x1360, "addtron8139",   "Addtron Technology 8139"),
 582 PCI_ROM(0x1186, 0x1340, "dfe690txd",     "D-Link DFE690TXD"),
 583 PCI_ROM(0x13d1, 0xab06, "fe2000vx",      "AboCom FE2000VX"),
 584 PCI_ROM(0x1259, 0xa117, "allied8139",    "Allied Telesyn 8139"),
 585 PCI_ROM(0x14ea, 0xab06, "fnw3603tx",     "Planex FNW-3603-TX"),
 586 PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
 587 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
 588 };
 589
 590 struct pci_driver rtl8139_driver __pci_driver = {
 591         .ids = rtl8139_nics,
 592         .id_count = ( sizeof ( rtl8139_nics ) / sizeof ( rtl8139_nics[0] ) ),
 593         .probe = rtl_probe,
 594         .remove = rtl_remove,
 595 };