Merge branch 'topic/dmam' into for-linus

8 files changed, 16 insertions, 36 deletions

diff --git a/drivers/dma/dma-jz4780.c b/drivers/dma/dma-jz4780.c
index 85820a2d69d4..b2a244902bc5 100644
--- a/drivers/dma/dma-jz4780.c
+++ b/drivers/dma/dma-jz4780.c
@@ -847,7 +847,7 @@ static int jz4780_dma_probe(struct platform_device *pdev)
                 jzchan->vchan.desc_free = jz4780_dma_desc_free;
         }
 
-        ret = dma_async_device_register(dd);
+        ret = dmaenginem_async_device_register(dd);
         if (ret) {
                 dev_err(dev, "failed to register device\n");
                 goto err_disable_clk;
@@ -858,15 +858,12 @@ static int jz4780_dma_probe(struct platform_device *pdev)
                                          jzdma);
         if (ret) {
                 dev_err(dev, "failed to register OF DMA controller\n");
-                goto err_unregister_dev;
+                goto err_disable_clk;
         }
 
         dev_info(dev, "JZ4780 DMA controller initialised\n");
         return 0;
 
-err_unregister_dev:
-        dma_async_device_unregister(dd);
-
 err_disable_clk:
         clk_disable_unprepare(jzdma->clk);
 
@@ -887,7 +884,6 @@ static int jz4780_dma_remove(struct platform_device *pdev)
         for (i = 0; i < JZ_DMA_NR_CHANNELS; i++)
                 tasklet_kill(&jzdma->chan[i].vchan.task);
 
-        dma_async_device_unregister(&jzdma->dma_device);
         return 0;
 }
 
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 c4eb55e3011c..b2ac1d2c5b86 100644
--- a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
+++ b/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
@@ -934,7 +934,7 @@ static int dw_probe(struct platform_device *pdev)
 
         pm_runtime_put(chip->dev);
 
-        ret = dma_async_device_register(&dw->dma);
+        ret = dmaenginem_async_device_register(&dw->dma);
         if (ret)
                 goto err_pm_disable;
 
@@ -977,8 +977,6 @@ static int dw_remove(struct platform_device *pdev)
                 tasklet_kill(&chan->vc.task);
         }
 
-        dma_async_device_unregister(&dw->dma);
-
         return 0;
 }
 
diff --git a/drivers/dma/mmp_tdma.c b/drivers/dma/mmp_tdma.c
index c14f8820a567..0c56faa03e9a 100644
--- a/drivers/dma/mmp_tdma.c
+++ b/drivers/dma/mmp_tdma.c
@@ -548,9 +548,6 @@ static void mmp_tdma_issue_pending(struct dma_chan *chan)
 
 static int mmp_tdma_remove(struct platform_device *pdev)
 {
-        struct mmp_tdma_device *tdev = platform_get_drvdata(pdev);
-
-        dma_async_device_unregister(&tdev->device);
         return 0;
 }
 
@@ -714,7 +711,7 @@ static int mmp_tdma_probe(struct platform_device *pdev)
         dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
         platform_set_drvdata(pdev, tdev);
 
-        ret = dma_async_device_register(&tdev->device);
+        ret = dmaenginem_async_device_register(&tdev->device);
         if (ret) {
                 dev_err(tdev->device.dev, "unable to register\n");
                 return ret;
@@ -726,7 +723,7 @@ static int mmp_tdma_probe(struct platform_device *pdev)
                 if (ret) {
                         dev_err(tdev->device.dev,
                                 "failed to register controller\n");
-                        dma_async_device_unregister(&tdev->device);
+                        return ret;
                 }
         }
 
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index ae5182ff0128..35193b31a9e0 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -847,7 +847,7 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
         mxs_dma->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
         mxs_dma->dma_device.device_issue_pending = mxs_dma_enable_chan;
 
-        ret = dma_async_device_register(&mxs_dma->dma_device);
+        ret = dmaenginem_async_device_register(&mxs_dma->dma_device);
         if (ret) {
                 dev_err(mxs_dma->dma_device.dev, "unable to register\n");
                 return ret;
@@ -857,7 +857,6 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(mxs_dma->dma_device.dev,
                         "failed to register controller\n");
-                dma_async_device_unregister(&mxs_dma->dma_device);
         }
 
         dev_info(mxs_dma->dma_device.dev, "initialized\n");
diff --git a/drivers/dma/pxa_dma.c b/drivers/dma/pxa_dma.c
index b31c28b67ad3..825725057e00 100644
--- a/drivers/dma/pxa_dma.c
+++ b/drivers/dma/pxa_dma.c
@@ -1285,7 +1285,6 @@ static int pxad_remove(struct platform_device *op)
 
         pxad_cleanup_debugfs(pdev);
         pxad_free_channels(&pdev->slave);
