k9s1208.c

s3c6410的jtag程序sjf6410_1.0

#include <stdio.h>
#include "..\include\pin6410.h"
#include "..\include\Jtag.h"
#include "..\include\K9S1208.h"
#include "..\include\sjf6410.h"


#define BAD_CHECK	(0)
//#define BAD_CHECK	(1)
#define ECC_CHECK	(0)

//*************** JTAG dependent functions ***************
void K9S1208_JtagInit(void);
static void NF_CMD(U8 cmd);
static void NF_RADDR(U8 raddr);
static void NF_nFCE_L(void);
static void NF_nFCE_H(void);
static U8 NF_RDRDATA(void);
static void NF_WRRDATA(U8 rdata);
static void NF_WAITRB(void);
//*************** H/W dependent functions ***************
static U16 NF_CheckId(void);
static int NF_EraseBlock(U32 blockNum);
static int NF_ReadPage(U32 block,U32 page,U8 *buffer,U8 *spareBuf);
static int NF_WritePage(U32 block,U32 page,U8 *buffer,U8 *spareBuf);
//buffer size is 512 bytes
static int NF_IsBadBlock(U32 block);
static int NF_MarkBadBlock(U32 block);
static void NF_Reset(void);
static void NF_Init(void);
//*******************************************************

extern void ECC_GenM(U8 *pEcc, U32 *pBuf, U8 nBW);
extern U8 chk_parity_1bitECC_SB[4] = {0xff,0xff,0xff,0xff};	// 1bit ECC Data
U8 spareBuf_SB[16]= {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
                     0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};

//extern U8 *srcPt;	
U8 *srcPt;	


void K9S1208_PrintBlock(void);
void K9S1208_Program(void);

void Make_1bit_ECC_SB(int spareBuf_addr);


static U32 targetBlock;	    // Block number (0 ~ 4095)
static U32 targetSize;	    // Total byte size 
//static U8 blockBuf[0x4000];   
static U8 blockBuf[0x40000]; 
static void *function[][2]=
{
    (void *)K9S1208_Program,		"K9S1208 Program     ",
    (void *)K9S1208_PrintBlock,		"K9S1208 Pr BlkPage  ",
    (void *)1,			    		"Exit                ",
    0,0
};


void K9S1208_Menu(void)
{
	int i;
	U16 id;

	printf("\n[K9S1208 NAND Flash JTAG Programmer]\n");
	K9S1208_JtagInit();
//	NF_WRRDATA(0xFF);
//	NF_WRRDATA(0x0);
		
	NF_Init();

	id=NF_CheckId();

	if(id==0xec76)
	{
		printf("K9S1208(0xec76) is detected. ID=0x%x\n",id);
	}
	else if (id==0x9876)
	{
		printf("xD-Picture card(0x9876) is detected. ID=0x%x\n",id);
	}
	else
	{
		printf("ERROR: K9S1208(0xec76) is not detected. Detected ID=0x%x.\n",id);
		return;
	}

	while(1)
	{

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

		printf("Select the function to test :");
		scanf("%d",&i);
		if( i>=0 && (i<((sizeof(function)/8)-2)) ) 
			( (void (*)(void)) (function[i][0]) )();  
		else
			break; //Exit menu
	}
}



void K9S1208_Program(void)
{
    int i;
    int programError=0;
    U32 blockIndex;
    int noLoad=0;
    //U8 *srcPt;
    U32 progSize=0;

    printf("\n[SMC(K9S1208V0M) NAND Flash Writing Program]\n");
    
    printf("\nSource size:0h~%xh\n",imageSize-1);
    printf("\nAvailable target block number: 0~4095\n");
    printf("Input target block number:");
    scanf("%d",&targetBlock);
    targetSize=((imageSize+0x4000-1)/0x4000)*0x4000;
    printf("target start block number     =%d\n",targetBlock);
    printf("target size        (0x4000*n) =0x%x\n",targetSize);
    printf("STATUS:\n");
    blockIndex=targetBlock;
    
    
    while(1)
    {
		if(noLoad==0)
		{
			LoadImageFile(blockBuf,imageSize);
		}
		noLoad=0;
		
	#if BAD_CHECK       
		if(NF_IsBadBlock(blockIndex) && blockIndex!=0 )	// 1:bad 0:good
		{
			blockIndex++;   // for next block
			noLoad=1;
			continue;
		}
	#endif

		for(i=0;i<(imageSize/(512*32)+1);i++)
		{
			if(!NF_EraseBlock(blockIndex + i))
			{
				blockIndex++;   // for next block
				noLoad=1;
				continue;
			}
			printf("block #%d ~ #%d erase done", blockIndex, blockIndex+i);
			printf("%c",0x0D);
		}

		printf("\n");
		srcPt=blockBuf;	

		printf("page programing : #0");
		printf("%c",0x0D);

		for(i=0;i<(imageSize/512 + 1);i++)
		{
			//Make_1bit_ECC_SB(8);// 8 ~ 11
			Make_1bit_ECC_SB(0);// 0 ~ 3
			
			//if(!NF_WritePage(blockIndex,i,srcPt,NULL/*spareBuf*/))// block num, page num, buffer
			if(!NF_WritePage(blockIndex,i,srcPt,spareBuf_SB))// block num, page num, buffer
			{
				programError=1;
				break;
			}

			srcPt+=512;	// Increase buffer raddr one pase size

			printf("page programing : #0 ~ #%d", i);
			printf("%c",0x0D);
		}

		printf("\npage program done\n\n");

		if(programError==1)
		{
			blockIndex++;
			noLoad=1;
			programError=0;
			continue;
		}
		
		progSize+=imageSize;

		if(progSize>=imageSize)
			break;	// Exit while loop
		blockIndex++;
    }
}

