xtensa build failures in -next due to DMA API changes

xtensa build failures in -next due to DMA API changes

[Guenter Roeck]

Hi,

xtensa builds fail in -next (again) as follows.

In file included from include/linux/dma-mapping.h:86:0,
                 from include/asm-generic/pci-dma-compat.h:7,
		 from ./arch/xtensa/include/asm/pci.h:59,
		from include/linux/pci.h:1492,
		from arch/xtensa/kernel/platform.c:16:
./arch/xtensa/include/asm/dma-mapping.h:40:21:
	error: redefinition of ‘dma_alloc_attrs’

In file included from ./arch/xtensa/include/asm/dma-mapping.h:33:0,
                 from include/linux/dma-mapping.h:86,
		 from include/asm-generic/pci-dma-compat.h:7,
		from ./arch/xtensa/include/asm/pci.h:59,
		from include/linux/pci.h:1492,
		from arch/xtensa/kernel/platform.c:16:
include/asm-generic/dma-mapping-common.h:245:21:
	note: previous definition of ‘dma_alloc_attrs’ was here

and many similar errors; it looks like all dma attribute functions have been
redefined.

The problem seems to have been introduced with changes made by Christoph
Hellwig, coming in through Andrew's tree. Copying them here for comments.

Guenter

Re: xtensa build failures in -next due to DMA API changes

[Christoph Hellwig]

Hi Guenter,

> The problem seems to have been introduced with changes made by Christoph
> Hellwig, coming in through Andrew's tree. Copying them here for comments.

xtensa doesn't use the generic dma map implementation, so it shouldn't
include dma-mapping-common.h anywhere, and in my tree it doesn't.

Can you do a git-grep for dma-mapping-common.h on the tree that you
see this error on?  Nothing but arch/*/include/asm/dma-mapping.h should
include it.  In my tree it's all fine:

Documentation/DMA-API-HOWTO.txt:   can use include/linux/asm-generic/dma-mapping-common.h. It's a
arch/alpha/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/arm/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/arm64/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/h8300/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/hexagon/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/ia64/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/microblaze/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/mips/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/openrisc/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/powerpc/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/s390/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/sh/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/sparc/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/tile/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/unicore32/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
arch/x86/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>

Re: xtensa build failures in -next due to DMA API changes

[Guenter Roeck]

Hi Christoph,

On Tue, Aug 25, 2015 at 10:15:32PM +0200, Christoph Hellwig wrote:
> Hi Guenter,
> 
> > The problem seems to have been introduced with changes made by Christoph
> > Hellwig, coming in through Andrew's tree. Copying them here for comments.
> 
> xtensa doesn't use the generic dma map implementation, so it shouldn't
> include dma-mapping-common.h anywhere, and in my tree it doesn't.
> 
> Can you do a git-grep for dma-mapping-common.h on the tree that you
> see this error on?  Nothing but arch/*/include/asm/dma-mapping.h should
> include it.  In my tree it's all fine:
> 
I also see

arch/xtensa/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>

It looks like there is a conflict with "xtensa: reimplement DMA API using common
helpers" by Max Filippov, which added the include. This patch is in -next.

Guenter

Re: xtensa build failures in -next due to DMA API changes

[Andrew Morton]

On Tue, 25 Aug 2015 22:15:32 +0200 Christoph Hellwig <hch@lst.de> wrote:

