diff --git a/.gdbinit b/.gdbinit
index dc2071d..f09210b 100644
--- a/.gdbinit
+++ b/.gdbinit
@@ -7,4 +7,6 @@ define tbtr
 	target remote | m68k-bdm-gdbserver pipe /dev/tblcf3
 end
 source mcf5474.gdb
+set breakpoint auto-hw
+
 
diff --git a/Makefile b/Makefile
index faccded..5f1b5fd 100644
--- a/Makefile
+++ b/Makefile
@@ -29,7 +29,7 @@ OBJCOPY=$(TCPREFIX)objcopy
 AR=$(TCPREFIX)ar
 RANLIB=$(TCPREFIX)ranlib
 
-INCLUDE=-Iinclude
+INCLUDE=-Iinclude -Imcdapi
 CFLAGS=-mcpu=5474\
 	   -Wall\
 	   -g\
@@ -72,6 +72,7 @@ CSRCS= \
 	$(SRCDIR)/wait.c \
 	$(SRCDIR)/s19reader.c \
 	$(SRCDIR)/flash.c \
+	$(SRCDIR)/spidma.c \
 	$(SRCDIR)/xhdi_sd.c \
 	$(SRCDIR)/xhdi_interface.c
 
@@ -113,7 +114,7 @@ $(FLASH_EXEC): TARGET_ADDRESS=0xe0000000
 $(FLASH_EXEC): LDCFILE=bas.lk
 $(FLASH_EXEC): MAPFILE=bas.map
 
-$(RAM_EXEC): TARGET_ADDRESS=0x00008000
+$(RAM_EXEC): TARGET_ADDRESS=0x1d000000
 $(RAM_EXEC): LDCFILE=ram.lk
 $(RAM_EXEC): MAPFILE=ram.map
 
diff --git a/bas.lk.in b/bas.lk.in
index 58ec480..3012104 100644
--- a/bas.lk.in
+++ b/bas.lk.in
@@ -30,6 +30,10 @@ SECTIONS
 		objs/supervisor.o(.text)
 		objs/illegal_instruction.o(.text)
 		objs/exceptions.o(.text)
+		objs/spidma.o(.text)
+		mcdapi/MCD_dmaApi.o(.text)
+		mcdapi/MCD_tasks.o(.text)
+		mcdapi/MCD_tasksInit.o(.text)
 		objs/xhdi_sd.o(.text)
 		objs/xhdi_interface.o(text)
 		objs/xhdi_vec.o(text)
diff --git a/include/bas_string.h b/include/bas_string.h
index 01ffe88..da02ffa 100644
--- a/include/bas_string.h
+++ b/include/bas_string.h
@@ -17,6 +17,7 @@ extern size_t strlen(const char *str);
 extern char *strcat(char *dst, const char *src);
 extern char *strncat(char *dst, const char *src, int max);
 extern int atoi(const char *c);
+extern void *memcpy(void *dst, const void *src, size_t n);
 
 #define isdigit(c)	(((c) >= '0') && ((c) <= '9'))
 #define isupper(c)	((c) >= 'A' && ((c) <= 'Z'))
diff --git a/include/spidma.h b/include/spidma.h
new file mode 100644
index 0000000..abdd4d0
--- /dev/null
+++ b/include/spidma.h
@@ -0,0 +1,16 @@
+/*
+ * spidma.h
+ *
+ *  Created on: 27.07.2013
+ *      Author: mfro
+ */
+
+#ifndef _SPIDMA_H_
+#define _SPIDMA_H_
+
+#include <MCF5475.h>
+
+extern int spidma_init(void);
+
+
+#endif /* _SPIDMA_H_ */
diff --git a/mcdapi/MCD_dmaApi.c b/mcdapi/MCD_dmaApi.c
index 839fce1..5c1803a 100755
--- a/mcdapi/MCD_dmaApi.c
+++ b/mcdapi/MCD_dmaApi.c
@@ -29,25 +29,21 @@ extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS];
 volatile TaskTableEntry *MCD_taskTable;
 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
-};
+{ 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);
+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
@@ -61,7 +57,6 @@ MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
 #endif
 MCD_bufDesc *MCD_relocBuffDesc;
 
-
 /*
  * Defines for the debug control register's functions
  */
@@ -118,11 +113,11 @@ MCD_bufDesc *MCD_relocBuffDesc;
 typedef struct MCD_remVariants_struct MCD_remVariant;
 struct MCD_remVariants_struct
 {
-   int remDestRsdIncr[NCHANNELS];  /* -1,0,1 */
-   int remSrcRsdIncr[NCHANNELS];   /* -1,0,1 */
-   s16 remDestIncr[NCHANNELS];     /* DestIncr */
-   s16 remSrcIncr[NCHANNELS];      /* srcIncr */
-   u32 remXferSize[NCHANNELS];     /* xferSize */
+	int remDestRsdIncr[NCHANNELS]; /* -1,0,1 */
+	int remSrcRsdIncr[NCHANNELS]; /* -1,0,1 */
+	s16 remDestIncr[NCHANNELS]; /* DestIncr */
+	s16 remSrcIncr[NCHANNELS]; /* srcIncr */
+	u32 remXferSize[NCHANNELS]; /* xferSize */
 };
 
 /*
@@ -145,162 +140,163 @@ MCD_remVariant MCD_remVariants;
  */
 extern u32 MCD_funcDescTab0[];
 
-int MCD_initDma (dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags)
+int MCD_initDma(dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags)
 {
-    int i;
-    TaskTableEntry *entryPtr;
+	int i;
+	TaskTableEntry *entryPtr;
 
-    /* setup the local pointer to register set */
-    MCD_dmaBar = dmaBarAddr;
+	/* 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 *tablePtr = taskTableDest;TBD*/
-        int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
-        int taskDescTabsOffset;
-        int taskTableSize, varTabsSize, funcDescTabsSize, contextSavesSize;
-        int taskDescTabSize;
+	/* do we need to move/create a task table */
+	if ((flags & MCD_RELOC_TASKS) != 0)
+	{
+		int fixedSize;
+		u32 *fixedPtr;
+		/*int *tablePtr = taskTableDest;TBD*/
+		int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
+		int taskDescTabsOffset;
+		int taskTableSize, varTabsSize, funcDescTabsSize, contextSavesSize;
+		int taskDescTabSize;
 
-        int i;
+		int i;
 
-        /* check if physical address is aligned on 512 byte boundary */
-        if (((u32)taskTableDest & 0x000001ff) != 0)
-            return(MCD_TABLE_UNALIGNED);
+		/* check if physical address is aligned on 512 byte boundary */
+		if (((u32) taskTableDest & 0x000001ff) != 0)
+			return (MCD_TABLE_UNALIGNED);
 
-        MCD_taskTable = taskTableDest; /* set up local pointer to task Table */
+		MCD_taskTable = taskTableDest; /* set up local pointer to task Table */
 
-        /*
-         * 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
-         */
+		/*
+		 * 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(TaskTableEntry);
-        /* align variable tables to size */
-        varTabsOffset = taskTableSize + (u32)taskTableDest;
-        if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0)
-            varTabsOffset = (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE);
-        /* align function descriptor tables */
-        varTabsSize = NCHANNELS * VAR_TAB_SIZE;
-        funcDescTabsOffset = varTabsOffset + varTabsSize;
+		taskTableSize = NCHANNELS * sizeof(TaskTableEntry);
+		/* align variable tables to size */
+		varTabsOffset = taskTableSize + (u32) taskTableDest;
+		if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0)
+			varTabsOffset = (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE);
+		/* align function descriptor tables */
+		varTabsSize = NCHANNELS * VAR_TAB_SIZE;
+		funcDescTabsOffset = varTabsOffset + varTabsSize;
 
