nand_test.c

s3c6400 ADS下官方测试程序

			
        		UART_Printf("%02x ", aBuffer[i]);
		}
		UART_Printf("\n");

		UART_Printf("[Spare Area]");
		for(i=0 ; i<NAND_Inform[g_NandContNum].uSpareSize ; i++)
		{
			if(i%16==0)
	    			UART_Printf("\n%04xh:",i);
			
        		UART_Printf("%02x ", aSpareBuffer[i]);
		}
		UART_Printf("\n\n");
		
		UART_Printf("NAND Read Page : Success\n");
	}
	UART_Printf("\n");

	free(aBuffer);
	free(aSpareBuffer);	
}


//////////
// Function Name : NANDT_WritePage
// Function Description : Write 1 page data
// Input : 	eTest - Manual test or Auto test selection
//			oAutoVar - Parameters for Auto-Test
// Output : 	None
void NANDT_WritePage(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 i, uBlock, uPage;
	u8 uOffset;
	//u8 aBuffer[NAND_PAGE_MAX],  aSpareBuffer[NAND_SPARE_MAX];	
	u8 *aBuffer, *aSpareBuffer;
	NAND_eERROR eError;

	if(eTest == eTest_Manual)
		UART_Printf("[NANDT_WritePage]\n");

	if(eTest == eTest_Manual)
	{
		UART_Printf("Input the Block Number to write[0~%d] : ", NAND_Inform[g_NandContNum].uBlockNum-1);
		uBlock = UART_GetIntNum();
		UART_Printf("Input the Page Number to write[0~%d] : ", NAND_Inform[g_NandContNum].uPageNum-1);
		uPage = UART_GetIntNum();
		UART_Printf("Input the srand() offset data : ");
		uOffset = (u8)UART_GetIntNum();
		UART_Printf("\n");
	}
	else
	{
		uBlock = oAutoVar.Test_Parameter[0];
		uPage = oAutoVar.Test_Parameter[1];
		uOffset = oAutoVar.Test_Parameter[2];
	} 
	
	aBuffer = (u8 *)malloc(NAND_PAGE_MAX);
	if(aBuffer == 0)
	{
		UART_Printf("Memory Allocation Error...\n");
		UART_Getc();
		return;
	}	
	aSpareBuffer = (u8 *)malloc(NAND_SPARE_MAX);
	if(aSpareBuffer == 0)
	{
		UART_Printf("Memory Allocation Error...\n");
		free(aBuffer);
		UART_Getc();
		return;
	}

#if 1
	srand(uOffset);
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		aBuffer[i] = rand()%0xFF;
	}
#else
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		aBuffer[i] = i;
	}
#endif

	for(i=0 ; i<NAND_Inform[g_NandContNum].uSpareSize ; i++)
		aSpareBuffer[i] = 0xFF;	
	
	eError = NAND_WritePage(g_NandContNum, uBlock, uPage, aBuffer, aSpareBuffer);

	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		UART_Getc();
	}
	else
	{
		UART_Printf("[Main Area]");
		for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
		{
			if(i%16==0)
	    			UART_Printf("\n%04xh:",i);
			
        		UART_Printf("%02x ", aBuffer[i]);
		}
		UART_Printf("\n");
		
		UART_Printf("[Spare Area]");
		for(i=0 ; i<NAND_Inform[g_NandContNum].uSpareSize ; i++)
		{
			if(i%16==0)
	    			UART_Printf("\n%04xh:",i);
			
        		UART_Printf("%02x ", aSpareBuffer[i]);
		}
		UART_Printf("\n\n");
		
		UART_Printf("NAND Write Page : Success\n");
	}
	UART_Printf("\n");
	
	free(aBuffer);
	free(aSpareBuffer);
}