> > The problem seems to have been introduced with changes made by Christoph
> > Hellwig, coming in through Andrew's tree. Copying them here for comments.
> 
> xtensa doesn't use the generic dma map implementation, so it shouldn't
> include dma-mapping-common.h anywhere, and in my tree it doesn't.
> 
> Can you do a git-grep for dma-mapping-common.h on the tree that you
> see this error on?  Nothing but arch/*/include/asm/dma-mapping.h should
> include it.

This patch is in linux-next:


commit c75959a6da19df2700556dc76861442e9716317d
Author:     Max Filippov <jcmvbkbc@gmail.com>
AuthorDate: Mon May 25 06:55:05 2015 +0300
Commit:     Max Filippov <jcmvbkbc@gmail.com>
CommitDate: Mon Aug 17 07:31:00 2015 +0300

    xtensa: reimplement DMA API using common helpers
    
    - keep existing functionality: don't handle attributes, don't support
      high memory;
    - implement scatterlist primitives (map/unmap/sync);
    - enable DMA API debug.
    
    Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>

diff --git a/arch/xtensa/Kconfig b/arch/xtensa/Kconfig
index e5b872b..6ce10f9 100644
--- a/arch/xtensa/Kconfig
+++ b/arch/xtensa/Kconfig
@@ -14,6 +14,8 @@ config XTENSA
 	select GENERIC_IRQ_SHOW
 	select GENERIC_PCI_IOMAP
 	select GENERIC_SCHED_CLOCK
+	select HAVE_DMA_API_DEBUG
+	select HAVE_DMA_ATTRS
 	select HAVE_FUNCTION_TRACER
 	select HAVE_IRQ_TIME_ACCOUNTING
 	select HAVE_OPROFILE
diff --git a/arch/xtensa/include/asm/Kbuild b/arch/xtensa/include/asm/Kbuild
index 14d15bf..d870a59 100644
--- a/arch/xtensa/include/asm/Kbuild
+++ b/arch/xtensa/include/asm/Kbuild
@@ -2,7 +2,6 @@ generic-y += bitsperlong.h
 generic-y += bug.h
 generic-y += clkdev.h
 generic-y += cputime.h
-generic-y += device.h
 generic-y += div64.h
 generic-y += emergency-restart.h
 generic-y += errno.h
diff --git a/arch/xtensa/include/asm/device.h b/arch/xtensa/include/asm/device.h
new file mode 100644
index 0000000..fe1f5c8
--- /dev/null
+++ b/arch/xtensa/include/asm/device.h
@@ -0,0 +1,19 @@
+/*
+ * Arch specific extensions to struct device
+ *
+ * This file is released under the GPLv2
+ */
+#ifndef _ASM_XTENSA_DEVICE_H
+#define _ASM_XTENSA_DEVICE_H
+
+struct dma_map_ops;
+
+struct dev_archdata {
+	/* DMA operations on that device */
+	struct dma_map_ops *dma_ops;
+};
+
+struct pdev_archdata {
+};
+
+#endif /* _ASM_XTENSA_DEVICE_H */
diff --git a/arch/xtensa/include/asm/dma-mapping.h b/arch/xtensa/include/asm/dma-mapping.h
index 1f5f6dc..f01cb30 100644
--- a/arch/xtensa/include/asm/dma-mapping.h
+++ b/arch/xtensa/include/asm/dma-mapping.h
@@ -1,11 +1,10 @@
 /*
- * include/asm-xtensa/dma-mapping.h
- *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
  * Copyright (C) 2003 - 2005 Tensilica Inc.
+ * Copyright (C) 2015 Cadence Design Systems Inc.
  */
 
 #ifndef _XTENSA_DMA_MAPPING_H
@@ -13,142 +12,67 @@
 
 #include <asm/cache.h>
 #include <asm/io.h>
+
+#include <asm-generic/dma-coherent.h>
+
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
 
 #define DMA_ERROR_CODE		(~(dma_addr_t)0x0)
 
-/*
- * DMA-consistent mapping functions.
- */
-
-extern void *consistent_alloc(int, size_t, dma_addr_t, unsigned long);
-extern void consistent_free(void*, size_t, dma_addr_t);
-extern void consistent_sync(void*, size_t, int);
-
-#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
-#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
-
-void *dma_alloc_coherent(struct device *dev, size_t size,
-			   dma_addr_t *dma_handle, gfp_t flag);
+extern struct dma_map_ops xtensa_dma_map_ops;
 
