1 files changed, 110 insertions, 93 deletions

diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index 43a5329d4483..2e5deaa82b60 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -25,6 +25,8 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/acpi.h>
+#include <linux/acpi_dma.h>
 
 #include "dw_dmac_regs.h"
 #include "dmaengine.h"
@@ -49,29 +51,22 @@ static inline unsigned int dwc_get_sms(struct dw_dma_slave *slave)
         return slave ? slave->src_master : 1;
 }
 
-#define SRC_MASTER      0
-#define DST_MASTER      1
-
-static inline unsigned int dwc_get_master(struct dma_chan *chan, int master)
+static inline void dwc_set_masters(struct dw_dma_chan *dwc)
 {
-        struct dw_dma *dw = to_dw_dma(chan->device);
-        struct dw_dma_slave *dws = chan->private;
-        unsigned int m;
-
-        if (master == SRC_MASTER)
-                m = dwc_get_sms(dws);
-        else
-                m = dwc_get_dms(dws);
+        struct dw_dma *dw = to_dw_dma(dwc->chan.device);
+        struct dw_dma_slave *dws = dwc->chan.private;
+        unsigned char mmax = dw->nr_masters - 1;
 
-        return min_t(unsigned int, dw->nr_masters - 1, m);
+        if (dwc->request_line == ~0) {
+                dwc->src_master = min_t(unsigned char, mmax, dwc_get_sms(dws));
+                dwc->dst_master = min_t(unsigned char, mmax, dwc_get_dms(dws));
+        }
 }
 
 #define DWC_DEFAULT_CTLLO(_chan) ({                             \
                 struct dw_dma_chan *_dwc = to_dw_dma_chan(_chan);       \
                 struct dma_slave_config *_sconfig = &_dwc->dma_sconfig; \
                 bool _is_slave = is_slave_direction(_dwc->direction);   \
-                int _dms = dwc_get_master(_chan, DST_MASTER);           \
-                int _sms = dwc_get_master(_chan, SRC_MASTER);           \
                 u8 _smsize = _is_slave ? _sconfig->src_maxburst :       \
                         DW_DMA_MSIZE_16;                        \
                 u8 _dmsize = _is_slave ? _sconfig->dst_maxburst :       \
@@ -81,8 +76,8 @@ static inline unsigned int dwc_get_master(struct dma_chan *chan, int master)
                  | DWC_CTLL_SRC_MSIZE(_smsize)                  \
                  | DWC_CTLL_LLP_D_EN                            \
                  | DWC_CTLL_LLP_S_EN                            \
-                 | DWC_CTLL_DMS(_dms)                           \
-                 | DWC_CTLL_SMS(_sms));                         \
+                 | DWC_CTLL_DMS(_dwc->dst_master)               \
+                 | DWC_CTLL_SMS(_dwc->src_master));             \
         })
 
 /*
@@ -92,13 +87,6 @@ static inline unsigned int dwc_get_master(struct dma_chan *chan, int master)
  */
 #define NR_DESCS_PER_CHANNEL    64
 
-static inline unsigned int dwc_get_data_width(struct dma_chan *chan, int master)
-{
-        struct dw_dma *dw = to_dw_dma(chan->device);
-
-        return dw->data_width[dwc_get_master(chan, master)];
-}
-
 /*----------------------------------------------------------------------*/
 
 static struct device *chan2dev(struct dma_chan *chan)
@@ -172,13 +160,7 @@ static void dwc_initialize(struct dw_dma_chan *dwc)
         if (dwc->initialized == true)
                 return;
 
