flash16.c

sst flash的读写程序的编写 完整教程和实例程序和几个实用小工具

#include "mcf5307.h" 
//#include "string.h"


#define FLASH_555H 	 0x5555
#define FLASH_2AAH  	 0x2AAA


#define CHIP_PROTECT     
#define CHIP_UNPROTECT

//#define INTEL_FLASH               //注意，根据flash型号定义或屏蔽
//已经更改为SST39VF160

#define bool unsigned char
#define TRUE   1
#define True   TRUE
#define FALSE  0
#define False  FALSE

#define BlockSize 32768   // for intel TE28F800C3T , it's 32 K words at low address !


void delay(int);          //kang
void Unlock(void);
void Lock(void);
bool VerifyBlank(long lBaseAddress,long Size);
bool WriteTest(long lBaseAddress);


bool sChipErase( long lBaseAddress );
bool sSectorErase( long lBaseAddress, long lSectorAddress );
bool sSectorUnlock( long lBaseAddress, long lSectorAddress );

bool sWriteWord( long lBaseAddress, long lAddress, short sData );
bool sVerifyEnd( volatile short *spAddress, short sVerifyData );
short sChipManufacturerID( long lBaseAddress );
short sChipDeviceID( long lBaseAddress );
unsigned short GetFlashStatus( long lBaseAddress );
bool WriteBlockData(int lBaseAddress, int BlockStartAddress, volatile unsigned short * SrcAddress, int HowmanyWords);	

//extern void Printf(char * Index);

unsigned char Sta[100000];


//at 0xff000000
unsigned char StartImg[]={
			0x00,0x00,0x05,0x00,0xff,0x01,0x00,0x00               //第一个是堆栈地址，第二个是复位跳转地址
			};



//at 0xff010000
unsigned char BootImg[]={
			
				#include "..\code-boot\bootloader.txt"      //bootloader,自己编写的启动代码
         		//#include "diskloader.txt"	
			};

//at 0xff020000
unsigned char AppImg[]={
				#include "..\code-boot\linux.txt"               //uclinux代码
				//0,0,0,0
			};


//#include "e:\mat-work\1.txt"


//unsigned char StartAdd[]={0x00,0x30,0x00,0x00,0xff,0x01,0x00,0x00};
//unsigned char StartAdd[]={(0xff000000&(100+sizeof(LinuxImg)))>>24,(0x00ff0000&(100+sizeof(LinuxImg)))>>16,(0x00ff00&(100+sizeof(LinuxImg)))>>8,(0x00ff&(100+sizeof(LinuxImg))),0xff,0x01,0x00,0x00};

bool sFlashChip( long lBaseAddress )
{
	short m_ID,d_ID;
	bool FlashOp;
		
	d_ID = sChipDeviceID( lBaseAddress );
	m_ID = sChipManufacturerID( lBaseAddress );
	
        
        return 1;		
	
}


void Flash_Test()
{
  unsigned short m_ID,d_ID;
  unsigned short *resultP;
  long baseCS0 = 0xFF000000;
  char Buf[200];
  int size;           //kang

  //read  ChipDeviceID and ChipManufacturerID       
  //m_ID     :00BFH     for sst flash
  //d_ID      :2782H     for sst flash
  d_ID = sChipDeviceID( baseCS0 );
  m_ID = sChipManufacturerID( baseCS0 );

  m_ID=WriteBlockData(0xff000000,0x00000000/2, (unsigned short *)StartImg, (sizeof(StartImg)/2)+0x02);//+0x20
  
  m_ID=WriteBlockData(0xff000000,0x00010000/2, (unsigned short *)BootImg, (sizeof(BootImg)/2)+0x02);
     size=sizeof(AppImg);        //kang
  m_ID=WriteBlockData(0xff000000,0x00020000/2, (unsigned short *)AppImg,   sizeof(AppImg)); // ucLINUX在flash1上的部分



}


