sdhc_test.c

s3c6400 ADS下官方测试程序

	printf ("Error Count : %d \n" , errorcount );
}

void SDHC_SetStartBlock(void)
{
	int x;

	printf("Enter the starting block to test :\n");
	x = GetIntNum();

	if (x != -1) {
		SDHC_descriptor.m_uStartBlockPos = x;
	}

	printf( "start Block addresss : %d\n" , SDHC_descriptor.m_uStartBlockPos );
}

void SDHC_SetBusWidth(void)
{
	u32 x;

	printf(" Enter the bus width (1, 4, 8): ");
	x = GetIntNum();

	if (x == 1 || x == 4 || x == 8) {
		SDHC_descriptor.m_ucBandwidth = x;
	}
	printf ( "bus width : %d\n", SDHC_descriptor.m_ucBandwidth );
}
 


void SDHC_SetClockSource(void)
{
	u8 x;

	printf("Enter the clk source (1=HCLK, 2=EPLL, 3=EXTCLK) : ");
	x = GetIntNum();

	if (x == 2) {
		SDHC_descriptor.m_eClockSource = SDHC_EPLL;
		printf ( "SDHC_EPLL select\n");
	}
	else if (x == 3) {
		SDHC_descriptor.m_eClockSource = SDHC_EXTCLK;
		printf ( "SDHC_EXTCLK select\n");
	}
	else {	// x==1 default
		SDHC_descriptor.m_eClockSource = SDHC_HCLK;
		printf ( "SDHC_HCLK select\n");
	}
}


void SDHC_SetSdClkDivisor(void)
{
	u32 x;

	printf("Enter the clk divisor ( 1,2,4,8,16,32,64,128,256) : ");
	x = GetIntNum();

	if  (x==0||x == 1||x == 2||x == 4||x == 8||x == 16||x == 32||x == 64||x == 128||x == 256) {
		SDHC_descriptor.m_uClockDivision = x;
	}
	printf( "Clock divisor : %d\n", SDHC_descriptor.m_uClockDivision );
}


void SDHC_SetNumOfBlocks(void)
{
	int num;

	printf("Enter the num. of blocks to test : ");
	num = GetIntNum();

	if (num != -1) {
		SDHC_descriptor.m_uOneBlockSize = num;
	}
	printf("Block size = %d\n" , SDHC_descriptor.m_uOneBlockSize );
}

void SDHC_SetOperationMode(void)
{
	int sel;

	printf(" 1: POLLING\n");
	printf(" 2: INTERRUPT\n");
	printf(" 3: DMA\n");
	printf("Select the op mode : ");

	sel = GetIntNum();

	if (sel == 1) {
		SDHC_descriptor.m_eOpMode = SDHC_POLLING_MODE;
		printf( "SDHC_POLLING_MODE\n");
	}
	else if (sel == 2) {
		SDHC_descriptor.m_eOpMode = SDHC_INTERRUPT_MODE;
		printf( "SDHC_INTERRUPT_MODE\n");
	}
	else {//if (sel == 3) {	Default.
		SDHC_descriptor.m_eOpMode = SDHC_DMA_MODE;
		printf( "SDHC_DMA_MODE\n");
	}
}

void SDHC_TestFileWriteAndRead(void)
{
	u32* uSrcAddr = SDHC_getBuffer(0, TRUE, FALSE);
	u32* uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);
	const char* pFileName = "test.bin";
	SDHC* card;

	card = &SDHC_descriptor;
	
	if (!SDHC_OpenMediaWithMode(4, SDHC_DMA_MODE, SDHC_HCLK, 4, SDHC_TEST_CHANNEL, card )
		|| !FAT_LoadFileSystem(card)) {
		Assert(0);
	}

//	FAT_WriteFile(pFileName, 3100, (u32)uSrcAddr, card);

	FAT_ReadFile5(pFileName, 0, 10, (u32)uDstAddr, card);	//*512
	
//	Assert(uSizeRead == card->m_uRemainBlock*512);

	if(!SDHC_DataCompare(uSrcAddr,uDstAddr,10<<7))	// *512/4
		printf(" Failed !!\n");

	FAT_UnloadFileSystem(card);
	SDHC_CloseMedia(card);
}

