linux-kernel - Re: [PATCH resent] dma: add the freescale-provided MultiChannel DMA driver

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-ID: <20130220063147.GD23302@intel.com>
Date:	Wed, 20 Feb 2013 12:01:47 +0530
From:	Vinod Koul <vinod.koul@...el.com>
To:	Philippe De Muyter <phdm@...qel.be>
Cc:	linux-kernel@...r.kernel.org, Greg Ungerer <gerg@...pgear.com>,
	Stany MARCEL <smarcel@...tenovation.fr>,
	Dan Williams <djbw@...com>,
	Greg Kroah-Hartman <gregkh@...uxfoundation.org>
Subject: Re: [PATCH resent] dma: add the freescale-provided MultiChannel
 DMA driver

On Mon, Feb 04, 2013 at 06:38:23PM +0100, Philippe De Muyter wrote:
> This patch adds the (cleaned-up) Freescale-provided MultiChannel DMA
> driver for ColdFire M54xx and MPC8220 processors.
> 
> This driver is needed for the ethernet FEC driver of the ColdFire
> M547x and M548x processors.
> 
> It is not dmaengine-enabled, but that's not needed for the above FEC driver.
> I have however installed it in the driver/dma tree as this IP block is not
> m68k-specific, but freescale-specific, and shared at least between powerpc
> and coldfire parts (possibly arm-parts as well).
> 
> The installation in drivers/dma implies a small rule change in
> drivers/Makefile to enter drivers/dma on CONFIG_DMADEVICES instead
> of CONFIG_DMAENGINE.
BIG NAK
1. Please run Checkpath and reread Documentation/CodingStyle, specfically CH4.
Avoid the CamelCase
2. If you are not using dmaengine APIs then drivers/dma/ is not a place for you.
3. While glancing at the code, I dont see why you cant use dmaengine APIs?
4. lastly, am blown off by your own implementation of memcpy, WHY? Kernel is
smarter than you!

I guess the driver needs some solid plumbing to make it suitable for mainline

