Merge branch 'dmaengine' of git://git.linaro.org/people/rmk/linux-arm

Pull ARM DMA engine updates from Russell King:
 "This looks scary at first glance, but what it is is:
   - a rework of the sa11x0 DMA engine driver merged during the previous
     cycle, to extract a common set of helper functions for DMA engine
     implementations.
   - conversion of amba-pl08x.c to use these helper functions.
   - addition of OMAP DMA engine driver (using these helper functions),
     and conversion of some of the OMAP DMA users to use DMA engine.

  Nothing in the helper functions is ARM specific, so I hope that other
  implementations can consolidate some of their code by making use of
  these helpers.

  This has been sitting in linux-next most of the merge cycle, and has
  been tested by several OMAP folk.  I've tested it on sa11x0 platforms,
  and given it my best shot on my broken platforms which have the
  amba-pl08x controller.

  The last point is the addition to feature-removal-schedule.txt, which
  will have a merge conflict.  Between myself and TI, we're planning to
  remove the old TI DMA implementation next year."

Fix up trivial add/add conflicts in Documentation/feature-removal-schedule.txt
and drivers/dma/{Kconfig,Makefile}

* 'dmaengine' of git://git.linaro.org/people/rmk/linux-arm: (53 commits)
  ARM: 7481/1: OMAP2+: omap2plus_defconfig: enable OMAP DMA engine
  ARM: 7464/1: mmc: omap_hsmmc: ensure probe returns error if DMA channel request fails
  Add feature removal of old OMAP private DMA implementation
  mtd: omap2: remove private DMA API implementation
  mtd: omap2: add DMA engine support
  spi: omap2-mcspi: remove private DMA API implementation
  spi: omap2-mcspi: add DMA engine support
  ARM: omap: remove mmc platform data dma_mask and initialization
  mmc: omap: remove private DMA API implementation
  mmc: omap: add DMA engine support
  mmc: omap_hsmmc: remove private DMA API implementation
  mmc: omap_hsmmc: add DMA engine support
  dmaengine: omap: add support for cyclic DMA
  dmaengine: omap: add support for setting fi
  dmaengine: omap: add support for returning residue in tx_state method
  dmaengine: add OMAP DMA engine driver
  dmaengine: sa11x0-dma: add cyclic DMA support
  dmaengine: sa11x0-dma: fix DMA residue support
  dmaengine: PL08x: ensure all descriptors are freed when channel is released
  dmaengine: PL08x: get rid of write only pool_ctr and free_txd locking
  ...

2 files changed, 265 insertions, 307 deletions

diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index 3e8dcf8d2e05..50e08f03aa65 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -17,10 +17,12 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
+#include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
 #include <linux/timer.h>
+#include <linux/omap-dma.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/clk.h>
@@ -128,6 +130,10 @@ struct mmc_omap_host {
         unsigned char           id; /* 16xx chips have 2 MMC blocks */
         struct clk *            iclk;
         struct clk *            fclk;
+        struct dma_chan         *dma_rx;
+        u32                     dma_rx_burst;
+        struct dma_chan         *dma_tx;
+        u32                     dma_tx_burst;
         struct resource         *mem_res;
         void __iomem            *virt_base;
         unsigned int            phys_base;
@@ -153,12 +159,8 @@ struct mmc_omap_host {
 
         unsigned                use_dma:1;
         unsigned                brs_received:1, dma_done:1;
-        unsigned                dma_is_read:1;
         unsigned                dma_in_use:1;
-        int                     dma_ch;
         spinlock_t              dma_lock;
-        struct timer_list       dma_timer;
-        unsigned                dma_len;
 
         struct mmc_omap_slot    *slots[OMAP_MMC_MAX_SLOTS];
         struct mmc_omap_slot    *current_slot;
@@ -406,18 +408,25 @@ mmc_omap_release_dma(struct mmc_omap_host *host, struct mmc_data *data,
                      int abort)
 {
         enum dma_data_direction dma_data_dir;
+        struct device *dev = mmc_dev(host->mmc);
+        struct dma_chan *c;
 
-        BUG_ON(host->dma_ch < 0);
-        if (data->error)
-                omap_stop_dma(host->dma_ch);
-        /* Release DMA channel lazily */
-        mod_timer(&host->dma_timer, jiffies + HZ);
-        if (data->flags & MMC_DATA_WRITE)
+        if (data->flags & MMC_DATA_WRITE) {
                 dma_data_dir = DMA_TO_DEVICE;
-        else
+                c = host->dma_tx;
+        } else {
                 dma_data_dir = DMA_FROM_DEVICE;
-        dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->sg_len,
-                     dma_data_dir);
+                c = host->dma_rx;
+        }
+        if (c) {
+                if (data->error) {
+                        dmaengine_terminate_all(c);
+                        /* Claim nothing transferred on error... */
+                        data->bytes_xfered = 0;
+                }
+                dev = c->device->dev;
+        }
+        dma_unmap_sg(dev, data->sg, host->sg_len, dma_data_dir);
 }
 
 static void mmc_omap_send_stop_work(struct work_struct *work)
@@ -525,16 +534,6 @@ mmc_omap_end_of_data(struct mmc_omap_host *host, struct mmc_data *data)
 }
 
 static void
