Steve Kim / mbed-src-test

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_DISCO_L053C8/stm32l0xx_hal_flash_ex.c@376:cb4d9db17537, 2014-10-31 (annotated)

Committer:
mbed_official
Date:
Fri Oct 31 11:00:10 2014 +0000
Revision:
376:cb4d9db17537
Synchronized with git revision 07b49da75eac883fc8916d3d6b6962664b8db29e



Full URL: https://github.com/mbedmicro/mbed/commit/07b49da75eac883fc8916d3d6b6962664b8db29e/



Targets: DISCO_L053C8 - new platform - STM32L0 Discovery board

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