1 /* 2 Ported to U-Boot by Christian Pellegrin <chri@ascensit.com> 3 4 Based on sources from the Linux kernel (pcnet_cs.c, 8390.h) and 5 eCOS(if_dp83902a.c, if_dp83902a.h). Both of these 2 wonderful world 6 are GPL, so this is, of course, GPL. 7 8 ========================================================================== 9 10 dev/if_dp83902a.c 11 12 Ethernet device driver for NS DP83902a ethernet controller 13 14 ========================================================================== 15 ####ECOSGPLCOPYRIGHTBEGIN#### 16 ------------------------------------------- 17 This file is part of eCos, the Embedded Configurable Operating System. 18 Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. 19 20 eCos is free software; you can redistribute it and/or modify it under 21 the terms of the GNU General Public License as published by the Free 22 Software Foundation; either version 2 or (at your option) any later version. 23 24 eCos is distributed in the hope that it will be useful, but WITHOUT ANY 25 WARRANTY; without even the implied warranty of MERCHANTABILITY or 26 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 27 for more details. 28 29 You should have received a copy of the GNU General Public License along 30 with eCos; if not, write to the Free Software Foundation, Inc., 31 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 32 33 As a special exception, if other files instantiate templates or use macros 34 or inline functions from this file, or you compile this file and link it 35 with other works to produce a work based on this file, this file does not 36 by itself cause the resulting work to be covered by the GNU General Public 37 License. However the source code for this file must still be made available 38 in accordance with section (3) of the GNU General Public License. 39 40 This exception does not invalidate any other reasons why a work based on 41 this file might be covered by the GNU General Public License. 42 43 Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. 44 at http://sources.redhat.com/ecos/ecos-license/ 45 ------------------------------------------- 46 ####ECOSGPLCOPYRIGHTEND#### 47 ####BSDCOPYRIGHTBEGIN#### 48 49 ------------------------------------------- 50 51 Portions of this software may have been derived from OpenBSD or other sources, 52 and are covered by the appropriate copyright disclaimers included herein. 53 54 ------------------------------------------- 55 56 ####BSDCOPYRIGHTEND#### 57 ========================================================================== 58 #####DESCRIPTIONBEGIN#### 59 60 Author(s): gthomas 61 Contributors: gthomas, jskov, rsandifo 62 Date: 2001-06-13 63 Purpose: 64 Description: 65 66 FIXME: Will fail if pinged with large packets (1520 bytes) 67 Add promisc config 68 Add SNMP 69 70 ####DESCRIPTIONEND#### 71 72 ========================================================================== 73 */ 74 75 #include <common.h> 76 #include <command.h> 77 #include <net.h> 78 #include <malloc.h> 79 80 #define mdelay(n) udelay((n)*1000) 81 /* forward definition of function used for the uboot interface */ 82 void uboot_push_packet_len(int len); 83 void uboot_push_tx_done(int key, int val); 84 85 /* 86 ------------------------------------------------------------------------ 87 Debugging details 88 89 Set to perms of: 90 0 disables all debug output 91 1 for process debug output 92 2 for added data IO output: get_reg, put_reg 93 4 for packet allocation/free output 94 8 for only startup status, so we can tell we're installed OK 95 */ 96 /*#define DEBUG 0xf*/ 97 #define DEBUG 0 98 99 #if DEBUG & 1 100 #define DEBUG_FUNCTION() do { printf("%s\n", __FUNCTION__); } while (0) 101 #define DEBUG_LINE() do { printf("%d\n", __LINE__); } while (0) 102 #define PRINTK(args...) printf(args) 103 #else 104 #define DEBUG_FUNCTION() do {} while(0) 105 #define DEBUG_LINE() do {} while(0) 106 #define PRINTK(args...) 107 #endif 108 109 /* NE2000 base header file */ 110 #include "ne2000_base.h" 111 112 #if defined(CONFIG_DRIVER_AX88796L) 113 /* AX88796L support */ 114 #include "ax88796.h" 115 #else 116 /* Basic NE2000 chip support */ 117 #include "ne2000.h" 118 #endif 119 120 static dp83902a_priv_data_t nic; /* just one instance of the card supported */ 121 122 static bool 123 dp83902a_init(void) 124 { 125 dp83902a_priv_data_t *dp = &nic; 126 u8* base; 127 128 DEBUG_FUNCTION(); 129 130 base = dp->base; 131 if (!base) return false; /* No device found */ 132 133 DEBUG_LINE(); 134 135 #if defined(NE2000_BASIC_INIT) 136 /* AX88796L doesn't need */ 137 /* Prepare ESA */ 138 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1); /* Select page 1 */ 139 /* Use the address from the serial EEPROM */ 140 for (i = 0; i < 6; i++) 141 DP_IN(base, DP_P1_PAR0+i, dp->esa[i]); 142 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0); /* Select page 0 */ 143 144 printf("NE2000 - %s ESA: %02x:%02x:%02x:%02x:%02x:%02x\n", 145 "eeprom", 146 dp->esa[0], 147 dp->esa[1], 148 dp->esa[2], 149 dp->esa[3], 150 dp->esa[4], 151 dp->esa[5] ); 152 153 #endif /* NE2000_BASIC_INIT */ 154 return true; 155 } 156 157 static void 158 dp83902a_stop(void) 159 { 160 dp83902a_priv_data_t *dp = &nic; 161 u8 *base = dp->base; 162 163 DEBUG_FUNCTION(); 164 165 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */ 166 DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */ 167 DP_OUT(base, DP_IMR, 0x00); /* Disable all interrupts */ 168 169 dp->running = false; 170 } 171 172 /* 173 This function is called to "start up" the interface. It may be called 174 multiple times, even when the hardware is already running. It will be 175 called whenever something "hardware oriented" changes and should leave 176 the hardware ready to send/receive packets. 177 */ 178 static void 179 dp83902a_start(u8 * enaddr) 180 { 181 dp83902a_priv_data_t *dp = &nic; 182 u8 *base = dp->base; 183 int i; 184 185 DEBUG_FUNCTION(); 186 187 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_STOP); /* Brutal */ 188 DP_OUT(base, DP_DCR, DP_DCR_INIT); 189 DP_OUT(base, DP_RBCH, 0); /* Remote byte count */ 190 DP_OUT(base, DP_RBCL, 0); 191 DP_OUT(base, DP_RCR, DP_RCR_MON); /* Accept no packets */ 192 DP_OUT(base, DP_TCR, DP_TCR_LOCAL); /* Transmitter [virtually] off */ 193 DP_OUT(base, DP_TPSR, dp->tx_buf1); /* Transmitter start page */ 194 dp->tx1 = dp->tx2 = 0; 195 dp->tx_next = dp->tx_buf1; 196 dp->tx_started = false; 197 dp->running = true; 198 DP_OUT(base, DP_PSTART, dp->rx_buf_start); /* Receive ring start page */ 199 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1); /* Receive ring boundary */ 200 DP_OUT(base, DP_PSTOP, dp->rx_buf_end); /* Receive ring end page */ 201 dp->rx_next = dp->rx_buf_start-1; 202 dp->running = true; 203 DP_OUT(base, DP_ISR, 0xFF); /* Clear any pending interrupts */ 204 DP_OUT(base, DP_IMR, DP_IMR_All); /* Enable all interrupts */ 205 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE1 | DP_CR_STOP); /* Select page 1 */ 206 DP_OUT(base, DP_P1_CURP, dp->rx_buf_start); /* Current page - next free page for Rx */ 207 dp->running = true; 208 for (i = 0; i < ETHER_ADDR_LEN; i++) { 209 /* FIXME */ 210 /*((vu_short*)( base + ((DP_P1_PAR0 + i) * 2) + 211 * 0x1400)) = enaddr[i];*/ 212 DP_OUT(base, DP_P1_PAR0+i, enaddr[i]); 213 } 214 /* Enable and start device */ 215 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START); 216 DP_OUT(base, DP_TCR, DP_TCR_NORMAL); /* Normal transmit operations */ 217 DP_OUT(base, DP_RCR, DP_RCR_AB); /* Accept broadcast, no errors, no multicast */ 218 dp->running = true; 219 } 220 221 /* 222 This routine is called to start the transmitter. It is split out from the 223 data handling routine so it may be called either when data becomes first 224 available or when an Tx interrupt occurs 225 */ 226 227 static void 228 dp83902a_start_xmit(int start_page, int len) 229 { 230 dp83902a_priv_data_t *dp = (dp83902a_priv_data_t *) &nic; 231 u8 *base = dp->base; 232 233 DEBUG_FUNCTION(); 234 235 #if DEBUG & 1 236 printf("Tx pkt %d len %d\n", start_page, len); 237 if (dp->tx_started) 238 printf("TX already started?!?\n"); 239 #endif 240 241 DP_OUT(base, DP_ISR, (DP_ISR_TxP | DP_ISR_TxE)); 242 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START); 243 DP_OUT(base, DP_TBCL, len & 0xFF); 244 DP_OUT(base, DP_TBCH, len >> 8); 245 DP_OUT(base, DP_TPSR, start_page); 246 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START); 247 248 dp->tx_started = true; 249 } 250 251 /* 252 This routine is called to send data to the hardware. It is known a-priori 253 that there is free buffer space (dp->tx_next). 254 */ 255 static void 256 dp83902a_send(u8 *data, int total_len, u32 key) 257 { 258 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic; 259 u8 *base = dp->base; 260 int len, start_page, pkt_len, i, isr; 261 #if DEBUG & 4 262 int dx; 263 #endif 264 265 DEBUG_FUNCTION(); 266 267 len = pkt_len = total_len; 268 if (pkt_len < IEEE_8023_MIN_FRAME) pkt_len = IEEE_8023_MIN_FRAME; 269 270 start_page = dp->tx_next; 271 if (dp->tx_next == dp->tx_buf1) { 272 dp->tx1 = start_page; 273 dp->tx1_len = pkt_len; 274 dp->tx1_key = key; 275 dp->tx_next = dp->tx_buf2; 276 } else { 277 dp->tx2 = start_page; 278 dp->tx2_len = pkt_len; 279 dp->tx2_key = key; 280 dp->tx_next = dp->tx_buf1; 281 } 282 283 #if DEBUG & 5 284 printf("TX prep page %d len %d\n", start_page, pkt_len); 285 #endif 286 287 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */ 288 { 289 /* Dummy read. The manual sez something slightly different, */ 290 /* but the code is extended a bit to do what Hitachi's monitor */ 291 /* does (i.e., also read data). */ 292 293 u16 tmp; 294 int len = 1; 295 296 DP_OUT(base, DP_RSAL, 0x100-len); 297 DP_OUT(base, DP_RSAH, (start_page-1) & 0xff); 298 DP_OUT(base, DP_RBCL, len); 299 DP_OUT(base, DP_RBCH, 0); 300 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_RDMA | DP_CR_START); 301 DP_IN_DATA(dp->data, tmp); 302 } 303 304 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA 305 /* Stall for a bit before continuing to work around random data */ 306 /* corruption problems on some platforms. */ 307 CYGACC_CALL_IF_DELAY_US(1); 308 #endif 309 310 /* Send data to device buffer(s) */ 311 DP_OUT(base, DP_RSAL, 0); 312 DP_OUT(base, DP_RSAH, start_page); 313 DP_OUT(base, DP_RBCL, pkt_len & 0xFF); 314 DP_OUT(base, DP_RBCH, pkt_len >> 8); 315 DP_OUT(base, DP_CR, DP_CR_WDMA | DP_CR_START); 316 317 /* Put data into buffer */ 318 #if DEBUG & 4 319 printf(" sg buf %08lx len %08x\n ", (u32)data, len); 320 dx = 0; 321 #endif 322 while (len > 0) { 323 #if DEBUG & 4 324 printf(" %02x", *data); 325 if (0 == (++dx % 16)) printf("\n "); 326 #endif 327 328 DP_OUT_DATA(dp->data, *data++); 329 len--; 330 } 331 #if DEBUG & 4 332 printf("\n"); 333 #endif 334 if (total_len < pkt_len) { 335 #if DEBUG & 4 336 printf(" + %d bytes of padding\n", pkt_len - total_len); 337 #endif 338 /* Padding to 802.3 length was required */ 339 for (i = total_len; i < pkt_len;) { 340 i++; 341 DP_OUT_DATA(dp->data, 0); 342 } 343 } 344 345 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_TX_DMA 346 /* After last data write, delay for a bit before accessing the */ 347 /* device again, or we may get random data corruption in the last */ 348 /* datum (on some platforms). */ 349 CYGACC_CALL_IF_DELAY_US(1); 350 #endif 351 352 /* Wait for DMA to complete */ 353 do { 354 DP_IN(base, DP_ISR, isr); 355 } while ((isr & DP_ISR_RDC) == 0); 356 357 /* Then disable DMA */ 358 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START); 359 360 /* Start transmit if not already going */ 361 if (!dp->tx_started) { 362 if (start_page == dp->tx1) { 363 dp->tx_int = 1; /* Expecting interrupt from BUF1 */ 364 } else { 365 dp->tx_int = 2; /* Expecting interrupt from BUF2 */ 366 } 367 dp83902a_start_xmit(start_page, pkt_len); 368 } 369 } 370 371 /* 372 This function is called when a packet has been received. It's job is 373 to prepare to unload the packet from the hardware. Once the length of 374 the packet is known, the upper layer of the driver can be told. When 375 the upper layer is ready to unload the packet, the internal function 376 'dp83902a_recv' will be called to actually fetch it from the hardware. 377 */ 378 static void 379 dp83902a_RxEvent(void) 380 { 381 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic; 382 u8 *base = dp->base; 383 u8 rsr; 384 u8 rcv_hdr[4]; 385 int i, len, pkt, cur; 386 387 DEBUG_FUNCTION(); 388 389 DP_IN(base, DP_RSR, rsr); 390 while (true) { 391 /* Read incoming packet header */ 392 DP_OUT(base, DP_CR, DP_CR_PAGE1 | DP_CR_NODMA | DP_CR_START); 393 DP_IN(base, DP_P1_CURP, cur); 394 DP_OUT(base, DP_P1_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START); 395 DP_IN(base, DP_BNDRY, pkt); 396 397 pkt += 1; 398 if (pkt == dp->rx_buf_end) 399 pkt = dp->rx_buf_start; 400 401 if (pkt == cur) { 402 break; 403 } 404 DP_OUT(base, DP_RBCL, sizeof(rcv_hdr)); 405 DP_OUT(base, DP_RBCH, 0); 406 DP_OUT(base, DP_RSAL, 0); 407 DP_OUT(base, DP_RSAH, pkt); 408 if (dp->rx_next == pkt) { 409 if (cur == dp->rx_buf_start) 410 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1); 411 else 412 DP_OUT(base, DP_BNDRY, cur-1); /* Update pointer */ 413 return; 414 } 415 dp->rx_next = pkt; 416 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */ 417 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START); 418 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA 419 CYGACC_CALL_IF_DELAY_US(10); 420 #endif 421 422 /* read header (get data size)*/ 423 for (i = 0; i < sizeof(rcv_hdr);) { 424 DP_IN_DATA(dp->data, rcv_hdr[i++]); 425 } 426 427 #if DEBUG & 5 428 printf("rx hdr %02x %02x %02x %02x\n", 429 rcv_hdr[0], rcv_hdr[1], rcv_hdr[2], rcv_hdr[3]); 430 #endif 431 len = ((rcv_hdr[3] << 8) | rcv_hdr[2]) - sizeof(rcv_hdr); 432 433 /* data read */ 434 uboot_push_packet_len(len); 435 436 if (rcv_hdr[1] == dp->rx_buf_start) 437 DP_OUT(base, DP_BNDRY, dp->rx_buf_end-1); 438 else 439 DP_OUT(base, DP_BNDRY, rcv_hdr[1]-1); /* Update pointer */ 440 } 441 } 442 443 /* 444 This function is called as a result of the "eth_drv_recv()" call above. 445 It's job is to actually fetch data for a packet from the hardware once 446 memory buffers have been allocated for the packet. Note that the buffers 447 may come in pieces, using a scatter-gather list. This allows for more 448 efficient processing in the upper layers of the stack. 449 */ 450 static void 451 dp83902a_recv(u8 *data, int len) 452 { 453 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic; 454 u8 *base = dp->base; 455 int i, mlen; 456 u8 saved_char = 0; 457 bool saved; 458 #if DEBUG & 4 459 int dx; 460 #endif 461 462 DEBUG_FUNCTION(); 463 464 #if DEBUG & 5 465 printf("Rx packet %d length %d\n", dp->rx_next, len); 466 #endif 467 468 /* Read incoming packet data */ 469 DP_OUT(base, DP_CR, DP_CR_PAGE0 | DP_CR_NODMA | DP_CR_START); 470 DP_OUT(base, DP_RBCL, len & 0xFF); 471 DP_OUT(base, DP_RBCH, len >> 8); 472 DP_OUT(base, DP_RSAL, 4); /* Past header */ 473 DP_OUT(base, DP_RSAH, dp->rx_next); 474 DP_OUT(base, DP_ISR, DP_ISR_RDC); /* Clear end of DMA */ 475 DP_OUT(base, DP_CR, DP_CR_RDMA | DP_CR_START); 476 #ifdef CYGHWR_NS_DP83902A_PLF_BROKEN_RX_DMA 477 CYGACC_CALL_IF_DELAY_US(10); 478 #endif 479 480 saved = false; 481 for (i = 0; i < 1; i++) { 482 if (data) { 483 mlen = len; 484 #if DEBUG & 4 485 printf(" sg buf %08lx len %08x \n", (u32) data, mlen); 486 dx = 0; 487 #endif 488 while (0 < mlen) { 489 /* Saved byte from previous loop? */ 490 if (saved) { 491 *data++ = saved_char; 492 mlen--; 493 saved = false; 494 continue; 495 } 496 497 { 498 u8 tmp; 499 DP_IN_DATA(dp->data, tmp); 500 #if DEBUG & 4 501 printf(" %02x", tmp); 502 if (0 == (++dx % 16)) printf("\n "); 503 #endif 504 *data++ = tmp;; 505 mlen--; 506 } 507 } 508 #if DEBUG & 4 509 printf("\n"); 510 #endif 511 } 512 } 513 } 514 515 static void 516 dp83902a_TxEvent(void) 517 { 518 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic; 519 u8 *base = dp->base; 520 u8 tsr; 521 u32 key; 522 523 DEBUG_FUNCTION(); 524 525 DP_IN(base, DP_TSR, tsr); 526 if (dp->tx_int == 1) { 527 key = dp->tx1_key; 528 dp->tx1 = 0; 529 } else { 530 key = dp->tx2_key; 531 dp->tx2 = 0; 532 } 533 /* Start next packet if one is ready */ 534 dp->tx_started = false; 535 if (dp->tx1) { 536 dp83902a_start_xmit(dp->tx1, dp->tx1_len); 537 dp->tx_int = 1; 538 } else if (dp->tx2) { 539 dp83902a_start_xmit(dp->tx2, dp->tx2_len); 540 dp->tx_int = 2; 541 } else { 542 dp->tx_int = 0; 543 } 544 /* Tell higher level we sent this packet */ 545 uboot_push_tx_done(key, 0); 546 } 547 548 /* Read the tally counters to clear them. Called in response to a CNT */ 549 /* interrupt. */ 550 static void 551 dp83902a_ClearCounters(void) 552 { 553 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic; 554 u8 *base = dp->base; 555 u8 cnt1, cnt2, cnt3; 556 557 DP_IN(base, DP_FER, cnt1); 558 DP_IN(base, DP_CER, cnt2); 559 DP_IN(base, DP_MISSED, cnt3); 560 DP_OUT(base, DP_ISR, DP_ISR_CNT); 561 } 562 563 /* Deal with an overflow condition. This code follows the procedure set */ 564 /* out in section 7.0 of the datasheet. */ 565 static void 566 dp83902a_Overflow(void) 567 { 568 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *)&nic; 569 u8 *base = dp->base; 570 u8 isr; 571 572 /* Issue a stop command and wait 1.6ms for it to complete. */ 573 DP_OUT(base, DP_CR, DP_CR_STOP | DP_CR_NODMA); 574 CYGACC_CALL_IF_DELAY_US(1600); 575 576 /* Clear the remote byte counter registers. */ 577 DP_OUT(base, DP_RBCL, 0); 578 DP_OUT(base, DP_RBCH, 0); 579 580 /* Enter loopback mode while we clear the buffer. */ 581 DP_OUT(base, DP_TCR, DP_TCR_LOCAL); 582 DP_OUT(base, DP_CR, DP_CR_START | DP_CR_NODMA); 583 584 /* Read in as many packets as we can and acknowledge any and receive */ 585 /* interrupts. Since the buffer has overflowed, a receive event of */ 586 /* some kind will have occured. */ 587 dp83902a_RxEvent(); 588 DP_OUT(base, DP_ISR, DP_ISR_RxP|DP_ISR_RxE); 589 590 /* Clear the overflow condition and leave loopback mode. */ 591 DP_OUT(base, DP_ISR, DP_ISR_OFLW); 592 DP_OUT(base, DP_TCR, DP_TCR_NORMAL); 593 594 /* If a transmit command was issued, but no transmit event has occured, */ 595 /* restart it here. */ 596 DP_IN(base, DP_ISR, isr); 597 if (dp->tx_started && !(isr & (DP_ISR_TxP|DP_ISR_TxE))) { 598 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_TXPKT | DP_CR_START); 599 } 600 } 601 602 static void 603 dp83902a_poll(void) 604 { 605 struct dp83902a_priv_data *dp = (struct dp83902a_priv_data *) &nic; 606 u8 *base = dp->base; 607 u8 isr; 608 609 DP_OUT(base, DP_CR, DP_CR_NODMA | DP_CR_PAGE0 | DP_CR_START); 610 DP_IN(base, DP_ISR, isr); 611 while (0 != isr) { 612 /* The CNT interrupt triggers when the MSB of one of the error */ 613 /* counters is set. We don't much care about these counters, but */ 614 /* we should read their values to reset them. */ 615 if (isr & DP_ISR_CNT) { 616 dp83902a_ClearCounters(); 617 } 618 /* Check for overflow. It's a special case, since there's a */ 619 /* particular procedure that must be followed to get back into */ 620 /* a running state.a */ 621 if (isr & DP_ISR_OFLW) { 622 dp83902a_Overflow(); 623 } else { 624 /* Other kinds of interrupts can be acknowledged simply by */ 625 /* clearing the relevant bits of the ISR. Do that now, then */ 626 /* handle the interrupts we care about. */ 627 DP_OUT(base, DP_ISR, isr); /* Clear set bits */ 628 if (!dp->running) break; /* Is this necessary? */ 629 /* Check for tx_started on TX event since these may happen */ 630 /* spuriously it seems. */ 631 if (isr & (DP_ISR_TxP|DP_ISR_TxE) && dp->tx_started) { 632 dp83902a_TxEvent(); 633 } 634 if (isr & (DP_ISR_RxP|DP_ISR_RxE)) { 635 dp83902a_RxEvent(); 636 } 637 } 638 DP_IN(base, DP_ISR, isr); 639 } 640 } 641 642 /* find prom (taken from pc_net_cs.c from Linux) */ 643 644 #include "8390.h" 645 /* 646 typedef struct hw_info_t { 647 u_int offset; 648 u_char a0, a1, a2; 649 u_int flags; 650 } hw_info_t; 651 */ 652 #define DELAY_OUTPUT 0x01 653 #define HAS_MISC_REG 0x02 654 #define USE_BIG_BUF 0x04 655 #define HAS_IBM_MISC 0x08 656 #define IS_DL10019 0x10 657 #define IS_DL10022 0x20 658 #define HAS_MII 0x40 659 #define USE_SHMEM 0x80 /* autodetected */ 660 661 #define AM79C9XX_HOME_PHY 0x00006B90 /* HomePNA PHY */ 662 #define AM79C9XX_ETH_PHY 0x00006B70 /* 10baseT PHY */ 663 #define MII_PHYID_REV_MASK 0xfffffff0 664 #define MII_PHYID_REG1 0x02 665 #define MII_PHYID_REG2 0x03 666 667 static hw_info_t hw_info[] = { 668 { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT }, 669 { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 }, 670 { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 }, 671 { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94, 672 DELAY_OUTPUT | HAS_IBM_MISC }, 673 { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 }, 674 { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 }, 675 { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 }, 676 { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 }, 677 { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 }, 678 { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 }, 679 { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48, 680 HAS_MISC_REG | HAS_IBM_MISC }, 681 { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 }, 682 { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 }, 683 { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a, 684 HAS_MISC_REG | HAS_IBM_MISC }, 685 { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac, 686 HAS_MISC_REG | HAS_IBM_MISC }, 687 { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29, 688 HAS_MISC_REG | HAS_IBM_MISC }, 689 { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a, 690 HAS_MISC_REG | HAS_IBM_MISC }, 691 { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac, 692 HAS_MISC_REG | HAS_IBM_MISC }, 693 { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87, 694 HAS_MISC_REG | HAS_IBM_MISC }, 695 { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17, 696 HAS_MISC_REG | HAS_IBM_MISC }, 697 { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8, 698 HAS_MISC_REG | HAS_IBM_MISC }, 699 { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0, 700 HAS_MISC_REG | HAS_IBM_MISC }, 701 { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0, 702 HAS_MISC_REG | HAS_IBM_MISC }, 703 { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 }, 704 { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 }, 705 { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0, 706 HAS_MISC_REG | HAS_IBM_MISC }, 707 { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f, 708 HAS_MISC_REG | HAS_IBM_MISC }, 709 { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 }, 710 { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 }, 711 { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 }, 712 { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 }, 713 { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65, 714 HAS_MISC_REG | HAS_IBM_MISC }, 715 { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45, 716 HAS_MISC_REG | HAS_IBM_MISC }, 717 { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 }, 718 { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 }, 719 { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 }, 720 { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b, 721 DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF }, 722 { /* Socket LP-E CF+ */ 0x01c0, 0x00, 0xc0, 0x1b, 0 }, 723 { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 }, 724 { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 }, 725 { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 }, 726 { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 }, 727 { /* Qemu */ 0x0, 0x52, 0x54, 0x00, 0 } 728 }; 729 730 #define NR_INFO (sizeof(hw_info)/sizeof(hw_info_t)) 731 732 static hw_info_t default_info = { 0, 0, 0, 0, 0 }; 733 734 u8 dev_addr[6]; 735 736 #define PCNET_CMD 0x00 737 #define PCNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */ 738 #define PCNET_RESET 0x1f /* Issue a read to reset, a write to clear. */ 739 #define PCNET_MISC 0x18 /* For IBM CCAE and Socket EA cards */ 740 741 u32 nic_base; 742 743 /* U-boot specific routines */ 744 static u8 *pbuf = NULL; 745 746 static int pkey = -1; 747 static int initialized=0; 748 749 void uboot_push_packet_len(int len) { 750 PRINTK("pushed len = %d\n", len); 751 if (len>=2000) { 752 printf("NE2000: packet too big\n"); 753 return; 754 } 755 dp83902a_recv(&pbuf[0], len); 756 757 /*Just pass it to the upper layer*/ 758 NetReceive(&pbuf[0], len); 759 } 760 761 void uboot_push_tx_done(int key, int val) { 762 PRINTK("pushed key = %d\n", key); 763 pkey = key; 764 } 765 766 int eth_init(bd_t *bd) { 767 static hw_info_t * r; 768 char ethaddr[20]; 769 770 PRINTK("### eth_init\n"); 771 772 if (!pbuf) { 773 pbuf = malloc(2000); 774 if (!pbuf) { 775 printf("Cannot allocate rx buffer\n"); 776 return -1; 777 } 778 } 779 780 #ifdef CONFIG_DRIVER_NE2000_CCR 781 { 782 vu_char *p = (vu_char *) CONFIG_DRIVER_NE2000_CCR; 783 784 PRINTK("CCR before is %x\n", *p); 785 *p = CONFIG_DRIVER_NE2000_VAL; 786 PRINTK("CCR after is %x\n", *p); 787 } 788 #endif 789 790 nic_base = CONFIG_DRIVER_NE2000_BASE; 791 nic.base = (u8 *) CONFIG_DRIVER_NE2000_BASE; 792 793 r = get_prom(dev_addr); 794 if (!r) 795 return -1; 796 797 sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X", 798 dev_addr[0], dev_addr[1], 799 dev_addr[2], dev_addr[3], 800 dev_addr[4], dev_addr[5]) ; 801 PRINTK("Set environment from HW MAC addr = \"%s\"\n", ethaddr); 802 setenv ("ethaddr", ethaddr); 803 804 nic.data = nic.base + DP_DATA; 805 nic.tx_buf1 = START_PG; 806 nic.tx_buf2 = START_PG2; 807 nic.rx_buf_start = RX_START; 808 nic.rx_buf_end = RX_END; 809 810 if (dp83902a_init() == false) 811 return -1; 812 813 dp83902a_start(dev_addr); 814 initialized=1; 815 816 return 0; 817 } 818 819 void eth_halt() { 820 821 PRINTK("### eth_halt\n"); 822 if(initialized) 823 dp83902a_stop(); 824 initialized=0; 825 } 826 827 int eth_rx() { 828 dp83902a_poll(); 829 return 1; 830 } 831 832 int eth_send(volatile void *packet, int length) { 833 int tmo; 834 835 PRINTK("### eth_send\n"); 836 837 pkey = -1; 838 839 dp83902a_send((u8 *) packet, length, 666); 840 tmo = get_timer (0) + TOUT * CFG_HZ; 841 while(1) { 842 dp83902a_poll(); 843 if (pkey != -1) { 844 PRINTK("Packet sucesfully sent\n"); 845 return 0; 846 } 847 if (get_timer (0) >= tmo) { 848 printf("transmission error (timoeut)\n"); 849 return 0; 850 } 851 852 } 853 return 0; 854 } 855