1 files changed, 89 insertions, 70 deletions

diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 4f7c3f3ca234..dfa55f94ba7f 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -10,7 +10,7 @@
  * Maintainer: Kumar Gala
  * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
  *
- * Copyright 2002-2009 Freescale Semiconductor, Inc.
+ * Copyright 2002-2009, 2011 Freescale Semiconductor, Inc.
  * Copyright 2007 MontaVista Software, Inc.
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -95,6 +95,7 @@
 #include <linux/phy.h>
 #include <linux/phy_fixed.h>
 #include <linux/of.h>
+#include <linux/of_net.h>
 
 #include "gianfar.h"
 #include "fsl_pq_mdio.h"
@@ -122,8 +123,7 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id);
 static void adjust_link(struct net_device *dev);
 static void init_registers(struct net_device *dev);
 static int init_phy(struct net_device *dev);
-static int gfar_probe(struct platform_device *ofdev,
-                const struct of_device_id *match);
+static int gfar_probe(struct platform_device *ofdev);
 static int gfar_remove(struct platform_device *ofdev);
 static void free_skb_resources(struct gfar_private *priv);
 static void gfar_set_multi(struct net_device *dev);
@@ -143,7 +143,8 @@ void gfar_halt(struct net_device *dev);
 static void gfar_halt_nodisable(struct net_device *dev);
 void gfar_start(struct net_device *dev);
 static void gfar_clear_exact_match(struct net_device *dev);
-static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr);
+static void gfar_set_mac_for_addr(struct net_device *dev, int num,
+                                  const u8 *addr);
 static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 
 MODULE_AUTHOR("Freescale Semiconductor, Inc");
@@ -364,7 +365,7 @@ static void gfar_init_mac(struct net_device *ndev)
                 gfar_write(&regs->rir0, DEFAULT_RIR0);
         }
 
