Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e3ad57c9 authored by Giuseppe Cavallaro's avatar Giuseppe Cavallaro Committed by David S. Miller
Browse files

stmmac: review RX/TX ring management 



This patch is to rework the ring management now optimized.
The indexes into the ring buffer are always incremented, and
the entry is accessed via doing a modulo to find the "real"
position in the ring.
It is inefficient, modulo is an expensive operation.

The formula [(entry + 1) & (size - 1)] is now adopted on
a ring that is power-of-2 in size.
Then, the number of elements cannot be set by command line but
it is fixed.

Signed-off-by: default avatarGiuseppe Cavallaro <peppe.cavallaro@st.com>
Signed-off-by: default avatarAlexandre TORGUE <alexandre.torgue@st.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 293e4365

drivers/net/ethernet/stmicro/stmmac/chain_mode.c

+9 −8
Original line number Diff line number Diff line
@@ -31,8 +31,7 @@ 
static int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum)

{

	struct stmmac_priv *priv = (struct stmmac_priv *)p;

	unsigned int txsize = priv->dma_tx_size;

	unsigned int entry = priv->cur_tx % txsize;

	unsigned int entry = priv->cur_tx;

	struct dma_desc *desc = priv->dma_tx + entry;

	unsigned int nopaged_len = skb_headlen(skb);

	unsigned int bmax;
@@ -54,7 +53,7 @@ static int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum) 


	while (len != 0) {

		priv->tx_skbuff[entry] = NULL;

		entry = (++priv->cur_tx) % txsize;

		entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);

		desc = priv->dma_tx + entry;



		if (len > bmax) {
@@ -82,6 +81,9 @@ static int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum) 
			len = 0;

		}

	}



	priv->cur_tx = entry;



	return entry;

}
@@ -138,7 +140,7 @@ static void stmmac_refill_desc3(void *priv_ptr, struct dma_desc *p) 
		 */

		p->des3 = (unsigned int)(priv->dma_rx_phy +

					 (((priv->dirty_rx) + 1) %

					  priv->dma_rx_size) *

					  DMA_RX_SIZE) *

					 sizeof(struct dma_desc));

}
@@ -151,10 +153,9 @@ static void stmmac_clean_desc3(void *priv_ptr, struct dma_desc *p) 
		 * 1588-2002 time stamping is enabled, hence reinitialize it

		 * to keep explicit chaining in the descriptor.

		 */

		p->des3 = (unsigned int)(priv->dma_tx_phy +

					 (((priv->dirty_tx + 1) %

					   priv->dma_tx_size) *

					  sizeof(struct dma_desc)));

		p->des3 = (unsigned int)((priv->dma_tx_phy +

					  ((priv->dirty_tx + 1) % DMA_TX_SIZE))

					  * sizeof(struct dma_desc));

}



const struct stmmac_mode_ops chain_mode_ops = {

drivers/net/ethernet/stmicro/stmmac/common.h

+4 −0
Original line number Diff line number Diff line
@@ -42,6 +42,10 @@ 
#define	DWMAC_CORE_3_40	0x34

#define	DWMAC_CORE_3_50	0x35



#define DMA_TX_SIZE 512

#define DMA_RX_SIZE 512

#define STMMAC_GET_ENTRY(x, size)	((x + 1) & (size - 1))



#undef FRAME_FILTER_DEBUG

/* #define FRAME_FILTER_DEBUG */

drivers/net/ethernet/stmicro/stmmac/ring_mode.c

+4 −3
Original line number Diff line number Diff line
@@ -31,8 +31,7 @@ 
static int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum)

{

	struct stmmac_priv *priv = (struct stmmac_priv *)p;

	unsigned int txsize = priv->dma_tx_size;

	unsigned int entry = priv->cur_tx % txsize;

	unsigned int entry = priv->cur_tx;

	struct dma_desc *desc;

	unsigned int nopaged_len = skb_headlen(skb);

	unsigned int bmax, len;
@@ -62,7 +61,7 @@ static int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum) 
						STMMAC_RING_MODE);

		wmb();

		priv->tx_skbuff[entry] = NULL;

		entry = (++priv->cur_tx) % txsize;

		entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);



		if (priv->extend_desc)

			desc = (struct dma_desc *)(priv->dma_etx + entry);