//////////
// Function Name : NANDT_WritePageVerify
// Function Description : Write 1 page data & Verfy
// Input : 	eTest - Manual test or Auto test selection
//			oAutoVar - Parameters for Auto-Test
// Output : 	None
void NANDT_WritePageVerify(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 i, uBlock, uPage;
	u8 uOffset;
	//u8 aBuffer[NAND_PAGE_MAX],  aSpareBuffer[NAND_SPARE_MAX];	
	u8 *aBuffer, *aSpareBuffer;
	u8 *pReadBuffer, *pReadSpareBuffer;
	NAND_eERROR eError;
	bool bError = FALSE;
	
	if(eTest == eTest_Manual)
		UART_Printf("[NANDT_WritePage]\n");

	if(eTest == eTest_Manual)
	{
		UART_Printf("Input the Block Number to write[0~%d] : ", NAND_Inform[g_NandContNum].uBlockNum-1);
		uBlock = UART_GetIntNum();
		UART_Printf("Input the Page Number to write[0~%d] : ", NAND_Inform[g_NandContNum].uPageNum-1);
		uPage = UART_GetIntNum();
		UART_Printf("Input the srand() offset data : ");
		uOffset = (u8)UART_GetIntNum();
		UART_Printf("\n");
	}
	else
	{
		uBlock = oAutoVar.Test_Parameter[0];
		uPage = oAutoVar.Test_Parameter[1];
		uOffset = oAutoVar.Test_Parameter[2];
	} 
	
	aBuffer = (u8 *)malloc(NAND_PAGE_MAX);
	if((aBuffer == 0))
	{
		UART_Printf("Memory Allocation Error...\n");
		UART_Getc();
		return;
	}
	
	aSpareBuffer = (u8 *)malloc(NAND_SPARE_MAX);
	if((aSpareBuffer == 0))
	{
		UART_Printf("Memory Allocation Error...\n");
		free(aBuffer);
		UART_Getc();
		return;
	}
	
	pReadBuffer = (u8 *)malloc(NAND_PAGE_MAX);
	if((pReadBuffer == 0))
	{
		UART_Printf("Memory Allocation Error...\n");
		free(aBuffer);
		free(aSpareBuffer);
		UART_Getc();
		return;
	}
	
	pReadSpareBuffer = (u8 *)malloc(NAND_SPARE_MAX);
	if((pReadSpareBuffer == 0))
	{
		UART_Printf("Memory Allocation Error...\n");
		free(aBuffer);
		free(aSpareBuffer);
		free(pReadBuffer);
		UART_Getc();
		return;
	}
	
#if 1
	srand(uOffset);
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		aBuffer[i] = rand()%0xFF;
	}
#else
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		aBuffer[i] = i;
	}
#endif

	for(i=0 ; i<NAND_Inform[g_NandContNum].uSpareSize ; i++)
		aSpareBuffer[i] = 0xFF;	
	
	eError = NAND_WritePage(g_NandContNum, uBlock, uPage, aBuffer, aSpareBuffer);

	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		UART_Getc();
		free(aBuffer);
		free(aSpareBuffer);
		free(pReadBuffer);
		free(pReadSpareBuffer);
		return;
	}

	// Read Buffer Clear
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		pReadBuffer[i] = 0;
	}
	
	eError = NAND_ReadPage(g_NandContNum, uBlock, uPage, pReadBuffer, pReadSpareBuffer);

	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		UART_Printf("Read page Error [%d block  %d page]\n", uBlock, uPage);
		UART_Getc();
		free(aBuffer);
		free(aSpareBuffer);
		free(pReadBuffer);
		free(pReadSpareBuffer);
		return;
	}
	else
	{	
		for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
		{
			if(pReadBuffer[i] != aBuffer[i])
			{
				UART_Printf("Write&Read Verify Error [%d Block : %d Page] :  \n", uBlock, uPage);
				UART_Printf("\t [Write data : Read data] = [0x%08x  : 0x%08x ]  \n", aBuffer[i], pReadBuffer[i]);
				UART_Getc();
				bError = TRUE;
				break;				
			}
		}
	}

	if(eTest == eTest_Manual)
	{
		if(bError == FALSE)
			UART_Printf("Write&Read Verify OK\n");
		UART_Printf("\n");
	}
	else
	{
		UART_Printf(".");
	}
	
	free(aBuffer);
	free(aSpareBuffer);
	free(pReadBuffer);
	free(pReadSpareBuffer);
}


const AutotestFuncMenu nand_ReadWrite_menu[] =
{
	NANDT_WritePage,					"Write Single Page       ",
	NANDT_ReadPage,                			"Read Single Page       ",	
	NANDT_WritePageVerify,				"Write & Verify Single Page",
	0, 0
};


