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         { /* 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 unsigned char 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 unsigned long nic_base;
 742
 743 static void pcnet_reset_8390(void)
 744 {
 745         int i, r;
 746
 747         PRINTK("nic base is %lx\n", nic_base);
 748
 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         n2k_outb(E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD);
 756
 757         n2k_outb(n2k_inb(PCNET_RESET), PCNET_RESET);
 758
 759         for (i = 0; i < 100; i++) {
 760                 if ((r = (n2k_inb(EN0_ISR) & ENISR_RESET)) != 0)
 761                         break;
 762                 PRINTK("got %x in reset\n", r);
 763                 my_udelay(100);
 764         }
 765         n2k_outb(ENISR_RESET, EN0_ISR); /* Ack intr. */
 766
 767         if (i == 100)
 768                 printf("pcnet_reset_8390() did not complete.\n");
 769 } /* pcnet_reset_8390 */
 770
 771 static hw_info_t * get_prom(void ) {
 772         unsigned char prom[32];
 773         int i, j;
 774         struct {
 775                 u_char value, offset;
 776         } program_seq[] = {
 777                 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 778                 {0x48,  EN0_DCFG},      /* Set byte-wide (0x48) access. */
 779                 {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 780                 {0x00,  EN0_RCNTHI},
 781                 {0x00,  EN0_IMR},       /* Mask completion irq. */
 782                 {0xFF,  EN0_ISR},
 783                 {E8390_RXOFF, EN0_RXCR},        /* 0x20  Set to monitor */
 784                 {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 785                 {32,    EN0_RCNTLO},
 786                 {0x00,  EN0_RCNTHI},
 787                 {0x00,  EN0_RSARLO},    /* DMA starting at 0x0000. */
 788                 {0x00,  EN0_RSARHI},
 789                 {E8390_RREAD+E8390_START, E8390_CMD},
 790         };
 791
 792         PRINTK("trying to get MAC via prom reading\n");
 793
 794         pcnet_reset_8390();
 795
 796         mdelay(10);
 797
 798         for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
 799                 n2k_outb(program_seq[i].value, program_seq[i].offset);
 800
 801         PRINTK("PROM:");
 802         for (i = 0; i < 32; i++) {
 803                 prom[i] = n2k_inb(PCNET_DATAPORT);
 804                 PRINTK(" %02x", prom[i]);
 805         }
 806         PRINTK("\n");
 807         for (i = 0; i < NR_INFO; i++) {
 808                 if ((prom[0] == hw_info[i].a0) &&
 809                     (prom[2] == hw_info[i].a1) &&
 810                     (prom[4] == hw_info[i].a2)) {
 811                         PRINTK("matched board %d\n", i);
 812                         break;
 813                 }
 814         }
 815         if ((i < NR_INFO) || ((prom[28] == 0x57) && (prom[30] == 0x57))) {
 816                 for (j = 0; j < 6; j++)
 817                         dev_addr[j] = prom[j<<1];
 818                 PRINTK("on exit i is %d/%ld\n", i, NR_INFO);
 819                 PRINTK("MAC address is %02x:%02x:%02x:%02x:%02x:%02x\n",
 820                        dev_addr[0],dev_addr[1],dev_addr[2],dev_addr[3],dev_addr[4],dev_addr[5]);
 821                 return (i < NR_INFO) ? hw_info+i : &default_info;
 822         }
 823         return NULL;
 824 }
 825
 826 /* U-boot specific routines */
 827
 828
 829 static unsigned char *pbuf = NULL;
 830
 831 static int pkey = -1;
 832 static int initialized=0;
 833
 834 void uboot_push_packet_len(int len) {
 835         PRINTK("pushed len = %d\n", len);
 836         if (len>=2000) {
 837                 printf("NE2000: packet too big\n");
 838                 return;
 839         }
 840         dp83902a_recv(&pbuf[0], len);
 841
 842         /*Just pass it to the upper layer*/
 843         NetReceive(&pbuf[0], len);
 844 }
 845
 846 void uboot_push_tx_done(int key, int val) {
 847         PRINTK("pushed key = %d\n", key);
 848         pkey = key;
 849 }
 850
 851 int eth_init(bd_t *bd) {
 852         static hw_info_t * r;
 853         char ethaddr[20];
 854
 855         PRINTK("### eth_init\n");
 856
 857         if (!pbuf) {
 858                 pbuf = malloc(2000);
 859                 if (!pbuf) {
 860                         printf("Cannot allocate rx buffer\n");
 861                         return -1;
 862                 }
 863         }
 864
 865 #ifdef CONFIG_DRIVER_NE2000_CCR
 866         {
 867                 volatile unsigned char *p =  (volatile unsigned char *) CONFIG_DRIVER_NE2000_CCR;
 868
 869                 PRINTK("CCR before is %x\n", *p);
 870                 *p = CONFIG_DRIVER_NE2000_VAL;
 871                 PRINTK("CCR after is %x\n", *p);
 872         }
 873 #endif
 874
 875         nic_base = CONFIG_DRIVER_NE2000_BASE;
 876         nic.base = (cyg_uint8 *) CONFIG_DRIVER_NE2000_BASE;
 877
 878         r = get_prom();
 879         if (!r)
 880                 return -1;
 881
 882         sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
 883                  dev_addr[0], dev_addr[1],
 884                  dev_addr[2], dev_addr[3],
 885                  dev_addr[4], dev_addr[5]) ;
 886         PRINTK("Set environment from HW MAC addr = \"%s\"\n", ethaddr);
 887         setenv ("ethaddr", ethaddr);
 888
 889
 890 #define DP_DATA         0x10
 891         nic.data = nic.base + DP_DATA;
 892         nic.tx_buf1 = 0x40;
 893         nic.tx_buf2 = 0x48;
 894         nic.rx_buf_start = 0x50;
 895         nic.rx_buf_end = 0x80;
 896
 897         if (dp83902a_init() == false)
 898                 return -1;
 899         dp83902a_start(dev_addr);
 900         initialized=1;
 901         return 0;
 902 }
 903
 904 void eth_halt() {
 905
 906         PRINTK("### eth_halt\n");
 907         if(initialized)
 908                 dp83902a_stop();
 909         initialized=0;
 910 }
 911
 912 int eth_rx() {
 913 dp83902a_poll();
 914 return 1;
 915 }
 916
 917 int eth_send(volatile void *packet, int length) {
 918         int tmo;
 919
 920         PRINTK("### eth_send\n");
 921
 922         pkey = -1;
 923
 924         dp83902a_send((unsigned char *) packet, length, 666);
 925         tmo = get_timer (0) + TOUT * CFG_HZ;
 926         while(1) {
 927                 dp83902a_poll();
 928                 if (pkey != -1) {
 929                         PRINTK("Packet sucesfully sent\n");
 930                         return 0;
 931                 }
 932                 if (get_timer (0) >= tmo) {
 933                         printf("transmission error (timoeut)\n");
 934                         return 0;
 935                 }
 936
 937         }
 938         return 0;
 939 }
 940 #endif