bool sChipErase( long lBaseAddress )
{
  volatile short *sp;
  bool retval;
  sp = (short*)lBaseAddress;

  *( sp + FLASH_555H ) = 0xAA;
  *( sp + FLASH_2AAH ) = 0x55;
  *( sp + FLASH_555H ) = 0x80;
  *( sp + FLASH_555H ) = 0xAA;
  *( sp + FLASH_2AAH ) = 0x55;
  *( sp + FLASH_555H ) = 0x10;

  retval = sVerifyEnd( sp, 0x80 );   //if operation is finished, DQ7 = 1
  return retval;
}

/************************************************************************
Name:     sSectorErase
Function: erase data of a sector
input:    lBaseAddress, the base address of Flash memory to be erased
          lSectorAddress, the base address the sector to be erased
return:   True: erase is successful; False: erase is fail
*************************************************************************/

bool sSectorErase( long lBaseAddress, long lSectorAddress )
{
  volatile short *sp;
  bool retval;
  unsigned short ID;
  sp = (short*)lBaseAddress;

  #ifndef INTEL_FLASH

	*( sp + FLASH_555H ) = 0xAA;
	*( sp + FLASH_2AAH ) = 0x55;
	*( sp + FLASH_555H ) = 0x80;
	*( sp + FLASH_555H ) = 0xAA;
	*( sp + FLASH_2AAH ) = 0x55;
//	*( sp + lSectorAddress ) = 0x30;   //??? lSectorAddress = 0x3000
   	*( sp + lSectorAddress ) = 0x50;   //KANG,Block-Erase
 
    retval = sVerifyEnd( sp+lSectorAddress, 0x80 );   //if operation is finished, DQ7 = 1
   
   
    return retval;

  #else

	Unlock();

   
  	*sp=0x50;								//clear flag
  	
    *sp=0x60;								//set config
    *( sp + lSectorAddress ) = 0xd0;		//unlock it!

    *sp=0x90;								//read config

    ID=*(sp+lSectorAddress+2);								//is unlock ?
    while(0x00!=(ID&0x01))
    	{
    	 ID=*(sp+lSectorAddress+2);		
    	}


    *sp=0x50;							  //clear flag	
    *( sp + lSectorAddress ) = 0x20;  	//setup erase
    *( sp + lSectorAddress ) = 0xd0;   //confirm it! 


	ID=*sp;								//ready ?
    while(0x00==(ID&0x80))
    	{
    	 ID=*sp;		
    	}


    ID=*(sp);							 //all ok?
    if(0x00==(ID&0x3a))
    	{
    	*sp=0xff;						//set it in read mode
    	return True;
    	}
    else
    	{
    	*sp=0xff;						
    	return False;
    	}
    	

  #endif

  	
}


bool sSectorUnlock( long lBaseAddress, long lSectorAddress )
{
  volatile short *sp;
  bool retval;
  unsigned short ID;
  int i=0;
  sp = (short*)lBaseAddress;

  #ifndef INTEL_FLASH

    return 0x01;

  #else

	Unlock();

   
  	*sp=0x50;								//clear flag
  	
    *sp=0x60;								//set config
    *( sp + lSectorAddress ) = 0xd0;		//unlock it!

    *sp=0x90;								//read config

    ID=*(sp+lSectorAddress+2);								//is unlock ?
    i=0;
    while(0x00!=(ID&0x01))
    	{
    	 ID=*(sp+lSectorAddress+2);
    	 i++;
    	 if(i>10000)						//over time ?
    	 	return False;
    	}


    *sp=0x50;							  //clear flag	
   	*sp=0xff;						
   	return True;
   
  #endif

  	
}









/***************************************************************************
Name:    sVerifyEnd
Function: Verify if the operation to Flash mem is finished
input:    spAddress: the address of Flash mem to be verified
	  sVerifyData: Verify Data
return:   True: writing passed;     False: writing is fail	        
***************************************************************************/

