amdflash.c

基于dragon_MX1_ads的装载启动代码armboot

#include "AMDFlash.h"

flash_t _gOpenedFlash[] = { {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
                            {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0} };

U32 FlashReset(S32 fd)
{
  return _gOpenedFlash[fd-1].pFlashType->Reset(_gOpenedFlash[fd-1].BaseAddress) ;
}

S32 FlashOpen(flash_type_t* pFlashType, U32 BaseAddress)
{
  S32 fd=0;
  U32  n, i;
  
  n= sizeof(_gOpenedFlash)/sizeof(flash_t);
  
  for(i=0; i<n; i++)
    if(_gOpenedFlash[i].Opened == 0) {
      fd = i + 1;
      _gOpenedFlash[fd-1].pFlashType  = pFlashType;
      _gOpenedFlash[fd-1].BaseAddress = BaseAddress;
      _gOpenedFlash[fd-1].Opened      = 1;
      break;
    }

  FlashReset(fd);

  return fd; /* return zero if cannot open flash */
}

U32 FlashClose(S32 fd)
{
  _gOpenedFlash[fd-1].Opened = 0;

  return 0;
}

U32 FlashBlockLock(S32 fd, U32 target_offset)
{
  return _gOpenedFlash[fd-1].pFlashType->BlockLock(_gOpenedFlash[fd-1].BaseAddress, target_offset);
}

U32 FlashBlockUnlock(S32 fd, U32 target_offset)
{
  return _gOpenedFlash[fd-1].pFlashType->BlockUnlock(_gOpenedFlash[fd-1].BaseAddress, target_offset);
}

U32 FlashEnterReadMode(S32 fd, U32 offset)
{
  return _gOpenedFlash[fd-1].pFlashType->EnterReadMode(_gOpenedFlash[fd-1].BaseAddress, offset);
}

U32 FlashBlockUnlockAll(S32 fd)
{
  U32 i;
  U32 blk_max;
  U32 *pMemMap;
 
  pMemMap     = _gOpenedFlash[fd-1].pFlashType->memorymap;
  blk_max     = _gOpenedFlash[fd-1].pFlashType->BlockNumber();

  for(i=0; i<blk_max; i++)
    FlashBlockUnlock(fd, pMemMap[i]);
    
  return 0;
}

U32 FlashBlockErase(S32 fd, U32 offset)
{
  return _gOpenedFlash[fd-1].pFlashType->BlockErase(_gOpenedFlash[fd-1].BaseAddress, offset);
}

U32 FlashBlockEraseComplete(S32 fd, U32 offset)
{
  return _gOpenedFlash[fd-1].pFlashType->BlockEraseComplete(_gOpenedFlash[fd-1].BaseAddress, offset);
}

U32 FlashWriteSetup(S32 fd, U32 target_offset)
{
  return _gOpenedFlash[fd-1].pFlashType->WriteSetup(_gOpenedFlash[fd-1].BaseAddress, target_offset);
}

U32 FlashWriteCommand(S32 fd, U32 target_offset)
{
  return _gOpenedFlash[fd-1].pFlashType->WriteCommand(_gOpenedFlash[fd-1].BaseAddress, target_offset);
}

U32 FlashWrite(S32 fd, U32 target_offset, void* pData)
{
  return _gOpenedFlash[fd-1].pFlashType->Write(_gOpenedFlash[fd-1].BaseAddress, target_offset, pData);
}

U32 FlashWriteComplete(S32 fd, U32 target_offset, void* pData)
{
  return _gOpenedFlash[fd-1].pFlashType->WriteComplete(_gOpenedFlash[fd-1].BaseAddress, target_offset, pData);
}

U32 FlashCheckBlockNumber(S32 fd, U32 target_offset)
{
  U32 i, n;
  U32 *pMemMap;
  
  pMemMap = _gOpenedFlash[fd-1].pFlashType->memorymap;
  n = _gOpenedFlash[fd-1].pFlashType->BlockNumber();

  for(i=0; i<n; i++) {
    if( pMemMap[i] <= target_offset && target_offset < pMemMap[i+1] )
      return i;
  }

  return 0;
}

/***************************************************************************/

U32 FlashProgram(S32 fd, U32 source_address, U32 target_offset, U32 byte_size)
{
  U32 i;
  U32 blk_count;
  U32 blk_max;
  U32 error=0;
  U32 status;

  U32 BaseAddress;
  U32 BusWidth;
  U32 *pMemMap;
 
  BaseAddress = _gOpenedFlash[fd-1].BaseAddress;
  BusWidth    = _gOpenedFlash[fd-1].pFlashType->BusWidth;
  pMemMap     = _gOpenedFlash[fd-1].pFlashType->memorymap;
  blk_max     = _gOpenedFlash[fd-1].pFlashType->BlockNumber();
  blk_count   = FlashCheckBlockNumber(fd, target_offset); // Find the first block to be program

  /* Need to Erase the block when starting in the middle of a block */
  if( target_offset != pMemMap[blk_count] ) { /* if it is not a staring of a block */
    FlashBlockUnlock(fd, pMemMap[blk_count]);
    FlashBlockErase(fd, pMemMap[blk_count]);
    EUARTputString("P");
    while(! (status=FlashBlockEraseComplete(fd, pMemMap[blk_count])) );
    if(status & STATUS_ERROR) {
         error++;
         EUARTputString("\n*** Error - Block Erase ***\n");
         return error;
    }
    FlashWriteSetup(fd, pMemMap[blk_count]);
  }
 
  for(i=0; i<byte_size; ) {
    if( i+target_offset == pMemMap[blk_count] ) { /* if it is a staring of a block */
       FlashBlockUnlock(fd, pMemMap[blk_count]);
       FlashBlockErase(fd, pMemMap[blk_count]); 
       EUARTputString("P"); 
       while(! (status=FlashBlockEraseComplete(fd, pMemMap[blk_count])) );
       if(status & STATUS_ERROR) {
         error++;
         EUARTputString("\n*** Error ***\n");
         return error;
       }
       FlashWriteSetup(fd, pMemMap[blk_count]);
    }

    FlashWriteCommand(fd, i+target_offset);
    FlashWrite(fd, i+target_offset, (void *)(source_address+i));

    while( ! (status=FlashWriteComplete(fd, i+target_offset, (void *)(source_address+i))) )
    {
	;
    }
    if(status & STATUS_ERROR) {
         error++;
         EUARTputString("\n*** Error - Write Error ***\n");
         return error;
    }

    switch(BusWidth) {
    case 8:
      i++;
      break;
    case 16:
      i+=2;
      break;
    case 32:
      i+=4;
      break;
    }

    if( i + target_offset == pMemMap[blk_count+1] ) { /* if it is a starting of next block */
      FlashEnterReadMode(fd, pMemMap[blk_count]);
      blk_count++;
    }
  }

  FlashEnterReadMode(fd, pMemMap[blk_count]);
  FlashReset(fd);

  return error;
}

U32 FlashVerify(S32 fd, U32 source_address, U32 target_offset, U32 byte_size)
{
  U32 i;
  U32 error = 0;
  U32 BaseAddress;

  BaseAddress = _gOpenedFlash[fd-1].BaseAddress;

  for(i=0; i<byte_size; i++)
  {
    if( *(volatile U8 *)(source_address+i) != 
        *(volatile U8 *)(BaseAddress+target_offset+i) ) {
      error++;
//      EUARTputString("\n0x%X\n", BaseAddress+target_offset+i);
    }
    
    if( (i & 0x3FFFF) == 0 )
      EUARTputString("V");
  }

  return error;
}