Merge branch 'for-linus' of git://git.linaro.org/people/mszyprowski/linux-dma-mapping

Pull DMA mapping branch from Marek Szyprowski:
 "Short summary for the whole series:

  A few limitations have been identified in the current dma-mapping
  design and its implementations for various architectures.  There exist
  more than one function for allocating and freeing the buffers:
  currently these 3 are used dma_{alloc, free}_coherent,
  dma_{alloc,free}_writecombine, dma_{alloc,free}_noncoherent.

  For most of the systems these calls are almost equivalent and can be
  interchanged.  For others, especially the truly non-coherent ones
  (like ARM), the difference can be easily noticed in overall driver
  performance.  Sadly not all architectures provide implementations for
  all of them, so the drivers might need to be adapted and cannot be
  easily shared between different architectures.  The provided patches
  unify all these functions and hide the differences under the already
  existing dma attributes concept.  The thread with more references is
  available here:

    http://www.spinics.net/lists/linux-sh/msg09777.html

  These patches are also a prerequisite for unifying DMA-mapping
  implementation on ARM architecture with the common one provided by
  dma_map_ops structure and extending it with IOMMU support.  More
  information is available in the following thread:

    http://thread.gmane.org/gmane.linux.kernel.cross-arch/12819

  More works on dma-mapping framework are planned, especially in the
  area of buffer sharing and managing the shared mappings (together with
  the recently introduced dma_buf interface: commit d15bd7ee445d
  "dma-buf: Introduce dma buffer sharing mechanism").

  The patches in the current set introduce a new alloc/free methods
  (with support for memory attributes) in dma_map_ops structure, which
  will later replace dma_alloc_coherent and dma_alloc_writecombine
  functions."

People finally started piping up with support for merging this, so I'm
merging it as the last of the pending stuff from the merge window.
Looks like pohmelfs is going to wait for 3.5 and more external support
for merging.

* 'for-linus' of git://git.linaro.org/people/mszyprowski/linux-dma-mapping:
  common: DMA-mapping: add NON-CONSISTENT attribute
  common: DMA-mapping: add WRITE_COMBINE attribute
  common: dma-mapping: introduce mmap method
  common: dma-mapping: remove old alloc_coherent and free_coherent methods
  Hexagon: adapt for dma_map_ops changes
  Unicore32: adapt for dma_map_ops changes
  Microblaze: adapt for dma_map_ops changes
  SH: adapt for dma_map_ops changes
  Alpha: adapt for dma_map_ops changes
  SPARC: adapt for dma_map_ops changes
  PowerPC: adapt for dma_map_ops changes
  MIPS: adapt for dma_map_ops changes
  X86 & IA64: adapt for dma_map_ops changes
  common: dma-mapping: introduce generic alloc() and free() methods

8 files changed, 60 insertions, 41 deletions

diff --git a/arch/powerpc/include/asm/dma-mapping.h b/arch/powerpc/include/asm/dma-mapping.h
index dd70fac57ec8..62678e365ca0 100644
--- a/arch/powerpc/include/asm/dma-mapping.h
+++ b/arch/powerpc/include/asm/dma-mapping.h
@@ -22,9 +22,11 @@
 
 /* Some dma direct funcs must be visible for use in other dma_ops */
 extern void *dma_direct_alloc_coherent(struct device *dev, size_t size,
-                                       dma_addr_t *dma_handle, gfp_t flag);
+                                       dma_addr_t *dma_handle, gfp_t flag,
+                                       struct dma_attrs *attrs);
 extern void dma_direct_free_coherent(struct device *dev, size_t size,
-                                     void *vaddr, dma_addr_t dma_handle);
+                                     void *vaddr, dma_addr_t dma_handle,
+                                     struct dma_attrs *attrs);
 
 
 #ifdef CONFIG_NOT_COHERENT_CACHE
@@ -130,23 +132,29 @@ static inline int dma_supported(struct device *dev, u64 mask)
 
 extern int dma_set_mask(struct device *dev, u64 dma_mask);
 
-static inline void *dma_alloc_coherent(struct device *dev, size_t size,
-                                       dma_addr_t *dma_handle, gfp_t flag)
+#define dma_alloc_coherent(d,s,h,f)     dma_alloc_attrs(d,s,h,f,NULL)
+
+static inline void *dma_alloc_attrs(struct device *dev, size_t size,
+                                    dma_addr_t *dma_handle, gfp_t flag,
+                                    struct dma_attrs *attrs)
 {
         struct dma_map_ops *dma_ops = get_dma_ops(dev);
         void *cpu_addr;
 
         BUG_ON(!dma_ops);
 
-        cpu_addr = dma_ops->alloc_coherent(dev, size, dma_handle, flag);
+        cpu_addr = dma_ops->alloc(dev, size, dma_handle, flag, attrs);
 
         debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
 
         return cpu_addr;
 }
 