-        if (priv->rx_csum_enable)
+        if (ndev->features & NETIF_F_RXCSUM)
                 rctrl |= RCTRL_CHECKSUMMING;
 
         if (priv->extended_hash) {
@@ -432,7 +433,6 @@ static void gfar_init_mac(struct net_device *ndev)
 static struct net_device_stats *gfar_get_stats(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct netdev_queue *txq;
         unsigned long rx_packets = 0, rx_bytes = 0, rx_dropped = 0;
         unsigned long tx_packets = 0, tx_bytes = 0;
         int i = 0;
@@ -448,9 +448,8 @@ static struct net_device_stats *gfar_get_stats(struct net_device *dev)
         dev->stats.rx_dropped = rx_dropped;
 
         for (i = 0; i < priv->num_tx_queues; i++) {
-                txq = netdev_get_tx_queue(dev, i);
-                tx_bytes += txq->tx_bytes;
-                tx_packets += txq->tx_packets;
+                tx_bytes += priv->tx_queue[i]->stats.tx_bytes;
+                tx_packets += priv->tx_queue[i]->stats.tx_packets;
         }
 
         dev->stats.tx_bytes = tx_bytes;
@@ -464,6 +463,7 @@ static const struct net_device_ops gfar_netdev_ops = {
         .ndo_start_xmit = gfar_start_xmit,
         .ndo_stop = gfar_close,
         .ndo_change_mtu = gfar_change_mtu,
+        .ndo_set_features = gfar_set_features,
         .ndo_set_multicast_list = gfar_set_multi,
         .ndo_tx_timeout = gfar_timeout,
         .ndo_do_ioctl = gfar_ioctl,
@@ -476,9 +476,6 @@ static const struct net_device_ops gfar_netdev_ops = {
 #endif
 };
 
-unsigned int ftp_rqfpr[MAX_FILER_IDX + 1];
-unsigned int ftp_rqfcr[MAX_FILER_IDX + 1];
-
 void lock_rx_qs(struct gfar_private *priv)
 {
         int i = 0x0;
@@ -514,7 +511,7 @@ void unlock_tx_qs(struct gfar_private *priv)
 /* Returns 1 if incoming frames use an FCB */
 static inline int gfar_uses_fcb(struct gfar_private *priv)
 {
-        return priv->vlgrp || priv->rx_csum_enable ||
+        return priv->vlgrp || (priv->ndev->features & NETIF_F_RXCSUM) ||
                 (priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER);
 }
 
@@ -577,11 +574,10 @@ static int gfar_parse_group(struct device_node *np,
                         irq_of_parse_and_map(np, 1);
                 priv->gfargrp[priv->num_grps].interruptError =
                         irq_of_parse_and_map(np,2);
-                if (priv->gfargrp[priv->num_grps].interruptTransmit < 0 ||
-                        priv->gfargrp[priv->num_grps].interruptReceive < 0 ||
-                        priv->gfargrp[priv->num_grps].interruptError < 0) {
+                if (priv->gfargrp[priv->num_grps].interruptTransmit == NO_IRQ ||
+                    priv->gfargrp[priv->num_grps].interruptReceive  == NO_IRQ ||
+                    priv->gfargrp[priv->num_grps].interruptError    == NO_IRQ)
                         return -EINVAL;
-                }
         }
 
         priv->gfargrp[priv->num_grps].grp_id = priv->num_grps;
@@ -654,9 +650,8 @@ static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
         priv->node = ofdev->dev.of_node;
         priv->ndev = dev;
 
-        dev->num_tx_queues = num_tx_qs;
-        dev->real_num_tx_queues = num_tx_qs;
         priv->num_tx_queues = num_tx_qs;
+        netif_set_real_num_rx_queues(dev, num_rx_qs);
         priv->num_rx_queues = num_rx_qs;
         priv->num_grps = 0x0;
 
@@ -870,28 +865,28 @@ static u32 cluster_entry_per_class(struct gfar_private *priv, u32 rqfar,
 
         rqfar--;
         rqfcr = RQFCR_CLE | RQFCR_PID_MASK | RQFCR_CMP_EXACT;
-        ftp_rqfpr[rqfar] = rqfpr;
-        ftp_rqfcr[rqfar] = rqfcr;
+        priv->ftp_rqfpr[rqfar] = rqfpr;
+        priv->ftp_rqfcr[rqfar] = rqfcr;
         gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
 
         rqfar--;
         rqfcr = RQFCR_CMP_NOMATCH;
-        ftp_rqfpr[rqfar] = rqfpr;
-        ftp_rqfcr[rqfar] = rqfcr;
+        priv->ftp_rqfpr[rqfar] = rqfpr;
+        priv->ftp_rqfcr[rqfar] = rqfcr;
         gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
 
         rqfar--;
         rqfcr = RQFCR_CMP_EXACT | RQFCR_PID_PARSE | RQFCR_CLE | RQFCR_AND;
         rqfpr = class;
-        ftp_rqfcr[rqfar] = rqfcr;
-        ftp_rqfpr[rqfar] = rqfpr;
+        priv->ftp_rqfcr[rqfar] = rqfcr;
+        priv->ftp_rqfpr[rqfar] = rqfpr;
         gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
 
         rqfar--;
         rqfcr = RQFCR_CMP_EXACT | RQFCR_PID_MASK | RQFCR_AND;
         rqfpr = class;
-        ftp_rqfcr[rqfar] = rqfcr;
-        ftp_rqfpr[rqfar] = rqfpr;
+        priv->ftp_rqfcr[rqfar] = rqfcr;
+        priv->ftp_rqfpr[rqfar] = rqfpr;
         gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
 
         return rqfar;
@@ -906,8 +901,8 @@ static void gfar_init_filer_table(struct gfar_private *priv)
 
         /* Default rule */
         rqfcr = RQFCR_CMP_MATCH;
-        ftp_rqfcr[rqfar] = rqfcr;
-        ftp_rqfpr[rqfar] = rqfpr;
+        priv->ftp_rqfcr[rqfar] = rqfcr;
+        priv->ftp_rqfpr[rqfar] = rqfpr;
         gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
 
         rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6);
@@ -923,8 +918,8 @@ static void gfar_init_filer_table(struct gfar_private *priv)
         /* Rest are masked rules */
         rqfcr = RQFCR_CMP_NOMATCH;
         for (i = 0; i < rqfar; i++) {
-                ftp_rqfcr[i] = rqfcr;
-                ftp_rqfpr[i] = rqfpr;
+                priv->ftp_rqfcr[i] = rqfcr;
+                priv->ftp_rqfpr[i] = rqfpr;
                 gfar_write_filer(priv, i, rqfcr, rqfpr);
         }
 }
@@ -952,6 +947,11 @@ static void gfar_detect_errata(struct gfar_private *priv)
                         (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))
+                priv->errata |= GFAR_ERRATA_12;
+
         if (priv->errata)
                 dev_info(dev, "enabled errata workarounds, flags: 0x%x\n",
                          priv->errata);
@@ -959,8 +959,7 @@ static void gfar_detect_errata(struct gfar_private *priv)
 
 /* Set up the ethernet device structure, private data,
  * and anything else we need before we start */
-static int gfar_probe(struct platform_device *ofdev,
-                const struct of_device_id *match)
+static int gfar_probe(struct platform_device *ofdev)
 {
         u32 tempval;
         struct net_device *dev = NULL;
@@ -1029,10 +1028,11 @@ static int gfar_probe(struct platform_device *ofdev,
                 netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll, GFAR_DEV_WEIGHT);
 
         if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
-                priv->rx_csum_enable = 1;
-                dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_HIGHDMA;
-        } else
-                priv->rx_csum_enable = 0;
+                dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+                        NETIF_F_RXCSUM;
+                dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG |
+                        NETIF_F_RXCSUM | NETIF_F_HIGHDMA;
+        }
 
         priv->vlgrp = NULL;
 
@@ -1859,7 +1859,7 @@ static int register_grp_irqs(struct gfar_priv_grp *grp)
                                 printk(KERN_ERR "%s: Can't get IRQ %d\n",
                                         dev->name, grp->interruptError);
 
-                                goto err_irq_fail;
+                        goto err_irq_fail;
                 }
 
                 if ((err = request_irq(grp->interruptTransmit, gfar_transmit,
@@ -1922,7 +1922,7 @@ int startup_gfar(struct net_device *ndev)
                 if (err) {
                         for (j = 0; j < i; j++)
                                 free_grp_irqs(&priv->gfargrp[j]);
-                                goto irq_fail;
+                        goto irq_fail;
                 }
         }
 
@@ -2048,7 +2048,6 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         u32 bufaddr;
         unsigned long flags;
         unsigned int nr_frags, nr_txbds, length;
-        union skb_shared_tx *shtx;
 
         /*
          * TOE=1 frames larger than 2500 bytes may see excess delays
@@ -2069,15 +2068,15 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         txq = netdev_get_tx_queue(dev, rq);
         base = tx_queue->tx_bd_base;
         regs = tx_queue->grp->regs;
-        shtx = skb_tx(skb);
 
         /* check if time stamp should be generated */
-        if (unlikely(shtx->hardware && priv->hwts_tx_en))
+        if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
+                     priv->hwts_tx_en))
                 do_tstamp = 1;
 
         /* make space for additional header when fcb is needed */
         if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
