run indent on ar2313 driver
authorFelix Fietkau <nbd@openwrt.org>
Sun, 25 Feb 2007 20:06:27 +0000 (20:06 +0000)
committerFelix Fietkau <nbd@openwrt.org>
Sun, 25 Feb 2007 20:06:27 +0000 (20:06 +0000)
SVN-Revision: 6366

target/linux/atheros-2.6/files/drivers/net/ar2313/ar2313.c
target/linux/atheros-2.6/files/drivers/net/ar2313/ar2313.h
target/linux/atheros-2.6/files/drivers/net/ar2313/dma.h

index 34ba752..8ecfade 100644 (file)
 #define AR2313_BUFSIZE         (AR2313_MTU + ETH_HLEN + CRC_LEN + RX_OFFSET)
 
 #ifdef MODULE
-MODULE_AUTHOR("Sameer Dekate <sdekate@arubanetworks.com>, Imre Kaloz <kaloz@openwrt.org>, Felix Fietkau <nbd@openwrt.org>");
+MODULE_AUTHOR
+       ("Sameer Dekate <sdekate@arubanetworks.com>, Imre Kaloz <kaloz@openwrt.org>, Felix Fietkau <nbd@openwrt.org>");
 MODULE_DESCRIPTION("AR2313 Ethernet driver");
 #endif
 
@@ -144,7 +145,8 @@ MODULE_DESCRIPTION("AR2313 Ethernet driver");
 
 // prototypes
 static short armiiread(struct net_device *dev, short phy, short reg);
-static void armiiwrite(struct net_device *dev, short phy, short reg, short data);
+static void armiiwrite(struct net_device *dev, short phy, short reg,
+                                          short data);
 #ifdef TX_TIMEOUT
 static void ar2313_tx_timeout(struct net_device *dev);
 #endif
@@ -163,13 +165,14 @@ int __init ar2313_probe(struct platform_device *pdev)
        struct ar2313_private *sp;
        struct resource *res;
        unsigned long ar_eth_base;
-       char buf[64] ;
+       char buf[64];
 
        dev = alloc_etherdev(sizeof(struct ar2313_private));
 
        if (dev == NULL) {
-       printk(KERN_ERR "ar2313: Unable to allocate net_device structure!\n");
-       return -ENOMEM;
+               printk(KERN_ERR
+                          "ar2313: Unable to allocate net_device structure!\n");
+               return -ENOMEM;
        }
 
        SET_MODULE_OWNER(dev);
@@ -183,7 +186,7 @@ int __init ar2313_probe(struct platform_device *pdev)
        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
        if (!res)
                return -ENODEV;
-       
+
        sp->link = 0;
        ar_eth_base = res->start;
        sp->phy = sp->cfg->phy;
@@ -212,10 +215,11 @@ int __init ar2313_probe(struct platform_device *pdev)
        tasklet_init(&sp->rx_tasklet, rx_tasklet_func, (unsigned long) dev);
        tasklet_disable(&sp->rx_tasklet);
 
-       sp->eth_regs = ioremap_nocache(virt_to_phys(ar_eth_base), sizeof(*sp->eth_regs));
+       sp->eth_regs =
+               ioremap_nocache(virt_to_phys(ar_eth_base), sizeof(*sp->eth_regs));
        if (!sp->eth_regs) {
                printk("Can't remap eth registers\n");
-               return(-ENXIO);
+               return (-ENXIO);
        }
 
        /* 
@@ -226,49 +230,52 @@ int __init ar2313_probe(struct platform_device *pdev)
        if (virt_to_phys(ar_eth_base) == virt_to_phys(sp->phy_regs))
                sp->phy_regs = sp->eth_regs;
        else {
-               sp->phy_regs = ioremap_nocache(virt_to_phys(sp->cfg->phy_base), sizeof(*sp->phy_regs));
+               sp->phy_regs =
+                       ioremap_nocache(virt_to_phys(sp->cfg->phy_base),
+                                                       sizeof(*sp->phy_regs));
                if (!sp->phy_regs) {
                        printk("Can't remap phy registers\n");
-                       return(-ENXIO);
+                       return (-ENXIO);
                }
        }
 
-       sp->dma_regs = ioremap_nocache(virt_to_phys(ar_eth_base + 0x1000), sizeof(*sp->dma_regs));
+       sp->dma_regs =
+               ioremap_nocache(virt_to_phys(ar_eth_base + 0x1000),
+                                               sizeof(*sp->dma_regs));
        dev->base_addr = (unsigned int) sp->dma_regs;
        if (!sp->dma_regs) {
                printk("Can't remap DMA registers\n");
-               return(-ENXIO);
+               return (-ENXIO);
        }
 
        sp->int_regs = ioremap_nocache(virt_to_phys(sp->cfg->reset_base), 4);
        if (!sp->int_regs) {
                printk("Can't remap INTERRUPT registers\n");
-               return(-ENXIO);
+               return (-ENXIO);
        }
 
-       strncpy(sp->name, "Atheros AR231x", sizeof (sp->name) - 1);
-       sp->name [sizeof (sp->name) - 1] = '\0';
+       strncpy(sp->name, "Atheros AR231x", sizeof(sp->name) - 1);
+       sp->name[sizeof(sp->name) - 1] = '\0';
        memcpy(dev->dev_addr, sp->cfg->macaddr, 6);
        sp->board_idx = BOARD_IDX_STATIC;
 
        if (ar2313_init(dev)) {
-           /*
-            * ar2313_init() calls ar2313_init_cleanup() on error.
-            */
-           kfree(dev);
-           return -ENODEV;
+               /* 
+                * ar2313_init() calls ar2313_init_cleanup() on error.
+                */
+               kfree(dev);
+               return -ENODEV;
        }
 
-       if (register_netdev(dev)){
-         printk("%s: register_netdev failed\n", __func__);
-         return -1;
+       if (register_netdev(dev)) {
+               printk("%s: register_netdev failed\n", __func__);
+               return -1;
        }
 
        printk("%s: %s: %02x:%02x:%02x:%02x:%02x:%02x, irq %d\n",
-              dev->name, sp->name, 
-              dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
-              dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5],
-              dev->irq);
+                  dev->name, sp->name,
+                  dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
+                  dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5], dev->irq);
 
        /* start link poll timer */
        ar2313_setup_timer(dev);