@@ -90,6 +89,8 @@ static int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum) 
						STMMAC_RING_MODE);

	}



	priv->cur_tx = entry;



	return entry;

}

drivers/net/ethernet/stmicro/stmmac/stmmac.h

+0 −2
Original line number Diff line number Diff line
@@ -54,7 +54,6 @@ struct stmmac_priv { 
	struct sk_buff **tx_skbuff;

	unsigned int cur_tx;

	unsigned int dirty_tx;

	unsigned int dma_tx_size;

	u32 tx_count_frames;

	u32 tx_coal_frames;

	u32 tx_coal_timer;
@@ -71,7 +70,6 @@ struct stmmac_priv { 
	struct sk_buff **rx_skbuff;

	unsigned int cur_rx;

	unsigned int dirty_rx;

	unsigned int dma_rx_size;

	unsigned int dma_buf_sz;

	u32 rx_riwt;

	int hwts_rx_en;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

+94 −104
Original line number Diff line number Diff line
@@ -71,15 +71,7 @@ static int phyaddr = -1; 
module_param(phyaddr, int, S_IRUGO);

MODULE_PARM_DESC(phyaddr, "Physical device address");



#define DMA_TX_SIZE 256

static int dma_txsize = DMA_TX_SIZE;

module_param(dma_txsize, int, S_IRUGO | S_IWUSR);

MODULE_PARM_DESC(dma_txsize, "Number of descriptors in the TX list");



#define DMA_RX_SIZE 256

static int dma_rxsize = DMA_RX_SIZE;

module_param(dma_rxsize, int, S_IRUGO | S_IWUSR);

MODULE_PARM_DESC(dma_rxsize, "Number of descriptors in the RX list");

#define STMMAC_TX_THRESH	(DMA_TX_SIZE / 4)



static int flow_ctrl = FLOW_OFF;

module_param(flow_ctrl, int, S_IRUGO | S_IWUSR);
@@ -134,10 +126,6 @@ static void stmmac_verify_args(void) 
{

	if (unlikely(watchdog < 0))

		watchdog = TX_TIMEO;

	if (unlikely(dma_rxsize < 0))

		dma_rxsize = DMA_RX_SIZE;

	if (unlikely(dma_txsize < 0))

		dma_txsize = DMA_TX_SIZE;

	if (unlikely((buf_sz < DEFAULT_BUFSIZE) || (buf_sz > BUF_SIZE_16KiB)))

		buf_sz = DEFAULT_BUFSIZE;

	if (unlikely(flow_ctrl > 1))
@@ -197,12 +185,28 @@ static void print_pkt(unsigned char *buf, int len) 
	print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, buf, len);

}



/* minimum number of free TX descriptors required to wake up TX process */

#define STMMAC_TX_THRESH(x)	(x->dma_tx_size/4)



static inline u32 stmmac_tx_avail(struct stmmac_priv *priv)

{

	return priv->dirty_tx + priv->dma_tx_size - priv->cur_tx - 1;

	unsigned avail;



	if (priv->dirty_tx > priv->cur_tx)

		avail = priv->dirty_tx - priv->cur_tx - 1;

	else

		avail = DMA_TX_SIZE - priv->cur_tx + priv->dirty_tx - 1;



	return avail;

}



static inline u32 stmmac_rx_dirty(struct stmmac_priv *priv)

{

	unsigned dirty;



	if (priv->dirty_rx <= priv->cur_rx)

		dirty = priv->cur_rx - priv->dirty_rx;

	else

		dirty = DMA_RX_SIZE - priv->dirty_rx + priv->cur_rx;



	return dirty;

}



/**
@@ -906,19 +910,16 @@ static void stmmac_display_ring(void *head, int size, int extend_desc) 


static void stmmac_display_rings(struct stmmac_priv *priv)

{

	unsigned int txsize = priv->dma_tx_size;

	unsigned int rxsize = priv->dma_rx_size;



	if (priv->extend_desc) {

		pr_info("Extended RX descriptor ring:\n");

		stmmac_display_ring((void *)priv->dma_erx, rxsize, 1);

		stmmac_display_ring((void *)priv->dma_erx, DMA_RX_SIZE, 1);

		pr_info("Extended TX descriptor ring:\n");

		stmmac_display_ring((void *)priv->dma_etx, txsize, 1);

		stmmac_display_ring((void *)priv->dma_etx, DMA_TX_SIZE, 1);

	} else {

		pr_info("RX descriptor ring:\n");

		stmmac_display_ring((void *)priv->dma_rx, rxsize, 0);

		stmmac_display_ring((void *)priv->dma_rx, DMA_RX_SIZE, 0);

		pr_info("TX descriptor ring:\n");

		stmmac_display_ring((void *)priv->dma_tx, txsize, 0);

		stmmac_display_ring((void *)priv->dma_tx, DMA_TX_SIZE, 0);

	}

}
@@ -947,28 +948,26 @@ static int stmmac_set_bfsize(int mtu, int bufsize) 
static void stmmac_clear_descriptors(struct stmmac_priv *priv)

{

	int i;

	unsigned int txsize = priv->dma_tx_size;

	unsigned int rxsize = priv->dma_rx_size;



	/* Clear the Rx/Tx descriptors */

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

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

		if (priv->extend_desc)

			priv->hw->desc->init_rx_desc(&priv->dma_erx[i].basic,

						     priv->use_riwt, priv->mode,

						     (i == rxsize - 1));

						     (i == DMA_RX_SIZE - 1));

		else

			priv->hw->desc->init_rx_desc(&priv->dma_rx[i],

						     priv->use_riwt, priv->mode,

						     (i == rxsize - 1));

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

						     (i == DMA_RX_SIZE - 1));

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

		if (priv->extend_desc)

			priv->hw->desc->init_tx_desc(&priv->dma_etx[i].basic,

						     priv->mode,

						     (i == txsize - 1));

						     (i == DMA_TX_SIZE - 1));

		else

			priv->hw->desc->init_tx_desc(&priv->dma_tx[i],

						     priv->mode,

						     (i == txsize - 1));

						     (i == DMA_TX_SIZE - 1));

}



