用CFlashAmd对些DBAU1200开发板的BOOT FLASH

最新推荐文章于 2023-03-02 18:52:36 发布

norains

最新推荐文章于 2023-03-02 18:52:36 发布

阅读量2.2k

点赞数

分类专栏： WinCE 文章标签： flash command buffer byte wince parallel

本文链接：https://blog.csdn.net/norains/article/details/2498178

版权

WinCE 专栏收录该内容

193 篇文章 1 订阅

订阅专栏

//========================================================================
//TITLE:
//    DBAU1200开发板的BOOT FLASH读写
//AUTHOR:
//    norains
//DATE:
//    Saturday 31-May-2008
//Environment:
//    VS2005 + DBAU1200 BOARD + MIPSII SDK
//========================================================================

    WinCE的一个好处就是，能够在应用程序中访问物理内存。也正是在这个基础之上，才使我们在应用程序中能够更新boot flash。

    为了使用上方便，已经将flash的读写操作封装为Class，在此先看代码：

//
// Flash.h
//
//
namespace Flash
{
   //Flash information
   struct FlashInfo
   {
       int Bank;
       int Width;
       unsigned long Size;   //The size of the flash
       unsigned long SectorSize; //The sector size, in bytes.
       unsigned long BootSectorCount;
       unsigned long BootSectorSize;
       unsigned long WriteBufferSize;
   };

   //The information of the specified flash
   const FlashInfo   FLASH_INFO_AM29LV256M = {2,16,0x04000000,0x10000,0,0,(16 * (16 / 8))};
};

//
// FlashAmd.h: interface for the CFlashAmd class.
//
//Version:
//   1.1.0
//
//Date:
//   2008.05.29
//
//Description:
//
//
//

#pragma once

#include "Flash.h"

