/** ****************************************************************************** * @file stm32l0xx_hal_flash_ex.c * @author MCD Application Team * @version V1.2.0 * @date 06-February-2015 * @brief 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 sectors @endverbatim ****************************************************************************** * @attention * *

© COPYRIGHT(c) 2015 STMicroelectronics

* * 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 * @{ */ /** @addtogroup FLASHEx * @brief FLASH HAL Extension module driver * @{ */ #ifdef HAL_FLASH_MODULE_ENABLED /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP); static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR); static uint8_t FLASH_OB_GetUser(void); static uint8_t FLASH_OB_GetRDP(void); static uint8_t FLASH_OB_GetBOR(void); static uint8_t FLASH_OB_GetBOOTBit1(void); #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 HAL_StatusTypeDef FLASH_OB_PCROPSelectionConfig(uint32_t WPRMOD); 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 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY); static HAL_StatusTypeDef FLASH_OB_BOOTBit1Config(uint8_t OB_BOOT_Bit1); #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) static HAL_StatusTypeDef FLASH_OB_BFB2Config(uint8_t OB_BFB2); #endif /* Exported functions ---------------------------------------------------------*/ /** @addtogroup FLASHEx_Exported_Functions * @{ */ /** @addtogroup FLASHEx_Exported_Functions_Group1 * @brief FLASH Memory Erasing functions * @verbatim ============================================================================== ##### FLASH Erasing Programming functions ##### ============================================================================== [..] The FLASH Memory Erasing functions, includes the following functions: (+) HAL_FLASHEx_Erase: return only when erase has been done (+) HAL_FLASHEx_Erase_IT: end of erase is done when HAL_FLASH_EndOfOperationCallback is called with parameter 0xFFFFFFFF [..] Any operation of erase should follow these steps: (#) Call the HAL_FLASH_Unlock() function to enable the flash control register and program memory access. (#) Call the desired function to erase page. (#) Call the 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 HAL_FLASH_Unlock() function * must be called before. * Call the 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 sector in case of error * (0xFFFFFFFF means that all the sectors 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 index = 0; /* Process Locked */ __HAL_LOCK(&ProcFlash); /* Wait for last operation to be completed */ status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); if (status == HAL_OK) { /* Clean the error context */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; /*Initialization of PageError variable*/ *PageError = 0xFFFFFFFF; /* 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 + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1)); /* Erase by sector by sector to be done*/ for(index = pEraseInit->PageAddress; index < ((pEraseInit->NbPages * FLASH_PAGE_SIZE)+ pEraseInit->PageAddress); index += FLASH_PAGE_SIZE) { FLASH_ErasePage(index); /* 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 sector*/ *PageError = index; break; } } } /* Process Unlocked */ __HAL_UNLOCK(&ProcFlash); return status; } /** * @brief Perform a page erase of the specified FLASH memory pages with interrupt enabled * @note To correctly run this function, the HAL_FLASH_Unlock() function * must be called before. * Call the 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 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_OK; /* Process Locked */ __HAL_LOCK(&ProcFlash); /* Enable End of FLASH Operation interrupt */ __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP); /* Enable Error source interrupt */ __HAL_FLASH_ENABLE_IT(FLASH_IT_ERR); /* 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 + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1)); /* Clean the error context */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; ProcFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE; ProcFlash.NbPagesToErase = pEraseInit->NbPages; ProcFlash.Page = pEraseInit->PageAddress; /* Erase 1st page and wait for IT */ FLASH_ErasePage(pEraseInit->PageAddress); return status; } /** * @} */ /** @addtogroup FLASHEx_Exported_Functions_Group2 * @brief Option Bytes Programming functions * @verbatim ============================================================================== ##### Option Bytes Programming functions ##### ============================================================================== [..] Any operation of erase or program should follow these steps: (#) Call the HAL_FLASH_OB_Unlock() function to enable the Flash option control register access. (#) Call following function to program the desired option bytes. (++) 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 HAL_FLASH_OB_Launch(void) function to launch the Option Bytes programming process. (#) Call the 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: (++) HAL_FLASHEx_AdvOBProgram in selecting sectors to be read/write protected (++) 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(&ProcFlash); /* 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(&ProcFlash); 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(&ProcFlash); 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(&ProcFlash); return status; } } /* BOR Level configuration */ if((pOBInit->OptionType & OPTIONBYTE_BOR) == OPTIONBYTE_BOR) { status = FLASH_OB_BORConfig(pOBInit->BORLevel); } /* 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(&ProcFlash); 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(); } /** * @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)); /* 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 } #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) if ((pAdvOBInit->OptionType & OPTIONBYTE_BOOTCONFIG) == OPTIONBYTE_BOOTCONFIG) { status = FLASH_OB_BFB2Config(pAdvOBInit->BootConfig); } #endif 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) { #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) pAdvOBInit->OptionType = OPTIONBYTE_PCROP| OPTIONBYTE_BOOTCONFIG; #else pAdvOBInit->OptionType = OPTIONBYTE_PCROP; #endif /* Get PCROP state */ pAdvOBInit->PCROPState = (FLASH->OPTR & FLASH_OPTR_WPRMOD) >> 8; /* 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; /* Get boot bank config */ pAdvOBInit->BootConfig = (FLASH->OPTR & FLASH_OPTR_BFB2) >> 23; #endif } /** * @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 * @param None * @retval HAL status */ HAL_StatusTypeDef HAL_FLASHEx_OB_SelectPCROP(void) { return (FLASH_OB_PCROPSelectionConfig(1)); } /** * @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 * @param None * @retval HAL status */ HAL_StatusTypeDef HAL_FLASHEx_OB_DeSelectPCROP(void) { return (FLASH_OB_PCROPSelectionConfig(0)); } /** * @} */ /** @addtogroup FLASHEx_Exported_Functions_Group3 * @brief DATA EEPROM Programming functions * @verbatim =============================================================================== ##### DATA EEPROM Programming functions ##### =============================================================================== [..] The FLASH_DATAEEPROM Programming_Functions, includes the following functions: (+) HAL_FLASHEx_DATAEEPROM_Unlock(void); (+) HAL_FLASHEx_DATAEEPROM_Lock(void); (+) HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address) (+) HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data) [..] Any operation of erase or program should follow these steps: (#) Call the 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 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. * @param None * @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; return HAL_OK; } else { return HAL_ERROR; } } /** * @brief Locks the Data memory and FLASH_PECR register access. * @param None * @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 HAL_FLASHEx_DATAEEPROM_Unlock() function * must be called before. * Call the 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 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 */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; /* Write "00000000h" to valid address in the data memory" */ *(__IO uint32_t *) Address = 0x00000000; } return status; } /** * @brief Program word at a specified address * @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: specifies the address to be programmed. * @param Data: specifies 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(&ProcFlash); /* 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 */ ProcFlash.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 word (16-bit) at a specified address */ *(__IO uint16_t *)Address = (uint16_t) Data; } else if(TypeProgram == FLASH_TYPEPROGRAMDATA_BYTE) { /*Program word (8-bit) at a specified address */ *(__IO uint8_t *)Address = (uint8_t) Data; } else { status = HAL_ERROR; } /* Wait for last operation to be completed */ status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); } /* Process Unlocked */ __HAL_UNLOCK(&ProcFlash); 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); } /** * @} */ /** * @brief Returns the FLASH User Option Bytes values. * @param None * @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) >> 16); } /** * @brief Returns the FLASH Read out Protection Level. * @param None * @retval FLASH RDP level. */ static uint8_t FLASH_OB_GetRDP(void) { return (uint8_t)(FLASH->OPTR & FLASH_OPTR_RDPROT); } /** * @brief Returns the FLASH BOR level. * @param None * @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) >> 16); } /** * @brief Returns the FLASH BOOT bit1 value. * @param None * @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) >> 31; } /** * @brief Returns the FLASH Write Protection Option Bytes value. * @param None * @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. * @param None * @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 */ /** * @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 OB_IWDG_SW: Software WDG selected * @arg 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 OB_STOP_NoRST: No reset generated when entering in STOP * @arg 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 OB_STDBY_NORST: No reset generated when entering in STANDBY * @arg 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, OB_Bits = (uint32_t) (OB_IWDG | OB_STOP | OB_STDBY); /* 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)); /* Clean the error context */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; /* Get the User Option byte register */ tmp1 = OB->USER & ((~FLASH_OPTR_USER) >> 16); /* Calculate the user option byte to write */ tmp = (~(OB_Bits | tmp1)) << 16; 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 */ ProcFlash.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 Enables or disables the read out protection. * @note To correctly run this function, the FLASH_OB_Unlock() function * must be called before. * @param OB_RDP: specifies the read protection level. * This parameter can be: * @arg OB_RDP_LEVEL0: No protection * @arg OB_RDP_LEVEL1: Read protection of the memory * @arg OB_RDP_LEVEL2: Chip protection * * !!!Warning!!! When enabling OB_RDP_LEVEL2 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; uint32_t tmp = 0, tmp1 = 0, OB_Bits = (uint32_t) OB_RDP; /* Check the parameters */ assert_param(IS_OB_RDP(OB_RDP)); /* Calculate the option byte to write */ tmp = (OB->RDP & ((~FLASH_OPTR_RDPROT) & 0x0000FFFF)) | OB_Bits; tmp1 = (~tmp << 16) | tmp; /* Wait for last operation to be completed */ status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); if(status == HAL_OK) { /* Clean the error context */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; /* Program OB */ OB->RDP = tmp1; /* Wait for last operation to be completed */ status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); } 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 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 OB_BOR_LEVEL1: BOR Reset threshold levels for 1.7V - 1.8V VDD power supply * @arg OB_BOR_LEVEL2: BOR Reset threshold levels for 1.9V - 2.0V VDD power supply * @arg OB_BOR_LEVEL3: BOR Reset threshold levels for 2.3V - 2.4V VDD power supply * @arg OB_BOR_LEVEL4: BOR Reset threshold levels for 2.55V - 2.65V VDD power supply * @arg 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, OB_Bits = (uint32_t) OB_BOR; /* Check the parameters */ assert_param(IS_OB_BOR_LEVEL(OB_BOR)); /* Get the User Option byte register */ tmp1 = OB->USER & ((~FLASH_OPTR_BOR_LEV) >> 16); /* Calculate the user option byte to write */ tmp = (~(OB_Bits | tmp1)) << 16; 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 */ ProcFlash.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 Sets or resets the BOOT bit1 option bit. * @param OB_BOOT_BIT1: Set or Reset the BOOT bit1 option bit. * This parameter can be one of the following values: * @arg OB_BOOT_BIT1_RESET: BOOT1 option bit reset * @arg OB_BOOT_BIT1_SET: BOOT1 option bit set * @retval HAL status */ static HAL_StatusTypeDef FLASH_OB_BOOTBit1Config(uint8_t OB_BOOT_BIT1) { HAL_StatusTypeDef status = HAL_OK; uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) OB_BOOT_BIT1) << 15; /* Check the parameters */ assert_param(IS_OB_BOOT1(OB_BOOT_BIT1)); /* Get the User Option byte register */ tmp1 = OB->USER & ((~FLASH_OPTR_BOOT1) >> 16); /* Calculate the user option byte to write */ tmp = (~(OB_Bits | tmp1)) << 16; 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 */ ProcFlash.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 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 * @param OB_PcROP: Select the Protection Mode of WPR bits. * This parameter can be: * @arg OB_PCROP_SELECTED: nWRP control the read&write protection (PcROP) of respective user sectors. * @arg OB_PCROP_DESELECTED: nWRP control the write protection of respective user sectors. * @retval HAL status */ static HAL_StatusTypeDef FLASH_OB_PCROPSelectionConfig(uint32_t WPRMOD) { HAL_StatusTypeDef status; uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) WPRMOD) << 8; /* Get the User Option byte register */ tmp1 = OB->USER & ((~FLASH_OPTR_WPRMOD) >> 16); /* Calculate the user option byte to write */ tmp = (~(OB_Bits | tmp1)) << 16; 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 */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; /* Program OB */ OB->RDP = tmp; /* Wait for last operation to be completed */ status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); } return status; } #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) /** * @brief Sets or resets the BFB2 option bit. * @param BFB2: Set or Reset the BFB2 option bit. * This parameter can be one of the following values: * @arg OB_BOOT_BANK1: BFB2 option bit reset * @arg OB_BOOT_BANK2: BFB2 option bit set * @retval None */ static HAL_StatusTypeDef FLASH_OB_BFB2Config(uint8_t OB_BFB2) { HAL_StatusTypeDef status = HAL_OK; uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) OB_BFB2) << 7; /* Check the parameters */ assert_param(IS_OB_BOOT_BANK(OB_BFB2)); /* Get the User Option byte register */ tmp1 = OB->USER & ((~FLASH_OPTR_BFB2) >> 16); /* Calculate the user option byte to write */ tmp = (~(OB_Bits | tmp1)) << 16; 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 */ ProcFlash.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; } #endif /** * @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 Wite protection. * This parameter can be: ENABLE or DISABLE. * @retval HAL_StatusTypeDef */ #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 { HAL_StatusTypeDef status = HAL_OK; uint32_t WRP_Data = 0; uint32_t OB_WRP = Sector; /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Wait for last operation to be completed */ status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); if(status == HAL_OK) { /* Clean the error context */ ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE; if (OB_WRP & 0x0000FFFF) { if (NewState != OB_WRPSTATE_DISABLE) { WRP_Data = (uint16_t)(((OB_WRP & WRP_MASK_LOW) | OB->WRP01)); OB->WRP01 = (uint32_t)(~(WRP_Data) << 16) | (WRP_Data); } else { WRP_Data = (uint16_t)(~OB_WRP & (WRP_MASK_LOW & OB->WRP01)); OB->WRP01 = (uint32_t)((~WRP_Data) << 16) | (WRP_Data); } } #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx) if (OB_WRP & 0xFFFF0000) { if (NewState != OB_WRPSTATE_DISABLE) { WRP_Data = (uint16_t)((((OB_WRP & WRP_MASK_HIGH) >> 16 | OB->WRP23))); OB->WRP23 = (uint32_t)(~(WRP_Data) << 16) | (WRP_Data); } else { WRP_Data = (uint16_t)((((~OB_WRP & WRP_MASK_HIGH) >> 16 & OB->WRP23))); OB->WRP23 = (uint32_t)((~WRP_Data) << 16) | (WRP_Data); } } OB_WRP = Sector2; if (OB_WRP & 0x0000FFFF) { if (NewState != OB_WRPSTATE_DISABLE) { WRP_Data = (uint16_t)(((OB_WRP & WRP_MASK_LOW) | OB->WRP45)); OB->WRP45 =(uint32_t)(~(WRP_Data) << 16) | (WRP_Data); } else { WRP_Data = (uint16_t)(~OB_WRP & (WRP_MASK_LOW & OB->WRP45)); OB->WRP45 = (uint32_t)((~WRP_Data) << 16) | (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; } /** * @} */ #endif /* HAL_FLASH_MODULE_ENABLED */ /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/