void NANDT_ReadWrite(void)
{
	u32 i;
	s32 uSel;
	oFunctionT_AutoVar oAutoTest;

	UART_Printf("\n[NANDT_ReadWrite]\n");
	
	while(1)
	{
		UART_Printf("\n");
		for (i=0; (u32)(nand_ReadWrite_menu[i].desc)!=0; i++)
			UART_Printf("%2d: %s\n", i, nand_ReadWrite_menu[i].desc);

		UART_Printf("\nSelect the function to test : ");
		uSel =UART_GetIntNum();
		UART_Printf("\n");
		if(uSel == -1) 
			break;

		if (uSel>=0 && uSel<(sizeof(nand_ReadWrite_menu)/8-1))
			(nand_ReadWrite_menu[uSel].func) (eTest_Manual, oAutoTest);
	}
}



//////////
// Function Name : NANDT_EraseSingleBlock
// Function Description : Erase 1 block
// Input : 	eTest - Manual test or Auto test selection
//			oAutoVar - Parameters for Auto-Test
// Output : 	None
void NANDT_EraseSingleBlock(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 uBlock;
	NAND_eERROR eError;
	
	if(eTest == eTest_Manual)
		UART_Printf("[NANDT_EraseSingleBlock]\n");

	if(eTest == eTest_Manual)
	{
		UART_Printf("Input the Block Number to erase[0~%d]", NAND_Inform[g_NandContNum].uBlockNum-1);
		uBlock = UART_GetIntNum();
	}
	else
		uBlock = oAutoVar.Test_Parameter[0];
	
	eError = NAND_EraseSingleBlock(g_NandContNum, uBlock);

	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		UART_Getc();
	}
	else
	{
		if(eTest == eTest_Manual)
			UART_Printf("NAND Erase Block : Success\n\n");	
	}
}


//////////
// Function Name : NANDT_EraseMultiBlock
// Function Description : Erase Multi block
// Input : 	eTest - Manual test or Auto test selection
//			oAutoVar - Parameters for Auto-Test
// Output : 	None
void NANDT_EraseMultiBlock(eFunction_Test eTest, oFunctionT_AutoVar oAutoVar)
{
	u32 uBlock, uBlockNum;
	NAND_eERROR eError;

	if(eTest == eTest_Manual)
	{
		UART_Printf("[NANDT_EraseMultiBlock]\n");
	}
	
	if(NAND_Inform[g_NandContNum].uNandType == NAND_Normal8bit)	
	{
		if(eTest == eTest_Manual)
		{
			UART_Printf("Input the Start Block Number to erase the multi-block[0~%d]", NAND_Inform[g_NandContNum].uBlockNum-1);
			uBlock = UART_GetIntNum();		
			UART_Printf("Input the Block Number to erase[multiples of 4 : 0~%d]", NAND_Inform[g_NandContNum].uBlockNum-uBlock-1);
			uBlockNum = UART_GetIntNum();
		}	
		else
		{
			uBlock = oAutoVar.Test_Parameter[0];
			uBlockNum = oAutoVar.Test_Parameter[1];
		}
		//make the multiples of 4
		if(uBlockNum%4)
			uBlockNum += (4-(uBlockNum%4));		
	}
	else
	{
		if(eTest == eTest_Manual)
		{
			UART_Printf("Input the Start Block Number to erase the multi-block[multiples of 2 : 0~%d]", NAND_Inform[g_NandContNum].uBlockNum-1);
			uBlock = UART_GetIntNum();
			if(uBlock%2)		//uBlock is must be multiples of 2
				uBlock++;		
			UART_Printf("Input the Block Number to erase[multiples of 2 : 2~%d]", NAND_Inform[g_NandContNum].uBlockNum-uBlock);
			uBlockNum = UART_GetIntNum();
		}	
		else
		{
			uBlock = oAutoVar.Test_Parameter[0];
			uBlockNum = oAutoVar.Test_Parameter[1];
		}
		//make the multiples of 2
		if(uBlockNum%2)
			uBlockNum += (2-(uBlockNum%2));