nand_test.c

s3c6400 ADS下官方测试程序

		if( (NAND_EccError.uEccErrByte1 != aNANDT_EccError[0][0]) || (NAND_EccError.uEccErrBit1 != aNANDT_EccError[0][1]) )
		{
			UART_Printf("Ecc Error Check Error[%d byte:%d bit] != [%d byte:%d bit] \n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																		aNANDT_EccError[0][0], aNANDT_EccError[0][1]);	
			UART_Getc();
			NAND_Inform[g_NandContNum].uECCtest = 0;
			NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
			return;
		}
	}
	else if(uErrorType == NAND_ECCERR_2BIT)
	{
		if( 	((NAND_EccError.uEccErrByte1 != aNANDT_EccError[0][0]) || (NAND_EccError.uEccErrBit1 != aNANDT_EccError[0][1])) ||
			((NAND_EccError.uEccErrByte2 != aNANDT_EccError[1][0]) || (NAND_EccError.uEccErrBit2 != aNANDT_EccError[1][1])) )
		{
			UART_Printf("Ecc Error Check Error[%d byte:%d bit] != [%d byte:%d bit] \n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																		aNANDT_EccError[0][0], aNANDT_EccError[0][1]);	
			UART_Printf("                     [%d byte:%d bit] != [%d byte:%d bit] \n", 	NAND_EccError.uEccErrByte2, NAND_EccError.uEccErrBit2,
																	aNANDT_EccError[1][0], aNANDT_EccError[1][1]);						
			UART_Getc();
			NAND_Inform[g_NandContNum].uECCtest = 0;
			NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
			return;
		}
	}
	else if(uErrorType == NAND_ECCERR_3BIT)
	{
		if( 	((NAND_EccError.uEccErrByte1 != aNANDT_EccError[0][0]) || (NAND_EccError.uEccErrBit1 != aNANDT_EccError[0][1])) ||
			((NAND_EccError.uEccErrByte2 != aNANDT_EccError[1][0]) || (NAND_EccError.uEccErrBit2 != aNANDT_EccError[1][1])) ||
			((NAND_EccError.uEccErrByte3 != aNANDT_EccError[2][0]) || (NAND_EccError.uEccErrBit3 != aNANDT_EccError[2][1])) )
		{
			UART_Printf("Ecc Error Check Error[%d byte:%d bit] != [%d byte:%d bit] \n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																		aNANDT_EccError[0][0], aNANDT_EccError[0][1]);	
			UART_Printf("                     [%d byte:%d bit] != [%d byte:%d bit] \n", 	NAND_EccError.uEccErrByte2, NAND_EccError.uEccErrBit2,
																	aNANDT_EccError[1][0], aNANDT_EccError[1][1]);
			UART_Printf("                     [%d byte:%d bit] != [%d byte:%d bit] \n", 	NAND_EccError.uEccErrByte3, NAND_EccError.uEccErrBit3,
																	aNANDT_EccError[2][0], aNANDT_EccError[2][1]);
			UART_Getc();
			NAND_Inform[g_NandContNum].uECCtest = 0;
			NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
			return;
		}
	}
	else if(uErrorType == NAND_ECCERR_4BIT)
	{
		if( 	((NAND_EccError.uEccErrByte1 != aNANDT_EccError[0][0]) || (NAND_EccError.uEccErrBit1 != aNANDT_EccError[0][1])) ||
			((NAND_EccError.uEccErrByte2 != aNANDT_EccError[1][0]) || (NAND_EccError.uEccErrBit2 != aNANDT_EccError[1][1])) ||
			((NAND_EccError.uEccErrByte3 != aNANDT_EccError[2][0]) || (NAND_EccError.uEccErrBit3 != aNANDT_EccError[2][1])) ||
			((NAND_EccError.uEccErrByte4 != aNANDT_EccError[3][0]) || (NAND_EccError.uEccErrBit4 != aNANDT_EccError[3][1])) )
		{
			UART_Printf("Ecc Error Check Error[%d byte:%d bit] != [%d byte:%d bit] \n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																		aNANDT_EccError[0][0], aNANDT_EccError[0][1]);	
			UART_Printf("                     [%d byte:%d bit] != [%d byte:%d bit] \n", 	NAND_EccError.uEccErrByte2, NAND_EccError.uEccErrBit2,
																	aNANDT_EccError[1][0], aNANDT_EccError[1][1]);
			UART_Printf("                     [%d byte:%d bit] != [%d byte:%d bit] \n", 	NAND_EccError.uEccErrByte3, NAND_EccError.uEccErrBit3,
																	aNANDT_EccError[2][0], aNANDT_EccError[2][1]);
			UART_Printf("                     [%d byte:%d bit] != [%d byte:%d bit] \n", 	NAND_EccError.uEccErrByte4, NAND_EccError.uEccErrBit4,
																	aNANDT_EccError[3][0], aNANDT_EccError[3][1]);
			UART_Getc();
			NAND_Inform[g_NandContNum].uECCtest = 0;
			NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
			return;
		}
	}
	else if(uErrorType == NAND_ECCERR_UNCORRECT)
	{
		if( aNANDT_EccError[0][0] != NAND_ECC_UNCORRECT_ERROR)
		{
			UART_Printf("Uncorrectable Ecc Error Check Error\n");	
			aNANDT_EccError[0][0] = 0;
			UART_Getc();
			NAND_Inform[g_NandContNum].uECCtest = 0;
			NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
			return;
		}
		aNANDT_EccError[0][0] = 0;
	}				

	NAND_Inform[g_NandContNum].uECCtest = 0;
	NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
	
	UART_Printf("MLC Nand ECC test complete & OK...!!\n");
	UART_Printf("\n");	
}


//////////
// Function Name : NANDT_SLCECC_All
// Function Description : This function checks the ECC operation (all bit of SLC Nand Device 1 page)
// Input : 	None
// Output : 	None
void NANDT_SLCECC_All(void)
{
	u32 i, j, uBlock, uPage, uError, uErrorType;
	u8 aBuffer[NAND_PAGE_MAX];
	u8 aSpareBuffer[NAND_SPARE_MAX];
	NAND_eERROR eError;
	u8 aReadBuffer[NAND_PAGE_MAX];
		
	UART_Printf("[NANDT_SLCECC_All]\n");

	if(NAND_Inform[g_NandContNum].uNandType == NAND_MLC8bit)
	{
		UART_Printf("The current Nand Memory is MLC type.....!!\n\n");
		return;
	}
	
	UART_Printf("Input the Block Number to test[0~%d]", NAND_Inform[g_NandContNum].uBlockNum-1);
	uBlock = UART_GetIntNum();
	UART_Printf("Input the Page Number to test[0~%d]", NAND_Inform[g_NandContNum].uPageNum-1);
	uPage = UART_GetIntNum();	
	
	UART_Printf("Input the ECC Error Type\n");
	UART_Printf("1: 1bit error(D),	2: multiple error\n");
	uError = UART_GetIntNum();
	
	switch(uError)
	{
		case 1 :	uErrorType = NAND_ECCERR_1BIT;
				break;
		case 2 :	uErrorType = NAND_ECCERR_MULTI;
				break;
		default :	uErrorType = NAND_ECCERR_1BIT;
				break;				
	}
	
	srand(0);
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		aBuffer[i] = rand()%0xFF;
	}
	for(i=0 ; i<NAND_Inform[g_NandContNum].uSpareSize ; i++)
		aSpareBuffer[i] = 0xFF;	
		
	UART_Printf("\n");
	UART_Printf("The all bit ecc check of %dBlock:%dPage\n", uBlock, uPage);
	UART_Printf("\n");
		
	NAND_EccError.uEccErrByte1 = 0;
	NAND_EccError.uEccErrBit1 = 0;
	NAND_EccError.uEccErrByte2 = (NAND_EccError.uEccErrByte1+1)%NAND_Inform[g_NandContNum].uPageSize;
	NAND_EccError.uEccErrBit2 = 0;

	NAND_Inform[g_NandContNum].uECCtest = 1;	
	NAND_Inform[g_NandContNum].uAllBitEccCheck = 1;
	
	// uBlock+1[Block] Erase & Write to generate the accurate ECC code(aNand_Spare_Data_Temp[i])
	eError = NAND_EraseSingleBlock(g_NandContNum, uBlock);
	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		NAND_Inform[g_NandContNum].uECCtest = 0;
		NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
		return;
	}
		
	eError = NAND_WritePage(g_NandContNum, uBlock, 0, aBuffer, aSpareBuffer);	// write to 0th page
	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		NAND_Inform[g_NandContNum].uECCtest = 0;
		NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
		return;
	}

	// Test Start......!!
	for(j=0 ; j<NAND_Inform[g_NandContNum].uPageSize ; j++)
	{
		for(i=0 ; i<8 ; i++)
		{
			if(uErrorType == NAND_ECCERR_1BIT)
			{				
				UART_Printf("[%d byte : %d bit]\n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1);
			}
			else if(uErrorType == NAND_ECCERR_MULTI)
			{
				UART_Printf("[%d byte : %d bit] & [%d byte : %d bit] \n", 	NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
															NAND_EccError.uEccErrByte2, NAND_EccError.uEccErrBit2);
			}
				
			// Erase Block for test
			eError = NAND_EraseSingleBlock(g_NandContNum, uBlock);
			if(eError != eNAND_NoError)
			{
				NANDT_PrintErrorType(eError);
				NAND_Inform[g_NandContNum].uECCtest = 0;
				NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
				return;
			}

			// Write the invalid data to page( uBlock[block] 1[page] )
			eError = NAND_WritePageWithInvalidData(g_NandContNum, uBlock, uPage, aBuffer, uErrorType);
			if(eError != eNAND_NoError)
			{
				NANDT_PrintErrorType(eError);
				NAND_Inform[g_NandContNum].uECCtest = 0;
				NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
				return;
			}
				
			// Read the invalid data to detect the ECC error	
			eError = NAND_ReadPage(g_NandContNum, uBlock, uPage, aReadBuffer, aSpareBuffer);

			NANDT_PrintErrorType(eError);
			if(uErrorType == NAND_ECCERR_1BIT)
			{
				if( (NAND_EccError.uEccErrByte1 != aNANDT_EccError[0][0]) || (NAND_EccError.uEccErrBit1 != aNANDT_EccError[0][1]) )
				{
					UART_Printf("Ecc Error Check Error[%d byte:%d bit] != [%d byte:%d bit] \n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																				aNANDT_EccError[0][0], aNANDT_EccError[0][1]);	
					UART_Getc();
					NAND_Inform[g_NandContNum].uECCtest = 0;
					NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
					return;
				}
			}
			else if(uErrorType == NAND_ECCERR_MULTI)
			{
				if( aNANDT_EccError[0][0] != NAND_ECC_MULTI_ERROR)
				{
					UART_Printf("Multi Ecc Error Check Error\n");	
					aNANDT_EccError[0][0] = 0;
					UART_Getc();
					NAND_Inform[g_NandContNum].uECCtest = 0;
					NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
					return;
				}
				aNANDT_EccError[0][0] = 0;
			}				

			NAND_EccError.uEccErrBit1++;
			NAND_EccError.uEccErrBit2++;		
		}

		NAND_EccError.uEccErrBit1 = 0;
		NAND_EccError.uEccErrBit2 = 0;	
		NAND_EccError.uEccErrByte1++;
		NAND_EccError.uEccErrByte2 = (NAND_EccError.uEccErrByte1+1)%NAND_Inform[g_NandContNum].uPageSize;
	}

	NAND_EccError.uEccErrByte1 = 0;
	NAND_EccError.uEccErrByte2 = 0;
	
	NAND_Inform[g_NandContNum].uECCtest = 0;
	NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;

	UART_Printf("SLC Nand All bit ECC test complete\n");
	UART_Printf("\n");	
}


//////////
// Function Name : NANDT_SLCSpareECC_All
// Function Description : This function checks the ECC operation (all bit of Nand Device Spare Area)
// Input : 	None
// Output : 	None
void NANDT_SLCSpareECC_All(void)
{
	u32 i, j, uBlock, uPage, uError, uErrorType, uFirstEccPos=0;
	u8 aBuffer[NAND_PAGE_MAX];
	u8 aSpareBuffer[NAND_SPARE_MAX];
	NAND_eERROR eError;
	u8 aReadBuffer[NAND_PAGE_MAX];
		
	UART_Printf("[NANDT_SLCSpareECC]\n");

	if(NAND_Inform[g_NandContNum].uNandType == NAND_MLC8bit)
	{
		UART_Printf("The current Nand Memory is MLC type.....!!\n\n");
		return;
	}
	
	UART_Printf("Input the Block Number to test[0~%d]", NAND_Inform[g_NandContNum].uBlockNum-1);
	uBlock = UART_GetIntNum();
	UART_Printf("Input the Page Number to test[0~%d]", NAND_Inform[g_NandContNum].uPageNum-1);
	uPage = UART_GetIntNum();	
	
	UART_Printf("Input the ECC Error Type\n");
	UART_Printf("1: 1bit error(D),	2: multiple error\n");
	uError = UART_GetIntNum();
	
	switch(uError)
	{
		case 1 :	uErrorType = NAND_ECCERR_1BIT;
				break;
		case 2 :	uErrorType = NAND_ECCERR_MULTI;
				break;
		default :	uErrorType = NAND_ECCERR_1BIT;
				break;				
	}
	
	srand(0);
	for(i=0 ; i<NAND_Inform[g_NandContNum].uPageSize ; i++)
	{
		aBuffer[i] = rand()%0xFF;
	}
	for(i=0 ; i<NAND_Inform[g_NandContNum].uSpareSize ; i++)
		aSpareBuffer[i] = 0xFF;	


		
	UART_Printf("\n");
	UART_Printf("The all bit ecc check of [%d Block:%dPage] Spare Area\n", uBlock, uPage);
	UART_Printf("\n");

	if(NAND_Inform[g_NandContNum].uNandType == NAND_Normal8bit)
	{		
		// Spare Area 0~3 byte : Main ECC Value
		// Spare Area 8~9 byte : Spare ECC Value
		NAND_EccError.uEccErrByte1 = 0;
		NAND_EccError.uEccErrBit1 = 0;
		NAND_EccError.uEccErrByte2 = (NAND_EccError.uEccErrByte1+1)%4;
		NAND_EccError.uEccErrBit2 = 0;

		// The first ECC data byte position
		uFirstEccPos = 0;
	}
	else if(NAND_Inform[g_NandContNum].uNandType == NAND_Advanced8bit)
	{
		// Spare Area 1~4 byte : Main ECC Value
		// Spare Area 8~9 byte : Spare ECC Value
		NAND_EccError.uEccErrByte1 = 1;
		NAND_EccError.uEccErrBit1 = 0;
		NAND_EccError.uEccErrByte2 = (NAND_EccError.uEccErrByte1%4) + 1;
		NAND_EccError.uEccErrBit2 = 0;

		// The first ECC data byte position
		uFirstEccPos = 1;			
	}
		
	NAND_Inform[g_NandContNum].uECCtest = 1;
	NAND_Inform[g_NandContNum].uAllBitEccCheck = 1;
	NAND_Inform[g_NandContNum].uSpareECCtest = 0;

	// uBlock+1[Block] Erase & Write to generate the accurate ECC code(aNand_Spare_Data_Temp[i])
	eError = NAND_EraseSingleBlock(g_NandContNum, uBlock);
	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		NAND_Inform[g_NandContNum].uECCtest = 0;
		NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;		
		NAND_Inform[g_NandContNum].uSpareECCtest = 0;			
		return;
	}
		
	eError = NAND_WritePage(g_NandContNum, uBlock, 0, aBuffer, aSpareBuffer);	// write to 0th page, ECC generation
	if(eError != eNAND_NoError)
	{
		NANDT_PrintErrorType(eError);
		NAND_Inform[g_NandContNum].uECCtest = 0;
		NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
		NAND_Inform[g_NandContNum].uSpareECCtest = 0;				
		return;
	}

	NAND_Inform[g_NandContNum].uSpareECCtest = 1;	
		
	// Test Start......!!
	for(j=0 ; j<4 ; j++)	// Main ECC Data : 4 Bytes
	{
		for(i=0 ; i<8 ; i++)	// 8bit
		{
			if(uErrorType == NAND_ECCERR_1BIT)
			{				
				UART_Printf("Spare [%d byte : %d bit] Test\n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1);
			}
			else if(uErrorType == NAND_ECCERR_MULTI)
			{
				UART_Printf("Spare[%d byte : %d bit] & [%d byte : %d bit] Test\n", 	NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																NAND_EccError.uEccErrByte2, NAND_EccError.uEccErrBit2);
			}
			
			// Erase Block for test
			eError = NAND_EraseSingleBlock(g_NandContNum, uBlock);
			if(eError != eNAND_NoError)
			{
				NANDT_PrintErrorType(eError);
				NAND_Inform[g_NandContNum].uECCtest = 0;
				NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
				NAND_Inform[g_NandContNum].uSpareECCtest = 0;						
				return;
			}

			// Write the invalid data to page( uBlock[block] 1[page] )
			eError = NAND_WritePageWithInvalidSpareData(g_NandContNum, uBlock, uPage, aBuffer, uErrorType);
			if(eError != eNAND_NoError)
			{
				NANDT_PrintErrorType(eError);
				NAND_Inform[g_NandContNum].uECCtest = 0;
				NAND_Inform[g_NandContNum].uAllBitEccCheck = 0;
				NAND_Inform[g_NandContNum].uSpareECCtest = 0;						
				return;
			}
			
			// Read the invalid data to detect the ECC error	
			eError = NAND_ReadPage(g_NandContNum, uBlock, uPage, aReadBuffer, aSpareBuffer);

			NANDT_PrintErrorType(eError);
			if(uErrorType == NAND_ECCERR_1BIT)
			{
				if( (NAND_EccError.uEccErrByte1 != (aNANDT_EccError[0][0]+uFirstEccPos)) || (NAND_EccError.uEccErrBit1 != aNANDT_EccError[0][1]) )
				{
					UART_Printf("Ecc Error Check Error[%d byte:%d bit] != [%d byte:%d bit] \n", NAND_EccError.uEccErrByte1, NAND_EccError.uEccErrBit1,
																				aNANDT_EccError[0][0], aNANDT_EccError[0][1]);	
					UART_Getc();
					NAND_Inform[g_NandContNum].uECCtest