5 files changed, 330 insertions, 243 deletions

diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index ff875028fdff..648ca85c5859 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -109,15 +109,15 @@
 
 #define TX_TIMEOUT      (1*HZ)
 
-const char gfar_driver_version[] = "1.3";
+const char gfar_driver_version[] = "2.0";
 
 static int gfar_enet_open(struct net_device *dev);
 static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static void gfar_reset_task(struct work_struct *work);
 static void gfar_timeout(struct net_device *dev);
 static int gfar_close(struct net_device *dev);
-static struct sk_buff *gfar_new_skb(struct net_device *dev,
-                                    dma_addr_t *bufaddr);
+static void gfar_alloc_rx_buffs(struct gfar_priv_rx_q *rx_queue,
+                                int alloc_cnt);
 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);
@@ -141,8 +141,7 @@ static void gfar_netpoll(struct net_device *dev);
 #endif
 int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit);
 static void gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue);
-static void gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
-                               int amount_pull, struct napi_struct *napi);
+static void gfar_process_frame(struct net_device *ndev, struct sk_buff *skb);
 static void gfar_halt_nodisable(struct gfar_private *priv);
 static void gfar_clear_exact_match(struct net_device *dev);
 static void gfar_set_mac_for_addr(struct net_device *dev, int num,
@@ -169,17 +168,15 @@ static void gfar_init_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
         bdp->lstatus = cpu_to_be32(lstatus);
 }
 
-static int gfar_init_bds(struct net_device *ndev)
+static void gfar_init_bds(struct net_device *ndev)
 {
         struct gfar_private *priv = netdev_priv(ndev);
         struct gfar __iomem *regs = priv->gfargrp[0].regs;
         struct gfar_priv_tx_q *tx_queue = NULL;
         struct gfar_priv_rx_q *rx_queue = NULL;
         struct txbd8 *txbdp;
-        struct rxbd8 *rxbdp;
         u32 __iomem *rfbptr;
         int i, j;
-        dma_addr_t bufaddr;
 
         for (i = 0; i < priv->num_tx_queues; i++) {
                 tx_queue = priv->tx_queue[i];
@@ -207,40 +204,26 @@ static int gfar_init_bds(struct net_device *ndev)
         rfbptr = &regs->rfbptr0;
         for (i = 0; i < priv->num_rx_queues; i++) {
                 rx_queue = priv->rx_queue[i];
-                rx_queue->cur_rx = rx_queue->rx_bd_base;
-                rx_queue->skb_currx = 0;
-                rxbdp = rx_queue->rx_bd_base;
 
-                for (j = 0; j < rx_queue->rx_ring_size; j++) {
-                        struct sk_buff *skb = rx_queue->rx_skbuff[j];
+                rx_queue->next_to_clean = 0;
+                rx_queue->next_to_use = 0;
+                rx_queue->next_to_alloc = 0;
 
-                        if (skb) {
-                                bufaddr = be32_to_cpu(rxbdp->bufPtr);
-                        } else {
-                                skb = gfar_new_skb(ndev, &bufaddr);
-                                if (!skb) {
-                                        netdev_err(ndev, "Can't allocate RX buffers\n");
-                                        return -ENOMEM;
-                                }
-                                rx_queue->rx_skbuff[j] = skb;
-                        }
-
-                        gfar_init_rxbdp(rx_queue, rxbdp, bufaddr);
-                        rxbdp++;
-                }
+                /* make sure next_to_clean != next_to_use after this
+                 * by leaving at least 1 unused descriptor
+                 */
+                gfar_alloc_rx_buffs(rx_queue, gfar_rxbd_unused(rx_queue));
 
                 rx_queue->rfbptr = rfbptr;
                 rfbptr += 2;
         }
-
-        return 0;
 }
 
 static int gfar_alloc_skb_resources(struct net_device *ndev)
 {
         void *vaddr;
         dma_addr_t addr;
-        int i, j, k;
+        int i, j;
         struct gfar_private *priv = netdev_priv(ndev);
         struct device *dev = priv->dev;
         struct gfar_priv_tx_q *tx_queue = NULL;
@@ -279,7 +262,8 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
                 rx_queue = priv->rx_queue[i];
                 rx_queue->rx_bd_base = vaddr;
                 rx_queue->rx_bd_dma_base = addr;
-                rx_queue->dev = ndev;
+                rx_queue->ndev = ndev;
+                rx_queue->dev = dev;
                 addr  += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
                 vaddr += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
         }
@@ -294,25 +278,20 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
                 if (!tx_queue->tx_skbuff)
                         goto cleanup;
 
-                for (k = 0; k < tx_queue->tx_ring_size; k++)
-                        tx_queue->tx_skbuff[k] = NULL;
+                for (j = 0; j < tx_queue->tx_ring_size; j++)
+                        tx_queue->tx_skbuff[j] = NULL;
         }
 
         for (i = 0; i < priv->num_rx_queues; i++) {
                 rx_queue = priv->rx_queue[i];
-                rx_queue->rx_skbuff =
-                        kmalloc_array(rx_queue->rx_ring_size,
-                                      sizeof(*rx_queue->rx_skbuff),
-                                      GFP_KERNEL);
-                if (!rx_queue->rx_skbuff)
+                rx_queue->rx_buff = kcalloc(rx_queue->rx_ring_size,
+                                            sizeof(*rx_queue->rx_buff),
+                                            GFP_KERNEL);
+                if (!rx_queue->rx_buff)
                         goto cleanup;
-
-                for (j = 0; j < rx_queue->rx_ring_size; j++)
-                        rx_queue->rx_skbuff[j] = NULL;
         }
 
