6 files changed, 124 insertions, 270 deletions

diff --git a/arch/parisc/Kconfig b/arch/parisc/Kconfig
index 7c34cafdf301..1489351134fa 100644
--- a/arch/parisc/Kconfig
+++ b/arch/parisc/Kconfig
@@ -29,6 +29,8 @@ config PARISC
         select TTY # Needed for pdc_cons.c
         select HAVE_DEBUG_STACKOVERFLOW
         select HAVE_ARCH_AUDITSYSCALL
+        select ARCH_NO_COHERENT_DMA_MMAP
+        select HAVE_DMA_ATTRS
 
         help
           The PA-RISC microprocessor is designed by Hewlett-Packard and used
diff --git a/arch/parisc/include/asm/dma-mapping.h b/arch/parisc/include/asm/dma-mapping.h
index d8d60a57183f..4de518647612 100644
--- a/arch/parisc/include/asm/dma-mapping.h
+++ b/arch/parisc/include/asm/dma-mapping.h
@@ -1,30 +1,11 @@
 #ifndef _PARISC_DMA_MAPPING_H
 #define _PARISC_DMA_MAPPING_H
 
-#include <linux/mm.h>
-#include <linux/scatterlist.h>
 #include <asm/cacheflush.h>
 
-/* See Documentation/DMA-API-HOWTO.txt */
-struct hppa_dma_ops {
-        int  (*dma_supported)(struct device *dev, u64 mask);
-        void *(*alloc_consistent)(struct device *dev, size_t size, dma_addr_t *iova, gfp_t flag);
-        void *(*alloc_noncoherent)(struct device *dev, size_t size, dma_addr_t *iova, gfp_t flag);
-        void (*free_consistent)(struct device *dev, size_t size, void *vaddr, dma_addr_t iova);
-        dma_addr_t (*map_single)(struct device *dev, void *addr, size_t size, enum dma_data_direction direction);
-        void (*unmap_single)(struct device *dev, dma_addr_t iova, size_t size, enum dma_data_direction direction);
-        int  (*map_sg)(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction);
-        void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nhwents, enum dma_data_direction direction);
-        void (*dma_sync_single_for_cpu)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
-        void (*dma_sync_single_for_device)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
-        void (*dma_sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
-        void (*dma_sync_sg_for_device)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
-};
-
 /*
-** We could live without the hppa_dma_ops indirection if we didn't want
-** to support 4 different coherent dma models with one binary (they will
-** someday be loadable modules):
+** We need to support 4 different coherent dma models with one binary:
+**
 **     I/O MMU        consistent method           dma_sync behavior
 **  =============   ======================       =======================
 **  a) PA-7x00LC    uncachable host memory          flush/purge
@@ -40,158 +21,22 @@ struct hppa_dma_ops {
 */
 
 #ifdef CONFIG_PA11
-extern struct hppa_dma_ops pcxl_dma_ops;
-extern struct hppa_dma_ops pcx_dma_ops;
+extern struct dma_map_ops pcxl_dma_ops;
+extern struct dma_map_ops pcx_dma_ops;
 #endif
 