bool sVerifyEnd( volatile short *spAddress, short sVerifyData )
{
  unsigned short sb;
  unsigned  i;
  sb = * spAddress;


  #ifndef INTEL_FLASH


  while( (sb & 0x80 ) != ( sVerifyData & 0x80 ) )
  {
    if( (sb & 0x20 ) == 0x20 )            //if DQ5 == 1, exceed timing limits
    {
      sb = *spAddress;                    //read data again
      if( (sb & 0x80) != (sVerifyData & 0x80) )   //if DQ7!=Data, writing is failure
	return False;
      else
        return True;
    }
    sb = *spAddress;                      //read data again
  }
  return True;


#else

 
  sb=GetFlashStatus((long)spAddress);

  while( (sb & 0x80 ) != 0x80 )       //  1 means ready
  	{
  	
    if( 0x00!= ((sb)&sVerifyData) )  // 0 means ok!
			return False;
    else
    	    return True;		
        
    sb=GetFlashStatus((long) spAddress); 
  	}

  if( 0x00!= ((sb)&sVerifyData) )  // 0 means ok!
			return False;
    else
    	    return True;		
        

#endif


  
}

/*****************************************************************************
Name:     sWriteWord
Function: Write a word to Flash memory
input:    lBaseAddress: The first address of Flash memory
	  lAddress: Address of the memory to be written
	  sData: Data to be written
return:   True: writing is successful;  False: writing is failure
*****************************************************************************/

bool sWriteWord( long lBaseAddress, long lAddress, short sData )
{
  volatile short *sp;
  bool retval;
  unsigned short ID;

  sp = (short*)lBaseAddress;

  #ifndef INTEL_FLASH

        *( sp + FLASH_555H ) = 0xAA;
        *( sp + FLASH_2AAH ) = 0x55;
        *( sp + FLASH_555H ) = 0xA0;

        sp += lAddress;
        *sp = sData;
		
	//return 1;   //kang
        retval = sVerifyEnd( sp, sData );  
        return retval;

  #else

  		Unlock();


        *sp=0x50;													 //clear flag

	    *sp=0x40;												    //program command 
	    
    	*( sp + lAddress ) = (unsigned short)(sData);		//send data
    	
		while( 0x80!=(0x80&(*sp)) )							//wait ready
			{
			;
			}


	ID=*(sp);							 //all ok?
    if(0x00==(ID&0x1a))
    	{
    	*sp=0xff;						//set it in read mode
    	return True;
    	}
    else
    	{
    	*sp=0xff;						
    	return False;
    	}
	

  #endif

  	
  
}


short sChipManufacturerID( long lBaseAddress )
{

#ifndef INTEL_FLASH

  volatile short *sp, M_ID;
  sp = (short*)lBaseAddress;

  *( sp + FLASH_555H ) = 0xAA;
  *( sp + FLASH_2AAH ) = 0x55;
  *( sp + FLASH_555H ) = 0x90;
  M_ID = * sp ;
  *sp=0xf0;
  return M_ID;

#else

  volatile short *sp,M_ID;
  sp = (short*)lBaseAddress; 
  
  *sp=0x90;				// first cycle, 

  M_ID = *(sp+0x0);
  *sp=0xff;
  
  return M_ID;  		//intel should be 0x0089
   
#endif
  
}

short sChipDeviceID( long lBaseAddress )
{
  volatile short *sp,D_ID;
  sp = (short*)lBaseAddress;


#ifndef INTEL_FLASH


  *( sp + FLASH_555H ) = 0xAA;
  *( sp + FLASH_2AAH ) = 0x55;
  *( sp + FLASH_555H ) = 0x90;
  D_ID = * ( sp + 0x01 );
  *sp=0xf0;
  return D_ID;

#else

  sp = (short*)lBaseAddress; 
  
  *sp=0x90;				// first cycle, 

  D_ID = *(sp+0x1);
  *sp=0xff;
  return D_ID;  		//
  

#endif


  
}


unsigned short GetFlashStatus( long lBaseAddress )
{
#ifdef INTEL_FLASH

	volatile unsigned short * sp;

	unsigned short Status;
	
	sp = (unsigned short *)lBaseAddress;
	*sp=0x70;
	Status=*sp;

	return (Status);

#endif
}


