Merge with /home/hs/U-Boot/u-boot-dev
[platform/kernel/u-boot.git] / drivers / ne2000.c
1 /*
2 Ported to U-Boot  by Christian Pellegrin <chri@ascensit.com>
3
4 Based on sources from the Linux kernel (pcnet_cs.c, 8390.h) and
5 eCOS(if_dp83902a.c, if_dp83902a.h). Both of these 2 wonderful world
6 are GPL, so this is, of course, GPL.
7
8
9 ==========================================================================
10
11 dev/if_dp83902a.c
12
13 Ethernet device driver for NS DP83902a ethernet controller
14
15 ==========================================================================
16 ####ECOSGPLCOPYRIGHTBEGIN####
17 -------------------------------------------
18 This file is part of eCos, the Embedded Configurable Operating System.
19 Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
20
21 eCos is free software; you can redistribute it and/or modify it under
22 the terms of the GNU General Public License as published by the Free
23 Software Foundation; either version 2 or (at your option) any later version.
24
25 eCos is distributed in the hope that it will be useful, but WITHOUT ANY
26 WARRANTY; without even the implied warranty of MERCHANTABILITY or
27 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
28 for more details.
29
30 You should have received a copy of the GNU General Public License along
31 with eCos; if not, write to the Free Software Foundation, Inc.,
32 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
33
34 As a special exception, if other files instantiate templates or use macros
35 or inline functions from this file, or you compile this file and link it
36 with other works to produce a work based on this file, this file does not
37 by itself cause the resulting work to be covered by the GNU General Public
38 License. However the source code for this file must still be made available
39 in accordance with section (3) of the GNU General Public License.
40
41 This exception does not invalidate any other reasons why a work based on
42 this file might be covered by the GNU General Public License.
43
44 Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
45 at http://sources.redhat.com/ecos/ecos-license/
46 -------------------------------------------
47 ####ECOSGPLCOPYRIGHTEND####
48 ####BSDCOPYRIGHTBEGIN####
49
50 -------------------------------------------
51
52 Portions of this software may have been derived from OpenBSD or other sources,
53 and are covered by the appropriate copyright disclaimers included herein.
54
55 -------------------------------------------
56
57 ####BSDCOPYRIGHTEND####
58 ==========================================================================
59 #####DESCRIPTIONBEGIN####
60
61 Author(s):    gthomas
62 Contributors: gthomas, jskov, rsandifo
63 Date:         2001-06-13
64 Purpose:
65 Description:
66
67 FIXME:        Will fail if pinged with large packets (1520 bytes)
68 Add promisc config
69 Add SNMP
70
71 ####DESCRIPTIONEND####
72
73
74 ==========================================================================
75
76 */
77
78 #include <common.h>
79 #include <command.h>
80 #include <net.h>
81 #include <malloc.h>
82
83 #ifdef CONFIG_DRIVER_NE2000
84
85 /* wor around udelay resetting OCR */
86 static void my_udelay(long us) {
87         long tmo;
88
89         tmo = get_timer (0) + us * CFG_HZ / 1000000; /* will this be much greater than 0 ? */
90         while (get_timer (0) < tmo);
91 }
92
93 #define mdelay(n)       my_udelay((n)*1000)
94
95 /* forward definition of function used for the uboot interface */
96 void uboot_push_packet_len(int len);
97 void uboot_push_tx_done(int key, int val);
98
99 /* timeout for tx/rx in s */
100 #define TOUT 5
101
102 #define ETHER_ADDR_LEN 6
103
104 /*
105   ------------------------------------------------------------------------
106   Debugging details
107
108   Set to perms of:
109   0 disables all debug output
110   1 for process debug output
111   2 for added data IO output: get_reg, put_reg
112   4 for packet allocation/free output
113   8 for only startup status, so we can tell we're installed OK
114 */
115 /*#define DEBUG 0xf*/
116 #define DEBUG 0
117
118 #if DEBUG & 1
119 #define DEBUG_FUNCTION() do { printf("%s\n", __FUNCTION__); } while (0)
120 #define DEBUG_LINE() do { printf("%d\n", __LINE__); } while (0)
121 #else
122 #define DEBUG_FUNCTION() do {} while(0)
123 #define DEBUG_LINE() do {} while(0)
124 #endif
125
126 #include "ne2000.h"
127
128 #if DEBUG & 1
129 #define PRINTK(args...) printf(args)
130 #else
131 #define PRINTK(args...)
132 #endif
133
134 static dp83902a_priv_data_t nic; /* just one instance of the card supported */
135
136 static bool
137 dp83902a_init(void)
138 {
139         dp83902a_priv_data_t *dp = &nic;
140         cyg_uint8* base;
141         int i;
142
143         DEBUG_FUNCTION();
144
145         base = dp->base;
146         if (!base) return false;  /* No device found */
147
148         DEBUG_LINE();
149
150         /* Prepare ESA */
151         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1);  /* Select page 1 */
152         /* Use the address from the serial EEPROM */
153         for (i = 0; i < 6; i++)
154                 DP_IN(base, DP_P1_PAR0+i, dp->esa[i]);
155         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0);  /* Select page 0 */
156
157         printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n",
158                "eeprom",
159                dp->esa[0],
160                dp->esa[1],
161                dp->esa[2],
162                dp->esa[3],
163                dp->esa[4],
164                dp->esa[5] );
165
166         return true;
167 }
168
169 static void
170 dp83902a_stop(void)
171 {
172         dp83902a_priv_data_t *dp = &nic;
173         cyg_uint8 *base = dp->base;
174
175         DEBUG_FUNCTION();
176
177         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP);  /* Brutal */
178         DP_OUT(base, DP_ISR, 0xFF);             /* Clear any pending interrupts */
179         DP_OUT(base, DP_IMR, 0x00);             /* Disable all interrupts */
180
181         dp->running = false;
182 }
183
184 /*
185   This function is called to "start up" the interface.  It may be called
186   multiple times, even when the hardware is already running.  It will be
187   called whenever something "hardware oriented" changes and should leave
188   the hardware ready to send/receive packets.
189 */
190 static void
191 dp83902a_start(unsigned char * enaddr)
192 {
193         dp83902a_priv_data_t *dp = &nic;
194         cyg_uint8 *base = dp->base;
195         int i;
196
197         DEBUG_FUNCTION();
198
199         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
200         DP_OUT(base, DP_DCR, DP_DCR_INIT);
201         DP_OUT(base, DP_RBCH, 0);               /* Remote byte count */
202         DP_OUT(base, DP_RBCL, 0);
203         DP_OUT(base, DP_RCR, DP_RCR_MON);       /* Accept no packets */
204         DP_OUT(base, DP_TCR, DP_TCR_LOCAL);     /* Transmitter [virtually] off */
205         DP_OUT(base, DP_TPSR, dp->tx_buf1);     /* Transmitter start page */
206         dp->tx1 = dp->tx2 = 0;
207         dp->tx_next = dp->tx_buf1;
208         dp->tx_started = false;
209         DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
210         DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1); /* Receive ring boundary */
211         DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
212         dp->rx_next = dp->rx_buf_start-1;
213         DP_OUT(base, DP_ISR, 0xFF);             /* Clear any pending interrupts */
214         DP_OUT(base, DP_IMR, DP_IMR_All);       /* Enable all interrupts */
215         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP);  /* Select page 1 */
216         DP_OUT(base, DP_P1_CURP, dp->rx_buf_start);   /* Current page - next free page for Rx */
217         for (i = 0;  i < ETHER_ADDR_LEN;  i++) {
218                 DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
219         }
220         /* Enable and start device */
221         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
222         DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
223         DP_OUT(base, DP_RCR, DP_RCR_AB);  /* Accept broadcast, no errors, no multicast */
224         dp->running = true;
225 }
226
227 /*
228   This routine is called to start the transmitter.  It is split out from the
229   data handling routine so it may be called either when data becomes first
230   available or when an Tx interrupt occurs
231 */
232
233 static void
234 dp83902a_start_xmit(int start_page, int len)
235 {
236         dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic;
237         cyg_uint8 *base = dp->base;
238
239         DEBUG_FUNCTION();
240
241 #if DEBUG & 1
242         printf("Tx pkt %d len %d\n", start_page, len);
243         if (dp->tx_started)
244                 printf("TX already started?!?\n");
245 #endif
246
247         DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE));
248         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
249         DP_OUT(base, DP_TBCL, len & 0xFF);
250         DP_OUT(base, DP_TBCH, len >> 8);
251         DP_OUT(base, DP_TPSR, start_page);
252         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
253
254         dp->tx_started = true;
255 }
256
257 /*
258   This routine is called to send data to the hardware.  It is known a-priori
259   that there is free buffer space (dp->tx_next).
260 */
261 static void
262 dp83902a_send(unsigned char *data, int total_len, unsigned long key)
263 {
264         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
265         cyg_uint8 *base = dp->base;
266         int len, start_page, pkt_len, i, isr;
267 #if DEBUG & 4
268         int dx;
269 #endif
270
271         DEBUG_FUNCTION();
272
273         len = pkt_len = total_len;
274         if (pkt_len < IEEE_8023_MIN_FRAME) pkt_len = IEEE_8023_MIN_FRAME;
275
276         start_page = dp->tx_next;
277         if (dp->tx_next == dp->tx_buf1) {
278                 dp->tx1 = start_page;
279                 dp->tx1_len = pkt_len;
280                 dp->tx1_key = key;
281                 dp->tx_next = dp->tx_buf2;
282         } else {
283                 dp->tx2 = start_page;
284                 dp->tx2_len = pkt_len;
285                 dp->tx2_key = key;
286                 dp->tx_next = dp->tx_buf1;
287         }
288
289 #if DEBUG & 5
290         printf("TX prep page %d len %d\n", start_page, pkt_len);
291 #endif
292
293         DP_OUT(base, DP_ISR, DP_ISR_RDC);  /* Clear end of DMA */
294         {
295                 /* Dummy read. The manual sez something slightly different, */
296                 /* but the code is extended a bit to do what Hitachi's monitor */
297                 /* does (i.e., also read data). */
298
299                 cyg_uint16 tmp;
300                 int len = 1;
301
302                 DP_OUT(base, DP_RSAL, 0x100-len);
303                 DP_OUT(base, DP_RSAH, (start_page-1) & 0xff);
304                 DP_OUT(base, DP_RBCL, len);
305                 DP_OUT(base, DP_RBCH, 0);
306                 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
307                 DP_IN_DATA(dp->data, tmp);
308         }
309
310 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
311         /* Stall for a bit before continuing to work around random data */
312         /* corruption problems on some platforms. */
313         CYGACC_CALL_IF_DELAY_US(1);
314 #endif
315
316         /* Send data to device buffer(s) */
317         DP_OUT(base, DP_RSAL, 0);
318         DP_OUT(base, DP_RSAH, start_page);
319         DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
320         DP_OUT(base, DP_RBCH, pkt_len >> 8);
321         DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
322
323         /* Put data into buffer */
324 #if DEBUG & 4
325         printf(" sg buf %08lx len %08x\n ", (unsigned long) data, len);
326         dx = 0;
327 #endif
328         while (len > 0) {
329 #if DEBUG & 4
330                 printf(" %02x", *data);
331                 if (0 == (++dx % 16)) printf("\n ");
332 #endif
333                 DP_OUT_DATA(dp->data, *data++);
334                 len--;
335         }
336 #if DEBUG & 4
337         printf("\n");
338 #endif
339         if (total_len < pkt_len) {
340 #if DEBUG & 4
341                 printf("  + %d bytes of padding\n", pkt_len - total_len);
342 #endif
343                 /* Padding to 802.3 length was required */
344                 for (i = total_len;  i < pkt_len;) {
345                         i++;
346                         DP_OUT_DATA(dp->data, 0);
347                 }
348         }
349
350 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
351         /* After last data write, delay for a bit before accessing the */
352         /* device again, or we may get random data corruption in the last */
353         /* datum (on some platforms). */
354         CYGACC_CALL_IF_DELAY_US(1);
355 #endif
356
357         /* Wait for DMA to complete */
358         do {
359                 DP_IN(base, DP_ISR, isr);
360         } while ((isr & DP_ISR_RDC) == 0);
361         /* Then disable DMA */
362         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
363
364         /* Start transmit if not already going */
365         if (!dp->tx_started) {
366                 if (start_page == dp->tx1) {
367                         dp->tx_int = 1;  /* Expecting interrupt from BUF1 */
368                 } else {
369                         dp->tx_int = 2;  /* Expecting interrupt from BUF2 */
370                 }
371                 dp83902a_start_xmit(start_page, pkt_len);
372         }
373 }
374
375 /*
376   This function is called when a packet has been received.  It's job is
377   to prepare to unload the packet from the hardware.  Once the length of
378   the packet is known, the upper layer of the driver can be told.  When
379   the upper layer is ready to unload the packet, the internal function
380   'dp83902a_recv' will be called to actually fetch it from the hardware.
381 */
382 static void
383 dp83902a_RxEvent(void)
384 {
385         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
386         cyg_uint8 *base = dp->base;
387         unsigned char rsr;
388         unsigned char rcv_hdr[4];
389         int i, len, pkt, cur;
390
391         DEBUG_FUNCTION();
392
393         DP_IN(base, DP_RSR, rsr);
394         while (true) {
395                 /* Read incoming packet header */
396                 DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
397                 DP_IN(base, DP_P1_CURP, cur);
398                 DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
399                 DP_IN(base, DP_BNDRY, pkt);
400
401                 pkt += 1;
402                 if (pkt == dp->rx_buf_end)
403                         pkt = dp->rx_buf_start;
404
405                 if (pkt == cur) {
406                         break;
407                 }
408                 DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
409                 DP_OUT(base, DP_RBCH, 0);
410                 DP_OUT(base, DP_RSAL, 0);
411                 DP_OUT(base, DP_RSAH, pkt);
412                 if (dp->rx_next == pkt) {
413                         if (cur == dp->rx_buf_start)
414                                 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1);
415                         else
416                                 DP_OUT(base, DP_BNDRY, cur-1); /* Update pointer */
417                         return;
418                 }
419                 dp->rx_next = pkt;
420                 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
421                 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
422 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
423                 CYGACC_CALL_IF_DELAY_US(10);
424 #endif
425
426                 for (i = 0;  i < sizeof(rcv_hdr);) {
427                         DP_IN_DATA(dp->data, rcv_hdr[i++]);
428                 }
429
430 #if DEBUG & 5
431                 printf("rx hdr %02x %02x %02x %02x\n",
432                        rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
433 #endif
434                 len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
435                 uboot_push_packet_len(len);
436                 if (rcv_hdr[1] == dp->rx_buf_start)
437                         DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1);
438                 else
439                         DP_OUT(base, DP_BNDRY, rcv_hdr[1]-1); /* Update pointer */
440         }
441 }
442
443 /*
444   This function is called as a result of the "eth_drv_recv()" call above.
445   It's job is to actually fetch data for a packet from the hardware once
446   memory buffers have been allocated for the packet.  Note that the buffers
447   may come in pieces, using a scatter-gather list.  This allows for more
448   efficient processing in the upper layers of the stack.
449 */
450 static void
451 dp83902a_recv(unsigned char *data, int len)
452 {
453         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
454         cyg_uint8 *base = dp->base;
455         int i, mlen;
456         cyg_uint8 saved_char = 0;
457         bool saved;
458 #if DEBUG & 4
459         int dx;
460 #endif
461
462         DEBUG_FUNCTION();
463
464 #if DEBUG & 5
465         printf("Rx packet %d length %d\n", dp->rx_next, len);
466 #endif
467
468         /* Read incoming packet data */
469         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
470         DP_OUT(base, DP_RBCL, len & 0xFF);
471         DP_OUT(base, DP_RBCH, len >> 8);
472         DP_OUT(base, DP_RSAL, 4);               /* Past header */
473         DP_OUT(base, DP_RSAH, dp->rx_next);
474         DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
475         DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
476 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
477         CYGACC_CALL_IF_DELAY_US(10);
478 #endif
479
480         saved = false;
481         for (i = 0;  i < 1;  i++) {
482                 if (data) {
483                         mlen = len;
484 #if DEBUG & 4
485                         printf(" sg buf %08lx len %08x \n", (unsigned long) data, mlen);
486                         dx = 0;
487 #endif
488                         while (0 < mlen) {
489                                 /* Saved byte from previous loop? */
490                                 if (saved) {
491                                         *data++ = saved_char;
492                                         mlen--;
493                                         saved = false;
494                                         continue;
495                                 }
496
497                                 {
498                                         cyg_uint8 tmp;
499                                         DP_IN_DATA(dp->data, tmp);
500 #if DEBUG & 4
501                                         printf(" %02x", tmp);
502                                         if (0 == (++dx % 16)) printf("\n ");
503 #endif
504                                         *data++ = tmp;;
505                                         mlen--;
506                                 }
507                         }
508 #if DEBUG & 4
509                         printf("\n");
510 #endif
511                 }
512         }
513 }
514
515 static void
516 dp83902a_TxEvent(void)
517 {
518         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
519         cyg_uint8 *base = dp->base;
520         unsigned char tsr;
521         unsigned long key;
522
523         DEBUG_FUNCTION();
524
525         DP_IN(base, DP_TSR, tsr);
526         if (dp->tx_int == 1) {
527                 key = dp->tx1_key;
528                 dp->tx1 = 0;
529         } else {
530                 key = dp->tx2_key;
531                 dp->tx2 = 0;
532         }
533         /* Start next packet if one is ready */
534         dp->tx_started = false;
535         if (dp->tx1) {
536                 dp83902a_start_xmit(dp->tx1, dp->tx1_len);
537                 dp->tx_int = 1;
538         } else if (dp->tx2) {
539                 dp83902a_start_xmit(dp->tx2, dp->tx2_len);
540                 dp->tx_int = 2;
541         } else {
542                 dp->tx_int = 0;
543         }
544         /* Tell higher level we sent this packet */
545         uboot_push_tx_done(key, 0);
546 }
547
548 /* Read the tally counters to clear them.  Called in response to a CNT */
549 /* interrupt. */
550 static void
551 dp83902a_ClearCounters(void)
552 {
553         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
554         cyg_uint8 *base = dp->base;
555         cyg_uint8 cnt1, cnt2, cnt3;
556
557         DP_IN(base, DP_FER, cnt1);
558         DP_IN(base, DP_CER, cnt2);
559         DP_IN(base, DP_MISSED, cnt3);
560         DP_OUT(base, DP_ISR, DP_ISR_CNT);
561 }
562
563 /* Deal with an overflow condition.  This code follows the procedure set */
564 /* out in section 7.0 of the datasheet. */
565 static void
566 dp83902a_Overflow(void)
567 {
568         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *)&nic;
569         cyg_uint8 *base = dp->base;
570         cyg_uint8 isr;
571
572         /* Issue a stop command and wait 1.6ms for it to complete. */
573         DP_OUT(base, DP_CR, DP_CR_STOP | DP_CR_NODMA);
574         CYGACC_CALL_IF_DELAY_US(1600);
575
576         /* Clear the remote byte counter registers. */
577         DP_OUT(base, DP_RBCL, 0);
578         DP_OUT(base, DP_RBCH, 0);
579
580         /* Enter loopback mode while we clear the buffer. */
581         DP_OUT(base, DP_TCR, DP_TCR_LOCAL);
582         DP_OUT(base, DP_CR, DP_CR_START | DP_CR_NODMA);
583
584         /* Read in as many packets as we can and acknowledge any and receive */
585         /* interrupts.  Since the buffer has overflowed, a receive event of */
586         /* some kind will have occured. */
587         dp83902a_RxEvent();
588         DP_OUT(base, DP_ISR, DP_ISR_RxP|DP_ISR_RxE);
589
590         /* Clear the overflow condition and leave loopback mode. */
591         DP_OUT(base, DP_ISR, DP_ISR_OFLW);
592         DP_OUT(base, DP_TCR, DP_TCR_NORMAL);
593
594         /* If a transmit command was issued, but no transmit event has occured, */
595         /* restart it here. */
596         DP_IN(base, DP_ISR, isr);
597         if (dp->tx_started && !(isr & (DP_ISR_TxP|DP_ISR_TxE))) {
598                 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
599         }
600 }
601
602 static void
603 dp83902a_poll(void)
604 {
605         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
606         cyg_uint8 *base = dp->base;
607         unsigned char isr;
608
609         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0 | DP_CR_START);
610         DP_IN(base, DP_ISR, isr);
611         while (0 != isr) {
612                 /* The CNT interrupt triggers when the MSB of one of the error */
613                 /* counters is set.  We don't much care about these counters, but */
614                 /* we should read their values to reset them. */
615                 if (isr & DP_ISR_CNT) {
616                         dp83902a_ClearCounters();
617                 }
618                 /* Check for overflow.  It's a special case, since there's a */
619                 /* particular procedure that must be followed to get back into */
620                 /* a running state.a */
621                 if (isr & DP_ISR_OFLW) {
622                         dp83902a_Overflow();
623                 } else {
624                         /* Other kinds of interrupts can be acknowledged simply by */
625                         /* clearing the relevant bits of the ISR.  Do that now, then */
626                         /* handle the interrupts we care about. */
627                         DP_OUT(base, DP_ISR, isr);      /* Clear set bits */
628                         if (!dp->running) break;        /* Is this necessary? */
629                         /* Check for tx_started on TX event since these may happen */
630                         /* spuriously it seems. */
631                         if (isr & (DP_ISR_TxP|DP_ISR_TxE) && dp->tx_started) {
632                                 dp83902a_TxEvent();
633                         }
634                         if (isr & (DP_ISR_RxP|DP_ISR_RxE)) {
635                                 dp83902a_RxEvent();
636                         }
637                 }
638                 DP_IN(base, DP_ISR, isr);
639         }
640 }
641
642 /* find prom (taken from pc_net_cs.c from Linux) */
643
644 #include "8390.h"
645
646 typedef struct hw_info_t {
647         u_int   offset;
648         u_char  a0, a1, a2;
649         u_int   flags;
650 } hw_info_t;
651
652 #define DELAY_OUTPUT    0x01
653 #define HAS_MISC_REG    0x02
654 #define USE_BIG_BUF     0x04
655 #define HAS_IBM_MISC    0x08
656 #define IS_DL10019      0x10
657 #define IS_DL10022      0x20
658 #define HAS_MII         0x40
659 #define USE_SHMEM       0x80    /* autodetected */
660
661 #define AM79C9XX_HOME_PHY       0x00006B90  /* HomePNA PHY */
662 #define AM79C9XX_ETH_PHY        0x00006B70  /* 10baseT PHY */
663 #define MII_PHYID_REV_MASK      0xfffffff0
664 #define MII_PHYID_REG1          0x02
665 #define MII_PHYID_REG2          0x03
666
667 static hw_info_t hw_info[] = {
668         { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT },
669         { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
670         { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
671         { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94,
672           DELAY_OUTPUT | HAS_IBM_MISC },
673         { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 },
674         { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 },
675         { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 },
676         { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 },
677         { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 },
678         { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 },
679         { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48,
680           HAS_MISC_REG | HAS_IBM_MISC },
681         { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 },
682         { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 },
683         { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a,
684           HAS_MISC_REG | HAS_IBM_MISC },
685         { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac,
686           HAS_MISC_REG | HAS_IBM_MISC },
687         { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29,
688           HAS_MISC_REG | HAS_IBM_MISC },
689         { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a,
690           HAS_MISC_REG | HAS_IBM_MISC },
691         { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac,
692           HAS_MISC_REG | HAS_IBM_MISC },
693         { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87,
694           HAS_MISC_REG | HAS_IBM_MISC },
695         { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17,
696           HAS_MISC_REG | HAS_IBM_MISC },
697         { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8,
698           HAS_MISC_REG | HAS_IBM_MISC },
699         { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0,
700           HAS_MISC_REG | HAS_IBM_MISC },
701         { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0,
702           HAS_MISC_REG | HAS_IBM_MISC },
703         { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 },
704         { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 },
705         { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0,
706           HAS_MISC_REG | HAS_IBM_MISC },
707         { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f,
708           HAS_MISC_REG | HAS_IBM_MISC },
709         { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 },
710         { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 },
711         { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 },
712         { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 },
713         { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65,
714           HAS_MISC_REG | HAS_IBM_MISC },
715         { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45,
716           HAS_MISC_REG | HAS_IBM_MISC },
717         { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 },
718         { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 },
719         { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 },
720         { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b,
721           DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF },
722         { /* Socket LP-E CF+ */ 0x01c0, 0x00, 0xc0, 0x1b, 0 },
723         { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 },
724         { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 },
725         { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 },
726         { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 }
727 };
728
729 #define NR_INFO         (sizeof(hw_info)/sizeof(hw_info_t))
730
731 static hw_info_t default_info = { 0, 0, 0, 0, 0 };
732
733 unsigned char dev_addr[6];
734
735 #define PCNET_CMD       0x00
736 #define PCNET_DATAPORT  0x10    /* NatSemi-defined port window offset. */
737 #define PCNET_RESET     0x1f    /* Issue a read to reset, a write to clear. */
738 #define PCNET_MISC      0x18    /* For IBM CCAE and Socket EA cards */
739
740 unsigned long nic_base;
741
742 static void pcnet_reset_8390(void)
743 {
744         int i, r;
745
746         PRINTK("nic base is %lx\n", nic_base);
747
748 #if 1
749         n2k_outb(E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD);
750         PRINTK("cmd (at %lx) is %x\n", nic_base+ E8390_CMD, n2k_inb(E8390_CMD));
751         n2k_outb(E8390_NODMA+E8390_PAGE1+E8390_STOP, E8390_CMD);
752         PRINTK("cmd (at %lx) is %x\n", nic_base+ E8390_CMD, n2k_inb(E8390_CMD));
753         n2k_outb(E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD);
754         PRINTK("cmd (at %lx) is %x\n", nic_base+ E8390_CMD, n2k_inb(E8390_CMD));
755 #endif
756         n2k_outb(E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD);
757
758         n2k_outb(n2k_inb(nic_base + PCNET_RESET), PCNET_RESET);
759
760         for (i = 0; i < 100; i++) {
761                 if ((r = (n2k_inb(EN0_ISR) & ENISR_RESET)) != 0)
762                         break;
763                 PRINTK("got %x in reset\n", r);
764                 my_udelay(100);
765         }
766         n2k_outb(ENISR_RESET, EN0_ISR); /* Ack intr. */
767
768         if (i == 100)
769                 printf("pcnet_reset_8390() did not complete.\n");
770 } /* pcnet_reset_8390 */
771
772 static hw_info_t * get_prom(void ) {
773         unsigned char prom[32];
774         int i, j;
775         struct {
776                 u_char value, offset;
777         } program_seq[] = {
778                 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
779                 {0x48,  EN0_DCFG},      /* Set byte-wide (0x48) access. */
780                 {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
781                 {0x00,  EN0_RCNTHI},
782                 {0x00,  EN0_IMR},       /* Mask completion irq. */
783                 {0xFF,  EN0_ISR},
784                 {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
785                 {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
786                 {32,    EN0_RCNTLO},
787                 {0x00,  EN0_RCNTHI},
788                 {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
789                 {0x00,  EN0_RSARHI},
790                 {E8390_RREAD+E8390_START, E8390_CMD},
791         };
792
793         PRINTK("trying to get MAC via prom reading\n");
794
795         pcnet_reset_8390();
796
797         mdelay(10);
798
799         for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
800                 n2k_outb(program_seq[i].value, program_seq[i].offset);
801
802         PRINTK("PROM:");
803         for (i = 0; i < 32; i++) {
804                 prom[i] = n2k_inb(PCNET_DATAPORT);
805                 PRINTK(" %02x", prom[i]);
806         }
807         PRINTK("\n");
808         for (i = 0; i < NR_INFO; i++) {
809                 if ((prom[0] == hw_info[i].a0) &&
810                     (prom[2] == hw_info[i].a1) &&
811                     (prom[4] == hw_info[i].a2)) {
812                         PRINTK("matched board %d\n", i);
813                         break;
814                 }
815         }
816         if ((i < NR_INFO) || ((prom[28] == 0x57) && (prom[30] == 0x57))) {
817                 for (j = 0; j < 6; j++)
818                         dev_addr[j] = prom[j<<1];
819                 PRINTK("on exit i is %d/%ld\n", i, NR_INFO);
820                 PRINTK("MAC address is %02x:%02x:%02x:%02x:%02x:%02x\n",
821                        dev_addr[0],dev_addr[1],dev_addr[2],dev_addr[3],dev_addr[4],dev_addr[5]);
822                 return (i < NR_INFO) ? hw_info+i : &default_info;
823         }
824         return NULL;
825 }
826
827 /* U-boot specific routines */
828
829 #define NB 5
830
831 static unsigned char *pbuf = NULL;
832 static int plen[NB];
833 static int nrx = 0;
834
835 static int pkey = -1;
836
837 void uboot_push_packet_len(int len) {
838         PRINTK("pushed len = %d, nrx = %d\n", len, nrx);
839         if (len>=2000) {
840                 printf("NE2000: packet too big\n");
841                 return;
842         }
843         if (nrx >= NB) {
844                 printf("losing packets in rx\n");
845                 return;
846         }
847         plen[nrx] = len;
848         dp83902a_recv(&pbuf[nrx*2000], len);
849         nrx++;
850 }
851
852 void uboot_push_tx_done(int key, int val) {
853         PRINTK("pushed key = %d\n", key);
854         pkey = key;
855 }
856
857 int eth_init(bd_t *bd) {
858         static hw_info_t * r;
859         char ethaddr[20];
860
861         PRINTK("### eth_init\n");
862
863         if (!pbuf) {
864                 pbuf = malloc(NB*2000);
865                 if (!pbuf) {
866                         printf("Cannot allocate rx buffers\n");
867                         return -1;
868                 }
869         }
870
871 #ifdef CONFIG_DRIVER_NE2000_CCR
872         {
873                 volatile unsigned char *p =  (volatile unsigned char *) CONFIG_DRIVER_NE2000_CCR;
874
875                 PRINTK("CCR before is %x\n", *p);
876                 *p = CONFIG_DRIVER_NE2000_VAL;
877                 PRINTK("CCR after is %x\n", *p);
878         }
879 #endif
880
881         nic_base = CONFIG_DRIVER_NE2000_BASE;
882         nic.base = (cyg_uint8 *) CONFIG_DRIVER_NE2000_BASE;
883
884         r = get_prom();
885         if (!r)
886                 return -1;
887
888         sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
889                  dev_addr[0], dev_addr[1],
890                  dev_addr[2], dev_addr[3],
891                  dev_addr[4], dev_addr[5]) ;
892         PRINTK("Set environment from HW MAC addr = \"%s\"\n", ethaddr);
893         setenv ("ethaddr", ethaddr);
894
895
896 #define DP_DATA         0x10
897         nic.data = nic.base + DP_DATA;
898         nic.tx_buf1 = 0x40;
899         nic.tx_buf2 = 0x48;
900         nic.rx_buf_start = 0x50;
901         nic.rx_buf_end = 0x80;
902
903         if (dp83902a_init() == false)
904                 return -1;
905         dp83902a_start(dev_addr);
906         return 0;
907 }
908
909 void eth_halt() {
910
911         PRINTK("### eth_halt\n");
912
913         dp83902a_stop();
914 }
915
916 int eth_rx() {
917         int j, tmo;
918
919         PRINTK("### eth_rx\n");
920
921         tmo = get_timer (0) + TOUT * CFG_HZ;
922         while(1) {
923                 dp83902a_poll();
924                 if (nrx > 0) {
925                         for(j=0; j<nrx; j++) {
926                                 NetReceive(&pbuf[j*2000], plen[j]);
927                         }
928                         nrx = 0;
929                         return 1;
930                 }
931                 if (get_timer (0) >= tmo) {
932                         printf("timeout during rx\n");
933                         return 0;
934                 }
935         }
936         return 0;
937 }
938
939 int eth_send(volatile void *packet, int length) {
940         int tmo;
941
942         PRINTK("### eth_send\n");
943
944         pkey = -1;
945
946         dp83902a_send((unsigned char *) packet, length, 666);
947         tmo = get_timer (0) + TOUT * CFG_HZ;
948         while(1) {
949                 dp83902a_poll();
950                 if (pkey != -1) {
951                         PRINTK("Packet sucesfully sent\n");
952                         return 0;
953                 }
954                 if (get_timer (0) >= tmo) {
955                         printf("transmission error (timoeut)\n");
956                         return 0;
957                 }
958
959         }
960         return 0;
961 }
962
963 #endif