k9s1208.c

s3c24a0固件测试代码 ? ? ? ? ?啊

#include <string.h>
#include "def.h"
#include "option.h"
#include "24a0addr.h"
#include "24a0lib.h"
#include "24a0slib.h" 
#include "nand.h"

#define BAD_CHECK	(1)
#define ECC_CHECK	(1)

void __RdPage528(U8 *pPage);
void __WrPage528(U8 *pPage);

static int NF_EraseBlock(U32 blockNum);
static int NF_ReadPage(U32 block,U32 page,U8 *buffer);
static int NF_WritePage(U32 block,U32 page,U8 *buffer);
static int NF_IsBadBlock(U32 block);
static int NF_MarkBadBlock(U32 block);

static void NF_AutoLoad(U32 block, U32 page, U16 addr, U8 size);
static void NF_AutoStore(U32 block, U32 page, U16 addr);

static void Input_x8_TargetBlock(void);

static U32 srcAddress;
static U32 dstAddress;
static U32 targetBlock;	// Block number (0 ~ 8191)
static U32 targetSize;	    	// Total byte size 
static U32 steppingstone;

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


#define NF_CMD(cmd)	{rNFCMMD=cmd;}
#define NF_ADDR(addr) {rNFADDR=addr;}
#define NF_nFCE_L()	{rNFCONT&=~(1<<7);}
#define NF_nFCE_H()	{rNFCONT|=(1<<7);}
#define NF_RSTECC()	{rNFCONT|=(1<<8);}
#define NF_RDDATA() 	(rNFDATA)
#define NF_WRDATA(data) {rNFDATA=data;}
#define NF_TRANSRnB()    {while(!(rNFSTAT&(1<<13)));} 
#define NF_CLRRnB()    {(rNFSTAT|=(1<<13));} 
#define NF_MECC_Lock()  { rNFCONT|=(1<<9);}
#define NF_MECC_UnLock()  { rNFCONT&=~(1<<9);}

#define ID_K9S1208V0M	0xec76
#define LdStrAddr  0x00

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

void K9S1208_Program(void)
{
    int i,j;
    int programError=0;
    U8 *srcPt,*saveSrcPt;
    U32 blockIndex;
    U8 *testdata;	

    Uart_Printf("\n[ SMC(K9S1208V0M) NAND Flash writing program]\n");

     rNFCONT&=~(1<<2); // Lock disable

    srcAddress=0x10300000; 
    Uart_Printf("source base address(0x10300000)=0x%x\n",srcAddress);	
/*
		// Initializing Buffer ----------------INIT
		testdata = (U8 *)(srcAddress);
		for(i=0;i<4096;i++)
			*(testdata++) = i; 

*/

    Input_x8_TargetBlock();


    //Uart_Printf("target start block number      =%d\n",targetBlock);
    //Uart_Printf("target size        (0x4000*n)  =0x%x\n",targetSize);
	
    srcPt=(U8 *)srcAddress;
    blockIndex=targetBlock;
	
    while(1)
    {
	saveSrcPt=srcPt;
	
	#if BAD_CHECK
	if(NF_IsBadBlock(blockIndex))	// 1:bad 0:good
        {
	    blockIndex++;   // for next block
	    continue;
	}
	#endif
    
	if(!NF_EraseBlock(blockIndex))
	{
           blockIndex++;   // for next block
	    continue;
	}
	   
	for(i=0;i<32;i++)
	{
		if(!NF_WritePage(blockIndex,i,srcPt))// block num, page num, buffer
		{
	        	programError=1;
		 	Uart_Printf("ECC Error(block=%d,page=%d!!!\n",blockIndex,i);
	        	break;
		}
		
		#if ECC_CHECK    
		if(!NF_ReadPage(blockIndex,i,srcPt))
		{
			Uart_Printf("ECC Error(block=%d,page=%d!!!\n",blockIndex,i);
		}
		#endif	    
		
		srcPt+=512;	// Increase buffer addr one page size

		if((U32)srcPt>=(srcAddress+targetSize)) // Check end of buffer
			break;	// Exit for loop
	}
	Uart_Printf(".");		
        if(programError==1)
	{
	    blockIndex++;
	    srcPt=saveSrcPt;
	    programError=0;
	    continue;
	}
	
	if((U32)srcPt>=(srcAddress+targetSize))
	    break;	// Exit while loop
	blockIndex++;
	

    }


}

void K9S1208_PrintBadBlockNum(void)
{
    int i;

    Uart_Printf("\n[SMC(K9S1208V0M) NAND Flash bad block check]\n");

    
    for(i=0;i<4096;i++)
    {
	NF_IsBadBlock(i);   // Print bad block
    }
}

void K9S1208_PrintBlock(void)// Printf one page
{
    int i,j;
    U32 block,page;
    U8 * downPt;
	
	downPt=(unsigned char *)0x11000000;

    Uart_Printf("\n[SMC(K9S1208V0M) NAND Flash block read]\n");	

    Uart_Printf("Input target block number:");
    block=Uart_GetIntNum();
    Uart_Printf("Input target page number:");   
    page=Uart_GetIntNum();

    NF_ReadPage(block,page,downPt);
    Uart_Printf("block=%d,page=%d:",block,page);
    for(j=0;j<512;j++)
    {
        if(j%16==0)
	    Uart_Printf("\n%3xh:",j);
        Uart_Printf("%02x ",*downPt++);
    }
    Uart_Printf("\n");    	
}

