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