14497640431cbf636d097200951c4ef00d03698a
[people/asdlkf/gpxe.git] / src / drivers / net / w89c840.c
1 /*
2  * Etherboot -  BOOTP/TFTP Bootstrap Program
3  *
4  * w89c840.c -- This file implements the winbond-840 driver for etherboot.
5  *
6  */
7
8 /*
9  * Adapted by Igor V. Kovalenko
10  *  -- <garrison@mail.ru>
11  *   OR
12  *  -- <iko@crec.mipt.ru>
13  * Initial adaptaion stage, including testing, completed 23 August 2000.
14  */
15
16 /*
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License as
19  * published by the Free Software Foundation; either version 2, or (at
20  * your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful, but
23  * WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30  */
31
32 /*
33  *              date       version  by   what
34  *  Written:    Aug 20 2000  V0.10  iko  Initial revision.
35  * changes:     Aug 22 2000  V0.90  iko  Works!
36  *              Aug 23 2000  V0.91  iko  Cleanup, posted to etherboot
37  *                                       maintainer.
38  *              Aug 26 2000  V0.92  iko  Fixed Rx ring handling.
39  *                                       First Linux Kernel (TM)
40  *                                       successfully loaded using
41  *                                       this driver.
42  *              Jan 07 2001  V0.93  iko  Transmitter timeouts are handled
43  *                                       using timer2 routines. Proposed
44  *                                       by Ken Yap to eliminate CPU speed
45  *                                       dependency.
46  *             Dec 12 2003  V0.94   timlegge    Fixed issues in 5.2, removed 
47  *                                              interrupt usage, enabled
48  *                                              multicast support
49  *
50  * This is the etherboot driver for cards based on Winbond W89c840F chip.
51  *
52  * It was written from skeleton source, with Donald Becker's winbond-840.c
53  * kernel driver as a guideline. Mostly the w89c840 related definitions
54  * and the lower level routines have been cut-and-pasted into this source.
55  *
56  * Frankly speaking, about 90% of the code was obtained using cut'n'paste
57  * sequence :) while the remainder appeared while brainstorming
58  * Linux Kernel 2.4.0-testX source code. Thanks, Donald and Linus!
59  *
60  * There was a demand for using this card in a rather large
61  * remote boot environment at MSKP OVTI Lab of
62  * Moscow Institute for Physics and Technology (MIPT) -- http://www.mipt.ru/
63  * so you may count that for motivation.
64  *
65  */
66
67 /*
68  * If you want to see debugging output then define W89C840_DEBUG
69  */
70
71 /*
72 #define W89C840_DEBUG
73 */
74
75 /*
76  * Keep using IO_OPS for Etherboot driver!
77  */
78 #define USE_IO_OPS
79
80 #include "etherboot.h"
81 #include "nic.h"
82 #include <gpxe/pci.h>
83 #include <gpxe/ethernet.h>
84
85 static const char *w89c840_version = "driver Version 0.94 - December 12, 2003";
86
87 /* Linux support functions */
88 #define virt_to_le32desc(addr)  virt_to_bus(addr)
89 #define le32desc_to_virt(addr)  bus_to_virt(addr)
90
91 /*
92 #define cpu_to_le32(val) (val)
93 #define le32_to_cpu(val) (val)
94 */
95
96 /* Operational parameters that are set at compile time. */
97
98 /* Keep the ring sizes a power of two for compile efficiency.
99    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
100    Making the Tx ring too large decreases the effectiveness of channel
101    bonding and packet priority.
102    There are no ill effects from too-large receive rings. */
103 #define TX_RING_SIZE    2
104 #define RX_RING_SIZE    2
105
106 /* The presumed FIFO size for working around the Tx-FIFO-overflow bug.
107    To avoid overflowing we don't queue again until we have room for a
108    full-size packet.
109  */
110 #define TX_FIFO_SIZE (2048)
111 #define TX_BUG_FIFO_LIMIT (TX_FIFO_SIZE-1514-16)
112
113 /* Operational parameters that usually are not changed. */
114 /* Time in jiffies before concluding the transmitter is hung. */
115 #define TX_TIMEOUT  (10*USECS_IN_MSEC)
116
117 #define PKT_BUF_SZ  1536  /* Size of each temporary Rx buffer.*/
118
119 /*
120  * Used to be this much CPU loops on Celeron@400 (?),
121  * now using real timer and TX_TIMEOUT!
122  * #define TX_LOOP_COUNT 10000000
123  */
124
125 #if !defined(__OPTIMIZE__)
126 #warning  You must compile this file with the correct options!
127 #warning  See the last lines of the source file.
128 #error You must compile this driver with "-O".
129 #endif
130
131 enum chip_capability_flags {CanHaveMII=1, HasBrokenTx=2};
132
133 #ifdef USE_IO_OPS
134 #define W840_FLAGS (PCI_USES_IO | PCI_ADDR0 | PCI_USES_MASTER)
135 #else
136 #define W840_FLAGS (PCI_USES_MEM | PCI_ADDR1 | PCI_USES_MASTER)
137 #endif
138
139 static u32 driver_flags = CanHaveMII | HasBrokenTx;
140
141 /* This driver was written to use PCI memory space, however some x86 systems
142    work only with I/O space accesses.  Pass -DUSE_IO_OPS to use PCI I/O space
143    accesses instead of memory space. */
144
145 #ifdef USE_IO_OPS
146 #undef readb
147 #undef readw
148 #undef readl
149 #undef writeb
150 #undef writew
151 #undef writel
152 #define readb inb
153 #define readw inw
154 #define readl inl
155 #define writeb outb
156 #define writew outw
157 #define writel outl
158 #endif
159
160 /* Offsets to the Command and Status Registers, "CSRs".
161    While similar to the Tulip, these registers are longword aligned.
162    Note: It's not useful to define symbolic names for every register bit in
163    the device.  The name can only partially document the semantics and make
164    the driver longer and more difficult to read.
165 */
166 enum w840_offsets {
167     PCIBusCfg=0x00, TxStartDemand=0x04, RxStartDemand=0x08,
168     RxRingPtr=0x0C, TxRingPtr=0x10,
169     IntrStatus=0x14, NetworkConfig=0x18, IntrEnable=0x1C,
170     RxMissed=0x20, EECtrl=0x24, MIICtrl=0x24, BootRom=0x28, GPTimer=0x2C,
171     CurRxDescAddr=0x30, CurRxBufAddr=0x34,            /* Debug use */
172     MulticastFilter0=0x38, MulticastFilter1=0x3C, StationAddr=0x40,
173     CurTxDescAddr=0x4C, CurTxBufAddr=0x50,
174 };
175
176 /* Bits in the interrupt status/enable registers. */
177 /* The bits in the Intr Status/Enable registers, mostly interrupt sources. */
178 enum intr_status_bits {
179     NormalIntr=0x10000, AbnormalIntr=0x8000,
180     IntrPCIErr=0x2000, TimerInt=0x800,
181     IntrRxDied=0x100, RxNoBuf=0x80, IntrRxDone=0x40,
182     TxFIFOUnderflow=0x20, RxErrIntr=0x10,
183     TxIdle=0x04, IntrTxStopped=0x02, IntrTxDone=0x01,
184 };
185
186 /* Bits in the NetworkConfig register. */
187 enum rx_mode_bits {
188     AcceptErr=0x80, AcceptRunt=0x40,
189     AcceptBroadcast=0x20, AcceptMulticast=0x10,
190     AcceptAllPhys=0x08, AcceptMyPhys=0x02,
191 };
192
193 enum mii_reg_bits {
194     MDIO_ShiftClk=0x10000, MDIO_DataIn=0x80000, MDIO_DataOut=0x20000,
195     MDIO_EnbOutput=0x40000, MDIO_EnbIn = 0x00000,
196 };
197
198 /* The Tulip Rx and Tx buffer descriptors. */
199 struct w840_rx_desc {
200     s32 status;
201     s32 length;
202     u32 buffer1;
203     u32 next_desc;
204 };
205
206 struct w840_tx_desc {
207     s32 status;
208     s32 length;
209     u32 buffer1, buffer2;                /* We use only buffer 1.  */
210 };
211
212 /* Bits in network_desc.status */
213 enum desc_status_bits {
214     DescOwn=0x80000000, DescEndRing=0x02000000, DescUseLink=0x01000000,
215     DescWholePkt=0x60000000, DescStartPkt=0x20000000, DescEndPkt=0x40000000,
216     DescIntr=0x80000000,
217 };
218 #define PRIV_ALIGN    15     /* Required alignment mask */
219 #define PRIV_ALIGN_BYTES 32
220
221 static struct winbond_private
222 {
223     /* Descriptor rings first for alignment. */
224     struct w840_rx_desc rx_ring[RX_RING_SIZE];
225     struct w840_tx_desc tx_ring[TX_RING_SIZE];
226     struct net_device *next_module;        /* Link for devices of this type. */
227     void *priv_addr;                    /* Unaligned address for kfree */
228     const char *product_name;
229     /* Frequently used values: keep some adjacent for cache effect. */
230     int chip_id, drv_flags;
231     struct pci_dev *pci_dev;
232     int csr6;
233     struct w840_rx_desc *rx_head_desc;
234     unsigned int cur_rx, dirty_rx;        /* Producer/consumer ring indices */
235     unsigned int rx_buf_sz;                /* Based on MTU+slack. */
236     unsigned int cur_tx, dirty_tx;
237     int tx_q_bytes;
238     unsigned int tx_full:1;                /* The Tx queue is full. */
239     /* These values are keep track of the transceiver/media in use. */
240     unsigned int full_duplex:1;            /* Full-duplex operation requested. */
241     unsigned int duplex_lock:1;
242     unsigned int medialock:1;            /* Do not sense media. */
243     unsigned int default_port:4;        /* Last dev->if_port value. */
244     /* MII transceiver section. */
245     int mii_cnt;                        /* MII device addresses. */
246     u16 advertising;                    /* NWay media advertisement */
247     unsigned char phys[2];                /* MII device addresses. */
248 } w840private __attribute__ ((aligned (PRIV_ALIGN_BYTES)));
249
250 /* NIC specific static variables go here */
251
252 static int ioaddr;
253 static unsigned short eeprom [0x40];
254 struct {
255         char        rx_packet[PKT_BUF_SZ * RX_RING_SIZE];
256         char        tx_packet[PKT_BUF_SZ * TX_RING_SIZE];
257 } w89c840_buf __shared;
258
259 static int  eeprom_read(long ioaddr, int location);
260 static int  mdio_read(int base_address, int phy_id, int location);
261 #if 0
262 static void mdio_write(int base_address, int phy_id, int location, int value);
263 #endif
264
265 static void check_duplex(void);
266 static void set_rx_mode(void);
267 static void init_ring(void);
268
269 #if defined(W89C840_DEBUG)
270 static void decode_interrupt(u32 intr_status)
271 {
272     printf("Interrupt status: ");
273
274 #define TRACE_INTR(_intr_) \
275     if (intr_status & (_intr_)) { printf (" " #_intr_); }
276
277     TRACE_INTR(NormalIntr);
278     TRACE_INTR(AbnormalIntr);
279     TRACE_INTR(IntrPCIErr);
280     TRACE_INTR(TimerInt);
281     TRACE_INTR(IntrRxDied);
282     TRACE_INTR(RxNoBuf);
283     TRACE_INTR(IntrRxDone);
284     TRACE_INTR(TxFIFOUnderflow);
285     TRACE_INTR(RxErrIntr);
286     TRACE_INTR(TxIdle);
287     TRACE_INTR(IntrTxStopped);
288     TRACE_INTR(IntrTxDone);
289
290     printf("\n");
291     /*sleep(1);*/
292 }
293 #endif
294
295 /**************************************************************************
296 w89c840_reset - Reset adapter
297 ***************************************************************************/
298 static void w89c840_reset(struct nic *nic)
299 {
300     int i;
301
302     /* Reset the chip to erase previous misconfiguration.
303        No hold time required! */
304     writel(0x00000001, ioaddr + PCIBusCfg);
305
306     init_ring();
307
308     writel(virt_to_bus(w840private.rx_ring), ioaddr + RxRingPtr);
309     writel(virt_to_bus(w840private.tx_ring), ioaddr + TxRingPtr);
310
311     for (i = 0; i < ETH_ALEN; i++)
312         writeb(nic->node_addr[i], ioaddr + StationAddr + i);
313
314     /* Initialize other registers. */
315     /* Configure the PCI bus bursts and FIFO thresholds.
316        486: Set 8 longword cache alignment, 8 longword burst.
317        586: Set 16 longword cache alignment, no burst limit.
318        Cache alignment bits 15:14         Burst length 13:8
319         0000    <not allowed>         0000 align to cache    0800 8 longwords
320         4000    8  longwords        0100 1 longword        1000 16 longwords
321         8000    16 longwords        0200 2 longwords    2000 32 longwords
322         C000    32  longwords        0400 4 longwords
323        Wait the specified 50 PCI cycles after a reset by initializing
324        Tx and Rx queues and the address filter list. */
325
326     writel(0xE010, ioaddr + PCIBusCfg);
327
328     writel(0, ioaddr + RxStartDemand);
329     w840private.csr6 = 0x20022002;
330     check_duplex();
331     set_rx_mode();
332
333     /* Do not enable the interrupts Etherboot doesn't need them */
334 /*
335     writel(0x1A0F5, ioaddr + IntrStatus);
336     writel(0x1A0F5, ioaddr + IntrEnable);
337 */
338 #if defined(W89C840_DEBUG)
339     printf("winbond-840 : Done reset.\n");
340 #endif
341 }
342
343 #if 0
344 static void handle_intr(u32 intr_stat)
345 {
346     if ((intr_stat & (NormalIntr|AbnormalIntr)) == 0) {
347         /* we are polling, do not return now */
348         /*return 0;*/
349     } else {
350         /* Acknowledge all of the current interrupt sources ASAP. */
351         writel(intr_stat & 0x001ffff, ioaddr + IntrStatus);
352     }
353
354     if (intr_stat & AbnormalIntr) {
355         /* There was an abnormal interrupt */
356         printf("\n-=- Abnormal interrupt.\n");
357
358 #if defined(W89C840_DEBUG)
359         decode_interrupt(intr_stat);
360 #endif
361
362         if (intr_stat & RxNoBuf) {
363             /* There was an interrupt */
364             printf("-=- <=> No receive buffers available.\n");
365             writel(0, ioaddr + RxStartDemand);
366         }
367     }
368 }
369 #endif
370
371 /**************************************************************************
372 w89c840_poll - Wait for a frame
373 ***************************************************************************/
374 static int w89c840_poll(struct nic *nic, int retrieve)
375 {
376     /* return true if there's an ethernet packet ready to read */
377     /* nic->packet should contain data on return */
378     /* nic->packetlen should contain length of data */
379     int packet_received = 0;
380
381 #if defined(W89C840_DEBUG)
382     u32 intr_status = readl(ioaddr + IntrStatus);
383 #endif
384
385     do {
386         /* Code from netdev_rx(dev) */
387
388         int entry = w840private.cur_rx % RX_RING_SIZE;
389
390         struct w840_rx_desc *desc = w840private.rx_head_desc;
391         s32 status = desc->status;
392
393         if (status & DescOwn) {
394             /* DescOwn bit is still set, we should wait for RX to complete */
395             packet_received = 0;
396             break;
397         }
398
399         if ( !retrieve ) {
400             packet_received = 1;
401             break;
402         }
403
404         if ((status & 0x38008300) != 0x0300) {
405             if ((status & 0x38000300) != 0x0300) {
406                 /* Ingore earlier buffers. */
407                 if ((status & 0xffff) != 0x7fff) {
408                     printf("winbond-840 : Oversized Ethernet frame spanned "
409                            "multiple buffers, entry %d status %X !\n",
410                            w840private.cur_rx, (unsigned int) status);
411                 }
412             } else if (status & 0x8000) {
413                 /* There was a fatal error. */
414 #if defined(W89C840_DEBUG)
415                 printf("winbond-840 : Receive error, Rx status %X :", status);
416                 if (status & 0x0890) {
417                     printf(" RXLEN_ERROR");
418                 }
419                 if (status & 0x004C) {
420                     printf(", FRAME_ERROR");
421                 }
422                 if (status & 0x0002) {
423                     printf(", CRC_ERROR");
424                 }
425                 printf("\n");
426 #endif
427
428                 /* Simpy do a reset now... */
429                 w89c840_reset(nic);
430
431                 packet_received = 0;
432                 break;
433             }
434         } else {
435             /* Omit the four octet CRC from the length. */
436             int pkt_len = ((status >> 16) & 0x7ff) - 4;
437
438 #if defined(W89C840_DEBUG)
439             printf(" netdev_rx() normal Rx pkt ring %d length %d status %X\n", entry, pkt_len, status);
440 #endif
441
442             nic->packetlen = pkt_len;
443
444             /* Check if the packet is long enough to accept without copying
445                to a minimally-sized skbuff. */
446
447             memcpy(nic->packet, le32desc_to_virt(w840private.rx_ring[entry].buffer1), pkt_len);
448             packet_received = 1;
449
450             /* Release buffer to NIC */
451             w840private.rx_ring[entry].status = DescOwn;
452
453 #if defined(W89C840_DEBUG)
454             /* You will want this info for the initial debug. */
455             printf("  Rx data %hhX:%hhX:%hhX:%hhX:%hhX:"
456                    "%hhX %hhX:%hhX:%hhX:%hhX:%hhX:%hhX %hhX%hhX "
457                    "%hhX.%hhX.%hhX.%hhX.\n",
458                    nic->packet[0],  nic->packet[1],  nic->packet[2], nic->packet[3],
459                    nic->packet[4],  nic->packet[5],  nic->packet[6], nic->packet[7],
460                    nic->packet[8],  nic->packet[9],  nic->packet[10],
461                    nic->packet[11], nic->packet[12], nic->packet[13],
462                    nic->packet[14], nic->packet[15], nic->packet[16],
463                    nic->packet[17]);
464 #endif
465
466         }
467
468         entry = (++w840private.cur_rx) % RX_RING_SIZE;
469         w840private.rx_head_desc = &w840private.rx_ring[entry];
470     } while (0);
471     
472     return packet_received;
473 }
474
475 /**************************************************************************
476 w89c840_transmit - Transmit a frame
477 ***************************************************************************/
478
479 static void w89c840_transmit(
480     struct nic *nic,
481     const char *d,            /* Destination */
482     unsigned int t,            /* Type */
483     unsigned int s,            /* size */
484     const char *p)            /* Packet */
485 {
486     /* send the packet to destination */
487     unsigned entry;
488     int transmit_status;
489     tick_t ct;
490
491     /* Caution: the write order is important here, set the field
492        with the "ownership" bits last. */
493
494     /* Fill in our transmit buffer */
495     entry = w840private.cur_tx % TX_RING_SIZE;
496
497     memcpy (w89c840_buf.tx_packet, d, ETH_ALEN);    /* dst */
498     memcpy (w89c840_buf.tx_packet + ETH_ALEN, nic->node_addr, ETH_ALEN);/*src*/
499
500     *((char *) w89c840_buf.tx_packet + 12) = t >> 8;    /* type */
501     *((char *) w89c840_buf.tx_packet + 13) = t;
502
503     memcpy (w89c840_buf.tx_packet + ETH_HLEN, p, s);
504     s += ETH_HLEN;
505
506     while (s < ETH_ZLEN)
507     *((char *) w89c840_buf.tx_packet + ETH_HLEN + (s++)) = 0;
508
509     w840private.tx_ring[entry].buffer1
510             = virt_to_le32desc(w89c840_buf.tx_packet);
511
512     w840private.tx_ring[entry].length = (DescWholePkt | (u32) s);
513     if (entry >= TX_RING_SIZE-1)         /* Wrap ring */
514         w840private.tx_ring[entry].length |= (DescIntr | DescEndRing);
515     w840private.tx_ring[entry].status = (DescOwn);
516     w840private.cur_tx++;
517
518     w840private.tx_q_bytes = (u16) s;
519     writel(0, ioaddr + TxStartDemand);
520
521     /* Work around horrible bug in the chip by marking the queue as full
522        when we do not have FIFO room for a maximum sized packet. */
523
524     if ((w840private.drv_flags & HasBrokenTx) && w840private.tx_q_bytes > TX_BUG_FIFO_LIMIT) {
525         /* Actually this is left to help finding error tails later in debugging...
526          * See Linux kernel driver in winbond-840.c for details.
527          */
528         w840private.tx_full = 1;
529     }
530
531 #if defined(W89C840_DEBUG)
532     printf("winbond-840 : Transmit frame # %d size %d queued in slot %d.\n", w840private.cur_tx, s, entry);
533 #endif
534
535     /* Now wait for TX to complete. */
536     transmit_status = w840private.tx_ring[entry].status;
537
538     ct = currticks();
539     {
540 #if defined W89C840_DEBUG
541         u32 intr_stat = 0;
542 #endif
543         while (1) {
544
545 #if defined(W89C840_DEBUG)
546               decode_interrupt(intr_stat);
547 #endif
548
549                 while ( (transmit_status & DescOwn) && ct + TX_TIMEOUT < currticks()) {
550
551                     transmit_status = w840private.tx_ring[entry].status;
552                 }
553
554                 break;
555         }
556     }
557
558     if ((transmit_status & DescOwn) == 0) {
559
560 #if defined(W89C840_DEBUG)
561         printf("winbond-840 : transmission complete after wait loop iterations, status %X\n",
562                 w840private.tx_ring[entry].status);
563 #endif
564
565         return;
566     }
567
568     /* Transmit timed out... */
569
570     printf("winbond-840 : transmission TIMEOUT : status %X\n", 
571            (unsigned int) w840private.tx_ring[entry].status);
572
573     return;
574 }
575
576 /**************************************************************************
577 w89c840_disable - Turn off ethernet interface
578 ***************************************************************************/
579 static void w89c840_disable ( struct nic *nic ) {
580
581     w89c840_reset(nic);
582
583     /* Don't know what to do to disable the board. Is this needed at all? */
584     /* Yes, a live NIC can corrupt the loaded memory later [Ken] */
585     /* Stop the chip's Tx and Rx processes. */
586     writel(w840private.csr6 &= ~0x20FA, ioaddr + NetworkConfig);
587 }
588
589 /**************************************************************************
590 w89c840_irq - Enable, Disable, or Force interrupts
591 ***************************************************************************/
592 static void w89c840_irq(struct nic *nic __unused, irq_action_t action __unused)
593 {
594   switch ( action ) {
595   case DISABLE :
596     break;
597   case ENABLE :
598     break;
599   case FORCE :
600     break;
601   }
602 }
603
604 static struct nic_operations w89c840_operations = {
605         .connect        = dummy_connect,
606         .poll           = w89c840_poll,
607         .transmit       = w89c840_transmit,
608         .irq            = w89c840_irq,
609
610 };
611
612 static struct pci_device_id w89c840_nics[] = {
613 PCI_ROM(0x1050, 0x0840, "winbond840",     "Winbond W89C840F"),
614 PCI_ROM(0x11f6, 0x2011, "compexrl100atx", "Compex RL100ATX"),
615 };
616
617 PCI_DRIVER ( w89c840_driver, w89c840_nics, PCI_NO_CLASS );
618
619 /**************************************************************************
620 w89c840_probe - Look for an adapter, this routine's visible to the outside
621 ***************************************************************************/
622 static int w89c840_probe ( struct nic *nic, struct pci_device *p ) {
623
624
625     u16 sum = 0;
626     int i, j;
627     unsigned short value;
628
629     if (p->ioaddr == 0)
630         return 0;
631
632     nic->ioaddr = p->ioaddr;
633     nic->irqno  = 0;
634
635 #if defined(W89C840_DEBUG)
636     printf("winbond-840: PCI bus %hhX device function %hhX: I/O address: %hX\n", p->bus, p->devfn, ioaddr);
637 #endif
638
639     ioaddr = ioaddr & ~3; /* Mask the bit that says "this is an io addr" */
640
641 #define PCI_DEVICE_ID_WINBOND2_89C840   0x0840
642 #define PCI_DEVICE_ID_COMPEX_RL100ATX   0x2011
643
644     /* From Matt Hortman <mbhortman@acpthinclient.com> */
645     if (p->vendor == PCI_VENDOR_ID_WINBOND2
646         && p->device == PCI_DEVICE_ID_WINBOND2_89C840) {
647
648         /* detected "Winbond W89c840 Fast Ethernet PCI NIC" */
649
650     } else if ( p->vendor == PCI_VENDOR_ID_COMPEX
651                 && p->device == PCI_DEVICE_ID_COMPEX_RL100ATX) {
652
653         /* detected "Compex RL100ATX Fast Ethernet PCI NIC" */
654
655     } else {
656         /* Gee, guess what? They missed again. */
657         printf("device ID : %X - is not a Compex RL100ATX NIC.\n",
658                p->device);
659         return 0;
660     }
661
662     printf(" %s\n", w89c840_version);
663
664     adjust_pci_device(p);
665
666     /* Ok. Got one. Read the eeprom. */
667     for (j = 0, i = 0; i < 0x40; i++) {
668         value = eeprom_read(ioaddr, i);
669         eeprom[i] = value;
670         sum += value;
671     }
672
673     for (i=0;i<ETH_ALEN;i++) {
674         nic->node_addr[i] =  (eeprom[i/2] >> (8*(i&1))) & 0xff;
675     }
676
677     DBG ( "Ethernet addr: %s\n", eth_ntoa ( nic->node_addr ) );
678
679 #if defined(W89C840_DEBUG)
680     printf("winbond-840: EEPROM checksum %hX, got eeprom", sum);
681 #endif
682
683     /* Reset the chip to erase previous misconfiguration.
684        No hold time required! */
685     writel(0x00000001, ioaddr + PCIBusCfg);
686
687     if (driver_flags & CanHaveMII) {
688         int phy, phy_idx = 0;
689         for (phy = 1; phy < 32 && phy_idx < 4; phy++) {
690             int mii_status = mdio_read(ioaddr, phy, 1);
691             if (mii_status != 0xffff  &&  mii_status != 0x0000) {
692                 w840private.phys[phy_idx++] = phy;
693                 w840private.advertising = mdio_read(ioaddr, phy, 4);
694
695 #if defined(W89C840_DEBUG)
696                 printf("winbond-840 : MII PHY found at address %d, status "
697                        "%X advertising %hX.\n", phy, mii_status, w840private.advertising);
698 #endif
699
700             }
701         }
702
703         w840private.mii_cnt = phy_idx;
704
705         if (phy_idx == 0) {
706                 printf("winbond-840 : MII PHY not found -- this device may not operate correctly.\n");
707         }
708     }
709
710     /* point to NIC specific routines */
711     nic->nic_op = &w89c840_operations;
712
713     w89c840_reset(nic);
714
715     return 1;
716 }
717
718 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces.  These are
719    often serial bit streams generated by the host processor.
720    The example below is for the common 93c46 EEPROM, 64 16 bit words. */
721
722 /* Delay between EEPROM clock transitions.
723    No extra delay is needed with 33Mhz PCI, but future 66Mhz access may need
724    a delay.  Note that pre-2.0.34 kernels had a cache-alignment bug that
725    made udelay() unreliable.
726    The old method of using an ISA access as a delay, __SLOW_DOWN_IO__, is
727    depricated.
728 */
729 #define eeprom_delay(ee_addr)    readl(ee_addr)
730
731 enum EEPROM_Ctrl_Bits {
732     EE_ShiftClk=0x02, EE_Write0=0x801, EE_Write1=0x805,
733     EE_ChipSelect=0x801, EE_DataIn=0x08,
734 };
735
736 /* The EEPROM commands include the alway-set leading bit. */
737 enum EEPROM_Cmds {
738     EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
739 };
740
741 static int eeprom_read(long addr, int location)
742 {
743     int i;
744     int retval = 0;
745     int ee_addr = addr + EECtrl;
746     int read_cmd = location | EE_ReadCmd;
747     writel(EE_ChipSelect, ee_addr);
748
749     /* Shift the read command bits out. */
750     for (i = 10; i >= 0; i--) {
751         short dataval = (read_cmd & (1 << i)) ? EE_Write1 : EE_Write0;
752         writel(dataval, ee_addr);
753         eeprom_delay(ee_addr);
754         writel(dataval | EE_ShiftClk, ee_addr);
755         eeprom_delay(ee_addr);
756     }
757     writel(EE_ChipSelect, ee_addr);
758
759     for (i = 16; i > 0; i--) {
760         writel(EE_ChipSelect | EE_ShiftClk, ee_addr);
761         eeprom_delay(ee_addr);
762         retval = (retval << 1) | ((readl(ee_addr) & EE_DataIn) ? 1 : 0);
763         writel(EE_ChipSelect, ee_addr);
764         eeprom_delay(ee_addr);
765     }
766
767     /* Terminate the EEPROM access. */
768     writel(0, ee_addr);
769     return retval;
770 }
771
772 /*  MII transceiver control section.
773     Read and write the MII registers using software-generated serial
774     MDIO protocol.  See the MII specifications or DP83840A data sheet
775     for details.
776
777     The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
778     met by back-to-back 33Mhz PCI cycles. */
779 #define mdio_delay(mdio_addr) readl(mdio_addr)
780
781 /* Set iff a MII transceiver on any interface requires mdio preamble.
782    This only set with older tranceivers, so the extra
783    code size of a per-interface flag is not worthwhile. */
784 static char mii_preamble_required = 1;
785
786 #define MDIO_WRITE0 (MDIO_EnbOutput)
787 #define MDIO_WRITE1 (MDIO_DataOut | MDIO_EnbOutput)
788
789 /* Generate the preamble required for initial synchronization and
790    a few older transceivers. */
791 static void mdio_sync(long mdio_addr)
792 {
793     int bits = 32;
794
795     /* Establish sync by sending at least 32 logic ones. */
796     while (--bits >= 0) {
797         writel(MDIO_WRITE1, mdio_addr);
798         mdio_delay(mdio_addr);
799         writel(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
800         mdio_delay(mdio_addr);
801     }
802 }
803
804 static int mdio_read(int base_address, int phy_id, int location)
805 {
806     long mdio_addr = base_address + MIICtrl;
807     int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
808     int i, retval = 0;
809
810     if (mii_preamble_required)
811         mdio_sync(mdio_addr);
812
813     /* Shift the read command bits out. */
814     for (i = 15; i >= 0; i--) {
815         int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
816
817         writel(dataval, mdio_addr);
818         mdio_delay(mdio_addr);
819         writel(dataval | MDIO_ShiftClk, mdio_addr);
820         mdio_delay(mdio_addr);
821     }
822     /* Read the two transition, 16 data, and wire-idle bits. */
823     for (i = 20; i > 0; i--) {
824         writel(MDIO_EnbIn, mdio_addr);
825         mdio_delay(mdio_addr);
826         retval = (retval << 1) | ((readl(mdio_addr) & MDIO_DataIn) ? 1 : 0);
827         writel(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
828         mdio_delay(mdio_addr);
829     }
830     return (retval>>1) & 0xffff;
831 }
832
833 #if 0
834 static void mdio_write(int base_address, int phy_id, int location, int value)
835 {
836     long mdio_addr = base_address + MIICtrl;
837     int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
838     int i;
839
840     if (location == 4  &&  phy_id == w840private.phys[0])
841         w840private.advertising = value;
842
843     if (mii_preamble_required)
844         mdio_sync(mdio_addr);
845
846     /* Shift the command bits out. */
847     for (i = 31; i >= 0; i--) {
848         int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
849
850         writel(dataval, mdio_addr);
851         mdio_delay(mdio_addr);
852         writel(dataval | MDIO_ShiftClk, mdio_addr);
853         mdio_delay(mdio_addr);
854     }
855     /* Clear out extra bits. */
856     for (i = 2; i > 0; i--) {
857         writel(MDIO_EnbIn, mdio_addr);
858         mdio_delay(mdio_addr);
859         writel(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
860         mdio_delay(mdio_addr);
861     }
862     return;
863 }
864 #endif
865
866 static void check_duplex(void)
867 {
868     int mii_reg5 = mdio_read(ioaddr, w840private.phys[0], 5);
869     int negotiated =  mii_reg5 & w840private.advertising;
870     int duplex;
871
872     if (w840private.duplex_lock  ||  mii_reg5 == 0xffff)
873         return;
874
875     duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
876     if (w840private.full_duplex != duplex) {
877         w840private.full_duplex = duplex;       
878
879 #if defined(W89C840_DEBUG)
880         printf("winbond-840 : Setting %s-duplex based on MII # %d negotiated capability %X\n",
881                duplex ? "full" : "half", w840private.phys[0], negotiated);
882 #endif
883
884         w840private.csr6 &= ~0x200;
885         w840private.csr6 |= duplex ? 0x200 : 0;
886     }
887 }
888
889 static void set_rx_mode(void)
890 {
891     u32 mc_filter[2];            /* Multicast hash filter */
892     u32 rx_mode;
893
894     /* Accept all multicasts from now on. */
895     memset(mc_filter, 0xff, sizeof(mc_filter));
896
897 /*
898  * works OK with multicast enabled. 
899  */
900
901     rx_mode = AcceptBroadcast | AcceptMyPhys | AcceptMulticast;
902
903     writel(mc_filter[0], ioaddr + MulticastFilter0);
904     writel(mc_filter[1], ioaddr + MulticastFilter1);
905     w840private.csr6 &= ~0x00F8;
906     w840private.csr6 |= rx_mode;
907     writel(w840private.csr6, ioaddr + NetworkConfig);
908
909 #if defined(W89C840_DEBUG)
910     printf("winbond-840 : Done setting RX mode.\n");
911 #endif
912 }
913
914 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
915 static void init_ring(void)
916 {
917     int i;
918     char * p;
919
920     w840private.tx_full = 0;
921     w840private.tx_q_bytes = w840private.cur_rx = w840private.cur_tx = 0;
922     w840private.dirty_rx = w840private.dirty_tx = 0;
923
924     w840private.rx_buf_sz = PKT_BUF_SZ;
925     w840private.rx_head_desc = &w840private.rx_ring[0];
926
927     /* Initial all Rx descriptors. Fill in the Rx buffers. */
928
929     p = &w89c840_buf.rx_packet[0];
930
931     for (i = 0; i < RX_RING_SIZE; i++) {
932         w840private.rx_ring[i].length = w840private.rx_buf_sz;
933         w840private.rx_ring[i].status = 0;
934         w840private.rx_ring[i].next_desc = virt_to_le32desc(&w840private.rx_ring[i+1]);
935
936         w840private.rx_ring[i].buffer1 = virt_to_le32desc(p + (PKT_BUF_SZ * i));
937         w840private.rx_ring[i].status = DescOwn | DescIntr;
938     }
939
940     /* Mark the last entry as wrapping the ring. */
941     w840private.rx_ring[i-1].length |= DescEndRing;
942     w840private.rx_ring[i-1].next_desc = virt_to_le32desc(&w840private.rx_ring[0]);
943
944     w840private.dirty_rx = (unsigned int)(i - RX_RING_SIZE);
945
946     for (i = 0; i < TX_RING_SIZE; i++) {
947         w840private.tx_ring[i].status = 0;
948     }
949     return;
950 }
951
952
953 DRIVER ( "W89C840F", nic_driver, pci_driver, w89c840_driver,
954          w89c840_probe, w89c840_disable );
955
956 /*
957  * Local variables:
958  *  c-basic-offset: 8
959  *  c-indent-level: 8
960  *  tab-width: 8
961  * End:
962  */