flashmanager.c

flash驱动和简单管理程序

 ERROR_CODE ErrorCode=NO_ERR;

 ulOffset=STUFF_OFFSET_ADDRESS[iStuff];
 //Get where to write
 for(i=0;i<STUFF_NUM[iStuff];i++)
 {
  ErrorCode=ReadData(ulOffset,lCount,lStride,&Data);
  if(ErrorCode==NO_ERR)
  {
   if(Data!=FLASH_FLAG) break;
  }
  else
  {
   ErrorCode=READ_ERROR;
   LedIndicator(ErrorCode);
   return ErrorCode;
  }
  ulOffset+=STUFF_SIZE[iStuff];
 }
 if(i==STUFF_NUM[iStuff])
 {
  ErrorHandler(iStuff);	//Flash is filled totally with stuff
 }
 else
 {
  wStuffCurrentAddress[iStuff]=STUFF_OFFSET_ADDRESS[iStuff]+i*STUFF_SIZE[iStuff];	
 }
 //Go on searching
 for(;i<STUFF_NUM[iStuff];i++)
 {
  ErrorCode=ReadData(ulOffset,lCount,lStride,&Data);
  if(ErrorCode==NO_ERR)
  {
   if(Data==FLASH_FLAG) break;
  }
  else
  {
   ErrorCode=READ_ERROR;
   LedIndicator(ErrorCode);
   return ErrorCode;
  }
  ulOffset+=STUFF_SIZE[iStuff];
 }
 if(i==STUFF_NUM[iStuff])
 {
  rStuffCurrentAddress[iStuff]=STUFF_OFFSET_ADDRESS[iStuff];
 }
 else
 {
  rStuffCurrentAddress[iStuff]=STUFF_OFFSET_ADDRESS[iStuff]+i*STUFF_SIZE[iStuff];
 }
 LedIndicator(ErrorCode);
 return ErrorCode;	
}

//--------------------------------------------------------------------------//
// ERROR_CODE IsEmpty()                                                      //
//                                                                          //
// Purpose: Check to see if it is empty(no data)                            //
//                                                                          //
// Input(s):iStuff,pData                                                    //                                                                         //
//--------------------------------------------------------------------------//

ERROR_CODE IsEmpty(int iStuff,int *pData)
{
 int i;
 long lCount=1;
 long lStride=0x1;
 unsigned long ulOffset=0x0;
 ERROR_CODE ErrorCode=NO_ERR;
 
 ulOffset=STUFF_OFFSET_ADDRESS[iStuff];
 for(i=0;i<STUFF_NUM[iStuff];i++)
 {            //Check the first 4 bytes in that segment
  ErrorCode=ReadData(ulOffset,lCount,lStride,pData);
  if(ErrorCode==NO_ERR)
  {
   if(*pData==FLASH_FLAG)//if it is not a FLASH_FLAG,we think it goes to the end
   {
   	*pData=0;//Is not empty
    break;
   }
  }
  ulOffset+=STUFF_SIZE[iStuff];
 }
 if(i==STUFF_NUM[iStuff])
 {
  *pData=1;	
 }
 LedIndicator(ErrorCode);
 return ErrorCode;
}

