Commit 4256af62 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'via-rhine-rework' 



Francois Romieu says:

====================
via-rhine rework

The series applies against davem-next as of
9dd3c797 ("drivers: net: xgene: fix kbuild
warnings").

Patches #1..#4 avoid holes in the receive ring.

Patch #5 is a small leftover cleanup for #1..#4.

Patches #6 and #7 are fairly simple barrier stuff.

Patch #8 closes some SMP transmit races - not that anyone really
complained about these but it's a bit hard to handwave that they
can be safely ignored. Some testing, especially SMP testing of
course, would be welcome.

. Changes since #2:
  - added dma_rmb barrier in vlan related patch 6.
  - s/wmb/dma_wmb/ in (*new*) patch 7 of 8.
  - added explicit SMP barriers in (*new*) patch 8 of 8.

. Changes since #1:
  - turned wmb() into dma_wmb() as suggested by davem and Alexander Duyck
    in patch 1 of 6.
  - forgot to reset rx_head_desc in rhine_reset_rbufs in patch 4 of 6.
  - removed rx_head_desc altogether in (*new*) patch 5 of 6
  - remoed some vlan receive uglyness in (*new*) patch 6 of 6.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 7c9a2eea 3a5a883a

drivers/net/ethernet/via/via-rhine.c

+162 −87
Original line number Diff line number Diff line
@@ -472,8 +472,7 @@ struct rhine_private { 


	/* Frequently used values: keep some adjacent for cache effect. */

	u32 quirks;

	struct rx_desc *rx_head_desc;

	unsigned int cur_rx, dirty_rx;	/* Producer/consumer ring indices */

	unsigned int cur_rx;

	unsigned int cur_tx, dirty_tx;

	unsigned int rx_buf_sz;		/* Based on MTU+slack. */

	struct rhine_stats rx_stats;
@@ -1213,17 +1212,61 @@ static void free_ring(struct net_device* dev) 


}



static void alloc_rbufs(struct net_device *dev)

struct rhine_skb_dma {

	struct sk_buff *skb;

	dma_addr_t dma;

};



static inline int rhine_skb_dma_init(struct net_device *dev,

				     struct rhine_skb_dma *sd)

{

	struct rhine_private *rp = netdev_priv(dev);

	struct device *hwdev = dev->dev.parent;

	dma_addr_t next;

	const int size = rp->rx_buf_sz;



	sd->skb = netdev_alloc_skb(dev, size);

	if (!sd->skb)

		return -ENOMEM;



	sd->dma = dma_map_single(hwdev, sd->skb->data, size, DMA_FROM_DEVICE);

	if (unlikely(dma_mapping_error(hwdev, sd->dma))) {

		netif_err(rp, drv, dev, "Rx DMA mapping failure\n");

		dev_kfree_skb_any(sd->skb);

		return -EIO;

	}



	return 0;

}



static void rhine_reset_rbufs(struct rhine_private *rp)

{

	int i;



	rp->dirty_rx = rp->cur_rx = 0;

	rp->cur_rx = 0;



	for (i = 0; i < RX_RING_SIZE; i++)

		rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);

}



static inline void rhine_skb_dma_nic_store(struct rhine_private *rp,

					   struct rhine_skb_dma *sd, int entry)

{

	rp->rx_skbuff_dma[entry] = sd->dma;

	rp->rx_skbuff[entry] = sd->skb;



	rp->rx_ring[entry].addr = cpu_to_le32(sd->dma);

	dma_wmb();

}



static void free_rbufs(struct net_device* dev);



static int alloc_rbufs(struct net_device *dev)

{

	struct rhine_private *rp = netdev_priv(dev);

	dma_addr_t next;

	int rc, i;



	rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);

	rp->rx_head_desc = &rp->rx_ring[0];

	next = rp->rx_ring_dma;



	/* Init the ring entries */