-mmc_omap_dma_timer(unsigned long data)
-{
-        struct mmc_omap_host *host = (struct mmc_omap_host *) data;
-
-        BUG_ON(host->dma_ch < 0);
-        omap_free_dma(host->dma_ch);
-        host->dma_ch = -1;
-}
-
-static void
 mmc_omap_dma_done(struct mmc_omap_host *host, struct mmc_data *data)
 {
         unsigned long flags;
@@ -891,159 +890,15 @@ static void mmc_omap_cover_handler(unsigned long param)
                   jiffies + msecs_to_jiffies(OMAP_MMC_COVER_POLL_DELAY));
 }
 
-/* Prepare to transfer the next segment of a scatterlist */
-static void
-mmc_omap_prepare_dma(struct mmc_omap_host *host, struct mmc_data *data)
+static void mmc_omap_dma_callback(void *priv)
 {
-        int dma_ch = host->dma_ch;
-        unsigned long data_addr;
-        u16 buf, frame;
-        u32 count;
-        struct scatterlist *sg = &data->sg[host->sg_idx];
-        int src_port = 0;
-        int dst_port = 0;
-        int sync_dev = 0;
-
-        data_addr = host->phys_base + OMAP_MMC_REG(host, DATA);
-        frame = data->blksz;
-        count = sg_dma_len(sg);
-
-        if ((data->blocks == 1) && (count > data->blksz))
-                count = frame;
-
-        host->dma_len = count;
-
-        /* FIFO is 16x2 bytes on 15xx, and 32x2 bytes on 16xx and 24xx.
-         * Use 16 or 32 word frames when the blocksize is at least that large.
-         * Blocksize is usually 512 bytes; but not for some SD reads.
-         */
-        if (cpu_is_omap15xx() && frame > 32)
-                frame = 32;
-        else if (frame > 64)
-                frame = 64;
-        count /= frame;
-        frame >>= 1;
-
-        if (!(data->flags & MMC_DATA_WRITE)) {
-                buf = 0x800f | ((frame - 1) << 8);
-
-                if (cpu_class_is_omap1()) {
-                        src_port = OMAP_DMA_PORT_TIPB;
-                        dst_port = OMAP_DMA_PORT_EMIFF;
-                }
-                if (cpu_is_omap24xx())
-                        sync_dev = OMAP24XX_DMA_MMC1_RX;
-
-                omap_set_dma_src_params(dma_ch, src_port,
-                                        OMAP_DMA_AMODE_CONSTANT,
-                                        data_addr, 0, 0);
-                omap_set_dma_dest_params(dma_ch, dst_port,
-                                         OMAP_DMA_AMODE_POST_INC,
-                                         sg_dma_address(sg), 0, 0);
-                omap_set_dma_dest_data_pack(dma_ch, 1);
-                omap_set_dma_dest_burst_mode(dma_ch, OMAP_DMA_DATA_BURST_4);
-        } else {
-                buf = 0x0f80 | ((frame - 1) << 0);
-
-                if (cpu_class_is_omap1()) {
-                        src_port = OMAP_DMA_PORT_EMIFF;
-                        dst_port = OMAP_DMA_PORT_TIPB;
-                }
-                if (cpu_is_omap24xx())
-                        sync_dev = OMAP24XX_DMA_MMC1_TX;
-
-                omap_set_dma_dest_params(dma_ch, dst_port,
-                                         OMAP_DMA_AMODE_CONSTANT,
-                                         data_addr, 0, 0);
-                omap_set_dma_src_params(dma_ch, src_port,
-                                        OMAP_DMA_AMODE_POST_INC,
-                                        sg_dma_address(sg), 0, 0);
-                omap_set_dma_src_data_pack(dma_ch, 1);
-                omap_set_dma_src_burst_mode(dma_ch, OMAP_DMA_DATA_BURST_4);
-        }
+        struct mmc_omap_host *host = priv;
+        struct mmc_data *data = host->data;
 
-        /* Max limit for DMA frame count is 0xffff */
-        BUG_ON(count > 0xffff);
+        /* If we got to the end of DMA, assume everything went well */
+        data->bytes_xfered += data->blocks * data->blksz;
 
-        OMAP_MMC_WRITE(host, BUF, buf);
-        omap_set_dma_transfer_params(dma_ch, OMAP_DMA_DATA_TYPE_S16,
-                                     frame, count, OMAP_DMA_SYNC_FRAME,
-                                     sync_dev, 0);
-}
-
-/* A scatterlist segment completed */
-static void mmc_omap_dma_cb(int lch, u16 ch_status, void *data)
-{
-        struct mmc_omap_host *host = (struct mmc_omap_host *) data;
-        struct mmc_data *mmcdat = host->data;
-
-        if (unlikely(host->dma_ch < 0)) {
-                dev_err(mmc_dev(host->mmc),
-                        "DMA callback while DMA not enabled\n");
-                return;
-        }
-        /* FIXME: We really should do something to _handle_ the errors */
-        if (ch_status & OMAP1_DMA_TOUT_IRQ) {
-                dev_err(mmc_dev(host->mmc),"DMA timeout\n");
-                return;
-        }
-        if (ch_status & OMAP_DMA_DROP_IRQ) {
-                dev_err(mmc_dev(host->mmc), "DMA sync error\n");
-                return;
-        }
-        if (!(ch_status & OMAP_DMA_BLOCK_IRQ)) {
-                return;
-        }
-        mmcdat->bytes_xfered += host->dma_len;
-        host->sg_idx++;
-        if (host->sg_idx < host->sg_len) {
-                mmc_omap_prepare_dma(host, host->data);
-                omap_start_dma(host->dma_ch);
-        } else
-                mmc_omap_dma_done(host, host->data);
-}
-
-static int mmc_omap_get_dma_channel(struct mmc_omap_host *host, struct mmc_data *data)
-{
-        const char *dma_dev_name;
-        int sync_dev, dma_ch, is_read, r;
-
-        is_read = !(data->flags & MMC_DATA_WRITE);
-        del_timer_sync(&host->dma_timer);
-        if (host->dma_ch >= 0) {
-                if (is_read == host->dma_is_read)
-                        return 0;
-                omap_free_dma(host->dma_ch);
-                host->dma_ch = -1;
-        }
-
-        if (is_read) {
-                if (host->id == 0) {
-                        sync_dev = OMAP_DMA_MMC_RX;
-                        dma_dev_name = "MMC1 read";
-                } else {
-                        sync_dev = OMAP_DMA_MMC2_RX;
-                        dma_dev_name = "MMC2 read";
-                }
-        } else {
-                if (host->id == 0) {
-                        sync_dev = OMAP_DMA_MMC_TX;
-                        dma_dev_name = "MMC1 write";
-                } else {
-                        sync_dev = OMAP_DMA_MMC2_TX;
-                        dma_dev_name = "MMC2 write";
-                }
-        }
-        r = omap_request_dma(sync_dev, dma_dev_name, mmc_omap_dma_cb,
-                             host, &dma_ch);
-        if (r != 0) {
-                dev_dbg(mmc_dev(host->mmc), "omap_request_dma() failed with %d\n", r);
-                return r;
-        }
-        host->dma_ch = dma_ch;
-        host->dma_is_read = is_read;
-
-        return 0;
+        mmc_omap_dma_done(host, data);
 }
 
 static inline void set_cmd_timeout(struct mmc_omap_host *host, struct mmc_request *req)
