dmaengine: drivers: Use devm_platform_ioremap_resource()

platform_get_resource() and devm_ioremap_resource() are wrapped up in the
devm_platform_ioremap_resource() helper. Use the helper and get rid of the
local variable for struct resource *. We now have a function call less.

Signed-off-by: Tudor Ambarus <tudor.ambarus@microchip.com>
Acked-by: Jernej Skrabec <jernej.skrabec@gmail.com>
Acked-by: Peter Ujfalusi <peter.ujfalusi@gmail.com>
Link: https://lore.kernel.org/r/20221110152528.7821-1-tudor.ambarus@microchip.com
Signed-off-by: Vinod Koul <vkoul@kernel.org>

diff --git a/drivers/dma/bcm2835-dma.c b/drivers/dma/bcm2835-dma.c
index 630dfbb01a40e6a7431b9bd566492b3f954c8bfe..0807fb9eb2626b8cfa358301ee344934ba393ba2 100644 (file)
--- a/drivers/dma/bcm2835-dma.c
+++ b/drivers/dma/bcm2835-dma.c
@@ -878,7 +878,6 @@ static struct dma_chan *bcm2835_dma_xlate(struct of_phandle_args *spec,
 static int bcm2835_dma_probe(struct platform_device *pdev)
 {
        struct bcm2835_dmadev *od;
-       struct resource *res;
        void __iomem *base;
        int rc;
        int i, j;
@@ -902,8 +901,7 @@ static int bcm2835_dma_probe(struct platform_device *pdev)
 
        dma_set_max_seg_size(&pdev->dev, 0x3FFFFFFF);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       base = devm_ioremap_resource(&pdev->dev, res);
+       base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(base))
                return PTR_ERR(base);
 

diff --git a/drivers/dma/dma-axi-dmac.c b/drivers/dma/dma-axi-dmac.c
index f30dabc99795d012f73ef0702265a0c7e5ed7b13..a812b9b00e6bee1fc72edc6ede9a249b7c30aad3 100644 (file)
--- a/drivers/dma/dma-axi-dmac.c
+++ b/drivers/dma/dma-axi-dmac.c
@@ -910,7 +910,6 @@ static int axi_dmac_probe(struct platform_device *pdev)
 {
        struct dma_device *dma_dev;
        struct axi_dmac *dmac;
-       struct resource *res;
        struct regmap *regmap;
        unsigned int version;
        int ret;
@@ -925,8 +924,7 @@ static int axi_dmac_probe(struct platform_device *pdev)
        if (dmac->irq == 0)
                return -EINVAL;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       dmac->base = devm_ioremap_resource(&pdev->dev, res);
+       dmac->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(dmac->base))
                return PTR_ERR(dmac->base);
 

diff --git a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c b/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
index a183d93bd7e2986e6a4f385d62395cde2a5af834..3dec8adfc4ea08eb84711b9cf5b9a2c3ca1b267d 100644 (file)
--- a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
+++ b/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
@@ -1365,7 +1365,6 @@ static int dw_probe(struct platform_device *pdev)
 {
        struct device_node *node = pdev->dev.of_node;
        struct axi_dma_chip *chip;
-       struct resource *mem;
        struct dw_axi_dma *dw;
        struct dw_axi_dma_hcfg *hdata;
        u32 i;
@@ -1391,8 +1390,7 @@ static int dw_probe(struct platform_device *pdev)
        if (chip->irq < 0)
                return chip->irq;
 
-       mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       chip->regs = devm_ioremap_resource(chip->dev, mem);
+       chip->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(chip->regs))
                return PTR_ERR(chip->regs);
 

diff --git a/drivers/dma/fsl-edma.c b/drivers/dma/fsl-edma.c
index 76cbf54aec58f1d73639ffb8dbc6d31f38244797..e40769666e3933f649692ddb29a8e4968817eacb 100644 (file)
--- a/drivers/dma/fsl-edma.c
+++ b/drivers/dma/fsl-edma.c
@@ -272,7 +272,6 @@ static int fsl_edma_probe(struct platform_device *pdev)
        const struct fsl_edma_drvdata *drvdata = NULL;
        struct fsl_edma_chan *fsl_chan;
        struct edma_regs *regs;
-       struct resource *res;
        int len, chans;
        int ret, i;
 
@@ -298,8 +297,7 @@ static int fsl_edma_probe(struct platform_device *pdev)
        fsl_edma->n_chans = chans;
        mutex_init(&fsl_edma->fsl_edma_mutex);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       fsl_edma->membase = devm_ioremap_resource(&pdev->dev, res);
+       fsl_edma->membase = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(fsl_edma->membase))
                return PTR_ERR(fsl_edma->membase);
 
