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