-        if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0)
-            funcDescTabsOffset = (funcDescTabsOffset + FUNCDESC_TAB_SIZE) &
-            (~FUNCDESC_TAB_SIZE);
+		if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0)
+			funcDescTabsOffset = (funcDescTabsOffset + FUNCDESC_TAB_SIZE)
+					& (~FUNCDESC_TAB_SIZE);
 
-        funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE;
-        contextSavesOffset = funcDescTabsOffset + funcDescTabsSize;
-        contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE);
-        fixedSize = taskTableSize + varTabsSize + funcDescTabsSize +
-                    contextSavesSize;
+		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;
+		/* zero the thing out */
+		fixedPtr = (u32 *) taskTableDest;
+		for (i = 0; i < (fixedSize / 4); i++)
+			fixedPtr[i] = 0;
 
-        entryPtr = (TaskTableEntry*)MCD_taskTable;
-        /* set up fixed pointers */
-        for (i = 0; i < NCHANNELS; i++)
-        {
-            entryPtr[i].varTab = (u32)varTabsOffset; /* update ptr to local value */
-            entryPtr[i].FDTandFlags = (u32)funcDescTabsOffset | MCD_TT_FLAGS_DEF;
-            entryPtr[i].contextSaveSpace = (u32)contextSavesOffset;
-            varTabsOffset += VAR_TAB_SIZE;
+		entryPtr = (TaskTableEntry*) MCD_taskTable;
+		/* set up fixed pointers */
+		for (i = 0; i < NCHANNELS; i++)
+		{
+			entryPtr[i].varTab = (u32) varTabsOffset; /* update ptr to local value */
+			entryPtr[i].FDTandFlags = (u32) funcDescTabsOffset
+					| MCD_TT_FLAGS_DEF;
+			entryPtr[i].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;
+			funcDescTabsOffset += FUNCDESC_TAB_SIZE;
 #endif
-            contextSavesOffset += CONTEXT_SAVE_SIZE;
-        }
-        /* copy over the function descriptor table */
-        for ( i = 0; i < FUNCDESC_TAB_NUM; i++)
-        {
-            MCD_memcpy((void*)(entryPtr[i].FDTandFlags & ~MCD_TT_FLAGS_MASK),
-                       (void*)MCD_funcDescTab0, FUNCDESC_TAB_SIZE);
-        }
+			contextSavesOffset += CONTEXT_SAVE_SIZE;
+		}
+		/* copy over the function descriptor table */
+		for (i = 0; i < FUNCDESC_TAB_NUM; i++)
+		{
+			MCD_memcpy((void*) (entryPtr[i].FDTandFlags & ~MCD_TT_FLAGS_MASK),
+					(void*) MCD_funcDescTab0, FUNCDESC_TAB_SIZE);
+		}
 
-        /* copy model task table to where the context saves stuff leaves off*/
-        MCD_modelTaskTable = (TaskTableEntry*)contextSavesOffset;
+		/* copy model task table to where the context saves stuff leaves off*/
+		MCD_modelTaskTable = (TaskTableEntry*) contextSavesOffset;
 
-        MCD_memcpy ((void*)MCD_modelTaskTable, (void*)MCD_modelTaskTableSrc,
-                    NUMOFVARIANTS * sizeof(TaskTableEntry));
+		MCD_memcpy((void*) MCD_modelTaskTable, (void*) MCD_modelTaskTableSrc,
+				NUMOFVARIANTS * sizeof(TaskTableEntry));
 
-        entryPtr = MCD_modelTaskTable; /* point to local version of
-                                                            model task table */
-        taskDescTabsOffset = (u32)MCD_modelTaskTable +
-                            (NUMOFVARIANTS * sizeof(TaskTableEntry));
+		entryPtr = MCD_modelTaskTable; /* point to local version of
+		 model task table */
+		taskDescTabsOffset = (u32) MCD_modelTaskTable
+				+ (NUMOFVARIANTS * sizeof(TaskTableEntry));
 
-        /* copy actual task code and update TDT ptrs in local model task table */
-        for (i = 0; i < NUMOFVARIANTS; i++)
-        {
-            taskDescTabSize = entryPtr[i].TDTend - entryPtr[i].TDTstart + 4;
-            MCD_memcpy ((void*)taskDescTabsOffset, (void*)entryPtr[i].TDTstart, taskDescTabSize);
-            entryPtr[i].TDTstart = (u32)taskDescTabsOffset;
-            taskDescTabsOffset += taskDescTabSize;
-            entryPtr[i].TDTend = (u32)taskDescTabsOffset - 4;
-        }
+		/* copy actual task code and update TDT ptrs in local model task table */
+		for (i = 0; i < NUMOFVARIANTS; i++)
+		{
+			taskDescTabSize = entryPtr[i].TDTend - entryPtr[i].TDTstart + 4;
+			MCD_memcpy((void*) taskDescTabsOffset, (void*) entryPtr[i].TDTstart,
+					taskDescTabSize);
+			entryPtr[i].TDTstart = (u32) taskDescTabsOffset;
+			taskDescTabsOffset += taskDescTabSize;
+			entryPtr[i].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 = (MCD_bufDesc*)(entryPtr[NUMOFVARIANTS - 1].TDTend + 4);
+                         where they are since DMA might write to them */
+		MCD_relocBuffDesc = (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;
+		MCD_relocBuffDesc = MCD_singleBufDescs;
 #endif
-    }
-    else
-    {
-        /* point the would-be relocated task tables and the
-        buffer descriptors to the ones the linker generated */
+	}
+	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);
+		if (((u32) MCD_realTaskTableSrc & 0x000001ff) != 0)
+			return (MCD_TABLE_UNALIGNED);
 
-        /* need to add code to make sure that every thing else is aligned properly TBD*/
-        /* this is problematic if we init more than once or after running tasks,
-            need to add variable to see if we have aleady init'd */
-        entryPtr = MCD_realTaskTableSrc;
-        for (i = 0; i < NCHANNELS; i++)
-        {
-            if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) ||
-                ((entryPtr[i].FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0))
-                return(MCD_TABLE_UNALIGNED);
-        }
+		/* need to add code to make sure that every thing else is aligned properly TBD*/
+		/* this is problematic if we init more than once or after running tasks,
+		 need to add variable to see if we have aleady init'd */
+		entryPtr = MCD_realTaskTableSrc;
+		for (i = 0; i < NCHANNELS; i++)
+		{
+			if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0)
+					|| ((entryPtr[i].FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0))
+				return (MCD_TABLE_UNALIGNED);
+		}
 
-        MCD_taskTable = MCD_realTaskTableSrc;
-        MCD_modelTaskTable = MCD_modelTaskTableSrc;
-        MCD_relocBuffDesc = MCD_singleBufDescs;
-    }
+		MCD_taskTable = MCD_realTaskTableSrc;
+		MCD_modelTaskTable = MCD_modelTaskTableSrc;
+		MCD_relocBuffDesc = MCD_singleBufDescs;
+	}
 
+	/* Make all channels as totally inactive, and remember them as such: */
 
-    /* Make all channels as totally inactive, and remember them as such: */
+	MCD_dmaBar->taskbar = (u32) MCD_taskTable;
+	for (i = 0; i < NCHANNELS; i++)
+	{
+		MCD_dmaBar->taskControl[i] = 0x0;
+		MCD_chStatus[i] = MCD_NO_DMA;
+	}
 
