自学教程：C++ HAL_FLASH_Program函数代码示例

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();}

/** Program one page starting at defined address * * The page should be at page boundary, should not cross multiple sectors. * This function does not do any check for address alignments or if size * is aligned to a page size. * @param obj The flash object * @param address The sector starting address * @param data The data buffer to be programmed * @param size The number of bytes to program * @return 0 for success, -1 for error */int32_t flash_program_page(flash_t *obj, uint32_t address,        const uint8_t *data, uint32_t size){    uint32_t StartAddress = 0;    int32_t status = 0;    if ((address >= (FLASH_BASE + FLASH_SIZE)) || (address < FLASH_BASE)) {        return -1;    }    if ((size % 8) != 0) {        /* L4 flash devices can only be programmed 64bits/8 bytes at a time */        return -1;    }    if (flash_unlock() != HAL_OK) {        return -1;    }    /* Program the user Flash area word by word */    StartAddress = address;    /*  HW needs an aligned address to program flash, which data     *  parameters doesn't ensure  */    if ((uint32_t) data % 4 != 0) {        volatile uint64_t data64;        while ((address < (StartAddress + size)) && (status == 0)) {            for (uint8_t i =0; i < 8; i++) {                *(((uint8_t *) &data64) + i) = *(data + i);            }            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, address, data64)                    == HAL_OK) {                address = address + 8;                data = data + 8;            } else {                status = -1;            }        }    } else { /*  case where data is aligned, so let's avoid any copy */        while ((address < (StartAddress + size)) && (status == 0)) {            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, address,                        *((uint64_t*) data))                    == HAL_OK) {                address = address + 8;                data = data + 8;            } else {                status = -1;            }        }    }    flash_lock();    return status;}

int32_t flash_program_page(flash_t *obj, uint32_t address, const uint8_t *data, uint32_t size){    uint32_t StartAddress = 0;    int32_t status = 0;    if (!(IS_FLASH_PROGRAM_ADDRESS(address))) {        return -1;    }    if ((size % MIN_PROG_SIZE) != 0) {        return -1;    }    if (flash_unlock() != HAL_OK) {        return -1;    }    /* Program the user Flash area word by word */    StartAddress = address;    /* HW needs an aligned address to program flash, which data parameter doesn't ensure */    if ((uint32_t) data % 4 != 0) {        volatile uint32_t data32;        while (address < (StartAddress + size) && (status == 0)) {            for (uint8_t i = 0; i < MIN_PROG_SIZE; i++) {                *(((uint8_t *) &data32) + i) = *(data + i);            }            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data32) == HAL_OK) {                address = address + MIN_PROG_SIZE;                data = data + MIN_PROG_SIZE;            } else {                status = -1;            }        }    } else { /*  case where data is aligned, so let's avoid any copy */        while ((address < (StartAddress + size)) && (status == 0)) {            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, *((uint32_t*) data)) == HAL_OK) {                address = address + MIN_PROG_SIZE;                data = data + MIN_PROG_SIZE;            } else {                status = -1;            }        }    }    flash_lock();    return status;}

/**  * @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){  HAL_StatusTypeDef FlashStatus = HAL_OK;  uint16_t ValidPage = PAGE0;  uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE;  /* 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 = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));  /* Get the valid Page end Address */  PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 1) + (uint32_t)((ValidPage + 1) * 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 = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address, Data);             /* If program operation was failed, a Flash error code is returned */      if (FlashStatus != HAL_OK)      {        return FlashStatus;      }      /* Set variable virtual address */      FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, 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  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);}

