mlc.c

samsung 最新芯片2450 的测试程序.

//====================================================================
// File Name : K9k2g16.c
// Function  : S3C2440 16-bit interface Nand Test program(this program used by nand.c).
// Date      : May xx, 2003
// Version   : 0.0
// History
//   R0.0 (200305xx): Modified for 2440 from 2410. -> DonGo
//====================================================================


/**************** K9s1206 NAND flash ********************/
// 1block=(NF8_PAGE_BYTE+16)bytes x 32pages
// 4096block
// Block: A[23:14], Page: [13:9]
/**************** K9K2G16 NAND flash *******************/
// 1block=(2048+64)bytes x 64pages
// 2048block
// Block: A[23:14], page: [13:9]
/*****************************************************/


#include "system.h"

#include "MLC.h"
#include "nand.h"
#define BAD_CHECK	(0)
#define ECC_CHECK	(0)

#define C_LANG	1
#define DMA		2
#define TRANS_MODE_MLC  1


extern void Nand_Reset(void);

extern U32 srcAddress;
extern U32 targetBlock;	    // Block number (0 ~ 4095)
extern U32 targetSize;	    // Total byte size 

U8 MLC_Spare_Data[64]={
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
};
volatile int NFConDone_MLC;

volatile int NFConDone_MLC, NFECCEncDone, NFECCDecDone;


void __irq NFCon_Int_MLC(void);

static U8 MLC_Buf[64]={
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
};


void * MLC_func[][2]=
{
	(void *)MLC_Print_Id,			"Read ID             ",
	(void *)Test_MLC_Block_Erase,	"Block erase         ",
	(void *)Test_MLC_Page_Read,		"Page read           ",
	(void *)Test_MLC_Page_Write,	"Page write          ",
	(void *)MLC_Program,			"K9HBG08_Program     ",
	(void *)Test_MLC_Adv_ECC,		"MLC ECC         ",
	0,0
};




void Test_K9HBG08(void)
{
	int i;
	U32 blocknum, pagenum;

	printf("\nK9K2G16 Nand flash test start.\n");

	MLC_Init();
	
	while(1) {
		Print_MLC_SubMessage();
		printf("\nSelect(-1 to exit): ");
		i = GetIntNum();
		if(i==-1) break;
		
		if(i>=0 && (i<(sizeof(MLC_func)/8)) ) 
	    	( (void (*)(void)) (MLC_func[i][0]) )();	// execute selected function.
	}

}

void Print_MLC_SubMessage(void)
{
	int i;
	
	i=0;	
	printf("\n\n");
	while(1)
	{   //display menu
		printf("%2d:%s",i,MLC_func[i][1]);
	    i++;
	    if((int)(MLC_func[i][0])==0)
	    {
			printf("\n");
			break;
	    }
	    if((i%4)==0) printf("\n");
	}
}



void MLC_Print_Id(void)
{
	U16 id;
	U8 maker, device;

//	MLC_Init();
	
	id = MLC_CheckId();

	
	device = (U8)id;
	maker = (U8)(id>>8);
	
	printf(" Maker:%x, Device:%x\n", maker, device);
}



void Test_MLC_Block_Erase(void)
{
	U32 block=0;

	printf("MLC(K9HBG08) NAND Block erase\n");

	printf("Block # to erase: ");
	block = GetIntNum();
	


	if(MLC_EraseBlock(block)==FAIL) return;

	printf("%d-block erased.\n", block);

}






void Test_MLC_Page_Read(void)
{
	U32 block=0, page=0;
	U32 i, j;

    unsigned char * srcPt;
	srcPt=(unsigned char *)0x31000000;
	
	rGPHCON=rGPHCON&~(0xf<<26)|(0x5<<26);  // GPH13, 14 => OUTPUT
	rGPHDAT&=~(0x3<<13);	
	
	printf("MLC(K9HBG08) NAND Page Read.\n");

/*
    rGPHDAT|=(0x3<<13);
    for(i=0; i<100; i++)
	{
	 printf(".");
	 for(j=0; j<128; j++)
	 {
	  	MLC_ReadPage(i, j, (U8 *)srcPt);	
	 }
	}
	
	rGPHDAT&=~(0x3<<13);
*/
	
	printf("Block # to read: ");
	block = GetIntNum();
	printf("Page # to read: ");
	page = GetIntNum();

	if(MLC_ReadPage(block, page, (U8 *)srcPt)==FAIL) {
		printf("Read error.\n");
	} else {
		printf("Read OK.\n");
	};

	// Print data.
	printf("Read data(%d-block,%d-page)\n", block, page);
	for(i=0; i<2048; i++) {
		if((i%16)==0) printf("\n%4x: ", i);
		printf("%02x ", *srcPt++);
	}
	printf("\n");
	printf("Spare:");

	for(i=0; i<64; i++) {
		if((i%16)==0) printf("\n%4x: ", i);
	 	printf("%02x ", MLC_Spare_Data[i]);
	}
	printf("\n");

}