-    MCD_dmaBar->taskbar = (u32) MCD_taskTable;
-    for (i = 0;  i < NCHANNELS;  i++)
-    {
-        MCD_dmaBar->taskControl[i] = 0x0;
-        MCD_chStatus[i] = MCD_NO_DMA;
-    }
+	/* Set up pausing mechanism to inactive state: */
+	MCD_dmaBar->debugComp1 = 0; /* no particular values yet for either comparator registers */
+	MCD_dmaBar->debugComp2 = 0;
+	MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
+	MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT;
 
-   /* Set up pausing mechanism to inactive state: */
-    MCD_dmaBar->debugComp1 = 0;  /* no particular values yet for either comparator registers */
-    MCD_dmaBar->debugComp2 = 0;
-    MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
-    MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT;
+	/* enable or disable commbus prefetch, really need an ifdef or
+	 something to keep from trying to set this in the 8220 */
+	if ((flags & MCD_COMM_PREFETCH_EN) != 0)
+		MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH;
+	else
+		MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH;
 
-    /* enable or disable commbus prefetch, really need an ifdef or
-       something to keep from trying to set this in the 8220 */
-    if ((flags & MCD_COMM_PREFETCH_EN) != 0)
-        MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH;
-    else
-        MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH;
-
-    return(MCD_OK);
+	return (MCD_OK);
 }
 /*********************** End of MCD_initDma() ***********************/
 
@@ -310,38 +306,38 @@ int MCD_initDma (dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags)
  * Arguments:  channel - channel number
  * Returns:    Predefined status indicators
  */
-int MCD_dmaStatus (int channel)
+int MCD_dmaStatus(int channel)
 {
-    u16 tcrValue;
+	u16 tcrValue;
 
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
 
-    tcrValue = 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)
-        {
-            MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
-            /* This register is selected to know which initiator is
-            actually asserted. */
-            if ((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];
+	tcrValue = 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)
+		{
+			MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
+			/* This register is selected to know which initiator is
+			 actually asserted. */
+			if ((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() ************************/
 
@@ -352,202 +348,219 @@ int MCD_dmaStatus (int channel)
  * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
  */
 
-int MCD_startDma (
-    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 */
+int MCD_startDma(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*/
+		s8 *srcAddrVirt /* virtual buffer descriptor address TBD*/
 #endif
-)
+		)
 {
-    int srcRsdIncr, destRsdIncr;
-    int *cSave;
-    short xferSizeIncr;
-    int tcrCount = 0;
+	int srcRsdIncr, destRsdIncr;
+	int *cSave;
+	short xferSizeIncr;
+	int tcrCount = 0;
 #ifdef MCD_INCLUDE_EU
-    u32 *realFuncArray;
+	u32 *realFuncArray;
 #endif
 
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
-        
-    /* tbd - need to determine the proper response to a bad funcDesc when not 
-       including EU functions, for now, assign a benign funcDesc, but maybe
-       should return an error */
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
+
+	/* tbd - need to determine the proper response to a bad funcDesc when not
+	 including EU functions, for now, assign a benign funcDesc, but maybe
+	 should return an error */
 #ifndef MCD_INCLUDE_EU
-    funcDesc = MCD_FUNC_NOEU1;
+	funcDesc = MCD_FUNC_NOEU1;
 #endif
-        
+
 #ifdef MCD_DEBUG
-printf("startDma:Setting up params\n");
+	printf("startDma:Setting up params\n");
 #endif
-   /* Set us up for task-wise priority.  We don't technically need to do this on every start, but
-      since the register involved is in the same longword as other registers that users are in control
-      of, setting it more than once is probably preferable.  That since the documentation doesn't seem
-      to be completely consistent about the nature of the PTD control register. */
-    MCD_dmaBar->ptdControl |= (u16) 0x8000;
+	/* Set us up for task-wise priority.  We don't technically need to do this on every start, but
+	 since the register involved is in the same longword as other registers that users are in control
+	 of, setting it more than once is probably preferable.  That since the documentation doesn't seem
+	 to be completely consistent about the nature of the PTD control register. */
+	MCD_dmaBar->ptdControl |= (u16) 0x8000;
 #if 1 /* Not sure what we need to keep here rtm TBD */
-    /* Calculate additional parameters to the regular DMA calls. */
-    srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0);
-    destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0);
+	/* 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;
+	xferSizeIncr = (xferSize & 0xffff) | 0x20000000;
 
-    /* Remember for each channel which variant is running. */
-    MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr;
-    MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr;
-    MCD_remVariants.remDestIncr[channel] = destIncr;
-    MCD_remVariants.remSrcIncr[channel] = srcIncr;
-    MCD_remVariants.remXferSize[channel] = xferSize;
+	/* Remember for each channel which variant is running. */
+	MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr;
+	MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr;
+	MCD_remVariants.remDestIncr[channel] = destIncr;
+	MCD_remVariants.remSrcIncr[channel] = srcIncr;
+	MCD_remVariants.remXferSize[channel] = xferSize;
 #endif
 
-    cSave = (int*)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET + CURRBD;
+	cSave = (int*) (MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET
+			+ CURRBD;
 
 #ifdef MCD_INCLUDE_EU /* may move this to EU specific calls */
-    realFuncArray = (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00);
-    /* Modify the LURC's normal and byte-residue-loop functions according to parameter. */
-    realFuncArray[(LURC*16)] = xferSize == 4 ?
-                                 funcDesc : xferSize == 2 ?
-                                     funcDesc & 0xfffff00f : funcDesc & 0xffff000f;
-    realFuncArray[(LURC*16+1)] = (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL;
+	realFuncArray = (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00);
+	/* Modify the LURC's normal and byte-residue-loop functions according to parameter. */
+	realFuncArray[(LURC*16)] = xferSize == 4 ?
+	funcDesc : xferSize == 2 ?
+	funcDesc & 0xfffff00f : funcDesc & 0xffff000f;
+	realFuncArray[(LURC*16+1)] = (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL;
 #endif
-   /* Write the initiator field in the TCR, and also set the initiator-hold
-      bit.  Note that,due to a hardware quirk, this could collide with an
-      MDE access to the initiator-register file, so we have to verify that the write
-      reads back correctly. */
+	/* Write the initiator field in the TCR, and also set the initiator-hold
+	 bit.  Note that,due to a hardware quirk, this could collide with an
+	 MDE access to the initiator-register file, so we have to verify that the write
+	 reads back correctly. */
 
-    MCD_dmaBar->taskControl[channel] =
-        (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
+	MCD_dmaBar->taskControl[channel] = (initiator << 8) | TASK_CTL_HIPRITSKEN
+			| TASK_CTL_HLDINITNUM;
 
-    while(((MCD_dmaBar->taskControl[channel] & 0x1fff) !=
-          ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) &&
-            (tcrCount < 1000))
-    {
-        tcrCount++;
-        /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020;*/
-        MCD_dmaBar->taskControl[channel] =
-            (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
-    }
+	while (((MCD_dmaBar->taskControl[channel] & 0x1fff)
+			!= ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM))
+			&& (tcrCount < 1000))
+	{
+		tcrCount++;
+		/*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020;*/
+		MCD_dmaBar->taskControl[channel] = (initiator << 8)
+				| TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
+	}
 
-    MCD_dmaBar->priority[channel] = (u8)priority & PRIORITY_PRI_MASK;
-    /* should be albe to handle this stuff with only one write to ts reg - tbd */
-    if (channel < 8 && channel >= 0)
-    {
-        MCD_dmaBar->taskSize0 &= ~(0xf << (7-channel)*4);
-        MCD_dmaBar->taskSize0 |= (xferSize & 3) << (((7 - channel)*4) + 2);
-        MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel)*4);
-    }
-    else
-    {
-        MCD_dmaBar->taskSize1 &= ~(0xf << (15-channel)*4);
-        MCD_dmaBar->taskSize1 |= (xferSize & 3) << (((15 - channel)*4) + 2);
-        MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel)*4);
-    }
+	MCD_dmaBar->priority[channel] = (u8) priority & PRIORITY_PRI_MASK;
+	/* should be albe to handle this stuff with only one write to ts reg - tbd */
+	if (channel < 8 && channel >= 0)
+	{
+		MCD_dmaBar->taskSize0 &= ~(0xf << (7 - channel) * 4);
+		MCD_dmaBar->taskSize0 |= (xferSize & 3) << (((7 - channel) * 4) + 2);
+		MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel) * 4);
+	}
+	else
+	{
+		MCD_dmaBar->taskSize1 &= ~(0xf << (15 - channel) * 4);
+		MCD_dmaBar->taskSize1 |= (xferSize & 3) << (((15 - channel) * 4) + 2);
+		MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel) * 4);
+	}
 
