blob: 8275091871d16bddde5d31ce320ed0875747e953 [file] [log] [blame]
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +09001/*
2Ported to U-Boot by Christian Pellegrin <chri@ascensit.com>
3
4Based on sources from the Linux kernel (pcnet_cs.c, 8390.h) and
5eCOS(if_dp83902a.c, if_dp83902a.h). Both of these 2 wonderful world
6are GPL, so this is, of course, GPL.
7
8==========================================================================
9
10dev/if_dp83902a.c
11
12Ethernet device driver for NS DP83902a ethernet controller
13
14==========================================================================
15####ECOSGPLCOPYRIGHTBEGIN####
16-------------------------------------------
17This file is part of eCos, the Embedded Configurable Operating System.
18Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
19
20eCos is free software; you can redistribute it and/or modify it under
21the terms of the GNU General Public License as published by the Free
22Software Foundation; either version 2 or (at your option) any later version.
23
24eCos is distributed in the hope that it will be useful, but WITHOUT ANY
25WARRANTY; without even the implied warranty of MERCHANTABILITY or
26FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
27for more details.
28
29You should have received a copy of the GNU General Public License along
30with eCos; if not, write to the Free Software Foundation, Inc.,
3159 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
32
33As a special exception, if other files instantiate templates or use macros
34or inline functions from this file, or you compile this file and link it
35with other works to produce a work based on this file, this file does not
36by itself cause the resulting work to be covered by the GNU General Public
37License. However the source code for this file must still be made available
38in accordance with section (3) of the GNU General Public License.
39
40This exception does not invalidate any other reasons why a work based on
41this file might be covered by the GNU General Public License.
42
43Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
44at http://sources.redhat.com/ecos/ecos-license/
45-------------------------------------------
46####ECOSGPLCOPYRIGHTEND####
47####BSDCOPYRIGHTBEGIN####
48
49-------------------------------------------
50
51Portions of this software may have been derived from OpenBSD or other sources,
52and are covered by the appropriate copyright disclaimers included herein.
53
54-------------------------------------------
55
56####BSDCOPYRIGHTEND####
57==========================================================================
58#####DESCRIPTIONBEGIN####
59
60Author(s): gthomas
61Contributors: gthomas, jskov, rsandifo
62Date: 2001-06-13
63Purpose:
64Description:
65
66FIXME: Will fail if pinged with large packets (1520 bytes)
67Add promisc config
68Add SNMP
69
70####DESCRIPTIONEND####
71
72==========================================================================
73*/
74
75#include <common.h>
76#include <command.h>
77#include <net.h>
78#include <malloc.h>
Wolfgang Denk4eaf1722011-12-08 22:28:57 +010079#include <linux/compiler.h>
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +090080
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +090081/* forward definition of function used for the uboot interface */
82void uboot_push_packet_len(int len);
83void uboot_push_tx_done(int key, int val);
84
85/* NE2000 base header file */
86#include "ne2000_base.h"
87
88#if defined(CONFIG_DRIVER_AX88796L)
89/* AX88796L support */
90#include "ax88796.h"
91#else
92/* Basic NE2000 chip support */
93#include "ne2000.h"
94#endif
95
96static dp83902a_priv_data_t nic; /* just one instance of the card supported */
97
Bernhard Kaindld0201692011-10-20 10:56:59 +000098/**
99 * This function reads the MAC address from the serial EEPROM,
100 * used if PROM read fails. Does nothing for ax88796 chips (sh boards)
101 */
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900102static bool
Bernhard Kaindld0201692011-10-20 10:56:59 +0000103dp83902a_init(unsigned char *enetaddr)
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900104{
105 dp83902a_priv_data_t *dp = &nic;
106 u8* base;
107#if defined(NE2000_BASIC_INIT)
108 int i;
109#endif
110
111 DEBUG_FUNCTION();
112
113 base = dp->base;
114 if (!base)
115 return false; /* No device found */
116
117 DEBUG_LINE();
118
119#if defined(NE2000_BASIC_INIT)
120 /* AX88796L doesn't need */
121 /* Prepare ESA */
122 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1); /* Select page 1 */
123 /* Use the address from the serial EEPROM */
124 for (i = 0; i < 6; i++)
125 DP_IN(base, DP_P1_PAR0+i, dp->esa[i]);
126 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0); /* Select page 0 */
127
128 printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n",
129 "eeprom",
130 dp->esa[0],
131 dp->esa[1],
132 dp->esa[2],
133 dp->esa[3],
134 dp->esa[4],
135 dp->esa[5] );
136
Bernhard Kaindld0201692011-10-20 10:56:59 +0000137 memcpy(enetaddr, dp->esa, 6); /* Use MAC from serial EEPROM */
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900138#endif /* NE2000_BASIC_INIT */
139 return true;
140}
141
142static void
143dp83902a_stop(void)
144{
145 dp83902a_priv_data_t *dp = &nic;
146 u8 *base = dp->base;
147
148 DEBUG_FUNCTION();
149
150 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
151 DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */
152 DP_OUT(base, DP_IMR, 0x00); /* Disable all interrupts */
153
154 dp->running = false;
155}
156
157/*
158 * This function is called to "start up" the interface. It may be called
159 * multiple times, even when the hardware is already running. It will be
160 * called whenever something "hardware oriented" changes and should leave
161 * the hardware ready to send/receive packets.
162 */
163static void
164dp83902a_start(u8 * enaddr)
165{
166 dp83902a_priv_data_t *dp = &nic;
167 u8 *base = dp->base;
168 int i;
169
Bernhard Kaindld0201692011-10-20 10:56:59 +0000170 debug("The MAC is %pM\n", enaddr);
171
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900172 DEBUG_FUNCTION();
173
174 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
175 DP_OUT(base, DP_DCR, DP_DCR_INIT);
176 DP_OUT(base, DP_RBCH, 0); /* Remote byte count */
177 DP_OUT(base, DP_RBCL, 0);
178 DP_OUT(base, DP_RCR, DP_RCR_MON); /* Accept no packets */
179 DP_OUT(base, DP_TCR, DP_TCR_LOCAL); /* Transmitter [virtually] off */
180 DP_OUT(base, DP_TPSR, dp->tx_buf1); /* Transmitter start page */
181 dp->tx1 = dp->tx2 = 0;
182 dp->tx_next = dp->tx_buf1;
183 dp->tx_started = false;
184 dp->running = true;
185 DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
186 DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1); /* Receive ring boundary */
187 DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
188 dp->rx_next = dp->rx_buf_start - 1;
189 dp->running = true;
190 DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */
191 DP_OUT(base, DP_IMR, DP_IMR_All); /* Enable all interrupts */
192 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP); /* Select page 1 */
193 DP_OUT(base, DP_P1_CURP, dp->rx_buf_start); /* Current page - next free page for Rx */
194 dp->running = true;
195 for (i = 0; i < ETHER_ADDR_LEN; i++) {
196 /* FIXME */
197 /*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) +
198 * 0x1400)) = enaddr[i];*/
199 DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
200 }
201 /* Enable and start device */
202 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
203 DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
204 DP_OUT(base, DP_RCR, DP_RCR_AB); /* Accept broadcast, no errors, no multicast */
205 dp->running = true;
206}
207
208/*
209 * This routine is called to start the transmitter. It is split out from the
210 * data handling routine so it may be called either when data becomes first
211 * available or when an Tx interrupt occurs
212 */
213
214static void
215dp83902a_start_xmit(int start_page, int len)
216{
217 dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic;
218 u8 *base = dp->base;
219
220 DEBUG_FUNCTION();
221
222#if DEBUG & 1
223 printf("Tx pkt %d len %d\n", start_page, len);
224 if (dp->tx_started)
225 printf("TX already started?!?\n");
226#endif
227
228 DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE));
229 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
230 DP_OUT(base, DP_TBCL, len & 0xFF);
231 DP_OUT(base, DP_TBCH, len >> 8);
232 DP_OUT(base, DP_TPSR, start_page);
233 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
234
235 dp->tx_started = true;
236}
237
238/*
239 * This routine is called to send data to the hardware. It is known a-priori
240 * that there is free buffer space (dp->tx_next).
241 */
242static void
243dp83902a_send(u8 *data, int total_len, u32 key)
244{
245 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
246 u8 *base = dp->base;
247 int len, start_page, pkt_len, i, isr;
248#if DEBUG & 4
249 int dx;
250#endif
251
252 DEBUG_FUNCTION();
253
254 len = pkt_len = total_len;
255 if (pkt_len < IEEE_8023_MIN_FRAME)
256 pkt_len = IEEE_8023_MIN_FRAME;
257
258 start_page = dp->tx_next;
259 if (dp->tx_next == dp->tx_buf1) {
260 dp->tx1 = start_page;
261 dp->tx1_len = pkt_len;
262 dp->tx1_key = key;
263 dp->tx_next = dp->tx_buf2;
264 } else {
265 dp->tx2 = start_page;
266 dp->tx2_len = pkt_len;
267 dp->tx2_key = key;
268 dp->tx_next = dp->tx_buf1;
269 }
270
271#if DEBUG & 5
272 printf("TX prep page %d len %d\n", start_page, pkt_len);
273#endif
274
275 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
276 {
277 /*
278 * Dummy read. The manual sez something slightly different,
279 * but the code is extended a bit to do what Hitachi's monitor
280 * does (i.e., also read data).
281 */
282
Wolfgang Denk4eaf1722011-12-08 22:28:57 +0100283 __maybe_unused u16 tmp;
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900284 int len = 1;
285
286 DP_OUT(base, DP_RSAL, 0x100 - len);
287 DP_OUT(base, DP_RSAH, (start_page - 1) & 0xff);
288 DP_OUT(base, DP_RBCL, len);
289 DP_OUT(base, DP_RBCH, 0);
290 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
291 DP_IN_DATA(dp->data, tmp);
292 }
293
294#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
295 /*
296 * Stall for a bit before continuing to work around random data
297 * corruption problems on some platforms.
298 */
299 CYGACC_CALL_IF_DELAY_US(1);
300#endif
301
302 /* Send data to device buffer(s) */
303 DP_OUT(base, DP_RSAL, 0);
304 DP_OUT(base, DP_RSAH, start_page);
305 DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
306 DP_OUT(base, DP_RBCH, pkt_len >> 8);
307 DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
308
309 /* Put data into buffer */
310#if DEBUG & 4
311 printf(" sg buf %08lx len %08x\n ", (u32)data, len);
312 dx = 0;
313#endif
314 while (len > 0) {
315#if DEBUG & 4
316 printf(" %02x", *data);
317 if (0 == (++dx % 16)) printf("\n ");
318#endif
319
320 DP_OUT_DATA(dp->data, *data++);
321 len--;
322 }
323#if DEBUG & 4
324 printf("\n");
325#endif
326 if (total_len < pkt_len) {
327#if DEBUG & 4
328 printf(" + %d bytes of padding\n", pkt_len - total_len);
329#endif
330 /* Padding to 802.3 length was required */
331 for (i = total_len; i < pkt_len;) {
332 i++;
333 DP_OUT_DATA(dp->data, 0);
334 }
335 }
336
337#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
338 /*
339 * After last data write, delay for a bit before accessing the
340 * device again, or we may get random data corruption in the last
341 * datum (on some platforms).
342 */
343 CYGACC_CALL_IF_DELAY_US(1);
344#endif
345
346 /* Wait for DMA to complete */
347 do {
348 DP_IN(base, DP_ISR, isr);
349 } while ((isr & DP_ISR_RDC) == 0);
350
351 /* Then disable DMA */
352 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
353
354 /* Start transmit if not already going */
355 if (!dp->tx_started) {
356 if (start_page == dp->tx1) {
357 dp->tx_int = 1; /* Expecting interrupt from BUF1 */
358 } else {
359 dp->tx_int = 2; /* Expecting interrupt from BUF2 */
360 }
361 dp83902a_start_xmit(start_page, pkt_len);
362 }
363}
364
365/*
366 * This function is called when a packet has been received. It's job is
367 * to prepare to unload the packet from the hardware. Once the length of
368 * the packet is known, the upper layer of the driver can be told. When
369 * the upper layer is ready to unload the packet, the internal function
370 * 'dp83902a_recv' will be called to actually fetch it from the hardware.
371 */
372static void
373dp83902a_RxEvent(void)
374{
375 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
376 u8 *base = dp->base;
Wolfgang Denk4eaf1722011-12-08 22:28:57 +0100377 __maybe_unused u8 rsr;
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900378 u8 rcv_hdr[4];
379 int i, len, pkt, cur;
380
381 DEBUG_FUNCTION();
382
383 DP_IN(base, DP_RSR, rsr);
384 while (true) {
385 /* Read incoming packet header */
386 DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
387 DP_IN(base, DP_P1_CURP, cur);
388 DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
389 DP_IN(base, DP_BNDRY, pkt);
390
391 pkt += 1;
392 if (pkt == dp->rx_buf_end)
393 pkt = dp->rx_buf_start;
394
395 if (pkt == cur) {
396 break;
397 }
398 DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
399 DP_OUT(base, DP_RBCH, 0);
400 DP_OUT(base, DP_RSAL, 0);
401 DP_OUT(base, DP_RSAH, pkt);
402 if (dp->rx_next == pkt) {
403 if (cur == dp->rx_buf_start)
404 DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
405 else
406 DP_OUT(base, DP_BNDRY, cur - 1); /* Update pointer */
407 return;
408 }
409 dp->rx_next = pkt;
410 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
411 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
412#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
413 CYGACC_CALL_IF_DELAY_US(10);
414#endif
415
416 /* read header (get data size)*/
417 for (i = 0; i < sizeof(rcv_hdr);) {
418 DP_IN_DATA(dp->data, rcv_hdr[i++]);
419 }
420
421#if DEBUG & 5
422 printf("rx hdr %02x %02x %02x %02x\n",
423 rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
424#endif
425 len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
426
427 /* data read */
428 uboot_push_packet_len(len);
429
430 if (rcv_hdr[1] == dp->rx_buf_start)
431 DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
432 else
433 DP_OUT(base, DP_BNDRY, rcv_hdr[1] - 1); /* Update pointer */
434 }
435}
436
437/*
438 * This function is called as a result of the "eth_drv_recv()" call above.
439 * It's job is to actually fetch data for a packet from the hardware once
440 * memory buffers have been allocated for the packet. Note that the buffers
441 * may come in pieces, using a scatter-gather list. This allows for more
442 * efficient processing in the upper layers of the stack.
443 */
444static void
445dp83902a_recv(u8 *data, int len)
446{
447 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
448 u8 *base = dp->base;
449 int i, mlen;
450 u8 saved_char = 0;
451 bool saved;
452#if DEBUG & 4
453 int dx;
454#endif
455
456 DEBUG_FUNCTION();
457
458#if DEBUG & 5
459 printf("Rx packet %d length %d\n", dp->rx_next, len);
460#endif
461
462 /* Read incoming packet data */
463 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
464 DP_OUT(base, DP_RBCL, len & 0xFF);
465 DP_OUT(base, DP_RBCH, len >> 8);
466 DP_OUT(base, DP_RSAL, 4); /* Past header */
467 DP_OUT(base, DP_RSAH, dp->rx_next);
468 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
469 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
470#ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
471 CYGACC_CALL_IF_DELAY_US(10);
472#endif
473
474 saved = false;
475 for (i = 0; i < 1; i++) {
476 if (data) {
477 mlen = len;
478#if DEBUG & 4
479 printf(" sg buf %08lx len %08x \n", (u32) data, mlen);
480 dx = 0;
481#endif
482 while (0 < mlen) {
483 /* Saved byte from previous loop? */
484 if (saved) {
485 *data++ = saved_char;
486 mlen--;
487 saved = false;
488 continue;
489 }
490
491 {
492 u8 tmp;
493 DP_IN_DATA(dp->data, tmp);
494#if DEBUG & 4
495 printf(" %02x", tmp);
496 if (0 == (++dx % 16)) printf("\n ");
497#endif
498 *data++ = tmp;;
499 mlen--;
500 }
501 }
502#if DEBUG & 4
503 printf("\n");
504#endif
505 }
506 }
507}
508
509static void
510dp83902a_TxEvent(void)
511{
512 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
513 u8 *base = dp->base;
Wolfgang Denk4eaf1722011-12-08 22:28:57 +0100514 __maybe_unused u8 tsr;
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900515 u32 key;
516
517 DEBUG_FUNCTION();
518
519 DP_IN(base, DP_TSR, tsr);
520 if (dp->tx_int == 1) {
521 key = dp->tx1_key;
522 dp->tx1 = 0;
523 } else {
524 key = dp->tx2_key;
525 dp->tx2 = 0;
526 }
527 /* Start next packet if one is ready */
528 dp->tx_started = false;
529 if (dp->tx1) {
530 dp83902a_start_xmit(dp->tx1, dp->tx1_len);
531 dp->tx_int = 1;
532 } else if (dp->tx2) {
533 dp83902a_start_xmit(dp->tx2, dp->tx2_len);
534 dp->tx_int = 2;
535 } else {
536 dp->tx_int = 0;
537 }
538 /* Tell higher level we sent this packet */
539 uboot_push_tx_done(key, 0);
540}
541
542/*
543 * Read the tally counters to clear them. Called in response to a CNT
544 * interrupt.
545 */
546static void
547dp83902a_ClearCounters(void)
548{
549 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
550 u8 *base = dp->base;
Wolfgang Denk4eaf1722011-12-08 22:28:57 +0100551 __maybe_unused u8 cnt1, cnt2, cnt3;
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900552
553 DP_IN(base, DP_FER, cnt1);
554 DP_IN(base, DP_CER, cnt2);
555 DP_IN(base, DP_MISSED, cnt3);
556 DP_OUT(base, DP_ISR, DP_ISR_CNT);
557}
558
559/*
560 * Deal with an overflow condition. This code follows the procedure set
561 * out in section 7.0 of the datasheet.
562 */
563static void
564dp83902a_Overflow(void)
565{
566 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *)&nic;
567 u8 *base = dp->base;
568 u8 isr;
569
570 /* Issue a stop command and wait 1.6ms for it to complete. */
571 DP_OUT(base, DP_CR, DP_CR_STOP | DP_CR_NODMA);
572 CYGACC_CALL_IF_DELAY_US(1600);
573
574 /* Clear the remote byte counter registers. */
575 DP_OUT(base, DP_RBCL, 0);
576 DP_OUT(base, DP_RBCH, 0);
577
578 /* Enter loopback mode while we clear the buffer. */
579 DP_OUT(base, DP_TCR, DP_TCR_LOCAL);
580 DP_OUT(base, DP_CR, DP_CR_START | DP_CR_NODMA);
581
582 /*
583 * Read in as many packets as we can and acknowledge any and receive
584 * interrupts. Since the buffer has overflowed, a receive event of
585 * some kind will have occured.
586 */
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 /*
595 * If a transmit command was issued, but no transmit event has occured,
596 * restart it here.
597 */
598 DP_IN(base, DP_ISR, isr);
599 if (dp->tx_started && !(isr & (DP_ISR_TxP|DP_ISR_TxE))) {
600 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
601 }
602}
603
604static void
605dp83902a_poll(void)
606{
607 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
608 u8 *base = dp->base;
609 u8 isr;
610
611 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0 | DP_CR_START);
612 DP_IN(base, DP_ISR, isr);
613 while (0 != isr) {
614 /*
615 * The CNT interrupt triggers when the MSB of one of the error
616 * counters is set. We don't much care about these counters, but
617 * we should read their values to reset them.
618 */
619 if (isr & DP_ISR_CNT) {
620 dp83902a_ClearCounters();
621 }
622 /*
623 * Check for overflow. It's a special case, since there's a
624 * particular procedure that must be followed to get back into
625 * a running state.a
626 */
627 if (isr & DP_ISR_OFLW) {
628 dp83902a_Overflow();
629 } else {
630 /*
631 * Other kinds of interrupts can be acknowledged simply by
632 * clearing the relevant bits of the ISR. Do that now, then
633 * handle the interrupts we care about.
634 */
635 DP_OUT(base, DP_ISR, isr); /* Clear set bits */
636 if (!dp->running) break; /* Is this necessary? */
637 /*
638 * Check for tx_started on TX event since these may happen
639 * spuriously it seems.
640 */
641 if (isr & (DP_ISR_TxP|DP_ISR_TxE) && dp->tx_started) {
642 dp83902a_TxEvent();
643 }
644 if (isr & (DP_ISR_RxP|DP_ISR_RxE)) {
645 dp83902a_RxEvent();
646 }
647 }
648 DP_IN(base, DP_ISR, isr);
649 }
650}
651
652
653/* U-boot specific routines */
654static u8 *pbuf = NULL;
655
656static int pkey = -1;
657static int initialized = 0;
658
659void uboot_push_packet_len(int len) {
660 PRINTK("pushed len = %d\n", len);
661 if (len >= 2000) {
662 printf("NE2000: packet too big\n");
663 return;
664 }
665 dp83902a_recv(&pbuf[0], len);
666
667 /*Just pass it to the upper layer*/
668 NetReceive(&pbuf[0], len);
669}
670
671void uboot_push_tx_done(int key, int val) {
672 PRINTK("pushed key = %d\n", key);
673 pkey = key;
674}
675
Bernhard Kaindld0201692011-10-20 10:56:59 +0000676/**
677 * Setup the driver and init MAC address according to doc/README.enetaddr
678 * Called by ne2k_register() before registering the driver @eth layer
679 *
680 * @param struct ethdevice of this instance of the driver for dev->enetaddr
681 * @return 0 on success, -1 on error (causing caller to print error msg)
682 */
683static int ne2k_setup_driver(struct eth_device *dev)
684{
685 PRINTK("### ne2k_setup_driver\n");
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900686
687 if (!pbuf) {
688 pbuf = malloc(2000);
689 if (!pbuf) {
690 printf("Cannot allocate rx buffer\n");
691 return -1;
692 }
693 }
694
695#ifdef CONFIG_DRIVER_NE2000_CCR
696 {
697 vu_char *p = (vu_char *) CONFIG_DRIVER_NE2000_CCR;
698
699 PRINTK("CCR before is %x\n", *p);
700 *p = CONFIG_DRIVER_NE2000_VAL;
701 PRINTK("CCR after is %x\n", *p);
702 }
703#endif
704
705 nic.base = (u8 *) CONFIG_DRIVER_NE2000_BASE;
706
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900707 nic.data = nic.base + DP_DATA;
708 nic.tx_buf1 = START_PG;
709 nic.tx_buf2 = START_PG2;
710 nic.rx_buf_start = RX_START;
711 nic.rx_buf_end = RX_END;
712
Bernhard Kaindld0201692011-10-20 10:56:59 +0000713 /*
714 * According to doc/README.enetaddr, drivers shall give priority
715 * to the MAC address value in the environment, so we do not read
716 * it from the prom or eeprom if it is specified in the environment.
717 */
718 if (!eth_getenv_enetaddr("ethaddr", dev->enetaddr)) {
719 /* If the MAC address is not in the environment, get it: */
720 if (!get_prom(dev->enetaddr, nic.base)) /* get MAC from prom */
721 dp83902a_init(dev->enetaddr); /* fallback: seeprom */
722 /* And write it into the environment otherwise eth_write_hwaddr
723 * returns -1 due to eth_getenv_enetaddr_by_index() failing,
724 * and this causes "Warning: failed to set MAC address", and
725 * cmd_bdinfo has no ethaddr value which it can show: */
726 eth_setenv_enetaddr("ethaddr", dev->enetaddr);
727 }
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900728 return 0;
729}
730
Bernhard Kaindld0201692011-10-20 10:56:59 +0000731static int ne2k_init(struct eth_device *dev, bd_t *bd)
732{
733 dp83902a_start(dev->enetaddr);
734 initialized = 1;
735 return 0;
736}
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900737
Bernhard Kaindld0201692011-10-20 10:56:59 +0000738static void ne2k_halt(struct eth_device *dev)
739{
740 debug("### ne2k_halt\n");
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900741 if(initialized)
742 dp83902a_stop();
743 initialized = 0;
744}
745
Bernhard Kaindld0201692011-10-20 10:56:59 +0000746static int ne2k_recv(struct eth_device *dev)
747{
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900748 dp83902a_poll();
749 return 1;
750}
751
Bernhard Kaindld0201692011-10-20 10:56:59 +0000752static int ne2k_send(struct eth_device *dev, volatile void *packet, int length)
753{
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900754 int tmo;
755
Bernhard Kaindld0201692011-10-20 10:56:59 +0000756 debug("### ne2k_send\n");
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900757
758 pkey = -1;
759
760 dp83902a_send((u8 *) packet, length, 666);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200761 tmo = get_timer (0) + TOUT * CONFIG_SYS_HZ;
Nobuhiro Iwamatsu702c85b2008-09-30 15:02:53 +0900762 while(1) {
763 dp83902a_poll();
764 if (pkey != -1) {
765 PRINTK("Packet sucesfully sent\n");
766 return 0;
767 }
768 if (get_timer (0) >= tmo) {
769 printf("transmission error (timoeut)\n");
770 return 0;
771 }
772
773 }
774 return 0;
775}
Bernhard Kaindld0201692011-10-20 10:56:59 +0000776
777/**
778 * Setup the driver for use and register it with the eth layer
779 * @return 0 on success, -1 on error (causing caller to print error msg)
780 */
781int ne2k_register(void)
782{
783 struct eth_device *dev;
784
785 dev = calloc(sizeof(*dev), 1);
786 if (dev == NULL)
787 return -1;
788
789 if (ne2k_setup_driver(dev))
790 return -1;
791
792 dev->init = ne2k_init;
793 dev->halt = ne2k_halt;
794 dev->send = ne2k_send;
795 dev->recv = ne2k_recv;
796
797 sprintf(dev->name, "NE2000");
798
799 return eth_register(dev);
800}