/**
@@ -1031,8 +1030,6 @@ static int init_dma_desc_rings(struct net_device *dev, gfp_t flags) 
{

	int i;

	struct stmmac_priv *priv = netdev_priv(dev);

	unsigned int txsize = priv->dma_tx_size;

	unsigned int rxsize = priv->dma_rx_size;

	unsigned int bfsize = 0;

	int ret = -ENOMEM;
@@ -1044,10 +1041,6 @@ static int init_dma_desc_rings(struct net_device *dev, gfp_t flags) 


	priv->dma_buf_sz = bfsize;



	if (netif_msg_probe(priv))

		pr_debug("%s: txsize %d, rxsize %d, bfsize %d\n", __func__,

			 txsize, rxsize, bfsize);



	if (netif_msg_probe(priv)) {

		pr_debug("(%s) dma_rx_phy=0x%08x dma_tx_phy=0x%08x\n", __func__,

			 (u32) priv->dma_rx_phy, (u32) priv->dma_tx_phy);
@@ -1055,7 +1048,7 @@ static int init_dma_desc_rings(struct net_device *dev, gfp_t flags) 
		/* RX INITIALIZATION */

		pr_debug("\tSKB addresses:\nskb\t\tskb data\tdma data\n");

	}

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

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

		struct dma_desc *p;

		if (priv->extend_desc)

			p = &((priv->dma_erx + i)->basic);