void Unlock(void)
{
//	unsigned char * p;
//	p=(unsigned char *)0x33400000;
//	*p=0x20;
 	
}
void Lock(void)
{
//	unsigned char * p;
//	p=(unsigned char *)0x33400000;
//	*p=0x00;
}

bool VerifyBlank(long lBaseAddress,long Size)
{
 unsigned short int Blank;
 volatile unsigned short int *BlankPtr;
 long Temp;
 
 Temp=0;
 BlankPtr=(unsigned short int *)lBaseAddress;
 while(Temp<Size)
 {
  Blank=*BlankPtr;
  BlankPtr++;
  Temp++;
  if(Blank!=0xffff)  return FALSE;
 }
 return TRUE;
  	
}

bool WriteTest(long lBaseAddress)
{
 volatile unsigned  short  int *Ptr;
 
 if(sSectorErase(lBaseAddress,0x1f8000)==0x00)           //erase the bottom
    return 0x00;
 
 if(sWriteWord(lBaseAddress,0x1f8000,0x1234)==0x00)    // write the bottom  
    return 0x00;
    
 Ptr=(unsigned  short  int *)(lBaseAddress+2*0x1f8000);

 if( (*Ptr)!=0x1234  )                                  //read th result 
    return 0x00;    
 else
    return 0x01;
    
 
 if(sSectorErase(lBaseAddress,0x0)==0x00)         //erase the top
    return 0x00;
 
 if(sWriteWord(lBaseAddress,0x0,0x1234)==0x00)    // write the top  
    return 0x00;
    
 Ptr=(unsigned  short  int *)(lBaseAddress+2*0x0);

 if( (*Ptr)!=0x1234  )                                  //read th result 
    return 0x00;    
 else
    return 0x01;   
    	
}

//for example 
// 0xfe000000
// 0x00010000
// 0x2000
//macro BlockSize needed!
// return 0x01 if ok
bool WriteBlockData(int lBaseAddress, int BlockStartAddress, volatile unsigned short * SrcAddress, int HowmanyWords)	
{

 int BlockIndex;
 int SrcCheckSum;
 int DestCheckSum;
 unsigned short Temp;

 volatile unsigned short * Src;
 volatile unsigned short * Dest; 
 
 int i;
 
 BlockIndex=0;

 Src=(unsigned short *)SrcAddress;
 Dest=(unsigned short *)(lBaseAddress+2*BlockStartAddress);

 //erase the first sector
 if( False==sSectorErase(lBaseAddress,BlockStartAddress+BlockSize*BlockIndex) )
 	return False;
 	delay(1000);//kang
 	
 for(i=0;i<HowmanyWords;)
 	{
     Temp=*SrcAddress;
     //Temp=(unsigned short)(0xffff&(*SrcAddress));
     	
     if(False==sWriteWord(lBaseAddress,BlockStartAddress+BlockSize*BlockIndex+(i%BlockSize),Temp) )
     	return False;
     //delay(1);//kang
     SrcAddress++;
     i++;
     
     if( (0x0==(i%BlockSize)) && (i!=HowmanyWords))
     	{
     	BlockIndex++;
     	//delay(10);//kang
     	if( False==sSectorErase(lBaseAddress,BlockStartAddress+BlockSize*BlockIndex) )
		 	return False;
		delay(1000);//kang
     	}
 		
 	}


 //now we will check it!

 
 for(i=0;i<HowmanyWords;i++)
 	{
 	
 	
	if(*Src!=*Dest)
		return False;

    /*
	if( *Dest!=((unsigned short)(0xffff&(unsigned short)Dest)) )
		return False;
    */
    
	
	Src++;
	Dest++;
 	}

 return True;	


}


// 延时
void delay(int t)
{
	int i=0,j=0;
	for(i=0;i<t;i++)
		for(j=0;j<10000;j++)
		;
		
}