-    /* setup task table flags/options which mostly control the line buffers */
-    MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK;
-    MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
+	/* setup task table flags/options which mostly control the line buffers */
+	MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK;
+	MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
 
-    if (flags & MCD_FECTX_DMA)
-    {
-        /* TDTStart and TDTEnd */
-        MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECTX].TDTstart;
-        MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECTX].TDTend;
-        MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable, channel);
-    }
-    else if (flags & MCD_FECRX_DMA)
-    {
-        /* TDTStart and TDTEnd */
-        MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECRX].TDTstart;
-        MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECRX].TDTend;
-        MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable, channel);
-    }
-    else if(flags & MCD_SINGLE_DMA)
-    {
-        /* 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*/
-        MCD_relocBuffDesc[channel].srcAddr = srcAddr;
-        MCD_relocBuffDesc[channel].destAddr = destAddr;
-        MCD_relocBuffDesc[channel].lastDestAddr = destAddr;  /* definitely not its final value */
-        MCD_relocBuffDesc[channel].dmaSize = dmaSize;
-        MCD_relocBuffDesc[channel].flags = 0;       /* not used */
-        MCD_relocBuffDesc[channel].csumResult = 0;  /* not used */
-        MCD_relocBuffDesc[channel].next = 0;        /* not used */
+	if (flags & MCD_FECTX_DMA)
+	{
+		/* TDTStart and TDTEnd */
+		MCD_taskTable[channel].TDTstart =
+				MCD_modelTaskTable[TASK_FECTX].TDTstart;
+		MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECTX].TDTend;
+		MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable,
+				channel);
+	}
+	else if (flags & MCD_FECRX_DMA)
+	{
+		/* TDTStart and TDTEnd */
+		MCD_taskTable[channel].TDTstart =
+				MCD_modelTaskTable[TASK_FECRX].TDTstart;
+		MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECRX].TDTend;
+		MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable, channel);
+	}
+	else if (flags & MCD_SINGLE_DMA)
+	{
+		/* 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*/
+		MCD_relocBuffDesc[channel].srcAddr = srcAddr;
+		MCD_relocBuffDesc[channel].destAddr = destAddr;
+		MCD_relocBuffDesc[channel].lastDestAddr = destAddr; /* definitely not its final value */
+		MCD_relocBuffDesc[channel].dmaSize = dmaSize;
+		MCD_relocBuffDesc[channel].flags = 0; /* not used */
+		MCD_relocBuffDesc[channel].csumResult = 0; /* not used */
+		MCD_relocBuffDesc[channel].next = 0; /* not used */
 
-        /* Initialize the progress-querying stuff to show no progress:*/
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr;
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr;
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] =
-                                             (u32) &(MCD_relocBuffDesc[channel]);
-        /* tbd - need to keep the user from trying to call the EU routine
-           when MCD_INCLUDE_EU is not defined */
-        if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2)
-        {
-           /* TDTStart and TDTEnd */
-           MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart;
-           MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLENOEU].TDTend;
-           MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize,
-                                xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave,
-                                MCD_taskTable, channel);
-        }
-        else
-        {
-           /* TDTStart and TDTEnd */
-           MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLEEU].TDTstart;
-           MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLEEU].TDTend;
-           MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize,
-                              xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave,
-                              MCD_taskTable, channel);
-        }
-    }
-    else
-    { /* chained DMAS */
-        /* Initialize the progress-querying stuff to show no progress:*/
+		/* Initialize the progress-querying stuff to show no progress:*/
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[SRCPTR
+				+ CSAVE_OFFSET] = (int) srcAddr;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[DESTPTR
+				+ CSAVE_OFFSET] = (int) destAddr;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[DCOUNT
+				+ CSAVE_OFFSET] = 0;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[CURRBD
+				+ CSAVE_OFFSET] = (u32) &(MCD_relocBuffDesc[channel]);
+		/* tbd - need to keep the user from trying to call the EU routine
+		 when MCD_INCLUDE_EU is not defined */
+		if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2)
+		{
+			/* TDTStart and TDTEnd */
+			MCD_taskTable[channel].TDTstart =
+					MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart;
+			MCD_taskTable[channel].TDTend =
+					MCD_modelTaskTable[TASK_SINGLENOEU].TDTend;
+			MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr,
+					dmaSize, xferSizeIncr, flags,
+					(int *) &(MCD_relocBuffDesc[channel]), cSave, MCD_taskTable,
+					channel);
+		}
+		else
+		{
+			/* TDTStart and TDTEnd */
+			MCD_taskTable[channel].TDTstart =
+					MCD_modelTaskTable[TASK_SINGLEEU].TDTstart;
+			MCD_taskTable[channel].TDTend =
+					MCD_modelTaskTable[TASK_SINGLEEU].TDTend;
+			MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize,
+					xferSizeIncr, flags, (int *) &(MCD_relocBuffDesc[channel]),
+					cSave, MCD_taskTable, channel);
+		}
+	}
+	else
+	{ /* chained DMAS */
+		/* Initialize the progress-querying stuff to show no progress:*/
 #if 1 /* (!defined(MCD_NEED_ADDR_TRANS)) */
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
-          = (int)((MCD_bufDesc*) srcAddr)->srcAddr;
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
-          = (int)((MCD_bufDesc*) srcAddr)->destAddr;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[SRCPTR
+				+ CSAVE_OFFSET] = (int) ((MCD_bufDesc*) srcAddr)->srcAddr;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[DESTPTR
+				+ CSAVE_OFFSET] = (int) ((MCD_bufDesc*) srcAddr)->destAddr;
 #else /* if using address translation, need the virtual addr of the first buffdesc */
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
-          = (int)((MCD_bufDesc*) srcAddrVirt)->srcAddr;
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
-          = (int)((MCD_bufDesc*) srcAddrVirt)->destAddr;
+		((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
+		= (int)((MCD_bufDesc*) srcAddrVirt)->srcAddr;
+		((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
+		= (int)((MCD_bufDesc*) srcAddrVirt)->destAddr;
 #endif
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
-        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[DCOUNT
+				+ CSAVE_OFFSET] = 0;
+		((volatile int *) MCD_taskTable[channel].contextSaveSpace)[CURRBD
+				+ CSAVE_OFFSET] = (u32) srcAddr;
 
-        if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2)
-        {
-          /*TDTStart and TDTEnd*/
-          MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart;
-          MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINNOEU].TDTend;
-          MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr, xferSize,
-                                    xferSizeIncr, cSave, MCD_taskTable, channel);
-        }
-        else
-        {
-          /*TDTStart and TDTEnd*/
-          MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINEU].TDTstart;
-          MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINEU].TDTend;
-          MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, xferSize,
-                                 xferSizeIncr, cSave, MCD_taskTable, channel);
-        }
-    }
-    MCD_chStatus[channel] = MCD_IDLE;
-    return(MCD_OK);
+		if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2)
+		{
+			/*TDTStart and TDTEnd*/
+			MCD_taskTable[channel].TDTstart =
+					MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart;
+			MCD_taskTable[channel].TDTend =
+					MCD_modelTaskTable[TASK_CHAINNOEU].TDTend;
+			MCD_startDmaChainNoEu((int *) srcAddr, srcIncr, destIncr, xferSize,
+					xferSizeIncr, cSave, MCD_taskTable, channel);
+		}
+		else
+		{
+			/*TDTStart and TDTEnd*/
+			MCD_taskTable[channel].TDTstart =
+					MCD_modelTaskTable[TASK_CHAINEU].TDTstart;
+			MCD_taskTable[channel].TDTend =
+					MCD_modelTaskTable[TASK_CHAINEU].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() *********************/
@@ -584,117 +597,136 @@ printf("startDma:Setting up params\n");
  */
 #define STABTIME 0
 
-int MCD_XferProgrQuery (int channel, MCD_XferProg *progRep)
+int MCD_XferProgrQuery(int channel, MCD_XferProg *progRep)
 {
-    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 */
+	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 */
 
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
 
-    /* Read a trial value for the progress-reporting values*/
-    prevRep.lastSrcAddr =
-          (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
-    prevRep.lastDestAddr =
-          (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET];
-    prevRep.dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET];
-    prevRep.currBufDesc =
-          (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET];
-    /* Repeatedly reread those values until they match previous values: */
-    do {
-        /* Waste 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 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
-        progRep->lastDestAddr =
-            (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET];
-        progRep->dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET];
-        progRep->currBufDesc =
-            (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET];
-       /* 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);
+	/* Read a trial value for the progress-reporting values*/
+	prevRep.lastSrcAddr =
+			(s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR
+					+ CSAVE_OFFSET];
+	prevRep.lastDestAddr =
+			(s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR
+					+ CSAVE_OFFSET];
+	prevRep.dmaSize =
+			((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT
+					+ CSAVE_OFFSET];
+	prevRep.currBufDesc =
+			(MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD
+					+ CSAVE_OFFSET];
+	/* Repeatedly reread those values until they match previous values: */
+	do
+	{
+		/* Waste 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 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR
+						+ CSAVE_OFFSET];
+		progRep->lastDestAddr =
+				(s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR
+						+ CSAVE_OFFSET];
+		progRep->dmaSize =
+				((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT
+						+ CSAVE_OFFSET];
+		progRep->currBufDesc =
+				(MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD
+						+ CSAVE_OFFSET];
+		/* 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 the dCount, srcAddr and destAddr */
+	/* To calculate dmaCount, we consider destination address. C
+	 overs M1,P1,Z for destination */
+	switch (MCD_remVariants.remDestRsdIncr[channel])
+	{
+	case MINUS1:
+		subModVal = ((int) progRep->lastDestAddr)
+				& ((MCD_remVariants.remXferSize[channel]) - 1);
+		addModVal = ((int) progRep->currBufDesc->destAddr)
+				& ((MCD_remVariants.remXferSize[channel]) - 1);
+		LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal;
+		LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal;
+		destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr;
+		bytesNotXfered = (destDiffBytes / MCD_remVariants.remDestIncr[channel])
+				* (MCD_remVariants.remDestIncr[channel]
+						+ MCD_remVariants.remXferSize[channel]);
+		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 dCount. */
+		subModVal = ((int) progRep->currBufDesc->destAddr)
+				& ((MCD_remVariants.remXferSize[channel]) - 1);
+		/* These bytes are already in lastDestAddr. */
+		addModVal = ((int) progRep->lastDestAddr)
+				& ((MCD_remVariants.remXferSize[channel]) - 1);
+		LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal;
+		LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
+		destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
+		numIterations = (LWAlignedCurrDestAddr - LWAlignedInitDestAddr)
+				/ MCD_remVariants.remDestIncr[channel];
+		bytesNotXfered = numIterations
+				* (MCD_remVariants.remDestIncr[channel]
+						- MCD_remVariants.remXferSize[channel]);
+		progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
+		break;
+	default:
+		break;
+	}
 
-    /* Update the dCount, srcAddr and destAddr */
-    /* To calculate dmaCount, we consider destination address. C
-       overs M1,P1,Z for destination */
-    switch(MCD_remVariants.remDestRsdIncr[channel]) {
-        case MINUS1:
-           subModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
-           addModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
-           LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal;
-           LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal;
-           destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr;
-           bytesNotXfered = (destDiffBytes/MCD_remVariants.remDestIncr[channel]) *
-                            ( MCD_remVariants.remDestIncr[channel]
-                            + MCD_remVariants.remXferSize[channel]);
-           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 dCount. */
-           subModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
-           /* These bytes are already in lastDestAddr. */
-            addModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
-            LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal;
-            LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
-            destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
-            numIterations = ( LWAlignedCurrDestAddr - LWAlignedInitDestAddr)/MCD_remVariants.remDestIncr[channel];
-            bytesNotXfered =  numIterations *
-                ( MCD_remVariants.remDestIncr[channel]
-                  - MCD_remVariants.remXferSize[channel]);
-           progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
-           break;
-        default:
-           break;
-    }
+	/* This covers M1,P1,Z for source */
+	switch (MCD_remVariants.remSrcRsdIncr[channel])
+	{
+	case MINUS1:
+		progRep->lastSrcAddr = progRep->currBufDesc->srcAddr
+				+ (MCD_remVariants.remSrcIncr[channel]
+						* (progRep->dmaSize
+								/ MCD_remVariants.remXferSize[channel]));
+		break;
+	case ZERO:
+		progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
+		break;
+	case PLUS1:
+		progRep->lastSrcAddr = progRep->currBufDesc->srcAddr
+				+ (MCD_remVariants.remSrcIncr[channel]
+						* (progRep->dmaSize
+								/ MCD_remVariants.remXferSize[channel]));
+		break;
+	default:
+		break;
+	}
 
-    /* This covers M1,P1,Z for source */
-    switch(MCD_remVariants.remSrcRsdIncr[channel]) {
-        case MINUS1:
-            progRep->lastSrcAddr =
-                progRep->currBufDesc->srcAddr +
-                 ( MCD_remVariants.remSrcIncr[channel] *
-                   (progRep->dmaSize/MCD_remVariants.remXferSize[channel]));
-            break;
-        case ZERO:
-            progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
-            break;
-       case PLUS1:
-            progRep->lastSrcAddr =
-                progRep->currBufDesc->srcAddr +
-                 ( MCD_remVariants.remSrcIncr[channel] *
-                   (progRep->dmaSize/MCD_remVariants.remXferSize[channel]));
-          break;
-       default: break;
-    }
-
-    return(MCD_OK);
+	return (MCD_OK);
 }
 /******************* End of MCD_XferProgrQuery() ********************/
 
@@ -705,16 +737,19 @@ int MCD_XferProgrQuery (int channel, MCD_XferProg *progRep)
  * 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)
+static void MCD_resmActions(int channel)
 {
-   MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
-   MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus;
-   MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; /* This register is selected to know
-                                        which initiator is actually asserted. */
-   if((MCD_dmaBar->ptdDebug >> channel ) & 0x1)
-       MCD_chStatus[channel] = MCD_RUNNING;
-   else
-       MCD_chStatus[channel] = MCD_IDLE;
+	u32 debugStatus;
+
+	MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
+	debugStatus = MCD_dmaBar->debugStatus;
+	MCD_dmaBar->debugStatus = debugStatus;
+	MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; /* This register is selected to know
+	 which initiator is actually asserted. */
+	if ((MCD_dmaBar->ptdDebug >> channel) & 0x1)
+		MCD_chStatus[channel] = MCD_RUNNING;
+	else
+		MCD_chStatus[channel] = MCD_IDLE;
 }
 /********************* End of MCD_resmActions() *********************/
 
@@ -730,30 +765,30 @@ static void MCD_resmActions (int channel)
  *  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)
+int MCD_killDma(int channel)
 {
-   /* MCD_XferProg progRep; */
+	/* MCD_XferProg progRep; */
 
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
 
-    MCD_dmaBar->taskControl[channel] = 0x0;
-    MCD_resumeDma (channel);
-    /*
-     * This must be after the write to the TCR so that the task doesn't
-     * start up again momentarily, and before the status assignment so
-     * as to override whatever MCD_resumeDma() may do to the channel
-     * status.
-     */
-    MCD_chStatus[channel] = MCD_HALTED;
+	MCD_dmaBar->taskControl[channel] = 0x0;
+	MCD_resumeDma(channel);
+	/*
+	 * This must be after the write to the TCR so that the task doesn't
+	 * start up again momentarily, and before the status assignment so
+	 * as to override whatever MCD_resumeDma() may do to the channel
+	 * status.
+	 */
+	MCD_chStatus[channel] = MCD_HALTED;
 
-    /*
-     * Update the current buffer descriptor's lastDestAddr field
-     *
-     * MCD_XferProgrQuery (channel, &progRep);
-     * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
-     */
-    return(MCD_OK);
+	/*
+	 * Update the current buffer descriptor's lastDestAddr field
+	 *
+	 * MCD_XferProgrQuery (channel, &progRep);
+	 * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
+	 */
+	return (MCD_OK);
 }
 /************************ End of MCD_killDma() **********************/
 
@@ -768,15 +803,15 @@ int MCD_killDma (int channel)
  *  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)
+int MCD_continDma(int channel)
 {
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
 
-    MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN;
-    MCD_chStatus[channel] = MCD_RUNNING;
+	MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN;
+	MCD_chStatus[channel] = MCD_RUNNING;
 
-    return(MCD_OK);
+	return (MCD_OK);
 }
 /********************** End of MCD_continDma() **********************/
 
@@ -819,27 +854,27 @@ int MCD_continDma (int channel)
  * Arguments:   channel
  * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
  */
-int MCD_pauseDma (int channel)
+int MCD_pauseDma(int channel)
 {
-    /* MCD_XferProg progRep; */
+	/* MCD_XferProg progRep; */
 
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
 
-    if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
-    {
-        MCD_dmaBar->debugComp1 = channel;
-        MCD_dmaBar->debugControl = DBG_CTL_ENABLE | (1 << (channel + 16));
-        MCD_chStatus[channel] = MCD_PAUSED;
+	if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
+	{
+		MCD_dmaBar->debugComp1 = channel;
+		MCD_dmaBar->debugControl = DBG_CTL_ENABLE | (1 << (channel + 16));
+		MCD_chStatus[channel] = MCD_PAUSED;
 
-        /*
-         * Update the current buffer descriptor's lastDestAddr field
-         *
-         * MCD_XferProgrQuery (channel, &progRep);
-         * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
-         */
-    }
-    return(MCD_OK);
+		/*
+		 * Update the current buffer descriptor's lastDestAddr field
+		 *
+		 * MCD_XferProgrQuery (channel, &progRep);
+		 * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
+		 */
+	}
+	return (MCD_OK);
 }
 /************************* End of MCD_pauseDma() ********************/
 
@@ -850,15 +885,15 @@ int MCD_pauseDma (int 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)
+int MCD_resumeDma(int channel)
 {
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if ((channel < 0) || (channel >= NCHANNELS))
+		return (MCD_CHANNEL_INVALID);
 
-    if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
-        MCD_resmActions (channel);
+	if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
+		MCD_resmActions(channel);
 
-    return(MCD_OK);
+	return (MCD_OK);
 }
 /************************ End of MCD_resumeDma() ********************/
 
@@ -872,16 +907,16 @@ int MCD_resumeDma (int channel)
  * Notes:
  *
  */
-int MCD_csumQuery (int channel, u32 *csum)
+int MCD_csumQuery(int channel, u32 *csum)
 {
 #ifdef MCD_INCLUDE_EU
-    if((channel < 0) || (channel >= NCHANNELS))
-        return(MCD_CHANNEL_INVALID);
+	if((channel < 0) || (channel >= NCHANNELS))
+	return(MCD_CHANNEL_INVALID);
 
-    *csum = MCD_relocBuffDesc[channel].csumResult;
-    return(MCD_OK);
+	*csum = MCD_relocBuffDesc[channel].csumResult;
+	return(MCD_OK);
 #else
-    return(MCD_ERROR);
+	return (MCD_ERROR);
 #endif
 }
 /*********************** End of MCD_resumeDma() *********************/
@@ -894,9 +929,9 @@ int MCD_csumQuery (int channel, u32 *csum)
 int MCD_getCodeSize(void)
 {
 #ifdef MCD_INCLUDE_EU
-    return(0x2b5c);
+	return(0x2b5c);
 #else
-    return(0x173c);
+	return (0x173c);
 #endif
 }
 /********************** End of MCD_getCodeSize() ********************/
@@ -914,8 +949,8 @@ char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)";
 
 int MCD_getVersion(char **longVersion)
 {
-    *longVersion = MCD_versionString;
-    return((MCD_REV_MAJOR << 8) | MCD_REV_MINOR);
+	*longVersion = MCD_versionString;
+	return ((MCD_REV_MAJOR << 8) | MCD_REV_MINOR);
 }
 /********************** End of MCD_getVersion() *********************/
 