-void dma_free_coherent(struct device *dev, size_t size,
-			 void *vaddr, dma_addr_t dma_handle);
-
-static inline dma_addr_t
-dma_map_single(struct device *dev, void *ptr, size_t size,
-	       enum dma_data_direction direction)
-{
-	BUG_ON(direction == DMA_NONE);
-	consistent_sync(ptr, size, direction);
-	return virt_to_phys(ptr);
-}
-
-static inline void
-dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
-		 enum dma_data_direction direction)
+static inline struct dma_map_ops *get_dma_ops(struct device *dev)
 {
-	BUG_ON(direction == DMA_NONE);
+	if (dev && dev->archdata.dma_ops)
+		return dev->archdata.dma_ops;
+	else
+		return &xtensa_dma_map_ops;
 }
 
-static inline int
-dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
-	   enum dma_data_direction direction)
-{
-	int i;
-	struct scatterlist *sg;
-
-	BUG_ON(direction == DMA_NONE);
-
-	for_each_sg(sglist, sg, nents, i) {
-		BUG_ON(!sg_page(sg));
+#include <asm-generic/dma-mapping-common.h>
 
-		sg->dma_address = sg_phys(sg);
-		consistent_sync(sg_virt(sg), sg->length, direction);
-	}
+#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
+#define dma_free_noncoherent(d, s, v, h) dma_free_attrs(d, s, v, h, NULL)
+#define dma_alloc_coherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
+#define dma_free_coherent(d, s, c, h) dma_free_attrs(d, s, c, h, NULL)
 
-	return nents;
-}
-
-static inline dma_addr_t
-dma_map_page(struct device *dev, struct page *page, unsigned long offset,
-	     size_t size, enum dma_data_direction direction)
-{
-	BUG_ON(direction == DMA_NONE);
-	return (dma_addr_t)(page_to_pfn(page)) * PAGE_SIZE + offset;
-}
-
-static inline void
-dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
-	       enum dma_data_direction direction)
+static inline void *dma_alloc_attrs(struct device *dev, size_t size,
+				    dma_addr_t *dma_handle, gfp_t gfp,
+				    struct dma_attrs *attrs)
 {
-	BUG_ON(direction == DMA_NONE);
-}
+	void *ret;
+	struct dma_map_ops *ops = get_dma_ops(dev);
 
+	if (dma_alloc_from_coherent(dev, size, dma_handle, &ret))
+		return ret;
 
-static inline void
-dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
-	     enum dma_data_direction direction)
-{
-	BUG_ON(direction == DMA_NONE);
-}
-
-static inline void
-dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
-		enum dma_data_direction direction)
-{
-	consistent_sync((void *)bus_to_virt(dma_handle), size, direction);
-}
+	ret = ops->alloc(dev, size, dma_handle, gfp, attrs);
+	debug_dma_alloc_coherent(dev, size, *dma_handle, ret);
 
-static inline void
-dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
-		           size_t size, enum dma_data_direction direction)
-{
-	consistent_sync((void *)bus_to_virt(dma_handle), size, direction);
+	return ret;
 }
 
-static inline void
-dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
-		      unsigned long offset, size_t size,
-		      enum dma_data_direction direction)
-{
-
-	consistent_sync((void *)bus_to_virt(dma_handle)+offset,size,direction);
-}
-
-static inline void
-dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
-		      unsigned long offset, size_t size,
-		      enum dma_data_direction direction)
+static inline void dma_free_attrs(struct device *dev, size_t size,
+				  void *vaddr, dma_addr_t dma_handle,
+				  struct dma_attrs *attrs)
 {
+	struct dma_map_ops *ops = get_dma_ops(dev);
 
-	consistent_sync((void *)bus_to_virt(dma_handle)+offset,size,direction);
-}
-static inline void
-dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nelems,
-		 enum dma_data_direction dir)
-{
-	int i;
-	struct scatterlist *sg;
+	if (dma_release_from_coherent(dev, get_order(size), vaddr))
+		return;
 
-	for_each_sg(sglist, sg, nelems, i)
-		consistent_sync(sg_virt(sg), sg->length, dir);
+	ops->free(dev, size, vaddr, dma_handle, attrs);
+	debug_dma_free_coherent(dev, size, vaddr, dma_handle);
 }
 