@@ -280,38 +287,38 @@ int __init ar2313_probe(struct platform_device *pdev)
 static void ar2313_dump_regs(struct net_device *dev)
 {
        unsigned int *ptr, i;
-       struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
+       struct ar2313_private *sp = (struct ar2313_private *) dev->priv;
 
-       ptr = (unsigned int *)sp->eth_regs;
-       for(i=0; i< (sizeof(ETHERNET_STRUCT)/ sizeof(unsigned int)); i++, ptr++) {
-           printk("ENET: %08x = %08x\n", (int)ptr, *ptr);
+       ptr = (unsigned int *) sp->eth_regs;
+       for (i = 0; i < (sizeof(ETHERNET_STRUCT) / sizeof(unsigned int));
+                i++, ptr++) {
+               printk("ENET: %08x = %08x\n", (int) ptr, *ptr);
        }
 
-       ptr = (unsigned int *)sp->dma_regs;
-       for(i=0; i< (sizeof(DMA)/ sizeof(unsigned int)); i++, ptr++) {
-           printk("DMA: %08x = %08x\n", (int)ptr, *ptr);
+       ptr = (unsigned int *) sp->dma_regs;
+       for (i = 0; i < (sizeof(DMA) / sizeof(unsigned int)); i++, ptr++) {
+               printk("DMA: %08x = %08x\n", (int) ptr, *ptr);
        }
 
-       ptr = (unsigned int *)sp->int_regs;
-       for(i=0; i< (sizeof(INTERRUPT)/ sizeof(unsigned int)); i++, ptr++){
-           printk("INT: %08x = %08x\n", (int)ptr, *ptr);
+       ptr = (unsigned int *) sp->int_regs;
+       for (i = 0; i < (sizeof(INTERRUPT) / sizeof(unsigned int)); i++, ptr++) {
+               printk("INT: %08x = %08x\n", (int) ptr, *ptr);
        }
 
        for (i = 0; i < AR2313_DESCR_ENTRIES; i++) {
-       ar2313_descr_t *td = &sp->tx_ring[i];
-           printk("Tx desc %2d: %08x %08x %08x %08x\n", i,
-                  td->status, td->devcs, td->addr, td->descr);
+               ar2313_descr_t *td = &sp->tx_ring[i];
+               printk("Tx desc %2d: %08x %08x %08x %08x\n", i,
+                          td->status, td->devcs, td->addr, td->descr);
        }
 }
 #endif
 
 #ifdef TX_TIMEOUT
-static void
-ar2313_tx_timeout(struct net_device *dev)
+static void ar2313_tx_timeout(struct net_device *dev)
 {
-       struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
+       struct ar2313_private *sp = (struct ar2313_private *) dev->priv;
        unsigned long flags;
-       
+
 #if DEBUG_TX
        printk("Tx timeout\n");
 #endif
@@ -322,17 +329,16 @@ ar2313_tx_timeout(struct net_device *dev)
 #endif
 
 #if DEBUG_MC
-static void
-printMcList(struct net_device *dev)
+static void printMcList(struct net_device *dev)
 {
        struct dev_mc_list *list = dev->mc_list;
-       int num=0, i;
-       while(list){
+       int num = 0, i;
+       while (list) {
                printk("%d MC ADDR ", num);
-               for(i=0;i<list->dmi_addrlen;i++) {
-                   printk(":%02x", list->dmi_addr[i]);
+               for (i = 0; i < list->dmi_addrlen; i++) {
+                       printk(":%02x", list->dmi_addr[i]);
                }
-       list = list->next;
+               list = list->next;
                printk("\n");
        }
 }
@@ -342,19 +348,18 @@ printMcList(struct net_device *dev)
  * Set or clear the multicast filter for this adaptor.
  * THIS IS ABSOLUTE CRAP, disabled
  */
-static void
-ar2313_multicast_list(struct net_device *dev)
-{   
+static void ar2313_multicast_list(struct net_device *dev)
+{
        /* 
         * Always listen to broadcasts and 
         * treat IFF bits independently 
         */
-       struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
+       struct ar2313_private *sp = (struct ar2313_private *) dev->priv;
        unsigned int recognise;
 
        recognise = sp->eth_regs->mac_control;
 
-       if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
+       if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
                recognise |= MAC_CONTROL_PR;
        } else {
                recognise &= ~MAC_CONTROL_PR;
@@ -362,21 +367,23 @@ ar2313_multicast_list(struct net_device *dev)
 
        if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 15)) {
 #if DEBUG_MC
-       printMcList(dev);
-               printk("%s: all MULTICAST mc_count %d\n", __FUNCTION__, dev->mc_count);
+               printMcList(dev);
+               printk("%s: all MULTICAST mc_count %d\n", __FUNCTION__,
+                          dev->mc_count);
 #endif
-               recognise |= MAC_CONTROL_PM;/* all multicast */
+               recognise |= MAC_CONTROL_PM;    /* all multicast */
        } else if (dev->mc_count > 0) {
 #if DEBUG_MC
-       printMcList(dev);
+               printMcList(dev);
                printk("%s: mc_count %d\n", __FUNCTION__, dev->mc_count);
 #endif
-               recognise |= MAC_CONTROL_PM; /* for the time being */
+               recognise |= MAC_CONTROL_PM;    /* for the time being */
        }
 #if DEBUG_MC
-       printk("%s: setting %08x to %08x\n", __FUNCTION__, (int)sp->eth_regs, recognise);
+       printk("%s: setting %08x to %08x\n", __FUNCTION__, (int) sp->eth_regs,
+                  recognise);
 #endif
-       
+
        sp->eth_regs->mac_control = recognise;
 }
 
@@ -384,7 +391,7 @@ static void rx_tasklet_cleanup(struct net_device *dev)
 {
        struct ar2313_private *sp = dev->priv;
 
-       /*
+       /* 
         * Tasklet may be scheduled. Need to get it removed from the list
         * since we're about to free the struct.
         */
@@ -415,13 +422,13 @@ static int ar2313_restart(struct net_device *dev)
 
        /* stop mac */
        ar2313_halt(dev);
-       
+
        /* initialize */
        ar2313_init(dev);
-       
+
        /* enable interrupts */
        enable_irq(dev->irq);
-       
+
        return 0;
 }
 
@@ -449,9 +456,9 @@ static void ar2313_free_descriptors(struct net_device *dev)
 {
        struct ar2313_private *sp = dev->priv;
        if (sp->rx_ring != NULL) {
-       kfree((void*)KSEG0ADDR(sp->rx_ring));
-       sp->rx_ring = NULL;
-       sp->tx_ring = NULL;
+               kfree((void *) KSEG0ADDR(sp->rx_ring));
+               sp->rx_ring = NULL;
+               sp->tx_ring = NULL;
        }
 }
 
@@ -463,23 +470,24 @@ static int ar2313_allocate_descriptors(struct net_device *dev)
        int j;
        ar2313_descr_t *space;
 
-       if(sp->rx_ring != NULL){
-       printk("%s: already done.\n", __FUNCTION__);
-       return 0;
+       if (sp->rx_ring != NULL) {
+               printk("%s: already done.\n", __FUNCTION__);
+               return 0;
        }
 
-       size = (sizeof(ar2313_descr_t) * (AR2313_DESCR_ENTRIES * AR2313_QUEUES));
+       size =
+               (sizeof(ar2313_descr_t) * (AR2313_DESCR_ENTRIES * AR2313_QUEUES));
        space = kmalloc(size, GFP_KERNEL);
        if (space == NULL)
-           return 1;
+               return 1;
 
        /* invalidate caches */
-       dma_cache_inv((unsigned int)space, size);
+       dma_cache_inv((unsigned int) space, size);
 
        /* now convert pointer to KSEG1 */
-       space = (ar2313_descr_t *)KSEG1ADDR(space);
+       space = (ar2313_descr_t *) KSEG1ADDR(space);
 
-       memset((void *)space, 0, size);
+       memset((void *) space, 0, size);
 
        sp->rx_ring = space;
        space += AR2313_DESCR_ENTRIES;
@@ -489,11 +497,13 @@ static int ar2313_allocate_descriptors(struct net_device *dev)
 
        /* Initialize the transmit Descriptors */
        for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
-       ar2313_descr_t *td = &sp->tx_ring[j];
-       td->status = 0;
-       td->devcs  = DMA_TX1_CHAINED;
-       td->addr   = 0;
-       td->descr  = virt_to_phys(&sp->tx_ring[(j+1) & (AR2313_DESCR_ENTRIES-1)]);
+               ar2313_descr_t *td = &sp->tx_ring[j];
+               td->status = 0;
+               td->devcs = DMA_TX1_CHAINED;
+               td->addr = 0;
+               td->descr =
+                       virt_to_phys(&sp->
+                                                tx_ring[(j + 1) & (AR2313_DESCR_ENTRIES - 1)]);
        }
 
        return 0;
@@ -512,37 +522,39 @@ static void ar2313_init_cleanup(struct net_device *dev)
 
        ar2313_free_descriptors(dev);
 
-       if (sp->eth_regs) iounmap((void*)sp->eth_regs);
-       if (sp->dma_regs) iounmap((void*)sp->dma_regs);
+       if (sp->eth_regs)
+               iounmap((void *) sp->eth_regs);
+       if (sp->dma_regs)
+               iounmap((void *) sp->dma_regs);
 
        if (sp->rx_skb) {
-       for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
-           skb = sp->rx_skb[j];
-           if (skb) {
-               sp->rx_skb[j] = NULL;
-               dev_kfree_skb(skb);
-           }
-       }
-       kfree(sp->rx_skb);
-       sp->rx_skb = NULL;
+               for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
+                       skb = sp->rx_skb[j];
+                       if (skb) {
+                               sp->rx_skb[j] = NULL;
+                               dev_kfree_skb(skb);
+                       }
+               }
+               kfree(sp->rx_skb);
+               sp->rx_skb = NULL;
        }
 
        if (sp->tx_skb) {
-       for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
-           skb = sp->tx_skb[j];
-           if (skb) {
-               sp->tx_skb[j] = NULL;
-               dev_kfree_skb(skb);
-           }
-       }
-       kfree(sp->tx_skb);
-       sp->tx_skb = NULL;
+               for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
+                       skb = sp->tx_skb[j];
+                       if (skb) {
+                               sp->tx_skb[j] = NULL;
+                               dev_kfree_skb(skb);
+                       }
+               }
+               kfree(sp->tx_skb);
+               sp->tx_skb = NULL;
        }
 }
 
 static int ar2313_setup_timer(struct net_device *dev)
 {
-       struct ar2313_private *sp = dev->priv; 
+       struct ar2313_private *sp = dev->priv;
 
        init_timer(&sp->link_timer);
 
@@ -558,17 +570,17 @@ static int ar2313_setup_timer(struct net_device *dev)
 static void ar2313_link_timer_fn(unsigned long data)
 {
        struct net_device *dev = (struct net_device *) data;
-       struct ar2313_private *sp = dev->priv; 
+       struct ar2313_private *sp = dev->priv;
 
        // see if the link status changed
        // This was needed to make sure we set the PHY to the
        // autonegotiated value of half or full duplex.
        ar2313_check_link(dev);
-       
+
        // Loop faster when we don't have link. 
        // This was needed to speed up the AP bootstrap time.
-       if(sp->link == 0) {
-               mod_timer(&sp->link_timer, jiffies + HZ/2);
+       if (sp->link == 0) {
+               mod_timer(&sp->link_timer, jiffies + HZ / 2);
        } else {
                mod_timer(&sp->link_timer, jiffies + LINK_TIMER);
        }
@@ -581,46 +593,48 @@ static void ar2313_check_link(struct net_device *dev)
 
        phyData = armiiread(dev, sp->phy, MII_BMSR);
        if (sp->phyData != phyData) {
-       if (phyData & BMSR_LSTATUS) {
-               /* link is present, ready link partner ability to deterine duplexity */
-               int duplex = 0;
-               u16 reg;
-
-               sp->link = 1;
-               reg = armiiread(dev, sp->phy, MII_BMCR);
-               if (reg & BMCR_ANENABLE) {
-                   /* auto neg enabled */
-                   reg = armiiread(dev, sp->phy, MII_LPA);
-                   duplex = (reg & (LPA_100FULL|LPA_10FULL))? 1:0;
-               } else {
-                   /* no auto neg, just read duplex config */
-                   duplex = (reg & BMCR_FULLDPLX)? 1:0;
-               }
-
-               printk(KERN_INFO "%s: Configuring MAC for %s duplex\n", dev->name,
-                      (duplex)? "full":"half");
-
-               if (duplex) {
-                   /* full duplex */
-                   sp->eth_regs->mac_control = ((sp->eth_regs->mac_control | MAC_CONTROL_F) &
-                                                ~MAC_CONTROL_DRO);
-               } else {
-                   /* half duplex */
-                   sp->eth_regs->mac_control = ((sp->eth_regs->mac_control | MAC_CONTROL_DRO) &
-                                                ~MAC_CONTROL_F);
-               }
+               if (phyData & BMSR_LSTATUS) {
+                       /* link is present, ready link partner ability to deterine
+                          duplexity */
+                       int duplex = 0;
+                       u16 reg;
+
+                       sp->link = 1;
+                       reg = armiiread(dev, sp->phy, MII_BMCR);
+                       if (reg & BMCR_ANENABLE) {
+                               /* auto neg enabled */
+                               reg = armiiread(dev, sp->phy, MII_LPA);
+                               duplex = (reg & (LPA_100FULL | LPA_10FULL)) ? 1 : 0;
+                       } else {
+                               /* no auto neg, just read duplex config */
+                               duplex = (reg & BMCR_FULLDPLX) ? 1 : 0;
+                       }
+
+                       printk(KERN_INFO "%s: Configuring MAC for %s duplex\n",
+                                  dev->name, (duplex) ? "full" : "half");
+
+                       if (duplex) {
+                               /* full duplex */
+                               sp->eth_regs->mac_control =
+                                       ((sp->eth_regs->
+                                         mac_control | MAC_CONTROL_F) & ~MAC_CONTROL_DRO);
+                       } else {
+                               /* half duplex */
+                               sp->eth_regs->mac_control =
+                                       ((sp->eth_regs->
+                                         mac_control | MAC_CONTROL_DRO) & ~MAC_CONTROL_F);
+                       }
                } else {
-               /* no link */
-               sp->link = 0;
+                       /* no link */
+                       sp->link = 0;
                }
-           sp->phyData = phyData;
+               sp->phyData = phyData;
        }
 }
-  
-static int
-ar2313_reset_reg(struct net_device *dev)
+
+static int ar2313_reset_reg(struct net_device *dev)
 {
-       struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
+       struct ar2313_private *sp = (struct ar2313_private *) dev->priv;
        unsigned int ethsal, ethsah;
        unsigned int flags;
 
@@ -635,91 +649,96 @@ ar2313_reset_reg(struct net_device *dev)
 
        sp->dma_regs->bus_mode = (DMA_BUS_MODE_SWR);
        mdelay(10);
-       sp->dma_regs->bus_mode = ((32 << DMA_BUS_MODE_PBL_SHIFT) | DMA_BUS_MODE_BLE);
+       sp->dma_regs->bus_mode =
+               ((32 << DMA_BUS_MODE_PBL_SHIFT) | DMA_BUS_MODE_BLE);
 
        /* enable interrupts */
        sp->dma_regs->intr_ena = (DMA_STATUS_AIS |
-                             DMA_STATUS_NIS |
-                             DMA_STATUS_RI  |
-                             DMA_STATUS_TI  |
-                             DMA_STATUS_FBE);
+                                                         DMA_STATUS_NIS |
+                                                         DMA_STATUS_RI |
+                                                         DMA_STATUS_TI | DMA_STATUS_FBE);
        sp->dma_regs->xmt_base = virt_to_phys(sp->tx_ring);
        sp->dma_regs->rcv_base = virt_to_phys(sp->rx_ring);
-       sp->dma_regs->control = (DMA_CONTROL_SR | DMA_CONTROL_ST | DMA_CONTROL_SF);
-       
+       sp->dma_regs->control =
+               (DMA_CONTROL_SR | DMA_CONTROL_ST | DMA_CONTROL_SF);
+
        sp->eth_regs->flow_control = (FLOW_CONTROL_FCE);
        sp->eth_regs->vlan_tag = (0x8100);
 
        /* Enable Ethernet Interface */
-       flags = (MAC_CONTROL_TE  | /* transmit enable */
-            MAC_CONTROL_PM  | /* pass mcast */
-            MAC_CONTROL_F   | /* full duplex */
-            MAC_CONTROL_HBD); /* heart beat disabled */
+       flags = (MAC_CONTROL_TE |       /* transmit enable */
+                        MAC_CONTROL_PM |       /* pass mcast */
+                        MAC_CONTROL_F |        /* full duplex */
+                        MAC_CONTROL_HBD);      /* heart beat disabled */
 
-       if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
-       flags |= MAC_CONTROL_PR;
+       if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
+               flags |= MAC_CONTROL_PR;
        }
        sp->eth_regs->mac_control = flags;
 
        /* Set all Ethernet station address registers to their initial values */
-       ethsah = ((((u_int)(dev->dev_addr[5]) << 8) & (u_int)0x0000FF00) |
-             (((u_int)(dev->dev_addr[4]) << 0) & (u_int)0x000000FF));
+       ethsah = ((((u_int) (dev->dev_addr[5]) << 8) & (u_int) 0x0000FF00) |
+                         (((u_int) (dev->dev_addr[4]) << 0) & (u_int) 0x000000FF));
 
-       ethsal = ((((u_int)(dev->dev_addr[3]) << 24) & (u_int)0xFF000000) |
-                 (((u_int)(dev->dev_addr[2]) << 16) & (u_int)0x00FF0000) |
-                 (((u_int)(dev->dev_addr[1]) <<  8) & (u_int)0x0000FF00) |
-                 (((u_int)(dev->dev_addr[0]) <<  0) & (u_int)0x000000FF) );
+       ethsal = ((((u_int) (dev->dev_addr[3]) << 24) & (u_int) 0xFF000000) |
+                         (((u_int) (dev->dev_addr[2]) << 16) & (u_int) 0x00FF0000) |
+                         (((u_int) (dev->dev_addr[1]) << 8) & (u_int) 0x0000FF00) |
+                         (((u_int) (dev->dev_addr[0]) << 0) & (u_int) 0x000000FF));
 
        sp->eth_regs->mac_addr[0] = ethsah;
        sp->eth_regs->mac_addr[1] = ethsal;
 
        mdelay(10);
 
-       return(0);
+       return (0);
 }
 
 
 static int ar2313_init(struct net_device *dev)
 {
        struct ar2313_private *sp = dev->priv;
-       int ecode=0;
+       int ecode = 0;
 
-       /*
+       /* 
         * Allocate descriptors
         */
        if (ar2313_allocate_descriptors(dev)) {
-       printk("%s: %s: ar2313_allocate_descriptors failed\n", 
-                       dev->name, __FUNCTION__);
-       ecode = -EAGAIN;
-           goto init_error;
+               printk("%s: %s: ar2313_allocate_descriptors failed\n",
+                          dev->name, __FUNCTION__);
+               ecode = -EAGAIN;
+               goto init_error;
        }
 
-       /*
+       /* 
         * Get the memory for the skb rings.
         */
-       if(sp->rx_skb == NULL) {
-       sp->rx_skb = kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES, GFP_KERNEL);
-       if (!(sp->rx_skb)) {
-           printk("%s: %s: rx_skb kmalloc failed\n", 
-                           dev->name, __FUNCTION__);
-           ecode = -EAGAIN;
-           goto init_error;
-       }
+       if (sp->rx_skb == NULL) {
+               sp->rx_skb =
+                       kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES,
+                                       GFP_KERNEL);
+               if (!(sp->rx_skb)) {
+                       printk("%s: %s: rx_skb kmalloc failed\n",
+                                  dev->name, __FUNCTION__);
+                       ecode = -EAGAIN;
+                       goto init_error;
+               }
        }
        memset(sp->rx_skb, 0, sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES);
 
-       if(sp->tx_skb == NULL) {
-       sp->tx_skb = kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES, GFP_KERNEL);
-       if (!(sp->tx_skb)) {
-           printk("%s: %s: tx_skb kmalloc failed\n", 
-                           dev->name, __FUNCTION__);
-           ecode = -EAGAIN;
-           goto init_error;
-       }
+       if (sp->tx_skb == NULL) {
+               sp->tx_skb =
+                       kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES,
+                                       GFP_KERNEL);
+               if (!(sp->tx_skb)) {
+                       printk("%s: %s: tx_skb kmalloc failed\n",
+                                  dev->name, __FUNCTION__);
+                       ecode = -EAGAIN;
+                       goto init_error;
+               }
        }
        memset(sp->tx_skb, 0, sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES);
 
