dmaengine: dw_dmac: Enhance device tree support

dw_dmac driver already supports device tree but it used to have its platform
data passed the non-DT way.

This patch does following changes:
- pass platform data via DT, non-DT way still takes precedence if both are used.
- create generic filter routine
- Earlier slave information was made available by slave specific filter routines
  in chan->private field. Now, this information would be passed from within dmac
  DT node. Slave drivers would now be required to pass bus_id (a string) as
  parameter to this generic filter(), which would be compared against the slave
  data passed from DT, by the generic filter routine.
- Update binding document

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
[Fixed __devinit usage]
Signed-off-by: Vinod Koul <vinod.koul@linux.intel.com>

2 files changed, 138 insertions, 0 deletions

diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index 8f0b111af4de..27b8e1d1845e 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -1179,6 +1179,50 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         dev_vdbg(chan2dev(chan), "%s: done\n", __func__);
 }
 
+bool dw_dma_generic_filter(struct dma_chan *chan, void *param)
+{
+        struct dw_dma *dw = to_dw_dma(chan->device);
+        static struct dw_dma *last_dw;
+        static char *last_bus_id;
+        int i = -1;
+
+        /*
+         * dmaengine framework calls this routine for all channels of all dma
+         * controller, until true is returned. If 'param' bus_id is not
+         * registered with a dma controller (dw), then there is no need of
+         * running below function for all channels of dw.
+         *
+         * This block of code does this by saving the parameters of last
+         * failure. If dw and param are same, i.e. trying on same dw with
+         * different channel, return false.
+         */
+        if ((last_dw == dw) && (last_bus_id == param))
+                return false;
+        /*
+         * Return true:
+         * - If dw_dma's platform data is not filled with slave info, then all
+         *   dma controllers are fine for transfer.
+         * - Or if param is NULL
+         */
+        if (!dw->sd || !param)
+                return true;
+
+        while (++i < dw->sd_count) {
+                if (!strcmp(dw->sd[i].bus_id, param)) {
+                        chan->private = &dw->sd[i];
+                        last_dw = NULL;
+                        last_bus_id = NULL;
+
+                        return true;
+                }
+        }
+
+        last_dw = dw;
+        last_bus_id = param;
+        return false;
+}
+EXPORT_SYMBOL(dw_dma_generic_filter);
+
 /* --------------------- Cyclic DMA API extensions -------------------- */
 
 /**
@@ -1462,6 +1506,91 @@ static void dw_dma_off(struct dw_dma *dw)
                 dw->chan[i].initialized = false;
 }
 
+#ifdef CONFIG_OF
+static struct dw_dma_platform_data *
+dw_dma_parse_dt(struct platform_device *pdev)
+{
+        struct device_node *sn, *cn, *np = pdev->dev.of_node;
+        struct dw_dma_platform_data *pdata;
+        struct dw_dma_slave *sd;
+        u32 tmp, arr[4];
+
+        if (!np) {
+                dev_err(&pdev->dev, "Missing DT data\n");
+                return NULL;
+        }
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        if (of_property_read_u32(np, "nr_channels", &pdata->nr_channels))
+                return NULL;
+
+        if (of_property_read_bool(np, "is_private"))
+                pdata->is_private = true;
+
+        if (!of_property_read_u32(np, "chan_allocation_order", &tmp))
+                pdata->chan_allocation_order = (unsigned char)tmp;
+
+        if (!of_property_read_u32(np, "chan_priority", &tmp))
+                pdata->chan_priority = tmp;
+
+        if (!of_property_read_u32(np, "block_size", &tmp))
+                pdata->block_size = tmp;
+
+        if (!of_property_read_u32(np, "nr_masters", &tmp)) {
+                if (tmp > 4)
+                        return NULL;
+
+                pdata->nr_masters = tmp;
+        }
+
+        if (!of_property_read_u32_array(np, "data_width", arr,
+                                pdata->nr_masters))
+                for (tmp = 0; tmp < pdata->nr_masters; tmp++)
+                        pdata->data_width[tmp] = arr[tmp];
+
+        /* parse slave data */
+        sn = of_find_node_by_name(np, "slave_info");
+        if (!sn)
+                return pdata;
+
+        /* calculate number of slaves */
+        tmp = of_get_child_count(sn);
+        if (!tmp)
+                return NULL;
+
+        sd = devm_kzalloc(&pdev->dev, sizeof(*sd) * tmp, GFP_KERNEL);
+        if (!sd)
+                return NULL;
+
+        pdata->sd = sd;
+        pdata->sd_count = tmp;
+
+        for_each_child_of_node(sn, cn) {
+                sd->dma_dev = &pdev->dev;
+                of_property_read_string(cn, "bus_id", &sd->bus_id);
+                of_property_read_u32(cn, "cfg_hi", &sd->cfg_hi);
+                of_property_read_u32(cn, "cfg_lo", &sd->cfg_lo);
+                if (!of_property_read_u32(cn, "src_master", &tmp))
+                        sd->src_master = tmp;
+
+                if (!of_property_read_u32(cn, "dst_master", &tmp))
+                        sd->dst_master = tmp;
+                sd++;
+        }
+
+        return pdata;
+}
+#else
+static inline struct dw_dma_platform_data *
+dw_dma_parse_dt(struct platform_device *pdev)
+{
+        return NULL;
+}
+#endif
+
 static int dw_probe(struct platform_device *pdev)
 {
         struct dw_dma_platform_data *pdata;
@@ -1478,6 +1607,9 @@ static int dw_probe(struct platform_device *pdev)
         int                     i;
 
         pdata = dev_get_platdata(&pdev->dev);
+        if (!pdata)
+                pdata = dw_dma_parse_dt(pdev);
+
         if (!pdata || pdata->nr_channels > DW_DMA_MAX_NR_CHANNELS)
                 return -EINVAL;
 
@@ -1512,6 +1644,8 @@ static int dw_probe(struct platform_device *pdev)
         clk_prepare_enable(dw->clk);
 
         dw->regs = regs;
+        dw->sd = pdata->sd;
+        dw->sd_count = pdata->sd_count;
 
         /* get hardware configuration parameters */
         if (autocfg) {
diff --git a/drivers/dma/dw_dmac_regs.h b/drivers/dma/dw_dmac_regs.h
index 88965597b7d0..88a069f66b89 100644
--- a/drivers/dma/dw_dmac_regs.h
+++ b/drivers/dma/dw_dmac_regs.h
@@ -239,6 +239,10 @@ struct dw_dma {
         struct tasklet_struct   tasklet;
         struct clk              *clk;
 
+        /* slave information */
+        struct dw_dma_slave     *sd;
+        unsigned int            sd_count;
+
         u8                      all_chan_mask;
 
         /* hardware configuration */