@@ -323,8 +321,8 @@ static int fsl_edma_probe(struct platform_device *pdev)
        for (i = 0; i < fsl_edma->drvdata->dmamuxs; i++) {
                char clkname[32];
 
-               res = platform_get_resource(pdev, IORESOURCE_MEM, 1 + i);
-               fsl_edma->muxbase[i] = devm_ioremap_resource(&pdev->dev, res);
+               fsl_edma->muxbase[i] = devm_platform_ioremap_resource(pdev,
+                                                                     1 + i);
                if (IS_ERR(fsl_edma->muxbase[i])) {
                        /* on error: disable all previously enabled clks */
                        fsl_disable_clocks(fsl_edma, i);

diff --git a/drivers/dma/fsl-qdma.c b/drivers/dma/fsl-qdma.c
index 045ead46ec8fcb6fb410e219165c2a944a77f7f5..eddb2688f234060cbfdb12e6e31a4f1ec6dc2f7d 100644 (file)
--- a/drivers/dma/fsl-qdma.c
+++ b/drivers/dma/fsl-qdma.c
@@ -1119,7 +1119,6 @@ static int fsl_qdma_probe(struct platform_device *pdev)
        int ret, i;
        int blk_num, blk_off;
        u32 len, chans, queues;
-       struct resource *res;
        struct fsl_qdma_chan *fsl_chan;
        struct fsl_qdma_engine *fsl_qdma;
        struct device_node *np = pdev->dev.of_node;
@@ -1183,18 +1182,15 @@ static int fsl_qdma_probe(struct platform_device *pdev)
                if (!fsl_qdma->status[i])
                        return -ENOMEM;
        }
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       fsl_qdma->ctrl_base = devm_ioremap_resource(&pdev->dev, res);
+       fsl_qdma->ctrl_base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(fsl_qdma->ctrl_base))
                return PTR_ERR(fsl_qdma->ctrl_base);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-       fsl_qdma->status_base = devm_ioremap_resource(&pdev->dev, res);
+       fsl_qdma->status_base = devm_platform_ioremap_resource(pdev, 1);
        if (IS_ERR(fsl_qdma->status_base))
                return PTR_ERR(fsl_qdma->status_base);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
-       fsl_qdma->block_base = devm_ioremap_resource(&pdev->dev, res);
+       fsl_qdma->block_base = devm_platform_ioremap_resource(pdev, 2);
        if (IS_ERR(fsl_qdma->block_base))
                return PTR_ERR(fsl_qdma->block_base);
        fsl_qdma->queue = fsl_qdma_alloc_queue_resources(pdev, fsl_qdma);

diff --git a/drivers/dma/idma64.c b/drivers/dma/idma64.c
index c33087c5cd0214f23f5f595c86bedf1371f4912f..cd9622f6e59cc28d040f26ba6b5c610cce55fd12 100644 (file)
--- a/drivers/dma/idma64.c
+++ b/drivers/dma/idma64.c
@@ -627,7 +627,6 @@ static int idma64_platform_probe(struct platform_device *pdev)
        struct idma64_chip *chip;
        struct device *dev = &pdev->dev;
        struct device *sysdev = dev->parent;
-       struct resource *mem;
        int ret;
 
        chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
@@ -638,8 +637,7 @@ static int idma64_platform_probe(struct platform_device *pdev)
        if (chip->irq < 0)
                return chip->irq;
 
-       mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       chip->regs = devm_ioremap_resource(dev, mem);
+       chip->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(chip->regs))
                return PTR_ERR(chip->regs);
 