-        if (gfar_init_bds(ndev))
-                goto cleanup;
+        gfar_init_bds(ndev);
 
         return 0;
 
@@ -354,10 +333,8 @@ static void gfar_init_rqprm(struct gfar_private *priv)
         }
 }
 
-static void gfar_rx_buff_size_config(struct gfar_private *priv)
+static void gfar_rx_offload_en(struct gfar_private *priv)
 {
-        int frame_size = priv->ndev->mtu + ETH_HLEN + ETH_FCS_LEN;
-
         /* set this when rx hw offload (TOE) functions are being used */
         priv->uses_rxfcb = 0;
 
@@ -366,16 +343,6 @@ static void gfar_rx_buff_size_config(struct gfar_private *priv)
 
         if (priv->hwts_rx_en)
                 priv->uses_rxfcb = 1;
-
-        if (priv->uses_rxfcb)
-                frame_size += GMAC_FCB_LEN;
-
-        frame_size += priv->padding;
-
-        frame_size = (frame_size & ~(INCREMENTAL_BUFFER_SIZE - 1)) +
-                     INCREMENTAL_BUFFER_SIZE;
-
-        priv->rx_buffer_size = frame_size;
 }
 
 static void gfar_mac_rx_config(struct gfar_private *priv)
@@ -609,9 +576,8 @@ static int gfar_alloc_rx_queues(struct gfar_private *priv)
                 if (!priv->rx_queue[i])
                         return -ENOMEM;
 
-                priv->rx_queue[i]->rx_skbuff = NULL;
                 priv->rx_queue[i]->qindex = i;
-                priv->rx_queue[i]->dev = priv->ndev;
+                priv->rx_queue[i]->ndev = priv->ndev;
         }
         return 0;
 }
@@ -1203,12 +1169,11 @@ void gfar_mac_reset(struct gfar_private *priv)
 
         udelay(3);
 
-        /* Compute rx_buff_size based on config flags */
-        gfar_rx_buff_size_config(priv);
+        gfar_rx_offload_en(priv);
 
         /* Initialize the max receive frame/buffer lengths */
-        gfar_write(&regs->maxfrm, priv->rx_buffer_size);
-        gfar_write(&regs->mrblr, priv->rx_buffer_size);
+        gfar_write(&regs->maxfrm, GFAR_JUMBO_FRAME_SIZE);
+        gfar_write(&regs->mrblr, GFAR_RXB_SIZE);
 
         /* Initialize the Minimum Frame Length Register */
         gfar_write(&regs->minflr, MINFLR_INIT_SETTINGS);
@@ -1216,12 +1181,11 @@ void gfar_mac_reset(struct gfar_private *priv)
         /* Initialize MACCFG2. */
         tempval = MACCFG2_INIT_SETTINGS;
 
-        /* If the mtu is larger than the max size for standard
-         * ethernet frames (ie, a jumbo frame), then set maccfg2
-         * to allow huge frames, and to check the length
+        /* eTSEC74 erratum: Rx frames of length MAXFRM or MAXFRM-1
+         * are marked as truncated.  Avoid this by MACCFG2[Huge Frame]=1,
+         * and by checking RxBD[LG] and discarding larger than MAXFRM.
          */
-        if (priv->rx_buffer_size > DEFAULT_RX_BUFFER_SIZE ||
-            gfar_has_errata(priv, GFAR_ERRATA_74))
+        if (gfar_has_errata(priv, GFAR_ERRATA_74))
                 tempval |= MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK;
 
         gfar_write(&regs->maccfg2, tempval);
@@ -1432,8 +1396,6 @@ static int gfar_probe(struct platform_device *ofdev)
             priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)
                 dev->needed_headroom = GMAC_FCB_LEN;
 
-        priv->rx_buffer_size = DEFAULT_RX_BUFFER_SIZE;
-
         /* Initializing some of the rx/tx queue level parameters */
         for (i = 0; i < priv->num_tx_queues; i++) {
                 priv->tx_queue[i]->tx_ring_size = DEFAULT_TX_RING_SIZE;
@@ -1639,10 +1601,7 @@ static int gfar_restore(struct device *dev)
                 return 0;
         }
 
-        if (gfar_init_bds(ndev)) {
-                free_skb_resources(priv);
-                return -ENOMEM;
-        }
+        gfar_init_bds(ndev);
 
         gfar_mac_reset(priv);
 
