sparc: remove the sparc32_dma_ops indirection

There is no good reason to have a double indirection for the sparc32
dma ops, so remove the sparc32_dma_ops and define separate dma_map_ops
instance for the different IOMMU types.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Acked-by: David S. Miller <davem@davemloft.net>

2 files changed, 133 insertions, 69 deletions

diff --git a/arch/sparc/mm/io-unit.c b/arch/sparc/mm/io-unit.c
index c8cb27d3ea75..2088d292c6e5 100644
--- a/arch/sparc/mm/io-unit.c
+++ b/arch/sparc/mm/io-unit.c
@@ -12,7 +12,7 @@
 #include <linux/mm.h>
 #include <linux/highmem.h>      /* pte_offset_map => kmap_atomic */
 #include <linux/bitops.h>
-#include <linux/scatterlist.h>
+#include <linux/dma-mapping.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 
@@ -140,18 +140,26 @@ nexti:	scan = find_next_zero_bit(iounit->bmap, limit, scan);
         return vaddr;
 }
 
-static __u32 iounit_get_scsi_one(struct device *dev, char *vaddr, unsigned long len)
+static dma_addr_t iounit_map_page(struct device *dev, struct page *page,
+                unsigned long offset, size_t len, enum dma_data_direction dir,
+                unsigned long attrs)
 {
+        void *vaddr = page_address(page) + offset;
         struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long ret, flags;
         
+        /* XXX So what is maxphys for us and how do drivers know it? */
+        if (!len || len > 256 * 1024)
+                return DMA_MAPPING_ERROR;
+
         spin_lock_irqsave(&iounit->lock, flags);
         ret = iounit_get_area(iounit, (unsigned long)vaddr, len);
         spin_unlock_irqrestore(&iounit->lock, flags);
         return ret;
 }
 
-static void iounit_get_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
+static int iounit_map_sg(struct device *dev, struct scatterlist *sg, int sz,
+                enum dma_data_direction dir, unsigned long attrs)
 {
         struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long flags;
@@ -165,9 +173,11 @@ static void iounit_get_scsi_sgl(struct device *dev, struct scatterlist *sg, int
                 sg = sg_next(sg);
         }
         spin_unlock_irqrestore(&iounit->lock, flags);
+        return sz;
 }
 
