gianfar: various coding style and whitespace cleanups
authorJan Ceuleers <jan.ceuleers@computer.org>
Tue, 5 Jun 2012 03:42:13 +0000 (03:42 +0000)
committerDavid S. Miller <davem@davemloft.net>
Tue, 5 Jun 2012 22:38:40 +0000 (15:38 -0700)
Signed-off-by: Jan Ceuleers <jan.ceuleers@computer.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/net/ethernet/freescale/gianfar.c

index 314456000335955434d14e7651a61091c7d14ee3..ed0b1369a5d99df7cb39533c0fd9d27dc956bd12 100644 (file)
@@ -113,7 +113,7 @@ static void gfar_timeout(struct net_device *dev);
 static int gfar_close(struct net_device *dev);
 struct sk_buff *gfar_new_skb(struct net_device *dev);
 static void gfar_new_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
-               struct sk_buff *skb);
+                          struct sk_buff *skb);
 static int gfar_set_mac_address(struct net_device *dev);
 static int gfar_change_mtu(struct net_device *dev, int new_mtu);
 static irqreturn_t gfar_error(int irq, void *dev_id);
@@ -265,8 +265,8 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
                tx_queue->tx_bd_dma_base = addr;
                tx_queue->dev = ndev;
                /* enet DMA only understands physical addresses */
-               addr    += sizeof(struct txbd8) * tx_queue->tx_ring_size;
-               vaddr   += sizeof(struct txbd8) * tx_queue->tx_ring_size;
+               addr  += sizeof(struct txbd8) * tx_queue->tx_ring_size;
+               vaddr += sizeof(struct txbd8) * tx_queue->tx_ring_size;
        }
 
        /* Start the rx descriptor ring where the tx ring leaves off */
@@ -275,15 +275,16 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
                rx_queue->rx_bd_base = vaddr;
                rx_queue->rx_bd_dma_base = addr;
                rx_queue->dev = ndev;