// FIXME: HAL for now this will only work for F4/F7 as flash layout is differentvoid 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();}

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  Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE  * @param  None  * @retval Status of the last operation (Flash write or erase) done during  *         EEPROM formating  */static HAL_StatusTypeDef EE_Format(void){  HAL_StatusTypeDef OperationStatus = HAL_OK;  /* Erase Page0 */  FLASH_Erase_Sector(PAGE0_ID, VOLTAGE_RANGE);  /* If erase operation was failed, a Flash error code is returned */  OperationStatus = FLASH_WaitForLastOperation(1000);  if(OperationStatus != HAL_OK)  {  	return OperationStatus;  }  /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */  OperationStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);  /* If program operation was failed, a Flash error code is returned */  if (OperationStatus != HAL_OK)  {    return OperationStatus;  }  /* Erase Page1 */  FLASH_Erase_Sector(PAGE1_ID, VOLTAGE_RANGE);  OperationStatus = FLASH_WaitForLastOperation(1000);  if(OperationStatus != HAL_OK)  {  	return OperationStatus;  }  /* Return Page1 erase operation status */  return OperationStatus;}

/**  * @brief  Writes Data into Memory.  * @param  src: Pointer to the source buffer. Address to be written to.  * @param  dest: Pointer to the destination buffer.  * @param  Len: Number of data to be written (in bytes).  * @retval 0 if operation is successeful, MAL_FAIL else.  */uint16_t Flash_If_Write(uint8_t *src, uint8_t *dest, uint32_t Len){  uint32_t i = 0;    for(i = 0; i < Len; i+=4)  {    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will       be done by byte */     if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)(dest+i), *(uint32_t*)(src+i)) == HAL_OK)    {     /* Check the written value */      if(*(uint32_t *)(src + i) != *(uint32_t*)(dest+i))      {        /* Flash content doesn't match SRAM content */        return 2;      }    }    else    {      /* Error occurred while writing data in Flash memory */      return 1;    }  }  return 0;}

/** * @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;}

int program_flash_data(uint32_t start, uint32_t size, uint8_t *data){  uint64_t data64;  uint32_t offset = 0;  while (offset < size) {    data64 = 0xFFFFFFFFFFFFFFFF;    if((size - offset) < 8) {      memcpy((uint8_t *)&data64, (uint8_t *)&data[offset], (size - offset));    } else {      memcpy((uint8_t *)&data64, (uint8_t *)&data[offset], 8);    }    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, start, data64) == HAL_OK) {      start += 8;      offset += 8;    } else {      /* Error occurred while writing data in Flash memory.         User can add here some code to deal with this error */      while (1) {      }    }  }  return 0;}

static intstm32f4_flash_write(const struct hal_flash *dev, uint32_t address,        const void *src, uint32_t num_bytes){    const uint8_t *sptr;    uint32_t i;    int rc;    sptr = src;    /*     * Clear status of previous operation.     */    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | /      FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR| FLASH_FLAG_PGSERR);    for (i = 0; i < num_bytes; i++) {        rc = HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, address, sptr[i]);        if (rc != 0) {            return rc;        }        address++;    }    return 0;}

/**  * @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  FlashAddress: start address for writing data buffer  * @param  Data: pointer on data buffer  * @param  DataLength: length of data buffer (unit is 32-bit word)     * @retval 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(__IO uint32_t* FlashAddress, uint32_t* Data ,uint16_t DataLength){  uint32_t i = 0;  for (i = 0; (i < DataLength) && (*FlashAddress <= (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, *FlashAddress,  *(uint32_t*)(Data+i)) == HAL_OK)    {     /* Check the written value */      if (*(uint32_t*)*FlashAddress != *(uint32_t*)(Data+i))      {        /* Flash content doesn't match SRAM content */        return(2);      }      /* Increment FLASH destination address */      *FlashAddress += 4;    }    else    {      /* Error occurred while writing data in Flash memory */      return (1);    }  }  return (0);}