diff --git a/drivers/dma/img-mdc-dma.c b/drivers/dma/img-mdc-dma.c
index e4ea107ce78cdc99634048f9bcc525667cd3f158..ad084552640ffd8c250cdd1daad7fe8142de6807 100644 (file)
--- a/drivers/dma/img-mdc-dma.c
+++ b/drivers/dma/img-mdc-dma.c
@@ -886,7 +886,6 @@ static int img_mdc_runtime_resume(struct device *dev)
 static int mdc_dma_probe(struct platform_device *pdev)
 {
        struct mdc_dma *mdma;
-       struct resource *res;
        unsigned int i;
        u32 val;
        int ret;
@@ -898,8 +897,7 @@ static int mdc_dma_probe(struct platform_device *pdev)
 
        mdma->soc = of_device_get_match_data(&pdev->dev);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       mdma->regs = devm_ioremap_resource(&pdev->dev, res);
+       mdma->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(mdma->regs))
                return PTR_ERR(mdma->regs);
 

diff --git a/drivers/dma/imx-dma.c b/drivers/dma/imx-dma.c
index 65c6094ce0639c4fd068eead4a289f53d077e7cb..80086977973f14cfc0c58d3594adc29234e0d70b 100644 (file)
--- a/drivers/dma/imx-dma.c
+++ b/drivers/dma/imx-dma.c
@@ -1038,7 +1038,6 @@ static struct dma_chan *imxdma_xlate(struct of_phandle_args *dma_spec,
 static int __init imxdma_probe(struct platform_device *pdev)
 {
        struct imxdma_engine *imxdma;
-       struct resource *res;
        int ret, i;
        int irq, irq_err;
 
@@ -1049,8 +1048,7 @@ static int __init imxdma_probe(struct platform_device *pdev)
        imxdma->dev = &pdev->dev;
        imxdma->devtype = (uintptr_t)of_device_get_match_data(&pdev->dev);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       imxdma->base = devm_ioremap_resource(&pdev->dev, res);
+       imxdma->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(imxdma->base))
                return PTR_ERR(imxdma->base);
 

diff --git a/drivers/dma/imx-sdma.c b/drivers/dma/imx-sdma.c
index ab877ceeac3f97c4c9d3776882491f4b57baedb1..97396af129f88f0c7aaf352c13ec75d56d5c1456 100644 (file)
--- a/drivers/dma/imx-sdma.c
+++ b/drivers/dma/imx-sdma.c
@@ -2189,7 +2189,6 @@ static int sdma_probe(struct platform_device *pdev)
        const char *fw_name;
        int ret;
        int irq;
-       struct resource *iores;
        struct resource spba_res;
        int i;
        struct sdma_engine *sdma;
@@ -2212,8 +2211,7 @@ static int sdma_probe(struct platform_device *pdev)
        if (irq < 0)
                return irq;
 
-       iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       sdma->regs = devm_ioremap_resource(&pdev->dev, iores);
+       sdma->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(sdma->regs))
                return PTR_ERR(sdma->regs);
 

diff --git a/drivers/dma/mcf-edma.c b/drivers/dma/mcf-edma.c
index e12b754e6398d8cecf2ebaf6cd1444e737341694..ebd8733f72ad43c93a5909f7bb60720cc3e6adc0 100644 (file)
--- a/drivers/dma/mcf-edma.c
+++ b/drivers/dma/mcf-edma.c
@@ -182,7 +182,6 @@ static int mcf_edma_probe(struct platform_device *pdev)
        struct fsl_edma_engine *mcf_edma;
        struct fsl_edma_chan *mcf_chan;
        struct edma_regs *regs;
-       struct resource *res;
        int ret, i, len, chans;
 
        pdata = dev_get_platdata(&pdev->dev);
@@ -210,9 +209,7 @@ static int mcf_edma_probe(struct platform_device *pdev)
 
        mutex_init(&mcf_edma->fsl_edma_mutex);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-
-       mcf_edma->membase = devm_ioremap_resource(&pdev->dev, res);
+       mcf_edma->membase = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(mcf_edma->membase))
                return PTR_ERR(mcf_edma->membase);
 

