#include <string.h>

#include "def.h"
#include "option.h"
#include "2460addr.h"
#include "2460lib.h"
#include "2460slib.h" 
#include "nand.h"

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

void __RdPage528(unsigned char *pPage);
void __WrPage528(unsigned char *pPage);

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

static void NF_AutoLoad(unsigned int block, unsigned int page, unsigned short addr, unsigned char size);
static void NF_AutoStore(unsigned int block, unsigned int page, unsigned short addr);

static void Input_x8_TargetBlock(void);

static void __irq NFCon_Int(void);


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

static unsigned char seBuf[16]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
static unsigned char spare[16]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
volatile int NFConDone;


#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_WRDATA8(data) 	{(*(volatile unsigned char *)0x40c00010)=data;}

#define NF_WRDATA(data) {rNFDATA=data;}
#define NF_RDDATA8() 		((*(volatile unsigned char*)0x40c00010) )

#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

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

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

	//org
    //srcAddress=0x10500000; 
    //khs(050909)
    srcAddress=(_RAM_STARTADDRESS+0x00500000); 
    printf("source base address(0x10500000)=0x%x\n",srcAddress);	
/*
	// Initializing Buffer ----------------INIT
	testdata = (unsigned char *)(srcAddress);
	for(i=0;i<4096;i++)
		*(testdata++) = i; 

*/

    Input_x8_TargetBlock();


    //printf("target start block number      =%d\n",targetBlock);
    //printf("target size        (0x4000*n)  =0x%x\n",targetSize);
	
    srcPt=(unsigned char *)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;
			 	printf("ECC Error(block=%d,page=%d!!!\n",blockIndex,i);
		        break;
			}
			
			#if ECC_CHECK    
			if(!NF_ReadPage(blockIndex,i,srcPt))
			{
				printf("ECC Error(block=%d,page=%d!!!\n",blockIndex,i);
			}
			#endif	    
			
			srcPt+=512;	// Increase buffer addr one page size

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

		blockIndex++;

    }

}

void K9S1208_PrintBadBlockNum(void)
{
    int i,bad_cnt=0;

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

    
    for(i=0;i<4096;i++)
    {
		if(NF_IsBadBlock(i))   // Print bad block
			bad_cnt++;
    }
    if(bad_cnt==0)
    	printf("There is no bad block\n");
    else
    	printf("There are %d bad blocks\n",bad_cnt);
}

void K9S1208_Page_Write(void)
{
	unsigned int block=0, page=0;
	int i, offset;
	unsigned char * srcPt;
	
	//org.
	//srcPt=(unsigned char *)0x11100000;
	//khs(050909)
	srcPt=(unsigned char *)(_NONCACHE_STARTADDRESS+0x00100000);
		
	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(offset==-1) *srcPt++ = rand()%0xff;
		else *srcPt++ =  i+offset;
	}
	//org.
	//srcPt=(unsigned char *)0x11100000;
	//khs(050909)
	srcPt=(unsigned char *)(_NONCACHE_STARTADDRESS+0x00100000);
	
	printf("Write data[%d block, %d page].\n", block, page);
	if(NF_WritePage(block, page, srcPt)==FALSE) {
		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 ", spare[i]);
	}
	printf("\n\n");

}


void K9S1208_PrintBlock(void)// Printf one page
{
    int i,j;
    unsigned int block,page;
    unsigned char * downPt;
	
	//org.
	//downPt=(unsigned char *)0x11000000;
	//khs(050909)
	downPt=(unsigned char *)_NONCACHE_STARTADDRESS;

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

    printf("Input target block number:");
    block=GetIntNum();
    printf("Input target page number:");   
    page=GetIntNum();

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

void K9S1208_Erase(void)
{
	unsigned int block=0;

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

	printf("Block # to erase: ");
	block = 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;

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

}

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

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

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


void K9S1208_SoftUnLock(void)
{
	unsigned int S_block, E_block;
	printf("SMC(K9S1208V0M) NAND SoftUnLock Test !!!\n");



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

	rNFSBLK=0x0;
	rNFEBLK=0x0;
}


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

static int NF_IsBadBlock(unsigned int block)
{
    int i;
    unsigned int blockPage;
    unsigned char 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(0x5);		// 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)
    {
    	printf("[block %d has been marked as a bad block(%x)]\n",block,data);
    	return 1;
    }
    else
    {
    	return 0;
    }
}

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

  
    NFConDone=0;
    rNFCONT|=(1<<12);		// RnB interrupt enable
    rNFCONT|=(1<<15);	       // Illegal interrupt enable
    pISR_NFLASH= (unsigned)NFCon_Int;
    rSRCPND=BIT_NFLASH;
    rINTMSK=~(BIT_NFLASH);
	
    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++);
//    NF_TRANSRnB();    // Wait tBERS max 3ms.