用CFlashAmd对些DBAU1200开发板的BOOT FLASH

//========================================================================
//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);