/*======================================================================

 Project Name : S3C2443 verification project

 Copyright 2006 by Samsung Electronics, Inc.
 All rights reserved.

 Project Description :
 This software is only for verifying functions of the S3C2443. 
 Anybody can use this code without our permission.

 File Name    : AM29F800.c
 Description  : Program AMD AM29F800 Flash memory 
 Author       : Junon Jeon
 Dept         : AP
 Created Date : 2006.06.02
 Version      : 0.0
 History
   R0.0 (2006.06.02): Junon draft
		- This code is derived from flash.c of S3C2460A test code.
		
=======================================================================*/

#include <string.h>
#include "option.h"
#include "2443addr.h"
#include "System.h"
#include "Console.h" 
#include "Am29f800.h"


// The addr parameter : WORD mode(16bit), so called in AMD specification.
#define _WR(addr,data)	*((volatile unsigned short *)(addr<<1))=(unsigned short)data
#define _RD(addr)	( *((volatile unsigned short *)(addr<<1)) )
#define _RESET()	_WR(0x0,0xf0f0)
#define BADDR2WADDR(addr)   (addr>>1)

int AM29F800_ProgFlash(unsigned int realAddr,unsigned short data);
void AM29F800_EraseSector(int targetAddr);
void AM29F800_EraseAll(void);
int AM29F800_CheckId(void);
int BlankCheck(int targetAddr,int targetSize);
int _WAIT(void);
  
static void InputTargetAddr(void);
 
static unsigned int srcAddress;
static unsigned int srcOffset;
static unsigned int targetAddress;
static unsigned int targetSize;


void ProgramAM29F800(void)
{
    int i, iSectorAddr;   

    InputTargetAddr();
    
    if(UartDownProgramSize==0)
    {
        printf("The data must be downloaded using ICE from %x\n",UartDownAddress);
    	srcAddress=UartDownAddress;
    }
    else
    	srcAddress=UartDownAddress+4; //to discard the data head for the size
    	

    printf("[Check AM29LVxxx]\n");
    switch(AM29F800_CheckId())  //04.01.12 junon
    {
	case 1 :
	    printf("This device is AM29LV200BB!\n");	
	    break;
	case 2 :
	    printf("This device is AM29LV400BB!\n");	
	    break;
	case 3 :
	    printf("This device is AM29LV800BB!\n");	
	    break;
	case 4 :
	    printf("This device is AM29LV160DB!\n");	
	    break;
	case 5 :
	    printf("This device is AM29LV320DB!\n");	
	    break;
    case 100 :
	    printf("This device is maybe AM29LVxxxXB compatible, but we can use only bottom type!!\n");	
	    break;
   	default:
	    printf("ID Check Error or Not supported IC !!!\n");
	    return;
    }
    
    printf("\nErase the sector:0x%x.\n",targetAddress);

    if(targetAddress<0x4000) iSectorAddr=0x0;
    else if(targetAddress<0x6000) iSectorAddr=0x4000;
    else if(targetAddress<0x8000) iSectorAddr=0x6000;
    else if(targetAddress<0x10000) iSectorAddr=0x8000; 
    else 
    {
    	for (i=2; i<256; i++) // until..16MB
    		if (targetAddress < i*0x10000) 
    		{ 
    			iSectorAddr = (i-1)*0x10000; 
    			break;
    		}
    }

    while (iSectorAddr < targetAddress+targetSize)
    {
	AM29F800_EraseSector(iSectorAddr);
    	if (iSectorAddr == 0x0 ) iSectorAddr = 0x4000;
    	else if (iSectorAddr == 0x4000 ) iSectorAddr = 0x6000;
    	else if (iSectorAddr == 0x6000 ) iSectorAddr = 0x8000;
    	else if (iSectorAddr == 0x8000 ) iSectorAddr = 0x10000;    		
    	else iSectorAddr += 0x10000;
    }

    if(!BlankCheck(targetAddress, targetSize))
    {
		printf("Blank Check Error!!!\n");
		return;
    }

    printf("\nStart of the data writing.\n");

    for(i=0x0;i<targetSize;i+=2) 
    {
        AM29F800_ProgFlash(  i+targetAddress,*( (unsigned short *)(srcAddress+i) )  );
        if((i%0x1000)==0)printf("%x ",i);
    }
    printf("\nEnd of the data writing!!!\n");

    _RESET();

    printf("\nVerifying Start.\n");
    for(i=0x0;i<targetSize;i+=2) 
    {
        if(*( (unsigned short *)(i+targetAddress) )!=*( (unsigned short *)(srcAddress+i) )  )
	{    
	    printf("%x=verify error\n",i+targetAddress);
	    return;
	}
        if((i%0x1000)==0)printf("%x ",i);
    }
    printf("\nVerifying End!!!\n");

    printf("Do you want another programming without additional download? [y/N]\n");
    if(getchar()=='y')ProgramAM29F800();
}

		  
static void InputTargetAddr(void)
{
    static unsigned int nextTargetAddr=0,nextSrcOffset=0;
    
    printf("[AM29F800 Writing Program]\n");

    printf("\nCAUTION: Check AM29LV800 BYTE#(47) pin is connected to VDD.\n");

    printf("\nSource size:0h~%xh\n",UartDownProgramSize);
    printf("\nAvailable Target/Source Address:\n"); 
    printf("    0x0, 0x4000, 0x6000, 0x8000,0x10000,0x20000,0x30000,0x40000,\n");
    printf("0x50000,0x60000,0x70000,0x80000,0x90000,0xa0000,0xb0000,0xc0000,\n");
    printf("0xd0000,0xe0000,0xf0000\n");

    printf("Input target start address among above addresses[0x%x]:",nextTargetAddr);
    targetAddress=GetIntNum();
    if(targetAddress==(unsigned int)(-1))targetAddress=nextTargetAddr;

    printf("Input target data size [0x%x]:",UartDownProgramSize);
    targetSize=GetIntNum();
    if(targetSize==(unsigned int)(-1)) targetSize=UartDownProgramSize;

    printf("target start address=0x%x\n",targetAddress);
    printf("target data size=0x%x\n",targetSize);   
}

								 
int AM29F800_CheckId(void)
{
    unsigned short manId,devId;

    _RESET();
    
    _WR(0x555,0xaaaa);
    _WR(0x2aa,0x5555);
    _WR(0x555,0x9090);
    manId=_RD(0x0);

    _RESET(); // New 5V AM29F800 needs this command. 
    _WR(0x555,0xaaaa);
    _WR(0x2aa,0x5555);
    _WR(0x555,0x9090);
    devId=_RD(0x1);

    _RESET();   

    printf("Manufacture ID(0x0001)=%4x, Device ID(0x22xx)=%4x\n",manId,devId);

    if(manId==0x0001 && devId==0x22bf) return 1; // AM29LV200B
    else if(manId==0x0001 && devId==0x22ba) return 2; // AM29LV400B
    else if(manId==0x0001 && devId==0x225b) return 3; // AM29LV800B
    else if(manId==0x0001 && devId==0x2249) return 4; // AM29LV160D        
    else if(manId==0x0004 && devId==0x2249) return 4; // 29LV160D fairchild        
    else if(manId==0x0001 && devId==0x22f9) return 5; // AM29LV320D        
    else if((devId&0xff00)==0x2200) return 100; // maybe AM29LVxxx series, but we can use only bottom type        
    else return 0;
}