-               addr    += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
-               vaddr   += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
+               addr  += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
+               vaddr += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
        }
 
        /* Setup the skbuff rings */
        for (i = 0; i < priv->num_tx_queues; i++) {
                tx_queue = priv->tx_queue[i];
                tx_queue->tx_skbuff = kmalloc(sizeof(*tx_queue->tx_skbuff) *
-                                 tx_queue->tx_ring_size, GFP_KERNEL);
+                                             tx_queue->tx_ring_size,
+                                             GFP_KERNEL);
                if (!tx_queue->tx_skbuff) {
                        netif_err(priv, ifup, ndev,
                                  "Could not allocate tx_skbuff\n");
@@ -297,7 +298,8 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
        for (i = 0; i < priv->num_rx_queues; i++) {
                rx_queue = priv->rx_queue[i];
                rx_queue->rx_skbuff = kmalloc(sizeof(*rx_queue->rx_skbuff) *
-                                 rx_queue->rx_ring_size, GFP_KERNEL);
+                                             rx_queue->rx_ring_size,
+                                             GFP_KERNEL);
 
                if (!rx_queue->rx_skbuff) {
                        netif_err(priv, ifup, ndev,
@@ -326,15 +328,15 @@ static void gfar_init_tx_rx_base(struct gfar_private *priv)
        int i;
 
        baddr = &regs->tbase0;
-       for(i = 0; i < priv->num_tx_queues; i++) {
+       for (i = 0; i < priv->num_tx_queues; i++) {
                gfar_write(baddr, priv->tx_queue[i]->tx_bd_dma_base);
-               baddr   += 2;
+               baddr += 2;
        }
 
        baddr = &regs->rbase0;
-       for(i = 0; i < priv->num_rx_queues; i++) {
+       for (i = 0; i < priv->num_rx_queues; i++) {
                gfar_write(baddr, priv->rx_queue[i]->rx_bd_dma_base);
-               baddr   += 2;
+               baddr += 2;
        }
 }
 
@@ -430,12 +432,12 @@ static struct net_device_stats *gfar_get_stats(struct net_device *dev)
 
        for (i = 0; i < priv->num_rx_queues; i++) {
                rx_packets += priv->rx_queue[i]->stats.rx_packets;
-               rx_bytes += priv->rx_queue[i]->stats.rx_bytes;
+               rx_bytes   += priv->rx_queue[i]->stats.rx_bytes;
                rx_dropped += priv->rx_queue[i]->stats.rx_dropped;
        }
 
        dev->stats.rx_packets = rx_packets;
-       dev->stats.rx_bytes = rx_bytes;
+       dev->stats.rx_bytes   = rx_bytes;
        dev->stats.rx_dropped = rx_dropped;
 
        for (i = 0; i < priv->num_tx_queues; i++) {
@@ -443,7 +445,7 @@ static struct net_device_stats *gfar_get_stats(struct net_device *dev)
                tx_packets += priv->tx_queue[i]->stats.tx_packets;
        }
 
-       dev->stats.tx_bytes = tx_bytes;
+       dev->stats.tx_bytes   = tx_bytes;
        dev->stats.tx_packets = tx_packets;
 
        return &dev->stats;
@@ -508,8 +510,8 @@ static bool gfar_is_vlan_on(struct gfar_private *priv)
 static inline int gfar_uses_fcb(struct gfar_private *priv)
 {
        return gfar_is_vlan_on(priv) ||
-               (priv->ndev->features & NETIF_F_RXCSUM) ||
-               (priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER);
+              (priv->ndev->features & NETIF_F_RXCSUM) ||
+              (priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER);
 }
 
 static void free_tx_pointers(struct gfar_private *priv)
@@ -554,7 +556,7 @@ static void enable_napi(struct gfar_private *priv)
 }
 
 static int gfar_parse_group(struct device_node *np,
-               struct gfar_private *priv, const char *model)
+                           struct gfar_private *priv, const char *model)
 {
        u32 *queue_mask;
 
@@ -580,15 +582,13 @@ static int gfar_parse_group(struct device_node *np,
        priv->gfargrp[priv->num_grps].grp_id = priv->num_grps;
        priv->gfargrp[priv->num_grps].priv = priv;
        spin_lock_init(&priv->gfargrp[priv->num_grps].grplock);
-       if(priv->mode == MQ_MG_MODE) {
-               queue_mask = (u32 *)of_get_property(np,
-                                       "fsl,rx-bit-map", NULL);
-               priv->gfargrp[priv->num_grps].rx_bit_map =
-                       queue_mask ?  *queue_mask :(DEFAULT_MAPPING >> priv->num_grps);
-               queue_mask = (u32 *)of_get_property(np,
-                                       "fsl,tx-bit-map", NULL);
-               priv->gfargrp[priv->num_grps].tx_bit_map =
-                       queue_mask ? *queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
+       if (priv->mode == MQ_MG_MODE) {
+               queue_mask = (u32 *)of_get_property(np, "fsl,rx-bit-map", NULL);
+               priv->gfargrp[priv->num_grps].rx_bit_map = queue_mask ?
+                       *queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
+               queue_mask = (u32 *)of_get_property(np, "fsl,tx-bit-map", NULL);
+               priv->gfargrp[priv->num_grps].tx_bit_map = queue_mask ?
+                       *queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
        } else {
                priv->gfargrp[priv->num_grps].rx_bit_map = 0xFF;
                priv->gfargrp[priv->num_grps].tx_bit_map = 0xFF;
@@ -673,7 +673,7 @@ static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
        } else {
                priv->mode = SQ_SG_MODE;
                err = gfar_parse_group(np, priv, model);
-               if(err)
+               if (err)
                        goto err_grp_init;
        }
 
@@ -730,27 +730,27 @@ static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
                priv->device_flags |= FSL_GIANFAR_DEV_HAS_BUF_STASHING;
 
        mac_addr = of_get_mac_address(np);
+
        if (mac_addr)
                memcpy(dev->dev_addr, mac_addr, ETH_ALEN);
 
        if (model && !strcasecmp(model, "TSEC"))
-               priv->device_flags =
-                       FSL_GIANFAR_DEV_HAS_GIGABIT |
-                       FSL_GIANFAR_DEV_HAS_COALESCE |
-                       FSL_GIANFAR_DEV_HAS_RMON |
-                       FSL_GIANFAR_DEV_HAS_MULTI_INTR;
+               priv->device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT |
+                                    FSL_GIANFAR_DEV_HAS_COALESCE |
+                                    FSL_GIANFAR_DEV_HAS_RMON |
+                                    FSL_GIANFAR_DEV_HAS_MULTI_INTR;
+
        if (model && !strcasecmp(model, "eTSEC"))
-               priv->device_flags =
-                       FSL_GIANFAR_DEV_HAS_GIGABIT |
-                       FSL_GIANFAR_DEV_HAS_COALESCE |
-                       FSL_GIANFAR_DEV_HAS_RMON |
-                       FSL_GIANFAR_DEV_HAS_MULTI_INTR |
-                       FSL_GIANFAR_DEV_HAS_PADDING |
-                       FSL_GIANFAR_DEV_HAS_CSUM |
-                       FSL_GIANFAR_DEV_HAS_VLAN |
-                       FSL_GIANFAR_DEV_HAS_MAGIC_PACKET |
-                       FSL_GIANFAR_DEV_HAS_EXTENDED_HASH |
-                       FSL_GIANFAR_DEV_HAS_TIMER;
+               priv->device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT |
+                                    FSL_GIANFAR_DEV_HAS_COALESCE |
+                                    FSL_GIANFAR_DEV_HAS_RMON |
+                                    FSL_GIANFAR_DEV_HAS_MULTI_INTR |
+                                    FSL_GIANFAR_DEV_HAS_PADDING |
+                                    FSL_GIANFAR_DEV_HAS_CSUM |
+                                    FSL_GIANFAR_DEV_HAS_VLAN |
+                                    FSL_GIANFAR_DEV_HAS_MAGIC_PACKET |
+                                    FSL_GIANFAR_DEV_HAS_EXTENDED_HASH |
+                                    FSL_GIANFAR_DEV_HAS_TIMER;
 
        ctype = of_get_property(np, "phy-connection-type", NULL);
 
@@ -781,7 +781,7 @@ err_grp_init:
 }
 
 static int gfar_hwtstamp_ioctl(struct net_device *netdev,
-                       struct ifreq *ifr, int cmd)
+                              struct ifreq *ifr, int cmd)
 {
        struct hwtstamp_config config;
        struct gfar_private *priv = netdev_priv(netdev);
@@ -851,6 +851,7 @@ static unsigned int reverse_bitmap(unsigned int bit_map, unsigned int max_qs)
 {
        unsigned int new_bit_map = 0x0;
        int mask = 0x1 << (max_qs - 1), i;
+
        for (i = 0; i < max_qs; i++) {
                if (bit_map & mask)
                        new_bit_map = new_bit_map + (1 << i);
@@ -936,22 +937,22 @@ static void gfar_detect_errata(struct gfar_private *priv)
 
        /* MPC8313 Rev 2.0 and higher; All MPC837x */
        if ((pvr == 0x80850010 && mod == 0x80b0 && rev >= 0x0020) ||
-                       (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
+           (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
                priv->errata |= GFAR_ERRATA_74;
 
        /* MPC8313 and MPC837x all rev */
        if ((pvr == 0x80850010 && mod == 0x80b0) ||
-                       (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
+           (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
                priv->errata |= GFAR_ERRATA_76;
 
        /* MPC8313 and MPC837x all rev */
        if ((pvr == 0x80850010 && mod == 0x80b0) ||
-                       (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
+           (pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
                priv->errata |= GFAR_ERRATA_A002;
 
        /* MPC8313 Rev < 2.0, MPC8548 rev 2.0 */
        if ((pvr == 0x80850010 && mod == 0x80b0 && rev < 0x0020) ||
-                       (pvr == 0x80210020 && mod == 0x8030 && rev == 0x0020))
+           (pvr == 0x80210020 && mod == 0x8030 && rev == 0x0020))
                priv->errata |= GFAR_ERRATA_12;
 
        if (priv->errata)
@@ -1028,13 +1029,14 @@ static int gfar_probe(struct platform_device *ofdev)
 
        /* Register for napi ...We are registering NAPI for each grp */
        for (i = 0; i < priv->num_grps; i++)
-               netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll, GFAR_DEV_WEIGHT);
+               netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll,
+                              GFAR_DEV_WEIGHT);
 
        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
                dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
-                       NETIF_F_RXCSUM;
+                                  NETIF_F_RXCSUM;
                dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG |
-                       NETIF_F_RXCSUM | NETIF_F_HIGHDMA;
+                                NETIF_F_RXCSUM | NETIF_F_HIGHDMA;
        }
 
        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_VLAN) {
@@ -1083,7 +1085,7 @@ static int gfar_probe(struct platform_device *ofdev)
                priv->padding = 0;
 
        if (dev->features & NETIF_F_IP_CSUM ||
-                       priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)
+           priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)
                dev->needed_headroom = GMAC_FCB_LEN;
 
        /* Program the isrg regs only if number of grps > 1 */
@@ -1103,10 +1105,10 @@ static int gfar_probe(struct platform_device *ofdev)
         * basically reverses the queue numbers
         */
        for (i = 0; i< priv->num_grps; i++) {
-               priv->gfargrp[i].tx_bit_map = reverse_bitmap(
-                               priv->gfargrp[i].tx_bit_map, MAX_TX_QS);
-               priv->gfargrp[i].rx_bit_map = reverse_bitmap(
-                               priv->gfargrp[i].rx_bit_map, MAX_RX_QS);
+               priv->gfargrp[i].tx_bit_map =
+                       reverse_bitmap(priv->gfargrp[i].tx_bit_map, MAX_TX_QS);
+               priv->gfargrp[i].rx_bit_map =
+                       reverse_bitmap(priv->gfargrp[i].rx_bit_map, MAX_RX_QS);
        }
 
        /* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values,
@@ -1114,16 +1116,18 @@ static int gfar_probe(struct platform_device *ofdev)
         */
        for (grp_idx = 0; grp_idx < priv->num_grps; grp_idx++) {
                priv->gfargrp[grp_idx].num_rx_queues = 0x0;
+
                for_each_set_bit(i, &priv->gfargrp[grp_idx].rx_bit_map,
-                               priv->num_rx_queues) {
+                                priv->num_rx_queues) {
                        priv->gfargrp[grp_idx].num_rx_queues++;
                        priv->rx_queue[i]->grp = &priv->gfargrp[grp_idx];
                        rstat = rstat | (RSTAT_CLEAR_RHALT >> i);
                        rqueue = rqueue | ((RQUEUE_EN0 | RQUEUE_EX0) >> i);
                }
                priv->gfargrp[grp_idx].num_tx_queues = 0x0;
+
                for_each_set_bit(i, &priv->gfargrp[grp_idx].tx_bit_map,
-                               priv->num_tx_queues) {
+                                priv->num_tx_queues) {
                        priv->gfargrp[grp_idx].num_tx_queues++;
                        priv->tx_queue[i]->grp = &priv->gfargrp[grp_idx];
                        tstat = tstat | (TSTAT_CLEAR_THALT >> i);
@@ -1169,7 +1173,8 @@ static int gfar_probe(struct platform_device *ofdev)
        }
 
        device_init_wakeup(&dev->dev,
-               priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
+                          priv->device_flags &
+                          FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
 
        /* fill out IRQ number and name fields */
        for (i = 0; i < priv->num_grps; i++) {
@@ -1200,7 +1205,7 @@ static int gfar_probe(struct platform_device *ofdev)
        for (i = 0; i < priv->num_rx_queues; i++)
                netdev_info(dev, "RX BD ring size for Q[%d]: %d\n",
                            i, priv->rx_queue[i]->rx_ring_size);
-       for(i = 0; i < priv->num_tx_queues; i++)
+       for (i = 0; i < priv->num_tx_queues; i++)
                netdev_info(dev, "TX BD ring size for Q[%d]: %d\n",
                            i, priv->tx_queue[i]->tx_ring_size);
 
@@ -1247,7 +1252,8 @@ static int gfar_suspend(struct device *dev)
        u32 tempval;
 
        int magic_packet = priv->wol_en &&
-               (priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
+                          (priv->device_flags &
+                           FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
 
        netif_device_detach(ndev);
 
@@ -1299,7 +1305,8 @@ static int gfar_resume(struct device *dev)
        unsigned long flags;
        u32 tempval;
        int magic_packet = priv->wol_en &&
-               (priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
+                          (priv->device_flags &
+                           FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
 
        if (!netif_running(ndev)) {
                netif_device_attach(ndev);
@@ -1398,8 +1405,9 @@ static phy_interface_t gfar_get_interface(struct net_device *dev)
        }
 
        if (ecntrl & ECNTRL_REDUCED_MODE) {
-               if (ecntrl & ECNTRL_REDUCED_MII_MODE)
+               if (ecntrl & ECNTRL_REDUCED_MII_MODE) {
                        return PHY_INTERFACE_MODE_RMII;
+               }
                else {
                        phy_interface_t interface = priv->interface;
 
@@ -1494,11 +1502,12 @@ static void gfar_configure_serdes(struct net_device *dev)
        phy_write(tbiphy, MII_TBICON, TBICON_CLK_SELECT);
 
        phy_write(tbiphy, MII_ADVERTISE,
-                       ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
-                       ADVERTISE_1000XPSE_ASYM);
+                 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
+                 ADVERTISE_1000XPSE_ASYM);
 
-       phy_write(tbiphy, MII_BMCR, BMCR_ANENABLE |
-                       BMCR_ANRESTART | BMCR_FULLDPLX | BMCR_SPEED1000);
+       phy_write(tbiphy, MII_BMCR,
+                 BMCR_ANENABLE | BMCR_ANRESTART | BMCR_FULLDPLX |
+                 BMCR_SPEED1000);
 }
 
 static void init_registers(struct net_device *dev)
@@ -1594,8 +1603,8 @@ static void gfar_halt_nodisable(struct net_device *dev)
        regs = priv->gfargrp[0].regs;
        /* Stop the DMA, and wait for it to stop */
        tempval = gfar_read(&regs->dmactrl);
-       if ((tempval & (DMACTRL_GRS | DMACTRL_GTS))
-           != (DMACTRL_GRS | DMACTRL_GTS)) {
+       if ((tempval & (DMACTRL_GRS | DMACTRL_GTS)) !=
+           (DMACTRL_GRS | DMACTRL_GTS)) {
                int ret;
 
                tempval |= (DMACTRL_GRS | DMACTRL_GTS);
@@ -1660,7 +1669,7 @@ void stop_gfar(struct net_device *dev)
        } else {
                for (i = 0; i < priv->num_grps; i++)
                        free_irq(priv->gfargrp[i].interruptTransmit,
-                                       &priv->gfargrp[i]);
+                                &priv->gfargrp[i]);
        }
 
        free_skb_resources(priv);
@@ -1679,13 +1688,13 @@ static void free_skb_tx_queue(struct gfar_priv_tx_q *tx_queue)
                        continue;
 
                dma_unmap_single(&priv->ofdev->dev, txbdp->bufPtr,
-                               txbdp->length, DMA_TO_DEVICE);
+                                txbdp->length, DMA_TO_DEVICE);
                txbdp->lstatus = 0;
                for (j = 0; j < skb_shinfo(tx_queue->tx_skbuff[i])->nr_frags;
-                               j++) {
+                    j++) {
                        txbdp++;
                        dma_unmap_page(&priv->ofdev->dev, txbdp->bufPtr,
-                                       txbdp->length, DMA_TO_DEVICE);
+                                      txbdp->length, DMA_TO_DEVICE);
                }
                txbdp++;
                dev_kfree_skb_any(tx_queue->tx_skbuff[i]);
@@ -1705,8 +1714,8 @@ static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue)
        for (i = 0; i < rx_queue->rx_ring_size; i++) {
                if (rx_queue->rx_skbuff[i]) {
                        dma_unmap_single(&priv->ofdev->dev,
-                                       rxbdp->bufPtr, priv->rx_buffer_size,
-                                       DMA_FROM_DEVICE);
+                                        rxbdp->bufPtr, priv->rx_buffer_size,
+                                        DMA_FROM_DEVICE);
                        dev_kfree_skb_any(rx_queue->rx_skbuff[i]);
                        rx_queue->rx_skbuff[i] = NULL;
                }
@@ -1729,24 +1738,25 @@ static void free_skb_resources(struct gfar_private *priv)
        /* Go through all the buffer descriptors and free their data buffers */
        for (i = 0; i < priv->num_tx_queues; i++) {
                struct netdev_queue *txq;
+
                tx_queue = priv->tx_queue[i];
                txq = netdev_get_tx_queue(tx_queue->dev, tx_queue->qindex);
-               if(tx_queue->tx_skbuff)
+               if (tx_queue->tx_skbuff)
                        free_skb_tx_queue(tx_queue);
                netdev_tx_reset_queue(txq);
        }
 
        for (i = 0; i < priv->num_rx_queues; i++) {
                rx_queue = priv->rx_queue[i];
-               if(rx_queue->rx_skbuff)
+               if (rx_queue->rx_skbuff)
                        free_skb_rx_queue(rx_queue);
        }
 
        dma_free_coherent(&priv->ofdev->dev,
-                       sizeof(struct txbd8) * priv->total_tx_ring_size +
-                       sizeof(struct rxbd8) * priv->total_rx_ring_size,
-                       priv->tx_queue[0]->tx_bd_base,
-                       priv->tx_queue[0]->tx_bd_dma_base);
+                         sizeof(struct txbd8) * priv->total_tx_ring_size +
+                         sizeof(struct rxbd8) * priv->total_rx_ring_size,
+                         priv->tx_queue[0]->tx_bd_base,
+                         priv->tx_queue[0]->tx_bd_dma_base);
        skb_queue_purge(&priv->rx_recycle);
 }
 
@@ -1785,7 +1795,7 @@ void gfar_start(struct net_device *dev)
 }
 
 void gfar_configure_coalescing(struct gfar_private *priv,
-       unsigned long tx_mask, unsigned long rx_mask)
+                              unsigned long tx_mask, unsigned long rx_mask)
 {
        struct gfar __iomem *regs = priv->gfargrp[0].regs;
        u32 __iomem *baddr;
@@ -1795,11 +1805,11 @@ void gfar_configure_coalescing(struct gfar_private *priv,
         * multiple queues, there's only single reg to program
         */
        gfar_write(&regs->txic, 0);
-       if(likely(priv->tx_queue[0]->txcoalescing))
+       if (likely(priv->tx_queue[0]->txcoalescing))
                gfar_write(&regs->txic, priv->tx_queue[0]->txic);
 
        gfar_write(&regs->rxic, 0);
-       if(unlikely(priv->rx_queue[0]->rxcoalescing))
+       if (unlikely(priv->rx_queue[0]->rxcoalescing))
                gfar_write(&regs->rxic, priv->rx_queue[0]->rxic);
 
        if (priv->mode == MQ_MG_MODE) {
@@ -1834,8 +1844,8 @@ static int register_grp_irqs(struct gfar_priv_grp *grp)
                /* Install our interrupt handlers for Error,
                 * Transmit, and Receive
                 */
-               if ((err = request_irq(grp->interruptError, gfar_error, 0,
-                               grp->int_name_er,grp)) < 0) {
+               if ((err = request_irq(grp->interruptError, gfar_error,
+                                      0, grp->int_name_er, grp)) < 0) {
                        netif_err(priv, intr, dev, "Can't get IRQ %d\n",
                                  grp->interruptError);
 
@@ -1843,21 +1853,21 @@ static int register_grp_irqs(struct gfar_priv_grp *grp)
                }
 
                if ((err = request_irq(grp->interruptTransmit, gfar_transmit,
-                               0, grp->int_name_tx, grp)) < 0) {
+                                      0, grp->int_name_tx, grp)) < 0) {
                        netif_err(priv, intr, dev, "Can't get IRQ %d\n",
                                  grp->interruptTransmit);
                        goto tx_irq_fail;
                }
 
-               if ((err = request_irq(grp->interruptReceive, gfar_receive, 0,
-                               grp->int_name_rx, grp)) < 0) {
+               if ((err = request_irq(grp->interruptReceive, gfar_receive,
+                                      0, grp->int_name_rx, grp)) < 0) {
                        netif_err(priv, intr, dev, "Can't get IRQ %d\n",
                                  grp->interruptReceive);
                        goto rx_irq_fail;
                }
        } else {
-               if ((err = request_irq(grp->interruptTransmit, gfar_interrupt, 0,
-                               grp->int_name_tx, grp)) < 0) {
+               if ((err = request_irq(grp->interruptTransmit, gfar_interrupt,
+                                      0, grp->int_name_tx, grp)) < 0) {
                        netif_err(priv, intr, dev, "Can't get IRQ %d\n",
                                  grp->interruptTransmit);
                        goto err_irq_fail;
@@ -1964,7 +1974,7 @@ static inline struct txfcb *gfar_add_fcb(struct sk_buff *skb)
 }
 
 static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb,
-               int fcb_length)
+                                   int fcb_length)
 {
        u8 flags = 0;
 
@@ -2001,7 +2011,7 @@ void inline gfar_tx_vlan(struct sk_buff *skb, struct txfcb *fcb)
 }
 
 static inline struct txbd8 *skip_txbd(struct txbd8 *bdp, int stride,
-                              struct txbd8 *base, int ring_size)
+                                     struct txbd8 *base, int ring_size)
 {
        struct txbd8 *new_bd = bdp + stride;
 
@@ -2009,7 +2019,7 @@ static inline struct txbd8 *skip_txbd(struct txbd8 *bdp, int stride,
 }
 
 static inline struct txbd8 *next_txbd(struct txbd8 *bdp, struct txbd8 *base,
-               int ring_size)
+                                     int ring_size)
 {
        return skip_txbd(bdp, 1, base, ring_size);
 }
@@ -2035,8 +2045,8 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         * before start of transmission.
         */
        if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_76) &&
-                       skb->ip_summed == CHECKSUM_PARTIAL &&
-                       skb->len > 2500)) {
+                    skb->ip_summed == CHECKSUM_PARTIAL &&
+                    skb->len > 2500)) {
                int ret;
 
                ret = skb_checksum_help(skb);
@@ -2052,16 +2062,16 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
        /* check if time stamp should be generated */
        if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
-                       priv->hwts_tx_en)) {
+                    priv->hwts_tx_en)) {
                do_tstamp = 1;
                fcb_length = GMAC_FCB_LEN + GMAC_TXPAL_LEN;
        }
 
        /* make space for additional header when fcb is needed */
        if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
-                       vlan_tx_tag_present(skb) ||
-                       unlikely(do_tstamp)) &&
-                       (skb_headroom(skb) < fcb_length)) {
+            vlan_tx_tag_present(skb) ||
+            unlikely(do_tstamp)) &&
+           (skb_headroom(skb) < fcb_length)) {
                struct sk_buff *skb_new;
 
                skb_new = skb_realloc_headroom(skb, fcb_length);
@@ -2105,12 +2115,12 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
        /* Time stamp insertion requires one additional TxBD */
        if (unlikely(do_tstamp))
                txbdp_tstamp = txbdp = next_txbd(txbdp, base,
-                               tx_queue->tx_ring_size);
+                                                tx_queue->tx_ring_size);
 
        if (nr_frags == 0) {
                if (unlikely(do_tstamp))
                        txbdp_tstamp->lstatus |= BD_LFLAG(TXBD_LAST |
-                                       TXBD_INTERRUPT);
+                                                         TXBD_INTERRUPT);
                else
                        lstatus |= BD_LFLAG(TXBD_LAST | TXBD_INTERRUPT);
        } else {
@@ -2122,7 +2132,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
                        length = skb_shinfo(skb)->frags[i].size;
 
                        lstatus = txbdp->lstatus | length |
-                               BD_LFLAG(TXBD_READY);
+                                 BD_LFLAG(TXBD_READY);
 
                        /* Handle the last BD specially */
                        if (i == nr_frags - 1)
@@ -2152,8 +2162,8 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
        if (CHECKSUM_PARTIAL == skb->ip_summed) {
                fcb = gfar_add_fcb(skb);
                /* as specified by errata */
-               if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_12)
-                            && ((unsigned long)fcb % 0x20) > 0x18)) {
+               if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_12) &&
+                            ((unsigned long)fcb % 0x20) > 0x18)) {
                        __skb_pull(skb, GMAC_FCB_LEN);
                        skb_checksum_help(skb);
                } else {
@@ -2181,7 +2191,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
        }
 
        txbdp_start->bufPtr = dma_map_single(&priv->ofdev->dev, skb->data,
-                       skb_headlen(skb), DMA_TO_DEVICE);
+                                            skb_headlen(skb), DMA_TO_DEVICE);
 
        /* If time stamping is requested one additional TxBD must be set up. The
         * first TxBD points to the FCB and must have a data length of
@@ -2191,7 +2201,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
        if (unlikely(do_tstamp)) {
                txbdp_tstamp->bufPtr = txbdp_start->bufPtr + fcb_length;
                txbdp_tstamp->lstatus |= BD_LFLAG(TXBD_READY) |
-                               (skb_headlen(skb) - fcb_length);
+                                        (skb_headlen(skb) - fcb_length);
                lstatus |= BD_LFLAG(TXBD_CRC | TXBD_READY) | GMAC_FCB_LEN;
        } else {
                lstatus |= BD_LFLAG(TXBD_CRC | TXBD_READY) | skb_headlen(skb);
@@ -2231,7 +2241,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         * (wrapping if necessary)
         */
        tx_queue->skb_curtx = (tx_queue->skb_curtx + 1) &
