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 static struct spi_device_type rtl_ee9346 = AT93C46 ( 16 );
 244 static struct spi_device_type rtl_ee9356 = AT93C56 ( 16 );
 245
 246 /**
 247  * Set up for EEPROM access
 248  *
 249  * @v rtl               RTL8139 NIC
 250  */
 251 static void rtl_init_eeprom ( struct rtl8139_nic *rtl ) {
 252         int ee9356;
 253
 254         /* Initialise three-wire bus */
 255         rtl->spibit.basher.op = &rtl_basher_ops;
 256         rtl->spibit.bus.mode = SPI_MODE_THREEWIRE;
 257         init_spi_bit_basher ( &rtl->spibit );
 258
 259         /* Detect EEPROM type and initialise three-wire device */
 260         ee9356 = ( inw ( rtl->ioaddr + RxConfig ) & Eeprom9356 );
 261         DBG ( "EEPROM is an %s\n", ( ee9356 ? "AT93C56" : "AT93C46" ) );
 262         rtl->eeprom.type = ( ee9356 ? &rtl_ee9356 : &rtl_ee9346 );
 263         rtl->eeprom.bus = &rtl->spibit.bus;
 264 }
 265
 266 /**
 267  * Read the MAC address
 268  *
 269  * @v rtl               RTL8139 NIC
 270  * @v mac_addr          Buffer to contain MAC address (ETH_ALEN bytes)
 271  */
 272 static void rtl_read_mac ( struct rtl8139_nic *rtl, uint8_t *mac_addr ) {
 273
 274         struct spi_device *device = &rtl->eeprom;
 275         int i;
 276
 277         DBG ( "MAC address is " );
 278         for ( i = EE_MAC ; i < ( EE_MAC + ( ETH_ALEN / 2 ) ) ; i++ ) {
 279                 device->type->read ( device, i, mac_addr, 2 );
 280                 DBG ( "%02x%02x", mac_addr[0], mac_addr[1] );
 281                 mac_addr += 2;
 282         }
 283         DBG ( "\n" );
 284 }
 285
 286 /**
 287  * Reset NIC
 288  *
 289  * @v rtl               RTL8139 NIC
 290  *
 291  * Issues a hardware reset and waits for the reset to complete.
 292  */
 293 static void rtl_reset ( struct rtl8139_nic *rtl ) {
 294
 295         /* Reset chip */
 296         outb ( CmdReset, rtl->ioaddr + ChipCmd );
 297         mdelay ( 10 );
 298         rtl->tx.next = 0;
 299         rtl->rx.offset = 0;
 300 }
 301
 302 /**
 303  * Open NIC
 304  *
 305  * @v netdev            Net device
 306  * @ret rc              Return status code
 307  */
 308 static int rtl_open ( struct net_device *netdev ) {
 309         struct rtl8139_nic *rtl = netdev->priv;
 310         int i;
 311
 312         /* Program the MAC address */
 313         for ( i = 0 ; i < ETH_ALEN ; i++ )
 314                 outb ( netdev->ll_addr[i], rtl->ioaddr + MAC0 + i );
 315
 316         /* Set up RX ring */
 317         rtl->rx.ring = malloc ( RX_BUF_LEN + RX_BUF_PAD );
 318         if ( ! rtl->rx.ring )
 319                 return -ENOMEM;
 320         outl ( virt_to_bus ( rtl->rx.ring ), rtl->ioaddr + RxBuf );
 321         DBG ( "RX ring at %lx\n", virt_to_bus ( rtl->rx.ring ) );
 322
 323         /* Enable TX and RX */
 324         outb ( ( CmdRxEnb | CmdTxEnb ), rtl->ioaddr + ChipCmd );
 325         outl ( ( ( RX_FIFO_THRESH << 13 ) | ( RX_BUF_LEN_IDX << 11 ) |
 326                  ( RX_DMA_BURST << 8 ) | AcceptBroadcast | AcceptMulticast |
 327                  AcceptMyPhys ), rtl->ioaddr + RxConfig );
 328         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 0 );
 329         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 4 );
 330         outl ( ( ( TX_DMA_BURST << 8 ) | ( TX_IPG << 24 ) ),
 331                rtl->ioaddr + TxConfig );
 332
 333         return 0;
 334 }
 335
 336 /**
 337  * Close NIC
 338  *
 339  * @v netdev            Net device
 340  */
 341 static void rtl_close ( struct net_device *netdev ) {
 342         struct rtl8139_nic *rtl = netdev->priv;
 343         int i;
 344
 345         /* Reset the hardware to disable everything in one go */
 346         rtl_reset ( rtl );
 347
 348         /* Free RX ring */
 349         free ( rtl->rx.ring );
 350         rtl->rx.ring = NULL;
 351
 352         /* Free any old TX buffers that hadn't yet completed */
 353         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 354                 if ( rtl->tx.pkb[i] ) {
 355                         free_pkb ( rtl->tx.pkb[i] );
 356                         rtl->tx.pkb[i] = NULL;
 357                         DBG ( "TX id %d discarded\n", i );
 358                 }
 359         }
 360 }
 361
 362 /**
 363  * Transmit packet
 364  *
 365  * @v netdev    Network device
 366  * @v pkb       Packet buffer
 367  * @ret rc      Return status code
 368  */
 369 static int rtl_transmit ( struct net_device *netdev, struct pk_buff *pkb ) {
 370         struct rtl8139_nic *rtl = netdev->priv;
 371         int align;
 372         int pad_len;
 373
 374         /* Check for space in TX ring */
 375         if ( rtl->tx.pkb[rtl->tx.next] != NULL ) {
 376                 printf ( "TX overflow\n" );
 377                 free_pkb ( pkb );
 378                 return -ENOBUFS;
 379         }
 380
 381         /* Align packet data */
 382         align = ( virt_to_bus ( pkb->data ) & 0x3 );
 383         pkb_push ( pkb, align );
 384         memmove ( pkb->data, pkb->data + align, pkb_len ( pkb ) - align );
 385         pkb_unput ( pkb, align );
 386
 387         /* Pad to minimum packet length */
 388         pad_len = ( ETH_ZLEN - pkb_len ( pkb ) );
 389         if ( pad_len > 0 )
 390                 memset ( pkb_put ( pkb, pad_len ), 0, pad_len );
 391
 392         /* Add to TX ring */
 393         DBG ( "TX id %d at %lx+%x\n", rtl->tx.next,
 394               virt_to_bus ( pkb->data ), pkb_len ( pkb ) );
 395         rtl->tx.pkb[rtl->tx.next] = pkb;
 396         outl ( virt_to_bus ( pkb->data ),
 397                rtl->ioaddr + TxAddr0 + 4 * rtl->tx.next );
 398         outl ( ( ( ( TX_FIFO_THRESH & 0x7e0 ) << 11 ) | pkb_len ( pkb ) ),
 399                rtl->ioaddr + TxStatus0 + 4 * rtl->tx.next );
 400         rtl->tx.next = ( rtl->tx.next + 1 ) % TX_RING_SIZE;
 401
 402         return 0;
 403 }
 404
 405 /**
 406  * Poll for received packets
 407  *
 408  * @v netdev    Network device
 409  */
 410 static void rtl_poll ( struct net_device *netdev ) {
 411         struct rtl8139_nic *rtl = netdev->priv;
 412         unsigned int status;
 413         unsigned int tsad;
 414         unsigned int rx_status;
 415         unsigned int rx_len;
 416         struct pk_buff *rx_pkb;
 417         int wrapped_len;
 418         int i;
 419
 420         /* Acknowledge interrupts */
 421         status = inw ( rtl->ioaddr + IntrStatus );
 422         if ( ! status )
 423                 return;
 424         outw ( status, rtl->ioaddr + IntrStatus );
 425
 426         /* Handle TX completions */
 427         tsad = inw ( rtl->ioaddr + TxSummary );
 428         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 429                 if ( ( rtl->tx.pkb[i] != NULL ) && ( tsad & ( 1 << i ) ) ) {
 430                         DBG ( "TX id %d complete\n", i );
 431                         free_pkb ( rtl->tx.pkb[i] );
 432                         rtl->tx.pkb[i] = NULL;
 433                 }
 434         }
 435
 436         /* Handle received packets */
 437         while ( ! ( inw ( rtl->ioaddr + ChipCmd ) & RxBufEmpty ) ) {
 438                 rx_status = * ( ( uint16_t * )
 439                                 ( rtl->rx.ring + rtl->rx.offset ) );
 440                 rx_len = * ( ( uint16_t * )
 441                              ( rtl->rx.ring + rtl->rx.offset + 2 ) );
 442                 if ( rx_status & RxOK ) {
 443                         DBG ( "RX packet at offset %x+%x\n", rtl->rx.offset,
 444                               rx_len );
 445
 446                         rx_pkb = alloc_pkb ( rx_len );
 447                         if ( ! rx_pkb ) {
 448                                 /* Leave packet for next call to poll() */
 449                                 break;
 450                         }
 451
 452                         wrapped_len = ( ( rtl->rx.offset + 4 + rx_len )
 453                                         - RX_BUF_LEN );
 454                         if ( wrapped_len < 0 )
 455                                 wrapped_len = 0;
 456
 457                         memcpy ( pkb_put ( rx_pkb, rx_len - wrapped_len ),
 458                                  rtl->rx.ring + rtl->rx.offset + 4,
 459                                  rx_len - wrapped_len );
 460                         memcpy ( pkb_put ( rx_pkb, wrapped_len ),
 461                                  rtl->rx.ring, wrapped_len );
 462
 463                         netdev_rx ( netdev, rx_pkb );
 464                 } else {
 465                         DBG ( "RX bad packet (status %#04x len %d)\n",
 466                               rx_status, rx_len );
 467                 }
 468                 rtl->rx.offset = ( ( ( rtl->rx.offset + 4 + rx_len + 3 ) & ~3 )
 469                                    % RX_BUF_LEN );
 470                 outw ( rtl->rx.offset - 16, rtl->ioaddr + RxBufPtr );
 471         }
 472 }
 473
 474 #if 0
 475 static void rtl_irq(struct nic *nic, irq_action_t action)
 476 {
 477         unsigned int mask;
 478         /* Bit of a guess as to which interrupts we should allow */
 479         unsigned int interested = ROK | RER | RXOVW | FOVW | SERR;
 480
 481         switch ( action ) {
 482         case DISABLE :
 483         case ENABLE :
 484                 mask = inw(rtl->ioaddr + IntrMask);
 485                 mask = mask & ~interested;
 486                 if ( action == ENABLE ) mask = mask | interested;
 487                 outw(mask, rtl->ioaddr + IntrMask);
 488                 break;
 489         case FORCE :
 490                 /* Apparently writing a 1 to this read-only bit of a
 491                  * read-only and otherwise unrelated register will
 492                  * force an interrupt.  If you ever want to see how
 493                  * not to write a datasheet, read the one for the
 494                  * RTL8139...
 495                  */
 496                 outb(EROK, rtl->ioaddr + RxEarlyStatus);
 497                 break;
 498         }
 499 }
 500 #endif
 501
 502 /**
 503  * Probe PCI device
 504  *
 505  * @v pci       PCI device
 506  * @v id        PCI ID
 507  * @ret rc      Return status code
 508  */
 509 static int rtl_probe ( struct pci_device *pci,
 510                        const struct pci_device_id *id __unused ) {
 511         struct net_device *netdev;
 512         struct rtl8139_nic *rtl = NULL;
 513         int rc;
 514
 515         /* Fix up PCI device */
 516         adjust_pci_device ( pci );
 517
 518         /* Allocate net device */
 519         netdev = alloc_etherdev ( sizeof ( *rtl ) );
 520         if ( ! netdev ) {
 521                 rc = -ENOMEM;
 522                 goto err;
 523         }
 524         rtl = netdev->priv;
 525         pci_set_drvdata ( pci, netdev );
 526         memset ( rtl, 0, sizeof ( *rtl ) );
 527         rtl->ioaddr = pci->ioaddr;
 528
 529         /* Reset the NIC, set up EEPROM access and read MAC address */
 530         rtl_reset ( rtl );
 531         rtl_init_eeprom ( rtl );
 532         rtl_read_mac ( rtl, netdev->ll_addr );
 533
 534         /* Point to NIC specific routines */
 535         //      netdev->open     = rtl_open;
 536         //      netdev->close    = rtl_close;
 537         netdev->transmit = rtl_transmit;
 538         netdev->poll     = rtl_poll;
 539
 540         /* Register network device */
 541         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 542                 goto err;
 543
 544
 545 #warning "Hack alert"
 546         rtl_open ( netdev );
 547
 548
 549         return 0;
 550
 551  err:
 552         /* Disable NIC */
 553         if ( rtl )
 554                 rtl_reset ( rtl );
 555         /* Free net device */
 556         free_netdev ( netdev );
 557         return rc;
 558 }
 559
 560 /**
 561  * Remove PCI device
 562  *
 563  * @v pci       PCI device
 564  */
 565 static void rtl_remove ( struct pci_device *pci ) {
 566         struct net_device *netdev = pci_get_drvdata ( pci );
 567         struct rtl8139_nic *rtl = netdev->priv;
 568
 569
 570 #warning "Hack alert"
 571         rtl_close ( netdev );
 572
 573
 574         unregister_netdev ( netdev );
 575         rtl_reset ( rtl );
 576         free_netdev ( netdev );
 577 }
 578
 579 static struct pci_device_id rtl8139_nics[] = {
 580 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
 581 PCI_ROM(0x10ec, 0x8139, "rtl8139",       "Realtek 8139"),
 582 PCI_ROM(0x10ec, 0x8138, "rtl8139b",      "Realtek 8139B"),
 583 PCI_ROM(0x1186, 0x1300, "dfe538",        "DFE530TX+/DFE538TX"),
 584 PCI_ROM(0x1113, 0x1211, "smc1211-1",     "SMC EZ10/100"),
 585 PCI_ROM(0x1112, 0x1211, "smc1211",       "SMC EZ10/100"),
 586 PCI_ROM(0x1500, 0x1360, "delta8139",     "Delta Electronics 8139"),
 587 PCI_ROM(0x4033, 0x1360, "addtron8139",   "Addtron Technology 8139"),
 588 PCI_ROM(0x1186, 0x1340, "dfe690txd",     "D-Link DFE690TXD"),
 589 PCI_ROM(0x13d1, 0xab06, "fe2000vx",      "AboCom FE2000VX"),
 590 PCI_ROM(0x1259, 0xa117, "allied8139",    "Allied Telesyn 8139"),
 591 PCI_ROM(0x14ea, 0xab06, "fnw3603tx",     "Planex FNW-3603-TX"),
 592 PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
 593 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
 594 };
 595
 596 struct pci_driver rtl8139_driver __pci_driver = {
 597         .ids = rtl8139_nics,
 598         .id_count = ( sizeof ( rtl8139_nics ) / sizeof ( rtl8139_nics[0] ) ),
 599         .probe = rtl_probe,
 600         .remove = rtl_remove,
 601 };