用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);