-               TX_RING_MOD_MASK(tx_queue->tx_ring_size);
+                             TX_RING_MOD_MASK(tx_queue->tx_ring_size);
 
        tx_queue->cur_tx = next_txbd(txbdp, base, tx_queue->tx_ring_size);
 
@@ -2365,9 +2375,8 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
 
        frame_size += priv->padding;
 
-       tempsize =
-           (frame_size & ~(INCREMENTAL_BUFFER_SIZE - 1)) +
-           INCREMENTAL_BUFFER_SIZE;
+       tempsize = (frame_size & ~(INCREMENTAL_BUFFER_SIZE - 1)) +
+                  INCREMENTAL_BUFFER_SIZE;
 
        /* Only stop and start the controller if it isn't already
         * stopped, and we changed something
@@ -2389,7 +2398,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
        tempval = gfar_read(&regs->maccfg2);
 
        if (priv->rx_buffer_size > DEFAULT_RX_BUFFER_SIZE ||
-                       gfar_has_errata(priv, GFAR_ERRATA_74))
+           gfar_has_errata(priv, GFAR_ERRATA_74))
                tempval |= (MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK);
        else
                tempval &= ~(MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK);
@@ -2410,7 +2419,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
 static void gfar_reset_task(struct work_struct *work)
 {
        struct gfar_private *priv = container_of(work, struct gfar_private,
-                       reset_task);
+                                                reset_task);
        struct net_device *dev = priv->ndev;
 
        if (dev->flags & IFF_UP) {
@@ -2437,7 +2446,7 @@ static void gfar_align_skb(struct sk_buff *skb)
         * as many bytes as needed to align the data properly
         */
        skb_reserve(skb, RXBUF_ALIGNMENT -
-               (((unsigned long) skb->data) & (RXBUF_ALIGNMENT - 1)));
+                   (((unsigned long) skb->data) & (RXBUF_ALIGNMENT - 1)));
 }
 
 /* Interrupt Handler for Transmit complete */
