iPXE - Open Source Boot Firmware

[build] Rename gPXE to iPXE
[ipxe.git] / src / drivers / net / eepro100.c
1 /*
2  * eepro100.c -- This is a driver for Intel Fast Ethernet Controllers
3  * (ifec).
4  *
5  * Originally written for Etherboot by:
6  *
7  *   Copyright (C) AW Computer Systems.
8  *   written by R.E.Wolff -- R.E.Wolff@BitWizard.nl
9  *
10  *   AW Computer Systems is contributing to the free software community
11  *   by paying for this driver and then putting the result under GPL.
12  *
13  *   If you need a Linux device driver, please contact BitWizard for a
14  *   quote.
15  *
16  * This program is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU General Public License as
18  * published by the Free Software Foundation; either version 2, or (at
19  * your option) any later version.
20  *
21  * This program is distributed in the hope that it will be useful, but
22  * WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29  *
30  *
31  *              date       version  by      what
32  *  Written:    May 29 1997  V0.10  REW     Initial revision.
33  * changes:     May 31 1997  V0.90  REW     Works!
34  *              Jun 1  1997  V0.91  REW     Cleanup
35  *              Jun 2  1997  V0.92  REW     Add some code documentation
36  *              Jul 25 1997  V1.00  REW     Tested by AW to work in a PROM
37  *                                          Cleanup for publication
38  *              Dez 11 2004  V1.10  Kiszka  Add RX ring buffer support
39  *              Jun    2008  v2.0   mdeck   Updated to iPXE. Changed much.
40  *
41  * Cleanups and fixes by Thomas Miletich<thomas.miletich@gmail.com>
42  *
43  * This is the etherboot intel etherexpress Pro/100B driver.
44  *
45  * It was written from scratch, with Donald Beckers eepro100.c kernel
46  * driver as a guideline. Mostly the 82557 related definitions and the
47  * lower level routines have been cut-and-pasted into this source.
48  *
49  * The driver was finished before Intel got the NDA out of the closet.
50  *
51  * Datasheet is now published and available from 
52  * ftp://download.intel.com/design/network/manuals/8255X_OpenSDM.pdf
53  *    - Michael Brown
54  * */
55
56 FILE_LICENCE ( GPL2_OR_LATER );
57
58 /*
59  * General Theory of Operation
60  *
61  * Initialization
62  *
63  * ifec_pci_probe() is called by iPXE during initialization. Typical NIC
64  * initialization is performed.  EEPROM data is read.
65  *
66  * Network Boot
67  *
68  * ifec_net_open() is called by iPXE before attempting to network boot from the
69  * card.  Here, the Command Unit & Receive Unit are initialized.  The tx & rx
70  * rings are setup.  The MAC address is programmed and the card is configured.
71  *
72  * Transmit
73  *
74  * ifec_net_transmit() enqueues a packet in the tx ring - active::tcbs[]  The tx
75  * ring is composed of TCBs linked to each other into a ring.  A tx request
76  * fills out the next available TCB with a pointer to the packet data.
77  * The last enqueued tx is always at active::tcb_head.  Thus, a tx request fills
78  * out the TCB following tcb_head.
79  * active::tcb_tail points to the TCB we're awaiting completion of.
80  * ifec_tx_process() checks tcb_tail, and once complete,
81  * blindly increments tcb_tail to the next ring TCB.
82  *
83  * Receive
84  *
85  * priv::rfds[] is an array of Receive Frame Descriptors. The RFDs are linked
86  * together to form a ring.
87  * ifec_net_poll() calls ifec_rx_process(), which checks the next RFD for
88  * data.  If we received a packet, we allocate a new io_buffer and copy the
89  * packet data into it. If alloc_iob() fails, we don't touch the RFD and try
90  * again on the next poll.
91  */
92
93 /*
94  * Debugging levels:
95  *      - DBG() is for any errors, i.e. failed alloc_iob(), malloc_dma(),
96  *        TX overflow, corrupted packets, ...
97  *      - DBG2() is for successful events, like packet received,
98  *        packet transmitted, and other general notifications.
99  *      - DBGP() prints the name of each called function on entry
100  */
101
102 #include <stdint.h>
103 #include <byteswap.h>
104 #include <errno.h>
105 #include <stdio.h>
106 #include <unistd.h>
107 #include <ipxe/ethernet.h>
108 #include <ipxe/if_ether.h>
109 #include <ipxe/iobuf.h>
110 #include <ipxe/malloc.h>
111 #include <ipxe/pci.h>
112 #include <ipxe/spi_bit.h>
113 #include <ipxe/timer.h>
114 #include <ipxe/nvs.h>
115 #include <ipxe/threewire.h>
116 #include <ipxe/netdevice.h>
117 #include "eepro100.h"
118
119 /****************************** Global data **********************************/
120
121 /*
122  * This is the default configuration command data. The values were copied from
123  * the Linux kernel initialization for the eepro100.
124  */
125 static struct ifec_cfg ifec_cfg = {
126         .status  = 0,
127         .command = CmdConfigure | CmdSuspend,
128         .link    = 0,        /* Filled in later */
129         .byte = { 22,        /* How many bytes in this array */
130                   ( TX_FIFO << 4 ) | RX_FIFO,  /* Rx & Tx FIFO limits */
131                   0, 0,                        /* Adaptive Interframe Spacing */
132                   RX_DMA_COUNT,                /* Rx DMA max byte count */
133                   TX_DMA_COUNT + 0x80,         /* Tx DMA max byte count */
134                   0x32,      /* Many bits. */
135                   0x03,      /* Discard short receive & Underrun retries */
136                   1,         /* 1=Use MII  0=Use AUI */
137                   0,
138                   0x2E,      /* NSAI, Preamble length, & Loopback*/
139                   0,         /* Linear priority */
140                   0x60,      /* L PRI MODE & Interframe spacing */
141                   0, 0xf2,
142                   0x48,      /* Promiscuous, Broadcast disable, CRS & CDT */
143                   0, 0x40,
144                   0xf2,      /* Stripping, Padding, Receive CRC Transfer */
145                   0x80,      /* 0x40=Force full-duplex, 0x80=Allowfull-duplex*/
146                   0x3f,      /* Multiple IA */
147                   0x0D }     /* Multicast all */
148 };
149
150 static struct net_device_operations ifec_operations = {
151         .open     = ifec_net_open,
152         .close    = ifec_net_close,
153         .transmit = ifec_net_transmit,
154         .poll     = ifec_net_poll,
155         .irq      = ifec_net_irq
156 };
157
158 /******************* iPXE PCI Device Driver API functions ********************/
159
160 /*
161  * Initialize the PCI device.
162  *
163  * @v pci               The device's associated pci_device structure.
164  * @v id                The PCI device + vendor id.
165  * @ret rc              Returns zero if successfully initialized.
166  *
167  * This function is called very early on, while iPXE is initializing.
168  * This is a iPXE PCI Device Driver API function.
169  */
170 static int ifec_pci_probe ( struct pci_device *pci,
171                             const struct pci_device_id *id __unused )
172 {
173         struct net_device *netdev;
174         struct ifec_private *priv;
175         int rc;
176
177         DBGP ( "ifec_pci_probe: " );
178
179         if ( pci->ioaddr == 0 )
180                 return -EINVAL;
181
182         netdev = alloc_etherdev ( sizeof(*priv) );
183         if ( !netdev )
184                 return -ENOMEM;
185
186         netdev_init ( netdev, &ifec_operations );
187         priv = netdev->priv;
188
189         pci_set_drvdata ( pci, netdev );
190         netdev->dev = &pci->dev;
191
192         /* enable bus master, etc */
193         adjust_pci_device( pci );
194
195         DBGP ( "pci " );
196
197         memset ( priv, 0, sizeof(*priv) );
198         priv->ioaddr = pci->ioaddr;
199
200         ifec_reset ( netdev );
201         DBGP ( "reset " );
202
203         ifec_init_eeprom ( netdev );
204
205         /* read MAC address */
206         nvs_read ( &priv->eeprom.nvs, EEPROM_ADDR_MAC_0, netdev->hw_addr,
207                    ETH_ALEN );
208         /* read mdio_register */
209         nvs_read ( &priv->eeprom.nvs, EEPROM_ADDR_MDIO_REGISTER,
210                    &priv->mdio_register, 2 );
211
212         netdev_link_up ( netdev );
213
214         if ( ( rc = register_netdev ( netdev ) ) != 0 )
215                 goto error;
216
217         DBGP ( "ints\n" );
218
219         return 0;
220
221 error:
222         ifec_reset     ( netdev );
223         netdev_nullify ( netdev );
224         netdev_put     ( netdev );
225
226         return rc;
227 }
228
229 /*
230  * Remove a device from the PCI device list.
231  *
232  * @v pci               PCI device to remove.
233  *
234  * This is a PCI Device Driver API function.
235  */
236 static void ifec_pci_remove ( struct pci_device *pci )
237 {
238         struct net_device *netdev = pci_get_drvdata ( pci );
239
240         DBGP ( "ifec_pci_remove\n" );
241
242         unregister_netdev ( netdev );
243         ifec_reset        ( netdev );
244         netdev_nullify    ( netdev );
245         netdev_put        ( netdev );
246 }
247
248 /****************** iPXE Network Device Driver API functions *****************/
249
250 /*
251  * Close a network device.
252  *
253  * @v netdev            Device to close.
254  *
255  * This is a iPXE Network Device Driver API function.
256  */
257 static void ifec_net_close ( struct net_device *netdev )
258 {
259         struct ifec_private *priv = netdev->priv;
260         unsigned long ioaddr = priv->ioaddr;
261         unsigned short intr_status;
262
263         DBGP ( "ifec_net_close\n" );
264
265         /* disable interrupts */
266         ifec_net_irq ( netdev, 0 );
267
268         /* Ack & clear ints */
269         intr_status = inw ( ioaddr + SCBStatus );
270         outw ( intr_status, ioaddr + SCBStatus );
271         inw ( ioaddr + SCBStatus );
272
273         ifec_reset ( netdev );
274
275         /* Free any resources */
276         ifec_free ( netdev );
277 }
278
279 /* Interrupts to be masked */
280 #define INTERRUPT_MASK  ( SCBMaskEarlyRx | SCBMaskFlowCtl )
281
282 /*
283  * Enable or disable IRQ masking.
284  *
285  * @v netdev            Device to control.
286  * @v enable            Zero to mask off IRQ, non-zero to enable IRQ.
287  *
288  * This is a iPXE Network Driver API function.
289  */
290 static void ifec_net_irq ( struct net_device *netdev, int enable )
291 {
292         struct ifec_private *priv = netdev->priv;
293         unsigned long ioaddr = priv->ioaddr;
294
295         DBGP ( "ifec_net_irq\n" );
296
297         outw ( enable ? INTERRUPT_MASK : SCBMaskAll, ioaddr + SCBCmd );
298 }
299
300 /*
301  * Opens a network device.
302  *
303  * @v netdev            Device to be opened.
304  * @ret rc              Non-zero if failed to open.
305  *
306  * This enables tx and rx on the device.
307  * This is a iPXE Network Device Driver API function.
308  */
309 static int ifec_net_open ( struct net_device *netdev )
310 {
311         struct ifec_private *priv = netdev->priv;
312         struct ifec_ias *ias = NULL;
313         struct ifec_cfg *cfg = NULL;
314         int i, options;
315         int rc = -ENOMEM;
316
317         DBGP ( "ifec_net_open: " );
318
319         /* Ensure interrupts are disabled. */
320         ifec_net_irq ( netdev, 0 );
321
322         /* Initialize Command Unit and Receive Unit base addresses. */
323         ifec_scb_cmd ( netdev, 0, RUAddrLoad );
324         ifec_scb_cmd ( netdev, virt_to_bus ( &priv->stats ), CUStatsAddr );
325         ifec_scb_cmd ( netdev, 0, CUCmdBase );
326
327         /* Initialize both rings */
328         if ( ( rc = ifec_rx_setup ( netdev ) ) != 0 )
329                 goto error;
330         if ( ( rc = ifec_tx_setup ( netdev ) ) != 0 )
331                 goto error;
332
333         /* Initialize MDIO */
334         options = 0x00; /* 0x40 = 10mbps half duplex, 0x00 = Autosense */
335         ifec_mdio_setup ( netdev, options );
336
337         /* Prepare MAC address w/ Individual Address Setup (ias) command.*/
338         ias = malloc_dma ( sizeof ( *ias ), CB_ALIGN );
339         if ( !ias ) {
340                 rc = -ENOMEM;
341                 goto error;
342         }
343         ias->command      = CmdIASetup;
344         ias->status       = 0;
345         memcpy ( ias->ia, netdev->ll_addr, ETH_ALEN );
346
347         /* Prepare operating parameters w/ a configure command. */
348         cfg = malloc_dma ( sizeof ( *cfg ), CB_ALIGN );
349         if ( !cfg ) {
350                 rc = -ENOMEM;
351                 goto error;
352         }
353         memcpy ( cfg, &ifec_cfg, sizeof ( *cfg ) );
354         cfg->link     = virt_to_bus ( priv->tcbs );
355         cfg->byte[19] = ( options & 0x10 ) ? 0xC0 : 0x80;
356         ias->link     = virt_to_bus ( cfg );
357
358         /* Issue the ias and configure commands. */
359         ifec_scb_cmd ( netdev, virt_to_bus ( ias ), CUStart );
360         ifec_scb_cmd_wait ( netdev );
361         priv->configured = 1;
362
363         /* Wait up to 10 ms for configuration to initiate */
364         for ( i = 10; i && !cfg->status; i-- )
365                 mdelay ( 1 );
366         if ( ! cfg->status ) {
367                 DBG ( "Failed to initiate!\n" );
368                 goto error;
369         }
370         free_dma ( ias, sizeof ( *ias ) );
371         free_dma ( cfg, sizeof ( *cfg ) );
372         DBG2 ( "cfg " );
373
374         /* Enable rx by sending ring address to card */
375         if ( priv->rfds[0] != NULL ) {
376                 ifec_scb_cmd ( netdev, virt_to_bus( priv->rfds[0] ), RUStart );
377                 ifec_scb_cmd_wait ( netdev );
378         }
379         DBG2 ( "rx_start\n" );
380
381         return 0;
382
383 error:
384         free_dma ( cfg, sizeof ( *cfg ) );
385         free_dma ( ias, sizeof ( *ias ) );
386         ifec_free ( netdev );
387         ifec_reset ( netdev );
388         return rc;
389 }
390
391 /*
392  * This function allows a driver to process events during operation.
393  *
394  * @v netdev            Device being polled.
395  *
396  * This is called periodically by iPXE to let the driver check the status of
397  * transmitted packets and to allow the driver to check for received packets.
398  * This is a iPXE Network Device Driver API function.
399  */
400 static void ifec_net_poll ( struct net_device *netdev )
401 {
402         struct ifec_private *priv = netdev->priv;
403         unsigned short intr_status;
404
405         DBGP ( "ifec_net_poll\n" );
406
407         /* acknowledge interrupts ASAP */
408         intr_status = inw ( priv->ioaddr + SCBStatus );
409         outw ( intr_status, priv->ioaddr + SCBStatus );
410         inw ( priv->ioaddr + SCBStatus );
411
412         DBG2 ( "poll - status: 0x%04X\n", intr_status );
413
414         /* anything to do here? */
415         if ( ( intr_status & ( ~INTERRUPT_MASK ) ) == 0 )
416                 return;
417
418         /* process received and transmitted packets */
419         ifec_tx_process ( netdev );
420         ifec_rx_process ( netdev );
421
422         ifec_check_ru_status ( netdev, intr_status );
423
424         return;
425 }
426
427 /*
428  * This transmits a packet.
429  *
430  * @v netdev            Device to transmit from.
431  * @v iobuf             Data to transmit.
432  * @ret rc              Non-zero if failed to transmit.
433  *
434  * This is a iPXE Network Driver API function.
435  */
436 static int ifec_net_transmit ( struct net_device *netdev,
437                                struct io_buffer *iobuf )
438 {
439         struct ifec_private *priv = netdev->priv;
440         struct ifec_tcb *tcb = priv->tcb_head->next;
441         unsigned long ioaddr = priv->ioaddr;
442
443         DBGP ( "ifec_net_transmit\n" );
444
445         /* Wait for TCB to become available. */
446         if ( tcb->status || tcb->iob ) {
447                 DBG ( "TX overflow\n" );
448                 return -ENOBUFS;
449         }
450
451         DBG2 ( "transmitting packet (%d bytes). status = %hX, cmd=%hX\n",
452                 iob_len ( iobuf ), tcb->status, inw ( ioaddr + SCBCmd ) );
453
454         tcb->command   = CmdSuspend | CmdTx | CmdTxFlex;
455         tcb->count     = 0x01208000;
456         tcb->tbd_addr0 = virt_to_bus ( iobuf->data );
457         tcb->tbd_size0 = 0x3FFF & iob_len ( iobuf );
458         tcb->iob = iobuf;
459
460         ifec_tx_wake ( netdev );
461
462         /* Append to end of ring. */
463         priv->tcb_head = tcb;
464
465         return 0;
466 }
467
468 /*************************** Local support functions *************************/
469
470 /* Define what each GPIO Pin does */
471 static const uint16_t ifec_ee_bits[] = {
472         [SPI_BIT_SCLK]  = EE_SHIFT_CLK,
473         [SPI_BIT_MOSI]  = EE_DATA_WRITE,
474         [SPI_BIT_MISO]  = EE_DATA_READ,
475         [SPI_BIT_SS(0)] = EE_ENB,
476 };
477
478 /*
479  * Read a single bit from the GPIO pins used for SPI.
480  * should be called by SPI bitbash functions only
481  *
482  * @v basher            Bitbash device
483  * @v bit_id            Line to be read
484  */
485 static int ifec_spi_read_bit ( struct bit_basher *basher,
486                                unsigned int bit_id )
487 {
488         struct ifec_private *priv =
489                 container_of ( basher, struct ifec_private, spi.basher );
490         unsigned long ee_addr = priv->ioaddr + CSREeprom;
491         unsigned int ret = 0;
492         uint16_t mask;
493
494         DBGP ( "ifec_spi_read_bit\n" );
495
496         mask = ifec_ee_bits[bit_id];
497         ret = inw (ee_addr);
498
499         return ( ret & mask ) ? 1 : 0;
500 }
501
502 /*
503  * Write a single bit to the GPIO pins used for SPI.
504  * should be called by SPI bitbash functions only
505  *
506  * @v basher            Bitbash device
507  * @v bit_id            Line to write to
508  * @v data              Value to write
509  */
510 static void ifec_spi_write_bit ( struct bit_basher *basher,
511                                  unsigned int bit_id,
512                                  unsigned long data )
513 {
514         struct ifec_private *priv =
515                 container_of ( basher, struct ifec_private, spi.basher );
516         unsigned long ee_addr = priv->ioaddr + CSREeprom;
517         short val;
518         uint16_t mask = ifec_ee_bits[bit_id];
519
520         DBGP ( "ifec_spi_write_bit\n" );
521
522         val = inw ( ee_addr );
523         val &= ~mask;
524         val |= data & mask;
525
526         outw ( val, ee_addr );
527 }
528
529 /* set function pointer to SPI read- and write-bit functions */
530 static struct bit_basher_operations ifec_basher_ops = {
531         .read = ifec_spi_read_bit,
532         .write = ifec_spi_write_bit,
533 };
534
535 /*
536  * Initialize the eeprom stuff
537  *
538  * @v netdev            Network device
539  */
540 static void ifec_init_eeprom ( struct net_device *netdev )
541 {
542         struct ifec_private *priv = netdev->priv;
543
544         DBGP ( "ifec_init_eeprom\n" );
545
546         priv->spi.basher.op = &ifec_basher_ops;
547         priv->spi.bus.mode = SPI_MODE_THREEWIRE;
548         init_spi_bit_basher ( &priv->spi );
549
550         priv->eeprom.bus = &priv->spi.bus;
551
552         /* init as 93c46(93c14 compatible) first, to set the command len,
553          * block size and word len. Needs to be set for address len detection.
554          */
555         init_at93c46 ( &priv->eeprom, 16 );
556
557         /* detect address length, */
558         threewire_detect_address_len ( &priv->eeprom );
559
560         /* address len == 8 means 93c66 instead of 93c46 */
561         if ( priv->eeprom.address_len == 8 )
562                 init_at93c66 ( &priv->eeprom, 16 );
563 }
564
565 /*
566  * Support function: ifec_mdio_read
567  *
568  * This probably reads a register in the "physical media interface chip".
569  * -- REW
570  */
571 static int ifec_mdio_read ( struct net_device *netdev, int phy_id,
572                                                        int location )
573 {
574         struct ifec_private *priv = netdev->priv;
575         unsigned long ioaddr = priv->ioaddr;
576         int val;
577         int boguscnt = 64*4;     /* <64 usec. to complete, typ 27 ticks */
578
579         DBGP ( "ifec_mdio_read\n" );
580
581         outl ( 0x08000000 | ( location << 16 ) | ( phy_id << 21 ),
582                ioaddr + CSRCtrlMDI );
583         do {
584                 udelay ( 16 );
585
586                 val = inl ( ioaddr + CSRCtrlMDI );
587
588                 if ( --boguscnt < 0 ) {
589                         DBG ( " ifec_mdio_read() time out with val = %X.\n",
590                                  val );
591                         break;
592                 }
593         } while (! ( val & 0x10000000 ) );
594         return val & 0xffff;
595 }
596
597 /*
598  * Initializes MDIO.
599  *
600  * @v netdev            Network device
601  * @v options           MDIO options
602  */
603 static void ifec_mdio_setup ( struct net_device *netdev, int options )
604 {
605         struct ifec_private *priv = netdev->priv;
606         unsigned short mdio_register = priv->mdio_register;
607
608         DBGP ( "ifec_mdio_setup\n" );
609
610         if (   ( (mdio_register>>8) & 0x3f ) == DP83840
611             || ( (mdio_register>>8) & 0x3f ) == DP83840A ) {
612                 int mdi_reg23 = ifec_mdio_read ( netdev, mdio_register
613                                                   & 0x1f, 23 ) | 0x0422;
614                 if (CONGENB)
615                         mdi_reg23 |= 0x0100;
616                 DBG2 ( "DP83840 specific setup, setting register 23 to "
617                                                          "%hX.\n", mdi_reg23 );
618                 ifec_mdio_write ( netdev, mdio_register & 0x1f, 23, mdi_reg23 );
619         }
620         DBG2 ( "dp83840 " );
621         if ( options != 0 ) {
622                 ifec_mdio_write ( netdev, mdio_register & 0x1f, 0,
623                                            ( (options & 0x20) ? 0x2000 : 0 ) |
624                                            ( (options & 0x10) ? 0x0100 : 0 ) );
625                 DBG2 ( "set mdio_register. " );
626         }
627 }
628
629 /*
630  * Support function: ifec_mdio_write
631  *
632  * This probably writes to the "physical media interface chip".
633  * -- REW
634  */
635 static int ifec_mdio_write ( struct net_device *netdev,
636                              int phy_id, int location, int value )
637 {
638         struct ifec_private *priv = netdev->priv;
639         unsigned long ioaddr = priv->ioaddr;
640         int val;
641         int boguscnt = 64*4;     /* <64 usec. to complete, typ 27 ticks */
642
643         DBGP ( "ifec_mdio_write\n" );
644
645         outl ( 0x04000000 | ( location << 16 ) | ( phy_id << 21 ) | value,
646                ioaddr + CSRCtrlMDI );
647         do {
648                 udelay ( 16 );
649
650                 val = inl ( ioaddr + CSRCtrlMDI );
651                 if ( --boguscnt < 0 ) {
652                         DBG ( " ifec_mdio_write() time out with val = %X.\n",
653                               val );
654                         break;
655                 }
656         } while (! ( val & 0x10000000 ) );
657         return val & 0xffff;
658 }
659
660 /*
661  * Resets the hardware.
662  *
663  * @v netdev            Network device
664  */
665 static void ifec_reset ( struct net_device *netdev )
666 {
667         struct ifec_private *priv = netdev->priv;
668         unsigned long ioaddr = priv->ioaddr;
669
670         DBGP ( "ifec_reset\n" );
671
672         /* do partial reset first */
673         outl ( PortPartialReset, ioaddr + CSRPort );
674         inw ( ioaddr + SCBStatus );
675         udelay ( 20 );
676
677         /* full reset */
678         outl ( PortReset, ioaddr + CSRPort );
679         inw ( ioaddr + SCBStatus );
680         udelay ( 20 );
681
682         /* disable interrupts again */
683         ifec_net_irq ( netdev, 0 );
684 }
685
686 /*
687  * free()s the tx/rx rings.
688  *
689  * @v netdev            Network device
690  */
691 static void ifec_free ( struct net_device *netdev )
692 {
693         struct ifec_private *priv = netdev_priv ( netdev );
694         int i;
695
696         DBGP ( "ifec_free\n" );
697
698         /* free all allocated receive io_buffers */
699         for ( i = 0; i < RFD_COUNT; i++ ) {
700                 free_iob ( priv->rx_iobs[i] );
701                 priv->rx_iobs[i] = NULL;
702                 priv->rfds[i] = NULL;
703         }
704
705         /* free TX ring buffer */
706         free_dma ( priv->tcbs, TX_RING_BYTES );
707
708         priv->tcbs = NULL;
709 }
710
711 /*
712  * Initializes an RFD.
713  *
714  * @v rfd               RFD struct to initialize
715  * @v command           Command word
716  * @v link              Link value
717  */
718 static void ifec_rfd_init ( struct ifec_rfd *rfd, s16 command, u32 link )
719 {
720         DBGP ( "ifec_rfd_init\n" );
721
722         rfd->status      = 0;
723         rfd->command     = command;
724         rfd->rx_buf_addr = 0xFFFFFFFF;
725         rfd->count       = 0;
726         rfd->size        = RFD_PACKET_LEN;
727         rfd->link        = link;
728 }
729
730 /*
731  * Send address of new RFD to card
732  *
733  * @v netdev            Network device
734  */
735 static void ifec_reprime_ru ( struct net_device *netdev )
736 {
737         struct ifec_private *priv = netdev->priv;
738         int cur_rx = priv->cur_rx;
739         
740         DBGP ( "ifec_reprime_ru\n" );
741         
742         if ( priv->rfds[cur_rx] != NULL ) {
743                 ifec_scb_cmd ( netdev, virt_to_bus ( priv->rfds[cur_rx] ),
744                                RUStart );
745                 ifec_scb_cmd_wait ( netdev );
746         }
747 }
748
749 /*
750  * Check if reprime of RU needed
751  *
752  * @v netdev            Network device
753  */
754 static void ifec_check_ru_status ( struct net_device *netdev,
755                                    unsigned short intr_status )
756 {
757         struct ifec_private *priv = netdev->priv;
758
759         DBGP ( "ifec_check_ru_status\n" );
760
761         /*
762         * The chip may have suspended reception for various reasons.
763         * Check for that, and re-prime it should this be the case.
764         */
765         switch ( ( intr_status >> 2 ) & 0xf ) {
766                 case 0:  /* Idle */
767                 case 4:  /* Ready */
768                         break;
769                 case 1:  /* Suspended */
770                 case 2:  /* No resources (RFDs) */
771                 case 9:  /* Suspended with no more RBDs */
772                 case 10: /* No resources due to no RBDs */
773                 case 12: /* Ready with no RBDs */
774                         DBG ( "ifec_net_poll: RU reprimed.\n" );
775                         ifec_reprime_ru ( netdev );
776                         break;
777                 default:
778                         /* reserved values */
779                         DBG ( "ifec_net_poll: RU state anomaly: %i\n",
780                               ( inw ( priv->ioaddr + SCBStatus ) >> 2 ) & 0xf );
781                         break;
782         }
783 }
784
785 #define RFD_STATUS ( RFD_OK | RFDRxCol | RFDRxErr | RFDShort | \
786                      RFDDMAOverrun | RFDNoBufs | RFDCRCError )
787 /*
788  * Looks for received packets in the rx ring, reports success or error to
789  * the core accordingly. Starts reallocation of rx ring.
790  *
791  * @v netdev            Network device
792  */
793 static void ifec_rx_process ( struct net_device *netdev )
794 {
795         struct ifec_private *priv   = netdev->priv;
796         int cur_rx = priv->cur_rx;
797         struct io_buffer *iob = priv->rx_iobs[cur_rx];
798         struct ifec_rfd *rfd = priv->rfds[cur_rx];
799         unsigned int rx_len;
800         s16 status;
801
802         DBGP ( "ifec_rx_process\n" );
803
804         /* Process any received packets */
805         while ( iob && rfd && ( status = rfd->status ) ) {
806                 rx_len = rfd->count & RFDMaskCount;
807
808                 DBG2 ( "Got a packet: Len = %d, cur_rx = %d.\n", rx_len,
809                        cur_rx );
810                 DBGIO_HD ( (void*)rfd->packet, 0x30 );
811
812                 if ( ( status & RFD_STATUS ) != RFD_OK ) {
813                         DBG ( "Corrupted packet received. "
814                               "Status = %#08hx\n", status );
815                         netdev_rx_err ( netdev, iob, -EINVAL );
816                 } else {
817                         /* Hand off the packet to the network subsystem */
818                         iob_put ( iob, rx_len );
819                         DBG2 ( "Received packet: %p, len: %d\n", iob, rx_len );
820                         netdev_rx ( netdev, iob );
821                 }
822
823                 /* make sure we don't reuse this RFD */
824                 priv->rx_iobs[cur_rx] = NULL;
825                 priv->rfds[cur_rx] = NULL;
826
827                 /* Next RFD */
828                 priv->cur_rx = ( cur_rx + 1 ) % RFD_COUNT;
829                 cur_rx = priv->cur_rx;
830                 iob = priv->rx_iobs[cur_rx];
831                 rfd = priv->rfds[cur_rx];
832         }
833
834         ifec_refill_rx_ring ( netdev );
835 }
836
837 /*
838  * Allocates io_buffer, set pointers in ifec_private structure accordingly,
839  * reserves space for RFD header in io_buffer.
840  *
841  * @v netdev            Network device
842  * @v cur               Descriptor number to work on
843  * @v cmd               Value to set cmd field in RFD to
844  * @v link              Pointer to ned RFD
845  * @ret rc              0 on success, negative on failure
846  */
847 static int ifec_get_rx_desc ( struct net_device *netdev, int cur, int cmd,
848                               int link )
849 {
850         struct ifec_private *priv = netdev->priv;
851         struct ifec_rfd *rfd  = priv->rfds[cur];
852
853         DBGP ( "ifec_get_rx_desc\n" );
854
855         priv->rx_iobs[cur] = alloc_iob ( sizeof ( *rfd ) );
856         if ( ! priv->rx_iobs[cur] ) {
857                 DBG ( "alloc_iob failed. desc. nr: %d\n", cur );
858                 priv->rfds[cur] = NULL;
859                 return -ENOMEM;
860         }
861
862         /* Initialize new tail. */
863         priv->rfds[cur] = priv->rx_iobs[cur]->data;
864         ifec_rfd_init ( priv->rfds[cur], cmd, link );
865         iob_reserve ( priv->rx_iobs[cur], RFD_HEADER_LEN );
866
867         return 0;
868 }
869
870 /*
871  * Allocate new descriptor entries and initialize them if needed
872  *
873  * @v netdev            Network device
874  */
875 static void ifec_refill_rx_ring ( struct net_device *netdev )
876 {
877         struct ifec_private *priv = netdev->priv;
878         int i, cur_rx;
879         unsigned short intr_status;
880
881         DBGP ( "ifec_refill_rx_ring\n" );
882
883         for ( i = 0; i < RFD_COUNT; i++ ) {
884                 cur_rx = ( priv->cur_rx + i ) % RFD_COUNT;
885                 /* only refill if empty */
886                 if ( priv->rfds[cur_rx] != NULL ||
887                      priv->rx_iobs[cur_rx] != NULL )
888                         continue;
889
890                 DBG2 ( "refilling RFD %d\n", cur_rx );
891
892                 if ( ifec_get_rx_desc ( netdev, cur_rx,
893                      CmdSuspend | CmdEndOfList, 0 ) == 0 ) {
894                         if ( i > 0 ) {
895                                 int prev_rx = ( ( ( cur_rx + RFD_COUNT ) - 1 )
896                                                 % RFD_COUNT );
897                                 struct ifec_rfd *rfd = priv->rfds[prev_rx];
898
899                                 rfd->command = 0;
900                                 rfd->link = virt_to_bus ( priv->rfds[cur_rx] );
901                         }
902                 }
903         }
904
905         intr_status = inw ( priv->ioaddr + SCBStatus );
906         ifec_check_ru_status ( netdev, intr_status );
907 }
908
909 /*
910  * Initial allocation & initialization of the rx ring.
911  *
912  * @v netdev            Device of rx ring.
913  * @ret rc              Non-zero if error occured
914  */
915 static int ifec_rx_setup ( struct net_device *netdev )
916 {
917         struct ifec_private *priv = netdev->priv;
918         int i;
919
920         DBGP ( "ifec_rx_setup\n" );
921
922         priv->cur_rx = 0;
923
924         /* init values for ifec_refill_rx_ring() */
925         for ( i = 0; i < RFD_COUNT; i++ ) {
926                 priv->rfds[i] = NULL;
927                 priv->rx_iobs[i] = NULL;
928         }
929         ifec_refill_rx_ring ( netdev );
930
931         return 0;
932 }
933
934 /*
935  * Initiates a SCB command.
936  *
937  * @v netdev            Network device
938  * @v ptr               General pointer value for command.
939  * @v cmd               Command to issue.
940  * @ret rc              Non-zero if command not issued.
941  */
942 static int ifec_scb_cmd ( struct net_device *netdev, u32 ptr, u8 cmd )
943 {
944         struct ifec_private *priv = netdev->priv;
945         unsigned long ioaddr = priv->ioaddr;
946         int rc;
947
948         DBGP ( "ifec_scb_cmd\n" );
949
950         rc = ifec_scb_cmd_wait ( netdev );      /* Wait until ready */
951         if ( !rc ) {
952                 outl ( ptr, ioaddr + SCBPointer );
953                 outb ( cmd, ioaddr + SCBCmd );          /* Issue command */
954         }
955         return rc;
956 }
957
958 /*
959  * Wait for command unit to accept a command.
960  *
961  * @v cmd_ioaddr        I/O address of command register.
962  * @ret rc              Non-zero if command timed out.
963  */
964 static int ifec_scb_cmd_wait ( struct net_device *netdev )
965 {
966         struct ifec_private *priv = netdev->priv;
967         unsigned long cmd_ioaddr = priv->ioaddr + SCBCmd;
968         int rc, wait = CU_CMD_TIMEOUT;
969
970         DBGP ( "ifec_scb_cmd_wait\n" );
971
972         for ( ; wait && ( rc = inb ( cmd_ioaddr ) ); wait-- )
973                 udelay ( 1 );
974
975         if ( !wait )
976                 DBG ( "ifec_scb_cmd_wait timeout!\n" );
977         return rc;
978 }
979
980 /*
981  * Check status of transmitted packets & perform tx completions.
982  *
983  * @v netdev            Network device.
984  */
985 static void ifec_tx_process ( struct net_device *netdev )
986 {
987         struct ifec_private *priv = netdev->priv;
988         struct ifec_tcb *tcb = priv->tcb_tail;
989         s16 status;
990
991         DBGP ( "ifec_tx_process\n" );
992
993         /* Check status of transmitted packets */
994         while ( ( status = tcb->status ) && tcb->iob ) {
995                 if ( status & TCB_U ) {
996                         /* report error to iPXE */
997                         DBG ( "ifec_tx_process : tx error!\n " );
998                         netdev_tx_complete_err ( netdev, tcb->iob, -EINVAL );
999                 } else {
1000                         /* report successful transmit */
1001                         netdev_tx_complete ( netdev, tcb->iob );
1002                 }
1003                 DBG2 ( "tx completion\n" );
1004
1005                 tcb->iob = NULL;
1006                 tcb->status = 0;
1007
1008                 priv->tcb_tail = tcb->next;     /* Next TCB */
1009                 tcb = tcb->next;
1010         }
1011 }
1012
1013 /*
1014  * Allocates & initialize tx resources.
1015  *
1016  * @v netdev            Network device.
1017  * @ret rc              Non-zero if error occurred.
1018  */
1019 static int ifec_tx_setup ( struct net_device *netdev )
1020 {
1021         struct ifec_private *priv = netdev->priv;
1022         struct ifec_tcb *tcb;
1023         int i;
1024
1025         DBGP ( "ifec_tx_setup\n" );
1026
1027         /* allocate tx ring */
1028         priv->tcbs = malloc_dma ( TX_RING_BYTES, CB_ALIGN );
1029         if ( !priv->tcbs ) {
1030                 DBG ( "TX-ring allocation failed\n" );
1031                 return -ENOMEM;
1032         }
1033
1034         tcb = priv->tcb_tail = priv->tcbs;
1035         priv->tx_curr = priv->tx_tail = 0;
1036         priv->tx_cnt = 0;
1037
1038         for ( i = 0; i < TCB_COUNT; i++, tcb++ ) {
1039                 tcb->status    = 0;
1040                 tcb->count     = 0x01208000;
1041                 tcb->iob       = NULL;
1042                 tcb->tbda_addr = virt_to_bus ( &tcb->tbd_addr0 );
1043                 tcb->link      = virt_to_bus ( tcb + 1 );
1044                 tcb->next      = tcb + 1;
1045         }
1046         /* We point tcb_head at the last TCB, so the first ifec_net_transmit()
1047          * will use the first (head->next) TCB to transmit. */
1048         priv->tcb_head = --tcb;
1049         tcb->link = virt_to_bus ( priv->tcbs );
1050         tcb->next = priv->tcbs;
1051         
1052         return 0;
1053 }
1054
1055 /*
1056  * Wake up the Command Unit and issue a Resume/Start.
1057  *
1058  * @v netdev            Network device containing Command Unit
1059  *
1060  * The time between clearing the S bit and issuing Resume must be as short as
1061  * possible to prevent a race condition. As noted in linux eepro100.c :
1062  *   Note: Watch out for the potential race condition here: imagine
1063  *      erasing the previous suspend
1064  *              the chip processes the previous command
1065  *              the chip processes the final command, and suspends
1066  *      doing the CU_RESUME
1067  *              the chip processes the next-yet-valid post-final-command.
1068  *   So blindly sending a CU_RESUME is only safe if we do it immediately after
1069  *   erasing the previous CmdSuspend, without the possibility of an intervening
1070  *   delay.
1071  */
1072 void ifec_tx_wake ( struct net_device *netdev )
1073 {
1074         struct ifec_private *priv = netdev->priv;
1075         unsigned long ioaddr = priv->ioaddr;
1076         struct ifec_tcb *tcb = priv->tcb_head->next;
1077
1078         DBGP ( "ifec_tx_wake\n" );
1079
1080         /* For the special case of the first transmit, we issue a START. The
1081          * card won't RESUME after the configure command. */
1082         if ( priv->configured ) {
1083                 priv->configured = 0;
1084                 ifec_scb_cmd ( netdev, virt_to_bus ( tcb ), CUStart );
1085                 ifec_scb_cmd_wait ( netdev );
1086                 return;
1087         }
1088
1089         /* Resume if suspended. */
1090         switch ( ( inw ( ioaddr + SCBStatus ) >> 6 ) & 0x3 ) {
1091         case 0:  /* Idle - We should not reach this state. */
1092                 DBG2 ( "ifec_tx_wake: tx idle!\n" );
1093                 ifec_scb_cmd ( netdev, virt_to_bus ( tcb ), CUStart );
1094                 ifec_scb_cmd_wait ( netdev );
1095                 return;
1096         case 1:  /* Suspended */
1097                 DBG2 ( "s" );
1098                 break;
1099         default: /* Active */
1100                 DBG2 ( "a" );
1101         }
1102         ifec_scb_cmd_wait ( netdev );
1103         outl ( 0, ioaddr + SCBPointer );
1104         priv->tcb_head->command &= ~CmdSuspend;
1105         /* Immediately issue Resume command */
1106         outb ( CUResume, ioaddr + SCBCmd );
1107         ifec_scb_cmd_wait ( netdev );
1108 }
1109
1110 /*********************************************************************/
1111
1112 static struct pci_device_id ifec_nics[] = {
1113 PCI_ROM(0x8086, 0x1029, "id1029",        "Intel EtherExpressPro100 ID1029", 0),
1114 PCI_ROM(0x8086, 0x1030, "id1030",        "Intel EtherExpressPro100 ID1030", 0),
1115 PCI_ROM(0x8086, 0x1031, "82801cam",      "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1116 PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection", 0),
1117 PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection", 0),
1118 PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection", 0),
1119 PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1120 PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1121 PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller", 0),
1122 PCI_ROM(0x8086, 0x1038, "id1038",        "Intel PRO/100 VM Network Connection", 0),
1123 PCI_ROM(0x8086, 0x1039, "82562et",       "Intel PRO100 VE 82562ET", 0),
1124 PCI_ROM(0x8086, 0x103a, "id103a",        "Intel Corporation 82559 InBusiness 10/100", 0),
1125 PCI_ROM(0x8086, 0x103b, "82562etb",      "Intel PRO100 VE 82562ETB", 0),
1126 PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection", 0),
1127 PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection", 0),
1128 PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection", 0),
1129 PCI_ROM(0x8086, 0x1051, "prove",         "Intel PRO/100 VE Network Connection", 0),
1130 PCI_ROM(0x8086, 0x1059, "82551qm",       "Intel PRO/100 M Mobile Connection", 0),
1131 PCI_ROM(0x8086, 0x1209, "82559er",       "Intel EtherExpressPro100 82559ER", 0),
1132 PCI_ROM(0x8086, 0x1227, "82865",         "Intel 82865 EtherExpress PRO/100A", 0),
1133 PCI_ROM(0x8086, 0x1228, "82556",         "Intel 82556 EtherExpress PRO/100 Smart", 0),
1134 PCI_ROM(0x8086, 0x1229, "eepro100",      "Intel EtherExpressPro100", 0),
1135 PCI_ROM(0x8086, 0x2449, "82562em",       "Intel EtherExpressPro100 82562EM", 0),
1136 PCI_ROM(0x8086, 0x2459, "82562-1",       "Intel 82562 based Fast Ethernet Connection", 0),
1137 PCI_ROM(0x8086, 0x245d, "82562-2",       "Intel 82562 based Fast Ethernet Connection", 0),
1138 PCI_ROM(0x8086, 0x1050, "82562ez",       "Intel 82562EZ Network Connection", 0),
1139 PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller", 0),
1140 PCI_ROM(0x8086, 0x1065, "82562-3",       "Intel 82562 based Fast Ethernet Connection", 0),
1141 PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server", 0),
1142 PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server", 0),
1143 };
1144
1145 /* Cards with device ids 0x1030 to 0x103F, 0x2449, 0x2459 or 0x245D might need
1146  * a workaround for hardware bug on 10 mbit half duplex (see linux driver eepro100.c)
1147  * 2003/03/17 gbaum */
1148
1149 struct pci_driver ifec_driver __pci_driver = {
1150         .ids      = ifec_nics,
1151         .id_count = ( sizeof (ifec_nics) / sizeof (ifec_nics[0]) ),
1152         .probe    = ifec_pci_probe,
1153         .remove   = ifec_pci_remove
1154 };
1155
1156 /*
1157  * Local variables:
1158  *  c-basic-offset: 8
1159  *  c-indent-level: 8
1160  *  tab-width: 8
1161  * End:
1162  */