src/drivers/net/eepro100.c

   1 /*
   2  * eepro100.c -- This file implements the eepro100 driver for etherboot.
   3  *
   4  *
   5  * Copyright (C) AW Computer Systems.
   6  * written by R.E.Wolff -- R.E.Wolff@BitWizard.nl
   7  *
   8  *
   9  * AW Computer Systems is contributing to the free software community
  10  * by paying for this driver and then putting the result under GPL.
  11  *
  12  * If you need a Linux device driver, please contact BitWizard for a
  13  * quote.
  14  *
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License as
  18  * published by the Free Software Foundation; either version 2, or (at
  19  * your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful, but
  22  * WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29  *
  30  *
  31  *              date       version  by   what
  32  *  Written:    May 29 1997  V0.10  REW  Initial revision.
  33  * changes:     May 31 1997  V0.90  REW  Works!
  34  *              Jun 1  1997  V0.91  REW  Cleanup
  35  *              Jun 2  1997  V0.92  REW  Add some code documentation
  36  *              Jul 25 1997  V1.00  REW  Tested by AW to work in a PROM
  37  *                                       Cleanup for publication
  38  *              Dez 11 2004  V1.10  Kiszka  Add RX ring buffer support
  39  *
  40  * This is the etherboot intel etherexpress Pro/100B driver.
  41  *
  42  * It was written from scratch, with Donald Beckers eepro100.c kernel
  43  * driver as a guideline. Mostly the 82557 related definitions and the
  44  * lower level routines have been cut-and-pasted into this source.
  45  *
  46  * The driver was finished before Intel got the NDA out of the closet.
  47  * I still don't have the docs.
  48  *
  49  *
  50  * Datasheet is now published and available from
  51  * ftp://download.intel.com/design/network/manuals/8255X_OpenSDM.pdf
  52  *    - Michael Brown
  53  * */
  54
  55 /* Philosophy of this driver.
  56  *
  57  * Probing:
  58  *
  59  * Using the pci.c functions of the Etherboot code, the 82557 chip is detected.
  60  * It is verified that the BIOS initialized everything properly and if
  61  * something is missing it is done now.
  62  *
  63  *
  64  * Initialization:
  65  *
  66  *
  67  * The chip is then initialized to "know" its ethernet address, and to
  68  * start recieving packets. The Linux driver has a whole transmit and
  69  * recieve ring of buffers. This is neat if you need high performance:
  70  * you can write the buffers asynchronously to the chip reading the
  71  * buffers and transmitting them over the network.  Performance is NOT
  72  * an issue here. We can boot a 400k kernel in about two
  73  * seconds. (Theory: 0.4 seconds). Booting a system is going to take
  74  * about half a minute anyway, so getting 10 times closer to the
  75  * theoretical limit is going to make a difference of a few percent. */
  76 /* Not totally true: busy networks can cause packet drops due to RX
  77  * buffer overflows. Fixed in V1.10 of this driver. [Kiszka] */
  78 /*
  79  *
  80  * Transmitting and recieving.
  81  *
  82  * We have only one transmit descriptor. It has two buffer descriptors:
  83  * one for the header, and the other for the data.
  84  * We have multiple receive buffers (currently: 4). The chip is told to
  85  * receive packets and suspend itself once it ran on the last free buffer.
  86  * The recieve (poll) routine simply looks at the current recieve buffer,
  87  * picks the packet if any, and releases this buffer again (classic ring
  88  * buffer concept). This helps to avoid packet drops on busy networks.
  89  *
  90  * Caveats:
  91  *
  92  * The Etherboot framework moves the code to the 48k segment from
  93  * 0x94000 to 0xa0000. There is just a little room between the end of
  94  * this driver and the 0xa0000 address. If you compile in too many
  95  * features, this will overflow.
  96  * The number under "hex" in the output of size that scrolls by while
  97  * compiling should be less than 8000. Maybe even the stack is up there,
  98  * so that you need even more headroom.
  99  */
 100
 101 /* The etherboot authors seem to dislike the argument ordering in
 102  * outb macros that Linux uses. I disklike the confusion that this
 103  * has caused even more.... This file uses the Linux argument ordering.  */
 104 /* Sorry not us. It's inherited code from FreeBSD. [The authors] */
 105
 106 #include "etherboot.h"
 107 #include "nic.h"
 108 #include <gpxe/ethernet.h>
 109 #include <gpxe/pci.h>
 110
 111 static int ioaddr;
 112
 113 enum speedo_offsets {
 114   SCBStatus = 0, SCBCmd = 2,      /* Rx/Command Unit command and status. */
 115   SCBPointer = 4,                 /* General purpose pointer. */
 116   SCBPort = 8,                    /* Misc. commands and operands.  */
 117   SCBflash = 12, SCBeeprom = 14,  /* EEPROM and flash memory control. */
 118   SCBCtrlMDI = 16,                /* MDI interface control. */
 119   SCBEarlyRx = 20,                /* Early receive byte count. */
 120 };
 121
 122 enum SCBCmdBits {
 123         SCBMaskCmdDone=0x8000, SCBMaskRxDone=0x4000, SCBMaskCmdIdle=0x2000,
 124         SCBMaskRxSuspend=0x1000, SCBMaskEarlyRx=0x0800, SCBMaskFlowCtl=0x0400,
 125         SCBTriggerIntr=0x0200, SCBMaskAll=0x0100,
 126         /* The rest are Rx and Tx commands. */
 127         CUStart=0x0010, CUResume=0x0020, CUStatsAddr=0x0040, CUShowStats=0x0050,
 128         CUCmdBase=0x0060,       /* CU Base address (set to zero) . */
 129         CUDumpStats=0x0070, /* Dump then reset stats counters. */
 130         RxStart=0x0001, RxResume=0x0002, RxAbort=0x0004, RxAddrLoad=0x0006,
 131         RxResumeNoResources=0x0007,
 132 };
 133
 134 static int do_eeprom_cmd(int cmd, int cmd_len);
 135 void hd(void *where, int n);
 136
 137 /***********************************************************************/
 138 /*                       I82557 related defines                        */
 139 /***********************************************************************/
 140
 141 /* Serial EEPROM section.
 142    A "bit" grungy, but we work our way through bit-by-bit :->. */
 143 /*  EEPROM_Ctrl bits. */
 144 #define EE_SHIFT_CLK    0x01    /* EEPROM shift clock. */
 145 #define EE_CS           0x02    /* EEPROM chip select. */
 146 #define EE_DATA_WRITE   0x04    /* EEPROM chip data in. */
 147 #define EE_DATA_READ    0x08    /* EEPROM chip data out. */
 148 #define EE_WRITE_0      0x4802
 149 #define EE_WRITE_1      0x4806
 150 #define EE_ENB          (0x4800 | EE_CS)
 151
 152 /* The EEPROM commands include the alway-set leading bit. */
 153 #define EE_READ_CMD     6
 154
 155 /* The SCB accepts the following controls for the Tx and Rx units: */
 156 #define  CU_START       0x0010
 157 #define  CU_RESUME      0x0020
 158 #define  CU_STATSADDR   0x0040
 159 #define  CU_SHOWSTATS   0x0050  /* Dump statistics counters. */
 160 #define  CU_CMD_BASE    0x0060  /* Base address to add to add CU commands. */
 161 #define  CU_DUMPSTATS   0x0070  /* Dump then reset stats counters. */
 162
 163 #define  RX_START       0x0001
 164 #define  RX_RESUME      0x0002
 165 #define  RX_ABORT       0x0004
 166 #define  RX_ADDR_LOAD   0x0006
 167 #define  RX_RESUMENR    0x0007
 168 #define INT_MASK        0x0100
 169 #define DRVR_INT        0x0200          /* Driver generated interrupt. */
 170
 171 enum phy_chips { NonSuchPhy=0, I82553AB, I82553C, I82503, DP83840, S80C240,
 172                                          S80C24, PhyUndefined, DP83840A=10, };
 173
 174 /* Commands that can be put in a command list entry. */
 175 enum commands {
 176   CmdNOp = 0,
 177   CmdIASetup = 1,
 178   CmdConfigure = 2,
 179   CmdMulticastList = 3,
 180   CmdTx = 4,
 181   CmdTDR = 5,
 182   CmdDump = 6,
 183   CmdDiagnose = 7,
 184
 185   /* And some extra flags: */
 186   CmdSuspend = 0x4000,      /* Suspend after completion. */
 187   CmdIntr = 0x2000,         /* Interrupt after completion. */
 188   CmdTxFlex = 0x0008,       /* Use "Flexible mode" for CmdTx command. */
 189 };
 190
 191 /* How to wait for the command unit to accept a command.
 192    Typically this takes 0 ticks. */
 193 static inline void wait_for_cmd_done(int cmd_ioaddr)
 194 {
 195   int wait = 0;
 196   int delayed_cmd;
 197
 198   do
 199     if (inb(cmd_ioaddr) == 0) return;
 200   while(++wait <= 100);
 201   delayed_cmd = inb(cmd_ioaddr);
 202   do
 203     if (inb(cmd_ioaddr) == 0) break;
 204   while(++wait <= 10000);
 205   printf("Command %2.2x was not immediately accepted, %d ticks!\n",
 206       delayed_cmd, wait);
 207 }
 208
 209 /* Elements of the dump_statistics block. This block must be lword aligned. */
 210 static struct speedo_stats {
 211         u32 tx_good_frames;
 212         u32 tx_coll16_errs;
 213         u32 tx_late_colls;
 214         u32 tx_underruns;
 215         u32 tx_lost_carrier;
 216         u32 tx_deferred;
 217         u32 tx_one_colls;
 218         u32 tx_multi_colls;
 219         u32 tx_total_colls;
 220         u32 rx_good_frames;
 221         u32 rx_crc_errs;
 222         u32 rx_align_errs;
 223         u32 rx_resource_errs;
 224         u32 rx_overrun_errs;
 225         u32 rx_colls_errs;
 226         u32 rx_runt_errs;
 227         u32 done_marker;
 228 } lstats;
 229
 230 /* A speedo3 TX buffer descriptor with two buffers... */
 231 static struct TxFD {
 232         volatile s16 status;
 233         s16 command;
 234         u32 link;          /* void * */
 235         u32 tx_desc_addr;  /* (almost) Always points to the tx_buf_addr element. */
 236         s32 count;         /* # of TBD (=2), Tx start thresh., etc. */
 237         /* This constitutes two "TBD" entries: hdr and data */
 238         u32 tx_buf_addr0;  /* void *, header of frame to be transmitted.  */
 239         s32 tx_buf_size0;  /* Length of Tx hdr. */
 240         u32 tx_buf_addr1;  /* void *, data to be transmitted.  */
 241         s32 tx_buf_size1;  /* Length of Tx data. */
 242 } txfd;
 243
 244 struct RxFD {               /* Receive frame descriptor. */
 245         volatile s16 status;
 246         s16 command;
 247         u32 link;                 /* struct RxFD * */
 248         u32 rx_buf_addr;          /* void * */
 249         u16 count;
 250         u16 size;
 251         char packet[1518];
 252 };
 253
 254 static struct nic_operations eepro100_operations;
 255
 256 #define RXFD_COUNT 4
 257 struct {
 258         struct RxFD rxfds[RXFD_COUNT];
 259 } eepro100_bufs __shared;
 260 #define rxfds eepro100_bufs.rxfds
 261 static unsigned int rxfd = 0;
 262
 263 static int congenb = 0;         /* Enable congestion control in the DP83840. */
 264 static int txfifo = 8;          /* Tx FIFO threshold in 4 byte units, 0-15 */
 265 static int rxfifo = 8;          /* Rx FIFO threshold, default 32 bytes. */
 266 static int txdmacount = 0;      /* Tx DMA burst length, 0-127, default 0. */
 267 static int rxdmacount = 0;      /* Rx DMA length, 0 means no preemption. */
 268
 269 /* I don't understand a byte in this structure. It was copied from the
 270  * Linux kernel initialization for the eepro100. -- REW */
 271 static struct ConfCmd {
 272   s16 status;
 273   s16 command;
 274   u32 link;
 275   unsigned char data[22];
 276 } confcmd = {
 277   0, 0, 0, /* filled in later */
 278   {22, 0x08, 0, 0,  0, 0x80, 0x32, 0x03,  1, /* 1=Use MII  0=Use AUI */
 279    0, 0x2E, 0,  0x60, 0,
 280    0xf2, 0x48,   0, 0x40, 0xf2, 0x80,        /* 0x40=Force full-duplex */
 281    0x3f, 0x05, }
 282 };
 283
 284 /***********************************************************************/
 285 /*                       Locally used functions                        */
 286 /***********************************************************************/
 287
 288 /* Support function: mdio_write
 289  *
 290  * This probably writes to the "physical media interface chip".
 291  * -- REW
 292  */
 293
 294 static int mdio_write(int phy_id, int location, int value)
 295 {
 296         int val, boguscnt = 64*4;         /* <64 usec. to complete, typ 27 ticks */
 297
 298         outl(0x04000000 | (location<<16) | (phy_id<<21) | value,
 299              ioaddr + SCBCtrlMDI);
 300         do {
 301                 udelay(16);
 302
 303                 val = inl(ioaddr + SCBCtrlMDI);
 304                 if (--boguscnt < 0) {
 305                         printf(" mdio_write() timed out with val = %X.\n", val);
 306                         break;
 307                 }
 308         } while (! (val & 0x10000000));
 309         return val & 0xffff;
 310 }
 311
 312 /* Support function: mdio_read
 313  *
 314  * This probably reads a register in the "physical media interface chip".
 315  * -- REW
 316  */
 317 static int mdio_read(int phy_id, int location)
 318 {
 319         int val, boguscnt = 64*4;               /* <64 usec. to complete, typ 27 ticks */
 320         outl(0x08000000 | (location<<16) | (phy_id<<21), ioaddr + SCBCtrlMDI);
 321         do {
 322                 udelay(16);
 323
 324                 val = inl(ioaddr + SCBCtrlMDI);
 325
 326                 if (--boguscnt < 0) {
 327                         printf( " mdio_read() timed out with val = %X.\n", val);
 328                         break;
 329                 }
 330         } while (! (val & 0x10000000));
 331         return val & 0xffff;
 332 }
 333
 334 /* The fixes for the code were kindly provided by Dragan Stancevic
 335    <visitor@valinux.com> to strictly follow Intel specifications of EEPROM
 336    access timing.
 337    The publicly available sheet 64486302 (sec. 3.1) specifies 1us access
 338    interval for serial EEPROM.  However, it looks like that there is an
 339    additional requirement dictating larger udelay's in the code below.
 340    2000/05/24  SAW */
 341 static int do_eeprom_cmd(int cmd, int cmd_len)
 342 {
 343         unsigned retval = 0;
 344         long ee_addr = ioaddr + SCBeeprom;
 345
 346         outw(EE_ENB, ee_addr); udelay(2);
 347         outw(EE_ENB | EE_SHIFT_CLK, ee_addr); udelay(2);
 348
 349         /* Shift the command bits out. */
 350         do {
 351                 short dataval = (cmd & (1 << cmd_len)) ? EE_WRITE_1 : EE_WRITE_0;
 352                 outw(dataval, ee_addr); udelay(2);
 353                 outw(dataval | EE_SHIFT_CLK, ee_addr); udelay(2);
 354                 retval = (retval << 1) | ((inw(ee_addr) & EE_DATA_READ) ? 1 : 0);
 355         } while (--cmd_len >= 0);
 356         outw(EE_ENB, ee_addr); udelay(2);
 357
 358         /* Terminate the EEPROM access. */
 359         outw(EE_ENB & ~EE_CS, ee_addr);
 360         return retval;
 361 }
 362
 363 #if 0
 364 static inline void whereami (const char *str)
 365 {
 366   printf ("%s\n", str);
 367   sleep (2);
 368 }
 369 #else
 370 #define whereami(s)
 371 #endif
 372
 373 static void eepro100_irq(struct nic *nic __unused, irq_action_t action)
 374 {
 375         uint16_t enabled_mask = ( SCBMaskCmdDone | SCBMaskCmdIdle |
 376                                   SCBMaskEarlyRx | SCBMaskFlowCtl );
 377
 378         switch ( action ) {
 379         case DISABLE :
 380                 outw(SCBMaskAll, ioaddr + SCBCmd);
 381                 break;
 382         case ENABLE :
 383                 outw(enabled_mask, ioaddr + SCBCmd);
 384                 break;
 385         case FORCE :
 386                 outw(enabled_mask | SCBTriggerIntr, ioaddr + SCBCmd);
 387                 break;
 388         }
 389 }
 390
 391 /* function: eepro100_transmit
 392  * This transmits a packet.
 393  *
 394  * Arguments: char d[6]:          destination ethernet address.
 395  *            unsigned short t:   ethernet protocol type.
 396  *            unsigned short s:   size of the data-part of the packet.
 397  *            char *p:            the data for the packet.
 398  * returns:   void.
 399  */
 400
 401 static void eepro100_transmit(struct nic *nic, const char *d, unsigned int t, unsigned int s, const char *p)
 402 {
 403         struct eth_hdr {
 404                 unsigned char dst_addr[ETH_ALEN];
 405                 unsigned char src_addr[ETH_ALEN];
 406                 unsigned short type;
 407         } hdr;
 408         unsigned short status;
 409         int s1, s2;
 410         tick_t ct;
 411
 412         status = inw(ioaddr + SCBStatus);
 413         /* Acknowledge all of the current interrupt sources ASAP. */
 414         outw(status & 0xfc00, ioaddr + SCBStatus);
 415
 416 #ifdef  DEBUG
 417         printf ("transmitting type %hX packet (%d bytes). status = %hX, cmd=%hX\n",
 418                 t, s, status, inw (ioaddr + SCBCmd));
 419 #endif
 420
 421         memcpy (&hdr.dst_addr, d, ETH_ALEN);
 422         memcpy (&hdr.src_addr, nic->node_addr, ETH_ALEN);
 423
 424         hdr.type = htons (t);
 425
 426         txfd.status = 0;
 427         txfd.command = CmdSuspend | CmdTx | CmdTxFlex;
 428         txfd.link   = virt_to_bus (&txfd);
 429         txfd.count   = 0x02208000;
 430         txfd.tx_desc_addr = virt_to_bus(&txfd.tx_buf_addr0);
 431
 432         txfd.tx_buf_addr0 = virt_to_bus (&hdr);
 433         txfd.tx_buf_size0 = sizeof (hdr);
 434
 435         txfd.tx_buf_addr1 = virt_to_bus (p);
 436         txfd.tx_buf_size1 = s;
 437
 438 #ifdef  DEBUG
 439         printf ("txfd: \n");
 440         hd (&txfd, sizeof (txfd));
 441 #endif
 442
 443         outl(virt_to_bus(&txfd), ioaddr + SCBPointer);
 444         outb(CU_START, ioaddr + SCBCmd);
 445         wait_for_cmd_done(ioaddr + SCBCmd);
 446
 447         s1 = inw (ioaddr + SCBStatus);
 448
 449         ct = currticks();
 450         /* timeout 10 ms for transmit */
 451         while (!txfd.status && ct + 10*USECS_IN_MSEC)
 452                 /* Wait */;
 453         s2 = inw (ioaddr + SCBStatus);
 454
 455 #ifdef  DEBUG
 456         printf ("s1 = %hX, s2 = %hX.\n", s1, s2);
 457 #endif
 458 }
 459
 460 /*
 461  * Sometimes the receiver stops making progress.  This routine knows how to
 462  * get it going again, without losing packets or being otherwise nasty like
 463  * a chip reset would be.  Previously the driver had a whole sequence
 464  * of if RxSuspended, if it's no buffers do one thing, if it's no resources,
 465  * do another, etc.  But those things don't really matter.  Separate logic
 466  * in the ISR provides for allocating buffers--the other half of operation
 467  * is just making sure the receiver is active.  speedo_rx_soft_reset does that.
 468  * This problem with the old, more involved algorithm is shown up under
 469  * ping floods on the order of 60K packets/second on a 100Mbps fdx network.
 470  */
 471 static void
 472 speedo_rx_soft_reset(void)
 473 {
 474         int i;
 475
 476
 477 #ifdef  DEBUG
 478         printf("reset\n");
 479 #endif
 480         wait_for_cmd_done(ioaddr + SCBCmd);
 481         /*
 482          * Put the hardware into a known state.
 483          */
 484         outb(RX_ABORT, ioaddr + SCBCmd);
 485
 486         for (i = 0; i < RXFD_COUNT; i++) {
 487                 rxfds[i].status      = 0;
 488                 rxfds[i].rx_buf_addr = 0xffffffff;
 489                 rxfds[i].count       = 0;
 490                 rxfds[i].size        = 1528;
 491         }
 492
 493         wait_for_cmd_done(ioaddr + SCBCmd);
 494
 495         outl(virt_to_bus(&rxfds[rxfd]), ioaddr + SCBPointer);
 496         outb(RX_START, ioaddr + SCBCmd);
 497 }
 498
 499 /* function: eepro100_poll / eth_poll
 500  * This receives a packet from the network.
 501  *
 502  * Arguments: none
 503  *
 504  * returns:   1 if a packet was received.
 505  *            0 if no packet was received.
 506  * side effects:
 507  *            returns the packet in the array nic->packet.
 508  *            returns the length of the packet in nic->packetlen.
 509  */
 510
 511 static int eepro100_poll(struct nic *nic, int retrieve)
 512 {
 513         if (rxfds[rxfd].status) {
 514                 if (!retrieve)
 515                         return 1;
 516 #ifdef  DEBUG
 517                 printf("Got a packet: Len = %d, rxfd = %d.\n",
 518                        rxfds[rxfd].count & 0x3fff, rxfd);
 519 #endif
 520                 /* First save the data from the rxfd */
 521                 nic->packetlen = rxfds[rxfd].count & 0x3fff;
 522                 memcpy(nic->packet, rxfds[rxfd].packet, nic->packetlen);
 523
 524                 rxfds[rxfd].status      = 0;
 525                 rxfds[rxfd].command     = 0xc000;
 526                 rxfds[rxfd].rx_buf_addr = 0xFFFFFFFF;
 527                 rxfds[rxfd].count       = 0;
 528                 rxfds[rxfd].size        = 1528;
 529                 rxfds[(rxfd-1) % RXFD_COUNT].command = 0x0000;
 530                 rxfd = (rxfd+1) % RXFD_COUNT;
 531
 532 #ifdef  DEBUG
 533                 hd (nic->packet, 0x30);
 534 #endif
 535
 536                 /* Acknowledge all conceivable interrupts */
 537                 outw(0xff00, ioaddr + SCBStatus);
 538
 539                 return 1;
 540         }
 541
 542         /*
 543          * The chip may have suspended reception for various reasons.
 544          * Check for that, and re-prime it should this be the case.
 545          */
 546         switch ((inw(ioaddr + SCBStatus) >> 2) & 0xf) {
 547                 case 0:  /* Idle */
 548                         break;
 549                 case 1:  /* Suspended */
 550                 case 2:  /* No resources (RxFDs) */
 551                 case 9:  /* Suspended with no more RBDs */
 552                 case 10: /* No resources due to no RBDs */
 553                 case 12: /* Ready with no RBDs */
 554                         speedo_rx_soft_reset();
 555                         break;
 556                 default:
 557                         /* reserved values */
 558                         break;
 559         }
 560         return 0;
 561 }
 562
 563 /* function: eepro100_disable
 564  * resets the card. This is used to allow Etherboot or Linux
 565  * to probe the card again from a "virginal" state....
 566  * Arguments: none
 567  *
 568  * returns:   void.
 569  */
 570 static void eepro100_disable ( struct nic *nic __unused ) {
 571 /* from eepro100_reset */
 572         outl(0, ioaddr + SCBPort);
 573 /* from eepro100_disable */
 574         /* See if this PartialReset solves the problem with interfering with
 575            kernel operation after Etherboot hands over. - Ken 20001102 */
 576         outl(2, ioaddr + SCBPort);
 577
 578         /* The following is from the Intel e100 driver.
 579          * This hopefully solves the problem with hanging hard DOS images. */
 580
 581         /* wait for the reset to take effect */
 582         udelay(20);
 583
 584         /* Mask off our interrupt line -- it is unmasked after reset */
 585         {
 586                 u16 intr_status;
 587                 /* Disable interrupts on our PCI board by setting the mask bit */
 588                 outw(INT_MASK, ioaddr + SCBCmd);
 589                 intr_status = inw(ioaddr + SCBStatus);
 590                 /* ack and clear intrs */
 591                 outw(intr_status, ioaddr + SCBStatus);
 592                 inw(ioaddr + SCBStatus);
 593         }
 594 }
 595
 596 /* exported function: eepro100_probe / eth_probe
 597  * initializes a card
 598  *
 599  * side effects:
 600  *            leaves the ioaddress of the 82557 chip in the variable ioaddr.
 601  *            leaves the 82557 initialized, and ready to recieve packets.
 602  */
 603
 604 static int eepro100_probe ( struct nic *nic, struct pci_device *pci ) {
 605
 606         unsigned short sum = 0;
 607         int i;
 608         int read_cmd, ee_size;
 609         int options;
 610         int rx_mode;
 611         tick_t ct;
 612
 613         /* we cache only the first few words of the EEPROM data
 614            be careful not to access beyond this array */
 615         unsigned short eeprom[16];
 616
 617         if (pci->ioaddr == 0)
 618                 return 0;
 619
 620         adjust_pci_device(pci);
 621
 622         nic->ioaddr = pci->ioaddr;
 623         nic->irqno = pci->irq;
 624
 625         ioaddr = nic->ioaddr;
 626
 627         if ((do_eeprom_cmd(EE_READ_CMD << 24, 27) & 0xffe0000)
 628                 == 0xffe0000) {
 629                 ee_size = 0x100;
 630                 read_cmd = EE_READ_CMD << 24;
 631         } else {
 632                 ee_size = 0x40;
 633                 read_cmd = EE_READ_CMD << 22;
 634         }
 635
 636         for (i = 0, sum = 0; i < ee_size; i++) {
 637                 unsigned short value = do_eeprom_cmd(read_cmd | (i << 16), 27);
 638                 if (i < (int)(sizeof(eeprom)/sizeof(eeprom[0])))
 639                         eeprom[i] = value;
 640                 sum += value;
 641         }
 642
 643         for (i=0;i<ETH_ALEN;i++) {
 644                 nic->node_addr[i] =  (eeprom[i/2] >> (8*(i&1))) & 0xff;
 645         }
 646
 647         DBG ( "Ethernet addr: %s\n", eth_ntoa ( nic->node_addr ) );
 648
 649         if (sum != 0xBABA)
 650                 printf("eepro100: Invalid EEPROM checksum %#hX, "
 651                        "check settings before activating this device!\n", sum);
 652         outl(0, ioaddr + SCBPort);
 653         udelay (10000);
 654         whereami ("Got eeprom.");
 655
 656         /* Base = 0, disable all interrupts  */
 657         outl(0, ioaddr + SCBPointer);
 658         outw(INT_MASK | RX_ADDR_LOAD, ioaddr + SCBCmd);
 659         wait_for_cmd_done(ioaddr + SCBCmd);
 660         whereami ("set rx base addr.");
 661
 662         outl(virt_to_bus(&lstats), ioaddr + SCBPointer);
 663         outb(CU_STATSADDR, ioaddr + SCBCmd);
 664         wait_for_cmd_done(ioaddr + SCBCmd);
 665         whereami ("set stats addr.");
 666
 667         /* INIT RX stuff. */
 668         for (i = 0; i < RXFD_COUNT; i++) {
 669                 rxfds[i].status      = 0x0000;
 670                 rxfds[i].command     = 0x0000;
 671                 rxfds[i].rx_buf_addr = 0xFFFFFFFF;
 672                 rxfds[i].count       = 0;
 673                 rxfds[i].size        = 1528;
 674                 rxfds[i].link        = virt_to_bus(&rxfds[i+1]);
 675         }
 676
 677         rxfds[RXFD_COUNT-1].status  = 0x0000;
 678         rxfds[RXFD_COUNT-1].command = 0xC000;
 679         rxfds[RXFD_COUNT-1].link    = virt_to_bus(&rxfds[0]);
 680
 681         outl(virt_to_bus(&rxfds[0]), ioaddr + SCBPointer);
 682         outb(RX_START, ioaddr + SCBCmd);
 683         wait_for_cmd_done(ioaddr + SCBCmd);
 684
 685         whereami ("started RX process.");
 686
 687         /* INIT TX stuff. */
 688
 689         /* Base = 0 */
 690         outl(0, ioaddr + SCBPointer);
 691         outb(CU_CMD_BASE, ioaddr + SCBCmd);
 692         wait_for_cmd_done(ioaddr + SCBCmd);
 693
 694         whereami ("set TX base addr.");
 695
 696         txfd.command      = (CmdIASetup);
 697         txfd.status       = 0x0000;
 698         txfd.link         = virt_to_bus (&confcmd);
 699
 700         {
 701                 char *t = (char *)&txfd.tx_desc_addr;
 702
 703                 for (i=0;i<ETH_ALEN;i++)
 704                         t[i] = nic->node_addr[i];
 705         }
 706
 707 #ifdef  DEBUG
 708         printf ("Setup_eaddr:\n");
 709         hd (&txfd, 0x20);
 710 #endif
 711         /*      options = 0x40; */ /* 10mbps half duplex... */
 712         options = 0x00;            /* Autosense */
 713
 714 #ifdef PROMISC
 715         rx_mode = 3;
 716 #elif ALLMULTI
 717         rx_mode = 1;
 718 #else
 719         rx_mode = 0;
 720 #endif
 721
 722         if (   ((eeprom[6]>>8) & 0x3f) == DP83840
 723                || ((eeprom[6]>>8) & 0x3f) == DP83840A) {
 724                 int mdi_reg23 = mdio_read(eeprom[6] & 0x1f, 23) | 0x0422;
 725                 if (congenb)
 726                         mdi_reg23 |= 0x0100;
 727                 printf("  DP83840 specific setup, setting register 23 to %hX.\n",
 728                        mdi_reg23);
 729                 mdio_write(eeprom[6] & 0x1f, 23, mdi_reg23);
 730         }
 731         whereami ("Done DP8340 special setup.");
 732         if (options != 0) {
 733                 mdio_write(eeprom[6] & 0x1f, 0,
 734                            ((options & 0x20) ? 0x2000 : 0) |    /* 100mbps? */
 735                            ((options & 0x10) ? 0x0100 : 0)); /* Full duplex? */
 736                 whereami ("set mdio_register.");
 737         }
 738
 739         confcmd.command  = CmdSuspend | CmdConfigure;
 740         confcmd.status   = 0x0000;
 741         confcmd.link     = virt_to_bus (&txfd);
 742         confcmd.data[1]  = (txfifo << 4) | rxfifo;
 743         confcmd.data[4]  = rxdmacount;
 744         confcmd.data[5]  = txdmacount + 0x80;
 745         confcmd.data[15] = (rx_mode & 2) ? 0x49: 0x48;
 746         confcmd.data[19] = (options & 0x10) ? 0xC0 : 0x80;
 747         confcmd.data[21] = (rx_mode & 1) ? 0x0D: 0x05;
 748
 749         outl(virt_to_bus(&txfd), ioaddr + SCBPointer);
 750         outb(CU_START, ioaddr + SCBCmd);
 751         wait_for_cmd_done(ioaddr + SCBCmd);
 752
 753         whereami ("started TX thingy (config, iasetup).");
 754
 755         ct = currticks();
 756         while (!txfd.status && ct + 10*USECS_IN_MSEC < currticks())
 757                 /* Wait */;
 758
 759         /* Read the status register once to disgard stale data */
 760         mdio_read(eeprom[6] & 0x1f, 1);
 761         /* Check to see if the network cable is plugged in.
 762          * This allows for faster failure if there is nothing
 763          * we can do.
 764          */
 765         if (!(mdio_read(eeprom[6] & 0x1f, 1) & (1 << 2))) {
 766                 printf("Valid link not established\n");
 767                 eepro100_disable(nic);
 768                 return 0;
 769         }
 770         nic->nic_op     = &eepro100_operations;
 771         return 1;
 772 }
 773
 774 /*********************************************************************/
 775
 776 #ifdef  DEBUG
 777
 778 /* Hexdump a number of bytes from memory... */
 779 void hd (void *where, int n)
 780 {
 781         int i;
 782
 783         while (n > 0) {
 784                 printf ("%X ", where);
 785                 for (i=0;i < ( (n>16)?16:n);i++)
 786                         printf (" %hhX", ((char *)where)[i]);
 787                 printf ("\n");
 788                 n -= 16;
 789                 where += 16;
 790         }
 791 }
 792 #endif
 793
 794 static struct nic_operations eepro100_operations = {
 795         .connect        = dummy_connect,
 796         .poll           = eepro100_poll,
 797         .transmit       = eepro100_transmit,
 798         .irq            = eepro100_irq,
 799
 800 };
 801
 802 static struct pci_device_id eepro100_nics[] = {
 803 PCI_ROM(0x8086, 0x1029, "id1029",        "Intel EtherExpressPro100 ID1029"),
 804 PCI_ROM(0x8086, 0x1030, "id1030",        "Intel EtherExpressPro100 ID1030"),
 805 PCI_ROM(0x8086, 0x1031, "82801cam",      "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 806 PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection"),
 807 PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection"),
 808 PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection"),
 809 PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 810 PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 811 PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 812 PCI_ROM(0x8086, 0x1038, "id1038",        "Intel PRO/100 VM Network Connection"),
 813 PCI_ROM(0x8086, 0x1039, "82562et",       "Intel PRO100 VE 82562ET"),
 814 PCI_ROM(0x8086, 0x103a, "id103a",        "Intel Corporation 82559 InBusiness 10/100"),
 815 PCI_ROM(0x8086, 0x103b, "82562etb",      "Intel PRO100 VE 82562ETB"),
 816 PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection"),
 817 PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection"),
 818 PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection"),
 819 PCI_ROM(0x8086, 0x1051, "prove",       "Intel PRO/100 VE Network Connection"),
 820 PCI_ROM(0x8086, 0x1059, "82551qm",       "Intel PRO/100 M Mobile Connection"),
 821 PCI_ROM(0x8086, 0x1209, "82559er",       "Intel EtherExpressPro100 82559ER"),
 822 PCI_ROM(0x8086, 0x1227, "82865",         "Intel 82865 EtherExpress PRO/100A"),
 823 PCI_ROM(0x8086, 0x1228, "82556",         "Intel 82556 EtherExpress PRO/100 Smart"),
 824 PCI_ROM(0x8086, 0x1229, "eepro100",      "Intel EtherExpressPro100"),
 825 PCI_ROM(0x8086, 0x2449, "82562em",       "Intel EtherExpressPro100 82562EM"),
 826 PCI_ROM(0x8086, 0x2459, "82562-1",       "Intel 82562 based Fast Ethernet Connection"),
 827 PCI_ROM(0x8086, 0x245d, "82562-2",       "Intel 82562 based Fast Ethernet Connection"),
 828 PCI_ROM(0x8086, 0x1050, "82562ez",       "Intel 82562EZ Network Connection"),
 829 PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller"),
 830 PCI_ROM(0x8086, 0x1065, "82562-3",       "Intel 82562 based Fast Ethernet Connection"),
 831 PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server"),
 832 PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server"),
 833 };
 834
 835 /* Cards with device ids 0x1030 to 0x103F, 0x2449, 0x2459 or 0x245D might need
 836  * a workaround for hardware bug on 10 mbit half duplex (see linux driver eepro100.c)
 837  * 2003/03/17 gbaum */
 838
 839
 840 PCI_DRIVER ( eepro100_driver, eepro100_nics, PCI_NO_CLASS );
 841
 842 DRIVER ( "EEPRO100", nic_driver, pci_driver, eepro100_driver,
 843          eepro100_probe, eepro100_disable );
 844
 845 /*
 846  * Local variables:
 847  *  c-basic-offset: 8
 848  *  c-indent-level: 8
 849  *  tab-width: 8
 850  * End:
 851  */