@@ -2485,7 +2494,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
 
                /* Only clean completed frames */
                if ((lstatus & BD_LFLAG(TXBD_READY)) &&
-                               (lstatus & BD_LENGTH_MASK))
+                   (lstatus & BD_LENGTH_MASK))
                        break;
 
                if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
@@ -2495,11 +2504,12 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                        buflen = bdp->length;
 
                dma_unmap_single(&priv->ofdev->dev, bdp->bufPtr,
-                               buflen, DMA_TO_DEVICE);
+                                buflen, DMA_TO_DEVICE);
 
                if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
                        struct skb_shared_hwtstamps shhwtstamps;
                        u64 *ns = (u64*) (((u32)skb->data + 0x10) & ~0x7);
+
                        memset(&shhwtstamps, 0, sizeof(shhwtstamps));
                        shhwtstamps.hwtstamp = ns_to_ktime(*ns);
                        skb_pull(skb, GMAC_FCB_LEN + GMAC_TXPAL_LEN);
@@ -2512,10 +2522,8 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                bdp = next_txbd(bdp, base, tx_ring_size);
 
                for (i = 0; i < frags; i++) {
-                       dma_unmap_page(&priv->ofdev->dev,
-                                       bdp->bufPtr,
-                                       bdp->length,
-                                       DMA_TO_DEVICE);
+                       dma_unmap_page(&priv->ofdev->dev, bdp->bufPtr,
+                                      bdp->length, DMA_TO_DEVICE);
                        bdp->lstatus &= BD_LFLAG(TXBD_WRAP);
                        bdp = next_txbd(bdp, base, tx_ring_size);
                }
