k9g8g08.c

三星6410的烧写工具源码

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


//#define BAD_CHECK	(0)
#define BAD_CHECK	(1)
#define ECC_CHECK	(0)
 
//#define unsigned char U8

extern void enc_reg(msg_len, fdin, chk_parity);
extern void ECC_GenM(U8 *pEcc, U32 *pBuf, U8 nBW);
void Make_1bit_ECC(int spareBuf_addr);
void Make_4bit_ECC(int spareBuf_addr);
void Make_4bit_ECC2(int spareBuf_addr);
void Make_4bit_SpareECC(int spareBuf_addr);
void Make_4bit_SpareECC2(int spareBuf_addr);
static int NF_2Plane_WritePage(U32 block,U32 page,U8 *buffer,U8 *spareBuf,U8 *spareBuf2);

// 1bit ECC use only 4Byte, 4th Byte is 0xff
U8 chk_parity_1bitECC[4] = {0xff,0xff,0xff,0xff};	// 1bit ECC Data

// 4bit ECC use only 7Byte, 8th Byte is 0x00.
unsigned char chk_parity[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};	// 4bit ECC Data


U8 spareBuf[64]=
	{0xff,0x00,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};
	 
U8 spareBuf2[64]=
	{0xff,0x00,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};
	 
U8 spareECC_Buf[512];	
U8 spareECC_Buf2[512];
	 
int msg_len = 512;
U8 *srcPt;
U32 *srcPt32;


//*************** JTAG dependent functions ***************
void K9g8g08_JtagInit(void);
static void NF_CMD(U8 cmd);
static void NF_ADDR(U8 addr);
static void NF_Xm0CSn2_OUT_L(void);
static void NF_Xm0CSn2_OUT_H(void);
static U8 NF_RDDATA(void);
static void NF_WRDATA(U8 data);
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);
//*******************************************************

void K9g8g08_PrintBlock(void);
void K9g8g08_Program(void);
void K9g8g08_Program_SLC(void);
void K9g8g08_2Plain_Program(void);


static U32 targetBlock;	    // Block number (0 ~ 4095)
static U32 UseBlockNumber;	
static U32 targetSize;	    // Total byte size 
static U32 barcount=0;
static U32 spacecount=0;
static U8 bar[34];
static U8 space[34];

static U8 blockBuf[0x80000]; 

static void *function[][2]=
{
    (void *)K9g8g08_Program,		"K9g8g08 Program",
    (void *)K9g8g08_Program_SLC,	"K9g8g08 Program like SLC (34page fix)",
    (void *)K9g8g08_2Plain_Program, "K9g8g08 two Plain program",
    (void *)K9g8g08_PrintBlock,		"K9g8g08 Print blkPage  ",
    (void *)1,			    	    "Exit                ",
    0,0
};


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

	printf("\n[K9G8G08 NAND Flash JTAG Programmer]\n");
    K9g8g08_JtagInit();
    NF_Init();    
    

    id=NF_CheckId();
    
	if((id!=0xecd3)&&(id!=0xecd5)) // K9g808Q0A Device Id = dc    : msp4 2006/09/27
    {
		printf("ERROR: K9G8G08 or K9LAG08 is not detected.\n Detected ID=0x%x.\n",id);
		return;
    }
    else if (id == 0xecd3)
		printf("K9G8G08 is detected. ID=0x%x\n\n",id);
    else if (id == 0xecd5)
		printf("K9LAG08 is detected. ID=0x%x\n\n",id);

    while(1)
    {

	i=0;
    	while(1)
	{   //display menu
	    printf( "%2d : %s\n",i,function[i][1]);
	    i++;
	    if((int)(function[i][0])==0)
	    {
		printf("\n");
		break;
	    }	    
	}
	
	for(barcount=0;barcount<34;barcount++){
		bar[barcount] = '=';
		space[barcount] = ' ';
	}

	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 K9g8g08_Program(void)
{
    U32 i;
    int programError=0;
    U32 blockIndex;
    int noLoad=0;    
    U32 percent=0;
    U32 progSize=0;

	printf("\n[SMC(K9g8g08Q0M) NAND Flash Writing Program]\n");    
    printf("\nSource size:0h~%xh\n",imageSize-1);
	printf("\nAvailable target block number : 0~4096\n"); // msp4 2006.09.27 
    printf("Input target block number : ");
    scanf("%d",&targetBlock);    
    blockIndex=targetBlock;
    printf("blockIndex = %d\n", blockIndex);
    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/(2048*128)+1);i++){
		if(!NF_EraseBlock(blockIndex + i))
		{
		    blockIndex++;   // for next block
		    noLoad=1;
		    continue;
		}
		printf("block #%d erase done\n",blockIndex + i);
	}
		
	srcPt=blockBuf;	