-extern struct hppa_dma_ops *hppa_dma_ops;
-
-#define dma_alloc_attrs(d, s, h, f, a) dma_alloc_coherent(d, s, h, f)
-#define dma_free_attrs(d, s, h, f, a) dma_free_coherent(d, s, h, f)
-
-static inline void *
-dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
-                   gfp_t flag)
-{
-        return hppa_dma_ops->alloc_consistent(dev, size, dma_handle, flag);
-}
-
-static inline void *
-dma_alloc_noncoherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
-                      gfp_t flag)
-{
-        return hppa_dma_ops->alloc_noncoherent(dev, size, dma_handle, flag);
-}
-
-static inline void
-dma_free_coherent(struct device *dev, size_t size, 
-                    void *vaddr, dma_addr_t dma_handle)
-{
-        hppa_dma_ops->free_consistent(dev, size, vaddr, dma_handle);
-}
-
-static inline void
-dma_free_noncoherent(struct device *dev, size_t size, 
-                    void *vaddr, dma_addr_t dma_handle)
-{
-        hppa_dma_ops->free_consistent(dev, size, vaddr, dma_handle);
-}
-
-static inline dma_addr_t
-dma_map_single(struct device *dev, void *ptr, size_t size,
-               enum dma_data_direction direction)
-{
-        return hppa_dma_ops->map_single(dev, ptr, size, direction);
-}
-
-static inline void
-dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
-                 enum dma_data_direction direction)
-{
-        hppa_dma_ops->unmap_single(dev, dma_addr, size, direction);
-}
-
-static inline int
-dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
-           enum dma_data_direction direction)
-{
-        return hppa_dma_ops->map_sg(dev, sg, nents, direction);
-}
-
-static inline void
-dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
-             enum dma_data_direction direction)
-{
-        hppa_dma_ops->unmap_sg(dev, sg, nhwentries, direction);
-}
-
-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)
-{
-        return dma_map_single(dev, (page_address(page) + (offset)), size, direction);
-}
-
-static inline void
-dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
-               enum dma_data_direction direction)
-{
-        dma_unmap_single(dev, dma_address, size, direction);
-}
-
-
-static inline void
-dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
-                enum dma_data_direction direction)
-{
-        if(hppa_dma_ops->dma_sync_single_for_cpu)
-                hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, 0, size, direction);
-}
-
-static inline void
-dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
-                enum dma_data_direction direction)
-{
-        if(hppa_dma_ops->dma_sync_single_for_device)
-                hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, 0, size, direction);
-}
-
-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)
-{
-        if(hppa_dma_ops->dma_sync_single_for_cpu)
-                hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, offset, size, direction);
-}
+extern struct dma_map_ops *hppa_dma_ops;
 
-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 struct dma_map_ops *get_dma_ops(struct device *dev)
 {
-        if(hppa_dma_ops->dma_sync_single_for_device)
-                hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, offset, size, direction);
-}
-
-static inline void
-dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
-                 enum dma_data_direction direction)
-{
-        if(hppa_dma_ops->dma_sync_sg_for_cpu)
-                hppa_dma_ops->dma_sync_sg_for_cpu(dev, sg, nelems, direction);
-}
-
-static inline void
-dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
-                 enum dma_data_direction direction)
-{
-        if(hppa_dma_ops->dma_sync_sg_for_device)
-                hppa_dma_ops->dma_sync_sg_for_device(dev, sg, nelems, direction);
-}
-
-static inline int
-dma_supported(struct device *dev, u64 mask)
-{
-        return hppa_dma_ops->dma_supported(dev, mask);
-}
-
-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;
+        return hppa_dma_ops;
 }
 
 static inline void
 dma_cache_sync(struct device *dev, void *vaddr, size_t size,
                enum dma_data_direction direction)
 {
-        if(hppa_dma_ops->dma_sync_single_for_cpu)
+        if (hppa_dma_ops->sync_single_for_cpu)
                 flush_kernel_dcache_range((unsigned long)vaddr, size);
 }
 
@@ -238,22 +83,6 @@ struct parisc_device;
 void * sba_get_iommu(struct parisc_device *dev);
 #endif
 
-/* At the moment, we panic on error for IOMMU resource exaustion */
-#define dma_mapping_error(dev, x)       0
-
-/* This API cannot be supported on PA-RISC */
-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;
-}
+#include <asm-generic/dma-mapping-common.h>
 
 #endif
diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c
index dba508fe1683..f8150669b8c6 100644
--- a/arch/parisc/kernel/drivers.c
+++ b/arch/parisc/kernel/drivers.c
@@ -40,7 +40,7 @@
 #include <asm/parisc-device.h>
 
 /* See comments in include/asm-parisc/pci.h */
