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

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

Merge branch 'stmmac-Clean-up-and-tune-up' 



Jose Abreu says:

====================
net: stmmac: Clean-up and tune-up

This targets to uniformize the handling of the different GMAC versions in
stmmac_main.c file and also tune-up the HW.

Currently there are some if/else conditions in the main source file which
calls different callbacks depending on the ID of GMAC.

With the introducion of a generic HW interface handling which automatically
selects the GMAC callbacks to be used, it is now unpleasant to see if
conditions in the main code because this should be completely agnostic of the
GMAC version.

This series removes most of these conditions. There are some if conditions
that remain untouched but the callbacks handling are now uniformized.

Tested in GMAC5, hope I didn't break any previous versions.

Please check [1] for performance analisys of patches 3-12.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 538e2de1 61fac60a

drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c

+51 −31
Original line number Diff line number Diff line
@@ -276,17 +276,28 @@ static int sun8i_dwmac_dma_reset(void __iomem *ioaddr) 
 * Called from stmmac via stmmac_dma_ops->init

 */

static void sun8i_dwmac_dma_init(void __iomem *ioaddr,

				 struct stmmac_dma_cfg *dma_cfg,

				 u32 dma_tx, u32 dma_rx, int atds)

				 struct stmmac_dma_cfg *dma_cfg, int atds)

{

	/* Write TX and RX descriptors address */

	writel(dma_rx, ioaddr + EMAC_RX_DESC_LIST);

	writel(dma_tx, ioaddr + EMAC_TX_DESC_LIST);



	writel(EMAC_RX_INT | EMAC_TX_INT, ioaddr + EMAC_INT_EN);

	writel(0x1FFFFFF, ioaddr + EMAC_INT_STA);

}



static void sun8i_dwmac_dma_init_rx(void __iomem *ioaddr,

				    struct stmmac_dma_cfg *dma_cfg,

				    u32 dma_rx_phy, u32 chan)

{

	/* Write RX descriptors address */

	writel(dma_rx_phy, ioaddr + EMAC_RX_DESC_LIST);

}



static void sun8i_dwmac_dma_init_tx(void __iomem *ioaddr,

				    struct stmmac_dma_cfg *dma_cfg,

				    u32 dma_tx_phy, u32 chan)

{

	/* Write TX descriptors address */

	writel(dma_tx_phy, ioaddr + EMAC_TX_DESC_LIST);

}



