[PATCH 0/2] net: macb: fix dma usage

[PATCH 0/2] net: macb: fix dma usage

[Steffen Trumtrar]

The rx_buffer is only dma_alloc'ed but never properly flushed.
Fix that.

While at it, also use proper volatile access instead of sw barriers.

Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
---
Steffen Trumtrar (2):
      net: macb: fix dma_alloc for rx_buffer
      net: macb: convert to volatile accesses

 drivers/net/macb.c | 90 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 50 insertions(+), 40 deletions(-)
---
base-commit: 5f200dd534c848dfa5d948334b6373f0310b8f73
change-id: 20231128-v2023-08-0-topic-macb-0c13ed91179d

Best regards,
-- 
Steffen Trumtrar <s.trumtrar@pengutronix.de>

[PATCH 1/2] net: macb: fix dma_alloc for rx_buffer

[Steffen Trumtrar]

rx_buffer gets dma_alloc'ed but is never dma_map'ed and therefor not
flushed before it is initially used.

Map the rx_buffer when the macb is initialized and unmap it on ether_halt.

While at it, cleanup the dma_alloc_coherent rx_ring/tx_ring, too.

Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
---
 drivers/net/macb.c | 37 ++++++++++++++++++++++++++++---------
 1 file changed, 28 insertions(+), 9 deletions(-)

diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index 260c1e806a..92f78f7253 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -63,10 +63,13 @@ struct macb_device {
 	unsigned int		tx_head;
 
 	void			*rx_buffer;
+	dma_addr_t		rx_buffer_phys;
 	void			*tx_buffer;
 	void			*rx_packet_buf;
 	struct macb_dma_desc	*rx_ring;
+	dma_addr_t		rx_ring_phys;
 	struct macb_dma_desc	*tx_ring;
+	dma_addr_t		tx_ring_phys;
 	struct macb_dma_desc	*gem_q1_descs;
 
 	int			rx_buffer_size;
@@ -181,7 +184,7 @@ static int gem_recv(struct eth_device *edev)
 		barrier();
 		status = macb->rx_ring[macb->rx_tail].ctrl;
 		length = MACB_BFEXT(RX_FRMLEN, status);
-		buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
+		buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
 		dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer, length,
 					DMA_FROM_DEVICE);
 		net_receive(edev, buffer, length);
