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