void Test_MLC_Page_Write(void)
{
	U32 block=0, page=0;
	int i, offset;
	unsigned char *srcPt;
	srcPt=(unsigned char *)0x31100000;
	
	rGPHCON=rGPHCON&~(0xf<<26)|(0x5<<26);  // GPH13, 14 => OUTPUT
	rGPHDAT&=~(0x3<<13);	
	printf("MLC(K9HBG08) NAND Page Write.\n");
	


	printf("Block # to write: ");
	block = GetIntNum();
	printf("Page # to write: ");
	page = GetIntNum();
	printf("offset data(-1:random): ");
	offset = GetIntNum();

#if ADS10==TRUE	
	srand(0);
#endif

	
	// Init wdata.
	for(i=0; i<2048; i++) {
	#if ADS10==TRUE
		if(offset==-1) *srcPt++ = rand()%0xffffffff;
	#else
		if(offset==-1) *srcPt++ = i;
	#endif
		else *srcPt++ =i+offset;
	}
     
    srcPt=(unsigned char *)0x31100000;
	printf("Write data[%d block, %d page].\n", block, page);
	
	
    printf("\n\n");

	
	if(MLC_WritePage(block, page, (U8 *)srcPt)==FAIL) {
		printf("Write Error.\n");
	} else {
		printf("Write OK.\n");
	    printf("Write data is");
	    	
		for(i=0; i<2048; i++) {
		if((i%16)==0) printf("\n%4x: ", i);
		printf("%02x ", *srcPt++);
		}
		printf("\n");

		printf("Spare:");
		for(i=0; i<64; i++) {
		if((i%16)==0) printf("\n%4x: ", i);
	 	printf("%02x ", MLC_Spare_Data[i]);
	}
	
		printf("\n\n");
	}
  
}






void MLC_Program(void)
{
    int i, page_num;
    int programError=0;
    U8 *srcPt,*saveSrcPt;
    U32 blockIndex;

    printf("\n[SOP(K9K2G16U0M) NAND Flash writing program]\n");
    printf("The program buffer: 0x30100000~0x31ffffff\n");
    
    

     rINTMSK = BIT_ALLMSK; 	
     srcAddress=0x30100000; 

     InputTargetBlock_MLC();

     srcPt=(U8 *)srcAddress;
     blockIndex=targetBlock;

     while(1) {
             saveSrcPt=srcPt;	
              
     	#if BAD_CHECK
     	  if(MLC_IsBadBlock(blockIndex)==FAIL) {
		    blockIndex++;   // for next block
		    continue;
	  }
     	#endif
		
     	if(MLC_EraseBlock(blockIndex)==FAIL) {
		    blockIndex++;   // for next block
		    continue;
     	}
   	// After 1-Block erase, Write 1-Block(64 pages).
	for(i=0;i<64;i++) {
		    if(MLC_WritePage(blockIndex,i,srcPt)==FAIL) {// block num, page num, buffer
		        programError=1;
		        break;
		    }

	#if ECC_CHECK
		    if(MLC_ReadPage(blockIndex,i,srcPt)==FAIL) {
			printf("ECC Error(block=%d,page=%d!!!\n",blockIndex,i);
		    }
	#endif

	srcPt+=2048;	// Increase buffer addr one pase size
    	if(i==0)  printf(".");
	if((U32)srcPt>=(srcAddress+targetSize)) // Check end of buffer
	break;	// Exit for loop
    }
		
	if(programError==1) {
	    blockIndex++;
	    srcPt=saveSrcPt;
	    programError=0;
	    continue;
	}

	if((U32)srcPt>=(srcAddress+targetSize)) break;	// Exit while loop

		blockIndex++;

    }

}


