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