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