-static inline void
-dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist,
-		       int nelems, enum dma_data_direction dir)
-{
-	int i;
-	struct scatterlist *sg;
-
-	for_each_sg(sglist, sg, nelems, i)
-		consistent_sync(sg_virt(sg), sg->length, dir);
-}
 static inline int
 dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
 {
-	return 0;
+	struct dma_map_ops *ops = get_dma_ops(dev);
+
+	debug_dma_mapping_error(dev, dma_addr);
+	return ops->mapping_error(dev, dma_addr);
 }
 
 static inline int
@@ -168,39 +92,7 @@ dma_set_mask(struct device *dev, u64 mask)
 	return 0;
 }
 
-static inline void
-dma_cache_sync(struct device *dev, void *vaddr, size_t size,
-	       enum dma_data_direction direction)
-{
-	consistent_sync(vaddr, size, direction);
-}
-
-/* Not supported for now */
-static inline int dma_mmap_coherent(struct device *dev,
-				    struct vm_area_struct *vma, void *cpu_addr,
-				    dma_addr_t dma_addr, size_t size)
-{
-	return -EINVAL;
-}
-
-static inline int dma_get_sgtable(struct device *dev, struct sg_table *sgt,
-				  void *cpu_addr, dma_addr_t dma_addr,
-				  size_t size)
-{
-	return -EINVAL;
-}
-
-static inline void *dma_alloc_attrs(struct device *dev, size_t size,
-				    dma_addr_t *dma_handle, gfp_t flag,
-				    struct dma_attrs *attrs)
-{
-	return NULL;
-}
-
-static inline void dma_free_attrs(struct device *dev, size_t size,
-				  void *vaddr, dma_addr_t dma_handle,
-				  struct dma_attrs *attrs)
-{
-}
+void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
+		    enum dma_data_direction direction);
 
 #endif	/* _XTENSA_DMA_MAPPING_H */
diff --git a/arch/xtensa/kernel/pci-dma.c b/arch/xtensa/kernel/pci-dma.c
index e8b76b8..fb75ebf 100644
--- a/arch/xtensa/kernel/pci-dma.c
+++ b/arch/xtensa/kernel/pci-dma.c
@@ -1,6 +1,4 @@
 /*
- * arch/xtensa/kernel/pci-dma.c
- *
  * DMA coherent memory allocation.
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -9,6 +7,7 @@
  * option) any later version.
  *
  * Copyright (C) 2002 - 2005 Tensilica Inc.
+ * Copyright (C) 2015 Cadence Design Systems Inc.
  *
  * Based on version for i386.
  *
@@ -25,13 +24,107 @@
 #include <asm/io.h>
 #include <asm/cacheflush.h>
 
+void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
+		    enum dma_data_direction dir)
+{
+	switch (dir) {
+	case DMA_BIDIRECTIONAL:
+		__flush_invalidate_dcache_range((unsigned long)vaddr, size);
+		break;
+
+	case DMA_FROM_DEVICE:
+		__invalidate_dcache_range((unsigned long)vaddr, size);
+		break;
+
+	case DMA_TO_DEVICE:
+		__flush_dcache_range((unsigned long)vaddr, size);
+		break;
+
+	case DMA_NONE:
+		BUG();
+		break;
+	}
+}
+EXPORT_SYMBOL(dma_cache_sync);
+
+static void xtensa_sync_single_for_cpu(struct device *dev,
+				       dma_addr_t dma_handle, size_t size,
+				       enum dma_data_direction dir)
+{
+	void *vaddr;
+
+	switch (dir) {
+	case DMA_BIDIRECTIONAL:
+	case DMA_FROM_DEVICE:
+		vaddr = bus_to_virt(dma_handle);
+		__invalidate_dcache_range((unsigned long)vaddr, size);
+		break;
+
+	case DMA_NONE:
+		BUG();
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void xtensa_sync_single_for_device(struct device *dev,
+					  dma_addr_t dma_handle, size_t size,
+					  enum dma_data_direction dir)
+{
+	void *vaddr;
+
+	switch (dir) {
+	case DMA_BIDIRECTIONAL:
+	case DMA_TO_DEVICE:
+		vaddr = bus_to_virt(dma_handle);
+		__flush_dcache_range((unsigned long)vaddr, size);
+		break;
+
+	case DMA_NONE:
+		BUG();
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void xtensa_sync_sg_for_cpu(struct device *dev,
+				   struct scatterlist *sg, int nents,
+				   enum dma_data_direction dir)
+{
+	struct scatterlist *s;
+	int i;
+
+	for_each_sg(sg, s, nents, i) {
+		xtensa_sync_single_for_cpu(dev, sg_dma_address(s),
+					   sg_dma_len(s), dir);
+	}
+}
+
+static void xtensa_sync_sg_for_device(struct device *dev,
+				      struct scatterlist *sg, int nents,
+				      enum dma_data_direction dir)
+{
+	struct scatterlist *s;
+	int i;
+
+	for_each_sg(sg, s, nents, i) {
+		xtensa_sync_single_for_device(dev, sg_dma_address(s),
+					      sg_dma_len(s), dir);
+	}
+}
+
 /*
  * Note: We assume that the full memory space is always mapped to 'kseg'
  *	 Otherwise we have to use page attributes (not implemented).
  */
 