void AM29F800_EraseSector(int targetAddr)
{
    printf("Erasing a sector 0x%x is started!\n", targetAddr);

    _RESET();

    _WR(0x555,0xaaaa);
    _WR(0x2aa,0x5555);
    _WR(0x555,0x8080);
    _WR(0x555,0xaaaa);
    _WR(0x2aa,0x5555);
    _WR(BADDR2WADDR(targetAddr),0x3030);
    _WAIT();
    _RESET();
}


void AM29F800_EraseAll(void) // It takes too many time to erase all
{
    printf("Erasing a chip is started!\n");

    _RESET();

    _WR(0x555,0xaaaa);
    _WR(0x2aa,0x5555);
    _WR(0x555,0x8080);
    _WR(0x555,0xaaaa);
    _WR(0x2aa,0x5555);
    _WR(0x555,0x1010);
    _WAIT();
    _RESET();

    printf("Erasing device is completed!\n");
}


int BlankCheck(int targetAddr,int targetSize)
{
    int i,j;
    for(i=0;i<targetSize;i+=2)
    {
		j=*((unsigned short *)(i+targetAddr));
		if( j!=0xffff)
		{
		    printf("Error!! [Addr:0x%x, Data:0x%x]\n",(i+targetAddr),j);
		    return 0;
		}
    }
    return 1;
}
		   

int _WAIT(void) //Check if the bit6 toggle ends.
{
	volatile unsigned short flashStatus,old;

	old=*((volatile unsigned short *)0x0);

	while(1)
	{
	    flashStatus=*((volatile unsigned short *)0x0);
        if( (old&0x40) == (flashStatus&0x40) )break;
        if( flashStatus&0x20 )
	    {
			//printf("[DQ5=1:%x]\n",flashStatus);
			old=*((volatile unsigned short *)0x0);
			flashStatus=*((volatile unsigned short *)0x0);
			if( (old&0x40) == (flashStatus&0x40) )
			    return 0;
			else return 1;
	    }
	    //printf(".");
	    old=flashStatus;
	}
	//printf("!\n");
	return 1;
}
				

int AM29F800_ProgFlash(unsigned int realAddr,unsigned short data)
{
	volatile unsigned short *tempPt;

        tempPt=(volatile unsigned short *)realAddr;
        _WR(0x555,0xaaaa);
        _WR(0x2aa,0x5555);
        _WR(0x555,0xa0a0);
        *tempPt=data;
        
	return _WAIT();

}