class CFlashAmd
{

public:
   //Interface

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Erase the flash
   //
   //Parameters:
   //   ulAddressOffset : [in] The offset address to erase
   //   ulSize : [in] The number of byte
   //   bCompletion : If true, the function would return after finish erasing,or it would return immediately.
   //
   //-------------------------------------------------------------------------------------------------------
   virtual bool EraseFlash(unsigned long ulAddressOffset,unsigned long ulSize,bool bCompletion );

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Lock the flash
   //
   //Parameters:
   //   ulAddressOffset : [in] The offset address to lock
   //   ulSize : [in] The number of byte to lock
   //-------------------------------------------------------------------------------------------------------
   virtual void LockFlash(unsigned long ulAddressOffset,unsigned long ulSize);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Unlock the flash
   //
   //Parameters:
   //   ulAddressOffset : [in] The offset address to unlock
   //   ulSize : [in] The number of byte to unlock
   //-------------------------------------------------------------------------------------------------------
   virtual void UnlockFlash(unsigned long ulAddressOffset,unsigned long ulSize);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Read the flash
   //
   //Parameters:
   //   ulAddressOffset : [in] The offset address to read
   //   pDataStore : [out] The buffer for storing the data.
   //   ulSize : [in] The size of the buffer
   //-------------------------------------------------------------------------------------------------------
   virtual bool ReadFlash(unsigned long ulAddressOffset,void *pDataStore,unsigned long ulSize);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Wait for finishing erasing
   //
   //Parameters:
   //   ulAddressOffset : [in] The offset address to wait
   //-------------------------------------------------------------------------------------------------------
   virtual bool WaitForEraseComplete(unsigned long ulAddressOffset);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Write the data to the flash
   //
   //Parameters:
   //   ulAddressOffset : [in] The offset address to write.
   //   pDataWrite : [in] The data buffer to write
   //   ulSize : [in] The source buffer length in bytes,must be multiple of 4
   //   bErase : [in] If true, it would erase the block before writing.
   //-------------------------------------------------------------------------------------------------------
   virtual bool WriteFlash(unsigned long ulAddressOffset,const void * pDataWrite,unsigned long ulSize,bool bErase);


   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Set the flash base address
   //
   //Parameters:
   //   dwAddress : [in] The base address to set
   //-------------------------------------------------------------------------------------------------------
   bool SetFlashAddressBase(unsigned long ulAddress);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Set the flash base address
   //-------------------------------------------------------------------------------------------------------
   unsigned long GetFlashAddressBase(void);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Set the flash information
   //-------------------------------------------------------------------------------------------------------
   bool SetFlashInfo(const Flash::FlashInfo & flashInfo);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Get the flash information
   //-------------------------------------------------------------------------------------------------------
   const Flash::FlashInfo& GetFlashInfo();

public:
   CFlashAmd(void);
   ~CFlashAmd(void);

private:

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Return the base address of a FLASH bank
   //
   //Parameters:
   //   iBank : [in] Bank number (zero based)
   //
   //Return Values:
   //   Base address of the FLASH bank
   //
   //-------------------------------------------------------------------------------------------------------
   unsigned long GetBankBaseAddress(int iBank);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Returns the index of the FLASH bank containing the specified address
   //
   //Parameters:
   //   ulAddr : [in] FLASH Address
   //
   //Return Values:
   //   Index of the FLASH bank containing Address
   //
   //-------------------------------------------------------------------------------------------------------
   int GetBankIndex(unsigned long ulAddr);


   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   IssueFlashCommand RESET/UNLOCK/ERASE/.....
   //
   //Parameters:
   //   ulCommand : [in] command id
   //   ulParam1, ulParam2 : [in] Command Dependent:
   //       CMDRESET:           ulParam1 - FLASH Bank
   //                           ulParam2 - Ignore
   //       CMDUNLOCK:           ulParam1 - FLASH Bank
   //                           ulParam2 - Ignore
   //       CMDERASESET:       ulParam1 - FLASH Bank
   //                           ulParam2 - Ignore
   //       CMDERASESECTOR:       ulParam1 - FLASH Bank
   //                           ulParam2 - Sector
   //       CMDPROGRAM:           ulParam1 - FLASH Bank
   //                           ulParam2 - Ignore
   //       CMDWRITEBUFFER:       ulParam1 - Program Location
   //                           ulParam2 - Word Count - 1. Present twice in 32bit word
   //       CMDCOMMITBUFFER:   ulParam1 - Program Location
   //                           ulParam2 - Ignore
   //
   //Return Values:
   //   NONE
   //
   //-------------------------------------------------------------------------------------------------------
   void IssueFlashCommand(unsigned long ulCommand, unsigned long ulParam1, unsigned long ulParam2);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Get the address of the specified sector
   //
   //Parameters:
   //   iBank : [in] Bank number (zero based)
   //   ulSector : [in] Sector number
   //
   //Return Values:
   //   Address of the sector
   //
   //-------------------------------------------------------------------------------------------------------
   unsigned long GetSectorAddress(int iBank, unsigned long ulSector);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Return the size of sector, uses GetFlashInfo().Width to handle the case of two 16bit FLASH parts in parallel to form up a 32bit word.
   //
   //Parameters:
   //   ulSector - Sector number
   //
   //Return Values:
   //   Size in bytes of the sector including both parts
   //
   //-------------------------------------------------------------------------------------------------------
   unsigned long GetSectorSize(unsigned long ulSector);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Returns the index of the FLASH bank and sector containing the specified address
   //
   //Parameters:
   //   ulAddress : [in] FLASH Address
   //   iBank : [out] The variable to receive the Bank containing Address
   //   ulSector : [out] The variable to receive the Sector containing Address
   //
   //Return Values:
   //   NONE
   //
   //-------------------------------------------------------------------------------------------------------
   void GetBankAndSectorIndex(unsigned long ulAddress, int & iBank, unsigned long & ulSector);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Erases the specified sector and waits until sector is completely erased.
   //   Typical sector erase time varies from 0.7 seconds to 15 seconds.. See data sheet
   //
   //Parameters:
   //   BYTE bSector. Sector number to be erased .. 0 denotes SA0 and 70 denotes SA70
   //
   //Return Values:
   //   True to indicate that sector has been successfully erased and flash is ready for other operation
   //
   //-------------------------------------------------------------------------------------------------------
   bool EraseSectorWithCompletion(int iBank, unsigned long ulSector, bool bCompletion);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Erases the specified sector
   //
   //Parameters:
   //   iBank : [in] Bank being worked on
   //   ulSector : [in] Sector number to be erased

