Skip to contentSkip to conversation

dma: ti: k3-udma: Add support for J721e

PATCH RESEND Superseded Vignesh Raghavendra 2 participants 13 messages Dec 2, 2019

Subsystems (5)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Vignesh Raghavendra

author maintainer
#0 lore raw

v2 cover dma: ti: k3-udma: Add support for J721e

This series adds DMA support for J721e using exist K3 UDMA driver.

One main change is thati, on J721e, DMA resources such as DMA channels are shared between different entities running on different cores of the SoC. Therefore, U-Boot running on A72 core should request range of resources allocated to it from centralized resource management core (DMSC) and use only the allocated resource.

First two patches adds support for dynamically querying and using allocated resources. Remaining patches fix issues when using UDMA driver on a 32 bit core like R5. Last patch adds a new compatible for J721e

Vignesh Raghavendra (10):
lib: Import few bitmap functions from Linux
dma: ti: k3-udma: Query DMA channels allocated from Resource Manager
soc: ti: k3-navss-ringacc: Flush/invalidate caches on ring push/pop
soc: ti: k3-navss-ringacc: Get SYSFW reference from DT phandle
dma: ti: k3-udma: Remove coherency check for cache ops
dma: ti: k3-udma: Fix debug prints during enabling MEM_TO_DEV
transfers
dma: ti: k3-udma: Switch to exposed ring mode
dma: ti: k3-udma: Fix ring push operation for 32 bit cores
dma: ti: k3-udma: Fix build warnings when building for 32 bit
platforms
dma: ti: k3-udma: Add new compatible to J721e

 drivers/dma/ti/k3-udma-hwdef.h    |  19 ++
 drivers/dma/ti/k3-udma.c          | 346 ++++++++++++++++++++----------
 drivers/soc/ti/k3-navss-ringacc.c |  13 +-
 include/linux/bitmap.h            | 133 ++++++++++++
 include/linux/bitops.h            |  12 ++
 5 files changed, 403 insertions(+), 120 deletions(-)
Signature · 1 line
2.24.0
author maintainer
#1 lore raw

PATCH RESEND v2 1/10 lib: Import few bitmap functions from Linux

Import few basic bitmap functions (bitmap_{weight,fill,set,clear,or}()) and their dependencies from Linux. These are required for upcoming DMA resource allocation support for TI's K3 SoCs.

---
 include/linux/bitmap.h | 133 +++++++++++++++++++++++++++++++++++++++++
 include/linux/bitops.h |  12 ++++
 2 files changed, 145 insertions(+)
include/linux/bitmap.h +133 -0
index fbbb67c8b24e..dae4225be549 100644
@@ -5,10 +5,88 @@
 #include <asm/types.h>
 #include <linux/types.h>
 #include <linux/bitops.h>
+#include <linux/string.h>
 