-        dma_async_device_unregister(&pdev->slave);
         return 0;
 }
 
@@ -1396,7 +1395,7 @@ static int pxad_init_dmadev(struct platform_device *op,
                 init_waitqueue_head(&c->wq_state);
         }
 
-        return dma_async_device_register(&pdev->slave);
+        return dmaenginem_async_device_register(&pdev->slave);
 }
 
 static int pxad_probe(struct platform_device *op)
@@ -1433,7 +1432,7 @@ static int pxad_probe(struct platform_device *op)
                                  "#dma-requests set to default 32 as missing in OF: %d",
                                  ret);
                         nb_requestors = 32;
-                };
+                }
         } else if (pdata && pdata->dma_channels) {
                 dma_channels = pdata->dma_channels;
                 nb_requestors = pdata->nb_requestors;
diff --git a/drivers/dma/st_fdma.c b/drivers/dma/st_fdma.c
index bfb79bd0c6de..07c20aa2e955 100644
--- a/drivers/dma/st_fdma.c
+++ b/drivers/dma/st_fdma.c
@@ -833,7 +833,7 @@ static int st_fdma_probe(struct platform_device *pdev)
         fdev->dma_device.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
         fdev->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
 
-        ret = dma_async_device_register(&fdev->dma_device);
+        ret = dmaenginem_async_device_register(&fdev->dma_device);
         if (ret) {
                 dev_err(&pdev->dev,
                         "Failed to register DMA device (%d)\n", ret);
@@ -844,15 +844,13 @@ static int st_fdma_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(&pdev->dev,
                         "Failed to register controller (%d)\n", ret);
-                goto err_dma_dev;
+                goto err_rproc;
         }
 
         dev_info(&pdev->dev, "ST FDMA engine driver, irq:%d\n", fdev->irq);
 
         return 0;
 
-err_dma_dev:
-        dma_async_device_unregister(&fdev->dma_device);
 err_rproc:
         st_fdma_free(fdev);
         st_slim_rproc_put(fdev->slim_rproc);
@@ -867,7 +865,6 @@ static int st_fdma_remove(struct platform_device *pdev)
         devm_free_irq(&pdev->dev, fdev->irq, fdev);
         st_slim_rproc_put(fdev->slim_rproc);
         of_dma_controller_free(pdev->dev.of_node);
-        dma_async_device_unregister(&fdev->dma_device);
 
         return 0;
 }
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index f4edfc56f34e..5e328bd10c27 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -2839,7 +2839,7 @@ static int __init d40_dmaengine_init(struct d40_base *base,
 
         d40_ops_init(base, &base->dma_slave);
 
-        err = dma_async_device_register(&base->dma_slave);
+        err = dmaenginem_async_device_register(&base->dma_slave);
 
         if (err) {
                 d40_err(base->dev, "Failed to register slave channels\n");
@@ -2854,12 +2854,12 @@ static int __init d40_dmaengine_init(struct d40_base *base,
 
         d40_ops_init(base, &base->dma_memcpy);
 
-        err = dma_async_device_register(&base->dma_memcpy);
+        err = dmaenginem_async_device_register(&base->dma_memcpy);
 
         if (err) {
                 d40_err(base->dev,
                         "Failed to register memcpy only channels\n");
-                goto unregister_slave;
+                goto exit;
         }
 
         d40_chan_init(base, &base->dma_both, base->phy_chans,
@@ -2871,18 +2871,14 @@ static int __init d40_dmaengine_init(struct d40_base *base,
         dma_cap_set(DMA_CYCLIC, base->dma_slave.cap_mask);
 
         d40_ops_init(base, &base->dma_both);
-        err = dma_async_device_register(&base->dma_both);
+        err = dmaenginem_async_device_register(&base->dma_both);
 
         if (err) {
                 d40_err(base->dev,
                         "Failed to register logical and physical capable channels\n");
-                goto unregister_memcpy;
+                goto exit;
         }
         return 0;
- unregister_memcpy:
-        dma_async_device_unregister(&base->dma_memcpy);
- unregister_slave:
-        dma_async_device_unregister(&base->dma_slave);
  exit:
         return err;
 }
diff --git a/drivers/dma/stm32-mdma.c b/drivers/dma/stm32-mdma.c
index 06dd1725375e..390e4cae0e1a 100644
--- a/drivers/dma/stm32-mdma.c
+++ b/drivers/dma/stm32-mdma.c
@@ -1656,7 +1656,7 @@ static int stm32_mdma_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        ret = dma_async_device_register(dd);
+        ret = dmaenginem_async_device_register(dd);
         if (ret)
                 return ret;
 
@@ -1674,8 +1674,6 @@ static int stm32_mdma_probe(struct platform_device *pdev)
         return 0;
 
 err_unregister:
-        dma_async_device_unregister(dd);
-
         return ret;
 }