/******************************************************************************* * 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; }
/************************************************* Function: hw_flash_erase Descroption: Input: 1.SectorAddress Output: Return: Other: *************************************************/ uint32_t hw_flash_erase(uint32_t SectorAddress) { #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS) FLASH_ClearFlag(FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR); return FLASH_ErasePage(SectorAddress); #else return FLASH_ErasePage(SectorAddress); #endif /* STM32L1XX_XD */ }
//================================================ static void write_mem(void) { u32 addr = 0; u16 i = 0; u8 temp[4]; u16 length = 0; u32 data = 0; u8 crc = 0; FLASH_Status status = FLASH_COMPLETE; // Receive start address for(i=0;i<4;i++) temp[i] = USART_GetC(); crc = USART_GetC(); if(crc == (temp[0]^temp[1]^temp[2]^temp[3])) { mem_cpy(&addr,temp,4); USART_PutC(ACK); length = USART_GetC(); length = (length<<8) | USART_GetC(); for(i = 0;i<length;i++) fwBuff[i] = USART_GetC(); crc = USART_GetC(); // Write memmory FLASH_UnlockBank1(); if(!fUpdating) { // Disable systick SysTick->CTRL &=~( SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk); status = FLASH_ErasePage(FLAG_ADDR); if(status == FLASH_COMPLETE) status = FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATING); fUpdating = true; } if(status == FLASH_COMPLETE) status = FLASH_ErasePage(addr); for(i = 0;i<length;i+=4) { mem_cpy(&data,&fwBuff[i],((length-i)>4?4:(length-i))); if(status != FLASH_COMPLETE) break; status = FLASH_ProgramWord(addr,data); addr += 4; } FLASH_LockBank1(); if(status == FLASH_COMPLETE) USART_PutC(ACK); else USART_PutC(NACK); } else USART_PutC(NACK); }
/******************************************************************************* * Function Name : FLASH_If_Erase * Description : Erase sector * Input : None * Output : None * Return : None *******************************************************************************/ uint16_t FLASH_If_Erase(uint32_t SectorAddress) { #ifdef STM32L1XX_MD FLASH_ClearFlag(FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR); FLASH_ErasePage(SectorAddress); #else FLASH_ErasePage(SectorAddress); #endif /* STM32L1XX_MD */ return MAL_OK; }
void Erase_All_User_id(void) { uint8_t i; FLASH_Unlock(); FLASH_ErasePage(USER_ID_PAGE0_ADDR_START); FLASH_ErasePage(USER_ID_PAGE1_ADDR_START); FLASH_ErasePage(USER_ID_PAGE2_ADDR_START); FLASH_Lock(); for(i=1; i<96; i++) lock_infor.index_map[(i-1)/MAP_SIZE] &= (~(1<<((i-1)%MAP_SIZE))); Index_Save(); }
bool writeEEPROM(bool blink) { FLASH_Status status; uint8_t chk = 0; const uint8_t *p; // prepare checksum/version constants _params.version = EEPROM_CONF_VERSION; _params.size = sizeof(params_t); _params.magic_be = 0xBE; _params.magic_ef = 0xEF; _params.chk = 0; // recalculate checksum before writing for (p = (const uint8_t *)&_params; p < ((const uint8_t *)&_params + sizeof(params_t)); p++) chk ^= *p; _params.chk = chk; // write it FLASH_Unlock(); for (unsigned int tries = 3; tries; tries--) { FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); FLASH_ErasePage(FLASH_WRITE_ADDR); status = FLASH_ErasePage(FLASH_WRITE_ADDR + FLASH_PAGE_SIZE); for (unsigned int i = 0; i < sizeof(params_t) && status == FLASH_COMPLETE; i += 4) status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&_params + i)); if (status == FLASH_COMPLETE) break; } FLASH_Lock(); // Flash write failed - just die now if (status != FLASH_COMPLETE || !validEEPROM()) { return false; } if (blink) { for (uint8_t i=0; i < 3; i++) { LED0_TOGGLE; delay(100); LED0_TOGGLE; delay(50); } } return true; }
void writeEEPROM(uint8_t b, uint8_t updateProfile) { FLASH_Status status; int i, tries = 3; uint8_t chk = 0; const uint8_t *p; // prepare checksum/version constants mcfg.version = EEPROM_CONF_VERSION; mcfg.size = sizeof(master_t); mcfg.magic_be = 0xBE; mcfg.magic_ef = 0xEF; mcfg.chk = 0; // when updateProfile = true, we copy contents of cfg to global configuration. when false, only profile number is updated, and then that profile is loaded on readEEPROM() if (updateProfile) { // copy current in-memory profile to stored configuration memcpy(&mcfg.profile[mcfg.current_profile], &cfg, sizeof(config_t)); } // recalculate checksum before writing for (p = (const uint8_t *)&mcfg; p < ((const uint8_t *)&mcfg + sizeof(master_t)); p++) chk ^= *p; mcfg.chk = chk; // write it FLASH_Unlock(); while (tries--) { FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); FLASH_ErasePage(FLASH_WRITE_ADDR); status = FLASH_ErasePage(FLASH_WRITE_ADDR + FLASH_PAGE_SIZE); for (i = 0; i < sizeof(master_t) && status == FLASH_COMPLETE; i += 4) status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&mcfg + i)); if (status == FLASH_COMPLETE) break; } FLASH_Lock(); // Flash write failed - just die now if (status != FLASH_COMPLETE || !validEEPROM()) { failureMode(10); } // re-read written data loadAndActivateConfig(); if (b) blinkLED(15, 20, 1); }
/** * Erase data on flash. * @note This operation is irreversible. * @note This operation's units is different which on many chips. * * @param addr flash address * @param size erase bytes size * * @return result */ EfErrCode ef_port_erase(uint32_t addr, size_t size) { EfErrCode result = EF_NO_ERR; FLASH_Status flash_status; size_t erase_pages, i; /* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */ EF_ASSERT(addr % ERASE_MIN_SIZE == 0); /* calculate pages */ erase_pages = size / PAGE_SIZE; if (size % PAGE_SIZE != 0) { erase_pages++; } /* start erase */ FLASH_Unlock(); FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); for (i = 0; i < erase_pages; i++) { flash_status = FLASH_ErasePage(addr + (PAGE_SIZE * i)); if (flash_status != FLASH_COMPLETE) { result = EF_ERASE_ERR; break; } } FLASH_Lock(); return result; }
/*********************************************************** * 函数名: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); }
void ErasePage(uint32_t p_addr, unsigned char with_lock) { FLASH_Unlock(); FLASH_ErasePage(p_addr); if (with_lock) FLASH_Lock(); }
uint8_t PIOS_BL_HELPER_FLASH_Start() { const struct pios_board_info * bdinfo = &pios_board_info_blob; uint32_t pageAdress = bdinfo->fw_base; uint8_t fail = false; while ((pageAdress < (bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size)) && (fail == false)) { for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) { if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) { fail = false; break; } else { fail = true; } } #ifdef STM32F10X_HD pageAdress += 2048; #elif defined (STM32F10X_MD) pageAdress += 1024; #endif } return (fail == true) ? 0 : 1; }
//----清除全部刷卡记录----------------------------------------------------- void clear_CardID() { char DateSt[12], TimeSt[12]; storeaddrlist.RecordCount = 0; storeaddrlist.CountAddrOffset = 0; timeoutaddrlist.RecordCount = 0; timeoutaddrlist.CountAddrOffset = 0; LastSaveTime = GetRTC(DateSt, TimeSt);///获取当前时间,秒数 //需要优化; //清除记录区 FLASH_Unlock(); FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); FLASH_ErasePage(PLACELASTID); FLASH_ErasePage(POINTOFSECTION); FLASH_Lock(); }
uint8_t FLASH_Start() { uint32_t pageAdress; pageAdress = START_OF_USER_CODE; uint8_t fail = FALSE; while ((pageAdress < START_OF_USER_CODE + SIZE_OF_CODE + SIZE_OF_DESCRIPTION) || (fail == TRUE)) { for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) { if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) { fail = FALSE; break; } else { fail = TRUE; } } #ifdef STM32F10X_HD pageAdress += 2048; #elif defined (STM32F10X_MD) pageAdress += 1024; #endif } return (fail == TRUE) ? 0 : 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; }
uint8_t PIOS_BL_HELPER_FLASH_Start() { const struct pios_board_info * bdinfo = &pios_board_info_blob; uint32_t pageAdress = bdinfo->fw_base; uint8_t fail = FALSE; while ((pageAdress < (bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size)) || (fail == TRUE)) { for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) { if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) { fail = FALSE; break; } else { fail = TRUE; } } #ifdef STM32F10X_HD pageAdress += 2048; #else /* everything else */ pageAdress += 1024; #endif } return (fail == TRUE) ? 0 : 1; }
/*************************** Function : Erase the internal Flash data Input :- start address - Number of page Output: return the FLASH status ***************************/ u16 Flash_EEPROM_ErasePage( u32 Start_Address, u16 No_of_Size) { FLASH_Unlock(); FLASHStatus=FLASH_COMPLETE; FLASH_EEPROM_ProgramStatus= PASSED; Flash_EEPROM_Nb_Of_Page= No_of_Size; // /*Clear all the flash */ FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR | FLASH_FLAG_OPTERR); /*erase the page*/ for(EraseCounter=0; EraseCounter<Flash_EEPROM_Nb_Of_Page; EraseCounter++) { FLASHStatus = FLASH_ErasePage(Start_Address +(FL_EEPROM_PageSize* EraseCounter)); if (FLASHStatus != FLASH_COMPLETE) { return FLASHStatus; } } FLASH_Lock(); return FLASHStatus; }
//写多个数据到一个页 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; }
int StoreApInfo() { rtw_wifi_config_t wifi_config; uint32_t address; #ifdef STM32F10X_XL address = 0x08080000; //bank2 domain #else uint16_t sector_nb = FLASH_Sector_11; address = flash_SectorAddress(sector_nb); #endif wifi_config.boot_mode = 0x77665502; memcpy(wifi_config.ssid, wifi_setting.ssid, strlen((char*)wifi_setting.ssid)); wifi_config.ssid_len = strlen((char*)wifi_setting.ssid); wifi_config.security_type = wifi_setting.security_type; memcpy(wifi_config.password, wifi_setting.password, strlen((char*)wifi_setting.password)); wifi_config.password_len= strlen((char*)wifi_setting.password); wifi_config.channel = wifi_setting.channel; printf("\n\rWritting boot mode 0x77665502 and Wi-Fi setting to flash ..."); #ifdef STM32F10X_XL FLASH_ErasePage(address); #else flash_EraseSector(sector_nb); #endif flash_Wrtie(address, (char *)&wifi_config, sizeof(rtw_wifi_config_t)); return 0; }
//===================================== void saveFont(u32 addr,u8* fontData,u16 length) { u32 i = 0; u32 addr_temp; u32 data_temp = 0; FLASH_Status status = FLASH_COMPLETE; addr_temp = addr; // Unlock flash to rewrite to flash FLASH_UnlockBank1(); // Erase pages used to store font for(i = 0;i<3;i++) { status = FLASH_ErasePage(addr_temp); addr_temp += FLASH_PAGE_SIZE; } // Write font data to flash for(i = 0;i<length;i+=4) { memcpy(&data_temp,&fontData[i],((length-i)>4?4:(length-i))); status = FLASH_ProgramWord(addr,data_temp); addr += sizeof(u32); } FLASH_LockBank1(); }
int write_whole_poweroff_info_tbl(struct poweroff_info_st *data) { u32 *ps, *pd; int i; FLASH_Status status; if (NULL == data) return -RT_ERROR; FLASH_Unlock(); /* Clear pending flags (if any) */ FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPTERR | FLASH_FLAG_WRPRTERR | FLASH_FLAG_PGERR | FLASH_FLAG_BSY); status = FLASH_ErasePage((rt_uint32_t)POWEROFF_INFO_TBL_BASE_OF_FLASH); /* wait for complete in FLASH_ErasePage() */ if (FLASH_COMPLETE != status) while(1); //return status; ps = (u32 *)data; pd = (u32 *)POWEROFF_INFO_TBL_BASE_OF_FLASH; for (i=0; i < RT_ALIGN(POWEROFF_INFO_TBL_SIZE_OF_FLASH, 4)/4; i++) { status = FLASH_ProgramWord((u32)pd, *ps); /* wait for complete in FLASH_ProgramWord() */ if (FLASH_COMPLETE != status) while(1); //return status; ++pd; ++ps; } FLASH_Lock(); return FLASH_COMPLETE; }
/*********************************************************** * 函数名:Write_GPS_Info * 描述 :把GPS信息从CPU写入Flash * 输入 : 无 * 输出 : 无 ***********************************************************/ void Write_Flash_GPS_Info(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[10] - StartAddr[10]) / FLASH_PAGE_SIZE; //页面擦除子程序 FLASHStatus = FLASH_ErasePage(StartAddr[10] + (FLASH_PAGE_SIZE * NbrOfPage)); FlashAddress = StartAddr[10]; FLASHStatus = FLASH_ProgramWord(FlashAddress, jingdu); FlashAddress = FlashAddress + 4; FLASHStatus = FLASH_ProgramWord(FlashAddress, weidu); FlashAddress = FlashAddress + 4; FLASHStatus = FLASH_ProgramWord(FlashAddress, sog); FlashAddress = FlashAddress + 4; FLASHStatus = FLASH_ProgramWord(FlashAddress, direction); BKP_WriteBackupRegister(BKP_DR4,(u16)(jingdu >> 16)); BKP_WriteBackupRegister(BKP_DR5,(u16)(weidu >> 16)); BKP_WriteBackupRegister(BKP_DR7,(u16)jingdu); BKP_WriteBackupRegister(BKP_DR8,(u16)weidu); BKP_WriteBackupRegister(BKP_DR9,sog); BKP_WriteBackupRegister(BKP_DR10,direction); }
/** * @brief Main program * @param None * @retval None */ int main(void) { RCC_Configuration(); GPIO_Configuration(); USART_Configuration(); SysTick_Config(SystemCoreClock/10); // Enable the LSI OSC RCC_LSICmd(ENABLE); // Wait till LSI is ready while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {}; IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable); // IWDG counter clock: LSI/256 IWDG_SetPrescaler(IWDG_Prescaler_256); IWDG_SetReload(0x0FFF); // Reload IWDG counter IWDG_ReloadCounter(); // Enable IWDG (the LSI oscillator will be enabled by hardware) IWDG_Enable(); // Write memmory FLASH_UnlockBank1(); FLASH_ErasePage(FLAG_ADDR); FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATED); FLASH_LockBank1(); updateFW_control(); }
void cmd_page_erase() { int adrs=BSWAP32(PacketFromPC.adrs); if( check_flash_adrs(adrs)) { FLASH_ErasePage(adrs); } }
/******************************************************************************* * Function Name : FLASH_If_Erase * Description : Erase sector * Input : None * Output : None * Return : None *******************************************************************************/ uint16_t FLASH_If_Erase(uint32_t Add) { /* Unlock the internal flash */ FLASH_Unlock(); FLASH_ClearFlags(); #if defined (STM32F2XX) || defined (STM32F4XX) /* Disable sector write protection if it's already protected */ uint16_t OB_WRP_Sector = FLASH_SectorToWriteProtect(FLASH_INTERNAL, Add); FLASH_WriteProtection_Disable(OB_WRP_Sector); /* Check which sector has to be erased */ uint16_t FLASH_Sector = FLASH_SectorToErase(FLASH_INTERNAL, Add); FLASH_Status status = FLASH_EraseSector(FLASH_Sector, VoltageRange_3); #elif defined(STM32F10X_CL) /* Call the standard Flash erase function */ FLASH_ErasePage(Add); #endif /* STM32F2XX */ /* Lock the internal flash */ FLASH_Lock(); if (status != FLASH_COMPLETE) return MAL_FAIL; return MAL_OK; }
Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length) { Fls_AddressType pageStart = 0; Fls_AddressType erased = 0; u32 page = 0; u32 pageIndex; /* 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); /* Find first sector. */ page = (TargetAddress - flsConfigPtr->FlsSectorList[0].FlsSectorStartaddress) / flsConfigPtr->FlsSectorList[0].FlsPageSize; pageStart = flsConfigPtr->FlsSectorList[0].FlsSectorStartaddress + page * flsConfigPtr->FlsSectorList[0].FlsPageSize; //page = Length / flsConfigPtr->FlsSectorList[0].FlsPageSize; /* Erase the pages... */ for (pageIndex = page; erased < Length; pageIndex++) { volatile FLASH_Status status = FLASH_BUSY; while(status != FLASH_COMPLETE){ status = FLASH_ErasePage((uint32_t)pageStart); } erased += flsConfigPtr->FlsSectorList[0].FlsPageSize; pageStart += flsConfigPtr->FlsSectorList[0].FlsPageSize; } return E_OK; }
static int32_t PIOS_Flash_Internal_EraseSector(uintptr_t flash_id, uint32_t addr) { struct pios_internal_flash_dev * flash_dev = (struct pios_internal_flash_dev *)flash_id; if (!PIOS_Flash_Internal_Validate(flash_dev)) return -1; #if defined(PIOS_INCLUDE_WDG) PIOS_WDG_Clear(); #endif uint32_t sector_start; uint32_t sector_size; if (!PIOS_Flash_Internal_GetSectorInfo(addr, §or_start, §or_size)) { /* We're asking for an invalid flash address */ return -2; } FLASH_Status ret = FLASH_ErasePage(sector_start); if (ret != FLASH_COMPLETE) return -3; return 0; }
void writeParams(uint8_t b) { FLASH_Status status; uint32_t i; uint8_t chk = 0; const uint8_t *p; cfg.version = EEPROM_CONF_VERSION; cfg.size = sizeof(config_t); cfg.magic_be = 0xBE; cfg.magic_ef = 0xEF; cfg.chk = 0; for (p = (const uint8_t *)&cfg; p < ((const uint8_t *)&cfg + sizeof(config_t)); p++) chk ^= *p; // recalculate checksum before writing cfg.chk = chk; FLASH_Unlock(); // write it FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); for (i = 0; i < FLASH_PAGES_FORCONFIG; i++) // Erase the pages here { while (FLASH_ErasePage(FLASH_WRITE_ADDR + (i * FLASH_PAGE_SIZE)) != FLASH_COMPLETE); } for (i = 0; i < sizeof(config_t); i += 4) // Write that config now. { status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *) ((char *) &cfg + i)); if (status != FLASH_COMPLETE) break; // TODO: fail } FLASH_Lock(); readEEPROM(); if (b) blinkLED(15, 20, 1); }
void writeParams(void) { FLASH_Status status; uint32_t i; uint8_t chk = 0; const uint8_t *p; cfg.version = EEPROM_CONF_VERSION; cfg.size = sizeof(config_t); cfg.magic_be = 0xBE; cfg.magic_ef = 0xEF; cfg.chk = 0; // recalculate checksum before writing for (p = (const uint8_t *)&cfg; p < ((const uint8_t *)&cfg + sizeof(config_t)); ++p) chk ^= *p; cfg.chk = chk; // write it FLASH_Unlock(); FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); if (FLASH_ErasePage(FLASH_WRITE_ADDR) == FLASH_COMPLETE) { for (i = 0; i < sizeof(config_t); i += 4) { status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&cfg + i)); if (status != FLASH_COMPLETE) while(1);//break; // TODO: fail } } FLASH_Lock(); readEEPROM(); }
void Erase_All_id(void) { uint8_t i; FLASH_Unlock(); FLASH_ErasePage(USER_ID_PAGE0_ADDR_START); FLASH_ErasePage(USER_ID_PAGE1_ADDR_START); FLASH_ErasePage(USER_ID_PAGE2_ADDR_START); FLASH_ErasePage(ADMIN_ID_PAGE4_ADDR_START); FLASH_Lock(); lock_infor.work_mode = NORMAL; for(i=0; i<4; i++) lock_infor.index_map[i]=0; Index_Save(); }
// write to a specified page in flash // page_addr: the page address that write to void write_embedded_flash_with_addr_len(uint32_t page_addr, uint8_t *buf, uint16_t len) { uint32_t saddr = page_addr; // start address for the page to write uint32_t eaddr = saddr+len; // end addrees for that page uint32_t *pbuf = (uint32_t*)buf; // Unlock the Flash Program Erase controller FLASH_Unlock(); // Clear All pending flags FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_SIZERR); // Erase the FLASH pages FLASHStatus = FLASH_ErasePage(saddr); // write buf to that page while((saddr < eaddr) && (FLASHStatus == FLASH_COMPLETE)) { FLASHStatus = FLASH_FastProgramWord(saddr, *(pbuf)); //problem saddr = saddr + 4; pbuf++; } if (FLASHStatus != FLASH_COMPLETE) { HardFault_Handler();//enter_unexpected(); do something here; } // Lock flash FLASH_Lock(); }