diff --git a/drivers/dma/mediatek/mtk-hsdma.c b/drivers/dma/mediatek/mtk-hsdma.c
index f7717c44b887905505c3cc1180a1f3df6e6bb2a2..69cc61c0b262b3c84e51f588a437fb2d67f1e3d6 100644 (file)
--- a/drivers/dma/mediatek/mtk-hsdma.c
+++ b/drivers/dma/mediatek/mtk-hsdma.c
@@ -896,7 +896,6 @@ static int mtk_hsdma_probe(struct platform_device *pdev)
        struct mtk_hsdma_device *hsdma;
        struct mtk_hsdma_vchan *vc;
        struct dma_device *dd;
-       struct resource *res;
        int i, err;
 
        hsdma = devm_kzalloc(&pdev->dev, sizeof(*hsdma), GFP_KERNEL);
@@ -905,8 +904,7 @@ static int mtk_hsdma_probe(struct platform_device *pdev)
 
        dd = &hsdma->ddev;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       hsdma->base = devm_ioremap_resource(&pdev->dev, res);
+       hsdma->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(hsdma->base))
                return PTR_ERR(hsdma->base);
 

diff --git a/drivers/dma/mmp_pdma.c b/drivers/dma/mmp_pdma.c
index e8d71b35593e38d117579e24fe77a249781e7317..ebdfdcbb4f7ae8b09d05ad61a4821d9c6554242b 100644 (file)
--- a/drivers/dma/mmp_pdma.c
+++ b/drivers/dma/mmp_pdma.c
@@ -1022,7 +1022,6 @@ static int mmp_pdma_probe(struct platform_device *op)
        struct mmp_pdma_device *pdev;
        const struct of_device_id *of_id;
        struct mmp_dma_platdata *pdata = dev_get_platdata(&op->dev);
-       struct resource *iores;
        int i, ret, irq = 0;
        int dma_channels = 0, irq_num = 0;
        const enum dma_slave_buswidth widths =
@@ -1037,8 +1036,7 @@ static int mmp_pdma_probe(struct platform_device *op)
 
        spin_lock_init(&pdev->phy_lock);
 
-       iores = platform_get_resource(op, IORESOURCE_MEM, 0);
-       pdev->base = devm_ioremap_resource(pdev->dev, iores);
+       pdev->base = devm_platform_ioremap_resource(op, 0);
        if (IS_ERR(pdev->base))
                return PTR_ERR(pdev->base);
 

diff --git a/drivers/dma/mmp_tdma.c b/drivers/dma/mmp_tdma.c
index a262e0eb4cc94d42c4284b4b3914166ed1c558ca..e956702932aaf02a774b6ec9e3aae20bf8900980 100644 (file)
--- a/drivers/dma/mmp_tdma.c
+++ b/drivers/dma/mmp_tdma.c
@@ -639,7 +639,6 @@ static int mmp_tdma_probe(struct platform_device *pdev)
        enum mmp_tdma_type type;
        const struct of_device_id *of_id;
        struct mmp_tdma_device *tdev;
-       struct resource *iores;
        int i, ret;
        int irq = 0, irq_num = 0;
        int chan_num = TDMA_CHANNEL_NUM;
@@ -663,8 +662,7 @@ static int mmp_tdma_probe(struct platform_device *pdev)
                        irq_num++;
        }
 
-       iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       tdev->base = devm_ioremap_resource(&pdev->dev, iores);
+       tdev->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(tdev->base))
                return PTR_ERR(tdev->base);
 

diff --git a/drivers/dma/moxart-dma.c b/drivers/dma/moxart-dma.c
index 7459382a8353aa07471d13afc2daa9e1caa19284..7565ad98ba6604e0fddcf0f174d929c51b00323c 100644 (file)
--- a/drivers/dma/moxart-dma.c
+++ b/drivers/dma/moxart-dma.c
@@ -563,7 +563,6 @@ static int moxart_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct device_node *node = dev->of_node;
-       struct resource *res;
        void __iomem *dma_base_addr;
        int ret, i;
        unsigned int irq;
@@ -580,8 +579,7 @@ static int moxart_probe(struct platform_device *pdev)
                return -EINVAL;
        }
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       dma_base_addr = devm_ioremap_resource(dev, res);
+       dma_base_addr = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(dma_base_addr))
                return PTR_ERR(dma_base_addr);
 

