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