/* sun8i_dwmac_dump_regs() - Dump EMAC address space

 * Called from stmmac_dma_ops->dump_regs

 * Used for ethtool
@@ -437,13 +448,36 @@ static int sun8i_dwmac_dma_interrupt(void __iomem *ioaddr, 
	return ret;

}



static void sun8i_dwmac_dma_operation_mode(void __iomem *ioaddr, int txmode,

					   int rxmode, int rxfifosz)

static void sun8i_dwmac_dma_operation_mode_rx(void __iomem *ioaddr, int mode,

					      u32 channel, int fifosz, u8 qmode)

{

	u32 v;



	v = readl(ioaddr + EMAC_RX_CTL1);

	if (mode == SF_DMA_MODE) {

		v |= EMAC_RX_MD;

	} else {

		v &= ~EMAC_RX_MD;

		v &= ~EMAC_RX_TH_MASK;

		if (mode < 32)

			v |= EMAC_RX_TH_32;

		else if (mode < 64)

			v |= EMAC_RX_TH_64;

		else if (mode < 96)

			v |= EMAC_RX_TH_96;

		else if (mode < 128)

			v |= EMAC_RX_TH_128;

	}

	writel(v, ioaddr + EMAC_RX_CTL1);

}



static void sun8i_dwmac_dma_operation_mode_tx(void __iomem *ioaddr, int mode,

					      u32 channel, int fifosz, u8 qmode)

{

	u32 v;



	v = readl(ioaddr + EMAC_TX_CTL1);

	if (txmode == SF_DMA_MODE) {

	if (mode == SF_DMA_MODE) {

		v |= EMAC_TX_MD;

		/* Undocumented bit (called TX_NEXT_FRM in BSP), the original

		 * comment is
@@ -454,40 +488,26 @@ static void sun8i_dwmac_dma_operation_mode(void __iomem *ioaddr, int txmode, 
	} else {

		v &= ~EMAC_TX_MD;

		v &= ~EMAC_TX_TH_MASK;

		if (txmode < 64)

		if (mode < 64)

			v |= EMAC_TX_TH_64;

		else if (txmode < 128)

		else if (mode < 128)

			v |= EMAC_TX_TH_128;

		else if (txmode < 192)

		else if (mode < 192)

			v |= EMAC_TX_TH_192;

		else if (txmode < 256)

		else if (mode < 256)

			v |= EMAC_TX_TH_256;

	}

	writel(v, ioaddr + EMAC_TX_CTL1);



	v = readl(ioaddr + EMAC_RX_CTL1);

	if (rxmode == SF_DMA_MODE) {

		v |= EMAC_RX_MD;

	} else {

		v &= ~EMAC_RX_MD;

		v &= ~EMAC_RX_TH_MASK;

		if (rxmode < 32)

			v |= EMAC_RX_TH_32;

		else if (rxmode < 64)

			v |= EMAC_RX_TH_64;

		else if (rxmode < 96)

			v |= EMAC_RX_TH_96;

		else if (rxmode < 128)

			v |= EMAC_RX_TH_128;

	}

	writel(v, ioaddr + EMAC_RX_CTL1);

}



static const struct stmmac_dma_ops sun8i_dwmac_dma_ops = {

	.reset = sun8i_dwmac_dma_reset,

	.init = sun8i_dwmac_dma_init,

	.init_rx_chan = sun8i_dwmac_dma_init_rx,

	.init_tx_chan = sun8i_dwmac_dma_init_tx,

	.dump_regs = sun8i_dwmac_dump_regs,

	.dma_mode = sun8i_dwmac_dma_operation_mode,

	.dma_rx_mode = sun8i_dwmac_dma_operation_mode_rx,

	.dma_tx_mode = sun8i_dwmac_dma_operation_mode_tx,

	.enable_dma_transmission = sun8i_dwmac_enable_dma_transmission,

	.enable_dma_irq = sun8i_dwmac_enable_dma_irq,

	.disable_dma_irq = sun8i_dwmac_disable_dma_irq,

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

+56 −36
Original line number Diff line number Diff line
@@ -81,8 +81,7 @@ static void dwmac1000_dma_axi(void __iomem *ioaddr, struct stmmac_axi *axi) 
}



static void dwmac1000_dma_init(void __iomem *ioaddr,

			       struct stmmac_dma_cfg *dma_cfg,

			       u32 dma_tx, u32 dma_rx, int atds)

			       struct stmmac_dma_cfg *dma_cfg, int atds)

{

	u32 value = readl(ioaddr + DMA_BUS_MODE);

	int txpbl = dma_cfg->txpbl ?: dma_cfg->pbl;
@@ -119,12 +118,22 @@ static void dwmac1000_dma_init(void __iomem *ioaddr, 


	/* Mask interrupts by writing to CSR7 */

	writel(DMA_INTR_DEFAULT_MASK, ioaddr + DMA_INTR_ENA);

}



	/* RX/TX descriptor base address lists must be written into

	 * DMA CSR3 and CSR4, respectively

	 */

	writel(dma_tx, ioaddr + DMA_TX_BASE_ADDR);

	writel(dma_rx, ioaddr + DMA_RCV_BASE_ADDR);

static void dwmac1000_dma_init_rx(void __iomem *ioaddr,

				  struct stmmac_dma_cfg *dma_cfg,

				  u32 dma_rx_phy, u32 chan)

{

	/* RX descriptor base address list must be written into DMA CSR3 */

	writel(dma_rx_phy, ioaddr + DMA_RCV_BASE_ADDR);

}



static void dwmac1000_dma_init_tx(void __iomem *ioaddr,

				  struct stmmac_dma_cfg *dma_cfg,

				  u32 dma_tx_phy, u32 chan)

{

	/* TX descriptor base address list must be written into DMA CSR4 */

	writel(dma_tx_phy, ioaddr + DMA_TX_BASE_ADDR);

}



