Patched in Tegra support.

1 files changed, 12 insertions, 30 deletions

diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index a815d44c70a..b48967b499d 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -45,8 +45,6 @@
  * See Documentation/dmaengine.txt for more details
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/dma-mapping.h>
 #include <linux/init.h>
 #include <linux/module.h>
@@ -263,7 +261,7 @@ enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie)
         do {
                 status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);
                 if (time_after_eq(jiffies, dma_sync_wait_timeout)) {
-                        pr_err("%s: timeout!\n", __func__);
+                        printk(KERN_ERR "dma_sync_wait_timeout!\n");
                         return DMA_ERROR;
                 }
         } while (status == DMA_IN_PROGRESS);
@@ -314,7 +312,7 @@ static int __init dma_channel_table_init(void)
         }
 
         if (err) {
-                pr_err("initialization failure\n");
+                pr_err("dmaengine: initialization failure\n");
                 for_each_dma_cap_mask(cap, dma_cap_mask_all)
                         if (channel_table[cap])
                                 free_percpu(channel_table[cap]);
@@ -334,20 +332,6 @@ struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type)
 }
 EXPORT_SYMBOL(dma_find_channel);
 
-/*
- * net_dma_find_channel - find a channel for net_dma
- * net_dma has alignment requirements
- */
-struct dma_chan *net_dma_find_channel(void)
-{
-        struct dma_chan *chan = dma_find_channel(DMA_MEMCPY);
-        if (chan && !is_dma_copy_aligned(chan->device, 1, 1, 1))
-                return NULL;
-
-        return chan;
-}
-EXPORT_SYMBOL(net_dma_find_channel);
-
 /**
  * dma_issue_pending_all - flush all pending operations across all channels
  */
@@ -522,12 +506,12 @@ struct dma_chan *__dma_request_channel(dma_cap_mask_t *mask, dma_filter_fn fn, v
                         err = dma_chan_get(chan);
 
                         if (err == -ENODEV) {
-                                pr_debug("%s: %s module removed\n",
-                                         __func__, dma_chan_name(chan));
+                                pr_debug("%s: %s module removed\n", __func__,
+                                         dma_chan_name(chan));
                                 list_del_rcu(&device->global_node);
                         } else if (err)
-                                pr_debug("%s: failed to get %s: (%d)\n",
-                                         __func__, dma_chan_name(chan), err);
+                                pr_debug("dmaengine: failed to get %s: (%d)\n",
+                                         dma_chan_name(chan), err);
                         else
                                 break;
                         if (--device->privatecnt == 0)
@@ -537,9 +521,7 @@ struct dma_chan *__dma_request_channel(dma_cap_mask_t *mask, dma_filter_fn fn, v
         }
         mutex_unlock(&dma_list_mutex);
 
-        pr_debug("%s: %s (%s)\n",
-                 __func__,
-                 chan ? "success" : "fail",
+        pr_debug("%s: %s (%s)\n", __func__, chan ? "success" : "fail",
                  chan ? dma_chan_name(chan) : NULL);
 
         return chan;
@@ -582,8 +564,8 @@ void dmaengine_get(void)
                                 list_del_rcu(&device->global_node);
                                 break;
                         } else if (err)
-                                pr_debug("%s: failed to get %s: (%d)\n",
-                                       __func__, dma_chan_name(chan), err);
+                                pr_err("dmaengine: failed to get %s: (%d)\n",
+                                       dma_chan_name(chan), err);
                 }
         }
 
@@ -711,12 +693,12 @@ int dma_async_device_register(struct dma_device *device)
                 !device->device_prep_dma_interrupt);
         BUG_ON(dma_has_cap(DMA_SG, device->cap_mask) &&
                 !device->device_prep_dma_sg);
+        BUG_ON(dma_has_cap(DMA_SLAVE, device->cap_mask) &&
+                !device->device_prep_slave_sg);
         BUG_ON(dma_has_cap(DMA_CYCLIC, device->cap_mask) &&
                 !device->device_prep_dma_cyclic);
         BUG_ON(dma_has_cap(DMA_SLAVE, device->cap_mask) &&
                 !device->device_control);
-        BUG_ON(dma_has_cap(DMA_INTERLEAVE, device->cap_mask) &&
-                !device->device_prep_interleaved_dma);
 
         BUG_ON(!device->device_alloc_chan_resources);
         BUG_ON(!device->device_free_chan_resources);
@@ -1019,7 +1001,7 @@ dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
         while (tx->cookie == -EBUSY) {
                 if (time_after_eq(jiffies, dma_sync_wait_timeout)) {
                         pr_err("%s timeout waiting for descriptor submission\n",
-                               __func__);
+                                __func__);
                         return DMA_ERROR;
                 }
                 cpu_relax();