dma.c

三星s3c2460开发板完整功能测试代码

/*****************************************
  NAME: 24A0dma.c
  DESC: DMA memory to memory test
  HISTORY:
  2004.08.25 Baik Seung Woo  ver 0.0
 *****************************************/

#include <string.h>
#include "def.h"
#include "option.h"
#include "2460addr.h"
#include "2460lib.h"
#include "2460slib.h" 
#include "dma.h"
#include "type.h"
//#include "dma2.h"
//#include "extdmam.h"
//#include "extdmas.h"


//DMA channel
static void __irq Dma0Done(void);
static void __irq Dma1Done(void);
static void __irq Dma2Done(void);
static void __irq Dma3Done(void);

void M2M_test(int ch, int s_addr, int d_addr, int burst, int dsz, int tc);
void Test_DMA_Temp(void);


static volatile int dmaDone;

void * dma_func[][2]=
{
	(void *)Test_DMA,				"DMA M2M test(500KB)     ",
	(void *)Test_DMA_1MH,			"DMA M2M_test test(1MB)       ",
	(void *)Test_DMA_Temp,			"DMA M2M_test temp       ",
//	(void *)Test_DMAWorst,			"DMA 4-ch test           ",
//	(void *)Intro , 				"EXTDMA main B'd         ",
//	(void *)Test_Dmareq,			"EXTDMA REQUEST signal B'd ",
	(void *)Memory_Write_test,		"Address & data write test   ",
//	(void *)DMA_whole,              "DMA whole mode test     ",
	0,0
};

void Ch9_DMA(void)
{
	while(1)
	{
		int i = 0;
  		printf("\n");
		while(1)
		{	//display menu
			printf("%2d:%s\t",i,dma_func[i][1]);
			i++;
			if((int)(dma_func[i][0])==0)
			{
				printf("\n");
				break;
			}
			if((i%3)==0)
			printf("\n");
		}
		
		printf("\nSelect the function to test : ");
		i = GetIntNum();
		printf("\n");
	 	if(i==-1) break;
		if(i>=0 && (i<(sizeof(dma_func)/8)) ) 
		( (void (*)(void)) (dma_func[i][0]) )();			
	}
}

void Memory_Write_test(void)
{
	volatile unsigned int i,j;

	while(Uart_GetKey()!='\n')
	{
	printf("Type address....:");
		i = GetIntNum();
		if(i==-1) break;
	printf("Type data....  :");
	    j = GetIntNum();
		if(i==-1) break;
	*((unsigned int *)i) =j; 

	printf("Real Addr & Data  %x = %x\n",i,*((unsigned int *)i));
	}
}

/*
void DMA_whole(void)
{
	int i,memSum0;
	int s_addr, d_addr, trscount;
	
	printf("DMA whole mode test\n");

	pISR_DMA = (int)Dma0Done;
	rINTMSK = ~(BIT_DMA);
	rINTSUBMSK=~(BIT_SUB_DMA0);

	printf("Type the source addr:");
	s_addr=GetIntNum();

	printf("Type the destination addr:");
	d_addr=GetIntNum();
	
	for(i=s_addr;i<s_addr+trscount;i+=4)
	{
	*((unsigned int *)i)=i;
    memSum0+=i;
	}

	rDISRC0=s_addr;
	rDISRCC0=(0<<1)|(0<<0);
	rDIDST0=d_addr;
	rDIDSTC0=(0<<2)|(0<<1)|(0<<0);//Check Interrupt occurrence time
	rDCON0=((unsigned)1<<31)|(1<<30)|(1<<29)|(burst<<28)|(1<<27)|(0<<23)|(1<<22)|(dsz<<20)|(tc);
	rDMASKTRIG0=(1<<1)|(1<<0);

}
*/

void Test_DMA_1MH(void)
{
//ch-0

	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 0, 0xffff0);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 1, 0x7fff8);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 2, 0x3fffc);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100010, 1, 0, 0x3fffc);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100010, 1, 1, 0x1fffe);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100010, 1, 2, 0xffff);

	