@@ -1933,26 +1892,32 @@ static void free_skb_tx_queue(struct gfar_priv_tx_q *tx_queue)
 
 static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue)
 {
-        struct rxbd8 *rxbdp;
-        struct gfar_private *priv = netdev_priv(rx_queue->dev);
         int i;
 
-        rxbdp = rx_queue->rx_bd_base;
+        struct rxbd8 *rxbdp = rx_queue->rx_bd_base;
+
+        if (rx_queue->skb)
+                dev_kfree_skb(rx_queue->skb);
 
         for (i = 0; i < rx_queue->rx_ring_size; i++) {
-                if (rx_queue->rx_skbuff[i]) {
-                        dma_unmap_single(priv->dev, be32_to_cpu(rxbdp->bufPtr),
-                                         priv->rx_buffer_size,
-                                         DMA_FROM_DEVICE);
-                        dev_kfree_skb_any(rx_queue->rx_skbuff[i]);
-                        rx_queue->rx_skbuff[i] = NULL;
-                }
+                struct  gfar_rx_buff *rxb = &rx_queue->rx_buff[i];
+
                 rxbdp->lstatus = 0;
                 rxbdp->bufPtr = 0;
                 rxbdp++;
+
+                if (!rxb->page)
+                        continue;
+
+                dma_unmap_single(rx_queue->dev, rxb->dma,
+                                 PAGE_SIZE, DMA_FROM_DEVICE);
+                __free_page(rxb->page);
+
+                rxb->page = NULL;
         }
-        kfree(rx_queue->rx_skbuff);
-        rx_queue->rx_skbuff = NULL;
+
+        kfree(rx_queue->rx_buff);
+        rx_queue->rx_buff = NULL;
 }
 
 /* If there are any tx skbs or rx skbs still around, free them.
@@ -1977,7 +1942,7 @@ static void free_skb_resources(struct gfar_private *priv)
 
         for (i = 0; i < priv->num_rx_queues; i++) {
                 rx_queue = priv->rx_queue[i];
-                if (rx_queue->rx_skbuff)
+                if (rx_queue->rx_buff)
                         free_skb_rx_queue(rx_queue);
         }
 
@@ -2535,7 +2500,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
         struct gfar_private *priv = netdev_priv(dev);
         int frame_size = new_mtu + ETH_HLEN;
 
-        if ((frame_size < 64) || (frame_size > JUMBO_FRAME_SIZE)) {
+        if ((frame_size < 64) || (frame_size > GFAR_JUMBO_FRAME_SIZE)) {
                 netif_err(priv, drv, dev, "Invalid MTU setting\n");
                 return -EINVAL;
         }
@@ -2589,15 +2554,6 @@ static void gfar_timeout(struct net_device *dev)
         schedule_work(&priv->reset_task);
 }
 
-static void gfar_align_skb(struct sk_buff *skb)
-{
-        /* We need the data buffer to be aligned properly.  We will reserve
-         * as many bytes as needed to align the data properly
-         */
-        skb_reserve(skb, RXBUF_ALIGNMENT -
-                    (((unsigned long) skb->data) & (RXBUF_ALIGNMENT - 1)));
-}
-
 /* Interrupt Handler for Transmit complete */
 static void gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
 {
@@ -2704,49 +2660,85 @@ static void gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
         netdev_tx_completed_queue(txq, howmany, bytes_sent);
 }
 
-static struct sk_buff *gfar_alloc_skb(struct net_device *dev)
+static bool gfar_new_page(struct gfar_priv_rx_q *rxq, struct gfar_rx_buff *rxb)
 {
-        struct gfar_private *priv = netdev_priv(dev);
-        struct sk_buff *skb;
+        struct page *page;
+        dma_addr_t addr;
 
-        skb = netdev_alloc_skb(dev, priv->rx_buffer_size + RXBUF_ALIGNMENT);
-        if (!skb)
-                return NULL;
+        page = dev_alloc_page();
+        if (unlikely(!page))
+                return false;
 
-        gfar_align_skb(skb);
+        addr = dma_map_page(rxq->dev, page, 0, PAGE_SIZE, DMA_FROM_DEVICE);
+        if (unlikely(dma_mapping_error(rxq->dev, addr))) {
+                __free_page(page);
 
-        return skb;
+                return false;
+        }
+
+        rxb->dma = addr;
+        rxb->page = page;
+        rxb->page_offset = 0;
+
+        return true;
 }
 
-static struct sk_buff *gfar_new_skb(struct net_device *dev, dma_addr_t *bufaddr)
+static void gfar_rx_alloc_err(struct gfar_priv_rx_q *rx_queue)
 {
-        struct gfar_private *priv = netdev_priv(dev);
-        struct sk_buff *skb;
-        dma_addr_t addr;
+        struct gfar_private *priv = netdev_priv(rx_queue->ndev);
+        struct gfar_extra_stats *estats = &priv->extra_stats;
 
-        skb = gfar_alloc_skb(dev);
-        if (!skb)
-                return NULL;
+        netdev_err(rx_queue->ndev, "Can't alloc RX buffers\n");
+        atomic64_inc(&estats->rx_alloc_err);
+}
 