diff --git a/drivers/dma/mv_xor_v2.c b/drivers/dma/mv_xor_v2.c
index 113834e1167b6f89ec2f3d955ad274da8ad04424..89790beba3052d3513f26531a8f4032d3b583d48 100644 (file)
--- a/drivers/dma/mv_xor_v2.c
+++ b/drivers/dma/mv_xor_v2.c
@@ -714,7 +714,6 @@ static int mv_xor_v2_resume(struct platform_device *dev)
 static int mv_xor_v2_probe(struct platform_device *pdev)
 {
        struct mv_xor_v2_device *xor_dev;
-       struct resource *res;
        int i, ret = 0;
        struct dma_device *dma_dev;
        struct mv_xor_v2_sw_desc *sw_desc;
@@ -726,13 +725,11 @@ static int mv_xor_v2_probe(struct platform_device *pdev)
        if (!xor_dev)
                return -ENOMEM;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       xor_dev->dma_base = devm_ioremap_resource(&pdev->dev, res);
+       xor_dev->dma_base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(xor_dev->dma_base))
                return PTR_ERR(xor_dev->dma_base);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-       xor_dev->glob_base = devm_ioremap_resource(&pdev->dev, res);
+       xor_dev->glob_base = devm_platform_ioremap_resource(pdev, 1);
        if (IS_ERR(xor_dev->glob_base))
                return PTR_ERR(xor_dev->glob_base);
 

diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index dc147cc2436e9e35566fffba413ba539baa9e05f..acc4d53e4630d144fafca99e1f58b2608bbdc19f 100644 (file)
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -746,7 +746,6 @@ static int mxs_dma_probe(struct platform_device *pdev)
        struct device_node *np = pdev->dev.of_node;
        const struct mxs_dma_type *dma_type;
        struct mxs_dma_engine *mxs_dma;
-       struct resource *iores;
        int ret, i;
 
        mxs_dma = devm_kzalloc(&pdev->dev, sizeof(*mxs_dma), GFP_KERNEL);
@@ -763,8 +762,7 @@ static int mxs_dma_probe(struct platform_device *pdev)
        mxs_dma->type = dma_type->type;
        mxs_dma->dev_id = dma_type->id;
 
-       iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       mxs_dma->base = devm_ioremap_resource(&pdev->dev, iores);
+       mxs_dma->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(mxs_dma->base))
                return PTR_ERR(mxs_dma->base);
 

diff --git a/drivers/dma/nbpfaxi.c b/drivers/dma/nbpfaxi.c
index a7063e9cd551cf230583776c2acc8f8afd6eed66..e72e8c10355ea2a91986c4072cb9ca4d30a9ff4f 100644 (file)
--- a/drivers/dma/nbpfaxi.c
+++ b/drivers/dma/nbpfaxi.c
@@ -1294,7 +1294,6 @@ static int nbpf_probe(struct platform_device *pdev)
        struct device_node *np = dev->of_node;
        struct nbpf_device *nbpf;
        struct dma_device *dma_dev;
-       struct resource *iomem;
        const struct nbpf_config *cfg;
        int num_channels;
        int ret, irq, eirq, i;
@@ -1318,8 +1317,7 @@ static int nbpf_probe(struct platform_device *pdev)
        dma_dev = &nbpf->dma_dev;
        dma_dev->dev = dev;
 
-       iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       nbpf->base = devm_ioremap_resource(dev, iomem);
+       nbpf->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(nbpf->base))
                return PTR_ERR(nbpf->base);
 

diff --git a/drivers/dma/pxa_dma.c b/drivers/dma/pxa_dma.c
index 22a392fe6d32bf3024c14965cd9e4923b64f8a8c..1b046d9a3a269aed4080a890f5950a11e7f5b30c 100644 (file)
--- a/drivers/dma/pxa_dma.c
+++ b/drivers/dma/pxa_dma.c
@@ -1346,7 +1346,6 @@ static int pxad_probe(struct platform_device *op)
        const struct of_device_id *of_id;
        const struct dma_slave_map *slave_map = NULL;
        struct mmp_dma_platdata *pdata = dev_get_platdata(&op->dev);
-       struct resource *iores;
        int ret, dma_channels = 0, nb_requestors = 0, slave_map_cnt = 0;
        const enum dma_slave_buswidth widths =
                DMA_SLAVE_BUSWIDTH_1_BYTE   | DMA_SLAVE_BUSWIDTH_2_BYTES |
