mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_flash_ex.c@382:ee426a420dbb, 2014-11-03 (annotated)

Committer:
mbed_official
Date:
Mon Nov 03 10:45:07 2014 +0000
Revision:
382:ee426a420dbb
Parent:
targets/cmsis/TARGET_STM/TARGET_DISCO_L053C8/stm32l0xx_hal_flash_ex.c@376:cb4d9db17537
Child:
489:119543c9f674
Synchronized with git revision d54467eb07f62efd9ccdf44f1ede7fe1c1b0cf83



Full URL: https://github.com/mbedmicro/mbed/commit/d54467eb07f62efd9ccdf44f1ede7fe1c1b0cf83/

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 376:cb4d9db17537 1 /**
mbed_official 376:cb4d9db17537 2 ******************************************************************************
mbed_official 376:cb4d9db17537 3 * @file stm32l0xx_hal_flash_ex.c
mbed_official 376:cb4d9db17537 4 * @author MCD Application Team
mbed_official 376:cb4d9db17537 5 * @version V1.1.0
mbed_official 376:cb4d9db17537 6 * @date 18-June-2014
mbed_official 376:cb4d9db17537 7 * @brief FLASH HAL module driver.
mbed_official 376:cb4d9db17537 8 * This file provides firmware functions to manage the following
mbed_official 376:cb4d9db17537 9 * functionalities of the internal FLASH memory:
mbed_official 376:cb4d9db17537 10 * + FLASH Interface configuration
mbed_official 376:cb4d9db17537 11 * + FLASH Memory Programming
mbed_official 376:cb4d9db17537 12 * + DATA EEPROM Programming
mbed_official 376:cb4d9db17537 13 * + Option Bytes Programming
mbed_official 376:cb4d9db17537 14 * + Interrupts and flags management
mbed_official 376:cb4d9db17537 15 *
mbed_official 376:cb4d9db17537 16 * @verbatim
mbed_official 376:cb4d9db17537 17 ==============================================================================
mbed_official 376:cb4d9db17537 18 ##### Flash peripheral Extended features #####
mbed_official 376:cb4d9db17537 19 ==============================================================================
mbed_official 376:cb4d9db17537 20
mbed_official 376:cb4d9db17537 21 [..] Comparing to other products, the FLASH interface for STM32L0xx
mbed_official 376:cb4d9db17537 22 devices contains the following additional features
mbed_official 376:cb4d9db17537 23 (+) DATA_EEPROM memory management
mbed_official 376:cb4d9db17537 24 (+) BOOT option bit configuration
mbed_official 376:cb4d9db17537 25 (+) PCROP protection for all sectors
mbed_official 376:cb4d9db17537 26
mbed_official 376:cb4d9db17537 27 ##### How to use this driver #####
mbed_official 376:cb4d9db17537 28 ==============================================================================
mbed_official 376:cb4d9db17537 29 [..] This driver provides functions to configure and program the FLASH memory
mbed_official 376:cb4d9db17537 30 of all STM32L0xx. It includes:
mbed_official 376:cb4d9db17537 31 (+) Full DATA_EEPROM erase and program management
mbed_official 376:cb4d9db17537 32 (+) Boot activation
mbed_official 376:cb4d9db17537 33 (+) PCROP protection configuration and control for all pages
mbed_official 376:cb4d9db17537 34
mbed_official 376:cb4d9db17537 35 @endverbatim
mbed_official 376:cb4d9db17537 36 ******************************************************************************
mbed_official 376:cb4d9db17537 37 * @attention
mbed_official 376:cb4d9db17537 38 *
mbed_official 376:cb4d9db17537 39 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 376:cb4d9db17537 40 *
mbed_official 376:cb4d9db17537 41 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 376:cb4d9db17537 42 * are permitted provided that the following conditions are met:
mbed_official 376:cb4d9db17537 43 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 376:cb4d9db17537 44 * this list of conditions and the following disclaimer.
mbed_official 376:cb4d9db17537 45 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 376:cb4d9db17537 46 * this list of conditions and the following disclaimer in the documentation
mbed_official 376:cb4d9db17537 47 * and/or other materials provided with the distribution.
mbed_official 376:cb4d9db17537 48 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 376:cb4d9db17537 49 * may be used to endorse or promote products derived from this software
mbed_official 376:cb4d9db17537 50 * without specific prior written permission.
mbed_official 376:cb4d9db17537 51 *
mbed_official 376:cb4d9db17537 52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 376:cb4d9db17537 53 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 376:cb4d9db17537 54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 376:cb4d9db17537 55 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 376:cb4d9db17537 56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 376:cb4d9db17537 57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 376:cb4d9db17537 58 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 376:cb4d9db17537 59 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 376:cb4d9db17537 60 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 376:cb4d9db17537 61 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 376:cb4d9db17537 62 *
mbed_official 376:cb4d9db17537 63 ******************************************************************************
mbed_official 376:cb4d9db17537 64 */
mbed_official 376:cb4d9db17537 65
mbed_official 376:cb4d9db17537 66 /* Includes ------------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 67 #include "stm32l0xx_hal.h"
mbed_official 376:cb4d9db17537 68 /** @addtogroup STM32L0XX_HAL_Driver
mbed_official 376:cb4d9db17537 69 * @{
mbed_official 376:cb4d9db17537 70 */
mbed_official 376:cb4d9db17537 71
mbed_official 376:cb4d9db17537 72 /** @defgroup FLASHEx HAL FLASH Driver
mbed_official 376:cb4d9db17537 73 * @brief FLASH HAL Extension module driver
mbed_official 376:cb4d9db17537 74 * @{
mbed_official 376:cb4d9db17537 75 */
mbed_official 376:cb4d9db17537 76
mbed_official 376:cb4d9db17537 77 #ifdef HAL_FLASH_MODULE_ENABLED
mbed_official 376:cb4d9db17537 78
mbed_official 376:cb4d9db17537 79 /* Private typedef -----------------------------------------------------------*/
mbed_official 376:cb4d9db17537 80 /* Private define ------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 81 #define HAL_FLASH_TIMEOUT_VALUE ((uint32_t)0x50000
mbed_official 376:cb4d9db17537 82 #define WRP01_MASK ((uint32_t)0x0000FFFF)
mbed_official 376:cb4d9db17537 83 #define PAGESIZE ((uint32_t)0x00000080)
mbed_official 376:cb4d9db17537 84
mbed_official 376:cb4d9db17537 85 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 86 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 87 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 88 static HAL_StatusTypeDef FLASH_OB_PCROPConfig(uint32_t OB_WRP, FunctionalState NewState);
mbed_official 376:cb4d9db17537 89 static HAL_StatusTypeDef FLASH_OB_PCROPSelectionConfig(uint16_t OB_PcROP);
mbed_official 376:cb4d9db17537 90 static HAL_StatusTypeDef FLASH_OB_BootConfig(uint16_t OB_BOOT);
mbed_official 376:cb4d9db17537 91 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramByte(uint32_t Address, uint8_t Data);
mbed_official 376:cb4d9db17537 92 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramHalfWord(uint32_t Address, uint16_t Data);
mbed_official 376:cb4d9db17537 93 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramWord(uint32_t Address, uint32_t Data);
mbed_official 376:cb4d9db17537 94 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramByte(uint32_t Address, uint8_t Data);
mbed_official 376:cb4d9db17537 95 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramHalfWord(uint32_t Address, uint16_t Data);
mbed_official 376:cb4d9db17537 96 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramWord(uint32_t Address, uint32_t Data);
mbed_official 376:cb4d9db17537 97 static uint8_t FLASH_OB_GetUser(void);
mbed_official 376:cb4d9db17537 98 static uint32_t FLASH_OB_GetWRP(void);
mbed_official 376:cb4d9db17537 99 static FlagStatus FLASH_OB_GetRDP(void);
mbed_official 376:cb4d9db17537 100 static uint8_t FLASH_OB_GetBOR(void);
mbed_official 376:cb4d9db17537 101 static HAL_StatusTypeDef FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState);
mbed_official 376:cb4d9db17537 102 static HAL_StatusTypeDef FLASH_OB_RDP_LevelConfig(uint8_t OB_RDP);
mbed_official 376:cb4d9db17537 103 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY);
mbed_official 376:cb4d9db17537 104 static HAL_StatusTypeDef FLASH_OB_BOR_LevelConfig(uint8_t OB_BOR);
mbed_official 376:cb4d9db17537 105
mbed_official 376:cb4d9db17537 106 /* Aliases for legacy HAL versions compatibility */
mbed_official 376:cb4d9db17537 107 #define DATA_EEPROM_FastProgramByte FLASH_DATAEEPROM_FastProgramByte
mbed_official 376:cb4d9db17537 108 #define DATA_EEPROM_FastProgramHalfWord FLASH_DATAEEPROM_FastProgramHalfWord
mbed_official 376:cb4d9db17537 109 #define DATA_EEPROM_FastProgramWord FLASH_DATAEEPROM_FastProgramWord
mbed_official 376:cb4d9db17537 110 #define DATA_EEPROM_ProgramByte FLASH_DATAEEPROM_ProgramByte
mbed_official 376:cb4d9db17537 111 #define DATA_EEPROM_ProgramHalfWord FLASH_DATAEEPROM_ProgramHalfWord
mbed_official 376:cb4d9db17537 112 #define DATA_EEPROM_ProgramWord FLASH_DATAEEPROM_ProgramWord
mbed_official 376:cb4d9db17537 113
mbed_official 376:cb4d9db17537 114
mbed_official 376:cb4d9db17537 115 /* Private functions ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 116
mbed_official 376:cb4d9db17537 117 /** @defgroup FLASHEx_Private_Functions Extended FLASH Private functions
mbed_official 376:cb4d9db17537 118 * @{
mbed_official 376:cb4d9db17537 119 */
mbed_official 376:cb4d9db17537 120
mbed_official 376:cb4d9db17537 121 /** @defgroup FLASHEx_Group1 Peripheral extended features functions
mbed_official 376:cb4d9db17537 122 * @brief Data transfers functions
mbed_official 376:cb4d9db17537 123 *
mbed_official 376:cb4d9db17537 124 @verbatim
mbed_official 376:cb4d9db17537 125 ===============================================================================
mbed_official 376:cb4d9db17537 126 ##### Extended Features functions #####
mbed_official 376:cb4d9db17537 127 ===============================================================================
mbed_official 376:cb4d9db17537 128 [..]
mbed_official 376:cb4d9db17537 129 This subsection provides a set of functions allowing to manage the FLASH data
mbed_official 376:cb4d9db17537 130 transfers.
mbed_official 376:cb4d9db17537 131
mbed_official 376:cb4d9db17537 132 @endverbatim
mbed_official 376:cb4d9db17537 133 * @{
mbed_official 376:cb4d9db17537 134 */
mbed_official 376:cb4d9db17537 135
mbed_official 376:cb4d9db17537 136 /**
mbed_official 376:cb4d9db17537 137 * @brief Program option bytes
mbed_official 376:cb4d9db17537 138 * @param pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
mbed_official 376:cb4d9db17537 139 * contains the configuration information for the programming.
mbed_official 376:cb4d9db17537 140 *
mbed_official 376:cb4d9db17537 141 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 142 */
mbed_official 376:cb4d9db17537 143 HAL_StatusTypeDef HAL_FLASHEx_AdvOBProgram (FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
mbed_official 376:cb4d9db17537 144 {
mbed_official 376:cb4d9db17537 145 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 146
mbed_official 376:cb4d9db17537 147 /* Check the parameters */
mbed_official 376:cb4d9db17537 148 assert_param(IS_OBEX(pAdvOBInit->OptionType));
mbed_official 376:cb4d9db17537 149
mbed_official 376:cb4d9db17537 150 /*Program PCROP option byte*/
mbed_official 376:cb4d9db17537 151 if ((pAdvOBInit->OptionType&OBEX_PCROP) == OBEX_PCROP)
mbed_official 376:cb4d9db17537 152 {
mbed_official 376:cb4d9db17537 153 /* Check the parameters */
mbed_official 376:cb4d9db17537 154 assert_param(IS_PCROPSTATE(pAdvOBInit->PCROPState));
mbed_official 376:cb4d9db17537 155 if (pAdvOBInit->PCROPState == PCROPSTATE_ENABLE)
mbed_official 376:cb4d9db17537 156 {
mbed_official 376:cb4d9db17537 157 /*Enable of Write protection on the selected Sector*/
mbed_official 376:cb4d9db17537 158 status = FLASH_OB_PCROPConfig(pAdvOBInit->Pages, ENABLE);
mbed_official 376:cb4d9db17537 159 status = FLASH_OB_PCROPSelectionConfig(OB_PCROP_SELECTED);
mbed_official 376:cb4d9db17537 160 }
mbed_official 376:cb4d9db17537 161 else
mbed_official 376:cb4d9db17537 162 {
mbed_official 376:cb4d9db17537 163 /*Disable of Write protection on the selected Sector*/
mbed_official 376:cb4d9db17537 164 status = FLASH_OB_PCROPConfig(pAdvOBInit->Pages, DISABLE);
mbed_official 376:cb4d9db17537 165 status = FLASH_OB_PCROPSelectionConfig(OB_PCROP_DESELECTED);
mbed_official 376:cb4d9db17537 166 }
mbed_official 376:cb4d9db17537 167 }
mbed_official 376:cb4d9db17537 168 /*Program BOOT config option byte*/
mbed_official 376:cb4d9db17537 169 if ((pAdvOBInit->OptionType&OBEX_BOOTCONFIG) == OBEX_BOOTCONFIG)
mbed_official 376:cb4d9db17537 170 {
mbed_official 376:cb4d9db17537 171 status = FLASH_OB_BootConfig(pAdvOBInit->BootConfig);
mbed_official 376:cb4d9db17537 172 }
mbed_official 376:cb4d9db17537 173
mbed_official 376:cb4d9db17537 174 return status;
mbed_official 376:cb4d9db17537 175 }
mbed_official 376:cb4d9db17537 176
mbed_official 376:cb4d9db17537 177 /**
mbed_official 376:cb4d9db17537 178 * @brief Get the OBEX byte configuration
mbed_official 376:cb4d9db17537 179 * @param pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
mbed_official 376:cb4d9db17537 180 * contains the configuration information for the programming.
mbed_official 376:cb4d9db17537 181 *
mbed_official 376:cb4d9db17537 182 * @retval None
mbed_official 376:cb4d9db17537 183 */
mbed_official 376:cb4d9db17537 184 void HAL_FLASHEx_AdvOBGetConfig(FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
mbed_official 376:cb4d9db17537 185 {
mbed_official 376:cb4d9db17537 186 pAdvOBInit->OptionType = OBEX_PCROP| OBEX_BOOTCONFIG;
mbed_official 376:cb4d9db17537 187 /*Get PCROP state */
mbed_official 376:cb4d9db17537 188 pAdvOBInit->PCROPState = (FLASH->OBR & 0x00000100) >> 8;
mbed_official 376:cb4d9db17537 189 /*Get PCROP protected Pages */
mbed_official 376:cb4d9db17537 190 pAdvOBInit->Pages = FLASH->WRPR;
mbed_official 376:cb4d9db17537 191 /*Get Boot config OB*/
mbed_official 376:cb4d9db17537 192 pAdvOBInit->BootConfig = (FLASH->OBR & 0x80000000) >> 24;
mbed_official 376:cb4d9db17537 193 }
mbed_official 376:cb4d9db17537 194
mbed_official 376:cb4d9db17537 195 /**
mbed_official 376:cb4d9db17537 196 * @}
mbed_official 376:cb4d9db17537 197 */
mbed_official 376:cb4d9db17537 198
mbed_official 376:cb4d9db17537 199 /** @defgroup FLASHEx_Group2 DATA EEPROM Programming functions
mbed_official 376:cb4d9db17537 200 * @brief DATA EEPROM Programming functions
mbed_official 376:cb4d9db17537 201 *
mbed_official 376:cb4d9db17537 202 @verbatim
mbed_official 376:cb4d9db17537 203 ===============================================================================
mbed_official 376:cb4d9db17537 204 ##### DATA EEPROM Programming functions #####
mbed_official 376:cb4d9db17537 205 ===============================================================================
mbed_official 376:cb4d9db17537 206
mbed_official 376:cb4d9db17537 207 [..] The FLASH_DATAEEPROM Programming_Functions, includes the following functions:
mbed_official 376:cb4d9db17537 208 (+) HAL_FLASHEx_DATAEEPROM_Unlock(void);
mbed_official 376:cb4d9db17537 209 (+) HAL_FLASHEx_DATAEEPROM_Lock(void);
mbed_official 376:cb4d9db17537 210 (+) HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
mbed_official 376:cb4d9db17537 211 (+) HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)
mbed_official 376:cb4d9db17537 212
mbed_official 376:cb4d9db17537 213 [..] Any operation of erase or program should follow these steps:
mbed_official 376:cb4d9db17537 214 (#) Call the HAL_FLASHEx_DATAEEPROM_Unlock() function to enable the data EEPROM access
mbed_official 376:cb4d9db17537 215 and Flash program erase control register access.
mbed_official 376:cb4d9db17537 216 (#) Call the desired function to erase or program data.
mbed_official 376:cb4d9db17537 217 (#) Call the HAL_FLASHEx_DATAEEPROM_Lock() to disable the data EEPROM access
mbed_official 376:cb4d9db17537 218 and Flash program erase control register access(recommended
mbed_official 376:cb4d9db17537 219 to protect the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 220
mbed_official 376:cb4d9db17537 221 @endverbatim
mbed_official 376:cb4d9db17537 222 * @{
mbed_official 376:cb4d9db17537 223 */
mbed_official 376:cb4d9db17537 224 /**
mbed_official 376:cb4d9db17537 225 * @brief Unlocks the data memory and FLASH_PECR register access.
mbed_official 376:cb4d9db17537 226 * @param None
mbed_official 376:cb4d9db17537 227 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 228 */
mbed_official 376:cb4d9db17537 229 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Unlock(void)
mbed_official 376:cb4d9db17537 230 {
mbed_official 376:cb4d9db17537 231 if((FLASH->PECR & FLASH_PECR_PELOCK) != RESET)
mbed_official 376:cb4d9db17537 232 {
mbed_official 376:cb4d9db17537 233 /* Unlocking the Data memory and FLASH_PECR register access*/
mbed_official 376:cb4d9db17537 234 FLASH->PEKEYR = FLASH_PEKEY1;
mbed_official 376:cb4d9db17537 235 FLASH->PEKEYR = FLASH_PEKEY2;
mbed_official 376:cb4d9db17537 236 }
mbed_official 376:cb4d9db17537 237 else
mbed_official 376:cb4d9db17537 238 {
mbed_official 376:cb4d9db17537 239 return HAL_ERROR;
mbed_official 376:cb4d9db17537 240 }
mbed_official 376:cb4d9db17537 241 return HAL_OK;
mbed_official 376:cb4d9db17537 242 }
mbed_official 376:cb4d9db17537 243
mbed_official 376:cb4d9db17537 244 /**
mbed_official 376:cb4d9db17537 245 * @brief Locks the Data memory and FLASH_PECR register access.
mbed_official 376:cb4d9db17537 246 * @param None
mbed_official 376:cb4d9db17537 247 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 248 */
mbed_official 376:cb4d9db17537 249 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Lock(void)
mbed_official 376:cb4d9db17537 250 {
mbed_official 376:cb4d9db17537 251 /* Set the PELOCK Bit to lock the data memory and FLASH_PECR register access */
mbed_official 376:cb4d9db17537 252 FLASH->PECR |= FLASH_PECR_PELOCK;
mbed_official 376:cb4d9db17537 253
mbed_official 376:cb4d9db17537 254 return HAL_OK;
mbed_official 376:cb4d9db17537 255 }
mbed_official 376:cb4d9db17537 256
mbed_official 376:cb4d9db17537 257 /**
mbed_official 376:cb4d9db17537 258 * @brief Erase a word in data memory.
mbed_official 376:cb4d9db17537 259 * @param Address: specifies the address to be erased.
mbed_official 376:cb4d9db17537 260 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
mbed_official 376:cb4d9db17537 261 * must be called before.
mbed_official 376:cb4d9db17537 262 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
mbed_official 376:cb4d9db17537 263 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 264 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 265 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 266 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 267 */
mbed_official 376:cb4d9db17537 268 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
mbed_official 376:cb4d9db17537 269 {
mbed_official 376:cb4d9db17537 270 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 271
mbed_official 376:cb4d9db17537 272 /* Check the parameters */
mbed_official 376:cb4d9db17537 273 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 274
mbed_official 376:cb4d9db17537 275 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 276 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 277
mbed_official 376:cb4d9db17537 278 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 279 {
mbed_official 376:cb4d9db17537 280 /* Write "00000000h" to valid address in the data memory" */
mbed_official 376:cb4d9db17537 281 *(__IO uint32_t *) Address = 0x00000000;
mbed_official 376:cb4d9db17537 282 }
mbed_official 376:cb4d9db17537 283
mbed_official 376:cb4d9db17537 284 /* Return the erase status */
mbed_official 376:cb4d9db17537 285 return status;
mbed_official 376:cb4d9db17537 286 }
mbed_official 376:cb4d9db17537 287
mbed_official 376:cb4d9db17537 288 /**
mbed_official 376:cb4d9db17537 289 * @brief Program word at a specified address
mbed_official 376:cb4d9db17537 290 * @param TypeProgram: Indicate the way to program at a specified address.
mbed_official 376:cb4d9db17537 291 * This parameter can be a value of @ref FLASH_Type_Program
mbed_official 376:cb4d9db17537 292 * @param Address: specifies the address to be programmed.
mbed_official 376:cb4d9db17537 293 * @param Data: specifies the data to be programmed
mbed_official 376:cb4d9db17537 294 *
mbed_official 376:cb4d9db17537 295 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 296 */
mbed_official 376:cb4d9db17537 297
mbed_official 376:cb4d9db17537 298 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)
mbed_official 376:cb4d9db17537 299 {
mbed_official 376:cb4d9db17537 300 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 301
mbed_official 376:cb4d9db17537 302 /* Process Locked */
mbed_official 376:cb4d9db17537 303 __HAL_LOCK(&pFlash);
mbed_official 376:cb4d9db17537 304
mbed_official 376:cb4d9db17537 305 /* Check the parameters */
mbed_official 376:cb4d9db17537 306 assert_param(IS_TYPEPROGRAM(TypeProgram));
mbed_official 376:cb4d9db17537 307
mbed_official 376:cb4d9db17537 308 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 309 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 310
mbed_official 376:cb4d9db17537 311 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 312 {
mbed_official 376:cb4d9db17537 313 if(TypeProgram == TYPEPROGRAM_FASTBYTE)
mbed_official 376:cb4d9db17537 314 {
mbed_official 376:cb4d9db17537 315 /*Program word (8-bit) at a specified address.*/
mbed_official 376:cb4d9db17537 316 FLASH_DATAEEPROM_FastProgramByte(Address, (uint8_t) Data);
mbed_official 376:cb4d9db17537 317
mbed_official 376:cb4d9db17537 318 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 319 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 320 }
mbed_official 376:cb4d9db17537 321
mbed_official 376:cb4d9db17537 322 if(TypeProgram == TYPEPROGRAM_FASTHALFWORD)
mbed_official 376:cb4d9db17537 323 {
mbed_official 376:cb4d9db17537 324 /*Program word (16-bit) at a specified address.*/
mbed_official 376:cb4d9db17537 325 FLASH_DATAEEPROM_FastProgramHalfWord(Address, (uint16_t) Data);
mbed_official 376:cb4d9db17537 326
mbed_official 376:cb4d9db17537 327 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 328 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 329 }
mbed_official 376:cb4d9db17537 330 if(TypeProgram == TYPEPROGRAM_FASTWORD)
mbed_official 376:cb4d9db17537 331 {
mbed_official 376:cb4d9db17537 332 /*Program word (32-bit) at a specified address.*/
mbed_official 376:cb4d9db17537 333 FLASH_DATAEEPROM_FastProgramWord(Address, (uint32_t) Data);
mbed_official 376:cb4d9db17537 334
mbed_official 376:cb4d9db17537 335 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 336 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 337 }
mbed_official 376:cb4d9db17537 338 if(TypeProgram == TYPEPROGRAM_WORD)
mbed_official 376:cb4d9db17537 339 {
mbed_official 376:cb4d9db17537 340 /*Program word (32-bit) at a specified address.*/
mbed_official 376:cb4d9db17537 341 FLASH_DATAEEPROM_ProgramWord(Address, (uint32_t) Data);
mbed_official 376:cb4d9db17537 342
mbed_official 376:cb4d9db17537 343 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 344 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 345 }
mbed_official 376:cb4d9db17537 346
mbed_official 376:cb4d9db17537 347 if(TypeProgram == TYPEPROGRAM_HALFWORD)
mbed_official 376:cb4d9db17537 348 {
mbed_official 376:cb4d9db17537 349 /*Program word (16-bit) at a specified address.*/
mbed_official 376:cb4d9db17537 350 FLASH_DATAEEPROM_ProgramHalfWord(Address, (uint16_t) Data);
mbed_official 376:cb4d9db17537 351
mbed_official 376:cb4d9db17537 352 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 353 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 354 }
mbed_official 376:cb4d9db17537 355
mbed_official 376:cb4d9db17537 356 if(TypeProgram == TYPEPROGRAM_BYTE)
mbed_official 376:cb4d9db17537 357 {
mbed_official 376:cb4d9db17537 358 /*Program word (8-bit) at a specified address.*/
mbed_official 376:cb4d9db17537 359 FLASH_DATAEEPROM_ProgramByte(Address, (uint8_t) Data);
mbed_official 376:cb4d9db17537 360
mbed_official 376:cb4d9db17537 361 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 362 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 363 }
mbed_official 376:cb4d9db17537 364 }
mbed_official 376:cb4d9db17537 365 /* Process Unlocked */
mbed_official 376:cb4d9db17537 366 __HAL_UNLOCK(&pFlash);
mbed_official 376:cb4d9db17537 367
mbed_official 376:cb4d9db17537 368 return status;
mbed_official 376:cb4d9db17537 369 }
mbed_official 376:cb4d9db17537 370
mbed_official 376:cb4d9db17537 371 /**
mbed_official 376:cb4d9db17537 372 * @brief Erase the specified FLASH memory Pages
mbed_official 376:cb4d9db17537 373 * @param[in] pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that
mbed_official 376:cb4d9db17537 374 * contains the configuration information for the erasing.
mbed_official 376:cb4d9db17537 375 *
mbed_official 376:cb4d9db17537 376 * @param[out] PageError: pointer to variable that
mbed_official 376:cb4d9db17537 377 * contains the configuration information on faulty sector in case of error
mbed_official 376:cb4d9db17537 378 * (0xFFFFFFFF means that all the sectors have been correctly erased)
mbed_official 376:cb4d9db17537 379 *
mbed_official 376:cb4d9db17537 380 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 381 */
mbed_official 376:cb4d9db17537 382 HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)
mbed_official 376:cb4d9db17537 383 {
mbed_official 376:cb4d9db17537 384 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 385 uint32_t index = 0;
mbed_official 376:cb4d9db17537 386
mbed_official 376:cb4d9db17537 387 /* Process Locked */
mbed_official 376:cb4d9db17537 388 __HAL_LOCK(&pFlash);
mbed_official 376:cb4d9db17537 389
mbed_official 376:cb4d9db17537 390 /* Check the parameters */
mbed_official 376:cb4d9db17537 391 assert_param(IS_TYPEERASE(pEraseInit->TypeErase));
mbed_official 376:cb4d9db17537 392
mbed_official 376:cb4d9db17537 393 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 394 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 395
mbed_official 376:cb4d9db17537 396 if (status == HAL_OK)
mbed_official 376:cb4d9db17537 397 {
mbed_official 376:cb4d9db17537 398 /*Initialization of PageError variable*/
mbed_official 376:cb4d9db17537 399 *PageError = 0xFFFFFFFF;
mbed_official 376:cb4d9db17537 400
mbed_official 376:cb4d9db17537 401 /* Check the parameters */
mbed_official 376:cb4d9db17537 402 assert_param(IS_NBPAGES(pEraseInit->NbPages + pEraseInit->Page));
mbed_official 376:cb4d9db17537 403
mbed_official 376:cb4d9db17537 404 /* Erase by sector by sector to be done*/
mbed_official 376:cb4d9db17537 405 for(index = pEraseInit->Page; index < ((pEraseInit->NbPages*PAGESIZE)+ pEraseInit->Page); index+=PAGESIZE)
mbed_official 376:cb4d9db17537 406 {
mbed_official 376:cb4d9db17537 407 FLASH_Erase_Page(index);
mbed_official 376:cb4d9db17537 408
mbed_official 376:cb4d9db17537 409 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 410 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 411
mbed_official 376:cb4d9db17537 412 /* If the erase operation is completed, disable the ERASE Bit */
mbed_official 376:cb4d9db17537 413 FLASH->PECR &= (~FLASH_PECR_PROG);
mbed_official 376:cb4d9db17537 414 FLASH->PECR &= (~FLASH_PECR_ERASE);
mbed_official 376:cb4d9db17537 415
mbed_official 376:cb4d9db17537 416 if (status != HAL_OK)
mbed_official 376:cb4d9db17537 417 {
mbed_official 376:cb4d9db17537 418 /* In case of error, stop erase procedure and return the faulty sector*/
mbed_official 376:cb4d9db17537 419 *PageError = index;
mbed_official 376:cb4d9db17537 420 break;
mbed_official 376:cb4d9db17537 421 }
mbed_official 376:cb4d9db17537 422 }
mbed_official 376:cb4d9db17537 423 }
mbed_official 376:cb4d9db17537 424
mbed_official 376:cb4d9db17537 425 /* Process Unlocked */
mbed_official 376:cb4d9db17537 426 __HAL_UNLOCK(&pFlash);
mbed_official 376:cb4d9db17537 427
mbed_official 376:cb4d9db17537 428 return status;
mbed_official 376:cb4d9db17537 429 }
mbed_official 376:cb4d9db17537 430
mbed_official 376:cb4d9db17537 431 /**
mbed_official 376:cb4d9db17537 432 * @brief Perform a page erase of the specified FLASH memory pages with interrupt enabled
mbed_official 376:cb4d9db17537 433 * @param pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that
mbed_official 376:cb4d9db17537 434 * contains the configuration information for the erasing.
mbed_official 376:cb4d9db17537 435 *
mbed_official 376:cb4d9db17537 436 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 437 */
mbed_official 376:cb4d9db17537 438 HAL_StatusTypeDef HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef *pEraseInit)
mbed_official 376:cb4d9db17537 439 {
mbed_official 376:cb4d9db17537 440 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 441
mbed_official 376:cb4d9db17537 442 /* Process Locked */
mbed_official 376:cb4d9db17537 443 __HAL_LOCK(&pFlash);
mbed_official 376:cb4d9db17537 444
mbed_official 376:cb4d9db17537 445 /* Check the parameters */
mbed_official 376:cb4d9db17537 446 assert_param(IS_TYPEERASE(pEraseInit->TypeErase));
mbed_official 376:cb4d9db17537 447
mbed_official 376:cb4d9db17537 448 /* Enable End of FLASH Operation interrupt */
mbed_official 376:cb4d9db17537 449 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP);
mbed_official 376:cb4d9db17537 450
mbed_official 376:cb4d9db17537 451 /* Enable Error source interrupt */
mbed_official 376:cb4d9db17537 452 __HAL_FLASH_ENABLE_IT(FLASH_IT_ERR);
mbed_official 376:cb4d9db17537 453
mbed_official 376:cb4d9db17537 454 /* Clear pending flags (if any) */
mbed_official 376:cb4d9db17537 455 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_ENDHV | FLASH_FLAG_WRPERR |\
mbed_official 376:cb4d9db17537 456 FLASH_FLAG_PGAERR | FLASH_FLAG_SIZERR| FLASH_FLAG_OPTVERR |\
mbed_official 376:cb4d9db17537 457 FLASH_FLAG_RDERR | FLASH_FLAG_NOTZEROERR);
mbed_official 376:cb4d9db17537 458
mbed_official 376:cb4d9db17537 459 if (pEraseInit->TypeErase == TYPEERASE_PAGEERASE)
mbed_official 376:cb4d9db17537 460 {
mbed_official 376:cb4d9db17537 461 /* Erase by sector to be done*/
mbed_official 376:cb4d9db17537 462
mbed_official 376:cb4d9db17537 463 /* Check the parameters */
mbed_official 376:cb4d9db17537 464 assert_param(IS_NBPAGES(pEraseInit->NbPages + pEraseInit->Page));
mbed_official 376:cb4d9db17537 465
mbed_official 376:cb4d9db17537 466 pFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE;
mbed_official 376:cb4d9db17537 467 pFlash.NbPagesToErase = pEraseInit->NbPages;
mbed_official 376:cb4d9db17537 468 pFlash.Page = pEraseInit->Page;
mbed_official 376:cb4d9db17537 469
mbed_official 376:cb4d9db17537 470 /*Erase 1st page and wait for IT*/
mbed_official 376:cb4d9db17537 471 FLASH_Erase_Page(pEraseInit->Page);
mbed_official 376:cb4d9db17537 472 }
mbed_official 376:cb4d9db17537 473
mbed_official 376:cb4d9db17537 474 return status;
mbed_official 376:cb4d9db17537 475 }
mbed_official 376:cb4d9db17537 476
mbed_official 376:cb4d9db17537 477
mbed_official 376:cb4d9db17537 478 /**
mbed_official 376:cb4d9db17537 479 * @brief Program option bytes
mbed_official 376:cb4d9db17537 480 * @param pOBInit: pointer to an FLASH_OBInitStruct structure that
mbed_official 376:cb4d9db17537 481 * contains the configuration information for the programming.
mbed_official 376:cb4d9db17537 482 *
mbed_official 376:cb4d9db17537 483 * @retval HAL_StatusTypeDef HAL Status
mbed_official 376:cb4d9db17537 484 */
mbed_official 376:cb4d9db17537 485 HAL_StatusTypeDef HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef *pOBInit)
mbed_official 376:cb4d9db17537 486 {
mbed_official 376:cb4d9db17537 487 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 488
mbed_official 376:cb4d9db17537 489 /* Process Locked */
mbed_official 376:cb4d9db17537 490 __HAL_LOCK(&pFlash);
mbed_official 376:cb4d9db17537 491
mbed_official 376:cb4d9db17537 492 /* Check the parameters */
mbed_official 376:cb4d9db17537 493 assert_param(IS_OPTIONBYTE(pOBInit->OptionType));
mbed_official 376:cb4d9db17537 494
mbed_official 376:cb4d9db17537 495 /*Write protection configuration*/
mbed_official 376:cb4d9db17537 496 if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP)
mbed_official 376:cb4d9db17537 497 {
mbed_official 376:cb4d9db17537 498 assert_param(IS_WRPSTATE(pOBInit->WRPState));
mbed_official 376:cb4d9db17537 499 if (pOBInit->WRPState == WRPSTATE_ENABLE)
mbed_official 376:cb4d9db17537 500 {
mbed_official 376:cb4d9db17537 501 /*Enable of Write protection on the selected Sector*/
mbed_official 376:cb4d9db17537 502 status = FLASH_OB_WRPConfig(pOBInit->WRPSector, ENABLE);
mbed_official 376:cb4d9db17537 503 }
mbed_official 376:cb4d9db17537 504 else
mbed_official 376:cb4d9db17537 505 {
mbed_official 376:cb4d9db17537 506 /*Disable of Write protection on the selected Sector*/
mbed_official 376:cb4d9db17537 507 status = FLASH_OB_WRPConfig(pOBInit->WRPSector, DISABLE);
mbed_official 376:cb4d9db17537 508 }
mbed_official 376:cb4d9db17537 509 }
mbed_official 376:cb4d9db17537 510
mbed_official 376:cb4d9db17537 511 /* Read protection configuration*/
mbed_official 376:cb4d9db17537 512 if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP)
mbed_official 376:cb4d9db17537 513 {
mbed_official 376:cb4d9db17537 514 status = FLASH_OB_RDP_LevelConfig(pOBInit->RDPLevel);
mbed_official 376:cb4d9db17537 515 }
mbed_official 376:cb4d9db17537 516
mbed_official 376:cb4d9db17537 517 /* USER configuration*/
mbed_official 376:cb4d9db17537 518 if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER)
mbed_official 376:cb4d9db17537 519 {
mbed_official 376:cb4d9db17537 520 status = FLASH_OB_UserConfig(pOBInit->USERConfig&OB_IWDG_SW,
mbed_official 376:cb4d9db17537 521 pOBInit->USERConfig&OB_STOP_NoRST,
mbed_official 376:cb4d9db17537 522 pOBInit->USERConfig&OB_STDBY_NoRST);
mbed_official 376:cb4d9db17537 523 }
mbed_official 376:cb4d9db17537 524
mbed_official 376:cb4d9db17537 525 /* BOR Level configuration*/
mbed_official 376:cb4d9db17537 526 if((pOBInit->OptionType & OPTIONBYTE_BOR) == OPTIONBYTE_BOR)
mbed_official 376:cb4d9db17537 527 {
mbed_official 376:cb4d9db17537 528 status = FLASH_OB_BOR_LevelConfig(pOBInit->BORLevel);
mbed_official 376:cb4d9db17537 529 }
mbed_official 376:cb4d9db17537 530 /* Process Unlocked */
mbed_official 376:cb4d9db17537 531 __HAL_UNLOCK(&pFlash);
mbed_official 376:cb4d9db17537 532
mbed_official 376:cb4d9db17537 533 return status;
mbed_official 376:cb4d9db17537 534 }
mbed_official 376:cb4d9db17537 535
mbed_official 376:cb4d9db17537 536 /**
mbed_official 376:cb4d9db17537 537 * @brief Get the Option byte configuration
mbed_official 376:cb4d9db17537 538 * @param pOBInit: pointer to an FLASH_OBInitStruct structure that
mbed_official 376:cb4d9db17537 539 * contains the configuration information for the programming.
mbed_official 376:cb4d9db17537 540 *
mbed_official 376:cb4d9db17537 541 * @retval None
mbed_official 376:cb4d9db17537 542 */
mbed_official 376:cb4d9db17537 543 void HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef *pOBInit)
mbed_official 376:cb4d9db17537 544 {
mbed_official 376:cb4d9db17537 545 pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER | OPTIONBYTE_BOR;
mbed_official 376:cb4d9db17537 546
mbed_official 376:cb4d9db17537 547 /*Get WRP*/
mbed_official 376:cb4d9db17537 548 pOBInit->WRPSector = FLASH_OB_GetWRP();
mbed_official 376:cb4d9db17537 549
mbed_official 376:cb4d9db17537 550 /*Get RDP Level*/
mbed_official 376:cb4d9db17537 551 pOBInit->RDPLevel = FLASH_OB_GetRDP();
mbed_official 376:cb4d9db17537 552
mbed_official 376:cb4d9db17537 553 /*Get USER*/
mbed_official 376:cb4d9db17537 554 pOBInit->USERConfig = FLASH_OB_GetUser();
mbed_official 376:cb4d9db17537 555
mbed_official 376:cb4d9db17537 556 /*Get BOR Level*/
mbed_official 376:cb4d9db17537 557 pOBInit->BORLevel = FLASH_OB_GetBOR();
mbed_official 376:cb4d9db17537 558 }
mbed_official 376:cb4d9db17537 559
mbed_official 376:cb4d9db17537 560 /**
mbed_official 376:cb4d9db17537 561 * @}
mbed_official 376:cb4d9db17537 562 */
mbed_official 376:cb4d9db17537 563
mbed_official 376:cb4d9db17537 564 /**
mbed_official 376:cb4d9db17537 565 * @brief Returns the FLASH User Option Bytes values.
mbed_official 376:cb4d9db17537 566 * @param None
mbed_official 376:cb4d9db17537 567 * @retval The FLASH User Option Bytes.
mbed_official 376:cb4d9db17537 568 */
mbed_official 376:cb4d9db17537 569 static uint8_t FLASH_OB_GetUser(void)
mbed_official 376:cb4d9db17537 570 {
mbed_official 376:cb4d9db17537 571 /* Return the User Option Byte */
mbed_official 376:cb4d9db17537 572 return (uint8_t)(FLASH->OBR >> 20);
mbed_official 376:cb4d9db17537 573 }
mbed_official 376:cb4d9db17537 574
mbed_official 376:cb4d9db17537 575 /**
mbed_official 376:cb4d9db17537 576 * @brief Returns the FLASH Write Protection Option Bytes value.
mbed_official 376:cb4d9db17537 577 * @param None
mbed_official 376:cb4d9db17537 578 * @retval The FLASH Write Protection Option Bytes value.
mbed_official 376:cb4d9db17537 579 */
mbed_official 376:cb4d9db17537 580 static uint32_t FLASH_OB_GetWRP(void)
mbed_official 376:cb4d9db17537 581 {
mbed_official 376:cb4d9db17537 582 /* Return the FLASH write protection Register value */
mbed_official 376:cb4d9db17537 583 return (uint32_t)(FLASH->WRPR);
mbed_official 376:cb4d9db17537 584 }
mbed_official 376:cb4d9db17537 585
mbed_official 376:cb4d9db17537 586 /**
mbed_official 376:cb4d9db17537 587 * @brief Checks whether the FLASH Read out Protection Status is set or not.
mbed_official 376:cb4d9db17537 588 * @param None
mbed_official 376:cb4d9db17537 589 * @retval FLASH ReadOut Protection Status(SET or RESET).
mbed_official 376:cb4d9db17537 590 */
mbed_official 376:cb4d9db17537 591 static FlagStatus FLASH_OB_GetRDP(void)
mbed_official 376:cb4d9db17537 592 {
mbed_official 376:cb4d9db17537 593 FlagStatus readstatus = RESET;
mbed_official 376:cb4d9db17537 594
mbed_official 376:cb4d9db17537 595 if ((uint8_t)(FLASH->OBR) != (uint8_t)OB_RDP_Level_0)
mbed_official 376:cb4d9db17537 596 {
mbed_official 376:cb4d9db17537 597 readstatus = SET;
mbed_official 376:cb4d9db17537 598 }
mbed_official 376:cb4d9db17537 599 else
mbed_official 376:cb4d9db17537 600 {
mbed_official 376:cb4d9db17537 601 readstatus = RESET;
mbed_official 376:cb4d9db17537 602 }
mbed_official 376:cb4d9db17537 603 return readstatus;
mbed_official 376:cb4d9db17537 604 }
mbed_official 376:cb4d9db17537 605
mbed_official 376:cb4d9db17537 606 /**
mbed_official 376:cb4d9db17537 607 * @brief Returns the FLASH BOR level.
mbed_official 376:cb4d9db17537 608 * @param None
mbed_official 376:cb4d9db17537 609 * @retval The FLASH User Option Bytes.
mbed_official 376:cb4d9db17537 610 */
mbed_official 376:cb4d9db17537 611 static uint8_t FLASH_OB_GetBOR(void)
mbed_official 376:cb4d9db17537 612 {
mbed_official 376:cb4d9db17537 613 /* Return the BOR level */
mbed_official 376:cb4d9db17537 614 return (uint8_t)((FLASH->OBR & (uint32_t)0x000F0000) >> 16);
mbed_official 376:cb4d9db17537 615 }
mbed_official 376:cb4d9db17537 616
mbed_official 376:cb4d9db17537 617 /**
mbed_official 376:cb4d9db17537 618 * @brief Write protects the desired pages of the first 64KB of the Flash.
mbed_official 376:cb4d9db17537 619 * @param OB_WRP: specifies the address of the pages to be write protected.
mbed_official 376:cb4d9db17537 620 * This parameter can be:
mbed_official 376:cb4d9db17537 621 * @arg value between OB_WRP_Pages0to31 and OB_WRP_Pages480to511
mbed_official 376:cb4d9db17537 622 * @arg OB_WRP_AllPages
mbed_official 376:cb4d9db17537 623 * @param NewState: new state of the specified FLASH Pages Wtite protection.
mbed_official 376:cb4d9db17537 624 * This parameter can be: ENABLE or DISABLE.
mbed_official 376:cb4d9db17537 625 * @retval HAL_StatusTypeDef
mbed_official 376:cb4d9db17537 626 */
mbed_official 376:cb4d9db17537 627 static HAL_StatusTypeDef FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState)
mbed_official 376:cb4d9db17537 628 {
mbed_official 376:cb4d9db17537 629 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 630 uint32_t WRP01_Data = 0;
mbed_official 376:cb4d9db17537 631 uint32_t tmp1 = 0;
mbed_official 376:cb4d9db17537 632
mbed_official 376:cb4d9db17537 633 /* Check the parameters */
mbed_official 376:cb4d9db17537 634 assert_param(IS_OB_WRP(OB_WRP));
mbed_official 376:cb4d9db17537 635 assert_param(IS_FUNCTIONAL_STATE(NewState));
mbed_official 376:cb4d9db17537 636
mbed_official 376:cb4d9db17537 637 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 638 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 639
mbed_official 376:cb4d9db17537 640 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 641 {
mbed_official 376:cb4d9db17537 642 if (NewState != DISABLE)
mbed_official 376:cb4d9db17537 643 {
mbed_official 376:cb4d9db17537 644 WRP01_Data = (uint16_t)(((OB_WRP & WRP01_MASK) | OB->WRP01));
mbed_official 376:cb4d9db17537 645 tmp1 = (uint32_t)(~(WRP01_Data) << 16)|(WRP01_Data);
mbed_official 376:cb4d9db17537 646 OB->WRP01 = tmp1;
mbed_official 376:cb4d9db17537 647 }
mbed_official 376:cb4d9db17537 648 else
mbed_official 376:cb4d9db17537 649 {
mbed_official 376:cb4d9db17537 650 WRP01_Data = (uint16_t)(~OB_WRP & (WRP01_MASK & OB->WRP01));
mbed_official 376:cb4d9db17537 651 tmp1 = (uint32_t)((~WRP01_Data) << 16)|(WRP01_Data);
mbed_official 376:cb4d9db17537 652 OB->WRP01 = tmp1;
mbed_official 376:cb4d9db17537 653 }
mbed_official 376:cb4d9db17537 654 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 655 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 656 }
mbed_official 376:cb4d9db17537 657
mbed_official 376:cb4d9db17537 658 /* Return the write protection operation Status */
mbed_official 376:cb4d9db17537 659 return status;
mbed_official 376:cb4d9db17537 660 }
mbed_official 376:cb4d9db17537 661 /**
mbed_official 376:cb4d9db17537 662 * @brief Enables or disables the read out protection.
mbed_official 376:cb4d9db17537 663 * @note To correctly run this function, the FLASH_OB_Unlock() function
mbed_official 376:cb4d9db17537 664 * must be called before.
mbed_official 376:cb4d9db17537 665 * @param FLASH_ReadProtection_Level: specifies the read protection level.
mbed_official 376:cb4d9db17537 666 * This parameter can be:
mbed_official 376:cb4d9db17537 667 * @arg OB_RDP_Level_0: No protection
mbed_official 376:cb4d9db17537 668 * @arg OB_RDP_Level_1: Read protection of the memory
mbed_official 376:cb4d9db17537 669 * @arg OB_RDP_Level_2: Chip protection
mbed_official 376:cb4d9db17537 670 *
mbed_official 376:cb4d9db17537 671 * !!!Warning!!! When enabling OB_RDP_Level_2 it's no more possible to go back to level 1 or 0
mbed_official 376:cb4d9db17537 672 *
mbed_official 376:cb4d9db17537 673 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 674 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 675 */
mbed_official 376:cb4d9db17537 676 static HAL_StatusTypeDef FLASH_OB_RDP_LevelConfig(uint8_t OB_RDP)
mbed_official 376:cb4d9db17537 677 {
mbed_official 376:cb4d9db17537 678 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 679 uint16_t tmp1 = 0;
mbed_official 376:cb4d9db17537 680 uint32_t tmp2 = 0;
mbed_official 376:cb4d9db17537 681
mbed_official 376:cb4d9db17537 682 /* Check the parameters */
mbed_official 376:cb4d9db17537 683 assert_param(IS_OB_RDP(OB_RDP));
mbed_official 376:cb4d9db17537 684 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 685
mbed_official 376:cb4d9db17537 686 /* calculate the option byte to write */
mbed_official 376:cb4d9db17537 687 tmp1 = ((uint16_t)(*(__IO uint16_t *)(OB_BASE)) & 0xFF00) | OB_RDP;
mbed_official 376:cb4d9db17537 688 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(~tmp1) << 16)) | ((uint32_t)tmp1));
mbed_official 376:cb4d9db17537 689
mbed_official 376:cb4d9db17537 690 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 691 {
mbed_official 376:cb4d9db17537 692 /* program read protection level */
mbed_official 376:cb4d9db17537 693 OB->RDP = tmp2;
mbed_official 376:cb4d9db17537 694 }
mbed_official 376:cb4d9db17537 695
mbed_official 376:cb4d9db17537 696 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 697 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 698
mbed_official 376:cb4d9db17537 699 /* Return the Read protection operation Status */
mbed_official 376:cb4d9db17537 700 return status;
mbed_official 376:cb4d9db17537 701 }
mbed_official 376:cb4d9db17537 702
mbed_official 376:cb4d9db17537 703 /**
mbed_official 376:cb4d9db17537 704 * @brief Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY.
mbed_official 376:cb4d9db17537 705 * @param OB_IWDG: Selects the WDG mode.
mbed_official 376:cb4d9db17537 706 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 707 * @arg OB_IWDG_SW: Software WDG selected
mbed_official 376:cb4d9db17537 708 * @arg OB_IWDG_HW: Hardware WDG selected
mbed_official 376:cb4d9db17537 709 * @param OB_STOP: Reset event when entering STOP mode.
mbed_official 376:cb4d9db17537 710 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 711 * @arg OB_STOP_NoRST: No reset generated when entering in STOP
mbed_official 376:cb4d9db17537 712 * @arg OB_STOP_RST: Reset generated when entering in STOP
mbed_official 376:cb4d9db17537 713 * @param OB_STDBY: Reset event when entering Standby mode.
mbed_official 376:cb4d9db17537 714 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 715 * @arg OB_STDBY_NoRST: No reset generated when entering in STANDBY
mbed_official 376:cb4d9db17537 716 * @arg OB_STDBY_RST: Reset generated when entering in STANDBY
mbed_official 376:cb4d9db17537 717 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 718 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 719 */
mbed_official 376:cb4d9db17537 720 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)
mbed_official 376:cb4d9db17537 721 {
mbed_official 376:cb4d9db17537 722 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 723 uint32_t tmp = 0, tmp1 = 0;
mbed_official 376:cb4d9db17537 724
mbed_official 376:cb4d9db17537 725 /* Check the parameters */
mbed_official 376:cb4d9db17537 726 assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));
mbed_official 376:cb4d9db17537 727 assert_param(IS_OB_STOP_SOURCE(OB_STOP));
mbed_official 376:cb4d9db17537 728 assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));
mbed_official 376:cb4d9db17537 729
mbed_official 376:cb4d9db17537 730 /* Get the User Option byte register */
mbed_official 376:cb4d9db17537 731 tmp1 = (FLASH->OBR & 0x800F0000) >> 16;
mbed_official 376:cb4d9db17537 732
mbed_official 376:cb4d9db17537 733 /* Calculate the user option byte to write */
mbed_official 376:cb4d9db17537 734 tmp = (uint32_t)(((uint32_t)~((uint32_t)((uint32_t)(OB_IWDG) | (uint32_t)(OB_STOP) | (uint32_t)(OB_STDBY) | tmp1))) << 16);
mbed_official 376:cb4d9db17537 735 tmp |= ((uint32_t)(OB_IWDG) | ((uint32_t)OB_STOP) | (uint32_t)(OB_STDBY) | tmp1);
mbed_official 376:cb4d9db17537 736
mbed_official 376:cb4d9db17537 737 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 738 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 739
mbed_official 376:cb4d9db17537 740 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 741 {
mbed_official 376:cb4d9db17537 742 /* Write the User Option Byte */
mbed_official 376:cb4d9db17537 743 OB->USER = tmp;
mbed_official 376:cb4d9db17537 744 }
mbed_official 376:cb4d9db17537 745
mbed_official 376:cb4d9db17537 746 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 747 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 748
mbed_official 376:cb4d9db17537 749 /* Return the Option Byte program Status */
mbed_official 376:cb4d9db17537 750 return status;
mbed_official 376:cb4d9db17537 751 }
mbed_official 376:cb4d9db17537 752
mbed_official 376:cb4d9db17537 753 /**
mbed_official 376:cb4d9db17537 754 * @brief Programs the FLASH brownout reset threshold level Option Byte.
mbed_official 376:cb4d9db17537 755 * @param OB_BOR: Selects the brownout reset threshold level.
mbed_official 376:cb4d9db17537 756 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 757 * @arg OB_BOR_OFF: BOR is disabled at power down, the reset is asserted when the VDD
mbed_official 376:cb4d9db17537 758 * power supply reaches the PDR(Power Down Reset) threshold (1.5V)
mbed_official 376:cb4d9db17537 759 * @arg OB_BOR_LEVEL1: BOR Reset threshold levels for 1.7V - 1.8V VDD power supply
mbed_official 376:cb4d9db17537 760 * @arg OB_BOR_LEVEL2: BOR Reset threshold levels for 1.9V - 2.0V VDD power supply
mbed_official 376:cb4d9db17537 761 * @arg OB_BOR_LEVEL3: BOR Reset threshold levels for 2.3V - 2.4V VDD power supply
mbed_official 376:cb4d9db17537 762 * @arg OB_BOR_LEVEL4: BOR Reset threshold levels for 2.55V - 2.65V VDD power supply
mbed_official 376:cb4d9db17537 763 * @arg OB_BOR_LEVEL5: BOR Reset threshold levels for 2.8V - 2.9V VDD power supply
mbed_official 376:cb4d9db17537 764 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 765 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 766 */
mbed_official 376:cb4d9db17537 767 static HAL_StatusTypeDef FLASH_OB_BOR_LevelConfig(uint8_t OB_BOR)
mbed_official 376:cb4d9db17537 768 {
mbed_official 376:cb4d9db17537 769 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 770 uint32_t tmp = 0, tmp1 = 0;
mbed_official 376:cb4d9db17537 771
mbed_official 376:cb4d9db17537 772 /* Check the parameters */
mbed_official 376:cb4d9db17537 773 assert_param(IS_OB_BOR_LEVEL(OB_BOR));
mbed_official 376:cb4d9db17537 774
mbed_official 376:cb4d9db17537 775 /* Get the User Option byte register */
mbed_official 376:cb4d9db17537 776 tmp1 = (FLASH->OBR & 0x000F0000) >> 16;
mbed_official 376:cb4d9db17537 777
mbed_official 376:cb4d9db17537 778 /* Calculate the option byte to write */
mbed_official 376:cb4d9db17537 779 tmp = (uint32_t)~(OB_BOR | tmp1)<<16;
mbed_official 376:cb4d9db17537 780 tmp |= (OB_BOR | tmp1);
mbed_official 376:cb4d9db17537 781
mbed_official 376:cb4d9db17537 782 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 783 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 784
mbed_official 376:cb4d9db17537 785 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 786 {
mbed_official 376:cb4d9db17537 787 /* Write the BOR Option Byte */
mbed_official 376:cb4d9db17537 788 OB->USER = tmp;
mbed_official 376:cb4d9db17537 789 }
mbed_official 376:cb4d9db17537 790
mbed_official 376:cb4d9db17537 791 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 792 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 793
mbed_official 376:cb4d9db17537 794 /* Return the Option Byte program Status */
mbed_official 376:cb4d9db17537 795 return status;
mbed_official 376:cb4d9db17537 796 }
mbed_official 376:cb4d9db17537 797
mbed_official 376:cb4d9db17537 798
mbed_official 376:cb4d9db17537 799 /**
mbed_official 376:cb4d9db17537 800 * @brief Enables or disables the read/write protection (PCROP) of the desired
mbed_official 376:cb4d9db17537 801 * sectors, for the first 64KB of the Flash.
mbed_official 376:cb4d9db17537 802 * @param OB_WRP: specifies the address of the pages to be write protected.
mbed_official 376:cb4d9db17537 803 * This parameter can be:
mbed_official 376:cb4d9db17537 804 * @arg value between OB_WRP_Pages0to31 and OB_WRP_Pages480to511
mbed_official 376:cb4d9db17537 805 * @arg OB_WRP_AllPages
mbed_official 376:cb4d9db17537 806 * @param NewState: new state of the specified FLASH Pages Write protection.
mbed_official 376:cb4d9db17537 807 * This parameter can be: ENABLE or DISABLE.
mbed_official 376:cb4d9db17537 808 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 809 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 810 */
mbed_official 376:cb4d9db17537 811 static HAL_StatusTypeDef FLASH_OB_PCROPConfig(uint32_t OB_WRP, FunctionalState NewState)
mbed_official 376:cb4d9db17537 812 {
mbed_official 376:cb4d9db17537 813 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 814 uint32_t WRP01_Data = 0;
mbed_official 376:cb4d9db17537 815 uint32_t tmp1 = 0;
mbed_official 376:cb4d9db17537 816
mbed_official 376:cb4d9db17537 817 /* Check the parameters */
mbed_official 376:cb4d9db17537 818 assert_param(IS_OB_WRP(OB_WRP));
mbed_official 376:cb4d9db17537 819 assert_param(IS_FUNCTIONAL_STATE(NewState));
mbed_official 376:cb4d9db17537 820
mbed_official 376:cb4d9db17537 821 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 822 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 823
mbed_official 376:cb4d9db17537 824 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 825 {
mbed_official 376:cb4d9db17537 826 if (NewState != DISABLE)
mbed_official 376:cb4d9db17537 827 {
mbed_official 376:cb4d9db17537 828 WRP01_Data = (uint16_t)(~OB_WRP & (WRP01_MASK & OB->WRP01));
mbed_official 376:cb4d9db17537 829
mbed_official 376:cb4d9db17537 830 tmp1 = (uint32_t)((~WRP01_Data) << 16)|(WRP01_Data);
mbed_official 376:cb4d9db17537 831 OB->WRP01 = tmp1;
mbed_official 376:cb4d9db17537 832 }
mbed_official 376:cb4d9db17537 833
mbed_official 376:cb4d9db17537 834 else
mbed_official 376:cb4d9db17537 835 {
mbed_official 376:cb4d9db17537 836 WRP01_Data = (uint16_t)((OB_WRP & WRP01_MASK) | OB->WRP01);
mbed_official 376:cb4d9db17537 837
mbed_official 376:cb4d9db17537 838 tmp1 = (uint32_t)(~(WRP01_Data) << 16)|(WRP01_Data);
mbed_official 376:cb4d9db17537 839 OB->WRP01 = tmp1;
mbed_official 376:cb4d9db17537 840 }
mbed_official 376:cb4d9db17537 841 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 842 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 843 }
mbed_official 376:cb4d9db17537 844
mbed_official 376:cb4d9db17537 845 /* Return the write protection operation Status */
mbed_official 376:cb4d9db17537 846 return status;
mbed_official 376:cb4d9db17537 847 }
mbed_official 376:cb4d9db17537 848
mbed_official 376:cb4d9db17537 849 /**
mbed_official 376:cb4d9db17537 850 * @brief Select the Protection Mode (SPRMOD).
mbed_official 376:cb4d9db17537 851 * @note Once SPRMOD bit is active, unprotection of a protected sector is not possible
mbed_official 376:cb4d9db17537 852 * @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
mbed_official 376:cb4d9db17537 853 * @param OB_PcROP: Select the Protection Mode of WPR bits.
mbed_official 376:cb4d9db17537 854 * This parameter can be:
mbed_official 376:cb4d9db17537 855 * @arg OB_PCROP_SELECTED: nWRP control the read&write protection (PcROP) of respective user sectors.
mbed_official 376:cb4d9db17537 856 * @arg OB_PCROP_DESELECTED: nWRP control the write protection of respective user sectors.
mbed_official 376:cb4d9db17537 857 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 858 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 859 */
mbed_official 376:cb4d9db17537 860 static HAL_StatusTypeDef FLASH_OB_PCROPSelectionConfig(uint16_t OB_PcROP)
mbed_official 376:cb4d9db17537 861 {
mbed_official 376:cb4d9db17537 862 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 863 uint16_t tmp1 = 0;
mbed_official 376:cb4d9db17537 864 uint32_t tmp2 = 0;
mbed_official 376:cb4d9db17537 865 uint8_t optiontmp = 0;
mbed_official 376:cb4d9db17537 866 uint16_t optiontmp2 = 0;
mbed_official 376:cb4d9db17537 867
mbed_official 376:cb4d9db17537 868 /* Check the parameters */
mbed_official 376:cb4d9db17537 869 assert_param(IS_OB_PCROP_SELECT(OB_PcROP));
mbed_official 376:cb4d9db17537 870
mbed_official 376:cb4d9db17537 871 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 872 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 873
mbed_official 376:cb4d9db17537 874 /* Mask RDP Byte */
mbed_official 376:cb4d9db17537 875 optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE));
mbed_official 376:cb4d9db17537 876
mbed_official 376:cb4d9db17537 877 /* Update Option Byte */
mbed_official 376:cb4d9db17537 878 optiontmp2 = (uint16_t)(OB_PcROP | optiontmp);
mbed_official 376:cb4d9db17537 879
mbed_official 376:cb4d9db17537 880
mbed_official 376:cb4d9db17537 881 /* calculate the option byte to write */
mbed_official 376:cb4d9db17537 882 tmp1 = (uint16_t)(~(optiontmp2 ));
mbed_official 376:cb4d9db17537 883 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16)) | ((uint32_t)optiontmp2));
mbed_official 376:cb4d9db17537 884
mbed_official 376:cb4d9db17537 885 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 886 {
mbed_official 376:cb4d9db17537 887 /* program PCRop */
mbed_official 376:cb4d9db17537 888 OB->RDP = tmp2;
mbed_official 376:cb4d9db17537 889 }
mbed_official 376:cb4d9db17537 890
mbed_official 376:cb4d9db17537 891 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 892 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 893
mbed_official 376:cb4d9db17537 894 /* Return the Read protection operation Status */
mbed_official 376:cb4d9db17537 895 return status;
mbed_official 376:cb4d9db17537 896 }
mbed_official 376:cb4d9db17537 897
mbed_official 376:cb4d9db17537 898 /**
mbed_official 376:cb4d9db17537 899 * @brief Select the Protection Mode (SPRMOD).
mbed_official 376:cb4d9db17537 900 * @note Once SPRMOD bit is active, unprotection of a protected sector is not possible
mbed_official 376:cb4d9db17537 901 * @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
mbed_official 376:cb4d9db17537 902 * @param None
mbed_official 376:cb4d9db17537 903 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 904 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 905 */
mbed_official 376:cb4d9db17537 906 HAL_StatusTypeDef HAL_FLASHEx_OB_SelectPCROP(void)
mbed_official 376:cb4d9db17537 907 {
mbed_official 376:cb4d9db17537 908 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 909 uint16_t tmp1 = 0;
mbed_official 376:cb4d9db17537 910 uint32_t tmp2 = 0;
mbed_official 376:cb4d9db17537 911 uint8_t optiontmp = 0;
mbed_official 376:cb4d9db17537 912 uint16_t optiontmp2 = 0;
mbed_official 376:cb4d9db17537 913
mbed_official 376:cb4d9db17537 914 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 915 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 916
mbed_official 376:cb4d9db17537 917 /* Mask RDP Byte */
mbed_official 376:cb4d9db17537 918 optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE));
mbed_official 376:cb4d9db17537 919
mbed_official 376:cb4d9db17537 920 /* Update Option Byte */
mbed_official 376:cb4d9db17537 921 optiontmp2 = (uint16_t)(FLASH_OBR_SPRMOD | optiontmp);
mbed_official 376:cb4d9db17537 922
mbed_official 376:cb4d9db17537 923
mbed_official 376:cb4d9db17537 924 /* calculate the option byte to write */
mbed_official 376:cb4d9db17537 925 tmp1 = (uint16_t)(~(optiontmp2 ));
mbed_official 376:cb4d9db17537 926 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16)) | ((uint32_t)optiontmp2));
mbed_official 376:cb4d9db17537 927
mbed_official 376:cb4d9db17537 928 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 929 {
mbed_official 376:cb4d9db17537 930 /* program PCRop */
mbed_official 376:cb4d9db17537 931 OB->RDP = tmp2;
mbed_official 376:cb4d9db17537 932 }
mbed_official 376:cb4d9db17537 933
mbed_official 376:cb4d9db17537 934 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 935 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 936
mbed_official 376:cb4d9db17537 937 /* Return the Read protection operation Status */
mbed_official 376:cb4d9db17537 938 return status;
mbed_official 376:cb4d9db17537 939
mbed_official 376:cb4d9db17537 940 }
mbed_official 376:cb4d9db17537 941
mbed_official 376:cb4d9db17537 942 /**
mbed_official 376:cb4d9db17537 943 * @brief Deselect the Protection Mode (SPRMOD).
mbed_official 376:cb4d9db17537 944 * @note Once SPRMOD bit is active, unprotection of a protected sector is not possible
mbed_official 376:cb4d9db17537 945 * @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
mbed_official 376:cb4d9db17537 946 * @param None
mbed_official 376:cb4d9db17537 947 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 948 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 949 */
mbed_official 376:cb4d9db17537 950 HAL_StatusTypeDef HAL_FLASHEx_OB_DeSelectPCROP(void)
mbed_official 376:cb4d9db17537 951 {
mbed_official 376:cb4d9db17537 952 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 953 uint16_t tmp1 = 0;
mbed_official 376:cb4d9db17537 954 uint32_t tmp2 = 0;
mbed_official 376:cb4d9db17537 955 uint8_t optiontmp = 0;
mbed_official 376:cb4d9db17537 956 uint16_t optiontmp2 = 0;
mbed_official 376:cb4d9db17537 957
mbed_official 376:cb4d9db17537 958 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 959 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 960
mbed_official 376:cb4d9db17537 961 /* Mask RDP Byte */
mbed_official 376:cb4d9db17537 962 optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE));
mbed_official 376:cb4d9db17537 963
mbed_official 376:cb4d9db17537 964 /* Update Option Byte */
mbed_official 376:cb4d9db17537 965 optiontmp2 = (uint16_t)(optiontmp);
mbed_official 376:cb4d9db17537 966
mbed_official 376:cb4d9db17537 967 /* calculate the option byte to write */
mbed_official 376:cb4d9db17537 968 tmp1 = (uint16_t)(~(optiontmp2 ));
mbed_official 376:cb4d9db17537 969 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16)) | ((uint32_t)optiontmp2));
mbed_official 376:cb4d9db17537 970
mbed_official 376:cb4d9db17537 971 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 972 {
mbed_official 376:cb4d9db17537 973 /* program PCRop */
mbed_official 376:cb4d9db17537 974 OB->RDP = tmp2;
mbed_official 376:cb4d9db17537 975 }
mbed_official 376:cb4d9db17537 976
mbed_official 376:cb4d9db17537 977 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 978 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 979
mbed_official 376:cb4d9db17537 980 /* Return the Read protection operation Status */
mbed_official 376:cb4d9db17537 981 return status;
mbed_official 376:cb4d9db17537 982 }
mbed_official 376:cb4d9db17537 983
mbed_official 376:cb4d9db17537 984
mbed_official 376:cb4d9db17537 985 /**
mbed_official 376:cb4d9db17537 986 * @brief Sets or resets the BOOT1 option bit.
mbed_official 376:cb4d9db17537 987 * @param OB_BOOT1: Set or Reset the BOOT1 option bit.
mbed_official 376:cb4d9db17537 988 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 989 * @arg OB_BOOT1_RESET: BOOT1 option bit reset
mbed_official 376:cb4d9db17537 990 * @arg OB_BOOT1_SET: BOOT1 option bit set
mbed_official 376:cb4d9db17537 991 * @retval None
mbed_official 376:cb4d9db17537 992 */
mbed_official 376:cb4d9db17537 993 static HAL_StatusTypeDef FLASH_OB_BootConfig(uint16_t OB_BOOT)
mbed_official 376:cb4d9db17537 994 {
mbed_official 376:cb4d9db17537 995 HAL_StatusTypeDef status = HAL_OK;
mbed_official 376:cb4d9db17537 996 uint32_t tmp = 0, tmp1 = 0;
mbed_official 376:cb4d9db17537 997
mbed_official 376:cb4d9db17537 998 /* Check the parameters */
mbed_official 376:cb4d9db17537 999 assert_param(IS_OB_BOOT1(OB_BOOT));
mbed_official 376:cb4d9db17537 1000
mbed_official 376:cb4d9db17537 1001 /* Get the User Option byte register */
mbed_official 376:cb4d9db17537 1002 tmp1 = (FLASH->OBR & 0x007F0000) >> 16;
mbed_official 376:cb4d9db17537 1003
mbed_official 376:cb4d9db17537 1004 /* Calculate the option byte to write */
mbed_official 376:cb4d9db17537 1005 tmp = (uint32_t)~(OB_BOOT | tmp1)<<16;
mbed_official 376:cb4d9db17537 1006 tmp |= (OB_BOOT | tmp1);
mbed_official 376:cb4d9db17537 1007
mbed_official 376:cb4d9db17537 1008 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1009 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1010
mbed_official 376:cb4d9db17537 1011 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1012 {
mbed_official 376:cb4d9db17537 1013 /* Write the BOOT Option Byte */
mbed_official 376:cb4d9db17537 1014 OB->USER = tmp;
mbed_official 376:cb4d9db17537 1015 }
mbed_official 376:cb4d9db17537 1016
mbed_official 376:cb4d9db17537 1017 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1018 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1019
mbed_official 376:cb4d9db17537 1020 /* Return the Option Byte program Status */
mbed_official 376:cb4d9db17537 1021 return status;
mbed_official 376:cb4d9db17537 1022 }
mbed_official 376:cb4d9db17537 1023
mbed_official 376:cb4d9db17537 1024 /**
mbed_official 376:cb4d9db17537 1025 * @brief Write a Byte at a specified address in data memory.
mbed_official 376:cb4d9db17537 1026 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
mbed_official 376:cb4d9db17537 1027 * must be called before.
mbed_official 376:cb4d9db17537 1028 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
mbed_official 376:cb4d9db17537 1029 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 1030 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 1031 * @param Address: specifies the address to be written.
mbed_official 376:cb4d9db17537 1032 * @param Data: specifies the data to be written.
mbed_official 376:cb4d9db17537 1033 * @note This function assumes that data word is already erased.
mbed_official 376:cb4d9db17537 1034 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 1035 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 1036 */
mbed_official 376:cb4d9db17537 1037 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramByte(uint32_t Address, uint8_t Data)
mbed_official 376:cb4d9db17537 1038 {
mbed_official 376:cb4d9db17537 1039 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 1040
mbed_official 376:cb4d9db17537 1041 /* Check the parameters */
mbed_official 376:cb4d9db17537 1042 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 1043
mbed_official 376:cb4d9db17537 1044 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1045 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1046
mbed_official 376:cb4d9db17537 1047 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1048 {
mbed_official 376:cb4d9db17537 1049 /* Clear the FTDW bit */
mbed_official 376:cb4d9db17537 1050 FLASH->PECR &= (uint32_t)(~((uint32_t)FLASH_PECR_FTDW));
mbed_official 376:cb4d9db17537 1051
mbed_official 376:cb4d9db17537 1052 /* If the previous operation is completed, proceed to write the new Data */
mbed_official 376:cb4d9db17537 1053 *(__IO uint8_t *)Address = Data;
mbed_official 376:cb4d9db17537 1054
mbed_official 376:cb4d9db17537 1055 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1056 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1057 }
mbed_official 376:cb4d9db17537 1058 /* Return the Write Status */
mbed_official 376:cb4d9db17537 1059 return status;
mbed_official 376:cb4d9db17537 1060 }
mbed_official 376:cb4d9db17537 1061
mbed_official 376:cb4d9db17537 1062 /**
mbed_official 376:cb4d9db17537 1063 * @brief Writes a half word at a specified address in data memory.
mbed_official 376:cb4d9db17537 1064 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
mbed_official 376:cb4d9db17537 1065 * must be called before.
mbed_official 376:cb4d9db17537 1066 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to he data EEPROM access
mbed_official 376:cb4d9db17537 1067 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 1068 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 1069 * @param Address: specifies the address to be written.
mbed_official 376:cb4d9db17537 1070 * @param Data: specifies the data to be written.
mbed_official 376:cb4d9db17537 1071 * @note This function assumes that the is data word is already erased.
mbed_official 376:cb4d9db17537 1072 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 1073 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 1074 */
mbed_official 376:cb4d9db17537 1075 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramHalfWord(uint32_t Address, uint16_t Data)
mbed_official 376:cb4d9db17537 1076 {
mbed_official 376:cb4d9db17537 1077 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 1078
mbed_official 376:cb4d9db17537 1079 /* Check the parameters */
mbed_official 376:cb4d9db17537 1080 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 1081
mbed_official 376:cb4d9db17537 1082 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1083 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1084
mbed_official 376:cb4d9db17537 1085 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1086 {
mbed_official 376:cb4d9db17537 1087 /* Clear the FTDW bit */
mbed_official 376:cb4d9db17537 1088 FLASH->PECR &= (uint32_t)(~((uint32_t)FLASH_PECR_FTDW));
mbed_official 376:cb4d9db17537 1089
mbed_official 376:cb4d9db17537 1090 /* If the previous operation is completed, proceed to write the new data */
mbed_official 376:cb4d9db17537 1091 *(__IO uint16_t *)Address = Data;
mbed_official 376:cb4d9db17537 1092
mbed_official 376:cb4d9db17537 1093 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1094 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1095 }
mbed_official 376:cb4d9db17537 1096 /* Return the Write Status */
mbed_official 376:cb4d9db17537 1097 return status;
mbed_official 376:cb4d9db17537 1098 }
mbed_official 376:cb4d9db17537 1099
mbed_official 376:cb4d9db17537 1100 /**
mbed_official 376:cb4d9db17537 1101 * @brief Programs a word at a specified address in data memory.
mbed_official 376:cb4d9db17537 1102 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
mbed_official 376:cb4d9db17537 1103 * must be called before.
mbed_official 376:cb4d9db17537 1104 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
mbed_official 376:cb4d9db17537 1105 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 1106 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 1107 * @param Address: specifies the address to be written.
mbed_official 376:cb4d9db17537 1108 * @param Data: specifies the data to be written.
mbed_official 376:cb4d9db17537 1109 * @note This function assumes that the is data word is already erased.
mbed_official 376:cb4d9db17537 1110 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 1111 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 1112 */
mbed_official 376:cb4d9db17537 1113 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramWord(uint32_t Address, uint32_t Data)
mbed_official 376:cb4d9db17537 1114 {
mbed_official 376:cb4d9db17537 1115 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 1116
mbed_official 376:cb4d9db17537 1117 /* Check the parameters */
mbed_official 376:cb4d9db17537 1118 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 1119
mbed_official 376:cb4d9db17537 1120 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1121 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1122
mbed_official 376:cb4d9db17537 1123 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1124 {
mbed_official 376:cb4d9db17537 1125 /* Clear the FTDW bit */
mbed_official 376:cb4d9db17537 1126 FLASH->PECR &= (uint32_t)(~((uint32_t)FLASH_PECR_FTDW));
mbed_official 376:cb4d9db17537 1127
mbed_official 376:cb4d9db17537 1128 /* If the previous operation is completed, proceed to program the new data */
mbed_official 376:cb4d9db17537 1129 *(__IO uint32_t *)Address = Data;
mbed_official 376:cb4d9db17537 1130
mbed_official 376:cb4d9db17537 1131 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1132 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1133 }
mbed_official 376:cb4d9db17537 1134 /* Return the Write Status */
mbed_official 376:cb4d9db17537 1135 return status;
mbed_official 376:cb4d9db17537 1136 }
mbed_official 376:cb4d9db17537 1137
mbed_official 376:cb4d9db17537 1138 /**
mbed_official 376:cb4d9db17537 1139 * @brief Write a Byte at a specified address in data memory without erase.
mbed_official 376:cb4d9db17537 1140 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
mbed_official 376:cb4d9db17537 1141 * must be called before.
mbed_official 376:cb4d9db17537 1142 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to he data EEPROM access
mbed_official 376:cb4d9db17537 1143 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 1144 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 1145 * @param Address: specifies the address to be written.
mbed_official 376:cb4d9db17537 1146 * @param Data: specifies the data to be written.
mbed_official 376:cb4d9db17537 1147 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 1148 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 1149 */
mbed_official 376:cb4d9db17537 1150 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramByte(uint32_t Address, uint8_t Data)
mbed_official 376:cb4d9db17537 1151 {
mbed_official 376:cb4d9db17537 1152 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 1153
mbed_official 376:cb4d9db17537 1154 /* Check the parameters */
mbed_official 376:cb4d9db17537 1155 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 1156
mbed_official 376:cb4d9db17537 1157 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1158 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1159
mbed_official 376:cb4d9db17537 1160 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1161 {
mbed_official 376:cb4d9db17537 1162 /* Set the FTDW bit */
mbed_official 376:cb4d9db17537 1163 FLASH->PECR |= (uint32_t)FLASH_PECR_FTDW;
mbed_official 376:cb4d9db17537 1164
mbed_official 376:cb4d9db17537 1165 *(__IO uint8_t *)Address = Data;
mbed_official 376:cb4d9db17537 1166
mbed_official 376:cb4d9db17537 1167 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1168 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1169 }
mbed_official 376:cb4d9db17537 1170 /* Return the Write Status */
mbed_official 376:cb4d9db17537 1171 return status;
mbed_official 376:cb4d9db17537 1172 }
mbed_official 376:cb4d9db17537 1173
mbed_official 376:cb4d9db17537 1174 /**
mbed_official 376:cb4d9db17537 1175 * @brief Writes a half word at a specified address in data memory without erase.
mbed_official 376:cb4d9db17537 1176 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock function
mbed_official 376:cb4d9db17537 1177 * must be called before.
mbed_official 376:cb4d9db17537 1178 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to he data EEPROM access
mbed_official 376:cb4d9db17537 1179 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 1180 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 1181 * @param Address: specifies the address to be written.
mbed_official 376:cb4d9db17537 1182 * @param Data: specifies the data to be written.
mbed_official 376:cb4d9db17537 1183 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 1184 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 1185 */
mbed_official 376:cb4d9db17537 1186 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramHalfWord(uint32_t Address, uint16_t Data)
mbed_official 376:cb4d9db17537 1187 {
mbed_official 376:cb4d9db17537 1188 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 1189
mbed_official 376:cb4d9db17537 1190 /* Check the parameters */
mbed_official 376:cb4d9db17537 1191 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 1192
mbed_official 376:cb4d9db17537 1193 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1194 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1195
mbed_official 376:cb4d9db17537 1196 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1197 {
mbed_official 376:cb4d9db17537 1198 /* Set the FTDW bit */
mbed_official 376:cb4d9db17537 1199 FLASH->PECR |= (uint32_t)FLASH_PECR_FTDW;
mbed_official 376:cb4d9db17537 1200
mbed_official 376:cb4d9db17537 1201 *(__IO uint16_t *)Address = Data;
mbed_official 376:cb4d9db17537 1202
mbed_official 376:cb4d9db17537 1203 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1204 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1205 }
mbed_official 376:cb4d9db17537 1206 /* Return the Write Status */
mbed_official 376:cb4d9db17537 1207 return status;
mbed_official 376:cb4d9db17537 1208 }
mbed_official 376:cb4d9db17537 1209
mbed_official 376:cb4d9db17537 1210 /**
mbed_official 376:cb4d9db17537 1211 * @brief Programs a word at a specified address in data memory without erase.
mbed_official 376:cb4d9db17537 1212 * @note To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
mbed_official 376:cb4d9db17537 1213 * must be called before.
mbed_official 376:cb4d9db17537 1214 * Call the HAL_FLASHEx_DATAEEPROM_Lock() to he data EEPROM access
mbed_official 376:cb4d9db17537 1215 * and Flash program erase control register access(recommended to protect
mbed_official 376:cb4d9db17537 1216 * the DATA_EEPROM against possible unwanted operation).
mbed_official 376:cb4d9db17537 1217 * @param Address: specifies the address to be written.
mbed_official 376:cb4d9db17537 1218 * @param Data: specifies the data to be written.
mbed_official 376:cb4d9db17537 1219 * @retval FLASH Status: The returned value can be:
mbed_official 376:cb4d9db17537 1220 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 376:cb4d9db17537 1221 */
mbed_official 376:cb4d9db17537 1222 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramWord(uint32_t Address, uint32_t Data)
mbed_official 376:cb4d9db17537 1223 {
mbed_official 376:cb4d9db17537 1224 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 376:cb4d9db17537 1225
mbed_official 376:cb4d9db17537 1226 /* Check the parameters */
mbed_official 376:cb4d9db17537 1227 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 376:cb4d9db17537 1228
mbed_official 376:cb4d9db17537 1229 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1230 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1231
mbed_official 376:cb4d9db17537 1232 if(status == HAL_OK)
mbed_official 376:cb4d9db17537 1233 {
mbed_official 376:cb4d9db17537 1234 /* Set the FTDW bit */
mbed_official 376:cb4d9db17537 1235 FLASH->PECR |= (uint32_t)FLASH_PECR_FTDW;
mbed_official 376:cb4d9db17537 1236
mbed_official 376:cb4d9db17537 1237 *(__IO uint32_t *)Address = Data;
mbed_official 376:cb4d9db17537 1238
mbed_official 376:cb4d9db17537 1239 /* Wait for last operation to be completed */
mbed_official 376:cb4d9db17537 1240 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE));
mbed_official 376:cb4d9db17537 1241 }
mbed_official 376:cb4d9db17537 1242 /* Return the Write Status */
mbed_official 376:cb4d9db17537 1243 return status;
mbed_official 376:cb4d9db17537 1244 }
mbed_official 376:cb4d9db17537 1245
mbed_official 376:cb4d9db17537 1246
mbed_official 376:cb4d9db17537 1247 /**
mbed_official 376:cb4d9db17537 1248 * @}
mbed_official 376:cb4d9db17537 1249 */
mbed_official 376:cb4d9db17537 1250 #endif /* HAL_FLASH_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1251
mbed_official 376:cb4d9db17537 1252 /**
mbed_official 376:cb4d9db17537 1253 * @}
mbed_official 376:cb4d9db17537 1254 */
mbed_official 376:cb4d9db17537 1255
mbed_official 376:cb4d9db17537 1256 /**
mbed_official 376:cb4d9db17537 1257 * @}
mbed_official 376:cb4d9db17537 1258 */
mbed_official 376:cb4d9db17537 1259
mbed_official 376:cb4d9db17537 1260
mbed_official 376:cb4d9db17537 1261 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 376:cb4d9db17537 1262
mbed_official 376:cb4d9db17537 1263