-struct hppa_dma_ops *hppa_dma_ops __read_mostly;
+struct dma_map_ops *hppa_dma_ops __read_mostly;
 EXPORT_SYMBOL(hppa_dma_ops);
 
 static struct device root = {
diff --git a/arch/parisc/kernel/pci-dma.c b/arch/parisc/kernel/pci-dma.c
index b9402c9b3454..a27e4928bf73 100644
--- a/arch/parisc/kernel/pci-dma.c
+++ b/arch/parisc/kernel/pci-dma.c
@@ -413,7 +413,8 @@ pcxl_dma_init(void)
 
 __initcall(pcxl_dma_init);
 
-static void * pa11_dma_alloc_consistent (struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag)
+static void *pa11_dma_alloc(struct device *dev, size_t size,
+                dma_addr_t *dma_handle, gfp_t flag, struct dma_attrs *attrs)
 {
         unsigned long vaddr;
         unsigned long paddr;
@@ -439,7 +440,8 @@ static void * pa11_dma_alloc_consistent (struct device *dev, size_t size, dma_ad
         return (void *)vaddr;
 }
 
-static void pa11_dma_free_consistent (struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle)
+static void pa11_dma_free(struct device *dev, size_t size, void *vaddr,
+                dma_addr_t dma_handle, struct dma_attrs *attrs)
 {
         int order;
 
@@ -450,15 +452,20 @@ static void pa11_dma_free_consistent (struct device *dev, size_t size, void *vad
         free_pages((unsigned long)__va(dma_handle), order);
 }
 
-static dma_addr_t pa11_dma_map_single(struct device *dev, void *addr, size_t size, enum dma_data_direction direction)
+static dma_addr_t pa11_dma_map_page(struct device *dev, struct page *page,
+                unsigned long offset, size_t size,
+                enum dma_data_direction direction, struct dma_attrs *attrs)
 {
+        void *addr = page_address(page) + offset;
         BUG_ON(direction == DMA_NONE);
 
         flush_kernel_dcache_range((unsigned long) addr, size);
         return virt_to_phys(addr);
 }
 
-static void pa11_dma_unmap_single(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
+static void pa11_dma_unmap_page(struct device *dev, dma_addr_t dma_handle,
+                size_t size, enum dma_data_direction direction,
+                struct dma_attrs *attrs)
 {
         BUG_ON(direction == DMA_NONE);
 
@@ -475,7 +482,9 @@ static void pa11_dma_unmap_single(struct device *dev, dma_addr_t dma_handle, siz
         return;
 }
 
-static int pa11_dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction)
+static int pa11_dma_map_sg(struct device *dev, struct scatterlist *sglist,
+                int nents, enum dma_data_direction direction,
+                struct dma_attrs *attrs)
 {
         int i;
         struct scatterlist *sg;
@@ -492,7 +501,9 @@ static int pa11_dma_map_sg(struct device *dev, struct scatterlist *sglist, int n
         return nents;
 }
 
-static void pa11_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction)
+static void pa11_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
+                int nents, enum dma_data_direction direction,
+                struct dma_attrs *attrs)
 {
         int i;
         struct scatterlist *sg;
@@ -509,18 +520,24 @@ static void pa11_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, in
         return;
 }
 
-static void pa11_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction)
+static void pa11_dma_sync_single_for_cpu(struct device *dev,
+                dma_addr_t dma_handle, size_t size,
+                enum dma_data_direction direction)
 {
         BUG_ON(direction == DMA_NONE);
 
-        flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle) + offset, size);
+        flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle),
+                        size);
 }
 
-static void pa11_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction)
+static void pa11_dma_sync_single_for_device(struct device *dev,
+                dma_addr_t dma_handle, size_t size,
+                enum dma_data_direction direction)
 {
         BUG_ON(direction == DMA_NONE);
 
-        flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle) + offset, size);
+        flush_kernel_dcache_range((unsigned long) phys_to_virt(dma_handle),
+                        size);
 }
 
 static void pa11_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction)
