Patched in Tegra support.

1 files changed, 93 insertions, 43 deletions

diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index aa384e53b7a..4234f416ef1 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -24,7 +24,6 @@
 #include <mach/coh901318.h>
 
 #include "coh901318_lli.h"
-#include "dmaengine.h"
 
 #define COHC_2_DEV(cohc) (&cohc->chan.dev->device)
 
@@ -40,7 +39,7 @@ struct coh901318_desc {
         struct scatterlist *sg;
         unsigned int sg_len;
         struct coh901318_lli *lli;
-        enum dma_transfer_direction dir;
+        enum dma_data_direction dir;
         unsigned long flags;
         u32 head_config;
         u32 head_ctrl;
@@ -60,6 +59,7 @@ struct coh901318_base {
 struct coh901318_chan {
         spinlock_t lock;
         int allocated;
+        int completed;
         int id;
         int stopped;
 
@@ -104,6 +104,13 @@ static void coh901318_list_print(struct coh901318_chan *cohc,
 static struct coh901318_base *debugfs_dma_base;
 static struct dentry *dma_dentry;
 
+static int coh901318_debugfs_open(struct inode *inode, struct file *file)
+{
+
+        file->private_data = inode->i_private;
+        return 0;
+}
+
 static int coh901318_debugfs_read(struct file *file, char __user *buf,
                                   size_t count, loff_t *f_pos)
 {
@@ -151,7 +158,7 @@ static int coh901318_debugfs_read(struct file *file, char __user *buf,
 
 static const struct file_operations coh901318_debugfs_status_operations = {
         .owner          = THIS_MODULE,
-        .open           = simple_open,
+        .open           = coh901318_debugfs_open,
         .read           = coh901318_debugfs_read,
         .llseek         = default_llseek,
 };
@@ -311,6 +318,20 @@ static int coh901318_prep_linked_list(struct coh901318_chan *cohc,
 
         return 0;
 }
+static dma_cookie_t
+coh901318_assign_cookie(struct coh901318_chan *cohc,
+                        struct coh901318_desc *cohd)
+{
+        dma_cookie_t cookie = cohc->chan.cookie;
+
+        if (++cookie < 0)
+                cookie = 1;
+
+        cohc->chan.cookie = cookie;
+        cohd->desc.cookie = cookie;
+
+        return cookie;
+}
 
 static struct coh901318_desc *
 coh901318_desc_get(struct coh901318_chan *cohc)
@@ -684,7 +705,7 @@ static void dma_tasklet(unsigned long data)
         callback_param = cohd_fin->desc.callback_param;
 
         /* sign this job as completed on the channel */
-        dma_cookie_complete(&cohd_fin->desc);
+        cohc->completed = cohd_fin->desc.cookie;
 
         /* release the lli allocation and remove the descriptor */
         coh901318_lli_free(&cohc->base->pool, &cohd_fin->lli);
@@ -908,7 +929,7 @@ static int coh901318_alloc_chan_resources(struct dma_chan *chan)
         coh901318_config(cohc, NULL);
 
         cohc->allocated = 1;
-        dma_cookie_init(chan);
+        cohc->completed = chan->cookie = 1;
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 
@@ -945,16 +966,16 @@ coh901318_tx_submit(struct dma_async_tx_descriptor *tx)
                                                    desc);
         struct coh901318_chan *cohc = to_coh901318_chan(tx->chan);
         unsigned long flags;
-        dma_cookie_t cookie;
 
         spin_lock_irqsave(&cohc->lock, flags);
-        cookie = dma_cookie_assign(tx);
+
+        tx->cookie = coh901318_assign_cookie(cohc, cohd);
 
         coh901318_desc_queue(cohc, cohd);
 
         spin_unlock_irqrestore(&cohc->lock, flags);
 
-        return cookie;
+        return tx->cookie;
 }
 
 static struct dma_async_tx_descriptor *
@@ -1013,8 +1034,8 @@ coh901318_prep_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
 
 static struct dma_async_tx_descriptor *
 coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
-                        unsigned int sg_len, enum dma_transfer_direction direction,
-                        unsigned long flags, void *context)
+                        unsigned int sg_len, enum dma_data_direction direction,
+                        unsigned long flags)
 {
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
         struct coh901318_lli *lli;
@@ -1033,7 +1054,7 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
 
         if (!sgl)
                 goto out;
-        if (sg_dma_len(sgl) == 0)
+        if (sgl->length == 0)
                 goto out;
 
         spin_lock_irqsave(&cohc->lock, flg);
@@ -1056,7 +1077,7 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         ctrl_last |= cohc->runtime_ctrl;
         ctrl |= cohc->runtime_ctrl;
 
-        if (direction == DMA_MEM_TO_DEV) {
+        if (direction == DMA_TO_DEVICE) {
                 u32 tx_flags = COH901318_CX_CTRL_PRDD_SOURCE |
                         COH901318_CX_CTRL_SRC_ADDR_INC_ENABLE;
 
@@ -1064,7 +1085,7 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 ctrl_chained |= tx_flags;
                 ctrl_last |= tx_flags;
                 ctrl |= tx_flags;
-        } else if (direction == DMA_DEV_TO_MEM) {
+        } else if (direction == DMA_FROM_DEVICE) {
                 u32 rx_flags = COH901318_CX_CTRL_PRDD_DEST |
                         COH901318_CX_CTRL_DST_ADDR_INC_ENABLE;
 
@@ -1144,12 +1165,17 @@ coh901318_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
                  struct dma_tx_state *txstate)
 {
         struct coh901318_chan *cohc = to_coh901318_chan(chan);
-        enum dma_status ret;
+        dma_cookie_t last_used;
+        dma_cookie_t last_complete;
+        int ret;
 
-        ret = dma_cookie_status(chan, cookie, txstate);
-        /* FIXME: should be conditional on ret != DMA_SUCCESS? */
-        dma_set_residue(txstate, coh901318_get_bytes_left(chan));
+        last_complete = cohc->completed;
+        last_used = chan->cookie;
 
+        ret = dma_async_is_complete(cookie, last_complete, last_used);
+
+        dma_set_tx_state(txstate, last_complete, last_used,
+                         coh901318_get_bytes_left(chan));
         if (ret == DMA_IN_PROGRESS && cohc->stopped)
                 ret = DMA_PAUSED;
 
@@ -1248,11 +1274,11 @@ static void coh901318_dma_set_runtimeconfig(struct dma_chan *chan,
         int i = 0;
 
         /* We only support mem to per or per to mem transfers */
-        if (config->direction == DMA_DEV_TO_MEM) {
+        if (config->direction == DMA_FROM_DEVICE) {
                 addr = config->src_addr;
                 addr_width = config->src_addr_width;
                 maxburst = config->src_maxburst;
-        } else if (config->direction == DMA_MEM_TO_DEV) {
+        } else if (config->direction == DMA_TO_DEVICE) {
                 addr = config->dst_addr;
                 addr_width = config->dst_addr_width;
                 maxburst = config->dst_maxburst;
@@ -1438,32 +1464,34 @@ static int __init coh901318_probe(struct platform_device *pdev)
 
         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!io)
-                return -ENODEV;
+                goto err_get_resource;
 
         /* Map DMA controller registers to virtual memory */
-        if (devm_request_mem_region(&pdev->dev,
-                                    io->start,
-                                    resource_size(io),
-                                    pdev->dev.driver->name) == NULL)
-                return -ENOMEM;
+        if (request_mem_region(io->start,
+                               resource_size(io),
+                               pdev->dev.driver->name) == NULL) {
+                err = -EBUSY;
+                goto err_request_mem;
+        }
 
         pdata = pdev->dev.platform_data;
         if (!pdata)
-                return -ENODEV;
+                goto err_no_platformdata;
 
-        base = devm_kzalloc(&pdev->dev,
-                            ALIGN(sizeof(struct coh901318_base), 4) +
-                            pdata->max_channels *
-                            sizeof(struct coh901318_chan),
-                            GFP_KERNEL);
+        base = kmalloc(ALIGN(sizeof(struct coh901318_base), 4) +
+                       pdata->max_channels *
+                       sizeof(struct coh901318_chan),
+                       GFP_KERNEL);
         if (!base)
-                return -ENOMEM;
+                goto err_alloc_coh_dma_channels;
 
         base->chans = ((void *)base) + ALIGN(sizeof(struct coh901318_base), 4);
 
-        base->virtbase = devm_ioremap(&pdev->dev, io->start, resource_size(io));
-        if (!base->virtbase)
-                return -ENOMEM;
+        base->virtbase = ioremap(io->start, resource_size(io));
+        if (!base->virtbase) {
+                err = -ENOMEM;
+                goto err_no_ioremap;
+        }
 
         base->dev = &pdev->dev;
         base->platform = pdata;
@@ -1472,20 +1500,25 @@ static int __init coh901318_probe(struct platform_device *pdev)
 
         COH901318_DEBUGFS_ASSIGN(debugfs_dma_base, base);
 
+        platform_set_drvdata(pdev, base);
+
         irq = platform_get_irq(pdev, 0);
         if (irq < 0)
-                return irq;
-
-        err = devm_request_irq(&pdev->dev, irq, dma_irq_handler, IRQF_DISABLED,
-                               "coh901318", base);
-        if (err)
-                return err;
+                goto err_no_irq;
+
+        err = request_irq(irq, dma_irq_handler, IRQF_DISABLED,
+                          "coh901318", base);
+        if (err) {
+                dev_crit(&pdev->dev,
+                         "Cannot allocate IRQ for DMA controller!\n");
+                goto err_request_irq;
+        }
 
         err = coh901318_pool_create(&base->pool, &pdev->dev,
                                     sizeof(struct coh901318_lli),
                                     32);
         if (err)
-                return err;
+                goto err_pool_create;
 
         /* init channels for device transfers */
         coh901318_base_init(&base->dma_slave,  base->platform->chans_slave,
@@ -1531,7 +1564,6 @@ static int __init coh901318_probe(struct platform_device *pdev)
         if (err)
                 goto err_register_memcpy;
 
-        platform_set_drvdata(pdev, base);
         dev_info(&pdev->dev, "Initialized COH901318 DMA on virtual base 0x%08x\n",
                 (u32) base->virtbase);
 
@@ -1541,6 +1573,19 @@ static int __init coh901318_probe(struct platform_device *pdev)
         dma_async_device_unregister(&base->dma_slave);
  err_register_slave:
         coh901318_pool_destroy(&base->pool);
+ err_pool_create:
+        free_irq(platform_get_irq(pdev, 0), base);
+ err_request_irq:
+ err_no_irq:
+        iounmap(base->virtbase);
+ err_no_ioremap:
+        kfree(base);
+ err_alloc_coh_dma_channels:
+ err_no_platformdata:
+        release_mem_region(pdev->resource->start,
+                           resource_size(pdev->resource));
+ err_request_mem:
+ err_get_resource:
         return err;
 }
 
@@ -1551,6 +1596,11 @@ static int __exit coh901318_remove(struct platform_device *pdev)
         dma_async_device_unregister(&base->dma_memcpy);
         dma_async_device_unregister(&base->dma_slave);
         coh901318_pool_destroy(&base->pool);
+        free_irq(platform_get_irq(pdev, 0), base);
+        iounmap(base->virtbase);
+        kfree(base);
+        release_mem_region(pdev->resource->start,
+                           resource_size(pdev->resource));
         return 0;
 }