Merge branch 'gianfar_rx_sg' (9061cb02) · Commits · 戴 / test

drivers/net/ethernet/freescale/gianfar.c

+279 −216

Original line number	Diff line number	Diff line
		@@ -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),
		rx_queue->rx_buff = kcalloc(rx_queue->rx_ring_size,
		sizeof(*rx_queue->rx_buff),
		GFP_KERNEL);
		if (!rx_queue->rx_skbuff)
		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;
		}

		static struct sk_buff gfar_new_skb(struct net_device dev, dma_addr_t *bufaddr)
		rxb->dma = addr;
		rxb->page = page;
		rxb->page_offset = 0;

		return true;
		}

		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;
		}
		}

		*bufaddr = addr;
		return skb;
		/* 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;
		}
		}

		static inline void count_errors(unsigned short status, struct net_device *dev)
		rx_queue->next_to_use = i;
		rx_queue->next_to_alloc = i;
		}

		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,92 +2964,89 @@ 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;

		if (cleaned_cnt >= GFAR_RX_BUFF_ALLOC) {
		gfar_alloc_rx_buffs(rx_queue, cleaned_cnt);
		cleaned_cnt = 0;
		}

		while (!(be16_to_cpu(bdp->status) & RXBD_EMPTY) && rx_work_limit--) {
		struct sk_buff *newskb;
		dma_addr_t bufaddr;
		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)
		if (unlikely(++i == rx_queue->rx_ring_size))
		i = 0;

		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);
		} else {
		skb = NULL;
		rx_queue->stats.rx_dropped++;
		continue;
		}

		/* Increment the number of packets */
		rx_queue->stats.rx_packets++;
		howmany++;
		total_pkts++;
		total_bytes += skb->len;

		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);

		} else {
		netif_warn(priv, rx_err, dev, "Missing skb!\n");
		rx_queue->stats.rx_dropped++;
		atomic64_inc(&priv->extra_stats.rx_skbmissing);
		}
		gfar_process_frame(ndev, skb);

		/* Send the packet up the stack */
		napi_gro_receive(&rx_queue->grp->napi_rx, skb);

		skb = NULL;
		}

		rx_queue->rx_skbuff[rx_queue->skb_currx] = newskb;
		/* Store incomplete frames for completion */
		rx_queue->skb = skb;

		/* Setup the new bdp */
		gfar_init_rxbdp(rx_queue, bdp, bufaddr);
		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(rx_queue->rfbptr && priv->tx_actual_en))
		if (unlikely(priv->tx_actual_en)) {
		bdp = gfar_rxbd_lastfree(rx_queue);
		gfar_write(rx_queue->rfbptr, (u32)bdp);

		/* Update to the next pointer */
		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);
		}

		/* Update the current rxbd pointer to be the next one */
		rx_queue->cur_rx = bdp;

		return howmany;
		}

		@@ -3552,13 +3621,7 @@ 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)
		bdp = gfar_rxbd_lastfree(rx_queue);
		gfar_write(rx_queue->rfbptr, (u32)bdp);
		}

drivers/net/ethernet/freescale/gianfar.h

+48 −24

Original line number	Diff line number	Diff line
		@@ -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 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);

drivers/net/ethernet/freescale/gianfar_ethtool.c

+3 −1

Original line number	Diff line number	Diff line
		@@ -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",

Admin message