mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-09-12 16:07:07 +03:00
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@18540 3c298f89-4303-0410-b956-a3cf2f4a3e73
3623 lines
110 KiB
Diff
3623 lines
110 KiB
Diff
--- /dev/null
|
|
+++ b/arch/arm/mach-ep93xx/dma_ep93xx.c
|
|
@@ -0,0 +1,2940 @@
|
|
+/******************************************************************************
|
|
+ * arch/arm/mach-ep9312/dma_ep93xx.c
|
|
+ *
|
|
+ * Support functions for the ep93xx internal DMA channels.
|
|
+ * (see also Documentation/arm/ep93xx/dma.txt)
|
|
+ *
|
|
+ * Copyright (C) 2003 Cirrus Logic
|
|
+ *
|
|
+ * A large portion of this file is based on the dma api implemented by
|
|
+ * Nicolas Pitre, dma-sa1100.c, copyrighted 2000.
|
|
+ *
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or modify
|
|
+ * it under the terms of the GNU General Public License as published by
|
|
+ * the Free Software Foundation; either version 2 of the License, or
|
|
+ * (at your option) any later version.
|
|
+ *
|
|
+ * This program is distributed in the hope that it will be useful,
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
+ * GNU General Public License for more details.
|
|
+ *
|
|
+ * You should have received a copy of the GNU General Public License
|
|
+ * along with this program; if not, write to the Free Software
|
|
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+#include <linux/autoconf.h>
|
|
+#include <linux/module.h>
|
|
+#include <linux/init.h>
|
|
+#include <linux/sched.h>
|
|
+#include <linux/spinlock.h>
|
|
+#include <linux/slab.h>
|
|
+#include <linux/errno.h>
|
|
+#include <linux/delay.h>
|
|
+#include <linux/interrupt.h>
|
|
+
|
|
+#include <asm/system.h>
|
|
+#include <asm/irq.h>
|
|
+#include <asm/hardware.h>
|
|
+#include <asm/io.h>
|
|
+#include <asm/dma.h>
|
|
+#include <asm/mach/dma.h>
|
|
+#include "dma_ep93xx.h"
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * Debugging macros
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+#undef DEBUG
|
|
+//#define DEBUG 1
|
|
+#ifdef DEBUG
|
|
+#define DPRINTK( fmt, arg... ) printk( fmt, ##arg )
|
|
+#else
|
|
+#define DPRINTK( fmt, arg... )
|
|
+#endif
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * static global variables
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+ep93xx_dma_t dma_chan[MAX_EP93XX_DMA_CHANNELS];
|
|
+
|
|
+/*
|
|
+ * lock used to protect the list of dma channels while searching for a free
|
|
+ * channel during dma_request.
|
|
+ */
|
|
+//static spinlock_t dma_list_lock;
|
|
+static spinlock_t dma_list_lock = SPIN_LOCK_UNLOCKED;
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * Internal DMA processing functions.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * get_dma_channel_from_handle()
|
|
+ *
|
|
+ * If Handle is valid, returns the DMA channel # (0 to 9 for channels 1-10)
|
|
+ * If Handle is not valid, returns -1.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static int
|
|
+dma_get_channel_from_handle(int handle)
|
|
+{
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA channel # from the handle.
|
|
+ */
|
|
+ channel = ((int)handle & DMA_HANDLE_SPECIFIER_MASK) >> 28;
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (dma_chan[channel].last_valid_handle != (int)handle) {
|
|
+ DPRINTK("DMA ERROR - invalid handle 0x%x \n", handle);
|
|
+ return(-1);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * See if this instance is still open
|
|
+ */
|
|
+ if (!dma_chan[channel].ref_count )
|
|
+ return(-1);
|
|
+
|
|
+ return(channel);
|
|
+}
|
|
+
|
|
+static void dma_m2m_transfer_done(ep93xx_dma_t *dma)
|
|
+{
|
|
+ unsigned int uiCONTROL;
|
|
+ unsigned int M2M_reg_base = dma->reg_base;
|
|
+ unsigned int read_back;
|
|
+
|
|
+ DPRINTK("1 ");
|
|
+
|
|
+ outl( 0, M2M_reg_base+M2M_OFFSET_INTERRUPT );
|
|
+
|
|
+ if (dma->total_buffers) {
|
|
+ /*
|
|
+ * The current_buffer has already been tranfered, so add the
|
|
+ * byte count to the total_bytes field.
|
|
+ */
|
|
+ dma->total_bytes = dma->total_bytes +
|
|
+ dma->buffer_queue[dma->current_buffer].size;
|
|
+
|
|
+ /*
|
|
+ * Mark the current_buffer as used.
|
|
+ */
|
|
+ dma->buffer_queue[dma->current_buffer].used = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Increment the used buffer counter
|
|
+ */
|
|
+ dma->used_buffers++;
|
|
+
|
|
+ DPRINTK("#%d", dma->current_buffer);
|
|
+
|
|
+ /*
|
|
+ * Increment the current_buffer
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ /*
|
|
+ * check if there's a new buffer to transfer.
|
|
+ */
|
|
+ if (dma->new_buffers && dma->xfer_enable) {
|
|
+ /*
|
|
+ * We have a new buffer to transfer so program in the
|
|
+ * buffer values. Since a STALL interrupt was
|
|
+ * triggered, we program the buffer descriptor 0
|
|
+ *
|
|
+ * Set the SAR_BASE/DAR_BASE/BCR registers with values
|
|
+ * from the next buffer in the queue.
|
|
+ */
|
|
+ outl( dma->buffer_queue[dma->current_buffer].source,
|
|
+ M2M_reg_base + M2M_OFFSET_SAR_BASE0 );
|
|
+
|
|
+ outl( dma->buffer_queue[dma->current_buffer].dest,
|
|
+ M2M_reg_base + M2M_OFFSET_DAR_BASE0 );
|
|
+
|
|
+ outl( dma->buffer_queue[dma->current_buffer].size,
|
|
+ M2M_reg_base + M2M_OFFSET_BCR0 );
|
|
+
|
|
+ DPRINTK("SAR_BASE0 - 0x%x\n", dma->buffer_queue[dma->current_buffer].source);
|
|
+ DPRINTK("DAR_BASE0 - 0x%x\n", dma->buffer_queue[dma->current_buffer].dest);
|
|
+ DPRINTK("BCR0 - 0x%x\n", dma->buffer_queue[dma->current_buffer].size);
|
|
+
|
|
+ /*
|
|
+ * Decrement the new buffer counter
|
|
+ */
|
|
+ dma->new_buffers--;
|
|
+
|
|
+ /*
|
|
+ * If there's a second new buffer, we program the
|
|
+ * second buffer descriptor.
|
|
+ */
|
|
+ if (dma->new_buffers) {
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2M_reg_base+M2M_OFFSET_SAR_BASE1 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].dest,
|
|
+ M2M_reg_base+M2M_OFFSET_DAR_BASE1 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2M_reg_base+M2M_OFFSET_BCR1 );
|
|
+
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2M_NFBINTEN;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ dma->new_buffers--;
|
|
+ }
|
|
+ } else {
|
|
+ DPRINTK("2 \n");
|
|
+ /*
|
|
+ * There's a chance we setup both buffer descriptors,
|
|
+ * but didn't service the NFB quickly enough, causing
|
|
+ * the channel to transfer both buffers, then enter the
|
|
+ * stall state. So, we need to be able to process the
|
|
+ * second buffer.
|
|
+ */
|
|
+ if ((dma->used_buffers + dma->new_buffers) < dma->total_buffers)
|
|
+ {
|
|
+ DPRINTK("3 ");
|
|
+
|
|
+ /*
|
|
+ * The current_buffer has already been
|
|
+ * tranferred, so add the byte count to the
|
|
+ * total_bytes field.
|
|
+ */
|
|
+ dma->total_bytes = dma->total_bytes +
|
|
+ dma->buffer_queue[dma->current_buffer].size;
|
|
+
|
|
+ /*
|
|
+ * Mark the current_buffer as used.
|
|
+ */
|
|
+ dma->buffer_queue[dma->current_buffer].used = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Increment the used buffer counter
|
|
+ */
|
|
+ dma->used_buffers++;
|
|
+
|
|
+ DPRINTK("#%d", dma->current_buffer);
|
|
+
|
|
+ /*
|
|
+ * Increment the current buffer pointer.
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * No new buffers to transfer, so disable the channel.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_ENABLE;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Indicate that this channel is in the pause by
|
|
+ * starvation state by setting the pause bit to true.
|
|
+ */
|
|
+ dma->pause = TRUE;
|
|
+ }
|
|
+ } else {
|
|
+ /*
|
|
+ * No buffers to transfer, or old buffers to mark as used,
|
|
+ * so disable the channel
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_ENABLE;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Must read the control register back after a write.
|
|
+ */
|
|
+ read_back = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+
|
|
+ /*
|
|
+ * Indicate that this channel is in the pause by
|
|
+ * starvation state by setting the pause bit to true.
|
|
+ */
|
|
+ dma->pause = TRUE;
|
|
+ }
|
|
+}
|
|
+
|
|
+static void dma_m2m_next_frame_buffer(ep93xx_dma_t *dma)
|
|
+{
|
|
+ int loop;
|
|
+ unsigned int uiCONTROL;
|
|
+ unsigned int M2M_reg_base = dma->reg_base;
|
|
+
|
|
+ DPRINTK("5 ");
|
|
+
|
|
+ if (dma->total_buffers) {
|
|
+ DPRINTK("6 ");
|
|
+ /*
|
|
+ * The iCurrentBuffer has already been transfered. so add the
|
|
+ * byte count from the current buffer to the total byte count.
|
|
+ */
|
|
+ dma->total_bytes = dma->total_bytes +
|
|
+ dma->buffer_queue[dma->current_buffer].size;
|
|
+
|
|
+ /*
|
|
+ * Mark the Current Buffer as used.
|
|
+ */
|
|
+ dma->buffer_queue[dma->current_buffer].used = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Increment the used buffer counter
|
|
+ */
|
|
+ dma->used_buffers++;
|
|
+
|
|
+ DPRINTK("#%d", dma->current_buffer);
|
|
+
|
|
+ if ((dma->buffer_queue[
|
|
+ (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS].last) ||
|
|
+ (dma->new_buffers == 0) || (dma->xfer_enable == FALSE)) {
|
|
+ DPRINTK("7 ");
|
|
+
|
|
+ /*
|
|
+ * This is the last Buffer in this transaction, so
|
|
+ * disable the NFB interrupt. We shouldn't get an NFB
|
|
+ * int when the FSM moves to the ON state where it
|
|
+ * would typically get the NFB int indicating a new
|
|
+ * buffer can be programmed. Instead, once in the ON
|
|
+ * state, the DMA will just proceed to complete the
|
|
+ * transfer of the current buffer, move the FSB
|
|
+ * directly to the STALL state where a STALL interrupt
|
|
+ * will be generated.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_NFBINTEN ;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * The current buffer has been transferred, so
|
|
+ * increment the current buffer counter to reflect
|
|
+ * this.
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ DPRINTK("End of NFB handling. \n");
|
|
+ DPRINTK("CONTROL - 0x%x \n",
|
|
+ inl(M2M_reg_base+M2M_OFFSET_CONTROL) );
|
|
+ DPRINTK("STATUS - 0x%x \n",
|
|
+ inl(M2M_reg_base+M2M_OFFSET_STATUS) );
|
|
+ DPRINTK("SAR_BASE0 - 0x%x \n",
|
|
+ inl(M2M_reg_base+M2M_OFFSET_SAR_BASE0) );
|
|
+ DPRINTK("SAR_CUR0 - 0x%x \n",
|
|
+ inl(M2M_reg_base+M2M_OFFSET_SAR_CURRENT0) );
|
|
+ DPRINTK("DAR_BASE0 - 0x%x \n",
|
|
+ inl(M2M_reg_base+M2M_OFFSET_DAR_BASE0) );
|
|
+ DPRINTK("DAR_CUR0 - 0x%x \n",
|
|
+ inl(M2M_reg_base+M2M_OFFSET_DAR_CURRENT0) );
|
|
+
|
|
+ DPRINTK("Buffer buf_id source size last used \n");
|
|
+ for (loop = 0; loop < 32; loop ++)
|
|
+ DPRINTK("%d 0x%x 0x%x 0x%x %d %d \n",
|
|
+ loop, dma->buffer_queue[loop].buf_id,
|
|
+ dma->buffer_queue[loop].source,
|
|
+ dma->buffer_queue[loop].size,
|
|
+ dma->buffer_queue[loop].last,
|
|
+ dma->buffer_queue[loop].used);
|
|
+ DPRINTK("pause 0x%x 0x%x 0x%x %d %d \n",
|
|
+ dma->pause_buf.buf_id, dma->pause_buf.source,
|
|
+ dma->pause_buf.size, dma->pause_buf.last,
|
|
+ dma->pause_buf.used);
|
|
+
|
|
+ DPRINTK("Pause - %d \n", dma->pause);
|
|
+ DPRINTK("xfer_enable - %d \n", dma->xfer_enable);
|
|
+ DPRINTK("total bytes - 0x%x \n", dma->total_bytes);
|
|
+ DPRINTK("total buffer - %d \n", dma->total_buffers);
|
|
+ DPRINTK("new buffers - %d \n", dma->new_buffers);
|
|
+ DPRINTK("current buffer - %d \n", dma->current_buffer);
|
|
+ DPRINTK("last buffer - %d \n", dma->last_buffer);
|
|
+ DPRINTK("used buffers - %d \n", dma->used_buffers);
|
|
+ DPRINTK("callback addr - 0x%p \n", dma->callback);
|
|
+
|
|
+ } else if (dma->new_buffers) {
|
|
+ DPRINTK("8 ");
|
|
+ /*
|
|
+ * We have a new buffer, so increment the current
|
|
+ * buffer to point to the next buffer, which is already
|
|
+ * programmed into the DMA. Next time around, it'll be
|
|
+ * pointing to the current buffer.
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ /*
|
|
+ * We know we have a new buffer to program as the next
|
|
+ * buffer, so check which set of SAR_BASE/DAR_BASE/BCR
|
|
+ * registers to program.
|
|
+ */
|
|
+ if ( inl(M2M_reg_base+M2M_OFFSET_STATUS) & STATUS_M2M_NB ) {
|
|
+ /*
|
|
+ * Set the SAR_BASE1/DAR_BASE1/BCR1 registers
|
|
+ * with values from the next buffer in the
|
|
+ * queue.
|
|
+ */
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2M_reg_base+M2M_OFFSET_SAR_BASE1 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].dest,
|
|
+ M2M_reg_base+M2M_OFFSET_DAR_BASE1 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2M_reg_base+M2M_OFFSET_BCR1 );
|
|
+ } else {
|
|
+ /*
|
|
+ * Set the SAR_BASE0/DAR_BASE0/BCR0 registers
|
|
+ * with values from the next buffer in the
|
|
+ * queue.
|
|
+ */
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2M_reg_base+M2M_OFFSET_SAR_BASE0 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].dest,
|
|
+ M2M_reg_base+M2M_OFFSET_DAR_BASE0 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2M_reg_base+M2M_OFFSET_BCR0 );
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Decrement the new buffers counter
|
|
+ */
|
|
+ dma->new_buffers--;
|
|
+ }
|
|
+ } else {
|
|
+ /*
|
|
+ * Total number of buffers is 0 - really we should never get
|
|
+ * here, but just in case.
|
|
+ */
|
|
+ DPRINTK("9 \n");
|
|
+
|
|
+ /*
|
|
+ * No new buffers to transfer, so Disable the channel
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_ENABLE;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Indicate that the channel is paused by starvation.
|
|
+ */
|
|
+ dma->pause = 1;
|
|
+ }
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * dma_m2m_irq_handler
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static irqreturn_t
|
|
+dma_m2m_irq_handler(int irq, void *dev_id)
|
|
+{
|
|
+ ep93xx_dma_t *dma = (ep93xx_dma_t *)dev_id;
|
|
+ unsigned int M2M_reg_base = dma->reg_base;
|
|
+ ep93xx_dma_dev_t dma_int = UNDEF_INT;
|
|
+ int status;
|
|
+
|
|
+// printk("+m2m irq=%d\n", irq);
|
|
+
|
|
+ /*
|
|
+ * Determine what kind of dma interrupt this is.
|
|
+ */
|
|
+ status = inl(M2M_reg_base + M2M_OFFSET_INTERRUPT);
|
|
+ if ( status & INTERRUPT_M2M_DONEINT )
|
|
+ dma_int = DONE; // we're done with a requested dma
|
|
+ else if ( status & INTERRUPT_M2M_NFBINT )
|
|
+ dma_int = NFB; // we're done with one dma buffer
|
|
+
|
|
+ DPRINTK("IRQ: b=%#x st=%#x\n", (int)dma->current_buffer, dma_int);
|
|
+
|
|
+ switch (dma_int) {
|
|
+ /*
|
|
+ * Next Frame Buffer Interrupt. If there's a new buffer program it
|
|
+ * Check if this is the last buffer in the transfer,
|
|
+ * and if it is, disable the NFB int to prevent being
|
|
+ * interrupted for another buffer when we know there won't be
|
|
+ * another.
|
|
+ */
|
|
+ case NFB:
|
|
+ dma_m2m_next_frame_buffer(dma);
|
|
+ break;
|
|
+ /*
|
|
+ * Done interrupt generated, indicating that the transfer is complete.
|
|
+ */
|
|
+ case DONE:
|
|
+ dma_m2m_transfer_done(dma);
|
|
+ break;
|
|
+
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ if ((dma_int != UNDEF_INT) && dma->callback)
|
|
+ dma->callback(dma_int, dma->device, dma->user_data);
|
|
+
|
|
+ return IRQ_HANDLED;
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * dma_m2p_irq_handler
|
|
+ *
|
|
+ *
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static irqreturn_t
|
|
+dma_m2p_irq_handler(int irq, void *dev_id)
|
|
+{
|
|
+ ep93xx_dma_t *dma = (ep93xx_dma_t *) dev_id;
|
|
+ unsigned int M2P_reg_base = dma->reg_base;
|
|
+ unsigned int read_back;
|
|
+ ep93xx_dma_dev_t dma_int = UNDEF_INT;
|
|
+ unsigned int loop, uiCONTROL, uiINTERRUPT;
|
|
+
|
|
+ /*
|
|
+ * Determine what kind of dma interrupt this is.
|
|
+ */
|
|
+ if ( inl(M2P_reg_base+M2P_OFFSET_INTERRUPT) & INTERRUPT_M2P_STALLINT )
|
|
+ dma_int = STALL;
|
|
+ else if ( inl(M2P_reg_base+M2P_OFFSET_INTERRUPT) & INTERRUPT_M2P_NFBINT )
|
|
+ dma_int = NFB;
|
|
+ else if ( inl(M2P_reg_base+M2P_OFFSET_INTERRUPT) & INTERRUPT_M2P_CHERRORINT )
|
|
+ dma_int = CHERROR;
|
|
+
|
|
+ /*
|
|
+ * Stall Interrupt: The Channel is stalled, meaning nothing is
|
|
+ * programmed to transfer right now. So, we're back to the
|
|
+ * beginnning. If there's a buffer to transfer, program it into
|
|
+ * max and base 0 registers.
|
|
+ */
|
|
+ if (dma_int == STALL) {
|
|
+ DPRINTK("1 ");
|
|
+
|
|
+ if (dma->total_buffers) {
|
|
+ /*
|
|
+ * The current_buffer has already been tranfered, so
|
|
+ * add the byte count to the total_bytes field.
|
|
+ */
|
|
+ dma->total_bytes = dma->total_bytes +
|
|
+ dma->buffer_queue[dma->current_buffer].size;
|
|
+
|
|
+ /*
|
|
+ * Mark the current_buffer as used.
|
|
+ */
|
|
+ dma->buffer_queue[dma->current_buffer].used = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Increment the used buffer counter
|
|
+ */
|
|
+ dma->used_buffers++;
|
|
+
|
|
+ DPRINTK("#%d", dma->current_buffer);
|
|
+
|
|
+ /*
|
|
+ * Increment the current_buffer
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ /*
|
|
+ * check if there's a new buffer to transfer.
|
|
+ */
|
|
+ if (dma->new_buffers && dma->xfer_enable) {
|
|
+ /*
|
|
+ * We have a new buffer to transfer so program
|
|
+ * in the buffer values. Since a STALL
|
|
+ * interrupt was triggered, we program the
|
|
+ * base0 and maxcnt0
|
|
+ *
|
|
+ * Set the MAXCNT0 register with the buffer
|
|
+ * size
|
|
+ */
|
|
+ outl( dma->buffer_queue[dma->current_buffer].size,
|
|
+ M2P_reg_base+M2P_OFFSET_MAXCNT0 );
|
|
+
|
|
+ /*
|
|
+ * Set the BASE0 register with the buffer base
|
|
+ * address
|
|
+ */
|
|
+ outl( dma->buffer_queue[dma->current_buffer].source,
|
|
+ M2P_reg_base+M2P_OFFSET_BASE0 );
|
|
+
|
|
+ /*
|
|
+ * Decrement the new buffer counter
|
|
+ */
|
|
+ dma->new_buffers--;
|
|
+
|
|
+ if (dma->new_buffers) {
|
|
+ DPRINTK("A ");
|
|
+ /*
|
|
+ * Set the MAXCNT1 register with the
|
|
+ * buffer size
|
|
+ */
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2P_reg_base+M2P_OFFSET_MAXCNT1 );
|
|
+
|
|
+ /*
|
|
+ * Set the BASE1 register with the
|
|
+ * buffer base address
|
|
+ */
|
|
+ outl( dma->buffer_queue[dma->current_buffer + 1 %
|
|
+ MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2P_reg_base+M2P_OFFSET_BASE1 );
|
|
+
|
|
+ /*
|
|
+ * Decrement the new buffer counter
|
|
+ */
|
|
+ dma->new_buffers--;
|
|
+
|
|
+ /*
|
|
+ * Enable the NFB Interrupt.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2P_NFBINTEN;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+ }
|
|
+ } else {
|
|
+ /*
|
|
+ * No new buffers.
|
|
+ */
|
|
+ DPRINTK("2 \n");
|
|
+
|
|
+ /*
|
|
+ * There's a chance we setup both buffer descriptors, but
|
|
+ * didn't service the NFB quickly enough, causing the channel
|
|
+ * to transfer both buffers, then enter the stall state.
|
|
+ * So, we need to be able to process the second buffer.
|
|
+ */
|
|
+ if ((dma->used_buffers + dma->new_buffers) < dma->total_buffers) {
|
|
+ DPRINTK("3 ");
|
|
+
|
|
+ /*
|
|
+ * The current_buffer has already been tranfered, so add the
|
|
+ * byte count to the total_bytes field.
|
|
+ */
|
|
+ dma->total_bytes = dma->total_bytes +
|
|
+ dma->buffer_queue[dma->current_buffer].size;
|
|
+
|
|
+ /*
|
|
+ * Mark the current_buffer as used.
|
|
+ */
|
|
+ dma->buffer_queue[dma->current_buffer].used = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Increment the used buffer counter
|
|
+ */
|
|
+ dma->used_buffers++;
|
|
+
|
|
+ DPRINTK("#%d", dma->current_buffer);
|
|
+
|
|
+ /*
|
|
+ * Increment the current buffer pointer.
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * No new buffers to transfer, so disable the channel.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2P_ENABLE;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Indicate that this channel is in the pause by starvation
|
|
+ * state by setting the pause bit to true.
|
|
+ */
|
|
+ dma->pause = TRUE;
|
|
+
|
|
+ DPRINTK("STATUS - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_STATUS) );
|
|
+ DPRINTK("CONTROL - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CONTROL) );
|
|
+ DPRINTK("REMAIN - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_REMAIN) );
|
|
+ DPRINTK("PPALLOC - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_PPALLOC) );
|
|
+ DPRINTK("BASE0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE0) );
|
|
+ DPRINTK("MAXCNT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT0) );
|
|
+ DPRINTK("CURRENT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT0) );
|
|
+ DPRINTK("BASE1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE1) );
|
|
+ DPRINTK("MAXCNT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT1) );
|
|
+ DPRINTK("CURRENT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT1) );
|
|
+
|
|
+ DPRINTK("Buffer buf_id source size last used \n");
|
|
+ for (loop = 0; loop < 32; loop ++)
|
|
+ DPRINTK("%d 0x%x 0x%x 0x%x %d %d \n",
|
|
+ loop, dma->buffer_queue[loop].buf_id, dma->buffer_queue[loop].source,
|
|
+ dma->buffer_queue[loop].size,
|
|
+ dma->buffer_queue[loop].last, dma->buffer_queue[loop].used);
|
|
+ DPRINTK("pause 0x%x 0x%x 0x%x %d %d \n",
|
|
+ dma->pause_buf.buf_id, dma->pause_buf.source, dma->pause_buf.size,
|
|
+ dma->pause_buf.last, dma->pause_buf.used);
|
|
+
|
|
+ DPRINTK("Pause - %d \n", dma->pause);
|
|
+ DPRINTK("xfer_enable - %d \n", dma->xfer_enable);
|
|
+ DPRINTK("total bytes - 0x%x \n", dma->total_bytes);
|
|
+ DPRINTK("total buffer - %d \n", dma->total_buffers);
|
|
+ DPRINTK("new buffers - %d \n", dma->new_buffers);
|
|
+ DPRINTK("current buffer - %d \n", dma->current_buffer);
|
|
+ DPRINTK("last buffer - %d \n", dma->last_buffer);
|
|
+ DPRINTK("used buffers - %d \n", dma->used_buffers);
|
|
+ DPRINTK("callback addr - 0x%p \n", dma->callback);
|
|
+ }
|
|
+ } else {
|
|
+ /*
|
|
+ * No buffers to transfer, or old buffers to mark as used,
|
|
+ * so Disable the channel
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2P_ENABLE;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Must read the control register back after a write.
|
|
+ */
|
|
+ read_back = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+
|
|
+ /*
|
|
+ * Indicate that this channel is in the pause by
|
|
+ * starvation state by setting the pause bit to true.
|
|
+ */
|
|
+ dma->pause = TRUE;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Next Frame Buffer Interrupt. If there's a new buffer program it
|
|
+ * Check if this is the last buffer in the transfer,
|
|
+ * and if it is, disable the NFB int to prevent being
|
|
+ * interrupted for another buffer when we know there won't be
|
|
+ * another.
|
|
+ */
|
|
+ if (dma_int == NFB) {
|
|
+ DPRINTK("5 ");
|
|
+
|
|
+ if (dma->total_buffers) {
|
|
+ DPRINTK("6 ");
|
|
+ /*
|
|
+ * The iCurrentBuffer has already been transfered. so add the
|
|
+ * byte count from the current buffer to the total byte count.
|
|
+ */
|
|
+ dma->total_bytes = dma->total_bytes +
|
|
+ dma->buffer_queue[dma->current_buffer].size;
|
|
+
|
|
+ /*
|
|
+ * Mark the Current Buffer as used.
|
|
+ */
|
|
+ dma->buffer_queue[dma->current_buffer].used = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Increment the used buffer counter
|
|
+ */
|
|
+ dma->used_buffers++;
|
|
+
|
|
+ DPRINTK("#%d", dma->current_buffer);
|
|
+
|
|
+ if ((dma->buffer_queue[
|
|
+ (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS].last) ||
|
|
+ (dma->new_buffers == 0) || (dma->xfer_enable == FALSE)) {
|
|
+ DPRINTK("7 ");
|
|
+
|
|
+ /*
|
|
+ * This is the last Buffer in this transaction, so disable
|
|
+ * the NFB interrupt. We shouldn't get an NFB int when the
|
|
+ * FSM moves to the ON state where it would typically get the
|
|
+ * NFB int indicating a new buffer can be programmed.
|
|
+ * Instead, once in the ON state, the DMA will just proceed
|
|
+ * to complet the transfer of the current buffer, move the
|
|
+ * FSB directly to the STALL state where a STALL interrupt
|
|
+ * will be generated.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2P_NFBINTEN;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * The current buffer has been transferred, so increment
|
|
+ * the current buffer counter to reflect this.
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ DPRINTK("End of NFB handling. \n");
|
|
+ DPRINTK("STATUS - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_STATUS) );
|
|
+ DPRINTK("CONTROL - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CONTROL) );
|
|
+ DPRINTK("REMAIN - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_REMAIN) );
|
|
+ DPRINTK("PPALLOC - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_PPALLOC) );
|
|
+ DPRINTK("BASE0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE0) );
|
|
+ DPRINTK("MAXCNT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT0) );
|
|
+ DPRINTK("CURRENT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT0) );
|
|
+ DPRINTK("BASE1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE1) );
|
|
+ DPRINTK("MAXCNT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT1) );
|
|
+ DPRINTK("CURRENT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT1) );
|
|
+
|
|
+ DPRINTK("Buffer buf_id source size last used \n");
|
|
+ for (loop = 0; loop < 32; loop ++)
|
|
+ DPRINTK("%d 0x%x 0x%x 0x%x %d %d \n",
|
|
+ loop, dma->buffer_queue[loop].buf_id, dma->buffer_queue[loop].source,
|
|
+ dma->buffer_queue[loop].size,
|
|
+ dma->buffer_queue[loop].last, dma->buffer_queue[loop].used);
|
|
+ DPRINTK("pause 0x%x 0x%x 0x%x %d %d \n",
|
|
+ dma->pause_buf.buf_id, dma->pause_buf.source, dma->pause_buf.size,
|
|
+ dma->pause_buf.last, dma->pause_buf.used);
|
|
+
|
|
+ DPRINTK("Pause - %d \n", dma->pause);
|
|
+ DPRINTK("xfer_enable - %d \n", dma->xfer_enable);
|
|
+ DPRINTK("total bytes - 0x%x \n", dma->total_bytes);
|
|
+ DPRINTK("total buffer - %d \n", dma->total_buffers);
|
|
+ DPRINTK("new buffers - %d \n", dma->new_buffers);
|
|
+ DPRINTK("current buffer - %d \n", dma->current_buffer);
|
|
+ DPRINTK("last buffer - %d \n", dma->last_buffer);
|
|
+ DPRINTK("used buffers - %d \n", dma->used_buffers);
|
|
+ DPRINTK("callback addr - 0x%p \n", dma->callback);
|
|
+
|
|
+ } else if (dma->new_buffers) {
|
|
+ DPRINTK("8 ");
|
|
+ /*
|
|
+ * we have a new buffer, so increment the current buffer to
|
|
+ * point to the next buffer, which is already programmed into
|
|
+ * the DMA. Next time around, it'll be pointing to the
|
|
+ * current buffer.
|
|
+ */
|
|
+ dma->current_buffer = (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ /*
|
|
+ * we know we have a new buffer to program as the next
|
|
+ * buffer, so check which set of MAXCNT and BASE registers
|
|
+ * to program.
|
|
+ */
|
|
+ if ( inl(M2P_reg_base+M2P_OFFSET_STATUS) & STATUS_M2P_NEXTBUFFER ) {
|
|
+ /*
|
|
+ * Set the MAXCNT1 register with the buffer size
|
|
+ */
|
|
+ outl( dma->buffer_queue[
|
|
+ (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2P_reg_base+M2P_OFFSET_MAXCNT1 );
|
|
+
|
|
+ /*
|
|
+ * Set the BASE1 register with the buffer base address
|
|
+ */
|
|
+ outl( dma->buffer_queue[
|
|
+ (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2P_reg_base+M2P_OFFSET_BASE1 );
|
|
+ } else {
|
|
+ /*
|
|
+ * Set the MAXCNT0 register with the buffer size
|
|
+ */
|
|
+ outl( dma->buffer_queue[
|
|
+ (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2P_reg_base+M2P_OFFSET_MAXCNT0 );
|
|
+
|
|
+ /*
|
|
+ * Set the BASE0 register with the buffer base address
|
|
+ */
|
|
+ outl( dma->buffer_queue[
|
|
+ (dma->current_buffer + 1) % MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2P_reg_base+M2P_OFFSET_BASE0 );
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Decrement the new buffers counter
|
|
+ */
|
|
+ dma->new_buffers--;
|
|
+ }
|
|
+ } else {
|
|
+ /*
|
|
+ * Total number of buffers is 0 - really we should never get here,
|
|
+ * but just in case.
|
|
+ */
|
|
+ DPRINTK("9 \n");
|
|
+
|
|
+ /*
|
|
+ * No new buffers to transfer, so Disable the channel
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2P_ENABLE;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Channel Error Interrupt, or perhipheral interrupt, specific to the
|
|
+ * memory to/from peripheral channels.
|
|
+ */
|
|
+ if (dma_int == CHERROR) {
|
|
+ /*
|
|
+ * just clear the interrupt, it's really up to the peripheral
|
|
+ * driver to determine if any further action is necessary.
|
|
+ */
|
|
+ uiINTERRUPT = inl(M2P_reg_base+M2P_OFFSET_INTERRUPT);
|
|
+ uiINTERRUPT &= ~INTERRUPT_M2P_CHERRORINT;
|
|
+ outl( uiINTERRUPT, M2P_reg_base+M2P_OFFSET_INTERRUPT );
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Make sure the interrupt was valid, and if it was, then check
|
|
+ * if a callback function was installed for this DMA channel. If a
|
|
+ * callback was installed call it.
|
|
+ */
|
|
+ if ((dma_int != UNDEF_INT) && dma->callback)
|
|
+ dma->callback(dma_int, dma->device, dma->user_data);
|
|
+
|
|
+ return IRQ_HANDLED;
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * ep9312_dma_open_m2p(int device)
|
|
+ *
|
|
+ * Description: This function will attempt to open a M2P/P2M DMA channel.
|
|
+ * If the open is successful, the channel number is returned,
|
|
+ * otherwise a negative number is returned.
|
|
+ *
|
|
+ * Parameters:
|
|
+ * device: device for which the dma channel is requested.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static int
|
|
+dma_open_m2p(int device)
|
|
+{
|
|
+ int channel = -1;
|
|
+ unsigned int loop;
|
|
+ unsigned int M2P_reg_base;
|
|
+ unsigned int uiPWRCNT;
|
|
+ /*unsigned long flags;*/
|
|
+
|
|
+ DPRINTK("DMA Open M2P with hw dev %d\n", device);
|
|
+
|
|
+ /*
|
|
+ * Lock the dma channel list.
|
|
+ */
|
|
+ //spin_lock_irqsave(&dma_list_lock, flags);
|
|
+ spin_lock(&dma_list_lock);
|
|
+
|
|
+ /*
|
|
+ * Verify that the device requesting DMA isn't already using a DMA channel
|
|
+ */
|
|
+ if (device >= 10)
|
|
+ loop = 1; // Rx transfer requested
|
|
+ else
|
|
+ loop = 0; // Tx transfer requested
|
|
+
|
|
+ for (; loop < 10; loop = loop + 2)
|
|
+ /*
|
|
+ * Before checking for a matching device, check that the
|
|
+ * channel is in use, otherwise the device field is
|
|
+ * invalid.
|
|
+ */
|
|
+ if (dma_chan[loop].ref_count)
|
|
+ if (device == dma_chan[loop].device) {
|
|
+ DPRINTK("DMA Open M2P - Error\n");
|
|
+ return(-1);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Get a DMA channel instance for the given hardware device.
|
|
+ * If this is a TX look for even numbered channels, else look for
|
|
+ * odd numbered channels
|
|
+ */
|
|
+ if (device >= 10)
|
|
+ loop = 1; /* Rx transfer requested */
|
|
+ else
|
|
+ loop = 0; /* Tx transfer requested */
|
|
+
|
|
+ for (; loop < 10; loop = loop + 2)
|
|
+ if (!dma_chan[loop].ref_count) {
|
|
+ /*
|
|
+ * Capture the channel and increment the reference count.
|
|
+ */
|
|
+ channel = loop;
|
|
+ dma_chan[channel].ref_count++;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Unlock the dma channel list.
|
|
+ */
|
|
+ //spin_unlock_irqrestore(&dma_list_lock, flags);
|
|
+ spin_unlock(&dma_list_lock);
|
|
+ /*
|
|
+ * See if we got a valid channel.
|
|
+ */
|
|
+ if (channel < 0)
|
|
+ return(-1);
|
|
+
|
|
+ /*
|
|
+ * Point regs to the correct dma channel register base.
|
|
+ */
|
|
+ M2P_reg_base = dma_chan[channel].reg_base;
|
|
+
|
|
+ /*
|
|
+ * Turn on the clock for the specified DMA channel
|
|
+ * TODO: need to use the correct register name for the
|
|
+ * power control register.
|
|
+ */
|
|
+ uiPWRCNT = inl(/*SYSCON_PWRCNT*/EP93XX_SYSCON_CLOCK_CONTROL);
|
|
+ switch (channel) {
|
|
+ case 0:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH0;
|
|
+ break;
|
|
+
|
|
+ case 1:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH1;
|
|
+ break;
|
|
+
|
|
+ case 2:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH2;
|
|
+ break;
|
|
+
|
|
+ case 3:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH3;
|
|
+ break;
|
|
+
|
|
+ case 4:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH4;
|
|
+ break;
|
|
+
|
|
+ case 5:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH5;
|
|
+ break;
|
|
+
|
|
+ case 6:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH6;
|
|
+ break;
|
|
+
|
|
+ case 7:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH7;
|
|
+ break;
|
|
+
|
|
+ case 8:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH8;
|
|
+ break;
|
|
+
|
|
+ case 9:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2PCH9;
|
|
+ break;
|
|
+
|
|
+ default:
|
|
+ return(-1);
|
|
+ }
|
|
+ outl( uiPWRCNT, /*SYSCON_PWRCNT*/EP93XX_SYSCON_CLOCK_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Clear out the control register before any further setup.
|
|
+ */
|
|
+ outl( 0, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Setup the peripheral port value in the DMA channel registers.
|
|
+ */
|
|
+ if (device < 10)
|
|
+ outl( (unsigned int)device, M2P_reg_base+M2P_OFFSET_PPALLOC );
|
|
+ else
|
|
+ outl( (unsigned int)(device - 10), M2P_reg_base+M2P_OFFSET_PPALLOC );
|
|
+
|
|
+ /*
|
|
+ * Let's hold on to the value of the Hw device for comparison later.
|
|
+ */
|
|
+ dma_chan[channel].device = device;
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(channel);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * dma_open_m2m(int device)
|
|
+ *
|
|
+ * Description: This function will attempt to open a M2M DMA channel.
|
|
+ * If the open is successful, the channel number is returned,
|
|
+ * otherwise a negative number is returned.
|
|
+ *
|
|
+ * Parameters:
|
|
+ * device: device for which the dma channel is requested.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static int
|
|
+dma_open_m2m(int device)
|
|
+{
|
|
+ int channel = -1;
|
|
+ unsigned int loop;
|
|
+ unsigned int M2M_reg_base;
|
|
+ unsigned int uiPWRCNT, uiCONTROL;
|
|
+ /*unsigned long flags;*/
|
|
+
|
|
+ DPRINTK("DMA Open M2M with hw dev %d\n", device);
|
|
+
|
|
+ /*
|
|
+ * Lock the dma channel list.
|
|
+ */
|
|
+ //spin_lock_irqsave(&dma_list_lock, flags);
|
|
+ spin_lock(&dma_list_lock);
|
|
+
|
|
+
|
|
+ /*
|
|
+ * Check if this device is already allocated a channel.
|
|
+ * TODO: can one M2M device be allocated multiple channels?
|
|
+ */
|
|
+ for (loop = 10; loop < 12; loop++)
|
|
+ /*
|
|
+ * Before checking for a matching device, check that the
|
|
+ * channel is in use, otherwise the device field is
|
|
+ * invalid.
|
|
+ */
|
|
+ if (dma_chan[loop].ref_count)
|
|
+ if (device == dma_chan[loop].device) {
|
|
+ DPRINTK("Error - dma_open_m2m - already allocated channel\n");
|
|
+
|
|
+ /*
|
|
+ * Unlock the dma channel list.
|
|
+ */
|
|
+ //spin_unlock_irqrestore(&dma_list_lock, flags);
|
|
+ spin_unlock(&dma_list_lock);
|
|
+ /*
|
|
+ * Fail.
|
|
+ */
|
|
+ return(-1);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Get a DMA channel instance for the given hardware device.
|
|
+ */
|
|
+ for (loop = 10; loop < 12; loop++)
|
|
+ if (!dma_chan[loop].ref_count) {
|
|
+ /*
|
|
+ * Capture the channel and increment the reference count.
|
|
+ */
|
|
+ channel = loop;
|
|
+ dma_chan[channel].ref_count++;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Unlock the dma channel list.
|
|
+ */
|
|
+ //spin_unlock(dma_list_lock);
|
|
+ spin_unlock(&dma_list_lock);
|
|
+ //spin_unlock_irqrestore(&dma_list_lock, flags);
|
|
+
|
|
+ /*
|
|
+ * See if we got a valid channel.
|
|
+ */
|
|
+ if (channel < 0)
|
|
+ return(-1);
|
|
+
|
|
+ /*
|
|
+ * Point regs to the correct dma channel register base.
|
|
+ */
|
|
+ M2M_reg_base = dma_chan[channel].reg_base;
|
|
+
|
|
+ /*
|
|
+ * Turn on the clock for the specified DMA channel
|
|
+ * TODO: need to use the correct register name for the
|
|
+ * power control register.
|
|
+ */
|
|
+ uiPWRCNT = inl(/*SYSCON_PWRCNT*/EP93XX_SYSCON_CLOCK_CONTROL);
|
|
+ switch (channel) {
|
|
+ case 10:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2MCH0;
|
|
+ break;
|
|
+
|
|
+ case 11:
|
|
+ uiPWRCNT |= SYSCON_PWRCNT_DMA_M2MCH1;
|
|
+ break;
|
|
+
|
|
+ default:
|
|
+ return(-1);
|
|
+ }
|
|
+ outl( uiPWRCNT, /*SYSCON_PWRCNT*/EP93XX_SYSCON_CLOCK_CONTROL);
|
|
+
|
|
+ DPRINTK("DMA Open - power control: 0x%x \n", inl(SYSCON_PWRCNT) );
|
|
+
|
|
+ /*
|
|
+ * Clear out the control register before any further setup.
|
|
+ */
|
|
+ outl( 0, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Setup the transfer mode and the request source selection within
|
|
+ * the DMA M2M channel registers.
|
|
+ */
|
|
+ switch (device) {
|
|
+ case DMA_MEMORY:
|
|
+ /*
|
|
+ * Clear TM field, set RSS field to 0
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_TM_MASK | CONTROL_M2M_RSS_MASK);
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ break;
|
|
+
|
|
+ case DMA_IDE:
|
|
+ /*
|
|
+ * Set RSS field to 3, Set NO_HDSK, Set PW field to 1
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_RSS_MASK|CONTROL_M2M_PW_MASK);
|
|
+ uiCONTROL |= (3<<CONTROL_M2M_RSS_SHIFT) |
|
|
+ CONTROL_M2M_NO_HDSK |
|
|
+ (2<<CONTROL_M2M_PW_SHIFT);
|
|
+
|
|
+ uiCONTROL &= ~(CONTROL_M2M_ETDP_MASK);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_DACKP);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_DREQP_MASK);
|
|
+
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ break;
|
|
+
|
|
+ case DMARx_SSP:
|
|
+ /*
|
|
+ * Set RSS field to 1, Set NO_HDSK, Set TM field to 2
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_RSS_MASK|CONTROL_M2M_TM_MASK);
|
|
+ uiCONTROL |= (1<<CONTROL_M2M_RSS_SHIFT) |
|
|
+ CONTROL_M2M_NO_HDSK |
|
|
+ (2<<CONTROL_M2M_TM_SHIFT);
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ break;
|
|
+
|
|
+ case DMATx_SSP:
|
|
+ /*
|
|
+ * Set RSS field to 2, Set NO_HDSK, Set TM field to 1
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_RSS_MASK|CONTROL_M2M_TM_MASK);
|
|
+ uiCONTROL |= (2<<CONTROL_M2M_RSS_SHIFT) |
|
|
+ CONTROL_M2M_NO_HDSK |
|
|
+ (1<<CONTROL_M2M_TM_SHIFT);
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ break;
|
|
+
|
|
+ case DMATx_EXT_DREQ:
|
|
+ /*
|
|
+ * Set TM field to 2, set RSS field to 0
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_RSS_MASK|CONTROL_M2M_TM_MASK);
|
|
+ uiCONTROL |= 1<<CONTROL_M2M_TM_SHIFT;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ break;
|
|
+
|
|
+ case DMARx_EXT_DREQ:
|
|
+ /*
|
|
+ * Set TM field to 2, set RSS field to 0
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~(CONTROL_M2M_RSS_MASK|CONTROL_M2M_TM_MASK);
|
|
+ uiCONTROL |= 2<<CONTROL_M2M_TM_SHIFT;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ break;
|
|
+
|
|
+ default:
|
|
+ return -1;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Let's hold on to the value of the Hw device for comparison later.
|
|
+ */
|
|
+ dma_chan[channel].device = device;
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(channel);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int dma_config_m2m(ep93xx_dma_t * dma, unsigned int flags_m2m,
|
|
+ * dma_callback callback, unsigned int user_data)
|
|
+ *
|
|
+ * Description: Configure the DMA channel and install a callback function.
|
|
+ * This function will have to be called for every transfer
|
|
+ *
|
|
+ * dma: Pointer to the dma instance data for the M2M channel to
|
|
+ * configure.
|
|
+ * flags_m2m Flags used to configure an M2M dma channel and determine
|
|
+ * if a callback function and user_data information are included
|
|
+ * in this call.
|
|
+ * callback function pointer which is called near the end of the
|
|
+ * dma channel's irq handler.
|
|
+ * user_data defined by the calling driver.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static int
|
|
+dma_config_m2m(ep93xx_dma_t * dma, unsigned int flags_m2m,
|
|
+ dma_callback callback, unsigned int user_data)
|
|
+{
|
|
+ unsigned long flags;
|
|
+ unsigned int M2M_reg_base, uiCONTROL;
|
|
+
|
|
+ /*
|
|
+ * Make sure the channel is disabled before configuring the channel.
|
|
+ *
|
|
+ * TODO: Is this correct?? Making a big change here...
|
|
+ */
|
|
+ /* if (!dma->pause || (!dma->pause && dma->xfer_enable)) */
|
|
+ if (dma->xfer_enable) {
|
|
+ /*
|
|
+ * DMA channel is not paused, so we can't configure it.
|
|
+ */
|
|
+ DPRINTK("DMA channel not paused, so can't configure! \n");
|
|
+ return(-1);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Mask interrupts.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Setup a pointer into the dma channel's register set.
|
|
+ */
|
|
+ M2M_reg_base = dma->reg_base;
|
|
+
|
|
+ uiCONTROL = inl(M2M_reg_base + M2M_OFFSET_CONTROL);
|
|
+ outl(0, M2M_reg_base + M2M_OFFSET_CONTROL);
|
|
+ inl(M2M_reg_base + M2M_OFFSET_CONTROL);
|
|
+ outl(uiCONTROL, M2M_reg_base + M2M_OFFSET_CONTROL);
|
|
+
|
|
+ /*
|
|
+ * By default we disable the stall interrupt.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_STALLINTEN;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * By default we disable the done interrupt.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_DONEINTEN;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Set up the transfer control fields based on values passed in
|
|
+ * the flags_m2m field.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+
|
|
+ if ( flags_m2m & DESTINATION_HOLD )
|
|
+ uiCONTROL |= CONTROL_M2M_DAH;
|
|
+ else
|
|
+ uiCONTROL &= ~CONTROL_M2M_DAH;
|
|
+
|
|
+ if ( flags_m2m & SOURCE_HOLD )
|
|
+ uiCONTROL |= CONTROL_M2M_SAH;
|
|
+ else
|
|
+ uiCONTROL &= ~CONTROL_M2M_SAH;
|
|
+
|
|
+ uiCONTROL &= ~CONTROL_M2M_TM_MASK;
|
|
+ uiCONTROL |= (((flags_m2m & TRANSFER_MODE_MASK) >> TRANSFER_MODE_SHIFT) <<
|
|
+ CONTROL_M2M_TM_SHIFT) & CONTROL_M2M_TM_MASK;
|
|
+
|
|
+ uiCONTROL &= ~CONTROL_M2M_PWSC_MASK;
|
|
+ uiCONTROL |= (((flags_m2m & WAIT_STATES_MASK) >> WAIT_STATES_SHIFT) <<
|
|
+ CONTROL_M2M_PWSC_SHIFT) & CONTROL_M2M_PWSC_MASK;
|
|
+
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ inl(M2M_reg_base + M2M_OFFSET_CONTROL);
|
|
+
|
|
+ /*
|
|
+ * Save the callback function in the dma instance for this channel.
|
|
+ */
|
|
+ dma->callback = callback;
|
|
+
|
|
+ /*
|
|
+ * Save the user data in the the dma instance for this channel.
|
|
+ */
|
|
+ dma->user_data = user_data;
|
|
+
|
|
+ /*
|
|
+ * Put the dma instance into the pause state by setting the
|
|
+ * pause bit to true.
|
|
+ */
|
|
+ dma->pause = TRUE;
|
|
+
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int dma_start(int handle, unsigned int channels, unsigned int * handles)
|
|
+ *
|
|
+ * Description: Initiate a transfer on up to 3 channels.
|
|
+ *
|
|
+ * handle: handle for the channel to initiate transfer on.
|
|
+ * channels: number of channels to initiate transfers on.
|
|
+ * handles: pointer to an array of handles, one for each channel which
|
|
+ * is to be started.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static int
|
|
+dma_start_m2m(int channel, ep93xx_dma_t * dma)
|
|
+{
|
|
+ unsigned long flags;
|
|
+ unsigned int M2M_reg_base = dma->reg_base;
|
|
+ unsigned int uiCONTROL;
|
|
+
|
|
+ /*
|
|
+ * Mask interrupts while we get this started.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Make sure the channel has at least one buffer in the queue.
|
|
+ */
|
|
+ if (dma->new_buffers < 1) {
|
|
+ /*
|
|
+ * Unmask irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ DPRINTK("DMA Start: Channel starved.\n");
|
|
+
|
|
+ /*
|
|
+ * This channel does not have enough buffers queued up,
|
|
+ * so enter the pause by starvation state.
|
|
+ */
|
|
+ dma->xfer_enable = TRUE;
|
|
+ dma->pause = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Clear any pending interrupts.
|
|
+ */
|
|
+ outl(0x0, M2M_reg_base+M2M_OFFSET_INTERRUPT);
|
|
+
|
|
+ /*
|
|
+ * Set up one or both buffer descriptors with values from the next one or
|
|
+ * two buffers in the queue. By default disable the next frame buffer
|
|
+ * interrupt on the channel.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_NFBINTEN;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * enable the done interrupt.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2M_DONEINTEN;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Update the dma channel instance transfer state.
|
|
+ */
|
|
+ dma->xfer_enable = TRUE;
|
|
+ dma->pause = FALSE;
|
|
+
|
|
+ /*
|
|
+ * Program up the first buffer descriptor with a source and destination
|
|
+ * and a byte count.
|
|
+ */
|
|
+ outl( dma->buffer_queue[dma->current_buffer].source,
|
|
+ M2M_reg_base+M2M_OFFSET_SAR_BASE0 );
|
|
+
|
|
+ outl( dma->buffer_queue[dma->current_buffer].dest,
|
|
+ M2M_reg_base+M2M_OFFSET_DAR_BASE0 );
|
|
+
|
|
+ outl( dma->buffer_queue[dma->current_buffer].size,
|
|
+ M2M_reg_base+M2M_OFFSET_BCR0 );
|
|
+
|
|
+ /*
|
|
+ * Decrement the new buffers counter.
|
|
+ */
|
|
+ dma->new_buffers--;
|
|
+
|
|
+ /*
|
|
+ * Set up the second buffer descriptor with a second buffer if we have
|
|
+ * a second buffer.
|
|
+ */
|
|
+ if (dma->new_buffers) {
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2M_reg_base+M2M_OFFSET_SAR_BASE1 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].dest,
|
|
+ M2M_reg_base+M2M_OFFSET_DAR_BASE1 );
|
|
+
|
|
+ outl( dma->buffer_queue[(dma->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2M_reg_base+M2M_OFFSET_BCR1 );
|
|
+
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2M_NFBINTEN;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+
|
|
+ dma->new_buffers--;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Now we enable the channel. This initiates the transfer.
|
|
+ */
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2M_ENABLE;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ inl(M2M_reg_base + M2M_OFFSET_CONTROL);
|
|
+
|
|
+ /*
|
|
+ * If this is a memory to memory transfer, we need to s/w trigger the
|
|
+ * transfer by setting the start bit within the control register.
|
|
+ */
|
|
+ if (dma->device == DMA_MEMORY) {
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2M_START;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA - It's been started!!");
|
|
+ DPRINTK("CONTROL - 0x%x \n", inl(M2M_reg_base+M2M_OFFSET_CONTROL) );
|
|
+ DPRINTK("STATUS - 0x%x \n", inl(M2M_reg_base+M2M_OFFSET_STATUS) );
|
|
+ DPRINTK("BCR0 - 0x%x \n", dma->buffer_queue[dma->current_buffer].size);
|
|
+ DPRINTK("SAR_BASE0 - 0x%x \n", inl(M2M_reg_base+M2M_OFFSET_SAR_BASE0) );
|
|
+ DPRINTK("SAR_CUR0 - 0x%x \n", inl(M2M_reg_base+M2M_OFFSET_SAR_CURRENT0) );
|
|
+ DPRINTK("DAR_BASE0 - 0x%x \n", inl(M2M_reg_base+M2M_OFFSET_DAR_BASE0) );
|
|
+ DPRINTK("DAR_CUR0 - 0x%x \n", inl(M2M_reg_base+M2M_OFFSET_DAR_CURRENT0) );
|
|
+
|
|
+ /*
|
|
+ * Unmask irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * DMA interface functions
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int dma_init(int handle, unsigned int flags_m2p, unsigned int flags_m2m,
|
|
+ * dma_callback callback, unsigned int user_data)
|
|
+ *
|
|
+ * Description: Configure the DMA channel and install a callback function.
|
|
+ *
|
|
+ * handle: Handle unique the each instance of the dma interface, used
|
|
+ * to verify this call.
|
|
+ * flags_m2p Flags used to configure an M2P/P2M dma channel and determine
|
|
+ * if a callback function and user_data information are included
|
|
+ * in this call. This field should be NULL if handle represents
|
|
+ * an M2M channel.
|
|
+ * flags_m2m Flags used to configure an M2M dma channel and determine
|
|
+ * if a callback function and user_data information are included
|
|
+ * in this call. This field should be NULL if handle represents
|
|
+ * an M2P/P2M channel.
|
|
+ * callback function pointer which is called near the end of the
|
|
+ * dma channel's irq handler.
|
|
+ * user_data defined by the calling driver.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_config(int handle, unsigned int flags_m2p, unsigned int flags_m2m,
|
|
+ dma_callback callback, unsigned int user_data)
|
|
+{
|
|
+ int channel;
|
|
+ ep93xx_dma_t * dma;
|
|
+ unsigned long flags;
|
|
+ unsigned int M2P_reg_base, uiCONTROL;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR
|
|
+ "DMA Config: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA Config \n");
|
|
+
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Check if the channel is currently transferring.
|
|
+ */
|
|
+ if (dma->xfer_enable) {
|
|
+ local_irq_restore(flags);
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Check if this is an m2m function.
|
|
+ */
|
|
+ if (channel >= 10) {
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Call another function to handle m2m config.
|
|
+ */
|
|
+ return(dma_config_m2m(dma, flags_m2m, callback, user_data));
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Setup a pointer into the dma channel's register set.
|
|
+ */
|
|
+ M2P_reg_base = dma->reg_base;
|
|
+
|
|
+ /*
|
|
+ * By default we enable the stall interrupt.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2P_STALLINTEN;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Configure the channel for an error from the peripheral.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ if ( flags_m2p && CHANNEL_ERROR_INT_ENABLE )
|
|
+ uiCONTROL |= CONTROL_M2P_CHERRORINTEN;
|
|
+ else
|
|
+ uiCONTROL &= ~CONTROL_M2P_CHERRORINTEN;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ if ( flags_m2p && CHANNEL_ABORT )
|
|
+ uiCONTROL |= CONTROL_M2P_ABRT;
|
|
+ else
|
|
+ uiCONTROL &= ~CONTROL_M2P_ABRT;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ if ( flags_m2p && IGNORE_CHANNEL_ERROR )
|
|
+ uiCONTROL |= CONTROL_M2P_ICE;
|
|
+ else
|
|
+ uiCONTROL &= ~CONTROL_M2P_ICE;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Save the callback function in the dma instance for this channel.
|
|
+ */
|
|
+ dma->callback = callback;
|
|
+
|
|
+ /*
|
|
+ * Save the user data in the the dma instance for this channel.
|
|
+ */
|
|
+ dma->user_data = user_data;
|
|
+
|
|
+ /*
|
|
+ * Put the dma instance into the pause state by setting the
|
|
+ * pause bit to true.
|
|
+ */
|
|
+ dma->pause = TRUE;
|
|
+
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int dma_start(int handle, unsigned int channels, unsigned int * handles)
|
|
+ *
|
|
+ * Description: Initiate a transfer on up to 3 channels.
|
|
+ *
|
|
+ * handle: handle for the channel to initiate transfer on.
|
|
+ * channels: number of channels to initiate transfers on.
|
|
+ * handles: pointer to an array of handles, one for each channel which
|
|
+ * is to be started.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_start(int handle, unsigned int channels, unsigned int * handles)
|
|
+{
|
|
+ ep93xx_dma_t * dma_pointers[3];
|
|
+ unsigned int M2P_reg_bases[3];
|
|
+ unsigned int loop, uiCONTROL;
|
|
+ unsigned long flags;
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "DMA Start: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ if (channels < 1) {
|
|
+ printk(KERN_ERR "DMA Start: Invalid parameter.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA Start \n");
|
|
+
|
|
+ /*
|
|
+ * Mask off registers.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Check if this is a start multiple.
|
|
+ */
|
|
+ if (channels > 1) {
|
|
+ DPRINTK("DMA ERROR: Start, multiple start not supported yet \n");
|
|
+ return(-1);
|
|
+ } else {
|
|
+ /*
|
|
+ * Check if this channel is already transferring.
|
|
+ */
|
|
+ if (dma_chan[channel].xfer_enable && !dma_chan[channel].pause) {
|
|
+ printk(KERN_ERR
|
|
+ "DMA Start: Invalid command for channel %d.\n", channel);
|
|
+
|
|
+ /*
|
|
+ * Unmask irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * This channel is already transferring, so return an error.
|
|
+ */
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * If this is an M2M channel, call a different function.
|
|
+ */
|
|
+ if (channel >= 10) {
|
|
+ /*
|
|
+ * Unmask irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Call the m2m start function. Only start one channel.
|
|
+ */
|
|
+ return(dma_start_m2m(channel, &dma_chan[channel]));
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Make sure the channel has at least one buffer in the queue.
|
|
+ */
|
|
+ if (dma_chan[channel].new_buffers < 1) {
|
|
+ DPRINTK("DMA Start: Channel starved.\n");
|
|
+
|
|
+ /*
|
|
+ * This channel does not have enough buffers queued up,
|
|
+ * so enter the pause by starvation state.
|
|
+ */
|
|
+ dma_chan[channel].xfer_enable = TRUE;
|
|
+ dma_chan[channel].pause = TRUE;
|
|
+
|
|
+ /*
|
|
+ * Unmask irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Set up a dma instance pointer for this dma channel.
|
|
+ */
|
|
+ dma_pointers[0] = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * Set up a pointer to the register set for this channel.
|
|
+ */
|
|
+ M2P_reg_bases[0] = dma_pointers[0]->reg_base;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Setup both MAXCNT registers with values from the next two buffers
|
|
+ * in the queue, and enable the next frame buffer interrupt on the channel.
|
|
+ */
|
|
+ for (loop = 0; loop < channels; loop++) {
|
|
+ /*
|
|
+ * Check if we need to restore a paused transfer.
|
|
+ */
|
|
+ if (dma_pointers[loop]->pause_buf.buf_id != -1)
|
|
+ outl( dma_pointers[loop]->pause_buf.size,
|
|
+ M2P_reg_bases[loop]+M2P_OFFSET_MAXCNT0 );
|
|
+ else
|
|
+ outl( dma_pointers[loop]->buffer_queue[dma_pointers[loop]->current_buffer].size,
|
|
+ M2P_reg_bases[loop]+M2P_OFFSET_MAXCNT0 );
|
|
+ }
|
|
+
|
|
+ for (loop = 0; loop < channels; loop++) {
|
|
+ /*
|
|
+ * Enable the specified dma channels.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_bases[loop]+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2P_ENABLE;
|
|
+ outl( uiCONTROL, M2P_reg_bases[loop]+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ /*
|
|
+ * Update the dma channel instance transfer state.
|
|
+ */
|
|
+ dma_pointers[loop]->xfer_enable = TRUE;
|
|
+ dma_pointers[loop]->pause = FALSE;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Program up the BASE0 registers for all specified channels, this
|
|
+ * will initiate transfers on all specified channels.
|
|
+ */
|
|
+ for (loop = 0; loop < channels; loop++)
|
|
+ /*
|
|
+ * Check if we need to restore a paused transfer.
|
|
+ */
|
|
+ if (dma_pointers[loop]->pause_buf.buf_id != -1) {
|
|
+ outl( dma_pointers[loop]->pause_buf.source,
|
|
+ M2P_reg_bases[loop]+M2P_OFFSET_BASE0 );
|
|
+
|
|
+ /*
|
|
+ * Set the pause buffer to NULL
|
|
+ */
|
|
+ dma_pointers[loop]->pause_buf.buf_id = -1;
|
|
+ dma_pointers[loop]->pause_buf.size = 0;
|
|
+ } else if(dma_pointers[loop]->new_buffers){
|
|
+ outl( dma_pointers[loop]->buffer_queue[
|
|
+ dma_pointers[loop]->current_buffer].source,
|
|
+ M2P_reg_bases[loop]+M2P_OFFSET_BASE0 );
|
|
+ dma_pointers[loop]->new_buffers--;
|
|
+
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Before restoring irqs setup the second MAXCNT/BASE
|
|
+ * register with a second buffer.
|
|
+ */
|
|
+ for (loop = 0; loop < channels; loop++)
|
|
+ if (dma_pointers[loop]->new_buffers) {
|
|
+ /*
|
|
+ * By default we enable the next frame buffer interrupt.
|
|
+ */
|
|
+ uiCONTROL = inl(M2P_reg_bases[loop]+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL |= CONTROL_M2P_NFBINTEN;
|
|
+ outl( uiCONTROL, M2P_reg_bases[loop]+M2P_OFFSET_CONTROL );
|
|
+
|
|
+ outl( dma_pointers[loop]->buffer_queue[
|
|
+ (dma_pointers[loop]->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].size,
|
|
+ M2P_reg_bases[loop]+M2P_OFFSET_MAXCNT1 );
|
|
+
|
|
+ outl( dma_pointers[loop]->buffer_queue[
|
|
+ (dma_pointers[loop]->current_buffer + 1) %
|
|
+ MAX_EP93XX_DMA_BUFFERS].source,
|
|
+ M2P_reg_bases[loop]+M2P_OFFSET_BASE1 );
|
|
+ dma_pointers[loop]->new_buffers--;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ DPRINTK("DMA - It's been started!!");
|
|
+ DPRINTK("STATUS - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_STATUS) );
|
|
+ DPRINTK("CONTROL - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CONTROL) );
|
|
+ DPRINTK("REMAIN - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_REMAIN) );
|
|
+ DPRINTK("PPALLOC - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_PPALLOC) );
|
|
+ DPRINTK("BASE0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE0) );
|
|
+ DPRINTK("MAXCNT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT0) );
|
|
+ DPRINTK("CURRENT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT0) );
|
|
+ DPRINTK("BASE1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE1) );
|
|
+ DPRINTK("MAXCNT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT1) );
|
|
+ DPRINTK("CURRENT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT1) );
|
|
+
|
|
+ DPRINTK("Pause - %d \n", dma_pointers[0]->pause);
|
|
+ DPRINTK("xfer_enable - %d \n", dma_pointers[0]->xfer_enable);
|
|
+ DPRINTK("total bytes - 0x%x \n", dma_pointers[0]->total_bytes);
|
|
+ DPRINTK("total buffer - %d \n", dma_pointers[0]->total_buffers);
|
|
+ DPRINTK("new buffers - %d \n", dma_pointers[0]->new_buffers);
|
|
+ DPRINTK("current buffer - %d \n", dma_pointers[0]->current_buffer);
|
|
+ DPRINTK("last buffer - %d \n", dma_pointers[0]->last_buffer);
|
|
+ DPRINTK("used buffers - %d \n", dma_pointers[0]->used_buffers);
|
|
+ */
|
|
+ /*
|
|
+ * Unmask irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_add_buffer(int handle, unsigned int * address,
|
|
+ * unsigned int size, unsigned int last)
|
|
+ *
|
|
+ * Description: Add a buffer entry to the DMA buffer queue.
|
|
+ *
|
|
+ * handle: handle for the channel to add this buffer to.
|
|
+ * address: Pointer to an integer which is the start address of the
|
|
+ * buffer which is to be added to the queue.
|
|
+ * size: size of the buffer in bytes.
|
|
+ * last: 1 if this is the last buffer in this stream, 0 otherwise.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_add_buffer(int handle, unsigned int source, unsigned int dest,
|
|
+ unsigned int size, unsigned int last,
|
|
+ unsigned int buf_id)
|
|
+{
|
|
+ unsigned long flags;
|
|
+ ep93xx_dma_t * dma;
|
|
+ int channel;
|
|
+#if 0
|
|
+ static int peak_total_buffers=0;
|
|
+#endif
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR
|
|
+ "DMA Add Buffer: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Get a pointer to the dma instance.
|
|
+ */
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+#if 0
|
|
+ if( dma->total_buffers > peak_total_buffers )
|
|
+ {
|
|
+ peak_total_buffers=dma->total_buffers;
|
|
+ printk("peak_total_buffers=%d\n", peak_total_buffers );
|
|
+ }
|
|
+#endif
|
|
+ /*
|
|
+ * Mask interrupts and hold on to the original state.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * If the buffer queue is full, last_buffer is the same as current_buffer and
|
|
+ * we're not tranfering, or last_buffer is pointing to a used buffer, then exit.
|
|
+ * TODO: do I need to do any more checks?
|
|
+ */
|
|
+ if (dma->total_buffers >= MAX_EP93XX_DMA_BUFFERS)
|
|
+ {
|
|
+ DPRINTK("too many dma buffers: MAX_EP93XX_DMA_BUFFERS set to low ?\n");
|
|
+ /*
|
|
+ * Restore the state of the irqs
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Fail.
|
|
+ */
|
|
+ return(-1);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Add this buffer to the queue
|
|
+ */
|
|
+ dma->buffer_queue[dma->last_buffer].source = source;
|
|
+ dma->buffer_queue[dma->last_buffer].dest = dest;
|
|
+ dma->buffer_queue[dma->last_buffer].size = size;
|
|
+ dma->buffer_queue[dma->last_buffer].last = last;
|
|
+ dma->buffer_queue[dma->last_buffer].buf_id = buf_id;
|
|
+
|
|
+ /*
|
|
+ * Reset the used field of the buffer structure.
|
|
+ */
|
|
+ dma->buffer_queue[dma->last_buffer].used = FALSE;
|
|
+
|
|
+ /*
|
|
+ * Increment the End Item Pointer.
|
|
+ */
|
|
+ dma->last_buffer = (dma->last_buffer + 1) % MAX_EP93XX_DMA_BUFFERS;
|
|
+
|
|
+ /*
|
|
+ * Increment the new buffers counter and the total buffers counter
|
|
+ */
|
|
+ dma->new_buffers++;
|
|
+ dma->total_buffers++;
|
|
+
|
|
+ /*
|
|
+ * restore the interrupt state.
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Check if the channel was starved into a stopped state.
|
|
+ */
|
|
+ if (dma->pause && dma->xfer_enable) {
|
|
+ if (dma->new_buffers >= 1) {
|
|
+ DPRINTK("DMA - calling start from add after starve. \n");
|
|
+
|
|
+ /*
|
|
+ * The channel was starved into a stopped state, and we've got
|
|
+ * 2 new buffers, so start tranferring again.
|
|
+ */
|
|
+ ep93xx_dma_start(handle, 1, 0);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_remove_buffer(int handle, unsigned int * address,
|
|
+ * unsigned int * size)
|
|
+ *
|
|
+ * Description: Remove a buffer entry from the DMA buffer queue. If
|
|
+ * buffer was removed successfully, return 0, otherwise
|
|
+ * return -1.
|
|
+ *
|
|
+ * handle: handle for the channel to remove a buffer from.
|
|
+ * address: Pointer to an integer which is filled in with the start
|
|
+ * address of the removed buffer.
|
|
+ * size: Pointer to an integer which is filled in with the size in
|
|
+ * bytes of the removed buffer.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_remove_buffer(int handle, unsigned int * buf_id)
|
|
+{
|
|
+ unsigned int test;
|
|
+ unsigned int loop;
|
|
+ int return_val = -1;
|
|
+ unsigned long flags;
|
|
+ ep93xx_dma_t *dma;
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR
|
|
+ "DMA Remove Buffer: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * Mask interrupts and hold on to the original state.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Make sure there are used buffers to be returned.
|
|
+ */
|
|
+ if (dma->used_buffers) {
|
|
+ test = dma->last_buffer;
|
|
+
|
|
+ for (loop = 0; loop < MAX_EP93XX_DMA_BUFFERS; loop++) {
|
|
+ if (dma->buffer_queue[test].used && (dma->buffer_queue[test].buf_id != -1)) {
|
|
+ /*DPRINTK("buffer %d used \n", test); */
|
|
+
|
|
+ /*
|
|
+ * This is a used buffer, fill in the buf_id pointer
|
|
+ * with the buf_id for this buffer.
|
|
+ */
|
|
+ *buf_id = dma->buffer_queue[test].buf_id;
|
|
+
|
|
+ /*
|
|
+ * Reset this buffer structure
|
|
+ */
|
|
+ dma->buffer_queue[test].buf_id = -1;
|
|
+
|
|
+ /*
|
|
+ * Decrement the used buffer counter, and the total buffer counter.
|
|
+ */
|
|
+ dma->used_buffers--;
|
|
+ dma->total_buffers--;
|
|
+
|
|
+ /*
|
|
+ * Successful removal of a buffer, so set the return
|
|
+ * value to 0, then exit this loop.
|
|
+ */
|
|
+ return_val = 0;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * This buffer isn't used, let's see if the next one is.
|
|
+ */
|
|
+ test = (test + 1) % MAX_EP93XX_DMA_BUFFERS;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Restore interrupts.
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(return_val);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_pause(int handle, unsigned int channels,
|
|
+ * unsigned int * handles)
|
|
+ *
|
|
+ * Description: Disable any ongoing transfer for the given channel, retaining
|
|
+ * the state of the current buffer transaction so that upon
|
|
+ * resume, the dma will continue where it left off.
|
|
+ *
|
|
+ * handle: Handle for the channel to be paused. If this is a pause for
|
|
+ * for multiple channels, handle is a valid handle for one of
|
|
+ * the channels to be paused.
|
|
+ * channels: number of channel to pause transfers on.
|
|
+ * handles: Pointer to an array of handles, one for each channel which
|
|
+ * to be paused. If this pause is intended only for one
|
|
+ * channel, this field should be set to NULL.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_pause(int handle, unsigned int channels, unsigned int * handles)
|
|
+{
|
|
+ unsigned long flags;
|
|
+ ep93xx_dma_t * dma;
|
|
+ int channel;
|
|
+
|
|
+ DPRINTK("ep93xx_dma_pause \n");
|
|
+
|
|
+ /*
|
|
+ * Mask interrupts and hold on to the original state.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ /*
|
|
+ * restore interrupts.
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ printk(KERN_ERR
|
|
+ "DMA Pause: Invalid dma handle.\n");
|
|
+
|
|
+ /*
|
|
+ * Fail.
|
|
+ */
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA %d: pause \n", channel);
|
|
+
|
|
+ /*
|
|
+ * Set up a pointer to the dma instance data.
|
|
+ */
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * Check if we're already paused.
|
|
+ */
|
|
+ if (dma->pause) {
|
|
+ /*
|
|
+ * We're paused, but are we stopped?
|
|
+ */
|
|
+ if (dma->xfer_enable)
|
|
+ /*
|
|
+ * Put the channel in the stopped state.
|
|
+ */
|
|
+ dma->xfer_enable = FALSE;
|
|
+
|
|
+ DPRINTK("DMA Pause - already paused.");
|
|
+ } else {
|
|
+ /*
|
|
+ * Put the channel into the stopped state.
|
|
+ */
|
|
+ dma->xfer_enable = FALSE;
|
|
+ dma->pause = TRUE;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * restore interrupts.
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Already paused, so exit.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * void ep93xx_dma_flush(int handle)
|
|
+ *
|
|
+ * Description: Flushes all queued buffers and transfers in progress
|
|
+ * for the given channel. Return the buffer entries
|
|
+ * to the calling function.
|
|
+ *
|
|
+ * handle: handle for the channel for which the flush is intended.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_flush(int handle)
|
|
+{
|
|
+ unsigned int loop;
|
|
+ unsigned long flags;
|
|
+ ep93xx_dma_t * dma;
|
|
+ int channel;
|
|
+ unsigned int M2P_reg_base,uiCONTROL;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "DMA Flush: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA %d: flush \n", channel);
|
|
+
|
|
+ /*
|
|
+ * Set up a pointer to the dma instance data for this channel
|
|
+ */
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * Mask interrupts and hold on to the original state.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * Disable the dma channel
|
|
+ */
|
|
+ if (channel < 10) {
|
|
+ /*
|
|
+ * M2P channel
|
|
+ */
|
|
+ uiCONTROL = inl(dma->reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2P_ENABLE;
|
|
+ outl( uiCONTROL, dma->reg_base+M2P_OFFSET_CONTROL );
|
|
+ } else {
|
|
+ /*
|
|
+ * M2M channel
|
|
+ */
|
|
+ uiCONTROL = inl(dma->reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_ENABLE;
|
|
+ outl( uiCONTROL, dma->reg_base+M2M_OFFSET_CONTROL );
|
|
+ }
|
|
+
|
|
+ for (loop = 0; loop < MAX_EP93XX_DMA_BUFFERS; loop++)
|
|
+ {
|
|
+ dma->buffer_queue[loop].buf_id = -1;
|
|
+ dma->buffer_queue[loop].last = 0;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Set the Current and Last item to zero.
|
|
+ */
|
|
+ dma->current_buffer = 0;
|
|
+ dma->last_buffer = 0;
|
|
+
|
|
+ /*
|
|
+ * Reset the Buffer counters
|
|
+ */
|
|
+ dma->used_buffers = 0;
|
|
+ dma->new_buffers = 0;
|
|
+ dma->total_buffers = 0;
|
|
+
|
|
+ /*
|
|
+ * reset the Total bytes counter.
|
|
+ */
|
|
+ dma->total_bytes = 0;
|
|
+
|
|
+ /*
|
|
+ * Reset the paused buffer.
|
|
+ */
|
|
+ dma->pause_buf.last = 0;
|
|
+ dma->pause_buf.buf_id = -1;
|
|
+
|
|
+ M2P_reg_base = dma_chan[channel].reg_base;
|
|
+
|
|
+ /*
|
|
+ * restore interrupts.
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_queue_full(int handle)
|
|
+ *
|
|
+ * Description: Query to determine if the DMA queue of buffers for
|
|
+ * a given channel is full.
|
|
+ * 0 = queue is full
|
|
+ * 1 = queue is not full
|
|
+ *
|
|
+ * handle: handle for the channel to query.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_queue_full(int handle)
|
|
+{
|
|
+ int list_full = 0;
|
|
+ unsigned long flags;
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "DMA Queue Full: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA %d: queue full \n", channel);
|
|
+
|
|
+ /*
|
|
+ * Mask interrupts and hold on to the original state.
|
|
+ */
|
|
+ local_irq_save(flags);
|
|
+
|
|
+ /*
|
|
+ * If the last item is equal to the used item then
|
|
+ * the queue is full.
|
|
+ */
|
|
+ if (dma_chan[channel].total_buffers < MAX_EP93XX_DMA_BUFFERS)
|
|
+ list_full = FALSE;
|
|
+ else
|
|
+ list_full = TRUE;
|
|
+
|
|
+ /*
|
|
+ * restore interrupts.
|
|
+ */
|
|
+ local_irq_restore(flags);
|
|
+
|
|
+ return(list_full);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_get_position()
|
|
+ *
|
|
+ * Description: Takes two integer pointers and fills them with the start
|
|
+ * and current address of the buffer currently transferring
|
|
+ * on the specified DMA channel.
|
|
+ *
|
|
+ * handle handle for the channel to query.
|
|
+ * *buf_id buffer id for the current buffer transferring on the
|
|
+ * dma channel.
|
|
+ * *total total bytes transferred on the channel. Only counts
|
|
+ * whole buffers transferred.
|
|
+ * *current_frac number of bytes transferred so far in the current buffer.
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_get_position(int handle, unsigned int * buf_id,
|
|
+ unsigned int * total, unsigned int * current_frac )
|
|
+{
|
|
+ int channel;
|
|
+ ep93xx_dma_t * dma;
|
|
+ unsigned int buf_id1, total1, current_frac1, buf_id2, total2;
|
|
+ unsigned int Status, NextBuffer, StateIsBufNext, M2P_reg_base=0;
|
|
+ unsigned int pause1, pause2;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle. See if this is a
|
|
+ * valid handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "DMA Get Position: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * If DMA moves to a new buffer in the middle of us grabbing the
|
|
+ * buffer info, then do it over again.
|
|
+ */
|
|
+ do{
|
|
+ buf_id1 = dma->buffer_queue[dma->current_buffer].buf_id;
|
|
+ total1 = dma->total_bytes;
|
|
+ pause1 = dma->pause;
|
|
+
|
|
+ if (channel < 10) {
|
|
+ // M2P
|
|
+ M2P_reg_base = dma->reg_base;
|
|
+
|
|
+ Status = inl(M2P_reg_base+M2P_OFFSET_STATUS);
|
|
+
|
|
+ NextBuffer = ((Status & STATUS_M2P_NEXTBUFFER) != 0);
|
|
+
|
|
+ StateIsBufNext = ((Status & STATUS_M2P_CURRENT_MASK) ==
|
|
+ STATUS_M2P_DMA_BUF_NEXT);
|
|
+
|
|
+ if( NextBuffer ^ StateIsBufNext )
|
|
+ current_frac1 = inl(M2P_reg_base+M2P_OFFSET_CURRENT1) -
|
|
+ inl(M2P_reg_base+M2P_OFFSET_BASE1);
|
|
+ else
|
|
+ current_frac1 = inl(M2P_reg_base+M2P_OFFSET_CURRENT0) -
|
|
+ inl(M2P_reg_base+M2P_OFFSET_BASE0);
|
|
+
|
|
+ } else {
|
|
+ // M2M - TODO implement this for M2M
|
|
+ current_frac1 = 0;
|
|
+ }
|
|
+
|
|
+ buf_id2 = dma->buffer_queue[dma->current_buffer].buf_id;
|
|
+ total2 = dma->total_bytes;
|
|
+ pause2 = dma->pause;
|
|
+
|
|
+ } while ( (buf_id1 != buf_id2) || (total1 != total2) || (pause1 != pause2) );
|
|
+
|
|
+ if (pause1)
|
|
+ current_frac1 = 0;
|
|
+
|
|
+ if (buf_id)
|
|
+ *buf_id = buf_id1;
|
|
+
|
|
+ if (total)
|
|
+ *total = total1;
|
|
+
|
|
+ if (current_frac)
|
|
+ *current_frac = current_frac1;
|
|
+
|
|
+// DPRINTK("DMA buf_id %d, total %d, frac %d\n", buf_id1, total1, current_frac1);
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_get_total(int handle)
|
|
+ *
|
|
+ * Description: Returns the total number of bytes transferred on the
|
|
+ * specified channel since the channel was requested.
|
|
+ *
|
|
+ * handle: handle for the channel to query.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_get_total(int handle)
|
|
+{
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "DMA Get Total: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA %d: total: %d \n", channel, dma_chan[channel].total_bytes);
|
|
+
|
|
+ /*
|
|
+ * Return the total number of bytes transferred on this channel since
|
|
+ * it was requested.
|
|
+ */
|
|
+ return(dma_chan[channel].total_bytes);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * int ep93xx_dma_is_done(int handle)
|
|
+ *
|
|
+ * Description: Determines if the specified channel is done
|
|
+ * transferring the requested data.
|
|
+ *
|
|
+ * handle: handle for the channel to query.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_is_done(int handle)
|
|
+{
|
|
+ ep93xx_dma_t *dma;
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "ep93xx_dma_is_done: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Get a pointer to the DMA channel state structure.
|
|
+ */
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * See if there are any buffers remaining to be provided to the HW.
|
|
+ */
|
|
+ if (dma->new_buffers)
|
|
+ return 0;
|
|
+
|
|
+ /*
|
|
+ * See if this is a M2P or M2M channel.
|
|
+ */
|
|
+ if (channel < 10) {
|
|
+ /*
|
|
+ * If the bytes remaining register of the HW is not zero, then
|
|
+ * there is more work to be done.
|
|
+ */
|
|
+ if (inl(dma->reg_base + M2P_OFFSET_REMAIN) != 0)
|
|
+ return 0;
|
|
+ } else {
|
|
+ /*
|
|
+ * If either byte count register in the HW is not zero, then there
|
|
+ * is more work to be done.
|
|
+ */
|
|
+ if ((inl(dma->reg_base + M2M_OFFSET_BCR0) != 0) ||
|
|
+ (inl(dma->reg_base + M2M_OFFSET_BCR1) != 0))
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * The DMA is complete.
|
|
+ */
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ * ep93xx_dma_request
|
|
+ *
|
|
+ * Description: This function will allocate a DMA channel for a particular
|
|
+ * hardware peripheral. Before initiating a transfer on the allocated
|
|
+ * channel, the channel must be set up and buffers have to queued up.
|
|
+ *
|
|
+ * handle: pointer to an integer which is filled in with a unique
|
|
+ * handle for this instance of the dma interface.
|
|
+ * device_id string with the device name, primarily used by /proc.
|
|
+ * device hardware device ID for which the requested dma channel will
|
|
+ * transfer data.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_request(int * handle, const char *device_id,
|
|
+ ep93xx_dma_dev_t device)
|
|
+{
|
|
+ ep93xx_dma_t *dma = NULL;
|
|
+ int channel;
|
|
+ unsigned int error = 0;
|
|
+ unsigned int loop;
|
|
+ unsigned int M2P_reg_base;
|
|
+
|
|
+ /*
|
|
+ * Check if the device requesting a DMA channel is a valid device.
|
|
+ */
|
|
+ if ((device >= UNDEF_DMA) || (device < 0))
|
|
+ return(-ENODEV);
|
|
+
|
|
+ /*
|
|
+ * We've got a valid hardware device requesting a DMA channel.
|
|
+ * Now check if the device should open an M2P or M2M channel
|
|
+ */
|
|
+ if (device < 20)
|
|
+ channel = dma_open_m2p(device);
|
|
+ else
|
|
+ channel = dma_open_m2m(device);
|
|
+
|
|
+ /*
|
|
+ * Check if we successfully opened a DMA channel
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "%s: Could not open dma channel for this device.\n",
|
|
+ device_id);
|
|
+ return(-EBUSY);
|
|
+ }
|
|
+
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ if(dma->terminated==1) {
|
|
+ free_irq(dma->irq, (void *) dma);
|
|
+ dma->terminated=0;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Request the appropriate IRQ for the specified channel
|
|
+ */
|
|
+ if (channel < 10)
|
|
+ error = request_irq(dma->irq, dma_m2p_irq_handler,
|
|
+ IRQF_DISABLED, device_id, (void *) dma);
|
|
+ else
|
|
+ error = request_irq(dma->irq, &dma_m2m_irq_handler,
|
|
+ IRQF_DISABLED, device_id, (void *) dma);
|
|
+
|
|
+ /*
|
|
+ * Check for any errors during the irq request
|
|
+ */
|
|
+ if (error) {
|
|
+ printk(KERN_ERR "%s: unable to request IRQ %d for DMA channel\n",
|
|
+ device_id, dma->irq);
|
|
+ return(error);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Generate a valid handle and exit.
|
|
+ *
|
|
+ * Increment the last valid handle.
|
|
+ * Check for wraparound (unlikely, but we like to be complete).
|
|
+ */
|
|
+ dma->last_valid_handle++;
|
|
+
|
|
+ if ( (dma->last_valid_handle & DMA_HANDLE_SPECIFIER_MASK) !=
|
|
+ (channel << 28) )
|
|
+ dma->last_valid_handle = (channel << 28) + 1;
|
|
+
|
|
+ /*
|
|
+ * Fill in the handle pointer with a valid handle for
|
|
+ * this dma channel instance.
|
|
+ */
|
|
+ *handle = dma->last_valid_handle;
|
|
+
|
|
+ DPRINTK("Handle for channel %d: 0x%x\n", channel, *handle);
|
|
+
|
|
+ /*
|
|
+ * Save the device ID and device name.
|
|
+ */
|
|
+ dma->device = device;
|
|
+ dma->device_id = device_id;
|
|
+
|
|
+ /*
|
|
+ * Init all fields within the dma instance.
|
|
+ */
|
|
+ for (loop = 0; loop < MAX_EP93XX_DMA_BUFFERS; loop++)
|
|
+ dma->buffer_queue[loop].buf_id = -1;
|
|
+
|
|
+ /*
|
|
+ * Initialize all buffer queue variables.
|
|
+ */
|
|
+ dma->current_buffer = 0;
|
|
+ dma->last_buffer = 0;
|
|
+
|
|
+ dma->new_buffers = 0;
|
|
+ dma->used_buffers = 0;
|
|
+ dma->total_buffers = 0;
|
|
+
|
|
+ /*
|
|
+ * Initialize the total bytes variable
|
|
+ */
|
|
+ dma->total_bytes = 0;
|
|
+
|
|
+ /*
|
|
+ * Initialize the transfer and pause state variables to 0.
|
|
+ */
|
|
+ dma->xfer_enable = 0;
|
|
+
|
|
+ dma->pause = 0;
|
|
+
|
|
+ /*
|
|
+ * Initialize the pause buffer structure.
|
|
+ */
|
|
+ dma->pause_buf.buf_id = -1;
|
|
+
|
|
+ /*
|
|
+ * Initialize the callback function and user data fields.
|
|
+ */
|
|
+ dma->callback = NULL;
|
|
+
|
|
+ /*
|
|
+ * User data used as a parameter for the Callback function. The user
|
|
+ * sets up the data and sends it with the callback function.
|
|
+ */
|
|
+ dma->user_data = 0;
|
|
+
|
|
+ M2P_reg_base = dma_chan[channel].reg_base;
|
|
+
|
|
+ /*
|
|
+ * Debugging message.
|
|
+ */
|
|
+ DPRINTK("Successfully requested dma channel %d\n", channel);
|
|
+ DPRINTK("STATUS - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_STATUS) );
|
|
+ DPRINTK("CONTROL - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CONTROL) );
|
|
+ DPRINTK("REMAIN - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_REMAIN) );
|
|
+ DPRINTK("PPALLOC - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_PPALLOC) );
|
|
+ DPRINTK("BASE0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE0) );
|
|
+ DPRINTK("MAXCNT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT0) );
|
|
+ DPRINTK("CURRENT0 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT0) );
|
|
+ DPRINTK("BASE1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_BASE1) );
|
|
+ DPRINTK("MAXCNT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_MAXCNT1) );
|
|
+ DPRINTK("CURRENT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT1) );
|
|
+
|
|
+ DPRINTK("Buffer source size last used \n");
|
|
+ for (loop = 0; loop < 5; loop ++)
|
|
+ DPRINTK("%d 0x%x 0x%x %d %d \n",
|
|
+ loop, dma->buffer_queue[loop].source, dma->buffer_queue[loop].size,
|
|
+ dma->buffer_queue[loop].last, dma->buffer_queue[loop].used);
|
|
+ DPRINTK("pause 0x%x 0x%x %d %d \n",
|
|
+ dma->pause_buf.source, dma->pause_buf.size,
|
|
+ dma->pause_buf.last, dma->pause_buf.used);
|
|
+
|
|
+ DPRINTK("Pause - %d \n", dma->pause);
|
|
+ DPRINTK("xfer_enable - %d \n", dma->xfer_enable);
|
|
+ DPRINTK("total bytes - 0x%x \n", dma->total_bytes);
|
|
+ DPRINTK("total buffer - %d \n", dma->total_buffers);
|
|
+ DPRINTK("new buffers - %d \n", dma->new_buffers);
|
|
+ DPRINTK("current buffer - %d \n", dma->current_buffer);
|
|
+ DPRINTK("last buffer - %d \n", dma->last_buffer);
|
|
+ DPRINTK("used buffers - %d \n", dma->used_buffers);
|
|
+
|
|
+ DPRINTK("CURRENT1 - 0x%x \n", inl(M2P_reg_base+M2P_OFFSET_CURRENT1) );
|
|
+ DPRINTK("VIC0IRQSTATUS - 0x%x, VIC0INTENABLE - 0x%x \n",
|
|
+ *(unsigned int *)(VIC0IRQSTATUS),
|
|
+ *(unsigned int *)(VIC0INTENABLE));
|
|
+
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * ep93xx_dma_free
|
|
+ *
|
|
+ * Description: This function will free the dma channel for future requests.
|
|
+ *
|
|
+ * handle: handle for the channel to be freed.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+int
|
|
+ep93xx_dma_free(int handle)
|
|
+{
|
|
+ ep93xx_dma_t *dma;
|
|
+ unsigned int M2M_reg_base, M2P_reg_base, uiCONTROL;
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Get the DMA hw channel # from the handle.
|
|
+ */
|
|
+ channel = dma_get_channel_from_handle(handle);
|
|
+
|
|
+ /*
|
|
+ * See if this is a valid handle.
|
|
+ */
|
|
+ if (channel < 0) {
|
|
+ printk(KERN_ERR "DMA Free: Invalid dma handle.\n");
|
|
+ return(-EINVAL);
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Get a pointer to the dma instance.
|
|
+ */
|
|
+ dma = &dma_chan[channel];
|
|
+
|
|
+ /*
|
|
+ * Disable the dma channel
|
|
+ */
|
|
+ if (channel < 10) {
|
|
+ /*
|
|
+ * M2P channel
|
|
+ */
|
|
+ M2P_reg_base = dma->reg_base;
|
|
+
|
|
+ uiCONTROL = inl(M2P_reg_base+M2P_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2P_ENABLE;
|
|
+ outl( uiCONTROL, M2P_reg_base+M2P_OFFSET_CONTROL );
|
|
+ } else {
|
|
+ /*
|
|
+ * M2M channel
|
|
+ */
|
|
+ M2M_reg_base = dma->reg_base;
|
|
+
|
|
+ uiCONTROL = inl(M2M_reg_base+M2M_OFFSET_CONTROL);
|
|
+ uiCONTROL &= ~CONTROL_M2M_ENABLE;
|
|
+ outl( uiCONTROL, M2M_reg_base+M2M_OFFSET_CONTROL );
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Free the interrupt servicing this dma channel
|
|
+ */
|
|
+ //free_irq(dma->irq, (void *) dma);
|
|
+ dma->terminated=1;
|
|
+
|
|
+ /*
|
|
+ * Decrement the reference count for this instance of the dma interface
|
|
+ */
|
|
+ dma->ref_count--;
|
|
+
|
|
+ /*
|
|
+ * Set the transfer and pause state variables to 0
|
|
+ * (unititialized state).
|
|
+ */
|
|
+ dma->xfer_enable = 0;
|
|
+ dma->pause = 0;
|
|
+
|
|
+ /*
|
|
+ * Debugging message.
|
|
+ */
|
|
+ DPRINTK("Successfully freed dma channel %d\n", channel);
|
|
+ /*
|
|
+ * Success.
|
|
+ */
|
|
+ return(0);
|
|
+}
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * ep93xx_dma_init(void)
|
|
+ *
|
|
+ * Description: This function is called during system initialization to
|
|
+ * setup the interrupt number and register set base address for each DMA
|
|
+ * channel.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+static int __init
|
|
+ep93xx_dma_init(void)
|
|
+{
|
|
+ int channel;
|
|
+
|
|
+ /*
|
|
+ * Init some values in each dma instance.
|
|
+ */
|
|
+ for (channel = 0; channel < MAX_EP93XX_DMA_CHANNELS; channel++) {
|
|
+ /*
|
|
+ * IRQ for the specified dma channel.
|
|
+ */
|
|
+ dma_chan[channel].irq = IRQ_EP93XX_DMAM2P0 + channel;
|
|
+
|
|
+ dma_chan[channel].terminated = 0;
|
|
+
|
|
+ /*
|
|
+ * Initial value of the dma channel handle.
|
|
+ */
|
|
+ dma_chan[channel].last_valid_handle = channel << 28;
|
|
+
|
|
+ /*
|
|
+ * Give the instance a pointer to the dma channel register
|
|
+ * base.
|
|
+ */
|
|
+ if (channel < 10)
|
|
+ dma_chan[channel].reg_base = DMAM2PChannelBase[channel];
|
|
+ else
|
|
+ dma_chan[channel].reg_base = DMAM2MChannelBase[channel - 10];
|
|
+
|
|
+ /*
|
|
+ * Initialize the reference count for this channel.
|
|
+ */
|
|
+ dma_chan[channel].ref_count = 0;
|
|
+ }
|
|
+
|
|
+ DPRINTK("DMA Interface intitialization complete\n");
|
|
+
|
|
+ /*
|
|
+ * Success
|
|
+ */
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+arch_initcall(ep93xx_dma_init);
|
|
+
|
|
+EXPORT_SYMBOL(ep93xx_dma_free);
|
|
+EXPORT_SYMBOL(ep93xx_dma_request);
|
|
+EXPORT_SYMBOL(ep93xx_dma_flush);
|
|
+EXPORT_SYMBOL(ep93xx_dma_pause);
|
|
+EXPORT_SYMBOL(ep93xx_dma_remove_buffer);
|
|
+EXPORT_SYMBOL(ep93xx_dma_add_buffer);
|
|
+EXPORT_SYMBOL(ep93xx_dma_start);
|
|
+EXPORT_SYMBOL(ep93xx_dma_config);
|
|
--- /dev/null
|
|
+++ b/arch/arm/mach-ep93xx/dma_ep93xx.h
|
|
@@ -0,0 +1,676 @@
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * arch/arm/mach-ep93xx/dma_ep93xx.h
|
|
+ *
|
|
+ * DESCRIPTION: 93XX DMA controller API private defintions.
|
|
+ *
|
|
+ * Copyright Cirrus Logic Corporation, 2003. All rights reserved
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or modify
|
|
+ * it under the terms of the GNU General Public License as published by
|
|
+ * the Free Software Foundation; either version 2 of the License, or
|
|
+ * (at your option) any later version.
|
|
+ *
|
|
+ * This program is distributed in the hope that it will be useful,
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
+ * GNU General Public License for more details.
|
|
+ *
|
|
+ * You should have received a copy of the GNU General Public License
|
|
+ * along with this program; if not, write to the Free Software
|
|
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+#ifndef _EP93XX_DMA_H_
|
|
+#define _EP93XX_DMA_H_
|
|
+
|
|
+// as it turns out the ide dma is the biggest dma buffer hog so far
|
|
+// in case the HDD is "thinking" (seek/buffer flush)
|
|
+// the continueing r/w DMAs to the HDD will be queued up to up to PRD_ENTRIES entries...
|
|
+#include <linux/ide.h>
|
|
+#define MAX_EP93XX_DMA_BUFFERS PRD_ENTRIES
|
|
+
|
|
+#ifndef TRUE
|
|
+#define TRUE 1
|
|
+#endif
|
|
+
|
|
+#ifndef FALSE
|
|
+#define FALSE 0
|
|
+#endif
|
|
+
|
|
+#ifndef NULL
|
|
+#define NULL 0
|
|
+#endif
|
|
+
|
|
+#define EP93XX_DMA_BASE (EP93XX_AHB_VIRT_BASE + 0x00000000)
|
|
+
|
|
+/*****************************************************************************
|
|
+ * 0x8000.0000 -> 0x8000.003C M2P Channel 0 Registers (Tx)
|
|
+ * 0x8000.0040 -> 0x8000.007C M2P Channel 1 Registers (Rx)
|
|
+ * 0x8000.0080 -> 0x8000.00BC M2P Channel 2 Registers (Tx)
|
|
+ * 0x8000.00C0 -> 0x8000.00FC M2P Channel 3 Registers (Rx)
|
|
+ * 0x8000.0100 -> 0x8000.013C M2M Channel 0 Registers
|
|
+ * 0x8000.0140 -> 0x8000.017C M2M Channel 1 Registers
|
|
+ * 0x8000.0180 -> 0x8000.01BC Not Used
|
|
+ * 0x8000.01C0 -> 0x8000.01FC Not Used
|
|
+ * 0x8000.0200 -> 0x8000.023C M2P Channel 5 Registers (Rx)
|
|
+ * 0x8000.0240 -> 0x8000.027C M2P Channel 4 Registers (Tx)
|
|
+ * 0x8000.0280 -> 0x8000.02BC M2P Channel 7 Registers (Rx)
|
|
+ * 0x8000.02C0 -> 0x8000.02FC M2P Channel 6 Registers (Tx)
|
|
+ * 0x8000.0300 -> 0x8000.033C M2P Channel 9 Registers (Rx)
|
|
+ * 0x8000.0340 -> 0x8000.037C M2P Channel 8 Registers (Tx)
|
|
+ * 0x8000.0380 DMA Channel Arbitration register
|
|
+ * 0x8000.03C0 DMA Global Interrupt register
|
|
+ * 0x8000.03C4 -> 0x8000.03FC Not Used
|
|
+ *
|
|
+ *
|
|
+ * Internal M2P/P2M Channel Register Map
|
|
+ *
|
|
+ * Offset Name Access Bits Reset Value
|
|
+ * 0x00 CONTROL R/W 6 0
|
|
+ * 0x04 INTERRUPT R/W TC* 3 0
|
|
+ * 0x08 PPALLOC R/W 4 channel dependant
|
|
+ * (see reg description)
|
|
+ * 0x0C STATUS RO 8 0
|
|
+ * 0x10 reserved
|
|
+ * 0x14 REMAIN RO 16 0
|
|
+ * 0X18 Reserved
|
|
+ * 0X1C Reserved
|
|
+ * 0x20 MAXCNT0 R/W 16 0
|
|
+ * 0x24 BASE0 R/W 32 0
|
|
+ * 0x28 CURRENT0 RO 32 0
|
|
+ * 0x2C Reserved
|
|
+ * 0x30 MAXCNT1 R/W 16 0
|
|
+ * 0x34 BASE1 R/W 32 0
|
|
+ * 0X38 CURRENT1 RO 32 0
|
|
+ * 0X3C Reserved
|
|
+ *
|
|
+ * M2M Channel Register Map
|
|
+ * Offset Name Access Bits Reset Value
|
|
+ *
|
|
+ * 0x00 CONTROL R/W 22 0
|
|
+ * 0x04 INTERRUPT R/W TC* 3 0
|
|
+ * 0x08 Reserved
|
|
+ * 0x0C STATUS R/W TC* 14 0
|
|
+ * 0x10 BCR0 R/W 16 0
|
|
+ * 0x14 BCR1 R/W 16 0
|
|
+ * 0x18 SAR_BASE0 R/W 32 0
|
|
+ * 0x1C SAR_BASE1 R/W 32 0
|
|
+ * 0x20 Reserved
|
|
+ * 0x24 SAR_CURRENT0 RO 32 0
|
|
+ * 0x28 SAR_CURRENT1 RO 32 0
|
|
+ * 0x2C DAR_BASE0 R/W 32 0
|
|
+ * 0x30 DAR_BASE1 R/W 32 0
|
|
+ * 0x34 DAR_CURRENT0 RO 32 0
|
|
+ * 0X38 Reserved
|
|
+ * 0X3C DAR_CURRENT1 RO 32 0
|
|
+ * * Write this location once to clear the bit (see
|
|
+ * Interrupt/Status register description for which bits
|
|
+ * this rule applies to).
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+
|
|
+
|
|
+/*----------------------------------------------------------------------------------*/
|
|
+/* M2P Registers */
|
|
+/*----------------------------------------------------------------------------------*/
|
|
+/*
|
|
+ * M2P CONTROL register bit defines
|
|
+ */
|
|
+#define CONTROL_M2P_STALLINTEN 0x00000001 /* Enables the STALL interrupt */
|
|
+#define CONTROL_M2P_NFBINTEN 0x00000002 /* Enables the NFB interrupt */
|
|
+#define CONTROL_M2P_CHERRORINTEN 0x00000008 /* Enables the ChError interrupt*/
|
|
+#define CONTROL_M2P_ENABLE 0x00000010 /* Enables the channel */
|
|
+#define CONTROL_M2P_ABRT 0x00000020 /* Determines how DMA behaves in*/
|
|
+ /* NEXT state with peripheral */
|
|
+ /* error */
|
|
+ /* 0: NEXT -> ON, ignore error */
|
|
+ /* 1: NEXT -> STALL, disable ch.*/
|
|
+#define CONTROL_M2P_ICE 0x00000040 /* Ignore Channel Error */
|
|
+
|
|
+/*
|
|
+ * M2P INTERRUPT register bit defines
|
|
+ */
|
|
+#define INTERRUPT_M2P_STALLINT 0x00000001 /* Indicates channel stalled. */
|
|
+#define INTERRUPT_M2P_NFBINT 0x00000002 /* Indicates channel is hungry. */
|
|
+#define INTERRUPT_M2P_CHERRORINT 0x00000008 /* Peripheral detects error */
|
|
+
|
|
+
|
|
+/*
|
|
+ * STATUS register bit defines
|
|
+ */
|
|
+#define STATUS_M2P_STALL 0x00000001 /* A '1' indicates channel is */
|
|
+ /* stalled */
|
|
+#define STATUS_M2P_NFB 0x00000002 /* A '1' indicates channel has moved*/
|
|
+ /* from NEXT state to ON state, but */
|
|
+ /* waiting for next buffer to be */
|
|
+ /* programmed. */
|
|
+#define STATUS_M2P_CHERROR 0x00000008 /* Enables the ChError interrupt */
|
|
+#define STATUS_M2P_CURRENT_MASK 0x00000030 /* Current state of the FSM */
|
|
+#define STATUS_M2P_CURRENT_SHIFT 4
|
|
+#define STATUS_M2P_NEXTBUFFER 0x00000040 /* Informs the int handler after an */
|
|
+ /* NFB int which pair of maxcnt and */
|
|
+ /* base regs to update. */
|
|
+#define STATUS_M2P_BYTES_MASK 0x0000f800 /* number of valid DMA data */
|
|
+#define STATUS_M2P_BYTES_SHIFT 7 /* currently in */
|
|
+ /* packer/unpacker */
|
|
+
|
|
+#define STATUS_M2P_DMA_NO_BUF 0x00000000
|
|
+#define STATUS_M2P_DMA_BUF_ON 0x00000010
|
|
+#define STATUS_M2P_DMA_BUF_NEXT 0x00000020
|
|
+
|
|
+/*
|
|
+ * Register masks to mask off reserved bits after reading register.
|
|
+ */
|
|
+#define M2P_MASK_PPALLOC 0x0000000f
|
|
+#define M2P_MASK_REMAIN 0x0000ffff
|
|
+#define M2P_MASK_MAXCNT0 0x0000ffff
|
|
+#define M2P_MASK_BASE0 0xffffffff
|
|
+#define M2P_MASK_CURRENT0 0xffffffff
|
|
+#define M2P_MASK_MAXCNT1 0x0000ffff
|
|
+#define M2P_MASK_BASE1 0xffffffff
|
|
+#define M2P_MASK_CURRENT1 0xffffffff
|
|
+
|
|
+
|
|
+/*----------------------------------------------------------------------------------*/
|
|
+/* M2M Registers */
|
|
+/*----------------------------------------------------------------------------------*/
|
|
+
|
|
+#define CONTROL_M2M_STALLINTEN 0x00000001 /* Enables the STALL interrupt */
|
|
+#define CONTROL_M2M_SCT 0x00000002 /* Source Copy Transfer. Setup a */
|
|
+ /* block transfer from 1 memory source */
|
|
+ /* location. */
|
|
+#define CONTROL_M2M_DONEINTEN 0x00000004 /* Enables the DONE interrupt which */
|
|
+ /* indicates if the xfer completed */
|
|
+ /* successfully */
|
|
+#define CONTROL_M2M_ENABLE 0x00000008 /* Enables the channel */
|
|
+#define CONTROL_M2M_START 0x00000010 /* Initiates the xfer. 'software trigger' */
|
|
+#define CONTROL_M2M_BWC_MASK 0x000001e0 /* Bandwidth control. Indicate number of */
|
|
+#define CONTROL_M2M_BWC_SHIFT 5 /* bytes in a transfer. */
|
|
+#define CONTROL_M2M_PW_MASK 0x00000600 /* Peripheral width. Used for xfers */
|
|
+#define CONTROL_M2M_PW_SHIFT 9 /* between memory and external peripheral. */
|
|
+ /* 00: byte, 01: halfword, 10: word. */
|
|
+#define CONTROL_M2M_DAH 0x00000800 /* Destination Address Hold */
|
|
+#define CONTROL_M2M_SAH 0x00001000 /* Source Address Hold */
|
|
+#define CONTROL_M2M_TM_MASK 0x00006000 /* Transfer Mode. 00: sw triggered, */
|
|
+#define CONTROL_M2M_TM_SHIFT 13 /* 01: hw initiated M2P, 01: hw initiated P2M */
|
|
+#define CONTROL_M2M_ETDP_MASK 0x00018000 /* End-of-Transfer/Terminal Count pin */
|
|
+#define CONTROL_M2M_ETDP_SHIFT 15 /* direction and polarity. */
|
|
+#define CONTROL_M2M_DACKP 0x00020000 /* DMA acknowledge pin polarity */
|
|
+
|
|
+#define CONTROL_M2M_DREQP_MASK 0x00180000 /* DMA request pin polarity. must be set */
|
|
+#define CONTROL_M2M_DREQP_SHIFT 19 /* before enable bit. */
|
|
+#define CONTROL_M2M_NFBINTEN 0x00200000 /* Enables generation of the NFB interrupt. */
|
|
+#define CONTROL_M2M_RSS_MASK 0x00c00000 /* Request source selection: */
|
|
+#define CONTROL_M2M_RSS_SHIFT 22 /* 000 - External DReq[0] */
|
|
+ /* 001 - External DReq[1] */
|
|
+ /* 01X - Internal SSPRx */
|
|
+ /* 10X - Internal SSPTx */
|
|
+ /* 11X - Internal IDE */
|
|
+#define CONTROL_M2M_NO_HDSK 0x01000000 /* No handshake. When set the peripheral doesn't */
|
|
+ /* require the regular handshake protocal. Must */
|
|
+ /* be set for SSP and IDE operations, optional */
|
|
+ /* for external peripherals. */
|
|
+#define CONTROL_M2M_PWSC_MASK 0xfe000000 /* Peripheral wait states count. Gives the latency */
|
|
+#define CONTROL_M2M_PWSC_SHIFT 25 /* (in PCLK cycles) needed by the peripheral to */
|
|
+ /* deassert its' request once the M2M xfer w/ DMA */
|
|
+ /* is complete. */
|
|
+
|
|
+/*
|
|
+ * M2M INTERRUPT register bit defines
|
|
+ */
|
|
+#define INTERRUPT_M2M_STALLINT 0x00000001 /* Stall interrupt indicates channel stalled. */
|
|
+#define INTERRUPT_M2M_DONEINT 0x00000002 /* Transaction done. */
|
|
+#define INTERRUPT_M2M_NFBINT 0x00000004 /* Next frame buffer interrupt indicates */
|
|
+ /* channel requires a new buffer */
|
|
+
|
|
+
|
|
+
|
|
+/*
|
|
+ * M2M STATUS register bit defines
|
|
+ */
|
|
+#define STATUS_M2M_STALL 0x00000001 /* A '1' indicates channel is stalled */
|
|
+#define STATUS_M2M_CURRENTSTATE_MASK 0x0000003e /* Indicates state of M2M Channel control */
|
|
+#define STATUS_M2M_CURRENTSTATE_SHIFT 1 /* FSM (0-2): */
|
|
+ /* 000 - IDLE, 001 - STALL, 010 - MEM_RD, */
|
|
+ /* 011 - MEM_WR, 100 - BWC_WAIT */
|
|
+ /* and M2M buffer FSM (3-2): */
|
|
+ /* 00 - NO_BUF, 01 - BUF_ON, 10 - BUF_NEXT */
|
|
+#define STATUS_M2M_DONE 0x00000040 /* Transfer completed successfully if 1. */
|
|
+#define STATUS_M2M_TCS_MASK 0x00000180 /* Terminal Count status. Indicates whether or */
|
|
+#define STATUS_M2M_TCS_SHIFT 7 /* or not the actual byte count reached */
|
|
+ /* programmed limit for buffer descriptor */
|
|
+#define STATUS_M2M_EOTS_MASK 0x00000600 /* End-of-Transfer status for buffer */
|
|
+#define STATUS_M2M_EOTS_SHIFT 9
|
|
+#define STATUS_M2M_NFB 0x00000800 /* A '1' indicates channel has moved */
|
|
+ /* from NEXT state to ON state, but the next */
|
|
+ /* byte count reg for next buffer has not been */
|
|
+ /* programmed yet. */
|
|
+#define STATUS_M2M_NB 0x00001000 /* NextBuffer status. Informs NFB service */
|
|
+ /* routine, after NFB int, which pair of buffer */
|
|
+ /* descriptor registers is free to update. */
|
|
+#define STATUS_M2M_DREQS 0x00002000 /* DREQ status. Reflects the status of the */
|
|
+ /* synchronized external peripherals DMA */
|
|
+ /* request signal. */
|
|
+
|
|
+/*
|
|
+ * Register masks to mask off reserved bits after reading register.
|
|
+ */
|
|
+#define M2M_MASK_BCR0 0x0000ffff
|
|
+#define M2M_MASK_BCR1 0x0000ffff
|
|
+#define M2M_MASK_SAR_BASE0 0xffffffff
|
|
+#define M2M_MASK_SAR_BASE1 0xffffffff
|
|
+#define M2M_MASK_SAR_CURRENT0 0xffffffff
|
|
+#define M2M_MASK_SAR_CURRENT1 0xffffffff
|
|
+#define M2M_MASK_DAR_BASE0 0xffffffff
|
|
+#define M2M_MASK_DAR_BASE1 0xffffffff
|
|
+#define M2M_MASK_DAR_CURRENT0 0xffffffff
|
|
+#define M2M_MASK_DAR_CURRENT1 0xffffffff
|
|
+
|
|
+
|
|
+//
|
|
+/* 8000_0000 - 8000_ffff: DMA */
|
|
+#define DMA_OFFSET 0x000000
|
|
+#define DMA_BASE (EP93XX_DMA_BASE)
|
|
+#define DMAMP_TX_0_CONTROL (DMA_BASE+0x0000)
|
|
+#define DMAMP_TX_0_INTERRUPT (DMA_BASE+0x0004)
|
|
+#define DMAMP_TX_0_PPALLOC (DMA_BASE+0x0008)
|
|
+#define DMAMP_TX_0_STATUS (DMA_BASE+0x000C)
|
|
+#define DMAMP_TX_0_REMAIN (DMA_BASE+0x0014)
|
|
+#define DMAMP_TX_0_MAXCNT0 (DMA_BASE+0x0020)
|
|
+#define DMAMP_TX_0_BASE0 (DMA_BASE+0x0024)
|
|
+#define DMAMP_TX_0_CURRENT0 (DMA_BASE+0x0028)
|
|
+#define DMAMP_TX_0_MAXCNT1 (DMA_BASE+0x0030)
|
|
+#define DMAMP_TX_0_BASE1 (DMA_BASE+0x0034)
|
|
+#define DMAMP_TX_0_CURRENT1 (DMA_BASE+0x0038)
|
|
+
|
|
+#define DMAMP_RX_1_CONTROL (DMA_BASE+0x0040)
|
|
+#define DMAMP_RX_1_INTERRUPT (DMA_BASE+0x0044)
|
|
+#define DMAMP_RX_1_PPALLOC (DMA_BASE+0x0048)
|
|
+#define DMAMP_RX_1_STATUS (DMA_BASE+0x004C)
|
|
+#define DMAMP_RX_1_REMAIN (DMA_BASE+0x0054)
|
|
+#define DMAMP_RX_1_MAXCNT0 (DMA_BASE+0x0060)
|
|
+#define DMAMP_RX_1_BASE0 (DMA_BASE+0x0064)
|
|
+#define DMAMP_RX_1_CURRENT0 (DMA_BASE+0x0068)
|
|
+#define DMAMP_RX_1_MAXCNT1 (DMA_BASE+0x0070)
|
|
+#define DMAMP_RX_1_BASE1 (DMA_BASE+0x0074)
|
|
+#define DMAMP_RX_1_CURRENT1 (DMA_BASE+0x0078)
|
|
+
|
|
+#define DMAMP_TX_2_CONTROL (DMA_BASE+0x0080)
|
|
+#define DMAMP_TX_2_INTERRUPT (DMA_BASE+0x0084)
|
|
+#define DMAMP_TX_2_PPALLOC (DMA_BASE+0x0088)
|
|
+#define DMAMP_TX_2_STATUS (DMA_BASE+0x008C)
|
|
+#define DMAMP_TX_2_REMAIN (DMA_BASE+0x0094)
|
|
+#define DMAMP_TX_2_MAXCNT0 (DMA_BASE+0x00A0)
|
|
+#define DMAMP_TX_2_BASE0 (DMA_BASE+0x00A4)
|
|
+#define DMAMP_TX_2_CURRENT0 (DMA_BASE+0x00A8)
|
|
+#define DMAMP_TX_2_MAXCNT1 (DMA_BASE+0x00B0)
|
|
+#define DMAMP_TX_2_BASE1 (DMA_BASE+0x00B4)
|
|
+#define DMAMP_TX_2_CURRENT1 (DMA_BASE+0x00B8)
|
|
+
|
|
+#define DMAMP_RX_3_CONTROL (DMA_BASE+0x00C0)
|
|
+#define DMAMP_RX_3_INTERRUPT (DMA_BASE+0x00C4)
|
|
+#define DMAMP_RX_3_PPALLOC (DMA_BASE+0x00C8)
|
|
+#define DMAMP_RX_3_STATUS (DMA_BASE+0x00CC)
|
|
+#define DMAMP_RX_3_REMAIN (DMA_BASE+0x00D4)
|
|
+#define DMAMP_RX_3_MAXCNT0 (DMA_BASE+0x00E0)
|
|
+#define DMAMP_RX_3_BASE0 (DMA_BASE+0x00E4)
|
|
+#define DMAMP_RX_3_CURRENT0 (DMA_BASE+0x00E8)
|
|
+#define DMAMP_RX_3_MAXCNT1 (DMA_BASE+0x00F0)
|
|
+#define DMAMP_RX_3_BASE1 (DMA_BASE+0x00F4)
|
|
+#define DMAMP_RX_3_CURRENT1 (DMA_BASE+0x00F8)
|
|
+
|
|
+#define DMAMM_0_CONTROL (DMA_BASE+0x0100)
|
|
+#define DMAMM_0_INTERRUPT (DMA_BASE+0x0104)
|
|
+#define DMAMM_0_STATUS (DMA_BASE+0x010C)
|
|
+#define DMAMM_0_BCR0 (DMA_BASE+0x0110)
|
|
+#define DMAMM_0_BCR1 (DMA_BASE+0x0114)
|
|
+#define DMAMM_0_SAR_BASE0 (DMA_BASE+0x0118)
|
|
+#define DMAMM_0_SAR_BASE1 (DMA_BASE+0x011C)
|
|
+#define DMAMM_0_SAR_CURRENT0 (DMA_BASE+0x0124)
|
|
+#define DMAMM_0_SAR_CURRENT1 (DMA_BASE+0x0128)
|
|
+#define DMAMM_0_DAR_BASE0 (DMA_BASE+0x012C)
|
|
+#define DMAMM_0_DAR_BASE1 (DMA_BASE+0x0130)
|
|
+#define DMAMM_0_DAR_CURRENT0 (DMA_BASE+0x0134)
|
|
+#define DMAMM_0_DAR_CURRENT1 (DMA_BASE+0x013C)
|
|
+
|
|
+#define DMAMM_1_CONTROL (DMA_BASE+0x0140)
|
|
+#define DMAMM_1_INTERRUPT (DMA_BASE+0x0144)
|
|
+#define DMAMM_1_STATUS (DMA_BASE+0x014C)
|
|
+#define DMAMM_1_BCR0 (DMA_BASE+0x0150)
|
|
+#define DMAMM_1_BCR1 (DMA_BASE+0x0154)
|
|
+#define DMAMM_1_SAR_BASE0 (DMA_BASE+0x0158)
|
|
+#define DMAMM_1_SAR_BASE1 (DMA_BASE+0x015C)
|
|
+#define DMAMM_1_SAR_CURRENT0 (DMA_BASE+0x0164)
|
|
+#define DMAMM_1_SAR_CURRENT1 (DMA_BASE+0x0168)
|
|
+#define DMAMM_1_DAR_BASE0 (DMA_BASE+0x016C)
|
|
+#define DMAMM_1_DAR_BASE1 (DMA_BASE+0x0170)
|
|
+#define DMAMM_1_DAR_CURRENT0 (DMA_BASE+0x0174)
|
|
+#define DMAMM_1_DAR_CURRENT1 (DMA_BASE+0x017C)
|
|
+
|
|
+#define DMAMP_RX_5_CONTROL (DMA_BASE+0x0200)
|
|
+#define DMAMP_RX_5_INTERRUPT (DMA_BASE+0x0204)
|
|
+#define DMAMP_RX_5_PPALLOC (DMA_BASE+0x0208)
|
|
+#define DMAMP_RX_5_STATUS (DMA_BASE+0x020C)
|
|
+#define DMAMP_RX_5_REMAIN (DMA_BASE+0x0214)
|
|
+#define DMAMP_RX_5_MAXCNT0 (DMA_BASE+0x0220)
|
|
+#define DMAMP_RX_5_BASE0 (DMA_BASE+0x0224)
|
|
+#define DMAMP_RX_5_CURRENT0 (DMA_BASE+0x0228)
|
|
+#define DMAMP_RX_5_MAXCNT1 (DMA_BASE+0x0230)
|
|
+#define DMAMP_RX_5_BASE1 (DMA_BASE+0x0234)
|
|
+#define DMAMP_RX_5_CURRENT1 (DMA_BASE+0x0238)
|
|
+
|
|
+#define DMAMP_TX_4_CONTROL (DMA_BASE+0x0240)
|
|
+#define DMAMP_TX_4_INTERRUPT (DMA_BASE+0x0244)
|
|
+#define DMAMP_TX_4_PPALLOC (DMA_BASE+0x0248)
|
|
+#define DMAMP_TX_4_STATUS (DMA_BASE+0x024C)
|
|
+#define DMAMP_TX_4_REMAIN (DMA_BASE+0x0254)
|
|
+#define DMAMP_TX_4_MAXCNT0 (DMA_BASE+0x0260)
|
|
+#define DMAMP_TX_4_BASE0 (DMA_BASE+0x0264)
|
|
+#define DMAMP_TX_4_CURRENT0 (DMA_BASE+0x0268)
|
|
+#define DMAMP_TX_4_MAXCNT1 (DMA_BASE+0x0270)
|
|
+#define DMAMP_TX_4_BASE1 (DMA_BASE+0x0274)
|
|
+#define DMAMP_TX_4_CURRENT1 (DMA_BASE+0x0278)
|
|
+
|
|
+#define DMAMP_RX_7_CONTROL (DMA_BASE+0x0280)
|
|
+#define DMAMP_RX_7_INTERRUPT (DMA_BASE+0x0284)
|
|
+#define DMAMP_RX_7_PPALLOC (DMA_BASE+0x0288)
|
|
+#define DMAMP_RX_7_STATUS (DMA_BASE+0x028C)
|
|
+#define DMAMP_RX_7_REMAIN (DMA_BASE+0x0294)
|
|
+#define DMAMP_RX_7_MAXCNT0 (DMA_BASE+0x02A0)
|
|
+#define DMAMP_RX_7_BASE0 (DMA_BASE+0x02A4)
|
|
+#define DMAMP_RX_7_CURRENT0 (DMA_BASE+0x02A8)
|
|
+#define DMAMP_RX_7_MAXCNT1 (DMA_BASE+0x02B0)
|
|
+#define DMAMP_RX_7_BASE1 (DMA_BASE+0x02B4)
|
|
+#define DMAMP_RX_7_CURRENT1 (DMA_BASE+0x02B8)
|
|
+
|
|
+#define DMAMP_TX_6_CONTROL (DMA_BASE+0x02C0)
|
|
+#define DMAMP_TX_6_INTERRUPT (DMA_BASE+0x02C4)
|
|
+#define DMAMP_TX_6_PPALLOC (DMA_BASE+0x02C8)
|
|
+#define DMAMP_TX_6_STATUS (DMA_BASE+0x02CC)
|
|
+#define DMAMP_TX_6_REMAIN (DMA_BASE+0x02D4)
|
|
+#define DMAMP_TX_6_MAXCNT0 (DMA_BASE+0x02E0)
|
|
+#define DMAMP_TX_6_BASE0 (DMA_BASE+0x02E4)
|
|
+#define DMAMP_TX_6_CURRENT0 (DMA_BASE+0x02E8)
|
|
+#define DMAMP_TX_6_MAXCNT1 (DMA_BASE+0x02F0)
|
|
+#define DMAMP_TX_6_BASE1 (DMA_BASE+0x02F4)
|
|
+#define DMAMP_TX_6_CURRENT1 (DMA_BASE+0x02F8)
|
|
+
|
|
+#define DMAMP_RX_9_CONTROL (DMA_BASE+0x0300)
|
|
+#define DMAMP_RX_9_INTERRUPT (DMA_BASE+0x0304)
|
|
+#define DMAMP_RX_9_PPALLOC (DMA_BASE+0x0308)
|
|
+#define DMAMP_RX_9_STATUS (DMA_BASE+0x030C)
|
|
+#define DMAMP_RX_9_REMAIN (DMA_BASE+0x0314)
|
|
+#define DMAMP_RX_9_MAXCNT0 (DMA_BASE+0x0320)
|
|
+#define DMAMP_RX_9_BASE0 (DMA_BASE+0x0324)
|
|
+#define DMAMP_RX_9_CURRENT0 (DMA_BASE+0x0328)
|
|
+#define DMAMP_RX_9_MAXCNT1 (DMA_BASE+0x0330)
|
|
+#define DMAMP_RX_9_BASE1 (DMA_BASE+0x0334)
|
|
+#define DMAMP_RX_9_CURRENT1 (DMA_BASE+0x0338)
|
|
+
|
|
+#define DMAMP_TX_8_CONTROL (DMA_BASE+0x0340)
|
|
+#define DMAMP_TX_8_INTERRUPT (DMA_BASE+0x0344)
|
|
+#define DMAMP_TX_8_PPALLOC (DMA_BASE+0x0348)
|
|
+#define DMAMP_TX_8_STATUS (DMA_BASE+0x034C)
|
|
+#define DMAMP_TX_8_REMAIN (DMA_BASE+0x0354)
|
|
+#define DMAMP_TX_8_MAXCNT0 (DMA_BASE+0x0360)
|
|
+#define DMAMP_TX_8_BASE0 (DMA_BASE+0x0364)
|
|
+#define DMAMP_TX_8_CURRENT0 (DMA_BASE+0x0368)
|
|
+#define DMAMP_TX_8_MAXCNT1 (DMA_BASE+0x0370)
|
|
+#define DMAMP_TX_8_BASE1 (DMA_BASE+0x0374)
|
|
+#define DMAMP_TX_8_CURRENT1 (DMA_BASE+0x0378)
|
|
+
|
|
+#define DMA_ARBITRATION (DMA_BASE+0x0380)
|
|
+#define DMA_INTERRUPT (DMA_BASE+0x03C0)
|
|
+
|
|
+
|
|
+/*
|
|
+ * DMA Register Base addresses and Offsets
|
|
+ */
|
|
+#define DMA_M2P_TX_0_BASE DMAMP_TX_0_CONTROL
|
|
+#define DMA_M2P_RX_1_BASE DMAMP_RX_1_CONTROL
|
|
+#define DMA_M2P_TX_2_BASE DMAMP_TX_2_CONTROL
|
|
+#define DMA_M2P_RX_3_BASE DMAMP_RX_3_CONTROL
|
|
+#define DMA_M2M_0_BASE DMAMM_0_CONTROL
|
|
+#define DMA_M2M_1_BASE DMAMM_1_CONTROL
|
|
+#define DMA_M2P_RX_5_BASE DMAMP_RX_5_CONTROL
|
|
+#define DMA_M2P_TX_4_BASE DMAMP_TX_4_CONTROL
|
|
+#define DMA_M2P_RX_7_BASE DMAMP_RX_7_CONTROL
|
|
+#define DMA_M2P_TX_6_BASE DMAMP_TX_6_CONTROL
|
|
+#define DMA_M2P_RX_9_BASE DMAMP_RX_9_CONTROL
|
|
+#define DMA_M2P_TX_8_BASE DMAMP_TX_8_CONTROL
|
|
+
|
|
+#define M2P_OFFSET_CONTROL 0x0000
|
|
+#define M2P_OFFSET_INTERRUPT 0x0004
|
|
+#define M2P_OFFSET_PPALLOC 0x0008
|
|
+#define M2P_OFFSET_STATUS 0x000C
|
|
+#define M2P_OFFSET_REMAIN 0x0014
|
|
+#define M2P_OFFSET_MAXCNT0 0x0020
|
|
+#define M2P_OFFSET_BASE0 0x0024
|
|
+#define M2P_OFFSET_CURRENT0 0x0028
|
|
+#define M2P_OFFSET_MAXCNT1 0x0030
|
|
+#define M2P_OFFSET_BASE1 0x0034
|
|
+#define M2P_OFFSET_CURRENT1 0x0038
|
|
+
|
|
+#define M2M_OFFSET_CONTROL 0x0000
|
|
+#define M2M_OFFSET_INTERRUPT 0x0004
|
|
+#define M2M_OFFSET_STATUS 0x000C
|
|
+#define M2M_OFFSET_BCR0 0x0010
|
|
+#define M2M_OFFSET_BCR1 0x0014
|
|
+#define M2M_OFFSET_SAR_BASE0 0x0018
|
|
+#define M2M_OFFSET_SAR_BASE1 0x001C
|
|
+#define M2M_OFFSET_SAR_CURRENT0 0x0024
|
|
+#define M2M_OFFSET_SAR_CURRENT1 0x0028
|
|
+#define M2M_OFFSET_DAR_BASE0 0x002C
|
|
+#define M2M_OFFSET_DAR_BASE1 0x0030
|
|
+#define M2M_OFFSET_DAR_CURRENT0 0x0034
|
|
+#define M2M_OFFSET_DAR_CURRENT1 0x003C
|
|
+
|
|
+
|
|
+
|
|
+//-----------------------------------------------------------------------------
|
|
+// PWRCNT Register Defines
|
|
+//-----------------------------------------------------------------------------
|
|
+#define SYSCON_PWRCNT_FIREN 0x80000000
|
|
+#define SYSCON_PWRCNT_UARTBAUD 0x20000000
|
|
+#define SYSCON_PWRCNT_USHEN 0x10000000
|
|
+#define SYSCON_PWRCNT_DMA_M2MCH1 0x08000000
|
|
+#define SYSCON_PWRCNT_DMA_M2MCH0 0x04000000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH8 0x02000000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH9 0x01000000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH6 0x00800000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH7 0x00400000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH4 0x00200000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH5 0x00100000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH2 0x00080000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH3 0x00040000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH0 0x00020000
|
|
+#define SYSCON_PWRCNT_DMA_M2PCH1 0x00010000
|
|
+
|
|
+#ifndef __ASSEMBLY__
|
|
+/*
|
|
+ * DMA Register Base addresses
|
|
+ */
|
|
+static unsigned int const DMAM2PChannelBase[10] =
|
|
+{
|
|
+ DMA_M2P_TX_0_BASE,
|
|
+ DMA_M2P_RX_1_BASE,
|
|
+ DMA_M2P_TX_2_BASE,
|
|
+ DMA_M2P_RX_3_BASE,
|
|
+ DMA_M2P_TX_4_BASE,
|
|
+ DMA_M2P_RX_5_BASE,
|
|
+ DMA_M2P_TX_6_BASE,
|
|
+ DMA_M2P_RX_7_BASE,
|
|
+ DMA_M2P_TX_8_BASE,
|
|
+ DMA_M2P_RX_9_BASE
|
|
+};
|
|
+
|
|
+static unsigned int const DMAM2MChannelBase[2] =
|
|
+{
|
|
+ DMA_M2M_0_BASE,
|
|
+ DMA_M2M_1_BASE
|
|
+};
|
|
+
|
|
+#endif /* __ASSEMBLY__ */
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * DMA buffer structure type.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+typedef struct ep93xx_dma_buffer_s
|
|
+{
|
|
+ unsigned int source; /* buffer physical source address. */
|
|
+ unsigned int dest; /* buffer physical destination address, */
|
|
+ /* only used with the 2 M2M channels. */
|
|
+ unsigned int size; /* buffer size in bytes */
|
|
+ unsigned int last; /* 1 if this is the last buffer */
|
|
+ /* in this transaction. If 1, */
|
|
+ /* disable the NFBint so we aren't */
|
|
+ /* interrupted for another buffer */
|
|
+ /* when we know there won't be another. */
|
|
+ unsigned int used; /* This field is set to 1 by the DMA */
|
|
+ /* interface after the buffer is transferred*/
|
|
+ int buf_id; /* unique identifyer specified by the */
|
|
+ /* the driver which requested the dma */
|
|
+} ep93xx_dma_buffer_t;
|
|
+
|
|
+typedef ep93xx_dma_buffer_t * ep93xx_dma_buffer_p;
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * Instance definition for the DMA interface.
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+typedef struct ep9312_dma_s
|
|
+{
|
|
+ /*
|
|
+ * This 1 when the instance is in use, and 0 when it's not.
|
|
+ */
|
|
+ unsigned int ref_count;
|
|
+
|
|
+ /*
|
|
+ * This is the last valid handle for this instance. When giving out a
|
|
+ * new handle this will be incremented and given out.
|
|
+ */
|
|
+ int last_valid_handle;
|
|
+
|
|
+ /*
|
|
+ * device specifies one of the 20 DMA hardware ports this
|
|
+ * DMA channel will service.
|
|
+ */
|
|
+ ep93xx_dma_dev_t device;
|
|
+
|
|
+ /*
|
|
+ * DMABufferQueue is the queue of buffer structure pointers which the
|
|
+ * dma channel will use to setup transfers.
|
|
+ */
|
|
+ ep93xx_dma_buffer_t buffer_queue[MAX_EP93XX_DMA_BUFFERS];
|
|
+
|
|
+ /*
|
|
+ * currnt_buffer : This is the buffer currently being transfered on
|
|
+ * this channel.
|
|
+ * last_buffer : This is the last buffer for this transfer.
|
|
+ * Note: current_buffer + 1 is already programmed into the dma
|
|
+ * channel as the next buffer to transfer. Don't write
|
|
+ * over either entry.
|
|
+ */
|
|
+ int current_buffer;
|
|
+ int last_buffer;
|
|
+
|
|
+ /*
|
|
+ * The following 3 fields are buffer counters.
|
|
+ *
|
|
+ * iNewBuffers: Buffers in the queue which have not been transfered.
|
|
+ * iUsedBuffers: Buffers in the queue which have have been tranferred,
|
|
+ * and are waiting to be returned.
|
|
+ * iTotalBuffers: Total number of buffers in the queue.
|
|
+ */
|
|
+ int new_buffers;
|
|
+ int used_buffers;
|
|
+ int total_buffers;
|
|
+
|
|
+ /*
|
|
+ * uiTotalBytes has the total bytes transfered on the channel since the
|
|
+ * last flush. This value does not include the bytes tranfered in the
|
|
+ * current buffer. A byte count is only added after a complete buffer
|
|
+ * is tranfered.
|
|
+ */
|
|
+ unsigned int total_bytes;
|
|
+
|
|
+ /*
|
|
+ * Interrupt number for this channel
|
|
+ */
|
|
+ unsigned int irq;
|
|
+
|
|
+ /*
|
|
+ * Indicates whether or not the channel is currently enabled to transfer
|
|
+ * data.
|
|
+ */
|
|
+ unsigned int xfer_enable;
|
|
+
|
|
+ /*
|
|
+ * pause indicates if the dma channel was paused by calling the pause
|
|
+ * ioctl.
|
|
+ */
|
|
+ unsigned int pause;
|
|
+
|
|
+ /*
|
|
+ * buffer structure used during a pause to capture the current
|
|
+ * address and remaining bytes for the buffer actively being transferred
|
|
+ * on the channel. This buffer will be used to reprogram the dma
|
|
+ * channel upon a resume.
|
|
+ */
|
|
+ ep93xx_dma_buffer_t pause_buf;
|
|
+
|
|
+ /*
|
|
+ * DMACallback is a function pointer which the calling application can
|
|
+ * use install a function to. this fuction can be used to notify the
|
|
+ * calling application of an interrupt.
|
|
+ */
|
|
+ dma_callback callback;
|
|
+
|
|
+ /*
|
|
+ * User data used as a parameter for the Callback function. The user
|
|
+ * sets up the data and sends it with the callback function.
|
|
+ */
|
|
+ unsigned int user_data;
|
|
+
|
|
+ /*
|
|
+ * A string representation of the device attached to the channel.
|
|
+ */
|
|
+ const char * device_id;
|
|
+
|
|
+ /*
|
|
+ * The register base address for this dma channel.
|
|
+ */
|
|
+ unsigned int reg_base;
|
|
+
|
|
+ /*
|
|
+ * terminated indicates
|
|
+ */
|
|
+ unsigned int terminated;
|
|
+
|
|
+
|
|
+} ep93xx_dma_t;
|
|
+
|
|
+/*****************************************************************************
|
|
+ *
|
|
+ * DMA macros
|
|
+ *
|
|
+ ****************************************************************************/
|
|
+#define DMA_HANDLE_SPECIFIER_MASK 0xF0000000
|
|
+#define DMA_CH0_HANDLE_SPECIFIER 0x00000000
|
|
+#define DMA_CH1_HANDLE_SPECIFIER 0x10000000
|
|
+#define DMA_CH2_HANDLE_SPECIFIER 0x20000000
|
|
+#define DMA_CH3_HANDLE_SPECIFIER 0x30000000
|
|
+#define DMA_CH4_HANDLE_SPECIFIER 0x40000000
|
|
+#define DMA_CH5_HANDLE_SPECIFIER 0x50000000
|
|
+#define DMA_CH6_HANDLE_SPECIFIER 0x60000000
|
|
+#define DMA_CH7_HANDLE_SPECIFIER 0x70000000
|
|
+#define DMA_CH8_HANDLE_SPECIFIER 0x80000000
|
|
+#define DMA_CH9_HANDLE_SPECIFIER 0x90000000
|
|
+#define DMA_CH10_HANDLE_SPECIFIER 0xA0000000
|
|
+#define DMA_CH11_HANDLE_SPECIFIER 0xB0000000
|
|
+
|
|
+#endif // _DMADRV_H_
|