c61f0374c2b655ae4c5df09c98b16dc15f1a29a8
[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   28 Dec 2002   ken_yap@users.sourceforge.net (Ken Yap)
21      Put in virt_to_bus calls to allow Etherboot relocation.
22
23   06 Apr 2001   ken_yap@users.sourceforge.net (Ken Yap)
24      Following email from Hyun-Joon Cha, added a disable routine, otherwise
25      NIC remains live and can crash the kernel later.
26
27   4 Feb 2000    espenlaub@informatik.uni-ulm.de (Klaus Espenlaub)
28      Shuffled things around, removed the leftovers from the 8129 support
29      that was in the Linux driver and added a bit more 8139 definitions.
30      Moved the 8K receive buffer to a fixed, available address outside the
31      0x98000-0x9ffff range.  This is a bit of a hack, but currently the only
32      way to make room for the Etherboot features that need substantial amounts
33      of code like the ANSI console support.  Currently the buffer is just below
34      0x10000, so this even conforms to the tagged boot image specification,
35      which reserves the ranges 0x00000-0x10000 and 0x98000-0xA0000.  My
36      interpretation of this "reserved" is that Etherboot may do whatever it
37      likes, as long as its environment is kept intact (like the BIOS
38      variables).  Hopefully fixed rtl_poll() once and for all.  The symptoms
39      were that if Etherboot was left at the boot menu for several minutes, the
40      first eth_poll failed.  Seems like I am the only person who does this.
41      First of all I fixed the debugging code and then set out for a long bug
42      hunting session.  It took me about a week full time work - poking around
43      various places in the driver, reading Don Becker's and Jeff Garzik's Linux
44      driver and even the FreeBSD driver (what a piece of crap!) - and
45      eventually spotted the nasty thing: the transmit routine was acknowledging
46      each and every interrupt pending, including the RxOverrun and RxFIFIOver
47      interrupts.  This confused the RTL8139 thoroughly.  It destroyed the
48      Rx ring contents by dumping the 2K FIFO contents right where we wanted to
49      get the next packet.  Oh well, what fun.
50
51   18 Jan 2000   mdc@thinguin.org (Marty Connor)
52      Drastically simplified error handling.  Basically, if any error
53      in transmission or reception occurs, the card is reset.
54      Also, pointed all transmit descriptors to the same buffer to
55      save buffer space.  This should decrease driver size and avoid
56      corruption because of exceeding 32K during runtime.
57
58   28 Jul 1999   (Matthias Meixner - meixner@rbg.informatik.tu-darmstadt.de)
59      rtl_poll was quite broken: it used the RxOK interrupt flag instead
60      of the RxBufferEmpty flag which often resulted in very bad
61      transmission performace - below 1kBytes/s.
62
63 */
64
65 #include "etherboot.h"
66 #include "nic.h"
67 #include "pci.h"
68 #include "timer.h"
69
70 #define RTL_TIMEOUT (1*TICKS_PER_SEC)
71
72 /* PCI Tuning Parameters
73    Threshold is bytes transferred to chip before transmission starts. */
74 #define TX_FIFO_THRESH 256      /* In bytes, rounded down to 32 byte units. */
75 #define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
76 #define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
77 #define TX_DMA_BURST    4       /* Calculate as 16<<val. */
78 #define NUM_TX_DESC     4       /* Number of Tx descriptor registers. */
79 #define TX_BUF_SIZE     ETH_FRAME_LEN   /* FCS is added by the chip */
80 #define RX_BUF_LEN_IDX 0        /* 0, 1, 2 is allowed - 8,16,32K rx buffer */
81 #define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
82
83 #undef DEBUG_TX
84 #undef DEBUG_RX
85
86 /* Symbolic offsets to registers. */
87 enum RTL8139_registers {
88         MAC0=0,                 /* Ethernet hardware address. */
89         MAR0=8,                 /* Multicast filter. */
90         TxStatus0=0x10,         /* Transmit status (four 32bit registers). */
91         TxAddr0=0x20,           /* Tx descriptors (also four 32bit). */
92         RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36,
93         ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A,
94         IntrMask=0x3C, IntrStatus=0x3E,
95         TxConfig=0x40, RxConfig=0x44,
96         Timer=0x48,             /* general-purpose counter. */
97         RxMissed=0x4C,          /* 24 bits valid, write clears. */
98         Cfg9346=0x50, Config0=0x51, Config1=0x52,
99         TimerIntrReg=0x54,      /* intr if gp counter reaches this value */
100         MediaStatus=0x58,
101         Config3=0x59,
102         MultiIntr=0x5C,
103         RevisionID=0x5E,        /* revision of the RTL8139 chip */
104         TxSummary=0x60,
105         MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68,
106         NWayExpansion=0x6A,
107         DisconnectCnt=0x6C, FalseCarrierCnt=0x6E,
108         NWayTestReg=0x70,
109         RxCnt=0x72,             /* packet received counter */
110         CSCR=0x74,              /* chip status and configuration register */
111         PhyParm1=0x78,TwisterParm=0x7c,PhyParm2=0x80,   /* undocumented */
112         /* from 0x84 onwards are a number of power management/wakeup frame
113          * definitions we will probably never need to know about.  */
114 };
115
116 enum RxEarlyStatusBits {
117         ERGood=0x08, ERBad=0x04, EROVW=0x02, EROK=0x01
118 };
119
120 enum ChipCmdBits {
121         CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, };
122
123 enum IntrMaskBits {
124         SERR=0x8000, TimeOut=0x4000, LenChg=0x2000,
125         FOVW=0x40, PUN_LinkChg=0x20, RXOVW=0x10,
126         TER=0x08, TOK=0x04, RER=0x02, ROK=0x01
127 };
128
129 /* Interrupt register bits, using my own meaningful names. */
130 enum IntrStatusBits {
131         PCIErr=0x8000, PCSTimeout=0x4000, CableLenChange= 0x2000,
132         RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10,
133         TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01,
134 };
135 enum TxStatusBits {
136         TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000,
137         TxOutOfWindow=0x20000000, TxAborted=0x40000000,
138         TxCarrierLost=0x80000000,
139 };
140 enum RxStatusBits {
141         RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000,
142         RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004,
143         RxBadAlign=0x0002, RxStatusOK=0x0001,
144 };
145
146 enum MediaStatusBits {
147         MSRTxFlowEnable=0x80, MSRRxFlowEnable=0x40, MSRSpeed10=0x08,
148         MSRLinkFail=0x04, MSRRxPauseFlag=0x02, MSRTxPauseFlag=0x01,
149 };
150
151 enum MIIBMCRBits {
152         BMCRReset=0x8000, BMCRSpeed100=0x2000, BMCRNWayEnable=0x1000,
153         BMCRRestartNWay=0x0200, BMCRDuplex=0x0100,
154 };
155
156 enum CSCRBits {
157         CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800,
158         CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0,
159         CSCR_LinkDownCmd=0x0f3c0,
160 };
161
162 /* Bits in RxConfig. */
163 enum rx_mode_bits {
164         RxCfgWrap=0x80,
165         AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
166         AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
167 };
168
169 static unsigned int cur_rx,cur_tx;
170
171 /* The RTL8139 can only transmit from a contiguous, aligned memory block.  */
172 static unsigned char tx_buffer[TX_BUF_SIZE] __attribute__((aligned(4)));
173 static unsigned char rx_ring[RX_BUF_LEN+16] __attribute__((aligned(4)));
174
175 static int rtl8139_probe(struct dev *dev);
176 static int read_eeprom(struct nic *nic, int location, int addr_len);
177 static void rtl_reset(struct nic *nic);
178 static void rtl_transmit(struct nic *nic, const char *destaddr,
179         unsigned int type, unsigned int len, const char *data);
180 static int rtl_poll(struct nic *nic, int retrieve);
181 static void rtl_disable(struct nic *nic);
182 static void rtl_irq(struct nic *nic, irq_action_t action);
183 static struct nic_operations rtl_operations;
184 static struct pci_driver rtl8139_driver;
185
186 static int rtl8139_probe ( struct dev *dev, struct pci_device *pci ) {
187         struct nic *nic = nic_device ( dev );
188         int i;
189         int speed10, fullduplex;
190         int addr_len;
191         unsigned short *ap = (unsigned short*)nic->node_addr;
192
193         /* Look for PCI device */
194         if ( ! find_pci_device ( pci, &rtl8139_driver ) )
195                 return 0;
196
197         /* Copy ioaddr and IRQ from PCI information */
198         nic->ioaddr = pci->ioaddr;
199         nic->irqno = pci->irq;
200
201         /* Bring the chip out of low-power mode. */
202         outb(0x00, nic->ioaddr + Config1);
203
204         addr_len = read_eeprom(nic,0,8) == 0x8129 ? 8 : 6;
205         for (i = 0; i < 3; i++)
206           *ap++ = read_eeprom(nic,i + 7,addr_len);
207
208         rtl_reset(nic);
209
210         speed10 = inb(nic->ioaddr + MediaStatus) & MSRSpeed10;
211         nic->mbps = speed10 ? 10 : 100;
212         fullduplex = inw(nic->ioaddr + MII_BMCR) & BMCRDuplex;
213         nic->duplex = fullduplex ? FULL_DUPLEX : HALF_DUPLEX;
214
215         nic->nic_op     = &rtl_operations;
216         return 1;
217 }
218
219 /* Serial EEPROM section. */
220
221 /*  EEPROM_Ctrl bits. */
222 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
223 #define EE_CS           0x08    /* EEPROM chip select. */
224 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
225 #define EE_WRITE_0      0x00
226 #define EE_WRITE_1      0x02
227 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
228 #define EE_ENB          (0x80 | EE_CS)
229
230 /*
231         Delay between EEPROM clock transitions.
232         No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
233 */
234
235 #define eeprom_delay()  inl(ee_addr)
236
237 /* The EEPROM commands include the alway-set leading bit. */
238 #define EE_WRITE_CMD    (5)
239 #define EE_READ_CMD     (6)
240 #define EE_ERASE_CMD    (7)
241
242 static int read_eeprom(struct nic *nic, int location, int addr_len)
243 {
244         int i;
245         unsigned int retval = 0;
246         long ee_addr = nic->ioaddr + Cfg9346;
247         int read_cmd = location | (EE_READ_CMD << addr_len);
248
249         outb(EE_ENB & ~EE_CS, ee_addr);
250         outb(EE_ENB, ee_addr);
251         eeprom_delay();
252
253         /* Shift the read command bits out. */
254         for (i = 4 + addr_len; i >= 0; i--) {
255                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
256                 outb(EE_ENB | dataval, ee_addr);
257                 eeprom_delay();
258                 outb(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
259                 eeprom_delay();
260         }
261         outb(EE_ENB, ee_addr);
262         eeprom_delay();
263
264         for (i = 16; i > 0; i--) {
265                 outb(EE_ENB | EE_SHIFT_CLK, ee_addr);
266                 eeprom_delay();
267                 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
268                 outb(EE_ENB, ee_addr);
269                 eeprom_delay();
270         }
271
272         /* Terminate the EEPROM access. */
273         outb(~EE_CS, ee_addr);
274         eeprom_delay();
275         return retval;
276 }
277
278 static const unsigned int rtl8139_rx_config = 
279         (RX_BUF_LEN_IDX << 11) |
280         (RX_FIFO_THRESH << 13) |
281         (RX_DMA_BURST << 8);
282         
283 static void set_rx_mode(struct nic *nic) {
284         unsigned int mc_filter[2];
285         int rx_mode;
286         /* !IFF_PROMISC */
287         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
288         mc_filter[1] = mc_filter[0] = 0xffffffff;
289
290         outl(rtl8139_rx_config | rx_mode, nic->ioaddr + RxConfig);
291
292         outl(mc_filter[0], nic->ioaddr + MAR0 + 0);
293         outl(mc_filter[1], nic->ioaddr + MAR0 + 4);
294 }
295
296 static int rtl_connect ( struct nic *nic ) {
297         if (inb(nic->ioaddr + MediaStatus) & MSRLinkFail) {
298                 printf("Cable not connected or other link failure\n");
299                 return 0;
300         }
301         return 1;
302 }
303         
304 static void rtl_reset(struct nic* nic)
305 {
306         int i;
307
308         outb(CmdReset, nic->ioaddr + ChipCmd);
309
310         cur_rx = 0;
311         cur_tx = 0;
312
313         /* Give the chip 10ms to finish the reset. */
314         load_timer2(10*TICKS_PER_MS);
315         while ((inb(nic->ioaddr + ChipCmd) & CmdReset) != 0 &&
316                timer2_running())
317                 /* wait */;
318
319         for (i = 0; i < ETH_ALEN; i++)
320                 outb(nic->node_addr[i], nic->ioaddr + MAC0 + i);
321
322         /* Must enable Tx/Rx before setting transfer thresholds! */
323         outb(CmdRxEnb | CmdTxEnb, nic->ioaddr + ChipCmd);
324         outl((RX_FIFO_THRESH<<13) | (RX_BUF_LEN_IDX<<11) | (RX_DMA_BURST<<8),
325                 nic->ioaddr + RxConfig);          /* accept no frames yet!  */
326         outl((TX_DMA_BURST<<8)|0x03000000, nic->ioaddr + TxConfig);
327
328         /* The Linux driver changes Config1 here to use a different LED pattern
329          * for half duplex or full/autodetect duplex (for full/autodetect, the
330          * outputs are TX/RX, Link10/100, FULL, while for half duplex it uses
331          * TX/RX, Link100, Link10).  This is messy, because it doesn't match
332          * the inscription on the mounting bracket.  It should not be changed
333          * from the configuration EEPROM default, because the card manufacturer
334          * should have set that to match the card.  */
335
336 #ifdef  DEBUG_RX
337         printf("rx ring address is %X\n",(unsigned long)rx_ring);
338 #endif
339         outl((unsigned long)virt_to_bus(rx_ring), nic->ioaddr + RxBuf);
340
341
342
343         /* If we add multicast support, the MAR0 register would have to be
344          * initialized to 0xffffffffffffffff (two 32 bit accesses).  Etherboot
345          * only needs broadcast (for ARP/RARP/BOOTP/DHCP) and unicast.  */
346
347         outb(CmdRxEnb | CmdTxEnb, nic->ioaddr + ChipCmd);
348         
349         outl(rtl8139_rx_config, nic->ioaddr + RxConfig);
350         
351         /* Start the chip's Tx and Rx process. */
352         outl(0, nic->ioaddr + RxMissed);
353
354         /* set_rx_mode */
355         set_rx_mode(nic);
356         
357         /* Disable all known interrupts by setting the interrupt mask. */
358         outw(0, nic->ioaddr + IntrMask);
359 }
360
361 static void rtl_transmit(struct nic *nic, const char *destaddr,
362         unsigned int type, unsigned int len, const char *data)
363 {
364         unsigned int status, to, nstype;
365         unsigned long txstatus;
366
367         /* nstype assignment moved up here to avoid gcc 3.0.3 compiler bug */
368         nstype = htons(type);
369         memcpy(tx_buffer, destaddr, ETH_ALEN);
370         memcpy(tx_buffer + ETH_ALEN, nic->node_addr, ETH_ALEN);
371         memcpy(tx_buffer + 2 * ETH_ALEN, &nstype, 2);
372         memcpy(tx_buffer + ETH_HLEN, data, len);
373
374         len += ETH_HLEN;
375 #ifdef  DEBUG_TX
376         printf("sending %d bytes ethtype %hX\n", len, type);
377 #endif
378
379         /* Note: RTL8139 doesn't auto-pad, send minimum payload (another 4
380          * bytes are sent automatically for the FCS, totalling to 64 bytes). */
381         while (len < ETH_ZLEN) {
382                 tx_buffer[len++] = '\0';
383         }
384
385         outl((unsigned long)virt_to_bus(tx_buffer), nic->ioaddr + TxAddr0 + cur_tx*4);
386         outl(((TX_FIFO_THRESH<<11) & 0x003f0000) | len,
387                 nic->ioaddr + TxStatus0 + cur_tx*4);
388
389         to = currticks() + RTL_TIMEOUT;
390
391         do {
392                 status = inw(nic->ioaddr + IntrStatus);
393                 /* Only acknlowledge interrupt sources we can properly handle
394                  * here - the RxOverflow/RxFIFOOver MUST be handled in the
395                  * rtl_poll() function.  */
396                 outw(status & (TxOK | TxErr | PCIErr), nic->ioaddr + IntrStatus);
397                 if ((status & (TxOK | TxErr | PCIErr)) != 0) break;
398         } while (currticks() < to);
399
400         txstatus = inl(nic->ioaddr+ TxStatus0 + cur_tx*4);
401
402         if (status & TxOK) {
403                 cur_tx = (cur_tx + 1) % NUM_TX_DESC;
404 #ifdef  DEBUG_TX
405                 printf("tx done (%d ticks), status %hX txstatus %X\n",
406                         to-currticks(), status, txstatus);
407 #endif
408         } else {
409 #ifdef  DEBUG_TX
410                 printf("tx timeout/error (%d ticks), status %hX txstatus %X\n",
411                         currticks()-to, status, txstatus);
412 #endif
413                 rtl_reset(nic);
414         }
415 }
416
417 static int rtl_poll(struct nic *nic, int retrieve)
418 {
419         unsigned int status;
420         unsigned int ring_offs;
421         unsigned int rx_size, rx_status;
422
423         if (inb(nic->ioaddr + ChipCmd) & RxBufEmpty) {
424                 return 0;
425         }
426
427         /* There is a packet ready */
428         if ( ! retrieve ) return 1;
429
430         status = inw(nic->ioaddr + IntrStatus);
431         /* See below for the rest of the interrupt acknowledges.  */
432         outw(status & ~(RxFIFOOver | RxOverflow | RxOK), nic->ioaddr + IntrStatus);
433
434 #ifdef  DEBUG_RX
435         printf("rtl_poll: int %hX ", status);
436 #endif
437
438         ring_offs = cur_rx % RX_BUF_LEN;
439         rx_status = *(unsigned int*)(rx_ring + ring_offs);
440         rx_size = rx_status >> 16;
441         rx_status &= 0xffff;
442
443         if ((rx_status & (RxBadSymbol|RxRunt|RxTooLong|RxCRCErr|RxBadAlign)) ||
444             (rx_size < ETH_ZLEN) || (rx_size > ETH_FRAME_LEN + 4)) {
445                 printf("rx error %hX\n", rx_status);
446                 rtl_reset(nic); /* this clears all interrupts still pending */
447                 return 0;
448         }
449
450         /* Received a good packet */
451         nic->packetlen = rx_size - 4;   /* no one cares about the FCS */
452         if (ring_offs+4+rx_size-4 > RX_BUF_LEN) {
453                 int semi_count = RX_BUF_LEN - ring_offs - 4;
454
455                 memcpy(nic->packet, rx_ring + ring_offs + 4, semi_count);
456                 memcpy(nic->packet+semi_count, rx_ring, rx_size-4-semi_count);
457 #ifdef  DEBUG_RX
458                 printf("rx packet %d+%d bytes", semi_count,rx_size-4-semi_count);
459 #endif
460         } else {
461                 memcpy(nic->packet, rx_ring + ring_offs + 4, nic->packetlen);
462 #ifdef  DEBUG_RX
463                 printf("rx packet %d bytes", rx_size-4);
464 #endif
465         }
466 #ifdef  DEBUG_RX
467         printf(" at %X type %hhX%hhX rxstatus %hX\n",
468                 (unsigned long)(rx_ring+ring_offs+4),
469                 nic->packet[12], nic->packet[13], rx_status);
470 #endif
471         cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
472         outw(cur_rx - 16, nic->ioaddr + RxBufPtr);
473         /* See RTL8139 Programming Guide V0.1 for the official handling of
474          * Rx overflow situations.  The document itself contains basically no
475          * usable information, except for a few exception handling rules.  */
476         outw(status & (RxFIFOOver | RxOverflow | RxOK), nic->ioaddr + IntrStatus);
477         return 1;
478 }
479
480 static void rtl_irq(struct nic *nic, irq_action_t action)
481 {
482         unsigned int mask;
483         /* Bit of a guess as to which interrupts we should allow */
484         unsigned int interested = ROK | RER | RXOVW | FOVW | SERR;
485
486         switch ( action ) {
487         case DISABLE :
488         case ENABLE :
489                 mask = inw(nic->ioaddr + IntrMask);
490                 mask = mask & ~interested;
491                 if ( action == ENABLE ) mask = mask | interested;
492                 outw(mask, nic->ioaddr + IntrMask);
493                 break;
494         case FORCE :
495                 /* Apparently writing a 1 to this read-only bit of a
496                  * read-only and otherwise unrelated register will
497                  * force an interrupt.  If you ever want to see how
498                  * not to write a datasheet, read the one for the
499                  * RTL8139...
500                  */
501                 outb(EROK, nic->ioaddr + RxEarlyStatus);
502                 break;
503         }
504 }
505
506 static void rtl_disable ( struct nic *nic ) {
507         /* merge reset and disable */
508         rtl_reset(nic);
509
510         /* reset the chip */
511         outb(CmdReset, nic->ioaddr + ChipCmd);
512
513         /* 10 ms timeout */
514         load_timer2(10*TICKS_PER_MS);
515         while ((inb(nic->ioaddr + ChipCmd) & CmdReset) != 0 && timer2_running())
516                 /* wait */;
517 }
518
519 static struct nic_operations rtl_operations = {
520         .connect        = rtl_connect,
521         .poll           = rtl_poll,
522         .transmit       = rtl_transmit,
523         .irq            = rtl_irq,
524         .disable        = rtl_disable,
525 };
526
527 static struct pci_id rtl8139_nics[] = {
528 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
529 PCI_ROM(0x10ec, 0x8139, "rtl8139",       "Realtek 8139"),
530 PCI_ROM(0x10ec, 0x8138, "rtl8139b",      "Realtek 8139B"),
531 PCI_ROM(0x1186, 0x1300, "dfe538",        "DFE530TX+/DFE538TX"),
532 PCI_ROM(0x1113, 0x1211, "smc1211-1",     "SMC EZ10/100"),
533 PCI_ROM(0x1112, 0x1211, "smc1211",       "SMC EZ10/100"),
534 PCI_ROM(0x1500, 0x1360, "delta8139",     "Delta Electronics 8139"),
535 PCI_ROM(0x4033, 0x1360, "addtron8139",   "Addtron Technology 8139"),
536 PCI_ROM(0x1186, 0x1340, "dfe690txd",     "D-Link DFE690TXD"),
537 PCI_ROM(0x13d1, 0xab06, "fe2000vx",      "AboCom FE2000VX"),
538 PCI_ROM(0x1259, 0xa117, "allied8139",    "Allied Telesyn 8139"),
539 PCI_ROM(0x14ea, 0xab06, "fnw3603tx",     "Planex FNW-3603-TX"),
540 PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
541 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
542 };
543
544 static struct pci_driver rtl8139_driver =
545         PCI_DRIVER ( "RTL8139", rtl8139_nics, PCI_NO_CLASS );
546
547 BOOT_DRIVER ( "RTL8139", rtl8139_probe );