复件 flash16.c

来自「coldfire5307的bootloader 将程序写入flash」· C语言 代码 · 共 791 行 · 第 1/2 页

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


#define FLASH_555H 	 0x555
#define FLASH_2AAH  	 0x2AA


#define CHIP_PROTECT     
#define CHIP_UNPROTECT

//#define INTEL_FLASH               //注意，根据flash型号定义或屏蔽

#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];
  //unsigned short *Protect=(unsigned short *)0x22800000;
  int size;           //kang

  //(*Protect)=0xffff;

  
  //read  ChipDeviceID and ChipManufacturerID                     //kang第二片
  d_ID = sChipDeviceID( 0xFF200000 );
  //sprintf(Buf,"Chip   ID is: %04x\r\n",d_ID);
  //Printf(Buf);
  
  
  m_ID = sChipManufacturerID( 0xFF200000 );
  //sprintf(Buf,"Vendor ID is: %04x\r\n",m_ID);
  //Printf(Buf);


 
  //read  ChipDeviceID and ChipManufacturerID       
  d_ID = sChipDeviceID( baseCS0 );
  //sprintf(Buf,"Chip   ID is: %04x\r\n",d_ID);
  //Printf(Buf);
  
  
  m_ID = sChipManufacturerID( baseCS0 );
  //sprintf(Buf,"Vendor ID is: %04x\r\n",m_ID);
  //Printf(Buf);



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

	//  m_ID=WriteBlockData(0xff200000,0x00020000/2, (unsigned short *)AppImg,   (0x1E0000/2));

  m_ID=WriteBlockData(0xff200000,0x00000000/2, (unsigned short *)((unsigned int)AppImg+(unsigned int)0x1E0000),   ((sizeof(AppImg)-0x1E0000)/2)+0x02);//ucLINUX在flash2上的部分

 // m_ID=WriteBlockData(0xff200000,0x00000000/2, (unsigned short *)AppImg,   (sizeof(AppImg)/2)+0x2);


   
   
  
  //if(0x01==m_ID)
  //	Printf("bootloader  write ok\r\n");
  //else
  //	Printf("bootloader  write fail\r\n");
 
  //m_ID=WriteBlockData(0xff000000,0x00020000/2, (unsigned short *)Phase_C, 2000);
  //if(0x01==m_ID)
  //	Printf("linux image write ok\r\n");
  //else
  //	Printf("linux image write fail\r\n");

  /*
  Printf("System halted\r\n");
 
  
  
  //erase Flash Memory 1
  CHIP_UNPROTECT;
  
  //if ( !sChipErase( 0xFe000000 ) )
  //   return;

  //read  ChipDeviceID and ChipManufacturerID
  d_ID = sChipDeviceID( baseCS0 );
  m_ID = sChipManufacturerID( baseCS0 );
  
  //  if ( !sSectorErase(baseCS0,0) )
  //     return;    


  while(1)
  {
  if ( !sSectorErase(baseCS0,0) )
       return; 
  sWriteWord( baseCS0,    0x0000, 0x0000 );  
  resultP=(unsigned short *)baseCS0;
  resultP+=0x0000;
  m_ID=*resultP;
  if(m_ID!=0x0)
  	{
  	while(1)
  		{
        m_ID++;
  		}
  	}

  if ( !sSectorErase(baseCS0,0x10000) )
       return; 
  sWriteWord( baseCS0,    0x10000, 0x1111 ); 
  resultP=(unsigned short *)baseCS0;
  resultP+=0x10000;
  m_ID=*resultP;
  if(m_ID!=0x1111)
  	{
  	while(1)
  		{
        m_ID++;
  		}
  	}


  if ( !sSectorErase(baseCS0,0x20000) )
       return; 
  sWriteWord( baseCS0,    0x20000, 0x2222 );  
  resultP=(unsigned short *)baseCS0;
  resultP+=0x20000;
  m_ID=*resultP;
  if(m_ID!=0x2222)
  	{
  	while(1)
  		{
        m_ID++;
  		}
  	}
  
  if ( !sSectorErase(baseCS0,0x30000) )
       return; 
  sWriteWord( baseCS0,    0x30000, 0x3333 );  
  resultP=(unsigned short *)baseCS0;
  resultP+=0x30000;
  m_ID=*resultP;
  if(m_ID!=0x3333)
  	{
  	while(1)
  		{
        m_ID++;
  		}
  	}
  
  if ( !sSectorErase(baseCS0,0x40000) )
       return;   
  sWriteWord( baseCS0,    0x40000, 0x4444 );  
  resultP=(unsigned short *)baseCS0;
  resultP+=0x40000;
  m_ID=*resultP;
  if(m_ID!=0x4444)
  	while(1)
  	{
  		{
        m_ID++;
  		}
  	}

  if ( !sSectorErase(baseCS0,0x50000) )
       return; 
  sWriteWord( baseCS0,    0x50000, 0x5555 );  
  resultP=(unsigned short *)baseCS0;
  resultP+=0x50000;
  m_ID=*resultP;
  if(m_ID!=0x5555)
  	{
  	while(1)
  		{
        m_ID++;
  		}
  	}
  	
  if ( !sSectorErase(baseCS0,0x3f8000) )
       return; 
  sWriteWord( baseCS0,    0x3f8000, 0xABCD );  
  resultP=(unsigned short *)baseCS0;
  resultP+=0x3f8000;
  m_ID=*resultP;
  if(m_ID!=0xABCD)
  	{
  	while(1)
  		{
        m_ID++;
  		}
  	}
  
  }
  
  CHIP_PROTECT;
*/

}


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
    
    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!