@@ -1358,8 +1357,7 @@ static int pxad_probe(struct platform_device *op)
 
        spin_lock_init(&pdev->phy_lock);
 
-       iores = platform_get_resource(op, IORESOURCE_MEM, 0);
-       pdev->base = devm_ioremap_resource(&op->dev, iores);
+       pdev->base = devm_platform_ioremap_resource(op, 0);
        if (IS_ERR(pdev->base))
                return PTR_ERR(pdev->base);
 

diff --git a/drivers/dma/qcom/bam_dma.c b/drivers/dma/qcom/bam_dma.c
index 2ff787df513e60ec23f14bb0e888aedf46cc4bbe..1e47d27e1f814b2681ffce8654ff369c81f44ff5 100644 (file)
--- a/drivers/dma/qcom/bam_dma.c
+++ b/drivers/dma/qcom/bam_dma.c
@@ -1237,7 +1237,6 @@ static int bam_dma_probe(struct platform_device *pdev)
 {
        struct bam_device *bdev;
        const struct of_device_id *match;
-       struct resource *iores;
        int ret, i;
 
        bdev = devm_kzalloc(&pdev->dev, sizeof(*bdev), GFP_KERNEL);
@@ -1254,8 +1253,7 @@ static int bam_dma_probe(struct platform_device *pdev)
 
        bdev->layout = match->data;
 
-       iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       bdev->regs = devm_ioremap_resource(&pdev->dev, iores);
+       bdev->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(bdev->regs))
                return PTR_ERR(bdev->regs);
 

diff --git a/drivers/dma/sf-pdma/sf-pdma.c b/drivers/dma/sf-pdma/sf-pdma.c
index 6b524eb6bcf3a016d84085248626d21fa8fe7c02..d7d2dacac830252821eee54fbc793d82a579c780 100644 (file)
--- a/drivers/dma/sf-pdma/sf-pdma.c
+++ b/drivers/dma/sf-pdma/sf-pdma.c
@@ -494,7 +494,6 @@ static void sf_pdma_setup_chans(struct sf_pdma *pdma)
 static int sf_pdma_probe(struct platform_device *pdev)
 {
        struct sf_pdma *pdma;
-       struct resource *res;
        int ret, n_chans;
        const enum dma_slave_buswidth widths =
                DMA_SLAVE_BUSWIDTH_1_BYTE | DMA_SLAVE_BUSWIDTH_2_BYTES |
@@ -519,8 +518,7 @@ static int sf_pdma_probe(struct platform_device *pdev)
 
        pdma->n_chans = n_chans;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       pdma->membase = devm_ioremap_resource(&pdev->dev, res);
+       pdma->membase = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(pdma->membase))
                return PTR_ERR(pdma->membase);
 

diff --git a/drivers/dma/sh/usb-dmac.c b/drivers/dma/sh/usb-dmac.c
index 5edaeb89d1e68e0009a3950f2f26bc32af0c89ee..b14cf350b669aa7d911b20b00bba63b2ee12b16b 100644 (file)
--- a/drivers/dma/sh/usb-dmac.c
+++ b/drivers/dma/sh/usb-dmac.c
@@ -768,7 +768,6 @@ static int usb_dmac_probe(struct platform_device *pdev)
        const enum dma_slave_buswidth widths = USB_DMAC_SLAVE_BUSWIDTH;
        struct dma_device *engine;
        struct usb_dmac *dmac;
-       struct resource *mem;
        unsigned int i;
        int ret;
 
@@ -789,8 +788,7 @@ static int usb_dmac_probe(struct platform_device *pdev)
                return -ENOMEM;
 
        /* Request resources. */
-       mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       dmac->iomem = devm_ioremap_resource(&pdev->dev, mem);
+       dmac->iomem = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(dmac->iomem))
                return PTR_ERR(dmac->iomem);
 

diff --git a/drivers/dma/stm32-dmamux.c b/drivers/dma/stm32-dmamux.c
index ee3cbbf510065acc5d5dbd58d3d7acdb4c5eae3d..46b884d461882cd4054d6567d8a5f7b7de555bc1 100644 (file)
--- a/drivers/dma/stm32-dmamux.c
+++ b/drivers/dma/stm32-dmamux.c
@@ -179,7 +179,6 @@ static int stm32_dmamux_probe(struct platform_device *pdev)
        const struct of_device_id *match;
        struct device_node *dma_node;
        struct stm32_dmamux_data *stm32_dmamux;
