drivers/net/lan91c96.c

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