drivers/net/smc91111.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*------------------------------------------------------------------------
   3  . smc91111.c
   4  . This is a driver for SMSC's 91C111 single-chip Ethernet device.
   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  .
  15  . Information contained in this file was obtained from the LAN91C111
  16  . manual from SMC.  To get a copy, if you really want one, you can find
  17  . information under www.smsc.com.
  18  .
  19  .
  20  . "Features" of the SMC chip:
  21  .   Integrated PHY/MAC for 10/100BaseT Operation
  22  .   Supports internal and external MII
  23  .   Integrated 8K packet memory
  24  .   EEPROM interface for configuration
  25  .
  26  . Arguments:
  27  .      io      = for the base address
  28  .      irq     = for the IRQ
  29  .
  30  . author:
  31  .      Erik Stahlman                           ( erik@vt.edu )
  32  .      Daris A Nevil                           ( dnevil@snmc.com )
  33  .
  34  .
  35  . Hardware multicast code from Peter Cammaert ( pc@denkart.be )
  36  .
  37  . Sources:
  38  .    o   SMSC LAN91C111 databook (www.smsc.com)
  39  .    o   smc9194.c by Erik Stahlman
  40  .    o   skeleton.c by Donald Becker ( becker@cesdis.gsfc.nasa.gov )
  41  .
  42  . History:
  43  .      06/19/03  Richard Woodruff Made u-boot environment aware and added mac addr checks.
  44  .      10/17/01  Marco Hasewinkel Modify for DNP/1110
  45  .      07/25/01  Woojung Huh      Modify for ADS Bitsy
  46  .      04/25/01  Daris A Nevil    Initial public release through SMSC
  47  .      03/16/01  Daris A Nevil    Modified smc9194.c for use with LAN91C111
  48  ----------------------------------------------------------------------------*/
  49
  50 #include <common.h>
  51 #include <command.h>
  52 #include <config.h>
  53 #include <malloc.h>
  54 #include <linux/delay.h>
  55 #include "smc91111.h"
  56 #include <net.h>
  57
  58 /* Use power-down feature of the chip */
  59 #define POWER_DOWN      0
  60
  61 #define NO_AUTOPROBE
  62
  63 #define SMC_DEBUG 0
  64
  65 #if SMC_DEBUG > 1
  66 static const char version[] =
  67         "smc91111.c:v1.0 04/25/01 by Daris A Nevil (dnevil@snmc.com)\n";
  68 #endif
  69
  70 /* Autonegotiation timeout in seconds */
  71 #ifndef CONFIG_SMC_AUTONEG_TIMEOUT
  72 #define CONFIG_SMC_AUTONEG_TIMEOUT 10
  73 #endif
  74
  75 /*------------------------------------------------------------------------
  76  .
  77  . Configuration options, for the experienced user to change.
  78  .
  79  -------------------------------------------------------------------------*/
  80
  81 /*
  82  . Wait time for memory to be free.  This probably shouldn't be
  83  . tuned that much, as waiting for this means nothing else happens
  84  . in the system
  85 */
  86 #define MEMORY_WAIT_TIME 16
  87
  88
  89 #if (SMC_DEBUG > 2 )
  90 #define PRINTK3(args...) printf(args)
  91 #else
  92 #define PRINTK3(args...)
  93 #endif
  94
  95 #if SMC_DEBUG > 1
  96 #define PRINTK2(args...) printf(args)
  97 #else
  98 #define PRINTK2(args...)
  99 #endif
 100
 101 #ifdef SMC_DEBUG
 102 #define PRINTK(args...) printf(args)
 103 #else
 104 #define PRINTK(args...)
 105 #endif
 106
 107
 108 /*------------------------------------------------------------------------
 109  .
 110  . The internal workings of the driver.  If you are changing anything
 111  . here with the SMC stuff, you should have the datasheet and know
 112  . what you are doing.
 113  .
 114  -------------------------------------------------------------------------*/
 115
 116 /* Memory sizing constant */
 117 #define LAN91C111_MEMORY_MULTIPLIER     (1024*2)
 118
 119 #ifndef CONFIG_SMC91111_BASE
 120 #error "SMC91111 Base address must be passed to initialization funciton"
 121 /* #define CONFIG_SMC91111_BASE 0x20000300 */
 122 #endif
 123
 124 #define SMC_DEV_NAME "SMC91111"
 125 #define SMC_PHY_ADDR 0x0000
 126 #define SMC_ALLOC_MAX_TRY 5
 127 #define SMC_TX_TIMEOUT 30
 128
 129 #define SMC_PHY_CLOCK_DELAY 1000
 130
 131 #define ETH_ZLEN 60
 132
 133 #ifdef  CONFIG_SMC_USE_32_BIT
 134 #define USE_32_BIT  1
 135 #else
 136 #undef USE_32_BIT
 137 #endif
 138
 139 #ifdef SHARED_RESOURCES
 140 extern void swap_to(int device_id);
 141 #else
 142 # define swap_to(x)
 143 #endif
 144
 145 #ifndef CONFIG_SMC91111_EXT_PHY
 146 static void smc_phy_configure(struct eth_device *dev);
 147 #endif /* !CONFIG_SMC91111_EXT_PHY */
 148
 149 /*
 150  ------------------------------------------------------------
 151  .
 152  . Internal routines
 153  .
 154  ------------------------------------------------------------
 155 */
 156
 157 #ifdef CONFIG_SMC_USE_IOFUNCS
 158 /*
 159  * input and output functions
 160  *
 161  * Implemented due to inx,outx macros accessing the device improperly
 162  * and putting the device into an unkown state.
 163  *
 164  * For instance, on Sharp LPD7A400 SDK, affects were chip memory
 165  * could not be free'd (hence the alloc failures), duplicate packets,
 166  * packets being corrupt (shifted) on the wire, etc.  Switching to the
 167  * inx,outx functions fixed this problem.
 168  */
 169
 170 static inline word SMC_inw(struct eth_device *dev, dword offset)
 171 {
 172         word v;
 173         v = *((volatile word*)(dev->iobase + offset));
 174         barrier(); *(volatile u32*)(0xc0000000);
 175         return v;
 176 }
 177
 178 static inline void SMC_outw(struct eth_device *dev, word value, dword offset)
 179 {
 180         *((volatile word*)(dev->iobase + offset)) = value;
 181         barrier(); *(volatile u32*)(0xc0000000);
 182 }
 183
 184 static inline byte SMC_inb(struct eth_device *dev, dword offset)
 185 {
 186         word  _w;
 187
 188         _w = SMC_inw(dev, offset & ~((dword)1));
 189         return (offset & 1) ? (byte)(_w >> 8) : (byte)(_w);
 190 }
 191
 192 static inline void SMC_outb(struct eth_device *dev, byte value, dword offset)
 193 {
 194         word  _w;
 195
 196         _w = SMC_inw(dev, offset & ~((dword)1));
 197         if (offset & 1)
 198                 *((volatile word*)(dev->iobase + (offset & ~((dword)1)))) =
 199                         (value<<8) | (_w & 0x00ff);
 200         else
 201                 *((volatile word*)(dev->iobase + offset)) =
 202                         value | (_w & 0xff00);
 203 }
 204
 205 static inline void SMC_insw(struct eth_device *dev, dword offset,
 206         volatile uchar* buf, dword len)
 207 {
 208         volatile word *p = (volatile word *)buf;
 209
 210         while (len-- > 0) {
 211                 *p++ = SMC_inw(dev, offset);
 212                 barrier();
 213                 *((volatile u32*)(0xc0000000));
 214         }
 215 }
 216
 217 static inline void SMC_outsw(struct eth_device *dev, dword offset,
 218         uchar* buf, dword len)
 219 {
 220         volatile word *p = (volatile word *)buf;
 221
 222         while (len-- > 0) {
 223                 SMC_outw(dev, *p++, offset);
 224                 barrier();
 225                 *(volatile u32*)(0xc0000000);
 226         }
 227 }
 228 #endif  /* CONFIG_SMC_USE_IOFUNCS */
 229
 230 /*
 231  . A rather simple routine to print out a packet for debugging purposes.
 232 */
 233 #if SMC_DEBUG > 2
 234 static void print_packet( byte *, int );
 235 #endif
 236
 237 #define tx_done(dev) 1
 238
 239 static int poll4int (struct eth_device *dev, byte mask, int timeout)
 240 {
 241         int tmo = get_timer (0) + timeout * CONFIG_SYS_HZ;
 242         int is_timeout = 0;
 243         word old_bank = SMC_inw (dev, BSR_REG);
 244
 245         PRINTK2 ("Polling...\n");
 246         SMC_SELECT_BANK (dev, 2);
 247         while ((SMC_inw (dev, SMC91111_INT_REG) & mask) == 0) {
 248                 if (get_timer (0) >= tmo) {
 249                         is_timeout = 1;
 250                         break;
 251                 }
 252         }
 253
 254         /* restore old bank selection */
 255         SMC_SELECT_BANK (dev, old_bank);
 256
 257         if (is_timeout)
 258                 return 1;
 259         else
 260                 return 0;
 261 }
 262
 263 /* Only one release command at a time, please */
 264 static inline void smc_wait_mmu_release_complete (struct eth_device *dev)
 265 {
 266         int count = 0;
 267
 268         /* assume bank 2 selected */
 269         while (SMC_inw (dev, MMU_CMD_REG) & MC_BUSY) {
 270                 udelay(1);      /* Wait until not busy */
 271                 if (++count > 200)
 272                         break;
 273         }
 274 }
 275
 276 /*
 277  . Function: smc_reset( void )
 278  . Purpose:
 279  .      This sets the SMC91111 chip to its normal state, hopefully from whatever
 280  .      mess that any other DOS driver has put it in.
 281  .
 282  . Maybe I should reset more registers to defaults in here?  SOFTRST  should
 283  . do that for me.
 284  .
 285  . Method:
 286  .      1.  send a SOFT RESET
 287  .      2.  wait for it to finish
 288  .      3.  enable autorelease mode
 289  .      4.  reset the memory management unit
 290  .      5.  clear all interrupts
 291  .
 292 */
 293 static void smc_reset (struct eth_device *dev)
 294 {
 295         PRINTK2 ("%s: smc_reset\n", SMC_DEV_NAME);
 296
 297         /* This resets the registers mostly to defaults, but doesn't
 298            affect EEPROM.  That seems unnecessary */
 299         SMC_SELECT_BANK (dev, 0);
 300         SMC_outw (dev, RCR_SOFTRST, RCR_REG);
 301
 302         /* Setup the Configuration Register */
 303         /* This is necessary because the CONFIG_REG is not affected */
 304         /* by a soft reset */
 305
 306         SMC_SELECT_BANK (dev, 1);
 307 #if defined(CONFIG_SMC91111_EXT_PHY)
 308         SMC_outw (dev, CONFIG_DEFAULT | CONFIG_EXT_PHY, CONFIG_REG);
 309 #else
 310         SMC_outw (dev, CONFIG_DEFAULT, CONFIG_REG);
 311 #endif
 312
 313
 314         /* Release from possible power-down state */
 315         /* Configuration register is not affected by Soft Reset */
 316         SMC_outw (dev, SMC_inw (dev, CONFIG_REG) | CONFIG_EPH_POWER_EN,
 317                 CONFIG_REG);
 318
 319         SMC_SELECT_BANK (dev, 0);
 320
 321         /* this should pause enough for the chip to be happy */
 322         udelay(10);
 323
 324         /* Disable transmit and receive functionality */
 325         SMC_outw (dev, RCR_CLEAR, RCR_REG);
 326         SMC_outw (dev, TCR_CLEAR, TCR_REG);
 327
 328         /* set the control register */
 329         SMC_SELECT_BANK (dev, 1);
 330         SMC_outw (dev, CTL_DEFAULT, CTL_REG);
 331
 332         /* Reset the MMU */
 333         SMC_SELECT_BANK (dev, 2);
 334         smc_wait_mmu_release_complete (dev);
 335         SMC_outw (dev, MC_RESET, MMU_CMD_REG);
 336         while (SMC_inw (dev, MMU_CMD_REG) & MC_BUSY)
 337                 udelay(1);      /* Wait until not busy */
 338
 339         /* Note:  It doesn't seem that waiting for the MMU busy is needed here,
 340            but this is a place where future chipsets _COULD_ break.  Be wary
 341            of issuing another MMU command right after this */
 342
 343         /* Disable all interrupts */
 344         SMC_outb (dev, 0, IM_REG);
 345 }
 346
 347 /*
 348  . Function: smc_enable
 349  . Purpose: let the chip talk to the outside work
 350  . Method:
 351  .      1.  Enable the transmitter
 352  .      2.  Enable the receiver
 353  .      3.  Enable interrupts
 354 */
 355 static void smc_enable(struct eth_device *dev)
 356 {
 357         PRINTK2("%s: smc_enable\n", SMC_DEV_NAME);
 358         SMC_SELECT_BANK( dev, 0 );
 359         /* see the header file for options in TCR/RCR DEFAULT*/
 360         SMC_outw( dev, TCR_DEFAULT, TCR_REG );
 361         SMC_outw( dev, RCR_DEFAULT, RCR_REG );
 362
 363         /* clear MII_DIS */
 364 /*      smc_write_phy_register(PHY_CNTL_REG, 0x0000); */
 365 }
 366
 367 /*
 368  . Function: smc_halt
 369  . Purpose:  closes down the SMC91xxx chip.
 370  . Method:
 371  .      1. zero the interrupt mask
 372  .      2. clear the enable receive flag
 373  .      3. clear the enable xmit flags
 374  .
 375  . TODO:
 376  .   (1) maybe utilize power down mode.
 377  .      Why not yet?  Because while the chip will go into power down mode,
 378  .      the manual says that it will wake up in response to any I/O requests
 379  .      in the register space.   Empirical results do not show this working.
 380 */
 381 static void smc_halt(struct eth_device *dev)
 382 {
 383         PRINTK2("%s: smc_halt\n", SMC_DEV_NAME);
 384
 385         /* no more interrupts for me */
 386         SMC_SELECT_BANK( dev, 2 );
 387         SMC_outb( dev, 0, IM_REG );
 388
 389         /* and tell the card to stay away from that nasty outside world */
 390         SMC_SELECT_BANK( dev, 0 );
 391         SMC_outb( dev, RCR_CLEAR, RCR_REG );
 392         SMC_outb( dev, TCR_CLEAR, TCR_REG );
 393
 394         swap_to(FLASH);
 395 }
 396
 397
 398 /*
 399  . Function:  smc_send(struct net_device * )
 400  . Purpose:
 401  .      This sends the actual packet to the SMC9xxx chip.
 402  .
 403  . Algorithm:
 404  .      First, see if a saved_skb is available.
 405  .              ( this should NOT be called if there is no 'saved_skb'
 406  .      Now, find the packet number that the chip allocated
 407  .      Point the data pointers at it in memory
 408  .      Set the length word in the chip's memory
 409  .      Dump the packet to chip memory
 410  .      Check if a last byte is needed ( odd length packet )
 411  .              if so, set the control flag right
 412  .      Tell the card to send it
 413  .      Enable the transmit interrupt, so I know if it failed
 414  .      Free the kernel data if I actually sent it.
 415 */
 416 static int smc_send(struct eth_device *dev, void *packet, int packet_length)
 417 {
 418         byte packet_no;
 419         byte *buf;
 420         int length;
 421         int numPages;
 422         int try = 0;
 423         int time_out;
 424         byte status;
 425         byte saved_pnr;
 426         word saved_ptr;
 427
 428         /* save PTR and PNR registers before manipulation */
 429         SMC_SELECT_BANK (dev, 2);
 430         saved_pnr = SMC_inb( dev, PN_REG );
 431         saved_ptr = SMC_inw( dev, PTR_REG );
 432
 433         PRINTK3 ("%s: smc_hardware_send_packet\n", SMC_DEV_NAME);
 434
 435         length = ETH_ZLEN < packet_length ? packet_length : ETH_ZLEN;
 436
 437         /* allocate memory
 438          ** The MMU wants the number of pages to be the number of 256 bytes
 439          ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
 440          **
 441          ** The 91C111 ignores the size bits, but the code is left intact
 442          ** for backwards and future compatibility.
 443          **
 444          ** Pkt size for allocating is data length +6 (for additional status
 445          ** words, length and ctl!)
 446          **
 447          ** If odd size then last byte is included in this header.
 448          */
 449         numPages = ((length & 0xfffe) + 6);
 450         numPages >>= 8;         /* Divide by 256 */
 451
 452         if (numPages > 7) {
 453                 printf ("%s: Far too big packet error. \n", SMC_DEV_NAME);
 454                 return 0;
 455         }
 456
 457         /* now, try to allocate the memory */
 458         SMC_SELECT_BANK (dev, 2);
 459         SMC_outw (dev, MC_ALLOC | numPages, MMU_CMD_REG);
 460
 461         /* FIXME: the ALLOC_INT bit never gets set *
 462          * so the following will always give a     *
 463          * memory allocation error.                *
 464          * same code works in armboot though       *
 465          * -ro
 466          */
 467
 468 again:
 469         try++;
 470         time_out = MEMORY_WAIT_TIME;
 471         do {
 472                 status = SMC_inb (dev, SMC91111_INT_REG);
 473                 if (status & IM_ALLOC_INT) {
 474                         /* acknowledge the interrupt */
 475                         SMC_outb (dev, IM_ALLOC_INT, SMC91111_INT_REG);
 476                         break;
 477                 }
 478         } while (--time_out);
 479
 480         if (!time_out) {
 481                 PRINTK2 ("%s: memory allocation, try %d failed ...\n",
 482                          SMC_DEV_NAME, try);
 483                 if (try < SMC_ALLOC_MAX_TRY)
 484                         goto again;
 485                 else
 486                         return 0;
 487         }
 488
 489         PRINTK2 ("%s: memory allocation, try %d succeeded ...\n",
 490                  SMC_DEV_NAME, try);
 491
 492         buf = (byte *) packet;
 493
 494         /* If I get here, I _know_ there is a packet slot waiting for me */
 495         packet_no = SMC_inb (dev, AR_REG);
 496         if (packet_no & AR_FAILED) {
 497                 /* or isn't there?  BAD CHIP! */
 498                 printf ("%s: Memory allocation failed. \n", SMC_DEV_NAME);
 499                 return 0;
 500         }
 501
 502         /* we have a packet address, so tell the card to use it */
 503         SMC_outb (dev, packet_no, PN_REG);
 504
 505         /* do not write new ptr value if Write data fifo not empty */
 506         while ( saved_ptr & PTR_NOTEMPTY )
 507                 printf ("Write data fifo not empty!\n");
 508
 509         /* point to the beginning of the packet */
 510         SMC_outw (dev, PTR_AUTOINC, PTR_REG);
 511
 512         PRINTK3 ("%s: Trying to xmit packet of length %x\n",
 513                  SMC_DEV_NAME, length);
 514
 515 #if SMC_DEBUG > 2
 516         printf ("Transmitting Packet\n");
 517         print_packet (buf, length);
 518 #endif
 519
 520         /* send the packet length ( +6 for status, length and ctl byte )
 521            and the status word ( set to zeros ) */
 522 #ifdef USE_32_BIT
 523         SMC_outl (dev, (length + 6) << 16, SMC91111_DATA_REG);
 524 #else
 525         SMC_outw (dev, 0, SMC91111_DATA_REG);
 526         /* send the packet length ( +6 for status words, length, and ctl */
 527         SMC_outw (dev, (length + 6), SMC91111_DATA_REG);
 528 #endif
 529
 530         /* send the actual data
 531            . I _think_ it's faster to send the longs first, and then
 532            . mop up by sending the last word.  It depends heavily
 533            . on alignment, at least on the 486.  Maybe it would be
 534            . a good idea to check which is optimal?  But that could take
 535            . almost as much time as is saved?
 536          */
 537 #ifdef USE_32_BIT
 538         SMC_outsl (dev, SMC91111_DATA_REG, buf, length >> 2);
 539         if (length & 0x2)
 540                 SMC_outw (dev, *((word *) (buf + (length & 0xFFFFFFFC))),
 541                           SMC91111_DATA_REG);
 542 #else
 543         SMC_outsw (dev, SMC91111_DATA_REG, buf, (length) >> 1);
 544 #endif /* USE_32_BIT */
 545
 546         /* Send the last byte, if there is one.   */
 547         if ((length & 1) == 0) {
 548                 SMC_outw (dev, 0, SMC91111_DATA_REG);
 549         } else {
 550                 SMC_outw (dev, buf[length - 1] | 0x2000, SMC91111_DATA_REG);
 551         }
 552
 553         /* and let the chipset deal with it */
 554         SMC_outw (dev, MC_ENQUEUE, MMU_CMD_REG);
 555
 556         /* poll for TX INT */
 557         /* if (poll4int (dev, IM_TX_INT, SMC_TX_TIMEOUT)) { */
 558         /* poll for TX_EMPTY INT - autorelease enabled */
 559         if (poll4int(dev, IM_TX_EMPTY_INT, SMC_TX_TIMEOUT)) {
 560                 /* sending failed */
 561                 PRINTK2 ("%s: TX timeout, sending failed...\n", SMC_DEV_NAME);
 562
 563                 /* release packet */
 564                 /* no need to release, MMU does that now */
 565
 566                 /* wait for MMU getting ready (low) */
 567                 while (SMC_inw (dev, MMU_CMD_REG) & MC_BUSY) {
 568                         udelay(10);
 569                 }
 570
 571                 PRINTK2 ("MMU ready\n");
 572
 573
 574                 return 0;
 575         } else {
 576                 /* ack. int */
 577                 SMC_outb (dev, IM_TX_EMPTY_INT, SMC91111_INT_REG);
 578                 /* SMC_outb (IM_TX_INT, SMC91111_INT_REG); */
 579                 PRINTK2 ("%s: Sent packet of length %d \n", SMC_DEV_NAME,
 580                          length);
 581
 582                 /* release packet */
 583                 /* no need to release, MMU does that now */
 584
 585                 /* wait for MMU getting ready (low) */
 586                 while (SMC_inw (dev, MMU_CMD_REG) & MC_BUSY) {
 587                         udelay(10);
 588                 }
 589
 590                 PRINTK2 ("MMU ready\n");
 591
 592
 593         }
 594
 595         /* restore previously saved registers */
 596         SMC_outb( dev, saved_pnr, PN_REG );
 597         SMC_outw( dev, saved_ptr, PTR_REG );
 598
 599         return length;
 600 }
 601
 602 static int smc_write_hwaddr(struct eth_device *dev)
 603 {
 604         int i;
 605
 606         swap_to(ETHERNET);
 607         SMC_SELECT_BANK (dev, 1);
 608 #ifdef USE_32_BIT
 609         for (i = 0; i < 6; i += 2) {
 610                 word address;
 611
 612                 address = dev->enetaddr[i + 1] << 8;
 613                 address |= dev->enetaddr[i];
 614                 SMC_outw(dev, address, (ADDR0_REG + i));
 615         }
 616 #else
 617         for (i = 0; i < 6; i++)
 618                 SMC_outb(dev, dev->enetaddr[i], (ADDR0_REG + i));
 619 #endif
 620         swap_to(FLASH);
 621         return 0;
 622 }
 623
 624 /*
 625  * Open and Initialize the board
 626  *
 627  * Set up everything, reset the card, etc ..
 628  *
 629  */
 630 static int smc_init(struct eth_device *dev, bd_t *bd)
 631 {
 632         swap_to(ETHERNET);
 633
 634         PRINTK2 ("%s: smc_init\n", SMC_DEV_NAME);
 635
 636         /* reset the hardware */
 637         smc_reset (dev);
 638         smc_enable (dev);
 639
 640         /* Configure the PHY */
 641 #ifndef CONFIG_SMC91111_EXT_PHY
 642         smc_phy_configure (dev);
 643 #endif
 644
 645         /* conservative setting (10Mbps, HalfDuplex, no AutoNeg.) */
 646 /*      SMC_SELECT_BANK(dev, 0); */
 647 /*      SMC_outw(dev, 0, RPC_REG); */
 648
 649         printf(SMC_DEV_NAME ": MAC %pM\n", dev->enetaddr);
 650
 651         return 0;
 652 }
 653
 654 /*-------------------------------------------------------------
 655  .
 656  . smc_rcv -  receive a packet from the card
 657  .
 658  . There is ( at least ) a packet waiting to be read from
 659  . chip-memory.
 660  .
 661  . o Read the status
 662  . o If an error, record it
 663  . o otherwise, read in the packet
 664  --------------------------------------------------------------
 665 */
 666 static int smc_rcv(struct eth_device *dev)
 667 {
 668         int     packet_number;
 669         word    status;
 670         word    packet_length;
 671         int     is_error = 0;
 672 #ifdef USE_32_BIT
 673         dword stat_len;
 674 #endif
 675         byte saved_pnr;
 676         word saved_ptr;
 677
 678         SMC_SELECT_BANK(dev, 2);
 679         /* save PTR and PTR registers */
 680         saved_pnr = SMC_inb( dev, PN_REG );
 681         saved_ptr = SMC_inw( dev, PTR_REG );
 682
 683         packet_number = SMC_inw( dev, RXFIFO_REG );
 684
 685         if ( packet_number & RXFIFO_REMPTY ) {
 686
 687                 return 0;
 688         }
 689
 690         PRINTK3("%s: smc_rcv\n", SMC_DEV_NAME);
 691         /*  start reading from the start of the packet */
 692         SMC_outw( dev, PTR_READ | PTR_RCV | PTR_AUTOINC, PTR_REG );
 693
 694         /* First two words are status and packet_length */
 695 #ifdef USE_32_BIT
 696         stat_len = SMC_inl(dev, SMC91111_DATA_REG);
 697         status = stat_len & 0xffff;
 698         packet_length = stat_len >> 16;
 699 #else
 700         status          = SMC_inw( dev, SMC91111_DATA_REG );
 701         packet_length   = SMC_inw( dev, SMC91111_DATA_REG );
 702 #endif
 703
 704         packet_length &= 0x07ff;  /* mask off top bits */
 705
 706         PRINTK2("RCV: STATUS %4x LENGTH %4x\n", status, packet_length );
 707
 708         if ( !(status & RS_ERRORS ) ){
 709                 /* Adjust for having already read the first two words */
 710                 packet_length -= 4; /*4; */
 711
 712
 713                 /* set odd length for bug in LAN91C111, */
 714                 /* which never sets RS_ODDFRAME */
 715                 /* TODO ? */
 716
 717
 718 #ifdef USE_32_BIT
 719                 PRINTK3(" Reading %d dwords (and %d bytes)\n",
 720                         packet_length >> 2, packet_length & 3 );
 721                 /* QUESTION:  Like in the TX routine, do I want
 722                    to send the DWORDs or the bytes first, or some
 723                    mixture.  A mixture might improve already slow PIO
 724                    performance  */
 725                 SMC_insl(dev, SMC91111_DATA_REG, net_rx_packets[0],
 726                          packet_length >> 2);
 727                 /* read the left over bytes */
 728                 if (packet_length & 3) {
 729                         int i;
 730
 731                         byte *tail = (byte *)(net_rx_packets[0] +
 732                                 (packet_length & ~3));
 733                         dword leftover = SMC_inl(dev, SMC91111_DATA_REG);
 734                         for (i=0; i<(packet_length & 3); i++)
 735                                 *tail++ = (byte) (leftover >> (8*i)) & 0xff;
 736                 }
 737 #else
 738                 PRINTK3(" Reading %d words and %d byte(s)\n",
 739                         (packet_length >> 1 ), packet_length & 1 );
 740                 SMC_insw(dev, SMC91111_DATA_REG , net_rx_packets[0],
 741                          packet_length >> 1);
 742
 743 #endif /* USE_32_BIT */
 744
 745 #if     SMC_DEBUG > 2
 746                 printf("Receiving Packet\n");
 747                 print_packet(net_rx_packets[0], packet_length);
 748 #endif
 749         } else {
 750                 /* error ... */
 751                 /* TODO ? */
 752                 is_error = 1;
 753         }
 754
 755         while ( SMC_inw( dev, MMU_CMD_REG ) & MC_BUSY )
 756                 udelay(1); /* Wait until not busy */
 757
 758         /*  error or good, tell the card to get rid of this packet */
 759         SMC_outw( dev, MC_RELEASE, MMU_CMD_REG );
 760
 761         while ( SMC_inw( dev, MMU_CMD_REG ) & MC_BUSY )
 762                 udelay(1); /* Wait until not busy */
 763
 764         /* restore saved registers */
 765         SMC_outb( dev, saved_pnr, PN_REG );
 766         SMC_outw( dev, saved_ptr, PTR_REG );
 767
 768         if (!is_error) {
 769                 /* Pass the packet up to the protocol layers. */
 770                 net_process_received_packet(net_rx_packets[0], packet_length);
 771                 return packet_length;
 772         } else {
 773                 return 0;
 774         }
 775
 776 }
 777
 778
 779 #if 0
 780 /*------------------------------------------------------------
 781  . Modify a bit in the LAN91C111 register set
 782  .-------------------------------------------------------------*/
 783 static word smc_modify_regbit(struct eth_device *dev, int bank, int ioaddr, int reg,
 784         unsigned int bit, int val)
 785 {
 786         word regval;
 787
 788         SMC_SELECT_BANK( dev, bank );
 789
 790         regval = SMC_inw( dev, reg );
 791         if (val)
 792                 regval |= bit;
 793         else
 794                 regval &= ~bit;
 795
 796         SMC_outw( dev, regval, 0 );
 797         return(regval);
 798 }
 799
 800
 801 /*------------------------------------------------------------
 802  . Retrieve a bit in the LAN91C111 register set
 803  .-------------------------------------------------------------*/
 804 static int smc_get_regbit(struct eth_device *dev, int bank, int ioaddr, int reg, unsigned int bit)
 805 {
 806         SMC_SELECT_BANK( dev, bank );
 807         if ( SMC_inw( dev, reg ) & bit)
 808                 return(1);
 809         else
 810                 return(0);
 811 }
 812
 813
 814 /*------------------------------------------------------------
 815  . Modify a LAN91C111 register (word access only)
 816  .-------------------------------------------------------------*/
 817 static void smc_modify_reg(struct eth_device *dev, int bank, int ioaddr, int reg, word val)
 818 {
 819         SMC_SELECT_BANK( dev, bank );
 820         SMC_outw( dev, val, reg );
 821 }
 822
 823
 824 /*------------------------------------------------------------
 825  . Retrieve a LAN91C111 register (word access only)
 826  .-------------------------------------------------------------*/
 827 static int smc_get_reg(struct eth_device *dev, int bank, int ioaddr, int reg)
 828 {
 829         SMC_SELECT_BANK( dev, bank );
 830         return(SMC_inw( dev, reg ));
 831 }
 832
 833 #endif /* 0 */
 834
 835 /*---PHY CONTROL AND CONFIGURATION----------------------------------------- */
 836
 837 #if (SMC_DEBUG > 2 )
 838
 839 /*------------------------------------------------------------
 840  . Debugging function for viewing MII Management serial bitstream
 841  .-------------------------------------------------------------*/
 842 static void smc_dump_mii_stream (byte * bits, int size)
 843 {
 844         int i;
 845
 846         printf ("BIT#:");
 847         for (i = 0; i < size; ++i) {
 848                 printf ("%d", i % 10);
 849         }
 850
 851         printf ("\nMDOE:");
 852         for (i = 0; i < size; ++i) {
 853                 if (bits[i] & MII_MDOE)
 854                         printf ("1");
 855                 else
 856                         printf ("0");
 857         }
 858
 859         printf ("\nMDO :");
 860         for (i = 0; i < size; ++i) {
 861                 if (bits[i] & MII_MDO)
 862                         printf ("1");
 863                 else
 864                         printf ("0");
 865         }
 866
 867         printf ("\nMDI :");
 868         for (i = 0; i < size; ++i) {
 869                 if (bits[i] & MII_MDI)
 870                         printf ("1");
 871                 else
 872                         printf ("0");
 873         }
 874
 875         printf ("\n");
 876 }
 877 #endif
 878
 879 /*------------------------------------------------------------
 880  . Reads a register from the MII Management serial interface
 881  .-------------------------------------------------------------*/
 882 #ifndef CONFIG_SMC91111_EXT_PHY
 883 static word smc_read_phy_register (struct eth_device *dev, byte phyreg)
 884 {
 885         int oldBank;
 886         int i;
 887         byte mask;
 888         word mii_reg;
 889         byte bits[64];
 890         int clk_idx = 0;
 891         int input_idx;
 892         word phydata;
 893         byte phyaddr = SMC_PHY_ADDR;
 894
 895         /* 32 consecutive ones on MDO to establish sync */
 896         for (i = 0; i < 32; ++i)
 897                 bits[clk_idx++] = MII_MDOE | MII_MDO;
 898
 899         /* Start code <01> */
 900         bits[clk_idx++] = MII_MDOE;
 901         bits[clk_idx++] = MII_MDOE | MII_MDO;
 902
 903         /* Read command <10> */
 904         bits[clk_idx++] = MII_MDOE | MII_MDO;
 905         bits[clk_idx++] = MII_MDOE;
 906
 907         /* Output the PHY address, msb first */
 908         mask = (byte) 0x10;
 909         for (i = 0; i < 5; ++i) {
 910                 if (phyaddr & mask)
 911                         bits[clk_idx++] = MII_MDOE | MII_MDO;
 912                 else
 913                         bits[clk_idx++] = MII_MDOE;
 914
 915                 /* Shift to next lowest bit */
 916                 mask >>= 1;
 917         }
 918
 919         /* Output the phy register number, msb first */
 920         mask = (byte) 0x10;
 921         for (i = 0; i < 5; ++i) {
 922                 if (phyreg & mask)
 923                         bits[clk_idx++] = MII_MDOE | MII_MDO;
 924                 else
 925                         bits[clk_idx++] = MII_MDOE;
 926
 927                 /* Shift to next lowest bit */
 928                 mask >>= 1;
 929         }
 930
 931         /* Tristate and turnaround (2 bit times) */
 932         bits[clk_idx++] = 0;
 933         /*bits[clk_idx++] = 0; */
 934
 935         /* Input starts at this bit time */
 936         input_idx = clk_idx;
 937
 938         /* Will input 16 bits */
 939         for (i = 0; i < 16; ++i)
 940                 bits[clk_idx++] = 0;
 941
 942         /* Final clock bit */
 943         bits[clk_idx++] = 0;
 944
 945         /* Save the current bank */
 946         oldBank = SMC_inw (dev, BANK_SELECT);
 947
 948         /* Select bank 3 */
 949         SMC_SELECT_BANK (dev, 3);
 950
 951         /* Get the current MII register value */
 952         mii_reg = SMC_inw (dev, MII_REG);
 953
 954         /* Turn off all MII Interface bits */
 955         mii_reg &= ~(MII_MDOE | MII_MCLK | MII_MDI | MII_MDO);
 956
 957         /* Clock all 64 cycles */
 958         for (i = 0; i < sizeof bits; ++i) {
 959                 /* Clock Low - output data */
 960                 SMC_outw (dev, mii_reg | bits[i], MII_REG);
 961                 udelay(SMC_PHY_CLOCK_DELAY);
 962
 963
 964                 /* Clock Hi - input data */
 965                 SMC_outw (dev, mii_reg | bits[i] | MII_MCLK, MII_REG);
 966                 udelay(SMC_PHY_CLOCK_DELAY);
 967                 bits[i] |= SMC_inw (dev, MII_REG) & MII_MDI;
 968         }
 969
 970         /* Return to idle state */
 971         /* Set clock to low, data to low, and output tristated */
 972         SMC_outw (dev, mii_reg, MII_REG);
 973         udelay(SMC_PHY_CLOCK_DELAY);
 974
 975         /* Restore original bank select */
 976         SMC_SELECT_BANK (dev, oldBank);
 977
 978         /* Recover input data */
 979         phydata = 0;
 980         for (i = 0; i < 16; ++i) {
 981                 phydata <<= 1;
 982
 983                 if (bits[input_idx++] & MII_MDI)
 984                         phydata |= 0x0001;
 985         }
 986
 987 #if (SMC_DEBUG > 2 )
 988         printf ("smc_read_phy_register(): phyaddr=%x,phyreg=%x,phydata=%x\n",
 989                 phyaddr, phyreg, phydata);
 990         smc_dump_mii_stream (bits, sizeof bits);
 991 #endif
 992
 993         return (phydata);
 994 }
 995
 996
 997 /*------------------------------------------------------------
 998  . Writes a register to the MII Management serial interface
 999  .-------------------------------------------------------------*/