static u32 dwmac1000_configure_fc(u32 csr6, int rxfifosz)
@@ -148,12 +157,40 @@ static u32 dwmac1000_configure_fc(u32 csr6, int rxfifosz) 
	return csr6;

}



static void dwmac1000_dma_operation_mode(void __iomem *ioaddr, int txmode,

					 int rxmode, int rxfifosz)

static void dwmac1000_dma_operation_mode_rx(void __iomem *ioaddr, int mode,

					    u32 channel, int fifosz, u8 qmode)

{

	u32 csr6 = readl(ioaddr + DMA_CONTROL);



	if (txmode == SF_DMA_MODE) {

	if (mode == SF_DMA_MODE) {

		pr_debug("GMAC: enable RX store and forward mode\n");

		csr6 |= DMA_CONTROL_RSF;

	} else {

		pr_debug("GMAC: disable RX SF mode (threshold %d)\n", mode);

		csr6 &= ~DMA_CONTROL_RSF;

		csr6 &= DMA_CONTROL_TC_RX_MASK;

		if (mode <= 32)

			csr6 |= DMA_CONTROL_RTC_32;

		else if (mode <= 64)

			csr6 |= DMA_CONTROL_RTC_64;

		else if (mode <= 96)

			csr6 |= DMA_CONTROL_RTC_96;

		else

			csr6 |= DMA_CONTROL_RTC_128;

	}



	/* Configure flow control based on rx fifo size */

	csr6 = dwmac1000_configure_fc(csr6, fifosz);



	writel(csr6, ioaddr + DMA_CONTROL);

}



static void dwmac1000_dma_operation_mode_tx(void __iomem *ioaddr, int mode,

					    u32 channel, int fifosz, u8 qmode)

{

	u32 csr6 = readl(ioaddr + DMA_CONTROL);



	if (mode == SF_DMA_MODE) {

		pr_debug("GMAC: enable TX store and forward mode\n");

		/* Transmit COE type 2 cannot be done in cut-through mode. */

		csr6 |= DMA_CONTROL_TSF;
@@ -162,42 +199,22 @@ static void dwmac1000_dma_operation_mode(void __iomem *ioaddr, int txmode, 
		 */

		csr6 |= DMA_CONTROL_OSF;

	} else {

		pr_debug("GMAC: disabling TX SF (threshold %d)\n", txmode);

		pr_debug("GMAC: disabling TX SF (threshold %d)\n", mode);

		csr6 &= ~DMA_CONTROL_TSF;

		csr6 &= DMA_CONTROL_TC_TX_MASK;

		/* Set the transmit threshold */

		if (txmode <= 32)

		if (mode <= 32)

			csr6 |= DMA_CONTROL_TTC_32;

		else if (txmode <= 64)

		else if (mode <= 64)

			csr6 |= DMA_CONTROL_TTC_64;

		else if (txmode <= 128)

		else if (mode <= 128)

			csr6 |= DMA_CONTROL_TTC_128;

		else if (txmode <= 192)

		else if (mode <= 192)

			csr6 |= DMA_CONTROL_TTC_192;

		else

			csr6 |= DMA_CONTROL_TTC_256;

	}



	if (rxmode == SF_DMA_MODE) {

		pr_debug("GMAC: enable RX store and forward mode\n");

		csr6 |= DMA_CONTROL_RSF;

	} else {

		pr_debug("GMAC: disable RX SF mode (threshold %d)\n", rxmode);

		csr6 &= ~DMA_CONTROL_RSF;

		csr6 &= DMA_CONTROL_TC_RX_MASK;

		if (rxmode <= 32)

			csr6 |= DMA_CONTROL_RTC_32;

		else if (rxmode <= 64)

			csr6 |= DMA_CONTROL_RTC_64;

		else if (rxmode <= 96)

			csr6 |= DMA_CONTROL_RTC_96;

		else

			csr6 |= DMA_CONTROL_RTC_128;

	}



	/* Configure flow control based on rx fifo size */

	csr6 = dwmac1000_configure_fc(csr6, rxfifosz);



	writel(csr6, ioaddr + DMA_CONTROL);

}
@@ -256,9 +273,12 @@ static void dwmac1000_rx_watchdog(void __iomem *ioaddr, u32 riwt, 
const struct stmmac_dma_ops dwmac1000_dma_ops = {

	.reset = dwmac_dma_reset,

	.init = dwmac1000_dma_init,

	.init_rx_chan = dwmac1000_dma_init_rx,

	.init_tx_chan = dwmac1000_dma_init_tx,

	.axi = dwmac1000_dma_axi,

	.dump_regs = dwmac1000_dump_dma_regs,

	.dma_mode = dwmac1000_dma_operation_mode,

	.dma_rx_mode = dwmac1000_dma_operation_mode_rx,

	.dma_tx_mode = dwmac1000_dma_operation_mode_tx,

	.enable_dma_transmission = dwmac_enable_dma_transmission,

	.enable_dma_irq = dwmac_enable_dma_irq,

	.disable_dma_irq = dwmac_disable_dma_irq,

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

+23 −12
Original line number Diff line number Diff line
@@ -29,8 +29,7 @@ 
#include "dwmac_dma.h"



static void dwmac100_dma_init(void __iomem *ioaddr,

			      struct stmmac_dma_cfg *dma_cfg,

			      u32 dma_tx, u32 dma_rx, int atds)

			      struct stmmac_dma_cfg *dma_cfg, int atds)

{

	/* Enable Application Access by writing to DMA CSR0 */

	writel(DMA_BUS_MODE_DEFAULT | (dma_cfg->pbl << DMA_BUS_MODE_PBL_SHIFT),
@@ -38,12 +37,22 @@ static void dwmac100_dma_init(void __iomem *ioaddr, 


	/* Mask interrupts by writing to CSR7 */

	writel(DMA_INTR_DEFAULT_MASK, ioaddr + DMA_INTR_ENA);

}



	/* RX/TX descriptor base addr lists must be written into

	 * DMA CSR3 and CSR4, respectively

	 */

	writel(dma_tx, ioaddr + DMA_TX_BASE_ADDR);

	writel(dma_rx, ioaddr + DMA_RCV_BASE_ADDR);

static void dwmac100_dma_init_rx(void __iomem *ioaddr,

				 struct stmmac_dma_cfg *dma_cfg,

				 u32 dma_rx_phy, u32 chan)

{

	/* RX descriptor base addr lists must be written into DMA CSR3 */

	writel(dma_rx_phy, ioaddr + DMA_RCV_BASE_ADDR);

}



static void dwmac100_dma_init_tx(void __iomem *ioaddr,

				 struct stmmac_dma_cfg *dma_cfg,

				 u32 dma_tx_phy, u32 chan)

{

	/* TX descriptor base addr lists must be written into DMA CSR4 */

	writel(dma_tx_phy, ioaddr + DMA_TX_BASE_ADDR);

}



/* Store and Forward capability is not used at all.
@@ -51,14 +60,14 @@ static void dwmac100_dma_init(void __iomem *ioaddr, 
 * The transmit threshold can be programmed by setting the TTC bits in the DMA

 * control register.

 */

static void dwmac100_dma_operation_mode(void __iomem *ioaddr, int txmode,

					int rxmode, int rxfifosz)

static void dwmac100_dma_operation_mode_tx(void __iomem *ioaddr, int mode,

					   u32 channel, int fifosz, u8 qmode)

{

	u32 csr6 = readl(ioaddr + DMA_CONTROL);



	if (txmode <= 32)

	if (mode <= 32)

		csr6 |= DMA_CONTROL_TTC_32;

	else if (txmode <= 64)

	else if (mode <= 64)

		csr6 |= DMA_CONTROL_TTC_64;

	else

		csr6 |= DMA_CONTROL_TTC_128;
@@ -112,8 +121,10 @@ static void dwmac100_dma_diagnostic_fr(void *data, struct stmmac_extra_stats *x, 
const struct stmmac_dma_ops dwmac100_dma_ops = {

	.reset = dwmac_dma_reset,

	.init = dwmac100_dma_init,

	.init_rx_chan = dwmac100_dma_init_rx,

	.init_tx_chan = dwmac100_dma_init_tx,

	.dump_regs = dwmac100_dump_dma_regs,

	.dma_mode = dwmac100_dma_operation_mode,

	.dma_tx_mode = dwmac100_dma_operation_mode_tx,

	.dma_diagnostic_fr = dwmac100_dma_diagnostic_fr,

	.enable_dma_transmission = dwmac_enable_dma_transmission,

	.enable_dma_irq = dwmac_enable_dma_irq,

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

+28 −6
Original line number Diff line number Diff line
@@ -189,9 +189,12 @@ static void dwmac4_set_tx_owner(struct dma_desc *p) 
	p->des3 |= cpu_to_le32(TDES3_OWN);

}



static void dwmac4_set_rx_owner(struct dma_desc *p)

static void dwmac4_set_rx_owner(struct dma_desc *p, int disable_rx_ic)

{

	p->des3 |= cpu_to_le32(RDES3_OWN);

	p->des3 = cpu_to_le32(RDES3_OWN | RDES3_BUFFER1_VALID_ADDR);



	if (!disable_rx_ic)

		p->des3 |= cpu_to_le32(RDES3_INT_ON_COMPLETION_EN);

}



static int dwmac4_get_tx_ls(struct dma_desc *p)
@@ -292,10 +295,7 @@ static int dwmac4_wrback_get_rx_timestamp_status(void *desc, void *next_desc, 
static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic,

				   int mode, int end)

{

	p->des3 = cpu_to_le32(RDES3_OWN | RDES3_BUFFER1_VALID_ADDR);



	if (!disable_rx_ic)

		p->des3 |= cpu_to_le32(RDES3_INT_ON_COMPLETION_EN);

	dwmac4_set_rx_owner(p, disable_rx_ic);

}



static void dwmac4_rd_init_tx_desc(struct dma_desc *p, int mode, int end)
@@ -424,6 +424,25 @@ static void dwmac4_set_mss_ctxt(struct dma_desc *p, unsigned int mss) 
	p->des3 = cpu_to_le32(TDES3_CONTEXT_TYPE | TDES3_CTXT_TCMSSV);

}



static void dwmac4_get_addr(struct dma_desc *p, unsigned int *addr)

{

	*addr = le32_to_cpu(p->des0);

}



static void dwmac4_set_addr(struct dma_desc *p, dma_addr_t addr)

{

	p->des0 = cpu_to_le32(addr);

	p->des1 = 0;

}



static void dwmac4_clear(struct dma_desc *p)

{

	p->des0 = 0;

	p->des1 = 0;

	p->des2 = 0;

	p->des3 = 0;

}



const struct stmmac_desc_ops dwmac4_desc_ops = {

	.tx_status = dwmac4_wrback_get_tx_status,

	.rx_status = dwmac4_wrback_get_rx_status,
@@ -445,6 +464,9 @@ const struct stmmac_desc_ops dwmac4_desc_ops = { 
	.init_tx_desc = dwmac4_rd_init_tx_desc,

	.display_ring = dwmac4_display_ring,

	.set_mss = dwmac4_set_mss_ctxt,

	.get_addr = dwmac4_get_addr,

	.set_addr = dwmac4_set_addr,

	.clear = dwmac4_clear,

};



const struct stmmac_mode_ops dwmac4_ring_mode_ops = { };

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

+5 −2
Original line number Diff line number Diff line
@@ -94,6 +94,10 @@ static void dwmac4_dma_init_tx_chan(void __iomem *ioaddr, 


	value = readl(ioaddr + DMA_CHAN_TX_CONTROL(chan));

	value = value | (txpbl << DMA_BUS_MODE_PBL_SHIFT);



	/* Enable OSP to get best performance */

	value |= DMA_CONTROL_OSP;



	writel(value, ioaddr + DMA_CHAN_TX_CONTROL(chan));



	writel(dma_tx_phy, ioaddr + DMA_CHAN_TX_BASE_ADDR(chan));
@@ -116,8 +120,7 @@ static void dwmac4_dma_init_channel(void __iomem *ioaddr, 
}



static void dwmac4_dma_init(void __iomem *ioaddr,

			    struct stmmac_dma_cfg *dma_cfg,

			    u32 dma_tx, u32 dma_rx, int atds)

			    struct stmmac_dma_cfg *dma_cfg, int atds)

{

	u32 value = readl(ioaddr + DMA_SYS_BUS_MODE);