@@ -2526,8 +2534,8 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                 * we add this skb back into the pool, if it's the right size
                 */
                if (skb_queue_len(&priv->rx_recycle) < rx_queue->rx_ring_size &&
-                               skb_recycle_check(skb, priv->rx_buffer_size +
-                                       RXBUF_ALIGNMENT)) {
+                   skb_recycle_check(skb, priv->rx_buffer_size +
+                                     RXBUF_ALIGNMENT)) {
                        gfar_align_skb(skb);
                        skb_queue_head(&priv->rx_recycle, skb);
                } else
@@ -2536,7 +2544,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                tx_queue->tx_skbuff[skb_dirtytx] = NULL;
 
                skb_dirtytx = (skb_dirtytx + 1) &
-                       TX_RING_MOD_MASK(tx_ring_size);
+                             TX_RING_MOD_MASK(tx_ring_size);
 
                howmany++;
                spin_lock_irqsave(&tx_queue->txlock, flags);
@@ -2583,7 +2591,7 @@ static irqreturn_t gfar_transmit(int irq, void *grp_id)
 }
 
 static void gfar_new_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
-               struct sk_buff *skb)
+                          struct sk_buff *skb)
 {
        struct net_device *dev = rx_queue->dev;
        struct gfar_private *priv = netdev_priv(dev);
@@ -2700,6 +2708,7 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
        if (priv->hwts_rx_en) {
                struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
                u64 *ns = (u64 *) skb->data;
+
                memset(shhwtstamps, 0, sizeof(*shhwtstamps));
                shhwtstamps->hwtstamp = ns_to_ktime(*ns);
        }
@@ -2752,6 +2761,7 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
 
        while (!((bdp->status & RXBD_EMPTY) || (--rx_work_limit < 0))) {
                struct sk_buff *newskb;
+
                rmb();
 
                /* Add another skb for the future */
@@ -2760,15 +2770,15 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
                skb = rx_queue->rx_skbuff[rx_queue->skb_currx];
 
                dma_unmap_single(&priv->ofdev->dev, bdp->bufPtr,
-                               priv->rx_buffer_size, DMA_FROM_DEVICE);
+                                priv->rx_buffer_size, DMA_FROM_DEVICE);
 
                if (unlikely(!(bdp->status & RXBD_ERR) &&
-                               bdp->length > priv->rx_buffer_size))
+                            bdp->length > priv->rx_buffer_size))
                        bdp->status = RXBD_LARGE;
 
                /* We drop the frame if we failed to allocate a new buffer */
                if (unlikely(!newskb || !(bdp->status & RXBD_LAST) ||
-                                bdp->status & RXBD_ERR)) {
+                            bdp->status & RXBD_ERR)) {
                        count_errors(bdp->status, dev);
 
                        if (unlikely(!newskb))
@@ -2787,7 +2797,7 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
                                rx_queue->stats.rx_bytes += pkt_len;
                                skb_record_rx_queue(skb, rx_queue->qindex);
                                gfar_process_frame(dev, skb, amount_pull,
-                                               &rx_queue->grp->napi);
+                                                  &rx_queue->grp->napi);
 
                        } else {
                                netif_warn(priv, rx_err, dev, "Missing skb!\n");
@@ -2806,9 +2816,8 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
                bdp = next_bd(bdp, base, rx_queue->rx_ring_size);
 
                /* update to point at the next skb */
-               rx_queue->skb_currx =
-                   (rx_queue->skb_currx + 1) &
-                   RX_RING_MOD_MASK(rx_queue->rx_ring_size);
+               rx_queue->skb_currx = (rx_queue->skb_currx + 1) &
+                                     RX_RING_MOD_MASK(rx_queue->rx_ring_size);
        }
 
        /* Update the current rxbd pointer to be the next one */