   //
   //Return Values:
   //   True to indicate that erase command has been successfully erased
   //
   //-------------------------------------------------------------------------------------------------------
   bool EraseSector(int iBank, unsigned long ulSector);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Get the status of operations(write/erase) on the flash
   //
   //Parameters:
   //   ulAddress : [in] Address of the flash to check status
   //
   //Return Values:
   //   STATUSREADY flash has completed an operation and is ready for new operation0
   //   STATUSERASESUSPEND .. flash erase has been suspended
   //   STATUSTIMEOUT Time out
   //   STATUSBUSY Busy
   //   STATUSERROR Error
   //
   //-------------------------------------------------------------------------------------------------------
   unsigned long GetFlashStatus(unsigned long ulAddress);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Program an entire write buffers worth of data
   //
   //Parameters:
   //
   //
   //Return Values:
   //
   //
   //-------------------------------------------------------------------------------------------------------
   bool WriteFlashBuffer(unsigned long ulAddress,const void * pSrcData, unsigned long ulByteCount);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Write the data to the flash address base on the flash width.
   //-------------------------------------------------------------------------------------------------------
   bool WriteFlash(unsigned long ulAddr, unsigned long ulValue);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Read the flash data from the address base on the flash width.
   //-------------------------------------------------------------------------------------------------------
   unsigned long ReadFlash(unsigned long ulAddr);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Write the flash which the width is 32bit
   //-------------------------------------------------------------------------------------------------------
   bool WriteFlash32(unsigned long ulAddr, unsigned long ulValue);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Read the flash which the width is 32bit
   //-------------------------------------------------------------------------------------------------------
   unsigned long ReadFlash32(unsigned long ulAddr);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Write the flash which the width is 16bit
   //-------------------------------------------------------------------------------------------------------
   bool WriteFlash16(unsigned long ulAddr, unsigned long ulValue);

   //-------------------------------------------------------------------------------------------------------
   //Description:
   //   Read the flash which the width is 16bit
   //-------------------------------------------------------------------------------------------------------
   unsigned short ReadFlash16(unsigned long ulAddr);

private:
   unsigned long m_ulAddressBase;
   Flash::FlashInfo m_FlashInfo;
};

//
// FlashAmd.cpp
//
//
#include "stdafx.h"
#include "FlashAmd.h"

//------------------------------------------------------------------------------------------------------
//Macro define

// AMD Specifics
#define LATCH_OFFSET1           (0x555 * (GetFlashInfo().Width / 8))
#define LATCH_OFFSET2           (0x2AA * (GetFlashInfo().Width / 8))
#define LATCH_UNLOCKBYPASS       (0xBA * (GetFlashInfo().Width / 8))
#define AMD_UNLOCK1               0x00AA00AA
#define AMD_UNLOCK2               0x00550055

#define AMD_AUTOSELECT32        0x00900090
#define AMD_RESET32             0x00F000F0
#define AMD_ERASESET            0x00800080
#define AMD_ERASESECTOR         0x00300030
#define AMD_SUSPENDERASE        0x00B000B0
#define AMD_RESUMEERASE         0x00300030
#define AMD_PROGRAM             0x00A000A0
#define AMD_PROGRAMBUFFER       0x00250025
#define AMD_UNLOCKBYPASS        0x00200020
#define AMD_UNLOCKBYPASSPROGRAM 0x00A000A0
#define AMD_UNLOCKBYPASSRESET1 0x00900090
#define AMD_UNLOCKBYPASSRESET2 0x00000000
#define AMD_CHIPERASE           0x00100010
#define AMD_COMMITBUFFER        0x00290029

// defines for GetFlashStatus() function
#define STATUS_READY            0x00000000
#define STATUS_ERASESUSPEND     0x00040004 // DQ2
#define STATUS_TIMEOUTVALUE     0x00200020 // DQ5
#define STATUS_TOGGLEVALUE      0x00400040 // DQ6 - toggle bit one

//Flash status
enum FlashStatus
{
   STATUSREADY         = 100,
   STATUSERASESUSPEND = 101,
   STATUSTIMEOUT       = 102,
   STATUSBUSY          = 103,
   STATUSERROR         = 104
};

   // Flash Commands