-        if (dws && dws->cfg_hi == ~0 && dws->cfg_lo == ~0) {
-                /* autoconfigure based on request line from DT */
-                if (dwc->direction == DMA_MEM_TO_DEV)
-                        cfghi = DWC_CFGH_DST_PER(dwc->request_line);
-                else if (dwc->direction == DMA_DEV_TO_MEM)
-                        cfghi = DWC_CFGH_SRC_PER(dwc->request_line);
-        } else if (dws) {
+        if (dws) {
                 /*
                  * We need controller-specific data to set up slave
                  * transfers.
@@ -189,9 +171,9 @@ static void dwc_initialize(struct dw_dma_chan *dwc)
                 cfglo |= dws->cfg_lo & ~DWC_CFGL_CH_PRIOR_MASK;
         } else {
                 if (dwc->direction == DMA_MEM_TO_DEV)
-                        cfghi = DWC_CFGH_DST_PER(dwc->dma_sconfig.slave_id);
+                        cfghi = DWC_CFGH_DST_PER(dwc->request_line);
                 else if (dwc->direction == DMA_DEV_TO_MEM)
-                        cfghi = DWC_CFGH_SRC_PER(dwc->dma_sconfig.slave_id);
+                        cfghi = DWC_CFGH_SRC_PER(dwc->request_line);
         }
 
         channel_writel(dwc, CFG_LO, cfglo);
@@ -473,16 +455,16 @@ static void dwc_scan_descriptors(struct dw_dma *dw, struct dw_dma_chan *dwc)
                         (unsigned long long)llp);
 
         list_for_each_entry_safe(desc, _desc, &dwc->active_list, desc_node) {
-                /* initial residue value */
+                /* Initial residue value */
                 dwc->residue = desc->total_len;
 
-                /* check first descriptors addr */
+                /* Check first descriptors addr */
                 if (desc->txd.phys == llp) {
                         spin_unlock_irqrestore(&dwc->lock, flags);
                         return;
                 }
 
-                /* check first descriptors llp */
+                /* Check first descriptors llp */
                 if (desc->lli.llp == llp) {
                         /* This one is currently in progress */
                         dwc->residue -= dwc_get_sent(dwc);
@@ -588,7 +570,7 @@ inline dma_addr_t dw_dma_get_dst_addr(struct dma_chan *chan)
 }
 EXPORT_SYMBOL(dw_dma_get_dst_addr);
 
-/* called with dwc->lock held and all DMAC interrupts disabled */
+/* Called with dwc->lock held and all DMAC interrupts disabled */
 static void dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
                 u32 status_err, u32 status_xfer)
 {
@@ -626,7 +608,7 @@ static void dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
 
                 dwc_chan_disable(dw, dwc);
 
-                /* make sure DMA does not restart by loading a new list */
+                /* Make sure DMA does not restart by loading a new list */
                 channel_writel(dwc, LLP, 0);
                 channel_writel(dwc, CTL_LO, 0);
                 channel_writel(dwc, CTL_HI, 0);
@@ -745,6 +727,7 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
                 size_t len, unsigned long flags)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
+        struct dw_dma           *dw = to_dw_dma(chan->device);
         struct dw_desc          *desc;
         struct dw_desc          *first;
         struct dw_desc          *prev;
@@ -767,8 +750,8 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
 
         dwc->direction = DMA_MEM_TO_MEM;
 
-        data_width = min_t(unsigned int, dwc_get_data_width(chan, SRC_MASTER),
-                           dwc_get_data_width(chan, DST_MASTER));
+        data_width = min_t(unsigned int, dw->data_width[dwc->src_master],
+                           dw->data_width[dwc->dst_master]);
 
         src_width = dst_width = min_t(unsigned int, data_width,
                                       dwc_fast_fls(src | dest | len));
@@ -826,6 +809,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 unsigned long flags, void *context)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
+        struct dw_dma           *dw = to_dw_dma(chan->device);
         struct dma_slave_config *sconfig = &dwc->dma_sconfig;
         struct dw_desc          *prev;
         struct dw_desc          *first;
@@ -859,7 +843,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 ctllo |= sconfig->device_fc ? DWC_CTLL_FC(DW_DMA_FC_P_M2P) :
                         DWC_CTLL_FC(DW_DMA_FC_D_M2P);
 