@@ -545,32 +562,28 @@ static void pa11_dma_sync_sg_for_device(struct device *dev, struct scatterlist *
                 flush_kernel_vmap_range(sg_virt(sg), sg->length);
 }
 
-struct hppa_dma_ops pcxl_dma_ops = {
+struct dma_map_ops pcxl_dma_ops = {
         .dma_supported =        pa11_dma_supported,
-        .alloc_consistent =     pa11_dma_alloc_consistent,
-        .alloc_noncoherent =    pa11_dma_alloc_consistent,
-        .free_consistent =      pa11_dma_free_consistent,
-        .map_single =           pa11_dma_map_single,
-        .unmap_single =         pa11_dma_unmap_single,
+        .alloc =                pa11_dma_alloc,
+        .free =                 pa11_dma_free,
+        .map_page =             pa11_dma_map_page,
+        .unmap_page =           pa11_dma_unmap_page,
         .map_sg =               pa11_dma_map_sg,
         .unmap_sg =             pa11_dma_unmap_sg,
-        .dma_sync_single_for_cpu = pa11_dma_sync_single_for_cpu,
-        .dma_sync_single_for_device = pa11_dma_sync_single_for_device,
-        .dma_sync_sg_for_cpu = pa11_dma_sync_sg_for_cpu,
-        .dma_sync_sg_for_device = pa11_dma_sync_sg_for_device,
+        .sync_single_for_cpu =  pa11_dma_sync_single_for_cpu,
+        .sync_single_for_device = pa11_dma_sync_single_for_device,
+        .sync_sg_for_cpu =      pa11_dma_sync_sg_for_cpu,
+        .sync_sg_for_device =   pa11_dma_sync_sg_for_device,
 };
 
-static void *fail_alloc_consistent(struct device *dev, size_t size,
-                                   dma_addr_t *dma_handle, gfp_t flag)
-{
-        return NULL;
-}
-
-static void *pa11_dma_alloc_noncoherent(struct device *dev, size_t size,
-                                          dma_addr_t *dma_handle, gfp_t flag)
+static void *pcx_dma_alloc(struct device *dev, size_t size,
+                dma_addr_t *dma_handle, gfp_t flag, struct dma_attrs *attrs)
 {
         void *addr;
 
+        if (!dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs))
+                return NULL;
+
         addr = (void *)__get_free_pages(flag, get_order(size));
         if (addr)
                 *dma_handle = (dma_addr_t)virt_to_phys(addr);
@@ -578,24 +591,23 @@ static void *pa11_dma_alloc_noncoherent(struct device *dev, size_t size,
         return addr;
 }
 
-static void pa11_dma_free_noncoherent(struct device *dev, size_t size,
-                                        void *vaddr, dma_addr_t iova)
+static void pcx_dma_free(struct device *dev, size_t size, void *vaddr,
+                dma_addr_t iova, struct dma_attrs *attrs)
 {
         free_pages((unsigned long)vaddr, get_order(size));
         return;
 }
 
-struct hppa_dma_ops pcx_dma_ops = {
+struct dma_map_ops pcx_dma_ops = {
         .dma_supported =        pa11_dma_supported,
-        .alloc_consistent =     fail_alloc_consistent,
-        .alloc_noncoherent =    pa11_dma_alloc_noncoherent,
-        .free_consistent =      pa11_dma_free_noncoherent,
-        .map_single =           pa11_dma_map_single,
-        .unmap_single =         pa11_dma_unmap_single,
+        .alloc =                pcx_dma_alloc,
+        .free =                 pcx_dma_free,
+        .map_page =             pa11_dma_map_page,
+        .unmap_page =           pa11_dma_unmap_page,
         .map_sg =               pa11_dma_map_sg,
         .unmap_sg =             pa11_dma_unmap_sg,
-        .dma_sync_single_for_cpu =      pa11_dma_sync_single_for_cpu,
-        .dma_sync_single_for_device =   pa11_dma_sync_single_for_device,
-        .dma_sync_sg_for_cpu =          pa11_dma_sync_sg_for_cpu,
-        .dma_sync_sg_for_device =       pa11_dma_sync_sg_for_device,
+        .sync_single_for_cpu =  pa11_dma_sync_single_for_cpu,
+        .sync_single_for_device = pa11_dma_sync_single_for_device,
+        .sync_sg_for_cpu =      pa11_dma_sync_sg_for_cpu,
+        .sync_sg_for_device =   pa11_dma_sync_sg_for_device,
 };
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 8e11fb2831cd..e24b05996a1b 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -786,18 +786,27 @@ ccio_map_single(struct device *dev, void *addr, size_t size,
         return CCIO_IOVA(iovp, offset);
 }
 
+
+static dma_addr_t
+ccio_map_page(struct device *dev, struct page *page, unsigned long offset,
+                size_t size, enum dma_data_direction direction,
+                struct dma_attrs *attrs)
+{
+        return ccio_map_single(dev, page_address(page) + offset, size,
+                        direction);
+}
+
+
 /**
- * ccio_unmap_single - Unmap an address range from the IOMMU.
+ * ccio_unmap_page - Unmap an address range from the IOMMU.
  * @dev: The PCI device.
  * @addr: The start address of the DMA region.
  * @size: The length of the DMA region.
  * @direction: The direction of the DMA transaction (to/from device).
- *
- * This function implements the pci_unmap_single function.
  */
 static void 
-ccio_unmap_single(struct device *dev, dma_addr_t iova, size_t size, 
-                  enum dma_data_direction direction)
+ccio_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
+                enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ioc *ioc;
         unsigned long flags; 
@@ -826,7 +835,7 @@ ccio_unmap_single(struct device *dev, dma_addr_t iova, size_t size,
 }
 
 /**
- * ccio_alloc_consistent - Allocate a consistent DMA mapping.
+ * ccio_alloc - Allocate a consistent DMA mapping.
  * @dev: The PCI device.
  * @size: The length of the DMA region.
  * @dma_handle: The DMA address handed back to the device (not the cpu).
@@ -834,7 +843,8 @@ ccio_unmap_single(struct device *dev, dma_addr_t iova, size_t size,
  * This function implements the pci_alloc_consistent function.
  */
 static void * 
-ccio_alloc_consistent(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag)
+ccio_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag,
+                struct dma_attrs *attrs)
 {
       void *ret;
 #if 0
@@ -858,7 +868,7 @@ ccio_alloc_consistent(struct device *dev, size_t size, dma_addr_t *dma_handle, g
 }
 
 /**
- * ccio_free_consistent - Free a consistent DMA mapping.
+ * ccio_free - Free a consistent DMA mapping.
  * @dev: The PCI device.
  * @size: The length of the DMA region.
  * @cpu_addr: The cpu address returned from the ccio_alloc_consistent.
@@ -867,10 +877,10 @@ ccio_alloc_consistent(struct device *dev, size_t size, dma_addr_t *dma_handle, g
  * This function implements the pci_free_consistent function.
  */
 static void 
-ccio_free_consistent(struct device *dev, size_t size, void *cpu_addr, 
-                     dma_addr_t dma_handle)
+ccio_free(struct device *dev, size_t size, void *cpu_addr,
+                dma_addr_t dma_handle, struct dma_attrs *attrs)
 {
-        ccio_unmap_single(dev, dma_handle, size, 0);
+        ccio_unmap_page(dev, dma_handle, size, 0, NULL);
         free_pages((unsigned long)cpu_addr, get_order(size));
 }
 
@@ -897,7 +907,7 @@ ccio_free_consistent(struct device *dev, size_t size, void *cpu_addr,
  */
 static int
 ccio_map_sg(struct device *dev, struct scatterlist *sglist, int nents, 
-            enum dma_data_direction direction)
+            enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ioc *ioc;
         int coalesced, filled = 0;
@@ -974,7 +984,7 @@ ccio_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
  */
 static void 
 ccio_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents, 
-              enum dma_data_direction direction)
+              enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ioc *ioc;
 
@@ -993,27 +1003,22 @@ ccio_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
 #ifdef CCIO_COLLECT_STATS
                 ioc->usg_pages += sg_dma_len(sglist) >> PAGE_SHIFT;
 #endif
-                ccio_unmap_single(dev, sg_dma_address(sglist),
-                                  sg_dma_len(sglist), direction);
+                ccio_unmap_page(dev, sg_dma_address(sglist),
+                                  sg_dma_len(sglist), direction, NULL);
                 ++sglist;
         }
 
         DBG_RUN_SG("%s() DONE (nents %d)\n", __func__, nents);
 }
 
