85d7571c61610bb50a211defd1b478d22de4c731
[people/cooldavid/gpxe.git] / src / drivers / net / eepro100.c
1 /*
2  * eepro100.c -- This file implements the eepro100 driver for etherboot.
3  *
4  *
5  * Copyright (C) AW Computer Systems.
6  * written by R.E.Wolff -- R.E.Wolff@BitWizard.nl
7  *
8  *
9  * AW Computer Systems is contributing to the free software community
10  * by paying for this driver and then putting the result under GPL.
11  *
12  * If you need a Linux device driver, please contact BitWizard for a
13  * quote.
14  *
15  *
16  * This program is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU General Public License as
18  * published by the Free Software Foundation; either version 2, or (at
19  * your option) any later version.
20  *
21  * This program is distributed in the hope that it will be useful, but
22  * WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29  *
30  *
31  *              date       version  by   what
32  *  Written:    May 29 1997  V0.10  REW  Initial revision.
33  * changes:     May 31 1997  V0.90  REW  Works!
34  *              Jun 1  1997  V0.91  REW  Cleanup
35  *              Jun 2  1997  V0.92  REW  Add some code documentation
36  *              Jul 25 1997  V1.00  REW  Tested by AW to work in a PROM
37  *                                       Cleanup for publication
38  *              Dez 11 2004  V1.10  Kiszka  Add RX ring buffer support
39  *
40  * This is the etherboot intel etherexpress Pro/100B driver.
41  *
42  * It was written from scratch, with Donald Beckers eepro100.c kernel
43  * driver as a guideline. Mostly the 82557 related definitions and the
44  * lower level routines have been cut-and-pasted into this source.
45  *
46  * The driver was finished before Intel got the NDA out of the closet.
47  * I still don't have the docs.
48  *
49  *
50  * Datasheet is now published and available from 
51  * ftp://download.intel.com/design/network/manuals/8255X_OpenSDM.pdf
52  *    - Michael Brown
53  * */
54
55 FILE_LICENCE ( GPL2_OR_LATER );
56
57 /* Philosophy of this driver.
58  *
59  * Probing:
60  *
61  * Using the pci.c functions of the Etherboot code, the 82557 chip is detected.
62  * It is verified that the BIOS initialized everything properly and if
63  * something is missing it is done now.
64  *
65  *
66  * Initialization:
67  *
68  *
69  * The chip is then initialized to "know" its ethernet address, and to
70  * start recieving packets. The Linux driver has a whole transmit and
71  * recieve ring of buffers. This is neat if you need high performance:
72  * you can write the buffers asynchronously to the chip reading the
73  * buffers and transmitting them over the network.  Performance is NOT
74  * an issue here. We can boot a 400k kernel in about two
75  * seconds. (Theory: 0.4 seconds). Booting a system is going to take
76  * about half a minute anyway, so getting 10 times closer to the
77  * theoretical limit is going to make a difference of a few percent. */
78 /* Not totally true: busy networks can cause packet drops due to RX
79  * buffer overflows. Fixed in V1.10 of this driver. [Kiszka] */
80 /*
81  *
82  * Transmitting and recieving.
83  *
84  * We have only one transmit descriptor. It has two buffer descriptors:
85  * one for the header, and the other for the data.
86  * We have multiple receive buffers (currently: 4). The chip is told to
87  * receive packets and suspend itself once it ran on the last free buffer.
88  * The recieve (poll) routine simply looks at the current recieve buffer,
89  * picks the packet if any, and releases this buffer again (classic ring
90  * buffer concept). This helps to avoid packet drops on busy networks.
91  *
92  * Caveats:
93  *
94  * The Etherboot framework moves the code to the 48k segment from
95  * 0x94000 to 0xa0000. There is just a little room between the end of
96  * this driver and the 0xa0000 address. If you compile in too many
97  * features, this will overflow.
98  * The number under "hex" in the output of size that scrolls by while
99  * compiling should be less than 8000. Maybe even the stack is up there,
100  * so that you need even more headroom.
101  */
102
103 /* The etherboot authors seem to dislike the argument ordering in
104  * outb macros that Linux uses. I disklike the confusion that this
105  * has caused even more.... This file uses the Linux argument ordering.  */
106 /* Sorry not us. It's inherited code from FreeBSD. [The authors] */
107
108 #include "etherboot.h"
109 #include "nic.h"
110 #include <gpxe/ethernet.h>
111 #include <gpxe/pci.h>
112
113 static int ioaddr;
114
115 enum speedo_offsets {
116   SCBStatus = 0, SCBCmd = 2,      /* Rx/Command Unit command and status. */
117   SCBPointer = 4,                 /* General purpose pointer. */
118   SCBPort = 8,                    /* Misc. commands and operands.  */
119   SCBflash = 12, SCBeeprom = 14,  /* EEPROM and flash memory control. */
120   SCBCtrlMDI = 16,                /* MDI interface control. */
121   SCBEarlyRx = 20,                /* Early receive byte count. */
122 };
123
124 enum SCBCmdBits {
125         SCBMaskCmdDone=0x8000, SCBMaskRxDone=0x4000, SCBMaskCmdIdle=0x2000,
126         SCBMaskRxSuspend=0x1000, SCBMaskEarlyRx=0x0800, SCBMaskFlowCtl=0x0400,
127         SCBTriggerIntr=0x0200, SCBMaskAll=0x0100,
128         /* The rest are Rx and Tx commands. */
129         CUStart=0x0010, CUResume=0x0020, CUStatsAddr=0x0040, CUShowStats=0x0050,
130         CUCmdBase=0x0060,       /* CU Base address (set to zero) . */
131         CUDumpStats=0x0070, /* Dump then reset stats counters. */
132         RxStart=0x0001, RxResume=0x0002, RxAbort=0x0004, RxAddrLoad=0x0006,
133         RxResumeNoResources=0x0007,
134 };
135
136 static int do_eeprom_cmd(int cmd, int cmd_len);
137 void hd(void *where, int n);
138
139 /***********************************************************************/
140 /*                       I82557 related defines                        */
141 /***********************************************************************/
142
143 /* Serial EEPROM section.
144    A "bit" grungy, but we work our way through bit-by-bit :->. */
145 /*  EEPROM_Ctrl bits. */
146 #define EE_SHIFT_CLK    0x01    /* EEPROM shift clock. */
147 #define EE_CS           0x02    /* EEPROM chip select. */
148 #define EE_DATA_WRITE   0x04    /* EEPROM chip data in. */
149 #define EE_DATA_READ    0x08    /* EEPROM chip data out. */
150 #define EE_WRITE_0      0x4802
151 #define EE_WRITE_1      0x4806
152 #define EE_ENB          (0x4800 | EE_CS)
153
154 /* The EEPROM commands include the alway-set leading bit. */
155 #define EE_READ_CMD     6
156
157 /* The SCB accepts the following controls for the Tx and Rx units: */
158 #define  CU_START       0x0010
159 #define  CU_RESUME      0x0020
160 #define  CU_STATSADDR   0x0040
161 #define  CU_SHOWSTATS   0x0050  /* Dump statistics counters. */
162 #define  CU_CMD_BASE    0x0060  /* Base address to add to add CU commands. */
163 #define  CU_DUMPSTATS   0x0070  /* Dump then reset stats counters. */
164
165 #define  RX_START       0x0001
166 #define  RX_RESUME      0x0002
167 #define  RX_ABORT       0x0004
168 #define  RX_ADDR_LOAD   0x0006
169 #define  RX_RESUMENR    0x0007
170 #define INT_MASK        0x0100
171 #define DRVR_INT        0x0200          /* Driver generated interrupt. */
172
173 enum phy_chips { NonSuchPhy=0, I82553AB, I82553C, I82503, DP83840, S80C240,
174                                          S80C24, PhyUndefined, DP83840A=10, };
175
176 /* Commands that can be put in a command list entry. */
177 enum commands {
178   CmdNOp = 0,
179   CmdIASetup = 1,
180   CmdConfigure = 2,
181   CmdMulticastList = 3,
182   CmdTx = 4,
183   CmdTDR = 5,
184   CmdDump = 6,
185   CmdDiagnose = 7,
186
187   /* And some extra flags: */
188   CmdSuspend = 0x4000,      /* Suspend after completion. */
189   CmdIntr = 0x2000,         /* Interrupt after completion. */
190   CmdTxFlex = 0x0008,       /* Use "Flexible mode" for CmdTx command. */
191 };
192
193 /* How to wait for the command unit to accept a command.
194    Typically this takes 0 ticks. */
195 static inline void wait_for_cmd_done(int cmd_ioaddr)
196 {
197   int wait = 0;
198   int delayed_cmd;
199
200   do
201     if (inb(cmd_ioaddr) == 0) return;
202   while(++wait <= 100);
203   delayed_cmd = inb(cmd_ioaddr);
204   do
205     if (inb(cmd_ioaddr) == 0) break;
206   while(++wait <= 10000);
207   printf("Command %2.2x was not immediately accepted, %d ticks!\n",
208       delayed_cmd, wait);
209 }
210
211 /* Elements of the dump_statistics block. This block must be lword aligned. */
212 static struct speedo_stats {
213         u32 tx_good_frames;
214         u32 tx_coll16_errs;
215         u32 tx_late_colls;
216         u32 tx_underruns;
217         u32 tx_lost_carrier;
218         u32 tx_deferred;
219         u32 tx_one_colls;
220         u32 tx_multi_colls;
221         u32 tx_total_colls;
222         u32 rx_good_frames;
223         u32 rx_crc_errs;
224         u32 rx_align_errs;
225         u32 rx_resource_errs;
226         u32 rx_overrun_errs;
227         u32 rx_colls_errs;
228         u32 rx_runt_errs;
229         u32 done_marker;
230 } lstats;
231
232 /* A speedo3 TX buffer descriptor with two buffers... */
233 static struct TxFD {
234         volatile s16 status;
235         s16 command;
236         u32 link;          /* void * */
237         u32 tx_desc_addr;  /* (almost) Always points to the tx_buf_addr element. */
238         s32 count;         /* # of TBD (=2), Tx start thresh., etc. */
239         /* This constitutes two "TBD" entries: hdr and data */
240         u32 tx_buf_addr0;  /* void *, header of frame to be transmitted.  */
241         s32 tx_buf_size0;  /* Length of Tx hdr. */
242         u32 tx_buf_addr1;  /* void *, data to be transmitted.  */
243         s32 tx_buf_size1;  /* Length of Tx data. */
244 } txfd;
245
246 struct RxFD {               /* Receive frame descriptor. */
247         volatile s16 status;
248         s16 command;
249         u32 link;                 /* struct RxFD * */
250         u32 rx_buf_addr;          /* void * */
251         u16 count;
252         u16 size;
253         char packet[1518];
254 };
255
256 static struct nic_operations eepro100_operations;
257
258 #define RXFD_COUNT 4
259 struct {
260         struct RxFD rxfds[RXFD_COUNT];
261 } eepro100_bufs __shared;
262 #define rxfds eepro100_bufs.rxfds
263 static unsigned int rxfd = 0;
264
265 static int congenb = 0;         /* Enable congestion control in the DP83840. */
266 static int txfifo = 8;          /* Tx FIFO threshold in 4 byte units, 0-15 */
267 static int rxfifo = 8;          /* Rx FIFO threshold, default 32 bytes. */
268 static int txdmacount = 0;      /* Tx DMA burst length, 0-127, default 0. */
269 static int rxdmacount = 0;      /* Rx DMA length, 0 means no preemption. */
270
271 /* I don't understand a byte in this structure. It was copied from the
272  * Linux kernel initialization for the eepro100. -- REW */
273 static struct ConfCmd {
274   s16 status;
275   s16 command;
276   u32 link;
277   unsigned char data[22];
278 } confcmd = {
279   0, 0, 0, /* filled in later */
280   {22, 0x08, 0, 0,  0, 0x80, 0x32, 0x03,  1, /* 1=Use MII  0=Use AUI */
281    0, 0x2E, 0,  0x60, 0,
282    0xf2, 0x48,   0, 0x40, 0xf2, 0x80,        /* 0x40=Force full-duplex */
283    0x3f, 0x05, }
284 };
285
286 /***********************************************************************/
287 /*                       Locally used functions                        */
288 /***********************************************************************/
289
290 /* Support function: mdio_write
291  *
292  * This probably writes to the "physical media interface chip".
293  * -- REW
294  */
295
296 static int mdio_write(int phy_id, int location, int value)
297 {
298         int val, boguscnt = 64*4;         /* <64 usec. to complete, typ 27 ticks */
299
300         outl(0x04000000 | (location<<16) | (phy_id<<21) | value,
301              ioaddr + SCBCtrlMDI);
302         do {
303                 udelay(16);
304
305                 val = inl(ioaddr + SCBCtrlMDI);
306                 if (--boguscnt < 0) {
307                         printf(" mdio_write() timed out with val = %X.\n", val);
308                         break;
309                 }
310         } while (! (val & 0x10000000));
311         return val & 0xffff;
312 }
313
314 /* Support function: mdio_read
315  *
316  * This probably reads a register in the "physical media interface chip".
317  * -- REW
318  */
319 static int mdio_read(int phy_id, int location)
320 {
321         int val, boguscnt = 64*4;               /* <64 usec. to complete, typ 27 ticks */
322         outl(0x08000000 | (location<<16) | (phy_id<<21), ioaddr + SCBCtrlMDI);
323         do {
324                 udelay(16);
325
326                 val = inl(ioaddr + SCBCtrlMDI);
327
328                 if (--boguscnt < 0) {
329                         printf( " mdio_read() timed out with val = %X.\n", val);
330                         break;
331                 }
332         } while (! (val & 0x10000000));
333         return val & 0xffff;
334 }
335
336 /* The fixes for the code were kindly provided by Dragan Stancevic
337    <visitor@valinux.com> to strictly follow Intel specifications of EEPROM
338    access timing.
339    The publicly available sheet 64486302 (sec. 3.1) specifies 1us access
340    interval for serial EEPROM.  However, it looks like that there is an
341    additional requirement dictating larger udelay's in the code below.
342    2000/05/24  SAW */
343 static int do_eeprom_cmd(int cmd, int cmd_len)
344 {
345         unsigned retval = 0;
346         long ee_addr = ioaddr + SCBeeprom;
347
348         outw(EE_ENB, ee_addr); udelay(2);
349         outw(EE_ENB | EE_SHIFT_CLK, ee_addr); udelay(2);
350
351         /* Shift the command bits out. */
352         do {
353                 short dataval = (cmd & (1 << cmd_len)) ? EE_WRITE_1 : EE_WRITE_0;
354                 outw(dataval, ee_addr); udelay(2);
355                 outw(dataval | EE_SHIFT_CLK, ee_addr); udelay(2);
356                 retval = (retval << 1) | ((inw(ee_addr) & EE_DATA_READ) ? 1 : 0);
357         } while (--cmd_len >= 0);
358         outw(EE_ENB, ee_addr); udelay(2);
359
360         /* Terminate the EEPROM access. */
361         outw(EE_ENB & ~EE_CS, ee_addr);
362         return retval;
363 }
364
365 #if 0
366 static inline void whereami (const char *str)
367 {
368   printf ("%s\n", str);
369   sleep (2);
370 }
371 #else
372 #define whereami(s)
373 #endif
374
375 static void eepro100_irq(struct nic *nic __unused, irq_action_t action)
376 {
377         uint16_t enabled_mask = ( SCBMaskCmdDone | SCBMaskCmdIdle |
378                                   SCBMaskEarlyRx | SCBMaskFlowCtl );
379
380         switch ( action ) {
381         case DISABLE :
382                 outw(SCBMaskAll, ioaddr + SCBCmd);
383                 break;
384         case ENABLE :
385                 outw(enabled_mask, ioaddr + SCBCmd);
386                 break;
387         case FORCE :
388                 outw(enabled_mask | SCBTriggerIntr, ioaddr + SCBCmd);
389                 break;
390         }
391 }
392
393 /* function: eepro100_transmit
394  * This transmits a packet.
395  *
396  * Arguments: char d[6]:          destination ethernet address.
397  *            unsigned short t:   ethernet protocol type.
398  *            unsigned short s:   size of the data-part of the packet.
399  *            char *p:            the data for the packet.
400  * returns:   void.
401  */
402
403 static void eepro100_transmit(struct nic *nic, const char *d, unsigned int t, unsigned int s, const char *p)
404 {
405         struct eth_hdr {
406                 unsigned char dst_addr[ETH_ALEN];
407                 unsigned char src_addr[ETH_ALEN];
408                 unsigned short type;
409         } hdr;
410         unsigned short status;
411         int s1, s2;
412         unsigned long ct;
413
414         status = inw(ioaddr + SCBStatus);
415         /* Acknowledge all of the current interrupt sources ASAP. */
416         outw(status & 0xfc00, ioaddr + SCBStatus);
417
418 #ifdef  DEBUG
419         printf ("transmitting type %hX packet (%d bytes). status = %hX, cmd=%hX\n",
420                 t, s, status, inw (ioaddr + SCBCmd));
421 #endif
422
423         memcpy (&hdr.dst_addr, d, ETH_ALEN);
424         memcpy (&hdr.src_addr, nic->node_addr, ETH_ALEN);
425
426         hdr.type = htons (t);
427
428         txfd.status = 0;
429         txfd.command = CmdSuspend | CmdTx | CmdTxFlex;
430         txfd.link   = virt_to_bus (&txfd);
431         txfd.count   = 0x02208000;
432         txfd.tx_desc_addr = virt_to_bus(&txfd.tx_buf_addr0);
433
434         txfd.tx_buf_addr0 = virt_to_bus (&hdr);
435         txfd.tx_buf_size0 = sizeof (hdr);
436
437         txfd.tx_buf_addr1 = virt_to_bus (p);
438         txfd.tx_buf_size1 = s;
439
440 #ifdef  DEBUG
441         printf ("txfd: \n");
442         hd (&txfd, sizeof (txfd));
443 #endif
444
445         outl(virt_to_bus(&txfd), ioaddr + SCBPointer);
446         outb(CU_START, ioaddr + SCBCmd);
447         wait_for_cmd_done(ioaddr + SCBCmd);
448
449         s1 = inw (ioaddr + SCBStatus);
450
451         ct = currticks();
452         /* timeout 10 ms for transmit */
453         while (!txfd.status && ct + 10*1000)
454                 /* Wait */;
455         s2 = inw (ioaddr + SCBStatus);
456
457 #ifdef  DEBUG
458         printf ("s1 = %hX, s2 = %hX.\n", s1, s2);
459 #endif
460 }
461
462 /*
463  * Sometimes the receiver stops making progress.  This routine knows how to
464  * get it going again, without losing packets or being otherwise nasty like
465  * a chip reset would be.  Previously the driver had a whole sequence
466  * of if RxSuspended, if it's no buffers do one thing, if it's no resources,
467  * do another, etc.  But those things don't really matter.  Separate logic
468  * in the ISR provides for allocating buffers--the other half of operation
469  * is just making sure the receiver is active.  speedo_rx_soft_reset does that.
470  * This problem with the old, more involved algorithm is shown up under
471  * ping floods on the order of 60K packets/second on a 100Mbps fdx network.
472  */
473 static void
474 speedo_rx_soft_reset(void)
475 {
476         int i;
477
478
479 #ifdef  DEBUG
480         printf("reset\n");
481 #endif
482         wait_for_cmd_done(ioaddr + SCBCmd);
483         /*
484          * Put the hardware into a known state.
485          */
486         outb(RX_ABORT, ioaddr + SCBCmd);
487
488         for (i = 0; i < RXFD_COUNT; i++) {
489                 rxfds[i].status      = 0;
490                 rxfds[i].rx_buf_addr = 0xffffffff;
491                 rxfds[i].count       = 0;
492                 rxfds[i].size        = 1528;
493         }
494
495         wait_for_cmd_done(ioaddr + SCBCmd);
496
497         outl(virt_to_bus(&rxfds[rxfd]), ioaddr + SCBPointer);
498         outb(RX_START, ioaddr + SCBCmd);
499 }
500
501 /* function: eepro100_poll / eth_poll
502  * This receives a packet from the network.
503  *
504  * Arguments: none
505  *
506  * returns:   1 if a packet was received.
507  *            0 if no packet was received.
508  * side effects:
509  *            returns the packet in the array nic->packet.
510  *            returns the length of the packet in nic->packetlen.
511  */
512
513 static int eepro100_poll(struct nic *nic, int retrieve)
514 {
515         if (rxfds[rxfd].status) {
516                 if (!retrieve)
517                         return 1;
518 #ifdef  DEBUG
519                 printf("Got a packet: Len = %d, rxfd = %d.\n",
520                        rxfds[rxfd].count & 0x3fff, rxfd);
521 #endif
522                 /* First save the data from the rxfd */
523                 nic->packetlen = rxfds[rxfd].count & 0x3fff;
524                 memcpy(nic->packet, rxfds[rxfd].packet, nic->packetlen);
525
526                 rxfds[rxfd].status      = 0;
527                 rxfds[rxfd].command     = 0xc000;
528                 rxfds[rxfd].rx_buf_addr = 0xFFFFFFFF;
529                 rxfds[rxfd].count       = 0;
530                 rxfds[rxfd].size        = 1528;
531                 rxfds[(rxfd-1) % RXFD_COUNT].command = 0x0000;
532                 rxfd = (rxfd+1) % RXFD_COUNT;
533
534 #ifdef  DEBUG
535                 hd (nic->packet, 0x30);
536 #endif
537
538                 /* Acknowledge all conceivable interrupts */
539                 outw(0xff00, ioaddr + SCBStatus);
540
541                 return 1;
542         }
543
544         /*
545          * The chip may have suspended reception for various reasons.
546          * Check for that, and re-prime it should this be the case.
547          */
548         switch ((inw(ioaddr + SCBStatus) >> 2) & 0xf) {
549                 case 0:  /* Idle */
550                         break;
551                 case 1:  /* Suspended */
552                 case 2:  /* No resources (RxFDs) */
553                 case 9:  /* Suspended with no more RBDs */
554                 case 10: /* No resources due to no RBDs */
555                 case 12: /* Ready with no RBDs */
556                         speedo_rx_soft_reset();
557                         break;
558                 default:
559                         /* reserved values */
560                         break;
561         }
562         return 0;
563 }
564
565 /* function: eepro100_disable
566  * resets the card. This is used to allow Etherboot or Linux
567  * to probe the card again from a "virginal" state....
568  * Arguments: none
569  *
570  * returns:   void.
571  */
572 static void eepro100_disable ( struct nic *nic __unused ) {
573 /* from eepro100_reset */
574         outl(0, ioaddr + SCBPort);
575 /* from eepro100_disable */
576         /* See if this PartialReset solves the problem with interfering with
577            kernel operation after Etherboot hands over. - Ken 20001102 */
578         outl(2, ioaddr + SCBPort);
579
580         /* The following is from the Intel e100 driver.
581          * This hopefully solves the problem with hanging hard DOS images. */
582
583         /* wait for the reset to take effect */
584         udelay(20);
585
586         /* Mask off our interrupt line -- it is unmasked after reset */
587         {
588                 u16 intr_status;
589                 /* Disable interrupts on our PCI board by setting the mask bit */
590                 outw(INT_MASK, ioaddr + SCBCmd);
591                 intr_status = inw(ioaddr + SCBStatus);
592                 /* ack and clear intrs */
593                 outw(intr_status, ioaddr + SCBStatus);
594                 inw(ioaddr + SCBStatus);
595         }
596 }
597
598 /* exported function: eepro100_probe / eth_probe
599  * initializes a card
600  *
601  * side effects:
602  *            leaves the ioaddress of the 82557 chip in the variable ioaddr.
603  *            leaves the 82557 initialized, and ready to recieve packets.
604  */
605
606 static int eepro100_probe ( struct nic *nic, struct pci_device *pci ) {
607
608         unsigned short sum = 0;
609         int i;
610         int read_cmd, ee_size;
611         int options;
612         int rx_mode;
613         unsigned long ct;
614
615         /* we cache only the first few words of the EEPROM data
616            be careful not to access beyond this array */
617         unsigned short eeprom[16];
618
619         if (pci->ioaddr == 0)
620                 return 0;
621
622         adjust_pci_device(pci);
623
624         nic->ioaddr = pci->ioaddr;
625         nic->irqno = pci->irq;
626
627         ioaddr = nic->ioaddr;
628
629         if ((do_eeprom_cmd(EE_READ_CMD << 24, 27) & 0xffe0000)
630                 == 0xffe0000) {
631                 ee_size = 0x100;
632                 read_cmd = EE_READ_CMD << 24;
633         } else {
634                 ee_size = 0x40;
635                 read_cmd = EE_READ_CMD << 22;
636         }
637
638         for (i = 0, sum = 0; i < ee_size; i++) {
639                 unsigned short value = do_eeprom_cmd(read_cmd | (i << 16), 27);
640                 if (i < (int)(sizeof(eeprom)/sizeof(eeprom[0])))
641                         eeprom[i] = value;
642                 sum += value;
643         }
644
645         for (i=0;i<ETH_ALEN;i++) {
646                 nic->node_addr[i] =  (eeprom[i/2] >> (8*(i&1))) & 0xff;
647         }
648
649         DBG ( "Ethernet addr: %s\n", eth_ntoa ( nic->node_addr ) );
650
651         if (sum != 0xBABA)
652                 printf("eepro100: Invalid EEPROM checksum %#hX, "
653                        "check settings before activating this device!\n", sum);
654         outl(0, ioaddr + SCBPort);
655         udelay (10000);
656         whereami ("Got eeprom.");
657
658         /* Base = 0, disable all interrupts  */
659         outl(0, ioaddr + SCBPointer);
660         outw(INT_MASK | RX_ADDR_LOAD, ioaddr + SCBCmd);
661         wait_for_cmd_done(ioaddr + SCBCmd);
662         whereami ("set rx base addr.");
663
664         outl(virt_to_bus(&lstats), ioaddr + SCBPointer);
665         outb(CU_STATSADDR, ioaddr + SCBCmd);
666         wait_for_cmd_done(ioaddr + SCBCmd);
667         whereami ("set stats addr.");
668
669         /* INIT RX stuff. */
670         for (i = 0; i < RXFD_COUNT; i++) {
671                 rxfds[i].status      = 0x0000;
672                 rxfds[i].command     = 0x0000;
673                 rxfds[i].rx_buf_addr = 0xFFFFFFFF;
674                 rxfds[i].count       = 0;
675                 rxfds[i].size        = 1528;
676                 rxfds[i].link        = virt_to_bus(&rxfds[i+1]);
677         }
678
679         rxfds[RXFD_COUNT-1].status  = 0x0000;
680         rxfds[RXFD_COUNT-1].command = 0xC000;
681         rxfds[RXFD_COUNT-1].link    = virt_to_bus(&rxfds[0]);
682
683         outl(virt_to_bus(&rxfds[0]), ioaddr + SCBPointer);
684         outb(RX_START, ioaddr + SCBCmd);
685         wait_for_cmd_done(ioaddr + SCBCmd);
686
687         whereami ("started RX process.");
688
689         /* INIT TX stuff. */
690
691         /* Base = 0 */
692         outl(0, ioaddr + SCBPointer);
693         outb(CU_CMD_BASE, ioaddr + SCBCmd);
694         wait_for_cmd_done(ioaddr + SCBCmd);
695
696         whereami ("set TX base addr.");
697
698         txfd.command      = (CmdIASetup);
699         txfd.status       = 0x0000;
700         txfd.link         = virt_to_bus (&confcmd);
701
702         {
703                 char *t = (char *)&txfd.tx_desc_addr;
704
705                 for (i=0;i<ETH_ALEN;i++)
706                         t[i] = nic->node_addr[i];
707         }
708
709 #ifdef  DEBUG
710         printf ("Setup_eaddr:\n");
711         hd (&txfd, 0x20);
712 #endif
713         /*      options = 0x40; */ /* 10mbps half duplex... */
714         options = 0x00;            /* Autosense */
715
716 #ifdef PROMISC
717         rx_mode = 3;
718 #elif ALLMULTI
719         rx_mode = 1;
720 #else
721         rx_mode = 0;
722 #endif
723
724         if (   ((eeprom[6]>>8) & 0x3f) == DP83840
725                || ((eeprom[6]>>8) & 0x3f) == DP83840A) {
726                 int mdi_reg23 = mdio_read(eeprom[6] & 0x1f, 23) | 0x0422;
727                 if (congenb)
728                         mdi_reg23 |= 0x0100;
729                 printf("  DP83840 specific setup, setting register 23 to %hX.\n",
730                        mdi_reg23);
731                 mdio_write(eeprom[6] & 0x1f, 23, mdi_reg23);
732         }
733         whereami ("Done DP8340 special setup.");
734         if (options != 0) {
735                 mdio_write(eeprom[6] & 0x1f, 0,
736                            ((options & 0x20) ? 0x2000 : 0) |    /* 100mbps? */
737                            ((options & 0x10) ? 0x0100 : 0)); /* Full duplex? */
738                 whereami ("set mdio_register.");
739         }
740
741         confcmd.command  = CmdSuspend | CmdConfigure;
742         confcmd.status   = 0x0000;
743         confcmd.link     = virt_to_bus (&txfd);
744         confcmd.data[1]  = (txfifo << 4) | rxfifo;
745         confcmd.data[4]  = rxdmacount;
746         confcmd.data[5]  = txdmacount + 0x80;
747         confcmd.data[15] = (rx_mode & 2) ? 0x49: 0x48;
748         confcmd.data[19] = (options & 0x10) ? 0xC0 : 0x80;
749         confcmd.data[21] = (rx_mode & 1) ? 0x0D: 0x05;
750
751         outl(virt_to_bus(&txfd), ioaddr + SCBPointer);
752         outb(CU_START, ioaddr + SCBCmd);
753         wait_for_cmd_done(ioaddr + SCBCmd);
754
755         whereami ("started TX thingy (config, iasetup).");
756
757         ct = currticks();
758         while (!txfd.status && ct + 10*1000 < currticks())
759                 /* Wait */;
760
761         /* Read the status register once to disgard stale data */
762         mdio_read(eeprom[6] & 0x1f, 1);
763         /* Check to see if the network cable is plugged in.
764          * This allows for faster failure if there is nothing
765          * we can do.
766          */
767         if (!(mdio_read(eeprom[6] & 0x1f, 1) & (1 << 2))) {
768                 printf("Valid link not established\n");
769                 eepro100_disable(nic);
770                 return 0;
771         }
772         nic->nic_op     = &eepro100_operations;
773         return 1;
774 }
775
776 /*********************************************************************/
777
778 #ifdef  DEBUG
779
780 /* Hexdump a number of bytes from memory... */
781 void hd (void *where, int n)
782 {
783         int i;
784
785         while (n > 0) {
786                 printf ("%X ", where);
787                 for (i=0;i < ( (n>16)?16:n);i++)
788                         printf (" %hhX", ((char *)where)[i]);
789                 printf ("\n");
790                 n -= 16;
791                 where += 16;
792         }
793 }
794 #endif
795
796 static struct nic_operations eepro100_operations = {
797         .connect        = dummy_connect,
798         .poll           = eepro100_poll,
799         .transmit       = eepro100_transmit,
800         .irq            = eepro100_irq,
801
802 };
803
804 static struct pci_device_id eepro100_nics[] = {
805 PCI_ROM(0x8086, 0x1029, "id1029",        "Intel EtherExpressPro100 ID1029", 0),
806 PCI_ROM(0x8086, 0x1030, "id1030",        "Intel EtherExpressPro100 ID1030", 0),
807 PCI_ROM(0x8086, 0x1031, "82801cam",      "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
808 PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection", 0),
809 PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection", 0),
810 PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection", 0),
811 PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
812 PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
813 PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
814 PCI_ROM(0x8086, 0x1038, "id1038",        "Intel PRO/100 VM Network Connection", 0),
815 PCI_ROM(0x8086, 0x1039, "82562et",       "Intel PRO100 VE 82562ET", 0),
816 PCI_ROM(0x8086, 0x103a, "id103a",        "Intel Corporation 82559 InBusiness 10/100", 0),
817 PCI_ROM(0x8086, 0x103b, "82562etb",      "Intel PRO100 VE 82562ETB", 0),
818 PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection", 0),
819 PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection", 0),
820 PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection", 0),
821 PCI_ROM(0x8086, 0x1051, "prove",       "Intel PRO/100 VE Network Connection", 0),
822 PCI_ROM(0x8086, 0x1059, "82551qm",       "Intel PRO/100 M Mobile Connection", 0),
823 PCI_ROM(0x8086, 0x1209, "82559er",       "Intel EtherExpressPro100 82559ER", 0),
824 PCI_ROM(0x8086, 0x1227, "82865",         "Intel 82865 EtherExpress PRO/100A", 0),
825 PCI_ROM(0x8086, 0x1228, "82556",         "Intel 82556 EtherExpress PRO/100 Smart", 0),
826 PCI_ROM(0x8086, 0x1229, "eepro100",      "Intel EtherExpressPro100", 0),
827 PCI_ROM(0x8086, 0x2449, "82562em",       "Intel EtherExpressPro100 82562EM", 0),
828 PCI_ROM(0x8086, 0x2459, "82562-1",       "Intel 82562 based Fast Ethernet Connection", 0),
829 PCI_ROM(0x8086, 0x245d, "82562-2",       "Intel 82562 based Fast Ethernet Connection", 0),
830 PCI_ROM(0x8086, 0x1050, "82562ez",       "Intel 82562EZ Network Connection", 0),
831 PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller", 0),
832 PCI_ROM(0x8086, 0x1065, "82562-3",       "Intel 82562 based Fast Ethernet Connection", 0),
833 PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server", 0),
834 PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server", 0),
835 };
836
837 /* Cards with device ids 0x1030 to 0x103F, 0x2449, 0x2459 or 0x245D might need
838  * a workaround for hardware bug on 10 mbit half duplex (see linux driver eepro100.c)
839  * 2003/03/17 gbaum */
840
841
842 PCI_DRIVER ( eepro100_driver, eepro100_nics, PCI_NO_CLASS );
843
844 DRIVER ( "EEPRO100", nic_driver, pci_driver, eepro100_driver,
845          eepro100_probe, eepro100_disable );
846
847 /*
848  * Local variables:
849  *  c-basic-offset: 8
850  *  c-indent-level: 8
851  *  tab-width: 8
852  * End:
853  */