#if 0 // in case of "for(i=0;i<34;i++)", display.
	printf("Page Program |");
#else
	printf("page programing : #0");
#endif
	printf("%c",0x0D);
	

	//for(i=0;i<34;i++)
	for(i=0;i<(imageSize/2048 + 1);i++)
	{						
		/*********** fill 'spareBuf' for SPARE AREA ************/
		// must be added : 4 ~ 15(Spare Context) area. Data is 0xFF now.
		Make_4bit_ECC(16);// 16 ~ 23(Sector 0)
		Make_4bit_ECC(24);// 24 ~ 31(Sector 1)
		Make_4bit_ECC(32);// 32 ~ 39(Sector 2)
		Make_4bit_ECC(40);// 40 ~ 47(Sector 3)
		Make_4bit_SpareECC(48);// 48 ~ 55(Spare ECC)
		Make_4bit_SpareECC(56);// 56 ~ 63(Spare ECC Copy)		
		
		srcPt=blockBuf+(i*2048);// back to the 'srcPt' value.	
		/*******************************************************/	
		
		if(!NF_WritePage(blockIndex,i,srcPt,spareBuf))// block num, page num, buffer
	    {
	        programError=1;
	        break;
	    }

		srcPt+=2048;	// Increase buffer addr one page size

	    //printf("page #%d program done", i);

#if 0	// in case of "for(i=0;i<34;i++)", display.
	    printf("Page Program |");
	    for(barcount=0; barcount<(i+1); barcount++)
	    	printf("%c",bar[barcount]);
	    for(spacecount=0; spacecount<34-(i+1); spacecount++)
	    	printf("%c",space[spacecount]);
	    printf("| %d%% page #0 ~ #%d",(i+1)*3,i);
	    printf("%c",0x0D);
#else
		printf("page programing : #0 ~ #%d", i);
	    printf("%c",0x0D);
#endif
	}
	
	printf("\npage program done\n\n");
	//printf("block %d, %d program complete!\n\n", blockIndex, blockIndex+1);	
	
    if(programError==1)
	{
	    blockIndex++;
	    noLoad=1;
	    programError=0;
	    continue;
	}
	

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

void K9g8g08_Program_SLC(void)
{
	U32 i, pagenum = 0;
    int programError=0;
    U32 blockIndex;
    int noLoad=0;    
    U32 progSize=0;

	printf("\n[SMC(K9g8g08Q0M) NAND Flash Writing Program]\n");
    
    printf("\nSource size:0h~%xh\n",imageSize-1);
	printf("\nAvailable target block number : 0~4096\n"); // msp4 2006.09.27 
    printf("Input target block number : ");
    scanf("%d",&targetBlock);    
    blockIndex=targetBlock;
    printf("blockIndex = %d\n", blockIndex);
    while(1)
    {
	if(noLoad==0)
	    LoadImageFile(blockBuf,0x40000);// 1block = 128page = 256KByte = 0x40000
		                                // but used the 34page.
	noLoad=0;
		
	
#if BAD_CHECK       
	if(NF_IsBadBlock(blockIndex) && blockIndex!=0 )	// 1:bad 0:good
	{
	    blockIndex++;   // for next block
	    noLoad=1;
	    continue;
	}
#endif

	if(!NF_EraseBlock(blockIndex))
	{
	    blockIndex++;   // for next block
	    noLoad=1;
	    continue;
	}
	
	printf("\nblock %d erase done\n",blockIndex);
	srcPt=blockBuf;	
	printf("Page Program |");
	printf("%c",0x0D);
	
	// K9G8G08(1 block = 128 page) 1st block
	//for(i=0;i<128;i++)    
	for(i=0;i<34;i++)    // Block 0 image : only 34 page
	{	
		/*********** fill 'spareBuf' for SPARE AREA ************/
		// must be added : 4 ~ 15(Spare Context) area. Data is 0xFF now.
		Make_1bit_ECC(16);// 16 ~ 19(Sector 0)
		Make_1bit_ECC(20);// 20 ~ 23(Sector 1)
		Make_1bit_ECC(24);// 24 ~ 27(Sector 2)
		Make_1bit_ECC(28);// 28 ~ 31(Sector 3)
				
		srcPt=blockBuf+(i*2048);// back to the 'srcPt' value.		
		/*******************************************************/	
		
	    if(!NF_WritePage(blockIndex,pagenum,srcPt,spareBuf))// block num, page num, buffer
	    {
	        programError=1;
	        break;
	    }
	    
	    pagenum = pagenum + 2;

		srcPt+=2048;	// Increase buffer addr one page size
	    
	    //printf("page #%d program done", i);	    
		printf("Page Program |");
	    for(barcount=0; barcount<(i+1); barcount++)
	    	printf("%c",bar[barcount]);
	    for(spacecount=0; spacecount<34-(i+1); spacecount++)
	    	printf("%c",space[spacecount]);
	    printf("| %d%% page #0 ~ #%d",(i+1)*3,i);
	    printf("%c",0x0D);
	}
	
	printf("page program done                                                     \n");
	printf("block %d program complete!\n\n", blockIndex);	
	
    if(programError==1)
	{
	    blockIndex++;
	    noLoad=1;
	    programError=0;
	    continue;
	}
	
	progSize+=0x40000;
	if(progSize>=imageSize)
	    break;	// Exit while loop
	    
	blockIndex++;	
    }
}