#if 0
static void TestFileRead(void)
{
	int i, sel;
	u32 size;

	for(i=0; i<=uLoopCnt ; i++)
	{
		if (!SDHC_OpenMedia(SDHC_HCLK, &oSdhc) || !FAT_LoadFileSystem(&oSdhc))
			Assert(0);

		sel = 0;

		FAT_ReadFile2(sel, CODEC_MEM_ST, &size, &oSdhc);
		Assert(size > 0);

		printf(" File size = %d\n", size);

		FAT_UnloadFileSystem(&oSdhc);
		SDHC_CloseMedia(&oSdhc);
	}
}
#endif

extern unsigned int sdhc_find_delay_tx;
extern unsigned int sdhc_find_delay_rx;
void SDHC_FindDelayValue(void) {
	int error_count =0;
	for ( sdhc_find_delay_tx=0; sdhc_find_delay_tx<4;sdhc_find_delay_tx++) {
		for( sdhc_find_delay_rx=0;sdhc_find_delay_rx<4;sdhc_find_delay_rx++ ) {
			printf( "=============Tx: %d ,, Rx: %d \n", sdhc_find_delay_tx, sdhc_find_delay_rx );
			if ( SDHC_SimpleRWTest() == FALSE ) {
				error_count++;
			}
		}
	}
	printf ( "error count : %d \n", error_count);
}

void SDHC_CardDetectionTest(void) {
	SDHC* oSdhc;
	
	oSdhc = &SDHC_descriptor;
	// channel initialize.
	SDHC_InitCh(SDHC_TEST_CHANNEL, oSdhc);
 	SDHC_CardDetection(oSdhc);
// 	*((volatile u32)0x7E00F804)
 	while ( 1 ) {
		if ( GetIntNum() == -1 ) {
			break;
		}
	}
}


// Don't support single block erasing.
void SDHC_CardEraseTest(void) {
	SDHC* oSdhc;
	//int i;
	u32* uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
	u32* uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);
	u32* tempAddr = SDHC_getBuffer(2, FALSE, TRUE);
	//u32 startAddress, blockSize;

	oSdhc = &SDHC_descriptor;

	if ( !SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return;
	}
	if (SDHC_WriteBlocks(0, 2000, (u32)uSrcAddr, oSdhc))
		printf(" Writing done.\n");
	else
		printf(" Writing failed !!\n");
	
	if ( SDHC_EraseBlocks( oSdhc, 0, 2) == FALSE ) {
		printf ( "Erase Error\n");
		return;
	}
	if (SDHC_ReadBlocks(0, 2000, (u32)uDstAddr, oSdhc))
		printf(" Reading done.\n");
	else
		printf(" Reading failed !!\n");

	SDHC_CloseMedia(oSdhc);
}


void SDHC_WakeupTest(void) {
	SDHC* oSdhc;

	oSdhc = &SDHC_descriptor;
	oSdhc->m_ucBandwidth = 4;
	oSdhc->m_eOpMode = SDHC_DMA_MODE;
	oSdhc->m_eChannel = SDHC_TEST_CHANNEL;
	oSdhc->m_uClockDivision = 2;
	SDHC_InitCh(SDHC_TEST_CHANNEL, oSdhc);
	SDHC_SetGPIO(oSdhc->m_eChannel, oSdhc->m_ucBandwidth);
	SDHC_ResetController(oSdhc);
 	SDHC_CardDetection(oSdhc);

 	// SDCLK Value Setting + Internal Clock Enable
	Outp16( oSdhc->m_uBaseAddr+SDHC_CLK_CTRL,
		(Inp16(oSdhc->m_uBaseAddr+SDHC_CLK_CTRL)&(~(0xff<<8)))|(1<<8)|(1<<0) );

	// CheckInternalClockStable
	while (!(Inp16( oSdhc->m_uBaseAddr+SDHC_CLK_CTRL )&0x2));

	SDHC_SetSdClockOnOff( TRUE, oSdhc);
	
//	*((volatile unsigned int*)0x7E00F804) &= ~(0x1<<14);
//	Outp8( oSdhc->m_uBaseAddr+SDHC_WAKEUP_CTRL, 0x06);	// connect wakeup source - Insert
//	Outp8( oSdhc->m_uBaseAddr+SDHC_WAKEUP_CTRL, 0x02);	// connect wakeup source - Remove
	Outp8( oSdhc->m_uBaseAddr+SDHC_WAKEUP_CTRL, 0x07);	// connect wakeup source - Insert/Remove
//	Outp8( oSdhc->m_uBaseAddr+SDHC_WAKEUP_CTRL, 0x06);	// connect wakeup source - Insert/Remove
}