@@ -1239,23 +1282,20 @@ static void alloc_rbufs(struct net_device *dev) 


	/* Fill in the Rx buffers.  Handle allocation failure gracefully. */

	for (i = 0; i < RX_RING_SIZE; i++) {

		struct sk_buff *skb = netdev_alloc_skb(dev, rp->rx_buf_sz);

		rp->rx_skbuff[i] = skb;

		if (skb == NULL)

			break;

		struct rhine_skb_dma sd;



		rp->rx_skbuff_dma[i] =

			dma_map_single(hwdev, skb->data, rp->rx_buf_sz,

				       DMA_FROM_DEVICE);

		if (dma_mapping_error(hwdev, rp->rx_skbuff_dma[i])) {

			rp->rx_skbuff_dma[i] = 0;

			dev_kfree_skb(skb);

			break;

		rc = rhine_skb_dma_init(dev, &sd);

		if (rc < 0) {

			free_rbufs(dev);

			goto out;

		}

		rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);

		rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);



		rhine_skb_dma_nic_store(rp, &sd, i);

	}

	rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);



	rhine_reset_rbufs(rp);

out:

	return rc;

}



static void free_rbufs(struct net_device* dev)
@@ -1659,16 +1699,18 @@ static int rhine_open(struct net_device *dev) 


	rc = request_irq(rp->irq, rhine_interrupt, IRQF_SHARED, dev->name, dev);

	if (rc)

		return rc;

		goto out;



	netif_dbg(rp, ifup, dev, "%s() irq %d\n", __func__, rp->irq);



	rc = alloc_ring(dev);

	if (rc) {

		free_irq(rp->irq, dev);

		return rc;

	}

	alloc_rbufs(dev);

	if (rc < 0)

		goto out_free_irq;



	rc = alloc_rbufs(dev);

	if (rc < 0)

		goto out_free_ring;



	alloc_tbufs(dev);

	rhine_chip_reset(dev);

	rhine_task_enable(rp);
@@ -1680,7 +1722,14 @@ static int rhine_open(struct net_device *dev) 


	netif_start_queue(dev);



	return 0;

out:

	return rc;



out_free_ring:

	free_ring(dev);

out_free_irq:

	free_irq(rp->irq, dev);

	goto out;

}



static void rhine_reset_task(struct work_struct *work)
@@ -1700,9 +1749,9 @@ static void rhine_reset_task(struct work_struct *work) 


	/* clear all descriptors */

	free_tbufs(dev);

	free_rbufs(dev);

	alloc_tbufs(dev);

	alloc_rbufs(dev);



	rhine_reset_rbufs(rp);



	/* Reinitialize the hardware. */

	rhine_chip_reset(dev);
@@ -1730,6 +1779,11 @@ static void rhine_tx_timeout(struct net_device *dev) 
	schedule_work(&rp->reset_task);

}



static inline bool rhine_tx_queue_full(struct rhine_private *rp)

{

	return (rp->cur_tx - rp->dirty_tx) >= TX_QUEUE_LEN;

}



static netdev_tx_t rhine_start_tx(struct sk_buff *skb,

				  struct net_device *dev)

{
@@ -1800,11 +1854,17 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb, 


	netdev_sent_queue(dev, skb->len);

	/* lock eth irq */

	wmb();

	dma_wmb();

	rp->tx_ring[entry].tx_status |= cpu_to_le32(DescOwn);

	wmb();



	rp->cur_tx++;

	/*

	 * Nobody wants cur_tx write to rot for ages after the NIC will have

	 * seen the transmit request, especially as the transmit completion

	 * handler could miss it.

	 */

	smp_wmb();



	/* Non-x86 Todo: explicitly flush cache lines here. */
@@ -1817,8 +1877,14 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb, 
	       ioaddr + ChipCmd1);

	IOSYNC;



	if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)

	/* dirty_tx may be pessimistically out-of-sync. See rhine_tx. */

	if (rhine_tx_queue_full(rp)) {

		netif_stop_queue(dev);

		smp_rmb();

		/* Rejuvenate. */

		if (!rhine_tx_queue_full(rp))

			netif_wake_queue(dev);

	}



	netif_dbg(rp, tx_queued, dev, "Transmit frame #%d queued in slot %d\n",

		  rp->cur_tx - 1, entry);
