drivers/net/rtl8139.c

   1 /*
   2  * rtl8139.c : U-Boot driver for the RealTek RTL8139
   3  *
   4  * Masami Komiya (mkomiya@sonare.it)
   5  *
   6  * Most part is taken from rtl8139.c of etherboot
   7  *
   8  */
   9
  10 /* rtl8139.c - etherboot driver for the Realtek 8139 chipset
  11
  12   ported from the linux driver written by Donald Becker
  13   by Rainer Bawidamann (Rainer.Bawidamann@informatik.uni-ulm.de) 1999
  14
  15   This software may be used and distributed according to the terms
  16   of the GNU Public License, incorporated herein by reference.
  17
  18   changes to the original driver:
  19   - removed support for interrupts, switching to polling mode (yuck!)
  20   - removed support for the 8129 chip (external MII)
  21
  22 */
  23
  24 /*********************************************************************/
  25 /* Revision History                                                  */
  26 /*********************************************************************/
  27
  28 /*
  29   28 Dec 2002   ken_yap@users.sourceforge.net (Ken Yap)
  30      Put in virt_to_bus calls to allow Etherboot relocation.
  31
  32   06 Apr 2001   ken_yap@users.sourceforge.net (Ken Yap)
  33      Following email from Hyun-Joon Cha, added a disable routine, otherwise
  34      NIC remains live and can crash the kernel later.
  35
  36   4 Feb 2000    espenlaub@informatik.uni-ulm.de (Klaus Espenlaub)
  37      Shuffled things around, removed the leftovers from the 8129 support
  38      that was in the Linux driver and added a bit more 8139 definitions.
  39      Moved the 8K receive buffer to a fixed, available address outside the
  40      0x98000-0x9ffff range.  This is a bit of a hack, but currently the only
  41      way to make room for the Etherboot features that need substantial amounts
  42      of code like the ANSI console support.  Currently the buffer is just below
  43      0x10000, so this even conforms to the tagged boot image specification,
  44      which reserves the ranges 0x00000-0x10000 and 0x98000-0xA0000.  My
  45      interpretation of this "reserved" is that Etherboot may do whatever it
  46      likes, as long as its environment is kept intact (like the BIOS
  47      variables).  Hopefully fixed rtl_poll() once and for all.  The symptoms
  48      were that if Etherboot was left at the boot menu for several minutes, the
  49      first eth_poll failed.  Seems like I am the only person who does this.
  50      First of all I fixed the debugging code and then set out for a long bug
  51      hunting session.  It took me about a week full time work - poking around
  52      various places in the driver, reading Don Becker's and Jeff Garzik's Linux
  53      driver and even the FreeBSD driver (what a piece of crap!) - and
  54      eventually spotted the nasty thing: the transmit routine was acknowledging
  55      each and every interrupt pending, including the RxOverrun and RxFIFIOver
  56      interrupts.  This confused the RTL8139 thoroughly.  It destroyed the
  57      Rx ring contents by dumping the 2K FIFO contents right where we wanted to
  58      get the next packet.  Oh well, what fun.
  59
  60   18 Jan 2000   mdc@thinguin.org (Marty Connor)
  61      Drastically simplified error handling.  Basically, if any error
  62      in transmission or reception occurs, the card is reset.
  63      Also, pointed all transmit descriptors to the same buffer to
  64      save buffer space.  This should decrease driver size and avoid
  65      corruption because of exceeding 32K during runtime.
  66
  67   28 Jul 1999   (Matthias Meixner - meixner@rbg.informatik.tu-darmstadt.de)
  68      rtl_poll was quite broken: it used the RxOK interrupt flag instead
  69      of the RxBufferEmpty flag which often resulted in very bad
  70      transmission performace - below 1kBytes/s.
  71
  72 */
  73
  74 #include <common.h>
  75 #include <malloc.h>
  76 #include <net.h>
  77 #include <netdev.h>
  78 #include <asm/io.h>
  79 #include <pci.h>
  80
  81 #define RTL_TIMEOUT     100000
  82
  83 #define ETH_FRAME_LEN           1514
  84 #define ETH_ALEN                6
  85 #define ETH_ZLEN                60
  86
  87 /* PCI Tuning Parameters
  88    Threshold is bytes transferred to chip before transmission starts. */
  89 #define TX_FIFO_THRESH 256      /* In bytes, rounded down to 32 byte units. */
  90 #define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
  91 #define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
  92 #define TX_DMA_BURST    4       /* Calculate as 16<<val. */
  93 #define NUM_TX_DESC     4       /* Number of Tx descriptor registers. */
  94 #define TX_BUF_SIZE     ETH_FRAME_LEN   /* FCS is added by the chip */
  95 #define RX_BUF_LEN_IDX 0        /* 0, 1, 2 is allowed - 8,16,32K rx buffer */
  96 #define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
  97
  98 #undef DEBUG_TX
  99 #undef DEBUG_RX
 100
 101 #define currticks()     get_timer(0)
 102 #define bus_to_phys(a)  pci_mem_to_phys((pci_dev_t)dev->priv, a)
 103 #define phys_to_bus(a)  pci_phys_to_mem((pci_dev_t)dev->priv, a)
 104
 105 /* Symbolic offsets to registers. */
 106 enum RTL8139_registers {
 107         MAC0=0,                 /* Ethernet hardware address. */
 108         MAR0=8,                 /* Multicast filter. */
 109         TxStatus0=0x10,         /* Transmit status (four 32bit registers). */
 110         TxAddr0=0x20,           /* Tx descriptors (also four 32bit). */
 111         RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36,
 112         ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A,
 113         IntrMask=0x3C, IntrStatus=0x3E,
 114         TxConfig=0x40, RxConfig=0x44,
 115         Timer=0x48,             /* general-purpose counter. */
 116         RxMissed=0x4C,          /* 24 bits valid, write clears. */
 117         Cfg9346=0x50, Config0=0x51, Config1=0x52,
 118         TimerIntrReg=0x54,      /* intr if gp counter reaches this value */
 119         MediaStatus=0x58,
 120         Config3=0x59,
 121         MultiIntr=0x5C,
 122         RevisionID=0x5E,        /* revision of the RTL8139 chip */
 123         TxSummary=0x60,
 124         MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68,
 125         NWayExpansion=0x6A,
 126         DisconnectCnt=0x6C, FalseCarrierCnt=0x6E,
 127         NWayTestReg=0x70,
 128         RxCnt=0x72,             /* packet received counter */
 129         CSCR=0x74,              /* chip status and configuration register */
 130         PhyParm1=0x78,TwisterParm=0x7c,PhyParm2=0x80,   /* undocumented */
 131         /* from 0x84 onwards are a number of power management/wakeup frame
 132          * definitions we will probably never need to know about.  */
 133 };
 134
 135 enum ChipCmdBits {
 136         CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, };
 137
 138 /* Interrupt register bits, using my own meaningful names. */
 139 enum IntrStatusBits {
 140         PCIErr=0x8000, PCSTimeout=0x4000, CableLenChange= 0x2000,
 141         RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10,
 142         TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01,
 143 };
 144 enum TxStatusBits {
 145         TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000,
 146         TxOutOfWindow=0x20000000, TxAborted=0x40000000,
 147         TxCarrierLost=0x80000000,
 148 };
 149 enum RxStatusBits {
 150         RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000,
 151         RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004,
 152         RxBadAlign=0x0002, RxStatusOK=0x0001,
 153 };
 154
 155 enum MediaStatusBits {
 156         MSRTxFlowEnable=0x80, MSRRxFlowEnable=0x40, MSRSpeed10=0x08,
 157         MSRLinkFail=0x04, MSRRxPauseFlag=0x02, MSRTxPauseFlag=0x01,
 158 };
 159
 160 enum MIIBMCRBits {
 161         BMCRReset=0x8000, BMCRSpeed100=0x2000, BMCRNWayEnable=0x1000,
 162         BMCRRestartNWay=0x0200, BMCRDuplex=0x0100,
 163 };
 164
 165 enum CSCRBits {
 166         CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800,
 167         CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0,
 168         CSCR_LinkDownCmd=0x0f3c0,
 169 };
 170
 171 /* Bits in RxConfig. */
 172 enum rx_mode_bits {
 173         RxCfgWrap=0x80,
 174         AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
 175         AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
 176 };
 177
 178 static int ioaddr;
 179 static unsigned int cur_rx,cur_tx;
 180
 181 /* The RTL8139 can only transmit from a contiguous, aligned memory block.  */
 182 static unsigned char tx_buffer[TX_BUF_SIZE] __attribute__((aligned(4)));
 183 static unsigned char rx_ring[RX_BUF_LEN+16] __attribute__((aligned(4)));
 184
 185 static int rtl8139_probe(struct eth_device *dev, bd_t *bis);
 186 static int read_eeprom(int location, int addr_len);
 187 static void rtl_reset(struct eth_device *dev);
 188 static int rtl_transmit(struct eth_device *dev, volatile void *packet, int length);
 189 static int rtl_poll(struct eth_device *dev);
 190 static void rtl_disable(struct eth_device *dev);
 191 #ifdef CONFIG_MCAST_TFTP/*  This driver already accepts all b/mcast */
 192 static int rtl_bcast_addr (struct eth_device *dev, u8 bcast_mac, u8 set)
 193 {
 194         return (0);
 195 }
 196 #endif
 197
 198 static struct pci_device_id supported[] = {
 199        {PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8139},
 200        {PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_8139},
 201        {}
 202 };
 203
 204 int rtl8139_initialize(bd_t *bis)
 205 {
 206         pci_dev_t devno;
 207         int card_number = 0;
 208         struct eth_device *dev;
 209         u32 iobase;
 210         int idx=0;
 211
 212         while(1){
 213                 /* Find RTL8139 */
 214                 if ((devno = pci_find_devices(supported, idx++)) < 0)
 215                         break;
 216
 217                 pci_read_config_dword(devno, PCI_BASE_ADDRESS_1, &iobase);
 218                 iobase &= ~0xf;
 219
 220                 debug ("rtl8139: REALTEK RTL8139 @0x%x\n", iobase);
 221
 222                 dev = (struct eth_device *)malloc(sizeof *dev);
 223                 if (!dev) {
 224                         printf("Can not allocate memory of rtl8139\n");
 225                         break;
 226                 }
 227                 memset(dev, 0, sizeof(*dev));
 228
 229                 sprintf (dev->name, "RTL8139#%d", card_number);
 230
 231                 dev->priv = (void *) devno;
 232                 dev->iobase = (int)bus_to_phys(iobase);
 233                 dev->init = rtl8139_probe;
 234                 dev->halt = rtl_disable;
 235                 dev->send = rtl_transmit;
 236                 dev->recv = rtl_poll;
 237 #ifdef CONFIG_MCAST_TFTP
 238                 dev->mcast = rtl_bcast_addr;
 239 #endif
 240
 241                 eth_register (dev);
 242
 243                 card_number++;
 244
 245                 pci_write_config_byte (devno, PCI_LATENCY_TIMER, 0x20);
 246
 247                 udelay (10 * 1000);
 248         }
 249
 250         return card_number;
 251 }
 252
 253 static int rtl8139_probe(struct eth_device *dev, bd_t *bis)
 254 {
 255         int i;
 256         int speed10, fullduplex;
 257         int addr_len;
 258         unsigned short *ap = (unsigned short *)dev->enetaddr;
 259
 260         ioaddr = dev->iobase;
 261
 262         /* Bring the chip out of low-power mode. */
 263         outb(0x00, ioaddr + Config1);
 264
 265         addr_len = read_eeprom(0,8) == 0x8129 ? 8 : 6;
 266         for (i = 0; i < 3; i++)
 267                 *ap++ = le16_to_cpu (read_eeprom(i + 7, addr_len));
 268
 269         speed10 = inb(ioaddr + MediaStatus) & MSRSpeed10;
 270         fullduplex = inw(ioaddr + MII_BMCR) & BMCRDuplex;
 271
 272         rtl_reset(dev);
 273
 274         if (inb(ioaddr + MediaStatus) & MSRLinkFail) {
 275                 printf("Cable not connected or other link failure\n");
 276                 return -1 ;
 277         }
 278
 279         return 0;
 280 }
 281
 282 /* Serial EEPROM section. */
 283
 284 /*  EEPROM_Ctrl bits. */
 285 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
 286 #define EE_CS           0x08    /* EEPROM chip select. */
 287 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
 288 #define EE_WRITE_0      0x00
 289 #define EE_WRITE_1      0x02
 290 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
 291 #define EE_ENB          (0x80 | EE_CS)
 292
 293 /*
 294         Delay between EEPROM clock transitions.
 295         No extra delay is needed with 33MHz PCI, but 66MHz may change this.
 296 */
 297
 298 #define eeprom_delay()  inl(ee_addr)
 299
 300 /* The EEPROM commands include the alway-set leading bit. */
 301 #define EE_WRITE_CMD    (5)
 302 #define EE_READ_CMD     (6)
 303 #define EE_ERASE_CMD    (7)
 304
 305 static int read_eeprom(int location, int addr_len)
 306 {
 307         int i;
 308         unsigned int retval = 0;
 309         long ee_addr = ioaddr + Cfg9346;
 310         int read_cmd = location | (EE_READ_CMD << addr_len);
 311
 312         outb(EE_ENB & ~EE_CS, ee_addr);
 313         outb(EE_ENB, ee_addr);
 314         eeprom_delay();
 315
 316         /* Shift the read command bits out. */
 317         for (i = 4 + addr_len; i >= 0; i--) {
 318                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 319                 outb(EE_ENB | dataval, ee_addr);
 320                 eeprom_delay();
 321                 outb(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
 322                 eeprom_delay();
 323         }
 324         outb(EE_ENB, ee_addr);
 325         eeprom_delay();
 326
 327         for (i = 16; i > 0; i--) {
 328                 outb(EE_ENB | EE_SHIFT_CLK, ee_addr);
 329                 eeprom_delay();
 330                 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
 331                 outb(EE_ENB, ee_addr);
 332                 eeprom_delay();
 333         }
 334
 335         /* Terminate the EEPROM access. */
 336         outb(~EE_CS, ee_addr);
 337         eeprom_delay();
 338         return retval;
 339 }
 340
 341 static const unsigned int rtl8139_rx_config =
 342         (RX_BUF_LEN_IDX << 11) |
 343         (RX_FIFO_THRESH << 13) |
 344         (RX_DMA_BURST << 8);
 345
 346 static void set_rx_mode(struct eth_device *dev) {
 347         unsigned int mc_filter[2];
 348         int rx_mode;
 349         /* !IFF_PROMISC */
 350         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
 351         mc_filter[1] = mc_filter[0] = 0xffffffff;
 352
 353         outl(rtl8139_rx_config | rx_mode, ioaddr + RxConfig);
 354
 355         outl(mc_filter[0], ioaddr + MAR0 + 0);
 356         outl(mc_filter[1], ioaddr + MAR0 + 4);
 357 }
 358
 359 static void rtl_reset(struct eth_device *dev)
 360 {
 361         int i;
 362
 363         outb(CmdReset, ioaddr + ChipCmd);
 364
 365         cur_rx = 0;
 366         cur_tx = 0;
 367
 368         /* Give the chip 10ms to finish the reset. */
 369         for (i=0; i<100; ++i){
 370                 if ((inb(ioaddr + ChipCmd) & CmdReset) == 0) break;
 371                 udelay (100); /* wait 100us */
 372         }
 373
 374
 375         for (i = 0; i < ETH_ALEN; i++)
 376                 outb(dev->enetaddr[i], ioaddr + MAC0 + i);
 377
 378         /* Must enable Tx/Rx before setting transfer thresholds! */
 379         outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd);
 380         outl((RX_FIFO_THRESH<<13) | (RX_BUF_LEN_IDX<<11) | (RX_DMA_BURST<<8),
 381                 ioaddr + RxConfig);             /* accept no frames yet!  */
 382         outl((TX_DMA_BURST<<8)|0x03000000, ioaddr + TxConfig);
 383
 384         /* The Linux driver changes Config1 here to use a different LED pattern
 385          * for half duplex or full/autodetect duplex (for full/autodetect, the
 386          * outputs are TX/RX, Link10/100, FULL, while for half duplex it uses
 387          * TX/RX, Link100, Link10).  This is messy, because it doesn't match
 388          * the inscription on the mounting bracket.  It should not be changed
 389          * from the configuration EEPROM default, because the card manufacturer
 390          * should have set that to match the card.  */
 391
 392 #ifdef  DEBUG_RX
 393         printf("rx ring address is %X\n",(unsigned long)rx_ring);
 394 #endif
 395         flush_cache((unsigned long)rx_ring, RX_BUF_LEN);
 396         outl(phys_to_bus((int)rx_ring), ioaddr + RxBuf);
 397
 398         /* If we add multicast support, the MAR0 register would have to be
 399          * initialized to 0xffffffffffffffff (two 32 bit accesses).  Etherboot
 400          * only needs broadcast (for ARP/RARP/BOOTP/DHCP) and unicast.  */
 401
 402         outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd);
 403
 404         outl(rtl8139_rx_config, ioaddr + RxConfig);
 405
 406         /* Start the chip's Tx and Rx process. */
 407         outl(0, ioaddr + RxMissed);
 408
 409         /* set_rx_mode */
 410         set_rx_mode(dev);
 411
 412         /* Disable all known interrupts by setting the interrupt mask. */
 413         outw(0, ioaddr + IntrMask);
 414 }
 415
 416 static int rtl_transmit(struct eth_device *dev, volatile void *packet, int length)
 417 {
 418         unsigned int status;
 419         unsigned long txstatus;
 420         unsigned int len = length;
 421         int i = 0;
 422
 423         ioaddr = dev->iobase;
 424
 425         memcpy((char *)tx_buffer, (char *)packet, (int)length);
 426
 427 #ifdef  DEBUG_TX
 428         printf("sending %d bytes\n", len);
 429 #endif
 430
 431         /* Note: RTL8139 doesn't auto-pad, send minimum payload (another 4
 432          * bytes are sent automatically for the FCS, totalling to 64 bytes). */
 433         while (len < ETH_ZLEN) {
 434                 tx_buffer[len++] = '\0';
 435         }
 436
 437         flush_cache((unsigned long)tx_buffer, length);
 438         outl(phys_to_bus((int)tx_buffer), ioaddr + TxAddr0 + cur_tx*4);
 439         outl(((TX_FIFO_THRESH<<11) & 0x003f0000) | len,
 440                 ioaddr + TxStatus0 + cur_tx*4);
 441
 442         do {
 443                 status = inw(ioaddr + IntrStatus);
 444                 /* Only acknlowledge interrupt sources we can properly handle
 445                  * here - the RxOverflow/RxFIFOOver MUST be handled in the
 446                  * rtl_poll() function.  */
 447                 outw(status & (TxOK | TxErr | PCIErr), ioaddr + IntrStatus);
 448                 if ((status & (TxOK | TxErr | PCIErr)) != 0) break;
 449                 udelay(10);
 450         } while (i++ < RTL_TIMEOUT);
 451
 452         txstatus = inl(ioaddr + TxStatus0 + cur_tx*4);
 453
 454         if (status & TxOK) {
 455                 cur_tx = (cur_tx + 1) % NUM_TX_DESC;
 456 #ifdef  DEBUG_TX
 457                 printf("tx done (%d ticks), status %hX txstatus %X\n",
 458                         to-currticks(), status, txstatus);
 459 #endif
 460                 return length;
 461         } else {
 462 #ifdef  DEBUG_TX
 463                 printf("tx timeout/error (%d usecs), status %hX txstatus %X\n",
 464                        10*i, status, txstatus);
 465 #endif
 466                 rtl_reset(dev);
 467
 468                 return 0;
 469         }
 470 }
 471
 472 static int rtl_poll(struct eth_device *dev)
 473 {
 474         unsigned int status;
 475         unsigned int ring_offs;
 476         unsigned int rx_size, rx_status;
 477         int length=0;
 478
 479         ioaddr = dev->iobase;
 480
 481         if (inb(ioaddr + ChipCmd) & RxBufEmpty) {
 482                 return 0;
 483         }
 484
 485         status = inw(ioaddr + IntrStatus);
 486         /* See below for the rest of the interrupt acknowledges.  */
 487         outw(status & ~(RxFIFOOver | RxOverflow | RxOK), ioaddr + IntrStatus);
 488
 489 #ifdef  DEBUG_RX
 490         printf("rtl_poll: int %hX ", status);
 491 #endif
 492
 493         ring_offs = cur_rx % RX_BUF_LEN;
 494         /* ring_offs is guaranteed being 4-byte aligned */
 495         rx_status = le32_to_cpu(*(unsigned int *)(rx_ring + ring_offs));
 496         rx_size = rx_status >> 16;
 497         rx_status &= 0xffff;
 498
 499         if ((rx_status & (RxBadSymbol|RxRunt|RxTooLong|RxCRCErr|RxBadAlign)) ||
 500             (rx_size < ETH_ZLEN) || (rx_size > ETH_FRAME_LEN + 4)) {
 501                 printf("rx error %hX\n", rx_status);
 502                 rtl_reset(dev); /* this clears all interrupts still pending */
 503                 return 0;
 504         }
 505
 506         /* Received a good packet */
 507         length = rx_size - 4;   /* no one cares about the FCS */
 508         if (ring_offs+4+rx_size-4 > RX_BUF_LEN) {
 509                 int semi_count = RX_BUF_LEN - ring_offs - 4;
 510                 unsigned char rxdata[RX_BUF_LEN];
 511
 512                 memcpy(rxdata, rx_ring + ring_offs + 4, semi_count);
 513                 memcpy(&(rxdata[semi_count]), rx_ring, rx_size-4-semi_count);
 514
 515                 NetReceive(rxdata, length);
 516 #ifdef  DEBUG_RX
 517                 printf("rx packet %d+%d bytes", semi_count,rx_size-4-semi_count);
 518 #endif
 519         } else {
 520                 NetReceive(rx_ring + ring_offs + 4, length);
 521 #ifdef  DEBUG_RX
 522                 printf("rx packet %d bytes", rx_size-4);
 523 #endif
 524         }
 525         flush_cache((unsigned long)rx_ring, RX_BUF_LEN);
 526
 527         cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
 528         outw(cur_rx - 16, ioaddr + RxBufPtr);
 529         /* See RTL8139 Programming Guide V0.1 for the official handling of
 530          * Rx overflow situations.  The document itself contains basically no
 531          * usable information, except for a few exception handling rules.  */
 532         outw(status & (RxFIFOOver | RxOverflow | RxOK), ioaddr + IntrStatus);
 533         return length;
 534 }
 535
 536 static void rtl_disable(struct eth_device *dev)
 537 {
 538         int i;
 539
 540         ioaddr = dev->iobase;
 541
 542         /* reset the chip */
 543         outb(CmdReset, ioaddr + ChipCmd);
 544
 545         /* Give the chip 10ms to finish the reset. */
 546         for (i=0; i<100; ++i){
 547                 if ((inb(ioaddr + ChipCmd) & CmdReset) == 0) break;
 548                 udelay (100); /* wait 100us */
 549         }
 550 }