void K9S1208_Erase(void)
{
	U32 block=0;

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

	Uart_Printf("Block # to erase: ");
	block = Uart_GetIntNum();

#if BAD_CHECK		
		if(NF_IsBadBlock(block));	// 1:bad 0:good
//		return;
#endif

	rNFCONT&=~(1<<2); // Lock disable	

	if(NF_EraseBlock(block)==0) return;

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

}

void K9S1208_Lock(void)
{
       U32 num;
       U32 S_block, E_block;
	Uart_Printf("SMC(K9S1208V0M) NAND Lock Test !!!\n");
	Uart_Printf("Select Lock type, Softlock(1)/Lock-tight(2) : ");

	num=Uart_GetIntNum();;
			
	Uart_Printf("\nEnter programmable start block address ");
	S_block = Uart_GetIntNum();
	Uart_Printf("Enter programmable end block address ");
       E_block = Uart_GetIntNum();

	rNFSBLK=(S_block<<5);
	rNFEBLK=(E_block<<5);
	
	if(num==1){
		rNFCONT|=(1<<2);
              Uart_Printf("Software Locked\n ");
	}
	if(num==2){
		rNFCONT|=(1<<3);
              Uart_Printf("Lock-tight: To clear Lock-tight, reset S3C2440!!!\n ");
	}
      Uart_Printf("%d block ~ %d block are Programmable\n ", S_block, (E_block-1));
}


void K9S1208_SoftUnLock(void)
{
       U32 S_block, E_block;
	Uart_Printf("SMC(K9S1208V0M) NAND SoftUnLock Test !!!\n");
	
	rNFSBLK=0x0;
	rNFEBLK=0x0;

	rNFCONT&=~(1<<2);
	if(rNFCONT&(1<<3)){
		rNFCONT&=~(1<<3);
		Uart_Printf("Lock-tight\n ");
		Uart_Printf("You can't unlock Protected blocks !!!\n ");
		Uart_Printf("%d block ~ %d block are Programmable\n ", (rNFSBLK>>5), ((rNFEBLK>>5)-1));
	}
       else Uart_Printf("All blocks are Programmable\n ");
}


static void Input_x8_TargetBlock(void)
{
    Uart_Printf("\nAvailable target block number: 0~4095\n");
    Uart_Printf("Input target start block number:");
    targetBlock=Uart_GetIntNum();	// Block number(0~4095)
    if(targetSize==0)
    {
//       Uart_Printf("1,048,576 = 0x100000,  31,457,280 = 0x1e00000 \n");
   	Uart_Printf("Input program file size(bytes): ");
	targetSize=Uart_GetIntNum();	// Total byte size
    }
}

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

    //  NF_RSTECC();    // Reset ECC
    NF_CLRRnB(); 
    NF_nFCE_L();    
    NF_CMD(0x50);		// Spare array read command
    NF_ADDR(517&0xf);		// Read the mark of bad block in spare array(M addr=5) 
    NF_ADDR(blockPage&0xff);	// The mark of bad block is in 0 page
    NF_ADDR((blockPage>>8)&0xff);   // For block number A[24:17]
    NF_ADDR((blockPage>>16)&0xff);  // For block number A[25]

   for(i=0;i<10;i++);	// wait tWB(100ns) //?????
    
    NF_TRANSRnB();	// Wait tR(max 12us)
    
    data=NF_RDDATA();

    NF_nFCE_H();    

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

static int NF_EraseBlock(U32 block)
{
    U32 blockPage;
    int i;

	// Port setting for SMC_WP
	   rGPCON_L =  (rGPCON_L & ~(0x3<<2))|(0x1<<2);
	   rGPDAT |=(1<<1);


    blockPage=(block<<5);

    NF_nFCE_L();
    
    NF_CMD(0x60);   // Erase one block 1st command

    NF_ADDR(blockPage&0xff);	    // Page number=0
    NF_ADDR((blockPage>>8)&0xff);   
    NF_ADDR((blockPage>>16)&0xff);
	
    NF_CLRRnB();    
    NF_CMD(0xd0);   // Erase one blcok 2nd command    
   for(i=0;i<10;i++); //wait tWB(100ns)//??????    
    NF_TRANSRnB();    // Wait tBERS max 3ms.
    NF_CMD(0x70);   // Read status command

   
    if (NF_RDDATA()&0x1) // Erase error
    {	
    	NF_nFCE_H();
	Uart_Printf("[ERASE_ERROR:block#=%d]\n",block);
	NF_MarkBadBlock(block);
  rGPCON_L =  (rGPCON_L & ~(0x3<<2))|(0x3<<2);	
	return 0;
    }
    else 
    {
    	NF_nFCE_H();
	  rGPCON_L =  (rGPCON_L & ~(0x3<<2))|(0x3<<2);	
        return 1;
    }
	
}

static int NF_MarkBadBlock(U32 block)
{
    int i;
    U32 blockPage;
    blockPage=(block<<5);
    
 
    seBuf[0]=0xff;
    seBuf[1]=0xff;    
    seBuf[2]=0xff;    
    //seBuf[3]=0xff;	
    seBuf[5]=0x44;   // Bad blcok mark=0

  
  //  NF_CLRRnB(); 
    NF_nFCE_L(); 
    
    
    NF_CMD(0x50);   
    NF_CMD(0x80);   // Write 1st command
    
    NF_ADDR(0x0);		    // The mark of bad block is 
    NF_ADDR((blockPage)&0xff);	    // marked 5th spare array 
    NF_ADDR((blockPage>>8)&0xff);   // in the 1st page.
    NF_ADDR((blockPage>>16)&0xff);  //
    
    for(i=0;i<16;i++)
    {
	//NF_WRDATA(0,seBuf[i]);	// Write spare array