-       struct resource *res;
        void __iomem *iomem;
        struct reset_control *rst;
        int i, count, ret;
@@ -238,8 +237,7 @@ static int stm32_dmamux_probe(struct platform_device *pdev)
        }
        pm_runtime_get_noresume(&pdev->dev);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       iomem = devm_ioremap_resource(&pdev->dev, res);
+       iomem = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(iomem))
                return PTR_ERR(iomem);
 

diff --git a/drivers/dma/stm32-mdma.c b/drivers/dma/stm32-mdma.c
index b9d4c843635fc6cec38ef3e6a2d487c51a1ea266..84e7f4f4a8007773d003957bb645138568363924 100644 (file)
--- a/drivers/dma/stm32-mdma.c
+++ b/drivers/dma/stm32-mdma.c
@@ -1580,7 +1580,6 @@ static int stm32_mdma_probe(struct platform_device *pdev)
        struct stm32_mdma_device *dmadev;
        struct dma_device *dd;
        struct device_node *of_node;
-       struct resource *res;
        struct reset_control *rst;
        u32 nr_channels, nr_requests;
        int i, count, ret;
@@ -1622,8 +1621,7 @@ static int stm32_mdma_probe(struct platform_device *pdev)
                                       count);
        dmadev->nr_ahb_addr_masks = count;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       dmadev->base = devm_ioremap_resource(&pdev->dev, res);
+       dmadev->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(dmadev->base))
                return PTR_ERR(dmadev->base);
 

diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
index f291b1b4db3256e076c4a7563219d851c98c7b03..e86c8829513a3339d50b33a1497c18a4520a8c8f 100644 (file)
--- a/drivers/dma/sun4i-dma.c
+++ b/drivers/dma/sun4i-dma.c
@@ -1144,15 +1144,13 @@ handle_pending:
 static int sun4i_dma_probe(struct platform_device *pdev)
 {
        struct sun4i_dma_dev *priv;
-       struct resource *res;
        int i, j, ret;
 
        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       priv->base = devm_ioremap_resource(&pdev->dev, res);
+       priv->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(priv->base))
                return PTR_ERR(priv->base);
 

diff --git a/drivers/dma/sun6i-dma.c b/drivers/dma/sun6i-dma.c
index 30667d251e978c24bc60a61d2aedd43c6ae1c410..ebfd29888b2f547144a0a2ad7b1f9f2c9c825a66 100644 (file)
--- a/drivers/dma/sun6i-dma.c
+++ b/drivers/dma/sun6i-dma.c
@@ -1284,7 +1284,6 @@ static int sun6i_dma_probe(struct platform_device *pdev)
 {
        struct device_node *np = pdev->dev.of_node;
        struct sun6i_dma_dev *sdc;
-       struct resource *res;
        int ret, i;
 
        sdc = devm_kzalloc(&pdev->dev, sizeof(*sdc), GFP_KERNEL);
@@ -1295,8 +1294,7 @@ static int sun6i_dma_probe(struct platform_device *pdev)
        if (!sdc->cfg)
                return -ENODEV;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       sdc->base = devm_ioremap_resource(&pdev->dev, res);
+       sdc->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(sdc->base))
                return PTR_ERR(sdc->base);
 

diff --git a/drivers/dma/tegra210-adma.c b/drivers/dma/tegra210-adma.c
index ae39b52012b2fb74e723637652b2e07ea718defe..d1a84483f627cc74dc3fa07ac0562baf13fc1f1a 100644 (file)
--- a/drivers/dma/tegra210-adma.c
+++ b/drivers/dma/tegra210-adma.c
@@ -837,7 +837,6 @@ static int tegra_adma_probe(struct platform_device *pdev)
 {
        const struct tegra_adma_chip_data *cdata;
        struct tegra_adma *tdma;
-       struct resource *res;
        int ret, i;
 
        cdata = of_device_get_match_data(&pdev->dev);
@@ -857,8 +856,7 @@ static int tegra_adma_probe(struct platform_device *pdev)
        tdma->nr_channels = cdata->nr_channels;
        platform_set_drvdata(pdev, tdma);
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       tdma->base_addr = devm_ioremap_resource(&pdev->dev, res);
+       tdma->base_addr = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(tdma->base_addr))
                return PTR_ERR(tdma->base_addr);
 