-                data_width = dwc_get_data_width(chan, SRC_MASTER);
+                data_width = dw->data_width[dwc->src_master];
 
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct dw_desc  *desc;
@@ -919,7 +903,7 @@ slave_sg_todev_fill_desc:
                 ctllo |= sconfig->device_fc ? DWC_CTLL_FC(DW_DMA_FC_P_P2M) :
                         DWC_CTLL_FC(DW_DMA_FC_D_P2M);
 
-                data_width = dwc_get_data_width(chan, DST_MASTER);
+                data_width = dw->data_width[dwc->dst_master];
 
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct dw_desc  *desc;
@@ -1001,13 +985,6 @@ static inline void convert_burst(u32 *maxburst)
                 *maxburst = 0;
 }
 
-static inline void convert_slave_id(struct dw_dma_chan *dwc)
-{
-        struct dw_dma *dw = to_dw_dma(dwc->chan.device);
-
-        dwc->dma_sconfig.slave_id -= dw->request_line_base;
-}
-
 static int
 set_runtime_config(struct dma_chan *chan, struct dma_slave_config *sconfig)
 {
@@ -1020,9 +997,12 @@ set_runtime_config(struct dma_chan *chan, struct dma_slave_config *sconfig)
         memcpy(&dwc->dma_sconfig, sconfig, sizeof(*sconfig));
         dwc->direction = sconfig->direction;
 
+        /* Take the request line from slave_id member */
+        if (dwc->request_line == ~0)
+                dwc->request_line = sconfig->slave_id;
+
         convert_burst(&dwc->dma_sconfig.src_maxburst);
         convert_burst(&dwc->dma_sconfig.dst_maxburst);
-        convert_slave_id(dwc);
 
         return 0;
 }
@@ -1030,10 +1010,11 @@ set_runtime_config(struct dma_chan *chan, struct dma_slave_config *sconfig)
 static inline void dwc_chan_pause(struct dw_dma_chan *dwc)
 {
         u32 cfglo = channel_readl(dwc, CFG_LO);
+        unsigned int count = 20;        /* timeout iterations */
 
         channel_writel(dwc, CFG_LO, cfglo | DWC_CFGL_CH_SUSP);
-        while (!(channel_readl(dwc, CFG_LO) & DWC_CFGL_FIFO_EMPTY))
-                cpu_relax();
+        while (!(channel_readl(dwc, CFG_LO) & DWC_CFGL_FIFO_EMPTY) && count--)
+                udelay(2);
 
         dwc->paused = true;
 }
@@ -1169,6 +1150,8 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
          * doesn't mean what you think it means), and status writeback.
          */
 
+        dwc_set_masters(dwc);
+
         spin_lock_irqsave(&dwc->lock, flags);
         i = dwc->descs_allocated;
         while (dwc->descs_allocated < NR_DESCS_PER_CHANNEL) {
@@ -1226,6 +1209,7 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         list_splice_init(&dwc->free_list, &list);
         dwc->descs_allocated = 0;
         dwc->initialized = false;
+        dwc->request_line = ~0;
 
         /* Disable interrupts */
         channel_clear_bit(dw, MASK.XFER, dwc->mask);
@@ -1241,42 +1225,36 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         dev_vdbg(chan2dev(chan), "%s: done\n", __func__);
 }
 
-struct dw_dma_filter_args {
+/*----------------------------------------------------------------------*/
+
+struct dw_dma_of_filter_args {
         struct dw_dma *dw;
         unsigned int req;
         unsigned int src;
         unsigned int dst;
 };
 
-static bool dw_dma_generic_filter(struct dma_chan *chan, void *param)
+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 *dw = to_dw_dma(chan->device);
-        struct dw_dma_filter_args *fargs = param;
-        struct dw_dma_slave *dws = &dwc->slave;
+        struct dw_dma_of_filter_args *fargs = param;
 
-        /* ensure the device matches our channel */
+        /* Ensure the device matches our channel */
         if (chan->device != &fargs->dw->dma)
                 return false;
 
-        dws->dma_dev    = dw->dma.dev;
-        dws->cfg_hi     = ~0;
-        dws->cfg_lo     = ~0;
-        dws->src_master = fargs->src;
-        dws->dst_master = fargs->dst;
-
         dwc->request_line = fargs->req;
-
-        chan->private = dws;
+        dwc->src_master = fargs->src;
+        dwc->dst_master = fargs->dst;
 
         return true;
 }
 