//	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 2, 0xfffff);


//ch-1
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 0, 0xffff0);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 1, 0x7fff8);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 2, 0x3fffc);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 0, 0x3fffc);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 1, 0x1fffe);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 2, 0xffff);
 //ch-2
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 0, 0xffff0);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 1, 0x7fff8);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 2, 0x3fffc);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 0, 0x3fffc);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 1, 0x1fffe);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 2, 0xffff);
//ch-3
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 0, 0xffff0);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 1, 0x7fff8);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 0, 2, 0x3fffc);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 0, 0x3fffc);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 1, 0x1fffe);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x100000, 1, 2, 0xffff);

}

//temp for test : by khs.050711
#define DMA_SOURCE_ADDRESS		_NONCACHE_STARTADDRESS
#define DMA_DESTINATION_ADDRESS	(_NONCACHE_STARTADDRESS+0x00200000)
#define DMA_TRANSFER_SIZE		0x00200000
void Test_DMA_Temp(void)
{
  #if 1//original
	//UNIT
	printf("\n\n=UNIT=========");	
	printf("\n\n<1> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS));
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS), 0, 0, DMA_TRANSFER_SIZE/1);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS), 0, 1, DMA_TRANSFER_SIZE/2);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS), 0, 2, DMA_TRANSFER_SIZE/4);
	
	printf("\n\n<2> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+4));
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 0, 0, DMA_TRANSFER_SIZE/1);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 0, 1, DMA_TRANSFER_SIZE/2);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 0, 2, DMA_TRANSFER_SIZE/4);
	
	printf("\n\n<3> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+8));
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 0, 0, DMA_TRANSFER_SIZE/1);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 0, 1, DMA_TRANSFER_SIZE/2);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 0, 2, DMA_TRANSFER_SIZE/4);
	
	printf("\n\n<4> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+12));
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 0, 0, DMA_TRANSFER_SIZE/1);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 0, 1, DMA_TRANSFER_SIZE/2);
	M2M_test(0, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 0, 2, DMA_TRANSFER_SIZE/4);
	
	//BURST
	printf("\n\n=BURST=========\n");
	printf("\n\n<1> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS));
	M2M_test(2, DMA_SOURCE_ADDRESS, DMA_DESTINATION_ADDRESS, 1, 0, DMA_TRANSFER_SIZE/4);
	M2M_test(2, DMA_SOURCE_ADDRESS, DMA_DESTINATION_ADDRESS, 1, 1, DMA_TRANSFER_SIZE/8);
	M2M_test(2, DMA_SOURCE_ADDRESS, DMA_DESTINATION_ADDRESS, 1, 2, DMA_TRANSFER_SIZE/16);
	
	printf("\n\n<2> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+4));
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 1, 0, DMA_TRANSFER_SIZE/4);
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 1, 1, DMA_TRANSFER_SIZE/8);
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 1, 2, DMA_TRANSFER_SIZE/16);
	
	printf("\n\n<3> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+8));
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 1, 0, DMA_TRANSFER_SIZE/4);
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 1, 1, DMA_TRANSFER_SIZE/8);
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 1, 2, DMA_TRANSFER_SIZE/16);
	
	printf("\n\n<4> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+12));
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 1, 0, DMA_TRANSFER_SIZE/4);
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 1, 1, DMA_TRANSFER_SIZE/8);
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 1, 2, DMA_TRANSFER_SIZE/16);

  #else //temp for test
	printf("\n\n=BURST=========\n");
	printf("\n\n<1> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS));
	M2M_test(2, DMA_SOURCE_ADDRESS, DMA_DESTINATION_ADDRESS, 1, 2, DMA_TRANSFER_SIZE/16);
	
	printf("\n\n<2> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+4));
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+4), 1, 2, DMA_TRANSFER_SIZE/16);
	
	printf("\n\n<3> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+8));
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+8), 1, 2, DMA_TRANSFER_SIZE/16);
	
	printf("\n\n<4> 0x%08x => 0x%08x\n\n",DMA_SOURCE_ADDRESS,(DMA_DESTINATION_ADDRESS+12));
	M2M_test(2, DMA_SOURCE_ADDRESS, (DMA_DESTINATION_ADDRESS+12), 1, 2, DMA_TRANSFER_SIZE/16);
  #endif
}


