powerpc: Override dma_get_required_mask by platform hook and ops

The hook dma_get_required_mask is supposed to return the mask required
by the platform to operate efficently.  The generic version of
dma_get_required_mask in driver/base/platform.c returns a mask based
only on max_pfn.  However, this is likely too big for iommu systems
and could be too small for platforms that require a dma offset or have
a secondary window at a high offset.

Override the default, provide a hook in ppc_md used by pseries lpar and
cell, and provide the default answer based on memblock_end_of_DRAM(),
with hooks for get_dma_offset, and provide an implementation for iommu
that looks at the defined table size.  Coverting from the end address
to the required bit mask is based on the generic implementation.

The need for this was discovered when the qla2xxx driver switched to
64 bit dma then reverted to 32 bit when dma_get_required_mask said
32 bits was sufficient.

Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: Nishanth Aravamudan <nacc@us.ibm.com>
Cc: linuxppc-dev@lists.ozlabs.org
Cc: linux-kernel@vger.kernel.org
Cc: benh@kernel.crashing.org
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>

2 files changed, 52 insertions, 0 deletions

diff --git a/arch/powerpc/kernel/dma-iommu.c b/arch/powerpc/kernel/dma-iommu.c
index e7554154a6de..1f2a711a261e 100644
--- a/arch/powerpc/kernel/dma-iommu.c
+++ b/arch/powerpc/kernel/dma-iommu.c
@@ -90,6 +90,19 @@ static int dma_iommu_dma_supported(struct device *dev, u64 mask)
                 return 1;
 }
 
+u64 dma_iommu_get_required_mask(struct device *dev)
+{
+        struct iommu_table *tbl = get_iommu_table_base(dev);
+        u64 mask;
+        if (!tbl)
+                return 0;
+
+        mask = 1ULL < (fls_long(tbl->it_offset + tbl->it_size) - 1);
+        mask += mask - 1;
+
+        return mask;
+}
+
 struct dma_map_ops dma_iommu_ops = {
         .alloc_coherent = dma_iommu_alloc_coherent,
         .free_coherent  = dma_iommu_free_coherent,
diff --git a/arch/powerpc/kernel/dma.c b/arch/powerpc/kernel/dma.c
index 4f0959fbfbee..503093efa202 100644
--- a/arch/powerpc/kernel/dma.c
+++ b/arch/powerpc/kernel/dma.c
@@ -170,6 +170,45 @@ int dma_set_mask(struct device *dev, u64 dma_mask)
 }
 EXPORT_SYMBOL(dma_set_mask);
 
+u64 dma_get_required_mask(struct device *dev)
+{
+        struct dma_map_ops *dma_ops = get_dma_ops(dev);
+        u64 mask, end = 0;
+
+        if (ppc_md.dma_get_required_mask)
+                return ppc_md.dma_get_required_mask(dev);
+
+        if (unlikely(dma_ops == NULL))
+                return 0;
+
+#ifdef CONFIG_PPC64
+        else if (dma_ops == &dma_iommu_ops)
+                return dma_iommu_get_required_mask(dev);
+#endif
+#ifdef CONFIG_SWIOTLB
+        else if (dma_ops == &swiotlb_dma_ops) {
+                u64 max_direct_dma_addr = dev->archdata.max_direct_dma_addr;
+
+                end = memblock_end_of_DRAM();
+                if (max_direct_dma_addr && end > max_direct_dma_addr)
+                        end = max_direct_dma_addr;
+                end += get_dma_offset(dev);
+        }
+#endif
+        else if (dma_ops == &dma_direct_ops)
+                end = memblock_end_of_DRAM() + get_dma_offset(dev);
+        else {
+                WARN_ONCE(1, "%s: unknown ops %p\n", __func__, dma_ops);
+                end = memblock_end_of_DRAM();
+        }
+
+        mask = 1ULL << (fls64(end) - 1);
+        mask += mask - 1;
+
+        return mask;
+}
+EXPORT_SYMBOL_GPL(dma_get_required_mask);
+
 static int __init dma_init(void)
 {
        dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);