-       /*
+       /* 
         * Set tx_csm before we start receiving interrupts, otherwise
         * the interrupt handler might think it is supposed to process
         * tx ints before we are up and running, which may cause a null
@@ -730,12 +749,12 @@ static int ar2313_init(struct net_device *dev)
        sp->tx_prd = 0;
        sp->tx_csm = 0;
 
-       /*
+       /* 
         * Zero the stats before starting the interface
         */
        memset(&sp->stats, 0, sizeof(sp->stats));
 
-       /*
+       /* 
         * We load the ring here as there seem to be no way to tell the
         * firmware to wipe the ring without re-initializing it.
         */
@@ -746,14 +765,17 @@ static int ar2313_init(struct net_device *dev)
         */
        ar2313_reset_reg(dev);
 
-       /*
+       /* 
         * Get the IRQ
         */
-       ecode = request_irq(dev->irq, &ar2313_interrupt, IRQF_SHARED | IRQF_DISABLED | IRQF_SAMPLE_RANDOM, dev->name, dev);
+       ecode =
+               request_irq(dev->irq, &ar2313_interrupt,
+                                       IRQF_SHARED | IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+                                       dev->name, dev);
        if (ecode) {
-           printk(KERN_WARNING "%s: %s: Requested IRQ %d is busy\n",
-              dev->name, __FUNCTION__, dev->irq);
-       goto init_error;
+               printk(KERN_WARNING "%s: %s: Requested IRQ %d is busy\n",
+                          dev->name, __FUNCTION__, dev->irq);
+               goto init_error;
        }
 
 
@@ -761,7 +783,7 @@ static int ar2313_init(struct net_device *dev)
 
        return 0;
 
- init_error:
 init_error:
        ar2313_init_cleanup(dev);
        return ecode;
 }
@@ -776,56 +798,59 @@ static int ar2313_init(struct net_device *dev)
 static void ar2313_load_rx_ring(struct net_device *dev, int nr_bufs)
 {
 
-       struct ar2313_private *sp = ((struct net_device *)dev)->priv;
+       struct ar2313_private *sp = ((struct net_device *) dev)->priv;
        short i, idx;
 
        idx = sp->rx_skbprd;
 
        for (i = 0; i < nr_bufs; i++) {
-           struct sk_buff *skb;
-       ar2313_descr_t *rd;
+               struct sk_buff *skb;
+               ar2313_descr_t *rd;
 
-       if (sp->rx_skb[idx]) {
+               if (sp->rx_skb[idx]) {
 #if DEBUG_RX
-           printk(KERN_INFO "ar2313 rx refill full\n");
-#endif /* DEBUG */
-           break;
-       }
-
-           // partha: create additional room for the second GRE fragment
-       skb = alloc_skb(AR2313_BUFSIZE+128, GFP_ATOMIC);
-       if (!skb) {
-           printk("\n\n\n\n %s: No memory in system\n\n\n\n", __FUNCTION__);
-           break;
-       }
-           // partha: create additional room in the front for tx pkt capture
-           skb_reserve(skb, 32);
-
-       /*
-        * Make sure IP header starts on a fresh cache line.
-        */
-       skb->dev = dev;
-       skb_reserve(skb, RX_OFFSET);
-       sp->rx_skb[idx] = skb;
-
-       rd = (ar2313_descr_t *) &sp->rx_ring[idx];
-
-       /* initialize dma descriptor */
-       rd->devcs  = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
-                         DMA_RX1_CHAINED);
-       rd->addr   = virt_to_phys(skb->data);
-       rd->descr  = virt_to_phys(&sp->rx_ring[(idx+1) & (AR2313_DESCR_ENTRIES-1)]);
-       rd->status = DMA_RX_OWN;
-
-       idx = DSC_NEXT(idx);
+                       printk(KERN_INFO "ar2313 rx refill full\n");
+#endif                                                 /* DEBUG */
+                       break;
+               }
+               // partha: create additional room for the second GRE fragment
+               skb = alloc_skb(AR2313_BUFSIZE + 128, GFP_ATOMIC);
+               if (!skb) {
+                       printk("\n\n\n\n %s: No memory in system\n\n\n\n",
+                                  __FUNCTION__);
+                       break;
+               }
+               // partha: create additional room in the front for tx pkt capture
+               skb_reserve(skb, 32);
+
+               /* 
+                * Make sure IP header starts on a fresh cache line.
+                */
+               skb->dev = dev;
+               skb_reserve(skb, RX_OFFSET);
+               sp->rx_skb[idx] = skb;
+
+               rd = (ar2313_descr_t *) & sp->rx_ring[idx];
+
+               /* initialize dma descriptor */
+               rd->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
+                                        DMA_RX1_CHAINED);
+               rd->addr = virt_to_phys(skb->data);
+               rd->descr =
+                       virt_to_phys(&sp->
+                                                rx_ring[(idx + 1) & (AR2313_DESCR_ENTRIES - 1)]);
+               rd->status = DMA_RX_OWN;
+
+               idx = DSC_NEXT(idx);
        }
 
        if (!i) {
 #if DEBUG_ERR
-           printk(KERN_INFO "Out of memory when allocating standard receive buffers\n");
-#endif /* DEBUG */
+               printk(KERN_INFO
+                          "Out of memory when allocating standard receive buffers\n");
+#endif                                                 /* DEBUG */
        } else {
-       sp->rx_skbprd = idx;
+               sp->rx_skbprd = idx;
        }
 
        return;