@@ -923,11 +958,11 @@ int MCD_getVersion(char **longVersion)
 /* Private version of memcpy()
  * Note that everything this is used for is longword-aligned.
  */
-static void MCD_memcpy (int *dest, int *src, u32 size)
+static void MCD_memcpy(int *dest, int *src, u32 size)
 {
-    u32 i;
+	u32 i;
 
-    for (i = 0;  i < size;  i += sizeof(int), dest++, src++)
-        *dest = *src;
+	for (i = 0; i < size; i += sizeof(int), dest++, src++)
+		*dest = *src;
 }
 /********************************************************************/
diff --git a/sources/BaS.c b/sources/BaS.c
index 55e2a2a..fff2d95 100644
--- a/sources/BaS.c
+++ b/sources/BaS.c
@@ -29,6 +29,7 @@
 #include "startcf.h"
 #include "cache.h"
 #include "bas_printf.h"
+#include "bas_string.h"
 #include "bas_types.h"
 #include "sd_card.h"
 #include "wait.h"
@@ -36,6 +37,7 @@
 #include "diskio.h"
 #include "ff.h"
 #include "s19reader.h"
+#include "spidma.h"
 
 /* imported routines */
 extern int mmu_init();
@@ -151,10 +153,15 @@ void nvram_init(void)
 	xprintf("finished\r\n");
 }
 