-        addr = dma_map_single(priv->dev, skb->data,
-                              priv->rx_buffer_size, DMA_FROM_DEVICE);
-        if (unlikely(dma_mapping_error(priv->dev, addr))) {
-                dev_kfree_skb_any(skb);
-                return NULL;
+static void gfar_alloc_rx_buffs(struct gfar_priv_rx_q *rx_queue,
+                                int alloc_cnt)
+{
+        struct rxbd8 *bdp;
+        struct gfar_rx_buff *rxb;
+        int i;
+
+        i = rx_queue->next_to_use;
+        bdp = &rx_queue->rx_bd_base[i];
+        rxb = &rx_queue->rx_buff[i];
+
+        while (alloc_cnt--) {
+                /* try reuse page */
+                if (unlikely(!rxb->page)) {
+                        if (unlikely(!gfar_new_page(rx_queue, rxb))) {
+                                gfar_rx_alloc_err(rx_queue);
+                                break;
+                        }
+                }
+
+                /* Setup the new RxBD */
+                gfar_init_rxbdp(rx_queue, bdp,
+                                rxb->dma + rxb->page_offset + RXBUF_ALIGNMENT);
+
+                /* Update to the next pointer */
+                bdp++;
+                rxb++;
+
+                if (unlikely(++i == rx_queue->rx_ring_size)) {
+                        i = 0;
+                        bdp = rx_queue->rx_bd_base;
+                        rxb = rx_queue->rx_buff;
+                }
         }
 
-        *bufaddr = addr;
-        return skb;
+        rx_queue->next_to_use = i;
+        rx_queue->next_to_alloc = i;
 }
 
-static inline void count_errors(unsigned short status, struct net_device *dev)
+static void count_errors(u32 lstatus, struct net_device *ndev)
 {
-        struct gfar_private *priv = netdev_priv(dev);
-        struct net_device_stats *stats = &dev->stats;
+        struct gfar_private *priv = netdev_priv(ndev);
+        struct net_device_stats *stats = &ndev->stats;
         struct gfar_extra_stats *estats = &priv->extra_stats;
 
         /* If the packet was truncated, none of the other errors matter */
-        if (status & RXBD_TRUNCATED) {
+        if (lstatus & BD_LFLAG(RXBD_TRUNCATED)) {
                 stats->rx_length_errors++;
 
                 atomic64_inc(&estats->rx_trunc);
@@ -2754,25 +2746,25 @@ static inline void count_errors(unsigned short status, struct net_device *dev)
                 return;
         }
         /* Count the errors, if there were any */
-        if (status & (RXBD_LARGE | RXBD_SHORT)) {
+        if (lstatus & BD_LFLAG(RXBD_LARGE | RXBD_SHORT)) {
                 stats->rx_length_errors++;
 
-                if (status & RXBD_LARGE)
+                if (lstatus & BD_LFLAG(RXBD_LARGE))
                         atomic64_inc(&estats->rx_large);
                 else
                         atomic64_inc(&estats->rx_short);
         }
-        if (status & RXBD_NONOCTET) {
+        if (lstatus & BD_LFLAG(RXBD_NONOCTET)) {
                 stats->rx_frame_errors++;
                 atomic64_inc(&estats->rx_nonoctet);
         }
-        if (status & RXBD_CRCERR) {
+        if (lstatus & BD_LFLAG(RXBD_CRCERR)) {
                 atomic64_inc(&estats->rx_crcerr);
                 stats->rx_crc_errors++;
         }
-        if (status & RXBD_OVERRUN) {
+        if (lstatus & BD_LFLAG(RXBD_OVERRUN)) {
                 atomic64_inc(&estats->rx_overrun);
-                stats->rx_crc_errors++;
+                stats->rx_over_errors++;
         }
 }
 
@@ -2823,6 +2815,93 @@ static irqreturn_t gfar_transmit(int irq, void *grp_id)
         return IRQ_HANDLED;
 }
 
+static bool gfar_add_rx_frag(struct gfar_rx_buff *rxb, u32 lstatus,
+                             struct sk_buff *skb, bool first)
+{
+        unsigned int size = lstatus & BD_LENGTH_MASK;
+        struct page *page = rxb->page;
+
+        /* Remove the FCS from the packet length */
+        if (likely(lstatus & BD_LFLAG(RXBD_LAST)))
+                size -= ETH_FCS_LEN;
+
+        if (likely(first))
+                skb_put(skb, size);
+        else
+                skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
+                                rxb->page_offset + RXBUF_ALIGNMENT,
+                                size, GFAR_RXB_TRUESIZE);
+
+        /* try reuse page */
+        if (unlikely(page_count(page) != 1))
+                return false;
+
+        /* change offset to the other half */
+        rxb->page_offset ^= GFAR_RXB_TRUESIZE;
+
+        atomic_inc(&page->_count);
+
+        return true;
+}
+
+static void gfar_reuse_rx_page(struct gfar_priv_rx_q *rxq,
+                               struct gfar_rx_buff *old_rxb)
+{
+        struct gfar_rx_buff *new_rxb;
+        u16 nta = rxq->next_to_alloc;
+
+        new_rxb = &rxq->rx_buff[nta];
+
+        /* find next buf that can reuse a page */
+        nta++;
+        rxq->next_to_alloc = (nta < rxq->rx_ring_size) ? nta : 0;
+
+        /* copy page reference */
+        *new_rxb = *old_rxb;
+
+        /* sync for use by the device */
+        dma_sync_single_range_for_device(rxq->dev, old_rxb->dma,
+                                         old_rxb->page_offset,
+                                         GFAR_RXB_TRUESIZE, DMA_FROM_DEVICE);
+}
+
+static struct sk_buff *gfar_get_next_rxbuff(struct gfar_priv_rx_q *rx_queue,
+                                            u32 lstatus, struct sk_buff *skb)
+{
+        struct gfar_rx_buff *rxb = &rx_queue->rx_buff[rx_queue->next_to_clean];
+        struct page *page = rxb->page;
+        bool first = false;
+
+        if (likely(!skb)) {
+                void *buff_addr = page_address(page) + rxb->page_offset;
+
+                skb = build_skb(buff_addr, GFAR_SKBFRAG_SIZE);
+                if (unlikely(!skb)) {
+                        gfar_rx_alloc_err(rx_queue);
+                        return NULL;
+                }
+                skb_reserve(skb, RXBUF_ALIGNMENT);
+                first = true;
+        }
+
+        dma_sync_single_range_for_cpu(rx_queue->dev, rxb->dma, rxb->page_offset,
+                                      GFAR_RXB_TRUESIZE, DMA_FROM_DEVICE);
+
+        if (gfar_add_rx_frag(rxb, lstatus, skb, first)) {
+                /* reuse the free half of the page */
+                gfar_reuse_rx_page(rx_queue, rxb);
+        } else {
+                /* page cannot be reused, unmap it */
+                dma_unmap_page(rx_queue->dev, rxb->dma,
+                               PAGE_SIZE, DMA_FROM_DEVICE);
+        }
+
+        /* clear rxb content */
+        rxb->page = NULL;
+
+        return skb;
+}
+
 static inline void gfar_rx_checksum(struct sk_buff *skb, struct rxfcb *fcb)
 {
         /* If valid headers were found, and valid sums
@@ -2837,10 +2916,9 @@ static inline void gfar_rx_checksum(struct sk_buff *skb, struct rxfcb *fcb)
 }
 
 /* gfar_process_frame() -- handle one incoming packet if skb isn't NULL. */
-static void gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
-                               int amount_pull, struct napi_struct *napi)
+static void gfar_process_frame(struct net_device *ndev, struct sk_buff *skb)
 {
-        struct gfar_private *priv = netdev_priv(dev);
+        struct gfar_private *priv = netdev_priv(ndev);
         struct rxfcb *fcb = NULL;
 
         /* fcb is at the beginning if exists */
@@ -2849,10 +2927,8 @@ static void gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
         /* Remove the FCB from the skb
          * Remove the padded bytes, if there are any
          */
-        if (amount_pull) {
-                skb_record_rx_queue(skb, fcb->rq);
-                skb_pull(skb, amount_pull);
-        }
+        if (priv->uses_rxfcb)
+                skb_pull(skb, GMAC_FCB_LEN);
 
         /* Get receive timestamp from the skb */
         if (priv->hwts_rx_en) {
@@ -2866,24 +2942,20 @@ static void gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
         if (priv->padding)
                 skb_pull(skb, priv->padding);
 
-        if (dev->features & NETIF_F_RXCSUM)
+        if (ndev->features & NETIF_F_RXCSUM)
                 gfar_rx_checksum(skb, fcb);
 
         /* Tell the skb what kind of packet this is */
-        skb->protocol = eth_type_trans(skb, dev);
+        skb->protocol = eth_type_trans(skb, ndev);
 
         /* There's need to check for NETIF_F_HW_VLAN_CTAG_RX here.
          * Even if vlan rx accel is disabled, on some chips
          * RXFCB_VLN is pseudo randomly set.
          */
-        if (dev->features & NETIF_F_HW_VLAN_CTAG_RX &&
+        if (ndev->features & NETIF_F_HW_VLAN_CTAG_RX &&
             be16_to_cpu(fcb->flags) & RXFCB_VLN)
                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
                                        be16_to_cpu(fcb->vlctl));
-
-        /* Send the packet up the stack */
-        napi_gro_receive(napi, skb);
-
 }
 
 /* gfar_clean_rx_ring() -- Processes each frame in the rx ring
@@ -2892,91 +2964,88 @@ static void gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
  */
 int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
 {
-        struct net_device *dev = rx_queue->dev;
-        struct rxbd8 *bdp, *base;
-        struct sk_buff *skb;
-        int pkt_len;
-        int amount_pull;
-        int howmany = 0;
-        struct gfar_private *priv = netdev_priv(dev);
+        struct net_device *ndev = rx_queue->ndev;
+        struct gfar_private *priv = netdev_priv(ndev);
+        struct rxbd8 *bdp;
+        int i, howmany = 0;
+        struct sk_buff *skb = rx_queue->skb;
+        int cleaned_cnt = gfar_rxbd_unused(rx_queue);
+        unsigned int total_bytes = 0, total_pkts = 0;
 
         /* Get the first full descriptor */
-        bdp = rx_queue->cur_rx;
-        base = rx_queue->rx_bd_base;
+        i = rx_queue->next_to_clean;
 
-        amount_pull = priv->uses_rxfcb ? GMAC_FCB_LEN : 0;
+        while (rx_work_limit--) {
+                u32 lstatus;
 
-        while (!(be16_to_cpu(bdp->status) & RXBD_EMPTY) && rx_work_limit--) {
-                struct sk_buff *newskb;
-                dma_addr_t bufaddr;
+                if (cleaned_cnt >= GFAR_RX_BUFF_ALLOC) {
+                        gfar_alloc_rx_buffs(rx_queue, cleaned_cnt);
+                        cleaned_cnt = 0;
+                }
+
+                bdp = &rx_queue->rx_bd_base[i];
+                lstatus = be32_to_cpu(bdp->lstatus);
+                if (lstatus & BD_LFLAG(RXBD_EMPTY))
+                        break;
 
+                /* order rx buffer descriptor reads */
                 rmb();
 
-                /* Add another skb for the future */
-                newskb = gfar_new_skb(dev, &bufaddr);
+                /* fetch next to clean buffer from the ring */
+                skb = gfar_get_next_rxbuff(rx_queue, lstatus, skb);
+                if (unlikely(!skb))
+                        break;
 
-                skb = rx_queue->rx_skbuff[rx_queue->skb_currx];
+                cleaned_cnt++;
+                howmany++;
 
-                dma_unmap_single(priv->dev, be32_to_cpu(bdp->bufPtr),
-                                 priv->rx_buffer_size, DMA_FROM_DEVICE);
-
-                if (unlikely(!(be16_to_cpu(bdp->status) & RXBD_ERR) &&
-                             be16_to_cpu(bdp->length) > priv->rx_buffer_size))
-                        bdp->status = cpu_to_be16(RXBD_LARGE);
-
-                /* We drop the frame if we failed to allocate a new buffer */
-                if (unlikely(!newskb ||
-                             !(be16_to_cpu(bdp->status) & RXBD_LAST) ||
-                             be16_to_cpu(bdp->status) & RXBD_ERR)) {
-                        count_errors(be16_to_cpu(bdp->status), dev);
-
-                        if (unlikely(!newskb)) {
-                                newskb = skb;
-                                bufaddr = be32_to_cpu(bdp->bufPtr);
-                        } else if (skb)
-                                dev_kfree_skb(skb);
-                } else {
-                        /* Increment the number of packets */
-                        rx_queue->stats.rx_packets++;
-                        howmany++;
-
-                        if (likely(skb)) {
-                                pkt_len = be16_to_cpu(bdp->length) -
-                                          ETH_FCS_LEN;
-                                /* Remove the FCS from the packet length */
-                                skb_put(skb, pkt_len);
-                                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);
+                if (unlikely(++i == rx_queue->rx_ring_size))
+                        i = 0;
 
-                        } else {
-                                netif_warn(priv, rx_err, dev, "Missing skb!\n");
-                                rx_queue->stats.rx_dropped++;
-                                atomic64_inc(&priv->extra_stats.rx_skbmissing);
-                        }
+                rx_queue->next_to_clean = i;
+
+                /* fetch next buffer if not the last in frame */
+                if (!(lstatus & BD_LFLAG(RXBD_LAST)))
+                        continue;
 
+                if (unlikely(lstatus & BD_LFLAG(RXBD_ERR))) {
+                        count_errors(lstatus, ndev);
+
+                        /* discard faulty buffer */
+                        dev_kfree_skb(skb);
+                        skb = NULL;
+                        rx_queue->stats.rx_dropped++;
+                        continue;
                 }
 
-                rx_queue->rx_skbuff[rx_queue->skb_currx] = newskb;
+                /* Increment the number of packets */
+                total_pkts++;
+                total_bytes += skb->len;
 
-                /* Setup the new bdp */
-                gfar_init_rxbdp(rx_queue, bdp, bufaddr);
+                skb_record_rx_queue(skb, rx_queue->qindex);
 
-                /* Update Last Free RxBD pointer for LFC */
-                if (unlikely(rx_queue->rfbptr && priv->tx_actual_en))
-                        gfar_write(rx_queue->rfbptr, (u32)bdp);
+                gfar_process_frame(ndev, skb);
 
-                /* Update to the next pointer */
-                bdp = next_bd(bdp, base, rx_queue->rx_ring_size);
+                /* Send the packet up the stack */
+                napi_gro_receive(&rx_queue->grp->napi_rx, skb);
 
-                /* 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);
+                skb = NULL;
         }
 
-        /* Update the current rxbd pointer to be the next one */
-        rx_queue->cur_rx = bdp;
+        /* Store incomplete frames for completion */
+        rx_queue->skb = skb;
+
+        rx_queue->stats.rx_packets += total_pkts;
+        rx_queue->stats.rx_bytes += total_bytes;
+
+        if (cleaned_cnt)
+                gfar_alloc_rx_buffs(rx_queue, cleaned_cnt);
+
+        /* Update Last Free RxBD pointer for LFC */
+        if (unlikely(priv->tx_actual_en)) {
+                bdp = gfar_rxbd_lastfree(rx_queue);
+                gfar_write(rx_queue->rfbptr, (u32)bdp);
+        }
 
         return howmany;
 }
@@ -3552,14 +3621,8 @@ static noinline void gfar_update_link_state(struct gfar_private *priv)
                 if ((tempval1 & MACCFG1_TX_FLOW) && !tx_flow_oldval) {
                         for (i = 0; i < priv->num_rx_queues; i++) {
                                 rx_queue = priv->rx_queue[i];
-                                bdp = rx_queue->cur_rx;
-                                /* skip to previous bd */
-                                bdp = skip_bd(bdp, rx_queue->rx_ring_size - 1,
-                                              rx_queue->rx_bd_base,
-                                              rx_queue->rx_ring_size);
-
-                                if (rx_queue->rfbptr)
-                                        gfar_write(rx_queue->rfbptr, (u32)bdp);
+                                bdp = gfar_rxbd_lastfree(rx_queue);
+                                gfar_write(rx_queue->rfbptr, (u32)bdp);
                         }
 
                         priv->tx_actual_en = 1;
diff --git a/drivers/net/ethernet/freescale/gianfar.h b/drivers/net/ethernet/freescale/gianfar.h
index daa1d37de642..44021243c187 100644
--- a/drivers/net/ethernet/freescale/gianfar.h
+++ b/drivers/net/ethernet/freescale/gianfar.h
@@ -71,11 +71,6 @@ struct ethtool_rx_list {
 /* Number of bytes to align the rx bufs to */
 #define RXBUF_ALIGNMENT 64
 
-/* The number of bytes which composes a unit for the purpose of
- * allocating data buffers.  ie-for any given MTU, the data buffer
- * will be the next highest multiple of 512 bytes. */
-#define INCREMENTAL_BUFFER_SIZE 512
-
 #define PHY_INIT_TIMEOUT 100000
 
 #define DRV_NAME "gfar-enet"
@@ -92,6 +87,8 @@ extern const char gfar_driver_version[];
 #define DEFAULT_TX_RING_SIZE    256
 #define DEFAULT_RX_RING_SIZE    256
 
+#define GFAR_RX_BUFF_ALLOC      16
+
 #define GFAR_RX_MAX_RING_SIZE   256
 #define GFAR_TX_MAX_RING_SIZE   256
 
@@ -103,11 +100,14 @@ extern const char gfar_driver_version[];
 #define DEFAULT_RX_LFC_THR  16
 #define DEFAULT_LFC_PTVVAL  4
 
-#define DEFAULT_RX_BUFFER_SIZE  1536
+#define GFAR_RXB_SIZE 1536
+#define GFAR_SKBFRAG_SIZE (RXBUF_ALIGNMENT + GFAR_RXB_SIZE \
+                          + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
+#define GFAR_RXB_TRUESIZE 2048
+
 #define TX_RING_MOD_MASK(size) (size-1)
 #define RX_RING_MOD_MASK(size) (size-1)
-#define JUMBO_BUFFER_SIZE 9728
-#define JUMBO_FRAME_SIZE 9600
+#define GFAR_JUMBO_FRAME_SIZE 9600
 
 #define DEFAULT_FIFO_TX_THR 0x100
 #define DEFAULT_FIFO_TX_STARVE 0x40
@@ -640,6 +640,7 @@ struct rmon_mib
 };
 
 struct gfar_extra_stats {
+        atomic64_t rx_alloc_err;
         atomic64_t rx_large;
         atomic64_t rx_short;
         atomic64_t rx_nonoctet;
@@ -651,7 +652,6 @@ struct gfar_extra_stats {
         atomic64_t eberr;
         atomic64_t tx_babt;
         atomic64_t tx_underrun;
-        atomic64_t rx_skbmissing;
         atomic64_t tx_timeout;
 };
 
@@ -1012,34 +1012,42 @@ struct rx_q_stats {
         unsigned long rx_dropped;
 };
 
+struct gfar_rx_buff {
+        dma_addr_t dma;
+        struct page *page;
+        unsigned int page_offset;
+};
+
 /**
  *      struct gfar_priv_rx_q - per rx queue structure
- *      @rx_skbuff: skb pointers
- *      @skb_currx: currently use skb pointer
+ *      @rx_buff: Array of buffer info metadata structs
  *      @rx_bd_base: First rx buffer descriptor
- *      @cur_rx: Next free rx ring entry
+ *      @next_to_use: index of the next buffer to be alloc'd
+ *      @next_to_clean: index of the next buffer to be cleaned
  *      @qindex: index of this queue
- *      @dev: back pointer to the dev structure
+ *      @ndev: back pointer to net_device
  *      @rx_ring_size: Rx ring size
  *      @rxcoalescing: enable/disable rx-coalescing
  *      @rxic: receive interrupt coalescing vlaue
  */
 
 struct gfar_priv_rx_q {
-        struct  sk_buff **rx_skbuff __aligned(SMP_CACHE_BYTES);
-        dma_addr_t rx_bd_dma_base;
+        struct  gfar_rx_buff *rx_buff __aligned(SMP_CACHE_BYTES);
         struct  rxbd8 *rx_bd_base;
-        struct  rxbd8 *cur_rx;
-        struct  net_device *dev;
-        struct gfar_priv_grp *grp;
+        struct  net_device *ndev;
+        struct  device *dev;
+        u16 rx_ring_size;
+        u16 qindex;
+        struct  gfar_priv_grp *grp;
+        u16 next_to_clean;
+        u16 next_to_use;
+        u16 next_to_alloc;
+        struct  sk_buff *skb;
         struct rx_q_stats stats;
-        u16     skb_currx;
-        u16     qindex;
-        unsigned int    rx_ring_size;
-        /* RX Coalescing values */
+        u32 __iomem *rfbptr;
         unsigned char rxcoalescing;
         unsigned long rxic;
-        u32 __iomem *rfbptr;
+        dma_addr_t rx_bd_dma_base;
 };
 
 enum gfar_irqinfo_id {
@@ -1109,7 +1117,6 @@ struct gfar_private {
         struct device *dev;
         struct net_device *ndev;
         enum gfar_errata errata;
-        unsigned int rx_buffer_size;
 
         u16 uses_rxfcb;
         u16 padding;
@@ -1295,6 +1302,23 @@ static inline void gfar_clear_txbd_status(struct txbd8 *bdp)
         bdp->lstatus = cpu_to_be32(lstatus);
 }
 
+static inline int gfar_rxbd_unused(struct gfar_priv_rx_q *rxq)
+{
+        if (rxq->next_to_clean > rxq->next_to_use)
+                return rxq->next_to_clean - rxq->next_to_use - 1;
+
+        return rxq->rx_ring_size + rxq->next_to_clean - rxq->next_to_use - 1;
+}
+
+static inline struct rxbd8 *gfar_rxbd_lastfree(struct gfar_priv_rx_q *rxq)
+{
+        int i;
+
+        i = rxq->next_to_use ? rxq->next_to_use - 1 : rxq->rx_ring_size - 1;
+
+        return &rxq->rx_bd_base[i];
+}
+
 irqreturn_t gfar_receive(int irq, void *dev_id);
 int startup_gfar(struct net_device *dev);
 void stop_gfar(struct net_device *dev);
diff --git a/drivers/net/ethernet/freescale/gianfar_ethtool.c b/drivers/net/ethernet/freescale/gianfar_ethtool.c
index fda12fb32ec7..3020aaabf0e4 100644
--- a/drivers/net/ethernet/freescale/gianfar_ethtool.c
+++ b/drivers/net/ethernet/freescale/gianfar_ethtool.c
@@ -61,6 +61,8 @@ static void gfar_gdrvinfo(struct net_device *dev,
                           struct ethtool_drvinfo *drvinfo);
 
 static const char stat_gstrings[][ETH_GSTRING_LEN] = {
+        /* extra stats */
+        "rx-allocation-errors",
         "rx-large-frame-errors",
         "rx-short-frame-errors",
         "rx-non-octet-errors",
@@ -72,8 +74,8 @@ static const char stat_gstrings[][ETH_GSTRING_LEN] = {
         "ethernet-bus-error",
         "tx-babbling-errors",
         "tx-underrun-errors",
-        "rx-skb-missing-errors",
         "tx-timeout-errors",
+        /* rmon stats */
         "tx-rx-64-frames",
         "tx-rx-65-127-frames",
         "tx-rx-128-255-frames",
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
index 2f6cc423ab1d..7dbab3c20db5 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
@@ -2403,7 +2403,6 @@ int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
                         qlcnic_free_tx_rings(adapter);
                         return -ENOMEM;
                 }
-                memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
                 tx_ring->cmd_buf_arr = cmd_buf_arr;
                 spin_lock_init(&tx_ring->tx_clean_lock);
         }
diff --git a/net/sched/sch_qfq.c b/net/sched/sch_qfq.c
index b8d73bca683c..ffaeea63d473 100644
--- a/net/sched/sch_qfq.c
+++ b/net/sched/sch_qfq.c
@@ -186,7 +186,6 @@ struct qfq_sched {
 
         u64                     oldV, V;        /* Precise virtual times. */
         struct qfq_aggregate    *in_serv_agg;   /* Aggregate being served. */
-        u32                     num_active_agg; /* Num. of active aggregates */
         u32                     wsum;           /* weight sum */
         u32                     iwsum;          /* inverse weight sum */