@@ -845,78 +870,83 @@ static int ar2313_rx_int(struct net_device *dev)
 
        idx = sp->cur_rx;
 
-       /* process at most the entire ring and then wait for another interrupt */
-       while(1) {
-
-       rxdesc = &sp->rx_ring[idx];
-       status = rxdesc->status;
-       if (status & DMA_RX_OWN) {
-           /* SiByte owns descriptor or descr not yet filled in */
-               rval = 0;
-           break;
-       }
-
-           if (++pkts > AR2313_MAX_PKTS_PER_CALL) {
-               rval = 1;
-               break;
-           }
+       /* process at most the entire ring and then wait for another interrupt 
+        */
+       while (1) {
+
+               rxdesc = &sp->rx_ring[idx];
+               status = rxdesc->status;
+               if (status & DMA_RX_OWN) {
+                       /* SiByte owns descriptor or descr not yet filled in */
+                       rval = 0;
+                       break;
+               }
 
+               if (++pkts > AR2313_MAX_PKTS_PER_CALL) {
+                       rval = 1;
+                       break;
+               }
 #if DEBUG_RX
-       printk("index %d\n", idx);
-       printk("RX status %08x\n", rxdesc->status);
-       printk("RX devcs  %08x\n", rxdesc->devcs );
-       printk("RX addr   %08x\n", rxdesc->addr  );
-       printk("RX descr  %08x\n", rxdesc->descr );
+               printk("index %d\n", idx);
+               printk("RX status %08x\n", rxdesc->status);
+               printk("RX devcs  %08x\n", rxdesc->devcs);
+               printk("RX addr   %08x\n", rxdesc->addr);
+               printk("RX descr  %08x\n", rxdesc->descr);
 #endif
 
-           if ((status & (DMA_RX_ERROR|DMA_RX_ERR_LENGTH)) &&
-           (!(status & DMA_RX_LONG))){
+               if ((status & (DMA_RX_ERROR | DMA_RX_ERR_LENGTH)) &&
+                       (!(status & DMA_RX_LONG))) {
 #if DEBUG_RX
-           printk("%s: rx ERROR %08x\n", __FUNCTION__, status);
+                       printk("%s: rx ERROR %08x\n", __FUNCTION__, status);
 #endif
-           sp->stats.rx_errors++;
-           sp->stats.rx_dropped++;
+                       sp->stats.rx_errors++;
+                       sp->stats.rx_dropped++;
 
-           /* add statistics counters */
-           if (status & DMA_RX_ERR_CRC)    sp->stats.rx_crc_errors++;
-           if (status & DMA_RX_ERR_COL)    sp->stats.rx_over_errors++;
-           if (status & DMA_RX_ERR_LENGTH)
-                   sp->stats.rx_length_errors++;
-           if (status & DMA_RX_ERR_RUNT)   sp->stats.rx_over_errors++;
-           if (status & DMA_RX_ERR_DESC)   sp->stats.rx_over_errors++;
+                       /* add statistics counters */
+                       if (status & DMA_RX_ERR_CRC)
+                               sp->stats.rx_crc_errors++;
+                       if (status & DMA_RX_ERR_COL)
+                               sp->stats.rx_over_errors++;
+                       if (status & DMA_RX_ERR_LENGTH)
+                               sp->stats.rx_length_errors++;
+                       if (status & DMA_RX_ERR_RUNT)
+                               sp->stats.rx_over_errors++;
+                       if (status & DMA_RX_ERR_DESC)
+                               sp->stats.rx_over_errors++;
 
-       } else {
-           /* alloc new buffer. */
-           skb_new = dev_alloc_skb(AR2313_BUFSIZE + RX_OFFSET + 128);
-           if (skb_new != NULL) {
-
-               skb = sp->rx_skb[idx];
-               /* set skb */
-               skb_put(skb, ((status >> DMA_RX_LEN_SHIFT) & 0x3fff) - CRC_LEN);
-
-               sp->stats.rx_bytes += skb->len;
-               skb->protocol = eth_type_trans(skb, dev);
-               /* pass the packet to upper layers */
-               netif_rx(skb);
-
-               skb_new->dev = dev;
-               /* 16 bit align */
-               skb_reserve(skb_new, RX_OFFSET+32);
-               /* reset descriptor's curr_addr */
-               rxdesc->addr = virt_to_phys(skb_new->data); 
-
-               sp->stats.rx_packets++;
-               sp->rx_skb[idx] = skb_new;
-           } else {
-                       sp->stats.rx_dropped++;
-           }
-       }
+               } else {
+                       /* alloc new buffer. */
+                       skb_new = dev_alloc_skb(AR2313_BUFSIZE + RX_OFFSET + 128);
+                       if (skb_new != NULL) {
+
+                               skb = sp->rx_skb[idx];
+                               /* set skb */
+                               skb_put(skb,
+                                               ((status >> DMA_RX_LEN_SHIFT) & 0x3fff) - CRC_LEN);
+
+                               sp->stats.rx_bytes += skb->len;
+                               skb->protocol = eth_type_trans(skb, dev);
+                               /* pass the packet to upper layers */
+                               netif_rx(skb);
+
+                               skb_new->dev = dev;
+                               /* 16 bit align */
+                               skb_reserve(skb_new, RX_OFFSET + 32);
+                               /* reset descriptor's curr_addr */
+                               rxdesc->addr = virt_to_phys(skb_new->data);
+
+                               sp->stats.rx_packets++;
+                               sp->rx_skb[idx] = skb_new;
+                       } else {
+                               sp->stats.rx_dropped++;
+                       }
+               }
 
-       rxdesc->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) | 
-                            DMA_RX1_CHAINED);
-       rxdesc->status = DMA_RX_OWN;
+               rxdesc->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
+                                                DMA_RX1_CHAINED);
+               rxdesc->status = DMA_RX_OWN;
 
-       idx = DSC_NEXT(idx);
+               idx = DSC_NEXT(idx);
        }
 
        sp->cur_rx = idx;
@@ -931,53 +961,54 @@ static void ar2313_tx_int(struct net_device *dev)
        u32 idx;
        struct sk_buff *skb;
        ar2313_descr_t *txdesc;
-       unsigned int status=0;
+       unsigned int status = 0;
 
        idx = sp->tx_csm;
 
        while (idx != sp->tx_prd) {
 
-       txdesc = &sp->tx_ring[idx];
+               txdesc = &sp->tx_ring[idx];
 
 #if DEBUG_TX
-       printk("%s: TXINT: csm=%d idx=%d prd=%d status=%x devcs=%x addr=%08x descr=%x\n", 
-               dev->name, sp->tx_csm, idx, sp->tx_prd,
-               txdesc->status, txdesc->devcs, txdesc->addr, txdesc->descr);
-#endif /* DEBUG */
-
-       if ((status = txdesc->status) & DMA_TX_OWN) {
-           /* ar2313 dma still owns descr */
-           break;
-       }
-       /* done with this descriptor */
-       dma_unmap_single(NULL, txdesc->addr, txdesc->devcs & DMA_TX1_BSIZE_MASK, DMA_TO_DEVICE);
-       txdesc->status = 0;
-
-       if (status & DMA_TX_ERROR){
-               sp->stats.tx_errors++;
-               sp->stats.tx_dropped++;
-               if(status & DMA_TX_ERR_UNDER)
-                       sp->stats.tx_fifo_errors++;
-               if(status & DMA_TX_ERR_HB)
-                       sp->stats.tx_heartbeat_errors++;
-               if(status & (DMA_TX_ERR_LOSS |
-                                DMA_TX_ERR_LINK))
-                       sp->stats.tx_carrier_errors++;
-                   if (status & (DMA_TX_ERR_LATE|
-                                 DMA_TX_ERR_COL |
-                                 DMA_TX_ERR_JABBER |
-                                 DMA_TX_ERR_DEFER))
-                       sp->stats.tx_aborted_errors++;
-       } else {
-               /* transmit OK */
-               sp->stats.tx_packets++;
-       }
+               printk
+                       ("%s: TXINT: csm=%d idx=%d prd=%d status=%x devcs=%x addr=%08x descr=%x\n",
+                        dev->name, sp->tx_csm, idx, sp->tx_prd, txdesc->status,
+                        txdesc->devcs, txdesc->addr, txdesc->descr);
+#endif                                                 /* DEBUG */
+
+               if ((status = txdesc->status) & DMA_TX_OWN) {
+                       /* ar2313 dma still owns descr */
+                       break;
+               }
+               /* done with this descriptor */
+               dma_unmap_single(NULL, txdesc->addr,
+                                                txdesc->devcs & DMA_TX1_BSIZE_MASK,
+                                                DMA_TO_DEVICE);
+               txdesc->status = 0;
+
+               if (status & DMA_TX_ERROR) {
+                       sp->stats.tx_errors++;
+                       sp->stats.tx_dropped++;
+                       if (status & DMA_TX_ERR_UNDER)
+                               sp->stats.tx_fifo_errors++;
+                       if (status & DMA_TX_ERR_HB)
+                               sp->stats.tx_heartbeat_errors++;
+                       if (status & (DMA_TX_ERR_LOSS | DMA_TX_ERR_LINK))
+                               sp->stats.tx_carrier_errors++;
+                       if (status & (DMA_TX_ERR_LATE |
+                                                 DMA_TX_ERR_COL |
+                                                 DMA_TX_ERR_JABBER | DMA_TX_ERR_DEFER))
+                               sp->stats.tx_aborted_errors++;
+               } else {
+                       /* transmit OK */
+                       sp->stats.tx_packets++;
+               }
 
-       skb = sp->tx_skb[idx];
-       sp->tx_skb[idx] = NULL;
-       idx = DSC_NEXT(idx);
-       sp->stats.tx_bytes += skb->len;
-       dev_kfree_skb_irq(skb);
+               skb = sp->tx_skb[idx];
+               sp->tx_skb[idx] = NULL;
+               idx = DSC_NEXT(idx);
+               sp->stats.tx_bytes += skb->len;
+               dev_kfree_skb_irq(skb);
        }
 
        sp->tx_csm = idx;
@@ -986,29 +1017,26 @@ static void ar2313_tx_int(struct net_device *dev)
 }
 
 
