/** | |
****************************************************************************** | |
* @file stm32l0xx_hal_flash_ex.c | |
* @author MCD Application Team | |
* @brief Extended FLASH HAL module driver. | |
* | |
* This file provides firmware functions to manage the following | |
* functionalities of the internal FLASH memory: | |
* + FLASH Interface configuration | |
* + FLASH Memory Erasing | |
* + DATA EEPROM Programming/Erasing | |
* + Option Bytes Programming | |
* + Interrupts management | |
* | |
@verbatim | |
============================================================================== | |
##### Flash peripheral Extended features ##### | |
============================================================================== | |
[..] Comparing to other products, the FLASH interface for STM32L0xx | |
devices contains the following additional features | |
(+) Erase functions | |
(+) DATA_EEPROM memory management | |
(+) BOOT option bit configuration | |
(+) PCROP protection for all sectors | |
##### How to use this driver ##### | |
============================================================================== | |
[..] This driver provides functions to configure and program the FLASH memory | |
of all STM32L0xx. It includes: | |
(+) Full DATA_EEPROM erase and program management | |
(+) Boot activation | |
(+) PCROP protection configuration and control for all pages | |
@endverbatim | |
****************************************************************************** | |
* @attention | |
* | |
* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2> | |
* | |
* Redistribution and use in source and binary forms, with or without modification, | |
* are permitted provided that the following conditions are met: | |
* 1. Redistributions of source code must retain the above copyright notice, | |
* this list of conditions and the following disclaimer. | |
* 2. Redistributions in binary form must reproduce the above copyright notice, | |
* this list of conditions and the following disclaimer in the documentation | |
* and/or other materials provided with the distribution. | |
* 3. Neither the name of STMicroelectronics nor the names of its contributors | |
* may be used to endorse or promote products derived from this software | |
* without specific prior written permission. | |
* | |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
* | |
****************************************************************************** | |
*/ | |
/* Includes ------------------------------------------------------------------*/ | |
#include "stm32l0xx_hal.h" | |
/** @addtogroup STM32L0xx_HAL_Driver | |
* @{ | |
*/ | |
#ifdef HAL_FLASH_MODULE_ENABLED | |
/** @addtogroup FLASH | |
* @{ | |
*/ | |
/** @addtogroup FLASH_Private_Variables | |
* @{ | |
*/ | |
/* Variables used for Erase pages under interruption*/ | |
extern FLASH_ProcessTypeDef pFlash; | |
/** | |
* @} | |
*/ | |
/** | |
* @} | |
*/ | |
/** @defgroup FLASHEx FLASHEx | |
* @brief FLASH HAL Extension module driver | |
* @{ | |
*/ | |
/* Private typedef -----------------------------------------------------------*/ | |
/* Private define ------------------------------------------------------------*/ | |
/** @defgroup FLASHEx_Private_Constants FLASHEx Private Constants | |
* @{ | |
*/ | |
/** | |
* @} | |
*/ | |
/* Private macro -------------------------------------------------------------*/ | |
/** @defgroup FLASHEx_Private_Macros FLASHEx Private Macros | |
* @{ | |
*/ | |
/** | |
* @} | |
*/ | |
/* Private variables ---------------------------------------------------------*/ | |
/* Private function prototypes -----------------------------------------------*/ | |
/** @defgroup FLASHEx_Private_Functions FLASHEx Private Functions | |
* @{ | |
*/ | |
void FLASH_PageErase(uint32_t PageAddress); | |
#if defined(FLASH_OPTR_BFB2) | |
static HAL_StatusTypeDef FLASH_OB_BootConfig(uint8_t OB_BOOT); | |
#endif /* FLASH_OPTR_BFB2 */ | |
static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP); | |
static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY); | |
static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR); | |
static uint8_t FLASH_OB_GetRDP(void); | |
static uint8_t FLASH_OB_GetUser(void); | |
static uint8_t FLASH_OB_GetBOR(void); | |
static uint8_t FLASH_OB_GetBOOTBit1(void); | |
static HAL_StatusTypeDef FLASH_OB_BOOTBit1Config(uint8_t OB_BootBit1); | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t Sector2, uint32_t NewState); | |
#else | |
static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t NewState); | |
#endif | |
static uint32_t FLASH_OB_GetWRP(void); | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
static uint32_t FLASH_OB_GetWRP2(void); | |
#endif | |
/** | |
* @} | |
*/ | |
/* Exported functions ---------------------------------------------------------*/ | |
/** @defgroup FLASHEx_Exported_Functions FLASHEx Exported Functions | |
* @{ | |
*/ | |
/** @defgroup FLASHEx_Exported_Functions_Group1 FLASHEx Memory Erasing functions | |
* @brief FLASH Memory Erasing functions | |
* | |
@verbatim | |
============================================================================== | |
##### FLASH Erasing Programming functions ##### | |
============================================================================== | |
[..] The FLASH Memory Erasing functions, includes the following functions: | |
(+) @ref HAL_FLASHEx_Erase: return only when erase has been done | |
(+) @ref HAL_FLASHEx_Erase_IT: end of erase is done when @ref HAL_FLASH_EndOfOperationCallback | |
is called with parameter 0xFFFFFFFF | |
[..] Any operation of erase should follow these steps: | |
(#) Call the @ref HAL_FLASH_Unlock() function to enable the flash control register and | |
program memory access. | |
(#) Call the desired function to erase page. | |
(#) Call the @ref HAL_FLASH_Lock() to disable the flash program memory access | |
(recommended to protect the FLASH memory against possible unwanted operation). | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Erase the specified FLASH memory Pages | |
* @note To correctly run this function, the @ref HAL_FLASH_Unlock() function | |
* must be called before. | |
* Call the @ref HAL_FLASH_Lock() to disable the flash memory access | |
* (recommended to protect the FLASH memory against possible unwanted operation) | |
* @param[in] pEraseInit pointer to an FLASH_EraseInitTypeDef structure that | |
* contains the configuration information for the erasing. | |
* | |
* @param[out] PageError pointer to variable that | |
* contains the configuration information on faulty page in case of error | |
* (0xFFFFFFFF means that all the pages have been correctly erased) | |
* | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError) | |
{ | |
HAL_StatusTypeDef status = HAL_ERROR; | |
uint32_t address = 0U; | |
/* Process Locked */ | |
__HAL_LOCK(&pFlash); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if (status == HAL_OK) | |
{ | |
/*Initialization of PageError variable*/ | |
*PageError = 0xFFFFFFFFU; | |
/* Check the parameters */ | |
assert_param(IS_NBPAGES(pEraseInit->NbPages)); | |
assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase)); | |
assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress)); | |
assert_param(IS_FLASH_PROGRAM_ADDRESS((pEraseInit->PageAddress & ~(FLASH_PAGE_SIZE - 1U)) + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1U)); | |
/* Erase page by page to be done*/ | |
for(address = pEraseInit->PageAddress; | |
address < ((pEraseInit->NbPages * FLASH_PAGE_SIZE) + pEraseInit->PageAddress); | |
address += FLASH_PAGE_SIZE) | |
{ | |
FLASH_PageErase(address); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
/* If the erase operation is completed, disable the ERASE Bit */ | |
CLEAR_BIT(FLASH->PECR, FLASH_PECR_PROG); | |
CLEAR_BIT(FLASH->PECR, FLASH_PECR_ERASE); | |
if (status != HAL_OK) | |
{ | |
/* In case of error, stop erase procedure and return the faulty address */ | |
*PageError = address; | |
break; | |
} | |
} | |
} | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
/** | |
* @brief Perform a page erase of the specified FLASH memory pages with interrupt enabled | |
* @note To correctly run this function, the @ref HAL_FLASH_Unlock() function | |
* must be called before. | |
* Call the @ref HAL_FLASH_Lock() to disable the flash memory access | |
* (recommended to protect the FLASH memory against possible unwanted operation) | |
* End of erase is done when @ref HAL_FLASH_EndOfOperationCallback is called with parameter | |
* 0xFFFFFFFF | |
* @param pEraseInit pointer to an FLASH_EraseInitTypeDef structure that | |
* contains the configuration information for the erasing. | |
* | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef *pEraseInit) | |
{ | |
HAL_StatusTypeDef status = HAL_ERROR; | |
/* If procedure already ongoing, reject the next one */ | |
if (pFlash.ProcedureOnGoing != FLASH_PROC_NONE) | |
{ | |
return HAL_ERROR; | |
} | |
/* Check the parameters */ | |
assert_param(IS_NBPAGES(pEraseInit->NbPages)); | |
assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase)); | |
assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress)); | |
assert_param(IS_FLASH_PROGRAM_ADDRESS((pEraseInit->PageAddress & ~(FLASH_PAGE_SIZE - 1)) + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1)); | |
/* Process Locked */ | |
__HAL_LOCK(&pFlash); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if (status == HAL_OK) | |
{ | |
/* Enable End of FLASH Operation and Error source interrupts */ | |
__HAL_FLASH_ENABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR); | |
pFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE; | |
pFlash.NbPagesToErase = pEraseInit->NbPages; | |
pFlash.Page = pEraseInit->PageAddress; | |
/*Erase 1st page and wait for IT*/ | |
FLASH_PageErase(pEraseInit->PageAddress); | |
} | |
else | |
{ | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
} | |
return status; | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup FLASHEx_Exported_Functions_Group2 Option Bytes Programming functions | |
* @brief Option Bytes Programming functions | |
* | |
@verbatim | |
============================================================================== | |
##### Option Bytes Programming functions ##### | |
============================================================================== | |
[..] Any operation of erase or program should follow these steps: | |
(#) Call the @ref HAL_FLASH_OB_Unlock() function to enable the Flash option control | |
register access. | |
(#) Call following function to program the desired option bytes. | |
(++) @ref HAL_FLASHEx_OBProgram: | |
- To Enable/Disable the desired sector write protection. | |
- To set the desired read Protection Level. | |
- To configure the user option Bytes: IWDG, STOP and the Standby. | |
- To Set the BOR level. | |
(#) Once all needed option bytes to be programmed are correctly written, call the | |
@ref HAL_FLASH_OB_Launch(void) function to launch the Option Bytes programming process. | |
(#) Call the @ref HAL_FLASH_OB_Lock() to disable the Flash option control register access (recommended | |
to protect the option Bytes against possible unwanted operations). | |
[..] Proprietary code Read Out Protection (PcROP): | |
(#) The PcROP sector is selected by using the same option bytes as the Write | |
protection (nWRPi bits). As a result, these 2 options are exclusive each other. | |
(#) In order to activate the PcROP (change the function of the nWRPi option bits), | |
the WPRMOD option bit must be activated. | |
(#) The active value of nWRPi bits is inverted when PCROP mode is active, this | |
means: if WPRMOD = 1 and nWRPi = 1 (default value), then the user sector "i" | |
is read/write protected. | |
(#) To activate PCROP mode for Flash sector(s), you need to call the following function: | |
(++) @ref HAL_FLASHEx_AdvOBProgram in selecting sectors to be read/write protected | |
(++) @ref HAL_FLASHEx_OB_SelectPCROP to enable the read/write protection | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Program option bytes | |
* @param pOBInit pointer to an FLASH_OBInitStruct structure that | |
* contains the configuration information for the programming. | |
* | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef *pOBInit) | |
{ | |
HAL_StatusTypeDef status = HAL_ERROR; | |
/* Process Locked */ | |
__HAL_LOCK(&pFlash); | |
/* Check the parameters */ | |
assert_param(IS_OPTIONBYTE(pOBInit->OptionType)); | |
/*Write protection configuration*/ | |
if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP) | |
{ | |
assert_param(IS_WRPSTATE(pOBInit->WRPState)); | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
status = FLASH_OB_ProtectedSectorsConfig(pOBInit->WRPSector, pOBInit->WRPSector2, pOBInit->WRPState); | |
#else | |
status = FLASH_OB_ProtectedSectorsConfig(pOBInit->WRPSector, pOBInit->WRPState); | |
#endif | |
if (status != HAL_OK) | |
{ | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
} | |
/* Read protection configuration*/ | |
if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP) | |
{ | |
status = FLASH_OB_RDPConfig(pOBInit->RDPLevel); | |
if (status != HAL_OK) | |
{ | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
} | |
/* USER configuration*/ | |
if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER) | |
{ | |
status = FLASH_OB_UserConfig(pOBInit->USERConfig & OB_IWDG_SW, | |
pOBInit->USERConfig & OB_STOP_NORST, | |
pOBInit->USERConfig & OB_STDBY_NORST); | |
if (status != HAL_OK) | |
{ | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
} | |
/* BOR Level configuration*/ | |
if((pOBInit->OptionType & OPTIONBYTE_BOR) == OPTIONBYTE_BOR) | |
{ | |
status = FLASH_OB_BORConfig(pOBInit->BORLevel); | |
if (status != HAL_OK) | |
{ | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
} | |
/* Program BOOT Bit1 config option byte */ | |
if ((pOBInit->OptionType & OPTIONBYTE_BOOT_BIT1) == OPTIONBYTE_BOOT_BIT1) | |
{ | |
status = FLASH_OB_BOOTBit1Config(pOBInit->BOOTBit1Config); | |
} | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
/** | |
* @brief Get the Option byte configuration | |
* @param pOBInit pointer to an FLASH_OBInitStruct structure that | |
* contains the configuration information for the programming. | |
* | |
* @retval None | |
*/ | |
void HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef *pOBInit) | |
{ | |
pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER | OPTIONBYTE_BOR; | |
/* Get WRP sector */ | |
pOBInit->WRPSector = FLASH_OB_GetWRP(); | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
pOBInit->WRPSector2 = FLASH_OB_GetWRP2(); | |
#endif | |
/*Get RDP Level*/ | |
pOBInit->RDPLevel = FLASH_OB_GetRDP(); | |
/*Get USER*/ | |
pOBInit->USERConfig = FLASH_OB_GetUser(); | |
/*Get BOR Level*/ | |
pOBInit->BORLevel = FLASH_OB_GetBOR(); | |
/* Get BOOT bit 1 config OB */ | |
pOBInit->BOOTBit1Config = FLASH_OB_GetBOOTBit1(); | |
} | |
#if defined(FLASH_OPTR_WPRMOD) || defined(FLASH_OPTR_BFB2) | |
/** | |
* @brief Program option bytes | |
* @param pAdvOBInit pointer to an FLASH_AdvOBProgramInitTypeDef structure that | |
* contains the configuration information for the programming. | |
* | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_AdvOBProgram (FLASH_AdvOBProgramInitTypeDef *pAdvOBInit) | |
{ | |
HAL_StatusTypeDef status = HAL_ERROR; | |
/* Check the parameters */ | |
assert_param(IS_OBEX(pAdvOBInit->OptionType)); | |
#if defined(FLASH_OPTR_WPRMOD) | |
/* Program PCROP option byte*/ | |
if ((pAdvOBInit->OptionType & OPTIONBYTE_PCROP) == OPTIONBYTE_PCROP) | |
{ | |
/* Check the parameters */ | |
assert_param(IS_PCROPSTATE(pAdvOBInit->PCROPState)); | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
status = FLASH_OB_ProtectedSectorsConfig(pAdvOBInit->PCROPSector, pAdvOBInit->PCROPSector2, pAdvOBInit->PCROPState); | |
#else | |
status = FLASH_OB_ProtectedSectorsConfig(pAdvOBInit->PCROPSector, pAdvOBInit->PCROPState); | |
#endif | |
} | |
#endif /* FLASH_OPTR_WPRMOD */ | |
#if defined(FLASH_OPTR_BFB2) | |
/* Program BOOT config option byte */ | |
if ((pAdvOBInit->OptionType & OPTIONBYTE_BOOTCONFIG) == OPTIONBYTE_BOOTCONFIG) | |
{ | |
status = FLASH_OB_BootConfig(pAdvOBInit->BootConfig); | |
} | |
#endif /* FLASH_OPTR_BFB2 */ | |
return status; | |
} | |
/** | |
* @brief Get the OBEX byte configuration | |
* @param pAdvOBInit pointer to an FLASH_AdvOBProgramInitTypeDef structure that | |
* contains the configuration information for the programming. | |
* | |
* @retval None | |
*/ | |
void HAL_FLASHEx_AdvOBGetConfig(FLASH_AdvOBProgramInitTypeDef *pAdvOBInit) | |
{ | |
pAdvOBInit->OptionType = 0; | |
#if defined(FLASH_OPTR_WPRMOD) | |
pAdvOBInit->OptionType |= OPTIONBYTE_PCROP; | |
/* Get PCROP state */ | |
pAdvOBInit->PCROPState = (FLASH->OPTR & FLASH_OPTR_WPRMOD) >> FLASH_OPTR_WPRMOD_Pos; | |
/* Get PCROP protected sector */ | |
pAdvOBInit->PCROPSector = FLASH->WRPR; | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
/* Get PCROP protected sector */ | |
pAdvOBInit->PCROPSector2 = FLASH->WRPR2; | |
#endif | |
#endif /* FLASH_OPTR_WPRMOD */ | |
#if defined(FLASH_OPTR_BFB2) | |
pAdvOBInit->OptionType |= OPTIONBYTE_BOOTCONFIG; | |
/* Get Boot config OB */ | |
pAdvOBInit->BootConfig = (FLASH->OPTR & FLASH_OPTR_BFB2) >> 16U; | |
#endif /* FLASH_OPTR_BFB2 */ | |
} | |
#endif /* FLASH_OPTR_WPRMOD || FLASH_OPTR_BFB2 */ | |
#if defined(FLASH_OPTR_WPRMOD) | |
/** | |
* @brief Select the Protection Mode (WPRMOD). | |
* @note Once WPRMOD bit is active, unprotection of a protected sector is not possible | |
* @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_OB_SelectPCROP(void) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint16_t tmp1 = 0; | |
uint32_t tmp2 = 0; | |
uint8_t optiontmp = 0; | |
uint16_t optiontmp2 = 0; | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
/* Mask RDP Byte */ | |
optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE)); | |
/* Update Option Byte */ | |
optiontmp2 = (uint16_t)(OB_PCROP_SELECTED | optiontmp); | |
/* calculate the option byte to write */ | |
tmp1 = (uint16_t)(~(optiontmp2 )); | |
tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16U)) | ((uint32_t)optiontmp2)); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* program PCRop */ | |
OB->RDP = tmp2; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the Read protection operation Status */ | |
return status; | |
} | |
/** | |
* @brief Deselect the Protection Mode (WPRMOD). | |
* @note Once WPRMOD bit is active, unprotection of a protected sector is not possible | |
* @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_OB_DeSelectPCROP(void) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint16_t tmp1 = 0; | |
uint32_t tmp2 = 0; | |
uint8_t optiontmp = 0; | |
uint16_t optiontmp2 = 0; | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
/* Mask RDP Byte */ | |
optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE)); | |
/* Update Option Byte */ | |
optiontmp2 = (uint16_t)(OB_PCROP_DESELECTED | optiontmp); | |
/* calculate the option byte to write */ | |
tmp1 = (uint16_t)(~(optiontmp2 )); | |
tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16U)) | ((uint32_t)optiontmp2)); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* program PCRop */ | |
OB->RDP = tmp2; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the Read protection operation Status */ | |
return status; | |
} | |
#endif /* FLASH_OPTR_WPRMOD */ | |
/** | |
* @} | |
*/ | |
/** @defgroup FLASHEx_Exported_Functions_Group3 DATA EEPROM Programming functions | |
* @brief DATA EEPROM Programming functions | |
* | |
@verbatim | |
=============================================================================== | |
##### DATA EEPROM Programming functions ##### | |
=============================================================================== | |
[..] Any operation of erase or program should follow these steps: | |
(#) Call the @ref HAL_FLASHEx_DATAEEPROM_Unlock() function to enable the data EEPROM access | |
and Flash program erase control register access. | |
(#) Call the desired function to erase or program data. | |
(#) Call the @ref HAL_FLASHEx_DATAEEPROM_Lock() to disable the data EEPROM access | |
and Flash program erase control register access(recommended | |
to protect the DATA_EEPROM against possible unwanted operation). | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Unlocks the data memory and FLASH_PECR register access. | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Unlock(void) | |
{ | |
if((FLASH->PECR & FLASH_PECR_PELOCK) != RESET) | |
{ | |
/* Unlocking the Data memory and FLASH_PECR register access*/ | |
FLASH->PEKEYR = FLASH_PEKEY1; | |
FLASH->PEKEYR = FLASH_PEKEY2; | |
} | |
else | |
{ | |
return HAL_ERROR; | |
} | |
return HAL_OK; | |
} | |
/** | |
* @brief Locks the Data memory and FLASH_PECR register access. | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Lock(void) | |
{ | |
/* Set the PELOCK Bit to lock the data memory and FLASH_PECR register access */ | |
SET_BIT(FLASH->PECR, FLASH_PECR_PELOCK); | |
return HAL_OK; | |
} | |
/** | |
* @brief Erase a word in data memory. | |
* @param Address specifies the address to be erased. | |
* @note To correctly run this function, the @ref HAL_FLASHEx_DATAEEPROM_Unlock() function | |
* must be called before. | |
* Call the @ref HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access | |
* and Flash program erase control register access(recommended to protect | |
* the DATA_EEPROM against possible unwanted operation). | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check the parameters */ | |
assert_param(IS_FLASH_DATA_ADDRESS(Address)); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Write 00000000h to valid address in the data memory */ | |
*(__IO uint32_t *) Address = 0x00000000U; | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the erase status */ | |
return status; | |
} | |
/** | |
* @brief Program word at a specified address | |
* @note To correctly run this function, the @ref HAL_FLASHEx_DATAEEPROM_Unlock() function | |
* must be called before. | |
* Call the @ref HAL_FLASHEx_DATAEEPROM_Unlock() to he data EEPROM access | |
* and Flash program erase control register access(recommended to protect | |
* the DATA_EEPROM against possible unwanted operation). | |
* @note The function @ref HAL_FLASHEx_DATAEEPROM_EnableFixedTimeProgram() can be called before | |
* this function to configure the Fixed Time Programming. | |
* @param TypeProgram Indicate the way to program at a specified address. | |
* This parameter can be a value of @ref FLASHEx_Type_Program_Data | |
* @param Address specifie the address to be programmed. | |
* @param Data specifie the data to be programmed | |
* | |
* @retval HAL_StatusTypeDef HAL Status | |
*/ | |
HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data) | |
{ | |
HAL_StatusTypeDef status = HAL_ERROR; | |
/* Process Locked */ | |
__HAL_LOCK(&pFlash); | |
/* Check the parameters */ | |
assert_param(IS_TYPEPROGRAMDATA(TypeProgram)); | |
assert_param(IS_FLASH_DATA_ADDRESS(Address)); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
if(TypeProgram == FLASH_TYPEPROGRAMDATA_WORD) | |
{ | |
/* Program word (32-bit) at a specified address.*/ | |
*(__IO uint32_t *)Address = Data; | |
} | |
else if(TypeProgram == FLASH_TYPEPROGRAMDATA_HALFWORD) | |
{ | |
/* Program halfword (16-bit) at a specified address.*/ | |
*(__IO uint16_t *)Address = (uint16_t) Data; | |
} | |
else if(TypeProgram == FLASH_TYPEPROGRAMDATA_BYTE) | |
{ | |
/* Program byte (8-bit) at a specified address.*/ | |
*(__IO uint8_t *)Address = (uint8_t) Data; | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
if (status != HAL_OK) | |
{ | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
} | |
/* Process Unlocked */ | |
__HAL_UNLOCK(&pFlash); | |
return status; | |
} | |
/** | |
* @brief Enable DATA EEPROM fixed Time programming (2*Tprog). | |
* @retval None | |
*/ | |
void HAL_FLASHEx_DATAEEPROM_EnableFixedTimeProgram(void) | |
{ | |
SET_BIT(FLASH->PECR, FLASH_PECR_FIX); | |
} | |
/** | |
* @brief Disables DATA EEPROM fixed Time programming (2*Tprog). | |
* @retval None | |
*/ | |
void HAL_FLASHEx_DATAEEPROM_DisableFixedTimeProgram(void) | |
{ | |
CLEAR_BIT(FLASH->PECR, FLASH_PECR_FIX); | |
} | |
/** | |
* @} | |
*/ | |
/** | |
* @} | |
*/ | |
/** @addtogroup FLASHEx_Private_Functions | |
* @{ | |
*/ | |
/* | |
============================================================================== | |
OPTIONS BYTES | |
============================================================================== | |
*/ | |
/** | |
* @brief Enables or disables the read out protection. | |
* @note To correctly run this function, the @ref HAL_FLASH_OB_Unlock() function | |
* must be called before. | |
* @param OB_RDP specifies the read protection level. | |
* This parameter can be: | |
* @arg @ref OB_RDP_LEVEL_0 No protection | |
* @arg @ref OB_RDP_LEVEL_1 Read protection of the memory | |
* @arg @ref OB_RDP_LEVEL_2 Chip protection | |
* | |
* !!!Warning!!! When enabling OB_RDP_LEVEL_2 it's no more possible to go back to level 1 or 0 | |
* | |
* @retval HAL status | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t tmp1 = 0U, tmp2 = 0U, tmp3 = 0U; | |
/* Check the parameters */ | |
assert_param(IS_OB_RDP(OB_RDP)); | |
tmp1 = (uint32_t)(OB->RDP & FLASH_OPTR_RDPROT); | |
#if defined(FLASH_OPTR_WPRMOD) | |
/* Mask WPRMOD bit */ | |
tmp3 = (uint32_t)(OB->RDP & FLASH_OPTR_WPRMOD); | |
#endif | |
/* calculate the option byte to write */ | |
tmp1 = (~((uint32_t)(OB_RDP | tmp3))); | |
tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16U)) | ((uint32_t)(OB_RDP | tmp3))); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* program read protection level */ | |
OB->RDP = tmp2; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the Read protection operation Status */ | |
return status; | |
} | |
/** | |
* @brief Programs the FLASH brownout reset threshold level Option Byte. | |
* @param OB_BOR Selects the brownout reset threshold level. | |
* This parameter can be one of the following values: | |
* @arg @ref OB_BOR_OFF BOR is disabled at power down, the reset is asserted when the VDD | |
* power supply reaches the PDR(Power Down Reset) threshold (1.5V) | |
* @arg @ref OB_BOR_LEVEL1 BOR Reset threshold levels for 1.7V - 1.8V VDD power supply | |
* @arg @ref OB_BOR_LEVEL2 BOR Reset threshold levels for 1.9V - 2.0V VDD power supply | |
* @arg @ref OB_BOR_LEVEL3 BOR Reset threshold levels for 2.3V - 2.4V VDD power supply | |
* @arg @ref OB_BOR_LEVEL4 BOR Reset threshold levels for 2.55V - 2.65V VDD power supply | |
* @arg @ref OB_BOR_LEVEL5 BOR Reset threshold levels for 2.8V - 2.9V VDD power supply | |
* @retval HAL status | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t tmp = 0, tmp1 = 0; | |
/* Check the parameters */ | |
assert_param(IS_OB_BOR_LEVEL(OB_BOR)); | |
/* Get the User Option byte register */ | |
tmp1 = OB->USER & ((~FLASH_OPTR_BOR_LEV) >> 16U); | |
/* Calculate the option byte to write - [0xFF | nUSER | 0x00 | USER]*/ | |
tmp = (uint32_t)~((OB_BOR | tmp1)) << 16U; | |
tmp |= (OB_BOR | tmp1); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Write the BOR Option Byte */ | |
OB->USER = tmp; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the Option Byte BOR programmation Status */ | |
return status; | |
} | |
/** | |
* @brief Sets or resets the BOOT bit1 option bit. | |
* @param OB_BootBit1 Set or Reset the BOOT bit1 option bit. | |
* This parameter can be one of the following values: | |
* @arg @ref OB_BOOT_BIT1_RESET BOOT1 option bit reset | |
* @arg @ref OB_BOOT_BIT1_SET BOOT1 option bit set | |
* @retval HAL status | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_BOOTBit1Config(uint8_t OB_BootBit1) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) OB_BootBit1) << 15; | |
/* Check the parameters */ | |
assert_param(IS_OB_BOOT1(OB_BootBit1)); | |
/* Get the User Option byte register */ | |
tmp1 = OB->USER & ((~FLASH_OPTR_BOOT1) >> 16U); | |
/* Calculate the user option byte to write */ | |
tmp = (~(OB_Bits | tmp1)) << 16U; | |
tmp |= OB_Bits | tmp1; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Program OB */ | |
OB->USER = tmp; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
return status; | |
} | |
/** | |
* @brief Returns the FLASH User Option Bytes values. | |
* @retval The FLASH User Option Bytes. | |
*/ | |
static uint8_t FLASH_OB_GetUser(void) | |
{ | |
/* Return the User Option Byte */ | |
return (uint8_t)((FLASH->OPTR & FLASH_OPTR_USER) >> 16U); | |
} | |
/** | |
* @brief Returns the FLASH Read Protection level. | |
* @retval FLASH RDP level | |
* This parameter can be one of the following values: | |
* @arg @ref OB_RDP_LEVEL_0 No protection | |
* @arg @ref OB_RDP_LEVEL_1 Read protection of the memory | |
* @arg @ref OB_RDP_LEVEL_2 Full chip protection | |
*/ | |
static uint8_t FLASH_OB_GetRDP(void) | |
{ | |
return (uint8_t)(FLASH->OPTR & FLASH_OPTR_RDPROT); | |
} | |
/** | |
* @brief Returns the FLASH BOR level. | |
* @retval The BOR level Option Bytes. | |
*/ | |
static uint8_t FLASH_OB_GetBOR(void) | |
{ | |
/* Return the BOR level */ | |
return (uint8_t)((FLASH->OPTR & (uint32_t)FLASH_OPTR_BOR_LEV) >> 16U); | |
} | |
/** | |
* @brief Returns the FLASH BOOT bit1 value. | |
* @retval The BOOT bit 1 value Option Bytes. | |
*/ | |
static uint8_t FLASH_OB_GetBOOTBit1(void) | |
{ | |
/* Return the BOR level */ | |
return (FLASH->OPTR & FLASH_OPTR_BOOT1) >> FLASH_OPTR_BOOT1_Pos; | |
} | |
/** | |
* @brief Returns the FLASH Write Protection Option Bytes value. | |
* @retval The FLASH Write Protection Option Bytes value. | |
*/ | |
static uint32_t FLASH_OB_GetWRP(void) | |
{ | |
/* Return the FLASH write protection Register value */ | |
return (uint32_t)(FLASH->WRPR); | |
} | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
/** | |
* @brief Returns the FLASH Write Protection Option Bytes value. | |
* @retval The FLASH Write Protection Option Bytes value. | |
*/ | |
static uint32_t FLASH_OB_GetWRP2(void) | |
{ | |
/* Return the FLASH write protection Register value */ | |
return (uint32_t)(FLASH->WRPR2); | |
} | |
#endif /* STM32L071xx || STM32L072xx || STM32L073xx || STM32L081xx || STM32L082xx || STM32L083xx */ | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
/** | |
* @brief Write Option Byte of the desired pages of the Flash. | |
* @param Sector specifies the sectors to be write protected. | |
* @param Sector2 specifies the sectors to be write protected (only stm32l07xxx and stm32l08xxx devices) | |
* @param NewState new state of the specified FLASH Pages Write protection. | |
* This parameter can be: | |
* @arg @ref OB_WRPSTATE_ENABLE | |
* @arg @ref OB_WRPSTATE_DISABLE | |
* @retval HAL_StatusTypeDef | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t Sector2, uint32_t NewState) | |
#else | |
/** | |
* @brief Write Option Byte of the desired pages of the Flash. | |
* @param Sector specifies the sectors to be write protected. | |
* @param NewState new state of the specified FLASH Pages Write protection. | |
* This parameter can be: | |
* @arg @ref OB_WRPSTATE_ENABLE | |
* @arg @ref OB_WRPSTATE_DISABLE | |
* @retval HAL_StatusTypeDef | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t NewState) | |
#endif | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t WRP_Data = 0; | |
uint32_t OB_WRP = Sector; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Update WRP only if at least 1 selected sector */ | |
if (OB_WRP != 0x00000000U) | |
{ | |
if ((OB_WRP & WRP_MASK_LOW) != 0x00000000U) | |
{ | |
if (NewState != OB_WRPSTATE_DISABLE) | |
{ | |
WRP_Data = (uint16_t)(((OB_WRP & WRP_MASK_LOW) | OB->WRP01)); | |
OB->WRP01 = (uint32_t)(~(WRP_Data) << 16U) | (WRP_Data); | |
} | |
else | |
{ | |
WRP_Data = (uint16_t)(~OB_WRP & (WRP_MASK_LOW & OB->WRP01)); | |
OB->WRP01 = (uint32_t)((~WRP_Data) << 16U) | (WRP_Data); | |
} | |
} | |
} | |
#if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) | |
/* Update WRP only if at least 1 selected sector */ | |
if (OB_WRP != 0x00000000U) | |
{ | |
if ((OB_WRP & WRP_MASK_HIGH) != 0x00000000U) | |
{ | |
if (NewState != OB_WRPSTATE_DISABLE) | |
{ | |
WRP_Data = (uint16_t)((((OB_WRP & WRP_MASK_HIGH) >> 16U | OB->WRP23))); | |
OB->WRP23 = (uint32_t)(~(WRP_Data) << 16U) | (WRP_Data); | |
} | |
else | |
{ | |
WRP_Data = (uint16_t)((((~OB_WRP & WRP_MASK_HIGH) >> 16U & OB->WRP23))); | |
OB->WRP23 = (uint32_t)((~WRP_Data) << 16U) | (WRP_Data); | |
} | |
} | |
} | |
OB_WRP = Sector2; | |
/* Update WRP only if at least 1 selected sector */ | |
if (OB_WRP != 0x00000000U) | |
{ | |
if ((OB_WRP & WRP_MASK_LOW) != 0x00000000U) | |
{ | |
if (NewState != OB_WRPSTATE_DISABLE) | |
{ | |
WRP_Data = (uint16_t)(((OB_WRP & WRP_MASK_LOW) | OB->WRP45)); | |
OB->WRP45 =(uint32_t)(~(WRP_Data) << 16U) | (WRP_Data); | |
} | |
else | |
{ | |
WRP_Data = (uint16_t)(~OB_WRP & (WRP_MASK_LOW & OB->WRP45)); | |
OB->WRP45 = (uint32_t)((~WRP_Data) << 16U) | (WRP_Data); | |
} | |
} | |
} | |
#endif /* STM32L071xx || STM32L072xx || STM32L073xx || STM32L081xx || STM32L082xx || STM32L083xx */ | |
} | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
/* Return the write protection operation Status */ | |
return status; | |
} | |
/** | |
* @brief Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY. | |
* @param OB_IWDG Selects the WDG mode. | |
* This parameter can be one of the following values: | |
* @arg @ref OB_IWDG_SW Software WDG selected | |
* @arg @ref OB_IWDG_HW Hardware WDG selected | |
* @param OB_STOP Reset event when entering STOP mode. | |
* This parameter can be one of the following values: | |
* @arg @ref OB_STOP_NORST No reset generated when entering in STOP | |
* @arg @ref OB_STOP_RST Reset generated when entering in STOP | |
* @param OB_STDBY Reset event when entering Standby mode. | |
* This parameter can be one of the following values: | |
* @arg @ref OB_STDBY_NORST No reset generated when entering in STANDBY | |
* @arg @ref OB_STDBY_RST Reset generated when entering in STANDBY | |
* @retval HAL status | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t tmp = 0, tmp1 = 0; | |
/* Check the parameters */ | |
assert_param(IS_OB_IWDG_SOURCE(OB_IWDG)); | |
assert_param(IS_OB_STOP_SOURCE(OB_STOP)); | |
assert_param(IS_OB_STDBY_SOURCE(OB_STDBY)); | |
/* Get the User Option byte register */ | |
tmp1 = OB->USER & ((~FLASH_OPTR_USER) >> 16U); | |
/* Calculate the user option byte to write */ | |
tmp = (uint32_t)(((uint32_t)~((uint32_t)((uint32_t)(OB_IWDG) | (uint32_t)(OB_STOP) | (uint32_t)(OB_STDBY) | tmp1))) << 16U); | |
tmp |= ((uint32_t)(OB_IWDG) | ((uint32_t)OB_STOP) | (uint32_t)(OB_STDBY) | tmp1); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Write the User Option Byte */ | |
OB->USER = tmp; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the Option Byte program Status */ | |
return status; | |
} | |
#if defined(FLASH_OPTR_BFB2) | |
/** | |
* @brief Configures to boot from Bank1 or Bank2. | |
* @param OB_BOOT select the FLASH Bank to boot from. | |
* This parameter can be one of the following values: | |
* This parameter can be one of the following values: | |
* @arg @ref OB_BOOT_BANK1 BFB2 option bit reset | |
* @arg @ref OB_BOOT_BANK2 BFB2 option bit set | |
* @retval HAL status | |
*/ | |
static HAL_StatusTypeDef FLASH_OB_BootConfig(uint8_t OB_BOOT) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t tmp = 0U, tmp1 = 0U; | |
/* Check the parameters */ | |
assert_param(IS_OB_BOOT_BANK(OB_BOOT)); | |
/* Get the User Option byte register and BOR Level*/ | |
tmp1 = OB->USER & ((~FLASH_OPTR_BFB2) >> 16U); | |
/* Calculate the option byte to write */ | |
tmp = (uint32_t)~(OB_BOOT | tmp1) << 16U; | |
tmp |= (OB_BOOT | tmp1); | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
if(status == HAL_OK) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Write the BOOT Option Byte */ | |
OB->USER = tmp; | |
/* Wait for last operation to be completed */ | |
status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); | |
} | |
/* Return the Option Byte program Status */ | |
return status; | |
} | |
#endif /* FLASH_OPTR_BFB2 */ | |
/** | |
* @} | |
*/ | |
/** | |
* @} | |
*/ | |
/** @addtogroup FLASH | |
* @{ | |
*/ | |
/** @addtogroup FLASH_Private_Functions | |
* @{ | |
*/ | |
/** | |
* @brief Erases a specified page in program memory. | |
* @param PageAddress The page address in program memory to be erased. | |
* @note A Page is erased in the Program memory only if the address to load | |
* is the start address of a page (multiple of @ref FLASH_PAGE_SIZE bytes). | |
* @retval None | |
*/ | |
void FLASH_PageErase(uint32_t PageAddress) | |
{ | |
/* Clean the error context */ | |
pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; | |
/* Set the ERASE bit */ | |
SET_BIT(FLASH->PECR, FLASH_PECR_ERASE); | |
/* Set PROG bit */ | |
SET_BIT(FLASH->PECR, FLASH_PECR_PROG); | |
/* Write 00000000h to the first word of the program page to erase */ | |
*(__IO uint32_t *)(uint32_t)(PageAddress & ~(FLASH_PAGE_SIZE - 1)) = 0x00000000; | |
} | |
/** | |
* @} | |
*/ | |
/** | |
* @} | |
*/ | |
#endif /* HAL_FLASH_MODULE_ENABLED */ | |
/** | |
* @} | |
*/ | |
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |