nand_061020_interrupt.c

三星2413芯片的测试代码,对进行驱动开发很有帮助.

//====================================================================
// File Name : nand.c
// Function  : S3C2413 Camera test code
// Date      : Apr. 21, 2006
// Version   : S3C2413
//====================================================================

/**************** K9s1208 NAND flash ********************/
// 1block=(512+16)bytes x 32pages
// 4096block
// Block: A[23:14], Page: [13:9]

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "def.h"
#include "2413addr.h"
#include "option.h"
#include "Nand.h"

#define FAIL 0
#define OK   1

#define BAD_CHECK	(0)
#define ECC_CHECK	(0)

#define ASM		1
#define C_LANG	2
#define DMA		3
#define TRANS_MODE 3

U8 NF8_Spare_Data[16];

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

extern U32 downloadAddress;
extern U32 downloadProgramSize;
volatile int NFConDone,NFECCEncDone, NFECCDecDone;

//*************************************************
//*************************************************
//**           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 ....

//=============    spare area configuration    ====================================
//     0		1		2		3		4		5		6		7		8		9		0xa ...	
//  Mecc0   Mecc1     Mecc2         FF           FF      Bad Block     FF           FF        Secc0     Secc1          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_nFCE_L()			{rNFCONT&=~(1<<1);}
#define NF_nFCE_H()			{rNFCONT|=(1<<1);}
#define NF_RSTECC()			{rNFCONT|=(1<<5|1<<4);}
#define NF_RDDATA() 		(rNFDATA)
#define NF_RDDATA8() 		((*(volatile unsigned char*)0x4E000010) )
#define NF_WRDATA(data) 	{rNFDATA=data;}
#define NF_WRDATA8(data) 	{rNFDATA8=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)));}


#define ID_K9S1208V0M	0xec76
#define ID_KMXD64P3 	0x9876
#define ID_K9K2G08U0M	0xecda
#define ID_K9K2G16U0M	0xecca

// HCLK=100Mhz
#define TACLS		7	// 1-clk(0ns) 
#define TWRPH0		7	// 3-clk(25ns)
#define TWRPH1		7	// 1-clk(10ns)  //TACLS+TWRPH0+TWRPH1>=50ns


static U8 se8Buf[16]={
	0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff,
	0xff,0xff,0xff,0xff
};

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

void __irq NFCon_Int(void);


//*************************************************



void * n8_func[][2]=
{
	(void *)NF8_Print_Id,			"Read ID         ",
	(void *)Nand_Reset,				"Nand reset      ",
	(void *)Test_NF8_Block_Erase,	"Block erase     ",
	(void *)Test_NF8_Page_Read,		"Page read       ",
	(void *)Test_NF8_Page_Write,	"Page write      ",
	(void *)Test_NF8_Rw,			"Nand R/W test   ",
	(void *) NF8_PrintBadBlockNum,	"Check Badblock  ",
	(void *)Test_NF8_Lock,			"Nand Block lock ",
	(void *)Test_NF8_SoftUnLock,	"Soft Unlock     ",
	(void *)NF8_Program,			"K9S1208 Program ",
	(void *)Test_MLC_ECC,			"MLC ECC         ",
	0,0
};

void * nand_func[][2]=
{
	(void *)Test_K9S1208,		"K9S1208 & XD Picture     ",
	0,0
};


void Ch5_Nand(void)
{

	U32 i;
		
	printf("Nand test\n");
	rBANK_CFG = (rBANK_CFG & ~(0x3<<2))|(0x1<<2);
	rGPACON |= (0xf<<17);
	// GPA     20    19    18    17
	//        nFRE  nFWE   ALE   CLE

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

		printf("\nPress Enter key to exit : ");
		i = GetIntNum();
		if(i==-1) break;		// return.
		if(i>=0 && (i<((sizeof(nand_func)-1)/8)) )	// select and execute...
			( (void (*)(void)) (nand_func[i][0]) )();
	}

}


void Test_K9S1208(void)
{
	int i;
	U8 ch;

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

	NF8_Init();

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

}

U8 Read_Status(void)
{
	// Read status
	U8 ch;
	int i;
	
	NF_nFCE_L();

	NF_CMD(0x70);
	for(i=0; i<10; i++);
	ch = NF_RDDATA();

	NF_nFCE_H();

	return ch;
}

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

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


void Test_NF8_Block_Erase(void)
{
	U32 block=0;

	printf("SMC(K9S1208V0M) NAND Block erase\n");

	if((Read_Status()&0x80)==0) {
		printf("Write protected.\n");
		return;
	}

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

//	NF8_Init();
	
	if(NF8_EraseBlock(block)==FAIL) return;

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

}

void Test_NF8_Page_Read(void)
{
	U32 block=0, page=0;
	U32 i;
	unsigned char * downPt;
	
	downPt=(unsigned char *)_NONCACHE_STARTADDRESS;
		
	printf("SMC(K9S1208V0M) NAND Page Read.\n");

	printf("Block # to read: ");
	block = GetIntNum();
	printf("Page # to read: ");
	page = GetIntNum();

	if(NF8_ReadPage(block, page, (U8 *)downPt )==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<512; i++) {
		if((i%16)==0) printf("\n%4x: ", i);
		printf("%02x ", *(U8 *)downPt++);
		}
	printf("\n");
	printf("Spare:");
	for(i=0; i<16; i++) {
	 	printf("%02x ", NF8_Spare_Data[i]);
	}
	printf("\n");

}

void Test_NF8_Page_Write(void)
{
	U32 block=0, page=0;
	int i, offset;
	unsigned char * srcPt;
	srcPt=(unsigned char *)0x31100000;
		
	printf("SMC(K9S1208V0M) NAND Page Write.\n");
	printf("You must erase block before you write data!!! \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<512; i++) {
	#if ADS10==TRUE
		if(offset==-1) *srcPt++ = rand()%0xff;
	#else
		if(offset==-1) *srcPt++ = i%0xff;
	#endif
		else *srcPt++ =  i+offset;
	}
       srcPt=(unsigned char *)0x31100000;
	if(NF8_EraseBlock(block)==FAIL)	return;       
	printf("Write data[%d block, %d page].\n", block, page);
	if(NF8_WritePage(block, page, srcPt)==FAIL) {
		printf("Write Error.\n");
	} else {
		printf("Write OK.\n");
	}

 	printf("Write data is");
	for(i=0; i<512; i++) {
		if((i%16)==0) printf("\n%4x: ", i);
		printf("%02x ", *srcPt++);
	}
	printf("\n");

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

}


void Test_NF8_Rw(void)
{

 	U32  count=0;
    U32 block=0, page=0;
	U32 i, status=FAIL, error, offset=0;
	unsigned char *srcPt, *dstPt;

	for(block =0; block <2048; block++)
	{
 	

		srcPt=(unsigned char *)0x31100000;
		dstPt=(unsigned char *)0x31200000;

	//	printf("x-D Picture Card R/W test(0x%x).\n", count);
		printf(".");
	    /*
		printf("Block number: ");
		block = GetIntNum();
		printf("Page nember: ");
		page = GetIntNum();
		printf("offset data(-1:random): ");
		offset = GetIntNum();
	    */
	    
#if ADS10==TRUE
		srand(0);
#endif
	       
		
		// Init R/W data.
		for(i=0; i<512; i++) *dstPt++=0x0;

		for(i=0; i<512; i++) {
		#if ADS10==TRUE
			if(offset==-1) *srcPt++ = rand()%0xff;
		#else
			if(offset==-1) *srcPt++ = i%0xff;
		#endif
			else *srcPt++ = i+offset;
		}

	    

		srcPt=(unsigned char *)0x31100000;
		dstPt=(unsigned char *)0x31200000; 
		
			// Block erase
	//	printf("%d block erase.\n", block);
		if(NF8_EraseBlock(block)==FAIL)	return;
		
		for(page=0; page<32; page++) 
		{

		srcPt=(unsigned char *)0x31100000;
		dstPt=(unsigned char *)0x31200000; 
			
	//	printf("Write data[%d block, %d page].\n", block, page);
		if(NF8_WritePage(block, page, srcPt)==FAIL) return;

	//	printf("Read data.\n");
	   	if(NF8_ReadPage(block, page, dstPt)==FAIL) 	return;
		
	 
	//	printf("Checking data.\n");

		for(error=0, i=0; i<512; i++) {
			if(*srcPt++!=*dstPt++) {
				printf("Error:%d[W:%x,R:%x]\n", i, *srcPt, *dstPt);
				error++;
			}
		}
		
		if(error!=0) 
		{
			printf("Fail to R/W test(%d).\n", error);
			printf("Write data[%d block, %d page, 0x%x count].\n", block, page, count);
		}
		else   ;
		//	printf(" %d pageR/W test OK.\n",page);
		}
	}
	if(error == 0) printf("Write/Read OK!\n");
	else printf("Write/Read Fail!\n");
}

void NF8_Program(void)
{
//    unsigned long interrupt_reservoir;
    int i;
    int programError=0;
	U8 *srcPt,*saveSrcPt;
	U32 blockIndex;

  	printf("\n[SMC(K9S1208V0M or XD Picture Card) NAND Flash writing program]\n");
       printf("The program buffer: 0x30100000~0x31ffffff\n");

//	NF8_Init();

      rINTMSK = BIT_ALLMSK; 	
      srcAddress=0x30100000; 

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

     while(1) {
        saveSrcPt=srcPt;	

		#if BAD_CHECK
		if(NF8_IsBadBlock(blockIndex)==FAIL) {
		    blockIndex++;   // for next block