@@ -221,7 +224,7 @@ static int macb_recv(struct eth_device *edev)
 		}
 
 		if (status & MACB_BIT(RX_EOF)) {
-			buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
+			buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
 			length = MACB_BFEXT(RX_FRMLEN, status);
 			if (wrapped) {
 				unsigned int headlen, taillen;
@@ -232,12 +235,12 @@ static int macb_recv(struct eth_device *edev)
 				dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer,
 							headlen, DMA_FROM_DEVICE);
 				memcpy(macb->rx_packet_buf, buffer, headlen);
-				dma_sync_single_for_cpu(macb->dev, (unsigned long)macb->rx_buffer,
+				dma_sync_single_for_cpu(macb->dev, (unsigned long)macb->rx_buffer_phys,
 							taillen, DMA_FROM_DEVICE);
 				memcpy(macb->rx_packet_buf + headlen, macb->rx_buffer, taillen);
 				dma_sync_single_for_device(macb->dev, (unsigned long)buffer,
 							headlen, DMA_FROM_DEVICE);
-				dma_sync_single_for_device(macb->dev, (unsigned long)macb->rx_buffer,
+				dma_sync_single_for_device(macb->dev, (unsigned long)macb->rx_buffer_phys,
 							taillen, DMA_FROM_DEVICE);
 				net_receive(edev, macb->rx_packet_buf, length);
 			} else {
@@ -377,7 +380,7 @@ static int gmac_init_dummy_tx_queues(struct macb_device *macb)
 	return 0;
 }
 
-static void macb_init(struct macb_device *macb)
+static int macb_init(struct macb_device *macb)
 {
 	unsigned long paddr, val = 0;
 	int i;
@@ -386,6 +389,11 @@ static void macb_init(struct macb_device *macb)
 	 * macb_halt should have been called at some point before now,
 	 * so we'll assume the controller is idle.
 	 */
+	macb->rx_buffer_phys = dma_map_single(macb->dev, macb->rx_buffer,
+					      macb->rx_buffer_size * macb->rx_ring_size,
+					      DMA_TO_DEVICE);
+	if (dma_mapping_error(macb->dev, macb->rx_buffer_phys))
+		return -EFAULT;
 
 	/* initialize DMA descriptors */
 	paddr = (ulong)macb->rx_buffer;
@@ -442,6 +450,7 @@ static void macb_init(struct macb_device *macb)
 
 	macb_or_gem_writel(macb, USRIO, val);
 
+	return 0;
 }
 
 static void macb_halt(struct eth_device *edev)
@@ -460,6 +469,13 @@ static void macb_halt(struct eth_device *edev)
 
 	/* Disable TX and RX, and clear statistics */
 	macb_writel(macb, NCR, MACB_BIT(CLRSTAT));
+
+	dma_unmap_single(macb->dev, macb->rx_buffer_phys,
+			 macb->rx_buffer_size * macb->rx_ring_size,
+			 DMA_TO_DEVICE);
+	free(macb->rx_buffer);
+	dma_free_coherent((void *)macb->rx_ring, macb->rx_ring_phys, RX_RING_BYTES(macb));
+	dma_free_coherent((void *)macb->tx_ring, macb->tx_ring_phys, TX_RING_BYTES);
 }
 
 static int macb_phy_read(struct mii_bus *bus, int addr, int reg)
@@ -780,6 +796,7 @@ static int macb_probe(struct device *dev)
 	const char *pclk_name, *hclk_name;
 	const struct macb_config *config = NULL;
 	u32 ncfgr;
+	int ret;
 
 	macb = xzalloc(sizeof(*macb));
 	edev = &macb->netdev;
@@ -877,7 +894,7 @@ static int macb_probe(struct device *dev)
 		clk_enable(macb->rxclk);
 
 	if (config) {
-		int ret = config->txclk_init(dev, &macb->txclk);
+		ret = config->txclk_init(dev, &macb->txclk);
 		if (ret)
 			return ret;
 	}
@@ -891,8 +908,8 @@ static int macb_probe(struct device *dev)
 
 	macb_init_rx_buffer_size(macb, PKTSIZE);
 	macb->rx_buffer = dma_alloc(macb->rx_buffer_size * macb->rx_ring_size);
-	macb->rx_ring = dma_alloc_coherent(RX_RING_BYTES(macb), DMA_ADDRESS_BROKEN);
-	macb->tx_ring = dma_alloc_coherent(TX_RING_BYTES, DMA_ADDRESS_BROKEN);
+	macb->rx_ring = dma_alloc_coherent(RX_RING_BYTES(macb), &macb->rx_ring_phys);
+	macb->tx_ring = dma_alloc_coherent(TX_RING_BYTES, &macb->tx_ring_phys);
 
 	if (macb->is_gem)
 		macb->gem_q1_descs = dma_alloc_coherent(GEM_Q1_DESC_BYTES,
@@ -907,7 +924,9 @@ static int macb_probe(struct device *dev)
 	ncfgr |= macb_dbw(macb);
 	macb_writel(macb, NCFGR, ncfgr);
 
-	macb_init(macb);
+	ret = macb_init(macb);
+	if (ret)
+		return ret;
 
 	mdiobus_register(&macb->miibus);
 	eth_register(edev);

-- 
2.40.1

[PATCH 2/2] net: macb: convert to volatile accesses

[Steffen Trumtrar]

Instead of directly reading from memory addresses and inserting
sw barriers to be sure that the compiler will not move loads/stores
behind this point, just use proper volatile writel/readl accesses.

Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
---
 drivers/net/macb.c | 53 ++++++++++++++++++++++-------------------------------
 1 file changed, 22 insertions(+), 31 deletions(-)

diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index 92f78f7253..c9a7e395d6 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -119,17 +119,15 @@ static int macb_send(struct eth_device *edev, void *packet,
 		macb->tx_head++;
 	}
 
-	macb->tx_ring[tx_head].ctrl = ctrl;
-	macb->tx_ring[tx_head].addr = (ulong)packet;
-	barrier();
+	writel(ctrl, &macb->tx_ring[tx_head].ctrl);
+	writel((ulong)packet, &macb->tx_ring[tx_head].addr);
 	dma_sync_single_for_device(macb->dev, (unsigned long)packet, length, DMA_TO_DEVICE);
 	macb_writel(macb, NCR, MACB_BIT(TE) | MACB_BIT(RE) | MACB_BIT(TSTART));
 
 	start = get_time_ns();
 	ret = -ETIMEDOUT;
 	do {
-		barrier();
-		ctrl = macb->tx_ring[0].ctrl;
+		ctrl = readl(&macb->tx_ring[0].ctrl);
 		if (ctrl & MACB_BIT(TX_USED)) {
 			ret = 0;
 			break;
@@ -154,18 +152,17 @@ static void reclaim_rx_buffers(struct macb_device *macb,
 
 	i = macb->rx_tail;
 	while (i > new_tail) {
-		macb->rx_ring[i].addr &= ~MACB_BIT(RX_USED);
+		clrbits_le32(&macb->rx_ring[i].addr, MACB_BIT(RX_USED));
 		i++;
 		if (i > macb->rx_ring_size)
 			i = 0;
 	}
 
 	while (i < new_tail) {
-		macb->rx_ring[i].addr &= ~MACB_BIT(RX_USED);
+		clrbits_le32(&macb->rx_ring[i].addr, MACB_BIT(RX_USED));
 		i++;
 	}
 
-	barrier();
 	macb->rx_tail = new_tail;
 }
 
@@ -177,12 +174,10 @@ static int gem_recv(struct eth_device *edev)
 	u32 status;
 
 	for (;;) {
-		barrier();
-		if (!(macb->rx_ring[macb->rx_tail].addr & MACB_BIT(RX_USED)))
+		if (!(readl(&macb->rx_ring[macb->rx_tail].addr) & MACB_BIT(RX_USED)))
 			return -1;
 
-		barrier();
-		status = macb->rx_ring[macb->rx_tail].ctrl;
+		status = readl(&macb->rx_ring[macb->rx_tail].ctrl);
 		length = MACB_BFEXT(RX_FRMLEN, status);
 		buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
 		dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer, length,
@@ -190,8 +185,7 @@ static int gem_recv(struct eth_device *edev)
 		net_receive(edev, buffer, length);
 		dma_sync_single_for_device(macb->dev, (unsigned long)buffer, length,
 					   DMA_FROM_DEVICE);
-		macb->rx_ring[macb->rx_tail].addr &= ~MACB_BIT(RX_USED);
-		barrier();
+		clrbits_le32(&macb->rx_ring[macb->rx_tail].addr, MACB_BIT(RX_USED));
 
 		macb->rx_tail++;
 		if (macb->rx_tail >= macb->rx_ring_size)
@@ -211,12 +205,10 @@ static int macb_recv(struct eth_device *edev)
 	u32 status;
 
 	for (;;) {
-		barrier();
-		if (!(macb->rx_ring[rx_tail].addr & MACB_BIT(RX_USED)))
+		if (!(readl(&macb->rx_ring[rx_tail].addr) & MACB_BIT(RX_USED)))
 			return -1;
 
-		barrier();
-		status = macb->rx_ring[rx_tail].ctrl;
+		status = readl(&macb->rx_ring[rx_tail].ctrl);
 		if (status & MACB_BIT(RX_SOF)) {
 			if (rx_tail != macb->rx_tail)
 				reclaim_rx_buffers(macb, rx_tail);
@@ -250,7 +242,6 @@ static int macb_recv(struct eth_device *edev)
 				dma_sync_single_for_device(macb->dev, (unsigned long)buffer, length,
 							DMA_FROM_DEVICE);
 			}
-			barrier();
 			if (++rx_tail >= macb->rx_ring_size)
 				rx_tail = 0;
 			reclaim_rx_buffers(macb, rx_tail);
@@ -370,9 +361,9 @@ static int gmac_init_dummy_tx_queues(struct macb_device *macb)
 		if (queue_mask & (1 << i))
 			num_queues++;
 
-	macb->gem_q1_descs[0].addr = 0;
-	macb->gem_q1_descs[0].ctrl = MACB_BIT(TX_WRAP) |
-		MACB_BIT(TX_LAST) | MACB_BIT(TX_USED);
+	writel(0, &macb->gem_q1_descs[0].addr);
+	setbits_le32(&macb->gem_q1_descs[0].ctrl,
+		     MACB_BIT(TX_WRAP) | MACB_BIT(TX_LAST) | MACB_BIT(TX_USED));
 
 	for (i = 1; i < num_queues; i++)
 		gem_writel_queue_TBQP(macb, (ulong)macb->gem_q1_descs, i - 1);
@@ -398,17 +389,17 @@ static int macb_init(struct macb_device *macb)
 	/* initialize DMA descriptors */
 	paddr = (ulong)macb->rx_buffer;
 	for (i = 0; i < macb->rx_ring_size; i++) {
-		macb->rx_ring[i].addr = paddr;
-		macb->rx_ring[i].ctrl = 0;
+		writel(paddr, &macb->rx_ring[i].addr);
+		writel(0, &macb->rx_ring[i].ctrl);
 		paddr += macb->rx_buffer_size;
 	}
-	macb->rx_ring[macb->rx_ring_size - 1].addr |= MACB_BIT(RX_WRAP);
+	setbits_le32(&macb->rx_ring[macb->rx_ring_size - 1].addr, MACB_BIT(RX_WRAP));
 
 	for (i = 0; i < TX_RING_SIZE; i++) {
-		macb->tx_ring[i].addr = 0;
-		macb->tx_ring[i].ctrl = MACB_BIT(TX_USED);
+		writel(0, &macb->tx_ring[i].addr);
+		writel(MACB_BIT(TX_USED), &macb->tx_ring[i].ctrl);
 	}
-	macb->tx_ring[TX_RING_SIZE - 1].addr |= MACB_BIT(TX_WRAP);
+	writel(MACB_BIT(TX_WRAP), &macb->tx_ring[TX_RING_SIZE - 1].addr);
 
 	macb->rx_tail = macb->tx_head = 0;
 
@@ -421,9 +412,9 @@ static int macb_init(struct macb_device *macb)
 		gmac_init_dummy_tx_queues(macb);
 
 		/* Disable the second priority rx queue */
-		macb->gem_q1_descs[1].addr = MACB_BIT(RX_USED) |
-				MACB_BIT(RX_WRAP);
-		macb->gem_q1_descs[1].ctrl = 0;
+		setbits_le32(&macb->gem_q1_descs[1].addr,
+			     MACB_BIT(RX_USED) | MACB_BIT(RX_WRAP));
+		writel(0, &macb->gem_q1_descs[1].ctrl);
 
 		gem_writel(macb, RQ1, (ulong)&macb->gem_q1_descs[1]);
 	}

-- 
2.40.1

Re: [PATCH 1/2] net: macb: fix dma_alloc for rx_buffer

[Lucas Stach]

Am Dienstag, dem 28.11.2023 um 17:29 +0100 schrieb Steffen Trumtrar:
> rx_buffer gets dma_alloc'ed but is never dma_map'ed and therefor not
> flushed before it is initially used.
> 
> Map the rx_buffer when the macb is initialized and unmap it on ether_halt.
> 
> While at it, cleanup the dma_alloc_coherent rx_ring/tx_ring, too.
> 
> Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
> ---
>  drivers/net/macb.c | 37 ++++++++++++++++++++++++++++---------
>  1 file changed, 28 insertions(+), 9 deletions(-)
> 
> diff --git a/drivers/net/macb.c b/drivers/net/macb.c
> index 260c1e806a..92f78f7253 100644
> --- a/drivers/net/macb.c
> +++ b/drivers/net/macb.c
> @@ -63,10 +63,13 @@ struct macb_device {
>  	unsigned int		tx_head;
>  
>  	void			*rx_buffer;
> +	dma_addr_t		rx_buffer_phys;
>  	void			*tx_buffer;
>  	void			*rx_packet_buf;
>  	struct macb_dma_desc	*rx_ring;
> +	dma_addr_t		rx_ring_phys;
>  	struct macb_dma_desc	*tx_ring;
> +	dma_addr_t		tx_ring_phys;
>  	struct macb_dma_desc	*gem_q1_descs;
>  
>  	int			rx_buffer_size;
> @@ -181,7 +184,7 @@ static int gem_recv(struct eth_device *edev)
>  		barrier();
>  		status = macb->rx_ring[macb->rx_tail].ctrl;
>  		length = MACB_BFEXT(RX_FRMLEN, status);
> -		buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
> +		buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
>  		dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer, length,
>  					DMA_FROM_DEVICE);
>  		net_receive(edev, buffer, length);
> @@ -221,7 +224,7 @@ static int macb_recv(struct eth_device *edev)
>  		}
>  
>  		if (status & MACB_BIT(RX_EOF)) {
> -			buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
> +			buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
>  			length = MACB_BFEXT(RX_FRMLEN, status);
>  			if (wrapped) {
>  				unsigned int headlen, taillen;
> @@ -232,12 +235,12 @@ static int macb_recv(struct eth_device *edev)
>  				dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer,
>  							headlen, DMA_FROM_DEVICE);
>  				memcpy(macb->rx_packet_buf, buffer, headlen);
> -				dma_sync_single_for_cpu(macb->dev, (unsigned long)macb->rx_buffer,
> +				dma_sync_single_for_cpu(macb->dev, (unsigned long)macb->rx_buffer_phys,

You can drop all those (unsigned long) casts in calls to
dma_sync_single, now that you are passing a argument of the proper
dma_addr_t type.

>  							taillen, DMA_FROM_DEVICE);
>  				memcpy(macb->rx_packet_buf + headlen, macb->rx_buffer, taillen);
>  				dma_sync_single_for_device(macb->dev, (unsigned long)buffer,
>  							headlen, DMA_FROM_DEVICE);
> -				dma_sync_single_for_device(macb->dev, (unsigned long)macb->rx_buffer,
> +				dma_sync_single_for_device(macb->dev, (unsigned long)macb->rx_buffer_phys,
>  							taillen, DMA_FROM_DEVICE);
>  				net_receive(edev, macb->rx_packet_buf, length);
>  			} else {
> @@ -377,7 +380,7 @@ static int gmac_init_dummy_tx_queues(struct macb_device *macb)
>  	return 0;
>  }
>  
> -static void macb_init(struct macb_device *macb)
> +static int macb_init(struct macb_device *macb)
>  {
>  	unsigned long paddr, val = 0;
>  	int i;
> @@ -386,6 +389,11 @@ static void macb_init(struct macb_device *macb)
>  	 * macb_halt should have been called at some point before now,
>  	 * so we'll assume the controller is idle.
>  	 */
> +	macb->rx_buffer_phys = dma_map_single(macb->dev, macb->rx_buffer,
> +					      macb->rx_buffer_size * macb->rx_ring_size,
> +					      DMA_TO_DEVICE);

The RX buffer is used to hold data written by the device, so it must be
mapped with DMA_FROM_DEVICE.

Regards,
Lucas

> +	if (dma_mapping_error(macb->dev, macb->rx_buffer_phys))
> +		return -EFAULT;
>  
>  	/* initialize DMA descriptors */
>  	paddr = (ulong)macb->rx_buffer;
> @@ -442,6 +450,7 @@ static void macb_init(struct macb_device *macb)
>  
>  	macb_or_gem_writel(macb, USRIO, val);
>  
> +	return 0;
>  }
>  
>  static void macb_halt(struct eth_device *edev)
> @@ -460,6 +469,13 @@ static void macb_halt(struct eth_device *edev)
>  
>  	/* Disable TX and RX, and clear statistics */
>  	macb_writel(macb, NCR, MACB_BIT(CLRSTAT));
> +
> +	dma_unmap_single(macb->dev, macb->rx_buffer_phys,
> +			 macb->rx_buffer_size * macb->rx_ring_size,
> +			 DMA_TO_DEVICE);
> +	free(macb->rx_buffer);
> +	dma_free_coherent((void *)macb->rx_ring, macb->rx_ring_phys, RX_RING_BYTES(macb));
> +	dma_free_coherent((void *)macb->tx_ring, macb->tx_ring_phys, TX_RING_BYTES);
>  }
>  
>  static int macb_phy_read(struct mii_bus *bus, int addr, int reg)
> @@ -780,6 +796,7 @@ static int macb_probe(struct device *dev)
>  	const char *pclk_name, *hclk_name;
>  	const struct macb_config *config = NULL;
>  	u32 ncfgr;
> +	int ret;
>  
>  	macb = xzalloc(sizeof(*macb));
>  	edev = &macb->netdev;
> @@ -877,7 +894,7 @@ static int macb_probe(struct device *dev)
>  		clk_enable(macb->rxclk);
>  
>  	if (config) {
> -		int ret = config->txclk_init(dev, &macb->txclk);
> +		ret = config->txclk_init(dev, &macb->txclk);
>  		if (ret)
>  			return ret;
>  	}
> @@ -891,8 +908,8 @@ static int macb_probe(struct device *dev)
>  
>  	macb_init_rx_buffer_size(macb, PKTSIZE);
>  	macb->rx_buffer = dma_alloc(macb->rx_buffer_size * macb->rx_ring_size);
> -	macb->rx_ring = dma_alloc_coherent(RX_RING_BYTES(macb), DMA_ADDRESS_BROKEN);
> -	macb->tx_ring = dma_alloc_coherent(TX_RING_BYTES, DMA_ADDRESS_BROKEN);
> +	macb->rx_ring = dma_alloc_coherent(RX_RING_BYTES(macb), &macb->rx_ring_phys);
> +	macb->tx_ring = dma_alloc_coherent(TX_RING_BYTES, &macb->tx_ring_phys);
>  
>  	if (macb->is_gem)
>  		macb->gem_q1_descs = dma_alloc_coherent(GEM_Q1_DESC_BYTES,
> @@ -907,7 +924,9 @@ static int macb_probe(struct device *dev)
>  	ncfgr |= macb_dbw(macb);
>  	macb_writel(macb, NCFGR, ncfgr);
>  
> -	macb_init(macb);
> +	ret = macb_init(macb);
> +	if (ret)
> +		return ret;
>  
>  	mdiobus_register(&macb->miibus);
>  	eth_register(edev);
> 

Re: [PATCH 1/2] net: macb: fix dma_alloc for rx_buffer

[Ahmad Fatoum]

Hello Steffen,

On 28.11.23 17:29, Steffen Trumtrar wrote:
> rx_buffer gets dma_alloc'ed but is never dma_map'ed and therefor not
> flushed before it is initially used.
> 
> Map the rx_buffer when the macb is initialized and unmap it on ether_halt.
> 
> While at it, cleanup the dma_alloc_coherent rx_ring/tx_ring, too.
> 
> Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
> ---
>  drivers/net/macb.c | 37 ++++++++++++++++++++++++++++---------
>  1 file changed, 28 insertions(+), 9 deletions(-)
> 
> diff --git a/drivers/net/macb.c b/drivers/net/macb.c
> index 260c1e806a..92f78f7253 100644
> --- a/drivers/net/macb.c
> +++ b/drivers/net/macb.c
> @@ -63,10 +63,13 @@ struct macb_device {
>  	unsigned int		tx_head;
>  
>  	void			*rx_buffer;
> +	dma_addr_t		rx_buffer_phys;
>  	void			*tx_buffer;
>  	void			*rx_packet_buf;
>  	struct macb_dma_desc	*rx_ring;
> +	dma_addr_t		rx_ring_phys;
>  	struct macb_dma_desc	*tx_ring;
> +	dma_addr_t		tx_ring_phys;
>  	struct macb_dma_desc	*gem_q1_descs;
>  
>  	int			rx_buffer_size;
> @@ -181,7 +184,7 @@ static int gem_recv(struct eth_device *edev)
>  		barrier();
>  		status = macb->rx_ring[macb->rx_tail].ctrl;
>  		length = MACB_BFEXT(RX_FRMLEN, status);
> -		buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
> +		buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;

For GEM-type NICs, rx_buffer_size is PKTSIZE (1518 bytes currently), which is not a multiple
of the cache line size of the 64 bytes cache line on the ZynqMP's Cortex-A53 the driver
is supposed to support.

>  		dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer, length,
>  					DMA_FROM_DEVICE);

This means this could potentially invalidate adjacent buffer contents.


>  	}
> @@ -891,8 +908,8 @@ static int macb_probe(struct device *dev)
>  
>  	macb_init_rx_buffer_size(macb, PKTSIZE);

^ Here's where PKTSIZE comes from. I'd be in favor of changing the global PKTSIZE
definition to be a multiple of 64 bytes (or use DMA_ALIGNMENT, but this isn't
correctly set for ARM yet.  I just sent out a patch for that).

Cheers,
Ahmad

-- 
Pengutronix e.K.                           |                             |
Steuerwalder Str. 21                       | http://www.pengutronix.de/  |
31137 Hildesheim, Germany                  | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |

Re: [PATCH 2/2] net: macb: convert to volatile accesses

[Ahmad Fatoum]

Hello Steffen,

On 28.11.23 17:29, Steffen Trumtrar wrote:
> +	writel(ctrl, &macb->tx_ring[tx_head].ctrl);
> +	writel((ulong)packet, &macb->tx_ring[tx_head].addr);
>  	dma_sync_single_for_device(macb->dev, (unsigned long)packet, length, DMA_TO_DEVICE);

For this buffer dma_map_single is missing. I just sent out a series to implement
CONFIG_DMA_API_DEBUG by the way that should catch this (as well as the original
issue in the Rx path).

> -	macb->gem_q1_descs[0].addr = 0;
> -	macb->gem_q1_descs[0].ctrl = MACB_BIT(TX_WRAP) |
> -		MACB_BIT(TX_LAST) | MACB_BIT(TX_USED);
> +	writel(0, &macb->gem_q1_descs[0].addr);
> +	setbits_le32(&macb->gem_q1_descs[0].ctrl,
> +		     MACB_BIT(TX_WRAP) | MACB_BIT(TX_LAST) | MACB_BIT(TX_USED));

Should be writel to maintain previous semantics.

> -	macb->tx_ring[TX_RING_SIZE - 1].addr |= MACB_BIT(TX_WRAP);
> +	writel(MACB_BIT(TX_WRAP), &macb->tx_ring[TX_RING_SIZE - 1].addr);

Should be a setbits_le32 to maintain previous semantics.

>  		/* Disable the second priority rx queue */
> -		macb->gem_q1_descs[1].addr = MACB_BIT(RX_USED) |
> -				MACB_BIT(RX_WRAP);
> -		macb->gem_q1_descs[1].ctrl = 0;
> +		setbits_le32(&macb->gem_q1_descs[1].addr,
> +			     MACB_BIT(RX_USED) | MACB_BIT(RX_WRAP));

Should be a writel to maintain previous semantics.

> +		writel(0, &macb->gem_q1_descs[1].ctrl);
>  
>  		gem_writel(macb, RQ1, (ulong)&macb->gem_q1_descs[1]);
>  	}
> 

Cheers,
Ahmad

-- 
Pengutronix e.K.                           |                             |
Steuerwalder Str. 21                       | http://www.pengutronix.de/  |
31137 Hildesheim, Germany                  | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |

Re: [PATCH 1/2] net: macb: fix dma_alloc for rx_buffer

[Steffen Trumtrar]

On 2023-11-28 at 17:56 +01, Lucas Stach <l.stach@pengutronix.de> wrote:

> Am Dienstag, dem 28.11.2023 um 17:29 +0100 schrieb Steffen Trumtrar:
>> rx_buffer gets dma_alloc'ed but is never dma_map'ed and therefor not
>> flushed before it is initially used.
>>
>> Map the rx_buffer when the macb is initialized and unmap it on ether_halt.
>>
>> While at it, cleanup the dma_alloc_coherent rx_ring/tx_ring, too.
>>
>> Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
>> ---
>>  drivers/net/macb.c | 37 ++++++++++++++++++++++++++++---------
>>  1 file changed, 28 insertions(+), 9 deletions(-)
>>
>> diff --git a/drivers/net/macb.c b/drivers/net/macb.c
>> index 260c1e806a..92f78f7253 100644
>> --- a/drivers/net/macb.c
>> +++ b/drivers/net/macb.c
>> @@ -63,10 +63,13 @@ struct macb_device {
>>  	unsigned int		tx_head;
>>
>>  	void			*rx_buffer;
>> +	dma_addr_t		rx_buffer_phys;
>>  	void			*tx_buffer;
>>  	void			*rx_packet_buf;
>>  	struct macb_dma_desc	*rx_ring;
>> +	dma_addr_t		rx_ring_phys;
>>  	struct macb_dma_desc	*tx_ring;
>> +	dma_addr_t		tx_ring_phys;
>>  	struct macb_dma_desc	*gem_q1_descs;
>>
>>  	int			rx_buffer_size;
>> @@ -181,7 +184,7 @@ static int gem_recv(struct eth_device *edev)
>>  		barrier();
>>  		status = macb->rx_ring[macb->rx_tail].ctrl;
>>  		length = MACB_BFEXT(RX_FRMLEN, status);
>> -		buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
>> +		buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
>>  		dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer, length,
>>  					DMA_FROM_DEVICE);
>>  		net_receive(edev, buffer, length);
>> @@ -221,7 +224,7 @@ static int macb_recv(struct eth_device *edev)
>>  		}
>>
>>  		if (status & MACB_BIT(RX_EOF)) {
>> -			buffer = macb->rx_buffer + macb->rx_buffer_size * macb->rx_tail;
>> +			buffer = (void *)macb->rx_buffer_phys + macb->rx_buffer_size * macb->rx_tail;
>>  			length = MACB_BFEXT(RX_FRMLEN, status);
>>  			if (wrapped) {
>>  				unsigned int headlen, taillen;
>> @@ -232,12 +235,12 @@ static int macb_recv(struct eth_device *edev)
>>  				dma_sync_single_for_cpu(macb->dev, (unsigned long)buffer,
>>  							headlen, DMA_FROM_DEVICE);
>>  				memcpy(macb->rx_packet_buf, buffer, headlen);
>> -				dma_sync_single_for_cpu(macb->dev, (unsigned long)macb->rx_buffer,
>> +				dma_sync_single_for_cpu(macb->dev, (unsigned long)macb->rx_buffer_phys,
>
> You can drop all those (unsigned long) casts in calls to
> dma_sync_single, now that you are passing a argument of the proper
> dma_addr_t type.
>

Thanks, will drop.

>>  							taillen, DMA_FROM_DEVICE);
>>  				memcpy(macb->rx_packet_buf + headlen, macb->rx_buffer, taillen);
>>  				dma_sync_single_for_device(macb->dev, (unsigned long)buffer,
>>  							headlen, DMA_FROM_DEVICE);
>> -				dma_sync_single_for_device(macb->dev, (unsigned long)macb->rx_buffer,
>> +				dma_sync_single_for_device(macb->dev, (unsigned long)macb->rx_buffer_phys,
>>  							taillen, DMA_FROM_DEVICE);
>>  				net_receive(edev, macb->rx_packet_buf, length);
>>  			} else {
>> @@ -377,7 +380,7 @@ static int gmac_init_dummy_tx_queues(struct macb_device *macb)
>>  	return 0;
>>  }
>>
>> -static void macb_init(struct macb_device *macb)
>> +static int macb_init(struct macb_device *macb)
>>  {
>>  	unsigned long paddr, val = 0;
>>  	int i;
>> @@ -386,6 +389,11 @@ static void macb_init(struct macb_device *macb)
>>  	 * macb_halt should have been called at some point before now,
>>  	 * so we'll assume the controller is idle.
>>  	 */
>> +	macb->rx_buffer_phys = dma_map_single(macb->dev, macb->rx_buffer,
>> +					      macb->rx_buffer_size * macb->rx_ring_size,
>> +					      DMA_TO_DEVICE);
>
> The RX buffer is used to hold data written by the device, so it must be
> mapped with DMA_FROM_DEVICE.
>

Argh, of course :(


Thanks,
Steffen

--
Pengutronix e.K.                | Dipl.-Inform. Steffen Trumtrar |
Steuerwalder Str. 21            | https://www.pengutronix.de/    |
31137 Hildesheim, Germany       | Phone: +49-5121-206917-0       |
Amtsgericht Hildesheim, HRA 2686| Fax:   +49-5121-206917-5555    |