-static inline void dma_free_coherent(struct device *dev, size_t size,
-                                     void *cpu_addr, dma_addr_t dma_handle)
+#define dma_free_coherent(d,s,c,h) dma_free_attrs(d,s,c,h,NULL)
+
+static inline void dma_free_attrs(struct device *dev, size_t size,
+                                  void *cpu_addr, dma_addr_t dma_handle,
+                                  struct dma_attrs *attrs)
 {
         struct dma_map_ops *dma_ops = get_dma_ops(dev);
 
@@ -154,7 +162,7 @@ static inline void dma_free_coherent(struct device *dev, size_t size,
 
         debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
 
-        dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);
+        dma_ops->free(dev, size, cpu_addr, dma_handle, attrs);
 }
 
 static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
diff --git a/arch/powerpc/kernel/dma-iommu.c b/arch/powerpc/kernel/dma-iommu.c
index 3f6464b4d970..bcfdcd22c766 100644
--- a/arch/powerpc/kernel/dma-iommu.c
+++ b/arch/powerpc/kernel/dma-iommu.c
@@ -17,7 +17,8 @@
  * to the dma address (mapping) of the first page.
  */
 static void *dma_iommu_alloc_coherent(struct device *dev, size_t size,
-                                      dma_addr_t *dma_handle, gfp_t flag)
+                                      dma_addr_t *dma_handle, gfp_t flag,
+                                      struct dma_attrs *attrs)
 {
         return iommu_alloc_coherent(dev, get_iommu_table_base(dev), size,
                                     dma_handle, dev->coherent_dma_mask, flag,
@@ -25,7 +26,8 @@ static void *dma_iommu_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void dma_iommu_free_coherent(struct device *dev, size_t size,
-                                    void *vaddr, dma_addr_t dma_handle)
+                                    void *vaddr, dma_addr_t dma_handle,
+                                    struct dma_attrs *attrs)
 {
         iommu_free_coherent(get_iommu_table_base(dev), size, vaddr, dma_handle);
 }
@@ -105,8 +107,8 @@ static u64 dma_iommu_get_required_mask(struct device *dev)
 }
 
 struct dma_map_ops dma_iommu_ops = {
-        .alloc_coherent         = dma_iommu_alloc_coherent,
-        .free_coherent          = dma_iommu_free_coherent,
+        .alloc                  = dma_iommu_alloc_coherent,
+        .free                   = dma_iommu_free_coherent,
         .map_sg                 = dma_iommu_map_sg,
         .unmap_sg               = dma_iommu_unmap_sg,
         .dma_supported          = dma_iommu_dma_supported,
diff --git a/arch/powerpc/kernel/dma-swiotlb.c b/arch/powerpc/kernel/dma-swiotlb.c
index 1ebc9189aada..4ab88dafb235 100644
--- a/arch/powerpc/kernel/dma-swiotlb.c
+++ b/arch/powerpc/kernel/dma-swiotlb.c
@@ -47,8 +47,8 @@ static u64 swiotlb_powerpc_get_required(struct device *dev)
  * for everything else.
  */
 struct dma_map_ops swiotlb_dma_ops = {
-        .alloc_coherent = dma_direct_alloc_coherent,
-        .free_coherent = dma_direct_free_coherent,
+        .alloc = dma_direct_alloc_coherent,
+        .free = dma_direct_free_coherent,
         .map_sg = swiotlb_map_sg_attrs,
         .unmap_sg = swiotlb_unmap_sg_attrs,
         .dma_supported = swiotlb_dma_supported,
diff --git a/arch/powerpc/kernel/dma.c b/arch/powerpc/kernel/dma.c
index 7d0233c12ee3..b1ec983dcec8 100644
--- a/arch/powerpc/kernel/dma.c
+++ b/arch/powerpc/kernel/dma.c
@@ -26,7 +26,8 @@
 
 
 void *dma_direct_alloc_coherent(struct device *dev, size_t size,
-                                dma_addr_t *dma_handle, gfp_t flag)
+                                dma_addr_t *dma_handle, gfp_t flag,
+                                struct dma_attrs *attrs)
 {
         void *ret;
 #ifdef CONFIG_NOT_COHERENT_CACHE
@@ -54,7 +55,8 @@ void *dma_direct_alloc_coherent(struct device *dev, size_t size,
 }
 
 void dma_direct_free_coherent(struct device *dev, size_t size,
-                              void *vaddr, dma_addr_t dma_handle)
+                              void *vaddr, dma_addr_t dma_handle,
+                              struct dma_attrs *attrs)
 {
 #ifdef CONFIG_NOT_COHERENT_CACHE
         __dma_free_coherent(size, vaddr);
@@ -150,8 +152,8 @@ static inline void dma_direct_sync_single(struct device *dev,
 #endif
 
 struct dma_map_ops dma_direct_ops = {
-        .alloc_coherent                 = dma_direct_alloc_coherent,
-        .free_coherent                  = dma_direct_free_coherent,
+        .alloc                          = dma_direct_alloc_coherent,
+        .free                           = dma_direct_free_coherent,
         .map_sg                         = dma_direct_map_sg,
         .unmap_sg                       = dma_direct_unmap_sg,
         .dma_supported                  = dma_direct_dma_supported,
diff --git a/arch/powerpc/kernel/ibmebus.c b/arch/powerpc/kernel/ibmebus.c
index 79bb282e6501..b01d14eeca8d 100644
--- a/arch/powerpc/kernel/ibmebus.c
+++ b/arch/powerpc/kernel/ibmebus.c
@@ -65,7 +65,8 @@ static struct of_device_id __initdata ibmebus_matches[] = {
 static void *ibmebus_alloc_coherent(struct device *dev,
                                     size_t size,
                                     dma_addr_t *dma_handle,
-                                    gfp_t flag)
+                                    gfp_t flag,
+                                    struct dma_attrs *attrs)
 {
         void *mem;
 
@@ -77,7 +78,8 @@ static void *ibmebus_alloc_coherent(struct device *dev,
 
 static void ibmebus_free_coherent(struct device *dev,
                                   size_t size, void *vaddr,
-                                  dma_addr_t dma_handle)
+                                  dma_addr_t dma_handle,
+                                  struct dma_attrs *attrs)
 {
         kfree(vaddr);
 }
@@ -136,8 +138,8 @@ static u64 ibmebus_dma_get_required_mask(struct device *dev)
 }
 
 static struct dma_map_ops ibmebus_dma_ops = {
-        .alloc_coherent     = ibmebus_alloc_coherent,
-        .free_coherent      = ibmebus_free_coherent,
+        .alloc              = ibmebus_alloc_coherent,
+        .free               = ibmebus_free_coherent,
         .map_sg             = ibmebus_map_sg,
         .unmap_sg           = ibmebus_unmap_sg,
         .dma_supported      = ibmebus_dma_supported,
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index b2f7c8480bf6..a3a99901c8ec 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -482,7 +482,8 @@ static void vio_cmo_balance(struct work_struct *work)
 }
 
 static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
-                                          dma_addr_t *dma_handle, gfp_t flag)
+                                          dma_addr_t *dma_handle, gfp_t flag,
+                                          struct dma_attrs *attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
         void *ret;
@@ -492,7 +493,7 @@ static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
                 return NULL;
         }
 
-        ret = dma_iommu_ops.alloc_coherent(dev, size, dma_handle, flag);
+        ret = dma_iommu_ops.alloc(dev, size, dma_handle, flag, attrs);
         if (unlikely(ret == NULL)) {
                 vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
                 atomic_inc(&viodev->cmo.allocs_failed);
@@ -502,11 +503,12 @@ static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void vio_dma_iommu_free_coherent(struct device *dev, size_t size,
-                                        void *vaddr, dma_addr_t dma_handle)
+                                        void *vaddr, dma_addr_t dma_handle,
+                                        struct dma_attrs *attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
 
-        dma_iommu_ops.free_coherent(dev, size, vaddr, dma_handle);
+        dma_iommu_ops.free(dev, size, vaddr, dma_handle, attrs);
 
         vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
 }
@@ -607,8 +609,8 @@ static u64 vio_dma_get_required_mask(struct device *dev)
 }
 
 struct dma_map_ops vio_dma_mapping_ops = {
-        .alloc_coherent    = vio_dma_iommu_alloc_coherent,
-        .free_coherent     = vio_dma_iommu_free_coherent,
+        .alloc             = vio_dma_iommu_alloc_coherent,
+        .free              = vio_dma_iommu_free_coherent,
         .map_sg            = vio_dma_iommu_map_sg,
         .unmap_sg          = vio_dma_iommu_unmap_sg,
         .map_page          = vio_dma_iommu_map_page,
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index ae9fc7bc17d6..b9f509a34c01 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -564,7 +564,8 @@ static struct iommu_table *cell_get_iommu_table(struct device *dev)
 /* A coherent allocation implies strong ordering */
 
 static void *dma_fixed_alloc_coherent(struct device *dev, size_t size,
-                                      dma_addr_t *dma_handle, gfp_t flag)
+                                      dma_addr_t *dma_handle, gfp_t flag,
+                                      struct dma_attrs *attrs)
 {
         if (iommu_fixed_is_weak)
                 return iommu_alloc_coherent(dev, cell_get_iommu_table(dev),
@@ -572,18 +573,19 @@ static void *dma_fixed_alloc_coherent(struct device *dev, size_t size,
                                             device_to_mask(dev), flag,
                                             dev_to_node(dev));
         else
-                return dma_direct_ops.alloc_coherent(dev, size, dma_handle,
-                                                     flag);
+                return dma_direct_ops.alloc(dev, size, dma_handle, flag,
+                                            attrs);
 }
 
 static void dma_fixed_free_coherent(struct device *dev, size_t size,
-                                    void *vaddr, dma_addr_t dma_handle)
+                                    void *vaddr, dma_addr_t dma_handle,
+                                    struct dma_attrs *attrs)
 {
         if (iommu_fixed_is_weak)
                 iommu_free_coherent(cell_get_iommu_table(dev), size, vaddr,
                                     dma_handle);
         else
-                dma_direct_ops.free_coherent(dev, size, vaddr, dma_handle);
+                dma_direct_ops.free(dev, size, vaddr, dma_handle, attrs);
 }
 
 static dma_addr_t dma_fixed_map_page(struct device *dev, struct page *page,
@@ -642,8 +644,8 @@ static int dma_fixed_dma_supported(struct device *dev, u64 mask)
 static int dma_set_mask_and_switch(struct device *dev, u64 dma_mask);
 
 struct dma_map_ops dma_iommu_fixed_ops = {
-        .alloc_coherent = dma_fixed_alloc_coherent,
-        .free_coherent  = dma_fixed_free_coherent,
+        .alloc          = dma_fixed_alloc_coherent,
+        .free           = dma_fixed_free_coherent,
         .map_sg         = dma_fixed_map_sg,
         .unmap_sg       = dma_fixed_unmap_sg,
         .dma_supported  = dma_fixed_dma_supported,
diff --git a/arch/powerpc/platforms/ps3/system-bus.c b/arch/powerpc/platforms/ps3/system-bus.c
index 880eb9ce22c5..5606fe36faf2 100644
--- a/arch/powerpc/platforms/ps3/system-bus.c
+++ b/arch/powerpc/platforms/ps3/system-bus.c
@@ -515,7 +515,8 @@ core_initcall(ps3_system_bus_init);
  * to the dma address (mapping) of the first page.
  */
 static void * ps3_alloc_coherent(struct device *_dev, size_t size,
-                                      dma_addr_t *dma_handle, gfp_t flag)
+                                 dma_addr_t *dma_handle, gfp_t flag,
+                                 struct dma_attrs *attrs)
 {
         int result;
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
@@ -552,7 +553,7 @@ clean_none:
 }
 
 static void ps3_free_coherent(struct device *_dev, size_t size, void *vaddr,
-        dma_addr_t dma_handle)
+                              dma_addr_t dma_handle, struct dma_attrs *attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
 
@@ -701,8 +702,8 @@ static u64 ps3_dma_get_required_mask(struct device *_dev)
 }
 
 static struct dma_map_ops ps3_sb_dma_ops = {
-        .alloc_coherent = ps3_alloc_coherent,
-        .free_coherent = ps3_free_coherent,
+        .alloc = ps3_alloc_coherent,
+        .free = ps3_free_coherent,
         .map_sg = ps3_sb_map_sg,
         .unmap_sg = ps3_sb_unmap_sg,
         .dma_supported = ps3_dma_supported,
@@ -712,8 +713,8 @@ static struct dma_map_ops ps3_sb_dma_ops = {
 };
 
 static struct dma_map_ops ps3_ioc0_dma_ops = {
-        .alloc_coherent = ps3_alloc_coherent,
-        .free_coherent = ps3_free_coherent,
+        .alloc = ps3_alloc_coherent,
+        .free = ps3_free_coherent,
         .map_sg = ps3_ioc0_map_sg,
         .unmap_sg = ps3_ioc0_unmap_sg,
         .dma_supported = ps3_dma_supported,