+/* ACP interrupt controller */
+#define FPGA_INTR_CONTRL	0xf0010000
+#define FPGA_INTR_ENABLE	0xf0010004
+#define FPGA_INTR_PENDIN	0xf0010008
+
 void enable_coldfire_interrupts()
 {
 	xprintf("enable interrupts: ");
-	* (volatile uint32_t *) 0xf0010004 = 0L;		/* disable all interrupts */
+	* (volatile uint32_t *) FPGA_INTR_CONTRL = 0L;		/* disable all interrupts */
 	MCF_EPORT_EPPAR = 0xaaa8;			/* all interrupts on falling edge */
 
 	MCF_GPT0_GMS = MCF_GPT_GMS_ICT(1) |	/* timer 0 on, video change capture on rising edge */
@@ -189,11 +196,7 @@ void BaS(void)
 
 	/* copy EMUTOS */
 	src = (uint8_t *) EMUTOS;
-	while (src < (uint8_t *)(EMUTOS + EMUTOS_SIZE))
-	{
-		*dst++ = *src++;
-	}
-
+	memcpy(dst, src, EMUTOS_SIZE);
 	xprintf("finished\r\n");
 
 	/* we have copied a code area, so flush the caches */
@@ -308,6 +311,8 @@ void BaS(void)
 	xprintf("Call OS. BaS initialization finished...\r\n");
 	enable_coldfire_interrupts();
 
+	spidma_init();
+
 	ROM_HEADER* os_header = (ROM_HEADER*)TOS;
 	os_header->initial_pc();
 }
