void flash_inside_write(void* address,void* data,long length) {
char old_data[2]={0};
int old_data_int=0;
long the_last=length-1;
if (!is_valid_address(address)) return;
FLASH_Unlock();
if ((long)address%2!=0) {
flash_inside_read((void*)((long)address-1),old_data,2);
old_data[1]=*(char*)data;
memcpy(&old_data_int,old_data,sizeof(int));
FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address-1),old_data_int);
--length;
}
for (;length>1;length-=2)
FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address+length-2),*(uint16_t*)((long)data+length-2));
if (length) {
flash_inside_read((void*)((long)address+the_last),old_data,2);
old_data[0]=*(char*)((long)data+the_last);
memcpy(&old_data_int,old_data,sizeof(int));
FLASH_ProgramHalfWord((uint32_t)(FLASH_INSIDE_ADDRESS_START+(long)address+the_last),old_data_int);
}
FLASH_Lock();
FLASH_ClearFlag(FLASH_FLAG_BSY|FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
}
static int
stm32f3_flash_write(uint32_t address, const void *src, uint32_t len)
{
FLASH_Status rc;
int num_half_words;
int i;
uint16_t *src16 = (uint16_t *)src;
if (address % sizeof(uint16_t)) {
/*
* Unaligned write.
*/
return -1;
}
num_half_words = len / 2;
for (i = 0; i < num_half_words; i++) {
rc = FLASH_ProgramHalfWord(address, src16[i]);
if (rc != FLASH_COMPLETE) {
goto err;
}
address += 2;
}
if (num_half_words * 2 != len) {
rc = FLASH_ProgramHalfWord(address, ((uint8_t *)src)[len] << 8);
if (rc != FLASH_COMPLETE) {
goto err;
}
}
return 0;
err:
return -1;
}
WORD EE_WriteVariable(WORD offset, WORD newValue)
{
FLASH_Status stat = FLASH_COMPLETE;
volatile WORD *pCurrentValue = (__IO uint16_t*) (PAGE0_BASE_ADDRESS + 2 + (offset * 2));
WORD PageStatus0 = *((__IO uint16_t*) PAGE0_BASE_ADDRESS);
WORD currentValue = *pCurrentValue;
// first check is page is valid, and if the value did change
if(PageStatus0 == VALID_PAGE && (currentValue == newValue)) { // page is valid, value didn't change? Good, quit
return FLASH_COMPLETE;
}
// if we got here, then either page is not valid, or the value changed
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
stat = FLASH_ErasePage(PAGE0_BASE_ADDRESS); // erase page
if(stat != FLASH_COMPLETE) {
return stat;
}
stat = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE); // write VALID_PAGE marker
if(stat != FLASH_COMPLETE) {
return stat;
}
stat = FLASH_ProgramHalfWord((uint32_t) pCurrentValue, newValue); // wite new vale
if(stat != FLASH_COMPLETE) {
return stat;
}
FLASH_Lock();
return stat;
}
static int32_t PIOS_Flash_Internal_WriteData(uintptr_t chip_id, uint32_t chip_offset, const uint8_t *data, uint16_t len)
{
PIOS_Assert(data);
PIOS_Assert((chip_offset & 0x0001) == 0)
struct pios_internal_flash_dev *flash_dev = (struct pios_internal_flash_dev *)chip_id;
if (!PIOS_Flash_Internal_Validate(flash_dev))
return -1;
/* Write the data */
for (uint16_t i = 0; i < (len & ~1); i += 2) {
/* Check if content has been changed prior to write.
* This should enhance performance and make this compatible with the F3 chip.
*/
uint8_t temp[2];
if (PIOS_Flash_Internal_ReadData(chip_id, chip_offset + i, temp, sizeof(temp)) != 0)
return -4;
if (temp[0] == data[i] && temp[1] == data[i + 1])
continue;
FLASH_Status status;
status = FLASH_ProgramHalfWord(FLASH_BASE + chip_offset + i, data[i + 1] << 8 | data[i]);
PIOS_Assert(status == FLASH_COMPLETE);
}
/* Handle uneven writes by filling up with 0xff*/
if ((len & 1) != 0) {
FLASH_Status status;
status = FLASH_ProgramHalfWord(FLASH_BASE + chip_offset + len - 1, 0xff << 8 | data[len - 1]);
PIOS_Assert(status == FLASH_COMPLETE);
}
return 0;
}
//Store the computed offsets to internal FLASH
void store_offsets()
{
union
{
float val;
struct
{
uint8_t bytes[4];
};
}extract_float;
uint32_t ADDRESS = BACKUP_ADDRESS;
uint8_t i,j;
IWDG_ReloadCounter();
FLASH_Unlock(); //unlock FLASH to enable writing
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); //clear any pending flags
FLASH_EraseSector(BACKUP_SECTOR,VoltageRange_3); //Erase the sector where data is to be written too
FLASH_ProgramHalfWord(ADDRESS, ASI_ZERO);
ADDRESS+=2;
for(j=0;j<6;j++)
{
extract_float.val = AN_OFFSET[j];
for(i=0;i<4;i++)
{
FLASH_ProgramByte(ADDRESS, extract_float.bytes[i]);
ADDRESS+=1;
}
}
for(i=0;i<3;i++)
{
FLASH_ProgramHalfWord(ADDRESS, MAG_OFFSET[i]);
ADDRESS+=2;
}
for(j=0;j<3;j++)
{
extract_float.val = MAG_SCALE[j];
for(i=0;i<4;i++)
{
FLASH_ProgramByte(ADDRESS, extract_float.bytes[i]);
ADDRESS+=1;
}
}
FLASH_ProgramHalfWord(ADDRESS, ground_alt_offset);
ADDRESS+=2;
for(i=0;i<8;i++)
{
FLASH_ProgramHalfWord(ADDRESS, RC_trim[i]);
ADDRESS+=2;
}
FLASH_Lock();
}
/*******************************************************************************
* Function Name : EE_VerifyPageFullWriteVariable
* Description : Verify if active page is full and Writes variable in EEPROM.
* Input : - VirtAddress: 16 bit virtual address of the variable
* - Data: 16 bit data to be written as variable value
* Output : None
* Return : - Success or error status:
* - FLASH_COMPLETE: on success
* - PAGE_FULL: if valid page is full
* - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error
*******************************************************************************/
u16 EE_VerifyPageFullWriteVariable(u16 VirtAddress, u16 Data)
{
FLASH_Status FlashStatus = FLASH_COMPLETE;
u16 ValidPage = PAGE0;
u32 Address = 0x08010000, PageEndAddress = 0x080107FF;
/* Get valid Page for write operation */
ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
/* Check if there is no valid page */
if (ValidPage == NO_VALID_PAGE)
{
return NO_VALID_PAGE;
}
/* Get the valid Page start Address */
Address = (u32)(EEPROM_START_ADDRESS + (u32)(ValidPage * PAGE_SIZE));
/* Get the valid Page end Address */
PageEndAddress = (u32)((EEPROM_START_ADDRESS - 2) + (u32)((1 + ValidPage) * PAGE_SIZE));
/* Check each active page address starting from beginning */
while (Address < PageEndAddress)
{
/* Verify each time if Address and Address+2 contents are equal to Data and VirtAddress respectively */
if (((*(vu16*)Address) == Data) && ((*(vu16*)(Address + 2)) == VirtAddress))
{
return FLASH_COMPLETE;
}
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */
if ((*(vu32*)Address) == 0xFFFFFFFF)
{
/* Set variable data */
FlashStatus = FLASH_ProgramHalfWord(Address, Data);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Set variable virtual address */
FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);
/* Return program operation status */
return FlashStatus;
}
else
{
/* Next address location */
Address = Address + 4;
}
}
/* Return PAGE_FULL in case the valid page is full */
return PAGE_FULL;
}
/**
* @brief Verify if active page is full and Writes variable in EEPROM.
* @param VirtAddress: 16 bit virtual address of the variable
* @param Data: 16 bit data to be written as variable value
* @retval Success or error status:
* - FLASH_COMPLETE: on success
* - PAGE_FULL: if valid page is full
* - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error
*/
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data)
{
FLASH_Status FlashStatus = FLASH_COMPLETE;
uint16_t ValidPage = PAGE0;
uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE-1;
/* Get valid Page for write operation */
ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
/* Check if there is no valid page */
if (ValidPage == NO_VALID_PAGE)
{
return NO_VALID_PAGE;
}
//FLASH_Unlock();
/* Get the valid Page start Address */
Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
/* Get the valid Page end Address */
PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
/* Check each active page address starting from begining */
while (Address < PageEndAddress)
{
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */
if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF)
{
/* Set variable data */
FlashStatus = FLASH_ProgramHalfWord(Address, Data);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
//FLASH_Lock();
return FlashStatus;
}
/* Set variable virtual address */
FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);
/* Return program operation status */
//FLASH_Lock();
return FlashStatus;
}
else
{
/* Next address location */
Address = Address + 4;
}
}
//FLASH_Lock();
/* Return PAGE_FULL in case the valid page is full */
return PAGE_FULL;
}
/******************************************************
flash 字符串写入
每次存入两个字节
*******************************************************/
void FlashWriteStr( u32 flash_add, u16 len, u8* data )
{
//char cp[12];
//u8 s = 0;
u16 byteN = 0;
uint32_t FlashData;
//FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_PGERR|FLASH_FLAG_WRPRTERR);
//FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
//FLASH_ErasePage(flash_add+FLASH_PAGE_SIZE * 1);
//FLASH_ErasePage(flash_add);
//sprintf( cp, "len:%d", len);
//USART1_Puts(cp);
while( len )
{
FlashData=*(vu32*)(flash_add+byteN); /* 读取地址中的16位数据 */
my_unTemp16.un_temp8[0] = *(data+byteN);
my_unTemp16.un_temp8[1] = *(data+byteN+1);
//my_unTemp16.un_temp8[2] = *(data+byteN+2);
//my_unTemp16.un_temp8[3] = *(data+byteN+3);
//my_unTemp16.un_temp16=(*(data+byteN))|((*(data+byteN+1))<<8)|((*(data+byteN+2))<<16)|((*(data+byteN+3))<<24);
if(FlashData==0xffffffff)
{
FLASH_Unlock();
FLASH_ProgramHalfWord(flash_add+byteN , my_unTemp16.un_temp16 );
FLASH_Lock();
}
// else if(FlashData==my_unTemp16.un_temp16)
// { FLASH_COMPLETE
// }
else
{
FLASH_Unlock();
FLASH_ErasePage(flash_add+byteN); /* 擦除页 */
FLASH_ProgramHalfWord(flash_add+byteN , my_unTemp16.un_temp16 );
FLASH_Lock();
}
//sprintf( cp, "bye:%d\r\n", s);
//USART1_Puts(cp);
if( 1==len )
{
//如果数据长度是奇数,为1的时候跳出
break;
}
else
{
byteN += 2;
len -= 2;
}
}
//FLASH_Lock();
}
static int32_t PIOS_Flash_Internal_WriteData(uintptr_t flash_id, uint32_t addr, uint8_t * data, uint16_t len)
{
PIOS_Assert(data);
PIOS_Assert((addr & 0x0001) == 0)
struct pios_internal_flash_dev * flash_dev = (struct pios_internal_flash_dev *)flash_id;
if (!PIOS_Flash_Internal_Validate(flash_dev))
return -1;
uint32_t sector_start;
uint32_t sector_size;
/* Ensure that the base address is in a valid sector */
if (!PIOS_Flash_Internal_GetSectorInfo(addr,
§or_start,
§or_size)) {
/* We're asking for an invalid flash address */
return -2;
}
/* Ensure that the entire write occurs within the same sector */
if ((uintptr_t)addr + len > sector_start + sector_size) {
/* Write crosses the end of the sector */
return -3;
}
/* Write the data */
for (uint16_t i = 0; i < (len & ~1); i += 2) {
/* Check if content has been changed prios to write.
* This should enhance performance and make this compatible with the F3 chip.
*/
uint8_t temp[2];
if (PIOS_Flash_Internal_ReadData(flash_id, addr + i, temp, sizeof(temp)) != 0)
return -4;
if (temp[0] == data[i] && temp[1] == data[i + 1])
continue;
FLASH_Status status;
status = FLASH_ProgramHalfWord(addr + i, data[i + 1] << 8 | data[i]);
PIOS_Assert(status == FLASH_COMPLETE);
}
/* Handle uneven writes by filling up with 0xff*/
if ((len & 1) != 0) {
FLASH_Status status;
status = FLASH_ProgramHalfWord(addr + len - 1, 0xff << 8 | data[len - 1]);
PIOS_Assert(status == FLASH_COMPLETE);
}
return 0;
}
static void
RCFS_Write( flash_file *f )
{
unsigned short *p;
unsigned short *q;
int i;
volatile FLASH_Status FLASHStatus = FLASH_COMPLETE;
// check for valid address
if( f->addr < baseaddr )
return;
if( f->data == NULL )
return;
// Init pointers (some wierd bug in ROBOTC here)
long tmp = f->addr;
p = (unsigned short *)tmp;
q = (unsigned short *)&(f->name[0]);
// Write header
for(i=0;i<(FLASH_FILE_HEADER_SIZE/2);i++)
{
// Write 16 bit data
FLASHStatus = FLASH_ProgramHalfWord( (uint32_t)p++, *q++ );
}
// point at the file data, we will write as words
q = (unsigned short *)f->data;
// Write Data, datalength is now in bytes so divide datalength by 2
for(i=0;i<(f->datalength/2);i++)
{
// Write 16 bit data
FLASHStatus = FLASH_ProgramHalfWord( (uint32_t)p++, *q++ );
// every 128 bytes abort time slice
if( (i % 128) == 0 )
abortTimeslice();
}
// Was it an odd number of bytes ?
if( (f->datalength & 1) == 1 )
{
// pad with 0xFF and write the last byte
unsigned short b = (*(unsigned char *)q) | 0xFF00;
FLASHStatus = FLASH_ProgramHalfWord( (uint32_t)p++, b);
}
}
mal_error_e mal_flash_write_uint16_values(unsigned int start_address, uint16_t *values, uint32_t count) {
FLASH_Status result = FLASH_BUSY;
// Unlock flash registers
FLASH_Unlock();
// Clear pending flags
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
// Write values
uint32_t i;
uint32_t address = start_address;
for (i = 0; i < count; i++) {
// Write data
result = FLASH_ProgramHalfWord(address, values[i]);
if (FLASH_COMPLETE != result) {
// We stop at first sign of error
break;
}
// Increment address
address += sizeof(uint16_t);
}
// Lock flash registers
FLASH_Lock();
// Return result
if (FLASH_COMPLETE != result) {
return MAL_ERROR_MEMORY;
}
return MAL_ERROR_OK;
}
// write data to FLASH, only within 1 page.
static bool fee_write_page(uint32_t fee_addr, uint32_t len, uint8_t *pData)
{
uint16_t din, dout;
for(; len > 0; len--)
{
din = (uint16_t)(*(pData++)) | 0xFF00;
dout = *(uint16_t *)(fee_addr);
if(din != dout)
{
if(dout != 0xFFFF)
return false;
if(FLASH_ProgramHalfWord(fee_addr, din) != FLASH_COMPLETE)
{
FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);
return false;
}
}
fee_addr += 2;
}
return true;
}
void Save_DoorInfor(Door_Infor_t *infor)
{
FLASH_Unlock();
FLASH_ErasePage(DOOR_INFOR_ADDR);
FLASH_ProgramHalfWord((uint32_t)DOOR_INFOR_ADDR, *(uint16_t*)infor);
FLASH_Lock();
}
bool write(uint32_t addr, uint16_t * data, const uint16_t data_len)
{
int sector;
/* Check bounds */
if ((addr >= (SECTOR11_START_ADDR + SECTOR_SIZE_128KB)) ||
(addr < SECTOR0_START_ADDR))
return false;
/* Need to compute sector to erase */
if (addr >= SECTOR5_START_ADDR)
sector = 5 + ((addr - SECTOR5_START_ADDR)/SECTOR_SIZE_128KB);
else if (addr >= SECTOR4_START_ADDR)
sector = 4;
else
sector = (addr - SECTOR0_START_ADDR)/SECTOR_SIZE_16KB;
/* Unlock flash */
FLASH_Unlock();
FLASH_EraseSector(sector * 0x08, VoltageRange_3);
/* Write data */
for (int i = 0; i < data_len; i += 2)
{
FLASH_ProgramHalfWord(addr, *data);
data++; addr += 2;
}
return true;
}
uint32_t FLASH_Write_16BITS( uint32_t* FlashAddress, uint16_t* Data ,uint16_t DataLength)
{
__disable_irq();
for (u16 i = 0; i < (DataLength); i++)
{
if (FLASH_ProgramHalfWord(*FlashAddress, Data[i]) == FLASH_COMPLETE)
{
/* Check the written value */
if (*(u16*)*FlashAddress != Data[i])
{
/* Flash content doesn't match SRAM content */
return FLASH_WRITE_ERROR;
}
}
else
{
return FLASH_ERASE_ERROR;
}
*FlashAddress += 2;
}
__enable_irq();
return FLASH_OK;
}
bool HardwareEEPROM::put(char * src, size_t size)
{
FLASH_Status status = (FLASH_Status)0;
FLASH_Unlock();
for (unsigned int tries = 3; tries; tries--) {
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
status = FLASH_COMPLETE;
for (size_t i=0; i<size && status==FLASH_COMPLETE; i+=2) {
uint16_t datum = 0;
memcpy(&datum, &src[i], (i+2>size)?1:2); // handle odd-length data
status = FLASH_ProgramHalfWord(FLASH_WRITE_ADDR+i, datum);
}
if (status == FLASH_COMPLETE)
break;
}
FLASH_Lock();
return status == FLASH_COMPLETE;
}
/***********************************************************
* 函数名：WriteflashMPeriod
* 描述 ：把interval_s从CPU写入Flash
* 输入 : 无
* 输出 : 无
***********************************************************/
void WriteflashMPeriod(void)
{
FLASHStatus = FLASH_COMPLETE;
MemoryProgramStatus = PASSED;
FLASH_Unlock(); //FLASH解锁
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位
NbrOfPage = (EndAddr[4] - StartAddr[4]) / FLASH_PAGE_SIZE;//页面擦除子程序
FLASHStatus = FLASH_ErasePage(StartAddr[4] + (FLASH_PAGE_SIZE * NbrOfPage));
FlashAddress = StartAddr[4];
FLASHStatus = FLASH_ProgramWord(FlashAddress, gps_invalid);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalA);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalB);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramWord(FlashAddress, interval_num);
FlashAddress = FlashAddress + 4;
// FLASHStatus = FLASH_ProgramWord(FlashAddress, time_o);
FlashAddress = FlashAddress + 4;
FLASHStatus = FLASH_ProgramHalfWord(FlashAddress, interval_s);
BKP_WriteBackupRegister(BKP_DR1,interval_num);
//BKP_WriteBackupRegister(BKP_DR2,time_o);
BKP_WriteBackupRegister(BKP_DR3,interval_s);
}
Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8 *SourceAddressPtr, Fls_LengthType Length)
{
FLASH_Status stResult;
Fls_LengthType len = Length;
Fls_AddressType addr = TargetAddress;
const uint8 *srcPtr = SourceAddressPtr;
while (len >= sizeof(uint32_t))
{
stResult = FLASH_ProgramWord((uint32_t)addr, (uint32_t)*(uint32_t *)srcPtr);
srcPtr += sizeof(uint32_t);
addr += sizeof(uint32_t);
len -= sizeof(uint32_t);
}
if (len == sizeof(uint16_t))
{
FLASH_ProgramHalfWord((uint32_t)addr, (uint16_t)*(uint16_t *)srcPtr);
srcPtr += sizeof(uint16_t);
addr += sizeof(uint16_t);
len -= sizeof(uint16_t);
}
return E_OK;
}
//写多个数据到一个页
u8 STMFLASH_Write(u32 PageAddr,u16 *pBuffer,u16 NumToWrite)
{
FLASH_Status temp_status;//状态
u16 i;
FLASH_Unlock();//解锁
temp_status = FLASH_ErasePage(PageAddr);//擦除一个页
if(temp_status != FLASH_COMPLETE)
{
FLASH_Lock();
return 0;
}
for(i=0;i<NumToWrite;i++)//数据写入
{
temp_status = FLASH_ProgramHalfWord(PageAddr+2*i,pBuffer[i]);
if(temp_status != FLASH_COMPLETE)
{
FLASH_Lock();
return 0;
}
}
FLASH_Lock();//上锁
return 1;
}
/*******************************************************************************
* Function Name : EE_Format
* Description : Erases PAGE0 and PAGE1 and writes VALID_PAGE header to PAGE0
* Input : None
* Output : None
* Return : Status of the last operation (Flash write or erase) done during
* EEPROM formating
*******************************************************************************/
FLASH_Status EE_Format(void)
{
FLASH_Status FlashStatus = FLASH_COMPLETE;
/* Erase Page0 */
FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Erase Page1 */
FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
/* Return Page1 erase operation status */
return FlashStatus;
}
unsigned char flash_write_operate_nocheckcomplete(u32 Address,u16 * buff,u32 len)
{
volatile FLASH_Status FLASHStatus;
u32 Temp_Addr;
FLASHStatus = FLASH_COMPLETE;
if(len%2) return WR_LEN_ERR;
if(Address%2) return WR_ADDRESS_ERR;
if( Address<StartAddr || Address+len>EndAddr ) return ADDRESS_LEN_ERR;
//Unlock the Flash Program Erase controller
FLASH_Unlock();
//Clear All pending flags
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP|FLASH_FLAG_PGERR |FLASH_FLAG_WRPRTERR);
Temp_Addr=Address+len;
while((Address < Temp_Addr) )
{
FLASHStatus = FLASH_ProgramHalfWord(Address, *buff);
Address = Address + 2;
buff++;
}
FLASH_Lock();
if( FLASHStatus==FLASH_COMPLETE ) return FLASH_OP_OK;
else
return FLASHStatus;
}
uint16_t EE_WriteBuf(uint16_t EEAddress, uint16_t* _data, uint16_t len)
{
uint16_t * rData, * fData;
uint32_t adr;
uint32_t ret;
uint32_t i;
volatile FLASH_Status FLASHStatus = FLASH_COMPLETE;
ret = 0;
// check data
rData = (uint16_t *)_data;
fData = (uint16_t *)(EEAddress + EEPROM_START_ADDRESS);
adr = EEAddress + EEPROM_START_ADDRESS;
for (i = 0; i < len; i++)
{
if (rData[i] != fData[i] )
{
ret = 1;
if (fData[i] != 0xFFFF)
{
ret = 2;
i = len;
}
}
}
if (ret)
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
// Clear Page
if (ret == 2)
FLASHStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
ret = 0;
if (FLASHStatus == FLASH_COMPLETE)
{
for (i = 0; i < len; i++)
{
FLASHStatus = FLASH_ProgramHalfWord(adr, rData[i]);
adr += 2;
}
// check flash write
rData = (uint16_t *)_data;
fData = (uint16_t *)(EEAddress + EEPROM_START_ADDRESS);
for (i = 0; i < len; i++)
{
if (rData[i] != fData[i] ) ret = 1;
}
}
else
{
ret = 2;
}
FLASH_Lock();
}
return ret;
}
void flash_write_ID()
{
for(uint8_t i = 0; i<ID_LENGTH;i++)
{
FLASH_ProgramHalfWord(ID_ADDRESS + i*2, addressToWrite[i]);
leds_sync_toggle();
}
memset(addressToWrite , 0, ID_LENGTH);
}
//不检查的写入
//WriteAddr:起始地址
//pBuffer:数据指针
//NumToWrite:半字(16位)数
void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
{
u16 i;
for(i=0;i<NumToWrite;i++)
{
FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);
WriteAddr+=2;//地址增加2.
}
}
void Write_Copy_File_Flag(uint16_t flag)
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
FLASH_ErasePage(COPY_FILE_ADDRESS);
FLASH_ProgramHalfWord(COPY_FILE_ADDRESS, flag);
FLASH_Lock();
}
ot_u8 NAND_write_short(ot_u16* addr, ot_u16 data) {
ot_u8 output;
NAND_unlock();
output = (ot_u8)FLASH_ProgramHalfWord((uint32_t)addr, (uint16_t)data);
NAND_lock();
return output;
}
// Initialise EEPROM hardware
void eeprom_init_hw(void)
{
// unlock flash
FLASH_Unlock();
// Clear Flags
FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);
uint8_t mirror;
uint16_t page;
uint32_t addr;
// Read pages status
eFEE_STATUS pages_status[FEE_MIRROR_NUMBER];
eFEE_STATUS status;
for(page = 0; page < FEE_SECTORS; page++)
{
fee_pages_map[page] = 0xFF;
for(mirror = 0; mirror < FEE_MIRROR_NUMBER; mirror++)
{
addr = FEE_BASE_ADDRESS + FEE_EEPROM_SIZE * mirror + FEE_SECTOR_SIZE * page;
status = *(uint16_t *)(addr);
pages_status[mirror] = status;
if((status == eFEE_PAGE_VALID) && (fee_pages_map[page] == 0xFF))
{
fee_pages_map[page] = mirror;
}
else if(status != eFEE_PAGE_ERASED)
{
if(FLASH_ErasePage(addr) == FLASH_COMPLETE)
pages_status[mirror] = eFEE_PAGE_ERASED;
else
{
FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);
pages_status[mirror] = eFEE_PAGE_INVALID;
}
}
}
if(fee_pages_map[page] == 0xFF) // No Valid mirror
for(mirror = 0; mirror < FEE_MIRROR_NUMBER; mirror++)
{
if(pages_status[mirror] == eFEE_PAGE_ERASED)
{
addr = FEE_BASE_ADDRESS + FEE_EEPROM_SIZE * mirror + FEE_SECTOR_SIZE * page;
if(FLASH_ProgramHalfWord(addr, eFEE_PAGE_VALID) == FLASH_COMPLETE)
{
fee_pages_map[page] = mirror;
break;
}
else
FLASH_ClearFlag(FLASH_FLAG_PGERR |FLASH_FLAG_WRPERR|FLASH_FLAG_EOP);
}
}
}
}
/**********************************************************
* 函数功能 ---> STM32 FLASH写入扇区
* 入口参数 ---> Address：写入数据的起始地址
* *pBuffer：写入数据缓存
* NumWriteData：写入（半字）数量
* 返回参数 ---> none
* 功能说明 ---> none
**********************************************************/
void FLASH_Write_HaifWord_SECTOR(uint32_t Address, uint16_t *pBuffer, uint16_t NumWriteData)
{
uint16_t i;
for(i = 0;i < NumWriteData;i++)
{
FLASH_ProgramHalfWord(Address, pBuffer[i]); //写入半字数据
Address += 2; //地址增加2
}
}
u16 Flash_EEPROM_Write_Data( u32 Start_Address, u16 *data, u16 No_of_Data, u8 Data_format)
{
// u32 Write_Addr_Cnt=Start_Address;
u32 End_Of_Address=0;
FLASHStatus=FLASH_COMPLETE;
FLASH_EEPROM_ProgramStatus= PASSED;
FLASH_Unlock();
/*Start EEPROM*/
Flash_EEPROM_Addr= Start_Address;
End_Of_Address= Start_Address +(No_of_Data * Data_format) ;
/* Write page data*/
while((Flash_EEPROM_Addr<End_Of_Address) )
{
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */
// if ((*( vu32 *)Flash_EEPROM_Addr) == 0xFFFFFFFF)
// {
switch(Data_format)
{
case Data_8Bit :
break;
case Data_16Bit :
FLASHStatus = FLASH_ProgramHalfWord(Flash_EEPROM_Addr, *data);
if (FLASHStatus != FLASH_COMPLETE)
{
return FLASHStatus;
}
Flash_EEPROM_Addr +=2; // point to next 2byte address
data++;
break;
case Data_32Bit :
FLASHStatus = FLASH_ProgramWord(Flash_EEPROM_Addr, *data);
if (FLASHStatus != FLASH_COMPLETE)
{
return FLASHStatus;
}
Flash_EEPROM_Addr +=4; // point to next 4byte address
data++;
break;
}
/*
}
else
{
Flash_EEPROM_Addr +=4; // point to next 4byte address
}
*/
}
FLASH_Lock();
return FLASHStatus;
}
void EEPROM_Write( u32 Offset, u16 Data )
{
volatile FLASH_Status FLASHStatus;
u32 Adr;
u16 cnt;
u16 Buffer[512];
Adr = EEPROM_START_ADDRESS + (Offset<<1);
if( (Data != EEPROM_Read(Offset)) && (Offset<512) )
{
for( cnt=0; cnt<512; cnt++ )
{
Buffer[cnt] = EEPROM_Read(cnt);
}
Buffer[Offset] = Data;
FLASH_Unlock();
/* Clear All pending flags */
FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
if( (Data==0) || (EEPROM_Read(Offset)==0xFFFF) )
{
FLASHStatus = FLASH_ProgramHalfWord( Adr, Data );
}
else
{ // Erase
/* Erase the FLASH pages */
FLASHStatus = FLASH_ErasePage( EEPROM_START_ADDRESS);
Adr = EEPROM_START_ADDRESS;
for( cnt=0; cnt<512; cnt++ )
{
if( Buffer[cnt] != 0xFFFF ) FLASHStatus = FLASH_ProgramHalfWord( Adr, Buffer[cnt] );
Adr += 2;
}
}
FLASH_Lock();
}
}
