Patched in Tegra support.

1 files changed, 27 insertions, 74 deletions

diff --git a/arch/arm/common/dmabounce.c b/arch/arm/common/dmabounce.c
index 1143c4d5c56..595ecd290eb 100644
--- a/arch/arm/common/dmabounce.c
+++ b/arch/arm/common/dmabounce.c
@@ -173,8 +173,7 @@ find_safe_buffer(struct dmabounce_device_info *device_info, dma_addr_t safe_dma_
         read_lock_irqsave(&device_info->lock, flags);
 
         list_for_each_entry(b, &device_info->safe_buffers, node)
-                if (b->safe_dma_addr <= safe_dma_addr &&
-                    b->safe_dma_addr + b->size > safe_dma_addr) {
+                if (b->safe_dma_addr == safe_dma_addr) {
                         rb = b;
                         break;
                 }
@@ -255,7 +254,7 @@ static inline dma_addr_t map_single(struct device *dev, void *ptr, size_t size,
         if (buf == NULL) {
                 dev_err(dev, "%s: unable to map unsafe buffer %p!\n",
                        __func__, ptr);
-                return DMA_ERROR_CODE;
+                return ~0;
         }
 
         dev_dbg(dev, "%s: unsafe buffer %p (dma=%#x) mapped to %p (dma=%#x)\n",
@@ -308,9 +307,8 @@ static inline void unmap_single(struct device *dev, struct safe_buffer *buf,
  * substitute the safe buffer for the unsafe one.
  * (basically move the buffer from an unsafe area to a safe one)
  */
-static dma_addr_t dmabounce_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_map_page(struct device *dev, struct page *page,
+                unsigned long offset, size_t size, enum dma_data_direction dir)
 {
         dma_addr_t dma_addr;
         int ret;
@@ -322,20 +320,21 @@ static dma_addr_t dmabounce_map_page(struct device *dev, struct page *page,
 
         ret = needs_bounce(dev, dma_addr, size);
         if (ret < 0)
-                return DMA_ERROR_CODE;
+                return ~0;
 
         if (ret == 0) {
-                arm_dma_ops.sync_single_for_device(dev, dma_addr, size, dir);
+                __dma_page_cpu_to_dev(page, offset, size, dir);
                 return dma_addr;
         }
 
         if (PageHighMem(page)) {
                 dev_err(dev, "DMA buffer bouncing of HIGHMEM pages is not supported\n");
-                return DMA_ERROR_CODE;
+                return ~0;
         }
 
         return map_single(dev, page_address(page) + offset, size, dir);
 }
+EXPORT_SYMBOL(__dma_map_page);
 
 /*
  * see if a mapped address was really a "safe" buffer and if so, copy
@@ -343,8 +342,8 @@ static dma_addr_t dmabounce_map_page(struct device *dev, struct page *page,
  * the safe buffer.  (basically return things back to the way they
  * should be)
  */
-static void dmabounce_unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
-                enum dma_data_direction dir, struct dma_attrs *attrs)
+void __dma_unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
+                enum dma_data_direction dir)
 {
         struct safe_buffer *buf;
 
@@ -353,32 +352,31 @@ static void dmabounce_unmap_page(struct device *dev, dma_addr_t dma_addr, size_t
 
         buf = find_safe_buffer_dev(dev, dma_addr, __func__);
         if (!buf) {
-                arm_dma_ops.sync_single_for_cpu(dev, dma_addr, size, dir);
+                __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, dma_addr)),
+                        dma_addr & ~PAGE_MASK, size, dir);
                 return;
         }
 
         unmap_single(dev, buf, size, dir);
 }
+EXPORT_SYMBOL(__dma_unmap_page);
 
-static int __dmabounce_sync_for_cpu(struct device *dev, dma_addr_t addr,
-                size_t sz, enum dma_data_direction dir)
+int dmabounce_sync_for_cpu(struct device *dev, dma_addr_t addr,
+                unsigned long off, size_t sz, enum dma_data_direction dir)
 {
         struct safe_buffer *buf;
-        unsigned long off;
 
-        dev_dbg(dev, "%s(dma=%#x,sz=%zx,dir=%x)\n",
-                __func__, addr, sz, dir);
+        dev_dbg(dev, "%s(dma=%#x,off=%#lx,sz=%zx,dir=%x)\n",
+                __func__, addr, off, sz, dir);
 
         buf = find_safe_buffer_dev(dev, addr, __func__);
         if (!buf)
                 return 1;
 
-        off = addr - buf->safe_dma_addr;
-
         BUG_ON(buf->direction != dir);
 
-        dev_dbg(dev, "%s: unsafe buffer %p (dma=%#x off=%#lx) mapped to %p (dma=%#x)\n",
-                __func__, buf->ptr, virt_to_dma(dev, buf->ptr), off,
+        dev_dbg(dev, "%s: unsafe buffer %p (dma=%#x) mapped to %p (dma=%#x)\n",
+                __func__, buf->ptr, virt_to_dma(dev, buf->ptr),
                 buf->safe, buf->safe_dma_addr);
 
         DO_STATS(dev->archdata.dmabounce->bounce_count++);
@@ -390,35 +388,24 @@ static int __dmabounce_sync_for_cpu(struct device *dev, dma_addr_t addr,
         }
         return 0;
 }
+EXPORT_SYMBOL(dmabounce_sync_for_cpu);
 
-static void dmabounce_sync_for_cpu(struct device *dev,
-                dma_addr_t handle, size_t size, enum dma_data_direction dir)
-{
-        if (!__dmabounce_sync_for_cpu(dev, handle, size, dir))
-                return;
-
-        arm_dma_ops.sync_single_for_cpu(dev, handle, size, dir);
-}
-
-static int __dmabounce_sync_for_device(struct device *dev, dma_addr_t addr,
-                size_t sz, enum dma_data_direction dir)
+int dmabounce_sync_for_device(struct device *dev, dma_addr_t addr,
+                unsigned long off, size_t sz, enum dma_data_direction dir)
 {
         struct safe_buffer *buf;
-        unsigned long off;
 
-        dev_dbg(dev, "%s(dma=%#x,sz=%zx,dir=%x)\n",
-                __func__, addr, sz, dir);
+        dev_dbg(dev, "%s(dma=%#x,off=%#lx,sz=%zx,dir=%x)\n",
+                __func__, addr, off, sz, dir);
 
         buf = find_safe_buffer_dev(dev, addr, __func__);
         if (!buf)
                 return 1;
 
-        off = addr - buf->safe_dma_addr;
-
         BUG_ON(buf->direction != dir);
 
-        dev_dbg(dev, "%s: unsafe buffer %p (dma=%#x off=%#lx) mapped to %p (dma=%#x)\n",
-                __func__, buf->ptr, virt_to_dma(dev, buf->ptr), off,
+        dev_dbg(dev, "%s: unsafe buffer %p (dma=%#x) mapped to %p (dma=%#x)\n",
+                __func__, buf->ptr, virt_to_dma(dev, buf->ptr),
                 buf->safe, buf->safe_dma_addr);
 
         DO_STATS(dev->archdata.dmabounce->bounce_count++);
@@ -430,39 +417,7 @@ static int __dmabounce_sync_for_device(struct device *dev, dma_addr_t addr,
         }
         return 0;
 }
-
-static void dmabounce_sync_for_device(struct device *dev,
-                dma_addr_t handle, size_t size, enum dma_data_direction dir)
-{
-        if (!__dmabounce_sync_for_device(dev, handle, size, dir))
-                return;
-
-        arm_dma_ops.sync_single_for_device(dev, handle, size, dir);
-}
-
-static int dmabounce_set_mask(struct device *dev, u64 dma_mask)
-{
-        if (dev->archdata.dmabounce)
-                return 0;
-
-        return arm_dma_ops.set_dma_mask(dev, dma_mask);
-}
-
-static struct dma_map_ops dmabounce_ops = {
-        .alloc                  = arm_dma_alloc,
-        .free                   = arm_dma_free,
-        .mmap                   = arm_dma_mmap,
-        .get_sgtable            = arm_dma_get_sgtable,
-        .map_page               = dmabounce_map_page,
-        .unmap_page             = dmabounce_unmap_page,
-        .sync_single_for_cpu    = dmabounce_sync_for_cpu,
-        .sync_single_for_device = dmabounce_sync_for_device,
-        .map_sg                 = arm_dma_map_sg,
-        .unmap_sg               = arm_dma_unmap_sg,
-        .sync_sg_for_cpu        = arm_dma_sync_sg_for_cpu,
-        .sync_sg_for_device     = arm_dma_sync_sg_for_device,
-        .set_dma_mask           = dmabounce_set_mask,
-};
+EXPORT_SYMBOL(dmabounce_sync_for_device);
 
 static int dmabounce_init_pool(struct dmabounce_pool *pool, struct device *dev,
                 const char *name, unsigned long size)
@@ -524,7 +479,6 @@ int dmabounce_register_dev(struct device *dev, unsigned long small_buffer_size,
 #endif
 
         dev->archdata.dmabounce = device_info;
-        set_dma_ops(dev, &dmabounce_ops);
 
         dev_info(dev, "dmabounce: registered device\n");
 
@@ -543,7 +497,6 @@ void dmabounce_unregister_dev(struct device *dev)
         struct dmabounce_device_info *device_info = dev->archdata.dmabounce;
 
         dev->archdata.dmabounce = NULL;
-        set_dma_ops(dev, NULL);
 
         if (!device_info) {
                 dev_warn(dev,