--
~Vinod
> 
> Signed-off-by: Philippe De Muyter <phdm@...qel.be>
> Cc: Greg Ungerer <gerg@...pgear.com>
> Cc: Stany MARCEL <smarcel@...tenovation.fr>
> Cc: Vinod Koul <vinod.koul@...el.com>
> Cc: Dan Williams <djbw@...com>
> Cc: Greg Kroah-Hartman <gregkh@...uxfoundation.org>
> ---
>  arch/m68k/Kconfig.cpu                   |    2 +
>  drivers/Makefile                        |    2 +-
>  drivers/dma/Kconfig                     |    9 +
>  drivers/dma/Makefile                    |    1 +
>  drivers/dma/fsl_mcd_dma/MCD_dmaApi.c    |  963 ++++++++++++
>  drivers/dma/fsl_mcd_dma/MCD_tasks.c     | 2425 +++++++++++++++++++++++++++++++
>  drivers/dma/fsl_mcd_dma/MCD_tasksInit.c |  274 ++++
>  drivers/dma/fsl_mcd_dma/MCD_tasksInit.h |   76 +
>  drivers/dma/fsl_mcd_dma/Makefile        |    1 +
>  include/linux/MCD_dma.h                 |  376 +++++
>  10 files changed, 4128 insertions(+), 1 deletions(-)
>  create mode 100644 drivers/dma/fsl_mcd_dma/MCD_dmaApi.c
>  create mode 100644 drivers/dma/fsl_mcd_dma/MCD_tasks.c
>  create mode 100644 drivers/dma/fsl_mcd_dma/MCD_tasksInit.c
>  create mode 100644 drivers/dma/fsl_mcd_dma/MCD_tasksInit.h
>  create mode 100644 drivers/dma/fsl_mcd_dma/Makefile
>  create mode 100644 include/linux/MCD_dma.h
> 
> diff --git a/arch/m68k/Kconfig.cpu b/arch/m68k/Kconfig.cpu
> index b1cfff8..721d64c 100644
> --- a/arch/m68k/Kconfig.cpu
> +++ b/arch/m68k/Kconfig.cpu
> @@ -242,6 +242,8 @@ config M5407
>  
>  config M54xx
>  	bool
> +	select HAS_DMA
> +	select DMADEVICES
>  
>  config M547x
>  	bool "MCF547x"
> diff --git a/drivers/Makefile b/drivers/Makefile
> index 7863b9f..d8372ab 100644
> --- a/drivers/Makefile
> +++ b/drivers/Makefile
> @@ -29,7 +29,7 @@ obj-$(CONFIG_PNP)		+= pnp/
>  obj-y				+= amba/
>  # Many drivers will want to use DMA so this has to be made available
>  # really early.
> -obj-$(CONFIG_DMA_ENGINE)	+= dma/
> +obj-$(CONFIG_DMADEVICES)	+= dma/
>  
>  obj-$(CONFIG_VIRTIO)		+= virtio/
>  obj-$(CONFIG_XEN)		+= xen/
> diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
> index d4c1218..4e25f5a 100644
> --- a/drivers/dma/Kconfig
> +++ b/drivers/dma/Kconfig
> @@ -118,6 +118,15 @@ config FSL_DMA
>  	  The Elo is the DMA controller on some 82xx and 83xx parts, and the
>  	  Elo Plus is the DMA controller on 85xx and 86xx parts.
>  
> +config FSL_MCD_DMA
> +	bool "Freescale MultiChannel DMA (MCD) support"
> +	depends on PPC_MPC8220 || M54xx
> +	---help---
> +	  This enables generic support for the Freescale MultiChannel DMA (MCD)
> +	  available on MPC8220 and ColdFire 547x/548x family.
> +	  This driver is used by the specific dma driver for the target CPU.
> +	  Some drivers, especially the FEC DMA driver, need it.
> +
>  config MPC512X_DMA
>  	tristate "Freescale MPC512x built-in DMA engine support"
>  	depends on PPC_MPC512x || PPC_MPC831x
> diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
> index 7428fea..6b1e42d 100644
> --- a/drivers/dma/Makefile
> +++ b/drivers/dma/Makefile
> @@ -9,6 +9,7 @@ obj-$(CONFIG_DMATEST) += dmatest.o
>  obj-$(CONFIG_INTEL_IOATDMA) += ioat/
>  obj-$(CONFIG_INTEL_IOP_ADMA) += iop-adma.o
>  obj-$(CONFIG_FSL_DMA) += fsldma.o
> +obj-$(CONFIG_FSL_MCD_DMA) += fsl_mcd_dma/
>  obj-$(CONFIG_MPC512X_DMA) += mpc512x_dma.o
>  obj-$(CONFIG_MV_XOR) += mv_xor.o
>  obj-$(CONFIG_DW_DMAC) += dw_dmac.o
> diff --git a/drivers/dma/fsl_mcd_dma/MCD_dmaApi.c b/drivers/dma/fsl_mcd_dma/MCD_dmaApi.c
> new file mode 100644
> index 0000000..06606a0
> --- /dev/null
> +++ b/drivers/dma/fsl_mcd_dma/MCD_dmaApi.c
> @@ -0,0 +1,963 @@
> +/*
> + * drivers/dma/MCD_dmaApi.c
> + *
> + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
> + *     Kurt Mahan <kmahan@...escale.com>
> + * readl/writel conversion and other cleanup
> + * (C) Copyright 2010-2012 Philippe De Muyter <phdm@...qel.be> Macq SA
> + *
> + * 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/MCD_dma.h>
> +#include <linux/io.h>
> +#include "MCD_tasksInit.h"
> +
> +/********************************************************************/
> +/*
> + * This is an API-internal pointer to the DMA's registers
> + */
> +struct dmaRegs *MCD_dmaBar;
> +
> +/*
> + * MCD_realTaskTableSrc & MCD_modelTaskTableSrc get relocated to on-chip
> + * SRAM, at which point we access them as these tables
> + */
> +struct TaskTableEntry *MCD_taskTable;
> +struct TaskTableEntry *MCD_modelTaskTable;
> +
> +
> +/*
> + * MCD_chStatus[] is an array of status indicators for remembering
> + * whether a DMA has ever been attempted on each channel, pausing
> + * status, etc.
> + */
> +static int MCD_chStatus[NCHANNELS] = {
> +	MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
> +	MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
> +	MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
> +	MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA
> +};
> +
> +/*
> + * Prototypes for local functions
> + */
> +static void MCD_memcpy(int *dest, int *src, u32 size);
> +static void MCD_resmActions(int channel);
> +
> +/*
> + * Buffer descriptors used for storage of progress info for single Dmas
> + * Also used as storage for the DMA for CRCs for single DMAs
> + * Otherwise, the DMA does not parse these buffer descriptors
> + */
> +#ifndef MCD_INCLUDE_EU
> +struct MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
> +#endif
> +struct MCD_bufDesc *MCD_relocBuffDesc;
> +
> +
> +/*
> + * Defines for the debug control register's functions
> + */
> +#define DBG_CTL_COMP1_TASK  (0x00002000) /* have comparator 1 look for a task # */
> +#define DBG_CTL_ENABLE      (DBG_CTL_AUTO_ARM    | \
> +			     DBG_CTL_BREAK       | \
> +			     DBG_CTL_INT_BREAK   | \
> +			     DBG_CTL_COMP1_TASK)
> +#define DBG_CTL_DISABLE     (DBG_CTL_AUTO_ARM    | \
> +			     DBG_CTL_INT_BREAK   | \
> +			     DBG_CTL_COMP1_TASK)
> +#define DBG_KILL_ALL_STAT   (0xFFFFFFFF)
> +
> +/*
> + * Offset to context save area where progress info is stored
> + */
> +#define CSAVE_OFFSET        10
> +#define CURRBD ((CSAVE_OFFSET + 4) * 4)
> +#define DCOUNT ((CSAVE_OFFSET + 6) * 4)
> +#define DESTPTR ((CSAVE_OFFSET + 5) * 4)
> +#define SRCPTR ((CSAVE_OFFSET + 7) * 4)
> +
> +/*
> + * Defines for Byte Swapping
> + */
> +#define MCD_BYTE_SWAP_KILLER    0xFFF8888F
> +#define MCD_NO_BYTE_SWAP_ATALL  0x00040000
> +
> +/*
> + * Execution Unit Identifiers
> + */
> +#define MAC  0  /* legacy - not used */
> +#define LUAC 1  /* legacy - not used */
> +#define CRC  2  /* legacy - not used */
> +#define LURC 3  /* Logic Unit with CRC */
> +
> +/*
> + * Task Identifiers
> + */
> +#define TASK_CHAINNOEU  0
> +#define TASK_SINGLENOEU 1
> +#ifdef MCD_INCLUDE_EU
> +#define TASK_CHAINEU    2
> +#define TASK_SINGLEEU   3
> +#define TASK_FECRX      4
> +#define TASK_FECTX      5
> +#else
> +#define TASK_CHAINEU    0
> +#define TASK_SINGLEEU   1
> +#define TASK_FECRX      2
> +#define TASK_FECTX      3
> +#endif
> +
> +/*
> + * Structure to remember which variant is on which channel
> + */
> +struct MCD_remVariants {
> +	int remDestRsdIncr;  /* -1,0,1 */
> +	int remSrcRsdIncr;   /* -1,0,1 */
> +	s16 remDestIncr;     /* DestIncr */
> +	s16 remSrcIncr;      /* srcIncr */
> +	u32 remXferSize;     /* xferSize */
> +};
> +
> +/*
> + * Structure to remember the startDma parameters for each channel
> + */
> +struct MCD_remVariants MCD_remVariants[NCHANNELS];
> +
> +/********************************************************************/
> +/*
> + * Function: MCD_initDma
> + * Purpose:  Initializes the DMA API by setting up a pointer to the DMA
> + *           registers, relocating and creating the appropriate task
> + *           structures, and setting up some global settings
> + * Arguments:
> + *  dmaBarAddr    - pointer to the multichannel DMA registers
> + *  taskTableDest - location to move DMA task code and structs to
> + *  flags         - operational parameters
> + * Return Value:
> + *  MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned
> + *  MCD_OK otherwise
> + */
> +
> +int MCD_initDma(struct dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags)
> +{
> +	int i;
> +	struct TaskTableEntry *entryPtr, *tte;
> +	u16 control;
> +
> +	/* Setup the local pointer to register set */
> +	MCD_dmaBar = dmaBarAddr;
> +
> +	/* Do we need to move/create a task table */
> +	if ((flags & MCD_RELOC_TASKS) != 0) {
> +		int fixedSize;
> +		u32 *fixedPtr;
> +		int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
> +		int taskDescTabsOffset;
> +		int varTabsSize, funcDescTabsSize, contextSavesSize;
> +		int taskTableSize, taskDescTabSize;
> +
> +		int i;
> +
> +		/* Check if physical address is aligned on 512 byte boundary */
> +		if (((u32)taskTableDest & 0x000001ff) != 0)
> +			return MCD_TABLE_UNALIGNED;
> +
> +		/* set up local pointer to task Table */
> +		MCD_taskTable = taskTableDest;
> +
> +		/*
> +		 * Create a task table:
> +		 * - compute aligned base offsets for variable tables and
> +		 *   function descriptor tables, then
> +		 * - loop through the task table and setup the pointers
> +		 * - copy over model task table with the the actual task
> +		 *   descriptor tables
> +		 */
> +		taskTableSize = NCHANNELS * sizeof(struct TaskTableEntry);
> +		/* Align variable tables to size */
> +		varTabsOffset = taskTableSize + (u32)taskTableDest;
> +		varTabsOffset = ALIGN(varTabsOffset, VAR_TAB_SIZE);
> +		/* Align function descriptor tables */
> +		varTabsSize = NCHANNELS * VAR_TAB_SIZE;
> +		funcDescTabsOffset = varTabsOffset + varTabsSize;
> +		funcDescTabsOffset = ALIGN(funcDescTabsOffset, FUNCDESC_TAB_SIZE);
> +
> +		funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE;
> +		contextSavesOffset = funcDescTabsOffset + funcDescTabsSize;
> +		contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE);
> +		fixedSize = taskTableSize + varTabsSize + funcDescTabsSize +
> +			    contextSavesSize;
> +
> +		/* Zero the thing out */
> +		fixedPtr = (u32 *)taskTableDest;
> +		for (i = 0; i < (fixedSize/4); i++)
> +			fixedPtr[i] = 0;
> +
> +		entryPtr = (struct TaskTableEntry *)MCD_taskTable;
> +		/* Set up fixed pointers */
> +		for (i = 0; i < NCHANNELS; i++) {
> +			tte = &entryPtr[i];
> +			tte->varTab = (u32)varTabsOffset; /* update ptr to local value */
> +			tte->FDTandFlags = (u32)funcDescTabsOffset | MCD_TT_FLAGS_DEF;
> +			tte->contextSaveSpace = (u32)contextSavesOffset;
> +			varTabsOffset += VAR_TAB_SIZE;
> +#ifdef MCD_INCLUDE_EU /* if not there is only one, just point to the same one */
> +			funcDescTabsOffset += FUNCDESC_TAB_SIZE;
> +#endif
> +			contextSavesOffset += CONTEXT_SAVE_SIZE;
> +		}
> +		/* Copy over the function descriptor table */
> +		for (i = 0; i < FUNCDESC_TAB_NUM; i++) {
> +			tte = &entryPtr[i];
> +			MCD_memcpy((void *)(tte->FDTandFlags & ~MCD_TT_FLAGS_MASK),
> +				   (void *)MCD_funcDescTab0, FUNCDESC_TAB_SIZE);
> +		}
> +
> +		/* Copy model task table to where the context save stuff leaves off */
> +		MCD_modelTaskTable = (struct TaskTableEntry *)contextSavesOffset;
> +
> +		MCD_memcpy((void *)MCD_modelTaskTable, (void *)MCD_modelTaskTableSrc,
> +			    NUMOFVARIANTS * sizeof(struct TaskTableEntry));
> +
> +		/* Point to local version of model task table */
> +		entryPtr = MCD_modelTaskTable;
> +		taskDescTabsOffset = (u32)MCD_modelTaskTable +
> +				    (NUMOFVARIANTS * sizeof(struct TaskTableEntry));
> +
> +		/* Copy actual task code and update TDT ptrs in local model task table */
> +		for (i = 0; i < NUMOFVARIANTS; i++) {
> +			tte = &entryPtr[i];
> +			taskDescTabSize = tte->TDTend - tte->TDTstart + 4;
> +			MCD_memcpy((void *)taskDescTabsOffset, (void *)tte->TDTstart, taskDescTabSize);
> +			tte->TDTstart = (u32)taskDescTabsOffset;
> +			taskDescTabsOffset += taskDescTabSize;
> +			tte->TDTend = (u32)taskDescTabsOffset - 4;
> +		}
> +#ifdef MCD_INCLUDE_EU
> +		/*
> +		 * Tack single DMA BDs onto end of code so API controls where
> +		 * they are since DMA might write to them
> +		 */
> +		MCD_relocBuffDesc = (struct MCD_bufDesc *)(entryPtr[NUMOFVARIANTS - 1].TDTend + 4);
> +#else
> +		/*
> +		 * DMA does not touch them so they can be wherever and we don't
> +		 * need to waste SRAM on them
> +		 */
> +		MCD_relocBuffDesc = MCD_singleBufDescs;
> +#endif
> +	} else {
> +		/*
> +		 * Point the would-be relocated task tables and the buffer
> +		 * descriptors to the ones the linker generated
> +		 */
> +		if (((u32)MCD_realTaskTableSrc & 0x000001ff) != 0)
> +			return MCD_TABLE_UNALIGNED;
> +
> +		entryPtr = (struct TaskTableEntry *)MCD_realTaskTableSrc;
> +		for (i = 0; i < NCHANNELS; i++) {
> +			tte = &entryPtr[i];
> +			if (((tte->varTab & (VAR_TAB_SIZE - 1)) != 0) ||
> +			   ((tte->FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0))
> +				return MCD_TABLE_UNALIGNED;
> +		}
> +
> +		MCD_taskTable = (struct TaskTableEntry *)MCD_realTaskTableSrc;
> +		MCD_modelTaskTable = (struct TaskTableEntry *)MCD_modelTaskTableSrc;
> +		MCD_relocBuffDesc = MCD_singleBufDescs;
> +	}
> +
> +	/* Make all channels inactive, and remember them as such: */
> +	writel((u32) MCD_taskTable, &MCD_dmaBar->taskbar);
> +	for (i = 0;  i < NCHANNELS;  i++) {
> +		writew(0x0, &MCD_dmaBar->taskControl[i]);
> +		MCD_chStatus[i] = MCD_NO_DMA;
> +	}
> +
> +	/* Set up pausing mechanism to inactive state: */
> +	writel(0, &MCD_dmaBar->debugComp1);
> +	writel(0, &MCD_dmaBar->debugComp2);
> +	writel(DBG_CTL_DISABLE, &MCD_dmaBar->debugControl);
> +	writel(DBG_KILL_ALL_STAT, &MCD_dmaBar->debugStatus);
> +
> +	/* Enable or disable commbus prefetch */
> +	control = readw(&MCD_dmaBar->ptdControl);
> +	if ((flags & MCD_COMM_PREFETCH_EN) != 0)
> +		control &= ~PTD_CTL_COMM_PREFETCH;
> +	else
> +		control |= PTD_CTL_COMM_PREFETCH;
> +	writew(control, &MCD_dmaBar->ptdControl);
> +
> +	return MCD_OK;
> +}
> +/*********************** End of MCD_initDma() ***********************/
> +
> +/********************************************************************/
> +/* Function:   MCD_dmaStatus
> + * Purpose:    Returns the status of the DMA on the requested channel
> + * Arguments:  channel - channel number
> + * Returns:    Predefined status indicators
> + */
> +int MCD_dmaStatus(int channel)
> +{
> +	u16 tcrValue;
> +
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	if ((tcrValue & TASK_CTL_EN) == 0) {
> +		/* Nothing running if last reported with task enabled */
> +		if (MCD_chStatus[channel] == MCD_RUNNING
> +			|| MCD_chStatus[channel] == MCD_IDLE)
> +			MCD_chStatus[channel] = MCD_DONE;
> +		} else { /* something is running */
> +		/* There are three possibilities: paused, running or idle. */
> +		if (MCD_chStatus[channel] == MCD_RUNNING
> +		    || MCD_chStatus[channel] == MCD_IDLE) {
> +			writel(PTD_DBG_TSK_VLD_INIT, &MCD_dmaBar->ptdDebug);
> +			/* Determine which initiator is asserted. */
> +			if ((readl(&MCD_dmaBar->ptdDebug) >> channel) & 0x1)
> +				MCD_chStatus[channel] = MCD_RUNNING;
> +			else
> +				MCD_chStatus[channel] = MCD_IDLE;
> +			/* Do not change the status if it is already paused */
> +		}
> +	}
> +	return MCD_chStatus[channel];
> +}
> +/******************** End of MCD_dmaStatus() ************************/
> +
> +/********************************************************************/
> +/* Function:    MCD_startDma
> + * Ppurpose:    Starts a particular kind of DMA
> + * Arguments:   see below
> + * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
> + */
> +
> +int MCD_startDma(
> +	const int  channel,   /* the channel on which to run the DMA */
> +	s8   *srcAddr,  /* the address to move data from, or physical buffer-descriptor address */
> +	s16  srcIncr,   /* the amount to increment the source address per transfer */
> +	s8   *destAddr, /* the address to move data to */
> +	s16  destIncr,  /* the amount to increment the destination address per transfer */
> +	u32  dmaSize,   /* the number of bytes to transfer independent of the transfer size */
> +	u32  xferSize,  /* the number bytes in of each data movement (1, 2, or 4) */
> +	u32  initiator, /* what device initiates the DMA */
> +	int  priority,  /* priority of the DMA */
> +	u32  flags,     /* flags describing the DMA */
> +	u32  funcDesc   /* a description of byte swapping, bit swapping, and CRC actions */
> +#ifdef MCD_NEED_ADDR_TRANS
> +	s8   *srcAddrVirt /* virtual buffer descriptor address TBD */
> +#endif
> +)
> +{
> +	int srcRsdIncr, destRsdIncr;
> +	int *cSave;
> +	short xferSizeIncr;
> +	int tcrCount = 0;
> +#ifdef MCD_INCLUDE_EU
> +	u32 *realFuncArray;
> +#endif
> +	u16 control;
> +	struct MCD_remVariants *var;
> +	struct TaskTableEntry *tte;
> +	u32 css;
> +	struct TaskTableEntry *mmte;
> +
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +#ifndef MCD_INCLUDE_EU
> +	funcDesc = MCD_FUNC_NOEU1;
> +#endif
> +
> +#ifdef MCD_DEBUG
> +printf("startDma:Setting up params\n");
> +#endif
> +
> +	/* Enable task-wise priority */
> +	control = readl(&MCD_dmaBar->ptdControl);
> +	writel(control | 0x8000, &MCD_dmaBar->ptdControl);
> +
> +	/* Calculate additional parameters to the regular DMA calls. */
> +	srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0);
> +	destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0);
> +	xferSizeIncr = (xferSize & 0xffff) | 0x20000000;
> +
> +	/* Remember which variant is running for each channel */
> +	var = &MCD_remVariants[channel];
> +	var->remSrcRsdIncr = srcRsdIncr;
> +	var->remDestRsdIncr = destRsdIncr;
> +	var->remDestIncr = destIncr;
> +	var->remSrcIncr = srcIncr;
> +	var->remXferSize = xferSize;
> +
> +	tte = &MCD_taskTable[channel];
> +
> +	cSave = (int *)(tte->contextSaveSpace + CURRBD);
> +
> +#ifdef MCD_INCLUDE_EU
> +	realFuncArray = (u32 *) (tte->FDTandFlags & 0xffffff00);
> +
> +	/*
> +	* Modify the LURC's normal and byte-residue-loop functions
> +	* according to parameter.
> +	*/
> +	switch (xferSize) {
> +	case 4:
> +		realFuncArray[(LURC*16)] = funcDesc;
> +		break;
> +	case 2:
> +		realFuncArray[(LURC*16)] = funcDesc & 0xfffff00f;
> +		break;
> +	case 1:
> +	default:
> +		realFuncArray[(LURC*16)] = funcDesc & 0xffff000f;
> +		break;
> +	}
> +
> +	realFuncArray[(LURC*16+1)] = 0
> +		| (funcDesc & MCD_BYTE_SWAP_KILLER)
> +		| MCD_NO_BYTE_SWAP_ATALL;
> +#endif
> +
> +	/* Write the initiator field in the TCR and set the initiator-hold bit */
> +	writew(0
> +		| (initiator << 8)
> +		| TASK_CTL_HIPRITSKEN
> +		| TASK_CTL_HLDINITNUM,
> +		&MCD_dmaBar->taskControl[channel]);
> +
> +	/*
> +	 * Current versions of the MPC8220 MCD have a hardware quirk that could
> +	 * cause the write to the TCR to collide with an MDE access to the
> +	 * initiator-register file, so we have to verify that the write occurred
> +	 * correctly by reading back the value.  On MCF547x/8x devices and any
> +	 * future revisions of the MPC8220, this loop will not be entered.
> +	 */
> +	while (((readw(&MCD_dmaBar->taskControl[channel]) & 0x1fff) !=
> +	  ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) &&
> +	    (tcrCount < 1000)) {
> +		tcrCount++;
> +		writew(0
> +		    | (initiator << 8)
> +		    | TASK_CTL_HIPRITSKEN
> +		    | TASK_CTL_HLDINITNUM,
> +			&MCD_dmaBar->taskControl[channel]);
> +	}
> +
> +	writeb(priority & PRIORITY_PRI_MASK, &MCD_dmaBar->priority[channel]);
> +
> +	if (channel < 8 && channel >= 0) {
> +		u32 tasksize = readl(&MCD_dmaBar->taskSize0);
> +		int shift = (7 - channel) * 4;
> +		u32 xfermask;
> +
> +		tasksize &= ~(0xf << shift);
> +		xfermask = xferSize & 3;
> +		xfermask |= xfermask << 2;
> +		tasksize |= xfermask << shift;
> +		writel(tasksize, &MCD_dmaBar->taskSize0);
> +	} else {
> +		u32 tasksize = readl(&MCD_dmaBar->taskSize1);
> +		int shift = (15 - channel) * 4;
> +		u32 xfermask;
> +
> +		tasksize &= ~(0xf << shift);
> +		xfermask = xferSize & 3;
> +		xfermask |= xfermask << 2;
> +		tasksize |= xfermask << shift;
> +		writel(tasksize, &MCD_dmaBar->taskSize1);
> +	}
> +
> +	/* Setup task table flags/options */
> +	tte->FDTandFlags &= ~MCD_TT_FLAGS_MASK;
> +	tte->FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
> +
> +	if (flags & MCD_FECTX_DMA) {
> +		/* TDTStart and TDTEnd */
> +		mmte = &MCD_modelTaskTable[TASK_FECTX];
> +		tte->TDTstart = mmte->TDTstart;
> +		tte->TDTend = mmte->TDTend;
> +		MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable,
> +				     channel);
> +	} else if (flags & MCD_FECRX_DMA) {
> +		/* TDTStart and TDTEnd */
> +		mmte = &MCD_modelTaskTable[TASK_FECRX];
> +		tte->TDTstart = mmte->TDTstart;
> +		tte->TDTend = mmte->TDTend;
> +		MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable,
> +				    channel);
> +	} else if (flags & MCD_SINGLE_DMA) {
> +		struct MCD_bufDesc *mrbd;
> +
> +		/*
> +		 * This buffer descriptor is used for storing off initial
> +		 * parameters * for later progress query calculation and for
> +		 * the DMA to write the resulting checksum. The DMA does not
> +		 * use this to determine how to * operate, that info is passed
> +		 * with the init routine
> +		 */
> +		mrbd = &MCD_relocBuffDesc[channel];
> +		mrbd->srcAddr = srcAddr;
> +		mrbd->destAddr = destAddr;
> +		mrbd->lastDestAddr = destAddr;
> +		mrbd->dmaSize = dmaSize;
> +		mrbd->flags = 0;       /* not used */
> +		mrbd->csumResult = 0;  /* not used */
> +		mrbd->next = 0;        /* not used */
> +
> +		/* Initialize the progress-querying stuff to show no progress:*/
> +		css = tte->contextSaveSpace;
> +		writel((int)srcAddr, css + SRCPTR);
> +		writel((int)destAddr, css + DESTPTR);
> +		writel(0, css + DCOUNT);
> +		writel((u32)mrbd, css + CURRBD);
> +
> +		if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) {
> +			/* TDTStart and TDTEnd */
> +			mmte = &MCD_modelTaskTable[TASK_SINGLENOEU];
> +			tte->TDTstart = mmte->TDTstart;
> +			tte->TDTend = mmte->TDTend;
> +			MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr,
> +					destIncr, dmaSize,
> +					xferSizeIncr, flags, (int *)mrbd,
> +					cSave, MCD_taskTable, channel);
> +		} else {
> +			/* TDTStart and TDTEnd */
> +			mmte = &MCD_modelTaskTable[TASK_SINGLEEU];
> +			tte->TDTstart = mmte->TDTstart;
> +			tte->TDTend = mmte->TDTend;
> +			MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr,
> +					destIncr, dmaSize,
> +					xferSizeIncr, flags, (int *)mrbd,
> +					cSave, MCD_taskTable, channel);
> +		}
> +	} else /* Chained DMA */ {
> +		struct MCD_bufDesc *mbd;
> +
> +		/* Initialize the progress-querying stuff to show no progress:*/
> +#if 1 /* (!defined(MCD_NEED_ADDR_TRANS)) */
> +		mbd = (struct MCD_bufDesc *) srcAddr;
> +#else /* if using address translation, need the virtual addr of the first buffdesc */
> +		mbd = (struct MCD_bufDesc *) srcAddrVirt;
> +#endif
> +		css = tte->contextSaveSpace;
> +		writel((int)mbd->srcAddr, css + SRCPTR);
> +		writel((int)mbd->destAddr, css + DESTPTR);
> +		writel(0, css + DCOUNT);
> +		writel((u32)srcAddr, css + CURRBD);
> +
> +		if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) {
> +			/* TDTStart and TDTEnd */
> +			mmte = &MCD_modelTaskTable[TASK_CHAINNOEU];
> +			tte->TDTstart = mmte->TDTstart;
> +			tte->TDTend = mmte->TDTend;
> +			MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr,
> +					      xferSize, xferSizeIncr, cSave,
> +					      MCD_taskTable, channel);
> +		} else {
> +			/* TDTStart and TDTEnd */
> +			mmte = &MCD_modelTaskTable[TASK_CHAINEU];
> +			tte->TDTstart = mmte->TDTstart;
> +			tte->TDTend = mmte->TDTend;
> +			MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr,
> +					    xferSize, xferSizeIncr, cSave,
> +					    MCD_taskTable, channel);
> +		}
> +	}
> +
> +	MCD_chStatus[channel] = MCD_IDLE;
> +	return MCD_OK;
> +}
> +
> +/************************ End of MCD_startDma() *********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_XferProgrQuery
> + * Purpose:     Returns progress of DMA on requested channel
> + * Arguments:   channel - channel to retrieve progress for
> + *              progRep - pointer to user supplied MCD_XferProg struct
> + * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
> + *
> + * Notes:
> + *  MCD_XferProgrQuery() upon completing or after aborting a DMA, or
> + *  while the DMA is in progress, this function returns the first
> + *  DMA-destination address not (or not yet) used in the DMA. When
> + *  encountering a non-ready buffer descriptor, the information for
> + *  the last completed descriptor is returned.
> + *
> + *  MCD_XferProgQuery() has to avoid the possibility of getting
> + *  partially-updated information in the event that we should happen
> + *  to query DMA progress just as the DMA is updating it. It does that
> + *  by taking advantage of the fact context is not saved frequently for
> + *  the most part. We therefore read it at least twice until we get the
> + *  same information twice in a row.
> + *
> + *  Because a small, but not insignificant, amount of time is required
> + *  to write out the progress-query information, especially upon
> + *  completion of the DMA, it would be wise to guarantee some time lag
> + *  between successive readings of the progress-query information.
> + */
> +
> +/*
> + * How many iterations of the loop below to execute to stabilize values
> + */
> +#define STABTIME 0
> +
> +int MCD_XferProgrQuery(const int channel, struct MCD_XferProg *progRep)
> +{
> +	struct MCD_XferProg prevRep;
> +	int again;  /* true if we are to try again to get consistent results */
> +	int i;  /* used as a time-waste counter */
> +	int destDiffBytes; /* Total number of bytes that we think actually got xfered. */
> +	int numIterations; /* number of iterations */
> +	int bytesNotXfered; /* bytes that did not get xfered. */
> +	s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr;
> +	int subModVal, addModVal; /* Mode values to added and subtracted from
> +				     the final destAddr */
> +	struct TaskTableEntry *tte;
> +	u32 css;
> +	struct MCD_remVariants *var;
> +
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	tte = &MCD_taskTable[channel];
> +	css = tte->contextSaveSpace;
> +
> +	/* Read a trial value for the progress-reporting values */
> +	prevRep.lastSrcAddr = (s8 *)readl(css + SRCPTR);
> +	prevRep.lastDestAddr = (s8 *)readl(css + DESTPTR);
> +	prevRep.dmaSize = readl(css + DCOUNT);
> +	prevRep.currBufDesc = (struct MCD_bufDesc *)readl(css + CURRBD);
> +
> +	/* Repeatedly reread those values until they match previous values: */
> +	do {
> +		/* Take a little bit of time to ensure stability: */
> +		for (i = 0;  i < STABTIME;  i++)
> +			i += i >> 2;  /* make sure this loop does something so
> +					 that it doesn't get optimized out */
> +		/* Check them again: */
> +		progRep->lastSrcAddr = (s8 *)readl(css + SRCPTR);
> +		progRep->lastDestAddr = (s8 *)readl(css + DESTPTR);
> +		progRep->dmaSize = readl(css + DCOUNT);
> +		progRep->currBufDesc = (struct MCD_bufDesc *)readl(css + CURRBD);
> +
> +		/* See if they match: */
> +		if (prevRep.lastSrcAddr  != progRep->lastSrcAddr
> +		    || prevRep.lastDestAddr != progRep->lastDestAddr
> +		    || prevRep.dmaSize      != progRep->dmaSize
> +		    || prevRep.currBufDesc  != progRep->currBufDesc) {
> +			/* If they don't match, remember previous values and try again:*/
> +			prevRep.lastSrcAddr = progRep->lastSrcAddr;
> +			prevRep.lastDestAddr = progRep->lastDestAddr;
> +			prevRep.dmaSize = progRep->dmaSize;
> +			prevRep.currBufDesc = progRep->currBufDesc;
> +			again = MCD_TRUE;
> +		} else
> +			again = MCD_FALSE;
> +	} while (again == MCD_TRUE);
> +
> +
> +	/* Update dmaSize and lastDestAddr */
> +	var = &MCD_remVariants[channel];
> +	switch (var->remDestRsdIncr) {
> +	case MINUS1:
> +		subModVal = ((int)progRep->lastDestAddr)
> +			    & ((var->remXferSize) - 1);
> +		addModVal = ((int)progRep->currBufDesc->destAddr)
> +			    & ((var->remXferSize) - 1);
> +		LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal;
> +		LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal;
> +		destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr;
> +		bytesNotXfered = (destDiffBytes/var->remDestIncr) *
> +				(var->remDestIncr + var->remXferSize);
> +		progRep->dmaSize = destDiffBytes - bytesNotXfered + addModVal - subModVal;
> +		break;
> +	case ZERO:
> +		progRep->lastDestAddr = progRep->currBufDesc->destAddr;
> +		break;
> +	case PLUS1:
> +		/* This value has to be subtracted from the final calculated dmaSize. */
> +		subModVal = ((int)progRep->currBufDesc->destAddr)
> +			    & ((var->remXferSize) - 1);
> +		/* These bytes are already in lastDestAddr. */
> +		addModVal = ((int)progRep->lastDestAddr)
> +			    & ((var->remXferSize) - 1);
> +		LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal;
> +		LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
> +		destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
> +		numIterations = (LWAlignedCurrDestAddr - LWAlignedInitDestAddr)/var->remDestIncr;
> +		bytesNotXfered =  numIterations *
> +				  (var->remDestIncr - var->remXferSize);
> +		progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
> +		break;
> +	default:
> +		break;
> +	}
> +
> +	/* This covers M1,P1,Z for source */
> +	switch (var->remSrcRsdIncr) {
> +	case MINUS1:
> +		progRep->lastSrcAddr = progRep->currBufDesc->srcAddr +
> +		     (var->remSrcIncr * (progRep->dmaSize/var->remXferSize));
> +		break;
> +	case ZERO:
> +		progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
> +		break;
> +	case PLUS1:
> +		progRep->lastSrcAddr = progRep->currBufDesc->srcAddr +
> +		     (var->remSrcIncr * (progRep->dmaSize/var->remXferSize));
> +		break;
> +	default:
> +		break;
> +	}
> +
> +	return MCD_OK;
> +}
> +/******************* End of MCD_XferProgrQuery() ********************/
> +
> +/********************************************************************/
> +/* MCD_resmActions() does the majority of the actions of a DMA resume.
> + * It is called from MCD_killDma() and MCD_resumeDma().  It has to be
> + * a separate function because the kill function has to negate the task
> + * enable before resuming it, but the resume function has to do nothing
> + * if there is no DMA on that channel (i.e., if the enable bit is 0).
> + */
> +static void MCD_resmActions(int channel)
> +{
> +	u32 status;
> +
> +	writel(DBG_CTL_DISABLE, &MCD_dmaBar->debugControl);
> +	status = readl(&MCD_dmaBar->debugStatus);
> +	writel(status, &MCD_dmaBar->debugStatus);
> +
> +	/* Determine which initiators are asserted */
> +	writel(PTD_DBG_TSK_VLD_INIT, &MCD_dmaBar->ptdDebug);
> +
> +	if ((readl(&MCD_dmaBar->ptdDebug) >> channel) & 0x1)
> +		MCD_chStatus[channel] = MCD_RUNNING;
> +	else
> +		MCD_chStatus[channel] = MCD_IDLE;
> +}
> +/********************* End of MCD_resmActions() *********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_killDma
> + * Purpose:     Halt the DMA on the requested channel, without any
> + *              intention of resuming the DMA.
> + * Arguments:   channel - requested channel
> + * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
> + *
> + * Notes:
> + *  A DMA may be killed from any state, including paused state, and it
> + *  always goes to the MCD_HALTED state even if it is killed while in
> + *  the MCD_NO_DMA or MCD_IDLE states.
> + */
> +int MCD_killDma(int channel)
> +{
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	writew(0x0, &MCD_dmaBar->taskControl[channel]);
> +
> +	/* Clean up after a paused task */
> +	if (MCD_chStatus[channel] == MCD_PAUSED) {
> +		u32 status;
> +
> +		writel(DBG_CTL_DISABLE, &MCD_dmaBar->debugControl);
> +		status = readl(&MCD_dmaBar->debugStatus);
> +		writel(status, &MCD_dmaBar->debugStatus);
> +	}
> +
> +	MCD_chStatus[channel] = MCD_HALTED;
> +
> +	return MCD_OK;
> +}
> +/************************ End of MCD_killDma() **********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_continDma
> + * Purpose:     Continue a DMA which as stopped due to encountering an
> + *              unready buffer descriptor.
> + * Arguments:   channel - channel to continue the DMA on
> + * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
> + *
> + * Notes:
> + *  This routine does not check to see if there is a task which can
> + *  be continued. Also this routine should not be used with single DMAs.
> + */
> +int MCD_continDma(int channel)
> +{
> +	u16 tcrValue;
> +
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | TASK_CTL_EN, &MCD_dmaBar->taskControl[channel]);
> +	MCD_chStatus[channel] = MCD_RUNNING;
> +
> +	return MCD_OK;
> +}
> +/********************** End of MCD_continDma() **********************/
> +
> +/*********************************************************************
> + * MCD_pauseDma() and MCD_resumeDma() below use the DMA's debug unit
> + * to freeze a task and resume it.  We freeze a task by breakpointing
> + * on the stated task.  That is, not any specific place in the task,
> + * but any time that task executes.  In particular, when that task
> + * executes, we want to freeze that task and only that task.
> + *
> + * The bits of the debug control register influence interrupts vs.
> + * breakpoints as follows:
> + * - Bits 14 and 0 enable or disable debug functions.  If enabled, you
> + *   will get the interrupt but you may or may not get a breakpoint.
> + * - Bits 2 and 1 decide whether you also get a breakpoint in addition
> + *   to an interrupt.
> + *
> + * The debug unit can do these actions in response to either internally
> + * detected breakpoint conditions from the comparators, or in response
> + * to the external breakpoint pin, or both.
> + * - Bits 14 and 1 perform the above-described functions for
> + *   internally-generated conditions, i.e., the debug comparators.
> + * - Bits 0 and 2 perform the above-described functions for external
> + *   conditions, i.e., the breakpoint external pin.
> + *
> + * Note that, although you "always" get the interrupt when you turn
> + * the debug functions, the interrupt can nevertheless, if desired, be
> + * masked by the corresponding bit in the PTD's IMR. Note also that
> + * this means that bits 14 and 0 must enable debug functions before
> + * bits 1 and 2, respectively, have any effect.
> + *
> + * NOTE: It's extremely important to not pause more than one DMA channel
> + *  at a time.
> + ********************************************************************/
> +
> +/********************************************************************/
> +/* Function:    MCD_pauseDma
> + * Purpose:     Pauses the DMA on a given channel (if any DMA is running
> + *              on that channel).
> + * Arguments:   channel
> + * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
> + */
> +int MCD_pauseDma(int channel)
> +{
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	if (readw(&MCD_dmaBar->taskControl[channel]) & TASK_CTL_EN) {
> +		writel(channel, &MCD_dmaBar->debugComp1);
> +		writel(DBG_CTL_ENABLE | (1 << (channel + 16)),
> +		       &MCD_dmaBar->debugControl);
> +		MCD_chStatus[channel] = MCD_PAUSED;
> +	}
> +	return MCD_OK;
> +}
> +/************************* End of MCD_pauseDma() ********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_resumeDma
> + * Purpose:     Resumes the DMA on a given channel (if any DMA is
> + *              running on that channel).
> + * Arguments:   channel - channel on which to resume DMA
> + * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
> + */
> +int MCD_resumeDma(int channel)
> +{
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	if (readw(&MCD_dmaBar->taskControl[channel]) & TASK_CTL_EN)
> +		MCD_resmActions(channel);
> +
> +	return MCD_OK;
> +}
> +/************************ End of MCD_resumeDma() ********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_csumQuery
> + * Purpose:     Provide the checksum after performing a non-chained DMA
> + * Arguments:   channel - channel to report on
> + *              csum - pointer to where to write the checksum/CRC
> + * Returns:     MCD_ERROR if the channel is invalid, else MCD_OK
> + *
> + * Notes:
> + *
> + */
> +int MCD_csumQuery(int channel, u32 *csum)
> +{
> +#ifdef MCD_INCLUDE_EU
> +	if ((channel < 0) || (channel >= NCHANNELS))
> +		return MCD_CHANNEL_INVALID;
> +
> +	*csum = MCD_relocBuffDesc[channel].csumResult;
> +	return MCD_OK;
> +#else
> +	return MCD_ERROR;
> +#endif
> +}
> +/*********************** End of MCD_resumeDma() *********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_getCodeSize
> + * Purpose:     Provide the size requirements of the microcoded tasks
> + * Returns:     Size in bytes
> + */
> +int MCD_getCodeSize(void)
> +{
> +#ifdef MCD_INCLUDE_EU
> +	return 0x2b64;
> +#else
> +	return 0x1744;
> +#endif
> +}
> +/********************** End of MCD_getCodeSize() ********************/
> +
> +/********************************************************************/
> +/* Function:    MCD_getVersion
> + * Purpose:     Provide the version string and number
> + * Arguments:   longVersion - user supplied pointer to a pointer to a char
> + *                    which points to the version string
> + * Returns:     Version number and version string (by reference)
> + */
> +char MCD_versionString[] = "Multi-channel DMA API v1.0";
> +#define MCD_REV_MAJOR   0x01
> +#define MCD_REV_MINOR   0x00
> +
> +int MCD_getVersion(char **longVersion)
> +{
> +	*longVersion = MCD_versionString;
> +	return (MCD_REV_MAJOR << 8) | MCD_REV_MINOR;
> +}
> +/********************** End of MCD_getVersion() *********************/
> +
> +/********************************************************************/
> +/* Private version of memcpy()
> + * Note that everything this is used for is longword-aligned.
> + */
> +static void MCD_memcpy(int *dest, int *src, u32 size)
> +{
> +	u32 i;
> +
> +	for (i = 0;  i < size;  i += sizeof(int), dest++, src++)
> +		*dest = *src;
> +}
> +/********************************************************************/
> diff --git a/drivers/dma/fsl_mcd_dma/MCD_tasks.c b/drivers/dma/fsl_mcd_dma/MCD_tasks.c
> new file mode 100644
> index 0000000..677ed9b
> --- /dev/null
> +++ b/drivers/dma/fsl_mcd_dma/MCD_tasks.c
> @@ -0,0 +1,2425 @@
> +/*
> + * drivers/dma/MCD_tasks.c
> + *
> + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
> + *     Kurt Mahan <kmahan@...escale.com>
> + *
> + * 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/MCD_dma.h>
> +
> +u32 MCD_varTab0[];
> +u32 MCD_varTab1[];
> +u32 MCD_varTab2[];
> +u32 MCD_varTab3[];
> +u32 MCD_varTab4[];
> +u32 MCD_varTab5[];
> +u32 MCD_varTab6[];
> +u32 MCD_varTab7[];
> +u32 MCD_varTab8[];
> +u32 MCD_varTab9[];
> +u32 MCD_varTab10[];
> +u32 MCD_varTab11[];
> +u32 MCD_varTab12[];
> +u32 MCD_varTab13[];
> +u32 MCD_varTab14[];
> +u32 MCD_varTab15[];
> +
> +u32 MCD_funcDescTab0[];
> +#ifdef MCD_INCLUDE_EU
> +u32 MCD_funcDescTab1[];
> +u32 MCD_funcDescTab2[];
> +u32 MCD_funcDescTab3[];
> +u32 MCD_funcDescTab4[];
> +u32 MCD_funcDescTab5[];
> +u32 MCD_funcDescTab6[];
> +u32 MCD_funcDescTab7[];
> +u32 MCD_funcDescTab8[];
> +u32 MCD_funcDescTab9[];
> +u32 MCD_funcDescTab10[];
> +u32 MCD_funcDescTab11[];
> +u32 MCD_funcDescTab12[];
> +u32 MCD_funcDescTab13[];
> +u32 MCD_funcDescTab14[];
> +u32 MCD_funcDescTab15[];
> +#endif
> +
> +u32 MCD_contextSave0[];
> +u32 MCD_contextSave1[];
> +u32 MCD_contextSave2[];
> +u32 MCD_contextSave3[];
> +u32 MCD_contextSave4[];
> +u32 MCD_contextSave5[];
> +u32 MCD_contextSave6[];
> +u32 MCD_contextSave7[];
> +u32 MCD_contextSave8[];
> +u32 MCD_contextSave9[];
> +u32 MCD_contextSave10[];
> +u32 MCD_contextSave11[];
> +u32 MCD_contextSave12[];
> +u32 MCD_contextSave13[];
> +u32 MCD_contextSave14[];
> +u32 MCD_contextSave15[];
> +
> +const u32 MCD_realTaskTableSrc[] = {
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab0,   /* Task 0 Variable Table */
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave0,  /* Task 0 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab1,   /* Task 1 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab1,  /* Task 1 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave1,  /* Task 1 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab2,   /* Task 2 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab2,  /* Task 2 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave2,  /* Task 2 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab3,   /* Task 3 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab3,  /* Task 3 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave3,  /* Task 3 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab4,   /* Task 4 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab4,  /* Task 4 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave4,  /* Task 4 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab5,   /* Task 5 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab5,  /* Task 5 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave5,  /* Task 5 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab6,   /* Task 6 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab6,  /* Task 6 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave6,  /* Task 6 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab7,   /* Task 7 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab7,  /* Task 7 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave7,  /* Task 7 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab8,   /* Task 8 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab8,  /* Task 8 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave8,  /* Task 8 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab9,   /* Task 9 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab9,  /* Task 9 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave9,  /* Task 9 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab10,  /* Task 10 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab10, /* Task 10 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave10, /* Task 10 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab11,  /* Task 11 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab11, /* Task 11 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave11, /* Task 11 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab12,  /* Task 12 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab12, /* Task 12 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave12, /* Task 12 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab13,  /* Task 13 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab13, /* Task 13 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave13, /* Task 13 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab14,  /* Task 14 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab14, /* Task 14 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave14, /* Task 14 context save space */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_varTab15,  /* Task 15 Variable Table */
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_funcDescTab15, /* Task 15 Function Descriptor Table & Flags */
> +#else
> +	(u32)MCD_funcDescTab0,  /* Task 0 Function Descriptor Table & Flags */
> +#endif
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_contextSave15, /* Task 15 context save space */
> +	0x00000000,
> +};
> +
> +
> +u32 MCD_varTab0[] = {   /* Task 0 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +
> +u32 MCD_varTab1[] = {   /* Task 1 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab2[] = {   /* Task 2 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab3[] = {   /* Task 3 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab4[] = {   /* Task 4 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab5[] = {   /* Task 5 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab6[] = {   /* Task 6 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab7[] = {   /* Task 7 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab8[] = {   /* Task 8 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab9[] = {   /* Task 9 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab10[] = {   /* Task 10 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab11[] = {   /* Task 11 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab12[] = {   /* Task 12 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab13[] = {   /* Task 13 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab14[] = {   /* Task 14 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_varTab15[] = {   /* Task 15 Variable Table */
> +	0x00000000, /* var[0] */
> +	0x00000000, /* var[1] */
> +	0x00000000, /* var[2] */
> +	0x00000000, /* var[3] */
> +	0x00000000, /* var[4] */
> +	0x00000000, /* var[5] */
> +	0x00000000, /* var[6] */
> +	0x00000000, /* var[7] */
> +	0x00000000, /* var[8] */
> +	0x00000000, /* var[9] */
> +	0x00000000, /* var[10] */
> +	0x00000000, /* var[11] */
> +	0x00000000, /* var[12] */
> +	0x00000000, /* var[13] */
> +	0x00000000, /* var[14] */
> +	0x00000000, /* var[15] */
> +	0x00000000, /* var[16] */
> +	0x00000000, /* var[17] */
> +	0x00000000, /* var[18] */
> +	0x00000000, /* var[19] */
> +	0x00000000, /* var[20] */
> +	0x00000000, /* var[21] */
> +	0x00000000, /* var[22] */
> +	0x00000000, /* var[23] */
> +	0xe0000000, /* inc[0] */
> +	0x20000000, /* inc[1] */
> +	0x2000ffff, /* inc[2] */
> +	0x00000000, /* inc[3] */
> +	0x00000000, /* inc[4] */
> +	0x00000000, /* inc[5] */
> +	0x00000000, /* inc[6] */
> +	0x00000000, /* inc[7] */
> +};
> +
> +u32 MCD_funcDescTab0[] = {   /* Task 0 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +#ifdef MCD_INCLUDE_EU
> +u32 MCD_funcDescTab1[] = {   /* Task 1 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab2[] = {   /* Task 2 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab3[] = {   /* Task 3 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab4[] = {   /* Task 4 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab5[] = {   /* Task 5 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab6[] = {   /* Task 6 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab7[] = {   /* Task 7 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab8[] = {   /* Task 8 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab9[] = {   /* Task 9 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab10[] = {   /* Task 10 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab11[] = {   /* Task 11 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab12[] = {   /* Task 12 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab13[] = {   /* Task 13 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab14[] = {   /* Task 14 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +
> +u32 MCD_funcDescTab15[] = {   /* Task 15 Function Descriptor Table */
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0xa0045670, /* mainFunc(), EU# 3 */
> +	0xa0000000, /* rsduFunc(), EU# 3 */
> +	0xa0000000, /* crcAccumVal(), EU# 3 */
> +	0x20000000, /* setCrcAccum(), EU# 3 */
> +	0x21800000, /* and(), EU# 3 */
> +	0x21e00000, /* or(), EU# 3 */
> +	0x20400000, /* add(), EU# 3 */
> +	0x20500000, /* sub(), EU# 3 */
> +	0x205a0000, /* andNot(), EU# 3 */
> +	0x20a00000, /* shiftR(), EU# 3 */
> +	0x202fa000, /* andReadyBit(), EU# 3 */
> +	0x202f9000, /* andNotReadyBit(), EU# 3 */
> +	0x202ea000, /* andWrapBit(), EU# 3 */
> +	0x202da000, /* andLastBit(), EU# 3 */
> +	0x202e2000, /* andInterruptBit(), EU# 3 */
> +	0x202f2000, /* andCrcRestartBit(), EU# 3 */
> +};
> +#endif /*MCD_INCLUDE_EU*/
> +
> +u32 MCD_contextSave0[128];  /* Task 0 context save space */
> +u32 MCD_contextSave1[128];  /* Task 1 context save space */
> +u32 MCD_contextSave2[128];  /* Task 2 context save space */
> +u32 MCD_contextSave3[128];  /* Task 3 context save space */
> +u32 MCD_contextSave4[128];  /* Task 4 context save space */
> +u32 MCD_contextSave5[128];  /* Task 5 context save space */
> +u32 MCD_contextSave6[128];  /* Task 6 context save space */
> +u32 MCD_contextSave7[128];  /* Task 7 context save space */
> +u32 MCD_contextSave8[128];  /* Task 8 context save space */
> +u32 MCD_contextSave9[128];  /* Task 9 context save space */
> +u32 MCD_contextSave10[128]; /* Task 10 context save space */
> +u32 MCD_contextSave11[128]; /* Task 11 context save space */
> +u32 MCD_contextSave12[128]; /* Task 12 context save space */
> +u32 MCD_contextSave13[128]; /* Task 13 context save space */
> +u32 MCD_contextSave14[128]; /* Task 14 context save space */
> +u32 MCD_contextSave15[128]; /* Task 15 context save space */
> +
> +u32 MCD_ChainNoEu_TDT[];
> +u32 MCD_SingleNoEu_TDT[];
> +#ifdef MCD_INCLUDE_EU
> +u32 MCD_ChainEu_TDT[];
> +u32 MCD_SingleEu_TDT[];
> +#endif
> +u32 MCD_ENetRcv_TDT[];
> +u32 MCD_ENetXmit_TDT[];
> +
> +const u32 MCD_modelTaskTableSrc[] = {
> +	(u32)MCD_ChainNoEu_TDT,
> +	(u32)&((u8 *)MCD_ChainNoEu_TDT)[0x0000016c],
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_SingleNoEu_TDT,
> +	(u32)&((u8 *)MCD_SingleNoEu_TDT)[0x000000d4],
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +#ifdef MCD_INCLUDE_EU
> +	(u32)MCD_ChainEu_TDT,
> +	(u32)&((u8 *)MCD_ChainEu_TDT)[0x000001b4],
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_SingleEu_TDT,
> +	(u32)&((u8 *)MCD_SingleEu_TDT)[0x00000124],
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +#endif
> +	(u32)MCD_ENetRcv_TDT,
> +	(u32)&((u8 *)MCD_ENetRcv_TDT)[0x000000a4],
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	(u32)MCD_ENetXmit_TDT,
> +	(u32)&((u8 *)MCD_ENetXmit_TDT)[0x000000d0],
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +	0x00000000,
> +};
> +u32 MCD_ChainNoEu_TDT[] = {
> +	0x80004000, /* 0000(:370):  LCDEXT: idx0 = 0x00000000; ; */
> +	0x8118801b, /* 0004(:370):  LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
> +	0xb8c60018, /* 0008(:371):    LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */
> +	0x10002b10, /* 000C(:372):      DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x7000000d, /* 0010(:373):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x018cf89f, /* 0014(:373):      DRD2B1: var6 = EU3(); EU3(idx2)  */
> +	0x6000000a, /* 0018(:374):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
> +	0x080cf89f, /* 001C(:374):      DRD2B1: idx0 = EU3(); EU3(idx2)  */
> +	0x000001f8, /* 0020(:0):    NOP */
> +	0x98180364, /* 0024(:378):  LCD: idx0 = idx0; idx0 == var13; idx0 += inc4 */
> +	0x8118801b, /* 0028(:380):    LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
> +	0xf8c6001a, /* 002C(:381):      LCDEXT: idx2 = *(idx1 + var12 + 8); idx2 once var0; idx2 += inc3 */
> +	0xb8c6601b, /* 0030(:382):      LCD: idx3 = *(idx1 + var12 + 12); ; idx3 += inc3 */
> +	0x10002710, /* 0034(:384):        DRD1A: var9 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x00000f18, /* 0038(:385):        DRD1A: var3 = idx3; FN=0 init=0 WS=0 RS=0 */
> +	0xb8c6001d, /* 003C(:387):      LCD: idx2 = *(idx1 + var12 + 20); idx2 once var0; idx2 += inc3 */
> +	0x10001310, /* 0040(:388):        DRD1A: var4 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x60000007, /* 0044(:389):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */
> +	0x014cf88b, /* 0048(:389):        DRD2B1: var5 = EU3(); EU3(idx2,var11)  */
> +	0x98c6001c, /* 004C(:391):      LCD: idx2 = idx1 + var12 + 4; idx2 once var0; idx2 += inc3 */
> +	0x00000710, /* 0050(:392):        DRD1A: var1 = idx2; FN=0 init=0 WS=0 RS=0 */
> +	0x98c70018, /* 0054(:393):      LCD: idx2 = idx1 + var14; idx2 once var0; idx2 += inc3 */
> +	0x10001f10, /* 0058(:394):        DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x0000c818, /* 005C(:395):        DRD1A: *idx2 = var3; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 0060(:0):      NOP */
> +	0xc1476018, /* 0064(:399):    LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */
> +	0xc003231d, /* 0068(:399):    LCDEXT: idx2 = var0, idx3 = var6; idx3 == var12; idx2 += inc3, idx3 += inc5 */
> +	0x811a601b, /* 006C(:400):    LCD: idx4 = var2; ; idx4 += inc3 */
> +	0xc1862102, /* 0070(:403):      LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */
> +	0x849be009, /* 0074(:403):      LCD: idx7 = var9; ; idx7 += inc1 */
> +	0x03fed7b8, /* 0078(:406):        DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */
> +	0xda9b001b, /* 007C(:408):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 0080(:408):      LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x1000cb20, /* 0084(:409):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0088(:410):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88f, /* 008C(:410):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
> +	0x1000cb28, /* 0090(:411):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0094(:412):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88f, /* 0098(:412):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
> +	0x1000cb30, /* 009C(:413):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00A0(:414):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88f, /* 00A4(:414):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
> +	0x1000cb38, /* 00A8(:415):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x0000c728, /* 00AC(:416):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 00B0(:0):      NOP */
> +	0xc1476018, /* 00B4(:420):    LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */
> +	0xc003241d, /* 00B8(:420):    LCDEXT: idx2 = var0, idx3 = var6; idx3 == var16; idx2 += inc3, idx3 += inc5 */
> +	0x811a601b, /* 00BC(:421):    LCD: idx4 = var2; ; idx4 += inc3 */
> +	0xda9b001b, /* 00C0(:424):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 00C4(:424):      LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x0000d3a0, /* 00C8(:425):        DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
> +	0xc1862102, /* 00CC(:427):      LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */
> +	0x849be009, /* 00D0(:427):      LCD: idx7 = var9; ; idx7 += inc1 */
> +	0x0bfed7b8, /* 00D4(:430):        DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */
> +	0xda9b001b, /* 00D8(:432):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 00DC(:432):      LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x1000cb20, /* 00E0(:433):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00E4(:434):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88f, /* 00E8(:434):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
> +	0x1000cb28, /* 00EC(:435):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00F0(:436):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88f, /* 00F4(:436):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
> +	0x1000cb30, /* 00F8(:437):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00FC(:438):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88f, /* 0100(:438):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
> +	0x1000cb38, /* 0104(:439):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x0000c728, /* 0108(:440):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 010C(:0):      NOP */
> +	0x8118801b, /* 0110(:444):    LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
> +	0xd8c60018, /* 0114(:446):      LCDEXT: idx2 = idx1 + var12; idx2 once var0; idx2 += inc3 */
> +	0x98c6601c, /* 0118(:446):      LCD: idx3 = idx1 + var12 + 4; ; idx3 += inc3 */
> +	0x6000000b, /* 011C(:447):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */
> +	0x0c8cfc9f, /* 0120(:447):        DRD2B1: *idx2 = EU3(); EU3(*idx2)  */
> +	0x000001f8, /* 0124(:0):      NOP */
> +	0xa146001e, /* 0128(:450):    LCD: idx1 = *(var2 + var12 + 24); idx1 once var0; idx1 += inc3 */
> +	0x10000b08, /* 012C(:451):      DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x10002050, /* 0130(:452):      DRD1A: var8 = var10; FN=0 MORE init=0 WS=0 RS=0 */
> +	0xb8c60018, /* 0134(:453):      LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */
> +	0x10002b10, /* 0138(:454):        DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x7000000a, /* 013C(:455):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */
> +	0x080cf89f, /* 0140(:455):        DRD2B1: idx0 = EU3(); EU3(idx2)  */
> +	0x6000000d, /* 0144(:456):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
> +	0x018cf89f, /* 0148(:456):        DRD2B1: var6 = EU3(); EU3(idx2)  */
> +	0x000001f8, /* 014C(:0):      NOP */
> +	0x8618801b, /* 0150(:462):    LCD: idx1 = var12; idx1 once var0; idx1 += inc3 */
> +	0x7000000e, /* 0154(:463):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
> +	0x084cf21f, /* 0158(:463):      DRD2B1: idx1 = EU3(); EU3(var8)  */
> +	0xd8990336, /* 015C(:464):      LCDEXT: idx2 = idx1; idx2 > var12; idx2 += inc6 */
> +	0x8019801b, /* 0160(:464):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
> +	0x040001f8, /* 0164(:465):        DRD1A: FN=0 INT init=0 WS=0 RS=0 */
> +	0x000001f8, /* 0168(:0):      NOP */
> +	0x000001f8, /* 016C(:0):    NOP */
> +};
> +u32 MCD_SingleNoEu_TDT[] = {
> +	0x8198001b, /* 0000(:657):  LCD: idx0 = var3; idx0 once var0; idx0 += inc3 */
> +	0x7000000d, /* 0004(:658):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x080cf81f, /* 0008(:658):    DRD2B1: idx0 = EU3(); EU3(idx0)  */
> +	0x8198801b, /* 000C(:659):    LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
> +	0x6000000e, /* 0010(:660):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
> +	0x084cf85f, /* 0014(:660):      DRD2B1: idx1 = EU3(); EU3(idx1)  */
> +	0x000001f8, /* 0018(:0):    NOP */
> +	0x8298001b, /* 001C(:664):  LCD: idx0 = var5; idx0 once var0; idx0 += inc3 */
> +	0x7000000d, /* 0020(:665):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x010cf81f, /* 0024(:665):    DRD2B1: var4 = EU3(); EU3(idx0)  */
> +	0x6000000e, /* 0028(:666):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
> +	0x018cf81f, /* 002C(:666):    DRD2B1: var6 = EU3(); EU3(idx0)  */
> +	0xc202601b, /* 0030(:669):  LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */
> +	0xc002221c, /* 0034(:669):  LCDEXT: idx2 = var0, idx3 = var4; idx3 == var8; idx2 += inc3, idx3 += inc4 */
> +	0x809a601b, /* 0038(:670):  LCD: idx4 = var1; ; idx4 += inc3 */
> +	0xc10420c2, /* 003C(:673):    LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */
> +	0x839be009, /* 0040(:673):    LCD: idx7 = var7; ; idx7 += inc1 */
> +	0x03fed7b8, /* 0044(:676):      DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */
> +	0xda9b001b, /* 0048(:678):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 004C(:678):    LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x70000006, /* 0050(:680):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf889, /* 0054(:680):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
> +	0x1000cb28, /* 0058(:681):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 005C(:682):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf889, /* 0060(:682):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
> +	0x1000cb30, /* 0064(:683):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0068(:684):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf889, /* 006C(:684):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
> +	0x0000cb38, /* 0070(:685):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 0074(:0):    NOP */
> +	0xc202601b, /* 0078(:689):  LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */
> +	0xc002229c, /* 007C(:689):  LCDEXT: idx2 = var0, idx3 = var4; idx3 == var10; idx2 += inc3, idx3 += inc4 */
> +	0x809a601b, /* 0080(:690):  LCD: idx4 = var1; ; idx4 += inc3 */
> +	0xda9b001b, /* 0084(:693):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 0088(:693):    LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x0000d3a0, /* 008C(:694):      DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
> +	0xc10420c2, /* 0090(:696):    LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */
> +	0x839be009, /* 0094(:696):    LCD: idx7 = var7; ; idx7 += inc1 */
> +	0x0bfed7b8, /* 0098(:699):      DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */
> +	0xda9b001b, /* 009C(:701):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 00A0(:701):    LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x70000006, /* 00A4(:703):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf889, /* 00A8(:703):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
> +	0x1000cb28, /* 00AC(:704):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00B0(:705):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf889, /* 00B4(:705):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
> +	0x1000cb30, /* 00B8(:706):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00BC(:707):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf889, /* 00C0(:707):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
> +	0x0000cb38, /* 00C4(:708):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 00C8(:0):    NOP */
> +	0xc318022d, /* 00CC(:712):  LCDEXT: idx0 = var6; idx0 > var8; idx0 += inc5 */
> +	0x8018801b, /* 00D0(:712):  LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */
> +	0x040001f8, /* 00D4(:713):    DRD1A: FN=0 INT init=0 WS=0 RS=0 */
> +};
> +#ifdef MCD_INCLUDE_EU
> +u32 MCD_ChainEu_TDT[] = {
> +	0x80004000, /* 0000(:947):  LCDEXT: idx0 = 0x00000000; ; */
> +	0x8198801b, /* 0004(:947):  LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
> +	0xb8c68018, /* 0008(:948):    LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */
> +	0x10002f10, /* 000C(:949):      DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x7000000d, /* 0010(:950):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x01ccf89f, /* 0014(:950):      DRD2B1: var7 = EU3(); EU3(idx2)  */
> +	0x6000000a, /* 0018(:951):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
> +	0x080cf89f, /* 001C(:951):      DRD2B1: idx0 = EU3(); EU3(idx2)  */
> +	0x000001f8, /* 0020(:0):    NOP */
> +	0x981803a4, /* 0024(:955):  LCD: idx0 = idx0; idx0 == var14; idx0 += inc4 */
> +	0x8198801b, /* 0028(:957):    LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
> +	0xf8c6801a, /* 002C(:958):      LCDEXT: idx2 = *(idx1 + var13 + 8); idx2 once var0; idx2 += inc3 */
> +	0xb8c6e01b, /* 0030(:959):      LCD: idx3 = *(idx1 + var13 + 12); ; idx3 += inc3 */
> +	0x10002b10, /* 0034(:961):        DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x00001318, /* 0038(:962):        DRD1A: var4 = idx3; FN=0 init=0 WS=0 RS=0 */
> +	0xb8c6801d, /* 003C(:964):      LCD: idx2 = *(idx1 + var13 + 20); idx2 once var0; idx2 += inc3 */
> +	0x10001710, /* 0040(:965):        DRD1A: var5 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x60000007, /* 0044(:966):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */
> +	0x018cf88c, /* 0048(:966):        DRD2B1: var6 = EU3(); EU3(idx2,var12)  */
> +	0x98c6801c, /* 004C(:968):      LCD: idx2 = idx1 + var13 + 4; idx2 once var0; idx2 += inc3 */
> +	0x00000b10, /* 0050(:969):        DRD1A: var2 = idx2; FN=0 init=0 WS=0 RS=0 */
> +	0x98c78018, /* 0054(:970):      LCD: idx2 = idx1 + var15; idx2 once var0; idx2 += inc3 */
> +	0x10002310, /* 0058(:971):        DRD1A: var8 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x0000c820, /* 005C(:972):        DRD1A: *idx2 = var4; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 0060(:0):      NOP */
> +	0x8698801b, /* 0064(:976):    LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */
> +	0x7000000f, /* 0068(:977):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */
> +	0x084cf2df, /* 006C(:977):      DRD2B1: idx1 = EU3(); EU3(var11)  */
> +	0xd899042d, /* 0070(:978):      LCDEXT: idx2 = idx1; idx2 >= var16; idx2 += inc5 */
> +	0x8019801b, /* 0074(:978):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
> +	0x60000003, /* 0078(:979):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
> +	0x2cd7c7df, /* 007C(:979):        DRD2B2: EU3(var13)  */
> +	0xd8990364, /* 0080(:980):      LCDEXT: idx2 = idx1; idx2 == var13; idx2 += inc4 */
> +	0x8019801b, /* 0084(:980):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
> +	0x60000003, /* 0088(:981):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
> +	0x2c17c7df, /* 008C(:981):        DRD2B2: EU3(var1)  */
> +	0x000001f8, /* 0090(:0):      NOP */
> +	0xc1c7e018, /* 0094(:984):    LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */
> +	0xc003a35e, /* 0098(:984):    LCDEXT: idx2 = var0, idx3 = var7; idx3 == var13; idx2 += inc3, idx3 += inc6 */
> +	0x819a601b, /* 009C(:985):    LCD: idx4 = var3; ; idx4 += inc3 */
> +	0xc206a142, /* 00A0(:988):      LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */
> +	0x851be009, /* 00A4(:988):      LCD: idx7 = var10; ; idx7 += inc1 */
> +	0x63fe0000, /* 00A8(:991):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */
> +	0x0d4cfddf, /* 00AC(:991):        DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
> +	0xda9b001b, /* 00B0(:993):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 00B4(:993):      LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x70000002, /* 00B8(:994):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
> +	0x004cf81f, /* 00BC(:994):        DRD2B1: var1 = EU3(); EU3(idx0)  */
> +	0x1000cb20, /* 00C0(:995):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00C4(:996):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf891, /* 00C8(:996):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
> +	0x1000cb28, /* 00CC(:997):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00D0(:998):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf891, /* 00D4(:998):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
> +	0x1000cb30, /* 00D8(:999):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00DC(:1000):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf891, /* 00E0(:1000):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
> +	0x1000cb38, /* 00E4(:1001):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x0000c728, /* 00E8(:1002):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 00EC(:0):      NOP */
> +	0xc1c7e018, /* 00F0(:1006):    LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */
> +	0xc003a49e, /* 00F4(:1006):    LCDEXT: idx2 = var0, idx3 = var7; idx3 == var18; idx2 += inc3, idx3 += inc6 */
> +	0x819a601b, /* 00F8(:1007):    LCD: idx4 = var3; ; idx4 += inc3 */
> +	0xda9b001b, /* 00FC(:1010):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 0100(:1010):      LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x0000d3a0, /* 0104(:1011):        DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
> +	0xc206a142, /* 0108(:1013):      LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */
> +	0x851be009, /* 010C(:1013):      LCD: idx7 = var10; ; idx7 += inc1 */
> +	0x6bfe0000, /* 0110(:1016):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */
> +	0x0d4cfddf, /* 0114(:1016):        DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
> +	0xda9b001b, /* 0118(:1018):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 011C(:1018):      LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x70000002, /* 0120(:1019):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
> +	0x004cf81f, /* 0124(:1019):        DRD2B1: var1 = EU3(); EU3(idx0)  */
> +	0x1000cb20, /* 0128(:1020):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 012C(:1021):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf891, /* 0130(:1021):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
> +	0x1000cb28, /* 0134(:1022):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0138(:1023):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf891, /* 013C(:1023):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
> +	0x1000cb30, /* 0140(:1024):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0144(:1025):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf891, /* 0148(:1025):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
> +	0x1000cb38, /* 014C(:1026):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x0000c728, /* 0150(:1027):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 0154(:0):      NOP */
> +	0x8198801b, /* 0158(:1031):    LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
> +	0xd8c68018, /* 015C(:1033):      LCDEXT: idx2 = idx1 + var13; idx2 once var0; idx2 += inc3 */
> +	0x98c6e01c, /* 0160(:1033):      LCD: idx3 = idx1 + var13 + 4; ; idx3 += inc3 */
> +	0x6000000b, /* 0164(:1034):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */
> +	0x0c8cfc9f, /* 0168(:1034):        DRD2B1: *idx2 = EU3(); EU3(*idx2)  */
> +	0x0000cc08, /* 016C(:1035):      DRD1A: *idx3 = var1; FN=0 init=0 WS=0 RS=0 */
> +	0xa1c6801e, /* 0170(:1038):    LCD: idx1 = *(var3 + var13 + 24); idx1 once var0; idx1 += inc3 */
> +	0x10000f08, /* 0174(:1039):      DRD1A: var3 = idx1; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x10002458, /* 0178(:1040):      DRD1A: var9 = var11; FN=0 MORE init=0 WS=0 RS=0 */
> +	0xb8c68018, /* 017C(:1041):      LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */
> +	0x10002f10, /* 0180(:1042):        DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x7000000a, /* 0184(:1043):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */
> +	0x080cf89f, /* 0188(:1043):        DRD2B1: idx0 = EU3(); EU3(idx2)  */
> +	0x6000000d, /* 018C(:1044):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
> +	0x01ccf89f, /* 0190(:1044):        DRD2B1: var7 = EU3(); EU3(idx2)  */
> +	0x000001f8, /* 0194(:0):      NOP */
> +	0x8698801b, /* 0198(:1050):    LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */
> +	0x7000000e, /* 019C(:1051):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
> +	0x084cf25f, /* 01A0(:1051):      DRD2B1: idx1 = EU3(); EU3(var9)  */
> +	0xd899037f, /* 01A4(:1052):      LCDEXT: idx2 = idx1; idx2 > var13; idx2 += inc7 */
> +	0x8019801b, /* 01A8(:1052):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
> +	0x040001f8, /* 01AC(:1053):        DRD1A: FN=0 INT init=0 WS=0 RS=0 */
> +	0x000001f8, /* 01B0(:0):      NOP */
> +	0x000001f8, /* 01B4(:0):    NOP */
> +};
> +u32 MCD_SingleEu_TDT[] = {
> +	0x8218001b, /* 0000(:1248):  LCD: idx0 = var4; idx0 once var0; idx0 += inc3 */
> +	0x7000000d, /* 0004(:1249):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x080cf81f, /* 0008(:1249):    DRD2B1: idx0 = EU3(); EU3(idx0)  */
> +	0x8218801b, /* 000C(:1250):    LCD: idx1 = var4; idx1 once var0; idx1 += inc3 */
> +	0x6000000e, /* 0010(:1251):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
> +	0x084cf85f, /* 0014(:1251):      DRD2B1: idx1 = EU3(); EU3(idx1)  */
> +	0x000001f8, /* 0018(:0):    NOP */
> +	0x8318001b, /* 001C(:1255):  LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */
> +	0x7000000d, /* 0020(:1256):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x014cf81f, /* 0024(:1256):    DRD2B1: var5 = EU3(); EU3(idx0)  */
> +	0x6000000e, /* 0028(:1257):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
> +	0x01ccf81f, /* 002C(:1257):    DRD2B1: var7 = EU3(); EU3(idx0)  */
> +	0x8498001b, /* 0030(:1260):  LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */
> +	0x7000000f, /* 0034(:1261):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */
> +	0x080cf19f, /* 0038(:1261):    DRD2B1: idx0 = EU3(); EU3(var6)  */
> +	0xd81882a4, /* 003C(:1262):    LCDEXT: idx1 = idx0; idx1 >= var10; idx1 += inc4 */
> +	0x8019001b, /* 0040(:1262):    LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */
> +	0x60000003, /* 0044(:1263):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
> +	0x2c97c7df, /* 0048(:1263):      DRD2B2: EU3(var9)  */
> +	0xd818826d, /* 004C(:1264):    LCDEXT: idx1 = idx0; idx1 == var9; idx1 += inc5 */
> +	0x8019001b, /* 0050(:1264):    LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */
> +	0x60000003, /* 0054(:1265):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
> +	0x2c17c7df, /* 0058(:1265):      DRD2B2: EU3(var1)  */
> +	0x000001f8, /* 005C(:0):    NOP */
> +	0xc282e01b, /* 0060(:1268):  LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */
> +	0xc002a25e, /* 0064(:1268):  LCDEXT: idx2 = var0, idx3 = var5; idx3 == var9; idx2 += inc3, idx3 += inc6 */
> +	0x811a601b, /* 0068(:1269):  LCD: idx4 = var2; ; idx4 += inc3 */
> +	0xc184a102, /* 006C(:1272):    LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */
> +	0x841be009, /* 0070(:1272):    LCD: idx7 = var8; ; idx7 += inc1 */
> +	0x63fe0000, /* 0074(:1275):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */
> +	0x0d4cfddf, /* 0078(:1275):      DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
> +	0xda9b001b, /* 007C(:1277):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 0080(:1277):    LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x70000002, /* 0084(:1279):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
> +	0x004cf99f, /* 0088(:1279):      DRD2B1: var1 = EU3(); EU3(idx6)  */
> +	0x70000006, /* 008C(:1280):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88b, /* 0090(:1280):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
> +	0x1000cb28, /* 0094(:1281):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0098(:1282):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88b, /* 009C(:1282):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
> +	0x1000cb30, /* 00A0(:1283):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00A4(:1284):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88b, /* 00A8(:1284):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
> +	0x0000cb38, /* 00AC(:1285):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 00B0(:0):    NOP */
> +	0xc282e01b, /* 00B4(:1289):  LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */
> +	0xc002a31e, /* 00B8(:1289):  LCDEXT: idx2 = var0, idx3 = var5; idx3 == var12; idx2 += inc3, idx3 += inc6 */
> +	0x811a601b, /* 00BC(:1290):  LCD: idx4 = var2; ; idx4 += inc3 */
> +	0xda9b001b, /* 00C0(:1293):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 00C4(:1293):    LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x0000d3a0, /* 00C8(:1294):      DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
> +	0xc184a102, /* 00CC(:1296):    LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */
> +	0x841be009, /* 00D0(:1296):    LCD: idx7 = var8; ; idx7 += inc1 */
> +	0x6bfe0000, /* 00D4(:1299):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */
> +	0x0d4cfddf, /* 00D8(:1299):      DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
> +	0xda9b001b, /* 00DC(:1301):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
> +	0x9b9be01b, /* 00E0(:1301):    LCD: idx7 = idx7; ; idx7 += inc3 */
> +	0x70000002, /* 00E4(:1303):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
> +	0x004cf99f, /* 00E8(:1303):      DRD2B1: var1 = EU3(); EU3(idx6)  */
> +	0x70000006, /* 00EC(:1304):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88b, /* 00F0(:1304):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
> +	0x1000cb28, /* 00F4(:1305):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 00F8(:1306):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88b, /* 00FC(:1306):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
> +	0x1000cb30, /* 0100(:1307):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x70000006, /* 0104(:1308):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
> +	0x088cf88b, /* 0108(:1308):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
> +	0x0000cb38, /* 010C(:1309):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
> +	0x000001f8, /* 0110(:0):    NOP */
> +	0x8144801c, /* 0114(:1312):  LCD: idx0 = var2 + var9 + 4; idx0 once var0; idx0 += inc3 */
> +	0x0000c008, /* 0118(:1313):    DRD1A: *idx0 = var1; FN=0 init=0 WS=0 RS=0 */
> +	0xc398027f, /* 011C(:1315):  LCDEXT: idx0 = var7; idx0 > var9; idx0 += inc7 */
> +	0x8018801b, /* 0120(:1315):  LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */
> +	0x040001f8, /* 0124(:1316):    DRD1A: FN=0 INT init=0 WS=0 RS=0 */
> +};
> +#endif
> +u32 MCD_ENetRcv_TDT[] = {
> +	0x80004000, /* 0000(:1389):  LCDEXT: idx0 = 0x00000000; ; */
> +	0x81988000, /* 0004(:1389):  LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
> +	0x10000788, /* 0008(:1390):    DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x6000000a, /* 000C(:1391):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
> +	0x080cf05f, /* 0010(:1391):    DRD2B1: idx0 = EU3(); EU3(var1)  */
> +	0x98180209, /* 0014(:1394):  LCD: idx0 = idx0; idx0 != var8; idx0 += inc1 */
> +	0x81c40004, /* 0018(:1396):    LCD: idx1 = var3 + var8 + 4; idx1 once var0; idx1 += inc0 */
> +	0x7000000e, /* 001C(:1397):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
> +	0x010cf05f, /* 0020(:1397):      DRD2B1: var4 = EU3(); EU3(var1)  */
> +	0x7000000c, /* 0024(:1398):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
> +	0x01ccf05f, /* 0028(:1398):      DRD2B1: var7 = EU3(); EU3(var1)  */
> +	0x70000004, /* 002C(:1399):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
> +	0x014cf049, /* 0030(:1399):      DRD2B1: var5 = EU3(); EU3(var1,var9)  */
> +	0x70000004, /* 0034(:1400):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
> +	0x004cf04a, /* 0038(:1400):      DRD2B1: var1 = EU3(); EU3(var1,var10)  */
> +	0x00000b88, /* 003C(:1403):      DRD1A: var2 = *idx1; FN=0 init=0 WS=0 RS=0 */
> +	0xc4030150, /* 0040(:1406):    LCDEXT: idx1 = var8, idx2 = var6; idx1 < var5; idx1 += inc2, idx2 += inc0 */
> +	0x8119e012, /* 0044(:1406):    LCD: idx3 = var2; ; idx3 += inc2 */
> +	0x03e0cf90, /* 0048(:1409):      DRD1A: *idx3 = *idx2; FN=0 init=31 WS=0 RS=0 */
> +	0x81188000, /* 004C(:1412):    LCD: idx1 = var2; idx1 once var0; idx1 += inc0 */
> +	0x000ac788, /* 0050(:1413):      DRD1A: *idx1 = *idx1; FN=0 init=0 WS=1 RS=1 */
> +	0xc4030000, /* 0054(:1415):    LCDEXT: idx1 = var8, idx2 = var6; idx1 once var0; idx1 += inc0, idx2 += inc0 */
> +	0x8199e000, /* 0058(:1415):    LCD: idx3 = var3; ; idx3 += inc0 */
> +	0x63e00004, /* 005C(:1418):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=31 WS=0 RS=0 */
> +	0x084cfc8b, /* 0060(:1418):      DRD2B1: idx1 = EU3(); EU3(*idx2,var11)  */
> +	0xd8990000, /* 0064(:1421):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
> +	0x9999e000, /* 0068(:1421):    LCD: idx3 = idx3; ; idx3 += inc0 */
> +	0x60000005, /* 006C(:1422):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=5 EXT init=0 WS=0 RS=0 */
> +	0x0cccf841, /* 0070(:1422):      DRD2B1: *idx3 = EU3(); EU3(idx1,var1)  */
> +	0x81c60000, /* 0074(:1427):    LCD: idx1 = var3 + var12; idx1 once var0; idx1 += inc0 */
> +	0xc399021b, /* 0078(:1429):      LCDEXT: idx2 = var7; idx2 > var8; idx2 += inc3 */
> +	0x80198000, /* 007C(:1429):      LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */
> +	0x00008400, /* 0080(:1430):        DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */
> +	0x00000f08, /* 0084(:1431):      DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */
> +	0x81988000, /* 0088(:1434):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
> +	0x10000788, /* 008C(:1435):      DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x6000000a, /* 0090(:1436):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
> +	0x080cf05f, /* 0094(:1436):      DRD2B1: idx0 = EU3(); EU3(var1)  */
> +	0xc2188209, /* 0098(:1439):    LCDEXT: idx1 = var4; idx1 != var8; idx1 += inc1 */
> +	0x80190000, /* 009C(:1439):    LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */
> +	0x040001f8, /* 00A0(:1440):      DRD1A: FN=0 INT init=0 WS=0 RS=0 */
> +	0x000001f8, /* 00A4(:0):    NOP */
> +};
> +u32 MCD_ENetXmit_TDT[] = {
> +	0x80004000, /* 0000(:1515):  LCDEXT: idx0 = 0x00000000; ; */
> +	0x81988000, /* 0004(:1515):  LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
> +	0x10000788, /* 0008(:1516):    DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x6000000a, /* 000C(:1517):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
> +	0x080cf05f, /* 0010(:1517):    DRD2B1: idx0 = EU3(); EU3(var1)  */
> +	0x98180309, /* 0014(:1520):  LCD: idx0 = idx0; idx0 != var12; idx0 += inc1 */
> +	0x80004003, /* 0018(:1522):    LCDEXT: idx1 = 0x00000003; ; */
> +	0x81c60004, /* 001C(:1522):    LCD: idx2 = var3 + var12 + 4; idx2 once var0; idx2 += inc0 */
> +	0x7000000e, /* 0020(:1523):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
> +	0x014cf05f, /* 0024(:1523):      DRD2B1: var5 = EU3(); EU3(var1)  */
> +	0x7000000c, /* 0028(:1524):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
> +	0x028cf05f, /* 002C(:1524):      DRD2B1: var10 = EU3(); EU3(var1)  */
> +	0x7000000d, /* 0030(:1525):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
> +	0x018cf05f, /* 0034(:1525):      DRD2B1: var6 = EU3(); EU3(var1)  */
> +	0x70000004, /* 0038(:1526):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
> +	0x01ccf04d, /* 003C(:1526):      DRD2B1: var7 = EU3(); EU3(var1,var13)  */
> +	0x10000b90, /* 0040(:1527):      DRD1A: var2 = *idx2; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x60000004, /* 0044(:1528):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=0 WS=0 RS=0 */
> +	0x020cf0a1, /* 0048(:1528):      DRD2B1: var8 = EU3(); EU3(var2,idx1)  */
> +	0xc3188312, /* 004C(:1531):    LCDEXT: idx1 = var6; idx1 > var12; idx1 += inc2 */
> +	0x83c70000, /* 0050(:1531):    LCD: idx2 = var7 + var14; idx2 once var0; idx2 += inc0 */
> +	0x00001f10, /* 0054(:1532):      DRD1A: var7 = idx2; FN=0 init=0 WS=0 RS=0 */
> +	0xc583a3c3, /* 0058(:1534):    LCDEXT: idx1 = var11, idx2 = var7; idx2 >= var15; idx1 += inc0, idx2 += inc3 */
> +	0x81042325, /* 005C(:1534):    LCD: idx3 = var2, idx4 = var8; idx4 == var12; idx3 += inc4, idx4 += inc5 */
> +	0x03e0c798, /* 0060(:1539):      DRD1A: *idx1 = *idx3; FN=0 init=31 WS=0 RS=0 */
> +	0xd8990000, /* 0064(:1542):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
> +	0x9999e000, /* 0068(:1542):    LCD: idx3 = idx3; ; idx3 += inc0 */
> +	0x000acf98, /* 006C(:1543):      DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */
> +	0xd8992306, /* 0070(:1545):    LCDEXT: idx1 = idx1, idx2 = idx2; idx2 > var12; idx1 += inc0, idx2 += inc6 */
> +	0x9999e03f, /* 0074(:1545):    LCD: idx3 = idx3; ; idx3 += inc7 */
> +	0x03eac798, /* 0078(:1548):      DRD1A: *idx1 = *idx3; FN=0 init=31 WS=1 RS=1 */
> +	0xd8990000, /* 007C(:1551):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
> +	0x9999e000, /* 0080(:1551):    LCD: idx3 = idx3; ; idx3 += inc0 */
> +	0x000acf98, /* 0084(:1552):      DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */
> +	0xd8990000, /* 0088(:1554):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
> +	0x99832302, /* 008C(:1554):    LCD: idx3 = idx3, idx4 = var6; idx4 > var12; idx3 += inc0, idx4 += inc2 */
> +	0x0beac798, /* 0090(:1557):      DRD1A: *idx1 = *idx3; FN=0 TFD init=31 WS=1 RS=1 */
> +	0x81988000, /* 0094(:1559):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
> +	0x6000000b, /* 0098(:1560):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */
> +	0x0c4cfc5f, /* 009C(:1560):      DRD2B1: *idx1 = EU3(); EU3(*idx1)  */
> +	0x81c80000, /* 00A0(:1562):    LCD: idx1 = var3 + var16; idx1 once var0; idx1 += inc0 */
> +	0xc5190312, /* 00A4(:1564):      LCDEXT: idx2 = var10; idx2 > var12; idx2 += inc2 */
> +	0x80198000, /* 00A8(:1564):      LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */
> +	0x00008400, /* 00AC(:1565):        DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */
> +	0x00000f08, /* 00B0(:1566):      DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */
> +	0x81988000, /* 00B4(:1569):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
> +	0x10000788, /* 00B8(:1570):      DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
> +	0x6000000a, /* 00BC(:1571):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
> +	0x080cf05f, /* 00C0(:1571):      DRD2B1: idx0 = EU3(); EU3(var1)  */
> +	0xc2988309, /* 00C4(:1574):    LCDEXT: idx1 = var5; idx1 != var12; idx1 += inc1 */
> +	0x80190000, /* 00C8(:1574):    LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */
> +	0x040001f8, /* 00CC(:1575):      DRD1A: FN=0 INT init=0 WS=0 RS=0 */
> +	0x000001f8, /* 00D0(:0):    NOP */
> +};
> +
> +#ifdef MCD_INCLUDE_EU
> +MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
> +#endif
> diff --git a/drivers/dma/fsl_mcd_dma/MCD_tasksInit.c b/drivers/dma/fsl_mcd_dma/MCD_tasksInit.c
> new file mode 100644
> index 0000000..28b9717
> --- /dev/null
> +++ b/drivers/dma/fsl_mcd_dma/MCD_tasksInit.c
> @@ -0,0 +1,274 @@
> +/*
> + * drivers/dma/MCD_tasksInit.c
> + *
> + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
> + *     Kurt Mahan <kmahan@...escale.com>
> + * readl/writel conversion and other cleanup
> + * (C) Copyright 2010-2012 Philippe De Muyter <phdm@...qel.be> Macq SA
> + *
> + * 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
> + */
> +
> +/*
> + * Autogenerated - Do not edit!
> + */
> +
> +#include <linux/MCD_dma.h>
> +#include <linux/io.h>
> +#include "MCD_tasksInit.h"
> +
> +#define MCD_SET_VAR(varTab, idx, value) writel(value, (u32 *)(varTab) + idx)
> +
> +#define U16PAIR(m, l) ((u32)(m << 16) | (0xffff & l))
> +
> +
> +/*
> + * Task 0
> + */
> +
> +void MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr,
> +			   int xferSize, short xferSizeIncr, int *cSave,
> +			   struct TaskTableEntry *taskTable, int channel)
> +{
> +	u32 var = taskTable[channel].varTab;
> +	u16 tcrValue;
> +
> +	MCD_SET_VAR(var, 2, (u32)currBD); /* var[2] */
> +	MCD_SET_VAR(var, 25, U16PAIR(0xe000, srcIncr));   /* inc[1] */
> +	MCD_SET_VAR(var, 24, U16PAIR(0xe000, destIncr));  /* inc[0] */
> +	MCD_SET_VAR(var, 11, (u32)xferSize);  /* var[11] */
> +	MCD_SET_VAR(var, 26, U16PAIR(0x2000, xferSizeIncr));  /* inc[2] */
> +	MCD_SET_VAR(var, 0, (u32)cSave);  /* var[0] */
> +	MCD_SET_VAR(var, 1, (u32)0x00000000); /* var[1] */
> +	MCD_SET_VAR(var, 3, (u32)0x00000000); /* var[3] */
> +	MCD_SET_VAR(var, 4, (u32)0x00000000); /* var[4] */
> +	MCD_SET_VAR(var, 5, (u32)0x00000000); /* var[5] */
> +	MCD_SET_VAR(var, 6, (u32)0x00000000); /* var[6] */
> +	MCD_SET_VAR(var, 7, (u32)0x00000000); /* var[7] */
> +	MCD_SET_VAR(var, 8, (u32)0x00000000); /* var[8] */
> +	MCD_SET_VAR(var, 9, (u32)0x00000000); /* var[9] */
> +	MCD_SET_VAR(var, 10, (u32)0x00000000);    /* var[10] */
> +	MCD_SET_VAR(var, 12, (u32)0x00000000);    /* var[12] */
> +	MCD_SET_VAR(var, 13, (u32)0x80000000);    /* var[13] */
> +	MCD_SET_VAR(var, 14, (u32)0x00000010);    /* var[14] */
> +	MCD_SET_VAR(var, 15, (u32)0x00000004);    /* var[15] */
> +	MCD_SET_VAR(var, 16, (u32)0x08000000);    /* var[16] */
> +	MCD_SET_VAR(var, 27, (u32)0x00000000);    /* inc[3] */
> +	MCD_SET_VAR(var, 28, (u32)0x80000000);    /* inc[4] */
> +	MCD_SET_VAR(var, 29, (u32)0x80000001);    /* inc[5] */
> +	MCD_SET_VAR(var, 30, (u32)0x40000000);    /* inc[6] */
> +
> +	/* Set the task's Enable bit in its Task Control Register */
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | 0x8000, &MCD_dmaBar->taskControl[channel]);
> +}
> +
> +
> +/*
> + * Task 1
> + */
> +
> +void MCD_startDmaSingleNoEu(char *srcAddr, short srcIncr, char *destAddr,
> +			    short destIncr, int dmaSize, short xferSizeIncr,
> +			    int flags, int *currBD, int *cSave,
> +			    struct TaskTableEntry *taskTable, int channel)
> +{
> +	u32 var = taskTable[channel].varTab;
> +	u16 tcrValue;
> +
> +	MCD_SET_VAR(var, 7, (u32)srcAddr);    /* var[7] */
> +	MCD_SET_VAR(var, 25, U16PAIR(0xe000, srcIncr));   /* inc[1] */
> +	MCD_SET_VAR(var, 2, (u32)destAddr);   /* var[2] */
> +	MCD_SET_VAR(var, 24, U16PAIR(0xe000, destIncr));  /* inc[0] */
> +	MCD_SET_VAR(var, 3, (u32)dmaSize);    /* var[3] */
> +	MCD_SET_VAR(var, 26, U16PAIR(0x2000, xferSizeIncr));  /* inc[2] */
> +	MCD_SET_VAR(var, 5, (u32)flags);  /* var[5] */
> +	MCD_SET_VAR(var, 1, (u32)currBD); /* var[1] */
> +	MCD_SET_VAR(var, 0, (u32)cSave);  /* var[0] */
> +	MCD_SET_VAR(var, 4, (u32)0x00000000); /* var[4] */
> +	MCD_SET_VAR(var, 6, (u32)0x00000000); /* var[6] */
> +	MCD_SET_VAR(var, 8, (u32)0x00000000); /* var[8] */
> +	MCD_SET_VAR(var, 9, (u32)0x00000004); /* var[9] */
> +	MCD_SET_VAR(var, 10, (u32)0x08000000);    /* var[10] */
> +	MCD_SET_VAR(var, 27, (u32)0x00000000);    /* inc[3] */
> +	MCD_SET_VAR(var, 28, (u32)0x80000001);    /* inc[4] */
> +	MCD_SET_VAR(var, 29, (u32)0x40000000);    /* inc[5] */
> +
> +	/* Set the task's Enable bit in its Task Control Register */
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | 0x8000, &MCD_dmaBar->taskControl[channel]);
> +}
> +
> +
> +/*
> + * Task 2
> + */
> +
> +void MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr,
> +			 int xferSize, short xferSizeIncr, int *cSave,
> +			 struct TaskTableEntry *taskTable, int channel)
> +{
> +	u32 var = taskTable[channel].varTab;
> +	u16 tcrValue;
> +
> +	MCD_SET_VAR(var, 3, (u32)currBD); /* var[3] */
> +	MCD_SET_VAR(var, 25, U16PAIR(0xe000, srcIncr));   /* inc[1] */
> +	MCD_SET_VAR(var, 24, U16PAIR(0xe000, destIncr));  /* inc[0] */
> +	MCD_SET_VAR(var, 12, (u32)xferSize);  /* var[12] */
> +	MCD_SET_VAR(var, 26, U16PAIR(0x2000, xferSizeIncr));  /* inc[2] */
> +	MCD_SET_VAR(var, 0, (u32)cSave);  /* var[0] */
> +	MCD_SET_VAR(var, 1, (u32)0x00000000); /* var[1] */
> +	MCD_SET_VAR(var, 2, (u32)0x00000000); /* var[2] */
> +	MCD_SET_VAR(var, 4, (u32)0x00000000); /* var[4] */
> +	MCD_SET_VAR(var, 5, (u32)0x00000000); /* var[5] */
> +	MCD_SET_VAR(var, 6, (u32)0x00000000); /* var[6] */
> +	MCD_SET_VAR(var, 7, (u32)0x00000000); /* var[7] */
> +	MCD_SET_VAR(var, 8, (u32)0x00000000); /* var[8] */
> +	MCD_SET_VAR(var, 9, (u32)0x00000000); /* var[9] */
> +	MCD_SET_VAR(var, 10, (u32)0x00000000);    /* var[10] */
> +	MCD_SET_VAR(var, 11, (u32)0x00000000);    /* var[11] */
> +	MCD_SET_VAR(var, 13, (u32)0x00000000);    /* var[13] */
> +	MCD_SET_VAR(var, 14, (u32)0x80000000);    /* var[14] */
> +	MCD_SET_VAR(var, 15, (u32)0x00000010);    /* var[15] */
> +	MCD_SET_VAR(var, 16, (u32)0x00000001);    /* var[16] */
> +	MCD_SET_VAR(var, 17, (u32)0x00000004);    /* var[17] */
> +	MCD_SET_VAR(var, 18, (u32)0x08000000);    /* var[18] */
> +	MCD_SET_VAR(var, 27, (u32)0x00000000);    /* inc[3] */
> +	MCD_SET_VAR(var, 28, (u32)0x80000000);    /* inc[4] */
> +	MCD_SET_VAR(var, 29, (u32)0xc0000000);    /* inc[5] */
> +	MCD_SET_VAR(var, 30, (u32)0x80000001);    /* inc[6] */
> +	MCD_SET_VAR(var, 31, (u32)0x40000000);    /* inc[7] */
> +
> +	/* Set the task's Enable bit in its Task Control Register */
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | 0x8000, &MCD_dmaBar->taskControl[channel]);
> +}
> +
> +
> +/*
> + * Task 3
> + */
> +
> +void MCD_startDmaSingleEu(char *srcAddr, short srcIncr, char *destAddr,
> +			  short destIncr, int dmaSize, short xferSizeIncr,
> +			  int flags, int *currBD, int *cSave,
> +			  struct TaskTableEntry *taskTable, int channel)
> +{
> +	u32 var = taskTable[channel].varTab;
> +	u16 tcrValue;
> +
> +	MCD_SET_VAR(var, 8, (u32)srcAddr);    /* var[8] */
> +	MCD_SET_VAR(var, 25, U16PAIR(0xe000, srcIncr));   /* inc[1] */
> +	MCD_SET_VAR(var, 3, (u32)destAddr);   /* var[3] */
> +	MCD_SET_VAR(var, 24, U16PAIR(0xe000, destIncr));  /* inc[0] */
> +	MCD_SET_VAR(var, 4, (u32)dmaSize);    /* var[4] */
> +	MCD_SET_VAR(var, 26, U16PAIR(0x2000, xferSizeIncr));  /* inc[2] */
> +	MCD_SET_VAR(var, 6, (u32)flags);  /* var[6] */
> +	MCD_SET_VAR(var, 2, (u32)currBD); /* var[2] */
> +	MCD_SET_VAR(var, 0, (u32)cSave);  /* var[0] */
> +	MCD_SET_VAR(var, 1, (u32)0x00000000); /* var[1] */
> +	MCD_SET_VAR(var, 5, (u32)0x00000000); /* var[5] */
> +	MCD_SET_VAR(var, 7, (u32)0x00000000); /* var[7] */
> +	MCD_SET_VAR(var, 9, (u32)0x00000000); /* var[9] */
> +	MCD_SET_VAR(var, 10, (u32)0x00000001);    /* var[10] */
> +	MCD_SET_VAR(var, 11, (u32)0x00000004);    /* var[11] */
> +	MCD_SET_VAR(var, 12, (u32)0x08000000);    /* var[12] */
> +	MCD_SET_VAR(var, 27, (u32)0x00000000);    /* inc[3] */
> +	MCD_SET_VAR(var, 28, (u32)0xc0000000);    /* inc[4] */
> +	MCD_SET_VAR(var, 29, (u32)0x80000000);    /* inc[5] */
> +	MCD_SET_VAR(var, 30, (u32)0x80000001);    /* inc[6] */
> +	MCD_SET_VAR(var, 31, (u32)0x40000000);    /* inc[7] */
> +
> +	/* Set the task's Enable bit in its Task Control Register */
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | 0x8000, &MCD_dmaBar->taskControl[channel]);
> +}
> +
> +
> +/*
> + * Task 4
> + */
> +
> +void MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr,
> +			 struct TaskTableEntry *taskTable, int channel)
> +{
> +	u32 var = taskTable[channel].varTab;
> +	u16 tcrValue;
> +
> +	MCD_SET_VAR(var, 0, (u32)bDBase); /* var[0] */
> +	MCD_SET_VAR(var, 3, (u32)currBD); /* var[3] */
> +	MCD_SET_VAR(var, 6, (u32)rcvFifoPtr); /* var[6] */
> +	MCD_SET_VAR(var, 1, (u32)0x00000000); /* var[1] */
> +	MCD_SET_VAR(var, 2, (u32)0x00000000); /* var[2] */
> +	MCD_SET_VAR(var, 4, (u32)0x00000000); /* var[4] */
> +	MCD_SET_VAR(var, 5, (u32)0x00000000); /* var[5] */
> +	MCD_SET_VAR(var, 7, (u32)0x00000000); /* var[7] */
> +	MCD_SET_VAR(var, 8, (u32)0x00000000); /* var[8] */
> +	MCD_SET_VAR(var, 9, (u32)0x0000ffff); /* var[9] */
> +	MCD_SET_VAR(var, 10, (u32)0x30000000);    /* var[10] */
> +	MCD_SET_VAR(var, 11, (u32)0x0fffffff);    /* var[11] */
> +	MCD_SET_VAR(var, 12, (u32)0x00000008);    /* var[12] */
> +	MCD_SET_VAR(var, 24, (u32)0x00000000);    /* inc[0] */
> +	MCD_SET_VAR(var, 25, (u32)0x60000000);    /* inc[1] */
> +	MCD_SET_VAR(var, 26, (u32)0x20000004);    /* inc[2] */
> +	MCD_SET_VAR(var, 27, (u32)0x40000000);    /* inc[3] */
> +
> +	/* Set the task's Enable bit in its Task Control Register */
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | 0x8000, &MCD_dmaBar->taskControl[channel]);
> +}
> +
> +
> +/*
> + * Task 5
> + */
> +
> +void MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr,
> +			  struct TaskTableEntry *taskTable, int channel)
> +{
> +	u32 var = taskTable[channel].varTab;
> +	u16 tcrValue;
> +
> +	MCD_SET_VAR(var, 0, (u32)bDBase); /* var[0] */
> +	MCD_SET_VAR(var, 3, (u32)currBD); /* var[3] */
> +	MCD_SET_VAR(var, 11, (u32)xmitFifoPtr);   /* var[11] */
> +	MCD_SET_VAR(var, 1, (u32)0x00000000); /* var[1] */
> +	MCD_SET_VAR(var, 2, (u32)0x00000000); /* var[2] */
> +	MCD_SET_VAR(var, 4, (u32)0x00000000); /* var[4] */
> +	MCD_SET_VAR(var, 5, (u32)0x00000000); /* var[5] */
> +	MCD_SET_VAR(var, 6, (u32)0x00000000); /* var[6] */
> +	MCD_SET_VAR(var, 7, (u32)0x00000000); /* var[7] */
> +	MCD_SET_VAR(var, 8, (u32)0x00000000); /* var[8] */
> +	MCD_SET_VAR(var, 9, (u32)0x00000000); /* var[9] */
> +	MCD_SET_VAR(var, 10, (u32)0x00000000);    /* var[10] */
> +	MCD_SET_VAR(var, 12, (u32)0x00000000);    /* var[12] */
> +	MCD_SET_VAR(var, 13, (u32)0x0000ffff);    /* var[13] */
> +	MCD_SET_VAR(var, 14, (u32)0xffffffff);    /* var[14] */
> +	MCD_SET_VAR(var, 15, (u32)0x00000004);    /* var[15] */
> +	MCD_SET_VAR(var, 16, (u32)0x00000008);    /* var[16] */
> +	MCD_SET_VAR(var, 24, (u32)0x00000000);    /* inc[0] */
> +	MCD_SET_VAR(var, 25, (u32)0x60000000);    /* inc[1] */
> +	MCD_SET_VAR(var, 26, (u32)0x40000000);    /* inc[2] */
> +	MCD_SET_VAR(var, 27, (u32)0xc000fffc);    /* inc[3] */
> +	MCD_SET_VAR(var, 28, (u32)0xe0000004);    /* inc[4] */
> +	MCD_SET_VAR(var, 29, (u32)0x80000000);    /* inc[5] */
> +	MCD_SET_VAR(var, 30, (u32)0x4000ffff);    /* inc[6] */
> +	MCD_SET_VAR(var, 31, (u32)0xe0000001);    /* inc[7] */
> +
> +	/* Set the task's Enable bit in its Task Control Register */
> +	tcrValue = readw(&MCD_dmaBar->taskControl[channel]);
> +	writew(tcrValue | 0x8000, &MCD_dmaBar->taskControl[channel]);
> +}
> diff --git a/drivers/dma/fsl_mcd_dma/MCD_tasksInit.h b/drivers/dma/fsl_mcd_dma/MCD_tasksInit.h
> new file mode 100644
> index 0000000..0a9722c
> --- /dev/null
> +++ b/drivers/dma/fsl_mcd_dma/MCD_tasksInit.h
> @@ -0,0 +1,76 @@
> +/*
> + * drivers/dma/MCD_tasksInit.h
> + *
> + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
> + *     Kurt Mahan <kmahan@...escale.com>
> + *
> + * 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 MCD_TSK_INIT_H
> +#define MCD_TSK_INIT_H 1
> +
> +/*
> + * Autogenerated - Do not edit!
> + */
> +
> +/*
> + * Task 0
> + */
> +void  MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr,
> +			    int xferSize, short xferSizeIncr, int *cSave,
> +			    struct TaskTableEntry *taskTable, int channel);
> +
> +
> +/*
> + * Task 1
> + */
> +void  MCD_startDmaSingleNoEu(char *srcAddr, short srcIncr, char *destAddr,
> +			     short destIncr, int dmaSize, short xferSizeIncr,
> +			     int flags, int *currBD, int *cSave,
> +			     struct TaskTableEntry *taskTable, int channel);
> +
> +
> +/*
> + * Task 2
> + */
> +void  MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr,
> +			  int xferSize, short xferSizeIncr, int *cSave,
> +			  struct TaskTableEntry *taskTable, int channel);
> +
> +
> +/*
> + * Task 3
> + */
> +void  MCD_startDmaSingleEu(char *srcAddr, short srcIncr, char *destAddr,
> +			   short destIncr, int dmaSize, short xferSizeIncr,
> +			   int flags, int *currBD, int *cSave,
> +			   struct TaskTableEntry *taskTable, int channel);
> +
> +
> +/*
> + * Task 4
> + */
> +void  MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr,
> +			  struct TaskTableEntry *taskTable, int channel);
> +
> +
> +/*
> + * Task 5
> + */
> +void  MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr,
> +			   struct TaskTableEntry *taskTable, int channel);
> +
> +#endif  /* MCD_TSK_INIT_H */
> diff --git a/drivers/dma/fsl_mcd_dma/Makefile b/drivers/dma/fsl_mcd_dma/Makefile
> new file mode 100644
> index 0000000..6bdd725
> --- /dev/null
> +++ b/drivers/dma/fsl_mcd_dma/Makefile
> @@ -0,0 +1 @@
> +obj-y	+= MCD_dmaApi.o MCD_tasks.o MCD_tasksInit.o
> diff --git a/include/linux/MCD_dma.h b/include/linux/MCD_dma.h
> new file mode 100644
> index 0000000..da0a928
> --- /dev/null
> +++ b/include/linux/MCD_dma.h
> @@ -0,0 +1,376 @@
> +/*
> + * drivers/dma/MCD_dma.h
> + *
> + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
> + *     Kurt Mahan <kmahan@...escale.com>
> + *
> + * 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 _MCD_API_H
> +#define _MCD_API_H
> +
> +/*
> + * Turn Execution Unit tasks ON (#define) or OFF (#undef)
> + */
> +#undef MCD_INCLUDE_EU
> +
> +/*
> + * Number of DMA channels
> + */
> +#define NCHANNELS 16
> +
> +/*
> + * Total number of variants
> + */
> +#ifdef MCD_INCLUDE_EU
> +#define NUMOFVARIANTS   6
> +#else
> +#define NUMOFVARIANTS   4
> +#endif
> +
> +/*
> + * Define sizes of the various tables
> + */
> +#define TASK_TABLE_SIZE     (NCHANNELS*32)
> +#define VAR_TAB_SIZE        (128)
> +#define CONTEXT_SAVE_SIZE   (128)
> +#define FUNCDESC_TAB_SIZE   (256)
> +
> +#ifdef MCD_INCLUDE_EU
> +#define FUNCDESC_TAB_NUM    16
> +#else
> +#define FUNCDESC_TAB_NUM    1
> +#endif
> +
> +
> +#ifndef DEFINESONLY
> +
> +#include <asm-generic/int-ll64.h>
> +
> +/*
> + * These structures represent the internal registers of the
> + * multi-channel DMA
> + */
> +struct dmaRegs {
> +	u32 taskbar;         /* task table base address register */
> +	u32 currPtr;
> +	u32 endPtr;
> +	u32 varTablePtr;
> +	u16 dma_rsvd0;
> +	u16 ptdControl;      /* ptd control */
> +	u32 intPending;      /* interrupt pending register */
> +	u32 intMask;         /* interrupt mask register */
> +	u16 taskControl[16]; /* task control registers */
> +	u8  priority[32];    /* priority registers */
> +	u32 initiatorMux;    /* initiator mux control */
> +	u32 taskSize0;       /* task size control register 0. */
> +	u32 taskSize1;       /* task size control register 1. */
> +	u32 dma_rsvd1;       /* reserved */
> +	u32 dma_rsvd2;       /* reserved */
> +	u32 debugComp1;      /* debug comparator 1 */
> +	u32 debugComp2;      /* debug comparator 2 */
> +	u32 debugControl;    /* debug control */
> +	u32 debugStatus;     /* debug status */
> +	u32 ptdDebug;        /* priority task decode debug */
> +	u32 dma_rsvd3[31];   /* reserved */
> +};
> +
> +extern struct dmaRegs *MCD_dmaBar;
> +
> +#endif
> +
> +/*
> + * PTD contrl reg bits
> + */
> +#define PTD_CTL_TSK_PRI         0x8000
> +#define PTD_CTL_COMM_PREFETCH   0x0001
> +
> +/*
> + * Task Control reg bits and field masks
> + */
> +#define TASK_CTL_EN             0x8000
> +#define TASK_CTL_VALID          0x4000
> +#define TASK_CTL_ALWAYS         0x2000
> +#define TASK_CTL_INIT_MASK      0x1f00
> +#define TASK_CTL_ASTRT          0x0080
> +#define TASK_CTL_HIPRITSKEN     0x0040
> +#define TASK_CTL_HLDINITNUM     0x0020
> +#define TASK_CTL_ASTSKNUM_MASK  0x000f
> +
> +/*
> + * Priority reg bits and field masks
> + */
> +#define PRIORITY_HLD            0x80
> +#define PRIORITY_PRI_MASK       0x07
> +
> +/*
> + * Debug Control reg bits and field masks
> + */
> +#define DBG_CTL_BLOCK_TASKS_MASK    0xffff0000
> +#define DBG_CTL_AUTO_ARM            0x00008000
> +#define DBG_CTL_BREAK               0x00004000
> +#define DBG_CTL_COMP1_TYP_MASK      0x00003800
> +#define DBG_CTL_COMP2_TYP_MASK      0x00000070
> +#define DBG_CTL_EXT_BREAK           0x00000004
> +#define DBG_CTL_INT_BREAK           0x00000002
> +
> +/*
> + * PTD Debug reg selector addresses
> + * This reg must be written with a value to show the contents of
> + * one of the desired internal register.
> + */
> +#define PTD_DBG_REQ             0x00 /* shows the state of 31 initiators */
> +#define PTD_DBG_TSK_VLD_INIT    0x01 /* shows which 16 tasks are valid and
> +					have initiators asserted */
> +
> +
> +/*
> + * General return values
> + */
> +#define MCD_OK                   0
> +#define MCD_ERROR               -1
> +#define MCD_TABLE_UNALIGNED     -2
> +#define MCD_CHANNEL_INVALID     -3
> +
> +/*
> + * MCD_initDma input flags
> + */
> +#define MCD_RELOC_TASKS         0x00000001
> +#define MCD_NO_RELOC_TASKS      0x00000000
> +#define MCD_COMM_PREFETCH_EN    0x00000002  /* Commbus Prefetching - MCF547x/548x ONLY */
> +
> +/*
> + * MCD_dmaStatus Status Values for each channel
> + */
> +#define MCD_NO_DMA  1 /* No DMA has been requested since reset */
> +#define MCD_IDLE    2 /* DMA active, but the initiator is currently inactive */
> +#define MCD_RUNNING 3 /* DMA active, and the initiator is currently active */
> +#define MCD_PAUSED  4 /* DMA active but it is currently paused */
> +#define MCD_HALTED  5 /* the most recent DMA has been killed with MCD_killTask() */
> +#define MCD_DONE    6 /* the most recent DMA has completed. */
> +
> +
> +/*
> + * MCD_startDma parameter defines
> + */
> +
> +/*
> + * Constants for the funcDesc parameter
> + */
> +/* Byte swapping: */
> +#define MCD_NO_BYTE_SWAP    0x00045670  /* to disable byte swapping. */
> +#define MCD_BYTE_REVERSE    0x00076540  /* to reverse the bytes of each u32 of the DMAed data. */
> +#define MCD_U16_REVERSE     0x00067450  /* to reverse the 16-bit halves of
> +					   each 32-bit data value being DMAed.*/
> +#define MCD_U16_BYTE_REVERSE    0x00054760 /* to reverse the byte halves of each
> +					    16-bit half of each 32-bit data value DMAed */
> +#define MCD_NO_BIT_REV  0x00000000  /* do not reverse the bits of each byte DMAed. */
> +#define MCD_BIT_REV     0x00088880  /* reverse the bits of each byte DMAed */
> +/* CRCing: */
> +#define MCD_CRC16       0xc0100000  /* to perform CRC-16 on DMAed data. */
> +#define MCD_CRCCCITT    0xc0200000  /* to perform CRC-CCITT on DMAed data. */
> +#define MCD_CRC32       0xc0300000  /* to perform CRC-32 on DMAed data. */
> +#define MCD_CSUMINET    0xc0400000  /* to perform internet checksums on DMAed data.*/
> +#define MCD_NO_CSUM     0xa0000000  /* to perform no checksumming. */
> +
> +#define MCD_FUNC_NOEU1 (MCD_NO_BYTE_SWAP | MCD_NO_BIT_REV | MCD_NO_CSUM)
> +#define MCD_FUNC_NOEU2 (MCD_NO_BYTE_SWAP | MCD_NO_CSUM)
> +
> +/*
> + * Constants for the flags parameter
> + */
> +#define MCD_TT_FLAGS_RL   0x00000001 /* Read line */
> +#define MCD_TT_FLAGS_CW   0x00000002 /* Combine Writes */
> +#define MCD_TT_FLAGS_SP   0x00000004 /* Speculative prefetch(XLB) MCF547x/548x ONLY  */
> +#define MCD_TT_FLAGS_PI   0x00000040 /* Precise Increment */
> +#define MCD_TT_FLAGS_MASK 0x000000ff
> +#define MCD_TT_FLAGS_DEF  (MCD_TT_FLAGS_RL | MCD_TT_FLAGS_CW)
> +
> +#define MCD_SINGLE_DMA  0x00000100 /* Unchained DMA */
> +#define MCD_CHAIN_DMA              /* TBD */
> +#define MCD_EU_DMA                 /* TBD */
> +#define MCD_FECTX_DMA   0x00001000 /* FEC TX ring DMA */
> +#define MCD_FECRX_DMA   0x00002000 /* FEC RX ring DMA */
> +
> +
> +/* these flags are valid for MCD_startDma and the chained buffer descriptors */
> +#define MCD_BUF_READY   0x80000000 /* indicates that this buffer is now under the DMA's control */
> +#define MCD_WRAP        0x20000000 /* to tell the FEC Dmas to wrap to the first BD */
> +#define MCD_INTERRUPT   0x10000000 /* to generate an interrupt after completion of the DMA. */
> +#define MCD_END_FRAME   0x08000000 /* tell the DMA to end the frame when transferring
> +				      last byte of data in buffer */
> +#define MCD_CRC_RESTART 0x40000000 /* to empty out the accumulated checksum
> +				      prior to performing the DMA. */
> +
> +/* Defines for the FEC buffer descriptor control/status word */
> +#define MCD_FEC_BUF_READY   0x8000
> +#define MCD_FEC_WRAP        0x2000
> +#define MCD_FEC_INTERRUPT   0x1000
> +#define MCD_FEC_END_FRAME   0x0800
> +
> +
> +/*
> + * Defines for general intuitiveness
> + */
> +
> +#define MCD_TRUE  1
> +#define MCD_FALSE 0
> +
> +/*
> + * Three different cases for destination and source.
> + */
> +#define MINUS1          -1
> +#define ZERO            0
> +#define PLUS1           1
> +
> +#ifndef DEFINESONLY
> +
> +/* Task Table Entry struct */
> +struct TaskTableEntry {
> +	u32 TDTstart;   /* task descriptor table start */
> +	u32 TDTend;     /* task descriptor table end */
> +	u32 varTab;     /* variable table start */
> +	u32 FDTandFlags;    /* function descriptor table start and flags */
> +	u32 descAddrAndStatus;
> +	u32 modifiedVarTab;
> +	u32 contextSaveSpace;   /* context save space start */
> +	u32 literalBases;
> +};
> +
> +/*
> + * These are the real and model task tables as generated by the
> + * build process
> + */
> +/* let's match the current definition in MCD_tasks.c */
> +extern const u32 MCD_realTaskTableSrc[];
> +extern const u32 MCD_modelTaskTableSrc[];
> +
> +extern u32 MCD_funcDescTab0[];
> +
> +/* Chained buffer descriptor */
> +struct MCD_bufDesc {
> +	u32 flags;         /* flags describing the DMA */
> +	u32 csumResult;    /* checksum from checksumming performed since last checksum reset */
> +	s8  *srcAddr;      /* the address to move data from */
> +	s8  *destAddr;     /* the address to move data to */
> +	s8  *lastDestAddr; /* the last address written to */
> +	u32 dmaSize;       /* the number of bytes to transfer independent of the transfer size */
> +	struct MCD_bufDesc *next; /* next buffer descriptor in chain */
> +	u32 info;          /* private information about this descriptor;  DMA does not affect it */
> +};
> +
> +extern struct MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
> +
> +/* Progress Query struct */
> +struct MCD_XferProg {
> +	s8 *lastSrcAddr;         /* the most-recent or last, post-increment source address */
> +	s8 *lastDestAddr;        /* the most-recent or last, post-increment destination address */
> +	u32  dmaSize;            /* the amount of data transferred for the current buffer */
> +	struct MCD_bufDesc *currBufDesc;/* pointer to the current buffer descriptor being DMAed */
> +};
> +
> +
> +/* FEC buffer descriptor */
> +struct MCD_bufDescFec {
> +	u16 statCtrl;
> +	u16 length;
> +	u32 dataPointer;
> +};
> +
> +
> +/*************************************************************************/
> +/*
> + * API function Prototypes  - see MCD_dmaApi.c for further notes
> + */
> +
> +/*
> + * MCD_startDma starts a particular kind of DMA .
> + */
> +int MCD_startDma(
> +	int channel,   /* the channel on which to run the DMA */
> +	s8  *srcAddr,  /* the address to move data from, or buffer-descriptor address */
> +	s16 srcIncr,   /* the amount to increment the source address per transfer */
> +	s8  *destAddr, /* the address to move data to */
> +	s16 destIncr,  /* the amount to increment the destination address per transfer */
> +	u32 dmaSize,   /* the number of bytes to transfer independent of the transfer size */
> +	u32 xferSize,  /* the number of bytes in each data movement (1, 2, or 4) */
> +	u32 initiator, /* what device initiates the DMA */
> +	int priority,  /* priority of the DMA */
> +	u32 flags,     /* flags describing the DMA */
> +	u32 funcDesc   /* a description of byte swapping, bit swapping, and CRC actions */
> +);
> +
> +/*
> + * MCD_initDma() initializes the DMA API by setting up a pointer to the DMA
> + * registers, relocating and creating the appropriate task structures, and
> + * setting up some global settings
> + */
> +int MCD_initDma(struct dmaRegs *sDmaBarAddr, void *taskTableDest, u32 flags);
> +
> +/*
> + * MCD_dmaStatus() returns the status of the DMA on the requested channel.
> + */
> +int MCD_dmaStatus(int channel);
> +
> +/*
> + * MCD_XferProgrQuery() returns progress of DMA on requested channel
> + */
> +int MCD_XferProgrQuery(int channel, struct MCD_XferProg *progRep);
> +
> +/*
> + * MCD_killDma() halts the DMA on the requested channel, without any
> + * intention of resuming the DMA.
> + */
> +int MCD_killDma(int channel);
> +
> +/*
> + * MCD_continDma() continues a DMA which as stopped due to encountering an
> + * unready buffer descriptor.
> + */
> +int MCD_continDma(int channel);
> +
> +/*
> + * MCD_pauseDma() pauses the DMA on the given channel ( if any DMA is
> + * running on that channel).
> + */
> +int MCD_pauseDma(int channel);
> +
> +/*
> + * MCD_resumeDma() resumes the DMA on a given channel (if any DMA is
> + * running on that channel).
> + */
> +int MCD_resumeDma(int channel);
> +
> +/*
> + * MCD_csumQuery provides the checksum/CRC after performing a non-chained DMA
> + */
> +int MCD_csumQuery(int channel, u32 *csum);
> +
> +/*
> + * MCD_getCodeSize provides the packed size required by the microcoded task
> + * and structures.
> + */
> +int MCD_getCodeSize(void);
> +
> +/*
> + * MCD_getVersion provides a pointer to a version string and returns a
> + * version number.
> + */
> +int MCD_getVersion(char **longVersion);
> +
> +#endif  /* DEFINESONLY */
> +
> +#endif /* _MCD_API_H */
> -- 
> 1.7.1
> 
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/