-                        (priv->vlgrp && vlan_tx_tag_present(skb)) ||
+                        vlan_tx_tag_present(skb) ||
                         unlikely(do_tstamp)) &&
                         (skb_headroom(skb) < GMAC_FCB_LEN)) {
                 struct sk_buff *skb_new;
@@ -2110,8 +2109,8 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         /* Update transmit stats */
-        txq->tx_bytes += skb->len;
-        txq->tx_packets ++;
+        tx_queue->stats.tx_bytes += skb->len;
+        tx_queue->stats.tx_packets++;
 
         txbdp = txbdp_start = tx_queue->cur_tx;
         lstatus = txbdp->lstatus;
@@ -2159,11 +2158,18 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         /* Set up checksumming */
         if (CHECKSUM_PARTIAL == skb->ip_summed) {
                 fcb = gfar_add_fcb(skb);
-                lstatus |= BD_LFLAG(TXBD_TOE);
-                gfar_tx_checksum(skb, fcb);
+                /* as specified by errata */
+                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 {
+                        lstatus |= BD_LFLAG(TXBD_TOE);
+                        gfar_tx_checksum(skb, fcb);
+                }
         }
 
-        if (priv->vlgrp && vlan_tx_tag_present(skb)) {
+        if (vlan_tx_tag_present(skb)) {
                 if (unlikely(NULL == fcb)) {
                         fcb = gfar_add_fcb(skb);
                         lstatus |= BD_LFLAG(TXBD_TOE);
@@ -2174,7 +2180,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* Setup tx hardware time stamping if requested */
         if (unlikely(do_tstamp)) {
-                shtx->in_progress = 1;
+                skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
                 if (fcb == NULL)
                         fcb = gfar_add_fcb(skb);
                 fcb->ptp = 1;
@@ -2283,6 +2289,23 @@ static int gfar_set_mac_address(struct net_device *dev)
         return 0;
 }
 
+/* Check if rx parser should be activated */
+void gfar_check_rx_parser_mode(struct gfar_private *priv)
+{
+        struct gfar __iomem *regs;
+        u32 tempval;
+
+        regs = priv->gfargrp[0].regs;
+
+        tempval = gfar_read(&regs->rctrl);
+        /* If parse is no longer required, then disable parser */
+        if (tempval & RCTRL_REQ_PARSER)
+                tempval |= RCTRL_PRSDEP_INIT;
+        else
+                tempval &= ~RCTRL_PRSDEP_INIT;
+        gfar_write(&regs->rctrl, tempval);
+}
+
 
 /* Enables and disables VLAN insertion/extraction */
 static void gfar_vlan_rx_register(struct net_device *dev,
@@ -2319,12 +2342,9 @@ static void gfar_vlan_rx_register(struct net_device *dev,
                 /* Disable VLAN tag extraction */
                 tempval = gfar_read(&regs->rctrl);
                 tempval &= ~RCTRL_VLEX;
-                /* If parse is no longer required, then disable parser */
-                if (tempval & RCTRL_REQ_PARSER)
-                        tempval |= RCTRL_PRSDEP_INIT;
-                else
-                        tempval &= ~RCTRL_PRSDEP_INIT;
                 gfar_write(&regs->rctrl, tempval);
+
+                gfar_check_rx_parser_mode(priv);
         }
 
         gfar_change_mtu(dev, dev->mtu);
@@ -2446,7 +2466,6 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
         int howmany = 0;
         u32 lstatus;
         size_t buflen;
-        union skb_shared_tx *shtx;
 
         rx_queue = priv->rx_queue[tx_queue->qindex];
         bdp = tx_queue->dirty_tx;
@@ -2461,8 +2480,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                  * When time stamping, one additional TxBD must be freed.
                  * Also, we need to dma_unmap_single() the TxPAL.
                  */
-                shtx = skb_tx(skb);
-                if (unlikely(shtx->in_progress))
+                if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
                         nr_txbds = frags + 2;
                 else
                         nr_txbds = frags + 1;
@@ -2476,7 +2494,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                                 (lstatus & BD_LENGTH_MASK))
                         break;
 
-                if (unlikely(shtx->in_progress)) {
+                if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
                         next = next_txbd(bdp, base, tx_ring_size);
                         buflen = next->length + GMAC_FCB_LEN;
                 } else
@@ -2485,7 +2503,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                 dma_unmap_single(&priv->ofdev->dev, bdp->bufPtr,
                                 buflen, DMA_TO_DEVICE);
 
-                if (unlikely(shtx->in_progress)) {
+                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));
@@ -2515,7 +2533,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                                 skb_recycle_check(skb, priv->rx_buffer_size +
                                         RXBUF_ALIGNMENT)) {
                         gfar_align_skb(skb);
-                        __skb_queue_head(&priv->rx_recycle, skb);
+                        skb_queue_head(&priv->rx_recycle, skb);
                 } else
                         dev_kfree_skb_any(skb);
 
@@ -2598,7 +2616,7 @@ struct sk_buff * gfar_new_skb(struct net_device *dev)
         struct gfar_private *priv = netdev_priv(dev);
         struct sk_buff *skb = NULL;
 
-        skb = __skb_dequeue(&priv->rx_recycle);
+        skb = skb_dequeue(&priv->rx_recycle);
         if (!skb)
                 skb = gfar_alloc_skb(dev);
 
@@ -2657,7 +2675,7 @@ static inline void gfar_rx_checksum(struct sk_buff *skb, struct rxfcb *fcb)
         if ((fcb->flags & RXFCB_CSUM_MASK) == (RXFCB_CIP | RXFCB_CTU))
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
         else
-                skb->ip_summed = CHECKSUM_NONE;
+                skb_checksum_none_assert(skb);
 }
 
 
@@ -2692,7 +2710,7 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
         if (priv->padding)
                 skb_pull(skb, priv->padding);
 
-        if (priv->rx_csum_enable)
+        if (dev->features & NETIF_F_RXCSUM)
                 gfar_rx_checksum(skb, fcb);
 
         /* Tell the skb what kind of packet this is */
@@ -2754,7 +2772,7 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
                         if (unlikely(!newskb))
                                 newskb = skb;
                         else if (skb)
-                                __skb_queue_head(&priv->rx_recycle, skb);
+                                skb_queue_head(&priv->rx_recycle, skb);
                 } else {
                         /* Increment the number of packets */
                         rx_queue->stats.rx_packets++;
@@ -3099,10 +3117,10 @@ static void gfar_set_multi(struct net_device *dev)
 static void gfar_clear_exact_match(struct net_device *dev)
 {
         int idx;
-        u8 zero_arr[MAC_ADDR_LEN] = {0,0,0,0,0,0};
+        static const u8 zero_arr[MAC_ADDR_LEN] = {0, 0, 0, 0, 0, 0};
 
         for(idx = 1;idx < GFAR_EM_NUM + 1;idx++)
-                gfar_set_mac_for_addr(dev, idx, (u8 *)zero_arr);
+                gfar_set_mac_for_addr(dev, idx, zero_arr);
 }
 
 /* Set the appropriate hash bit for the given addr */
@@ -3137,7 +3155,8 @@ static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr)
 /* There are multiple MAC Address register pairs on some controllers
  * This function sets the numth pair to a given address
  */
-static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr)
+static void gfar_set_mac_for_addr(struct net_device *dev, int num,
+                                  const u8 *addr)
 {
         struct gfar_private *priv = netdev_priv(dev);
         struct gfar __iomem *regs = priv->gfargrp[0].regs;
@@ -3260,7 +3279,7 @@ static struct of_device_id gfar_match[] =
 MODULE_DEVICE_TABLE(of, gfar_match);
 
 /* Structure for a device driver */
-static struct of_platform_driver gfar_driver = {
+static struct platform_driver gfar_driver = {
         .driver = {
                 .name = "fsl-gianfar",
                 .owner = THIS_MODULE,
@@ -3273,12 +3292,12 @@ static struct of_platform_driver gfar_driver = {
 
 static int __init gfar_init(void)
 {
-        return of_register_platform_driver(&gfar_driver);
+        return platform_driver_register(&gfar_driver);
 }
 
 static void __exit gfar_exit(void)
 {
-        of_unregister_platform_driver(&gfar_driver);
+        platform_driver_unregister(&gfar_driver);
 }
 
 module_init(gfar_init);