@@ -1072,26 +1065,26 @@ static int init_dma_desc_rings(struct net_device *dev, gfp_t flags) 
				 (unsigned int)priv->rx_skbuff_dma[i]);

	}

	priv->cur_rx = 0;

	priv->dirty_rx = (unsigned int)(i - rxsize);

	priv->dirty_rx = (unsigned int)(i - DMA_RX_SIZE);

	buf_sz = bfsize;



	/* Setup the chained descriptor addresses */

	if (priv->mode == STMMAC_CHAIN_MODE) {

		if (priv->extend_desc) {

			priv->hw->mode->init(priv->dma_erx, priv->dma_rx_phy,

					     rxsize, 1);

					     DMA_RX_SIZE, 1);

			priv->hw->mode->init(priv->dma_etx, priv->dma_tx_phy,

					     txsize, 1);

					     DMA_TX_SIZE, 1);

		} else {

			priv->hw->mode->init(priv->dma_rx, priv->dma_rx_phy,

					     rxsize, 0);

					     DMA_RX_SIZE, 0);

			priv->hw->mode->init(priv->dma_tx, priv->dma_tx_phy,

					     txsize, 0);

					     DMA_TX_SIZE, 0);

		}

	}



	/* TX INITIALIZATION */

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

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

		struct dma_desc *p;

		if (priv->extend_desc)

			p = &((priv->dma_etx + i)->basic);
