We still treat devices without a DMA mask as defaulting to 32-bits for
both mask, but a few releases ago we've started warning about such
cases, as they require special cases to work around this sloppyness.
Add a dma_mask field to struct platform_device so that we can initialize
the dma_mask pointer in struct device and initialize both masks to
32-bits by default, replacing similar functionality in m68k and
powerpc.  The arch_setup_pdev_archdata hooks is now unused and removed.
Note that the code looks a little odd with the various conditionals
because we have to support platform_device structures that are
statically allocated.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Acked-by: Geert Uytterhoeven <geert@linux-m68k.org>
Link: https://lore.kernel.org/r/20190816062435.881-7-hch@lst.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
 
                break;
        }
 }
-
-void arch_setup_pdev_archdata(struct platform_device *pdev)
-{
-       if (pdev->dev.coherent_dma_mask == DMA_MASK_NONE &&
-           pdev->dev.dma_mask == NULL) {
-               pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-               pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-       }
-}
 
        pr_info("%s\n", s);
 }
 
-void arch_setup_pdev_archdata(struct platform_device *pdev)
-{
-       pdev->archdata.dma_mask = DMA_BIT_MASK(32);
-       pdev->dev.dma_mask = &pdev->archdata.dma_mask;
-}
-
 static __init void print_system_info(void)
 {
        pr_info("-----------------------------------------------------\n");
 
 
        /* Initialize CEU platform device separately to map memory first */
        device_initialize(&ap325rxa_ceu_device.dev);
-       arch_setup_pdev_archdata(&ap325rxa_ceu_device);
        dma_declare_coherent_memory(&ap325rxa_ceu_device.dev,
                        ceu_dma_membase, ceu_dma_membase,
                        ceu_dma_membase + CEU_BUFFER_MEMORY_SIZE - 1);
 
 
        /* Initialize CEU platform devices separately to map memory first */
        device_initialize(&ecovec_ceu_devices[0]->dev);
-       arch_setup_pdev_archdata(ecovec_ceu_devices[0]);
        dma_declare_coherent_memory(&ecovec_ceu_devices[0]->dev,
                                    ceu0_dma_membase, ceu0_dma_membase,
                                    ceu0_dma_membase +
        platform_device_add(ecovec_ceu_devices[0]);
 
        device_initialize(&ecovec_ceu_devices[1]->dev);
-       arch_setup_pdev_archdata(ecovec_ceu_devices[1]);
        dma_declare_coherent_memory(&ecovec_ceu_devices[1]->dev,
                                    ceu1_dma_membase, ceu1_dma_membase,
                                    ceu1_dma_membase +
 
 
        /* Initialize CEU platform device separately to map memory first */
        device_initialize(&kfr2r09_ceu_device.dev);
-       arch_setup_pdev_archdata(&kfr2r09_ceu_device);
        dma_declare_coherent_memory(&kfr2r09_ceu_device.dev,
                        ceu_dma_membase, ceu_dma_membase,
                        ceu_dma_membase + CEU_BUFFER_MEMORY_SIZE - 1);
 
 
        /* Initialize CEU platform device separately to map memory first */
        device_initialize(&migor_ceu_device.dev);
-       arch_setup_pdev_archdata(&migor_ceu_device);
        dma_declare_coherent_memory(&migor_ceu_device.dev,
                        ceu_dma_membase, ceu_dma_membase,
                        ceu_dma_membase + CEU_BUFFER_MEMORY_SIZE - 1);
 
 
        /* Initialize CEU platform devices separately to map memory first */
        device_initialize(&ms7724se_ceu_devices[0]->dev);
-       arch_setup_pdev_archdata(ms7724se_ceu_devices[0]);
        dma_declare_coherent_memory(&ms7724se_ceu_devices[0]->dev,
                                    ceu0_dma_membase, ceu0_dma_membase,
                                    ceu0_dma_membase +
        platform_device_add(ms7724se_ceu_devices[0]);
 
        device_initialize(&ms7724se_ceu_devices[1]->dev);
-       arch_setup_pdev_archdata(ms7724se_ceu_devices[1]);
        dma_declare_coherent_memory(&ms7724se_ceu_devices[1]->dev,
                                    ceu1_dma_membase, ceu1_dma_membase,
                                    ceu1_dma_membase +
 
 };
 EXPORT_SYMBOL_GPL(platform_bus);
 
-/**
- * arch_setup_pdev_archdata - Allow manipulation of archdata before its used
- * @pdev: platform device
- *
- * This is called before platform_device_add() such that any pdev_archdata may
- * be setup before the platform_notifier is called.  So if a user needs to
- * manipulate any relevant information in the pdev_archdata they can do:
- *
- *     platform_device_alloc()
- *     ... manipulate ...
- *     platform_device_add()
- *
- * And if they don't care they can just call platform_device_register() and
- * everything will just work out.
- */
-void __weak arch_setup_pdev_archdata(struct platform_device *pdev)
-{
-}
-
 /**
  * platform_get_resource - get a resource for a device
  * @dev: platform device
        char name[];
 };
 
+/*
+ * Set up default DMA mask for platform devices if the they weren't
+ * previously set by the architecture / DT.
+ */
+static void setup_pdev_dma_masks(struct platform_device *pdev)
+{
+       if (!pdev->dev.coherent_dma_mask)
+               pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+       if (!pdev->dma_mask)
+               pdev->dma_mask = DMA_BIT_MASK(32);
+       if (!pdev->dev.dma_mask)
+               pdev->dev.dma_mask = &pdev->dma_mask;
+};
+
 /**
  * platform_device_put - destroy a platform device
  * @pdev: platform device to free
                pa->pdev.id = id;
                device_initialize(&pa->pdev.dev);
                pa->pdev.dev.release = platform_device_release;
-               arch_setup_pdev_archdata(&pa->pdev);
+               setup_pdev_dma_masks(&pa->pdev);
        }
 
        return pa ? &pa->pdev : NULL;
 int platform_device_register(struct platform_device *pdev)
 {
        device_initialize(&pdev->dev);
-       arch_setup_pdev_archdata(pdev);
+       setup_pdev_dma_masks(pdev);
        return platform_device_add(pdev);
 }
 EXPORT_SYMBOL_GPL(platform_device_register);
 
        int             id;
        bool            id_auto;
        struct device   dev;
+       u64             dma_mask;
        u32             num_resources;
        struct resource *resource;
 
 extern struct bus_type platform_bus_type;
 extern struct device platform_bus;
 
-extern void arch_setup_pdev_archdata(struct platform_device *);
 extern struct resource *platform_get_resource(struct platform_device *,
                                              unsigned int, unsigned int);
 extern void __iomem *