-static struct hppa_dma_ops ccio_ops = {
+static struct dma_map_ops ccio_ops = {
         .dma_supported =        ccio_dma_supported,
-        .alloc_consistent =     ccio_alloc_consistent,
-        .alloc_noncoherent =    ccio_alloc_consistent,
-        .free_consistent =      ccio_free_consistent,
-        .map_single =           ccio_map_single,
-        .unmap_single =         ccio_unmap_single,
+        .alloc =                ccio_alloc,
+        .free =                 ccio_free,
+        .map_page =             ccio_map_page,
+        .unmap_page =           ccio_unmap_page,
         .map_sg =               ccio_map_sg,
         .unmap_sg =             ccio_unmap_sg,
-        .dma_sync_single_for_cpu =      NULL,   /* NOP for U2/Uturn */
-        .dma_sync_single_for_device =   NULL,   /* NOP for U2/Uturn */
-        .dma_sync_sg_for_cpu =          NULL,   /* ditto */
-        .dma_sync_sg_for_device =               NULL,   /* ditto */
 };
 
 #ifdef CONFIG_PROC_FS
@@ -1062,7 +1067,7 @@ static int ccio_proc_info(struct seq_file *m, void *p)
                            ioc->msingle_calls, ioc->msingle_pages,
                            (int)((ioc->msingle_pages * 1000)/ioc->msingle_calls));
 