-static void iounit_release_scsi_one(struct device *dev, __u32 vaddr, unsigned long len)
+static void iounit_unmap_page(struct device *dev, dma_addr_t vaddr, size_t len,
+                enum dma_data_direction dir, unsigned long attrs)
 {
         struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long flags;
@@ -181,7 +191,8 @@ static void iounit_release_scsi_one(struct device *dev, __u32 vaddr, unsigned lo
         spin_unlock_irqrestore(&iounit->lock, flags);
 }
 
-static void iounit_release_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
+static void iounit_unmap_sg(struct device *dev, struct scatterlist *sg, int sz,
+                enum dma_data_direction dir, unsigned long attrs)
 {
         struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long flags;
@@ -201,14 +212,27 @@ static void iounit_release_scsi_sgl(struct device *dev, struct scatterlist *sg,
 }
 
 #ifdef CONFIG_SBUS
-static int iounit_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned long va, unsigned long addr, int len)
+static void *iounit_alloc(struct device *dev, size_t len,
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         struct iounit_struct *iounit = dev->archdata.iommu;
-        unsigned long page, end;
+        unsigned long va, addr, page, end, ret;
         pgprot_t dvma_prot;
         iopte_t __iomem *iopte;
 
-        *pba = addr;
+        /* XXX So what is maxphys for us and how do drivers know it? */
+        if (!len || len > 256 * 1024)
+                return NULL;
+
+        len = PAGE_ALIGN(len);
+        va = __get_free_pages(gfp, get_order(len));
+        if (!va)
+                return NULL;
+
+        addr = ret = sparc_dma_alloc_resource(dev, len);
+        if (!addr)
+                goto out_free_pages;
+        *dma_handle = addr;
 
         dvma_prot = __pgprot(SRMMU_CACHE | SRMMU_ET_PTE | SRMMU_PRIV);
         end = PAGE_ALIGN((addr + len));
@@ -237,27 +261,32 @@ static int iounit_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned lon
         flush_cache_all();
         flush_tlb_all();
 
-        return 0;
+        return (void *)ret;
+
+out_free_pages:
+        free_pages(va, get_order(len));
+        return NULL;
 }
 
-static void iounit_unmap_dma_area(struct device *dev, unsigned long addr, int len)
+static void iounit_free(struct device *dev, size_t size, void *cpu_addr,
+                dma_addr_t dma_addr, unsigned long attrs)
 {
         /* XXX Somebody please fill this in */
 }
 #endif
 
-static const struct sparc32_dma_ops iounit_dma_ops = {
-        .get_scsi_one           = iounit_get_scsi_one,
-        .get_scsi_sgl           = iounit_get_scsi_sgl,
-        .release_scsi_one       = iounit_release_scsi_one,
-        .release_scsi_sgl       = iounit_release_scsi_sgl,
+static const struct dma_map_ops iounit_dma_ops = {
 #ifdef CONFIG_SBUS
-        .map_dma_area           = iounit_map_dma_area,
-        .unmap_dma_area         = iounit_unmap_dma_area,
+        .alloc                  = iounit_alloc,
+        .free                   = iounit_free,
 #endif
+        .map_page               = iounit_map_page,
+        .unmap_page             = iounit_unmap_page,
+        .map_sg                 = iounit_map_sg,
+        .unmap_sg               = iounit_unmap_sg,
 };
 
 void __init ld_mmu_iounit(void)
 {
-        sparc32_dma_ops = &iounit_dma_ops;
+        dma_ops = &iounit_dma_ops;
 }
diff --git a/arch/sparc/mm/iommu.c b/arch/sparc/mm/iommu.c
index 2c5f8a648f8c..3599485717e7 100644
--- a/arch/sparc/mm/iommu.c
+++ b/arch/sparc/mm/iommu.c
@@ -13,7 +13,7 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/highmem.h>      /* pte_offset_map => kmap_atomic */
-#include <linux/scatterlist.h>
+#include <linux/dma-mapping.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 
@@ -205,38 +205,44 @@ static u32 iommu_get_one(struct device *dev, struct page *page, int npages)
         return busa0;
 }
 
-static u32 iommu_get_scsi_one(struct device *dev, char *vaddr, unsigned int len)
+static dma_addr_t __sbus_iommu_map_page(struct device *dev, struct page *page,
+                unsigned long offset, size_t len)
 {
-        unsigned long off;
-        int npages;
-        struct page *page;
-        u32 busa;
-
-        off = (unsigned long)vaddr & ~PAGE_MASK;
-        npages = (off + len + PAGE_SIZE-1) >> PAGE_SHIFT;
-        page = virt_to_page((unsigned long)vaddr & PAGE_MASK);
-        busa = iommu_get_one(dev, page, npages);
-        return busa + off;
+        void *vaddr = page_address(page) + offset;
+        unsigned long off = (unsigned long)vaddr & ~PAGE_MASK;
+        unsigned long npages = (off + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        
+        /* XXX So what is maxphys for us and how do drivers know it? */
+        if (!len || len > 256 * 1024)
+                return DMA_MAPPING_ERROR;
+        return iommu_get_one(dev, virt_to_page(vaddr), npages) + off;
 }
 
-static __u32 iommu_get_scsi_one_gflush(struct device *dev, char *vaddr, unsigned long len)
+static dma_addr_t sbus_iommu_map_page_gflush(struct device *dev,
+                struct page *page, unsigned long offset, size_t len,
+                enum dma_data_direction dir, unsigned long attrs)
 {
         flush_page_for_dma(0);
-        return iommu_get_scsi_one(dev, vaddr, len);
+        return __sbus_iommu_map_page(dev, page, offset, len);
 }
 
-static __u32 iommu_get_scsi_one_pflush(struct device *dev, char *vaddr, unsigned long len)
+static dma_addr_t sbus_iommu_map_page_pflush(struct device *dev,
+                struct page *page, unsigned long offset, size_t len,
+                enum dma_data_direction dir, unsigned long attrs)
 {
-        unsigned long page = ((unsigned long) vaddr) & PAGE_MASK;
+        void *vaddr = page_address(page) + offset;
+        unsigned long p = ((unsigned long)vaddr) & PAGE_MASK;
 
-        while(page < ((unsigned long)(vaddr + len))) {
-                flush_page_for_dma(page);
-                page += PAGE_SIZE;
+        while (p < (unsigned long)vaddr + len) {
+                flush_page_for_dma(p);
+                p += PAGE_SIZE;
         }
-        return iommu_get_scsi_one(dev, vaddr, len);
+
+        return __sbus_iommu_map_page(dev, page, offset, len);
 }
 
-static void iommu_get_scsi_sgl_gflush(struct device *dev, struct scatterlist *sg, int sz)
+static int sbus_iommu_map_sg_gflush(struct device *dev, struct scatterlist *sg,
+                int sz, enum dma_data_direction dir, unsigned long attrs)
 {
         int n;
 
@@ -248,9 +254,12 @@ static void iommu_get_scsi_sgl_gflush(struct device *dev, struct scatterlist *sg
                 sg->dma_length = sg->length;
                 sg = sg_next(sg);
         }
+
+        return sz;
 }
 
-static void iommu_get_scsi_sgl_pflush(struct device *dev, struct scatterlist *sg, int sz)
+static int sbus_iommu_map_sg_pflush(struct device *dev, struct scatterlist *sg,
+                int sz, enum dma_data_direction dir, unsigned long attrs)
 {
         unsigned long page, oldpage = 0;
         int n, i;
@@ -279,6 +288,8 @@ static void iommu_get_scsi_sgl_pflush(struct device *dev, struct scatterlist *sg
                 sg->dma_length = sg->length;
                 sg = sg_next(sg);
         }
+
+        return sz;
 }
 
 static void iommu_release_one(struct device *dev, u32 busa, int npages)
@@ -297,23 +308,23 @@ static void iommu_release_one(struct device *dev, u32 busa, int npages)
         bit_map_clear(&iommu->usemap, ioptex, npages);
 }
 
-static void iommu_release_scsi_one(struct device *dev, __u32 vaddr, unsigned long len)
+static void sbus_iommu_unmap_page(struct device *dev, dma_addr_t dma_addr,
+                size_t len, enum dma_data_direction dir, unsigned long attrs)
 {
-        unsigned long off;
+        unsigned long off = dma_addr & ~PAGE_MASK;
         int npages;
 
-        off = vaddr & ~PAGE_MASK;
         npages = (off + len + PAGE_SIZE-1) >> PAGE_SHIFT;
-        iommu_release_one(dev, vaddr & PAGE_MASK, npages);
+        iommu_release_one(dev, dma_addr & PAGE_MASK, npages);
 }
 
-static void iommu_release_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
+static void sbus_iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
+                int sz, enum dma_data_direction dir, unsigned long attrs)
 {
         int n;
 
         while(sz != 0) {
                 --sz;
-
                 n = (sg->length + sg->offset + PAGE_SIZE-1) >> PAGE_SHIFT;
                 iommu_release_one(dev, sg->dma_address & PAGE_MASK, n);
                 sg->dma_address = 0x21212121;
@@ -322,15 +333,28 @@ static void iommu_release_scsi_sgl(struct device *dev, struct scatterlist *sg, i
 }
 
 #ifdef CONFIG_SBUS
-static int iommu_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned long va,
-                              unsigned long addr, int len)
+static void *sbus_iommu_alloc(struct device *dev, size_t len,
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         struct iommu_struct *iommu = dev->archdata.iommu;
-        unsigned long page, end;
+        unsigned long va, addr, page, end, ret;
         iopte_t *iopte = iommu->page_table;
         iopte_t *first;
         int ioptex;
 
+        /* XXX So what is maxphys for us and how do drivers know it? */
+        if (!len || len > 256 * 1024)
+                return NULL;
+
+        len = PAGE_ALIGN(len);
+        va = __get_free_pages(gfp, get_order(len));
+        if (va == 0)
+                return NULL;
+
+        addr = ret = sparc_dma_alloc_resource(dev, len);
+        if (!addr)
+                goto out_free_pages;
+
         BUG_ON((va & ~PAGE_MASK) != 0);
         BUG_ON((addr & ~PAGE_MASK) != 0);
         BUG_ON((len & ~PAGE_MASK) != 0);
@@ -385,16 +409,25 @@ static int iommu_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned long
         flush_tlb_all();
         iommu_invalidate(iommu->regs);
 
-        *pba = iommu->start + (ioptex << PAGE_SHIFT);
-        return 0;
+        *dma_handle = iommu->start + (ioptex << PAGE_SHIFT);
+        return (void *)ret;
+
+out_free_pages:
+        free_pages(va, get_order(len));
+        return NULL;
 }
 
-static void iommu_unmap_dma_area(struct device *dev, unsigned long busa, int len)
+static void sbus_iommu_free(struct device *dev, size_t len, void *cpu_addr,
+                               dma_addr_t busa, unsigned long attrs)
 {
         struct iommu_struct *iommu = dev->archdata.iommu;
         iopte_t *iopte = iommu->page_table;
-        unsigned long end;
+        struct page *page = virt_to_page(cpu_addr);
         int ioptex = (busa - iommu->start) >> PAGE_SHIFT;
+        unsigned long end;
+
+        if (!sparc_dma_free_resource(cpu_addr, len))
+                return;
 
         BUG_ON((busa & ~PAGE_MASK) != 0);
         BUG_ON((len & ~PAGE_MASK) != 0);
@@ -408,38 +441,40 @@ static void iommu_unmap_dma_area(struct device *dev, unsigned long busa, int len
         flush_tlb_all();
         iommu_invalidate(iommu->regs);
         bit_map_clear(&iommu->usemap, ioptex, len >> PAGE_SHIFT);
+
+        __free_pages(page, get_order(len));
 }
 #endif
 
-static const struct sparc32_dma_ops iommu_dma_gflush_ops = {
-        .get_scsi_one           = iommu_get_scsi_one_gflush,
-        .get_scsi_sgl           = iommu_get_scsi_sgl_gflush,
-        .release_scsi_one       = iommu_release_scsi_one,
-        .release_scsi_sgl       = iommu_release_scsi_sgl,
+static const struct dma_map_ops sbus_iommu_dma_gflush_ops = {
 #ifdef CONFIG_SBUS
-        .map_dma_area           = iommu_map_dma_area,
-        .unmap_dma_area         = iommu_unmap_dma_area,
+        .alloc                  = sbus_iommu_alloc,
+        .free                   = sbus_iommu_free,
 #endif
+        .map_page               = sbus_iommu_map_page_gflush,
+        .unmap_page             = sbus_iommu_unmap_page,
+        .map_sg                 = sbus_iommu_map_sg_gflush,
+        .unmap_sg               = sbus_iommu_unmap_sg,
 };
 
-static const struct sparc32_dma_ops iommu_dma_pflush_ops = {
-        .get_scsi_one           = iommu_get_scsi_one_pflush,
-        .get_scsi_sgl           = iommu_get_scsi_sgl_pflush,
-        .release_scsi_one       = iommu_release_scsi_one,
-        .release_scsi_sgl       = iommu_release_scsi_sgl,
+static const struct dma_map_ops sbus_iommu_dma_pflush_ops = {
 #ifdef CONFIG_SBUS
-        .map_dma_area           = iommu_map_dma_area,
-        .unmap_dma_area         = iommu_unmap_dma_area,
+        .alloc                  = sbus_iommu_alloc,
+        .free                   = sbus_iommu_free,
 #endif
+        .map_page               = sbus_iommu_map_page_pflush,
+        .unmap_page             = sbus_iommu_unmap_page,
+        .map_sg                 = sbus_iommu_map_sg_pflush,
+        .unmap_sg               = sbus_iommu_unmap_sg,
 };
 
 void __init ld_mmu_iommu(void)
 {
         if (flush_page_for_dma_global) {
                 /* flush_page_for_dma flushes everything, no matter of what page is it */
-                sparc32_dma_ops = &iommu_dma_gflush_ops;
+                dma_ops = &sbus_iommu_dma_gflush_ops;
         } else {
-                sparc32_dma_ops = &iommu_dma_pflush_ops;
+                dma_ops = &sbus_iommu_dma_pflush_ops;
         }
 
         if (viking_mxcc_present || srmmu_modtype == HyperSparc) {