void SDHC_TestSDIORW(void) {
	SDHC* oSdhc;
	u32* uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
	u32* uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);
	u32 startAddress, blockSize;

	oSdhc = &SDHC_descriptor;

	blockSize = oSdhc->m_uOneBlockSize;
	startAddress = oSdhc->m_uStartBlockPos;

	if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return;
	}

	SDHC_CMD53_RW(0, startAddress, blockSize, (u32)uSrcAddr, oSdhc);

	while( oSdhc->m_uRemainBlock != 0 );
	
	SDHC_CloseMedia( oSdhc );
}

void SDHC_TestSDIO_SuspendResume(void) {
	u32 result;
	u32 time;
	SDHC* oSdhc;
	u32* uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
	u32* uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);
	u32 startAddress, blockSize;

	oSdhc = &SDHC_descriptor;

	blockSize = oSdhc->m_uOneBlockSize;
	startAddress = oSdhc->m_uStartBlockPos;

	if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return;
	}
	
	result = SDHC_WriteBlocksSuspend(startAddress, blockSize, (u32)uSrcAddr, oSdhc);
	if ( result == TRUE ) {
		printf("Suspend Writing Success\n" );
	}
	else {
		printf("Suspend Writing Fail\n" );
	}

	StartTimer(0);
	result = SDHC_ReadBlocks(startAddress, blockSize, (u32)uDstAddr, oSdhc);
   	time = StopTimer(0);
	
	if (result == TRUE)
		printf(" Reading done[%f MB/S]\n", ((float)(blockSize<<9))/((float)time) );
	else
		printf(" Reading failed !!\n");

	SDHC_CloseMedia(oSdhc);

	if (SDHC_DataCompare( uSrcAddr, uDstAddr, blockSize<<7))
		printf(" Compare Ok.\n");
	else
		printf(" Mismatches !!\n");
	
	SDHC_CloseMedia( oSdhc );

}