enum FlashCommand
{
   CMDRESET               = 0x1000,
   CMDUNLOCK              = 0x1001,
   CMDAUTOSELECT          = 0x1002,
   CMDERASESET            = 0x1003,
   CMDERASESECTOR         = 0x1004,
   CMDSUSPENDERASE        = 0x1005,
   CMDRESUMEERASE         = 0x1006,
   CMDPROGRAM             = 0x1007,
   CMDUNLOCKBYPASSSET     = 0x1008,
   CMDUNLOCKBYPASSRESET   = 0x1009,
   CMDCHIPERASE           = 0x1010,
   CMDREADIDCODES         = 0x1011,
   CMDCLEARSTATUS         = 0x1012,
   CMDREADSTATUS          = 0x1013,
   CMDWRITEWORD           = 0x1014,
   CMDWRITEBUFFER         = 0x1015,
   CMDCOMMITBUFFER        = 0x1016
};
//------------------------------------------------------------------------------------------------------

CFlashAmd::CFlashAmd(void):
m_ulAddressBase(0)
{
}

CFlashAmd::~CFlashAmd(void)
{
}

bool CFlashAmd::EraseFlash(unsigned long ulAddressOffset,unsigned long ulSize,bool bCompletion )
{
   unsigned long ulBeginAddr = GetFlashAddressBase() + ulAddressOffset;
   if(ulBeginAddr + ulSize - 1 > GetFlashAddressBase() + GetFlashInfo().Size)
   {
       return false;
   }

   unsigned long ulEndAddr = ulBeginAddr + ulSize - 1;
   unsigned long ulCurAddr = ulBeginAddr;

    //
    // erase the sectors in this range
    //

   for (int i = 0; i < GetFlashInfo().Bank; i ++)
   {
       IssueFlashCommand(CMDRESET, i, 0);
   }

   int iBank = 0;
   unsigned long ulSector = 0;
   do{
       GetBankAndSectorIndex(ulCurAddr, iBank, ulSector);

        EraseSectorWithCompletion(iBank, ulSector, bCompletion);

       ulCurAddr += GetSectorSize(ulSector);

   }
   while (ulCurAddr < ulEndAddr);


   // Verify Erase
   for (unsigned i = 0;i < ulSize; i += 4)
   {
       unsigned long ulTemp = ReadFlash32(ulBeginAddr + i);
       if (0xFFFFFFFF != ulTemp)
       {
           return false;
       }
   }


    return true;

}

void CFlashAmd::LockFlash(unsigned long ulAddressOffset,unsigned long ulSize)
{
   return ;
}

void CFlashAmd::UnlockFlash(unsigned long ulAddressOffset,unsigned long ulSize)
{
   return ;
}

bool CFlashAmd::ReadFlash(unsigned long ulAddressOffset,void *pDataStore,unsigned long ulSize)
{
   unsigned long ulAddrRead = ulAddressOffset + GetFlashAddressBase();;

   int iBank = GetBankIndex(ulAddrRead);
    IssueFlashCommand(CMDRESET, iBank, 0);

    while (ulSize --)
   {
        (reinterpret_cast<unsigned char *> (pDataStore))[ulSize] = *(reinterpret_cast<unsigned char *>(ulAddrRead + ulSize));
    }

    return true;
}

bool CFlashAmd::WaitForEraseComplete(unsigned long ulAddressOffset)
{
   unsigned long ulAddr = GetFlashAddressBase() + ulAddressOffset;

   return (GetFlashStatus(ulAddr) != 0 );
}