@@ -1118,33 +973,85 @@ mmc_omap_prepare_data(struct mmc_omap_host *host, struct mmc_request *req)
 
         host->sg_idx = 0;
         if (use_dma) {
-                if (mmc_omap_get_dma_channel(host, data) == 0) {
-                        enum dma_data_direction dma_data_dir;
-
-                        if (data->flags & MMC_DATA_WRITE)
-                                dma_data_dir = DMA_TO_DEVICE;
-                        else
-                                dma_data_dir = DMA_FROM_DEVICE;
-
-                        host->sg_len = dma_map_sg(mmc_dev(host->mmc), data->sg,
-                                                sg_len, dma_data_dir);
-                        host->total_bytes_left = 0;
-                        mmc_omap_prepare_dma(host, req->data);
-                        host->brs_received = 0;
-                        host->dma_done = 0;
-                        host->dma_in_use = 1;
-                } else
-                        use_dma = 0;
+                enum dma_data_direction dma_data_dir;
+                struct dma_async_tx_descriptor *tx;
+                struct dma_chan *c;
+                u32 burst, *bp;
+                u16 buf;
+
+                /*
+                 * FIFO is 16x2 bytes on 15xx, and 32x2 bytes on 16xx
+                 * and 24xx. Use 16 or 32 word frames when the
+                 * blocksize is at least that large. Blocksize is
+                 * usually 512 bytes; but not for some SD reads.
+                 */
+                burst = cpu_is_omap15xx() ? 32 : 64;
+                if (burst > data->blksz)
+                        burst = data->blksz;
+
+                burst >>= 1;
+
+                if (data->flags & MMC_DATA_WRITE) {
+                        c = host->dma_tx;
+                        bp = &host->dma_tx_burst;
+                        buf = 0x0f80 | (burst - 1) << 0;
+                        dma_data_dir = DMA_TO_DEVICE;
+                } else {
+                        c = host->dma_rx;
+                        bp = &host->dma_rx_burst;
+                        buf = 0x800f | (burst - 1) << 8;
+                        dma_data_dir = DMA_FROM_DEVICE;
+                }
+
+                if (!c)
+                        goto use_pio;
+
+                /* Only reconfigure if we have a different burst size */
+                if (*bp != burst) {
+                        struct dma_slave_config cfg;
+
+                        cfg.src_addr = host->phys_base + OMAP_MMC_REG(host, DATA);
+                        cfg.dst_addr = host->phys_base + OMAP_MMC_REG(host, DATA);
+                        cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
+                        cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
+                        cfg.src_maxburst = burst;
+                        cfg.dst_maxburst = burst;
+
+                        if (dmaengine_slave_config(c, &cfg))
+                                goto use_pio;
+
+                        *bp = burst;
+                }
+
+                host->sg_len = dma_map_sg(c->device->dev, data->sg, sg_len,
+                                          dma_data_dir);
+                if (host->sg_len == 0)
+                        goto use_pio;
+
+                tx = dmaengine_prep_slave_sg(c, data->sg, host->sg_len,
+                        data->flags & MMC_DATA_WRITE ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
+                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+                if (!tx)
+                        goto use_pio;
+
+                OMAP_MMC_WRITE(host, BUF, buf);
+
+                tx->callback = mmc_omap_dma_callback;
+                tx->callback_param = host;
+                dmaengine_submit(tx);
+                host->brs_received = 0;
+                host->dma_done = 0;
+                host->dma_in_use = 1;
+                return;
         }
+ use_pio:
 
         /* Revert to PIO? */
-        if (!use_dma) {
-                OMAP_MMC_WRITE(host, BUF, 0x1f1f);
-                host->total_bytes_left = data->blocks * block_size;
-                host->sg_len = sg_len;
-                mmc_omap_sg_to_buf(host);
-                host->dma_in_use = 0;
-        }
+        OMAP_MMC_WRITE(host, BUF, 0x1f1f);
+        host->total_bytes_left = data->blocks * block_size;
+        host->sg_len = sg_len;
+        mmc_omap_sg_to_buf(host);
+        host->dma_in_use = 0;
 }
 
 static void mmc_omap_start_request(struct mmc_omap_host *host,
@@ -1157,8 +1064,12 @@ static void mmc_omap_start_request(struct mmc_omap_host *host,
         /* only touch fifo AFTER the controller readies it */
         mmc_omap_prepare_data(host, req);
         mmc_omap_start_command(host, req->cmd);
-        if (host->dma_in_use)
-                omap_start_dma(host->dma_ch);
+        if (host->dma_in_use) {
+                struct dma_chan *c = host->data->flags & MMC_DATA_WRITE ?
+                                host->dma_tx : host->dma_rx;
+
+                dma_async_issue_pending(c);
+        }
 }
 
 static void mmc_omap_request(struct mmc_host *mmc, struct mmc_request *req)
@@ -1400,6 +1311,8 @@ static int __devinit mmc_omap_probe(struct platform_device *pdev)
         struct omap_mmc_platform_data *pdata = pdev->dev.platform_data;
         struct mmc_omap_host *host = NULL;
         struct resource *res;
+        dma_cap_mask_t mask;
+        unsigned sig;
         int i, ret = 0;
         int irq;
 
@@ -1439,7 +1352,6 @@ static int __devinit mmc_omap_probe(struct platform_device *pdev)
         setup_timer(&host->clk_timer, mmc_omap_clk_timer, (unsigned long) host);
 
         spin_lock_init(&host->dma_lock);
-        setup_timer(&host->dma_timer, mmc_omap_dma_timer, (unsigned long) host);
         spin_lock_init(&host->slot_lock);
         init_waitqueue_head(&host->slot_wq);
 
@@ -1450,11 +1362,7 @@ static int __devinit mmc_omap_probe(struct platform_device *pdev)
         host->id = pdev->id;
         host->mem_res = res;
         host->irq = irq;
-
         host->use_dma = 1;
-        host->dev->dma_mask = &pdata->dma_mask;
-        host->dma_ch = -1;
-
         host->irq = irq;
         host->phys_base = host->mem_res->start;
         host->virt_base = ioremap(res->start, resource_size(res));
@@ -1474,9 +1382,48 @@ static int __devinit mmc_omap_probe(struct platform_device *pdev)
                 goto err_free_iclk;
         }
 
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        host->dma_tx_burst = -1;
+        host->dma_rx_burst = -1;
+
+        if (cpu_is_omap24xx())
+                sig = host->id == 0 ? OMAP24XX_DMA_MMC1_TX : OMAP24XX_DMA_MMC2_TX;
+        else
+                sig = host->id == 0 ? OMAP_DMA_MMC_TX : OMAP_DMA_MMC2_TX;
+        host->dma_tx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
+#if 0
+        if (!host->dma_tx) {
+                dev_err(host->dev, "unable to obtain TX DMA engine channel %u\n",
+                        sig);
+                goto err_dma;
+        }
+#else
+        if (!host->dma_tx)
+                dev_warn(host->dev, "unable to obtain TX DMA engine channel %u\n",
+                        sig);
+#endif
+        if (cpu_is_omap24xx())
+                sig = host->id == 0 ? OMAP24XX_DMA_MMC1_RX : OMAP24XX_DMA_MMC2_RX;
+        else
+                sig = host->id == 0 ? OMAP_DMA_MMC_RX : OMAP_DMA_MMC2_RX;
+        host->dma_rx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
+#if 0
+        if (!host->dma_rx) {
+                dev_err(host->dev, "unable to obtain RX DMA engine channel %u\n",
+                        sig);
+                goto err_dma;
+        }
+#else
+        if (!host->dma_rx)
+                dev_warn(host->dev, "unable to obtain RX DMA engine channel %u\n",
+                        sig);
+#endif
+
         ret = request_irq(host->irq, mmc_omap_irq, 0, DRIVER_NAME, host);
         if (ret)
