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
  80 /* forward definition of function used for the uboot interface */
  81 void uboot_push_packet_len(int len);
  82 void uboot_push_tx_done(int key, int val);
  83
  84 /* NE2000 base header file */
  85 #include "ne2000_base.h"
  86
  87 #if defined(CONFIG_DRIVER_AX88796L)
  88 /* AX88796L support */
  89 #include "ax88796.h"
  90 #else
  91 /* Basic NE2000 chip support */
  92 #include "ne2000.h"
  93 #endif
  94
  95 static dp83902a_priv_data_t nic; /* just one instance of the card supported */
  96
  97 /**
  98  * This function reads the MAC address from the serial EEPROM,
  99  * used if PROM read fails. Does nothing for ax88796 chips (sh boards)
 100  */
 101 static bool
 102 dp83902a_init(unsigned char *enetaddr)
 103 {
 104         dp83902a_priv_data_t *dp = &nic;
 105         u8* base;
 106 #if defined(NE2000_BASIC_INIT)
 107         int i;
 108 #endif
 109
 110         DEBUG_FUNCTION();
 111
 112         base = dp->base;
 113         if (!base)
 114                 return false;   /* No device found */
 115
 116         DEBUG_LINE();
 117
 118 #if defined(NE2000_BASIC_INIT)
 119         /* AX88796L doesn't need */
 120         /* Prepare ESA */
 121         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1); /* Select page 1 */
 122         /* Use the address from the serial EEPROM */
 123         for (i = 0; i < 6; i++)
 124                 DP_IN(base, DP_P1_PAR0+i, dp->esa[i]);
 125         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0); /* Select page 0 */
 126
 127         printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n",
 128                 "eeprom",
 129                 dp->esa[0],
 130                 dp->esa[1],
 131                 dp->esa[2],
 132                 dp->esa[3],
 133                 dp->esa[4],
 134                 dp->esa[5] );
 135
 136         memcpy(enetaddr, dp->esa, 6); /* Use MAC from serial EEPROM */
 137 #endif  /* NE2000_BASIC_INIT */
 138         return true;
 139 }
 140
 141 static void
 142 dp83902a_stop(void)
 143 {
 144         dp83902a_priv_data_t *dp = &nic;
 145         u8 *base = dp->base;
 146
 147         DEBUG_FUNCTION();
 148
 149         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP);    /* Brutal */
 150         DP_OUT(base, DP_ISR, 0xFF);             /* Clear any pending interrupts */
 151         DP_OUT(base, DP_IMR, 0x00);             /* Disable all interrupts */
 152
 153         dp->running = false;
 154 }
 155
 156 /*
 157  * This function is called to "start up" the interface. It may be called
 158  * multiple times, even when the hardware is already running. It will be
 159  * called whenever something "hardware oriented" changes and should leave
 160  * the hardware ready to send/receive packets.
 161  */
 162 static void
 163 dp83902a_start(u8 * enaddr)
 164 {
 165         dp83902a_priv_data_t *dp = &nic;
 166         u8 *base = dp->base;
 167         int i;
 168
 169         debug("The MAC is %pM\n", enaddr);
 170
 171         DEBUG_FUNCTION();
 172
 173         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */
 174         DP_OUT(base, DP_DCR, DP_DCR_INIT);
 175         DP_OUT(base, DP_RBCH, 0);               /* Remote byte count */
 176         DP_OUT(base, DP_RBCL, 0);
 177         DP_OUT(base, DP_RCR, DP_RCR_MON);       /* Accept no packets */
 178         DP_OUT(base, DP_TCR, DP_TCR_LOCAL);     /* Transmitter [virtually] off */
 179         DP_OUT(base, DP_TPSR, dp->tx_buf1);     /* Transmitter start page */
 180         dp->tx1 = dp->tx2 = 0;
 181         dp->tx_next = dp->tx_buf1;
 182         dp->tx_started = false;
 183         dp->running = true;
 184         DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */
 185         DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1); /* Receive ring boundary */
 186         DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */
 187         dp->rx_next = dp->rx_buf_start - 1;
 188         dp->running = true;
 189         DP_OUT(base, DP_ISR, 0xFF);             /* Clear any pending interrupts */
 190         DP_OUT(base, DP_IMR, DP_IMR_All);       /* Enable all interrupts */
 191         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP);    /* Select page 1 */
 192         DP_OUT(base, DP_P1_CURP, dp->rx_buf_start);     /* Current page - next free page for Rx */
 193         dp->running = true;
 194         for (i = 0; i < ETHER_ADDR_LEN; i++) {
 195                 /* FIXME */
 196                 /*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) +
 197                  * 0x1400)) = enaddr[i];*/
 198                 DP_OUT(base, DP_P1_PAR0+i, enaddr[i]);
 199         }
 200         /* Enable and start device */
 201         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 202         DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */
 203         DP_OUT(base, DP_RCR, DP_RCR_AB); /* Accept broadcast, no errors, no multicast */
 204         dp->running = true;
 205 }
 206
 207 /*
 208  * This routine is called to start the transmitter. It is split out from the
 209  * data handling routine so it may be called either when data becomes first
 210  * available or when an Tx interrupt occurs
 211  */
 212
 213 static void
 214 dp83902a_start_xmit(int start_page, int len)
 215 {
 216         dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic;
 217         u8 *base = dp->base;
 218
 219         DEBUG_FUNCTION();
 220
 221 #if DEBUG & 1
 222         printf("Tx pkt %d len %d\n", start_page, len);
 223         if (dp->tx_started)
 224                 printf("TX already started?!?\n");
 225 #endif
 226
 227         DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE));
 228         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 229         DP_OUT(base, DP_TBCL, len & 0xFF);
 230         DP_OUT(base, DP_TBCH, len >> 8);
 231         DP_OUT(base, DP_TPSR, start_page);
 232         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
 233
 234         dp->tx_started = true;
 235 }
 236
 237 /*
 238  * This routine is called to send data to the hardware. It is known a-priori
 239  * that there is free buffer space (dp->tx_next).
 240  */
 241 static void
 242 dp83902a_send(u8 *data, int total_len, u32 key)
 243 {
 244         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 245         u8 *base = dp->base;
 246         int len, start_page, pkt_len, i, isr;
 247 #if DEBUG & 4
 248         int dx;
 249 #endif
 250
 251         DEBUG_FUNCTION();
 252
 253         len = pkt_len = total_len;
 254         if (pkt_len < IEEE_8023_MIN_FRAME)
 255                 pkt_len = IEEE_8023_MIN_FRAME;
 256
 257         start_page = dp->tx_next;
 258         if (dp->tx_next == dp->tx_buf1) {
 259                 dp->tx1 = start_page;
 260                 dp->tx1_len = pkt_len;
 261                 dp->tx1_key = key;
 262                 dp->tx_next = dp->tx_buf2;
 263         } else {
 264                 dp->tx2 = start_page;
 265                 dp->tx2_len = pkt_len;
 266                 dp->tx2_key = key;
 267                 dp->tx_next = dp->tx_buf1;
 268         }
 269
 270 #if DEBUG & 5
 271         printf("TX prep page %d len %d\n", start_page, pkt_len);
 272 #endif
 273
 274         DP_OUT(base, DP_ISR, DP_ISR_RDC);       /* Clear end of DMA */
 275         {
 276                 /*
 277                  * Dummy read. The manual sez something slightly different,
 278                  * but the code is extended a bit to do what Hitachi's monitor
 279                  * does (i.e., also read data).
 280                  */
 281
 282                 u16 tmp;
 283                 int len = 1;
 284
 285                 DP_OUT(base, DP_RSAL, 0x100 - len);
 286                 DP_OUT(base, DP_RSAH, (start_page - 1) & 0xff);
 287                 DP_OUT(base, DP_RBCL, len);
 288                 DP_OUT(base, DP_RBCH, 0);
 289                 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START);
 290                 DP_IN_DATA(dp->data, tmp);
 291         }
 292
 293 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
 294         /*
 295          * Stall for a bit before continuing to work around random data
 296          * corruption problems on some platforms.
 297          */
 298         CYGACC_CALL_IF_DELAY_US(1);
 299 #endif
 300
 301         /* Send data to device buffer(s) */
 302         DP_OUT(base, DP_RSAL, 0);
 303         DP_OUT(base, DP_RSAH, start_page);
 304         DP_OUT(base, DP_RBCL, pkt_len & 0xFF);
 305         DP_OUT(base, DP_RBCH, pkt_len >> 8);
 306         DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START);
 307
 308         /* Put data into buffer */
 309 #if DEBUG & 4
 310         printf(" sg buf %08lx len %08x\n ", (u32)data, len);
 311         dx = 0;
 312 #endif
 313         while (len > 0) {
 314 #if DEBUG & 4
 315                 printf(" %02x", *data);
 316                 if (0 == (++dx % 16)) printf("\n ");
 317 #endif
 318
 319                 DP_OUT_DATA(dp->data, *data++);
 320                 len--;
 321         }
 322 #if DEBUG & 4
 323         printf("\n");
 324 #endif
 325         if (total_len < pkt_len) {
 326 #if DEBUG & 4
 327                 printf("  + %d bytes of padding\n", pkt_len - total_len);
 328 #endif
 329                 /* Padding to 802.3 length was required */
 330                 for (i = total_len; i < pkt_len;) {
 331                         i++;
 332                         DP_OUT_DATA(dp->data, 0);
 333                 }
 334         }
 335
 336 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA
 337         /*
 338          * After last data write, delay for a bit before accessing the
 339          * device again, or we may get random data corruption in the last
 340          * datum (on some platforms).
 341          */
 342         CYGACC_CALL_IF_DELAY_US(1);
 343 #endif
 344
 345         /* Wait for DMA to complete */
 346         do {
 347                 DP_IN(base, DP_ISR, isr);
 348         } while ((isr & DP_ISR_RDC) == 0);
 349
 350         /* Then disable DMA */
 351         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 352
 353         /* Start transmit if not already going */
 354         if (!dp->tx_started) {
 355                 if (start_page == dp->tx1) {
 356                         dp->tx_int = 1; /* Expecting interrupt from BUF1 */
 357                 } else {
 358                         dp->tx_int = 2; /* Expecting interrupt from BUF2 */
 359                 }
 360                 dp83902a_start_xmit(start_page, pkt_len);
 361         }
 362 }
 363
 364 /*
 365  * This function is called when a packet has been received. It's job is
 366  * to prepare to unload the packet from the hardware. Once the length of
 367  * the packet is known, the upper layer of the driver can be told. When
 368  * the upper layer is ready to unload the packet, the internal function
 369  * 'dp83902a_recv' will be called to actually fetch it from the hardware.
 370  */
 371 static void
 372 dp83902a_RxEvent(void)
 373 {
 374         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 375         u8 *base = dp->base;
 376         u8 rsr;
 377         u8 rcv_hdr[4];
 378         int i, len, pkt, cur;
 379
 380         DEBUG_FUNCTION();
 381
 382         DP_IN(base, DP_RSR, rsr);
 383         while (true) {
 384                 /* Read incoming packet header */
 385                 DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START);
 386                 DP_IN(base, DP_P1_CURP, cur);
 387                 DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 388                 DP_IN(base, DP_BNDRY, pkt);
 389
 390                 pkt += 1;
 391                 if (pkt == dp->rx_buf_end)
 392                         pkt = dp->rx_buf_start;
 393
 394                 if (pkt == cur) {
 395                         break;
 396                 }
 397                 DP_OUT(base, DP_RBCL, sizeof(rcv_hdr));
 398                 DP_OUT(base, DP_RBCH, 0);
 399                 DP_OUT(base, DP_RSAL, 0);
 400                 DP_OUT(base, DP_RSAH, pkt);
 401                 if (dp->rx_next == pkt) {
 402                         if (cur == dp->rx_buf_start)
 403                                 DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
 404                         else
 405                                 DP_OUT(base, DP_BNDRY, cur - 1); /* Update pointer */
 406                         return;
 407                 }
 408                 dp->rx_next = pkt;
 409                 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
 410                 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
 411 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
 412                 CYGACC_CALL_IF_DELAY_US(10);
 413 #endif
 414
 415                 /* read header (get data size)*/
 416                 for (i = 0; i < sizeof(rcv_hdr);) {
 417                         DP_IN_DATA(dp->data, rcv_hdr[i++]);
 418                 }
 419
 420 #if DEBUG & 5
 421                 printf("rx hdr %02x %02x %02x %02x\n",
 422                         rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]);
 423 #endif
 424                 len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr);
 425
 426                 /* data read */
 427                 uboot_push_packet_len(len);
 428
 429                 if (rcv_hdr[1] == dp->rx_buf_start)
 430                         DP_OUT(base, DP_BNDRY, dp->rx_buf_end - 1);
 431                 else
 432                         DP_OUT(base, DP_BNDRY, rcv_hdr[1] - 1); /* Update pointer */
 433         }
 434 }
 435
 436 /*
 437  * This function is called as a result of the "eth_drv_recv()" call above.
 438  * It's job is to actually fetch data for a packet from the hardware once
 439  * memory buffers have been allocated for the packet. Note that the buffers
 440  * may come in pieces, using a scatter-gather list. This allows for more
 441  * efficient processing in the upper layers of the stack.
 442  */
 443 static void
 444 dp83902a_recv(u8 *data, int len)
 445 {
 446         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 447         u8 *base = dp->base;
 448         int i, mlen;
 449         u8 saved_char = 0;
 450         bool saved;
 451 #if DEBUG & 4
 452         int dx;
 453 #endif
 454
 455         DEBUG_FUNCTION();
 456
 457 #if DEBUG & 5
 458         printf("Rx packet %d length %d\n", dp->rx_next, len);
 459 #endif
 460
 461         /* Read incoming packet data */
 462         DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START);
 463         DP_OUT(base, DP_RBCL, len & 0xFF);
 464         DP_OUT(base, DP_RBCH, len >> 8);
 465         DP_OUT(base, DP_RSAL, 4);               /* Past header */
 466         DP_OUT(base, DP_RSAH, dp->rx_next);
 467         DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */
 468         DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START);
 469 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA
 470         CYGACC_CALL_IF_DELAY_US(10);
 471 #endif
 472
 473         saved = false;
 474         for (i = 0; i < 1; i++) {
 475                 if (data) {
 476                         mlen = len;
 477 #if DEBUG & 4
 478                         printf(" sg buf %08lx len %08x \n", (u32) data, mlen);
 479                         dx = 0;
 480 #endif
 481                         while (0 < mlen) {
 482                                 /* Saved byte from previous loop? */
 483                                 if (saved) {
 484                                         *data++ = saved_char;
 485                                         mlen--;
 486                                         saved = false;
 487                                         continue;
 488                                 }
 489
 490                                 {
 491                                         u8 tmp;
 492                                         DP_IN_DATA(dp->data, tmp);
 493 #if DEBUG & 4
 494                                         printf(" %02x", tmp);
 495                                         if (0 == (++dx % 16)) printf("\n ");
 496 #endif
 497                                         *data++ = tmp;;
 498                                         mlen--;
 499                                 }
 500                         }
 501 #if DEBUG & 4
 502                         printf("\n");
 503 #endif
 504                 }
 505         }
 506 }
 507
 508 static void
 509 dp83902a_TxEvent(void)
 510 {
 511         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 512         u8 *base = dp->base;
 513         u8 tsr;
 514         u32 key;
 515
 516         DEBUG_FUNCTION();
 517
 518         DP_IN(base, DP_TSR, tsr);
 519         if (dp->tx_int == 1) {
 520                 key = dp->tx1_key;
 521                 dp->tx1 = 0;
 522         } else {
 523                 key = dp->tx2_key;
 524                 dp->tx2 = 0;
 525         }
 526         /* Start next packet if one is ready */
 527         dp->tx_started = false;
 528         if (dp->tx1) {
 529                 dp83902a_start_xmit(dp->tx1, dp->tx1_len);
 530                 dp->tx_int = 1;
 531         } else if (dp->tx2) {
 532                 dp83902a_start_xmit(dp->tx2, dp->tx2_len);
 533                 dp->tx_int = 2;
 534         } else {
 535                 dp->tx_int = 0;
 536         }
 537         /* Tell higher level we sent this packet */
 538         uboot_push_tx_done(key, 0);
 539 }
 540
 541 /*
 542  * Read the tally counters to clear them. Called in response to a CNT
 543  * interrupt.
 544  */
 545 static void
 546 dp83902a_ClearCounters(void)
 547 {
 548         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 549         u8 *base = dp->base;
 550         u8 cnt1, cnt2, cnt3;
 551
 552         DP_IN(base, DP_FER, cnt1);
 553         DP_IN(base, DP_CER, cnt2);
 554         DP_IN(base, DP_MISSED, cnt3);
 555         DP_OUT(base, DP_ISR, DP_ISR_CNT);
 556 }
 557
 558 /*
 559  * Deal with an overflow condition. This code follows the procedure set
 560  * out in section 7.0 of the datasheet.
 561  */
 562 static void
 563 dp83902a_Overflow(void)
 564 {
 565         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *)&nic;
 566         u8 *base = dp->base;
 567         u8 isr;
 568
 569         /* Issue a stop command and wait 1.6ms for it to complete. */
 570         DP_OUT(base, DP_CR, DP_CR_STOP | DP_CR_NODMA);
 571         CYGACC_CALL_IF_DELAY_US(1600);
 572
 573         /* Clear the remote byte counter registers. */
 574         DP_OUT(base, DP_RBCL, 0);
 575         DP_OUT(base, DP_RBCH, 0);
 576
 577         /* Enter loopback mode while we clear the buffer. */
 578         DP_OUT(base, DP_TCR, DP_TCR_LOCAL);
 579         DP_OUT(base, DP_CR, DP_CR_START | DP_CR_NODMA);
 580
 581         /*
 582          * Read in as many packets as we can and acknowledge any and receive
 583          * interrupts. Since the buffer has overflowed, a receive event of
 584          * some kind will have occured.
 585          */
 586         dp83902a_RxEvent();
 587         DP_OUT(base, DP_ISR, DP_ISR_RxP|DP_ISR_RxE);
 588
 589         /* Clear the overflow condition and leave loopback mode. */
 590         DP_OUT(base, DP_ISR, DP_ISR_OFLW);
 591         DP_OUT(base, DP_TCR, DP_TCR_NORMAL);
 592
 593         /*
 594          * If a transmit command was issued, but no transmit event has occured,
 595          * restart it here.
 596          */
 597         DP_IN(base, DP_ISR, isr);
 598         if (dp->tx_started && !(isr & (DP_ISR_TxP|DP_ISR_TxE))) {
 599                 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START);
 600         }
 601 }
 602
 603 static void
 604 dp83902a_poll(void)
 605 {
 606         struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic;
 607         u8 *base = dp->base;
 608         u8 isr;
 609
 610         DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0 | DP_CR_START);
 611         DP_IN(base, DP_ISR, isr);
 612         while (0 != isr) {
 613                 /*
 614                  * The CNT interrupt triggers when the MSB of one of the error
 615                  * counters is set. We don't much care about these counters, but
 616                  * we should read their values to reset them.
 617                  */
 618                 if (isr & DP_ISR_CNT) {
 619                         dp83902a_ClearCounters();
 620                 }
 621                 /*
 622                  * Check for overflow. It's a special case, since there's a
 623                  * particular procedure that must be followed to get back into
 624                  * a running state.a
 625                  */
 626                 if (isr & DP_ISR_OFLW) {
 627                         dp83902a_Overflow();
 628                 } else {
 629                         /*
 630                          * Other kinds of interrupts can be acknowledged simply by
 631                          * clearing the relevant bits of the ISR. Do that now, then
 632                          * handle the interrupts we care about.
 633                          */
 634                         DP_OUT(base, DP_ISR, isr);      /* Clear set bits */
 635                         if (!dp->running) break;        /* Is this necessary? */
 636                         /*
 637                          * Check for tx_started on TX event since these may happen
 638                          * spuriously it seems.
 639                          */
 640                         if (isr & (DP_ISR_TxP|DP_ISR_TxE) && dp->tx_started) {
 641                                 dp83902a_TxEvent();
 642                         }
 643                         if (isr & (DP_ISR_RxP|DP_ISR_RxE)) {
 644                                 dp83902a_RxEvent();
 645                         }
 646                 }
 647                 DP_IN(base, DP_ISR, isr);
 648         }
 649 }
 650
 651
 652 /* U-boot specific routines */
 653 static u8 *pbuf = NULL;
 654
 655 static int pkey = -1;
 656 static int initialized = 0;
 657
 658 void uboot_push_packet_len(int len) {
 659         PRINTK("pushed len = %d\n", len);
 660         if (len >= 2000) {
 661                 printf("NE2000: packet too big\n");
 662                 return;
 663         }
 664         dp83902a_recv(&pbuf[0], len);
 665
 666         /*Just pass it to the upper layer*/
 667         NetReceive(&pbuf[0], len);
 668 }
 669
 670 void uboot_push_tx_done(int key, int val) {
 671         PRINTK("pushed key = %d\n", key);
 672         pkey = key;
 673 }
 674
 675 /**
 676  * Setup the driver and init MAC address according to doc/README.enetaddr
 677  * Called by ne2k_register() before registering the driver @eth layer
 678  *
 679  * @param struct ethdevice of this instance of the driver for dev->enetaddr
 680  * @return 0 on success, -1 on error (causing caller to print error msg)
 681  */
 682 static int ne2k_setup_driver(struct eth_device *dev)
 683 {
 684         PRINTK("### ne2k_setup_driver\n");
 685
 686         if (!pbuf) {
 687                 pbuf = malloc(2000);
 688                 if (!pbuf) {
 689                         printf("Cannot allocate rx buffer\n");
 690                         return -1;
 691                 }
 692         }
 693
 694 #ifdef CONFIG_DRIVER_NE2000_CCR
 695         {
 696                 vu_char *p = (vu_char *) CONFIG_DRIVER_NE2000_CCR;
 697
 698                 PRINTK("CCR before is %x\n", *p);
 699                 *p = CONFIG_DRIVER_NE2000_VAL;
 700                 PRINTK("CCR after is %x\n", *p);
 701         }
 702 #endif
 703
 704         nic.base = (u8 *) CONFIG_DRIVER_NE2000_BASE;
 705
 706         nic.data = nic.base + DP_DATA;
 707         nic.tx_buf1 = START_PG;
 708         nic.tx_buf2 = START_PG2;
 709         nic.rx_buf_start = RX_START;
 710         nic.rx_buf_end = RX_END;
 711
 712         /*
 713          * According to doc/README.enetaddr, drivers shall give priority
 714          * to the MAC address value in the environment, so we do not read
 715          * it from the prom or eeprom if it is specified in the environment.
 716          */
 717         if (!eth_getenv_enetaddr("ethaddr", dev->enetaddr)) {
 718                 /* If the MAC address is not in the environment, get it: */
 719                 if (!get_prom(dev->enetaddr, nic.base)) /* get MAC from prom */
 720                         dp83902a_init(dev->enetaddr);   /* fallback: seeprom */
 721                 /* And write it into the environment otherwise eth_write_hwaddr
 722                  * returns -1 due to eth_getenv_enetaddr_by_index() failing,
 723                  * and this causes "Warning: failed to set MAC address", and
 724                  * cmd_bdinfo has no ethaddr value which it can show: */
 725                 eth_setenv_enetaddr("ethaddr", dev->enetaddr);
 726         }
 727         return 0;
 728 }
 729
 730 static int ne2k_init(struct eth_device *dev, bd_t *bd)
 731 {
 732         dp83902a_start(dev->enetaddr);
 733         initialized = 1;
 734         return 0;
 735 }
 736
 737 static void ne2k_halt(struct eth_device *dev)
 738 {
 739         debug("### ne2k_halt\n");
 740         if(initialized)
 741                 dp83902a_stop();
 742         initialized = 0;
 743 }
 744
 745 static int ne2k_recv(struct eth_device *dev)
 746 {
 747         dp83902a_poll();
 748         return 1;
 749 }
 750
 751 static int ne2k_send(struct eth_device *dev, volatile void *packet, int length)
 752 {
 753         int tmo;
 754
 755         debug("### ne2k_send\n");
 756
 757         pkey = -1;
 758
 759         dp83902a_send((u8 *) packet, length, 666);
 760         tmo = get_timer (0) + TOUT * CONFIG_SYS_HZ;
 761         while(1) {
 762                 dp83902a_poll();
 763                 if (pkey != -1) {
 764                         PRINTK("Packet sucesfully sent\n");
 765                         return 0;
 766                 }
 767                 if (get_timer (0) >= tmo) {
 768                         printf("transmission error (timoeut)\n");
 769                         return 0;
 770                 }
 771
 772         }
 773         return 0;
 774 }
 775
 776 /**
 777  * Setup the driver for use and register it with the eth layer
 778  * @return 0 on success, -1 on error (causing caller to print error msg)
 779  */
 780 int ne2k_register(void)
 781 {
 782         struct eth_device *dev;
 783
 784         dev = calloc(sizeof(*dev), 1);
 785         if (dev == NULL)
 786                 return -1;
 787
 788         if (ne2k_setup_driver(dev))
 789                 return -1;
 790
 791         dev->init = ne2k_init;
 792         dev->halt = ne2k_halt;
 793         dev->send = ne2k_send;
 794         dev->recv = ne2k_recv;
 795
 796         sprintf(dev->name, "NE2000");
 797
 798         return eth_register(dev);
 799 }