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