void K9g8g08_2Plain_Program(void)
{
    U32 i;
    int programError=0;
    U32 blockIndex;
    int noLoad=0;    
    U32 progSize=0;
    U32 percent=0;

	printf("\n[SMC(K9g8g08Q0M) NAND Flash two plane Writing Program]\n");
    
    printf("\nSource size:0h~%xh\n",imageSize-1);
    printf("Available target two plane block number : 0~2096\n");
    printf("Input target block number : ");
    scanf("%d",&targetBlock);   
    
    blockIndex=targetBlock;
    printf("two plane block index = %d\n", blockIndex);
    printf("physical block = %d, %d\n", blockIndex*2, blockIndex*2+1);
    while(1)
    {
	if(noLoad==0)
	{	    
	    LoadImageFile(blockBuf,0x80000);// 2block = 2*128page = 2*256KByte = 0x80000
	}
	noLoad=0;
		
	
#if BAD_CHECK       
	if(NF_IsBadBlock(blockIndex) && blockIndex!=0 )	// 1:bad 0:good
	{
	    blockIndex++;   // for next block
	    noLoad=1;
	    continue;
	}
#endif
	
	NF_EraseBlock(blockIndex*2);
	NF_EraseBlock(blockIndex*2+1);
		
	printf("\nblock %d, %d erase done\n",blockIndex*2,blockIndex*2+1);	
	srcPt=blockBuf;	
	printf("Page Program |");
	printf("%c",0x0D);
	
	// K9G8G08(1 block = 128 page) 2~3 block
	for(i=0;i<128;i++)    // if y download the testcode or OS image, y replace 4 to 64.
	{	
		/*********** fill 'spareBuf' for SPARE AREA ************/
		// must be added : 4 ~ 15(Spare Context) area. Data is 0xFF now.
		Make_4bit_ECC(16);// 16 ~ 23(Sector 0)
		Make_4bit_ECC(24);// 24 ~ 31(Sector 1)
		Make_4bit_ECC(32);// 32 ~ 39(Sector 2)
		Make_4bit_ECC(40);// 40 ~ 47(Sector 3)
		Make_4bit_SpareECC(48);// 48 ~ 55(Spare ECC)
		Make_4bit_SpareECC(56);// 56 ~ 63(Spare ECC Copy)	
		
		Make_4bit_ECC2(16);// 16 ~ 23(Sector 0)
		Make_4bit_ECC2(24);// 24 ~ 31(Sector 1)
		Make_4bit_ECC2(32);// 32 ~ 39(Sector 2)
		Make_4bit_ECC2(40);// 40 ~ 47(Sector 3)
		Make_4bit_SpareECC2(48);// 48 ~ 55(Spare ECC)
		Make_4bit_SpareECC2(56);// 56 ~ 63(Spare ECC Copy)	
		
		srcPt=blockBuf+(i*4096);// back to the 'srcPt' value.	
		/*******************************************************/	
		
		//printf("\nSpare Area #%d: ", i);
		//for(j=0;j<64;j++)
		//	printf("%X ",spareBuf[j]);
			
		//printf("\n");  		
	    
	    if(!NF_2Plane_WritePage(blockIndex,i,srcPt,spareBuf,spareBuf2))// block num, page num, buffer
	    {
	        programError=1;
	        break;
	    }
	    		
		srcPt+=4096;	// Increase buffer addr 2 page size
	 	percent = 0.78125*(i+1);
	    //printf("page #%d program done\n", i);
	    printf("Page Program |");
	    
	    for(barcount=0; barcount<(i/4+1); barcount++)
	    	printf("%c",bar[barcount]);
	    for(spacecount=0; spacecount<32-(i/4+1); spacecount++)
	    	printf("%c",space[spacecount]);
	    	
	    printf("| %d%% page #0 ~ #%d", percent, i);
	    printf("%c",0x0D);
	}
	
	printf("page program done                                                     \n");
	printf("block %d, %d two plane program complete!\n\n",blockIndex*2,blockIndex*2+1);

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

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

/** MLC Spare Area Layout using like SLC(64Byte per 1page(2KByte)) **/
//
//  0      : Bad Mark(0xff)
//  1      : Clean Mark(0x00)
//  2 ~ 3  : Reserved(0xff)
//  4 ~ 15 : Spare context(0xff)
// 16 ~ 19 : Sector0 ECC
// 20 ~ 23 : Sector1 ECC
// 24 ~ 27 : Sector2 ECC
// 28 ~ 31 : Sector3 ECC
// 32 ~ 63 : NOT USED(0xff)
/********************************************************************/
void Make_1bit_ECC(int spareBuf_addr)
{
	int spareBuf_count=0;				
	
	//ECC_GenM(U8 *pEcc, U32 *pBuf, U8 nBW);
	ECC_GenM(chk_parity_1bitECC, srcPt, 0);
	srcPt += 512;
		
	for(spareBuf_count=0;spareBuf_count<4;spareBuf_count++)
		spareBuf[spareBuf_addr + spareBuf_count] = chk_parity_1bitECC[spareBuf_count];	
}



/** MLC Spare Area Layout(64Byte per 1page(2KByte)) **/
//
//  0      : Bad Mark(0xff)
//  1      : Clean Mark(0x00)
//  2 ~ 3  : Reserved(0xff)
//  4 ~ 15 : Spare context(0xff)
// 16 ~ 23 : Sector0 ECC
// 24 ~ 31 : Sector1 ECC
// 32 ~ 39 : Sector2 ECC
// 40 ~ 47 : Sector3 ECC
// 48 ~ 55 : Spare ECC
// 56 ~ 63 : Spare ECC Copy
/*****************************************************/

void Make_4bit_ECC(int spareBuf_addr) 
{	
	int spareBuf_count=0;		
		
	enc_reg(msg_len, srcPt, chk_parity);// msg_len = 512
	srcPt += 512;
		
	for(spareBuf_count=0;spareBuf_count<8;spareBuf_count++)
		spareBuf[spareBuf_addr + spareBuf_count] = chk_parity[spareBuf_count];	
}

void Make_4bit_ECC2(int spareBuf_addr) 
{	
	int spareBuf_count=0;		
		
	enc_reg(msg_len, srcPt, chk_parity);// msg_len = 512
	srcPt += 512;
		
	for(spareBuf_count=0;spareBuf_count<8;spareBuf_count++)
		spareBuf2[spareBuf_addr + spareBuf_count] = chk_parity[spareBuf_count];	
}

void Make_4bit_SpareECC(int spareBuf_addr) 
{	
	int spareBuf_count=0, i;		
		
	for(i=0;i<512;i++)
		spareECC_Buf[i] = 0xFF;
		
	for(i=0;i<44;i++)
		spareECC_Buf[i] = spareBuf[i+4];// spareECC_Buf : 512 buffer, spareBuf : 64 buffer

	enc_reg(msg_len, spareECC_Buf, chk_parity);// msg_len = 512
		
	for(spareBuf_count=0;spareBuf_count<8;spareBuf_count++)
		spareBuf[spareBuf_addr + spareBuf_count] = chk_parity[spareBuf_count];	
}

void Make_4bit_SpareECC2(int spareBuf_addr) 
{	
	int spareBuf_count=0, i;		
		
	for(i=0;i<512;i++)
		spareECC_Buf2[i] = 0xFF;
		
	for(i=0;i<44;i++)
		spareECC_Buf2[i] = spareBuf2[i+4];// spareECC_Buf2 : 512 buffer, spareBuf2 : 64 buffer

	enc_reg(msg_len, spareECC_Buf2, chk_parity);// msg_len = 512
		
	for(spareBuf_count=0;spareBuf_count<8;spareBuf_count++)
		spareBuf2[spareBuf_addr + spareBuf_count] = chk_parity[spareBuf_count];	
}

void K9g8g08_PrintBlock(void)// Printf one page
{
    int i;
    U16 id;