2 Ported to U-Boot by Christian Pellegrin <chri@ascensit.com>
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.
9 ==========================================================================
13 Ethernet device driver for NS DP83902a ethernet controller
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.
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.
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
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.
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.
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.
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####
50 -------------------------------------------
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.
55 -------------------------------------------
57 ####BSDCOPYRIGHTEND####
58 ==========================================================================
59 #####DESCRIPTIONBEGIN####
62 Contributors: gthomas, jskov, rsandifo
67 FIXME: Will fail if pinged with large packets (1520 bytes)
71 ####DESCRIPTIONEND####
74 ==========================================================================
83 #define mdelay(n) udelay((n)*1000)
84 /* forward definition of function used for the uboot interface */
85 void uboot_push_packet_len(int len);
86 void uboot_push_tx_done(int key, int val);
89 ------------------------------------------------------------------------
93 0 disables all debug output
94 1 for process debug output
95 2 for added data IO output: get_reg, put_reg
96 4 for packet allocation/free output
97 8 for only startup status, so we can tell we're installed OK
103 #define DEBUG_FUNCTION() do { printf("%s\n", __FUNCTION__); } while (0)
104 #define DEBUG_LINE() do { printf("%d\n", __LINE__); } while (0)
105 #define PRINTK(args...) printf(args)
107 #define DEBUG_FUNCTION() do {} while(0)
108 #define DEBUG_LINE() do {} while(0)
109 #define PRINTK(args...)
112 /* NE2000 base header file */
113 #include "ne2000_base.h"
115 #if defined(CONFIG_DRIVER_AX88796L)
116 /* AX88796L support */
119 /* Basic NE2000 chip support */
123 static dp83902a_priv_data_t nic; /* just one instance of the card supported */
128 dp83902a_priv_data_t *dp = &nic;
134 if (!base) return false; /* No device found */
138 #if defined(NE2000_BASIC_INIT)
139 /* AX88796L doesn't need */
141 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1); /* Select page 1 */
142 /* Use the address from the serial EEPROM */
143 for (i = 0; i < 6; i++)
144 DP_IN(base, DP_P1_PAR0+i, dp->esa[i]);
145 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0); /* Select page 0 */
147 printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n",
156 #endif /* NE2000_BASIC_INIT */
163 dp83902a_priv_data_t *dp = &nic;
168 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
169 DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */
170 DP_OUT(base, DP_IMR, 0x00); /* Disable all interrupts */
176 This function is called to "start up" the interface. It may be called
177 multiple times, even when the hardware is already running. It will be
178 called whenever something "hardware oriented" changes and should leave
179 the hardware ready to send/receive packets.
182 dp83902a_start(u8 * enaddr)
184 dp83902a_priv_data_t *dp = &nic;
190 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
191 DP_OUT(base, DP_DCR, DP_DCR_INIT);
192 DP_OUT(base, DP_RBCH, 0); /* Remote byte count */
193 DP_OUT(base, DP_RBCL, 0);
194 DP_OUT(base, DP_RCR, DP_RCR_MON); /* Accept no packets */
195 DP_OUT(base, DP_TCR, DP_TCR_LOCAL); /* Transmitter [virtually] off */
196 DP_OUT(base, DP_TPSR, dp->tx_buf1); /* Transmitter start page */
197 dp->tx1 = dp->tx2 = 0;
198 dp->tx_next = dp->tx_buf1;
199 dp->tx_started = false;
201 DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
202 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1); /* Receive ring boundary */
203 DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
204 dp->rx_next = dp->rx_buf_start-1;
206 DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */
207 DP_OUT(base, DP_IMR, DP_IMR_All); /* Enable all interrupts */
208 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP); /* Select page 1 */
209 DP_OUT(base, DP_P1_CURP, dp->rx_buf_start); /* Current page - next free page for Rx */
211 for (i = 0; i < ETHER_ADDR_LEN; i++) {
213 //*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) + 0x1400)) = enaddr[i];
214 DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
216 /* Enable and start device */
217 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
218 DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
219 DP_OUT(base, DP_RCR, DP_RCR_AB); /* Accept broadcast, no errors, no multicast */
225 This routine is called to start the transmitter. It is split out from the
226 data handling routine so it may be called either when data becomes first
227 available or when an Tx interrupt occurs
231 dp83902a_start_xmit(int start_page, int len)
233 dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic;
239 printf("Tx pkt %d len %d\n", start_page, len);
241 printf("TX already started?!?\n");
244 DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE));
245 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
246 DP_OUT(base, DP_TBCL, len & 0xFF);
247 DP_OUT(base, DP_TBCH, len >> 8);
248 DP_OUT(base, DP_TPSR, start_page);
249 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
251 dp->tx_started = true;
255 This routine is called to send data to the hardware. It is known a-priori
256 that there is free buffer space (dp->tx_next).
259 dp83902a_send(u8 *data, int total_len, u32 key)
261 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
263 int len, start_page, pkt_len, i, isr;
270 len = pkt_len = total_len;
271 if (pkt_len < IEEE_8023_MIN_FRAME) pkt_len = IEEE_8023_MIN_FRAME;
273 start_page = dp->tx_next;
274 if (dp->tx_next == dp->tx_buf1) {
275 dp->tx1 = start_page;
276 dp->tx1_len = pkt_len;
278 dp->tx_next = dp->tx_buf2;
280 dp->tx2 = start_page;
281 dp->tx2_len = pkt_len;
283 dp->tx_next = dp->tx_buf1;
287 printf("TX prep page %d len %d\n", start_page, pkt_len);
290 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
292 /* Dummy read. The manual sez something slightly different, */
293 /* but the code is extended a bit to do what Hitachi's monitor */
294 /* does (i.e., also read data). */
299 DP_OUT(base, DP_RSAL, 0x100-len);
300 DP_OUT(base, DP_RSAH, (start_page-1) & 0xff);
301 DP_OUT(base, DP_RBCL, len);
302 DP_OUT(base, DP_RBCH, 0);
303 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
304 DP_IN_DATA(dp->data, tmp);
307 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
308 /* Stall for a bit before continuing to work around random data */
309 /* corruption problems on some platforms. */
310 CYGACC_CALL_IF_DELAY_US(1);
313 /* Send data to device buffer(s) */
314 DP_OUT(base, DP_RSAL, 0);
315 DP_OUT(base, DP_RSAH, start_page);
316 DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
317 DP_OUT(base, DP_RBCH, pkt_len >> 8);
318 DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
320 /* Put data into buffer */
322 printf(" sg buf %08lx len %08x\n ", (u32)data, len);
327 printf(" %02x", *data);
328 if (0 == (++dx % 16)) printf("\n ");
331 DP_OUT_DATA(dp->data, *data++);
337 if (total_len < pkt_len) {
339 printf(" + %d bytes of padding\n", pkt_len - total_len);
341 /* Padding to 802.3 length was required */
342 for (i = total_len; i < pkt_len;) {
344 DP_OUT_DATA(dp->data, 0);
348 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
349 /* After last data write, delay for a bit before accessing the */
350 /* device again, or we may get random data corruption in the last */
351 /* datum (on some platforms). */
352 CYGACC_CALL_IF_DELAY_US(1);
355 /* Wait for DMA to complete */
357 DP_IN(base, DP_ISR, isr);
358 } while ((isr & DP_ISR_RDC) == 0);
360 /* Then disable DMA */
361 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
363 /* Start transmit if not already going */
364 if (!dp->tx_started) {
365 if (start_page == dp->tx1) {
366 dp->tx_int = 1; /* Expecting interrupt from BUF1 */
368 dp->tx_int = 2; /* Expecting interrupt from BUF2 */
370 dp83902a_start_xmit(start_page, pkt_len);
375 This function is called when a packet has been received. It's job is
376 to prepare to unload the packet from the hardware. Once the length of
377 the packet is known, the upper layer of the driver can be told. When
378 the upper layer is ready to unload the packet, the internal function
379 'dp83902a_recv' will be called to actually fetch it from the hardware.
382 dp83902a_RxEvent(void)
384 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
388 int i, len, pkt, cur;
392 DP_IN(base, DP_RSR, rsr);
394 /* Read incoming packet header */
395 DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
396 DP_IN(base, DP_P1_CURP, cur);
397 DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
398 DP_IN(base, DP_BNDRY, pkt);
401 if (pkt == dp->rx_buf_end)
402 pkt = dp->rx_buf_start;
407 DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
408 DP_OUT(base, DP_RBCH, 0);
409 DP_OUT(base, DP_RSAL, 0);
410 DP_OUT(base, DP_RSAH, pkt);
411 if (dp->rx_next == pkt) {
412 if (cur == dp->rx_buf_start)
413 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1);
415 DP_OUT(base, DP_BNDRY, cur-1); /* Update pointer */
419 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
420 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
421 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
422 CYGACC_CALL_IF_DELAY_US(10);
425 /* read header (get data size)*/
426 for (i = 0; i < sizeof(rcv_hdr);) {
427 DP_IN_DATA(dp->data, rcv_hdr[i++]);
431 printf("rx hdr %02x %02x %02x %02x\n",
432 rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
434 len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
437 uboot_push_packet_len(len);
439 if (rcv_hdr[1] == dp->rx_buf_start)
440 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1);
442 DP_OUT(base, DP_BNDRY, rcv_hdr[1]-1); /* Update pointer */
447 This function is called as a result of the "eth_drv_recv()" call above.
448 It's job is to actually fetch data for a packet from the hardware once
449 memory buffers have been allocated for the packet. Note that the buffers
450 may come in pieces, using a scatter-gather list. This allows for more
451 efficient processing in the upper layers of the stack.
454 dp83902a_recv(u8 *data, int len)
456 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
468 printf("Rx packet %d length %d\n", dp->rx_next, len);
471 /* Read incoming packet data */
472 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
473 DP_OUT(base, DP_RBCL, len & 0xFF);
474 DP_OUT(base, DP_RBCH, len >> 8);
475 DP_OUT(base, DP_RSAL, 4); /* Past header */
476 DP_OUT(base, DP_RSAH, dp->rx_next);
477 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
478 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
479 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
480 CYGACC_CALL_IF_DELAY_US(10);
484 for (i = 0; i < 1; i++) {
488 printf(" sg buf %08lx len %08x \n", (u32) data, mlen);
492 /* Saved byte from previous loop? */
494 *data++ = saved_char;
502 DP_IN_DATA(dp->data, tmp);
504 printf(" %02x", tmp);
505 if (0 == (++dx % 16)) printf("\n ");
519 dp83902a_TxEvent(void)
521 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
528 DP_IN(base, DP_TSR, tsr);
529 if (dp->tx_int == 1) {
536 /* Start next packet if one is ready */
537 dp->tx_started = false;
539 dp83902a_start_xmit(dp->tx1, dp->tx1_len);
541 } else if (dp->tx2) {
542 dp83902a_start_xmit(dp->tx2, dp->tx2_len);
547 /* Tell higher level we sent this packet */
548 uboot_push_tx_done(key, 0);
551 /* Read the tally counters to clear them. Called in response to a CNT */
554 dp83902a_ClearCounters(void)
556 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
560 DP_IN(base, DP_FER, cnt1);
561 DP_IN(base, DP_CER, cnt2);
562 DP_IN(base, DP_MISSED, cnt3);
563 DP_OUT(base, DP_ISR, DP_ISR_CNT);
566 /* Deal with an overflow condition. This code follows the procedure set */
567 /* out in section 7.0 of the datasheet. */
569 dp83902a_Overflow(void)
571 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *)&nic;
575 /* Issue a stop command and wait 1.6ms for it to complete. */
576 DP_OUT(base, DP_CR, DP_CR_STOP | DP_CR_NODMA);
577 CYGACC_CALL_IF_DELAY_US(1600);
579 /* Clear the remote byte counter registers. */
580 DP_OUT(base, DP_RBCL, 0);
581 DP_OUT(base, DP_RBCH, 0);
583 /* Enter loopback mode while we clear the buffer. */
584 DP_OUT(base, DP_TCR, DP_TCR_LOCAL);
585 DP_OUT(base, DP_CR, DP_CR_START | DP_CR_NODMA);
587 /* Read in as many packets as we can and acknowledge any and receive */
588 /* interrupts. Since the buffer has overflowed, a receive event of */
589 /* some kind will have occured. */
591 DP_OUT(base, DP_ISR, DP_ISR_RxP|DP_ISR_RxE);
593 /* Clear the overflow condition and leave loopback mode. */
594 DP_OUT(base, DP_ISR, DP_ISR_OFLW);
595 DP_OUT(base, DP_TCR, DP_TCR_NORMAL);
597 /* If a transmit command was issued, but no transmit event has occured, */
598 /* restart it here. */
599 DP_IN(base, DP_ISR, isr);
600 if (dp->tx_started && !(isr & (DP_ISR_TxP|DP_ISR_TxE))) {
601 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
608 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
612 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0 | DP_CR_START);
613 DP_IN(base, DP_ISR, isr);
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 if (isr & DP_ISR_CNT) {
619 dp83902a_ClearCounters();
621 /* Check for overflow. It's a special case, since there's a */
622 /* particular procedure that must be followed to get back into */
623 /* a running state.a */
624 if (isr & DP_ISR_OFLW) {
627 /* Other kinds of interrupts can be acknowledged simply by */
628 /* clearing the relevant bits of the ISR. Do that now, then */
629 /* handle the interrupts we care about. */
630 DP_OUT(base, DP_ISR, isr); /* Clear set bits */
631 if (!dp->running) break; /* Is this necessary? */
632 /* Check for tx_started on TX event since these may happen */
633 /* spuriously it seems. */
634 if (isr & (DP_ISR_TxP|DP_ISR_TxE) && dp->tx_started) {
637 if (isr & (DP_ISR_RxP|DP_ISR_RxE)) {
641 DP_IN(base, DP_ISR, isr);
645 /* find prom (taken from pc_net_cs.c from Linux) */
649 typedef struct hw_info_t {
655 #define DELAY_OUTPUT 0x01
656 #define HAS_MISC_REG 0x02
657 #define USE_BIG_BUF 0x04
658 #define HAS_IBM_MISC 0x08
659 #define IS_DL10019 0x10
660 #define IS_DL10022 0x20
662 #define USE_SHMEM 0x80 /* autodetected */
664 #define AM79C9XX_HOME_PHY 0x00006B90 /* HomePNA PHY */
665 #define AM79C9XX_ETH_PHY 0x00006B70 /* 10baseT PHY */
666 #define MII_PHYID_REV_MASK 0xfffffff0
667 #define MII_PHYID_REG1 0x02
668 #define MII_PHYID_REG2 0x03
670 static hw_info_t hw_info[] = {
671 { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT },
672 { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
673 { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
674 { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94,
675 DELAY_OUTPUT | HAS_IBM_MISC },
676 { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 },
677 { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 },
678 { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 },
679 { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 },
680 { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 },
681 { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 },
682 { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48,
683 HAS_MISC_REG | HAS_IBM_MISC },
684 { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 },
685 { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 },
686 { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a,
687 HAS_MISC_REG | HAS_IBM_MISC },
688 { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac,
689 HAS_MISC_REG | HAS_IBM_MISC },
690 { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29,
691 HAS_MISC_REG | HAS_IBM_MISC },
692 { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a,
693 HAS_MISC_REG | HAS_IBM_MISC },
694 { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac,
695 HAS_MISC_REG | HAS_IBM_MISC },
696 { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87,
697 HAS_MISC_REG | HAS_IBM_MISC },
698 { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17,
699 HAS_MISC_REG | HAS_IBM_MISC },
700 { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8,
701 HAS_MISC_REG | HAS_IBM_MISC },
702 { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0,
703 HAS_MISC_REG | HAS_IBM_MISC },
704 { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0,
705 HAS_MISC_REG | HAS_IBM_MISC },
706 { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 },
707 { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 },
708 { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0,
709 HAS_MISC_REG | HAS_IBM_MISC },
710 { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f,
711 HAS_MISC_REG | HAS_IBM_MISC },
712 { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 },
713 { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 },
714 { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 },
715 { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 },
716 { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65,
717 HAS_MISC_REG | HAS_IBM_MISC },
718 { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45,
719 HAS_MISC_REG | HAS_IBM_MISC },
720 { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 },
721 { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 },
722 { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 },
723 { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b,
724 DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF },
725 { /* Socket LP-E CF+ */ 0x01c0, 0x00, 0xc0, 0x1b, 0 },
726 { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 },
727 { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 },
728 { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 },
729 { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 },
730 { /* Qemu */ 0x0, 0x52, 0x54, 0x00, 0 }
733 #define NR_INFO (sizeof(hw_info)/sizeof(hw_info_t))
735 static hw_info_t default_info = { 0, 0, 0, 0, 0 };
739 #define PCNET_CMD 0x00
740 #define PCNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */
741 #define PCNET_RESET 0x1f /* Issue a read to reset, a write to clear. */
742 #define PCNET_MISC 0x18 /* For IBM CCAE and Socket EA cards */
746 /* U-boot specific routines */
747 static u8 *pbuf = NULL;
749 static int pkey = -1;
750 static int initialized=0;
752 void uboot_push_packet_len(int len) {
753 PRINTK("pushed len = %d\n", len);
755 printf("NE2000: packet too big\n");
758 dp83902a_recv(&pbuf[0], len);
760 /*Just pass it to the upper layer*/
761 NetReceive(&pbuf[0], len);
764 void uboot_push_tx_done(int key, int val) {
765 PRINTK("pushed key = %d\n", key);
769 int eth_init(bd_t *bd) {
770 static hw_info_t * r;
773 PRINTK("### eth_init\n");
778 printf("Cannot allocate rx buffer\n");
783 #ifdef CONFIG_DRIVER_NE2000_CCR
785 vu_char *p = (vu_char *) CONFIG_DRIVER_NE2000_CCR;
787 PRINTK("CCR before is %x\n", *p);
788 *p = CONFIG_DRIVER_NE2000_VAL;
789 PRINTK("CCR after is %x\n", *p);
793 nic_base = CONFIG_DRIVER_NE2000_BASE;
794 nic.base = (u8 *) CONFIG_DRIVER_NE2000_BASE;
796 r = get_prom(dev_addr);
800 sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
801 dev_addr[0], dev_addr[1],
802 dev_addr[2], dev_addr[3],
803 dev_addr[4], dev_addr[5]) ;
804 PRINTK("Set environment from HW MAC addr = \"%s\"\n", ethaddr);
805 setenv ("ethaddr", ethaddr);
807 nic.data = nic.base + DP_DATA;
808 nic.tx_buf1 = START_PG;
809 nic.tx_buf2 = START_PG2;
810 nic.rx_buf_start = RX_START;
811 nic.rx_buf_end = RX_END;
813 if (dp83902a_init() == false)
816 dp83902a_start(dev_addr);
824 PRINTK("### eth_halt\n");
835 int eth_send(volatile void *packet, int length) {
838 PRINTK("### eth_send\n");
842 dp83902a_send((u8 *) packet, length, 666);
843 tmo = get_timer (0) + TOUT * CFG_HZ;
847 PRINTK("Packet sucesfully sent\n");
850 if (get_timer (0) >= tmo) {
851 printf("transmission error (timoeut)\n");