//--------------------------------------------------------------------------//
// ERROR_CODE TrackableWrite()                                              //
//                                                                          //
// Purpose: Save stuff to flash with flash to lable it is a valid stuff.    //
//                                                                          //
// Input(s):iStuff,lCount,pnStuff                                           //
//--------------------------------------------------------------------------//
ERROR_CODE TrackableWrite(unsigned long ulOffset,long lCount,int *pnStuff)
{
  long lStride=0x1;
  int FlashFlag=FLASH_FLAG;
  ERROR_CODE ErrorCode=NO_ERR;
  ErrorCode=WriteData(ulOffset,1,lStride,&FlashFlag);
  if(ErrorCode==NO_ERR)
  {
    ErrorCode=WriteData(ulOffset+TWO_BYTES*1,lCount,lStride,pnStuff);
  }
  LedIndicator(ErrorCode);
  return ErrorCode;
}
//--------------------------------------------------------------------------//
// ERROR_CODE WriteStuff()                                                  //
//                                                                          //
// Purpose: Save stuff,such as config params,record strips,                 //
//          video images and so on, to flash                                //
//                                                                          //
// Input(s):iStuff,lCount,pnStuff                                           //
//--------------------------------------------------------------------------//
ERROR_CODE WriteStuff(int iStuff,long lCount,int *pnStuff)
{ 
  int i=0;
  int nSector=0;
  int IsFlashEmpty=0;//Not Empty
  unsigned long ulOffset;
  ERROR_CODE ErrorCode=NO_ERR;
  
  //Flash write and read initalization 
  if(!lCount) 
  {
   ErrorCode=READ_ERROR;
   LedIndicator(ErrorCode);
   return ErrorCode;
  }
  if(!GlobalCounter)
  {
   ErrorCode=IsEmpty(iStuff,&IsFlashEmpty);
   if(ErrorCode==NO_ERR&&!IsFlashEmpty)
   {
    Relocate(iStuff);
   }
  }
  else
  {
   IsFlashEmpty=0;	
  }
  ulOffset=wStuffCurrentAddress[iStuff];
  //Write data to flash
  if((lCount+1)*TWO_BYTES<STUFF_SIZE[iStuff])
  {
   ErrorCode=TrackableWrite(ulOffset,lCount,pnStuff);
  }
  else
  {
   lCount=STUFF_SIZE[iStuff]/TWO_BYTES-1;
   ErrorCode=TrackableWrite(ulOffset,lCount,pnStuff);	
  }
  //Renew current address
  if(ErrorCode==NO_ERR)
  {
   wStuffCurrentAddress[iStuff]+=STUFF_SIZE[iStuff];
  }
  //Get write state
  wStateMachine(iStuff);
  //Do corresponding action according to specific state
  switch(wState)
  {
   case 0://Do nothing
   break;
   case 1:
   	  if(!IsFlashEmpty)
   	  {
	   nSector=wStuffCurrentAddress[iStuff]&0xffff0000;
	   nSector=wStuffCurrentAddress[iStuff]>>16;
	   nSector=nSector&0x000ff;
	   for(i=nSector;i<nSector+STUFF_ERASE_STRIDE[iStuff]/BF533_FLASH_SECTOR_SIZE;i++)
	   {
	    EraseFlashBlock(i);
	   }
	   rStuffCurrentAddress[iStuff]=wStuffCurrentAddress[iStuff]+STUFF_ERASE_STRIDE[iStuff];
       if(rStuffCurrentAddress[iStuff]==STUFF_OFFSET_ADDRESS[iStuff]+STUFF_NUM[iStuff]*STUFF_SIZE[iStuff])
       {
        rStuffCurrentAddress[iStuff]=STUFF_OFFSET_ADDRESS[iStuff];
       }
   	  }
   break;
   case 2:
      if(!IsFlashEmpty)
      {
       nSector=STUFF_OFFSET_ADDRESS[iStuff]&0xffff0000;
	   nSector=STUFF_OFFSET_ADDRESS[iStuff]>>16;
	   nSector=nSector&0x000ff;
	   for(i=nSector;i<nSector+STUFF_ERASE_STRIDE[iStuff]/BF533_FLASH_SECTOR_SIZE;i++)
	   {
        EraseFlashBlock(i);
	   }
       rStuffCurrentAddress[iStuff]=STUFF_OFFSET_ADDRESS[iStuff]+STUFF_ERASE_STRIDE[iStuff];
       wStuffCurrentAddress[iStuff]=STUFF_OFFSET_ADDRESS[iStuff];
      }
   break;
   default:
   return NO_ERR;
  }	
 GlobalCounter++;
 LedIndicator(ErrorCode);
 return ErrorCode;
}
//--------------------------------------------------------------------------//
// ERROR_CODE TrackableRead()                                               //
//                                                                          //
// Purpose: Save stuff to flash with flash to lable it is a valid stuff.    //
//                                                                          //
// Input(s):iStuff,lCount,pnStuff                                           //
//--------------------------------------------------------------------------//
ERROR_CODE TrackableRead(unsigned long ulOffset,long lCount,int *pnStuff)
{
     long lStride=0x1;
     int FlashFlag=FLASH_FLAG;
     ERROR_CODE ErrorCode=NO_ERR;
     
     //Read first 4 bytes to test data validity
     ErrorCode=ReadData(ulOffset,1,lStride,&FlashFlag);
     if(ErrorCode==NO_ERR)
     {
      if(FlashFlag==FLASH_FLAG)
      {  
       //If it is valid,read the left data
       ErrorCode=ReadData(ulOffset+TWO_BYTES*1,lCount,lStride,pnStuff);
      }
      else
      {
       //Return corresponding error 
       ErrorCode=INVALID_DATA;
       LedIndicator(ErrorCode);
       return ErrorCode;	
      }
     }	
    LedIndicator(ErrorCode);
    return ErrorCode;
}
//--------------------------------------------------------------------------//
// ERROR_CODE ReadStuff()                                                   //
//                                                                          //
// Purpose: Restore stuff,such as config params,record strips,              //
//          video images and so on, from flash                              //
//                                                                          //
// Input(s):iStuff,nStuff,lCount,pnStuff                                    //
//--------------------------------------------------------------------------//
ERROR_CODE ReadStuff(int iStuff,int nStuff,long lCount,int *pnStuff)
{
 int FlashFlag=0x0;
 long lStride=0x1;
 unsigned long ulOffset;
 ERROR_CODE ErrorCode=NO_ERR;
 
 //Param Input check
 if(!nStuff||!lCount||(lCount+1)*TWO_BYTES>STUFF_SIZE[iStuff]) 
 {
  ErrorCode=READ_ERROR;
  LedIndicator(ErrorCode);
  return ErrorCode;	
 }
 //Get flash state
 rStateMachine(iStuff);	
 if(nStuff>nStuffTotalNum) 
 {
  ErrorCode=READ_ERROR;
  LedIndicator(ErrorCode);
  return ErrorCode;		
 }
 switch(rState)
 {
  case 0:
     ulOffset=STUFF_OFFSET_ADDRESS[iStuff]+(STUFF_NUM[iStuff]-nStuff)*STUFF_SIZE[iStuff];
     //Trackable flash read
     ErrorCode=TrackableRead(ulOffset,lCount,pnStuff);
     break;
  case 1:
     if(nStuff>nStuffPartialNum)
     { 
      ulOffset=STUFF_OFFSET_ADDRESS[iStuff]+(STUFF_NUM[iStuff]-(nStuff-nStuffPartialNum))*STUFF_SIZE[iStuff];	
     }
     else
     {
      ulOffset=STUFF_OFFSET_ADDRESS[iStuff]+(nStuffPartialNum-nStuff)*STUFF_SIZE[iStuff];	
     }
     //Trackable flash read
     ErrorCode=TrackableRead(ulOffset,lCount,pnStuff);
     break;
  case 2:
     if(nStuff>nStuffPartialNum)
     {//Reading is out of range
      /*ErrorCode=READ_ERROR;
      LedIndicator(ErrorCode);
      return ErrorCode;	*/
     }
     else
     {
      ulOffset=STUFF_OFFSET_ADDRESS[iStuff]+(nStuffPartialNum-nStuff)*STUFF_SIZE[iStuff];	
     }
     //Trackable flash read
     ErrorCode=TrackableRead(ulOffset,lCount,pnStuff);
     break;
  case 3:
      ErrorCode=FLASH_EMPTY;
      LedIndicator(ErrorCode);
      return ErrorCode;	
  default:
      return NO_ERR;
 }	
 LedIndicator(ErrorCode);
 return ErrorCode;		
}
//--------------------------------------------------------------------------//
// ERROR_CODE UpdateStuff()                                                 //
//                                                                          //
// Purpose: Update or modify any stuff item specified by nStuff when needed //                            //
//                                                                          //
// Input(s):iStuff,nStuff,lCount,pnStuff                                    //
//--------------------------------------------------------------------------//
//This UpdateStuff is reserved for modification about stuff item specified by nStuff
ERROR_CODE UpdateStuff(int iStuff,int nStuff,long lCount,int *pnStuff)
{//Reserved
 ERROR_CODE ErrorCode=NO_ERR;
 /*Strategy:
 1.Locate the block(s) to which the stuff is saved.
 2,Read data in that block(s) out to SDRAM(ReadStuff).
 3.Erase that block in flash(EraseBlock).
 4.Overlay the stuff with updated one(MoveData).
 5.Write back the block updated in SDRAM to flash(WriteStuff). 
 ...
 */
 LedIndicator(ErrorCode);
 return ErrorCode;		
}

//--------------------------------------------------------------------------//
// ERROR_CODE EraseStuff()                                                  //
//                                                                          //
// Purpose:  Erase stuff all specifed by iStuff                             //                           
//                                                                          //
// Input(s):iStuff                                                          //
//--------------------------------------------------------------------------//
ERROR_CODE EraseStuff(int iStuff) 
{
 int i;
 int nSectors=0;
 int StartSector=0;
 ERROR_CODE ErrorCode=NO_ERR;
 StartSector=STUFF_OFFSET_ADDRESS[iStuff]/BF533_FLASH_SECTOR_SIZE;
 nSectors=(FLASH_OFFSET_ADDRESS[iStuff+2]-STUFF_OFFSET_ADDRESS[iStuff])/BF533_FLASH_SECTOR_SIZE;
 for(i=StartSector;i<StartSector+nSectors;i++)
 {
  EraseFlashBlock(i); 	
 }
 
 LedIndicator(ErrorCode);
 return ErrorCode;	
}