sdhc_test.c

s3c6400 ADS下官方测试程序

/**************************************************************************************
* 
*	Project Name : S3C6400 Validation
*
*	Copyright 2006 by Samsung Electronics, Inc.
*	All rights reserved.
*
*	Project Description :
*		This software is only for validating functions of the S3C6400.
*		Anybody can use this software without our permission.
*  
*--------------------------------------------------------------------------------------
* 
*	File Name : sdhc_test.c
*  
*	File Description : This file implements the API functon for High Speed MMC.
*
*	Author : Youngbo.song
*	Dept. : AP Development Team
*	Created Date : 08.JAN.2007
*	Version : 0.1
* 
*	History
*	 1) 1st Made
*  
**************************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "def.h"
#include "option.h"
#include "library.h"
#include "sfr6400.h"
#include "system.h"
#include "intc.h"
#include "gpio.h"
#include "sdhc.h"
#include "sysc.h"
#include "fat.h"
#include "timer.h"

#define SDHC_TEST_CHANNEL SDHC_CHANNEL_0

//static INTC oIntc;
SDHC SDHC_descriptor;

void SDHC_DispCurrParams(void)
{
	SDHC* card = &SDHC_descriptor;
	printf("\n");

	if (card->m_eClockSource== SDHC_HCLK)
		printf(" eClkSrc = SDHC_HCLK,");
	else if (card->m_eClockSource == SDHC_EPLL)
		printf(" eClkSrc = SDHC_EPLL,");
	else if (card->m_eClockSource == SDHC_EXTCLK)
		printf("eClkSrc = SDHC_EXTCLK,");
	else
		printf("No Clock Selected.");
	
	printf(" uClkDiv = %d,", card->m_uClockDivision);
	printf(" uBusWidth = %d", card->m_ucBandwidth);
	printf(" uStBlock = %d, uBlocks = %d, ", card->m_uStartBlockPos, card->m_uOneBlockSize);

	if ( card->m_eOpMode == SDHC_POLLING_MODE )
		printf("SDHC_POLLING_MODE, ");
	else if ( card->m_eOpMode == SDHC_INTERRUPT_MODE )
		printf("SDHC_INTERRUPT_MODE, ");
	else if ( card->m_eOpMode == SDHC_DMA_MODE )
		printf("SDHC_DMA_MODE, ");
	else
		printf( "NO Operation Mode, " );
	printf("\n");
}


//////////
// File Name : SDHC_getBuffer
// File Description : get from mmc_test_buffer  from non-cachable area.
// Input : buffer index(per 1MB), is sequence data, clear buffer.
// Output : buffer pointer.
u32* SDHC_getBuffer(int index, bool sequence, bool clear) {
	u32* result, *p;
	int buffer_size = 0x100000;
	int i;
	int reqNum;
	
	result = (u32*)(CODEC_MEM_ST + index * buffer_size);
	
	if ( clear == TRUE ) {
		memset( result, 0, buffer_size );
	}
	p=result;
	if ( sequence == TRUE ) {
		reqNum = (int)(rand() & 0xfffffff);	// auto offset.
		for(i=buffer_size>>2;i>0;i--) {
			*p++=reqNum++;
			//*p++ = (i&1)?(0x55555555):(0xaaaaaaaa);
		}
	}
	return result;
}

//////////
// File Name : SDHC_DataCompare
// File Description : data compare function.
// Input : source1 pointer, source2 pointer, compare size( byte size ).
// Output : NONE.
bool SDHC_DataCompare(u32* source1, u32* source2, u32 bytes)
{	
	u32  ErrCnt = 0;
	u32 i;

	bytes = bytes >> 2;	// consider u32 type.
	for (i=0; i<bytes; i++) {
		if (*source1 != *source2) {
			if ( ErrCnt < 5 ) {
				printf("%08x=%08x <-> %08x=%08x\n", source1, *source1, source2, *source2);
			}
			ErrCnt++;
		}
		source1++;
		source2++;
	}

	if(ErrCnt == 0) {
		return TRUE;
	}
	printf("Total Error cnt = %d\n",ErrCnt);
	return FALSE;
}


bool SDHC_SimpleRWTest(void)
{
	SDHC* oSdhc;
	u32* uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
	u32* uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);
	u32 startAddress, blockSize;
	bool result;
	u32 time;
	
	oSdhc = &SDHC_descriptor;
	blockSize = oSdhc->m_uOneBlockSize;

//	oSdhc->m_ucBandwidth = 8;
	if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return FALSE;
	}
	DelayfrTimer(milli,1000);

	StartTimer(0);
	result = SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc);
   	time = StopTimer(0);
   	
	if (result == TRUE)
		printf(" Writing done. [%f]\n", ((float)(blockSize<<9))/((float)time) );
	else
		printf(" Writing failed !!\n");

	if (SDHC_ReadBlocks(startAddress, blockSize, (u32)uDstAddr, oSdhc))
		printf(" Reading done.\n");
	else
		printf(" Reading failed !!\n");

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

// up to 30MB R/W Test.
bool SDHC_BigBlockRWTest(void) {
	SDHC* oSdhc;
	u32* uSrcAddr;
	u32 startAddress, blockSize;
	int i;

	for(i=30;i>0;i--) {
		uSrcAddr = SDHC_getBuffer(i-1, FALSE, TRUE);
	}
	for(i=0;i<61440<<7;i++) {
		*(uSrcAddr+i) = i;
	}
	
	oSdhc = &SDHC_descriptor;
	blockSize = 61440;	// 30MB.
	startAddress = 9;

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

	if (SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc))
		printf(" Writing done.\n");
	else
		printf(" Writing failed !!\n");
	for(i=40;i>0;i--) {
		uSrcAddr = SDHC_getBuffer(i-1, FALSE, TRUE);
	}
	if (SDHC_ReadBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc))
		printf(" Reading done.\n");
	else
		printf(" Reading failed !!\n");

	SDHC_CloseMedia(oSdhc);

	// Data Compare.
	for(i=0;i<61440<<7;i++) {
		if ( *(uSrcAddr+i) != i ) {
			printf( "Error %x->%x\n", i, *(uSrcAddr+i) );
		}
	}

	return TRUE;
}

void SDHC_AgingRWTest(void) {
	SDHC* oSdhc;
	u32* uSrcAddr;
	u32* uDstAddr;
	u32 startAddress, blockSize;
	int result, w_time, r_time, i;
	
	oSdhc = &SDHC_descriptor;
	blockSize = oSdhc->m_uOneBlockSize;
	startAddress = 0;

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

	w_time = 0;
	r_time = 0;
	for (i=0;i<2000;i++) {
		uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
		uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);

		StartTimer(0);
		result = SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc);
		w_time = w_time + StopTimer(0);
		if (result == FALSE)
			printf(" Writing failed !!\n");

		StartTimer(0);
		result = SDHC_ReadBlocks(startAddress, blockSize, (u32)uDstAddr, oSdhc);
		r_time = r_time + StopTimer(0);
		if ( result == FALSE )
			printf(" Reading failed !%d!\n",i);

		if (!SDHC_DataCompare( uSrcAddr, uDstAddr, blockSize<<7)) {
			printf(" Mismatches !%d!\n",i);
		}
		startAddress = startAddress + blockSize;
		printf( "%d,", i );
	}
	printf("w[%f MB/S],", ((float)((blockSize*i)<<9))/((float)w_time) );
	printf("r[%f MB/S]\n", ((float)((blockSize*i)<<9))/((float)r_time) );
}

void SDHC_AgingSingleRandomRWTest(void) {
	SDHC* oSdhc;
	u32* uSrcAddr;
	u32* uDstAddr;
	u32 startAddress, blockSize;
	int i;
	
	oSdhc = &SDHC_descriptor;
	blockSize = 1;
	startAddress = 0;
	
	if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return;
	}

	for (i=0;i<0x2000000;i++) {
		uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
		uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);
		startAddress = rand() & 0x2FFFFF;
		if (!SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc)) {
			printf(" Writing failed !%d!\n",i);
		}

		if (!SDHC_ReadBlocks(startAddress, blockSize, (u32)uDstAddr, oSdhc)) {
			printf(" Reading failed !%d!\n",i);
		}

		if (!SDHC_DataCompare( uSrcAddr, uDstAddr, blockSize<<7)) {
			printf(" Mismatches !%d!\n",i);
		}
		printf( "%d,", i );
	}
}

void SDHC_AgingInit(void) {
	SDHC* oSdhc;
	int i;
	
	oSdhc = &SDHC_descriptor;

	for(i=0;i<0x200000;i++) {
		if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
									oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
			printf(" OpenMedia() failed !!!\n");
			return;
		}
		printf( "%d,",i);
	}
}

void SDHC_AgingMultiRandomRWTest(void) {
	SDHC* oSdhc;
	u32* uSrcAddr;
	u32* uDstAddr;
	u32 startAddress, blockSize;
	int i;
	
	oSdhc = &SDHC_descriptor;
	blockSize = 4096;
	startAddress = 0;
	
	if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return;
	}

	for (i=0;i<0x2000000;i++) {
		uSrcAddr = SDHC_getBuffer(1, TRUE, TRUE);
		uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
		uDstAddr = SDHC_getBuffer(3, FALSE, TRUE);
		uDstAddr = SDHC_getBuffer(2, FALSE, TRUE);
		startAddress = rand() & 0x2FFFFF;
		if (!SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc)) {
			printf(" Writing failed !%d!\n",i);
		}

		if (!SDHC_ReadBlocks(startAddress, blockSize, (u32)uDstAddr, oSdhc)) {
			printf(" Reading failed !%d!\n",i);
		}

		if (!SDHC_DataCompare( uSrcAddr, uDstAddr, blockSize<<7)) {
			printf(" Mismatches !%d!\n",i);
		}
		printf( "%d,", i );
	}
}

void SDHC_AgingMultiBlockTest(void) {
	SDHC* oSdhc;
	u32* uSrcAddr;
	u32* uDstAddr;
	u32 startAddress, blockSize;
	int result, w_time, r_time, i;
	
	oSdhc = &SDHC_descriptor;
	startAddress = 0;

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

	w_time = 0;
	r_time = 0;
	for (i=0;i<100;i++) {
		uSrcAddr = SDHC_getBuffer(0, TRUE, TRUE);
		uDstAddr = SDHC_getBuffer(1, FALSE, TRUE);

		blockSize = 16 * (i+1);
		StartTimer(0);
		result = SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc);
		w_time = w_time + StopTimer(0);
		if (result == FALSE)
			printf(" Writing failed !!\n");

		StartTimer(0);
		result = SDHC_ReadBlocks(startAddress, blockSize, (u32)uDstAddr, oSdhc);
		r_time = r_time + StopTimer(0);
		if ( result == FALSE )
			printf(" Reading failed !%d!\n",i);

		if (!SDHC_DataCompare( uSrcAddr, uDstAddr, blockSize<<7)) {
			printf(" Mismatches !%d!\n",i);
		}
		startAddress = startAddress + blockSize;
		printf( "%d,", i );
	}
}

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

	oSdhc = &SDHC_descriptor;

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

	Outp32( oSdhc->m_uBaseAddr+SDHC_CONTROL2, Inp32(oSdhc->m_uBaseAddr+SDHC_CONTROL2)|
		(1<<6)|(1<<3)|(1<<2)|(1<<1)|(1<<0) );
	
	if (!SDHC_OpenMediaWithMode(oSdhc->m_ucBandwidth, oSdhc->m_eOpMode, oSdhc->m_eClockSource,
								oSdhc->m_uClockDivision, oSdhc->m_eChannel, oSdhc)) {
		printf(" OpenMedia() failed !!!\n");
		return;
	}

	StartTimer(0);
	result = SDHC_WriteBlocks(startAddress, blockSize, (u32)uSrcAddr, oSdhc);
	time = StopTimer(0);
   	
	if (result == TRUE)
		printf(" Writing done. [%f MB/S]\n", ((float)(blockSize<<9))/((float)time) );
	else
		printf(" Writing failed !!\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");
}

void SDHC_TestAboveAll(void)
{
	int x;		// for input block size.
	int j, i;	// for loop.
//	u32 auBusWidth[] = {1, 4, 8};
	SDHC_clockSource aeClkSrc[] = {SDHC_HCLK, SDHC_EPLL};//, SDHC_EXTCLK};
//	u32 auClkDivisor[] = {1, 2, 4, 8};
	u32 auClkDivisor[] = {1, 1, 1, 1};
	int errorcount = 0;
	printf(" Number of blocks to test (%d) : ", SDHC_descriptor.m_uRemainBlock);
	x = GetIntNum();
	if (x != -1)
		SDHC_descriptor.m_uRemainBlock = x;

//	for (k=0; k<sizeof(auBusWidth)/sizeof(u32); k++) {
		for (j=0; j<sizeof(aeClkSrc)/sizeof(SDHC_clockSource); j++) {
			for (i=0; i<sizeof(auClkDivisor)/sizeof(u32); i++) {
				SDHC_descriptor.m_uClockDivision = auClkDivisor[i];
				SDHC_descriptor.m_eClockSource = aeClkSrc[j];
//				SDHC_descriptor.m_ucBandwidth = auBusWidth[k];
				SDHC_DispCurrParams();
				if ( SDHC_SimpleRWTest() == FALSE ) {
					errorcount++;
				}
			}
		}
//	}