//*************************************************
//*************************************************
//**           H/W dependent functions           **
//************************************************* 
//*************************************************

//The code is made for bi-endian mode

// block0: reserved for boot strap
// block1~4095: used for OS image
// badblock SE: xx xx xx xx xx 00 ....
// good block SE: ECC0 ECC1 ECC2 FF FF FF ....

/*
#define NF_MECC_UnLock()         {rNFCONT&=~(1<<7);}
#define NF_MECC_Lock()         {rNFCONT|=(1<<7);}
#define NF_SECC_UnLock()         {rNFCONT&=~(1<<6);}
#define NF_SECC_Lock()         {rNFCONT|=(1<<6);}

#define NF_CMD(cmd)			{rNFCMD=cmd;}
#define NF_ADDR(addr)		{rNFADDR=addr;}	
#define NF_nFCE_L()			{rNFCONT&=~(1<<2);}
#define NF_nFCE_H()			{rNFCONT|=(1<<2);}

#define NF_RSTECC()			{rNFCONT|=(1<<5|1<<4);}
#define NF_RDDATA() 		(rNFDATA)
#define NF_RDDATA16() 		((*(volatile unsigned short*)0x4E000010) )

#define NF_WRDATA(data) 	{rNFDATA=data;}

// RnB Signal
#define NF_CLEAR_RB()    		{rNFSTAT |= (1<<4);}	// Have write '1' to clear this bit.
#define NF_DETECT_RB()    		{while(!(rNFSTAT&(1<<4)));}	// edge detect.


#define ID_K9S1208V0M	0xec76
#define ID_K9K2G16U0M	0xecca

#define BAD_MARK	(0x44444444)



#if 1
// HCLK=100Mhz
#define TACLS		0	// 1-clk(0ns) 
#define TWRPH0		6	// 3-clk(25ns)
#define TWRPH1		0	// 1-clk(10ns)  //TACLS+TWRPH0+TWRPH1>=50ns
#else
// HCLK=50Mhz
#define TACLS		0  //1clk(0ns)
#define TWRPH0		1  //2clk(25ns)
#define TWRPH1		0  //1clk(10ns)
#endif

 */
 
 
static U32 MLCBuf[32/2]={
	0xffffffff,0xffffffff,0xffffffff,0xffffffff,
	0xffffffff,0xffffffff,0xffffffff,0xffffffff,
	0xffffffff,0xffffffff,0xffffffff,0xffffffff,
	0xffffffff,0xffffffff,0xffffffff,0xffffffff
};


void InputTargetBlock_MLC(void)
{
	U32 no_block, no_page, no_byte;
	
	printf("\nAvailable target block number: 0~2048\n");
	printf("Input target block number:");
    targetBlock=GetIntNum();	// Block number(0~4095)
    if(targetSize==0)
    {
    #if 0
    	printf("Input target size(0x4000*n):");
    	targetSize=GetIntNum();	// Total byte size
	#else
   	printf("Input program file size(bytes): ");
    	targetSize=GetIntNum();	// Total byte size
    	#endif
    }
	
	no_block = (U32)((targetSize/2048)/128);
	no_page = (U32)((targetSize/2048)%128);
	no_byte = (U32)(targetSize%2048);
	printf("File:%d[%d-block,%d-page,%d-bytes].\n", targetSize, no_block, no_page, no_byte);
}


