eepro100.c, rx buffers are now dynamically allocated
[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/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 };