-static struct dma_chan *dw_dma_xlate(struct of_phandle_args *dma_spec,
-                                         struct of_dma *ofdma)
+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_filter_args fargs = {
+        struct dw_dma_of_filter_args fargs = {
                 .dw = dw,
         };
         dma_cap_mask_t cap;
@@ -1297,8 +1275,48 @@ static struct dma_chan *dw_dma_xlate(struct of_phandle_args *dma_spec,
         dma_cap_set(DMA_SLAVE, cap);
 
         /* TODO: there should be a simpler way to do this */
-        return dma_request_channel(cap, dw_dma_generic_filter, &fargs);
+        return dma_request_channel(cap, dw_dma_of_filter, &fargs);
+}
+
+#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;
+
+        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;
+}
+
+static void dw_dma_acpi_controller_register(struct dw_dma *dw)
+{
+        struct device *dev = dw->dma.dev;
+        struct acpi_dma_filter_info *info;
+        int ret;
+
+        info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return;
+
+        dma_cap_zero(info->dma_cap);
+        dma_cap_set(DMA_SLAVE, info->dma_cap);
+        info->filter_fn = dw_dma_acpi_filter;
+
+        ret = devm_acpi_dma_controller_register(dev, acpi_dma_simple_xlate,
+                                                info);
+        if (ret)
+                dev_err(dev, "could not register acpi_dma_controller\n");
 }
+#else /* !CONFIG_ACPI */
+static inline void dw_dma_acpi_controller_register(struct dw_dma *dw) {}
+#endif /* !CONFIG_ACPI */
 
 /* --------------------- Cyclic DMA API extensions -------------------- */
 
@@ -1322,7 +1340,7 @@ int dw_dma_cyclic_start(struct dma_chan *chan)
 
         spin_lock_irqsave(&dwc->lock, flags);
 
-        /* assert channel is idle */
+        /* Assert channel is idle */
         if (dma_readl(dw, CH_EN) & dwc->mask) {
                 dev_err(chan2dev(&dwc->chan),
                         "BUG: Attempted to start non-idle channel\n");
@@ -1334,7 +1352,7 @@ int dw_dma_cyclic_start(struct dma_chan *chan)
         dma_writel(dw, CLEAR.ERROR, dwc->mask);
         dma_writel(dw, CLEAR.XFER, dwc->mask);
 
-        /* setup DMAC channel registers */
+        /* Setup DMAC channel registers */
         channel_writel(dwc, LLP, dwc->cdesc->desc[0]->txd.phys);
         channel_writel(dwc, CTL_LO, DWC_CTLL_LLP_D_EN | DWC_CTLL_LLP_S_EN);
         channel_writel(dwc, CTL_HI, 0);
@@ -1501,7 +1519,7 @@ struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
                 last = desc;
         }
 