-void *
-dma_alloc_coherent(struct device *dev,size_t size,dma_addr_t *handle,gfp_t flag)
+static void *xtensa_dma_alloc(struct device *dev, size_t size,
+			      dma_addr_t *handle, gfp_t flag,
+			      struct dma_attrs *attrs)
 {
 	unsigned long ret;
 	unsigned long uncached = 0;
@@ -52,20 +145,15 @@ dma_alloc_coherent(struct device *dev,size_t size,dma_addr_t *handle,gfp_t flag)
 	BUG_ON(ret < XCHAL_KSEG_CACHED_VADDR ||
 	       ret > XCHAL_KSEG_CACHED_VADDR + XCHAL_KSEG_SIZE - 1);
 
+	uncached = ret + XCHAL_KSEG_BYPASS_VADDR - XCHAL_KSEG_CACHED_VADDR;
+	*handle = virt_to_bus((void *)ret);
+	__invalidate_dcache_range(ret, size);
 
-	if (ret != 0) {
-		memset((void*) ret, 0, size);
-		uncached = ret+XCHAL_KSEG_BYPASS_VADDR-XCHAL_KSEG_CACHED_VADDR;
-		*handle = virt_to_bus((void*)ret);
-		__flush_invalidate_dcache_range(ret, size);
-	}
-
-	return (void*)uncached;
+	return (void *)uncached;
 }
-EXPORT_SYMBOL(dma_alloc_coherent);
 