/** SLC Small Block Spare Area Layout (16Byte per 1page(512Byte)) **/
//
//  - Linux, firmware
//  0 ~ 3  : Sector ECC
//  8 ~ 15 : 0xFF
//  
//  - WinCE
//  0 ~ 7  : 0xFF
//  8 ~ 11 : Sector ECC
// 12 ~ 15 : 0xFF
//
/*******************************************************************/

void Make_1bit_ECC_SB(int spareBuf_addr)
{
	int spareBuf_count=0;				
	
	ECC_GenM(chk_parity_1bitECC_SB, srcPt, 0);
		
	for(spareBuf_count=0;spareBuf_count<4;spareBuf_count++)
		spareBuf_SB[spareBuf_addr + spareBuf_count] = chk_parity_1bitECC_SB[spareBuf_count];	
}


void K9S1208_PrintBlock(void)// Printf one page
{
    int i;
    U16 id;
    U32 block,page;
    U8	buffer[512+16];

    printf("\n[SMC(K9S1208) NAND Flash block read]\n");	
    
    NF_Init();
    id=NF_CheckId();
    printf("ID = 0x%x\n",id);
	//printf("ID=%x(0xec76)\n",id);
    //if(id!=0xec76)
	//return;

    printf("Input target block number:");
    scanf("%d",&block);
    printf("Input target page number:");   
    scanf("%d",&page);
    
    NF_ReadPage(block,page,buffer,buffer+512);
    
    printf("block=%d,page=%d:",block,page);
    for(i=0;i<512;i++)
    {
        if(i%16==0)
	    printf("\n%3xh:",i);
        printf("%02x ",buffer[i]);
    }
    printf("\nS.A.:",i);

    for(i=512;i<512+16;i++)
    {
        printf("%02x ",buffer[i]);
    }

    printf("\n");    	
}

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

// NAND Flash Memory Commands
#define	SEQ_RDATA_INPUT			(0x80)
#define	READ_ID				(0x90)
#define	RESET				(0xFF)
#define	READ_1_1			(0x00)
#define	READ_1_2			(0x01)
#define	READ_2				(0x50)
#define	PAGE_PROGRAM			(0x10)
#define	BLOCK_ERASE			(0x60)
#define	BLOCK_ERASE_CONFIRM		(0xD0)
#define	READ_STATUS			(0x70)


// 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 WRITEVERIFY  (0)  //verifing is enable at writing.

/*
#define NF_CMD(cmd)	{rNFCMD=cmd;}
#define NF_RADDR(raddr)	{rNFRADDR=raddr;}	
#define NF_nFCE_L()	{rNFCONF&=~(1<<11);}
#define NF_nFCE_H()	{rNFCONF|=(1<<11);}
#define NF_RSTECC()	{rNFCONF|=(1<<12);}
#define NF_RDRDATA() 	(rNFRDATA)
#define NF_WRRDATA(rdata) {rNFRDATA=rdata;}

#define NF_WAITRB()    {while(!(rNFSTAT&(1<<0)));} 
	    //wait tWB and check F_RNB pin.   
*/
#define ID_K9S1208V0M	0xec76

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

// 1block=(512+16)bytes x 32pages
// 4096block

// A[23:14][13:9]
//  block   page

static int NF_EraseBlock(U32 block)
{
    U32 blockPage=(block<<5);

#if BAD_CHECK
    if(NF_IsBadBlock(block) && block!=0) //block #0 can't be bad block for NAND boot
	return 0;
#endif

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

    NF_RADDR( (U8)(blockPage&0xff) );	    // Page number=0
    NF_RADDR( (U8)((blockPage>>8)&0xff) );   
    NF_RADDR( (U8)((blockPage>>16)&0xff) );

    NF_CMD(0xd0);   // Erase one blcok 2nd command
    
    Delay(1); //wait tWB(100ns)

    NF_WAITRB();    // Wait tBERS max 3ms.
    NF_CMD(0x70);   // Read status command

    if (NF_RDRDATA()&0x1) // Erase error
    {	
    	NF_nFCE_H();
	printf("[ERASE_ERROR:block#=%d]\n",block);
	NF_MarkBadBlock(block);