added irq to eepro100
authorUdayan Kumar <udayan.kumar@gmail.com>
Thu, 26 Jul 2007 14:04:26 +0000 (10:04 -0400)
committerUdayan Kumar <udayan.kumar@gmail.com>
Sat, 18 Aug 2007 23:32:38 +0000 (19:32 -0400)
src/drivers/net/eepro100.c

index c1df96f..93a953c 100644 (file)
@@ -87,12 +87,14 @@ struct speedo_private {
 };
 
 enum speedo_offsets {
-  SCBStatus = 0, SCBCmd = 2,      /* Rx/Command Unit command and status. */
-  SCBPointer = 4,                 /* General purpose pointer. */
-  SCBPort = 8,                    /* Misc. commands and operands.  */
-  SCBflash = 12, SCBeeprom = 14,  /* EEPROM and flash memory control. */
-  SCBCtrlMDI = 16,                /* MDI interface control. */
-  SCBEarlyRx = 20,                /* Early receive byte count. */
+       SCBStatus = 0,  /* Rx/Command Unit status */
+       SCBCmd = 2,      /* Rx/Command Unit command */
+       SCBPointer = 4,                 /* General purpose pointer. */
+       SCBPort = 8,                    /* Misc. commands and operands.  */
+       SCBflash = 12, 
+       SCBeeprom = 14,  /* EEPROM and flash memory control. */
+       SCBCtrlMDI = 16,                /* MDI interface control. */
+       SCBEarlyRx = 20,                /* Early receive byte count. */
 };
 
 enum SCBCmdBits {
@@ -150,19 +152,18 @@ enum phy_chips { NonSuchPhy=0, I82553AB, I82553C, I82503, DP83840, S80C240,
 
 /* Commands that can be put in a command list entry. */
 enum commands {
-  CmdNOp = 0,
-  CmdIASetup = 1,
-  CmdConfigure = 2,
-  CmdMulticastList = 3,
-  CmdTx = 4,
-  CmdTDR = 5,
-  CmdDump = 6,
-  CmdDiagnose = 7,
-
-  /* And some extra flags: */
-  CmdSuspend = 0x4000,      /* Suspend after completion. */
-  CmdIntr = 0x2000,         /* Interrupt after completion. */
-  CmdTxFlex = 0x0008,       /* Use "Flexible mode" for CmdTx command. */
+       CmdNOp = 0,
+       CmdIASetup = 1,
+       CmdConfigure = 2,
+       CmdMulticastList = 3,
+       CmdTx = 4,
+       CmdTDR = 5,
+       CmdDump = 6,
+       CmdDiagnose = 7,
+       /* And some extra flags: */
+       CmdSuspend = 0x4000,      /* Suspend after completion. */
+       CmdIntr = 0x2000,         /* Interrupt after completion. */
+       CmdTxFlex = 0x0008,       /* Use "Flexible mode" for CmdTx command. */
 };
 
 /* Selected elements of the Tx/RxFD.status word. */
@@ -179,62 +180,61 @@ static int rxfifo = 8;          /* Rx FIFO threshold, default 32 bytes. */
 static int txdmacount = 0;      /* Tx DMA burst length, 0-127, default 0. */
 static int rxdmacount = 0;      /* Rx DMA length, 0 means no preemption. */
 
-
 /*  Function Prototypes: */
-static int speedo_open (struct net_device *netdev);
-static int speedo_transmit (struct net_device *netdev, struct io_buffer *iobuf);
-static void speedo_poll (struct net_device *netdev);
-static void speedo_disable ( struct net_device *netdev); 
+static int speedo_open ( struct net_device *netdev );
+static int speedo_transmit ( struct net_device *netdev, struct io_buffer *iobuf );
+static void speedo_poll ( struct net_device *netdev );
+static void speedo_disable ( struct net_device *netdev ); 
+static void speedo_close ( struct net_device *netdev );
+static void speedo_irq ( struct net_device *netdev, int enable );
 
 /** speedo net device operations */
 static struct net_device_operations speedo_operations = {
         .open           = speedo_open,
-        .close          = speedo_disable,
+        .close          = speedo_close,
         .transmit       = speedo_transmit,
         .poll           = speedo_poll,
-//     .irq            = speedo_irq,
+       .irq            = speedo_irq,
 };
 
 /* How to wait for the command unit to accept a command.
    Typically this takes 0 ticks. */
-static inline void wait_for_cmd_done(int cmd_ioaddr)
-{
-  int wait = 0;
-  int delayed_cmd;
-
-  do
-    if (inb(cmd_ioaddr) == 0) return;
-  while(++wait <= 100);
-  delayed_cmd = inb(cmd_ioaddr);
-  do
-    if (inb(cmd_ioaddr) == 0) break;
-  while(++wait <= 10000);
-  printf("Command %2.2x was not immediately accepted, %d ticks!\n",
-      delayed_cmd, wait);
+static inline void wait_for_cmd_done ( int cmd_ioaddr ) {
+       int wait = 0;
+       int delayed_cmd;
+
+        do
+                if ( inb ( cmd_ioaddr ) == 0 )
+                        return;
+        while ( ++wait <= 100 );
+        delayed_cmd = inb ( cmd_ioaddr );
+        do
+        if ( inb ( cmd_ioaddr ) == 0 )
+                break;
+        while ( ++wait <= 10000 );
+        DBG ( "Command %2.2x was not immediately accepted, %d ticks!\n",
+                delayed_cmd, wait );
 }
+
 /* Support function: mdio_write
  *
  * This probably writes to the "physical media interface chip".
  * -- REW
  */
-
-static int mdio_write(struct net_device *netdev, int phy_id, int location, int value)
-{
+static int mdio_write ( struct net_device *netdev, int phy_id, int location, int value ) {
        struct speedo_private *sp = netdev->priv;
        int val, boguscnt = 64*4;         /* <64 usec. to complete, typ 27 ticks */
 
-       outl(0x04000000 | (location<<16) | (phy_id<<21) | value,
-            sp->ioaddr + SCBCtrlMDI);
+       outl ( 0x04000000 | (location<<16) | (phy_id<<21) | value,
+            sp->ioaddr + SCBCtrlMDI );
        do {
-               udelay(16);
-
-               val = inl(sp->ioaddr + SCBCtrlMDI);
-               if (--boguscnt < 0) {
-                       printf(" mdio_write() timed out with val = %X.\n", val);
+               udelay ( 16 );
+               val = inl ( sp->ioaddr + SCBCtrlMDI );
+               if ( --boguscnt < 0 ) {
+                       DBG ( "mdio_write() timed out with val = %X.\n", val );
                        break;
                }
-       } while (! (val & 0x10000000));
+       } while ( ! ( val & 0x10000000 ));
        return val & 0xffff;
 }
 
@@ -243,23 +243,22 @@ static int mdio_write(struct net_device *netdev, int phy_id, int location, int v
  * This probably reads a register in the "physical media interface chip".
  * -- REW
  */
-static int mdio_read(struct net_device *netdev,int phy_id, int location)
-{
+static int mdio_read ( struct net_device *netdev,int phy_id, int location ) {
        struct speedo_private *sp = netdev->priv;
        int val, boguscnt = 64*4;               /* <64 usec. to complete, typ 27 ticks */
-       outl(0x08000000 | (location<<16) | (phy_id<<21), sp->ioaddr + SCBCtrlMDI);
-       do {
-               udelay(16);
 
-               val = inl(sp->ioaddr + SCBCtrlMDI);
-
-               if (--boguscnt < 0) {
-                       printf( " mdio_read() timed out with val = %X.\n", val);
+       outl ( 0x08000000 | (location<<16) | (phy_id<<21), sp->ioaddr + SCBCtrlMDI );
+       do {
+               udelay ( 16 );
+               val = inl ( sp->ioaddr + SCBCtrlMDI );
+               if ( --boguscnt < 0 ) {
+                       DBG ( " mdio_read() timed out with val = %X.\n", val );
                        break;
                }
-       } while (! (val & 0x10000000));
+       } while ( ! ( val & 0x10000000 ));
        return val & 0xffff;
 }
+
 /* The fixes for the code were kindly provided by Dragan Stancevic
    <visitor@valinux.com> to strictly follow Intel specifications of EEPROM
    access timing.
@@ -267,29 +266,45 @@ static int mdio_read(struct net_device *netdev,int phy_id, int location)
    interval for serial EEPROM.  However, it looks like that there is an
    additional requirement dictating larger udelay's in the code below.
    2000/05/24  SAW */
-static int do_eeprom_cmd(struct net_device *netdev,int cmd, int cmd_len)
-{
+static int do_eeprom_cmd ( struct net_device *netdev,int cmd, int cmd_len ) {
        struct speedo_private *sp = netdev->priv;
        unsigned retval = 0;
        long ee_addr = sp->ioaddr + SCBeeprom;
 
        outw(EE_ENB, ee_addr); udelay(2);
        outw(EE_ENB | EE_SHIFT_CLK, ee_addr); udelay(2);
-
        /* Shift the command bits out. */
        do {
-               short dataval = (cmd & (1 << cmd_len)) ? EE_WRITE_1 : EE_WRITE_0;
-               outw(dataval, ee_addr); udelay(2);
-               outw(dataval | EE_SHIFT_CLK, ee_addr); udelay(2);
-               retval = (retval << 1) | ((inw(ee_addr) & EE_DATA_READ) ? 1 : 0);
-       } while (--cmd_len >= 0);
-       outw(EE_ENB, ee_addr); udelay(2);
-
-       /* Terminate the EEPROM access. */
-       outw(EE_ENB & ~EE_CS, ee_addr);
+               short dataval = ( cmd & ( 1 << cmd_len )) ? EE_WRITE_1 : EE_WRITE_0;
+               outw ( dataval, ee_addr ); 
+               udelay ( 2 );
+               outw ( dataval | EE_SHIFT_CLK, ee_addr ); 
+               udelay ( 2 );
+               retval = ( retval << 1 )  | (( inw ( ee_addr ) & EE_DATA_READ ) ? 1 : 0);
+       } while ( --cmd_len >= 0 );
+       outw ( EE_ENB, ee_addr ); 
+       udelay ( 2 );
+       /* Terminate the EEPROM access.
+        */
+       outw ( EE_ENB & ~EE_CS, ee_addr );
        return retval;
 }
 
+static void speedo_irq ( struct net_device *netdev, int enable ) {
+       struct speedo_private *sp = netdev->priv;
+       uint16_t enabled_mask = ( SCBMaskCmdDone | SCBMaskCmdIdle |
+                                 SCBMaskEarlyRx | SCBMaskFlowCtl );
+
+       switch ( enable ) {
+       case 0:
+               outw ( SCBMaskAll, sp->ioaddr + SCBCmd );
+               break;
+       case 1:
+               outw ( enabled_mask, sp->ioaddr + SCBCmd );
+               break;
+       }
+}
+
 /* function: eepro100_disable
  * resets the card. This is used to allow Etherboot or Linux
  * to probe the card again from a "virginal" state....
@@ -297,34 +312,38 @@ static int do_eeprom_cmd(struct net_device *netdev,int cmd, int cmd_len)
  *
  * returns:   void.
  */
-static void speedo_disable ( struct net_device *netdev) {
+static void speedo_disable ( struct net_device *netdev ) {
        struct speedo_private *sp = netdev->priv;
-       /* from eepro100_reset */
-       outl(0, sp->ioaddr + SCBPort);
-       /* from eepro100_disable */
+       /* from eepro100_reset
+        */
+       outl ( 0, sp->ioaddr + SCBPort );
+       /* from eepro100_disable 
+        */
        /* See if this PartialReset solves the problem with interfering with
-          kernel operation after Etherboot hands over. - Ken 20001102 */
-       outl(2, sp->ioaddr + SCBPort);
-
+          kernel operation after Etherboot hands over. - Ken 20001102
+        */
+       outl ( 2, sp->ioaddr + SCBPort );
        /* The following is from the Intel e100 driver.
-        * This hopefully solves the problem with hanging hard DOS images. */
-
-       /* wait for the reset to take effect */
-       udelay(20);
-
-       /* Mask off our interrupt line -- it is unmasked after reset */
+        * This hopefully solves the problem with hanging hard DOS images.
+        */
+       /* wait for the reset to take effect
+        */
+       udelay ( 20 );
+       /* Mask off our interrupt line -- it is unmasked after reset
+        */
        {
                u16 intr_status;
-               /* Disable interrupts on our PCI board by setting the mask bit */
-               outw(INT_MASK, sp->ioaddr + SCBCmd);
-               intr_status = inw(sp->ioaddr + SCBStatus);
-               /* ack and clear intrs */
-               outw(intr_status, sp->ioaddr + SCBStatus);
-               inw(sp->ioaddr + SCBStatus);
+               /* Disable interrupts on our PCI board by setting the mask bit
+                */
+               outw ( INT_MASK, sp->ioaddr + SCBCmd );
+               intr_status = inw ( sp->ioaddr + SCBStatus );
+               /* ack and clear intrs
+                */
+               outw ( intr_status, sp->ioaddr + SCBStatus );
+               inw ( sp->ioaddr + SCBStatus );
        }
 }
 
-
 /**
  * Probe PCI device
  *
@@ -332,8 +351,8 @@ static void speedo_disable ( struct net_device *netdev) {
  * @v id       PCI ID
  * @ret rc     Return status code
  */
-static int speedo_probe (struct pci_device *pci,
-                      const struct pci_device_id *id __unused) {
+static int speedo_probe ( struct pci_device *pci,
+                      const struct pci_device_id *id __unused ) {
        struct net_device *netdev;
        struct speedo_private *sp = NULL;
        int rc;
@@ -343,24 +362,21 @@ static int speedo_probe (struct pci_device *pci,
        /* Allocate net device 
         */
        DBG("In probe routine \n");
-       netdev = alloc_etherdev (sizeof (*sp));
-       if (! netdev
+       netdev = alloc_etherdev ( sizeof ( *sp ) );
+       if ( ! netdev 
                return -ENOMEM;
 
-       netdev_init (netdev, &speedo_operations);
+       netdev_init ( netdev, &speedo_operations );
        sp = netdev->priv;
-       pci_set_drvdata (pci, netdev);
+       pci_set_drvdata ( pci, netdev );
        netdev->dev = &pci->dev;
-       memset (sp, 0, sizeof (*sp));
+       memset ( sp, 0, sizeof ( *sp ) );
        sp->ioaddr = pci->ioaddr;
-
-       adjust_pci_device (pci);
-
-       //natsemi_reset (netdev);
-       
-       /* read the MAC Address */
-       if ((do_eeprom_cmd(netdev,EE_READ_CMD << 24, 27) & 0xffe0000)
-               == 0xffe0000) {
+       adjust_pci_device ( pci );
+       /* read the MAC Address
+        */
+       if ( ( do_eeprom_cmd ( netdev, EE_READ_CMD << 24, 27 ) & 0xffe0000 )
+               == 0xffe0000 ) {
                ee_size = 0x100;
                read_cmd = EE_READ_CMD << 24;
        } else {
@@ -370,86 +386,93 @@ static int speedo_probe (struct pci_device *pci,
 
        for (i = 0, sum = 0; i < ee_size; i++) {
                unsigned short value = do_eeprom_cmd(netdev,read_cmd | (i << 16), 27);
-               if (i < (int)(sizeof(eeprom)/sizeof(eeprom[0])))
+               if (i < (int) ( sizeof ( eeprom ) / sizeof ( eeprom[0] ) ) )
                        eeprom[i] = value;
                sum += value;
        }
 
-       for (i=0;i<ETH_ALEN;i++) {
-               netdev->ll_addr[i] =  (eeprom[i/2] >> (8*(i&1))) & 0xff;
+       for (i = 0; i < ETH_ALEN; i++) {
+               netdev->ll_addr[i] =  ( eeprom[i/2] >> ( 8* ( i & 1 ) ) ) & 0xff;
        }
 
 
-       if ((rc = register_netdev (netdev)) != 0)
+       if ( (rc = register_netdev ( netdev ) ) != 0)
                goto err_register_netdev;
 
        return 0;
 
 err_register_netdev:
 
-       speedo_disable (netdev);
-       netdev_put (netdev);
+       speedo_disable ( netdev );
+       netdev_put ( netdev );
        return rc;
 }
 
+/**
+ * Close NIC
+ *
+ * @v netdev            Net device
+ */
+static void speedo_close (struct net_device *netdev) {
+       /* it looks nothing to be done to close the device */
+       return;
+       
+}
+
 /**
  * Open NIC
  *
  * @v netdev           Net device
  * @ret rc             Return status code
  */
-static int speedo_open (struct net_device *netdev) { 
+static int speedo_open ( struct net_device *netdev ) { 
        struct speedo_private *sp = netdev->priv; 
        int i; 
        int options = 0x00;
-       int rx_mode=0;
+       int rx_mode = 0;
+
        /* Setup RX ring
         */
-       /*TODO check what is required */
-       outl(0, sp->ioaddr + SCBPointer);
-       outw(INT_MASK | RX_ADDR_LOAD, sp->ioaddr + SCBCmd);
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
-
-       outl(virt_to_bus(&sp->lstats), sp->ioaddr + SCBPointer);
-       outb(CU_STATSADDR, sp->ioaddr + SCBCmd);
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
-
+       outl ( 0, sp->ioaddr + SCBPointer );
+       outw ( INT_MASK | RX_ADDR_LOAD, sp->ioaddr + SCBCmd );
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 
+       outl ( virt_to_bus ( &sp->lstats ), sp->ioaddr + SCBPointer );
+       outb ( CU_STATSADDR, sp->ioaddr + SCBCmd );
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
        sp->rx_cur = 0;
-       for (i = 0 ; i < NUM_RX_DESC ; i++) {
+       for ( i = 0 ; i < NUM_RX_DESC ; i++ ) {
                sp->rxfd[i].status      = 0x0000;
                sp->rxfd[i].command     = 0x0000;
                sp->rxfd[i].rx_buf_addr = 0xFFFFFFFF;
                sp->rxfd[i].count       = 0;
                sp->rxfd[i].size        = RX_BUF_SIZE;
-               sp->rxfd[i].link        = virt_to_bus(&sp->rxfd[i+1]);
+               sp->rxfd[i].link        = virt_to_bus ( &sp->rxfd[i+1] );
        }
 
        sp->rxfd[NUM_RX_DESC -1].status  = 0x0000;
        sp->rxfd[NUM_RX_DESC -1].command = 0xC000;
-       sp->rxfd[NUM_RX_DESC -1].link    = virt_to_bus(&sp->rxfd[0]);
+       sp->rxfd[NUM_RX_DESC -1].link    = virt_to_bus( &sp->rxfd[0] );
 
-
-       outl(virt_to_bus(&sp->rxfd[0]), sp->ioaddr + SCBPointer);
-       outb(RX_START, sp->ioaddr + SCBCmd);
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
+       outl ( virt_to_bus ( &sp->rxfd[0] ), sp->ioaddr + SCBPointer );
+       outb ( RX_START, sp->ioaddr + SCBCmd );
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 
        /* Setup Tx Ring 
         */
        /* Base = 0 */
-       outl(0, sp->ioaddr + SCBPointer);
-       outb(CU_CMD_BASE, sp->ioaddr + SCBCmd);
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
+       outl ( 0, sp->ioaddr + SCBPointer );
+       outb ( CU_CMD_BASE, sp->ioaddr + SCBCmd );
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
        sp->tx_cur = 0;
        sp->tx_dirty = 0;
-       for (i = 0 ; i < TX_RING_SIZE ; i++) {
-               sp->txfd[i].link   = virt_to_bus ((i + 1 < TX_RING_SIZE) ? &
-                                                  sp->txfd[i + 1] : &sp->txfd[0]);
-               sp->txfd[i].command = (CmdSuspend);
+       for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
+               sp->txfd[i].link   = virt_to_bus ( ( i + 1 < TX_RING_SIZE ) ? &
+                                                  sp->txfd[i + 1] : &sp->txfd[0] );
+               sp->txfd[i].command = ( CmdSuspend );
                sp->txfd[i].status = 0;
-               sp->txfd[i].tx_desc_addr = virt_to_bus(&sp->txfd[i].tx_buf_addr0);
+               sp->txfd[i].tx_desc_addr = virt_to_bus ( &sp->txfd[i].tx_buf_addr0 );
        }
-
        
        /* Setting up the RX mode */
        /* Set or clear the multicast filter for this adaptor.
@@ -462,62 +485,57 @@ static int speedo_open (struct net_device *netdev) {
           command, into a no-op and link it to the new command.
        */
        
-               if (   ((eeprom[6]>>8) & 0x3f) == DP83840
-              || ((eeprom[6]>>8) & 0x3f) == DP83840A) {
-               int mdi_reg23 = mdio_read(netdev,eeprom[6] & 0x1f, 23) | 0x0422;
-               if (congenb)
+       if ( ( ( eeprom[6] >> 8 ) & 0x3f ) == DP83840
+              || ( ( eeprom[6] >> 8 ) & 0x3f ) == DP83840A) {
+               int mdi_reg23 = mdio_read ( netdev,eeprom[6] & 0x1f, 23 ) | 0x0422;
+               if ( congenb )
                        mdi_reg23 |= 0x0100;
-               DBG("  DP83840 specific setup, setting register 23 to %hX.\n",
+               DBG ( "DP83840 specific setup, setting register 23 to %hX.\n",
                       mdi_reg23);
-               mdio_write(netdev,eeprom[6] & 0x1f, 23, mdi_reg23);
+               mdio_write ( netdev,eeprom[6] & 0x1f, 23, mdi_reg23 );
        }
-       DBG ("Done DP8340 special setup.\n");
-       if (options != 0) {
-               mdio_write(netdev,eeprom[6] & 0x1f, 0,
-                          ((options & 0x20) ? 0x2000 : 0) |    /* 100mbps? */
-                          ((options & 0x10) ? 0x0100 : 0)); /* Full duplex? */
-               DBG ("set mdio_register.\n");
+       DBG ( "Done DP8340 special setup.\n" );
+       if ( options != 0 )  {
+               mdio_write ( netdev,eeprom[6] & 0x1f, 0,
+                          ( ( options & 0x20 ) ? 0x2000 : 0) |    /* 100mbps? */
+                          ( ( options & 0x10 ) ? 0x0100 : 0)); /* Full duplex? */
+               DBG ( "set mdio_register.\n" );
        }
-
        
        sp->tx_cur++;
        sp->tx_dirty++;
-       sp->txfd[0].status = (CmdSuspend | CmdConfigure);
+       sp->txfd[0].status = ( CmdSuspend | CmdConfigure );
        uint8_t * config_cmd_data;
        config_cmd_data = (void *)&sp->txfd[0].tx_desc_addr;
-       /* Construct a full CmdConfig frame. */
-       memcpy(config_cmd_data, i82558_config_cmd, CONFIG_DATA_SIZE);   
-       config_cmd_data[1]  = (txfifo << 4) | rxfifo;
+       /* Construct a full CmdConfig frame.
+        */
+       memcpy ( config_cmd_data, i82558_config_cmd, CONFIG_DATA_SIZE );        
+       config_cmd_data[1]  = ( txfifo << 4 ) | rxfifo;
        config_cmd_data[4]  = rxdmacount;
        config_cmd_data[5]  = txdmacount + 0x80;
-       config_cmd_data[15] = (rx_mode & 2) ? 0x49: 0x48;
-       config_cmd_data[19] = (options & 0x10) ? 0xC0 : 0x80;
-       config_cmd_data[21] = (rx_mode & 1) ? 0x0D: 0x05;
+       config_cmd_data[15] = ( rx_mode & 2 ) ? 0x49: 0x48;
+       config_cmd_data[19] = ( options & 0x10 ) ? 0xC0 : 0x80;
+       config_cmd_data[21] = ( rx_mode & 1 ) ? 0x0D: 0x05;
 
-       outl(virt_to_bus(&sp->txfd[0]), sp->ioaddr + SCBPointer);
-       outb(CU_START, sp->ioaddr + SCBCmd);
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
+       outl ( virt_to_bus ( &sp->txfd[0] ), sp->ioaddr + SCBPointer );
+       outb ( CU_START, sp->ioaddr + SCBCmd );
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 
-       /* Read the status register once to disgard stale data */
-       mdio_read(netdev,eeprom[6] & 0x1f, 1);
+       /* Read the status register once to disgard stale data
+        */
+       mdio_read ( netdev,eeprom[6] & 0x1f, 1 );
        /* Check to see if the network cable is plugged in.
         * This allows for faster failure if there is nothing
         * we can do.
         */
-       if (!(mdio_read(netdev,eeprom[6] & 0x1f, 1) & (1 << 2))) {
-               printf("Valid link not established\n");
-               speedo_disable(netdev);
+       if (!( mdio_read ( netdev,eeprom[6] & 0x1f, 1 ) & ( 1 << 2 ))) {
+               DBG ( "Valid link not established\n" );
+               speedo_disable ( netdev );
                return -1;
        }
-
-
-       
-
        return 0;
-                      
 }
 
-
 /** 
  * Transmit packet
  *
@@ -525,64 +543,52 @@ static int speedo_open (struct net_device *netdev) {
  * @v iobuf    I/O buffer
  * @ret rc     Return status code
  */
-static int speedo_transmit (struct net_device *netdev, struct io_buffer *iobuf)
-{
+static int speedo_transmit ( struct net_device *netdev, struct io_buffer *iobuf ) {
        struct speedo_private *sp = netdev->priv;
-       unsigned short status;
 
-       status = inw(sp->ioaddr + SCBStatus);
-       /* Acknowledge all of the current interrupt sources ASAP. */
-       outw(status & 0xfc00, sp->ioaddr + SCBStatus);
-
-       if ((sp->tx_cur + 1)% TX_RING_SIZE == sp->tx_dirty) {
-               DBG ("TX overflow\n");
+       if ( ( sp->tx_cur + 1 ) % TX_RING_SIZE == sp->tx_dirty ) {
+               DBG ( "TX overflow\n" );
                return -ENOBUFS;
        }
-
        /* Used by netdev_tx_complete ()
         */
        sp->tx_iobuf[sp->tx_cur] = iobuf;
-
        /* Pad and align packet has not been used because its not required 
         * by the hardware.
         *      iob_pad (iobuf, ETH_ZLEN); 
         * can be used to achieve it, if required
         */
-
        /* Add the packet to TX ring
         */
 
        sp->txfd[sp->tx_cur].status =  0;
        sp->txfd[sp->tx_cur].command = CmdSuspend | CmdTx | CmdTxFlex;
        sp->txfd[sp->tx_cur].count =  0x02208000;
-       sp->txfd[sp->tx_cur].tx_buf_addr0 = virt_to_bus (iobuf->data);
-       sp->txfd[sp->tx_cur].tx_buf_size0 = iob_len(iobuf);
+       sp->txfd[sp->tx_cur].tx_buf_addr0 = virt_to_bus ( iobuf->data );
+       sp->txfd[sp->tx_cur].tx_buf_size0 = iob_len ( iobuf );
 
        DBG ("TX id %d at %#08lx + %#08x\n", sp->tx_cur,
-            virt_to_bus (&iobuf->data), iob_len (iobuf));
-
+            virt_to_bus ( &iobuf->data ), iob_len ( iobuf ) );
 
        /* start the transmitter 
         *
         * Removing suspend from the command of previous packet.  
         * As linx driver does
         */
-       sp->txfd[((sp->tx_cur-1) < 0 ? TX_RING_SIZE -1 : sp->tx_cur -1)].command 
+       sp->txfd[(( sp->tx_cur - 1 ) < 0 ? TX_RING_SIZE -1 : sp->tx_cur - 1 )].command 
                                                                &= ~CmdSuspend; 
        /* We want the time window between clearing suspend flag on the previous
           command and resuming CU to be as small as possible.
           Interrupts in between are very undesired.  --SAW */
-       outb(CUResume, sp->ioaddr + SCBCmd);
+       outb ( CUResume, sp->ioaddr + SCBCmd );
 
        /* increment the circular buffer pointer to the next buffer location
         */
-       sp->tx_cur = (sp->tx_cur + 1) % TX_RING_SIZE;
+       sp->tx_cur = ( sp->tx_cur + 1 ) % TX_RING_SIZE;
 
        return 0;
 }
 
-
-
 /*
  * Sometimes the receiver stops making progress.  This routine knows how to
  * get it going again, without losing packets or being otherwise nasty like
@@ -594,44 +600,36 @@ static int speedo_transmit (struct net_device *netdev, struct io_buffer *iobuf)
  * This problem with the old, more involved algorithm is shown up under
  * ping floods on the order of 60K packets/second on a 100Mbps fdx network.
  */
-static void
-speedo_rx_soft_reset(struct net_device *netdev)
-{
+static void speedo_rx_soft_reset ( struct net_device *netdev ) {
        struct speedo_private *sp = netdev->priv;
        int i;
 
-
        DBG("reset\n");
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
        /*
         * Put the hardware into a known state.
         */
-       outb(RX_ABORT, sp->ioaddr + SCBCmd);
+       outb ( RX_ABORT, sp->ioaddr + SCBCmd );
 
-       for (i = 0; i < NUM_RX_DESC; i++) {
+       for ( i = 0; i < NUM_RX_DESC; i++ ) {
                sp->rxfd[i].status      = 0;
                sp->rxfd[i].rx_buf_addr = 0xffffffff;
                sp->rxfd[i].count       = 0;
                sp->rxfd[i].size        = RX_BUF_SIZE;
        }
 
-       wait_for_cmd_done(sp->ioaddr + SCBCmd);
+       wait_for_cmd_done ( sp->ioaddr + SCBCmd );
 
-       outl(virt_to_bus(&sp->rxfd[sp->rx_cur]), sp->ioaddr + SCBPointer);
-       outb(RX_START, sp->ioaddr + SCBCmd);
+       outl ( virt_to_bus ( &sp->rxfd[sp->rx_cur] ), sp->ioaddr + SCBPointer );
+       outb ( RX_START, sp->ioaddr + SCBCmd );
 }
 
-
-
-
-
 /** 
  * Poll for received packets
  *
  * @v netdev   Network device
  */
-static void speedo_poll (struct net_device *netdev)
-{
+static void speedo_poll (struct net_device *netdev) {
        struct speedo_private *sp = netdev->priv;
        uint16_t tx_status;
        unsigned int rx_status;
@@ -639,73 +637,64 @@ static void speedo_poll (struct net_device *netdev)
        unsigned int rx_len;
        struct io_buffer *rx_iob;
        int i;
-       
-       /* read the interrupt register TODO
-        */
-       intr_status = inw (sp->ioaddr + SCBStatus);
-
-       //if (!intr_status)
-       //      goto end;
 
-        //DBG ("eepro/speedo speedo_poll: intr_status = %#08x\n", intr_status);
+       intr_status = inw ( sp->ioaddr + SCBStatus );
+       /* Acknowledge all of the current interrupt sources ASAP. */
+       outw ( intr_status & 0xfc00, sp->ioaddr + SCBStatus );
+       if ( !intr_status )
+               return;
 
        /* Check status of transmitted packets
         */
        i = sp->tx_dirty;
-       while (i != sp->tx_cur) {
+       while (i != sp->tx_cur ) {
                tx_status = sp->txfd[sp->tx_dirty].status;
-
-               DBG ("tx_dirty = %d tx_cur=%d tx_status=%#08x\n",
-                    sp->tx_dirty, sp->tx_cur, tx_status);
-               
+               DBG ( "tx_dirty = %d tx_cur=%d tx_status=%#08x\n",
+                    sp->tx_dirty, sp->tx_cur, tx_status );
                if (( tx_status & StatusComplete ) == 0) 
                        break;
+               netdev_tx_complete ( netdev, sp->tx_iobuf[sp->tx_dirty] );
+               DBG ( "Success transmitting packet\n" );
 
-               netdev_tx_complete (netdev, sp->tx_iobuf[sp->tx_dirty]);
-               DBG ("Success transmitting packet\n");
-
-               sp->tx_dirty = (sp->tx_dirty + 1) % TX_RING_SIZE;
-               i = (i + 1) % TX_RING_SIZE;
+               sp->tx_dirty = ( sp->tx_dirty + 1) % TX_RING_SIZE;
+               i = ( i + 1 ) % TX_RING_SIZE;
        }
-       
        /* Process received packets 
         */
        rx_status = sp->rxfd[sp->rx_cur].status; 
-       while (rx_status) {
+       while ( rx_status ) {
                rx_len = sp->rxfd[sp->rx_cur].count & 0x3fff;
 
-                DBG ("Received packet, rx_curr = %d, rx_status = %#08x, rx_len = %d\n",
-                     sp->rx_cur, rx_status, rx_len);
+                DBG ( "Received packet, rx_curr = %d, rx_status = %#08x, rx_len = %d\n",
+                     sp->rx_cur, rx_status, rx_len );
                /* If unable allocate space for this packet,
                 *  try again next poll
                 */
-               rx_iob = alloc_iob (rx_len);
-               if (! rx_iob
+               rx_iob = alloc_iob ( rx_len );
+               if ( ! rx_iob 
                        break;
-               memcpy (iob_put (rx_iob, rx_len), 
-                       sp->rxfd[sp->rx_cur].packet, rx_len);
+               memcpy ( iob_put (rx_iob, rx_len ), 
+                       sp->rxfd[sp->rx_cur].packet, rx_len );
                /* Add this packet to the receive queue. 
                 */
-               netdev_rx (netdev, rx_iob);
+               netdev_rx ( netdev, rx_iob );
                
                sp->rxfd[sp->rx_cur].status = 0;
                sp->rxfd[sp->rx_cur].command = 0xc000;
                sp->rxfd[sp->rx_cur].rx_buf_addr = 0xFFFFFFFF;
                sp->rxfd[sp->rx_cur].count = 0;
                sp->rxfd[sp->rx_cur].size = RX_BUF_SIZE;
-               sp->rxfd[(sp->rx_cur-1)% NUM_RX_DESC].command = 0;
-               sp->rx_cur = (sp->rx_cur + 1) % NUM_RX_DESC;
+               sp->rxfd[( sp->rx_cur - 1 )% NUM_RX_DESC].command = 0;
+               sp->rx_cur = ( sp->rx_cur + 1 ) % NUM_RX_DESC;
                rx_status = sp->rxfd[sp->rx_cur].status; 
                /* Acknowledge all interrupts */
-               outw(0xff00,sp->ioaddr + SCBStatus);
-
+               outw ( 0xff00,sp->ioaddr + SCBStatus );
        }
-
        /*
         * The chip may have suspended reception for various reasons.
         * Check for that, and re-prime it should this be the case.
         */
-       switch ((inw(sp->ioaddr + SCBStatus) >> 2) & 0xf) {
+       switch (( inw ( sp->ioaddr + SCBStatus ) >> 2) & 0xf) {
                case 0:  /* Idle */
                        break;
                case 1:  /* Suspended */
@@ -713,16 +702,14 @@ static void speedo_poll (struct net_device *netdev)
                case 9:  /* Suspended with no more RBDs */
                case 10: /* No resources due to no RBDs */
                case 12: /* Ready with no RBDs */
-                       speedo_rx_soft_reset(netdev);
+                       speedo_rx_soft_reset ( netdev );
                        break;
                default:
                        /* reserved values */
                        break;
        }
-
 }                              
 
-
 /**
  * Remove PCI device
  *
@@ -731,47 +718,47 @@ static void speedo_poll (struct net_device *netdev)
 static void speedo_remove (struct pci_device *pci) {
         struct net_device *netdev = pci_get_drvdata (pci);
 
-        unregister_netdev (netdev);
-        speedo_disable (netdev);
-        netdev_put (netdev);
+        unregister_netdev ( netdev );
+        speedo_disable ( netdev );
+        netdev_put ( netdev );
 }
 
 
 static struct pci_device_id speedo_nics[] = {
-PCI_ROM(0x8086, 0x1029, "id1029",        "Intel EtherExpressPro100 ID1029"),
-PCI_ROM(0x8086, 0x1030, "id1030",        "Intel EtherExpressPro100 ID1030"),
-PCI_ROM(0x8086, 0x1031, "82801cam",      "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
-PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection"),
-PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection"),
-PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection"),
-PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
-PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
-PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
-PCI_ROM(0x8086, 0x1038, "id1038",        "Intel PRO/100 VM Network Connection"),
-PCI_ROM(0x8086, 0x1039, "82562et",       "Intel PRO100 VE 82562ET"),
-PCI_ROM(0x8086, 0x103a, "id103a",        "Intel Corporation 82559 InBusiness 10/100"),
-PCI_ROM(0x8086, 0x103b, "82562etb",      "Intel PRO100 VE 82562ETB"),
-PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection"),
-PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection"),
-PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection"),
-PCI_ROM(0x8086, 0x1051, "prove",       "Intel PRO/100 VE Network Connection"),
-PCI_ROM(0x8086, 0x1059, "82551qm",       "Intel PRO/100 M Mobile Connection"),
-PCI_ROM(0x8086, 0x1209, "82559er",       "Intel EtherExpressPro100 82559ER"),
-PCI_ROM(0x8086, 0x1227, "82865",         "Intel 82865 EtherExpress PRO/100A"),
-PCI_ROM(0x8086, 0x1228, "82556",         "Intel 82556 EtherExpress PRO/100 Smart"),
-PCI_ROM(0x8086, 0x1229, "eepro100",      "Intel EtherExpressPro100"),
-PCI_ROM(0x8086, 0x2449, "82562em",       "Intel EtherExpressPro100 82562EM"),
-PCI_ROM(0x8086, 0x2459, "82562-1",       "Intel 82562 based Fast Ethernet Connection"),
-PCI_ROM(0x8086, 0x245d, "82562-2",       "Intel 82562 based Fast Ethernet Connection"),
-PCI_ROM(0x8086, 0x1050, "82562ez",       "Intel 82562EZ Network Connection"),
-PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller"),
-PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server"),
-PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server"),
+       PCI_ROM(0x8086, 0x1029, "id1029",        "Intel EtherExpressPro100 ID1029"),
+       PCI_ROM(0x8086, 0x1030, "id1030",        "Intel EtherExpressPro100 ID1030"),
+       PCI_ROM(0x8086, 0x1031, "82801cam",      "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
+       PCI_ROM(0x8086, 0x1032, "eepro100-1032", "Intel PRO/100 VE Network Connection"),
+       PCI_ROM(0x8086, 0x1033, "eepro100-1033", "Intel PRO/100 VM Network Connection"),
+       PCI_ROM(0x8086, 0x1034, "eepro100-1034", "Intel PRO/100 VM Network Connection"),
+       PCI_ROM(0x8086, 0x1035, "eepro100-1035", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),  
+       PCI_ROM(0x8086, 0x1036, "eepro100-1036", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
+       PCI_ROM(0x8086, 0x1037, "eepro100-1037", "Intel 82801CAM (ICH3) Chipset Ethernet Controller"),
+       PCI_ROM(0x8086, 0x1038, "id1038",        "Intel PRO/100 VM Network Connection"),
+       PCI_ROM(0x8086, 0x1039, "82562et",       "Intel PRO100 VE 82562ET"),
+       PCI_ROM(0x8086, 0x103a, "id103a",        "Intel Corporation 82559 InBusiness 10/100"),
+       PCI_ROM(0x8086, 0x103b, "82562etb",      "Intel PRO100 VE 82562ETB"),
+       PCI_ROM(0x8086, 0x103c, "eepro100-103c", "Intel PRO/100 VM Network Connection"),
+       PCI_ROM(0x8086, 0x103d, "eepro100-103d", "Intel PRO/100 VE Network Connection"),
+       PCI_ROM(0x8086, 0x103e, "eepro100-103e", "Intel PRO/100 VM Network Connection"),
+       PCI_ROM(0x8086, 0x1051, "prove",       "Intel PRO/100 VE Network Connection"),
+       PCI_ROM(0x8086, 0x1059, "82551qm",       "Intel PRO/100 M Mobile Connection"),
+       PCI_ROM(0x8086, 0x1209, "82559er",       "Intel EtherExpressPro100 82559ER"),
+       PCI_ROM(0x8086, 0x1227, "82865",         "Intel 82865 EtherExpress PRO/100A"),
+       PCI_ROM(0x8086, 0x1228, "82556",         "Intel 82556 EtherExpress PRO/100 Smart"),
+       PCI_ROM(0x8086, 0x1229, "eepro100",      "Intel EtherExpressPro100"),
+       PCI_ROM(0x8086, 0x2449, "82562em",       "Intel EtherExpressPro100 82562EM"),
+       PCI_ROM(0x8086, 0x2459, "82562-1",       "Intel 82562 based Fast Ethernet Connection"),
+       PCI_ROM(0x8086, 0x245d, "82562-2",       "Intel 82562 based Fast Ethernet Connection"),
+       PCI_ROM(0x8086, 0x1050, "82562ez",       "Intel 82562EZ Network Connection"),
+       PCI_ROM(0x8086, 0x1051, "eepro100-1051", "Intel 82801EB/ER (ICH5/ICH5R) Chipset Ethernet Controller"),
+       PCI_ROM(0x8086, 0x5200, "eepro100-5200", "Intel EtherExpress PRO/100 Intelligent Server"),
+       PCI_ROM(0x8086, 0x5201, "eepro100-5201", "Intel EtherExpress PRO/100 Intelligent Server"),
 };
 
 struct pci_driver epro100_driver __pci_driver = {
        .ids = speedo_nics,
-       .id_count = (sizeof (speedo_nics) / sizeof (speedo_nics[0])),
+       .id_count = ( sizeof ( speedo_nics ) / sizeof ( speedo_nics[0] )),
        .probe = speedo_probe,
        .remove = speedo_remove,
 };