-        /* lets make a cyclic list */
+        /* Let's make a cyclic list */
         last->lli.llp = cdesc->desc[0]->txd.phys;
 
         dev_dbg(chan2dev(&dwc->chan), "cyclic prepared buf 0x%llx len %zu "
@@ -1636,7 +1654,6 @@ dw_dma_parse_dt(struct platform_device *pdev)
 
 static int dw_probe(struct platform_device *pdev)
 {
-        const struct platform_device_id *match;
         struct dw_dma_platform_data *pdata;
         struct resource         *io;
         struct dw_dma           *dw;
@@ -1706,7 +1723,7 @@ static int dw_probe(struct platform_device *pdev)
 
         dw->regs = regs;
 
-        /* get hardware configuration parameters */
+        /* Get hardware configuration parameters */
         if (autocfg) {
                 max_blk_size = dma_readl(dw, MAX_BLK_SIZE);
 
@@ -1720,18 +1737,13 @@ static int dw_probe(struct platform_device *pdev)
                 memcpy(dw->data_width, pdata->data_width, 4);
         }
 
-        /* Get the base request line if set */
-        match = platform_get_device_id(pdev);
-        if (match)
-                dw->request_line_base = (unsigned int)match->driver_data;
-
         /* Calculate all channel mask before DMA setup */
         dw->all_chan_mask = (1 << nr_channels) - 1;
 
-        /* force dma off, just in case */
+        /* Force dma off, just in case */
         dw_dma_off(dw);
 
-        /* disable BLOCK interrupts as well */
+        /* Disable BLOCK interrupts as well */
         channel_clear_bit(dw, MASK.BLOCK, dw->all_chan_mask);
 
         err = devm_request_irq(&pdev->dev, irq, dw_dma_interrupt, 0,
@@ -1741,7 +1753,7 @@ static int dw_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, dw);
 
-        /* create a pool of consistent memory blocks for hardware descriptors */
+        /* Create a pool of consistent memory blocks for hardware descriptors */
         dw->desc_pool = dmam_pool_create("dw_dmac_desc_pool", &pdev->dev,
                                          sizeof(struct dw_desc), 4, 0);
         if (!dw->desc_pool) {
@@ -1781,8 +1793,9 @@ static int dw_probe(struct platform_device *pdev)
                 channel_clear_bit(dw, CH_EN, dwc->mask);
 
                 dwc->direction = DMA_TRANS_NONE;
+                dwc->request_line = ~0;
 
-                /* hardware configuration */
+                /* Hardware configuration */
                 if (autocfg) {
                         unsigned int dwc_params;
 
@@ -1842,12 +1855,15 @@ static int dw_probe(struct platform_device *pdev)
 
         if (pdev->dev.of_node) {
                 err = of_dma_controller_register(pdev->dev.of_node,
-                                                 dw_dma_xlate, dw);
-                if (err && err != -ENODEV)
+                                                 dw_dma_of_xlate, dw);
+                if (err)
                         dev_err(&pdev->dev,
                                 "could not register of_dma_controller\n");
         }
 
+        if (ACPI_HANDLE(&pdev->dev))
+                dw_dma_acpi_controller_register(dw);
+
         return 0;
 }
 
@@ -1912,18 +1928,19 @@ static const struct dev_pm_ops dw_dev_pm_ops = {
 };
 
 #ifdef CONFIG_OF
-static const struct of_device_id dw_dma_id_table[] = {
+static const struct of_device_id dw_dma_of_id_table[] = {
         { .compatible = "snps,dma-spear1340" },
         {}
 };
-MODULE_DEVICE_TABLE(of, dw_dma_id_table);
+MODULE_DEVICE_TABLE(of, dw_dma_of_id_table);
 #endif
 
-static const struct platform_device_id dw_dma_ids[] = {
-        /* Name,        Request Line Base */
-        { "INTL9C60",   (kernel_ulong_t)16 },
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id dw_dma_acpi_id_table[] = {
+        { "INTL9C60", 0 },
         { }
 };
+#endif
 
 static struct platform_driver dw_driver = {
         .probe          = dw_probe,
@@ -1932,9 +1949,9 @@ static struct platform_driver dw_driver = {
         .driver = {
                 .name   = "dw_dmac",
                 .pm     = &dw_dev_pm_ops,
-                .of_match_table = of_match_ptr(dw_dma_id_table),
+                .of_match_table = of_match_ptr(dw_dma_of_id_table),
+                .acpi_match_table = ACPI_PTR(dw_dma_acpi_id_table),
         },
-        .id_table       = dw_dma_ids,
 };
 
 static int __init dw_init(void)