1 /*------------------------------------------------------------------------ 2 * lan91c96.c 3 * This is a driver for SMSC's LAN91C96 single-chip Ethernet device, based 4 * on the SMC91111 driver from U-boot. 5 * 6 * (C) Copyright 2002 7 * Sysgo Real-Time Solutions, GmbH <www.elinos.com> 8 * Rolf Offermanns <rof@sysgo.de> 9 * 10 * Copyright (C) 2001 Standard Microsystems Corporation (SMSC) 11 * Developed by Simple Network Magic Corporation (SNMC) 12 * Copyright (C) 1996 by Erik Stahlman (ES) 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2 of the License, or 17 * (at your option) any later version. 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 27 * 28 * Information contained in this file was obtained from the LAN91C96 29 * manual from SMC. To get a copy, if you really want one, you can find 30 * information under www.smsc.com. 31 * 32 * 33 * "Features" of the SMC chip: 34 * 6144 byte packet memory. ( for the 91C96 ) 35 * EEPROM for configuration 36 * AUI/TP selection ( mine has 10Base2/10BaseT select ) 37 * 38 * Arguments: 39 * io = for the base address 40 * irq = for the IRQ 41 * 42 * author: 43 * Erik Stahlman ( erik@vt.edu ) 44 * Daris A Nevil ( dnevil@snmc.com ) 45 * 46 * 47 * Hardware multicast code from Peter Cammaert ( pc@denkart.be ) 48 * 49 * Sources: 50 * o SMSC LAN91C96 databook (www.smsc.com) 51 * o smc91111.c (u-boot driver) 52 * o smc9194.c (linux kernel driver) 53 * o lan91c96.c (Intel Diagnostic Manager driver) 54 * 55 * History: 56 * 04/30/03 Mathijs Haarman Modified smc91111.c (u-boot version) 57 * for lan91c96 58 *--------------------------------------------------------------------------- 59 */ 60 61 #include <common.h> 62 #include <command.h> 63 #include <malloc.h> 64 #include "lan91c96.h" 65 #include <net.h> 66 #include <linux/compiler.h> 67 68 /*------------------------------------------------------------------------ 69 * 70 * Configuration options, for the experienced user to change. 71 * 72 -------------------------------------------------------------------------*/ 73 74 /* Use power-down feature of the chip */ 75 #define POWER_DOWN 0 76 77 /* 78 * Wait time for memory to be free. This probably shouldn't be 79 * tuned that much, as waiting for this means nothing else happens 80 * in the system 81 */ 82 #define MEMORY_WAIT_TIME 16 83 84 #define SMC_DEBUG 0 85 86 #if (SMC_DEBUG > 2 ) 87 #define PRINTK3(args...) printf(args) 88 #else 89 #define PRINTK3(args...) 90 #endif 91 92 #if SMC_DEBUG > 1 93 #define PRINTK2(args...) printf(args) 94 #else 95 #define PRINTK2(args...) 96 #endif 97 98 #ifdef SMC_DEBUG 99 #define PRINTK(args...) printf(args) 100 #else 101 #define PRINTK(args...) 102 #endif 103 104 105 /*------------------------------------------------------------------------ 106 * 107 * The internal workings of the driver. If you are changing anything 108 * here with the SMC stuff, you should have the datasheet and know 109 * what you are doing. 110 * 111 *------------------------------------------------------------------------ 112 */ 113 #define DRIVER_NAME "LAN91C96" 114 #define SMC_ALLOC_MAX_TRY 5 115 #define SMC_TX_TIMEOUT 30 116 117 #define ETH_ZLEN 60 118 119 #ifdef CONFIG_LAN91C96_USE_32_BIT 120 #define USE_32_BIT 1 121 #else 122 #undef USE_32_BIT 123 #endif 124 125 /* See if a MAC address is defined in the current environment. If so use it. If not 126 . print a warning and set the environment and other globals with the default. 127 . If an EEPROM is present it really should be consulted. 128 */ 129 static int smc_get_ethaddr(bd_t *bd, struct eth_device *dev); 130 static int get_rom_mac(struct eth_device *dev, unsigned char *v_rom_mac); 131 132 /* ------------------------------------------------------------ 133 * Internal routines 134 * ------------------------------------------------------------ 135 */ 136 137 static unsigned char smc_mac_addr[] = { 0xc0, 0x00, 0x00, 0x1b, 0x62, 0x9c }; 138 139 /* 140 * This function must be called before smc_open() if you want to override 141 * the default mac address. 142 */ 143 144 static void smc_set_mac_addr(const unsigned char *addr) 145 { 146 int i; 147 148 for (i = 0; i < sizeof (smc_mac_addr); i++) { 149 smc_mac_addr[i] = addr[i]; 150 } 151 } 152 153 /*********************************************** 154 * Show available memory * 155 ***********************************************/ 156 void dump_memory_info(struct eth_device *dev) 157 { 158 __maybe_unused word mem_info; 159 word old_bank; 160 161 old_bank = SMC_inw(dev, LAN91C96_BANK_SELECT) & 0xF; 162 163 SMC_SELECT_BANK(dev, 0); 164 mem_info = SMC_inw(dev, LAN91C96_MIR); 165 PRINTK2 ("Memory: %4d available\n", (mem_info >> 8) * 2048); 166 167 SMC_SELECT_BANK(dev, old_bank); 168 } 169 170 /* 171 * A rather simple routine to print out a packet for debugging purposes. 172 */ 173 #if SMC_DEBUG > 2 174 static void print_packet (byte *, int); 175 #endif 176 177 static int poll4int (struct eth_device *dev, byte mask, int timeout) 178 { 179 int tmo = get_timer (0) + timeout * CONFIG_SYS_HZ; 180 int is_timeout = 0; 181 word old_bank = SMC_inw(dev, LAN91C96_BANK_SELECT); 182 183 PRINTK2 ("Polling...\n"); 184 SMC_SELECT_BANK(dev, 2); 185 while ((SMC_inw(dev, LAN91C96_INT_STATS) & mask) == 0) { 186 if (get_timer (0) >= tmo) { 187 is_timeout = 1; 188 break; 189 } 190 } 191 192 /* restore old bank selection */ 193 SMC_SELECT_BANK(dev, old_bank); 194 195 if (is_timeout) 196 return 1; 197 else 198 return 0; 199 } 200 201 /* 202 * Function: smc_reset 203 * Purpose: 204 * This sets the SMC91111 chip to its normal state, hopefully from whatever 205 * mess that any other DOS driver has put it in. 206 * 207 * Maybe I should reset more registers to defaults in here? SOFTRST should 208 * do that for me. 209 * 210 * Method: 211 * 1. send a SOFT RESET 212 * 2. wait for it to finish 213 * 3. enable autorelease mode 214 * 4. reset the memory management unit 215 * 5. clear all interrupts 216 * 217 */ 218 static void smc_reset(struct eth_device *dev) 219 { 220 PRINTK2("%s:smc_reset\n", dev->name); 221 222 /* This resets the registers mostly to defaults, but doesn't 223 affect EEPROM. That seems unnecessary */ 224 SMC_SELECT_BANK(dev, 0); 225 SMC_outw(dev, LAN91C96_RCR_SOFT_RST, LAN91C96_RCR); 226 227 udelay (10); 228 229 /* Disable transmit and receive functionality */ 230 SMC_outw(dev, 0, LAN91C96_RCR); 231 SMC_outw(dev, 0, LAN91C96_TCR); 232 233 /* set the control register */ 234 SMC_SELECT_BANK(dev, 1); 235 SMC_outw(dev, SMC_inw(dev, LAN91C96_CONTROL) | LAN91C96_CTR_BIT_8, 236 LAN91C96_CONTROL); 237 238 /* Disable all interrupts */ 239 SMC_outb(dev, 0, LAN91C96_INT_MASK); 240 } 241 242 /* 243 * Function: smc_enable 244 * Purpose: let the chip talk to the outside work 245 * Method: 246 * 1. Initialize the Memory Configuration Register 247 * 2. Enable the transmitter 248 * 3. Enable the receiver 249 */ 250 static void smc_enable(struct eth_device *dev) 251 { 252 PRINTK2("%s:smc_enable\n", dev->name); 253 SMC_SELECT_BANK(dev, 0); 254 255 /* Initialize the Memory Configuration Register. See page 256 49 of the LAN91C96 data sheet for details. */ 257 SMC_outw(dev, LAN91C96_MCR_TRANSMIT_PAGES, LAN91C96_MCR); 258 259 /* Initialize the Transmit Control Register */ 260 SMC_outw(dev, LAN91C96_TCR_TXENA, LAN91C96_TCR); 261 /* Initialize the Receive Control Register 262 * FIXME: 263 * The promiscuous bit set because I could not receive ARP reply 264 * packets from the server when I send a ARP request. It only works 265 * when I set the promiscuous bit 266 */ 267 SMC_outw(dev, LAN91C96_RCR_RXEN | LAN91C96_RCR_PRMS, LAN91C96_RCR); 268 } 269 270 /* 271 * Function: smc_shutdown 272 * Purpose: closes down the SMC91xxx chip. 273 * Method: 274 * 1. zero the interrupt mask 275 * 2. clear the enable receive flag 276 * 3. clear the enable xmit flags 277 * 278 * TODO: 279 * (1) maybe utilize power down mode. 280 * Why not yet? Because while the chip will go into power down mode, 281 * the manual says that it will wake up in response to any I/O requests 282 * in the register space. Empirical results do not show this working. 283 */ 284 static void smc_shutdown(struct eth_device *dev) 285 { 286 PRINTK2("%s:smc_shutdown\n", dev->name); 287 288 /* no more interrupts for me */ 289 SMC_SELECT_BANK(dev, 2); 290 SMC_outb(dev, 0, LAN91C96_INT_MASK); 291 292 /* and tell the card to stay away from that nasty outside world */ 293 SMC_SELECT_BANK(dev, 0); 294 SMC_outb(dev, 0, LAN91C96_RCR); 295 SMC_outb(dev, 0, LAN91C96_TCR); 296 } 297 298 299 /* 300 * Function: smc_hardware_send_packet(struct net_device * ) 301 * Purpose: 302 * This sends the actual packet to the SMC9xxx chip. 303 * 304 * Algorithm: 305 * First, see if a saved_skb is available. 306 * ( this should NOT be called if there is no 'saved_skb' 307 * Now, find the packet number that the chip allocated 308 * Point the data pointers at it in memory 309 * Set the length word in the chip's memory 310 * Dump the packet to chip memory 311 * Check if a last byte is needed ( odd length packet ) 312 * if so, set the control flag right 313 * Tell the card to send it 314 * Enable the transmit interrupt, so I know if it failed 315 * Free the kernel data if I actually sent it. 316 */ 317 static int smc_send_packet(struct eth_device *dev, volatile void *packet, 318 int packet_length) 319 { 320 byte packet_no; 321 byte *buf; 322 int length; 323 int numPages; 324 int try = 0; 325 int time_out; 326 byte status; 327 328 329 PRINTK3("%s:smc_hardware_send_packet\n", dev->name); 330 331 length = ETH_ZLEN < packet_length ? packet_length : ETH_ZLEN; 332 333 /* allocate memory 334 ** The MMU wants the number of pages to be the number of 256 bytes 335 ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) ) 336 ** 337 ** The 91C111 ignores the size bits, but the code is left intact 338 ** for backwards and future compatibility. 339 ** 340 ** Pkt size for allocating is data length +6 (for additional status 341 ** words, length and ctl!) 342 ** 343 ** If odd size then last byte is included in this header. 344 */ 345 numPages = ((length & 0xfffe) + 6); 346 numPages >>= 8; /* Divide by 256 */ 347 348 if (numPages > 7) { 349 printf("%s: Far too big packet error. \n", dev->name); 350 return 0; 351 } 352 353 /* now, try to allocate the memory */ 354 355 SMC_SELECT_BANK(dev, 2); 356 SMC_outw(dev, LAN91C96_MMUCR_ALLOC_TX | numPages, LAN91C96_MMU); 357 358 again: 359 try++; 360 time_out = MEMORY_WAIT_TIME; 361 do { 362 status = SMC_inb(dev, LAN91C96_INT_STATS); 363 if (status & LAN91C96_IST_ALLOC_INT) { 364 365 SMC_outb(dev, LAN91C96_IST_ALLOC_INT, 366 LAN91C96_INT_STATS); 367 break; 368 } 369 } while (--time_out); 370 371 if (!time_out) { 372 PRINTK2 ("%s: memory allocation, try %d failed ...\n", 373 dev->name, try); 374 if (try < SMC_ALLOC_MAX_TRY) 375 goto again; 376 else 377 return 0; 378 } 379 380 PRINTK2 ("%s: memory allocation, try %d succeeded ...\n", 381 dev->name, try); 382 383 /* I can send the packet now.. */ 384 buf = (byte *) packet; 385 386 /* If I get here, I _know_ there is a packet slot waiting for me */ 387 packet_no = SMC_inb(dev, LAN91C96_ARR); 388 if (packet_no & LAN91C96_ARR_FAILED) { 389 /* or isn't there? BAD CHIP! */ 390 printf("%s: Memory allocation failed. \n", dev->name); 391 return 0; 392 } 393 394 /* we have a packet address, so tell the card to use it */ 395 SMC_outb(dev, packet_no, LAN91C96_PNR); 396 397 /* point to the beginning of the packet */ 398 SMC_outw(dev, LAN91C96_PTR_AUTO_INCR, LAN91C96_POINTER); 399 400 PRINTK3("%s: Trying to xmit packet of length %x\n", 401 dev->name, length); 402 403 #if SMC_DEBUG > 2 404 printf ("Transmitting Packet\n"); 405 print_packet (buf, length); 406 #endif 407 408 /* send the packet length ( +6 for status, length and ctl byte ) 409 and the status word ( set to zeros ) */ 410 #ifdef USE_32_BIT 411 SMC_outl(dev, (length + 6) << 16, LAN91C96_DATA_HIGH); 412 #else 413 SMC_outw(dev, 0, LAN91C96_DATA_HIGH); 414 /* send the packet length ( +6 for status words, length, and ctl */ 415 SMC_outw(dev, (length + 6), LAN91C96_DATA_HIGH); 416 #endif /* USE_32_BIT */ 417 418 /* send the actual data 419 * I _think_ it's faster to send the longs first, and then 420 * mop up by sending the last word. It depends heavily 421 * on alignment, at least on the 486. Maybe it would be 422 * a good idea to check which is optimal? But that could take 423 * almost as much time as is saved? 424 */ 425 #ifdef USE_32_BIT 426 SMC_outsl(dev, LAN91C96_DATA_HIGH, buf, length >> 2); 427 if (length & 0x2) 428 SMC_outw(dev, *((word *) (buf + (length & 0xFFFFFFFC))), 429 LAN91C96_DATA_HIGH); 430 #else 431 SMC_outsw(dev, LAN91C96_DATA_HIGH, buf, (length) >> 1); 432 #endif /* USE_32_BIT */ 433 434 /* Send the last byte, if there is one. */ 435 if ((length & 1) == 0) { 436 SMC_outw(dev, 0, LAN91C96_DATA_HIGH); 437 } else { 438 SMC_outw(dev, buf[length - 1] | 0x2000, LAN91C96_DATA_HIGH); 439 } 440 441 /* and let the chipset deal with it */ 442 SMC_outw(dev, LAN91C96_MMUCR_ENQUEUE, LAN91C96_MMU); 443 444 /* poll for TX INT */ 445 if (poll4int (dev, LAN91C96_MSK_TX_INT, SMC_TX_TIMEOUT)) { 446 /* sending failed */ 447 PRINTK2("%s: TX timeout, sending failed...\n", dev->name); 448 449 /* release packet */ 450 SMC_outw(dev, LAN91C96_MMUCR_RELEASE_TX, LAN91C96_MMU); 451 452 /* wait for MMU getting ready (low) */ 453 while (SMC_inw(dev, LAN91C96_MMU) & LAN91C96_MMUCR_NO_BUSY) 454 udelay (10); 455 456 PRINTK2("MMU ready\n"); 457 458 459 return 0; 460 } else { 461 /* ack. int */ 462 SMC_outw(dev, LAN91C96_IST_TX_INT, LAN91C96_INT_STATS); 463 464 PRINTK2("%s: Sent packet of length %d \n", dev->name, length); 465 466 /* release packet */ 467 SMC_outw(dev, LAN91C96_MMUCR_RELEASE_TX, LAN91C96_MMU); 468 469 /* wait for MMU getting ready (low) */ 470 while (SMC_inw(dev, LAN91C96_MMU) & LAN91C96_MMUCR_NO_BUSY) 471 udelay (10); 472 473 PRINTK2 ("MMU ready\n"); 474 } 475 476 return length; 477 } 478 479 480 /* 481 * Open and Initialize the board 482 * 483 * Set up everything, reset the card, etc .. 484 * 485 */ 486 static int smc_open(bd_t *bd, struct eth_device *dev) 487 { 488 int i, err; /* used to set hw ethernet address */ 489 490 PRINTK2("%s:smc_open\n", dev->name); 491 492 /* reset the hardware */ 493 494 smc_reset(dev); 495 smc_enable(dev); 496 497 SMC_SELECT_BANK(dev, 1); 498 /* set smc_mac_addr, and sync it with u-boot globals */ 499 err = smc_get_ethaddr(bd, dev); 500 if (err < 0) 501 return -1; 502 #ifdef USE_32_BIT 503 for (i = 0; i < 6; i += 2) { 504 word address; 505 506 address = smc_mac_addr[i + 1] << 8; 507 address |= smc_mac_addr[i]; 508 SMC_outw(dev, address, LAN91C96_IA0 + i); 509 } 510 #else 511 for (i = 0; i < 6; i++) 512 SMC_outb(dev, smc_mac_addr[i], LAN91C96_IA0 + i); 513 #endif 514 return 0; 515 } 516 517 /*------------------------------------------------------------- 518 * 519 * smc_rcv - receive a packet from the card 520 * 521 * There is ( at least ) a packet waiting to be read from 522 * chip-memory. 523 * 524 * o Read the status 525 * o If an error, record it 526 * o otherwise, read in the packet 527 *------------------------------------------------------------- 528 */ 529 static int smc_rcv(struct eth_device *dev) 530 { 531 int packet_number; 532 word status; 533 word packet_length; 534 int is_error = 0; 535 536 #ifdef USE_32_BIT 537 dword stat_len; 538 #endif 539 540 541 SMC_SELECT_BANK(dev, 2); 542 packet_number = SMC_inw(dev, LAN91C96_FIFO); 543 544 if (packet_number & LAN91C96_FIFO_RXEMPTY) { 545 return 0; 546 } 547 548 PRINTK3("%s:smc_rcv\n", dev->name); 549 /* start reading from the start of the packet */ 550 SMC_outw(dev, LAN91C96_PTR_READ | LAN91C96_PTR_RCV | 551 LAN91C96_PTR_AUTO_INCR, LAN91C96_POINTER); 552 553 /* First two words are status and packet_length */ 554 #ifdef USE_32_BIT 555 stat_len = SMC_inl(dev, LAN91C96_DATA_HIGH); 556 status = stat_len & 0xffff; 557 packet_length = stat_len >> 16; 558 #else 559 status = SMC_inw(dev, LAN91C96_DATA_HIGH); 560 packet_length = SMC_inw(dev, LAN91C96_DATA_HIGH); 561 #endif 562 563 packet_length &= 0x07ff; /* mask off top bits */ 564 565 PRINTK2 ("RCV: STATUS %4x LENGTH %4x\n", status, packet_length); 566 567 if (!(status & FRAME_FILTER)) { 568 /* Adjust for having already read the first two words */ 569 packet_length -= 4; /*4; */ 570 571 572 /* set odd length for bug in LAN91C111, */ 573 /* which never sets RS_ODDFRAME */ 574 /* TODO ? */ 575 576 577 #ifdef USE_32_BIT 578 PRINTK3 (" Reading %d dwords (and %d bytes) \n", 579 packet_length >> 2, packet_length & 3); 580 /* QUESTION: Like in the TX routine, do I want 581 to send the DWORDs or the bytes first, or some 582 mixture. A mixture might improve already slow PIO 583 performance */ 584 SMC_insl(dev, LAN91C96_DATA_HIGH, NetRxPackets[0], 585 packet_length >> 2); 586 /* read the left over bytes */ 587 if (packet_length & 3) { 588 int i; 589 590 byte *tail = (byte *) (NetRxPackets[0] + (packet_length & ~3)); 591 dword leftover = SMC_inl(dev, LAN91C96_DATA_HIGH); 592 593 for (i = 0; i < (packet_length & 3); i++) 594 *tail++ = (byte) (leftover >> (8 * i)) & 0xff; 595 } 596 #else 597 PRINTK3 (" Reading %d words and %d byte(s) \n", 598 (packet_length >> 1), packet_length & 1); 599 SMC_insw(dev, LAN91C96_DATA_HIGH, NetRxPackets[0], 600 packet_length >> 1); 601 602 #endif /* USE_32_BIT */ 603 604 #if SMC_DEBUG > 2 605 printf ("Receiving Packet\n"); 606 print_packet((byte *)NetRxPackets[0], packet_length); 607 #endif 608 } else { 609 /* error ... */ 610 /* TODO ? */ 611 is_error = 1; 612 } 613 614 while (SMC_inw(dev, LAN91C96_MMU) & LAN91C96_MMUCR_NO_BUSY) 615 udelay (1); /* Wait until not busy */ 616 617 /* error or good, tell the card to get rid of this packet */ 618 SMC_outw(dev, LAN91C96_MMUCR_RELEASE_RX, LAN91C96_MMU); 619 620 while (SMC_inw(dev, LAN91C96_MMU) & LAN91C96_MMUCR_NO_BUSY) 621 udelay (1); /* Wait until not busy */ 622 623 if (!is_error) { 624 /* Pass the packet up to the protocol layers. */ 625 NetReceive (NetRxPackets[0], packet_length); 626 return packet_length; 627 } else { 628 return 0; 629 } 630 631 } 632 633 /*---------------------------------------------------- 634 * smc_close 635 * 636 * this makes the board clean up everything that it can 637 * and not talk to the outside world. Caused by 638 * an 'ifconfig ethX down' 639 * 640 -----------------------------------------------------*/ 641 static int smc_close(struct eth_device *dev) 642 { 643 PRINTK2("%s:smc_close\n", dev->name); 644 645 /* clear everything */ 646 smc_shutdown(dev); 647 648 return 0; 649 } 650 651 #if SMC_DEBUG > 2 652 static void print_packet(byte *buf, int length) 653 { 654 #if 0 655 int i; 656 int remainder; 657 int lines; 658 659 printf ("Packet of length %d \n", length); 660 661 lines = length / 16; 662 remainder = length % 16; 663 664 for (i = 0; i < lines; i++) { 665 int cur; 666 667 for (cur = 0; cur < 8; cur++) { 668 byte a, b; 669 670 a = *(buf++); 671 b = *(buf++); 672 printf ("%02x%02x ", a, b); 673 } 674 printf ("\n"); 675 } 676 for (i = 0; i < remainder / 2; i++) { 677 byte a, b; 678 679 a = *(buf++); 680 b = *(buf++); 681 printf ("%02x%02x ", a, b); 682 } 683 printf ("\n"); 684 #endif /* 0 */ 685 } 686 #endif /* SMC_DEBUG > 2 */ 687 688 static int lan91c96_init(struct eth_device *dev, bd_t *bd) 689 { 690 return smc_open(bd, dev); 691 } 692 693 static void lan91c96_halt(struct eth_device *dev) 694 { 695 smc_close(dev); 696 } 697 698 static int lan91c96_recv(struct eth_device *dev) 699 { 700 return smc_rcv(dev); 701 } 702 703 static int lan91c96_send(struct eth_device *dev, volatile void *packet, 704 int length) 705 { 706 return smc_send_packet(dev, packet, length); 707 } 708 709 /* smc_get_ethaddr 710 * 711 * This checks both the environment and the ROM for an ethernet address. If 712 * found, the environment takes precedence. 713 */ 714 715 static int smc_get_ethaddr(bd_t *bd, struct eth_device *dev) 716 { 717 uchar v_mac[6]; 718 719 if (!eth_getenv_enetaddr("ethaddr", v_mac)) { 720 /* get ROM mac value if any */ 721 if (!get_rom_mac(dev, v_mac)) { 722 printf("\n*** ERROR: ethaddr is NOT set !!\n"); 723 return -1; 724 } 725 eth_setenv_enetaddr("ethaddr", v_mac); 726 } 727 728 smc_set_mac_addr(v_mac); /* use old function to update smc default */ 729 PRINTK("Using MAC Address %pM\n", v_mac); 730 return 0; 731 } 732 733 /* 734 * get_rom_mac() 735 * Note, this has omly been tested for the OMAP730 P2. 736 */ 737 738 static int get_rom_mac(struct eth_device *dev, unsigned char *v_rom_mac) 739 { 740 #ifdef HARDCODE_MAC /* used for testing or to supress run time warnings */ 741 char hw_mac_addr[] = { 0x02, 0x80, 0xad, 0x20, 0x31, 0xb8 }; 742 743 memcpy (v_rom_mac, hw_mac_addr, 6); 744 return (1); 745 #else 746 int i; 747 SMC_SELECT_BANK(dev, 1); 748 for (i=0; i<6; i++) 749 { 750 v_rom_mac[i] = SMC_inb(dev, LAN91C96_IA0 + i); 751 } 752 return (1); 753 #endif 754 } 755 756 /* Structure to detect the device IDs */ 757 struct id_type { 758 u8 id; 759 char *name; 760 }; 761 static struct id_type supported_chips[] = { 762 {0, ""}, /* Dummy entry to prevent id check failure */ 763 {9, "LAN91C110"}, 764 {8, "LAN91C100FD"}, 765 {7, "LAN91C100"}, 766 {5, "LAN91C95"}, 767 {4, "LAN91C94/96"}, 768 {3, "LAN91C90/92"}, 769 }; 770 /* lan91c96_detect_chip 771 * See: 772 * http://www.embeddedsys.com/subpages/resources/images/documents/LAN91C96_datasheet.pdf 773 * page 71 - that is the closest we get to detect this device 774 */ 775 static int lan91c96_detect_chip(struct eth_device *dev) 776 { 777 u8 chip_id; 778 int r; 779 SMC_SELECT_BANK(dev, 3); 780 chip_id = (SMC_inw(dev, 0xA) & LAN91C96_REV_CHIPID) >> 4; 781 SMC_SELECT_BANK(dev, 0); 782 for (r = 0; r < sizeof(supported_chips) / sizeof(struct id_type); r++) 783 if (chip_id == supported_chips[r].id) 784 return r; 785 return 0; 786 } 787 788 int lan91c96_initialize(u8 dev_num, int base_addr) 789 { 790 struct eth_device *dev; 791 int r = 0; 792 793 dev = malloc(sizeof(*dev)); 794 if (!dev) { 795 return 0; 796 } 797 memset(dev, 0, sizeof(*dev)); 798 799 dev->iobase = base_addr; 800 801 /* Try to detect chip. Will fail if not present. */ 802 r = lan91c96_detect_chip(dev); 803 if (!r) { 804 free(dev); 805 return 0; 806 } 807 get_rom_mac(dev, dev->enetaddr); 808 809 dev->init = lan91c96_init; 810 dev->halt = lan91c96_halt; 811 dev->send = lan91c96_send; 812 dev->recv = lan91c96_recv; 813 sprintf(dev->name, "%s-%hu", supported_chips[r].name, dev_num); 814 815 eth_register(dev); 816 return 0; 817 } 818