Merge tag 'cleanup-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM SoC cleanups from Arnd Bergmann:
 "This time around, the cleanup branch contains mostly code removal.  A
  number of board files for at91, imx and msm have become obsolete
  because of the DT conversion and are now ready to be removed.  The
  OMAP platform has traditionally had its own DMA engine abstraction and
  as this is being phased out, a lot of the original code is now unused
  and can be removed as well.

  S3C24xx can be simplified now that the restart code is a proper device
  driver.

  Finally, a number of cleanups in shmobile are done to prepare for the
  addition of new code in other branches"

* tag 'cleanup-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (43 commits)
  ARM: at91: Remove the support for the RSI EWS board
  arm: mach-omap2: Convert pr_warning to pr_warn
  ARM: OMAP: Remove unused pieces of legacy DMA API
  ARM: at91: remove board file for Acme Systems Fox G20
  ARM: orion5x: Convert pr_warning to pr_warn
  ARM: S3C24XX: remove separate restart code
  ARM: EXYNOS: Do not calculate boot address twice
  ARM: sunxi: Remove sun4i reboot code from mach directory
  ARM: imx: Remove mach-mxt_td60 board file
  ARM: shmobile: armadillo800eva legacy: Use rmobile_add_devices_to_domains()
  ARM: shmobile: r8a7740: Clean up pm domain table
  ARM: shmobile: r8a7740: Use rmobile_add_devices_to_domains()
  ARM: shmobile: sh7372: Make domain_devices[] static __initdata
  ARM: shmobile: mackerel: Make domain_devices[] static __initdata
  clocksource: tcb_clksrc: sanitize IRQ request
  ARM: at91/tclib: mask interruptions at shutdown and probe
  ARM: at91/tclib: move initialization from alloc to probe
  ARM: at91/tclib: prefer using of devm_* functions
  ARM: clps711x: Switch CLPS711X subarch to use clk and clocksource driver
  ARM: shmobile: r8a7791 is now called "R-Car M2-W"
  ...

1 files changed, 6 insertions, 731 deletions

diff --git a/arch/arm/plat-omap/dma.c b/arch/arm/plat-omap/dma.c
index c2baa8ede543..24770e5a5081 100644
--- a/arch/arm/plat-omap/dma.c
+++ b/arch/arm/plat-omap/dma.c
@@ -64,7 +64,9 @@ enum { DMA_CHAIN_STARTED, DMA_CHAIN_NOTSTARTED };
 
 static struct omap_system_dma_plat_info *p;
 static struct omap_dma_dev_attr *d;
-
+static void omap_clear_dma(int lch);
+static int omap_dma_set_prio_lch(int lch, unsigned char read_prio,
+                                 unsigned char write_prio);
 static int enable_1510_mode;
 static u32 errata;
 
@@ -284,66 +286,6 @@ void omap_set_dma_transfer_params(int lch, int data_type, int elem_count,
 }
 EXPORT_SYMBOL(omap_set_dma_transfer_params);
 