-static void
-rx_tasklet_func(unsigned long data)
+static void rx_tasklet_func(unsigned long data)
 {
        struct net_device *dev = (struct net_device *) data;
        struct ar2313_private *sp = dev->priv;
 
        if (sp->unloading) {
-           return;
+               return;
        }
 
-           if (ar2313_rx_int(dev)) {
-               tasklet_hi_schedule(&sp->rx_tasklet);
-           }
-           else {
-               unsigned long flags;
-               spin_lock_irqsave(&sp->lock, flags);
-               sp->dma_regs->intr_ena |= DMA_STATUS_RI;
-               spin_unlock_irqrestore(&sp->lock, flags);
-           }
+       if (ar2313_rx_int(dev)) {
+               tasklet_hi_schedule(&sp->rx_tasklet);
+       } else {
+               unsigned long flags;
+               spin_lock_irqsave(&sp->lock, flags);
+               sp->dma_regs->intr_ena |= DMA_STATUS_RI;
+               spin_unlock_irqrestore(&sp->lock, flags);
+       }
 }
 
-static void
-rx_schedule(struct net_device *dev)
+static void rx_schedule(struct net_device *dev)
 {
        struct ar2313_private *sp = dev->priv;
 
@@ -1019,12 +1047,12 @@ rx_schedule(struct net_device *dev)
 
 static irqreturn_t ar2313_interrupt(int irq, void *dev_id)
 {
-       struct net_device *dev = (struct net_device *)dev_id;
+       struct net_device *dev = (struct net_device *) dev_id;
        struct ar2313_private *sp = dev->priv;
        unsigned int status, enabled;
 
        /* clear interrupt */
-       /*
+       /* 
         * Don't clear RI bit if currently disabled.
         */
        status = sp->dma_regs->status;
@@ -1032,30 +1060,30 @@ static irqreturn_t ar2313_interrupt(int irq, void *dev_id)
        sp->dma_regs->status = status & enabled;
 
        if (status & DMA_STATUS_NIS) {
-       /* normal status */
-           /*
-            * Don't schedule rx processing if interrupt
-            * is already disabled.
-            */
-       if (status & enabled & DMA_STATUS_RI) {
-           /* receive interrupt */
-           rx_schedule(dev);
-       }
-       if (status & DMA_STATUS_TI) {
-          /* transmit interrupt */
-           ar2313_tx_int(dev);
-       }
+               /* normal status */
+               /* 
+                * Don't schedule rx processing if interrupt
+                * is already disabled.
+                */
+               if (status & enabled & DMA_STATUS_RI) {
+                       /* receive interrupt */
+                       rx_schedule(dev);
+               }
+               if (status & DMA_STATUS_TI) {
+                       /* transmit interrupt */
+                       ar2313_tx_int(dev);
+               }
        }
 
        if (status & DMA_STATUS_AIS) {
 #if DEBUG_INT
-           printk("%s: AIS set %08x & %x\n", __FUNCTION__,
-                  status, (DMA_STATUS_FBE | DMA_STATUS_TPS));
+               printk("%s: AIS set %08x & %x\n", __FUNCTION__,
+                          status, (DMA_STATUS_FBE | DMA_STATUS_TPS));
 #endif
-       /* abnormal status */
-       if (status & (DMA_STATUS_FBE | DMA_STATUS_TPS)) {
-           ar2313_restart(dev);
-       }
+               /* abnormal status */
+               if (status & (DMA_STATUS_FBE | DMA_STATUS_TPS)) {
+                       ar2313_restart(dev);
+               }
        }
        return IRQ_HANDLED;
 }
@@ -1083,8 +1111,8 @@ static void ar2313_halt(struct net_device *dev)
        tasklet_disable(&sp->rx_tasklet);
 
        /* kill the MAC */
-       sp->eth_regs->mac_control &= ~(MAC_CONTROL_RE | /* disable Receives */
-                                      MAC_CONTROL_TE); /* disable Transmits */
+       sp->eth_regs->mac_control &= ~(MAC_CONTROL_RE | /* disable Receives */
+                                                                  MAC_CONTROL_TE);     /* disable Transmits */
        /* stop dma */
        sp->dma_regs->control = 0;
        sp->dma_regs->bus_mode = DMA_BUS_MODE_SWR;
@@ -1094,17 +1122,17 @@ static void ar2313_halt(struct net_device *dev)
 
        /* free buffers on tx ring */
        for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
-       struct sk_buff *skb;
-       ar2313_descr_t *txdesc;
+               struct sk_buff *skb;
+               ar2313_descr_t *txdesc;
 
-       txdesc = &sp->tx_ring[j];
-       txdesc->descr = 0;
+               txdesc = &sp->tx_ring[j];
+               txdesc->descr = 0;
 
-       skb = sp->tx_skb[j];
-       if (skb) {
-           dev_kfree_skb(skb);
-           sp->tx_skb[j] = NULL;
-       }
+               skb = sp->tx_skb[j];
+               if (skb) {
+                       dev_kfree_skb(skb);
+                       sp->tx_skb[j] = NULL;
+               }
        }
 }
 
@@ -1121,12 +1149,12 @@ static void ar2313_halt(struct net_device *dev)
 static int ar2313_close(struct net_device *dev)
 {
 #if 0
-       /*
+       /* 
         * Disable interrupts
         */
        disable_irq(dev->irq);
-               
-       /*
+
+       /* 
         * Without (or before) releasing irq and stopping hardware, this
         * is an absolute non-sense, by the way. It will be reset instantly
         * by the first irq.
@@ -1154,20 +1182,20 @@ static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
        if (td->status & DMA_TX_OWN) {
 #if DEBUG_TX
-       printk("%s: No space left to Tx\n", __FUNCTION__);
+               printk("%s: No space left to Tx\n", __FUNCTION__);
 #endif
-           /* free skbuf and lie to the caller that we sent it out */
-           sp->stats.tx_dropped++;
-       dev_kfree_skb(skb);
+               /* free skbuf and lie to the caller that we sent it out */
+               sp->stats.tx_dropped++;
+               dev_kfree_skb(skb);
 
-           /* restart transmitter in case locked */
-           sp->dma_regs->xmt_poll = 0;
-       return 0;
+               /* restart transmitter in case locked */
+               sp->dma_regs->xmt_poll = 0;
+               return 0;
        }
 
        /* Setup the transmit descriptor. */
-       td->devcs = ((skb->len << DMA_TX1_BSIZE_SHIFT) | 
-                    (DMA_TX1_LS|DMA_TX1_IC|DMA_TX1_CHAINED));
+       td->devcs = ((skb->len << DMA_TX1_BSIZE_SHIFT) |
+                                (DMA_TX1_LS | DMA_TX1_IC | DMA_TX1_CHAINED));
        td->addr = dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE);
        td->status = DMA_TX_OWN;
 
@@ -1177,9 +1205,9 @@ static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev)
 #if DEBUG_TX
        printk("index %d\n", idx);
        printk("TX status %08x\n", td->status);
-       printk("TX devcs  %08x\n", td->devcs );
-       printk("TX addr   %08x\n", td->addr  );
-       printk("TX descr  %08x\n", td->descr );
+       printk("TX devcs  %08x\n", td->devcs);
+       printk("TX addr   %08x\n", td->addr);
+       printk("TX descr  %08x\n", td->descr);
 #endif
 
        sp->tx_skb[idx] = skb;
@@ -1189,17 +1217,18 @@ static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev)
        return 0;
 }
 