-void dma_free_coherent(struct device *hwdev, size_t size,
-			 void *vaddr, dma_addr_t dma_handle)
+static void xtensa_dma_free(struct device *hwdev, size_t size, void *vaddr,
+			    dma_addr_t dma_handle, struct dma_attrs *attrs)
 {
 	unsigned long addr = (unsigned long)vaddr +
 		XCHAL_KSEG_CACHED_VADDR - XCHAL_KSEG_BYPASS_VADDR;
@@ -75,24 +163,79 @@ void dma_free_coherent(struct device *hwdev, size_t size,
 
 	free_pages(addr, get_order(size));
 }
-EXPORT_SYMBOL(dma_free_coherent);
 
+static dma_addr_t xtensa_map_page(struct device *dev, struct page *page,
+				  unsigned long offset, size_t size,
+				  enum dma_data_direction dir,
+				  struct dma_attrs *attrs)
+{
+	dma_addr_t dma_handle = page_to_phys(page) + offset;
+
+	BUG_ON(PageHighMem(page));
+	xtensa_sync_single_for_device(dev, dma_handle, size, dir);
+	return dma_handle;
+}
 
-void consistent_sync(void *vaddr, size_t size, int direction)
+static void xtensa_unmap_page(struct device *dev, dma_addr_t dma_handle,
+			      size_t size, enum dma_data_direction dir,
+			      struct dma_attrs *attrs)
 {
-	switch (direction) {
-	case PCI_DMA_NONE:
-		BUG();
-	case PCI_DMA_FROMDEVICE:        /* invalidate only */
-		__invalidate_dcache_range((unsigned long)vaddr,
-				          (unsigned long)size);
-		break;
+	xtensa_sync_single_for_cpu(dev, dma_handle, size, dir);
+}
 
-	case PCI_DMA_TODEVICE:          /* writeback only */
-	case PCI_DMA_BIDIRECTIONAL:     /* writeback and invalidate */
-		__flush_invalidate_dcache_range((unsigned long)vaddr,
-				    		(unsigned long)size);
-		break;
+static int xtensa_map_sg(struct device *dev, struct scatterlist *sg,
+			 int nents, enum dma_data_direction dir,
+			 struct dma_attrs *attrs)
+{
+	struct scatterlist *s;
+	int i;
+
+	for_each_sg(sg, s, nents, i) {
+		s->dma_address = xtensa_map_page(dev, sg_page(s), s->offset,
+						 s->length, dir, attrs);
+	}
+	return nents;
+}
+
+static void xtensa_unmap_sg(struct device *dev,
+			    struct scatterlist *sg, int nents,
+			    enum dma_data_direction dir,
+			    struct dma_attrs *attrs)
+{
+	struct scatterlist *s;
+	int i;
+
+	for_each_sg(sg, s, nents, i) {
+		xtensa_unmap_page(dev, sg_dma_address(s),
+				  sg_dma_len(s), dir, attrs);
 	}
 }
-EXPORT_SYMBOL(consistent_sync);
+
+int xtensa_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
+{
+	return 0;
+}
+
+struct dma_map_ops xtensa_dma_map_ops = {
+	.alloc = xtensa_dma_alloc,
+	.free = xtensa_dma_free,
+	.map_page = xtensa_map_page,
+	.unmap_page = xtensa_unmap_page,
+	.map_sg = xtensa_map_sg,
+	.unmap_sg = xtensa_unmap_sg,
+	.sync_single_for_cpu = xtensa_sync_single_for_cpu,
+	.sync_single_for_device = xtensa_sync_single_for_device,
+	.sync_sg_for_cpu = xtensa_sync_sg_for_cpu,
+	.sync_sg_for_device = xtensa_sync_sg_for_device,
+	.mapping_error = xtensa_dma_mapping_error,
+};
+EXPORT_SYMBOL(xtensa_dma_map_ops);
+
+#define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
+
+static int __init xtensa_dma_init(void)
+{
+	dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
+	return 0;
+}
+fs_initcall(xtensa_dma_init);

Re: xtensa build failures in -next due to DMA API changes

[Christoph Hellwig]

On Tue, Aug 25, 2015 at 01:21:40PM -0700, Guenter Roeck wrote:
> I also see
> 
> arch/xtensa/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
> 
> It looks like there is a conflict with "xtensa: reimplement DMA API using common
> helpers" by Max Filippov, which added the include. This patch is in -next.

Oh.  That one clashes badly with my whole series, basically each
of my patches will need the same work done for the other architectures
applied to xtensa as well.

In terms of effort it might be a better idea to rebase the patch from
Max on top of the series, as it will become a lot simpler that way.

Re: xtensa build failures in -next due to DMA API changes

[Max Filippov]

[-- Attachment #1: Type: text/plain, Size: 1028 bytes --]

On Tue, Aug 25, 2015 at 11:24 PM, Christoph Hellwig <hch@lst.de> wrote:
> On Tue, Aug 25, 2015 at 01:21:40PM -0700, Guenter Roeck wrote:
>> I also see
>>
>> arch/xtensa/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
>>
>> It looks like there is a conflict with "xtensa: reimplement DMA API using common
>> helpers" by Max Filippov, which added the include. This patch is in -next.
>
> Oh.  That one clashes badly with my whole series, basically each
> of my patches will need the same work done for the other architectures
> applied to xtensa as well.
>
> In terms of effort it might be a better idea to rebase the patch from
> Max on top of the series, as it will become a lot simpler that way.

Looks like I just need to remove now redundant function definitions from
xtensa/include/asm/dma-mapping.h. A patch that removes these
functions is attached, but I'm not sure where it should go. To the Andrew's
tree? Or should the xtensa tree merge Christoph's series and apply it on
top?

-- 
Thanks.
-- Max

[-- Attachment #2: 0001-xtensa-remove-duplicate-definitions-from-dma-mapping.patch --]
[-- Type: text/x-patch, Size: 2698 bytes --]

From 8707a6bd9f9bb4e40dc981be104e2eaa7b6355a6 Mon Sep 17 00:00:00 2001
From: Max Filippov <jcmvbkbc@gmail.com>
Date: Wed, 26 Aug 2015 08:42:18 +0300
Subject: [PATCH] xtensa: remove duplicate definitions from dma-mapping.h

DMA API reimplementation for xtensa conflicts with dma-mapping
consolidation series from Christoph Hellwig: now both xtensa
dma-mapping.h and dma-mapping-common.h define many dma_* functions.

Remove extra definitions from xtensa-specific dma-mapping.h

Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>
---
 arch/xtensa/include/asm/dma-mapping.h | 60 -----------------------------------
 1 file changed, 60 deletions(-)

diff --git a/arch/xtensa/include/asm/dma-mapping.h b/arch/xtensa/include/asm/dma-mapping.h
index f01cb30..4427f38 100644
--- a/arch/xtensa/include/asm/dma-mapping.h
+++ b/arch/xtensa/include/asm/dma-mapping.h
@@ -32,66 +32,6 @@ static inline struct dma_map_ops *get_dma_ops(struct device *dev)
 
 #include <asm-generic/dma-mapping-common.h>
 
-#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
-#define dma_free_noncoherent(d, s, v, h) dma_free_attrs(d, s, v, h, NULL)
-#define dma_alloc_coherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
-#define dma_free_coherent(d, s, c, h) dma_free_attrs(d, s, c, h, NULL)
-
-static inline void *dma_alloc_attrs(struct device *dev, size_t size,
-				    dma_addr_t *dma_handle, gfp_t gfp,
-				    struct dma_attrs *attrs)
-{
-	void *ret;
-	struct dma_map_ops *ops = get_dma_ops(dev);
-
-	if (dma_alloc_from_coherent(dev, size, dma_handle, &ret))
-		return ret;
-
-	ret = ops->alloc(dev, size, dma_handle, gfp, attrs);
-	debug_dma_alloc_coherent(dev, size, *dma_handle, ret);
-
-	return ret;
-}
-
-static inline void dma_free_attrs(struct device *dev, size_t size,
-				  void *vaddr, dma_addr_t dma_handle,
-				  struct dma_attrs *attrs)
-{
-	struct dma_map_ops *ops = get_dma_ops(dev);
-
-	if (dma_release_from_coherent(dev, get_order(size), vaddr))
-		return;
-
-	ops->free(dev, size, vaddr, dma_handle, attrs);
-	debug_dma_free_coherent(dev, size, vaddr, dma_handle);
-}
-
-static inline int
-dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
-{
-	struct dma_map_ops *ops = get_dma_ops(dev);
-
-	debug_dma_mapping_error(dev, dma_addr);
-	return ops->mapping_error(dev, dma_addr);
-}
-
-static inline int
-dma_supported(struct device *dev, u64 mask)
-{
-	return 1;
-}
-
-static inline int
-dma_set_mask(struct device *dev, u64 mask)
-{
-	if(!dev->dma_mask || !dma_supported(dev, mask))
-		return -EIO;
-
-	*dev->dma_mask = mask;
-
-	return 0;
-}
-
 void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
 		    enum dma_data_direction direction);
 
-- 
1.8.1.4

Re: xtensa build failures in -next due to DMA API changes

[Andrew Morton]

On Wed, 26 Aug 2015 10:53:25 +0300 Max Filippov <jcmvbkbc@gmail.com> wrote:

> On Tue, Aug 25, 2015 at 11:24 PM, Christoph Hellwig <hch@lst.de> wrote:
> > On Tue, Aug 25, 2015 at 01:21:40PM -0700, Guenter Roeck wrote:
> >> I also see
> >>
> >> arch/xtensa/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
> >>
> >> It looks like there is a conflict with "xtensa: reimplement DMA API using common
> >> helpers" by Max Filippov, which added the include. This patch is in -next.
> >
> > Oh.  That one clashes badly with my whole series, basically each
> > of my patches will need the same work done for the other architectures
> > applied to xtensa as well.
> >
> > In terms of effort it might be a better idea to rebase the patch from
> > Max on top of the series, as it will become a lot simpler that way.
> 
> Looks like I just need to remove now redundant function definitions from
> xtensa/include/asm/dma-mapping.h. A patch that removes these
> functions is attached, but I'm not sure where it should go. To the Andrew's
> tree? Or should the xtensa tree merge Christoph's series and apply it on
> top?

I can add it to Christoph's patch series.  This means that I won't be
merging Christoph's patches until you've sent your queue in to Linus, so
please don't leave it too late in the merge window.

Re: xtensa build failures in -next due to DMA API changes

[Christoph Hellwig]

On Wed, Aug 26, 2015 at 10:53:25AM +0300, Max Filippov wrote:
> Looks like I just need to remove now redundant function definitions from
> xtensa/include/asm/dma-mapping.h. A patch that removes these
> functions is attached, but I'm not sure where it should go. To the Andrew's
> tree? Or should the xtensa tree merge Christoph's series and apply it on
> top?

This looks fine to me.  Thanks for converting xtensa to the generic
DMA code!

Re: xtensa build failures in -next due to DMA API changes

[Chris Zankel]

I'll send the pull request as soon as possible.

On Wed, Aug 26, 2015 at 12:59 AM, Andrew Morton
<akpm@linux-foundation.org> wrote:
> On Wed, 26 Aug 2015 10:53:25 +0300 Max Filippov <jcmvbkbc@gmail.com> wrote:
>
>> On Tue, Aug 25, 2015 at 11:24 PM, Christoph Hellwig <hch@lst.de> wrote:
>> > On Tue, Aug 25, 2015 at 01:21:40PM -0700, Guenter Roeck wrote:
>> >> I also see
>> >>
>> >> arch/xtensa/include/asm/dma-mapping.h:#include <asm-generic/dma-mapping-common.h>
>> >>
>> >> It looks like there is a conflict with "xtensa: reimplement DMA API using common
>> >> helpers" by Max Filippov, which added the include. This patch is in -next.
>> >
>> > Oh.  That one clashes badly with my whole series, basically each
>> > of my patches will need the same work done for the other architectures
>> > applied to xtensa as well.
>> >
>> > In terms of effort it might be a better idea to rebase the patch from
>> > Max on top of the series, as it will become a lot simpler that way.
>>
>> Looks like I just need to remove now redundant function definitions from
>> xtensa/include/asm/dma-mapping.h. A patch that removes these
>> functions is attached, but I'm not sure where it should go. To the Andrew's
>> tree? Or should the xtensa tree merge Christoph's series and apply it on
>> top?
>
> I can add it to Christoph's patch series.  This means that I won't be
> merging Christoph's patches until you've sent your queue in to Linus, so
> please don't leave it too late in the merge window.
>

Re: xtensa build failures in -next due to DMA API changes

[Chris Zankel]

Hi Andrew,

Linus has merged the Xtensa patches, so you should be ready to go.

Thanks,
-Chris

On Wed, Aug 26, 2015 at 10:41 AM, Christoph Hellwig <hch@lst.de> wrote:
> On Wed, Aug 26, 2015 at 10:53:25AM +0300, Max Filippov wrote:
>> Looks like I just need to remove now redundant function definitions from
>> xtensa/include/asm/dma-mapping.h. A patch that removes these
>> functions is attached, but I'm not sure where it should go. To the Andrew's
>> tree? Or should the xtensa tree merge Christoph's series and apply it on
>> top?
>
> This looks fine to me.  Thanks for converting xtensa to the generic
> DMA code!