diff --git a/sources/bas_string.c b/sources/bas_string.c
index 6fb19b5..f795a52 100644
--- a/sources/bas_string.c
+++ b/sources/bas_string.c
@@ -7,6 +7,16 @@
 
 #include "bas_string.h"
 
+void *memcpy(void *dst, const void *src, size_t n)
+{
+	char *to = dst;
+
+	while (to < (char *) dst + n)
+		*to++ = * (char *) src++;
+
+	return dst;
+}
+
 int strncmp(const char *s1, const char *s2, int max)
 {
 	int i;
diff --git a/sources/exceptions.S b/sources/exceptions.S
index 21332f2..dd5da07 100644
--- a/sources/exceptions.S
+++ b/sources/exceptions.S
@@ -100,9 +100,9 @@
 #define	 std_mmutr	(MCF_MMU_MMUTR_SG|MCF_MMU_MMUTR_V)
 #define	 mmuord_d	(                   MCF_MMU_MMUOR_ACC|MCF_MMU_MMUOR_UAA)
 #define	 mmuord_i	(MCF_MMU_MMUOR_ITLB|MCF_MMU_MMUOR_ACC|MCF_MMU_MMUOR_UAA)
-#define	 wt_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(00)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
-#define	 cb_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(01)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
-#define	 nc_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(10)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
+#define	 writethrough_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(00)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
+#define	 copyback_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(01)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
+#define	 nocache_precise_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(10)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
 //---------------------------------------------------
 /*********************************************************************
 *
@@ -519,10 +519,10 @@ irq6:				// mfp
 		add.l	#std_mmutr,d0
 		move.l	d3,d1				// page 0?
 		beq		irq6_sca_pn0		// ja ->
-		add.l	#cb_mmudr,d1		// sonst page cb
+		add.l	#copyback_mmudr,d1		// sonst page cb
 		bra		irq6_sca_pn1c
 irq6_sca_pn0:
-		add.l	#wt_mmudr|MCF_MMU_MMUDR_LK,d1	// page wt and locked
+		add.l	#writethrough_mmudr|MCF_MMU_MMUDR_LK,d1	// page wt and locked
 irq6_sca_pn1c:
 		mvz.w	#0x10b,d2			// MMU update 
 		move.l	d0,MCF_MMU_MMUTR	
@@ -824,7 +824,7 @@ video_copy_data_loop:
  		move.l	d4,MCF_MMU_MMUAR
 		move.l	d0,d1
 		add.l	#MCF_MMU_MMUTR_ID(sca_page_ID)|std_mmutr,d0
-		add.l	#0x60000000|wt_mmudr|MCF_MMU_MMUDR_LK,d1
+		add.l	#0x60000000|writethrough_mmudr|MCF_MMU_MMUDR_LK,d1
 		mvz.w	#0x10b,d2								// MMU update 
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
diff --git a/sources/mmc.c b/sources/mmc.c
index 30e3fb9..cd0df6f 100644
--- a/sources/mmc.c
+++ b/sources/mmc.c
@@ -93,7 +93,7 @@ static volatile DSTATUS Stat = 0 /* STA_NOINIT */;	/* Physical drive status */
 static uint8_t CardType;			/* Card type flags */
 
 
-static uint32_t dspi_fifo_val = // MCF_DSPI_DTFR_CONT |	/* enable continous chip select */
+static uint32_t dspi_fifo_val = MCF_DSPI_DTFR_CONT |	/* enable continous chip select */
 								/* CTAS use DCTAR0 for clock and attributes */
 								MCF_DSPI_DTFR_CTCNT;
 
diff --git a/sources/mmu.S b/sources/mmu.S
index c11ecd6..053110a 100644
--- a/sources/mmu.S
+++ b/sources/mmu.S
@@ -71,9 +71,9 @@
 #define	 std_mmutr	(MCF_MMU_MMUTR_SG|MCF_MMU_MMUTR_V)
 #define	 mmuord_d	(                   MCF_MMU_MMUOR_ACC|MCF_MMU_MMUOR_UAA)
 #define	 mmuord_i	(MCF_MMU_MMUOR_ITLB|MCF_MMU_MMUOR_ACC|MCF_MMU_MMUOR_UAA)
-#define	 wt_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(00)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
-#define	 cb_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(01)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
-#define	 nc_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(10)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
+#define	 writethrough_mmudr		(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(00)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
+#define	 copyback_mmudr			(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(01)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
+#define	 nocache_precise_mmudr	(MCF_MMU_MMUDR_SZ(00)|MCF_MMU_MMUDR_CM(10)|MCF_MMU_MMUDR_R|MCF_MMU_MMUDR_W|MCF_MMU_MMUDR_X)
 
 		.global _mmu_init
 		.global _mmutr_miss
@@ -112,66 +112,75 @@ _mmu_init:
 		move.l	#MCF_MMU_MMUOR_CA,d0	// clear all entries, 
 		move.l	d0,MCF_MMU_MMUOR		
 		nop
+
 // 0000'0000 locked
   		moveq.l	#0x00000000|std_mmutr,d0
-  		moveq.l	#0x00000000|cb_mmudr|MCF_MMU_MMUDR_LK,d1						 
-		moveq.l	#mmuord_d,d2								// MMU update date
-		moveq.l	#mmuord_i,d3								// MMU update instruction
+  		moveq.l	#0x00000000|copyback_mmudr|MCF_MMU_MMUDR_LK,d1
+		moveq.l	#mmuord_d,d2				// MMU update data
+		moveq.l	#mmuord_i,d3				// MMU update instruction
  		move.l	d0,MCF_MMU_MMUTR		
  		move.l	d1,MCF_MMU_MMUDR
- 		move.l	d2,MCF_MMU_MMUOR						// MMU update date
- 		move.l	d3,MCF_MMU_MMUOR						// MMU update instruction
+ 		move.l	d2,MCF_MMU_MMUOR			// MMU update data
+ 		move.l	d3,MCF_MMU_MMUOR			// MMU update instruction
 
 //---------------------------------------------------------------------------------------
 // 00d0'0000 locked ID=6
 // video ram: read write execute normal write true
  		move.l	#0x00d00000|MCF_MMU_MMUTR_ID(sca_page_ID)|std_mmutr,d0
-		move.l	#0x60d00000|wt_mmudr|MCF_MMU_MMUDR_LK,d1						 
+		move.l	#0x60d00000|writethrough_mmudr|MCF_MMU_MMUDR_LK,d1
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
-		move.l	d2,MCF_MMU_MMUOR						// MMU update date
+		move.l	d2,MCF_MMU_MMUOR						// MMU update data
  		move.l	#0x00d00000|std_mmutr,d0
 		move.l	d3,MCF_MMU_MMUOR						// MMU update instruction  
 		
 		move.l	#0x2000,d0
 		move.l	d0,_video_tlb							// set page as video page
   		clr.l	_video_sbt								// clear time
+
+#ifdef _NOT_USED_
 //-------------------------------------------------------------------------------------
 // Make the TOS (in SDRAM) read-only
  		move.l	#__TOS+std_mmutr,d0
-		move.l	#__TOS+cb_mmudr+MCF_MMU_MMUDR_LK,d1
+		move.l	#__TOS+copyback_mmudr+MCF_MMU_MMUDR_LK,d1
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
  		move.l	d2,MCF_MMU_MMUOR						// setzen read only ?????? noch nicht
 		move.l	d3,MCF_MMU_MMUOR						// setzen
+#endif /* _NOT_USED_ */
+
 // 00f0'0000 locked		
 		move.l	#0x00f00000|std_mmutr,d0
-		move.l	#0xfff00000|nc_mmudr|MCF_MMU_MMUDR_LK,d1						 
+		move.l	#0xfff00000|nocache_precise_mmudr|MCF_MMU_MMUDR_LK,d1
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
-		move.l	d2,MCF_MMU_MMUOR						// maped to ffffxxx, precise,  
-		move.l	d3,MCF_MMU_MMUOR						// maped to ffffxxx, precise,  
+		move.l	d2,MCF_MMU_MMUOR						// mapped to ffffxxx, precise,
+		move.l	d3,MCF_MMU_MMUOR						// mapped to ffffxxx, precise,
+
 // 1fe0'0000 locked
 		move.l	#0x1FE00000|std_mmutr,d0
-		move.l	#0x1FE00000|cb_mmudr|MCF_MMU_MMUDR_LK,d1						 
+		move.l	#0x1FE00000|copyback_mmudr|MCF_MMU_MMUDR_LK,d1
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
 		move.l	d2,MCF_MMU_MMUOR						// setzen data
 		move.l	d3,MCF_MMU_MMUOR						// setzen instr
-// 1ff0'0000 locked
+
+#ifdef _NOT_USED_
+// 1ff0'0000 locked (FIXME: why is this?)
 		move.l	#0x1FF00000|std_mmutr,d0
-		move.l	#0x1FF00000|cb_mmudr|MCF_MMU_MMUDR_LK,d1						 
+		move.l	#0x1FF00000|copyback_mmudr|MCF_MMU_MMUDR_LK,d1
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
 		move.l	d2,MCF_MMU_MMUOR						// setzen data
 		move.l	d3,MCF_MMU_MMUOR						// setzen instr 
 // instr 0xFFF0'0000 nach 0x1FF0'0000 umleiten -->> short sprung 
 /*		move.l	#0xFFF00000|std_mmutr,d0
-		move.l	#0x1FF00000|cb_mmudr|MCF_MMU_MMUDR_LK,d1						 
+		move.l	#0x1FF00000|copyback_mmudr|MCF_MMU_MMUDR_LK,d1
 		move.l	d0,MCF_MMU_MMUTR		
 		move.l	d1,MCF_MMU_MMUDR
 		move.l	d3,MCF_MMU_MMUOR						// setzen instr
 */
+#endif /* _NOT_USED_ */
 		move.l	(sp)+,d2			// Restore registers
 		move.l	(sp)+,d3
 		rts
@@ -185,7 +194,7 @@ _mmutr_miss:
 		or.l	#std_mmutr,d0	
 		move.l	d0,MCF_MMU_MMUTR
 		and.l	#0xFFF00000,d0
-		or.l	#cb_mmudr,d0		
+		or.l	#copyback_mmudr,d0
 		move.l	d0,MCF_MMU_MMUDR
 		moveq.l	#mmuord_d,d0					// MMU update data
 		move.l	d0,MCF_MMU_MMUOR				// set
diff --git a/sources/spidma.c b/sources/spidma.c
new file mode 100644
index 0000000..bf6527a
--- /dev/null
+++ b/sources/spidma.c
@@ -0,0 +1,26 @@
+/*
+ * spidma.c
+ *
+ *  Created on: 27.07.2013
+ *      Author: mfro
+ */
+
+#include "spidma.h"
+#include <MCD_dma.h>
+#include "bas_printf.h"
+
+extern char *_SYS_SRAM;
+
+int spidma_init(void)
+{
+	int res;
+
+	res = MCD_initDma((dmaRegs *) &MCF_DMA_TASKBAR, &_SYS_SRAM, MCD_RELOC_TASKS | MCD_COMM_PREFETCH_EN);
+	if (res != MCD_OK)
+	{
+		xprintf("DMA API initialization failed (0x%x)\r\n", res);
+		return 0;
+	}
+	xprintf("DMA API initialized. Tasks are at %p\r\n", &_SYS_SRAM);
+	return 1;
+}
diff --git a/sources/sysinit.c b/sources/sysinit.c
index 495ba84..0f2701b 100644
--- a/sources/sysinit.c
+++ b/sources/sysinit.c
@@ -30,6 +30,7 @@
 #include "cache.h"
 #include "sysinit.h"
 #include "bas_printf.h"
+#include "bas_string.h"
 #include "bas_types.h"
 #include "wait.h"
 
@@ -796,10 +797,10 @@ extern uint8_t _FIRETOS[];
 #define FIRETOS ((uint32_t)_FIRETOS) /* where FireTOS is stored in flash */
 
 extern uint8_t _BAS_LMA[];
-#define BAS_LMA ((uint32_t)_BAS_LMA) /* where the BaS is stored in flash */
+#define BAS_LMA (&_BAS_LMA[0]) /* where the BaS is stored in flash */
 
 extern uint8_t _BAS_IN_RAM[];
-#define BAS_IN_RAM ((uint32_t)_BAS_IN_RAM) /* where the BaS is run in RAM */
+#define BAS_IN_RAM (&_BAS_IN_RAM[0]) /* where the BaS is run in RAM */
 
 extern uint8_t _BAS_SIZE[];
 #define BAS_SIZE ((uint32_t)_BAS_SIZE) /* size of the BaS, in bytes */
@@ -808,11 +809,6 @@ extern uint8_t _FASTRAM_END[];
 #define FASTRAM_END ((uint32_t)_FASTRAM_END)
 
 void initialize_hardware(void) {
-	/* used in copy loop */
-	uint32_t *src;	/* src address to read from flash */
-	uint32_t *end;	/* end address to read from flash */
-	uint32_t *dst;	/* destination address to copy to */
-
 	/* Test for FireTOS switch: DIP switch #5 up */
 	if (!(DIP_SWITCH & (1 << 6))) {
 		/* Minimal hardware initialization */
@@ -923,22 +919,11 @@ void initialize_hardware(void) {
 	//video_1280_1024();
 	init_ac97();
 
-	/* copy the BaS .data and .bss contained in flash to its final location */
-	src = (uint32_t *) BAS_LMA;
-	end = (uint32_t *) (BAS_LMA + BAS_SIZE);
-	dst = (uint32_t *) BAS_IN_RAM;
-
-	xprintf("copying BaS data (%p - %p) to RAM (%p)\r\n", src, end, dst);
+	xprintf("copying BaS data (%p - %p) to RAM (%p)\r\n", BAS_LMA, BAS_LMA + BAS_SIZE, BAS_IN_RAM);
 	/* The linker script will ensure that the Bas size
 	 * is a multiple of the following.
 	 */
-	while (src < end)
-	{
-		*dst++ = *src++;
-		*dst++ = *src++;
-		*dst++ = *src++;
-		*dst++ = *src++;
-	}
+	memcpy((void *) BAS_IN_RAM, BAS_LMA, BAS_SIZE);
 	xprintf("finished.\r\n");
 
 	/* we have copied a code area, so flush the caches */