-                /* KLUGE - unmap_sg calls unmap_single for each mapped page */
+                /* KLUGE - unmap_sg calls unmap_page for each mapped page */
                 min = ioc->usingle_calls - ioc->usg_calls;
                 max = ioc->usingle_pages - ioc->usg_pages;
                 seq_printf(m, "pci_unmap_single: %8ld calls  %8ld pages (avg %d/1000)\n",
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index 225049b492e5..42ec4600b7e4 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -780,8 +780,18 @@ sba_map_single(struct device *dev, void *addr, size_t size,
 }
 
 
+static dma_addr_t
+sba_map_page(struct device *dev, struct page *page, unsigned long offset,
+                size_t size, enum dma_data_direction direction,
+                struct dma_attrs *attrs)
+{
+        return sba_map_single(dev, page_address(page) + offset, size,
+                        direction);
+}
+
+
 /**
- * sba_unmap_single - unmap one IOVA and free resources
+ * sba_unmap_page - unmap one IOVA and free resources
  * @dev: instance of PCI owned by the driver that's asking.
  * @iova:  IOVA of driver buffer previously mapped.
  * @size:  number of bytes mapped in driver buffer.
@@ -790,8 +800,8 @@ sba_map_single(struct device *dev, void *addr, size_t size,
  * See Documentation/DMA-API-HOWTO.txt
  */
 static void
-sba_unmap_single(struct device *dev, dma_addr_t iova, size_t size,
-                 enum dma_data_direction direction)
+sba_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
+                enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ioc *ioc;
 #if DELAYED_RESOURCE_CNT > 0
@@ -858,15 +868,15 @@ sba_unmap_single(struct device *dev, dma_addr_t iova, size_t size,
 
 
 /**
- * sba_alloc_consistent - allocate/map shared mem for DMA
+ * sba_alloc - allocate/map shared mem for DMA
  * @hwdev: instance of PCI owned by the driver that's asking.
  * @size:  number of bytes mapped in driver buffer.
  * @dma_handle:  IOVA of new buffer.
  *
  * See Documentation/DMA-API-HOWTO.txt
  */
-static void *sba_alloc_consistent(struct device *hwdev, size_t size,
-                                        dma_addr_t *dma_handle, gfp_t gfp)
+static void *sba_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
+                gfp_t gfp, struct dma_attrs *attrs)
 {
         void *ret;
 
@@ -888,7 +898,7 @@ static void *sba_alloc_consistent(struct device *hwdev, size_t size,
 
 
 /**
- * sba_free_consistent - free/unmap shared mem for DMA
+ * sba_free - free/unmap shared mem for DMA
  * @hwdev: instance of PCI owned by the driver that's asking.
  * @size:  number of bytes mapped in driver buffer.
  * @vaddr:  virtual address IOVA of "consistent" buffer.
@@ -897,10 +907,10 @@ static void *sba_alloc_consistent(struct device *hwdev, size_t size,
  * See Documentation/DMA-API-HOWTO.txt
  */
 static void
-sba_free_consistent(struct device *hwdev, size_t size, void *vaddr,
-                    dma_addr_t dma_handle)
+sba_free(struct device *hwdev, size_t size, void *vaddr,
+                    dma_addr_t dma_handle, struct dma_attrs *attrs)
 {
-        sba_unmap_single(hwdev, dma_handle, size, 0);
+        sba_unmap_page(hwdev, dma_handle, size, 0, NULL);
         free_pages((unsigned long) vaddr, get_order(size));
 }
 
@@ -933,7 +943,7 @@ int dump_run_sg = 0;
  */
 static int
 sba_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
-           enum dma_data_direction direction)
+           enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ioc *ioc;
         int coalesced, filled = 0;
@@ -1016,7 +1026,7 @@ sba_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
  */
 static void 
 sba_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
-             enum dma_data_direction direction)
+             enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ioc *ioc;
 #ifdef ASSERT_PDIR_SANITY
@@ -1040,7 +1050,8 @@ sba_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
 
         while (sg_dma_len(sglist) && nents--) {
 
-                sba_unmap_single(dev, sg_dma_address(sglist), sg_dma_len(sglist), direction);
+                sba_unmap_page(dev, sg_dma_address(sglist), sg_dma_len(sglist),
+                                direction, NULL);
 #ifdef SBA_COLLECT_STATS
                 ioc->usg_pages += ((sg_dma_address(sglist) & ~IOVP_MASK) + sg_dma_len(sglist) + IOVP_SIZE - 1) >> PAGE_SHIFT;
                 ioc->usingle_calls--;   /* kluge since call is unmap_sg() */
@@ -1058,19 +1069,14 @@ sba_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
 
 }
 
-static struct hppa_dma_ops sba_ops = {
+static struct dma_map_ops sba_ops = {
         .dma_supported =        sba_dma_supported,
-        .alloc_consistent =     sba_alloc_consistent,
-        .alloc_noncoherent =    sba_alloc_consistent,
-        .free_consistent =      sba_free_consistent,
-        .map_single =           sba_map_single,
-        .unmap_single =         sba_unmap_single,
+        .alloc =                sba_alloc,
+        .free =                 sba_free,
+        .map_page =             sba_map_page,
+        .unmap_page =           sba_unmap_page,
         .map_sg =               sba_map_sg,
         .unmap_sg =             sba_unmap_sg,
-        .dma_sync_single_for_cpu =      NULL,
-        .dma_sync_single_for_device =   NULL,
-        .dma_sync_sg_for_cpu =          NULL,
-        .dma_sync_sg_for_device =       NULL,
 };