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