void flash_write(const uint32_t *src, uint32_t dst, uint32_t size)
{
// Unlock flash
HAL_FLASH_Unlock();
#if defined(MCU_SERIES_H7)
// Program the flash 32 bytes at a time.
for (int i=0; i<size/32; i++) {
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, dst, (uint64_t)(uint32_t) src) != HAL_OK) {
// error occurred during flash write
HAL_FLASH_Lock(); // lock the flash
__fatal_error();
}
src += 8;
dst += 32;
}
#else
// Program the flash 4 bytes at a time.
for (int i=0; i<size/4; i++) {
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, dst, *src) != HAL_OK) {
// error occurred during flash write
HAL_FLASH_Lock(); // lock the flash
__fatal_error();
}
src += 1;
dst += 4;
}
#endif
// lock the flash
HAL_FLASH_Lock();
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F103xB HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 64 MHz */
SystemClock_Config();
/* Unlock the Flash Program Erase controller */
HAL_FLASH_Unlock();
/* EEPROM Init */
EE_Init();
/* --- Store successively many values of the three variables in the EEPROM ---*/
/* Store 0x1000 values of Variable1 in EEPROM */
for (VarValue = 1; VarValue <= 0x1000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[0], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
/* Store 0x2000 values of Variable2 in EEPROM */
for (VarValue = 1; VarValue <= 0x2000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[1], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]);
/* Store 0x3000 values of Variable3 in EEPROM */
for (VarValue = 1; VarValue <= 0x3000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[2], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]);
EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]);
while (1)
{
};
}
void flash_erase(uint32_t sector)
{
uint32_t SectorError = 0;
// unlock
HAL_FLASH_Unlock();
// Clear pending flags (if any)
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
// erase the sector(s)
FLASH_EraseInitTypeDef EraseInitStruct;
EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V
EraseInitStruct.Sector = sector;
EraseInitStruct.NbSectors = 1;
if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) {
// error occurred during sector erase
HAL_FLASH_Lock(); // lock the flash
__fatal_error();
}
HAL_FLASH_Lock(); // lock the flash
}
/**
* @brief Erase flash block
* @note Block is the same thing as page in terms of stm32 lib:
* it's minimal erasable chunk of flash memory
*
* @param dev
* @param block
*
* @return Error code
*/
static int stm32f3_flash_erase_block(struct flash_dev *dev, uint32_t block) {
int err;
uint32_t page_err;
FLASH_EraseInitTypeDef erase_struct;
if (!stm32f3_flash_check_block(dev, block)) {
return -EINVAL;
}
HAL_FLASH_Unlock();
erase_struct = (FLASH_EraseInitTypeDef) {
.TypeErase = TYPEERASE_PAGES,
.PageAddress = dev->start + block * STM32F3_FLASH_PAGE_SIZE,
.NbPages = 1,
};
err = HAL_FLASHEx_Erase(&erase_struct, &page_err);
/* TODO check errcode */
/* Lock to prevent unwanted operations with flash memory */
HAL_FLASH_Lock();
return err;
}
static int stm32f3_flash_read(struct flash_dev *dev, uint32_t base, void* data, size_t len) {
size_t rlen = min(len, dev->end - dev->start + base);
/* read can be unaligned */
memcpy(data, (void *) dev->start + base, rlen);
return rlen;
}
/**
* @brief Configure the write protection status of user flash area.
* @param modifier DISABLE or ENABLE the protection
* @retval HAL_StatusTypeDef HAL_OK if change is applied.
*/
HAL_StatusTypeDef FLASH_If_WriteProtectionConfig(uint32_t modifier)
{
uint32_t ProtectedSECTOR = 0xFFF;
FLASH_OBProgramInitTypeDef config_new, config_old;
HAL_StatusTypeDef result = HAL_OK;
/* Get pages write protection status ****************************************/
HAL_FLASHEx_OBGetConfig(&config_old);
/* The parameter says whether we turn the protection on or off */
config_new.WRPState = modifier;
/* We want to modify only the Write protection */
config_new.OptionType = OPTIONBYTE_WRP;
/* No read protection, keep BOR and reset settings */
config_new.RDPLevel = OB_RDP_LEVEL_0;
config_new.USERConfig = config_old.USERConfig;
/* Get pages already write protected ****************************************/
ProtectedSECTOR = config_old.WRPSector | FLASH_SECTOR_TO_BE_PROTECTED;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
/* Unlock the Options Bytes *************************************************/
HAL_FLASH_OB_Unlock();
config_new.WRPSector = ProtectedSECTOR;
result = HAL_FLASHEx_OBProgram(&config_new);
return result;
}
/**
* @brief Erase Access Point parameters from FLASH
* @param None
* @retval System_Status_t (MODULE_SUCCESS/MODULE_ERROR)
*/
System_Status_t ResetSSIDPasswordInMemory(void)
{
/* Reset Calibration Values in FLASH */
System_Status_t status = MODULE_ERROR;
/* Erase First Flash sector */
FLASH_EraseInitTypeDef EraseInitStruct;
uint32_t SectorError = 0;
EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3;
EraseInitStruct.Sector = BLUEMSYS_FLASH_SECTOR;
EraseInitStruct.NbSectors = 1;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK){
/* Error occurred while sector erase.
User can add here some code to deal with this error.
SectorError will contain the faulty sector and then to know the code error on this sector,
user can call function 'HAL_FLASH_GetError()'
FLASH_ErrorTypeDef errorcode = HAL_FLASH_GetError(); */
printf("\n\rError while erasing FLASH memory");
} else {
status = MODULE_SUCCESS;
}
/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) *********/
HAL_FLASH_Lock();
return status;
}
/**
* @brief Returns the write protection status of application flash area.
* @param None
* @retval If a sector in application area is write-protected returned value is a combinaison
of the possible values : FLASHIF_PROTECTION_WRPENABLED, FLASHIF_PROTECTION_PCROPENABLED, ...
* If no sector is write-protected FLASHIF_PROTECTION_NONE is returned.
*/
uint32_t FLASH_If_GetWriteProtectionStatus(void)
{
uint32_t ProtectedPAGE = FLASHIF_PROTECTION_NONE;
FLASH_OBProgramInitTypeDef OptionsBytesStruct;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
/* Check if there are write protected sectors inside the user flash area ****/
HAL_FLASHEx_OBGetConfig(&OptionsBytesStruct);
/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) *********/
HAL_FLASH_Lock();
/* Get pages already write protected ****************************************/
ProtectedPAGE = ~(OptionsBytesStruct.WRPPage) & FLASH_PAGE_TO_BE_PROTECTED;
/* Check if desired pages are already write protected ***********************/
if(ProtectedPAGE != 0)
{
/* Some sectors inside the user flash area are write protected */
return FLASHIF_PROTECTION_WRPENABLED;
}
else
{
/* No write protected sectors inside the user flash area */
return FLASHIF_PROTECTION_NONE;
}
}
void flash_erase(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) {
// check there is something to write
if (num_word32 == 0) {
return;
}
// unlock
HAL_FLASH_Unlock();
// Clear pending flags (if any)
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
// erase the sector(s)
FLASH_EraseInitTypeDef EraseInitStruct;
EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V
EraseInitStruct.Sector = flash_get_sector_info(flash_dest, NULL, NULL);
EraseInitStruct.NbSectors = flash_get_sector_info(flash_dest + 4 * num_word32 - 1, NULL, NULL) - EraseInitStruct.Sector + 1;
uint32_t SectorError = 0;
if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) {
// error occurred during sector erase
HAL_FLASH_Lock(); // lock the flash
return;
}
}
/**
* @brief This function does an erase of all user flash area
* @param start: start of user flash area
* @retval FLASHIF_OK : user flash area successfully erased
* FLASHIF_ERASEKO : error occurred
*/
uint32_t FLASH_If_Erase(uint32_t start)
{
uint32_t NbrOfPages = 0;
uint32_t PageError = 0;
FLASH_EraseInitTypeDef pEraseInit;
HAL_StatusTypeDef status = HAL_OK;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
/* Get the sector where start the user flash area */
NbrOfPages = (USER_FLASH_END_ADDRESS - start)/FLASH_PAGE_SIZE;
pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
pEraseInit.PageAddress = start;
pEraseInit.NbPages = NbrOfPages;
status = HAL_FLASHEx_Erase(&pEraseInit, &PageError);
/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) *********/
HAL_FLASH_Lock();
if (status != HAL_OK)
{
/* Error occurred while page erase */
return FLASHIF_ERASEKO;
}
return FLASHIF_OK;
}
void ErasePage(uint32_t pageAddress)
{
FLASH_EraseInitTypeDef EraseInitStruct;
uint32_t FirstPage = 0, NbOfPages = 0, BankNumber = 0, PAGEError = 0;
/* Unlock the Flash to enable the flash control register access */
HAL_FLASH_Unlock();
/* Clear OPTVERR bit set on virgin samples */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);
/* Get the 1st page to erase */
FirstPage = GetPage(pageAddress);
/* Get the number of pages to erase from 1st page */
NbOfPages = 1;
/* Get the bank */
BankNumber = GetBank(pageAddress);
/* Fill EraseInit structure*/
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.Banks = BankNumber;
EraseInitStruct.Page = FirstPage;
EraseInitStruct.NbPages = NbOfPages;
HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError);
HAL_FLASH_Lock();
}
/**
* @brief Unlocks Flash for write access
* @param None
* @retval None
*/
void FLASH_If_Init(void)
{
HAL_FLASH_Unlock();
/* Clear pending flags (if any) */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_ERSERR);
}
/**
* @brief Writes the contents fo the TFTF header to the TFTF_PARTITION
*/
int program_tftf_header(uint8_t *data, uint32_t size)
{
HAL_FLASH_Unlock();
program_flash_data((uint32_t)(PARTITION_TFTF_START), size, data);
HAL_FLASH_Lock();
return 0;
}
static ssize_t stm32_flash_bdev_erase(struct bdev *bdev, off_t offset, size_t len)
{
LTRACEF("dev %p, offset 0x%llx, len 0x%zx\n", bdev, offset, len);
ssize_t total_erased = 0;
HAL_FLASH_Unlock();
while (len > 0) {
uint32_t sector = 0;
off_t sector_offset = 0;
off_t next_offset = 0;
if (offset_to_sector(offset, §or, §or_offset, &next_offset) < 0)
return ERR_INVALID_ARGS;
FLASH_EraseInitTypeDef erase;
erase.TypeErase = FLASH_TYPEERASE_SECTORS;
erase.Sector = sector;
erase.NbSectors = 1;
erase.VoltageRange = FLASH_VOLTAGE_RANGE_3; // XXX
LTRACEF("erase params: sector %u, num_sectors %u, next_offset 0x%llx\n", erase.Sector, erase.NbSectors, next_offset);
if (1) {
uint32_t sector_error;
HAL_StatusTypeDef err = HAL_FLASHEx_Erase(&erase, §or_error);
if (err != HAL_OK) {
TRACEF("error starting erase operation, sector error %u\n", sector_error);
total_erased = ERR_IO;
break;
}
err = FLASH_WaitForLastOperation(HAL_MAX_DELAY);
if (err != HAL_OK) {
TRACEF("error waiting for erase operation to end, hal error %u\n", HAL_FLASH_GetError());
total_erased = ERR_IO;
break;
}
// invalidate the cache on this region
arch_invalidate_cache_range(FLASHAXI_BASE + sector_offset, next_offset - sector_offset);
}
// move to the next erase boundary
total_erased += next_offset - sector_offset;
off_t erased_bytes = next_offset - offset;
if (erased_bytes >= len)
break;
len -= erased_bytes;
offset = next_offset;
}
HAL_FLASH_Lock();
return total_erased;
}
static int32_t flash_unlock(void)
{
/* Allow Access to Flash control registers and user Falsh */
if (HAL_FLASH_Unlock()) {
return -1;
} else {
return 0;
}
}
/**
* @brief Unlocks Flash for write access
* @param None
* @retval None
*/
void FLASH_If_Init(void)
{
/* Unlock the Program memory */
HAL_FLASH_Unlock();
/* Clear all FLASH flags */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
/* Unlock the Program memory */
HAL_FLASH_Lock();
}
void eeprom_write_byte(uint8_t *pos, unsigned char value) {
uint16_t eeprom_address = (unsigned) pos;
eeprom_init();
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
if (EE_WriteVariable(eeprom_address, (uint16_t) value) != EE_OK)
for (;;) HAL_Delay(1); // Spin forever until watchdog reset
HAL_FLASH_Lock();
}
void eeprom_init() {
if (!eeprom_initialized) {
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
/* EEPROM Init */
if (EE_Initialize() != EE_OK)
for (;;) HAL_Delay(1); // Spin forever until watchdog reset
HAL_FLASH_Lock();
eeprom_initialized = true;
}
}
int flash_erase(uint32_t start_addr, uint32_t size)
{
FLASH_EraseInitTypeDef EraseInitStruct;
uint32_t FirstPage = 0, NbOfPages = 0, BankNumber = 0, PAGEError = 0;
uint32_t end_addr = start_addr + size;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
/* Erase the user Flash area */
/* Clear OPTVERR bit set on virgin samples */
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);
/* Get the 1st page to erase */
FirstPage = GetPage(start_addr);
/* Get the number of pages to erase from 1st page */
NbOfPages = GetPage(end_addr) - FirstPage + 1;
/* Get the bank */
BankNumber = GetBank(start_addr);
/* Fill EraseInit structure*/
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.Banks = BankNumber;
EraseInitStruct.Page = FirstPage;
EraseInitStruct.NbPages = NbOfPages;
/* Note: If an erase operation in Flash memory also concerns data in the data or instruction cache,
you have to make sure that these data are rewritten before they are accessed during code
execution. If this cannot be done safely, it is recommended to flush the caches by setting the
DCRST and ICRST bits in the FLASH_CR register. */
if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
{
/*
Error occurred while page erase.
User can add here some code to deal with this error.
PAGEError will contain the faulty page and then to know the code error on this page,
user can call function 'HAL_FLASH_GetError()'
*/
/* Infinite loop */
while (1) {
}
}
return 0;
}
static int
stm32f3_flash_erase_sector(const struct hal_flash *dev, uint32_t sector_address)
{
FLASH_EraseInitTypeDef erase;
int rc = -1;
uint32_t errorPage = -1;
erase.TypeErase = FLASH_TYPEERASE_PAGES;
erase.PageAddress = sector_address;
erase.NbPages = 1;
HAL_FLASH_Unlock();
if (HAL_OK == HAL_FLASHEx_Erase(&erase, &errorPage)) {
rc = 0;
}
HAL_FLASH_Lock();
return rc;
}
/**
* @brief Write data to flash memory
*
* @param dev
* @param base
* @param data
* @param len
*
* @return Negative error code
*/
static int stm32f3_flash_program(struct flash_dev *dev, uint32_t base, const void* data, size_t len) {
int err = 0;
int offset;
if (!stm32f3_flash_check_align(base, len)
|| ((uintptr_t) data & 0x1) != 0) {
return -EINVAL;
}
if (!stm32f3_flash_check_range(dev, base, len)) {
return -EFBIG;
}
HAL_FLASH_Unlock();
/* Write data halfword by halfword */
for (offset = 0; offset < len; offset += 2) {
if (HAL_OK != HAL_FLASH_Program(TYPEPROGRAM_HALFWORD,
dev->start + base + offset,
*((uint32_t*) data + offset)))
return -1; /* TODO: set appropriate code */
}
/* Lock to prevent unwanted operations with flash memory */
HAL_FLASH_Lock();
return err;
}
// FIXME: HAL for now this will only work for F4/F7 as flash layout is different
void writeEEPROM(void)
{
// Generate compile time error if the config does not fit in the reserved area of flash.
BUILD_BUG_ON(sizeof(master_t) > FLASH_TO_RESERVE_FOR_CONFIG);
HAL_StatusTypeDef status;
uint32_t wordOffset;
int8_t attemptsRemaining = 3;
suspendRxSignal();
// prepare checksum/version constants
masterConfig.version = EEPROM_CONF_VERSION;
masterConfig.size = sizeof(master_t);
masterConfig.magic_be = 0xBE;
masterConfig.magic_ef = 0xEF;
masterConfig.chk = 0; // erase checksum before recalculating
masterConfig.chk = calculateChecksum((const uint8_t *) &masterConfig, sizeof(master_t));
// write it
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
while (attemptsRemaining--)
{
/* Fill EraseInit structure*/
FLASH_EraseInitTypeDef EraseInitStruct = {0};
EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3; // 2.7-3.6V
EraseInitStruct.Sector = (FLASH_SECTOR_TOTAL-1);
EraseInitStruct.NbSectors = 1;
uint32_t SECTORError;
status = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
if (status != HAL_OK)
{
continue;
}
else
{
for (wordOffset = 0; wordOffset < sizeof(master_t); wordOffset += 4)
{
status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, CONFIG_START_FLASH_ADDRESS + wordOffset, *(uint32_t *) ((char *) &masterConfig + wordOffset));
if(status != HAL_OK)
{
break;
}
}
}
if (status == HAL_OK) {
break;
}
}
HAL_FLASH_Lock();
// Flash write failed - just die now
if (status != HAL_OK || !isEEPROMContentValid()) {
failureMode(FAILURE_FLASH_WRITE_FAILED);
}
resumeRxSignal();
}
/**
* @brief This function writes a data buffer in flash (data are 32-bit aligned).
* @note After writing data buffer, the flash content is checked.
* @param destination: start address for target location
* @param p_source: pointer on buffer with data to write
* @param length: length of data buffer (unit is 32-bit word)
* @retval uint32_t 0: Data successfully written to Flash memory
* 1: Error occurred while writing data in Flash memory
* 2: Written Data in flash memory is different from expected one
*/
uint32_t FLASH_If_Write(uint32_t destination, uint32_t *p_source, uint32_t length)
{
uint32_t i = 0;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
for (i = 0; (i < length) && (destination <= (USER_FLASH_END_ADDRESS-4)); i++)
{
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
be done by word */
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, destination, *(uint32_t*)(p_source+i)) == HAL_OK)
{
/* Check the written value */
if (*(uint32_t*)destination != *(uint32_t*)(p_source+i))
{
/* Flash content doesn't match SRAM content */
return(FLASHIF_WRITINGCTRL_ERROR);
}
/* Increment FLASH destination address */
destination += 4;
}
else
{
/* Error occurred while writing data in Flash memory */
return (FLASHIF_WRITING_ERROR);
}
}
/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) *********/
HAL_FLASH_Lock();
return (FLASHIF_OK);
}
int hacs_pstore_set(hacs_pstore_type_t ent, uint8_t *wbuf, uint32_t byte_len)
{
uint32_t ent_addr = hacs_pstore_ent_rel_addr[ent];
hacs_pstore_entry_t *ent_header;
hacs_pstore_header_t *bank_header;
uint8_t *buf_ptr;
uint32_t counter;
uint32_t temp;
uint32_t sector;
int retval;
// Read in the entire current bank
memcpy(ram_buf, (uint8_t*)current_bank_addr, HACS_PSTORE_BANK_SIZE);
// Check entry size. Make sure we are not writing something too big.
retval = -HACS_INVALID_ARGS;
HACS_REQUIRES(byte_len <= hacs_pstore_ent_size[ent], done);
// Update entry content
buf_ptr = (uint8_t*)(ram_buf + ent_addr + sizeof(hacs_pstore_entry_t));
memcpy(buf_ptr, wbuf, byte_len);
// Update entry header
ent_header = (hacs_pstore_entry_t*)(ram_buf + ent_addr);
ent_header->byte_len = byte_len;
ent_header->crc = hacs_crc32_calc(wbuf, byte_len); // each entry has its own CRC
// Update bank header
bank_header = (hacs_pstore_header_t *)ram_buf;
bank_header->bank_version++;
bank_header->layout_version = HACS_PSTORE_LAYOUT_VERSION;
// Write the ram buffer to the alternate bank
HAL_FLASH_Unlock();
sector = (alternate_bank_addr == HACS_PSTORE_0_ADDR) ? HACS_PSTORE_0_SECTOR : HACS_PSTORE_1_SECTOR;
FLASH_Erase_Sector(sector, VOLTAGE_RANGE_3);
// Write the ram buffer word by word.
counter = 0;
while(counter < sizeof(ram_buf)) {
HAL_FLASH_Program(TYPEPROGRAM_WORD, alternate_bank_addr+counter,
*(uint32_t*)(ram_buf+counter)); // unaligned access supported
counter += 4;
}
// Note that I exploit the fact that the ram buffer is word-aligned
// (its length is multiple of 4).
assert(counter == sizeof(ram_buf));
HAL_FLASH_Lock();
// Switch current bank and alternate bank
temp = alternate_bank_addr;
alternate_bank_addr = current_bank_addr;
current_bank_addr = temp;
retval = HACS_NO_ERROR;
done:
return retval;
}
int main(void)
{
HAL_StatusTypeDef status;
FLASH_EraseInitTypeDef eraseInit;
uint32_t sectorError;
uint32_t *ptr=ADDRESS_SECTOR_18;
uint32_t checkCR;
int guard=0;
while(1){
status=HAL_FLASH_Unlock();
//this guard function is to program the Flash
if(guard){
while(status==HAL_BUSY);
status=HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, ADDRESS_SECTOR_18, DATA_PROGRAM);
while(status==HAL_BUSY);
guard=0;
}
//this guard function is to sector erase the Flash
if(guard){
flashEraseInit(&eraseInit,
FLASH_TYPEERASE_SECTORS,
0,
FLASH_SECTOR_18,
1,
FLASH_VOLTAGE_RANGE_3);
while(status==HAL_BUSY);
HAL_FLASHEx_Erase(&eraseInit,§orError);
while(status==HAL_BUSY);
guard=0;
}
//this guard function is to Mass erase the Flash
if(guard){
flashEraseInit(&eraseInit,
FLASH_TYPEERASE_MASSERASE,
0,
0,
1,
FLASH_VOLTAGE_RANGE_3);
while(status==HAL_BUSY);
HAL_FLASHEx_Erase(&eraseInit,§orError);
while(status==HAL_BUSY);
guard=0;
}
status=HAL_FLASH_Lock();
}
}
//set word from a specific memory address: remote debug session.
void EPS_set_memory_word(uint32_t memory_address, uint32_t *memory_data){
uint32_t flash_write_value = *memory_data;
/* write to memory the proper status true value */
HAL_FLASH_Unlock();
HAL_FLASH_Program(TYPEPROGRAM_WORD, memory_address, flash_write_value);
HAL_FLASH_Lock();
}
HAL_StatusTypeDef WriteFlash(int32_t* table, uint32_t Address, uint32_t lenth)
{
HAL_StatusTypeDef res;
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
/* Erase the user Flash area
(area defined by FLASH_USER_START_ADDR and FLASH_USER_END_ADDR) ***********/
EraseFlash(Address);
for(int i=0;i<lenth;i++)
HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,Address+4*i,*(table+i));
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,Address+4*lenth-4,table[lenth-1]);
HAL_FLASH_Lock();
return res;
}
/**
* @brief Save Access Point parameters to FLASH
* @param None
* @retval System_Status_t (MODULE_SUCCESS/MODULE_ERROR)
*/
System_Status_t SaveSSIDPasswordToMemory(void)
{
System_Status_t status = MODULE_ERROR;
/* Reset Before The data in Memory */
status = ResetSSIDPasswordInMemory();
if (status) {
/* Store in Flash Memory */
uint32_t Address = BLUEMSYS_FLASH_ADD;
int32_t WriteIndex;
/* Unlock the Flash to enable the flash control register access *************/
HAL_FLASH_Unlock();
/* Write the Magic Number */
{
uint32_t MagicNumber = WIFI_CHECK_SSID_KEY;
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, Address,MagicNumber) == HAL_OK) {
Address = Address + 4;
} else {
printf("\r\nError while writing in FLASH");
status = MODULE_ERROR;
}
}
/* Write the Wifi */
for (WriteIndex=0;WriteIndex<UNION_DATA_SIZE;WriteIndex++) {
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, Address,UnionWifiToken.Data[WriteIndex]) == HAL_OK){
Address = Address + 4;
} else {
printf("\r\nError while writing in FLASH");
status = MODULE_ERROR;
}
}
/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) *********/
HAL_FLASH_Lock();
printf("\n\rSaveSSIDPasswordToMemory OK");
} else {
printf("\n\rError while resetting FLASH memory");
}
return status;
}
void flash_write(const uint32_t *src, uint32_t dst, uint32_t size)
{
// unlock flash
HAL_FLASH_Unlock();
// program the flash word by word
for (int i=0; i<size/4; i++) {
if (HAL_FLASH_Program(TYPEPROGRAM_WORD, dst, *src) != HAL_OK) {
// error occurred during flash write
HAL_FLASH_Lock(); // lock the flash
__fatal_error();
}
src += 1;
dst += 4;
}
// lock the flash
HAL_FLASH_Lock();
}
HAL_StatusTypeDef
TpmUtilStorePersistedData(
void
)
{
HAL_StatusTypeDef retVal = HAL_OK;
HAL_FLASH_Unlock();
FLASH_Erase_Sector(FLASH_SECTOR_23, FLASH_VOLTAGE_RANGE_3);
for(uint32_t n = 0; n < sizeof(persistedData); n++)
{
if((retVal = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, ADDR_FLASH_SECTOR_23 + n, ((uint8_t*)&persistedData)[n])) != HAL_OK)
{
printf("Flash Write Error @ 0x%08x\r\n", ADDR_FLASH_SECTOR_23 + n);
goto Cleanup;
}
}
Cleanup:
HAL_FLASH_Lock();
}
void EE_WriteVariable(EepromAddress32 virtAddress, uint32_t data)
{
uint16_t length=EE_LastUnusedVariable;
uint32_t address = FLASH_USER_START_ADDR;
for (uint16_t varIndex = 0;varIndex < length;varIndex++)
{
uint32_t data32 = *(__IO uint32_t *)address;
EE_storage[varIndex] = data32;
address = address + 4;
}
EE_storage[virtAddress] = data; //write the new data
HAL_FLASH_Unlock();
/* Get the 1st page to erase */
uint32_t FirstPage = GetPage(FLASH_USER_START_ADDR);
/* Get the number of pages to erase from 1st page */
uint32_t NbOfPages = GetPage(FLASH_USER_END_ADDR) - FirstPage + 1;
/* Get the bank */
uint32_t BankNumber = GetBank(FLASH_USER_START_ADDR);
uint32_t PAGEError;
/* Fill EraseInit structure*/
FLASH_EraseInitTypeDef EraseInitStruct;
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.Banks = BankNumber;
EraseInitStruct.Page = FirstPage;
EraseInitStruct.NbPages = NbOfPages;
HAL_Error_Handler(HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError));
address = FLASH_USER_START_ADDR;
for (uint16_t varIndex = 0;varIndex < length;varIndex+=2)
{
uint64_t toWrite=EE_storage[varIndex];
if (varIndex+1<length)
{
toWrite|= ((uint64_t)EE_storage[varIndex+1])<<32;
}
HAL_Error_Handler(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, address, toWrite));
address = address + 8;
}
HAL_FLASH_Lock();
}
