powerpc: Update remaining dma_mapping_ops to use map/unmap_page

After the merge of the 32 and 64bit DMA code, dma_direct_ops lost
their map/unmap_single() functions but gained map/unmap_page().  This
caused a problem for Cell because Cell's dma_iommu_fixed_ops called
the dma_direct_ops if the fixed linear mapping was to be used or the
iommu ops if the dynamic window was to be used.  So in order to fix
this problem we need to update the 64bit DMA code to use
map/unmap_page.

First, we update the generic IOMMU code so that iommu_map_single()
becomes iommu_map_page() and iommu_unmap_single() becomes
iommu_unmap_page().  Then we propagate these changes up through all
the callers of these two functions and in the process update all the
dma_mapping_ops so that they have map/unmap_page rahter than
map/unmap_single.  We can do this because on 64bit there is no HIGHMEM
memory so map/unmap_page ends up performing exactly the same function
as map/unmap_single, just taking different arguments.

This has no affect on drivers because the dma_map_single_attrs() just
ends up calling the map_page() function of the appropriate
dma_mapping_ops and similarly the dma_unmap_single_attrs() calls
unmap_page().

This fixes an oops on Cell blades, which oops on boot without this
because they call dma_direct_ops.map_single, which is NULL.

Signed-off-by: Mark Nelson <markn@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>

1 files changed, 19 insertions, 17 deletions

diff --git a/arch/powerpc/platforms/ps3/system-bus.c b/arch/powerpc/platforms/ps3/system-bus.c
index a789bf58ca8b..661e9f77ebf6 100644
--- a/arch/powerpc/platforms/ps3/system-bus.c
+++ b/arch/powerpc/platforms/ps3/system-bus.c
@@ -555,18 +555,19 @@ static void ps3_free_coherent(struct device *_dev, size_t size, void *vaddr,
 }
 
 /* Creates TCEs for a user provided buffer.  The user buffer must be
- * contiguous real kernel storage (not vmalloc).  The address of the buffer
- * passed here is the kernel (virtual) address of the buffer.  The buffer
- * need not be page aligned, the dma_addr_t returned will point to the same
- * byte within the page as vaddr.
+ * contiguous real kernel storage (not vmalloc).  The address passed here
+ * comprises a page address and offset into that page. The dma_addr_t
+ * returned will point to the same byte within the page as was passed in.
  */
 
-static dma_addr_t ps3_sb_map_single(struct device *_dev, void *ptr, size_t size,
-        enum dma_data_direction direction, struct dma_attrs *attrs)
+static dma_addr_t ps3_sb_map_page(struct device *_dev, struct page *page,
+        unsigned long offset, size_t size, enum dma_data_direction direction,
+        struct dma_attrs *attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
         int result;
         unsigned long bus_addr;
+        void *ptr = page_address(page) + offset;
 
         result = ps3_dma_map(dev->d_region, (unsigned long)ptr, size,
                              &bus_addr,
@@ -580,15 +581,16 @@ static dma_addr_t ps3_sb_map_single(struct device *_dev, void *ptr, size_t size,
         return bus_addr;
 }
 
-static dma_addr_t ps3_ioc0_map_single(struct device *_dev, void *ptr,
-                                      size_t size,
-                                      enum dma_data_direction direction,
-                                      struct dma_attrs *attrs)
+static dma_addr_t ps3_ioc0_map_page(struct device *_dev, struct page *page,
+                                    unsigned long offset, size_t size,
+                                    enum dma_data_direction direction,
+                                    struct dma_attrs *attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
         int result;
         unsigned long bus_addr;
         u64 iopte_flag;
+        void *ptr = page_address(page) + offset;
 
         iopte_flag = IOPTE_M;
         switch (direction) {
@@ -615,7 +617,7 @@ static dma_addr_t ps3_ioc0_map_single(struct device *_dev, void *ptr,
         return bus_addr;
 }
 
-static void ps3_unmap_single(struct device *_dev, dma_addr_t dma_addr,
+static void ps3_unmap_page(struct device *_dev, dma_addr_t dma_addr,
         size_t size, enum dma_data_direction direction, struct dma_attrs *attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
@@ -689,21 +691,21 @@ static int ps3_dma_supported(struct device *_dev, u64 mask)
 static struct dma_mapping_ops ps3_sb_dma_ops = {
         .alloc_coherent = ps3_alloc_coherent,
         .free_coherent = ps3_free_coherent,
-        .map_single = ps3_sb_map_single,
-        .unmap_single = ps3_unmap_single,
         .map_sg = ps3_sb_map_sg,
         .unmap_sg = ps3_sb_unmap_sg,
-        .dma_supported = ps3_dma_supported
+        .dma_supported = ps3_dma_supported,
+        .map_page = ps3_sb_map_page,
+        .unmap_page = ps3_unmap_page,
 };
 
 static struct dma_mapping_ops ps3_ioc0_dma_ops = {
         .alloc_coherent = ps3_alloc_coherent,
         .free_coherent = ps3_free_coherent,
-        .map_single = ps3_ioc0_map_single,
-        .unmap_single = ps3_unmap_single,
         .map_sg = ps3_ioc0_map_sg,
         .unmap_sg = ps3_ioc0_unmap_sg,
-        .dma_supported = ps3_dma_supported
+        .dma_supported = ps3_dma_supported,
+        .map_page = ps3_ioc0_map_page,
+        .unmap_page = ps3_unmap_page,
 };
 
 /**