static int MLC_EraseBlock(U32 block)
{
    U32 blockPage=(block<<7);
    int i;

    NFConDone_MLC=0;
    rNFCONT|=(1<<9); //Enable RnB Interrupt
    rNFCONT|=(1<<10); //Enable Illegal Access Interrupt
    pISR_NFCON= (unsigned)NFCon_Int_MLC;
    rSRCPND=BIT_NFCON;
    rINTMSK=~(BIT_NFCON);
/*
#if BAD_CHECK
    if(MLC_IsBadBlock(block))
	return FAIL;
#endif
*/
	NF_nFCE_L();
    
	NF_CMD(0x60);   // Erase one block 1st command, Block Addr:A11-A27
	// Address 3-cycle
	NF_ADDR(blockPage&0xff);	    // A[18:11]
	NF_ADDR((blockPage>>8)&0xff);   // A[26:19]
	NF_ADDR((blockPage>>16)&0xff);	// A27


	NF_CLEAR_RB();
	NF_CMD(0xd0);	// Erase one blcok 2nd command
	
//	NF_DETECT_RB();
	 while(NFConDone_MLC==0);
	 rNFCONT&=~(1<<9);   // Disable RnB Interrupt
	 rNFCONT&=~(1<<10); // Disable Illegal Access Interrupt
	 if(rNFSTAT&0x8) return FAIL;
 
	NF_CMD(0x70);   // Read status command

    if (NF_RDDATA()&0x1) // Erase error
    {	
    	NF_nFCE_H();
		printf("[ERASE_ERROR:block#=%d]\n",block);
    	return FAIL;
    }
    else 
    {
    	NF_nFCE_H();
        return OK;
    }
}

void __irq NFCon_Int_MLC(void)
{
   
	
	 NFConDone_MLC=1;
    
    //printf("Interrupt is occurred!!!\n");

    //rINTMSK|=BIT_NFCON;
	ClearPending(BIT_NFCON);
	if(rNFSTAT&0x20) printf("Illegal Access is detected!!!\n");
	else if(rNFSTAT&0x40) 
	{
	       if ((rNFECCERR0&(0x7<<26)) == 0x0){
//	       printf("ECC OK!\n");
	 	   }
		   else {
//		   printf("ECC FAIL!\n");
//		   printf("status0:0x%x|status1:0x%x|bit:0x%x\n", rNFECCERR0, rNFECCERR1, rNFMLCBITPT);
		   }
	 
//		NFECCDecDone=1;
//		rNFSTAT|=0x40;	
//		printf("ECC decoding is completed!!!\n"); 
	}
	else if(rNFSTAT&0x10)
	{
		rNFSTAT|=0x10;
//		printf("RnB is Detected!!!\n");
	}
	 else if(rNFSTAT&0x80) 
	{
		NFECCEncDone=1;
//		rNFSTAT|=0x80;	
		printf("ECC Encoding is completed!!!\n"); 
	}
  }



static int MLC_IsBadBlock(U32 block)
{
    int i;
    unsigned int blockPage;
    U32 bad_block_data;
    U8 data;
    
    
    blockPage=(block<<7);	// For 2'nd cycle I/O[7:5] 
    
	NF_nFCE_L();
	NF_CLEAR_RB();

	NF_CMD(0x00);		 // read command
	NF_ADDR((2048+0)&0xff);			// 2060 = 0x080c
	NF_ADDR(((2048+0)>>8)&0xff);		// A[10:8]
	NF_ADDR((blockPage)&0xff);		// A[11;18]
	NF_ADDR((blockPage>>8)&0xff);	// A[26:19]
	NF_ADDR((blockPage>>16)&0xff);	// A27
	NF_CMD(0x30);	// 2'nd command
	
	NF_DETECT_RB();	 // Wait tR(max 12us)

    data=NF_RDDATA();

	NF_nFCE_H();    

    if(data!=0xff)
    {
    	printf("[block %d has been marked as a bad block(%x)]\n",block,data);
    	return FAIL;
    }
    else
    {
    	return OK;
    }
}




static int MLC_ReadPage(U32 block,U32 page,U8 *buffer)
{
  	int i,j;
   	U32 blockPage, Mecc0, Mecc1, Mecc2, Mecc3, Mecc4, Mecc5, Mecc6, Mecc7, Secc;
	U8 *bufPt=buffer;
	
	
	NFConDone_MLC=0, NFECCDecDone=0;

	
  //  rNFCONT|=(1<<9); // Enable RnB Interrupt 
  //  rNFCONT|=(1<<10); // Enable Illegal Access Interrupt
    
    rNFCONT|=(1<<13); // Enable ECC encoding conpletion interrupt enable
    rNFCONT|=(1<<12); // Enable ECC decoding conpletion interrupt enable
   	rNFCONF = (rNFCONF & ~(1<<30))|(1<<24); // System Clock is more than 66Mhz, ECC type is MLC.
	rNFCONT &= ~(1<<18); //ECC for reading.
    
   
    pISR_NFCON= (unsigned)NFCon_Int_MLC;