drivers/net/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 dev/if_dp83902a.c
  11
  12 Ethernet device driver for NS DP83902a ethernet controller
  13
  14 ==========================================================================
  15 ####ECOSGPLCOPYRIGHTBEGIN####
  16 -------------------------------------------
  17 This file is part of eCos, the Embedded Configurable Operating System.
  18 Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  19
  20 eCos is free software; you can redistribute it and/or modify it under
  21 the terms of the GNU General Public License as published by the Free
  22 Software Foundation; either version 2 or (at your option) any later version.
  23
  24 eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  25 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  26 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  27 for more details.
  28
  29 You should have received a copy of the GNU General Public License along
  30 with eCos; if not, write to the Free Software Foundation, Inc.,
  31 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  32
  33 As a special exception, if other files instantiate templates or use macros
  34 or inline functions from this file, or you compile this file and link it
  35 with other works to produce a work based on this file, this file does not
  36 by itself cause the resulting work to be covered by the GNU General Public
  37 License. However the source code for this file must still be made available
  38 in accordance with section (3) of the GNU General Public License.
  39
  40 This exception does not invalidate any other reasons why a work based on
  41 this file might be covered by the GNU General Public License.
  42
  43 Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  44 at http://sources.redhat.com/ecos/ecos-license/
  45 -------------------------------------------
  46 ####ECOSGPLCOPYRIGHTEND####
  47 ####BSDCOPYRIGHTBEGIN####
  48
  49 -------------------------------------------
  50
  51 Portions of this software may have been derived from OpenBSD or other sources,
  52 and are covered by the appropriate copyright disclaimers included herein.
  53
  54 -------------------------------------------
  55
  56 ####BSDCOPYRIGHTEND####
  57 ==========================================================================
  58 #####DESCRIPTIONBEGIN####
  59
  60 Author(s):    gthomas
  61 Contributors: gthomas, jskov, rsandifo
  62 Date:         2001-06-13
  63 Purpose:
  64 Description:
  65
  66 FIXME:        Will fail if pinged with large packets (1520 bytes)
  67 Add promisc config
  68 Add SNMP
  69
  70 ####DESCRIPTIONEND####
  71
  72 ==========================================================================
  73 */
  74
  75 #include <common.h>
  76 #include <command.h>
  77 #include <net.h>
  78 #include <malloc.h>
  79
  80 #define mdelay(n)       udelay((n)*1000)
  81 /* forward definition of function used for the uboot interface */
  82 void uboot_push_packet_len(int len);
  83 void uboot_push_tx_done(int key, int val);
  84
  85 /*
  86   ------------------------------------------------------------------------
  87   Debugging details
  88
  89   Set to perms of:
  90   0 disables all debug output
  91   1 for process debug output
  92   2 for added data IO output: get_reg, put_reg
  93   4 for packet allocation/free output
  94   8 for only startup status, so we can tell we're installed OK
  95 */
  96 /*#define DEBUG 0xf*/
  97 #define DEBUG 0
  98
  99 #if DEBUG & 1
 100 #define DEBUG_FUNCTION() do { printf("%s\n", __FUNCTION__); } while (0)
 101 #define DEBUG_LINE() do { printf("%d\n", __LINE__); } while (0)
 102 #define PRINTK(args...) printf(args)
 103 #else
 104 #define DEBUG_FUNCTION() do {} while(0)
 105 #define DEBUG_LINE() do {} while(0)
 106 #define PRINTK(args...)
 107 #endif
 108
 109 /* NE2000 base header file */
 110 #include "ne2000_base.h"
 111
 112 #if defined(CONFIG_DRIVER_AX88796L)
 113 /* AX88796L support */
 114 #include "ax88796.h"
 115 #else
 116 /* Basic NE2000 chip support */
 117 #include "ne2000.h"
 118 #endif
 119
 120 static dp83902a_priv_data_t nic; /* just one instance of the card supported */
 121
 122 static bool
 123 dp83902a_init(void)
 124 {
 125         dp83902a_priv_data_t *dp = &nic;
 126         u8* base;
 127
 128         DEBUG_FUNCTION();
 129
 130         base = dp->base;
 131         if (!base) return false;  /* No device found */
 132
 133         DEBUG_LINE();
 134
 135 #if defined(NE2000_BASIC_INIT)
 136         /* AX88796L doesn't need */
 137         /* Prepare ESA */
 138         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1);  /* Select page 1 */
 139         /* Use the address from the serial EEPROM */
 140         for (i = 0; i < 6; i++)
 141                 DP_IN(base, DP_P1_PAR0+i, dp->esa[i]);
 142         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0);  /* Select page 0 */
 143
 144         printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n",
 145                "eeprom",
 146                dp->esa[0],
 147                dp->esa[1],
 148                dp->esa[2],
 149                dp->esa[3],
 150                dp->esa[4],
 151                dp->esa[5] );
 152
 153 #endif  /* NE2000_BASIC_INIT */
 154         return true;
 155 }
 156
 157 static void
 158 dp83902a_stop(void)
 159 {
 160         dp83902a_priv_data_t *dp = &nic;
 161         u8 *base = dp->base;
 162
 163         DEBUG_FUNCTION();
 164
 165         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP);  /* Brutal */
 166         DP_OUT(base, DP_ISR, 0xFF);             /* Clear any pending interrupts */
 167         DP_OUT(base, DP_IMR, 0x00);             /* Disable all interrupts */
 168
 169         dp->running = false;
 170 }
 171
 172 /*
 173   This function is called to "start up" the interface.  It may be called
 174   multiple times, even when the hardware is already running.  It will be
 175   called whenever something "hardware oriented" changes and should leave
 176   the hardware ready to send/receive packets.
 177 */
 178 static void
 179 dp83902a_start(u8 * enaddr)
 180 {
 181         dp83902a_priv_data_t *dp = &nic;
 182         u8 *base = dp->base;
 183         int i;
 184
 185         DEBUG_FUNCTION();
 186
 187         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
 188         DP_OUT(base, DP_DCR, DP_DCR_INIT);
 189         DP_OUT(base, DP_RBCH, 0);               /* Remote byte count */
 190         DP_OUT(base, DP_RBCL, 0);
 191         DP_OUT(base, DP_RCR, DP_RCR_MON);       /* Accept no packets */
 192         DP_OUT(base, DP_TCR, DP_TCR_LOCAL);     /* Transmitter [virtually] off */
 193         DP_OUT(base, DP_TPSR, dp->tx_buf1);     /* Transmitter start page */
 194         dp->tx1 = dp->tx2 = 0;
 195         dp->tx_next = dp->tx_buf1;
 196         dp->tx_started = false;
 197         dp->running = true;
 198         DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
 199         DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1); /* Receive ring boundary */
 200         DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
 201         dp->rx_next = dp->rx_buf_start-1;
 202         dp->running = true;
 203         DP_OUT(base, DP_ISR, 0xFF);             /* Clear any pending interrupts */
 204         DP_OUT(base, DP_IMR, DP_IMR_All);       /* Enable all interrupts */
 205         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP);  /* Select page 1 */
 206         DP_OUT(base, DP_P1_CURP, dp->rx_buf_start);   /* Current page - next free page for Rx */
 207         dp->running = true;
 208         for (i = 0;  i < ETHER_ADDR_LEN;  i++) {
 209                 /* FIXME */
 210                 /*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) +
 211                  * 0x1400)) = enaddr[i];*/
 212                 DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
 213         }
 214         /* Enable and start device */
 215         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 216         DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
 217         DP_OUT(base, DP_RCR, DP_RCR_AB);  /* Accept broadcast, no errors, no multicast */
 218         dp->running = true;
 219 }
 220
 221 /*
 222   This routine is called to start the transmitter.  It is split out from the
 223   data handling routine so it may be called either when data becomes first
 224   available or when an Tx interrupt occurs
 225 */
 226
 227 static void
 228 dp83902a_start_xmit(int start_page, int len)
 229 {
 230         dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic;
 231         u8 *base = dp->base;
 232
 233         DEBUG_FUNCTION();
 234
 235 #if DEBUG & 1
 236         printf("Tx pkt %d len %d\n", start_page, len);
 237         if (dp->tx_started)
 238                 printf("TX already started?!?\n");
 239 #endif
 240
 241         DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE));
 242         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 243         DP_OUT(base, DP_TBCL, len & 0xFF);
 244         DP_OUT(base, DP_TBCH, len >> 8);
 245         DP_OUT(base, DP_TPSR, start_page);
 246         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
 247
 248         dp->tx_started = true;
 249 }
 250
 251 /*
 252   This routine is called to send data to the hardware.  It is known a-priori
 253   that there is free buffer space (dp->tx_next).
 254 */
 255 static void
 256 dp83902a_send(u8 *data, int total_len, u32 key)
 257 {
 258         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 259         u8 *base = dp->base;
 260         int len, start_page, pkt_len, i, isr;
 261 #if DEBUG & 4
 262         int dx;
 263 #endif
 264
 265         DEBUG_FUNCTION();
 266
 267         len = pkt_len = total_len;
 268         if (pkt_len < IEEE_8023_MIN_FRAME) pkt_len = IEEE_8023_MIN_FRAME;
 269
 270         start_page = dp->tx_next;
 271         if (dp->tx_next == dp->tx_buf1) {
 272                 dp->tx1 = start_page;
 273                 dp->tx1_len = pkt_len;
 274                 dp->tx1_key = key;
 275                 dp->tx_next = dp->tx_buf2;
 276         } else {
 277                 dp->tx2 = start_page;
 278                 dp->tx2_len = pkt_len;
 279                 dp->tx2_key = key;
 280                 dp->tx_next = dp->tx_buf1;
 281         }
 282
 283 #if DEBUG & 5
 284         printf("TX prep page %d len %d\n", start_page, pkt_len);
 285 #endif
 286
 287         DP_OUT(base, DP_ISR, DP_ISR_RDC);  /* Clear end of DMA */
 288         {
 289                 /* Dummy read. The manual sez something slightly different, */
 290                 /* but the code is extended a bit to do what Hitachi's monitor */
 291                 /* does (i.e., also read data). */
 292
 293                 u16 tmp;
 294                 int len = 1;
 295
 296                 DP_OUT(base, DP_RSAL, 0x100-len);
 297                 DP_OUT(base, DP_RSAH, (start_page-1) & 0xff);
 298                 DP_OUT(base, DP_RBCL, len);
 299                 DP_OUT(base, DP_RBCH, 0);
 300                 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
 301                 DP_IN_DATA(dp->data, tmp);
 302         }
 303
 304 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
 305         /* Stall for a bit before continuing to work around random data */
 306         /* corruption problems on some platforms. */
 307         CYGACC_CALL_IF_DELAY_US(1);
 308 #endif
 309
 310         /* Send data to device buffer(s) */
 311         DP_OUT(base, DP_RSAL, 0);
 312         DP_OUT(base, DP_RSAH, start_page);
 313         DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
 314         DP_OUT(base, DP_RBCH, pkt_len >> 8);
 315         DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
 316
 317         /* Put data into buffer */
 318 #if DEBUG & 4
 319         printf(" sg buf %08lx len %08x\n ", (u32)data, len);
 320         dx = 0;
 321 #endif
 322         while (len > 0) {
 323 #if DEBUG & 4
 324                 printf(" %02x", *data);
 325                 if (0 == (++dx % 16)) printf("\n ");
 326 #endif
 327
 328                 DP_OUT_DATA(dp->data, *data++);
 329                 len--;
 330         }
 331 #if DEBUG & 4
 332         printf("\n");
 333 #endif
 334         if (total_len < pkt_len) {
 335 #if DEBUG & 4
 336                 printf("  + %d bytes of padding\n", pkt_len - total_len);
 337 #endif
 338                 /* Padding to 802.3 length was required */
 339                 for (i = total_len;  i < pkt_len;) {
 340                         i++;
 341                         DP_OUT_DATA(dp->data, 0);
 342                 }
 343         }
 344
 345 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
 346         /* After last data write, delay for a bit before accessing the */
 347         /* device again, or we may get random data corruption in the last */
 348         /* datum (on some platforms). */
 349         CYGACC_CALL_IF_DELAY_US(1);
 350 #endif
 351
 352         /* Wait for DMA to complete */
 353         do {
 354                 DP_IN(base, DP_ISR, isr);
 355         } while ((isr & DP_ISR_RDC) == 0);
 356
 357         /* Then disable DMA */
 358         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 359
 360         /* Start transmit if not already going */
 361         if (!dp->tx_started) {
 362                 if (start_page == dp->tx1) {
 363                         dp->tx_int = 1;  /* Expecting interrupt from BUF1 */
 364                 } else {
 365                         dp->tx_int = 2;  /* Expecting interrupt from BUF2 */
 366                 }
 367                 dp83902a_start_xmit(start_page, pkt_len);
 368         }
 369 }
 370
 371 /*
 372   This function is called when a packet has been received.  It's job is
 373   to prepare to unload the packet from the hardware.  Once the length of
 374   the packet is known, the upper layer of the driver can be told.  When
 375   the upper layer is ready to unload the packet, the internal function
 376   'dp83902a_recv' will be called to actually fetch it from the hardware.
 377 */
 378 static void
 379 dp83902a_RxEvent(void)
 380 {
 381         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 382         u8 *base = dp->base;
 383         u8 rsr;
 384         u8 rcv_hdr[4];
 385         int i, len, pkt, cur;
 386
 387         DEBUG_FUNCTION();
 388
 389         DP_IN(base, DP_RSR, rsr);
 390         while (true) {
 391                 /* Read incoming packet header */
 392                 DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
 393                 DP_IN(base, DP_P1_CURP, cur);
 394                 DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 395                 DP_IN(base, DP_BNDRY, pkt);
 396
 397                 pkt += 1;
 398                 if (pkt == dp->rx_buf_end)
 399                         pkt = dp->rx_buf_start;
 400
 401                 if (pkt == cur) {
 402                         break;
 403                 }
 404                 DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
 405                 DP_OUT(base, DP_RBCH, 0);
 406                 DP_OUT(base, DP_RSAL, 0);
 407                 DP_OUT(base, DP_RSAH, pkt);
 408                 if (dp->rx_next == pkt) {
 409                         if (cur == dp->rx_buf_start)
 410                                 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1);
 411                         else
 412                                 DP_OUT(base, DP_BNDRY, cur-1); /* Update pointer */
 413                         return;
 414                 }
 415                 dp->rx_next = pkt;
 416                 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
 417                 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
 418 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
 419                 CYGACC_CALL_IF_DELAY_US(10);
 420 #endif
 421
 422                 /* read header (get data size)*/
 423                 for (i = 0;  i < sizeof(rcv_hdr);) {
 424                         DP_IN_DATA(dp->data, rcv_hdr[i++]);
 425                 }
 426
 427 #if DEBUG & 5
 428                 printf("rx hdr %02x %02x %02x %02x\n",
 429                        rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
 430 #endif
 431                 len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
 432
 433                 /* data read */
 434                 uboot_push_packet_len(len);
 435
 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(u8 *data, int len)
 452 {
 453         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 454         u8 *base = dp->base;
 455         int i, mlen;
 456         u8 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", (u32) 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                                         u8 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         u8 *base = dp->base;
 520         u8 tsr;
 521         u32 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         u8 *base = dp->base;
 555         u8 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         u8 *base = dp->base;
 570         u8 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         u8 *base = dp->base;
 607         u8 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         { /* Qemu */ 0x0, 0x52, 0x54, 0x00, 0 }
 728 };
 729
 730 #define NR_INFO         (sizeof(hw_info)/sizeof(hw_info_t))
 731
 732 static hw_info_t default_info = { 0, 0, 0, 0, 0 };
 733
 734 u8 dev_addr[6];
 735
 736 #define PCNET_CMD       0x00
 737 #define PCNET_DATAPORT  0x10    /* NatSemi-defined port window offset. */
 738 #define PCNET_RESET     0x1f    /* Issue a read to reset, a write to clear. */
 739 #define PCNET_MISC      0x18    /* For IBM CCAE and Socket EA cards */
 740
 741 u32 nic_base;
 742
 743 /* U-boot specific routines */
 744 static u8 *pbuf = NULL;
 745
 746 static int pkey = -1;
 747 static int initialized=0;
 748
 749 void uboot_push_packet_len(int len) {
 750         PRINTK("pushed len = %d\n", len);
 751         if (len>=2000) {
 752                 printf("NE2000: packet too big\n");
 753                 return;
 754         }
 755         dp83902a_recv(&pbuf[0], len);
 756
 757         /*Just pass it to the upper layer*/
 758         NetReceive(&pbuf[0], len);
 759 }
 760
 761 void uboot_push_tx_done(int key, int val) {
 762         PRINTK("pushed key = %d\n", key);
 763         pkey = key;
 764 }
 765
 766 int eth_init(bd_t *bd) {
 767         static hw_info_t * r;
 768         char ethaddr[20];
 769
 770         PRINTK("### eth_init\n");
 771
 772         if (!pbuf) {
 773                 pbuf = malloc(2000);
 774                 if (!pbuf) {
 775                         printf("Cannot allocate rx buffer\n");
 776                         return -1;
 777                 }
 778         }
 779
 780 #ifdef CONFIG_DRIVER_NE2000_CCR
 781         {
 782                 vu_char *p =  (vu_char *) CONFIG_DRIVER_NE2000_CCR;
 783
 784                 PRINTK("CCR before is %x\n", *p);
 785                 *p = CONFIG_DRIVER_NE2000_VAL;
 786                 PRINTK("CCR after is %x\n", *p);
 787         }
 788 #endif
 789
 790         nic_base = CONFIG_DRIVER_NE2000_BASE;
 791         nic.base = (u8 *) CONFIG_DRIVER_NE2000_BASE;
 792
 793         r = get_prom(dev_addr);
 794         if (!r)
 795                 return -1;
 796
 797         sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
 798                  dev_addr[0], dev_addr[1],
 799                  dev_addr[2], dev_addr[3],
 800                  dev_addr[4], dev_addr[5]) ;
 801         PRINTK("Set environment from HW MAC addr = \"%s\"\n", ethaddr);
 802         setenv ("ethaddr", ethaddr);
 803
 804         nic.data = nic.base + DP_DATA;
 805         nic.tx_buf1 = START_PG;
 806         nic.tx_buf2 = START_PG2;
 807         nic.rx_buf_start = RX_START;
 808         nic.rx_buf_end = RX_END;
 809
 810         if (dp83902a_init() == false)
 811                 return -1;
 812
 813         dp83902a_start(dev_addr);
 814         initialized=1;
 815
 816         return 0;
 817 }
 818
 819 void eth_halt() {
 820
 821         PRINTK("### eth_halt\n");
 822         if(initialized)
 823                 dp83902a_stop();
 824         initialized=0;
 825 }
 826
 827 int eth_rx() {
 828         dp83902a_poll();
 829         return 1;
 830 }
 831
 832 int eth_send(volatile void *packet, int length) {
 833         int tmo;
 834
 835         PRINTK("### eth_send\n");
 836
 837         pkey = -1;
 838
 839         dp83902a_send((u8 *) packet, length, 666);
 840         tmo = get_timer (0) + TOUT * CFG_HZ;
 841         while(1) {
 842                 dp83902a_poll();
 843                 if (pkey != -1) {
 844                         PRINTK("Packet sucesfully sent\n");
 845                         return 0;
 846                 }
 847                 if (get_timer (0) >= tmo) {
 848                         printf("transmission error (timoeut)\n");
 849                         return 0;
 850                 }
 851
 852         }
 853         return 0;
 854 }