@@ -1866,13 +1932,24 @@ static void rhine_tx(struct net_device *dev) 
{

	struct rhine_private *rp = netdev_priv(dev);

	struct device *hwdev = dev->dev.parent;

	int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;

	unsigned int pkts_compl = 0, bytes_compl = 0;

	unsigned int dirty_tx = rp->dirty_tx;

	unsigned int cur_tx;

	struct sk_buff *skb;



	/*

	 * The race with rhine_start_tx does not matter here as long as the

	 * driver enforces a value of cur_tx that was relevant when the

	 * packet was scheduled to the network chipset.

	 * Executive summary: smp_rmb() balances smp_wmb() in rhine_start_tx.

	 */

	smp_rmb();

	cur_tx = rp->cur_tx;

	/* find and cleanup dirty tx descriptors */

	while (rp->dirty_tx != rp->cur_tx) {

		txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);

	while (dirty_tx != cur_tx) {

		unsigned int entry = dirty_tx % TX_RING_SIZE;

		u32 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);



		netif_dbg(rp, tx_done, dev, "Tx scavenge %d status %08x\n",

			  entry, txstatus);

		if (txstatus & DescOwn)
@@ -1921,12 +1998,23 @@ static void rhine_tx(struct net_device *dev) 
		pkts_compl++;

		dev_consume_skb_any(skb);

		rp->tx_skbuff[entry] = NULL;

		entry = (++rp->dirty_tx) % TX_RING_SIZE;

		dirty_tx++;

	}



	rp->dirty_tx = dirty_tx;

	/* Pity we can't rely on the nearby BQL completion implicit barrier. */

	smp_wmb();



	netdev_completed_queue(dev, pkts_compl, bytes_compl);

	if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)



	/* cur_tx may be optimistically out-of-sync. See rhine_start_tx. */

	if (!rhine_tx_queue_full(rp) && netif_queue_stopped(dev)) {

		netif_wake_queue(dev);

		smp_rmb();

		/* Rejuvenate. */

		if (rhine_tx_queue_full(rp))

			netif_stop_queue(dev);

	}

}



/**
@@ -1944,22 +2032,33 @@ static inline u16 rhine_get_vlan_tci(struct sk_buff *skb, int data_size) 
	return be16_to_cpup((__be16 *)trailer);

}



static inline void rhine_rx_vlan_tag(struct sk_buff *skb, struct rx_desc *desc,

				     int data_size)

{

	dma_rmb();

	if (unlikely(desc->desc_length & cpu_to_le32(DescTag))) {

		u16 vlan_tci;



		vlan_tci = rhine_get_vlan_tci(skb, data_size);

		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tci);

	}

}



/* Process up to limit frames from receive ring */

static int rhine_rx(struct net_device *dev, int limit)