bool CFlashAmd::WriteFlash(unsigned long ulAddressOffset,const void * pDataWrite,unsigned long ulSize,bool bErase)
{
   unsigned long ulAddr = ulAddressOffset + GetFlashAddressBase();

   bool bResult = true;

   // Check parameters...
   if (ulAddressOffset + ulSize - 1 > GetFlashInfo().Size)
   {
       return false;
   }


   // Round up to whole word
   if (ulSize & 0x3)
   {
       ulSize += ulSize % 4;
   }

   int iBank = GetBankIndex(ulAddr);
   IssueFlashCommand(CMDRESET, iBank, 0);


   // Firstly check that is is erased
   if (!bErase)
   {
       for (unsigned long i = 0; i < ulSize; i ++)
       {
           if (0xff != *(reinterpret_cast<unsigned char *>(ulAddr + i)))
           {
               bResult = FALSE;

               goto EXIT;
           }
       }
   }

   if (bErase)
   {
       // Erase the area before write

       EraseFlash(ulAddressOffset,ulSize,true);
   }




   // Get to next buffer boundary
   const unsigned long * pulData = reinterpret_cast<const unsigned long *>(pDataWrite);
   while (ulSize && (ulAddr & (GetFlashInfo().WriteBufferSize - 1)) && bResult)
   {

       bResult = WriteFlash32(ulAddr, *pulData);

       ulSize -= 4;
       ulAddr += 4;
       pulData ++;
   }

   IssueFlashCommand(CMDRESET, iBank, 0);

   // Round Size up to multiple of 4 bytes
   ulSize = (ulSize+3) & ~0x3;

   while (ulSize && bResult)
   {
       unsigned long ulCopySize;

       // GetFlashInfo().WriteBufferSize specifies the number of bytes of write buffer
       ulCopySize = min(ulSize, GetFlashInfo().WriteBufferSize);

       bResult = WriteFlashBuffer(ulAddr, pulData, ulCopySize);

       //Sleep(5);//norains.Maybe don't finish writing.

       ulSize -= ulCopySize;
       ulAddr += ulCopySize;
       pulData = &pulData[ulCopySize / 4];
   }

EXIT:

   return bResult;
}

unsigned long CFlashAmd::GetBankBaseAddress(int iBank)
{
   return GetFlashAddressBase() + ( ( GetFlashInfo().Size / GetFlashInfo().Bank) * iBank);

}

int CFlashAmd::GetBankIndex(unsigned long ulAddr)
{
   int iBank;

   for(iBank = GetFlashInfo().Bank - 1; iBank >= 0; iBank--)
   {
       if(ulAddr >= GetBankBaseAddress(iBank))
       {
           break;
       }
   }

   return iBank;
}

void CFlashAmd::IssueFlashCommand(unsigned long ulCommand, unsigned long ulParam1, unsigned long ulParam2)
{
   unsigned long ulAddr; // will hold address of the flash

   switch (ulCommand)
   {
       case CMDRESET:
           ulAddr = GetBankBaseAddress(ulParam1);
           WriteFlash(ulAddr, AMD_RESET32); // Set the Device to Read Mode
           break;

       case CMDUNLOCK:
           ulAddr = GetBankBaseAddress(ulParam1);
           WriteFlash(ulAddr + LATCH_OFFSET1, AMD_UNLOCK1);
           WriteFlash(ulAddr + LATCH_OFFSET2, AMD_UNLOCK2);
           break;

       case CMDERASESET:
           ulAddr = GetBankBaseAddress(ulParam1);
           WriteFlash(ulAddr + LATCH_OFFSET1, AMD_ERASESET);
           break;

       case CMDERASESECTOR:
           ulAddr = GetSectorAddress(ulParam1,ulParam2);
           WriteFlash(ulAddr, AMD_ERASESECTOR); // issue erase sector command
           break;

       case CMDPROGRAM:
           ulAddr = GetBankBaseAddress(ulParam1);
           WriteFlash(ulAddr + LATCH_OFFSET1, AMD_PROGRAM);
           break;

       case CMDWRITEBUFFER:
           WriteFlash(ulParam1, AMD_PROGRAMBUFFER);
           WriteFlash(ulParam1, ulParam2);      // word count - 1
           break;

       case CMDCOMMITBUFFER:
           WriteFlash(ulParam1, AMD_COMMITBUFFER);
           break;

       default:
           break;
     }
}

unsigned long CFlashAmd::GetSectorAddress(int iBank, unsigned long ulSector)
{
    unsigned long ulSectorAddr;

   ulSectorAddr = GetBankBaseAddress(iBank);

   for (unsigned long i=0; i < ulSector; i ++)
   {
       ulSectorAddr += GetSectorSize(ulSector);
   }

   return ulSectorAddr;
}