void Test_DMA(void)
{

//ch-0

	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 0, 0x80000);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 1, 0x40000);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 2, 0x20000);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 0, 0x20000);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 1, 0x10000);
	M2M_test(0, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 2, 0x8000);

//ch-1
    M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 0, 0x80000);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 1, 0x40000);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 2, 0x20000);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 0, 0x20000);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 1, 0x10000);
	M2M_test(1, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 2, 0x8000);
//ch-2

	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 0, 0x80000);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 1, 0x40000);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 2, 0x20000);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 0, 0x20000);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 1, 0x10000);
	M2M_test(2, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 2, 0x8000);
//ch-3
    M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 0, 0x80000);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 1, 0x40000);
    M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 0, 2, 0x20000);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 0, 0x20000);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 1, 0x10000);
	M2M_test(3, _NONCACHE_STARTADDRESS, _NONCACHE_STARTADDRESS + 0x80000, 1, 2, 0x8000);

}

void M2M_test(int ch, int s_addr, int d_addr, int burst, int dsz, int tc)
{
	int i,j=0,k=0;
	unsigned int trscount;
	volatile unsigned int memSum0=0, memSum1=0;

	if(dsz==0)
	{
		trscount=tc*(burst ? 4:1)*1;
		printf("Transfer count1 =%x\n",trscount);
	}
	else if(dsz==1)
	{
		trscount=tc*(burst ? 4:1)*2;
		printf("Transfer count2 =%x\n",trscount);
	}
	else if(dsz==2)
	{
		trscount=tc*(burst ? 4:1)*4;
		printf("Transfer count3 =%x\n",trscount);
	}


	switch(ch)
		{
		case 0 : 
			pISR_DMA_SBUS= (int)Dma0Done;
			rINTMSK = ~(BIT_DMA_SBUS);
			rINTSUBMSK=~(BIT_SUB_DMA0);
			break;
		case 1 :
			pISR_DMA_SBUS = (int)Dma1Done;
			rINTMSK = ~(BIT_DMA_SBUS);
			rINTSUBMSK=~(BIT_SUB_DMA1);
			break;
		case 2 :
			pISR_DMA_SBUS = (int)Dma2Done;
			rINTMSK = ~(BIT_DMA_SBUS);
			rINTSUBMSK=~(BIT_SUB_DMA2);
			break;
		case 3 :
			pISR_DMA_SBUS = (int)Dma3Done;
			rINTMSK = ~(BIT_DMA_SBUS);
			rINTSUBMSK=~(BIT_SUB_DMA3);
			break;
		}

	dmaDone=0;

	for(i=s_addr;i<s_addr+trscount;i+=4)
		{
		*((unsigned int *)i)=i;
        memSum0+=i;
		}
	
	printf("DMA%d start\n",ch);


	switch(ch)
		{
		case 0 :
			rDISRC0=s_addr;
			rDISRCC0=(0<<1)|(0<<0);
			rDIDST0=d_addr;
			rDIDSTC0=(0<<1)|(0<<0);//Check Interrupt occurrence time
			rDCON0=((unsigned)1<<31)|(1<<30)|(1<<29)|(burst<<28)|(1<<27)|(1<<22)|(dsz<<20)|(tc);
			rDMAREQSEL0=0x0;
			rDMASKTRIG0=(0<<2)|(1<<1)|(1<<0);
/*						
			printf("%x\n",rDSTAT0);	
			printf("%x\n",rDSTAT0);	
			printf("%x\n",rDSTAT0);	
			printf("%x\n",rDSTAT0);	
			printf("%x\n",rDSTAT0);	
			printf("%x\n",rDSTAT0);
*/			
			break;
			
		case 1 :
			rDISRC1=s_addr;
			rDISRCC1=(0<<1)|(0<<0);
			rDIDST1=d_addr;
			rDIDSTC1=(0<<1)|(0<<0);//Check Interrupt occurrence time
			rDCON1=((unsigned)1<<31)|(1<<30)|(1<<29)|(burst<<28)|(1<<27)|(1<<22)|(dsz<<20)|(tc);
			rDMAREQSEL1=0x0;
			rDMASKTRIG1=(0<<2)|(1<<1)|(1<<0);
			break;

		case 2 :
			rDISRC2=s_addr;
			rDISRCC2=(0<<1)|(0<<0);
			rDIDST2=d_addr;
			rDIDSTC2=(0<<1)|(0<<0);//Check Interrupt occurrence time
			rDCON2=((unsigned)1<<31)|(1<<30)|(1<<29)|(burst<<28)|(1<<27)|(1<<22)|(dsz<<20)|(tc);
			rDMAREQSEL2=0x0;
			rDMASKTRIG2=(0<<2)|(1<<1)|(1<<0);
			break;


		case 3 :
			rDISRC3=s_addr;
			rDISRCC3=(0<<1)|(0<<0);
			rDIDST3=d_addr;
			rDIDSTC3=(0<<1)|(0<<0);//Check Interrupt occurrence time
			rDCON3=((unsigned)1<<31)|(1<<30)|(1<<29)|(burst<<28)|(1<<27)|(1<<22)|(dsz<<20)|(tc);
			rDMAREQSEL3=0x0;
			rDMASKTRIG3=(0<<2)|(1<<1)|(1<<0);
			break;
		}

/*	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
	printf("%x\n",rDSTAT0);	
*/	
	while(dmaDone==0);
	

	printf("%x\n",rDSTAT0);	


	printf("DMA transfer done.\n");

	rINTMSK = BIT_ALLMSK;
	rINTSUBMSK=BIT_SUB_ALLMSK1;

	j=0;
	
	for(k=d_addr;k<d_addr+trscount;k+=4) //Compare source data with destination data
	{
		if(*((unsigned int *)k) != s_addr+j)
			printf("Error!!! Src value=%x, Addr %x=%x\n",s_addr+j,k,*((unsigned int *)k));
		j=j+4;
	}
	
	for(i=d_addr;i<d_addr+trscount;i+=4)
	{
		memSum1+=*((unsigned int *)i);
	}

	printf("memSum0=%x,memSum1=%x\n",memSum0,memSum1);
	if(memSum0==memSum1)
		printf("DMA test result......................O.K.\n");
	else
		printf("DMA test result......................ERROR.\n");

}
	
void __irq Dma0Done(void)
{
	//printf("Current TC0 : %x\n",rDSTAT0);
	rSUBSRCPND=BIT_SUB_DMA0;
	ClearPending(BIT_DMA_SBUS);
	dmaDone=1;
}

void __irq Dma1Done(void)
{
	//printf("Current TC1 : %x\n",rDSTAT1);
	rSUBSRCPND=BIT_SUB_DMA1;
	ClearPending(BIT_DMA_SBUS);
	dmaDone=1;
}

void __irq Dma2Done(void)
{
	//printf("Current TC2 : %x\n",rDSTAT2);
	rSUBSRCPND=BIT_SUB_DMA2;
	ClearPending(BIT_DMA_SBUS);
	dmaDone=1;
}

void __irq Dma3Done(void)
{
	//printf("Current TC3 : %x\n",rDSTAT3);
	rSUBSRCPND=BIT_SUB_DMA3;
	ClearPending(BIT_DMA_SBUS);
	dmaDone=1;
}