src/drivers/net/eepro100.c

   1 /*
   2    eepro100.c - gPXE driver for the eepro100 8255x series.
   3 */
   4
   5 #include <stdint.h>
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <io.h>
   9 #include <errno.h>
  10 #include <timer.h>
  11 #include <byteswap.h>
  12 #include <gpxe/pci.h>
  13 #include <gpxe/errfile.h>
  14 #include <gpxe/if_ether.h>
  15 #include <gpxe/ethernet.h>
  16 #include <gpxe/iobuf.h>
  17 #include <gpxe/netdevice.h>
  18 #include <gpxe/spi_bit.h>
  19 #include <gpxe/threewire.h>
  20 #include <gpxe/nvo.h>
  21
  22
  23 #define TX_RING_SIZE 4
  24 #define NUM_RX_DESC  4
  25 #define RX_BUF_SIZE 1528
  26 #define CONFIG_DATA_SIZE 22
  27
  28 struct speedo_tx {
  29         volatile s16 status;
  30         s16 command;
  31         u32 link;          /* void * */
  32         u32 tx_desc_addr;  /* (almost) Always points to the tx_buf_addr element. */
  33         s32 count;         /* # of TBD (=2), Tx start thresh., etc. */
  34         /* This constitutes two "TBD" entries: hdr and data */
  35         u32 tx_buf_addr0;  /* void *, header of frame to be transmitted.  */
  36         s32 tx_buf_size0;  /* Length of Tx hdr. */
  37         u32 tx_buf_addr1;  /* void *, data to be transmitted.  */
  38         s32 tx_buf_size1;  /* Length of Tx data. */
  39 };
  40
  41 struct speedo_rx {
  42         volatile s16 status;
  43         s16 command;
  44         u32 link;                 /* struct RxFD * */
  45         u32 rx_buf_addr;          /* void * */
  46         u16 count;
  47         u16 size;
  48         char packet[RX_BUF_SIZE];
  49 };
  50
  51 struct speedo_private {
  52         unsigned short ioaddr;
  53         unsigned short tx_cur;
  54         unsigned short tx_dirty;
  55         unsigned short rx_cur;
  56         struct speedo_tx txfd[TX_RING_SIZE];
  57         struct speedo_rx *rxfd;
  58
  59         /* netdev_tx_complete needs pointer to the iobuf of the data so as to free
  60          * it from the memory.
  61          */
  62         struct io_buffer *tx_iobuf[TX_RING_SIZE];
  63         struct spi_bit_basher spibit;
  64         struct spi_device eeprom;
  65         struct nvo_block nvo;
  66 };
  67
  68 enum speedo_offsets {
  69         SCBStatus = 0,  /* Rx/Command Unit status */
  70         SCBCmd = 2,      /* Rx/Command Unit command */
  71         SCBPointer = 4,                 /* General purpose pointer. */
  72         SCBPort = 8,                    /* Misc. commands and operands.  */
  73         SCBflash = 12,
  74         SCBeeprom = 14,  /* EEPROM and flash memory control. */
  75         SCBCtrlMDI = 16,                /* MDI interface control. */
  76         SCBEarlyRx = 20,                /* Early receive byte count. */
  77 };
  78
  79 enum SCBCmdBits {
  80         SCBMaskCmdDone=0x8000, SCBMaskRxDone=0x4000, SCBMaskCmdIdle=0x2000,
  81         SCBMaskRxSuspend=0x1000, SCBMaskEarlyRx=0x0800, SCBMaskFlowCtl=0x0400,
  82         SCBTriggerIntr=0x0200, SCBMaskAll=0x0100,
  83         /* The rest are Rx and Tx commands. */
  84         CUStart=0x0010, CUResume=0x0020, CUStatsAddr=0x0040, CUShowStats=0x0050,
  85         CUCmdBase=0x0060,       /* CU Base address (set to zero) . */
  86         CUDumpStats=0x0070, /* Dump then reset stats counters. */
  87         RxStart=0x0001, RxResume=0x0002, RxAbort=0x0004, RxAddrLoad=0x0006,
  88         RxResumeNoResources=0x0007,
  89 };
  90
  91 static const char i82558_config_cmd[CONFIG_DATA_SIZE] = {
  92         22, 0x08, 0, 1,  0, 0, 0x22, 0x03,  1, /* 1=Use MII  0=Use AUI */
  93         0, 0x2E, 0,  0x60, 0x08, 0x88,
  94         0x68, 0, 0x40, 0xf2, 0x84,              /* Disable FC */
  95         0x31, 0x05, };
  96
  97 unsigned short eeprom[16];
  98 /* Serial EEPROM section.
  99    A "bit" grungy, but we work our way through bit-by-bit :->. */
 100 /*  EEPROM_Ctrl bits. */
 101 #define EE_SHIFT_CLK    0x01    /* EEPROM shift clock. */
 102 #define EE_CS           0x02    /* EEPROM chip select. */
 103 #define EE_DATA_WRITE   0x04    /* EEPROM chip data in. */
 104 #define EE_DATA_READ    0x08    /* EEPROM chip data out. */
 105 #define EE_WRITE_0      0x4802
 106 #define EE_WRITE_1      0x4806
 107 #define EE_ENB          (0x4800 | EE_CS)
 108
 109 /* The EEPROM commands include the alway-set leading bit. */
 110 #define EE_READ_CMD     6
 111
 112
 113 /* The SCB accepts the following controls for the Tx and Rx units: */
 114 #define  CU_START       0x0010
 115 #define  CU_RESUME      0x0020
 116 #define  CU_STATSADDR   0x0040
 117 #define  CU_SHOWSTATS   0x0050  /* Dump statistics counters. */
 118 #define  CU_CMD_BASE    0x0060  /* Base address to add to add CU commands. */
 119 #define  CU_DUMPSTATS   0x0070  /* Dump then reset stats counters. */
 120
 121 #define  RX_START       0x0001
 122 #define  RX_RESUME      0x0002
 123 #define  RX_ABORT       0x0004
 124 #define  RX_ADDR_LOAD   0x0006
 125 #define  RX_RESUMENR    0x0007
 126 #define INT_MASK        0x0100
 127 #define DRVR_INT        0x0200          /* Driver generated interrupt. */
 128
 129 enum phy_chips { NonSuchPhy=0, I82553AB, I82553C, I82503, DP83840, S80C240,
 130                                          S80C24, PhyUndefined, DP83840A=10, };
 131
 132 /* Commands that can be put in a command list entry. */
 133 enum commands {
 134         CmdNOp = 0,
 135         CmdIASetup = 1,
 136         CmdConfigure = 2,
 137         CmdMulticastList = 3,
 138         CmdTx = 4,
 139         CmdTDR = 5,
 140         CmdDump = 6,
 141         CmdDiagnose = 7,
 142         /* And some extra flags: */
 143         CmdSuspend = 0x4000,      /* Suspend after completion. */
 144         CmdIntr = 0x2000,         /* Interrupt after completion. */
 145         CmdTxFlex = 0x0008,       /* Use "Flexible mode" for CmdTx command. */
 146 };
 147
 148 /* Selected elements of the Tx/RxFD.status word. */
 149 enum RxFD_bits {
 150         RxComplete=0x8000, RxOK=0x2000,
 151         RxErrCRC=0x0800, RxErrAlign=0x0400, RxErrTooBig=0x0200, RxErrSymbol=0x0010,
 152         RxEth2Type=0x0020, RxNoMatch=0x0004, RxNoIAMatch=0x0002,
 153         TxUnderrun=0x1000,  StatusComplete=0x8000,
 154 };
 155
 156 static int congenb = 0;         /* Enable congestion control in the DP83840. */
 157 static int txfifo = 8;          /* Tx FIFO threshold in 4 byte units, 0-15 */
 158 static int rxfifo = 8;          /* Rx FIFO threshold, default 32 bytes. */
 159 static int txdmacount = 0;      /* Tx DMA burst length, 0-127, default 0. */
 160 static int rxdmacount = 0;      /* Rx DMA length, 0 means no preemption. */
 161
 162 /*  Function Prototypes: */
 163 static int speedo_open ( struct net_device *netdev );
 164 static int speedo_transmit ( struct net_device *netdev, struct io_buffer *iobuf );
 165 static void speedo_poll ( struct net_device *netdev );
 166 static void speedo_disable ( struct net_device *netdev );
 167 static void speedo_close ( struct net_device *netdev );
 168 static void speedo_irq ( struct net_device *netdev, int enable );
 169
 170 /** speedo net device operations */
 171 static struct net_device_operations speedo_operations = {
 172         .open           = speedo_open,
 173         .close          = speedo_close,
 174         .transmit       = speedo_transmit,
 175         .poll           = speedo_poll,
 176         .irq            = speedo_irq,
 177 };
 178
 179 /* How to wait for the command unit to accept a command.
 180    Typically this takes 0 ticks. */
 181 static inline void wait_for_cmd_done ( int cmd_ioaddr ) {
 182         int wait = 0;
 183         int delayed_cmd;
 184
 185          do
 186                  if ( inb ( cmd_ioaddr ) == 0 )
 187                          return;
 188          while ( ++wait <= 100 );
 189          delayed_cmd = inb ( cmd_ioaddr );
 190          do
 191          if ( inb ( cmd_ioaddr ) == 0 )
 192                  break;
 193          while ( ++wait <= 10000 );
 194          DBG ( "Command %2.2x was not immediately accepted, %d ticks!\n",
 195                 delayed_cmd, wait );
 196 }
 197
 198 /* Support function: mdio_write
 199  *
 200  * This probably writes to the "physical media interface chip".
 201  * -- REW
 202  */
 203 static int mdio_write ( struct net_device *netdev, int phy_id, int location, int value ) {
 204         struct speedo_private *sp = netdev->priv;
 205         int val, boguscnt = 64*4;         /* <64 usec. to complete, typ 27 ticks */
 206
 207         outl ( 0x04000000 | (location<<16) | (phy_id<<21) | value,
 208              sp->ioaddr + SCBCtrlMDI );
 209         do {
 210                 udelay ( 16 );
 211                 val = inl ( sp->ioaddr + SCBCtrlMDI );
 212                 if ( --boguscnt < 0 ) {
 213                         DBG ( "mdio_write() timed out with val = %X.\n", val );
 214                         break;
 215                 }
 216         } while ( ! ( val & 0x10000000 ));
 217         return val & 0xffff;
 218 }
 219
 220 /* Support function: mdio_read
 221  *
 222  * This probably reads a register in the "physical media interface chip".
 223  * -- REW
 224  */
 225 static int mdio_read ( struct net_device *netdev,int phy_id, int location ) {
 226         struct speedo_private *sp = netdev->priv;
 227         int val, boguscnt = 64*4;               /* <64 usec. to complete, typ 27 ticks */
 228
 229         outl ( 0x08000000 | (location<<16) | (phy_id<<21), sp->ioaddr + SCBCtrlMDI );
 230         do {
 231                 udelay ( 16 );
 232                 val = inl ( sp->ioaddr + SCBCtrlMDI );
 233                 if ( --boguscnt < 0 ) {
 234                         DBG ( " mdio_read() timed out with val = %X.\n", val );
 235                         break;
 236                 }
 237         } while ( ! ( val & 0x10000000 ));
 238         return val & 0xffff;
 239 }
 240
 241 /* The fixes for the code were kindly provided by Dragan Stancevic
 242    <visitor@valinux.com> to strictly follow Intel specifications of EEPROM
 243    access timing.
 244    The publicly available sheet 64486302 (sec. 3.1) specifies 1us access
 245    interval for serial EEPROM.  However, it looks like that there is an
 246    additional requirement dictating larger udelay's in the code below.
 247    2000/05/24  SAW */
 248 static int do_eeprom_cmd ( struct net_device *netdev,int cmd, int cmd_len ) {
 249         struct speedo_private *sp = netdev->priv;
 250         unsigned retval = 0;
 251         long ee_addr = sp->ioaddr + SCBeeprom;
 252
 253         outw(EE_ENB, ee_addr); udelay(2);
 254         outw(EE_ENB | EE_SHIFT_CLK, ee_addr); udelay(2);
 255         /* Shift the command bits out. */
 256         do {
 257                 short dataval = ( cmd & ( 1 << cmd_len )) ? EE_WRITE_1 : EE_WRITE_0;
 258                 outw ( dataval, ee_addr );
 259                 udelay ( 2 );
 260                 outw ( dataval | EE_SHIFT_CLK, ee_addr );
 261                 udelay ( 2 );
 262                 retval = ( retval << 1 )  | (( inw ( ee_addr ) & EE_DATA_READ ) ? 1 : 0);
 263         } while ( --cmd_len >= 0 );
 264         outw ( EE_ENB, ee_addr );
 265         udelay ( 2 );
 266         /* Terminate the EEPROM access.
 267          */
 268         outw ( EE_ENB & ~EE_CS, ee_addr );
 269         return retval;
 270 }
 271
 272 static void speedo_irq ( struct net_device *netdev, int enable ) {
 273         struct speedo_private *sp = netdev->priv;
 274         uint16_t enabled_mask = ( SCBMaskCmdDone | SCBMaskCmdIdle |
 275                                   SCBMaskEarlyRx | SCBMaskFlowCtl );
 276
 277         switch ( enable ) {
 278         case 0:
 279                 outw ( SCBMaskAll, sp->ioaddr + SCBCmd );
 280                 break;
 281         case 1:
 282                 outw ( enabled_mask, sp->ioaddr + SCBCmd );
 283                 break;
 284         }
 285 }
 286
 287 /* function: eepro100_disable
 288  * resets the card. This is used to allow Etherboot or Linux
 289  * to probe the card again from a "virginal" state....
 290  * Arguments: none
 291  *
 292  * returns:   void.
 293  */
 294 static void speedo_disable ( struct net_device *netdev ) {
 295         struct speedo_private *sp = netdev->priv;
 296         /* from eepro100_reset
 297          */
 298         outl ( 0, sp->ioaddr + SCBPort );
 299         /* from eepro100_disable
 300          */
 301         /* See if this PartialReset solves the problem with interfering with
 302            kernel operation after Etherboot hands over. - Ken 20001102
 303          */
 304         outl ( 2, sp->ioaddr + SCBPort );
 305         /* The following is from the Intel e100 driver.
 306          * This hopefully solves the problem with hanging hard DOS images.
 307          */
 308         /* wait for the reset to take effect
 309          */
 310         udelay ( 20 );
 311         /* Mask off our interrupt line -- it is unmasked after reset
 312          */
 313         {
 314                 u16 intr_status;
 315                 /* Disable interrupts on our PCI board by setting the mask bit
 316                  */
 317                 outw ( INT_MASK, sp->ioaddr + SCBCmd );
 318                 intr_status = inw ( sp->ioaddr + SCBStatus );
 319                 /* ack and clear intrs
 320                  */
 321                 outw ( intr_status, sp->ioaddr + SCBStatus );
 322                 inw ( sp->ioaddr + SCBStatus );
 323         }
 324 }
 325
 326 /**
 327  * Probe PCI device
 328  *
 329  * @v pci       PCI device
 330  * @v id        PCI ID
 331  * @ret rc      Return status code
 332  */
 333 static int speedo_probe ( struct pci_device *pci,
 334                        const struct pci_device_id *id __unused ) {
 335         struct net_device *netdev;
 336         struct speedo_private *sp = NULL;
 337         int rc;
 338         int read_cmd, ee_size;
 339         int i, sum;
 340
 341         /* Allocate net device
 342          */
 343         DBG("In probe routine \n");
 344         netdev = alloc_etherdev ( sizeof ( *sp ) );
 345         if ( ! netdev )
 346                 return -ENOMEM;
 347
 348         netdev_init ( netdev, &speedo_operations );
 349         sp = netdev->priv;
 350         pci_set_drvdata ( pci, netdev );
 351         netdev->dev = &pci->dev;
 352         memset ( sp, 0, sizeof ( *sp ) );
 353         sp->ioaddr = pci->ioaddr;
 354         adjust_pci_device ( pci );
 355         /* read the MAC Address
 356          */
 357         if ( ( do_eeprom_cmd ( netdev, EE_READ_CMD << 24, 27 ) & 0xffe0000 )
 358                 == 0xffe0000 ) {
 359                 ee_size = 0x100;
 360                 read_cmd = EE_READ_CMD << 24;
 361         } else {
 362                 ee_size = 0x40;
 363                 read_cmd = EE_READ_CMD << 22;
 364         }
 365
 366         for (i = 0, sum = 0; i < ee_size; i++) {
 367                 unsigned short value = do_eeprom_cmd(netdev,read_cmd | (i << 16), 27);
 368                 if (i < (int) ( sizeof ( eeprom ) / sizeof ( eeprom[0] ) ) )
 369                         eeprom[i] = value;
 370                 sum += value;
 371         }
 372
 373         for (i = 0; i < ETH_ALEN; i++) {
 374                 netdev->ll_addr[i] =  ( eeprom[i/2] >> ( 8* ( i & 1 ) ) ) & 0xff;
 375         }
 376
 377
 378         if ( (rc = register_netdev ( netdev ) ) != 0)
 379                 goto err_register_netdev;
 380
 381         return 0;
 382
 383 err_register_netdev:
 384
 385         speedo_disable ( netdev );
 386         netdev_put ( netdev );
 387         return rc;
 388 }
 389
 390 /**
 391  * Close NIC
 392  *
 393  * @v netdev            Net device
 394  */
 395 static void speedo_close (struct net_device *netdev) {
 396         struct speedo_private *sp = netdev->priv;
 397         /* from eepro100_reset
 398          */
 399         outl ( 0, sp->ioaddr + SCBPort );
 400         return;
 401
 402 }
 403
 404 /**
 405  * Open NIC
 406  *
 407  * @v netdev            Net device
 408  * @ret rc              Return status code
 409  */
 410 static int speedo_open ( struct net_device *netdev ) {
 411         struct speedo_private *sp = netdev->priv;
 412         int i;
 413         int options = 0x00;
 414         int rx_mode = 0;
 415
 416         /* Setup RX ring
 417          */
 418         outl ( 0, sp->ioaddr + SCBPointer );
 419         outw ( INT_MASK | RX_ADDR_LOAD, sp->ioaddr + SCBCmd );
 420         wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 421
 422         sp->rxfd=malloc((sizeof(struct speedo_rx))*NUM_RX_DESC);
 423         if (!sp->rxfd) {
 424                 DBG("No memory for RxFD\n");
 425                 return -ENOMEM;
 426         }
 427
 428         sp->rx_cur = 0;
 429         for ( i = 0 ; i < NUM_RX_DESC ; i++ ) {
 430                 sp->rxfd[i].status      = 0x0000;
 431                 sp->rxfd[i].command     = 0x0000;
 432                 sp->rxfd[i].rx_buf_addr = 0xFFFFFFFF;
 433                 sp->rxfd[i].count       = 0;
 434                 sp->rxfd[i].size        = RX_BUF_SIZE;
 435                 sp->rxfd[i].link        = virt_to_bus ( &sp->rxfd[i+1] );
 436         }
 437
 438         sp->rxfd[NUM_RX_DESC -1].status  = 0x0000;
 439         sp->rxfd[NUM_RX_DESC -1].command = 0xC000;
 440         sp->rxfd[NUM_RX_DESC -1].link    = virt_to_bus( &sp->rxfd[0] );
 441
 442         outl ( virt_to_bus ( &sp->rxfd[0] ), sp->ioaddr + SCBPointer );
 443         outb ( RX_START, sp->ioaddr + SCBCmd );
 444         wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 445
 446         /* Setup Tx Ring
 447          */
 448         /* Base = 0 */
 449         outl ( 0, sp->ioaddr + SCBPointer );
 450         outb ( CU_CMD_BASE, sp->ioaddr + SCBCmd );
 451         wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 452         sp->tx_cur = 0;
 453         sp->tx_dirty = 0;
 454         for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
 455                 sp->txfd[i].link   = virt_to_bus ( ( i + 1 < TX_RING_SIZE ) ? &
 456                                                    sp->txfd[i + 1] : &sp->txfd[0] );
 457                 sp->txfd[i].command = ( CmdSuspend );
 458                 sp->txfd[i].status = 0;
 459                 sp->txfd[i].tx_desc_addr = virt_to_bus ( &sp->txfd[i].tx_buf_addr0 );
 460         }
 461
 462         /* Setting up the RX mode */
 463         /* Set or clear the multicast filter for this adaptor.
 464            This is very ugly with Intel chips -- we usually have to execute an
 465            entire configuration command, plus process a multicast command.
 466            This is complicated.  We must put a large configuration command and
 467            an arbitrarily-sized multicast command in the transmit list.
 468            To minimize the disruption -- the previous command might have already
 469            loaded the link -- we convert the current command block, normally a Tx
 470            command, into a no-op and link it to the new command.
 471         */
 472
 473         if ( ( ( eeprom[6] >> 8 ) & 0x3f ) == DP83840
 474                || ( ( eeprom[6] >> 8 ) & 0x3f ) == DP83840A) {
 475                 int mdi_reg23 = mdio_read ( netdev,eeprom[6] & 0x1f, 23 ) | 0x0422;
 476                 if ( congenb )
 477                         mdi_reg23 |= 0x0100;
 478                 DBG ( "DP83840 specific setup, setting register 23 to %hX.\n",
 479                        mdi_reg23);
 480                 mdio_write ( netdev,eeprom[6] & 0x1f, 23, mdi_reg23 );
 481         }
 482         DBG ( "Done DP8340 special setup.\n" );
 483         if ( options != 0 )  {
 484                 mdio_write ( netdev,eeprom[6] & 0x1f, 0,
 485                            ( ( options & 0x20 ) ? 0x2000 : 0) |    /* 100mbps? */
 486                            ( ( options & 0x10 ) ? 0x0100 : 0)); /* Full duplex? */
 487                 DBG ( "set mdio_register.\n" );
 488         }
 489
 490         sp->tx_cur++;
 491         sp->tx_dirty++;
 492         sp->txfd[0].status = ( CmdSuspend | CmdConfigure );
 493         uint8_t * config_cmd_data;
 494         config_cmd_data = (void *)&sp->txfd[0].tx_desc_addr;
 495         /* Construct a full CmdConfig frame.
 496          */
 497         memcpy ( config_cmd_data, i82558_config_cmd, CONFIG_DATA_SIZE );
 498         config_cmd_data[1]  = ( txfifo << 4 ) | rxfifo;
 499         config_cmd_data[4]  = rxdmacount;
 500         config_cmd_data[5]  = txdmacount + 0x80;
 501         config_cmd_data[15] = ( rx_mode & 2 ) ? 0x49: 0x48;
 502         config_cmd_data[19] = ( options & 0x10 ) ? 0xC0 : 0x80;
 503         config_cmd_data[21] = ( rx_mode & 1 ) ? 0x0D: 0x05;
 504
 505         outl ( virt_to_bus ( &sp->txfd[0] ), sp->ioaddr + SCBPointer );
 506         outb ( CU_START, sp->ioaddr + SCBCmd );
 507         wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 508
 509         /* Read the status register once to disgard stale data
 510          */
 511         mdio_read ( netdev,eeprom[6] & 0x1f, 1 );
 512         /* Check to see if the network cable is plugged in.
 513          * This allows for faster failure if there is nothing
 514          * we can do.
 515          */
 516         if (!( mdio_read ( netdev,eeprom[6] & 0x1f, 1 ) & ( 1 << 2 ))) {
 517                 DBG ( "Valid link not established\n" );
 518                 speedo_disable ( netdev );
 519                 return -1;
 520         }
 521         return 0;
 522 }
 523
 524 /**
 525  * Transmit packet
 526  *
 527  * @v netdev    Network device
 528  * @v iobuf     I/O buffer
 529  * @ret rc      Return status code
 530  */
 531 static int speedo_transmit ( struct net_device *netdev, struct io_buffer *iobuf ) {
 532         struct speedo_private *sp = netdev->priv;
 533
 534         if ( ( sp->tx_cur + 1 ) % TX_RING_SIZE == sp->tx_dirty ) {
 535                 DBG ( "TX overflow\n" );
 536                 return -ENOBUFS;
 537         }
 538         /* Used by netdev_tx_complete ()
 539          */
 540         sp->tx_iobuf[sp->tx_cur] = iobuf;
 541         /* Pad and align packet has not been used because its not required
 542          * by the hardware.
 543          *      iob_pad (iobuf, ETH_ZLEN);
 544          * can be used to achieve it, if required
 545          */
 546         /* Add the packet to TX ring
 547          */
 548
 549         sp->txfd[sp->tx_cur].status =  0;
 550         sp->txfd[sp->tx_cur].command = CmdSuspend | CmdTx | CmdTxFlex;
 551         sp->txfd[sp->tx_cur].count =  0x02208000;
 552         sp->txfd[sp->tx_cur].tx_buf_addr0 = virt_to_bus ( iobuf->data );
 553         sp->txfd[sp->tx_cur].tx_buf_size0 = iob_len ( iobuf );
 554
 555         DBG ("TX id %d at %#08lx + %#08x\n", sp->tx_cur,
 556              virt_to_bus ( &iobuf->data ), iob_len ( iobuf ) );
 557
 558         /* start the transmitter
 559          *
 560          * Removing suspend from the command of previous packet.
 561          * As linx driver does
 562          */
 563         sp->txfd[(( sp->tx_cur - 1 ) < 0 ? TX_RING_SIZE -1 : sp->tx_cur - 1 )].command
 564                                                                 &= ~CmdSuspend;
 565         /* We want the time window between clearing suspend flag on the previous
 566            command and resuming CU to be as small as possible.
 567            Interrupts in between are very undesired.  --SAW */
 568         outb ( CUResume, sp->ioaddr + SCBCmd );
 569
 570         /* increment the circular buffer pointer to the next buffer location
 571          */
 572         sp->tx_cur = ( sp->tx_cur + 1 ) % TX_RING_SIZE;
 573
 574         return 0;
 575 }
 576
 577 /*
 578  * Sometimes the receiver stops making progress.  This routine knows how to
 579  * get it going again, without losing packets or being otherwise nasty like
 580  * a chip reset would be.  Previously the driver had a whole sequence
 581  * of if RxSuspended, if it's no buffers do one thing, if it's no resources,
 582  * do another, etc.  But those things don't really matter.  Separate logic
 583  * in the ISR provides for allocating buffers--the other half of operation
 584  * is just making sure the receiver is active.  speedo_rx_soft_reset does that.
 585  * This problem with the old, more involved algorithm is shown up under
 586  * ping floods on the order of 60K packets/second on a 100Mbps fdx network.
 587  */
 588 static void speedo_rx_soft_reset ( struct net_device *netdev ) {
 589         struct speedo_private *sp = netdev->priv;
 590         int i;
 591
 592         DBG("reset\n");
 593         wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 594         /*
 595          * Put the hardware into a known state.
 596          */
 597         outb ( RX_ABORT, sp->ioaddr + SCBCmd );
 598
 599         for ( i = 0; i < NUM_RX_DESC; i++ ) {
 600                 sp->rxfd[i].status      = 0;
 601                 sp->rxfd[i].rx_buf_addr = 0xffffffff;
 602                 sp->rxfd[i].count       = 0;
 603                 sp->rxfd[i].size        = RX_BUF_SIZE;
 604         }
 605
 606         wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 607
 608         outl ( virt_to_bus ( &sp->rxfd[sp->rx_cur] ), sp->ioaddr + SCBPointer );
 609         outb ( RX_START, sp->ioaddr + SCBCmd );
 610 }
 611
 612 /**
 613  * Poll for received packets
 614  *
 615  * @v netdev    Network device
 616  */
 617 static void speedo_poll (struct net_device *netdev) {
 618         struct speedo_private *sp = netdev->priv;
 619         uint16_t tx_status;
 620         unsigned int rx_status;
 621         unsigned int intr_status;
 622         unsigned int rx_len;
 623         struct io_buffer *rx_iob;
 624         int i;
 625
 626         intr_status = inw ( sp->ioaddr + SCBStatus );
 627         /* Acknowledge all of the current interrupt sources ASAP. */
 628         outw ( intr_status & 0xfc00, sp->ioaddr + SCBStatus );
 629         if ( !intr_status )
 630                 return;
 631
 632         /* Check status of transmitted packets
 633          */
 634         i = sp->tx_dirty;
 635         while (i != sp->tx_cur ) {
 636                 tx_status = sp->txfd[sp->tx_dirty].status;
 637                 DBG ( "tx_dirty = %d tx_cur=%d tx_status=%#08x\n",
 638                      sp->tx_dirty, sp->tx_cur, tx_status );
 639                 if (( tx_status & StatusComplete ) == 0)
 640                         break;
 641                 netdev_tx_complete ( netdev, sp->tx_iobuf[sp->tx_dirty] );
 642                 DBG ( "Success transmitting packet\n" );
 643
 644                 sp->tx_dirty = ( sp->tx_dirty + 1) % TX_RING_SIZE;
 645                 i = ( i + 1 ) % TX_RING_SIZE;
 646         }
 647         /* Process received packets
 648          */
 649         rx_status = sp->rxfd[sp->rx_cur].status;
 650         while ( rx_status ) {
 651                 rx_len = sp->rxfd[sp->rx_cur].count & 0x3fff;
 652
 653                 DBG ( "Received packet, rx_curr = %d, rx_status = %#08x, rx_len = %d\n",
 654                      sp->rx_cur, rx_status, rx_len );
 655                 /* If unable allocate space for this packet,
 656                  *  try again next poll
 657                  */
 658                 rx_iob = alloc_iob ( rx_len );
 659                 if ( ! rx_iob )
 660                         break;
 661                 memcpy ( iob_put (rx_iob, rx_len ),
 662                         sp->rxfd[sp->rx_cur].packet, rx_len );
 663                 /* Add this packet to the receive queue.
 664                  */
 665                 netdev_rx ( netdev, rx_iob );
 666
 667                 sp->rxfd[sp->rx_cur].status = 0;
 668                 sp->rxfd[sp->rx_cur].command = 0xc000;
 669                 sp->rxfd[sp->rx_cur].rx_buf_addr = 0xFFFFFFFF;
 670                 sp->rxfd[sp->rx_cur].count = 0;
 671                 sp->rxfd[sp->rx_cur].size = RX_BUF_SIZE;
 672                 sp->rxfd[( sp->rx_cur - 1 )% NUM_RX_DESC].command = 0;
 673                 sp->rx_cur = ( sp->rx_cur + 1 ) % NUM_RX_DESC;
 674                 rx_status = sp->rxfd[sp->rx_cur].status;
 675                 /* Acknowledge all interrupts */
 676                 outw ( 0xff00,sp->ioaddr + SCBStatus );
 677         }
 678         /*
 679          * The chip may have suspended reception for various reasons.
 680          * Check for that, and re-prime it should this be the case.
 681          */
 682         switch (( inw ( sp->ioaddr + SCBStatus ) >> 2) & 0xf) {
 683                 case 0:  /* Idle */
 684                         break;
 685                 case 1:  /* Suspended */
 686                 case 2:  /* No resources (RxFDs) */
 687                 case 9:  /* Suspended with no more RBDs */
 688                 case 10: /* No resources due to no RBDs */
 689                 case 12: /* Ready with no RBDs */
 690                         speedo_rx_soft_reset ( netdev );
 691                         break;
 692                 default:
 693                         /* reserved values */
 694                         break;
 695         }
 696 }
 697
 698 /**
 699  * Remove PCI device
 700  *
 701  * @v pci       PCI device
 702  */
 703 static void speedo_remove (struct pci_device *pci) {
 704         struct net_device *netdev = pci_get_drvdata (pci);
 705
 706         unregister_netdev ( netdev );
 707         speedo_disable ( netdev );
 708         netdev_put ( netdev );
 709 }
 710
 711
 712 static struct pci_device_id speedo_nics[] = {
 713         PCI_ROM(0x8086, 0x1029, "id1029",        "Intel EtherExpressPro100 ID1029"),
 714         PCI_ROM(0x8086, 0x1030, "id1030",        "Intel EtherExpressPro100 ID1030"),
 715         PCI_ROM(0x8086, 0x1031, "82801cam",      "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 716         PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection"),
 717         PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection"),
 718         PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection"),
 719         PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 720         PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 721         PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
 722         PCI_ROM(0x8086, 0x1038, "id1038",        "Intel PRO/100 VM Network Connection"),
 723         PCI_ROM(0x8086, 0x1039, "82562et",       "Intel PRO100 VE 82562ET"),
 724         PCI_ROM(0x8086, 0x103a, "id103a",        "Intel Corporation 82559 InBusiness 10/100"),
 725         PCI_ROM(0x8086, 0x103b, "82562etb",      "Intel PRO100 VE 82562ETB"),
 726         PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection"),
 727         PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection"),
 728         PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection"),
 729         PCI_ROM(0x8086, 0x1051, "prove",       "Intel PRO/100 VE Network Connection"),
 730         PCI_ROM(0x8086, 0x1059, "82551qm",       "Intel PRO/100 M Mobile Connection"),
 731         PCI_ROM(0x8086, 0x1209, "82559er",       "Intel EtherExpressPro100 82559ER"),
 732         PCI_ROM(0x8086, 0x1227, "82865",         "Intel 82865 EtherExpress PRO/100A"),
 733         PCI_ROM(0x8086, 0x1228, "82556",         "Intel 82556 EtherExpress PRO/100 Smart"),
 734         PCI_ROM(0x8086, 0x1229, "eepro100",      "Intel EtherExpressPro100"),
 735         PCI_ROM(0x8086, 0x2449, "82562em",       "Intel EtherExpressPro100 82562EM"),
 736         PCI_ROM(0x8086, 0x2459, "82562-1",       "Intel 82562 based Fast Ethernet Connection"),
 737         PCI_ROM(0x8086, 0x245d, "82562-2",       "Intel 82562 based Fast Ethernet Connection"),
 738         PCI_ROM(0x8086, 0x1050, "82562ez",       "Intel 82562EZ Network Connection"),
 739         PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller"),
 740         PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server"),
 741         PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server"),
 742 };
 743
 744 struct pci_driver epro100_driver __pci_driver = {
 745         .ids = speedo_nics,
 746         .id_count = ( sizeof ( speedo_nics ) / sizeof ( speedo_nics[0] )),
 747         .probe = speedo_probe,
 748         .remove = speedo_remove,
 749 };