1 files changed, 44 insertions, 48 deletions

diff --git a/drivers/dma/dw/platform.c b/drivers/dma/dw/platform.c
index c5b339af6be5..a630161473a4 100644
--- a/drivers/dma/dw/platform.c
+++ b/drivers/dma/dw/platform.c
@@ -25,72 +25,49 @@
 
 #include "internal.h"
 
-struct dw_dma_of_filter_args {
-        struct dw_dma *dw;
-        unsigned int req;
-        unsigned int src;
-        unsigned int dst;
-};
-
-static bool dw_dma_of_filter(struct dma_chan *chan, void *param)
-{
-        struct dw_dma_chan *dwc = to_dw_dma_chan(chan);
-        struct dw_dma_of_filter_args *fargs = param;
-
-        /* Ensure the device matches our channel */
-        if (chan->device != &fargs->dw->dma)
-                return false;
-
-        dwc->request_line = fargs->req;
-        dwc->src_master = fargs->src;
-        dwc->dst_master = fargs->dst;
-
-        return true;
-}
-
 static struct dma_chan *dw_dma_of_xlate(struct of_phandle_args *dma_spec,
                                         struct of_dma *ofdma)
 {
         struct dw_dma *dw = ofdma->of_dma_data;
-        struct dw_dma_of_filter_args fargs = {
-                .dw = dw,
+        struct dw_dma_slave slave = {
+                .dma_dev = dw->dma.dev,
         };
         dma_cap_mask_t cap;
 
         if (dma_spec->args_count != 3)
                 return NULL;
 
-        fargs.req = dma_spec->args[0];
-        fargs.src = dma_spec->args[1];
-        fargs.dst = dma_spec->args[2];
+        slave.src_id = dma_spec->args[0];
+        slave.dst_id = dma_spec->args[0];
+        slave.src_master = dma_spec->args[1];
+        slave.dst_master = dma_spec->args[2];
 
-        if (WARN_ON(fargs.req >= DW_DMA_MAX_NR_REQUESTS ||
-                    fargs.src >= dw->nr_masters ||
-                    fargs.dst >= dw->nr_masters))
+        if (WARN_ON(slave.src_id >= DW_DMA_MAX_NR_REQUESTS ||
+                    slave.dst_id >= DW_DMA_MAX_NR_REQUESTS ||
+                    slave.src_master >= dw->nr_masters ||
+                    slave.dst_master >= dw->nr_masters))
                 return NULL;
 
         dma_cap_zero(cap);
         dma_cap_set(DMA_SLAVE, cap);
 
         /* TODO: there should be a simpler way to do this */
-        return dma_request_channel(cap, dw_dma_of_filter, &fargs);
+        return dma_request_channel(cap, dw_dma_filter, &slave);
 }
 
 #ifdef CONFIG_ACPI
 static bool dw_dma_acpi_filter(struct dma_chan *chan, void *param)
 {
-        struct dw_dma_chan *dwc = to_dw_dma_chan(chan);
         struct acpi_dma_spec *dma_spec = param;
+        struct dw_dma_slave slave = {
+                .dma_dev = dma_spec->dev,
+                .src_id = dma_spec->slave_id,
+                .dst_id = dma_spec->slave_id,
+                .src_master = 1,
+                .dst_master = 0,
+        };
 
-        if (chan->device->dev != dma_spec->dev ||
-            chan->chan_id != dma_spec->chan_id)
-                return false;
-
-        dwc->request_line = dma_spec->slave_id;
-        dwc->src_master = dwc_get_sms(NULL);
-        dwc->dst_master = dwc_get_dms(NULL);
-
-        return true;
+        return dw_dma_filter(chan, &slave);
 }
 
 static void dw_dma_acpi_controller_register(struct dw_dma *dw)
@@ -201,10 +178,17 @@ static int dw_probe(struct platform_device *pdev)
 
         chip->dev = dev;
 
-        err = dw_dma_probe(chip, pdata);
+        chip->clk = devm_clk_get(chip->dev, "hclk");
+        if (IS_ERR(chip->clk))
+                return PTR_ERR(chip->clk);
+        err = clk_prepare_enable(chip->clk);
         if (err)
                 return err;
 
+        err = dw_dma_probe(chip, pdata);
+        if (err)
+                goto err_dw_dma_probe;
+
         platform_set_drvdata(pdev, chip);
 
         if (pdev->dev.of_node) {
@@ -219,6 +203,10 @@ static int dw_probe(struct platform_device *pdev)
                 dw_dma_acpi_controller_register(chip->dw);
 
         return 0;
+
+err_dw_dma_probe:
+        clk_disable_unprepare(chip->clk);
+        return err;
 }
 
 static int dw_remove(struct platform_device *pdev)
@@ -228,14 +216,18 @@ static int dw_remove(struct platform_device *pdev)
         if (pdev->dev.of_node)
                 of_dma_controller_free(pdev->dev.of_node);
 
-        return dw_dma_remove(chip);
+        dw_dma_remove(chip);
+        clk_disable_unprepare(chip->clk);
+
+        return 0;
 }
 
 static void dw_shutdown(struct platform_device *pdev)
 {
         struct dw_dma_chip *chip = platform_get_drvdata(pdev);
 
-        dw_dma_shutdown(chip);
+        dw_dma_disable(chip);
+        clk_disable_unprepare(chip->clk);
 }
 
 #ifdef CONFIG_OF
@@ -261,7 +253,10 @@ static int dw_suspend_late(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct dw_dma_chip *chip = platform_get_drvdata(pdev);
 
-        return dw_dma_suspend(chip);
+        dw_dma_disable(chip);
+        clk_disable_unprepare(chip->clk);
+
+        return 0;
 }
 
 static int dw_resume_early(struct device *dev)
@@ -269,7 +264,8 @@ static int dw_resume_early(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct dw_dma_chip *chip = platform_get_drvdata(pdev);
 
-        return dw_dma_resume(chip);
+        clk_prepare_enable(chip->clk);
+        return dw_dma_enable(chip);
 }
 
 #endif /* CONFIG_PM_SLEEP */
@@ -281,7 +277,7 @@ static const struct dev_pm_ops dw_dev_pm_ops = {
 static struct platform_driver dw_driver = {
         .probe          = dw_probe,
         .remove         = dw_remove,
-        .shutdown       = dw_shutdown,
+        .shutdown       = dw_shutdown,
         .driver = {
                 .name   = "dw_dmac",
                 .pm     = &dw_dev_pm_ops,