-static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
+static int netdev_get_ecmd(struct net_device *dev,
+                                                  struct ethtool_cmd *ecmd)
 {
        struct ar2313_private *np = dev->priv;
        u32 tmp;
 
-       ecmd->supported = 
+       ecmd->supported =
                (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
-               SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
-               SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
-       
-           ecmd->port = PORT_TP;
+                SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
+                SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
+
+       ecmd->port = PORT_TP;
        /* only supports internal transceiver */
        ecmd->transceiver = XCVR_INTERNAL;
        /* not sure what this is for */
@@ -1224,29 +1253,29 @@ static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
                ecmd->autoneg = AUTONEG_DISABLE;
        }
 
-           if (ecmd->autoneg == AUTONEG_ENABLE) {
-               tmp = armiiread(dev, np->phy, MII_LPA);
-               if (tmp & (LPA_100FULL|LPA_10FULL)) {
-                   ecmd->duplex = DUPLEX_FULL;
-               } else {
-                   ecmd->duplex = DUPLEX_HALF;
-               }
-               if (tmp & (LPA_100FULL|LPA_100HALF)) {
-               ecmd->speed = SPEED_100;
-               } else {
-               ecmd->speed = SPEED_10;
-               }
-           } else {
-               if (tmp & BMCR_FULLDPLX) {
-                   ecmd->duplex = DUPLEX_FULL;
-               } else {
-                   ecmd->duplex = DUPLEX_HALF;
-               }
-               if (tmp & BMCR_SPEED100) {
-               ecmd->speed = SPEED_100;
-               } else {
-               ecmd->speed = SPEED_10;
-               }
+       if (ecmd->autoneg == AUTONEG_ENABLE) {
+               tmp = armiiread(dev, np->phy, MII_LPA);
+               if (tmp & (LPA_100FULL | LPA_10FULL)) {
+                       ecmd->duplex = DUPLEX_FULL;
+               } else {
+                       ecmd->duplex = DUPLEX_HALF;
+               }
+               if (tmp & (LPA_100FULL | LPA_100HALF)) {
+                       ecmd->speed = SPEED_100;
+               } else {
+                       ecmd->speed = SPEED_10;
+               }
+       } else {
+               if (tmp & BMCR_FULLDPLX) {
+                       ecmd->duplex = DUPLEX_FULL;
+               } else {
+                       ecmd->duplex = DUPLEX_HALF;
+               }
+               if (tmp & BMCR_SPEED100) {
+                       ecmd->speed = SPEED_100;
+               } else {
+                       ecmd->speed = SPEED_10;
+               }
        }
 
        /* ignore maxtxpkt, maxrxpkt for now */
@@ -1254,7 +1283,8 @@ static int netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
        return 0;
 }
 
-static int netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
+static int netdev_set_ecmd(struct net_device *dev,
+                                                  struct ethtool_cmd *ecmd)
 {
        struct ar2313_private *np = dev->priv;
        u32 tmp;
@@ -1267,17 +1297,18 @@ static int netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
                return -EINVAL;
        if (ecmd->transceiver != XCVR_INTERNAL)
                return -EINVAL;
-       if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
+       if (ecmd->autoneg != AUTONEG_DISABLE
+               && ecmd->autoneg != AUTONEG_ENABLE)
                return -EINVAL;
        /* ignore phy_address, maxtxpkt, maxrxpkt for now */
-       
+
        /* WHEW! now lets bang some bits */
-       
+
        tmp = armiiread(dev, np->phy, MII_BMCR);
        if (ecmd->autoneg == AUTONEG_ENABLE) {
                /* turn on autonegotiation */
                tmp |= BMCR_ANENABLE;
-                   printk("%s: Enabling auto-neg\n", dev->name);
+               printk("%s: Enabling auto-neg\n", dev->name);
        } else {
                /* turn off auto negotiation, set speed and duplexity */
                tmp &= ~(BMCR_ANENABLE | BMCR_SPEED100 | BMCR_FULLDPLX);
@@ -1285,12 +1316,12 @@ static int netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
                        tmp |= BMCR_SPEED100;
                if (ecmd->duplex == DUPLEX_FULL)
                        tmp |= BMCR_FULLDPLX;
-                   printk("%s: Hard coding %d/%s\n", dev->name, 
-                          (ecmd->speed == SPEED_100)? 100:10,
-                          (ecmd->duplex == DUPLEX_FULL)? "full":"half");
+               printk("%s: Hard coding %d/%s\n", dev->name,
+                          (ecmd->speed == SPEED_100) ? 100 : 10,
+                          (ecmd->duplex == DUPLEX_FULL) ? "full" : "half");
        }
        armiiwrite(dev, np->phy, MII_BMCR, tmp);
-           np->phyData = 0;
+       np->phyData = 0;
        return 0;
 }
 
@@ -1298,94 +1329,97 @@ static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
 {
        struct ar2313_private *np = dev->priv;
        u32 cmd;
-       
-       if (get_user(cmd, (u32 *)useraddr))
+
+       if (get_user(cmd, (u32 *) useraddr))
                return -EFAULT;
 
-           switch (cmd) {
-       /* get settings */
-       case ETHTOOL_GSET: {
-               struct ethtool_cmd ecmd = { ETHTOOL_GSET };
-               spin_lock_irq(&np->lock);
-               netdev_get_ecmd(dev, &ecmd);
-               spin_unlock_irq(&np->lock);
-               if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
-                       return -EFAULT;
-               return 0;
-       }
-       /* set settings */
-       case ETHTOOL_SSET: {
-               struct ethtool_cmd ecmd;
-               int r;
-               if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
-                       return -EFAULT;
-               spin_lock_irq(&np->lock);
-               r = netdev_set_ecmd(dev, &ecmd);
-               spin_unlock_irq(&np->lock);
-               return r;
-       }
-       /* restart autonegotiation */
-       case ETHTOOL_NWAY_RST: {
-               int tmp;
-               int r = -EINVAL;
-               /* if autoneg is off, it's an error */
-               tmp = armiiread(dev, np->phy, MII_BMCR);
-               if (tmp & BMCR_ANENABLE) {
-                       tmp |= (BMCR_ANRESTART);
-                       armiiwrite(dev, np->phy, MII_BMCR, tmp);
-                       r = 0;
+       switch (cmd) {
+               /* get settings */
+       case ETHTOOL_GSET:{
+                       struct ethtool_cmd ecmd = { ETHTOOL_GSET };
+                       spin_lock_irq(&np->lock);
+                       netdev_get_ecmd(dev, &ecmd);
+                       spin_unlock_irq(&np->lock);
+                       if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
+                               return -EFAULT;
+                       return 0;
+               }
+               /* set settings */
+       case ETHTOOL_SSET:{
+                       struct ethtool_cmd ecmd;
+                       int r;
+                       if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
+                               return -EFAULT;
+                       spin_lock_irq(&np->lock);
+                       r = netdev_set_ecmd(dev, &ecmd);
+                       spin_unlock_irq(&np->lock);
+                       return r;
+               }
+               /* restart autonegotiation */
+       case ETHTOOL_NWAY_RST:{
+                       int tmp;
+                       int r = -EINVAL;
+                       /* if autoneg is off, it's an error */
+                       tmp = armiiread(dev, np->phy, MII_BMCR);
+                       if (tmp & BMCR_ANENABLE) {
+                               tmp |= (BMCR_ANRESTART);
+                               armiiwrite(dev, np->phy, MII_BMCR, tmp);
+                               r = 0;
+                       }
+                       return r;
+               }
+               /* get link status */
+       case ETHTOOL_GLINK:{
+                       struct ethtool_value edata = { ETHTOOL_GLINK };
+                       edata.data =
+                               (armiiread(dev, np->phy, MII_BMSR) & BMSR_LSTATUS) ? 1 : 0;
+                       if (copy_to_user(useraddr, &edata, sizeof(edata)))
+                               return -EFAULT;
+                       return 0;
                }
-               return r;
-       }
-       /* get link status */
-       case ETHTOOL_GLINK: {
-               struct ethtool_value edata = {ETHTOOL_GLINK};
-               edata.data = (armiiread(dev, np->phy, MII_BMSR)&BMSR_LSTATUS) ? 1:0;
-               if (copy_to_user(useraddr, &edata, sizeof(edata)))
-                       return -EFAULT;
-               return 0;
        }
-           }
-       
+
        return -EOPNOTSUPP;
 }
 
 static int ar2313_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
-       struct mii_ioctl_data *data = (struct mii_ioctl_data *)&ifr->ifr_data;
+       struct mii_ioctl_data *data = (struct mii_ioctl_data *) &ifr->ifr_data;
 
        switch (cmd) {
-         
+
        case SIOCETHTOOL:
-           return netdev_ethtool_ioctl(dev, (void *) ifr->ifr_data);
-
-       case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
-           data->phy_id = 1;
-           /* Fall Through */
-
-       case SIOCGMIIREG:               /* Read MII PHY register. */
-           data->val_out = armiiread(dev, data->phy_id & 0x1f, 
-                                     data->reg_num & 0x1f);
-           return 0;
-       case SIOCSMIIREG:               /* Write MII PHY register. */
-           if (!capable(CAP_NET_ADMIN))
-               return -EPERM;
-           armiiwrite(dev, data->phy_id & 0x1f, 
-                      data->reg_num & 0x1f, data->val_in);
-           return 0;
+               return netdev_ethtool_ioctl(dev, (void *) ifr->ifr_data);
+
+       case SIOCGMIIPHY:                       /* Get address of MII PHY in use. */
+               data->phy_id = 1;
+               /* Fall Through */
+
+       case SIOCGMIIREG:                       /* Read MII PHY register. */
+               data->val_out = armiiread(dev, data->phy_id & 0x1f,
+                                                                 data->reg_num & 0x1f);
+               return 0;
+       case SIOCSMIIREG:                       /* Write MII PHY register. */
+               if (!capable(CAP_NET_ADMIN))
+                       return -EPERM;
+               armiiwrite(dev, data->phy_id & 0x1f,
+                                  data->reg_num & 0x1f, data->val_in);
+               return 0;
 
        case SIOCSIFHWADDR:
-           if (copy_from_user(dev->dev_addr, ifr->ifr_data, sizeof(dev->dev_addr)))
-               return -EFAULT;
-           return 0;
+               if (copy_from_user
+                       (dev->dev_addr, ifr->ifr_data, sizeof(dev->dev_addr)))
+                       return -EFAULT;
+               return 0;
 
        case SIOCGIFHWADDR:
-           if (copy_to_user(ifr->ifr_data, dev->dev_addr, sizeof(dev->dev_addr)))
-               return -EFAULT;
-           return 0;
+               if (copy_to_user
+                       (ifr->ifr_data, dev->dev_addr, sizeof(dev->dev_addr)))
+                       return -EFAULT;
+               return 0;
 
        default:
-           break;
+               break;
        }
 
        return -EOPNOTSUPP;
@@ -1393,7 +1427,7 @@ static int ar2313_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 
 static struct net_device_stats *ar2313_get_stats(struct net_device *dev)
 {
-  struct ar2313_private *sp = dev->priv;
+       struct ar2313_private *sp = dev->priv;
        return &sp->stats;
 }
 
@@ -1401,10 +1435,9 @@ static struct net_device_stats *ar2313_get_stats(struct net_device *dev)
 #define MII_ADDR(phy, reg) \
        ((reg << MII_ADDR_REG_SHIFT) | (phy << MII_ADDR_PHY_SHIFT))
 
-static short
-armiiread(struct net_device *dev, short phy, short reg)
+static short armiiread(struct net_device *dev, short phy, short reg)
 {
-       struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
+       struct ar2313_private *sp = (struct ar2313_private *) dev->priv;
        volatile ETHERNET_STRUCT *ethernet = sp->phy_regs;
 
        ethernet->mii_addr = MII_ADDR(phy, reg);
@@ -1415,11 +1448,10 @@ armiiread(struct net_device *dev, short phy, short reg)
 static void
 armiiwrite(struct net_device *dev, short phy, short reg, short data)
 {
-       struct ar2313_private *sp = (struct ar2313_private *)dev->priv;
+       struct ar2313_private *sp = (struct ar2313_private *) dev->priv;
        volatile ETHERNET_STRUCT *ethernet = sp->phy_regs;
 
        while (ethernet->mii_addr & MII_ADDR_BUSY);
        ethernet->mii_data = data << MII_DATA_SHIFT;
        ethernet->mii_addr = MII_ADDR(phy, reg) | MII_ADDR_WRITE;
 }
-
index 464aaca..c0b3a4f 100644 (file)
@@ -8,7 +8,7 @@
 /*
  * probe link timer - 5 secs
  */
-#define LINK_TIMER    (5*HZ) 
+#define LINK_TIMER    (5*HZ)
 
 #define IS_DMA_TX_INT(X)   (((X) & (DMA_STATUS_TI)) != 0)
 #define IS_DMA_RX_INT(X)   (((X) & (DMA_STATUS_RI)) != 0)
 #define DSC_RING_ENTRIES_SIZE  (AR2313_DESCR_ENTRIES * sizeof(struct desc))
 #define DSC_NEXT(idx)          ((idx + 1) & (AR2313_DESCR_ENTRIES - 1))
 
-static inline int tx_space (u32 csm, u32 prd)
+static inline int tx_space(u32 csm, u32 prd)
 {
        return (csm - prd - 1) & (AR2313_DESCR_ENTRIES - 1);
 }
 
 #if MAX_SKB_FRAGS
-#define TX_RESERVED    (MAX_SKB_FRAGS+1) /* +1 for message header */
+#define TX_RESERVED    (MAX_SKB_FRAGS+1)       /* +1 for message header */
 #define tx_ring_full(csm, prd) (tx_space(csm, prd) <= TX_RESERVED)
 #else
 #define tx_ring_full           0
@@ -51,16 +51,16 @@ static inline int tx_space (u32 csm, u32 prd)
 // New Combo structure for Both Eth0 AND eth1
 //
 typedef struct {
-  volatile unsigned int mac_control;    /* 0x00 */
-  volatile unsigned int mac_addr[2];    /* 0x04 - 0x08*/
-  volatile unsigned int mcast_table[2]; /* 0x0c - 0x10 */
-  volatile unsigned int mii_addr;       /* 0x14 */
-  volatile unsigned int mii_data;       /* 0x18 */
-  volatile unsigned int flow_control;   /* 0x1c */
-  volatile unsigned int vlan_tag;       /* 0x20 */
-  volatile unsigned int pad[7];         /* 0x24 - 0x3c */
-  volatile unsigned int ucast_table[8]; /* 0x40-0x5c */
-  
+       volatile unsigned int mac_control;      /* 0x00 */
+       volatile unsigned int mac_addr[2];      /* 0x04 - 0x08 */
+       volatile unsigned int mcast_table[2];   /* 0x0c - 0x10 */
+       volatile unsigned int mii_addr; /* 0x14 */
+       volatile unsigned int mii_data; /* 0x18 */
+       volatile unsigned int flow_control;     /* 0x1c */
+       volatile unsigned int vlan_tag; /* 0x20 */
+       volatile unsigned int pad[7];   /* 0x24 - 0x3c */
+       volatile unsigned int ucast_table[8];   /* 0x40-0x5c */
+
 } ETHERNET_STRUCT;
 
 /********************************************************************
@@ -68,31 +68,31 @@ typedef struct {
  ********************************************************************/
 
 typedef struct {
-  volatile unsigned int wdog_control;          /* 0x08 */
-  volatile unsigned int wdog_timer;            /* 0x0c */
-  volatile unsigned int misc_status;           /* 0x10 */
-  volatile unsigned int misc_mask;             /* 0x14 */
-  volatile unsigned int global_status;         /* 0x18 */
-  volatile unsigned int reserved;              /* 0x1c */
-  volatile unsigned int reset_control;         /* 0x20 */
+       volatile unsigned int wdog_control;     /* 0x08 */
+       volatile unsigned int wdog_timer;       /* 0x0c */
+       volatile unsigned int misc_status;      /* 0x10 */
+       volatile unsigned int misc_mask;        /* 0x14 */
+       volatile unsigned int global_status;    /* 0x18 */
+       volatile unsigned int reserved; /* 0x1c */
+       volatile unsigned int reset_control;    /* 0x20 */
 } INTERRUPT;
 
 /********************************************************************
  * DMA controller
  ********************************************************************/
 typedef struct {
-  volatile unsigned int bus_mode;        /* 0x00 (CSR0) */
-  volatile unsigned int xmt_poll;        /* 0x04 (CSR1) */
-  volatile unsigned int rcv_poll;        /* 0x08 (CSR2) */
-  volatile unsigned int rcv_base;        /* 0x0c (CSR3) */
-  volatile unsigned int xmt_base;        /* 0x10 (CSR4) */
-  volatile unsigned int status;          /* 0x14 (CSR5) */
-  volatile unsigned int control;         /* 0x18 (CSR6) */
-  volatile unsigned int intr_ena;        /* 0x1c (CSR7) */
-  volatile unsigned int rcv_missed;      /* 0x20 (CSR8) */
-  volatile unsigned int reserved[11];    /* 0x24-0x4c (CSR9-19) */
-  volatile unsigned int cur_tx_buf_addr; /* 0x50 (CSR20) */
-  volatile unsigned int cur_rx_buf_addr; /* 0x50 (CSR21) */
+       volatile unsigned int bus_mode; /* 0x00 (CSR0) */
+       volatile unsigned int xmt_poll; /* 0x04 (CSR1) */
+       volatile unsigned int rcv_poll; /* 0x08 (CSR2) */
+       volatile unsigned int rcv_base; /* 0x0c (CSR3) */
+       volatile unsigned int xmt_base; /* 0x10 (CSR4) */
+       volatile unsigned int status;   /* 0x14 (CSR5) */
+       volatile unsigned int control;  /* 0x18 (CSR6) */
+       volatile unsigned int intr_ena; /* 0x1c (CSR7) */
+       volatile unsigned int rcv_missed;       /* 0x20 (CSR8) */
+       volatile unsigned int reserved[11];     /* 0x24-0x4c (CSR9-19) */
+       volatile unsigned int cur_tx_buf_addr;  /* 0x50 (CSR20) */
+       volatile unsigned int cur_rx_buf_addr;  /* 0x50 (CSR21) */
 } DMA;
 
 /*
@@ -105,59 +105,58 @@ typedef struct {
  * Frequently accessed variables are put at the beginning of the
  * struct to help the compiler generate better/shorter code.
  */
-struct ar2313_private
-{
+struct ar2313_private {
        struct net_device *dev;
-       int                     version;
-       u32                     mb[2];
-       
-       volatile ETHERNET_STRUCT        *phy_regs;
-       volatile ETHERNET_STRUCT        *eth_regs;
-       volatile DMA                    *dma_regs;
-       volatile u32                    *int_regs;
+       int version;
+       u32 mb[2];
+
+       volatile ETHERNET_STRUCT *phy_regs;
+       volatile ETHERNET_STRUCT *eth_regs;
+       volatile DMA *dma_regs;
+       volatile u32 *int_regs;
        struct ar531x_eth *cfg;
 
-       spinlock_t lock;        /* Serialise access to device */
+       spinlock_t lock;                        /* Serialise access to device */
 
-       /*
+       /* 
         * RX and TX descriptors, must be adjacent
         */
-       ar2313_descr_t          *rx_ring;
-       ar2313_descr_t          *tx_ring;
+       ar2313_descr_t *rx_ring;
+       ar2313_descr_t *tx_ring;
 
 
-       struct sk_buff          **rx_skb;
-       struct sk_buff          **tx_skb;
+       struct sk_buff **rx_skb;
+       struct sk_buff **tx_skb;
 
-       /*
+       /* 
         * RX elements
         */
-       u32                     rx_skbprd;
-       u32                     cur_rx;
+       u32 rx_skbprd;
+       u32 cur_rx;
 
-       /*
+       /* 
         * TX elements
         */
-       u32                     tx_prd;
-       u32                     tx_csm;
+       u32 tx_prd;
+       u32 tx_csm;
 
-       /*
+       /* 
         * Misc elements
         */
-       int                     board_idx;
-       char                    name[48];
+       int board_idx;
+       char name[48];
        struct net_device_stats stats;
        struct {
-           u32 address;
-           u32 length;
-           char *mapping;
+               u32 address;
+               u32 length;
+               char *mapping;
        } desc;
 
 
        struct timer_list link_timer;
-       unsigned short phy;  /* merlot phy = 1,  samsung phy = 0x1f */
+       unsigned short phy;                     /* merlot phy = 1, samsung phy = 0x1f */
        unsigned short mac;
-       unsigned short link; /* 0 - link down,  1 - link up */
+       unsigned short link;            /* 0 - link down, 1 - link up */
        u16 phyData;
 
        struct tasklet_struct rx_tasklet;
@@ -168,7 +167,7 @@ struct ar2313_private
 /*
  * Prototypes
  */
-static int  ar2313_init(struct net_device *dev);
+static int ar2313_init(struct net_device *dev);
 #ifdef TX_TIMEOUT
 static void ar2313_tx_timeout(struct net_device *dev);
 #endif
@@ -177,17 +176,18 @@ static void ar2313_multicast_list(struct net_device *dev);
 #endif
 static int ar2313_restart(struct net_device *dev);
 #if DEBUG
-static void  ar2313_dump_regs(struct net_device *dev);
+static void ar2313_dump_regs(struct net_device *dev);
 #endif
 static void ar2313_load_rx_ring(struct net_device *dev, int bufs);
 static irqreturn_t ar2313_interrupt(int irq, void *dev_id);
-static int  ar2313_open(struct net_device *dev);
-static int  ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev);
-static int  ar2313_close(struct net_device *dev);
-static int  ar2313_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
+static int ar2313_open(struct net_device *dev);
+static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev);
+static int ar2313_close(struct net_device *dev);
+static int ar2313_ioctl(struct net_device *dev, struct ifreq *ifr,
+                                               int cmd);
 static void ar2313_init_cleanup(struct net_device *dev);
-static int  ar2313_setup_timer(struct net_device *dev);
+static int ar2313_setup_timer(struct net_device *dev);
 static void ar2313_link_timer_fn(unsigned long data);
 static void ar2313_check_link(struct net_device *dev);
 static struct net_device_stats *ar2313_get_stats(struct net_device *dev);
-#endif /* _AR2313_H_ */
+#endif                                                 /* _AR2313_H_ */
index 6544c4e..1138270 100644 (file)
 #define DMA_RX_EV2           AR_BIT(5)
 #define DMA_RX_ERR_COL       AR_BIT(6)
 #define DMA_RX_LONG          AR_BIT(7)
-#define DMA_RX_LS            AR_BIT(8)  /* last descriptor */
-#define DMA_RX_FS            AR_BIT(9)  /* first descriptor */
-#define DMA_RX_MF            AR_BIT(10) /* multicast frame */
-#define DMA_RX_ERR_RUNT      AR_BIT(11) /* runt frame */
-#define DMA_RX_ERR_LENGTH    AR_BIT(12) /* length error */
-#define DMA_RX_ERR_DESC      AR_BIT(14) /* descriptor error */
-#define DMA_RX_ERROR         AR_BIT(15) /* error summary */
+#define DMA_RX_LS            AR_BIT(8) /* last descriptor */
+#define DMA_RX_FS            AR_BIT(9) /* first descriptor */
+#define DMA_RX_MF            AR_BIT(10)        /* multicast frame */
+#define DMA_RX_ERR_RUNT      AR_BIT(11)        /* runt frame */
+#define DMA_RX_ERR_LENGTH    AR_BIT(12)        /* length error */
+#define DMA_RX_ERR_DESC      AR_BIT(14)        /* descriptor error */
+#define DMA_RX_ERROR         AR_BIT(15)        /* error summary */
 #define DMA_RX_LEN_MASK      0x3fff0000
 #define DMA_RX_LEN_SHIFT     16
 #define DMA_RX_FILT          AR_BIT(30)
-#define DMA_RX_OWN           AR_BIT(31) /* desc owned by DMA controller */
+#define DMA_RX_OWN           AR_BIT(31)        /* desc owned by DMA controller */
 
 #define DMA_RX1_BSIZE_MASK   0x000007ff
 #define DMA_RX1_BSIZE_SHIFT  0
 #define DMA_RX1_CHAINED      AR_BIT(24)
 #define DMA_RX1_RER          AR_BIT(25)
 
-#define DMA_TX_ERR_UNDER     AR_BIT(1)  /* underflow error */
-#define DMA_TX_ERR_DEFER     AR_BIT(2)  /* excessive deferral */
+#define DMA_TX_ERR_UNDER     AR_BIT(1) /* underflow error */
+#define DMA_TX_ERR_DEFER     AR_BIT(2) /* excessive deferral */
 #define DMA_TX_COL_MASK      0x78
 #define DMA_TX_COL_SHIFT     3
-#define DMA_TX_ERR_HB        AR_BIT(7)  /* hearbeat failure */
-#define DMA_TX_ERR_COL       AR_BIT(8)  /* excessive collisions */
-#define DMA_TX_ERR_LATE      AR_BIT(9)  /* late collision */
-#define DMA_TX_ERR_LINK      AR_BIT(10) /* no carrier */
-#define DMA_TX_ERR_LOSS      AR_BIT(11) /* loss of carrier */
-#define DMA_TX_ERR_JABBER    AR_BIT(14) /* transmit jabber timeout */
-#define DMA_TX_ERROR         AR_BIT(15) /* frame aborted */
-#define DMA_TX_OWN           AR_BIT(31) /* descr owned by DMA controller */
+#define DMA_TX_ERR_HB        AR_BIT(7) /* hearbeat failure */
+#define DMA_TX_ERR_COL       AR_BIT(8) /* excessive collisions */
+#define DMA_TX_ERR_LATE      AR_BIT(9) /* late collision */
+#define DMA_TX_ERR_LINK      AR_BIT(10)        /* no carrier */
+#define DMA_TX_ERR_LOSS      AR_BIT(11)        /* loss of carrier */
+#define DMA_TX_ERR_JABBER    AR_BIT(14)        /* transmit jabber timeout */
+#define DMA_TX_ERROR         AR_BIT(15)        /* frame aborted */
+#define DMA_TX_OWN           AR_BIT(31)        /* descr owned by DMA controller */
 
 #define DMA_TX1_BSIZE_MASK   0x000007ff
 #define DMA_TX1_BSIZE_SHIFT  0
-#define DMA_TX1_CHAINED      AR_BIT(24) /* chained descriptors */
-#define DMA_TX1_TER          AR_BIT(25) /* transmit end of ring */
-#define DMA_TX1_FS           AR_BIT(29) /* first segment */
-#define DMA_TX1_LS           AR_BIT(30) /* last segment */
-#define DMA_TX1_IC           AR_BIT(31) /* interrupt on completion */
-
-#define RCVPKT_LENGTH(X)     (X  >> 16)               /* Received pkt Length  */
-
-#define MAC_CONTROL_RE       AR_BIT(2)  /* receive enable */
-#define MAC_CONTROL_TE       AR_BIT(3)  /* transmit enable */
-#define MAC_CONTROL_DC       AR_BIT(5)  /* Deferral check*/
-#define MAC_CONTROL_ASTP     AR_BIT(8)  /* Auto pad strip */
-#define MAC_CONTROL_DRTY     AR_BIT(10) /* Disable retry */
-#define MAC_CONTROL_DBF      AR_BIT(11) /* Disable bcast frames */
-#define MAC_CONTROL_LCC      AR_BIT(12) /* late collision ctrl */
-#define MAC_CONTROL_HP       AR_BIT(13) /* Hash Perfect filtering */
-#define MAC_CONTROL_HASH     AR_BIT(14) /* Unicast hash filtering */
-#define MAC_CONTROL_HO       AR_BIT(15) /* Hash only filtering */
-#define MAC_CONTROL_PB       AR_BIT(16) /* Pass Bad frames */
-#define MAC_CONTROL_IF       AR_BIT(17) /* Inverse filtering */
-#define MAC_CONTROL_PR       AR_BIT(18) /* promiscuous mode (valid frames only) */
-#define MAC_CONTROL_PM       AR_BIT(19) /* pass multicast */
-#define MAC_CONTROL_F        AR_BIT(20) /* full-duplex */
-#define MAC_CONTROL_DRO      AR_BIT(23) /* Disable Receive Own */
-#define MAC_CONTROL_HBD      AR_BIT(28) /* heart-beat disabled (MUST BE SET) */
-#define MAC_CONTROL_BLE      AR_BIT(30) /* big endian mode */
-#define MAC_CONTROL_RA       AR_BIT(31) /* receive all (valid and invalid frames) */
+#define DMA_TX1_CHAINED      AR_BIT(24)        /* chained descriptors */
+#define DMA_TX1_TER          AR_BIT(25)        /* transmit end of ring */
+#define DMA_TX1_FS           AR_BIT(29)        /* first segment */
+#define DMA_TX1_LS           AR_BIT(30)        /* last segment */
+#define DMA_TX1_IC           AR_BIT(31)        /* interrupt on completion */
+
+#define RCVPKT_LENGTH(X)     (X  >> 16)        /* Received pkt Length */
+
+#define MAC_CONTROL_RE       AR_BIT(2) /* receive enable */
+#define MAC_CONTROL_TE       AR_BIT(3) /* transmit enable */
+#define MAC_CONTROL_DC       AR_BIT(5) /* Deferral check */
+#define MAC_CONTROL_ASTP     AR_BIT(8) /* Auto pad strip */
+#define MAC_CONTROL_DRTY     AR_BIT(10)        /* Disable retry */
+#define MAC_CONTROL_DBF      AR_BIT(11)        /* Disable bcast frames */
+#define MAC_CONTROL_LCC      AR_BIT(12)        /* late collision ctrl */
+#define MAC_CONTROL_HP       AR_BIT(13)        /* Hash Perfect filtering */
+#define MAC_CONTROL_HASH     AR_BIT(14)        /* Unicast hash filtering */
+#define MAC_CONTROL_HO       AR_BIT(15)        /* Hash only filtering */
+#define MAC_CONTROL_PB       AR_BIT(16)        /* Pass Bad frames */
+#define MAC_CONTROL_IF       AR_BIT(17)        /* Inverse filtering */
+#define MAC_CONTROL_PR       AR_BIT(18)        /* promiscuous mode (valid frames
+                                                                                  only) */
+#define MAC_CONTROL_PM       AR_BIT(19)        /* pass multicast */
+#define MAC_CONTROL_F        AR_BIT(20)        /* full-duplex */
+#define MAC_CONTROL_DRO      AR_BIT(23)        /* Disable Receive Own */
+#define MAC_CONTROL_HBD      AR_BIT(28)        /* heart-beat disabled (MUST BE
+                                                                                  SET) */
+#define MAC_CONTROL_BLE      AR_BIT(30)        /* big endian mode */
+#define MAC_CONTROL_RA       AR_BIT(31)        /* receive all (valid and invalid
+                                                                                  frames) */
 
 #define MII_ADDR_BUSY        AR_BIT(0)
 #define MII_ADDR_WRITE       AR_BIT(1)
 
 #define FLOW_CONTROL_FCE     AR_BIT(1)
 
-#define DMA_BUS_MODE_SWR       AR_BIT(0)  /* software reset */
-#define DMA_BUS_MODE_BLE       AR_BIT(7)  /* big endian mode */
-#define DMA_BUS_MODE_PBL_SHIFT 8          /* programmable burst length 32 */
-#define DMA_BUS_MODE_DBO       AR_BIT(20) /* big-endian descriptors */
-
-#define DMA_STATUS_TI        AR_BIT(0)  /* transmit interrupt */
-#define DMA_STATUS_TPS       AR_BIT(1)  /* transmit process stopped */
-#define DMA_STATUS_TU        AR_BIT(2)  /* transmit buffer unavailable */
-#define DMA_STATUS_TJT       AR_BIT(3)  /* transmit buffer timeout */
-#define DMA_STATUS_UNF       AR_BIT(5)  /* transmit underflow */
-#define DMA_STATUS_RI        AR_BIT(6)  /* receive interrupt */
-#define DMA_STATUS_RU        AR_BIT(7)  /* receive buffer unavailable */
-#define DMA_STATUS_RPS       AR_BIT(8)  /* receive process stopped */
-#define DMA_STATUS_ETI       AR_BIT(10) /* early transmit interrupt */
-#define DMA_STATUS_FBE       AR_BIT(13) /* fatal bus interrupt */
-#define DMA_STATUS_ERI       AR_BIT(14) /* early receive interrupt */
-#define DMA_STATUS_AIS       AR_BIT(15) /* abnormal interrupt summary */
-#define DMA_STATUS_NIS       AR_BIT(16) /* normal interrupt summary */
-#define DMA_STATUS_RS_SHIFT  17         /* receive process state */
-#define DMA_STATUS_TS_SHIFT  20         /* transmit process state */
-#define DMA_STATUS_EB_SHIFT  23         /* error bits */
-
-#define DMA_CONTROL_SR       AR_BIT(1)  /* start receive */
-#define DMA_CONTROL_ST       AR_BIT(13) /* start transmit */
-#define DMA_CONTROL_SF       AR_BIT(21) /* store and forward */
+#define DMA_BUS_MODE_SWR       AR_BIT(0)       /* software reset */
+#define DMA_BUS_MODE_BLE       AR_BIT(7)       /* big endian mode */
+#define DMA_BUS_MODE_PBL_SHIFT 8       /* programmable burst length 32 */
+#define DMA_BUS_MODE_DBO       AR_BIT(20)      /* big-endian descriptors */
+
+#define DMA_STATUS_TI        AR_BIT(0) /* transmit interrupt */
+#define DMA_STATUS_TPS       AR_BIT(1) /* transmit process stopped */
+#define DMA_STATUS_TU        AR_BIT(2) /* transmit buffer unavailable */
+#define DMA_STATUS_TJT       AR_BIT(3) /* transmit buffer timeout */
+#define DMA_STATUS_UNF       AR_BIT(5) /* transmit underflow */
+#define DMA_STATUS_RI        AR_BIT(6) /* receive interrupt */
+#define DMA_STATUS_RU        AR_BIT(7) /* receive buffer unavailable */
+#define DMA_STATUS_RPS       AR_BIT(8) /* receive process stopped */
+#define DMA_STATUS_ETI       AR_BIT(10)        /* early transmit interrupt */
+#define DMA_STATUS_FBE       AR_BIT(13)        /* fatal bus interrupt */
+#define DMA_STATUS_ERI       AR_BIT(14)        /* early receive interrupt */
+#define DMA_STATUS_AIS       AR_BIT(15)        /* abnormal interrupt summary */
+#define DMA_STATUS_NIS       AR_BIT(16)        /* normal interrupt summary */
+#define DMA_STATUS_RS_SHIFT  17        /* receive process state */
+#define DMA_STATUS_TS_SHIFT  20        /* transmit process state */
+#define DMA_STATUS_EB_SHIFT  23        /* error bits */
+
+#define DMA_CONTROL_SR       AR_BIT(1) /* start receive */
+#define DMA_CONTROL_ST       AR_BIT(13)        /* start transmit */
+#define DMA_CONTROL_SF       AR_BIT(21)        /* store and forward */
 
 
 typedef struct {
-    volatile unsigned int      status;         // OWN, Device control and status.
-    volatile unsigned int      devcs;          // pkt Control bits + Length
-    volatile unsigned int      addr;           // Current Address.
-    volatile unsigned int      descr;          // Next descriptor in chain.
+       volatile unsigned int status;   // OWN, Device control and status.
+       volatile unsigned int devcs;    // pkt Control bits + Length
+       volatile unsigned int addr;     // Current Address.
+       volatile unsigned int descr;    // Next descriptor in chain.
 } ar2313_descr_t;
 
 
-#endif // __ARUBA_DMA_H__
-
+#endif                                                 // __ARUBA_DMA_H__