config FSL_PCI
        bool
+       select ARCH_HAS_DMA_SET_MASK
        select PPC_INDIRECT_PCI
        select PCI_QUIRKS
 
 
                dev->archdata.dma_offset = off;
 }
 
-#define HAVE_ARCH_DMA_SET_MASK 1
-
 #endif /* __KERNEL__ */
 #endif /* _ASM_DMA_MAPPING_H */
 
 #endif
 #endif /* CONFIG_PPC64 */
 
-       int             (*dma_set_mask)(struct device *dev, u64 dma_mask);
+       void            (*dma_set_mask)(struct device *dev, u64 dma_mask);
 
        int             (*probe)(void);
        void            (*setup_arch)(void); /* Optional, may be NULL */
 
 obj-$(CONFIG_PPC_UDBG_16550)   += legacy_serial.o udbg_16550.o
 obj-$(CONFIG_STACKTRACE)       += stacktrace.o
 obj-$(CONFIG_SWIOTLB)          += dma-swiotlb.o
+obj-$(CONFIG_ARCH_HAS_DMA_SET_MASK) += dma-mask.o
 
 pci64-$(CONFIG_PPC64)          += pci_dn.o pci-hotplug.o isa-bridge.o
 obj-$(CONFIG_PCI)              += pci_$(BITS).o $(pci64-y) \
 
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/dma-mapping.h>
+#include <linux/export.h>
+#include <asm/machdep.h>
+
+void arch_dma_set_mask(struct device *dev, u64 dma_mask)
+{
+       if (ppc_md.dma_set_mask)
+               ppc_md.dma_set_mask(dev, dma_mask);
+}
+EXPORT_SYMBOL(arch_dma_set_mask);
 
 };
 EXPORT_SYMBOL(dma_nommu_ops);
 
-int dma_set_mask(struct device *dev, u64 dma_mask)
-{
-       if (ppc_md.dma_set_mask)
-               return ppc_md.dma_set_mask(dev, dma_mask);
-
-       if (!dev->dma_mask || !dma_supported(dev, dma_mask))
-               return -EIO;
-       *dev->dma_mask = dma_mask;
-       return 0;
-}
-EXPORT_SYMBOL(dma_set_mask);
-
 static int __init dma_init(void)
 {
 #ifdef CONFIG_IBMVIO
 
 static inline void setup_swiotlb_ops(struct pci_controller *hose) {}
 #endif
 
-static int fsl_pci_dma_set_mask(struct device *dev, u64 dma_mask)
+static void fsl_pci_dma_set_mask(struct device *dev, u64 dma_mask)
 {
-       if (!dev->dma_mask || !dma_supported(dev, dma_mask))
-               return -EIO;
-
        /*
         * Fix up PCI devices that are able to DMA to the large inbound
         * mapping that allows addressing any RAM address from across PCI.
                set_dma_ops(dev, &dma_nommu_ops);
                set_dma_offset(dev, pci64_dma_offset);
        }
-
-       *dev->dma_mask = dma_mask;
-       return 0;
 }
 
 static int setup_one_atmu(struct ccsr_pci __iomem *pci,
 
 config ARCH_HAS_DMA_COHERENCE_H
        bool
 
+config ARCH_HAS_DMA_SET_MASK
+       bool
+
 config HAVE_GENERIC_DMA_COHERENT
        bool
 
 
 }
 EXPORT_SYMBOL(dma_supported);
 
-#ifndef HAVE_ARCH_DMA_SET_MASK
+#ifdef CONFIG_ARCH_HAS_DMA_SET_MASK
+void arch_dma_set_mask(struct device *dev, u64 mask);
+#else
+#define arch_dma_set_mask(dev, mask)   do { } while (0)
+#endif
+
 int dma_set_mask(struct device *dev, u64 mask)
 {
        if (!dev->dma_mask || !dma_supported(dev, mask))
                return -EIO;
 
+       arch_dma_set_mask(dev, mask);
        dma_check_mask(dev, mask);
        *dev->dma_mask = mask;
        return 0;
 }
 EXPORT_SYMBOL(dma_set_mask);
-#endif
 
 #ifndef CONFIG_ARCH_HAS_DMA_SET_COHERENT_MASK
 int dma_set_coherent_mask(struct device *dev, u64 mask)