{

	struct rhine_private *rp = netdev_priv(dev);

	struct device *hwdev = dev->dev.parent;

	int count;

	int entry = rp->cur_rx % RX_RING_SIZE;

	int count;



	netif_dbg(rp, rx_status, dev, "%s(), entry %d status %08x\n", __func__,

		  entry, le32_to_cpu(rp->rx_head_desc->rx_status));

		  entry, le32_to_cpu(rp->rx_ring[entry].rx_status));



	/* If EOP is set on the next entry, it's a new packet. Send it up. */

	for (count = 0; count < limit; ++count) {

		struct rx_desc *desc = rp->rx_head_desc;

		struct rx_desc *desc = rp->rx_ring + entry;

		u32 desc_status = le32_to_cpu(desc->rx_status);

		u32 desc_length = le32_to_cpu(desc->desc_length);

		int data_size = desc_status >> 16;



		if (desc_status & DescOwn)
@@ -1975,10 +2074,6 @@ static int rhine_rx(struct net_device *dev, int limit) 
	"entry %#x length %d status %08x!\n",

					    entry, data_size,

					    desc_status);

				netdev_warn(dev,

					    "Oversized Ethernet frame %p vs %p\n",

					    rp->rx_head_desc,

					    &rp->rx_ring[entry]);

				dev->stats.rx_length_errors++;

			} else if (desc_status & RxErr) {

				/* There was a error. */
@@ -2000,16 +2095,17 @@ static int rhine_rx(struct net_device *dev, int limit) 
				}

			}

		} else {

			struct sk_buff *skb = NULL;

			/* Length should omit the CRC */

			int pkt_len = data_size - 4;

			u16 vlan_tci = 0;

			struct sk_buff *skb;



			/* Check if the packet is long enough to accept without

			   copying to a minimally-sized skbuff. */

			if (pkt_len < rx_copybreak)

			if (pkt_len < rx_copybreak) {

				skb = netdev_alloc_skb_ip_align(dev, pkt_len);

			if (skb) {

				if (unlikely(!skb))

					goto drop;



				dma_sync_single_for_cpu(hwdev,

							rp->rx_skbuff_dma[entry],

							rp->rx_buf_sz,
@@ -2018,32 +2114,31 @@ static int rhine_rx(struct net_device *dev, int limit) 
				skb_copy_to_linear_data(skb,

						 rp->rx_skbuff[entry]->data,

						 pkt_len);

				skb_put(skb, pkt_len);



				dma_sync_single_for_device(hwdev,

							   rp->rx_skbuff_dma[entry],

							   rp->rx_buf_sz,

							   DMA_FROM_DEVICE);

			} else {

				struct rhine_skb_dma sd;



				if (unlikely(rhine_skb_dma_init(dev, &sd) < 0))

					goto drop;



				skb = rp->rx_skbuff[entry];

				if (skb == NULL) {

					netdev_err(dev, "Inconsistent Rx descriptor chain\n");

					break;

				}

				rp->rx_skbuff[entry] = NULL;

				skb_put(skb, pkt_len);



				dma_unmap_single(hwdev,

						 rp->rx_skbuff_dma[entry],

						 rp->rx_buf_sz,

						 DMA_FROM_DEVICE);

				rhine_skb_dma_nic_store(rp, &sd, entry);

			}



			if (unlikely(desc_length & DescTag))

				vlan_tci = rhine_get_vlan_tci(skb, data_size);



			skb_put(skb, pkt_len);

			skb->protocol = eth_type_trans(skb, dev);



			if (unlikely(desc_length & DescTag))

				__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tci);

			rhine_rx_vlan_tag(skb, desc, data_size);



			netif_receive_skb(skb);



			u64_stats_update_begin(&rp->rx_stats.syncp);
@@ -2051,35 +2146,16 @@ static int rhine_rx(struct net_device *dev, int limit) 
			rp->rx_stats.packets++;

			u64_stats_update_end(&rp->rx_stats.syncp);

		}

give_descriptor_to_nic:

		desc->rx_status = cpu_to_le32(DescOwn);

		entry = (++rp->cur_rx) % RX_RING_SIZE;

		rp->rx_head_desc = &rp->rx_ring[entry];

	}



	/* Refill the Rx ring buffers. */

	for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {

		struct sk_buff *skb;

		entry = rp->dirty_rx % RX_RING_SIZE;

		if (rp->rx_skbuff[entry] == NULL) {

			skb = netdev_alloc_skb(dev, rp->rx_buf_sz);

			rp->rx_skbuff[entry] = skb;

			if (skb == NULL)

				break;	/* Better luck next round. */

			rp->rx_skbuff_dma[entry] =

				dma_map_single(hwdev, skb->data,

					       rp->rx_buf_sz,

					       DMA_FROM_DEVICE);

			if (dma_mapping_error(hwdev,

					      rp->rx_skbuff_dma[entry])) {

				dev_kfree_skb(skb);

				rp->rx_skbuff_dma[entry] = 0;

				break;

			}

			rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);

		}

		rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);

	}



	return count;



drop:

	dev->stats.rx_dropped++;

	goto give_descriptor_to_nic;

}



static void rhine_restart_tx(struct net_device *dev) {
@@ -2484,9 +2560,8 @@ static int rhine_resume(struct device *device) 
	enable_mmio(rp->pioaddr, rp->quirks);

	rhine_power_init(dev);

	free_tbufs(dev);

	free_rbufs(dev);

	alloc_tbufs(dev);

	alloc_rbufs(dev);

	rhine_reset_rbufs(rp);

	rhine_task_enable(rp);

	spin_lock_bh(&rp->lock);

	init_registers(dev);

CRA Git | Maintained and supported by SUSTech CRA and CCSE