unsigned long CFlashAmd::GetSectorSize(unsigned long ulSector)
{
   unsigned long ulSectorSize;

   if (ulSector < GetFlashInfo().BootSectorCount)
   {
       ulSectorSize = GetFlashInfo().BootSectorSize;
    }
   else
   {
       ulSectorSize = GetFlashInfo().SectorSize;
    }

    return ulSectorSize * (GetFlashInfo().Width / 16);
}

void CFlashAmd::GetBankAndSectorIndex(unsigned long ulAddress, int & iBank, unsigned long & ulSector)
{
   //Reset
   iBank = 0;
   ulSector = 0;

   // Find the Bank number first
   for (iBank = GetFlashInfo().Bank - 1; iBank >= 0; iBank --)
   {
       if (ulAddress >= GetBankBaseAddress(iBank))
       {
           break;
       }
   }

   // Now work out the sector number
   while (ulAddress >= GetSectorAddress(iBank,ulSector))
   {
       ulSector ++;
   }
   ulSector --;

}

bool CFlashAmd::EraseSectorWithCompletion(int iBank, unsigned long ulSector, bool bCompletion)
{
   unsigned long ulAddr = GetSectorAddress(iBank, ulSector);
   EraseSector(iBank, ulSector);

   unsigned long ulStatus;

   if (bCompletion)
   {

       // wait until flash state machine is ready for other operation
       ulStatus = GetFlashStatus(ulAddr);
   }
   else
   {
       ulStatus = STATUSREADY;
   }

   return (ulStatus == STATUSREADY);
}

bool CFlashAmd::EraseSector(int iBank, unsigned long ulSector)
{
   IssueFlashCommand(CMDUNLOCK, iBank, 0); // issue unlock command // no data to write
   IssueFlashCommand(CMDERASESET, iBank, 0); // // erase setup command
   IssueFlashCommand(CMDUNLOCK, iBank, 0);
   IssueFlashCommand(CMDERASESECTOR, iBank, ulSector); // issue erase sector command

   return true;
}

unsigned long CFlashAmd::GetFlashStatus(unsigned long ulAddress)
{
   unsigned long ulStatus;

   int iBank = GetBankIndex(ulAddress);

    // Two consecutive reads to check if bits are toggling
   unsigned long ulOldRead = ReadFlash(ulAddress);
   unsigned long ulNewRead = ReadFlash(ulAddress);

   //The timeout value
   unsigned long ulStatusTimeoutValue = STATUS_TIMEOUTVALUE;
   if(GetFlashInfo().Width == 16)
   {
       ulStatusTimeoutValue &= 0xFFFF;
   }

   do {
       // XOR to see if bits toggled

       ulStatus = ulOldRead ^ ulNewRead;
       if (0 == (ulStatus & STATUS_TOGGLEVALUE))
       {
           ulStatus = STATUSREADY;
           break;
       }

       if ((ulNewRead & ulStatusTimeoutValue) == ulStatusTimeoutValue)
       {

           ulNewRead = ReadFlash(ulAddress);
           ulOldRead = ReadFlash(ulAddress);

           ulStatus = ulOldRead ^ ulNewRead;

           if (0 == (ulStatus & STATUS_TOGGLEVALUE))
           {
               ulStatus = STATUSREADY;
               break;
           }


           ulStatus = STATUSTIMEOUT;

           IssueFlashCommand(CMDRESET,iBank,0);

           break;
       }

       ulOldRead = ulNewRead;
       ulNewRead = ReadFlash(ulAddress);

   } while(true);

   return ulStatus;
}