@@ -1123,7 +1116,7 @@ static void dma_free_rx_skbufs(struct stmmac_priv *priv) 
{

	int i;



	for (i = 0; i < priv->dma_rx_size; i++)

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

		stmmac_free_rx_buffers(priv, i);

}
@@ -1131,7 +1124,7 @@ static void dma_free_tx_skbufs(struct stmmac_priv *priv) 
{

	int i;



	for (i = 0; i < priv->dma_tx_size; i++) {

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

		struct dma_desc *p;



		if (priv->extend_desc)
@@ -1171,33 +1164,31 @@ static void dma_free_tx_skbufs(struct stmmac_priv *priv) 
 */

static int alloc_dma_desc_resources(struct stmmac_priv *priv)

{

	unsigned int txsize = priv->dma_tx_size;

	unsigned int rxsize = priv->dma_rx_size;

	int ret = -ENOMEM;



	priv->rx_skbuff_dma = kmalloc_array(rxsize, sizeof(dma_addr_t),

	priv->rx_skbuff_dma = kmalloc_array(DMA_RX_SIZE, sizeof(dma_addr_t),

					    GFP_KERNEL);

	if (!priv->rx_skbuff_dma)

		return -ENOMEM;



	priv->rx_skbuff = kmalloc_array(rxsize, sizeof(struct sk_buff *),

	priv->rx_skbuff = kmalloc_array(DMA_RX_SIZE, sizeof(struct sk_buff *),

					GFP_KERNEL);

	if (!priv->rx_skbuff)

		goto err_rx_skbuff;



	priv->tx_skbuff_dma = kmalloc_array(txsize,

	priv->tx_skbuff_dma = kmalloc_array(DMA_TX_SIZE,

					    sizeof(*priv->tx_skbuff_dma),

					    GFP_KERNEL);

	if (!priv->tx_skbuff_dma)

		goto err_tx_skbuff_dma;



	priv->tx_skbuff = kmalloc_array(txsize, sizeof(struct sk_buff *),

	priv->tx_skbuff = kmalloc_array(DMA_TX_SIZE, sizeof(struct sk_buff *),

					GFP_KERNEL);

	if (!priv->tx_skbuff)

		goto err_tx_skbuff;



	if (priv->extend_desc) {

		priv->dma_erx = dma_zalloc_coherent(priv->device, rxsize *

		priv->dma_erx = dma_zalloc_coherent(priv->device, DMA_RX_SIZE *

						    sizeof(struct

							   dma_extended_desc),

						    &priv->dma_rx_phy,
@@ -1205,31 +1196,31 @@ static int alloc_dma_desc_resources(struct stmmac_priv *priv) 
		if (!priv->dma_erx)

			goto err_dma;



		priv->dma_etx = dma_zalloc_coherent(priv->device, txsize *

		priv->dma_etx = dma_zalloc_coherent(priv->device, DMA_TX_SIZE *

						    sizeof(struct

							   dma_extended_desc),

						    &priv->dma_tx_phy,

						    GFP_KERNEL);

		if (!priv->dma_etx) {

			dma_free_coherent(priv->device, priv->dma_rx_size *

			dma_free_coherent(priv->device, DMA_RX_SIZE *

					  sizeof(struct dma_extended_desc),

					  priv->dma_erx, priv->dma_rx_phy);

			goto err_dma;

		}

	} else {

		priv->dma_rx = dma_zalloc_coherent(priv->device, rxsize *

		priv->dma_rx = dma_zalloc_coherent(priv->device, DMA_RX_SIZE *

						   sizeof(struct dma_desc),

						   &priv->dma_rx_phy,

						   GFP_KERNEL);

		if (!priv->dma_rx)

			goto err_dma;



		priv->dma_tx = dma_zalloc_coherent(priv->device, txsize *

		priv->dma_tx = dma_zalloc_coherent(priv->device, DMA_TX_SIZE *

						   sizeof(struct dma_desc),

						   &priv->dma_tx_phy,

						   GFP_KERNEL);

		if (!priv->dma_tx) {

			dma_free_coherent(priv->device, priv->dma_rx_size *

			dma_free_coherent(priv->device, DMA_RX_SIZE *

					  sizeof(struct dma_desc),

					  priv->dma_rx, priv->dma_rx_phy);

			goto err_dma;
@@ -1258,16 +1249,16 @@ static void free_dma_desc_resources(struct stmmac_priv *priv) 
	/* Free DMA regions of consistent memory previously allocated */

	if (!priv->extend_desc) {

		dma_free_coherent(priv->device,

				  priv->dma_tx_size * sizeof(struct dma_desc),

				  DMA_TX_SIZE * sizeof(struct dma_desc),

				  priv->dma_tx, priv->dma_tx_phy);

		dma_free_coherent(priv->device,

				  priv->dma_rx_size * sizeof(struct dma_desc),

				  DMA_RX_SIZE * sizeof(struct dma_desc),

				  priv->dma_rx, priv->dma_rx_phy);

	} else {

		dma_free_coherent(priv->device, priv->dma_tx_size *

		dma_free_coherent(priv->device, DMA_TX_SIZE *

				  sizeof(struct dma_extended_desc),

				  priv->dma_etx, priv->dma_tx_phy);

		dma_free_coherent(priv->device, priv->dma_rx_size *

		dma_free_coherent(priv->device, DMA_RX_SIZE *

				  sizeof(struct dma_extended_desc),

				  priv->dma_erx, priv->dma_rx_phy);

	}
@@ -1312,16 +1303,15 @@ static void stmmac_dma_operation_mode(struct stmmac_priv *priv) 
 */

static void stmmac_tx_clean(struct stmmac_priv *priv)

{

	unsigned int txsize = priv->dma_tx_size;

	unsigned int bytes_compl = 0, pkts_compl = 0;

	unsigned int entry = priv->dirty_tx;



	spin_lock(&priv->tx_lock);



	priv->xstats.tx_clean++;



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

	while (entry != priv->cur_tx) {

		int last;

		unsigned int entry = priv->dirty_tx % txsize;

		struct sk_buff *skb = priv->tx_skbuff[entry];

		struct dma_desc *p;
@@ -1378,16 +1368,17 @@ static void stmmac_tx_clean(struct stmmac_priv *priv) 


		priv->hw->desc->release_tx_desc(p, priv->mode);



		priv->dirty_tx++;

		entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);

		priv->dirty_tx = entry;

	}



	netdev_completed_queue(priv->dev, pkts_compl, bytes_compl);



	if (unlikely(netif_queue_stopped(priv->dev) &&

		     stmmac_tx_avail(priv) > STMMAC_TX_THRESH(priv))) {

		     stmmac_tx_avail(priv) > STMMAC_TX_THRESH)) {

		netif_tx_lock(priv->dev);

		if (netif_queue_stopped(priv->dev) &&

		    stmmac_tx_avail(priv) > STMMAC_TX_THRESH(priv)) {

		    stmmac_tx_avail(priv) > STMMAC_TX_THRESH) {

			if (netif_msg_tx_done(priv))

				pr_debug("%s: restart transmit\n", __func__);

			netif_wake_queue(priv->dev);
@@ -1421,20 +1412,19 @@ static inline void stmmac_disable_dma_irq(struct stmmac_priv *priv) 
static void stmmac_tx_err(struct stmmac_priv *priv)

{

	int i;

	int txsize = priv->dma_tx_size;

	netif_stop_queue(priv->dev);



	priv->hw->dma->stop_tx(priv->ioaddr);

	dma_free_tx_skbufs(priv);

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

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

		if (priv->extend_desc)

			priv->hw->desc->init_tx_desc(&priv->dma_etx[i].basic,

						     priv->mode,

						     (i == txsize - 1));

						     (i == DMA_TX_SIZE - 1));

		else

			priv->hw->desc->init_tx_desc(&priv->dma_tx[i],

						     priv->mode,

						     (i == txsize - 1));

						     (i == DMA_TX_SIZE - 1));

	priv->dirty_tx = 0;

	priv->cur_tx = 0;

	netdev_reset_queue(priv->dev);
@@ -1811,9 +1801,6 @@ static int stmmac_open(struct net_device *dev) 
	memset(&priv->xstats, 0, sizeof(struct stmmac_extra_stats));

	priv->xstats.threshold = tc;



	/* Create and initialize the TX/RX descriptors chains. */

	priv->dma_tx_size = STMMAC_ALIGN(dma_txsize);

	priv->dma_rx_size = STMMAC_ALIGN(dma_rxsize);

	priv->dma_buf_sz = STMMAC_ALIGN(buf_sz);



	ret = alloc_dma_desc_resources(priv);
@@ -1955,7 +1942,6 @@ static int stmmac_release(struct net_device *dev) 
static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)

{

	struct stmmac_priv *priv = netdev_priv(dev);

	unsigned int txsize = priv->dma_tx_size;

	int entry;

	int i, csum_insertion = 0, is_jumbo = 0;

	int nfrags = skb_shinfo(skb)->nr_frags;
@@ -1978,7 +1964,8 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) 
	if (priv->tx_path_in_lpi_mode)

		stmmac_disable_eee_mode(priv);



	entry = priv->cur_tx % txsize;

	entry = priv->cur_tx;





	csum_insertion = (skb->ip_summed == CHECKSUM_PARTIAL);
@@ -2013,7 +2000,8 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) 
		int len = skb_frag_size(frag);



		priv->tx_skbuff[entry] = NULL;

		entry = (++priv->cur_tx) % txsize;

		entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);



		if (priv->extend_desc)

			desc = (struct dma_desc *)(priv->dma_etx + entry);

		else
@@ -2056,17 +2044,21 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) 
	priv->hw->desc->set_tx_owner(first);

	wmb();



	priv->cur_tx++;

	entry = STMMAC_GET_ENTRY(entry, DMA_TX_SIZE);



	priv->cur_tx = entry;



	if (netif_msg_pktdata(priv)) {

		pr_debug("%s: curr %d dirty=%d entry=%d, first=%p, nfrags=%d",

			__func__, (priv->cur_tx % txsize),

			(priv->dirty_tx % txsize), entry, first, nfrags);

			__func__, (priv->cur_tx % DMA_TX_SIZE),

			(priv->dirty_tx % DMA_TX_SIZE), entry, first, nfrags);



		if (priv->extend_desc)

			stmmac_display_ring((void *)priv->dma_etx, txsize, 1);

			stmmac_display_ring((void *)priv->dma_etx,

					    DMA_TX_SIZE, 1);

		else

			stmmac_display_ring((void *)priv->dma_tx, txsize, 0);

			stmmac_display_ring((void *)priv->dma_tx,

					    DMA_TX_SIZE, 0);



		pr_debug(">>> frame to be transmitted: ");

		print_pkt(skb->data, skb->len);
@@ -2128,11 +2120,11 @@ static void stmmac_rx_vlan(struct net_device *dev, struct sk_buff *skb) 
 */

static inline void stmmac_rx_refill(struct stmmac_priv *priv)

{

	unsigned int rxsize = priv->dma_rx_size;

	int bfsize = priv->dma_buf_sz;

	unsigned int entry = priv->dirty_rx;

	int dirty = stmmac_rx_dirty(priv);



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

		unsigned int entry = priv->dirty_rx % rxsize;

	while (dirty-- > 0) {

		struct dma_desc *p;



		if (priv->extend_desc)
@@ -2168,7 +2160,10 @@ static inline void stmmac_rx_refill(struct stmmac_priv *priv) 
		wmb();

		priv->hw->desc->set_rx_owner(p);

		wmb();



		entry = STMMAC_GET_ENTRY(entry, DMA_RX_SIZE);

	}

	priv->dirty_rx = entry;

}



/**
@@ -2180,8 +2175,7 @@ static inline void stmmac_rx_refill(struct stmmac_priv *priv) 
 */

static int stmmac_rx(struct stmmac_priv *priv, int limit)

{

	unsigned int rxsize = priv->dma_rx_size;

	unsigned int entry = priv->cur_rx % rxsize;

	unsigned int entry = priv->cur_rx;

	unsigned int next_entry;

	unsigned int count = 0;

	int coe = priv->hw->rx_csum;
@@ -2189,9 +2183,11 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit) 
	if (netif_msg_rx_status(priv)) {

		pr_debug("%s: descriptor ring:\n", __func__);

		if (priv->extend_desc)

			stmmac_display_ring((void *)priv->dma_erx, rxsize, 1);

			stmmac_display_ring((void *)priv->dma_erx,

					    DMA_RX_SIZE, 1);

		else

			stmmac_display_ring((void *)priv->dma_rx, rxsize, 0);

			stmmac_display_ring((void *)priv->dma_rx,

					    DMA_RX_SIZE, 0);

	}

	while (count < limit) {

		int status;
@@ -2207,7 +2203,9 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit) 


		count++;



		next_entry = (++priv->cur_rx) % rxsize;

		priv->cur_rx = STMMAC_GET_ENTRY(priv->cur_rx, DMA_RX_SIZE);

		next_entry = priv->cur_rx;



		if (priv->extend_desc)

			prefetch(priv->dma_erx + next_entry);

		else
@@ -2567,19 +2565,17 @@ static int stmmac_sysfs_ring_read(struct seq_file *seq, void *v) 
{

	struct net_device *dev = seq->private;

	struct stmmac_priv *priv = netdev_priv(dev);

	unsigned int txsize = priv->dma_tx_size;

	unsigned int rxsize = priv->dma_rx_size;



	if (priv->extend_desc) {

		seq_printf(seq, "Extended RX descriptor ring:\n");

		sysfs_display_ring((void *)priv->dma_erx, rxsize, 1, seq);

		sysfs_display_ring((void *)priv->dma_erx, DMA_RX_SIZE, 1, seq);

		seq_printf(seq, "Extended TX descriptor ring:\n");

		sysfs_display_ring((void *)priv->dma_etx, txsize, 1, seq);

		sysfs_display_ring((void *)priv->dma_etx, DMA_TX_SIZE, 1, seq);

	} else {

		seq_printf(seq, "RX descriptor ring:\n");

		sysfs_display_ring((void *)priv->dma_rx, rxsize, 0, seq);

		sysfs_display_ring((void *)priv->dma_rx, DMA_RX_SIZE, 0, seq);

		seq_printf(seq, "TX descriptor ring:\n");

		sysfs_display_ring((void *)priv->dma_tx, txsize, 0, seq);

		sysfs_display_ring((void *)priv->dma_tx, DMA_TX_SIZE, 0, seq);

	}



	return 0;
@@ -3149,12 +3145,6 @@ static int __init stmmac_cmdline_opt(char *str) 
		} else if (!strncmp(opt, "phyaddr:", 8)) {

			if (kstrtoint(opt + 8, 0, &phyaddr))

				goto err;

		} else if (!strncmp(opt, "dma_txsize:", 11)) {

			if (kstrtoint(opt + 11, 0, &dma_txsize))

				goto err;

		} else if (!strncmp(opt, "dma_rxsize:", 11)) {

			if (kstrtoint(opt + 11, 0, &dma_rxsize))

				goto err;

		} else if (!strncmp(opt, "buf_sz:", 7)) {

			if (kstrtoint(opt + 7, 0, &buf_sz))

				goto err;