sh: declared coherent memory support V2

This patch adds declared coherent memory support to the sh architecture. All
functions are based on the x86 implementation. Header files are adjusted to
use the new functions instead of the former consistent_alloc() code.

This version includes the few changes what were included in the fix patch
together with modifications based on feedback from Paul.

Signed-off-by: Magnus Damm <damm@igel.co.jp>
Signed-off-by: Paul Mundt <lethal@linux-sh.org>

1 files changed, 128 insertions, 46 deletions

diff --git a/arch/sh/mm/consistent.c b/arch/sh/mm/consistent.c
index 65ad30031ad7..7b2131c9eeda 100644
--- a/arch/sh/mm/consistent.c
+++ b/arch/sh/mm/consistent.c
@@ -3,6 +3,8 @@
  *
  * Copyright (C) 2004 - 2007  Paul Mundt
  *
+ * Declared coherent memory functions based on arch/x86/kernel/pci-dma_32.c
+ *
  * 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.
@@ -13,66 +15,146 @@
 #include <asm/addrspace.h>
 #include <asm/io.h>
 
-void *consistent_alloc(gfp_t gfp, size_t size, dma_addr_t *handle)
-{
-        struct page *page, *end, *free;
-        void *ret, *vp;
-        int order;
-
-        size = PAGE_ALIGN(size);
-        order = get_order(size);
+struct dma_coherent_mem {
+        void            *virt_base;
+        u32             device_base;
+        int             size;
+        int             flags;
+        unsigned long   *bitmap;
+};
 
-        page = alloc_pages(gfp, order);
-        if (!page)
-                return NULL;
-        split_page(page, order);
+void *dma_alloc_coherent(struct device *dev, size_t size,
+                           dma_addr_t *dma_handle, gfp_t gfp)
+{
+        void *ret;
+        struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
+        int order = get_order(size);
+
+        if (mem) {
+                int page = bitmap_find_free_region(mem->bitmap, mem->size,
+                                                     order);
+                if (page >= 0) {
+                        *dma_handle = mem->device_base + (page << PAGE_SHIFT);
+                        ret = mem->virt_base + (page << PAGE_SHIFT);
+                        memset(ret, 0, size);
+                        return ret;
+                }
+                if (mem->flags & DMA_MEMORY_EXCLUSIVE)
+                        return NULL;
+        }
 
-        ret = page_address(page);
-        *handle = virt_to_phys(ret);
+        ret = (void *)__get_free_pages(gfp, order);
 
-        vp = ioremap_nocache(*handle, size);
-        if (!vp) {
-                free_pages((unsigned long)ret, order);
-                return NULL;
+        if (ret != NULL) {
+                memset(ret, 0, size);
+                /*
+                 * Pages from the page allocator may have data present in
+                 * cache. So flush the cache before using uncached memory.
+                 */
+                dma_cache_sync(NULL, ret, size, DMA_BIDIRECTIONAL);
+                *dma_handle = virt_to_phys(ret);
         }
+        return ret;
+}
+EXPORT_SYMBOL(dma_alloc_coherent);
 
-        memset(vp, 0, size);
-
-        /*
-         * We must flush the cache before we pass it on to the device
-         */
-        dma_cache_sync(NULL, ret, size, DMA_BIDIRECTIONAL);
+void dma_free_coherent(struct device *dev, size_t size,
+                         void *vaddr, dma_addr_t dma_handle)
+{
+        struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
+        int order = get_order(size);
 
-        page = virt_to_page(ret);
-        free = page + (size >> PAGE_SHIFT);
-        end  = page + (1 << order);
+        if (mem && vaddr >= mem->virt_base && vaddr < (mem->virt_base + (mem->size << PAGE_SHIFT))) {
+                int page = (vaddr - mem->virt_base) >> PAGE_SHIFT;
 
-        while (++page < end) {
-                /* Free any unused pages */
-                if (page >= free) {
-                        __free_page(page);
-                }
+                bitmap_release_region(mem->bitmap, page, order);
+        } else {
+                WARN_ON(irqs_disabled());       /* for portability */
+                BUG_ON(mem && mem->flags & DMA_MEMORY_EXCLUSIVE);
+                free_pages((unsigned long)vaddr, order);
         }
-
-        return vp;
 }
-EXPORT_SYMBOL(consistent_alloc);
+EXPORT_SYMBOL(dma_free_coherent);
 
-void consistent_free(void *vaddr, size_t size, dma_addr_t dma_handle)
+int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
+                                dma_addr_t device_addr, size_t size, int flags)
 {
-        struct page *page;
-        unsigned long addr;
-
-        addr = (unsigned long)phys_to_virt((unsigned long)dma_handle);
-        page = virt_to_page(addr);
+        void __iomem *mem_base = NULL;
+        int pages = size >> PAGE_SHIFT;
+        int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
+
+        if ((flags & (DMA_MEMORY_MAP | DMA_MEMORY_IO)) == 0)
+                goto out;
+        if (!size)
+                goto out;
+        if (dev->dma_mem)
+                goto out;
+
+        /* FIXME: this routine just ignores DMA_MEMORY_INCLUDES_CHILDREN */
+
+        mem_base = ioremap_nocache(bus_addr, size);
+        if (!mem_base)
+                goto out;
+
+        dev->dma_mem = kmalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
+        if (!dev->dma_mem)
+                goto out;
+        dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
+        if (!dev->dma_mem->bitmap)
+                goto free1_out;
+
+        dev->dma_mem->virt_base = mem_base;
+        dev->dma_mem->device_base = device_addr;
+        dev->dma_mem->size = pages;
+        dev->dma_mem->flags = flags;
+
+        if (flags & DMA_MEMORY_MAP)
+                return DMA_MEMORY_MAP;
+
+        return DMA_MEMORY_IO;
+
+ free1_out:
+        kfree(dev->dma_mem);
+ out:
+        if (mem_base)
+                iounmap(mem_base);
+        return 0;
+}
+EXPORT_SYMBOL(dma_declare_coherent_memory);
 
-        free_pages(addr, get_order(size));
+void dma_release_declared_memory(struct device *dev)
+{
+        struct dma_coherent_mem *mem = dev->dma_mem;
+
+        if (!mem)
+                return;
+        dev->dma_mem = NULL;
+        iounmap(mem->virt_base);
+        kfree(mem->bitmap);
+        kfree(mem);
+}
+EXPORT_SYMBOL(dma_release_declared_memory);
 
-        iounmap(vaddr);
+void *dma_mark_declared_memory_occupied(struct device *dev,
+                                        dma_addr_t device_addr, size_t size)
+{
+        struct dma_coherent_mem *mem = dev->dma_mem;
+        int pages = (size + (device_addr & ~PAGE_MASK) + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        int pos, err;
+
+        if (!mem)
+                return ERR_PTR(-EINVAL);
+
+        pos = (device_addr - mem->device_base) >> PAGE_SHIFT;
+        err = bitmap_allocate_region(mem->bitmap, pos, get_order(pages));
+        if (err != 0)
+                return ERR_PTR(err);
+        return mem->virt_base + (pos << PAGE_SHIFT);
 }
-EXPORT_SYMBOL(consistent_free);
+EXPORT_SYMBOL(dma_mark_declared_memory_occupied);
 
-void consistent_sync(void *vaddr, size_t size, int direction)
+void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
+                    enum dma_data_direction direction)
 {
 #ifdef CONFIG_CPU_SH5
         void *p1addr = vaddr;
@@ -94,4 +176,4 @@ void consistent_sync(void *vaddr, size_t size, int direction)
                 BUG();
         }
 }
-EXPORT_SYMBOL(consistent_sync);
+EXPORT_SYMBOL(dma_cache_sync);