-                goto err_free_fclk;
+                goto err_free_dma;
 
         if (pdata->init != NULL) {
                 ret = pdata->init(&pdev->dev);
@@ -1510,7 +1457,11 @@ err_plat_cleanup:
                 pdata->cleanup(&pdev->dev);
 err_free_irq:
         free_irq(host->irq, host);
-err_free_fclk:
+err_free_dma:
+        if (host->dma_tx)
+                dma_release_channel(host->dma_tx);
+        if (host->dma_rx)
+                dma_release_channel(host->dma_rx);
         clk_put(host->fclk);
 err_free_iclk:
         clk_disable(host->iclk);
@@ -1545,6 +1496,11 @@ static int __devexit mmc_omap_remove(struct platform_device *pdev)
         clk_disable(host->iclk);
         clk_put(host->iclk);
 
+        if (host->dma_tx)
+                dma_release_channel(host->dma_tx);
+        if (host->dma_rx)
+                dma_release_channel(host->dma_rx);
+
         iounmap(host->virt_base);
         release_mem_region(pdev->resource[0].start,
                            pdev->resource[0].end - pdev->resource[0].start + 1);
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index bc28627af66b..3a09f93cc3b6 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -19,6 +19,7 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/debugfs.h>
+#include <linux/dmaengine.h>
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
@@ -29,6 +30,7 @@
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/of_device.h>
+#include <linux/omap-dma.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/core.h>
 #include <linux/mmc/mmc.h>
@@ -37,7 +39,6 @@
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
-#include <plat/dma.h>
 #include <mach/hardware.h>
 #include <plat/board.h>
 #include <plat/mmc.h>
@@ -166,7 +167,8 @@ struct omap_hsmmc_host {
         int                     suspended;
         int                     irq;
         int                     use_dma, dma_ch;
-        int                     dma_line_tx, dma_line_rx;
+        struct dma_chan         *tx_chan;
+        struct dma_chan         *rx_chan;
         int                     slot_id;
         int                     response_busy;
         int                     context_loss;
@@ -797,6 +799,12 @@ omap_hsmmc_get_dma_dir(struct omap_hsmmc_host *host, struct mmc_data *data)
                 return DMA_FROM_DEVICE;
 }
 
+static struct dma_chan *omap_hsmmc_get_dma_chan(struct omap_hsmmc_host *host,
+        struct mmc_data *data)
+{
+        return data->flags & MMC_DATA_WRITE ? host->tx_chan : host->rx_chan;
+}
+
 static void omap_hsmmc_request_done(struct omap_hsmmc_host *host, struct mmc_request *mrq)
 {
         int dma_ch;
@@ -889,10 +897,13 @@ static void omap_hsmmc_dma_cleanup(struct omap_hsmmc_host *host, int errno)
         spin_unlock_irqrestore(&host->irq_lock, flags);
 
         if (host->use_dma && dma_ch != -1) {
-                dma_unmap_sg(mmc_dev(host->mmc), host->data->sg,
-                        host->data->sg_len,
+                struct dma_chan *chan = omap_hsmmc_get_dma_chan(host, host->data);
+
+                dmaengine_terminate_all(chan);
+                dma_unmap_sg(chan->device->dev,
+                        host->data->sg, host->data->sg_len,
                         omap_hsmmc_get_dma_dir(host, host->data));
-                omap_free_dma(dma_ch);
+
                 host->data->host_cookie = 0;
         }
         host->data = NULL;
@@ -1190,90 +1201,29 @@ static irqreturn_t omap_hsmmc_detect(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int omap_hsmmc_get_dma_sync_dev(struct omap_hsmmc_host *host,
-                                     struct mmc_data *data)
-{
-        int sync_dev;
-
-        if (data->flags & MMC_DATA_WRITE)
-                sync_dev = host->dma_line_tx;
-        else
-                sync_dev = host->dma_line_rx;
-        return sync_dev;
-}
-
-static void omap_hsmmc_config_dma_params(struct omap_hsmmc_host *host,
-                                       struct mmc_data *data,
-                                       struct scatterlist *sgl)
-{
-        int blksz, nblk, dma_ch;
-
-        dma_ch = host->dma_ch;
-        if (data->flags & MMC_DATA_WRITE) {
-                omap_set_dma_dest_params(dma_ch, 0, OMAP_DMA_AMODE_CONSTANT,
-                        (host->mapbase + OMAP_HSMMC_DATA), 0, 0);
-                omap_set_dma_src_params(dma_ch, 0, OMAP_DMA_AMODE_POST_INC,
-                        sg_dma_address(sgl), 0, 0);
-        } else {
-                omap_set_dma_src_params(dma_ch, 0, OMAP_DMA_AMODE_CONSTANT,
-                        (host->mapbase + OMAP_HSMMC_DATA), 0, 0);
-                omap_set_dma_dest_params(dma_ch, 0, OMAP_DMA_AMODE_POST_INC,
-                        sg_dma_address(sgl), 0, 0);
-        }
-
-        blksz = host->data->blksz;
-        nblk = sg_dma_len(sgl) / blksz;
-
-        omap_set_dma_transfer_params(dma_ch, OMAP_DMA_DATA_TYPE_S32,
-                        blksz / 4, nblk, OMAP_DMA_SYNC_FRAME,
-                        omap_hsmmc_get_dma_sync_dev(host, data),
-                        !(data->flags & MMC_DATA_WRITE));
-
-        omap_start_dma(dma_ch);
-}
-
-/*
- * DMA call back function
- */
-static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
+static void omap_hsmmc_dma_callback(void *param)
 {
-        struct omap_hsmmc_host *host = cb_data;
+        struct omap_hsmmc_host *host = param;
+        struct dma_chan *chan;
         struct mmc_data *data;
-        int dma_ch, req_in_progress;
-        unsigned long flags;
-
-        if (!(ch_status & OMAP_DMA_BLOCK_IRQ)) {
-                dev_warn(mmc_dev(host->mmc), "unexpected dma status %x\n",
-                        ch_status);
-                return;
-        }
+        int req_in_progress;
 
-        spin_lock_irqsave(&host->irq_lock, flags);
+        spin_lock_irq(&host->irq_lock);
         if (host->dma_ch < 0) {
-                spin_unlock_irqrestore(&host->irq_lock, flags);
+                spin_unlock_irq(&host->irq_lock);
                 return;
         }
 
         data = host->mrq->data;
-        host->dma_sg_idx++;
-        if (host->dma_sg_idx < host->dma_len) {
-                /* Fire up the next transfer. */
-                omap_hsmmc_config_dma_params(host, data,
-                                           data->sg + host->dma_sg_idx);
-                spin_unlock_irqrestore(&host->irq_lock, flags);
-                return;
-        }
-
+        chan = omap_hsmmc_get_dma_chan(host, data);
         if (!data->host_cookie)
-                dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
+                dma_unmap_sg(chan->device->dev,
+                             data->sg, data->sg_len,
                              omap_hsmmc_get_dma_dir(host, data));
 
         req_in_progress = host->req_in_progress;
-        dma_ch = host->dma_ch;
         host->dma_ch = -1;
-        spin_unlock_irqrestore(&host->irq_lock, flags);
-
-        omap_free_dma(dma_ch);
+        spin_unlock_irq(&host->irq_lock);
 
         /* If DMA has finished after TC, complete the request */
         if (!req_in_progress) {
@@ -1286,7 +1236,8 @@ static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
 
 static int omap_hsmmc_pre_dma_transfer(struct omap_hsmmc_host *host,
                                        struct mmc_data *data,
-                                       struct omap_hsmmc_next *next)
+                                       struct omap_hsmmc_next *next,
+                                       struct dma_chan *chan)
 {
         int dma_len;
 
@@ -1301,8 +1252,7 @@ static int omap_hsmmc_pre_dma_transfer(struct omap_hsmmc_host *host,
         /* Check if next job is already prepared */
         if (next ||
             (!next && data->host_cookie != host->next_data.cookie)) {
-                dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg,
-                                     data->sg_len,
+                dma_len = dma_map_sg(chan->device->dev, data->sg, data->sg_len,
                                      omap_hsmmc_get_dma_dir(host, data));
 
         } else {
@@ -1329,8 +1279,11 @@ static int omap_hsmmc_pre_dma_transfer(struct omap_hsmmc_host *host,
 static int omap_hsmmc_start_dma_transfer(struct omap_hsmmc_host *host,
                                         struct mmc_request *req)
 {
-        int dma_ch = 0, ret = 0, i;
+        struct dma_slave_config cfg;
+        struct dma_async_tx_descriptor *tx;
+        int ret = 0, i;
         struct mmc_data *data = req->data;
+        struct dma_chan *chan;
 
         /* Sanity check: all the SG entries must be aligned by block size. */
         for (i = 0; i < data->sg_len; i++) {
@@ -1348,22 +1301,41 @@ static int omap_hsmmc_start_dma_transfer(struct omap_hsmmc_host *host,
 
         BUG_ON(host->dma_ch != -1);
 
-        ret = omap_request_dma(omap_hsmmc_get_dma_sync_dev(host, data),
-                               "MMC/SD", omap_hsmmc_dma_cb, host, &dma_ch);
-        if (ret != 0) {
-                dev_err(mmc_dev(host->mmc),
-                        "%s: omap_request_dma() failed with %d\n",
-                        mmc_hostname(host->mmc), ret);
+        chan = omap_hsmmc_get_dma_chan(host, data);
+
+        cfg.src_addr = host->mapbase + OMAP_HSMMC_DATA;
+        cfg.dst_addr = host->mapbase + OMAP_HSMMC_DATA;
+        cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        cfg.src_maxburst = data->blksz / 4;
+        cfg.dst_maxburst = data->blksz / 4;
+
+        ret = dmaengine_slave_config(chan, &cfg);
+        if (ret)
                 return ret;
-        }
-        ret = omap_hsmmc_pre_dma_transfer(host, data, NULL);
+
+        ret = omap_hsmmc_pre_dma_transfer(host, data, NULL, chan);
         if (ret)
                 return ret;
 
-        host->dma_ch = dma_ch;
-        host->dma_sg_idx = 0;
+        tx = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
+                data->flags & MMC_DATA_WRITE ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
+                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!tx) {
+                dev_err(mmc_dev(host->mmc), "prep_slave_sg() failed\n");
+                /* FIXME: cleanup */
+                return -1;
+        }
+
+        tx->callback = omap_hsmmc_dma_callback;
+        tx->callback_param = host;
 
-        omap_hsmmc_config_dma_params(host, data, data->sg);
+        /* Does not fail */
+        dmaengine_submit(tx);
+
+        host->dma_ch = 1;
+
+        dma_async_issue_pending(chan);
 
         return 0;
 }
@@ -1445,11 +1417,11 @@ static void omap_hsmmc_post_req(struct mmc_host *mmc, struct mmc_request *mrq,
         struct omap_hsmmc_host *host = mmc_priv(mmc);
         struct mmc_data *data = mrq->data;
 
-        if (host->use_dma) {
-                if (data->host_cookie)
-                        dma_unmap_sg(mmc_dev(host->mmc), data->sg,
-                                     data->sg_len,
-                                     omap_hsmmc_get_dma_dir(host, data));
+        if (host->use_dma && data->host_cookie) {
+                struct dma_chan *c = omap_hsmmc_get_dma_chan(host, data);
+
+                dma_unmap_sg(c->device->dev, data->sg, data->sg_len,
+                             omap_hsmmc_get_dma_dir(host, data));
                 data->host_cookie = 0;
         }
 }
@@ -1464,10 +1436,13 @@ static void omap_hsmmc_pre_req(struct mmc_host *mmc, struct mmc_request *mrq,
                 return ;
         }
 
-        if (host->use_dma)
+        if (host->use_dma) {
+                struct dma_chan *c = omap_hsmmc_get_dma_chan(host, mrq->data);
+
                 if (omap_hsmmc_pre_dma_transfer(host, mrq->data,
-                                                &host->next_data))
+                                                &host->next_data, c))
                         mrq->data->host_cookie = 0;
+        }
 }
 
 /*
@@ -1800,6 +1775,8 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
         struct resource *res;
         int ret, irq;
         const struct of_device_id *match;
+        dma_cap_mask_t mask;
+        unsigned tx_req, rx_req;
 
         match = of_match_device(of_match_ptr(omap_mmc_of_match), &pdev->dev);
         if (match) {
@@ -1844,7 +1821,6 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
         host->pdata     = pdata;
         host->dev       = &pdev->dev;
         host->use_dma   = 1;
-        host->dev->dma_mask = &pdata->dma_mask;
         host->dma_ch    = -1;
         host->irq       = irq;
         host->slot_id   = 0;
@@ -1934,7 +1910,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
                 ret = -ENXIO;
                 goto err_irq;
         }
-        host->dma_line_tx = res->start;
+        tx_req = res->start;
 
         res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx");
         if (!res) {
@@ -1942,7 +1918,24 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
                 ret = -ENXIO;
                 goto err_irq;
         }
-        host->dma_line_rx = res->start;
+        rx_req = res->start;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        host->rx_chan = dma_request_channel(mask, omap_dma_filter_fn, &rx_req);
+        if (!host->rx_chan) {
+                dev_err(mmc_dev(host->mmc), "unable to obtain RX DMA engine channel %u\n", rx_req);
+                ret = -ENXIO;
+                goto err_irq;
+        }
+
+        host->tx_chan = dma_request_channel(mask, omap_dma_filter_fn, &tx_req);
+        if (!host->tx_chan) {
+                dev_err(mmc_dev(host->mmc), "unable to obtain TX DMA engine channel %u\n", tx_req);
+                ret = -ENXIO;
+                goto err_irq;
+        }
 
         /* Request IRQ for MMC operations */
         ret = request_irq(host->irq, omap_hsmmc_irq, 0,
@@ -2021,6 +2014,10 @@ err_reg:
 err_irq_cd_init:
         free_irq(host->irq, host);
 err_irq:
+        if (host->tx_chan)
+                dma_release_channel(host->tx_chan);
+        if (host->rx_chan)
+                dma_release_channel(host->rx_chan);
         pm_runtime_put_sync(host->dev);
         pm_runtime_disable(host->dev);
         clk_put(host->fclk);
@@ -2056,6 +2053,11 @@ static int __devexit omap_hsmmc_remove(struct platform_device *pdev)
         if (mmc_slot(host).card_detect_irq)
                 free_irq(mmc_slot(host).card_detect_irq, host);
 
+        if (host->tx_chan)
+                dma_release_channel(host->tx_chan);
+        if (host->rx_chan)
+                dma_release_channel(host->rx_chan);
+
         pm_runtime_put_sync(host->dev);
         pm_runtime_disable(host->dev);
         clk_put(host->fclk);