/**  * @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;}

int program_flash_dword(const uint64_t *dword){    int rv;    dbgprintx32("program_flash_dword ", PARTITION_FLASHMODE_START, "/r/n");    rv = HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, PARTITION_FLASHMODE_START, *dword);    return rv;}

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,&sectorError);			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,&sectorError);			while(status==HAL_BUSY);			guard=0;		}		status=HAL_FLASH_Lock();	}}

void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) {    #if defined(MCU_SERIES_L4)    // program the flash uint64 by uint64    for (int i = 0; i < num_word32 / 2; i++) {        uint64_t val = *(uint64_t*)src;        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, flash_dest, val) != HAL_OK) {            // error occurred during flash write            HAL_FLASH_Lock(); // lock the flash            return;        }        flash_dest += 8;        src += 2;    }    if ((num_word32 & 0x01) == 1) {        uint64_t val = *(uint64_t*)flash_dest;        val = (val & 0xffffffff00000000uL) | (*src);        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, flash_dest, val) != HAL_OK) {            // error occurred during flash write            HAL_FLASH_Lock(); // lock the flash            return;        }    }    #else    // program the flash word by word    for (int i = 0; i < num_word32; i++) {        if (HAL_FLASH_Program(TYPEPROGRAM_WORD, flash_dest, *src) != HAL_OK) {            // error occurred during flash write            HAL_FLASH_Lock(); // lock the flash            return;        }        flash_dest += 4;        src += 1;    }    #endif    // lock the flash    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();}

void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) {    // program the flash word by word    for (int i = 0; i < num_word32; i++) {        if (HAL_FLASH_Program(TYPEPROGRAM_WORD, flash_dest, *src) != HAL_OK) {            // error occurred during flash write            HAL_FLASH_Lock(); // lock the flash            return;        }        flash_dest += 4;        src += 1;    }    // lock the flash    HAL_FLASH_Lock();}

/**  * @brief  Writes a data buffer in flash (data are 32-bit aligned).  * @note   After writing data buffer, the flash content is checked.  * @param  Address: Start address for writing data buffer  * @param  Data: Pointer on data buffer  * @retval 0: Data successfully written to Flash memory  *         1: Error occurred while writing data in Flash memory  */uint32_t FLASH_If_Write(uint32_t Address, uint32_t Data){  /* Program the user Flash area word by word    (area defined by FLASH_USER_START_ADDR and APPLICATION_ADDRESS) ***********/  if(Address <= (uint32_t) USER_FLASH_LAST_PAGE_ADDRESS)  {    if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data)!= HAL_OK)      return (1);  }  else  {    return (1);  }  return (0);}

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_StatusTypeDefTpmUtilStorePersistedData(    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();}

/**  * @brief  Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE  * @param  None  * @retval Status of the last operation (Flash write or erase) done during  *         EEPROM formating  */static HAL_StatusTypeDef EE_Format(void){  HAL_StatusTypeDef FlashStatus = HAL_OK;  uint32_t SectorError = 0;  FLASH_EraseInitTypeDef pEraseInit;  pEraseInit.TypeErase = FLASH_TYPEERASE_SECTORS;    pEraseInit.Sector = PAGE0_ID;  pEraseInit.NbSectors = 1;  pEraseInit.VoltageRange = VOLTAGE_RANGE;  /* Erase Page0 */  if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))  {    FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);     /* If erase operation was failed, a Flash error code is returned */    if (FlashStatus != HAL_OK)    {      return FlashStatus;    }  }  /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */  FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);   /* If program operation was failed, a Flash error code is returned */  if (FlashStatus != HAL_OK)  {    return FlashStatus;  }  pEraseInit.Sector = PAGE1_ID;  /* Erase Page1 */  if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))  {      FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);     /* If erase operation was failed, a Flash error code is returned */    if (FlashStatus != HAL_OK)    {      return FlashStatus;    }  }    return HAL_OK;}

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();}