bool CFlashAmd::WriteFlashBuffer(unsigned long ulAddress,const void * pSrcData, unsigned long ulByteCount)
{
    if ((ulByteCount & 3) || (0 == ulByteCount))
   {
        //Flash Write buffer requires a whole multiple of words
        return false;
    }

    //
    // issue Program Command
    // The Write buffer is GetFlashInfo().width entries deep
    // With 2 chips it is 32 bits wide
   unsigned long ulSize = (ulByteCount / (GetFlashInfo().Width / 8));

   int iBank = GetBankIndex(ulAddress);
    IssueFlashCommand(CMDUNLOCK, iBank, 0);
    IssueFlashCommand(CMDWRITEBUFFER, ulAddress, ulSize - 1 |((ulSize - 1) << 16));

    while (ulSize--)
   {
       if(GetFlashInfo().Width == 16)
       {
           WriteFlash(ulAddress, *(reinterpret_cast<const unsigned short *>(pSrcData)));
       }
       else if(GetFlashInfo().Width == 32)
       {
           WriteFlash(ulAddress, *(reinterpret_cast<const unsigned long *>(pSrcData)));
       }

       ulAddress = ulAddress + (GetFlashInfo().Width / 8);

       if(GetFlashInfo().Width == 16)
       {
           pSrcData = reinterpret_cast<const void *>(reinterpret_cast<const unsigned short *>(pSrcData) + 1);
       }
       else if(GetFlashInfo().Width == 32)
       {
           pSrcData = reinterpret_cast<const void *>(reinterpret_cast<const unsigned long *>(pSrcData) + 1 );
       }

    }

   ulAddress = ulAddress - (GetFlashInfo().Width / 8);

    IssueFlashCommand(CMDCOMMITBUFFER, ulAddress, 0);


    // wait until flash is ready to accept new command
    unsigned long ulStatus = GetFlashStatus(ulAddress);


    return (ulStatus != STATUSTIMEOUT);
}

bool CFlashAmd::SetFlashAddressBase(unsigned long ulAddress)
{
   m_ulAddressBase = ulAddress;
   return true;
}

unsigned long CFlashAmd::GetFlashAddressBase(void)
{
   return m_ulAddressBase;
}

bool CFlashAmd::SetFlashInfo(const Flash::FlashInfo & flashInfo)
{
   m_FlashInfo = flashInfo;

   return true;
}

const Flash::FlashInfo & CFlashAmd::GetFlashInfo(void)
{
   return m_FlashInfo;
}

bool CFlashAmd::WriteFlash32(unsigned long ulAddr, unsigned long ulValue)
{

   *(volatile unsigned long * const)(ulAddr) = (ulValue);
   __asm("sync");

   return (*(volatile unsigned long * const)(ulAddr) == (ulValue));
}

unsigned long CFlashAmd::ReadFlash32(unsigned long ulAddr)
{
   return *(volatile unsigned long * const)(ulAddr);
}

bool CFlashAmd::WriteFlash16(unsigned long ulAddr, unsigned long ulValue)
{

   *(volatile unsigned short * const)(ulAddr) = static_cast<unsigned short>( (ulValue) & 0xFFFF);
   __asm("sync");

   return (*(volatile unsigned short * const)(ulAddr) == static_cast<unsigned short>( (ulValue) & 0xFFFF));
}

unsigned short CFlashAmd::ReadFlash16(unsigned long ulAddr)
{
   return *(volatile unsigned short * const)(ulAddr);
}

bool CFlashAmd::WriteFlash(unsigned long ulAddr, unsigned long ulValue)
{
   switch(m_FlashInfo.Width)
   {
       case 16:
           WriteFlash16(ulAddr,ulValue);
           break;
       case 32:
           WriteFlash32(ulAddr,ulValue);
           break;
       default:
           return false;
   }

   return true;
}

unsigned long CFlashAmd::ReadFlash(unsigned long ulAddr)
{
   switch(m_FlashInfo.Width)
   {
       case 16:
           return ReadFlash16(ulAddr);
           break;
       case 32:
           return ReadFlash32(ulAddr);   ;
       default:
           return 0;
   }

}

    CFlashAmd主要限制于DBAU1200的开发板，并且该板子上的FLASH型号为AM29LV256M。

    如果条件具备，那么让我们看看如何烧写flash吧。

CFlashAmd flashAmd;
//设置flash型号
   flashAmd.SetFlashInfo(Flash::FLASH_INFO_AM29LV256M);
   //设置flash的起始地址。在开发板中，FLASH的起始地址为0xBC000000。
   flashAmd.SetFlashAddressBase(0xBC000000);

   ...

   //烧写FLASH。在这里注意的是，地址为偏移地址。该偏移地址是相对于之前通过SetFlashAddressBase所设置的地址。
   flashAmd.WriteFlash(dwOffsetAddr,&vtStore[0],vtStore.size(),true);