[Settings] Migrate DHCP and NVO code to the new settings API (untested)
[people/dverkamp/gpxe.git] / src / drivers / net / rtl8139.c
1 /* rtl8139.c - etherboot driver for the Realtek 8139 chipset
2
3   ported from the linux driver written by Donald Becker
4   by Rainer Bawidamann (Rainer.Bawidamann@informatik.uni-ulm.de) 1999
5
6   This software may be used and distributed according to the terms
7   of the GNU Public License, incorporated herein by reference.
8
9   changes to the original driver:
10   - removed support for interrupts, switching to polling mode (yuck!)
11   - removed support for the 8129 chip (external MII)
12
13 */
14
15 /*********************************************************************/
16 /* Revision History                                                  */
17 /*********************************************************************/
18
19 /*
20   27 May 2006   mcb30@users.sourceforge.net (Michael Brown)
21      Rewrote to use the new net driver API, the updated PCI API, and
22      the generic three-wire serial device support for EEPROM access.
23
24   28 Dec 2002   ken_yap@users.sourceforge.net (Ken Yap)
25      Put in virt_to_bus calls to allow Etherboot relocation.
26
27   06 Apr 2001   ken_yap@users.sourceforge.net (Ken Yap)
28      Following email from Hyun-Joon Cha, added a disable routine, otherwise
29      NIC remains live and can crash the kernel later.
30
31   4 Feb 2000    espenlaub@informatik.uni-ulm.de (Klaus Espenlaub)
32      Shuffled things around, removed the leftovers from the 8129 support
33      that was in the Linux driver and added a bit more 8139 definitions.
34      Moved the 8K receive buffer to a fixed, available address outside the
35      0x98000-0x9ffff range.  This is a bit of a hack, but currently the only
36      way to make room for the Etherboot features that need substantial amounts
37      of code like the ANSI console support.  Currently the buffer is just below
38      0x10000, so this even conforms to the tagged boot image specification,
39      which reserves the ranges 0x00000-0x10000 and 0x98000-0xA0000.  My
40      interpretation of this "reserved" is that Etherboot may do whatever it
41      likes, as long as its environment is kept intact (like the BIOS
42      variables).  Hopefully fixed rtl_poll() once and for all.  The symptoms
43      were that if Etherboot was left at the boot menu for several minutes, the
44      first eth_poll failed.  Seems like I am the only person who does this.
45      First of all I fixed the debugging code and then set out for a long bug
46      hunting session.  It took me about a week full time work - poking around
47      various places in the driver, reading Don Becker's and Jeff Garzik's Linux
48      driver and even the FreeBSD driver (what a piece of crap!) - and
49      eventually spotted the nasty thing: the transmit routine was acknowledging
50      each and every interrupt pending, including the RxOverrun and RxFIFIOver
51      interrupts.  This confused the RTL8139 thoroughly.  It destroyed the
52      Rx ring contents by dumping the 2K FIFO contents right where we wanted to
53      get the next packet.  Oh well, what fun.
54
55   18 Jan 2000   mdc@etherboot.org (Marty Connor)
56      Drastically simplified error handling.  Basically, if any error
57      in transmission or reception occurs, the card is reset.
58      Also, pointed all transmit descriptors to the same buffer to
59      save buffer space.  This should decrease driver size and avoid
60      corruption because of exceeding 32K during runtime.
61
62   28 Jul 1999   (Matthias Meixner - meixner@rbg.informatik.tu-darmstadt.de)
63      rtl_poll was quite broken: it used the RxOK interrupt flag instead
64      of the RxBufferEmpty flag which often resulted in very bad
65      transmission performace - below 1kBytes/s.
66
67 */
68
69 #include <stdint.h>
70 #include <stdlib.h>
71 #include <stdio.h>
72 #include <io.h>
73 #include <errno.h>
74 #include <unistd.h>
75 #include <byteswap.h>
76 #include <gpxe/pci.h>
77 #include <gpxe/if_ether.h>
78 #include <gpxe/ethernet.h>
79 #include <gpxe/iobuf.h>
80 #include <gpxe/netdevice.h>
81 #include <gpxe/spi_bit.h>
82 #include <gpxe/threewire.h>
83 #include <gpxe/nvo.h>
84
85 #define TX_RING_SIZE 4
86
87 struct rtl8139_tx {
88         unsigned int next;
89         struct io_buffer *iobuf[TX_RING_SIZE];
90 };
91
92 struct rtl8139_rx {
93         void *ring;
94         unsigned int offset;
95 };
96
97 struct rtl8139_nic {
98         unsigned short ioaddr;
99         struct rtl8139_tx tx;
100         struct rtl8139_rx rx;
101         struct spi_bit_basher spibit;
102         struct spi_device eeprom;
103         struct nvo_block nvo;
104 };
105
106 /* Tuning Parameters */
107 #define TX_FIFO_THRESH  256     /* In bytes, rounded down to 32 byte units. */
108 #define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
109 #define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
110 #define TX_DMA_BURST    4       /* Calculate as 16<<val. */
111 #define TX_IPG          3       /* This is the only valid value */
112 #define RX_BUF_LEN_IDX  0       /* 0, 1, 2 is allowed - 8,16,32K rx buffer */
113 #define RX_BUF_LEN ( (8192 << RX_BUF_LEN_IDX) )
114 #define RX_BUF_PAD 4
115
116 /* Symbolic offsets to registers. */
117 enum RTL8139_registers {
118         MAC0=0,                 /* Ethernet hardware address. */
119         MAR0=8,                 /* Multicast filter. */
120         TxStatus0=0x10,         /* Transmit status (four 32bit registers). */
121         TxAddr0=0x20,           /* Tx descriptors (also four 32bit). */
122         RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36,
123         ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A,
124         IntrMask=0x3C, IntrStatus=0x3E,
125         TxConfig=0x40, RxConfig=0x44,
126         Timer=0x48,             /* general-purpose counter. */
127         RxMissed=0x4C,          /* 24 bits valid, write clears. */
128         Cfg9346=0x50, Config0=0x51, Config1=0x52,
129         TimerIntrReg=0x54,      /* intr if gp counter reaches this value */
130         MediaStatus=0x58,
131         Config3=0x59,
132         MultiIntr=0x5C,
133         RevisionID=0x5E,        /* revision of the RTL8139 chip */
134         TxSummary=0x60,
135         MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68,
136         NWayExpansion=0x6A,
137         DisconnectCnt=0x6C, FalseCarrierCnt=0x6E,
138         NWayTestReg=0x70,
139         RxCnt=0x72,             /* packet received counter */
140         CSCR=0x74,              /* chip status and configuration register */
141         PhyParm1=0x78,TwisterParm=0x7c,PhyParm2=0x80,   /* undocumented */
142         /* from 0x84 onwards are a number of power management/wakeup frame
143          * definitions we will probably never need to know about.  */
144 };
145
146 enum RxEarlyStatusBits {
147         ERGood=0x08, ERBad=0x04, EROVW=0x02, EROK=0x01
148 };
149
150 enum ChipCmdBits {
151         CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, };
152
153 enum IntrMaskBits {
154         SERR=0x8000, TimeOut=0x4000, LenChg=0x2000,
155         FOVW=0x40, PUN_LinkChg=0x20, RXOVW=0x10,
156         TER=0x08, TOK=0x04, RER=0x02, ROK=0x01
157 };
158
159 /* Interrupt register bits, using my own meaningful names. */
160 enum IntrStatusBits {
161         PCIErr=0x8000, PCSTimeout=0x4000, CableLenChange= 0x2000,
162         RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10,
163         TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01,
164 };
165 enum TxStatusBits {
166         TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000,
167         TxOutOfWindow=0x20000000, TxAborted=0x40000000,
168         TxCarrierLost=0x80000000,
169 };
170 enum RxStatusBits {
171         RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000,
172         RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004,
173         RxBadAlign=0x0002, RxStatusOK=0x0001,
174 };
175
176 enum MediaStatusBits {
177         MSRTxFlowEnable=0x80, MSRRxFlowEnable=0x40, MSRSpeed10=0x08,
178         MSRLinkFail=0x04, MSRRxPauseFlag=0x02, MSRTxPauseFlag=0x01,
179 };
180
181 enum MIIBMCRBits {
182         BMCRReset=0x8000, BMCRSpeed100=0x2000, BMCRNWayEnable=0x1000,
183         BMCRRestartNWay=0x0200, BMCRDuplex=0x0100,
184 };
185
186 enum CSCRBits {
187         CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800,
188         CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0,
189         CSCR_LinkDownCmd=0x0f3c0,
190 };
191
192 enum RxConfigBits {
193         RxCfgWrap=0x80,
194         Eeprom9356=0x40,
195         AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
196         AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
197 };
198
199 enum Config1Bits {
200         VPDEnable=0x02,
201 };
202
203 /*  EEPROM access */
204 #define EE_M1           0x80    /* Mode select bit 1 */
205 #define EE_M0           0x40    /* Mode select bit 0 */
206 #define EE_CS           0x08    /* EEPROM chip select */
207 #define EE_SK           0x04    /* EEPROM shift clock */
208 #define EE_DI           0x02    /* Data in */
209 #define EE_DO           0x01    /* Data out */
210
211 /* Offsets within EEPROM (these are word offsets) */
212 #define EE_MAC 7
213
214 static const uint8_t rtl_ee_bits[] = {
215         [SPI_BIT_SCLK]  = EE_SK,
216         [SPI_BIT_MOSI]  = EE_DI,
217         [SPI_BIT_MISO]  = EE_DO,
218         [SPI_BIT_SS(0)] = ( EE_CS | EE_M1 ),
219 };
220
221 static int rtl_spi_read_bit ( struct bit_basher *basher,
222                               unsigned int bit_id ) {
223         struct rtl8139_nic *rtl = container_of ( basher, struct rtl8139_nic,
224                                                  spibit.basher );
225         uint8_t mask = rtl_ee_bits[bit_id];
226         uint8_t eereg;
227
228         eereg = inb ( rtl->ioaddr + Cfg9346 );
229         return ( eereg & mask );
230 }
231
232 static void rtl_spi_write_bit ( struct bit_basher *basher,
233                                 unsigned int bit_id, unsigned long data ) {
234         struct rtl8139_nic *rtl = container_of ( basher, struct rtl8139_nic,
235                                                  spibit.basher );
236         uint8_t mask = rtl_ee_bits[bit_id];
237         uint8_t eereg;
238
239         eereg = inb ( rtl->ioaddr + Cfg9346 );
240         eereg &= ~mask;
241         eereg |= ( data & mask );
242         outb ( eereg, rtl->ioaddr + Cfg9346 );
243 }
244
245 static struct bit_basher_operations rtl_basher_ops = {
246         .read = rtl_spi_read_bit,
247         .write = rtl_spi_write_bit,
248 };
249
250 /** Portion of EEPROM available for non-volatile stored options
251  *
252  * We use offset 0x40 (i.e. address 0x20), length 0x40.  This block is
253  * marked as VPD in the rtl8139 datasheets, so we use it only if we
254  * detect that the card is not supporting VPD.
255  */
256 static struct nvo_fragment rtl_nvo_fragments[] = {
257         { 0x20, 0x40 },
258         { 0, 0 }
259 };
260
261 /**
262  * Set up for EEPROM access
263  *
264  * @v netdev            Net device
265  */
266 static void rtl_init_eeprom ( struct net_device *netdev ) {
267         struct rtl8139_nic *rtl = netdev->priv;
268         int ee9356;
269         int vpd;
270
271         /* Initialise three-wire bus */
272         rtl->spibit.basher.op = &rtl_basher_ops;
273         rtl->spibit.bus.mode = SPI_MODE_THREEWIRE;
274         init_spi_bit_basher ( &rtl->spibit );
275
276         /* Detect EEPROM type and initialise three-wire device */
277         ee9356 = ( inw ( rtl->ioaddr + RxConfig ) & Eeprom9356 );
278         if ( ee9356 ) {
279                 DBG ( "EEPROM is an AT93C56\n" );
280                 init_at93c56 ( &rtl->eeprom, 16 );
281         } else {
282                 DBG ( "EEPROM is an AT93C46\n" );
283                 init_at93c46 ( &rtl->eeprom, 16 );
284         }
285         rtl->eeprom.bus = &rtl->spibit.bus;
286
287         /* Initialise space for non-volatile options, if available */
288         vpd = ( inw ( rtl->ioaddr + Config1 ) & VPDEnable );
289         if ( vpd ) {
290                 DBG ( "EEPROM in use for VPD; cannot use for options\n" );
291         } else {
292                 nvo_init ( &rtl->nvo, &rtl->eeprom.nvs, rtl_nvo_fragments,
293                            &netdev->refcnt );
294         }
295 }
296
297 /**
298  * Reset NIC
299  *
300  * @v netdev            Net device
301  *
302  * Issues a hardware reset and waits for the reset to complete.
303  */
304 static void rtl_reset ( struct net_device *netdev ) {
305         struct rtl8139_nic *rtl = netdev->priv;
306
307         /* Reset chip */
308         outb ( CmdReset, rtl->ioaddr + ChipCmd );
309         mdelay ( 10 );
310         memset ( &rtl->tx, 0, sizeof ( rtl->tx ) );
311         rtl->rx.offset = 0;
312 }
313
314 /**
315  * Open NIC
316  *
317  * @v netdev            Net device
318  * @ret rc              Return status code
319  */
320 static int rtl_open ( struct net_device *netdev ) {
321         struct rtl8139_nic *rtl = netdev->priv;
322         int i;
323
324         /* Program the MAC address */
325         for ( i = 0 ; i < ETH_ALEN ; i++ )
326                 outb ( netdev->ll_addr[i], rtl->ioaddr + MAC0 + i );
327
328         /* Set up RX ring */
329         rtl->rx.ring = malloc ( RX_BUF_LEN + RX_BUF_PAD );
330         if ( ! rtl->rx.ring )
331                 return -ENOMEM;
332         outl ( virt_to_bus ( rtl->rx.ring ), rtl->ioaddr + RxBuf );
333         DBG ( "RX ring at %lx\n", virt_to_bus ( rtl->rx.ring ) );
334
335         /* Enable TX and RX */
336         outb ( ( CmdRxEnb | CmdTxEnb ), rtl->ioaddr + ChipCmd );
337         outl ( ( ( RX_FIFO_THRESH << 13 ) | ( RX_BUF_LEN_IDX << 11 ) |
338                  ( RX_DMA_BURST << 8 ) | AcceptBroadcast | AcceptMulticast |
339                  AcceptMyPhys ), rtl->ioaddr + RxConfig );
340         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 0 );
341         outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 4 );
342         outl ( ( ( TX_DMA_BURST << 8 ) | ( TX_IPG << 24 ) ),
343                rtl->ioaddr + TxConfig );
344
345         return 0;
346 }
347
348 /**
349  * Close NIC
350  *
351  * @v netdev            Net device
352  */
353 static void rtl_close ( struct net_device *netdev ) {
354         struct rtl8139_nic *rtl = netdev->priv;
355
356         /* Reset the hardware to disable everything in one go */
357         rtl_reset ( netdev );
358
359         /* Free RX ring */
360         free ( rtl->rx.ring );
361         rtl->rx.ring = NULL;
362 }
363
364 /** 
365  * Transmit packet
366  *
367  * @v netdev    Network device
368  * @v iobuf     I/O buffer
369  * @ret rc      Return status code
370  */
371 static int rtl_transmit ( struct net_device *netdev,
372                           struct io_buffer *iobuf ) {
373         struct rtl8139_nic *rtl = netdev->priv;
374
375         /* Check for space in TX ring */
376         if ( rtl->tx.iobuf[rtl->tx.next] != NULL ) {
377                 DBG ( "TX overflow\n" );
378                 return -ENOBUFS;
379         }
380
381         /* Pad and align packet */
382         iob_pad ( iobuf, ETH_ZLEN );
383
384         /* Add to TX ring */
385         DBG ( "TX id %d at %lx+%zx\n", rtl->tx.next,
386               virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
387         rtl->tx.iobuf[rtl->tx.next] = iobuf;
388         outl ( virt_to_bus ( iobuf->data ),
389                rtl->ioaddr + TxAddr0 + 4 * rtl->tx.next );
390         outl ( ( ( ( TX_FIFO_THRESH & 0x7e0 ) << 11 ) | iob_len ( iobuf ) ),
391                rtl->ioaddr + TxStatus0 + 4 * rtl->tx.next );
392         rtl->tx.next = ( rtl->tx.next + 1 ) % TX_RING_SIZE;
393
394         return 0;
395 }
396
397 /**
398  * Poll for received packets
399  *
400  * @v netdev    Network device
401  */
402 static void rtl_poll ( struct net_device *netdev ) {
403         struct rtl8139_nic *rtl = netdev->priv;
404         unsigned int status;
405         unsigned int tsad;
406         unsigned int rx_status;
407         unsigned int rx_len;
408         struct io_buffer *rx_iob;
409         int wrapped_len;
410         int i;
411
412         /* Acknowledge interrupts */
413         status = inw ( rtl->ioaddr + IntrStatus );
414         if ( ! status )
415                 return;
416         outw ( status, rtl->ioaddr + IntrStatus );
417
418         /* Handle TX completions */
419         tsad = inw ( rtl->ioaddr + TxSummary );
420         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
421                 if ( ( rtl->tx.iobuf[i] != NULL ) && ( tsad & ( 1 << i ) ) ) {
422                         DBG ( "TX id %d complete\n", i );
423                         netdev_tx_complete ( netdev, rtl->tx.iobuf[i] );
424                         rtl->tx.iobuf[i] = NULL;
425                 }
426         }
427
428         /* Handle received packets */
429         while ( ! ( inw ( rtl->ioaddr + ChipCmd ) & RxBufEmpty ) ) {
430                 rx_status = * ( ( uint16_t * )
431                                 ( rtl->rx.ring + rtl->rx.offset ) );
432                 rx_len = * ( ( uint16_t * )
433                              ( rtl->rx.ring + rtl->rx.offset + 2 ) );
434                 if ( rx_status & RxOK ) {
435                         DBG ( "RX packet at offset %x+%x\n", rtl->rx.offset,
436                               rx_len );
437
438                         rx_iob = alloc_iob ( rx_len );
439                         if ( ! rx_iob ) {
440                                 netdev_rx_err ( netdev, NULL, -ENOMEM );
441                                 /* Leave packet for next call to poll() */
442                                 break;
443                         }
444
445                         wrapped_len = ( ( rtl->rx.offset + 4 + rx_len )
446                                         - RX_BUF_LEN );
447                         if ( wrapped_len < 0 )
448                                 wrapped_len = 0;
449
450                         memcpy ( iob_put ( rx_iob, rx_len - wrapped_len ),
451                                  rtl->rx.ring + rtl->rx.offset + 4,
452                                  rx_len - wrapped_len );
453                         memcpy ( iob_put ( rx_iob, wrapped_len ),
454                                  rtl->rx.ring, wrapped_len );
455
456                         netdev_rx ( netdev, rx_iob );
457                 } else {
458                         DBG ( "RX bad packet (status %#04x len %d)\n",
459                               rx_status, rx_len );
460                         netdev_rx_err ( netdev, NULL, -EINVAL );
461                 }
462                 rtl->rx.offset = ( ( ( rtl->rx.offset + 4 + rx_len + 3 ) & ~3 )
463                                    % RX_BUF_LEN );
464                 outw ( rtl->rx.offset - 16, rtl->ioaddr + RxBufPtr );
465         }
466 }
467
468 /**
469  * Enable/disable interrupts
470  *
471  * @v netdev    Network device
472  * @v enable    Interrupts should be enabled
473  */
474 static void rtl_irq ( struct net_device *netdev, int enable ) {
475         struct rtl8139_nic *rtl = netdev->priv;
476         
477         outw ( ( enable ? ( ROK | RER | TOK | TER ) : 0 ),
478                rtl->ioaddr + IntrMask );
479 }
480
481 /** RTL8139 net device operations */
482 static struct net_device_operations rtl_operations = {
483         .open           = rtl_open,
484         .close          = rtl_close,
485         .transmit       = rtl_transmit,
486         .poll           = rtl_poll,
487         .irq            = rtl_irq,
488 };
489
490 /**
491  * Probe PCI device
492  *
493  * @v pci       PCI device
494  * @v id        PCI ID
495  * @ret rc      Return status code
496  */
497 static int rtl_probe ( struct pci_device *pci,
498                        const struct pci_device_id *id __unused ) {
499         struct net_device *netdev;
500         struct rtl8139_nic *rtl;
501         int rc;
502
503         /* Allocate net device */
504         netdev = alloc_etherdev ( sizeof ( *rtl ) );
505         if ( ! netdev )
506                 return -ENOMEM;
507         netdev_init ( netdev, &rtl_operations );
508         rtl = netdev->priv;
509         pci_set_drvdata ( pci, netdev );
510         netdev->dev = &pci->dev;
511         memset ( rtl, 0, sizeof ( *rtl ) );
512         rtl->ioaddr = pci->ioaddr;
513
514         /* Fix up PCI device */
515         adjust_pci_device ( pci );
516
517         /* Reset the NIC, set up EEPROM access and read MAC address */
518         rtl_reset ( netdev );
519         rtl_init_eeprom ( netdev );
520         nvs_read ( &rtl->eeprom.nvs, EE_MAC, netdev->ll_addr, ETH_ALEN );
521         
522         /* Register network device */
523         if ( ( rc = register_netdev ( netdev ) ) != 0 )
524                 goto err_register_netdev;
525
526         /* Register non-volatile storage */
527         if ( rtl->nvo.nvs ) {
528                 if ( ( rc = register_nvo ( &rtl->nvo,
529                                            netdev_settings ( netdev ) ) ) != 0)
530                         goto err_register_nvo;
531         }
532
533         return 0;
534
535  err_register_nvo:
536         unregister_netdev ( netdev );
537  err_register_netdev:
538         rtl_reset ( netdev );
539         netdev_nullify ( netdev );
540         netdev_put ( netdev );
541         return rc;
542 }
543
544 /**
545  * Remove PCI device
546  *
547  * @v pci       PCI device
548  */
549 static void rtl_remove ( struct pci_device *pci ) {
550         struct net_device *netdev = pci_get_drvdata ( pci );
551         struct rtl8139_nic *rtl = netdev->priv;
552
553         if ( rtl->nvo.nvs )
554                 unregister_nvo ( &rtl->nvo );
555         unregister_netdev ( netdev );
556         rtl_reset ( netdev );
557         netdev_nullify ( netdev );
558         netdev_put ( netdev );
559 }
560
561 static struct pci_device_id rtl8139_nics[] = {
562 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
563 PCI_ROM(0x10ec, 0x8139, "rtl8139",       "Realtek 8139"),
564 PCI_ROM(0x10ec, 0x8138, "rtl8139b",      "Realtek 8139B"),
565 PCI_ROM(0x1186, 0x1300, "dfe538",        "DFE530TX+/DFE538TX"),
566 PCI_ROM(0x1113, 0x1211, "smc1211-1",     "SMC EZ10/100"),
567 PCI_ROM(0x1112, 0x1211, "smc1211",       "SMC EZ10/100"),
568 PCI_ROM(0x1500, 0x1360, "delta8139",     "Delta Electronics 8139"),
569 PCI_ROM(0x4033, 0x1360, "addtron8139",   "Addtron Technology 8139"),
570 PCI_ROM(0x1186, 0x1340, "dfe690txd",     "D-Link DFE690TXD"),
571 PCI_ROM(0x13d1, 0xab06, "fe2000vx",      "AboCom FE2000VX"),
572 PCI_ROM(0x1259, 0xa117, "allied8139",    "Allied Telesyn 8139"),
573 PCI_ROM(0x14ea, 0xab06, "fnw3603tx",     "Planex FNW-3603-TX"),
574 PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
575 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
576 };
577
578 struct pci_driver rtl8139_driver __pci_driver = {
579         .ids = rtl8139_nics,
580         .id_count = ( sizeof ( rtl8139_nics ) / sizeof ( rtl8139_nics[0] ) ),
581         .probe = rtl_probe,
582         .remove = rtl_remove,
583 };