/**  * @brief  Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE  * @param  None  * @retval Status of the last operation (Flash write or erase) done during  *         EEPROM formating  */static HAL_StatusTypeDef EE_Format(void){  HAL_StatusTypeDef flashstatus = HAL_OK;  uint32_t page_error = 0;  FLASH_EraseInitTypeDef s_eraseinit;  s_eraseinit.TypeErase   = FLASH_TYPEERASE_PAGES;  s_eraseinit.PageAddress = PAGE0_ID;  s_eraseinit.NbPages     = 1;  /* Erase Page0 */  if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))  {    flashstatus = HAL_FLASHEx_Erase(&s_eraseinit, &page_error);     /* If erase operation was failed, a Flash error code is returned */    if (flashstatus != HAL_OK)    {      return flashstatus;    }  }  /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */  flashstatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);   /* If program operation was failed, a Flash error code is returned */  if (flashstatus != HAL_OK)  {    return flashstatus;  }  s_eraseinit.PageAddress = PAGE1_ID;  /* Erase Page1 */  if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))  {      flashstatus = HAL_FLASHEx_Erase(&s_eraseinit, &page_error);     /* If erase operation was failed, a Flash error code is returned */    if (flashstatus != HAL_OK)    {      return flashstatus;    }  }    return HAL_OK;}

void saveState(){	HAL_FLASH_Unlock();	if (HAL_OK != erase((uint32_t) &_loader_state_addr, (uint32_t) &_loader_state_addr))	{		printf("Error while loader state saving: cannot erase state page. Rebooting.../n");		reboot();	}	//FLASH_PageErase((uint32_t) &_loader_state_addr);	for (uint32_t i=0; i < sizeof(LoaderState) / 4; i++)	{		uint32_t targetAddress = (uint32_t) &_loader_state_addr + 4*i;		uint32_t* pWord = ((uint32_t*) &state) + i;		if (HAL_OK != HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, targetAddress, *pWord))		{			printf("Error while loader state saving: cannot program state page. Rebooting.../n");			reboot();		}	}	HAL_FLASH_Lock();}

uint8_t setNetworkUpgradeTarg(uint8_t targ)  {	uint32_t   i;  	/*Unlock the Flash to enable the flash control register access*/ 	HAL_FLASH_Unlock();	/* Fill EraseInit structure ,Here just SECTOR_11 need to be erased*/    EraseInitStruct.TypeErase = TYPEERASE_SECTORS;    EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3;    EraseInitStruct.Sector = FLASH_SECTOR_2;    EraseInitStruct.NbSectors = 1;	if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK)	{      /*Erase failed*/	  printf("Set network Upgrade error/n/r");	  return 0;    }	/*Program the selected FLASH area byte by byte*/	Address = FLASH_TARG_START_ADDR;	if (HAL_FLASH_Program(TYPEPROGRAM_BYTE, Address,targ) != HAL_OK)	{	  printf("Set network Upgrade error/n/r");	  return 0; 							}	/*Lock the flash to ensure the security of my program*/	HAL_FLASH_Lock();	Address = FLASH_TARG_START_ADDR;	MemoryProgramStatus = 0;	data8 = *(__IO uint8_t*)Address;	if ( data8 != targ )	{	  MemoryProgramStatus++;  	}/*Check if there is an issue to program data*/	if (MemoryProgramStatus != 0)	{	  printf("Set network Upgrade error/n/r");	  return 0;	}	return 1;  }

static intstm32f3_flash_write(const struct hal_flash *dev, uint32_t address,        const void *src, uint32_t num_bytes){    const uint16_t *sptr;    uint32_t i, half_words;    int rc;    sptr = src;    half_words = (num_bytes + 1) / 2;    HAL_FLASH_Unlock();    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR);    for (i = 0, rc = HAL_OK; i < half_words && rc == HAL_OK; ++i) {        rc = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, address, sptr[i]);        address += 2;    }    HAL_FLASH_Lock();    return rc == HAL_OK ? 0 : rc;}

void flash_program(uint32_t flash_user_start_addr,uint32_t flash_user_end_addr){		uint32_t Address = 0;	  Address = flash_user_start_addr;		while (Address < flash_user_end_addr)		{			if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, DATA_32) == HAL_OK)			{				Address = Address + 4;			}			else			{ 				/* Error occurred while writing data in Flash memory. 					 User can add here some code to deal with this error */				/*					FLASH_ErrorTypeDef errorcode = HAL_FLASH_GetError();				*/				Error_Handler();			}		}}