diff --git a/drivers/dma/ti/cppi41.c b/drivers/dma/ti/cppi41.c
index 695915dba7079a5e28a431c4bad128ebeb30c073..c3555cfb06817d69e182d3c650af631074b817d8 100644 (file)
--- a/drivers/dma/ti/cppi41.c
+++ b/drivers/dma/ti/cppi41.c
@@ -1039,7 +1039,6 @@ static int cppi41_dma_probe(struct platform_device *pdev)
        struct cppi41_dd *cdd;
        struct device *dev = &pdev->dev;
        const struct cppi_glue_infos *glue_info;
-       struct resource *mem;
        int index;
        int irq;
        int ret;
@@ -1072,18 +1071,15 @@ static int cppi41_dma_probe(struct platform_device *pdev)
        if (index < 0)
                return index;
 
-       mem = platform_get_resource(pdev, IORESOURCE_MEM, index);
-       cdd->ctrl_mem = devm_ioremap_resource(dev, mem);
+       cdd->ctrl_mem = devm_platform_ioremap_resource(pdev, index);
        if (IS_ERR(cdd->ctrl_mem))
                return PTR_ERR(cdd->ctrl_mem);
 
-       mem = platform_get_resource(pdev, IORESOURCE_MEM, index + 1);
-       cdd->sched_mem = devm_ioremap_resource(dev, mem);
+       cdd->sched_mem = devm_platform_ioremap_resource(pdev, index + 1);
        if (IS_ERR(cdd->sched_mem))
                return PTR_ERR(cdd->sched_mem);
 
-       mem = platform_get_resource(pdev, IORESOURCE_MEM, index + 2);
-       cdd->qmgr_mem = devm_ioremap_resource(dev, mem);
+       cdd->qmgr_mem = devm_platform_ioremap_resource(pdev, index + 2);
        if (IS_ERR(cdd->qmgr_mem))
                return PTR_ERR(cdd->qmgr_mem);
 

diff --git a/drivers/dma/ti/omap-dma.c b/drivers/dma/ti/omap-dma.c
index 27f5019bdc1ed18ab81772808e025f75704880c7..02e1c08c596d1d9de84d293017d3e86083526c96 100644 (file)
--- a/drivers/dma/ti/omap-dma.c
+++ b/drivers/dma/ti/omap-dma.c
@@ -1658,7 +1658,6 @@ static int omap_dma_probe(struct platform_device *pdev)
 {
        const struct omap_dma_config *conf;
        struct omap_dmadev *od;
-       struct resource *res;
        int rc, i, irq;
        u32 val;
 
@@ -1666,8 +1665,7 @@ static int omap_dma_probe(struct platform_device *pdev)
        if (!od)
                return -ENOMEM;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       od->base = devm_ioremap_resource(&pdev->dev, res);
+       od->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(od->base))
                return PTR_ERR(od->base);
 

diff --git a/drivers/dma/xilinx/zynqmp_dma.c b/drivers/dma/xilinx/zynqmp_dma.c
index 21472a5d76368057601c425addf3c0373f2b6909..ce359058c63851c4cb0286c9c53811138d601f9b 100644 (file)
--- a/drivers/dma/xilinx/zynqmp_dma.c
+++ b/drivers/dma/xilinx/zynqmp_dma.c
@@ -890,7 +890,6 @@ static int zynqmp_dma_chan_probe(struct zynqmp_dma_device *zdev,
                           struct platform_device *pdev)
 {
        struct zynqmp_dma_chan *chan;
-       struct resource *res;
        struct device_node *node = pdev->dev.of_node;
        int err;
 
@@ -900,8 +899,7 @@ static int zynqmp_dma_chan_probe(struct zynqmp_dma_device *zdev,
        chan->dev = zdev->dev;
        chan->zdev = zdev;
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       chan->regs = devm_ioremap_resource(&pdev->dev, res);
+       chan->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(chan->regs))
                return PTR_ERR(chan->regs);