1000 static void smc_write_phy_register (struct eth_device *dev, byte phyreg,
1001         word phydata)
1002 {
1003         int oldBank;
1004         int i;
1005         word mask;
1006         word mii_reg;
1007         byte bits[65];
1008         int clk_idx = 0;
1009         byte phyaddr = SMC_PHY_ADDR;
1010
1011         /* 32 consecutive ones on MDO to establish sync */
1012         for (i = 0; i < 32; ++i)
1013                 bits[clk_idx++] = MII_MDOE | MII_MDO;
1014
1015         /* Start code <01> */
1016         bits[clk_idx++] = MII_MDOE;
1017         bits[clk_idx++] = MII_MDOE | MII_MDO;
1018
1019         /* Write command <01> */
1020         bits[clk_idx++] = MII_MDOE;
1021         bits[clk_idx++] = MII_MDOE | MII_MDO;
1022
1023         /* Output the PHY address, msb first */
1024         mask = (byte) 0x10;
1025         for (i = 0; i < 5; ++i) {
1026                 if (phyaddr & mask)
1027                         bits[clk_idx++] = MII_MDOE | MII_MDO;
1028                 else
1029                         bits[clk_idx++] = MII_MDOE;
1030
1031                 /* Shift to next lowest bit */
1032                 mask >>= 1;
1033         }
1034
1035         /* Output the phy register number, msb first */
1036         mask = (byte) 0x10;
1037         for (i = 0; i < 5; ++i) {
1038                 if (phyreg & mask)
1039                         bits[clk_idx++] = MII_MDOE | MII_MDO;
1040                 else
1041                         bits[clk_idx++] = MII_MDOE;
1042
1043                 /* Shift to next lowest bit */
1044                 mask >>= 1;
1045         }
1046
1047         /* Tristate and turnaround (2 bit times) */
1048         bits[clk_idx++] = 0;
1049         bits[clk_idx++] = 0;
1050
1051         /* Write out 16 bits of data, msb first */
1052         mask = 0x8000;
1053         for (i = 0; i < 16; ++i) {
1054                 if (phydata & mask)
1055                         bits[clk_idx++] = MII_MDOE | MII_MDO;
1056                 else
1057                         bits[clk_idx++] = MII_MDOE;
1058
1059                 /* Shift to next lowest bit */
1060                 mask >>= 1;
1061         }
1062
1063         /* Final clock bit (tristate) */
1064         bits[clk_idx++] = 0;
1065
1066         /* Save the current bank */
1067         oldBank = SMC_inw (dev, BANK_SELECT);
1068
1069         /* Select bank 3 */
1070         SMC_SELECT_BANK (dev, 3);
1071
1072         /* Get the current MII register value */
1073         mii_reg = SMC_inw (dev, MII_REG);
1074
1075         /* Turn off all MII Interface bits */
1076         mii_reg &= ~(MII_MDOE | MII_MCLK | MII_MDI | MII_MDO);
1077
1078         /* Clock all cycles */
1079         for (i = 0; i < sizeof bits; ++i) {
1080                 /* Clock Low - output data */
1081                 SMC_outw (dev, mii_reg | bits[i], MII_REG);
1082                 udelay(SMC_PHY_CLOCK_DELAY);
1083
1084
1085                 /* Clock Hi - input data */
1086                 SMC_outw (dev, mii_reg | bits[i] | MII_MCLK, MII_REG);
1087                 udelay(SMC_PHY_CLOCK_DELAY);
1088                 bits[i] |= SMC_inw (dev, MII_REG) & MII_MDI;
1089         }
1090
1091         /* Return to idle state */
1092         /* Set clock to low, data to low, and output tristated */
1093         SMC_outw (dev, mii_reg, MII_REG);
1094         udelay(SMC_PHY_CLOCK_DELAY);
1095
1096         /* Restore original bank select */
1097         SMC_SELECT_BANK (dev, oldBank);
1098
1099 #if (SMC_DEBUG > 2 )
1100         printf ("smc_write_phy_register(): phyaddr=%x,phyreg=%x,phydata=%x\n",
1101                 phyaddr, phyreg, phydata);
1102         smc_dump_mii_stream (bits, sizeof bits);
1103 #endif
1104 }
1105 #endif /* !CONFIG_SMC91111_EXT_PHY */
1106
1107
1108 /*------------------------------------------------------------
1109  . Configures the specified PHY using Autonegotiation. Calls
1110  . smc_phy_fixed() if the user has requested a certain config.
1111  .-------------------------------------------------------------*/
1112 #ifndef CONFIG_SMC91111_EXT_PHY
1113 static void smc_phy_configure (struct eth_device *dev)
1114 {
1115         int timeout;
1116         word my_phy_caps;       /* My PHY capabilities */
1117         word my_ad_caps;        /* My Advertised capabilities */
1118         word status = 0;        /*;my status = 0 */
1119
1120         PRINTK3 ("%s: smc_program_phy()\n", SMC_DEV_NAME);
1121
1122         /* Reset the PHY, setting all other bits to zero */
1123         smc_write_phy_register (dev, PHY_CNTL_REG, PHY_CNTL_RST);
1124
1125         /* Wait for the reset to complete, or time out */
1126         timeout = 6;            /* Wait up to 3 seconds */
1127         while (timeout--) {
1128                 if (!(smc_read_phy_register (dev, PHY_CNTL_REG)
1129                       & PHY_CNTL_RST)) {
1130                         /* reset complete */
1131                         break;
1132                 }
1133
1134                 mdelay(500);    /* wait 500 millisecs */
1135         }
1136
1137         if (timeout < 1) {
1138                 printf ("%s:PHY reset timed out\n", SMC_DEV_NAME);
1139                 goto smc_phy_configure_exit;
1140         }
1141
1142         /* Read PHY Register 18, Status Output */
1143         /* lp->lastPhy18 = smc_read_phy_register(PHY_INT_REG); */
1144
1145         /* Enable PHY Interrupts (for register 18) */
1146         /* Interrupts listed here are disabled */
1147         smc_write_phy_register (dev, PHY_MASK_REG, 0xffff);
1148
1149         /* Configure the Receive/Phy Control register */
1150         SMC_SELECT_BANK (dev, 0);
1151         SMC_outw (dev, RPC_DEFAULT, RPC_REG);
1152
1153         /* Copy our capabilities from PHY_STAT_REG to PHY_AD_REG */
1154         my_phy_caps = smc_read_phy_register (dev, PHY_STAT_REG);
1155         my_ad_caps = PHY_AD_CSMA;       /* I am CSMA capable */
1156
1157         if (my_phy_caps & PHY_STAT_CAP_T4)
1158                 my_ad_caps |= PHY_AD_T4;
1159
1160         if (my_phy_caps & PHY_STAT_CAP_TXF)
1161                 my_ad_caps |= PHY_AD_TX_FDX;
1162
1163         if (my_phy_caps & PHY_STAT_CAP_TXH)
1164                 my_ad_caps |= PHY_AD_TX_HDX;
1165
1166         if (my_phy_caps & PHY_STAT_CAP_TF)
1167                 my_ad_caps |= PHY_AD_10_FDX;
1168
1169         if (my_phy_caps & PHY_STAT_CAP_TH)
1170                 my_ad_caps |= PHY_AD_10_HDX;
1171
1172         /* Update our Auto-Neg Advertisement Register */
1173         smc_write_phy_register (dev, PHY_AD_REG, my_ad_caps);
1174
1175         /* Read the register back.  Without this, it appears that when */
1176         /* auto-negotiation is restarted, sometimes it isn't ready and */
1177         /* the link does not come up. */
1178         smc_read_phy_register(dev, PHY_AD_REG);
1179
1180         PRINTK2 ("%s: phy caps=%x\n", SMC_DEV_NAME, my_phy_caps);
1181         PRINTK2 ("%s: phy advertised caps=%x\n", SMC_DEV_NAME, my_ad_caps);
1182
1183         /* Restart auto-negotiation process in order to advertise my caps */
1184         smc_write_phy_register (dev, PHY_CNTL_REG,
1185                                 PHY_CNTL_ANEG_EN | PHY_CNTL_ANEG_RST);
1186
1187         /* Wait for the auto-negotiation to complete.  This may take from */
1188         /* 2 to 3 seconds. */
1189         /* Wait for the reset to complete, or time out */
1190         timeout = CONFIG_SMC_AUTONEG_TIMEOUT * 2;
1191         while (timeout--) {
1192
1193                 status = smc_read_phy_register (dev, PHY_STAT_REG);
1194                 if (status & PHY_STAT_ANEG_ACK) {
1195                         /* auto-negotiate complete */
1196                         break;
1197                 }
1198
1199                 mdelay(500);    /* wait 500 millisecs */
1200
1201                 /* Restart auto-negotiation if remote fault */
1202                 if (status & PHY_STAT_REM_FLT) {
1203                         printf ("%s: PHY remote fault detected\n",
1204                                 SMC_DEV_NAME);
1205
1206                         /* Restart auto-negotiation */
1207                         printf ("%s: PHY restarting auto-negotiation\n",
1208                                 SMC_DEV_NAME);
1209                         smc_write_phy_register (dev, PHY_CNTL_REG,
1210                                                 PHY_CNTL_ANEG_EN |
1211                                                 PHY_CNTL_ANEG_RST |
1212                                                 PHY_CNTL_SPEED |
1213                                                 PHY_CNTL_DPLX);
1214                 }
1215         }
1216
1217         if (timeout < 1) {
1218                 printf ("%s: PHY auto-negotiate timed out\n", SMC_DEV_NAME);
1219         }
1220
1221         /* Fail if we detected an auto-negotiate remote fault */
1222         if (status & PHY_STAT_REM_FLT) {
1223                 printf ("%s: PHY remote fault detected\n", SMC_DEV_NAME);
1224         }
1225
1226         /* Re-Configure the Receive/Phy Control register */
1227         SMC_outw (dev, RPC_DEFAULT, RPC_REG);
1228
1229 smc_phy_configure_exit: ;
1230
1231 }
1232 #endif /* !CONFIG_SMC91111_EXT_PHY */
1233
1234
1235 #if SMC_DEBUG > 2
1236 static void print_packet( byte * buf, int length )
1237 {
1238         int i;
1239         int remainder;
1240         int lines;
1241
1242         printf("Packet of length %d \n", length );
1243
1244 #if SMC_DEBUG > 3
1245         lines = length / 16;
1246         remainder = length % 16;
1247
1248         for ( i = 0; i < lines ; i ++ ) {
1249                 int cur;
1250
1251                 for ( cur = 0; cur < 8; cur ++ ) {
1252                         byte a, b;
1253
1254                         a = *(buf ++ );
1255                         b = *(buf ++ );
1256                         printf("%02x%02x ", a, b );
1257                 }
1258                 printf("\n");
1259         }
1260         for ( i = 0; i < remainder/2 ; i++ ) {
1261                 byte a, b;
1262
1263                 a = *(buf ++ );
1264                 b = *(buf ++ );
1265                 printf("%02x%02x ", a, b );
1266         }
1267         printf("\n");
1268 #endif
1269 }
1270 #endif
1271
1272 int smc91111_initialize(u8 dev_num, int base_addr)
1273 {
1274         struct smc91111_priv *priv;
1275         struct eth_device *dev;
1276         int i;
1277
1278         priv = malloc(sizeof(*priv));
1279         if (!priv)
1280                 return 0;
1281         dev = malloc(sizeof(*dev));
1282         if (!dev) {
1283                 free(priv);
1284                 return 0;
1285         }
1286
1287         memset(dev, 0, sizeof(*dev));
1288         priv->dev_num = dev_num;
1289         dev->priv = priv;
1290         dev->iobase = base_addr;
1291
1292         swap_to(ETHERNET);
1293         SMC_SELECT_BANK(dev, 1);
1294         for (i = 0; i < 6; ++i)
1295                 dev->enetaddr[i] = SMC_inb(dev, (ADDR0_REG + i));
1296         swap_to(FLASH);
1297
1298         dev->init = smc_init;
1299         dev->halt = smc_halt;
1300         dev->send = smc_send;
1301         dev->recv = smc_rcv;
1302         dev->write_hwaddr = smc_write_hwaddr;
1303         sprintf(dev->name, "%s-%hu", SMC_DEV_NAME, dev_num);
1304
1305         eth_register(dev);
1306         return 0;
1307 }