@@ -2819,8 +2828,8 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
 
 static int gfar_poll(struct napi_struct *napi, int budget)
 {
-       struct gfar_priv_grp *gfargrp = container_of(napi,
-                       struct gfar_priv_grp, napi);
+       struct gfar_priv_grp *gfargrp =
+               container_of(napi, struct gfar_priv_grp, napi);
        struct gfar_private *priv = gfargrp->priv;
        struct gfar __iomem *regs = gfargrp->regs;
        struct gfar_priv_tx_q *tx_queue = NULL;
@@ -2839,7 +2848,6 @@ static int gfar_poll(struct napi_struct *napi, int budget)
        gfar_write(&regs->ievent, IEVENT_RTX_MASK);
 
        while (num_queues && left_over_budget) {
-
                budget_per_queue = left_over_budget/num_queues;
                left_over_budget = 0;
 
@@ -2850,12 +2858,13 @@ static int gfar_poll(struct napi_struct *napi, int budget)
                        tx_queue = priv->tx_queue[rx_queue->qindex];
 
                        tx_cleaned += gfar_clean_tx_ring(tx_queue);
-                       rx_cleaned_per_queue = gfar_clean_rx_ring(rx_queue,
-                                                       budget_per_queue);
+                       rx_cleaned_per_queue =
+                               gfar_clean_rx_ring(rx_queue, budget_per_queue);
                        rx_cleaned += rx_cleaned_per_queue;
-                       if(rx_cleaned_per_queue < budget_per_queue) {
+                       if (rx_cleaned_per_queue < budget_per_queue) {
                                left_over_budget = left_over_budget +
-                                       (budget_per_queue - rx_cleaned_per_queue);
+                                       (budget_per_queue -
+                                        rx_cleaned_per_queue);
                                set_bit(i, &serviced_queues);
                                num_queues--;
                        }
@@ -2876,8 +2885,8 @@ static int gfar_poll(struct napi_struct *napi, int budget)
                /* If we are coalescing interrupts, update the timer
                 * Otherwise, clear it
                 */
-               gfar_configure_coalescing(priv,
-                               gfargrp->rx_bit_map, gfargrp->tx_bit_map);
+               gfar_configure_coalescing(priv, gfargrp->rx_bit_map,
+                                         gfargrp->tx_bit_map);
        }
 
        return rx_cleaned;
@@ -2900,7 +2909,7 @@ static void gfar_netpoll(struct net_device *dev)
                        disable_irq(priv->gfargrp[i].interruptReceive);
                        disable_irq(priv->gfargrp[i].interruptError);
                        gfar_interrupt(priv->gfargrp[i].interruptTransmit,
-                                               &priv->gfargrp[i]);
+                                      &priv->gfargrp[i]);
                        enable_irq(priv->gfargrp[i].interruptError);
                        enable_irq(priv->gfargrp[i].interruptReceive);
                        enable_irq(priv->gfargrp[i].interruptTransmit);
@@ -2909,7 +2918,7 @@ static void gfar_netpoll(struct net_device *dev)
                for (i = 0; i < priv->num_grps; i++) {
                        disable_irq(priv->gfargrp[i].interruptTransmit);
                        gfar_interrupt(priv->gfargrp[i].interruptTransmit,
-                                               &priv->gfargrp[i]);
+                                      &priv->gfargrp[i]);
                        enable_irq(priv->gfargrp[i].interruptTransmit);
                }
        }
@@ -3125,7 +3134,7 @@ static void gfar_clear_exact_match(struct net_device *dev)
        int idx;
        static const u8 zero_arr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
 
-       for(idx = 1;idx < GFAR_EM_NUM + 1;idx++)
+       for (idx = 1; idx < GFAR_EM_NUM + 1; idx++)
                gfar_set_mac_for_addr(dev, idx, zero_arr);
 }
 
@@ -3208,7 +3217,8 @@ static irqreturn_t gfar_error(int irq, void *grp_id)
 
        /* Hmm... */
        if (netif_msg_rx_err(priv) || netif_msg_tx_err(priv))
-               netdev_dbg(dev, "error interrupt (ievent=0x%08x imask=0x%08x)\n",
+               netdev_dbg(dev,
+                          "error interrupt (ievent=0x%08x imask=0x%08x)\n",
                           events, gfar_read(&regs->imask));
 
        /* Update the error counters */