#ifndef ___ASM_SPARC_DMA_MAPPING_H
 #define ___ASM_SPARC_DMA_MAPPING_H
 
-#include <asm/cpu_type.h>
-
 extern const struct dma_map_ops *dma_ops;
 
-extern struct bus_type pci_bus_type;
-
 static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus)
 {
-#ifdef CONFIG_SPARC_LEON
-       if (sparc_cpu_model == sparc_leon)
-               return NULL;
-#endif
-#if defined(CONFIG_SPARC32) && defined(CONFIG_PCI)
-       if (bus == &pci_bus_type)
-               return NULL;
-#endif
-       return dma_ops;
+       /* sparc32 uses per-device dma_ops */
+       return IS_ENABLED(CONFIG_SPARC64) ? dma_ops : NULL;
 }
 
 #endif
 
                dma_make_coherent(paddr, PAGE_ALIGN(size));
 }
 
-const struct dma_map_ops *dma_ops;
-EXPORT_SYMBOL(dma_ops);
-
 #ifdef CONFIG_PROC_FS
 
 static int sparc_io_proc_show(struct seq_file *m, void *v)
 
                op->dev.archdata.stc = bus_sd->stc;
                op->dev.archdata.host_controller = bus_sd->host_controller;
                op->dev.archdata.numa_node = bus_sd->numa_node;
+               op->dev.dma_ops = bus->dev.dma_ops;
 
                if (dp->child)
                        of_propagate_archdata(op);
 
 #define IOPERM        (IOUPTE_CACHE | IOUPTE_WRITE | IOUPTE_VALID)
 #define MKIOPTE(phys) __iopte((((phys)>>4) & IOUPTE_PAGE) | IOPERM)
 
+static const struct dma_map_ops iounit_dma_ops;
+
 static void __init iounit_iommu_init(struct platform_device *op)
 {
        struct iounit_struct *iounit;
        xptend = iounit->page_table + (16 * PAGE_SIZE) / sizeof(iopte_t);
        for (; xpt < xptend; xpt++)
                sbus_writel(0, xpt);
+
+       op->dev.dma_ops = &iounit_dma_ops;
 }
 
 static int __init iounit_init(void)
        .map_sg                 = iounit_map_sg,
        .unmap_sg               = iounit_unmap_sg,
 };
-
-void __init ld_mmu_iounit(void)
-{
-       dma_ops = &iounit_dma_ops;
-}
 
 #define IOPERM        (IOPTE_CACHE | IOPTE_WRITE | IOPTE_VALID)
 #define MKIOPTE(pfn, perm) (((((pfn)<<8) & IOPTE_PAGE) | (perm)) & ~IOPTE_WAZ)
 
+static const struct dma_map_ops sbus_iommu_dma_gflush_ops;
+static const struct dma_map_ops sbus_iommu_dma_pflush_ops;
+
 static void __init sbus_iommu_init(struct platform_device *op)
 {
        struct iommu_struct *iommu;
               (int)(IOMMU_NPTES*sizeof(iopte_t)), (int)IOMMU_NPTES);
 
        op->dev.archdata.iommu = iommu;
+
+       if (flush_page_for_dma_global)
+               op->dev.dma_ops = &sbus_iommu_dma_gflush_ops;
+        else
+               op->dev.dma_ops = &sbus_iommu_dma_pflush_ops;
 }
 
 static int __init iommu_init(void)
 
 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 */
-               dma_ops = &sbus_iommu_dma_gflush_ops;
-       } else {
-               dma_ops = &sbus_iommu_dma_pflush_ops;
-       }
-
        if (viking_mxcc_present || srmmu_modtype == HyperSparc) {
                dvma_prot = __pgprot(SRMMU_CACHE | SRMMU_ET_PTE | SRMMU_PRIV);
                ioperm_noc = IOPTE_CACHE | IOPTE_WRITE | IOPTE_VALID;
 
 
 /* iommu.c */
 void ld_mmu_iommu(void);
-
-/* io-unit.c */
-void ld_mmu_iounit(void);
 
                &smp_cachetlb_ops;
 #endif
 
-       if (sparc_cpu_model == sun4d)
-               ld_mmu_iounit();
-       else
+       if (sparc_cpu_model != sun4d)
                ld_mmu_iommu();
 #ifdef CONFIG_SMP
        if (sparc_cpu_model == sun4d)