void Test_SDHC(void)
{
	int i,sel;

	const testFuncMenu menu[]=
	{
//		SDHC_SimpleRWTest,				"SDHC_SimpleRWTest",
		SDHC_ComplexRWTest,			"SDHC_ComplexRWTest",
		SDHC_SetBusWidth,				"Set uBusWidth",
		SDHC_SetStartBlock,				"Set uStBlock",
		SDHC_SetNumOfBlocks,			"Set uBlocks", 
		SDHC_SetClockSource,			"Set eClkSrc",
		SDHC_SetSdClkDivisor,			"Set uClkDiv",
		SDHC_SetOperationMode,			"Set Operation Mode",
		SDHC_TestAboveAll,				"Test all the above cases\n",
		SDHC_TestFileWriteAndRead,		"Test File Read & Write",
		SDHC_FindDelayValue,			"FindDelayValue Test",
		SDHC_CardDetectionTest,			"SDHC_CardDetectionTest",
//		SDHC_WakeupTest,				"SDHC_WakeupTest", // move SYSCON.
		SDHC_CardEraseTest,			"SDHC_CardEraseTest",
//		SDHC_MoviBootloaderCopy,		"SDHC_MoviBootloaderCopy",
//		SDHC_PowerSelectTest,			"SDHC_PowerSelectTest",
		SDHC_AgingRWTest,				"SDHC_AgingRWTest",
		SDHC_AgingSingleRandomRWTest,	"SDHC_AgingSingleRandomRWTest",
		SDHC_AgingMultiRandomRWTest,	"SDHC_AgingMultiRandomRWTest",
		SDHC_AgingInit,					"SDHC_AgingInit",
		(void(*)(void))SDHC_BigBlockRWTest,	"SDHC_BigBlockRWTest",
		SDHC_AgingMultiBlockTest,		"SDHC_AgingMultiBlockTest",
		SDHC_TestSDIORW,				"SDHC_TestSDIORW",
		SDHC_TestSDIO_SuspendResume, "SDHC_TestSDIO_SuspendResume",
//		TestFileRead,				"Test File Read (Loop)",
		0,0
	};

	// EPLL_Setting.
//	SYSC_SetLockTime( eEPLL, 300);
//	SYSC_CtrlCLKOUT(eCLKOUT_EPLLOUT, 0);
//	SYSC_SetPLL(eEPLL, 100, 3, 2, 0);		// EPLL => 100MHz
//	Outp32( 0x7E00F01C, 7 );

	// Turn on USB Clock.
	*((volatile u32*)0x7E00F900) |= (1<<16);

	// youngbo.song - SYSCON Test.
/*
	// 1. MMC EPLL - source Setting.
	*((volatile u32*)0x7E00F01C) &= ~(0x3F<<18);
	//     Channel 0
	*((volatile u32*)0x7E00F01C) |= (0x0<<18);
	//     Channel 1
	*((volatile u32*)0x7E00F01C) |= (0x0<<20);
	//     Channel 2
	*((volatile u32*)0x7E00F01C) |= (0x0<<22);

	// 2. MMC EPLL - ratio setting.
	*((volatile u32*)0x7E00F024) &= ~(0xFFF<<0);
	//     Channel 0
	*((volatile u32*)0x7E00F024) |= (0x0<<0);
	//     Channel 1
	*((volatile u32*)0x7E00F024) |= (0x0<<4);
	//     Channel 2
	*((volatile u32*)0x7E00F024) |= (0x0<<8);

	// 3. MMC HCLK-Gate
	//     Channel 0
//	*((volatile u32*)0x7E00F030) &= ~(0x1<<17);
	//     Channel 1
//	*((volatile u32*)0x7E00F030) &= ~(0x1<<18);
	//     Channel 2
//	*((volatile u32*)0x7E00F030) &= ~(0x1<<19);

	// 4. MMC SCLK Gate
	//     SCLK_MMC2_48
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<29);
	//     SCLK_MMC1_48
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<28);
	//     SCLK_MMC0_48
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<27);
	//     SCLK_MMC2
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<26);
	//     SCLK_MMC1
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<25);
	//     SCLK_MMC0
//	*((volatile u32*)0x7E00F038) &= ~(0x1<<24);
*/
	// initial value.
	SDHC_descriptor.m_eChannel = SDHC_TEST_CHANNEL;
	SDHC_descriptor.m_eClockSource = SDHC_HCLK;
	SDHC_descriptor.m_eOpMode = SDHC_DMA_MODE;
	SDHC_descriptor.m_uStartBlockPos = 2100;// start Block address.
	SDHC_descriptor.m_ucBandwidth = 4;	// bandwidth.
	SDHC_descriptor.m_uClockDivision = 2;	// clock division
	SDHC_descriptor.m_uOneBlockSize = 2048;	// block size.

	while(1)
	{
		printf("\n ----------------------------------------------\n");
		for (i=0; (int)(menu[i].desc)!=0; i++) {
			printf("%2d: %s\n", i, menu[i].desc);
		}

		SDHC_DispCurrParams();

		printf("\nSelect the function to test : ");
		sel = GetIntNum();
		printf("\n");
		if(sel==-1) {
	   		break;		// return.
		}
		if (sel>=0 && sel<(sizeof(menu)/8-1)) {
			(menu[sel].func)();
		}
	}
}

void SDHC_GPIO_Test(void) {
	int i;

#if 0
	printf ( "GPG:%d Test\n", i );
	*((volatile unsigned int *)0x7F0080C0) = (0x1)<<(i*4);
	*((volatile unsigned int *)0x7F0080C8) = 0;
	while( 1 ) {
		*((volatile unsigned int *)0x7F0080C4) = 0<<i;
		Delay(1);
		*((volatile unsigned int *)0x7F0080C4) = 1<<i;
		Delay(1);
	}
#else
	i =9;
	printf ( "GPH:%d Test\n", i );
	if ( i <= 7 ) {
		*((volatile unsigned int *)0x7F0080E0) = (0x1)<<(i*4);
	}
	else {
		*((volatile unsigned int *)0x7F0080E0) = 0;
	}
	if ( i <= 7 ) {
		*((volatile unsigned int *)0x7F0080E4) = 0;
	}
	else {
		*((volatile unsigned int *)0x7F0080E4) =  (0x1)<<((i-8)*4);
	}
	
	while( 1 ) {
		*((volatile unsigned int *)0x7F0080E8) = 0<<i;
		Delay(1);
		*((volatile unsigned int *)0x7F0080E8) = 1<<i;
		Delay(1);
	}

#endif

}