drivers/net/ne2000_base.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 #include <linux/compiler.h>
  80
  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 /* 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
  96 static dp83902a_priv_data_t nic; /* just one instance of the card supported */
  97
  98 /**
  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  */
 102 static bool
 103 dp83902a_init(unsigned char *enetaddr)
 104 {
 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
 137         memcpy(enetaddr, dp->esa, 6); /* Use MAC from serial EEPROM */
 138 #endif  /* NE2000_BASIC_INIT */
 139         return true;
 140 }
 141
 142 static void
 143 dp83902a_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  */
 163 static void
 164 dp83902a_start(u8 * enaddr)
 165 {
 166         dp83902a_priv_data_t *dp = &nic;
 167         u8 *base = dp->base;
 168         int i;
 169
 170         debug("The MAC is %pM\n", enaddr);
 171
 172         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
 214 static void
 215 dp83902a_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  */
 242 static void
 243 dp83902a_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
 283                 __maybe_unused u16 tmp;
 284                 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  */
 372 static void
 373 dp83902a_RxEvent(void)
 374 {
 375         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 376         u8 *base = dp->base;
 377         __maybe_unused u8 rsr;
 378         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  */
 444 static void
 445 dp83902a_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
 509 static void
 510 dp83902a_TxEvent(void)
 511 {
 512         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 513         u8 *base = dp->base;
 514         __maybe_unused u8 tsr;
 515         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  */
 546 static void
 547 dp83902a_ClearCounters(void)
 548 {
 549         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 550         u8 *base = dp->base;
 551         __maybe_unused u8 cnt1, cnt2, cnt3;
 552
 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  */
 563 static void
 564 dp83902a_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
 604 static void
 605 dp83902a_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 */
 654 static u8 *pbuf = NULL;
 655
 656 static int pkey = -1;
 657 static int initialized = 0;
 658
 659 void 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
 671 void uboot_push_tx_done(int key, int val) {
 672         PRINTK("pushed key = %d\n", key);
 673         pkey = key;
 674 }
 675
 676 /**
 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  */
 683 static int ne2k_setup_driver(struct eth_device *dev)
 684 {
 685         PRINTK("### ne2k_setup_driver\n");
 686
 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
 707         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
 713         /*
 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         }
 728         return 0;
 729 }
 730
 731 static int ne2k_init(struct eth_device *dev, bd_t *bd)
 732 {
 733         dp83902a_start(dev->enetaddr);
 734         initialized = 1;
 735         return 0;
 736 }
 737
 738 static void ne2k_halt(struct eth_device *dev)
 739 {
 740         debug("### ne2k_halt\n");
 741         if(initialized)
 742                 dp83902a_stop();
 743         initialized = 0;
 744 }
 745
 746 static int ne2k_recv(struct eth_device *dev)
 747 {
 748         dp83902a_poll();
 749         return 1;
 750 }
 751
 752 static int ne2k_send(struct eth_device *dev, void *packet, int length)
 753 {
 754         int tmo;
 755
 756         debug("### ne2k_send\n");
 757
 758         pkey = -1;
 759
 760         dp83902a_send((u8 *) packet, length, 666);
 761         tmo = get_timer (0) + TOUT * CONFIG_SYS_HZ;
 762         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 }
 776
 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  */
 781 int 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 }