-void omap_set_dma_color_mode(int lch, enum omap_dma_color_mode mode, u32 color)
-{
-        BUG_ON(omap_dma_in_1510_mode());
-
-        if (dma_omap1()) {
-                u16 w;
-
-                w = p->dma_read(CCR2, lch);
-                w &= ~0x03;
-
-                switch (mode) {
-                case OMAP_DMA_CONSTANT_FILL:
-                        w |= 0x01;
-                        break;
-                case OMAP_DMA_TRANSPARENT_COPY:
-                        w |= 0x02;
-                        break;
-                case OMAP_DMA_COLOR_DIS:
-                        break;
-                default:
-                        BUG();
-                }
-                p->dma_write(w, CCR2, lch);
-
-                w = p->dma_read(LCH_CTRL, lch);
-                w &= ~0x0f;
-                /* Default is channel type 2D */
-                if (mode) {
-                        p->dma_write(color, COLOR, lch);
-                        w |= 1;         /* Channel type G */
-                }
-                p->dma_write(w, LCH_CTRL, lch);
-        }
-
-        if (dma_omap2plus()) {
-                u32 val;
-
-                val = p->dma_read(CCR, lch);
-                val &= ~((1 << 17) | (1 << 16));
-
-                switch (mode) {
-                case OMAP_DMA_CONSTANT_FILL:
-                        val |= 1 << 16;
-                        break;
-                case OMAP_DMA_TRANSPARENT_COPY:
-                        val |= 1 << 17;
-                        break;
-                case OMAP_DMA_COLOR_DIS:
-                        break;
-                default:
-                        BUG();
-                }
-                p->dma_write(val, CCR, lch);
-
-                color &= 0xffffff;
-                p->dma_write(color, COLOR, lch);
-        }
-}
-EXPORT_SYMBOL(omap_set_dma_color_mode);
-
 void omap_set_dma_write_mode(int lch, enum omap_dma_write_mode mode)
 {
         if (dma_omap2plus()) {
@@ -417,16 +359,6 @@ void omap_set_dma_params(int lch, struct omap_dma_channel_params *params)
 }
 EXPORT_SYMBOL(omap_set_dma_params);
 
-void omap_set_dma_src_index(int lch, int eidx, int fidx)
-{
-        if (dma_omap2plus())
-                return;
-
-        p->dma_write(eidx, CSEI, lch);
-        p->dma_write(fidx, CSFI, lch);
-}
-EXPORT_SYMBOL(omap_set_dma_src_index);
-
 void omap_set_dma_src_data_pack(int lch, int enable)
 {
         u32 l;
@@ -510,16 +442,6 @@ void omap_set_dma_dest_params(int lch, int dest_port, int dest_amode,
 }
 EXPORT_SYMBOL(omap_set_dma_dest_params);
 
-void omap_set_dma_dest_index(int lch, int eidx, int fidx)
-{
-        if (dma_omap2plus())
-                return;
-
-        p->dma_write(eidx, CDEI, lch);
-        p->dma_write(fidx, CDFI, lch);
-}
-EXPORT_SYMBOL(omap_set_dma_dest_index);
-
 void omap_set_dma_dest_data_pack(int lch, int enable)
 {
         u32 l;
@@ -843,7 +765,7 @@ EXPORT_SYMBOL(omap_dma_set_global_params);
  * Both of the above can be set with one of the following values :
  *      DMA_CH_PRIO_HIGH/DMA_CH_PRIO_LOW
  */
-int
+static int
 omap_dma_set_prio_lch(int lch, unsigned char read_prio,
                       unsigned char write_prio)
 {
@@ -864,13 +786,13 @@ omap_dma_set_prio_lch(int lch, unsigned char read_prio,
 
         return 0;
 }
-EXPORT_SYMBOL(omap_dma_set_prio_lch);
+
 
 /*
  * Clears any DMA state so the DMA engine is ready to restart with new buffers
  * through omap_start_dma(). Any buffers in flight are discarded.
  */
-void omap_clear_dma(int lch)
+static void omap_clear_dma(int lch)
 {
         unsigned long flags;
 
@@ -878,7 +800,6 @@ void omap_clear_dma(int lch)
         p->clear_dma(lch);
         local_irq_restore(flags);
 }
-EXPORT_SYMBOL(omap_clear_dma);
 
 void omap_start_dma(int lch)
 {
@@ -1167,652 +1088,6 @@ void omap_dma_link_lch(int lch_head, int lch_queue)
 }
 EXPORT_SYMBOL(omap_dma_link_lch);
 
-/*
- * Once the DMA queue is stopped, we can destroy it.
- */
-void omap_dma_unlink_lch(int lch_head, int lch_queue)
-{
-        if (omap_dma_in_1510_mode()) {
-                if (lch_head == lch_queue) {
-                        p->dma_write(p->dma_read(CCR, lch_head) & ~(3 << 8),
-                                                                CCR, lch_head);
-                        return;
-                }
-                printk(KERN_ERR "DMA linking is not supported in 1510 mode\n");
-                BUG();
-                return;
-        }
-
-        if (dma_chan[lch_head].next_lch != lch_queue ||
-            dma_chan[lch_head].next_lch == -1) {
-                pr_err("omap_dma: trying to unlink non linked channels\n");
-                dump_stack();
-        }
-
-        if ((dma_chan[lch_head].flags & OMAP_DMA_ACTIVE) ||
-            (dma_chan[lch_queue].flags & OMAP_DMA_ACTIVE)) {
-                pr_err("omap_dma: You need to stop the DMA channels before unlinking\n");
-                dump_stack();
-        }
-
-        dma_chan[lch_head].next_lch = -1;
-}
-EXPORT_SYMBOL(omap_dma_unlink_lch);
-
-#ifndef CONFIG_ARCH_OMAP1
-/* Create chain of DMA channesls */
-static void create_dma_lch_chain(int lch_head, int lch_queue)
-{
-        u32 l;
-
-        /* Check if this is the first link in chain */
-        if (dma_chan[lch_head].next_linked_ch == -1) {
-                dma_chan[lch_head].next_linked_ch = lch_queue;
-                dma_chan[lch_head].prev_linked_ch = lch_queue;
-                dma_chan[lch_queue].next_linked_ch = lch_head;
-                dma_chan[lch_queue].prev_linked_ch = lch_head;
-        }
-
-        /* a link exists, link the new channel in circular chain */
-        else {
-                dma_chan[lch_queue].next_linked_ch =
-                                        dma_chan[lch_head].next_linked_ch;
-                dma_chan[lch_queue].prev_linked_ch = lch_head;
-                dma_chan[lch_head].next_linked_ch = lch_queue;
-                dma_chan[dma_chan[lch_queue].next_linked_ch].prev_linked_ch =
-                                        lch_queue;
-        }
-
-        l = p->dma_read(CLNK_CTRL, lch_head);
-        l &= ~(0x1f);
-        l |= lch_queue;
-        p->dma_write(l, CLNK_CTRL, lch_head);
-
-        l = p->dma_read(CLNK_CTRL, lch_queue);
-        l &= ~(0x1f);
-        l |= (dma_chan[lch_queue].next_linked_ch);
-        p->dma_write(l, CLNK_CTRL, lch_queue);
-}
-
-/**
- * @brief omap_request_dma_chain : Request a chain of DMA channels
- *
- * @param dev_id - Device id using the dma channel
- * @param dev_name - Device name
- * @param callback - Call back function
- * @chain_id -
- * @no_of_chans - Number of channels requested
- * @chain_mode - Dynamic or static chaining : OMAP_DMA_STATIC_CHAIN
- *                                            OMAP_DMA_DYNAMIC_CHAIN
- * @params - Channel parameters
- *
- * @return - Success : 0
- *           Failure: -EINVAL/-ENOMEM
- */
-int omap_request_dma_chain(int dev_id, const char *dev_name,
-                           void (*callback) (int lch, u16 ch_status,
-                                             void *data),
-                           int *chain_id, int no_of_chans, int chain_mode,
-                           struct omap_dma_channel_params params)
-{
-        int *channels;
-        int i, err;
-
-        /* Is the chain mode valid ? */
-        if (chain_mode != OMAP_DMA_STATIC_CHAIN
-                        && chain_mode != OMAP_DMA_DYNAMIC_CHAIN) {
-                printk(KERN_ERR "Invalid chain mode requested\n");
-                return -EINVAL;
-        }
-
-        if (unlikely((no_of_chans < 1
-                        || no_of_chans > dma_lch_count))) {
-                printk(KERN_ERR "Invalid Number of channels requested\n");
-                return -EINVAL;
-        }
-
-        /*
-         * Allocate a queue to maintain the status of the channels
-         * in the chain
-         */
-        channels = kmalloc(sizeof(*channels) * no_of_chans, GFP_KERNEL);
-        if (channels == NULL) {
-                printk(KERN_ERR "omap_dma: No memory for channel queue\n");
-                return -ENOMEM;
-        }
-
-        /* request and reserve DMA channels for the chain */
-        for (i = 0; i < no_of_chans; i++) {
-                err = omap_request_dma(dev_id, dev_name,
-                                        callback, NULL, &channels[i]);
-                if (err < 0) {
-                        int j;
-                        for (j = 0; j < i; j++)
-                                omap_free_dma(channels[j]);
-                        kfree(channels);
-                        printk(KERN_ERR "omap_dma: Request failed %d\n", err);
-                        return err;
-                }
-                dma_chan[channels[i]].prev_linked_ch = -1;
-                dma_chan[channels[i]].state = DMA_CH_NOTSTARTED;
-
-                /*
-                 * Allowing client drivers to set common parameters now,
-                 * so that later only relevant (src_start, dest_start
-                 * and element count) can be set
-                 */
-                omap_set_dma_params(channels[i], &params);
-        }
-
-        *chain_id = channels[0];
-        dma_linked_lch[*chain_id].linked_dmach_q = channels;
-        dma_linked_lch[*chain_id].chain_mode = chain_mode;
-        dma_linked_lch[*chain_id].chain_state = DMA_CHAIN_NOTSTARTED;
-        dma_linked_lch[*chain_id].no_of_lchs_linked = no_of_chans;
-
-        for (i = 0; i < no_of_chans; i++)
-                dma_chan[channels[i]].chain_id = *chain_id;
-
-        /* Reset the Queue pointers */
-        OMAP_DMA_CHAIN_QINIT(*chain_id);
-
-        /* Set up the chain */
-        if (no_of_chans == 1)
-                create_dma_lch_chain(channels[0], channels[0]);
-        else {
-                for (i = 0; i < (no_of_chans - 1); i++)
-                        create_dma_lch_chain(channels[i], channels[i + 1]);
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(omap_request_dma_chain);
-
-/**
- * @brief omap_modify_dma_chain_param : Modify the chain's params - Modify the
- * params after setting it. Dont do this while dma is running!!
- *
- * @param chain_id - Chained logical channel id.
- * @param params
- *
- * @return - Success : 0
- *           Failure : -EINVAL
- */
-int omap_modify_dma_chain_params(int chain_id,
-                                struct omap_dma_channel_params params)
-{
-        int *channels;
-        u32 i;
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0
-                        || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        for (i = 0; i < dma_linked_lch[chain_id].no_of_lchs_linked; i++) {
-                /*
-                 * Allowing client drivers to set common parameters now,
-                 * so that later only relevant (src_start, dest_start
-                 * and element count) can be set
-                 */
-                omap_set_dma_params(channels[i], &params);
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(omap_modify_dma_chain_params);
-
-/**
- * @brief omap_free_dma_chain - Free all the logical channels in a chain.
- *
- * @param chain_id
- *
- * @return - Success : 0
- *           Failure : -EINVAL
- */
-int omap_free_dma_chain(int chain_id)
-{
-        int *channels;
-        u32 i;
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-        for (i = 0; i < dma_linked_lch[chain_id].no_of_lchs_linked; i++) {
-                dma_chan[channels[i]].next_linked_ch = -1;
-                dma_chan[channels[i]].prev_linked_ch = -1;
-                dma_chan[channels[i]].chain_id = -1;
-                dma_chan[channels[i]].state = DMA_CH_NOTSTARTED;
-                omap_free_dma(channels[i]);
-        }
-
-        kfree(channels);
-
-        dma_linked_lch[chain_id].linked_dmach_q = NULL;
-        dma_linked_lch[chain_id].chain_mode = -1;
-        dma_linked_lch[chain_id].chain_state = -1;
-
-        return (0);
-}
-EXPORT_SYMBOL(omap_free_dma_chain);
-
-/**
- * @brief omap_dma_chain_status - Check if the chain is in
- * active / inactive state.
- * @param chain_id
- *
- * @return - Success : OMAP_DMA_CHAIN_ACTIVE/OMAP_DMA_CHAIN_INACTIVE
- *           Failure : -EINVAL
- */
-int omap_dma_chain_status(int chain_id)
-{
-        /* Check for input params */
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-        pr_debug("CHAINID=%d, qcnt=%d\n", chain_id,
-                        dma_linked_lch[chain_id].q_count);
-
-        if (OMAP_DMA_CHAIN_QEMPTY(chain_id))
-                return OMAP_DMA_CHAIN_INACTIVE;
-
-        return OMAP_DMA_CHAIN_ACTIVE;
-}
-EXPORT_SYMBOL(omap_dma_chain_status);
-
-/**
- * @brief omap_dma_chain_a_transfer - Get a free channel from a chain,
- * set the params and start the transfer.
- *
- * @param chain_id
- * @param src_start - buffer start address
- * @param dest_start - Dest address
- * @param elem_count
- * @param frame_count
- * @param callbk_data - channel callback parameter data.
- *
- * @return  - Success : 0
- *            Failure: -EINVAL/-EBUSY
- */
-int omap_dma_chain_a_transfer(int chain_id, int src_start, int dest_start,
-                        int elem_count, int frame_count, void *callbk_data)
-{
-        int *channels;
-        u32 l, lch;
-        int start_dma = 0;
-
-        /*
-         * if buffer size is less than 1 then there is
-         * no use of starting the chain
-         */
-        if (elem_count < 1) {
-                printk(KERN_ERR "Invalid buffer size\n");
-                return -EINVAL;
-        }
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0
-                        || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exist\n");
-                return -EINVAL;
-        }
-
-        /* Check if all the channels in chain are in use */
-        if (OMAP_DMA_CHAIN_QFULL(chain_id))
-                return -EBUSY;
-
-        /* Frame count may be negative in case of indexed transfers */
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        /* Get a free channel */
-        lch = channels[dma_linked_lch[chain_id].q_tail];
-
-        /* Store the callback data */
-        dma_chan[lch].data = callbk_data;
-
-        /* Increment the q_tail */
-        OMAP_DMA_CHAIN_INCQTAIL(chain_id);
-
-        /* Set the params to the free channel */
-        if (src_start != 0)
-                p->dma_write(src_start, CSSA, lch);
-        if (dest_start != 0)
-                p->dma_write(dest_start, CDSA, lch);
-
-        /* Write the buffer size */
-        p->dma_write(elem_count, CEN, lch);
-        p->dma_write(frame_count, CFN, lch);
-
-        /*
-         * If the chain is dynamically linked,
-         * then we may have to start the chain if its not active
-         */
-        if (dma_linked_lch[chain_id].chain_mode == OMAP_DMA_DYNAMIC_CHAIN) {
-
-                /*
-                 * In Dynamic chain, if the chain is not started,
-                 * queue the channel
-                 */
-                if (dma_linked_lch[chain_id].chain_state ==
-                                                DMA_CHAIN_NOTSTARTED) {
-                        /* Enable the link in previous channel */
-                        if (dma_chan[dma_chan[lch].prev_linked_ch].state ==
-                                                                DMA_CH_QUEUED)
-                                enable_lnk(dma_chan[lch].prev_linked_ch);
-                        dma_chan[lch].state = DMA_CH_QUEUED;
-                }
-
-                /*
-                 * Chain is already started, make sure its active,
-                 * if not then start the chain
-                 */
-                else {
-                        start_dma = 1;
-
-                        if (dma_chan[dma_chan[lch].prev_linked_ch].state ==
-                                                        DMA_CH_STARTED) {
-                                enable_lnk(dma_chan[lch].prev_linked_ch);
-                                dma_chan[lch].state = DMA_CH_QUEUED;
-                                start_dma = 0;
-                                if (0 == ((1 << 7) & p->dma_read(
-                                        CCR, dma_chan[lch].prev_linked_ch))) {
-                                        disable_lnk(dma_chan[lch].
-                                                    prev_linked_ch);
-                                        pr_debug("\n prev ch is stopped\n");
-                                        start_dma = 1;
-                                }
-                        }
-
-                        else if (dma_chan[dma_chan[lch].prev_linked_ch].state
-                                                        == DMA_CH_QUEUED) {
-                                enable_lnk(dma_chan[lch].prev_linked_ch);
-                                dma_chan[lch].state = DMA_CH_QUEUED;
-                                start_dma = 0;
-                        }
-                        omap_enable_channel_irq(lch);
-
-                        l = p->dma_read(CCR, lch);
-
-                        if ((0 == (l & (1 << 24))))
-                                l &= ~(1 << 25);
-                        else
-                                l |= (1 << 25);
-                        if (start_dma == 1) {
-                                if (0 == (l & (1 << 7))) {
-                                        l |= (1 << 7);
-                                        dma_chan[lch].state = DMA_CH_STARTED;
-                                        pr_debug("starting %d\n", lch);
-                                        p->dma_write(l, CCR, lch);
-                                } else
-                                        start_dma = 0;
-                        } else {
-                                if (0 == (l & (1 << 7)))
-                                        p->dma_write(l, CCR, lch);
-                        }
-                        dma_chan[lch].flags |= OMAP_DMA_ACTIVE;
-                }
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(omap_dma_chain_a_transfer);
-
-/**
- * @brief omap_start_dma_chain_transfers - Start the chain
- *
- * @param chain_id
- *
- * @return - Success : 0
- *           Failure : -EINVAL/-EBUSY
- */
-int omap_start_dma_chain_transfers(int chain_id)
-{
-        int *channels;
-        u32 l, i;
-
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        if (dma_linked_lch[channels[0]].chain_state == DMA_CHAIN_STARTED) {
-                printk(KERN_ERR "Chain is already started\n");
-                return -EBUSY;
-        }
-
-        if (dma_linked_lch[chain_id].chain_mode == OMAP_DMA_STATIC_CHAIN) {
-                for (i = 0; i < dma_linked_lch[chain_id].no_of_lchs_linked;
-                                                                        i++) {
-                        enable_lnk(channels[i]);
-                        omap_enable_channel_irq(channels[i]);
-                }
-        } else {
-                omap_enable_channel_irq(channels[0]);
-        }
-
-        l = p->dma_read(CCR, channels[0]);
-        l |= (1 << 7);
-        dma_linked_lch[chain_id].chain_state = DMA_CHAIN_STARTED;
-        dma_chan[channels[0]].state = DMA_CH_STARTED;
-
-        if ((0 == (l & (1 << 24))))
-                l &= ~(1 << 25);
-        else
-                l |= (1 << 25);
-        p->dma_write(l, CCR, channels[0]);
-
-        dma_chan[channels[0]].flags |= OMAP_DMA_ACTIVE;
-
-        return 0;
-}
-EXPORT_SYMBOL(omap_start_dma_chain_transfers);
-
-/**
- * @brief omap_stop_dma_chain_transfers - Stop the dma transfer of a chain.
- *
- * @param chain_id
- *
- * @return - Success : 0
- *           Failure : EINVAL
- */
-int omap_stop_dma_chain_transfers(int chain_id)
-{
-        int *channels;
-        u32 l, i;
-        u32 sys_cf = 0;
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        if (IS_DMA_ERRATA(DMA_ERRATA_i88)) {
-                sys_cf = p->dma_read(OCP_SYSCONFIG, 0);
-                l = sys_cf;
-                /* Middle mode reg set no Standby */
-                l &= ~((1 << 12)|(1 << 13));
-                p->dma_write(l, OCP_SYSCONFIG, 0);
-        }
-
-        for (i = 0; i < dma_linked_lch[chain_id].no_of_lchs_linked; i++) {
-
-                /* Stop the Channel transmission */
-                l = p->dma_read(CCR, channels[i]);
-                l &= ~(1 << 7);
-                p->dma_write(l, CCR, channels[i]);
-
-                /* Disable the link in all the channels */
-                disable_lnk(channels[i]);
-                dma_chan[channels[i]].state = DMA_CH_NOTSTARTED;
-
-        }
-        dma_linked_lch[chain_id].chain_state = DMA_CHAIN_NOTSTARTED;
-
-        /* Reset the Queue pointers */
-        OMAP_DMA_CHAIN_QINIT(chain_id);
-
-        if (IS_DMA_ERRATA(DMA_ERRATA_i88))
-                p->dma_write(sys_cf, OCP_SYSCONFIG, 0);
-
-        return 0;
-}
-EXPORT_SYMBOL(omap_stop_dma_chain_transfers);
-
-/* Get the index of the ongoing DMA in chain */
-/**
- * @brief omap_get_dma_chain_index - Get the element and frame index
- * of the ongoing DMA in chain
- *
- * @param chain_id
- * @param ei - Element index
- * @param fi - Frame index
- *
- * @return - Success : 0
- *           Failure : -EINVAL
- */
-int omap_get_dma_chain_index(int chain_id, int *ei, int *fi)
-{
-        int lch;
-        int *channels;
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-        if ((!ei) || (!fi))
-                return -EINVAL;
-
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        /* Get the current channel */
-        lch = channels[dma_linked_lch[chain_id].q_head];
-
-        *ei = p->dma_read(CCEN, lch);
-        *fi = p->dma_read(CCFN, lch);
-
-        return 0;
-}
-EXPORT_SYMBOL(omap_get_dma_chain_index);
-
-/**
- * @brief omap_get_dma_chain_dst_pos - Get the destination position of the
- * ongoing DMA in chain
- *
- * @param chain_id
- *
- * @return - Success : Destination position
- *           Failure : -EINVAL
- */
-int omap_get_dma_chain_dst_pos(int chain_id)
-{
-        int lch;
-        int *channels;
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        /* Get the current channel */
-        lch = channels[dma_linked_lch[chain_id].q_head];
-
-        return p->dma_read(CDAC, lch);
-}
-EXPORT_SYMBOL(omap_get_dma_chain_dst_pos);
-
-/**
- * @brief omap_get_dma_chain_src_pos - Get the source position
- * of the ongoing DMA in chain
- * @param chain_id
- *
- * @return - Success : Destination position
- *           Failure : -EINVAL
- */
-int omap_get_dma_chain_src_pos(int chain_id)
-{
-        int lch;
-        int *channels;
-
-        /* Check for input params */
-        if (unlikely((chain_id < 0 || chain_id >= dma_lch_count))) {
-                printk(KERN_ERR "Invalid chain id\n");
-                return -EINVAL;
-        }
-
-        /* Check if the chain exists */
-        if (dma_linked_lch[chain_id].linked_dmach_q == NULL) {
-                printk(KERN_ERR "Chain doesn't exists\n");
-                return -EINVAL;
-        }
-
-        channels = dma_linked_lch[chain_id].linked_dmach_q;
-
-        /* Get the current channel */
-        lch = channels[dma_linked_lch[chain_id].q_head];
-
-        return p->dma_read(CSAC, lch);
-}
-EXPORT_SYMBOL(omap_get_dma_chain_src_pos);
-#endif  /* ifndef CONFIG_ARCH_OMAP1 */
-
 /*----------------------------------------------------------------------------*/
 
 #ifdef CONFIG_ARCH_OMAP1