+#ifdef __LITTLE_ENDIAN
+#define BITMAP_MEM_ALIGNMENT 8
+#else
+#define BITMAP_MEM_ALIGNMENT (8 * sizeof(unsigned long))
+#endif
+#define BITMAP_MEM_MASK (BITMAP_MEM_ALIGNMENT - 1)
+
+#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
+#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
 #define small_const_nbits(nbits) \
 	(__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
 
+static inline void
+__bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
+	    const unsigned long *bitmap2, unsigned int bits)
+{
+	unsigned int k;
+	unsigned int nr = BITS_TO_LONGS(bits);
+
+	for (k = 0; k < nr; k++)
+		dst[k] = bitmap1[k] | bitmap2[k];
+}
+
+static inline int
+__bitmap_weight(const unsigned long *bitmap, unsigned int bits)
+{
+	unsigned int k, lim = bits / BITS_PER_LONG;
+	int w = 0;
+
+	for (k = 0; k < lim; k++)
+		w += hweight_long(bitmap[k]);
+
+	if (bits % BITS_PER_LONG)
+		w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
+
+	return w;
+}
+
+static inline void
+__bitmap_set(unsigned long *map, unsigned int start, int len)
+{
+	unsigned long *p = map + BIT_WORD(start);
+	const unsigned int size = start + len;
+	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
+	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
+
+	while (len - bits_to_set >= 0) {
+		*p |= mask_to_set;
+		len -= bits_to_set;
+		bits_to_set = BITS_PER_LONG;
+		mask_to_set = ~0UL;
+		p++;
+	}
+	if (len) {
+		mask_to_set &= BITMAP_LAST_WORD_MASK(size);
+		*p |= mask_to_set;
+	}
+}
+
+static inline void
+__bitmap_clear(unsigned long *map, unsigned int start, int len)
+{
+	unsigned long *p = map + BIT_WORD(start);
+	const unsigned int size = start + len;
+	int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
+	unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
+
+	while (len - bits_to_clear >= 0) {
+		*p &= ~mask_to_clear;
+		len -= bits_to_clear;
+		bits_to_clear = BITS_PER_LONG;
+		mask_to_clear = ~0UL;
+		p++;
+	}
+	if (len) {
+		mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
+		*p &= ~mask_to_clear;
+	}
+}
+
 static inline void bitmap_zero(unsigned long *dst, int nbits)
 {
 	if (small_const_nbits(nbits)) {
@@ -81,4 +159,59 @@ static inline unsigned long find_first_bit(const unsigned long *addr, unsigned l
 	     (bit) < (size);					\
 	     (bit) = find_next_bit((addr), (size), (bit) + 1))
 
+static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
+{
+	if (small_const_nbits(nbits)) {
+		*dst = ~0UL;
+	} else {
+		unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+
+		memset(dst, 0xff, len);
+	}
+}
+
+static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
+			     const unsigned long *src2, unsigned int nbits)
+{
+	if (small_const_nbits(nbits))
+		*dst = *src1 | *src2;
+	else
+		__bitmap_or(dst, src1, src2, nbits);
+}
+
+static inline int bitmap_weight(const unsigned long *src, unsigned int nbits)
+{
+	if (small_const_nbits(nbits))
+		return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
+	return __bitmap_weight(src, nbits);
+}
+
+static inline void bitmap_set(unsigned long *map, unsigned int start,
+			      unsigned int nbits)
+{
+	if (__builtin_constant_p(nbits) && nbits == 1)
+		__set_bit(start, map);
+	else if (__builtin_constant_p(start & BITMAP_MEM_MASK) &&
+		 IS_ALIGNED(start, BITMAP_MEM_ALIGNMENT) &&
+		 __builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
+		 IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
+		memset((char *)map + start / 8, 0xff, nbits / 8);
+	else
+		__bitmap_set(map, start, nbits);
+}
+
+static inline void bitmap_clear(unsigned long *map, unsigned int start,
+				unsigned int nbits)
+{
+	if (__builtin_constant_p(nbits) && nbits == 1)
+		__clear_bit(start, map);
+	else if (__builtin_constant_p(start & BITMAP_MEM_MASK) &&
+		 IS_ALIGNED(start, BITMAP_MEM_ALIGNMENT) &&
+		 __builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
+		 IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
+		memset((char *)map + start / 8, 0, nbits / 8);
+	else
+		__bitmap_clear(map, start, nbits);
+}
+
 #endif /* __LINUX_BITMAP_H */
include/linux/bitops.h +12 -0
index 259df43fb00f..a07c70fd4858 100644
@@ -4,6 +4,7 @@
 #include <asm/types.h>
 #include <asm-generic/bitsperlong.h>
 #include <linux/compiler.h>
+#include <linux/kernel.h>
 
 #ifdef	__KERNEL__
 #define BIT(nr)			(1UL << (nr))
@@ -133,6 +134,17 @@ static inline unsigned int generic_hweight8(unsigned int w)
 	return (res & 0x0F) + ((res >> 4) & 0x0F);
 }
 
+static inline unsigned long generic_hweight64(__u64 w)
+{
+	return generic_hweight32((unsigned int)(w >> 32)) +
+	       generic_hweight32((unsigned int)w);
+}
+
+static inline unsigned long hweight_long(unsigned long w)
+{
+	return sizeof(w) == 4 ? generic_hweight32(w) : generic_hweight64(w);
+}
+
 #include <asm/bitops.h>
 
 /* linux/include/asm-generic/bitops/non-atomic.h */
Signature · 1 line
2.24.0
author maintainer
#2 lore raw

PATCH RESEND v2 2/10 dma: ti: k3-udma: Query DMA channels allocated from Resource Manager

In reply to Vignesh Raghavendra

On K3 SoCs, DMA channels are shared across multiple entities, therefore U-Boot DMA driver needs to query resource range from centralised resource management controller i.e SystemFirmware and use DMA channels allocated for A72 host. Add support for the same.

---
v2:
Address comments on v1 from Grygorii
Squash patch 5 (of v1) into this patch

 drivers/dma/ti/k3-udma-hwdef.h |  19 +++
 drivers/dma/ti/k3-udma.c       | 274 +++++++++++++++++++++++----------
 2 files changed, 214 insertions(+), 79 deletions(-)
drivers/dma/ti/k3-udma-hwdef.h +19 -0
index c88399a815ea..228a44cb73cf 100644
@@ -181,4 +181,23 @@
 #define PDMA_STATIC_TR_Z(x)	\
 	(((x) << PDMA_STATIC_TR_Z_SHIFT) & PDMA_STATIC_TR_Z_MASK)
 
+enum udma_rm_range {
+	RM_RANGE_TCHAN = 0,
+	RM_RANGE_RCHAN,
+	RM_RANGE_RFLOW,
+	RM_RANGE_LAST,
+};
+
+struct udma_tisci_rm {
+	const struct ti_sci_handle *tisci;
+	const struct ti_sci_rm_udmap_ops *tisci_udmap_ops;
+	u32  tisci_dev_id;
+
+	/* tisci information for PSI-L thread pairing/unpairing */
+	const struct ti_sci_rm_psil_ops *tisci_psil_ops;
+	u32  tisci_navss_dev_id;
+
+	struct ti_sci_resource *rm_ranges[RM_RANGE_LAST];
+};
+
 #endif /* K3_NAVSS_UDMA_HWDEF_H_ */
drivers/dma/ti/k3-udma.c +195 -79

420 lines not on this page · raw message

Signature · 1 line
2.24.0
#3 lore raw

PATCH RESEND v2 2/10 dma: ti: k3-udma: Query DMA channels allocated from Resource Manager

Quoted 31 lines · Vignesh Raghavendra

On K3 SoCs, DMA channels are shared across multiple entities, therefore U-Boot DMA driver needs to query resource range from centralised resource management controller i.e SystemFirmware and use DMA channels allocated for A72 host. Add support for the same.

---
v2:
Address comments on v1 from Grygorii
Squash patch 5 (of v1) into this patch

  drivers/dma/ti/k3-udma-hwdef.h |  19 +++
  drivers/dma/ti/k3-udma.c       | 274 +++++++++++++++++++++++----------
  2 files changed, 214 insertions(+), 79 deletions(-)
drivers/dma/ti/k3-udma-hwdef.h +8 -0
index c88399a815ea..228a44cb73cf 100644
@@ -181,4 +181,23 @@
  #define PDMA_STATIC_TR_Z(x)	\
  	(((x) << PDMA_STATIC_TR_Z_SHIFT) & PDMA_STATIC_TR_Z_MASK)
 
+enum udma_rm_range {
+	RM_RANGE_TCHAN = 0,
+	RM_RANGE_RCHAN,
+	RM_RANGE_RFLOW,
+	RM_RANGE_LAST,
+};
+
+struct udma_tisci_rm {

drivers/dma/ti/k3-udma-hwdef.h line 201

Quoted 10 lines
drivers/dma/ti/k3-udma-hwdef.h +10 -0
+	const struct ti_sci_handle *tisci;
+	const struct ti_sci_rm_udmap_ops *tisci_udmap_ops;
+	u32  tisci_dev_id;
+
+	/* tisci information for PSI-L thread pairing/unpairing */
+	const struct ti_sci_rm_psil_ops *tisci_psil_ops;
+	u32  tisci_navss_dev_id;
+
+	struct ti_sci_resource *rm_ranges[RM_RANGE_LAST];
+};

I'd move it in k3-udma.c

Quoted 8 lines
drivers/dma/ti/k3-udma-hwdef.h +1 -0
+
  #endif /* K3_NAVSS_UDMA_HWDEF_H_ */
drivers/dma/ti/k3-udma.c +0 -0
index a5fc7809bc41..2f82ab0955a4 100644
@@ -11,12 +11,14 @@
  #include <malloc.h>

[...]

Signature · 2 lines
Best regards,
grygorii
author maintainer
#4 lore raw

PATCH RESEND v2 3/10 soc: ti: k3-navss-ringacc: Flush/invalidate caches on ring push/pop

In reply to Vignesh Raghavendra

Flush caches when pushing an element to ring and invalidate caches when popping an element from ring in Exposed Ring mode. Otherwise DMA transfers don't work properly in R5 SPL (with caches enabled) where the core is not in coherency domain.

---
 drivers/soc/ti/k3-navss-ringacc.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
drivers/soc/ti/k3-navss-ringacc.c +10 -0
index 64ebc0ba0030..08b476d21049 100644
@@ -807,6 +807,11 @@ static int k3_nav_ringacc_ring_push_mem(struct k3_nav_ring *ring, void *elem)
 
 	memcpy(elem_ptr, elem, (4 << ring->elm_size));
 
+	flush_dcache_range((unsigned long)ring->ring_mem_virt,
+			   ALIGN((unsigned long)ring->ring_mem_virt +
+				 ring->size * (4 << ring->elm_size),
+				 ARCH_DMA_MINALIGN));
+
 	ring->windex = (ring->windex + 1) % ring->size;
 	ring->free--;
 	ringacc_writel(1, &ring->rt->db);
@@ -823,6 +828,11 @@ static int k3_nav_ringacc_ring_pop_mem(struct k3_nav_ring *ring, void *elem)
 
 	elem_ptr = k3_nav_ringacc_get_elm_addr(ring, ring->rindex);
 
+	invalidate_dcache_range((unsigned long)ring->ring_mem_virt,
+				ALIGN((unsigned long)ring->ring_mem_virt +
+				      ring->size * (4 << ring->elm_size),
+				      ARCH_DMA_MINALIGN));
+
 	memcpy(elem, elem_ptr, (4 << ring->elm_size));
 
 	ring->rindex = (ring->rindex + 1) % ring->size;
Signature · 1 line
2.24.0
author maintainer
#5 lore raw

PATCH RESEND v2 4/10 soc: ti: k3-navss-ringacc: Get SYSFW reference from DT phandle

In reply to Vignesh Raghavendra

Instead of looking getting reference to SYSFW device using name which is not guaranteed to be constant, use phandle supplied in the DT node to get reference to SYSFW

---
 drivers/soc/ti/k3-navss-ringacc.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/soc/ti/k3-navss-ringacc.c +2 -1
index 08b476d21049..c71f6576bdf8 100644
@@ -941,7 +941,8 @@ static int k3_nav_ringacc_probe_dt(struct k3_nav_ringacc *ringacc)
 	ringacc->dma_ring_reset_quirk =
 			dev_read_bool(dev, "ti,dma-ring-reset-quirk");
 
-	ret = uclass_get_device_by_name(UCLASS_FIRMWARE, "dmsc", &tisci_dev);
+	ret = uclass_get_device_by_phandle(UCLASS_FIRMWARE, dev,
+					   "ti,sci", &tisci_dev);
 	if (ret) {
 		pr_debug("TISCI RA RM get failed (%d)\n", ret);
 		ringacc->tisci = NULL;
Signature · 1 line
2.24.0
author maintainer
#6 lore raw

PATCH RESEND v2 5/10 dma: ti: k3-udma: Remove coherency check for cache ops

In reply to Vignesh Raghavendra

Remove redundant coherency checks before calling cache ops in UDMA driver. This is now handled in arch specific cache operation implementation based on Kconfig option

---
 drivers/dma/ti/k3-udma.c | 49 +++++++++++++---------------------------
 1 file changed, 16 insertions(+), 33 deletions(-)
drivers/dma/ti/k3-udma.c +16 -33
index 2f82ab0955a4..ee4bc531cb50 100644
@@ -93,7 +93,6 @@ struct udma_dev {
 	u32 psil_base;
 
 	u32 ch_count;
-	bool is_coherent;
 };
 
 struct udma_chan {
@@ -274,11 +273,6 @@ static inline bool udma_is_chan_running(struct udma_chan *uc)
 	return false;
 }
 
-static int udma_is_coherent(struct udma_chan *uc)
-{
-	return uc->ud->is_coherent;
-}
-
 static int udma_pop_from_ring(struct udma_chan *uc, dma_addr_t *addr)
 {
 	struct k3_nav_ring *ring = NULL;
@@ -1305,7 +1299,6 @@ static int udma_probe(struct udevice *dev)
 		return ret;
 	}
 
-	ud->is_coherent = dev_read_bool(dev, "dma-coherent");
 	tisci_rm->tisci_udmap_ops = &tisci_rm->tisci->ops.rm_udmap_ops;
 	tisci_rm->tisci_psil_ops = &tisci_rm->tisci->ops.rm_psil_ops;
 
@@ -1453,11 +1446,9 @@ static int *udma_prep_dma_memcpy(struct udma_chan *uc, dma_addr_t dest,
 
 	cppi5_tr_csf_set(&tr_req[num_tr - 1].flags, CPPI5_TR_CSF_EOP);
 
-	if (!udma_is_coherent(uc)) {
-		flush_dcache_range((u64)tr_desc,
-				   ALIGN((u64)tr_desc + desc_size,
-					 ARCH_DMA_MINALIGN));
-	}
+	flush_dcache_range((u64)tr_desc,
+			   ALIGN((u64)tr_desc + desc_size,
+				 ARCH_DMA_MINALIGN));
 
 	k3_nav_ringacc_ring_push(uc->tchan->t_ring, &tr_desc);
 
@@ -1622,14 +1613,12 @@ static int udma_send(struct dma *dma, void *src, size_t len, void *metadata)
 	cppi5_hdesc_set_pkttype(desc_tx, packet_data.pkt_type);
 	cppi5_desc_set_tags_ids(&desc_tx->hdr, 0, packet_data.dest_tag);
 
-	if (!udma_is_coherent(uc)) {
-		flush_dcache_range((u64)dma_src,
-				   ALIGN((u64)dma_src + len,
-					 ARCH_DMA_MINALIGN));
-		flush_dcache_range((u64)desc_tx,
-				   ALIGN((u64)desc_tx + uc->hdesc_size,
-					 ARCH_DMA_MINALIGN));
-	}
+	flush_dcache_range((u64)dma_src,
+			   ALIGN((u64)dma_src + len,
+				 ARCH_DMA_MINALIGN));
+	flush_dcache_range((u64)desc_tx,
+			   ALIGN((u64)desc_tx + uc->hdesc_size,
+				 ARCH_DMA_MINALIGN));
 
 	ret = k3_nav_ringacc_ring_push(uc->tchan->t_ring, &uc->desc_tx);
 	if (ret) {
@@ -1673,19 +1662,15 @@ static int udma_receive(struct dma *dma, void **dst, void *metadata)
 	}
 
 	/* invalidate cache data */
-	if (!udma_is_coherent(uc)) {
-		invalidate_dcache_range((ulong)desc_rx,
-					(ulong)(desc_rx + uc->hdesc_size));
-	}
+	invalidate_dcache_range((ulong)desc_rx,
+				(ulong)(desc_rx + uc->hdesc_size));
 
 	cppi5_hdesc_get_obuf(desc_rx, &buf_dma, &buf_dma_len);
 	pkt_len = cppi5_hdesc_get_pktlen(desc_rx);
 
 	/* invalidate cache data */
-	if (!udma_is_coherent(uc)) {
-		invalidate_dcache_range((ulong)buf_dma,
-					(ulong)(buf_dma + buf_dma_len));
-	}
+	invalidate_dcache_range((ulong)buf_dma,
+				(ulong)(buf_dma + buf_dma_len));
 
 	cppi5_desc_get_tags_ids(&desc_rx->hdr, &port_id, NULL);
 
@@ -1790,11 +1775,9 @@ int udma_prepare_rcv_buf(struct dma *dma, void *dst, size_t size)
 	cppi5_hdesc_set_pktlen(desc_rx, size);
 	cppi5_hdesc_attach_buf(desc_rx, dma_dst, size, dma_dst, size);
 
-	if (!udma_is_coherent(uc)) {
-		flush_dcache_range((u64)desc_rx,
-				   ALIGN((u64)desc_rx + uc->hdesc_size,
-					 ARCH_DMA_MINALIGN));
-	}
+	flush_dcache_range((u64)desc_rx,
+			   ALIGN((u64)desc_rx + uc->hdesc_size,
+				 ARCH_DMA_MINALIGN));
 
 	k3_nav_ringacc_ring_push(uc->rchan->fd_ring, &desc_rx);
 
Signature · 1 line
2.24.0
author maintainer
#7 lore raw

PATCH RESEND v2 6/10 dma: ti: k3-udma: Fix debug prints during enabling MEM_TO_DEV transfers

In reply to Vignesh Raghavendra

Fix up the debug prints that were dumping state of TCHAN RT registers to use tchan for MEM_TO_DEV transfers.

---
 drivers/dma/ti/k3-udma.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/dma/ti/k3-udma.c +2 -2
index ee4bc531cb50..ed5c64522a8e 100644
@@ -427,9 +427,9 @@ static int udma_start(struct udma_chan *uc)
 
 		pr_debug("%s(tx): RT_CTL:0x%08x PEER RT_ENABLE:0x%08x\n",
 			 __func__,
-			 udma_rchanrt_read(uc->rchan,
+			 udma_tchanrt_read(uc->tchan,
 					   UDMA_TCHAN_RT_CTL_REG),
-			 udma_rchanrt_read(uc->rchan,
+			 udma_tchanrt_read(uc->tchan,
 					   UDMA_TCHAN_RT_PEER_RT_EN_REG));
 		break;
 	case DMA_MEM_TO_MEM:
Signature · 1 line
2.24.0
author maintainer
#8 lore raw

PATCH RESEND v2 7/10 dma: ti: k3-udma: Switch to exposed ring mode

In reply to Vignesh Raghavendra

Exposed ring mode works well with 32 bit and 64 bit cores without need for Proxies for 32 bit cores. Therefore switch to exposed ring mode.

---
 drivers/dma/ti/k3-udma.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/dma/ti/k3-udma.c +2 -2
index ed5c64522a8e..783195572763 100644
@@ -759,7 +759,7 @@ static int udma_alloc_tx_resources(struct udma_chan *uc)
 	memset(&ring_cfg, 0, sizeof(ring_cfg));
 	ring_cfg.size = 16;
 	ring_cfg.elm_size = K3_NAV_RINGACC_RING_ELSIZE_8;
-	ring_cfg.mode = K3_NAV_RINGACC_RING_MODE_MESSAGE;
+	ring_cfg.mode = K3_NAV_RINGACC_RING_MODE_RING;
 
 	ret = k3_nav_ringacc_ring_cfg(uc->tchan->t_ring, &ring_cfg);
 	ret |= k3_nav_ringacc_ring_cfg(uc->tchan->tc_ring, &ring_cfg);
@@ -836,7 +836,7 @@ static int udma_alloc_rx_resources(struct udma_chan *uc)
 	memset(&ring_cfg, 0, sizeof(ring_cfg));
 	ring_cfg.size = 16;
 	ring_cfg.elm_size = K3_NAV_RINGACC_RING_ELSIZE_8;
-	ring_cfg.mode = K3_NAV_RINGACC_RING_MODE_MESSAGE;
+	ring_cfg.mode = K3_NAV_RINGACC_RING_MODE_RING;
 
 	ret = k3_nav_ringacc_ring_cfg(uc->rchan->fd_ring, &ring_cfg);
 	ret |= k3_nav_ringacc_ring_cfg(uc->rchan->r_ring, &ring_cfg);
Signature · 1 line
2.24.0
author maintainer
#9 lore raw

PATCH RESEND v2 8/10 dma: ti: k3-udma: Fix ring push operation for 32 bit cores

In reply to Vignesh Raghavendra

UDMA always expects 64 bit address pointer of the transfer descriptor in the Ring. But on 32 bit cores like R5, pointer is always 32 bit in size. Therefore copy over 32 bit pointer value to 64 bit variable before pushing it over to the ring, so that upper 32 bits are 0s.

---
 drivers/dma/ti/k3-udma.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)
drivers/dma/ti/k3-udma.c +11 -3
index 783195572763..33b1d7880bed 100644
@@ -1359,6 +1359,14 @@ static int udma_probe(struct udevice *dev)
 	return ret;
 }
 
+static int udma_push_to_ring(struct k3_nav_ring *ring, void *elem)
+{
+	u64 addr = 0;
+
+	memcpy(&addr, &elem, sizeof(elem));
+	return k3_nav_ringacc_ring_push(ring, &addr);
+}
+
 static int *udma_prep_dma_memcpy(struct udma_chan *uc, dma_addr_t dest,
 				 dma_addr_t src, size_t len)
 {
@@ -1450,7 +1458,7 @@ static int *udma_prep_dma_memcpy(struct udma_chan *uc, dma_addr_t dest,
 			   ALIGN((u64)tr_desc + desc_size,
 				 ARCH_DMA_MINALIGN));
 
-	k3_nav_ringacc_ring_push(uc->tchan->t_ring, &tr_desc);
+	udma_push_to_ring(uc->tchan->t_ring, tr_desc);
 
 	return 0;
 }
@@ -1620,7 +1628,7 @@ static int udma_send(struct dma *dma, void *src, size_t len, void *metadata)
 			   ALIGN((u64)desc_tx + uc->hdesc_size,
 				 ARCH_DMA_MINALIGN));
 
-	ret = k3_nav_ringacc_ring_push(uc->tchan->t_ring, &uc->desc_tx);
+	ret = udma_push_to_ring(uc->tchan->t_ring, uc->desc_tx);
 	if (ret) {
 		dev_err(dma->dev, "TX dma push fail ch_id %lu %d\n",
 			dma->id, ret);
@@ -1779,7 +1787,7 @@ int udma_prepare_rcv_buf(struct dma *dma, void *dst, size_t size)
 			   ALIGN((u64)desc_rx + uc->hdesc_size,
 				 ARCH_DMA_MINALIGN));
 
-	k3_nav_ringacc_ring_push(uc->rchan->fd_ring, &desc_rx);
+	udma_push_to_ring(uc->rchan->fd_ring, desc_rx);
 
 	uc->num_rx_bufs++;
 	uc->desc_rx_cur++;
Signature · 1 line
2.24.0
author maintainer
#10 lore raw

PATCH RESEND v2 9/10 dma: ti: k3-udma: Fix build warnings when building for 32 bit platforms

In reply to Vignesh Raghavendra

Cast pointers properly so as to avoid warnings when driver is built for 32 bit platforms

---
 drivers/dma/ti/k3-udma.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)
drivers/dma/ti/k3-udma.c +8 -8
index 33b1d7880bed..03c48c9d1ee2 100644
@@ -1454,8 +1454,8 @@ static int *udma_prep_dma_memcpy(struct udma_chan *uc, dma_addr_t dest,
 
 	cppi5_tr_csf_set(&tr_req[num_tr - 1].flags, CPPI5_TR_CSF_EOP);
 
-	flush_dcache_range((u64)tr_desc,
-			   ALIGN((u64)tr_desc + desc_size,
+	flush_dcache_range((unsigned long)tr_desc,
+			   ALIGN((unsigned long)tr_desc + desc_size,
 				 ARCH_DMA_MINALIGN));
 
 	udma_push_to_ring(uc->tchan->t_ring, tr_desc);
@@ -1621,11 +1621,11 @@ static int udma_send(struct dma *dma, void *src, size_t len, void *metadata)
 	cppi5_hdesc_set_pkttype(desc_tx, packet_data.pkt_type);
 	cppi5_desc_set_tags_ids(&desc_tx->hdr, 0, packet_data.dest_tag);
 
-	flush_dcache_range((u64)dma_src,
-			   ALIGN((u64)dma_src + len,
+	flush_dcache_range((unsigned long)dma_src,
+			   ALIGN((unsigned long)dma_src + len,
 				 ARCH_DMA_MINALIGN));
-	flush_dcache_range((u64)desc_tx,
-			   ALIGN((u64)desc_tx + uc->hdesc_size,
+	flush_dcache_range((unsigned long)desc_tx,
+			   ALIGN((unsigned long)desc_tx + uc->hdesc_size,
 				 ARCH_DMA_MINALIGN));
 
 	ret = udma_push_to_ring(uc->tchan->t_ring, uc->desc_tx);
@@ -1783,8 +1783,8 @@ int udma_prepare_rcv_buf(struct dma *dma, void *dst, size_t size)
 	cppi5_hdesc_set_pktlen(desc_rx, size);
 	cppi5_hdesc_attach_buf(desc_rx, dma_dst, size, dma_dst, size);
 
-	flush_dcache_range((u64)desc_rx,
-			   ALIGN((u64)desc_rx + uc->hdesc_size,
+	flush_dcache_range((unsigned long)desc_rx,
+			   ALIGN((unsigned long)desc_rx + uc->hdesc_size,
 				 ARCH_DMA_MINALIGN));
 
 	udma_push_to_ring(uc->rchan->fd_ring, desc_rx);
Signature · 1 line
2.24.0
author maintainer
#11 lore raw

PATCH RESEND v2 10/10 dma: ti: k3-udma: Add new compatible to J721e

In reply to Vignesh Raghavendra

Add new compatible to handle UDMA support for J721e SoC

---
 drivers/dma/ti/k3-udma.c | 1 +
 1 file changed, 1 insertion(+)
drivers/dma/ti/k3-udma.c +1 -0
index 03c48c9d1ee2..def3c5c38c66 100644
@@ -1809,6 +1809,7 @@ static const struct dma_ops udma_ops = {
 
 static const struct udevice_id udma_ids[] = {
 	{ .compatible = "ti,k3-navss-udmap" },
+	{ .compatible = "ti,j721e-navss-main-udmap" },
 	{ }
 };
 
Signature · 1 line
2.24.0
#12 lore raw

v2 cover dma: ti: k3-udma: Add support for J721e

In reply to Vignesh Raghavendra
Quoted 26 lines · Vignesh Raghavendra

This series adds DMA support for J721e using exist K3 UDMA driver.

One main change is thati, on J721e, DMA resources such as DMA channels are shared between different entities running on different cores of the SoC. Therefore, U-Boot running on A72 core should request range of resources allocated to it from centralized resource management core (DMSC) and use only the allocated resource.

First two patches adds support for dynamically querying and using allocated resources. Remaining patches fix issues when using UDMA driver on a 32 bit core like R5. Last patch adds a new compatible for J721e

Vignesh Raghavendra (10):
lib: Import few bitmap functions from Linux
dma: ti: k3-udma: Query DMA channels allocated from Resource Manager
soc: ti: k3-navss-ringacc: Flush/invalidate caches on ring push/pop
soc: ti: k3-navss-ringacc: Get SYSFW reference from DT phandle
dma: ti: k3-udma: Remove coherency check for cache ops
dma: ti: k3-udma: Fix debug prints during enabling MEM_TO_DEV
transfers
dma: ti: k3-udma: Switch to exposed ring mode
dma: ti: k3-udma: Fix ring push operation for 32 bit cores
dma: ti: k3-udma: Fix build warnings when building for 32 bit
platforms
dma: ti: k3-udma: Add new compatible to J721e

Quoted 7 lines
  drivers/dma/ti/k3-udma-hwdef.h    |  19 ++
  drivers/dma/ti/k3-udma.c          | 346 ++++++++++++++++++++----------
  drivers/soc/ti/k3-navss-ringacc.c |  13 +-
  include/linux/bitmap.h            | 133 ++++++++++++
  include/linux/bitops.h            |  12 ++
  5 files changed, 403 insertions(+), 120 deletions(-)

minor comment to patch 2.
Otherwise:

Signature · 2 lines
Best regards,
grygorii