dmaengine: add OMAP DMA engine driver

Tested-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

4 files changed, 553 insertions, 0 deletions

diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index eb2b60e8e1cb..8be3bf68c0bd 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -261,6 +261,12 @@ config DMA_SA11X0
           SA-1110 SoCs.  This DMA engine can only be used with on-chip
           devices.
 
+config DMA_OMAP
+        tristate "OMAP DMA support"
+        depends on ARCH_OMAP
+        select DMA_ENGINE
+        select DMA_VIRTUAL_CHANNELS
+
 config DMA_ENGINE
         bool
 
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index fc05f7ddac7e..ddc291a2116a 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -29,3 +29,4 @@ obj-$(CONFIG_PCH_DMA) += pch_dma.o
 obj-$(CONFIG_AMBA_PL08X) += amba-pl08x.o
 obj-$(CONFIG_EP93XX_DMA) += ep93xx_dma.o
 obj-$(CONFIG_DMA_SA11X0) += sa11x0-dma.o
+obj-$(CONFIG_DMA_OMAP) += omap-dma.o
diff --git a/drivers/dma/omap-dma.c b/drivers/dma/omap-dma.c
new file mode 100644
index 000000000000..fe33ddd8eb0f
--- /dev/null
+++ b/drivers/dma/omap-dma.c
@@ -0,0 +1,524 @@
+/*
+ * OMAP DMAengine support
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/omap-dma.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include "virt-dma.h"
+#include <plat/dma.h>
+
+struct omap_dmadev {
+        struct dma_device ddev;
+        spinlock_t lock;
+        struct tasklet_struct task;
+        struct list_head pending;
+};
+
+struct omap_chan {
+        struct virt_dma_chan vc;
+        struct list_head node;
+
+        struct dma_slave_config cfg;
+        unsigned dma_sig;
+
+        int dma_ch;
+        struct omap_desc *desc;
+        unsigned sgidx;
+};
+
+struct omap_sg {
+        dma_addr_t addr;
+        uint32_t en;            /* number of elements (24-bit) */
+        uint32_t fn;            /* number of frames (16-bit) */
+};
+
+struct omap_desc {
+        struct virt_dma_desc vd;
+        enum dma_transfer_direction dir;
+        dma_addr_t dev_addr;
+
+        uint8_t es;             /* OMAP_DMA_DATA_TYPE_xxx */
+        uint8_t sync_mode;      /* OMAP_DMA_SYNC_xxx */
+        uint8_t sync_type;      /* OMAP_DMA_xxx_SYNC* */
+        uint8_t periph_port;    /* Peripheral port */
+
+        unsigned sglen;
+        struct omap_sg sg[0];
+};
+
+static const unsigned es_bytes[] = {
+        [OMAP_DMA_DATA_TYPE_S8] = 1,
+        [OMAP_DMA_DATA_TYPE_S16] = 2,
+        [OMAP_DMA_DATA_TYPE_S32] = 4,
+};
+
+static inline struct omap_dmadev *to_omap_dma_dev(struct dma_device *d)
+{
+        return container_of(d, struct omap_dmadev, ddev);
+}
+
+static inline struct omap_chan *to_omap_dma_chan(struct dma_chan *c)
+{
+        return container_of(c, struct omap_chan, vc.chan);
+}
+
+static inline struct omap_desc *to_omap_dma_desc(struct dma_async_tx_descriptor *t)
+{
+        return container_of(t, struct omap_desc, vd.tx);
+}
+
+static void omap_dma_desc_free(struct virt_dma_desc *vd)
+{
+        kfree(container_of(vd, struct omap_desc, vd));
+}
+
+static void omap_dma_start_sg(struct omap_chan *c, struct omap_desc *d,
+        unsigned idx)
+{
+        struct omap_sg *sg = d->sg + idx;
+
+        if (d->dir == DMA_DEV_TO_MEM)
+                omap_set_dma_dest_params(c->dma_ch, OMAP_DMA_PORT_EMIFF,
+                        OMAP_DMA_AMODE_POST_INC, sg->addr, 0, 0);
+        else
+                omap_set_dma_src_params(c->dma_ch, OMAP_DMA_PORT_EMIFF,
+                        OMAP_DMA_AMODE_POST_INC, sg->addr, 0, 0);
+
+        omap_set_dma_transfer_params(c->dma_ch, d->es, sg->en, sg->fn,
+                d->sync_mode, c->dma_sig, d->sync_type);
+
+        omap_start_dma(c->dma_ch);
+}
+
+static void omap_dma_start_desc(struct omap_chan *c)
+{
+        struct virt_dma_desc *vd = vchan_next_desc(&c->vc);
+        struct omap_desc *d;
+
+        if (!vd) {
+                c->desc = NULL;
+                return;
+        }
+
+        list_del(&vd->node);
+
+        c->desc = d = to_omap_dma_desc(&vd->tx);
+        c->sgidx = 0;
+
+        if (d->dir == DMA_DEV_TO_MEM)
+                omap_set_dma_src_params(c->dma_ch, d->periph_port,
+                        OMAP_DMA_AMODE_CONSTANT, d->dev_addr, 0, 0);
+        else
+                omap_set_dma_dest_params(c->dma_ch, d->periph_port,
+                        OMAP_DMA_AMODE_CONSTANT, d->dev_addr, 0, 0);
+
+        omap_dma_start_sg(c, d, 0);
+}
+
+static void omap_dma_callback(int ch, u16 status, void *data)
+{
+        struct omap_chan *c = data;
+        struct omap_desc *d;
+        unsigned long flags;
+
+        spin_lock_irqsave(&c->vc.lock, flags);
+        d = c->desc;
+        if (d) {
+                if (++c->sgidx < d->sglen) {
+                        omap_dma_start_sg(c, d, c->sgidx);
+                } else {
+                        omap_dma_start_desc(c);
+                        vchan_cookie_complete(&d->vd);
+                }
+        }
+        spin_unlock_irqrestore(&c->vc.lock, flags);
+}
+
+/*
+ * This callback schedules all pending channels.  We could be more
+ * clever here by postponing allocation of the real DMA channels to
+ * this point, and freeing them when our virtual channel becomes idle.
+ *
+ * We would then need to deal with 'all channels in-use'
+ */
+static void omap_dma_sched(unsigned long data)
+{
+        struct omap_dmadev *d = (struct omap_dmadev *)data;
+        LIST_HEAD(head);
+
+        spin_lock_irq(&d->lock);
+        list_splice_tail_init(&d->pending, &head);
+        spin_unlock_irq(&d->lock);
+
+        while (!list_empty(&head)) {
+                struct omap_chan *c = list_first_entry(&head,
+                        struct omap_chan, node);
+
+                spin_lock_irq(&c->vc.lock);
+                list_del_init(&c->node);
+                omap_dma_start_desc(c);
+                spin_unlock_irq(&c->vc.lock);
+        }
+}