mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F0/device/stm32f0xx_hal_flash.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
180:96ed750bd169 
mbed library release version 165

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f0xx_hal_flash.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @brief FLASH HAL module driver.
<> 144:ef7eb2e8f9f7 6 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 7 * functionalities of the internal FLASH memory:
<> 144:ef7eb2e8f9f7 8 * + Program operations functions
<> 144:ef7eb2e8f9f7 9 * + Memory Control functions
<> 144:ef7eb2e8f9f7 10 * + Peripheral State functions
<> 144:ef7eb2e8f9f7 11 *
<> 144:ef7eb2e8f9f7 12 @verbatim
<> 144:ef7eb2e8f9f7 13 ==============================================================================
<> 144:ef7eb2e8f9f7 14 ##### FLASH peripheral features #####
<> 144:ef7eb2e8f9f7 15 ==============================================================================
<> 144:ef7eb2e8f9f7 16 [..] The Flash memory interface manages CPU AHB I-Code and D-Code accesses
<> 144:ef7eb2e8f9f7 17 to the Flash memory. It implements the erase and program Flash memory operations
<> 144:ef7eb2e8f9f7 18 and the read and write protection mechanisms.
<> 144:ef7eb2e8f9f7 19
<> 144:ef7eb2e8f9f7 20 [..] The Flash memory interface accelerates code execution with a system of instruction
<> 144:ef7eb2e8f9f7 21 prefetch.
<> 144:ef7eb2e8f9f7 22
<> 144:ef7eb2e8f9f7 23 [..] The FLASH main features are:
<> 144:ef7eb2e8f9f7 24 (+) Flash memory read operations
<> 144:ef7eb2e8f9f7 25 (+) Flash memory program/erase operations
<> 144:ef7eb2e8f9f7 26 (+) Read / write protections
<> 144:ef7eb2e8f9f7 27 (+) Prefetch on I-Code
<> 144:ef7eb2e8f9f7 28 (+) Option Bytes programming
<> 144:ef7eb2e8f9f7 29
<> 144:ef7eb2e8f9f7 30
<> 144:ef7eb2e8f9f7 31 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 32 ==============================================================================
<> 144:ef7eb2e8f9f7 33 [..]
<> 144:ef7eb2e8f9f7 34 This driver provides functions and macros to configure and program the FLASH
<> 144:ef7eb2e8f9f7 35 memory of all STM32F0xx devices.
<> 144:ef7eb2e8f9f7 36
<> 144:ef7eb2e8f9f7 37 (#) FLASH Memory I/O Programming functions: this group includes all needed
<> 144:ef7eb2e8f9f7 38 functions to erase and program the main memory:
<> 144:ef7eb2e8f9f7 39 (++) Lock and Unlock the FLASH interface
<> 144:ef7eb2e8f9f7 40 (++) Erase function: Erase page, erase all pages
<> 144:ef7eb2e8f9f7 41 (++) Program functions: half word, word and doubleword
<> 144:ef7eb2e8f9f7 42 (#) FLASH Option Bytes Programming functions: this group includes all needed
<> 144:ef7eb2e8f9f7 43 functions to manage the Option Bytes:
<> 144:ef7eb2e8f9f7 44 (++) Lock and Unlock the Option Bytes
<> 144:ef7eb2e8f9f7 45 (++) Set/Reset the write protection
<> 144:ef7eb2e8f9f7 46 (++) Set the Read protection Level
<> 144:ef7eb2e8f9f7 47 (++) Program the user Option Bytes
<> 144:ef7eb2e8f9f7 48 (++) Launch the Option Bytes loader
<> 144:ef7eb2e8f9f7 49 (++) Erase Option Bytes
<> 144:ef7eb2e8f9f7 50 (++) Program the data Option Bytes
<> 144:ef7eb2e8f9f7 51 (++) Get the Write protection.
<> 144:ef7eb2e8f9f7 52 (++) Get the user option bytes.
<> 144:ef7eb2e8f9f7 53
<> 144:ef7eb2e8f9f7 54 (#) Interrupts and flags management functions : this group
<> 144:ef7eb2e8f9f7 55 includes all needed functions to:
<> 144:ef7eb2e8f9f7 56 (++) Handle FLASH interrupts
<> 144:ef7eb2e8f9f7 57 (++) Wait for last FLASH operation according to its status
<> 144:ef7eb2e8f9f7 58 (++) Get error flag status
<> 144:ef7eb2e8f9f7 59
<> 144:ef7eb2e8f9f7 60 [..] In addition to these function, this driver includes a set of macros allowing
<> 144:ef7eb2e8f9f7 61 to handle the following operations:
<> 144:ef7eb2e8f9f7 62
<> 144:ef7eb2e8f9f7 63 (+) Set/Get the latency
<> 144:ef7eb2e8f9f7 64 (+) Enable/Disable the prefetch buffer
<> 144:ef7eb2e8f9f7 65 (+) Enable/Disable the FLASH interrupts
<> 144:ef7eb2e8f9f7 66 (+) Monitor the FLASH flags status
<> 144:ef7eb2e8f9f7 67
<> 144:ef7eb2e8f9f7 68 @endverbatim
<> 144:ef7eb2e8f9f7 69 ******************************************************************************
<> 144:ef7eb2e8f9f7 70 * @attention
<> 144:ef7eb2e8f9f7 71 *
<> 144:ef7eb2e8f9f7 72 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 73 *
<> 144:ef7eb2e8f9f7 74 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 75 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 76 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 77 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 78 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 79 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 80 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 81 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 82 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 83 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 84 *
<> 144:ef7eb2e8f9f7 85 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 86 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 87 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 88 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 89 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 90 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 92 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 93 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 94 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 95 *
<> 144:ef7eb2e8f9f7 96 ******************************************************************************
<> 144:ef7eb2e8f9f7 97 */
<> 144:ef7eb2e8f9f7 98
<> 144:ef7eb2e8f9f7 99 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 100 #include "stm32f0xx_hal.h"
<> 144:ef7eb2e8f9f7 101
<> 144:ef7eb2e8f9f7 102 /** @addtogroup STM32F0xx_HAL_Driver
<> 144:ef7eb2e8f9f7 103 * @{
<> 144:ef7eb2e8f9f7 104 */
<> 144:ef7eb2e8f9f7 105
<> 144:ef7eb2e8f9f7 106 #ifdef HAL_FLASH_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 107
<> 144:ef7eb2e8f9f7 108 /** @defgroup FLASH FLASH
<> 144:ef7eb2e8f9f7 109 * @brief FLASH HAL module driver
<> 144:ef7eb2e8f9f7 110 * @{
<> 144:ef7eb2e8f9f7 111 */
<> 144:ef7eb2e8f9f7 112
<> 144:ef7eb2e8f9f7 113 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 114 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 115 /** @defgroup FLASH_Private_Constants FLASH Private Constants
<> 144:ef7eb2e8f9f7 116 * @{
<> 144:ef7eb2e8f9f7 117 */
<> 144:ef7eb2e8f9f7 118 /**
<> 144:ef7eb2e8f9f7 119 * @}
<> 144:ef7eb2e8f9f7 120 */
<> 144:ef7eb2e8f9f7 121
<> 144:ef7eb2e8f9f7 122 /* Private macro ---------------------------- ---------------------------------*/
<> 144:ef7eb2e8f9f7 123 /** @defgroup FLASH_Private_Macros FLASH Private Macros
<> 144:ef7eb2e8f9f7 124 * @{
<> 144:ef7eb2e8f9f7 125 */
<> 144:ef7eb2e8f9f7 126
<> 144:ef7eb2e8f9f7 127 /**
<> 144:ef7eb2e8f9f7 128 * @}
<> 144:ef7eb2e8f9f7 129 */
<> 144:ef7eb2e8f9f7 130
<> 144:ef7eb2e8f9f7 131 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 132 /** @defgroup FLASH_Private_Variables FLASH Private Variables
<> 144:ef7eb2e8f9f7 133 * @{
<> 144:ef7eb2e8f9f7 134 */
<> 144:ef7eb2e8f9f7 135 /* Variables used for Erase pages under interruption*/
<> 144:ef7eb2e8f9f7 136 FLASH_ProcessTypeDef pFlash;
<> 144:ef7eb2e8f9f7 137 /**
<> 144:ef7eb2e8f9f7 138 * @}
<> 144:ef7eb2e8f9f7 139 */
<> 144:ef7eb2e8f9f7 140
<> 144:ef7eb2e8f9f7 141 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 142 /** @defgroup FLASH_Private_Functions FLASH Private Functions
<> 144:ef7eb2e8f9f7 143 * @{
<> 144:ef7eb2e8f9f7 144 */
<> 144:ef7eb2e8f9f7 145 static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data);
<> 144:ef7eb2e8f9f7 146 static void FLASH_SetErrorCode(void);
<> 144:ef7eb2e8f9f7 147 extern void FLASH_PageErase(uint32_t PageAddress);
<> 144:ef7eb2e8f9f7 148 /**
<> 144:ef7eb2e8f9f7 149 * @}
<> 144:ef7eb2e8f9f7 150 */
<> 144:ef7eb2e8f9f7 151
<> 144:ef7eb2e8f9f7 152 /* Exported functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 153 /** @defgroup FLASH_Exported_Functions FLASH Exported Functions
<> 144:ef7eb2e8f9f7 154 * @{
<> 144:ef7eb2e8f9f7 155 */
<> 144:ef7eb2e8f9f7 156
<> 144:ef7eb2e8f9f7 157 /** @defgroup FLASH_Exported_Functions_Group1 Programming operation functions
<> 144:ef7eb2e8f9f7 158 * @brief Programming operation functions
<> 144:ef7eb2e8f9f7 159 *
<> 144:ef7eb2e8f9f7 160 @verbatim
<> 144:ef7eb2e8f9f7 161 @endverbatim
<> 144:ef7eb2e8f9f7 162 * @{
<> 144:ef7eb2e8f9f7 163 */
<> 144:ef7eb2e8f9f7 164
<> 144:ef7eb2e8f9f7 165 /**
<> 144:ef7eb2e8f9f7 166 * @brief Program halfword, word or double word at a specified address
<> 144:ef7eb2e8f9f7 167 * @note The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface
<> 144:ef7eb2e8f9f7 168 * The function HAL_FLASH_Lock() should be called after to lock the FLASH interface
<> 144:ef7eb2e8f9f7 169 *
<> 144:ef7eb2e8f9f7 170 * @note If an erase and a program operations are requested simultaneously,
<> 144:ef7eb2e8f9f7 171 * the erase operation is performed before the program one.
<> 144:ef7eb2e8f9f7 172 *
<> 144:ef7eb2e8f9f7 173 * @note FLASH should be previously erased before new programmation (only exception to this
<> 144:ef7eb2e8f9f7 174 * is when 0x0000 is programmed)
<> 144:ef7eb2e8f9f7 175 *
<> 156:95d6b41a828b 176 * @param TypeProgram Indicate the way to program at a specified address.
<> 144:ef7eb2e8f9f7 177 * This parameter can be a value of @ref FLASH_Type_Program
<> 156:95d6b41a828b 178 * @param Address Specifie the address to be programmed.
<> 156:95d6b41a828b 179 * @param Data Specifie the data to be programmed
<> 144:ef7eb2e8f9f7 180 *
<> 144:ef7eb2e8f9f7 181 * @retval HAL_StatusTypeDef HAL Status
<> 144:ef7eb2e8f9f7 182 */
<> 144:ef7eb2e8f9f7 183 HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint64_t Data)
<> 144:ef7eb2e8f9f7 184 {
<> 144:ef7eb2e8f9f7 185 HAL_StatusTypeDef status = HAL_ERROR;
<> 156:95d6b41a828b 186 uint8_t index = 0U;
<> 156:95d6b41a828b 187 uint8_t nbiterations = 0U;
<> 144:ef7eb2e8f9f7 188
<> 144:ef7eb2e8f9f7 189 /* Process Locked */
<> 144:ef7eb2e8f9f7 190 __HAL_LOCK(&pFlash);
<> 144:ef7eb2e8f9f7 191
<> 144:ef7eb2e8f9f7 192 /* Check the parameters */
<> 144:ef7eb2e8f9f7 193 assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
<> 144:ef7eb2e8f9f7 194 assert_param(IS_FLASH_PROGRAM_ADDRESS(Address));
<> 144:ef7eb2e8f9f7 195
<> 144:ef7eb2e8f9f7 196 /* Wait for last operation to be completed */
<> 144:ef7eb2e8f9f7 197 status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
<> 144:ef7eb2e8f9f7 198
<> 144:ef7eb2e8f9f7 199 if(status == HAL_OK)
<> 144:ef7eb2e8f9f7 200 {
<> 144:ef7eb2e8f9f7 201 if(TypeProgram == FLASH_TYPEPROGRAM_HALFWORD)
<> 144:ef7eb2e8f9f7 202 {
<> 144:ef7eb2e8f9f7 203 /* Program halfword (16-bit) at a specified address. */
<> 156:95d6b41a828b 204 nbiterations = 1U;
<> 144:ef7eb2e8f9f7 205 }
<> 144:ef7eb2e8f9f7 206 else if(TypeProgram == FLASH_TYPEPROGRAM_WORD)
<> 144:ef7eb2e8f9f7 207 {
<> 144:ef7eb2e8f9f7 208 /* Program word (32-bit = 2*16-bit) at a specified address. */
<> 156:95d6b41a828b 209 nbiterations = 2U;
<> 144:ef7eb2e8f9f7 210 }
<> 144:ef7eb2e8f9f7 211 else
<> 144:ef7eb2e8f9f7 212 {
<> 144:ef7eb2e8f9f7 213 /* Program double word (64-bit = 4*16-bit) at a specified address. */
<> 156:95d6b41a828b 214 nbiterations = 4U;
<> 144:ef7eb2e8f9f7 215 }
<> 144:ef7eb2e8f9f7 216
<> 156:95d6b41a828b 217 for (index = 0U; index < nbiterations; index++)
<> 144:ef7eb2e8f9f7 218 {
<> 156:95d6b41a828b 219 FLASH_Program_HalfWord((Address + (2U*index)), (uint16_t)(Data >> (16U*index)));
<> 144:ef7eb2e8f9f7 220
<> 144:ef7eb2e8f9f7 221 /* Wait for last operation to be completed */
<> 144:ef7eb2e8f9f7 222 status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
<> 144:ef7eb2e8f9f7 223
<> 144:ef7eb2e8f9f7 224 /* If the program operation is completed, disable the PG Bit */
<> 144:ef7eb2e8f9f7 225 CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
<> 144:ef7eb2e8f9f7 226 /* In case of error, stop programation procedure */
<> 144:ef7eb2e8f9f7 227 if (status != HAL_OK)
<> 144:ef7eb2e8f9f7 228 {
<> 144:ef7eb2e8f9f7 229 break;
<> 144:ef7eb2e8f9f7 230 }
<> 144:ef7eb2e8f9f7 231 }
<> 144:ef7eb2e8f9f7 232 }
<> 144:ef7eb2e8f9f7 233
<> 144:ef7eb2e8f9f7 234 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 235 __HAL_UNLOCK(&pFlash);
<> 144:ef7eb2e8f9f7 236
<> 144:ef7eb2e8f9f7 237 return status;
<> 144:ef7eb2e8f9f7 238 }
<> 144:ef7eb2e8f9f7 239
<> 144:ef7eb2e8f9f7 240 /**
<> 144:ef7eb2e8f9f7 241 * @brief Program halfword, word or double word at a specified address with interrupt enabled.
<> 144:ef7eb2e8f9f7 242 * @note The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface
<> 144:ef7eb2e8f9f7 243 * The function HAL_FLASH_Lock() should be called after to lock the FLASH interface
<> 144:ef7eb2e8f9f7 244 *
<> 144:ef7eb2e8f9f7 245 * @note If an erase and a program operations are requested simultaneously,
<> 144:ef7eb2e8f9f7 246 * the erase operation is performed before the program one.
<> 144:ef7eb2e8f9f7 247 *
<> 156:95d6b41a828b 248 * @param TypeProgram Indicate the way to program at a specified address.
<> 144:ef7eb2e8f9f7 249 * This parameter can be a value of @ref FLASH_Type_Program
<> 156:95d6b41a828b 250 * @param Address Specifie the address to be programmed.
<> 156:95d6b41a828b 251 * @param Data Specifie the data to be programmed
<> 144:ef7eb2e8f9f7 252 *
<> 144:ef7eb2e8f9f7 253 * @retval HAL_StatusTypeDef HAL Status
<> 144:ef7eb2e8f9f7 254 */
<> 144:ef7eb2e8f9f7 255 HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint64_t Data)
<> 144:ef7eb2e8f9f7 256 {
<> 144:ef7eb2e8f9f7 257 HAL_StatusTypeDef status = HAL_OK;
<> 144:ef7eb2e8f9f7 258
<> 144:ef7eb2e8f9f7 259 /* Process Locked */
<> 144:ef7eb2e8f9f7 260 __HAL_LOCK(&pFlash);
<> 144:ef7eb2e8f9f7 261
<> 144:ef7eb2e8f9f7 262 /* Check the parameters */
<> 144:ef7eb2e8f9f7 263 assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
<> 144:ef7eb2e8f9f7 264 assert_param(IS_FLASH_PROGRAM_ADDRESS(Address));
<> 144:ef7eb2e8f9f7 265
<> 144:ef7eb2e8f9f7 266 /* Enable End of FLASH Operation and Error source interrupts */
<> 144:ef7eb2e8f9f7 267 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR);
<> 144:ef7eb2e8f9f7 268
<> 144:ef7eb2e8f9f7 269 pFlash.Address = Address;
<> 144:ef7eb2e8f9f7 270 pFlash.Data = Data;
<> 144:ef7eb2e8f9f7 271
<> 144:ef7eb2e8f9f7 272 if(TypeProgram == FLASH_TYPEPROGRAM_HALFWORD)
<> 144:ef7eb2e8f9f7 273 {
<> 144:ef7eb2e8f9f7 274 pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAMHALFWORD;
<> 144:ef7eb2e8f9f7 275 /* Program halfword (16-bit) at a specified address. */
<> 156:95d6b41a828b 276 pFlash.DataRemaining = 1U;
<> 144:ef7eb2e8f9f7 277 }
<> 144:ef7eb2e8f9f7 278 else if(TypeProgram == FLASH_TYPEPROGRAM_WORD)
<> 144:ef7eb2e8f9f7 279 {
<> 144:ef7eb2e8f9f7 280 pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAMWORD;
<> 144:ef7eb2e8f9f7 281 /* Program word (32-bit : 2*16-bit) at a specified address. */
<> 156:95d6b41a828b 282 pFlash.DataRemaining = 2U;
<> 144:ef7eb2e8f9f7 283 }
<> 144:ef7eb2e8f9f7 284 else
<> 144:ef7eb2e8f9f7 285 {
<> 144:ef7eb2e8f9f7 286 pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAMDOUBLEWORD;
<> 144:ef7eb2e8f9f7 287 /* Program double word (64-bit : 4*16-bit) at a specified address. */
<> 156:95d6b41a828b 288 pFlash.DataRemaining = 4U;
<> 144:ef7eb2e8f9f7 289 }
<> 144:ef7eb2e8f9f7 290
<> 144:ef7eb2e8f9f7 291 /* Program halfword (16-bit) at a specified address. */
<> 144:ef7eb2e8f9f7 292 FLASH_Program_HalfWord(Address, (uint16_t)Data);
<> 144:ef7eb2e8f9f7 293
<> 144:ef7eb2e8f9f7 294 return status;
<> 144:ef7eb2e8f9f7 295 }
<> 144:ef7eb2e8f9f7 296
<> 144:ef7eb2e8f9f7 297 /**
<> 144:ef7eb2e8f9f7 298 * @brief This function handles FLASH interrupt request.
<> 144:ef7eb2e8f9f7 299 * @retval None
<> 144:ef7eb2e8f9f7 300 */
<> 144:ef7eb2e8f9f7 301 void HAL_FLASH_IRQHandler(void)
<> 144:ef7eb2e8f9f7 302 {
<> 156:95d6b41a828b 303 uint32_t addresstmp = 0U;
<> 144:ef7eb2e8f9f7 304
<> 144:ef7eb2e8f9f7 305 /* Check FLASH operation error flags */
<> 144:ef7eb2e8f9f7 306 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) ||__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR))
<> 144:ef7eb2e8f9f7 307 {
<> 144:ef7eb2e8f9f7 308 /* Return the faulty address */
<> 144:ef7eb2e8f9f7 309 addresstmp = pFlash.Address;
<> 144:ef7eb2e8f9f7 310 /* Reset address */
<> 144:ef7eb2e8f9f7 311 pFlash.Address = 0xFFFFFFFFU;
<> 144:ef7eb2e8f9f7 312
<> 144:ef7eb2e8f9f7 313 /* Save the Error code */
<> 144:ef7eb2e8f9f7 314 FLASH_SetErrorCode();
<> 144:ef7eb2e8f9f7 315
<> 144:ef7eb2e8f9f7 316 /* FLASH error interrupt user callback */
<> 144:ef7eb2e8f9f7 317 HAL_FLASH_OperationErrorCallback(addresstmp);
<> 144:ef7eb2e8f9f7 318
<> 144:ef7eb2e8f9f7 319 /* Stop the procedure ongoing */
<> 144:ef7eb2e8f9f7 320 pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
<> 144:ef7eb2e8f9f7 321 }
<> 144:ef7eb2e8f9f7 322
<> 144:ef7eb2e8f9f7 323 /* Check FLASH End of Operation flag */
<> 144:ef7eb2e8f9f7 324 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP))
<> 144:ef7eb2e8f9f7 325 {
<> 144:ef7eb2e8f9f7 326 /* Clear FLASH End of Operation pending bit */
<> 144:ef7eb2e8f9f7 327 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP);
<> 144:ef7eb2e8f9f7 328
<> 144:ef7eb2e8f9f7 329 /* Process can continue only if no error detected */
<> 144:ef7eb2e8f9f7 330 if(pFlash.ProcedureOnGoing != FLASH_PROC_NONE)
<> 144:ef7eb2e8f9f7 331 {
<> 144:ef7eb2e8f9f7 332 if(pFlash.ProcedureOnGoing == FLASH_PROC_PAGEERASE)
<> 144:ef7eb2e8f9f7 333 {
<> 144:ef7eb2e8f9f7 334 /* Nb of pages to erased can be decreased */
<> 144:ef7eb2e8f9f7 335 pFlash.DataRemaining--;
<> 144:ef7eb2e8f9f7 336
<> 144:ef7eb2e8f9f7 337 /* Check if there are still pages to erase */
<> 156:95d6b41a828b 338 if(pFlash.DataRemaining != 0U)
<> 144:ef7eb2e8f9f7 339 {
<> 144:ef7eb2e8f9f7 340 addresstmp = pFlash.Address;
<> 144:ef7eb2e8f9f7 341 /*Indicate user which sector has been erased */
<> 144:ef7eb2e8f9f7 342 HAL_FLASH_EndOfOperationCallback(addresstmp);
<> 144:ef7eb2e8f9f7 343
<> 144:ef7eb2e8f9f7 344 /*Increment sector number*/
<> 144:ef7eb2e8f9f7 345 addresstmp = pFlash.Address + FLASH_PAGE_SIZE;
<> 144:ef7eb2e8f9f7 346 pFlash.Address = addresstmp;
<> 144:ef7eb2e8f9f7 347
<> 144:ef7eb2e8f9f7 348 /* If the erase operation is completed, disable the PER Bit */
<> 144:ef7eb2e8f9f7 349 CLEAR_BIT(FLASH->CR, FLASH_CR_PER);
<> 144:ef7eb2e8f9f7 350
<> 144:ef7eb2e8f9f7 351 FLASH_PageErase(addresstmp);
<> 144:ef7eb2e8f9f7 352 }
<> 144:ef7eb2e8f9f7 353 else
<> 144:ef7eb2e8f9f7 354 {
<> 144:ef7eb2e8f9f7 355 /* No more pages to Erase, user callback can be called. */
<> 144:ef7eb2e8f9f7 356 /* Reset Sector and stop Erase pages procedure */
<> 144:ef7eb2e8f9f7 357 pFlash.Address = addresstmp = 0xFFFFFFFFU;
<> 144:ef7eb2e8f9f7 358 pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
<> 144:ef7eb2e8f9f7 359 /* FLASH EOP interrupt user callback */
<> 144:ef7eb2e8f9f7 360 HAL_FLASH_EndOfOperationCallback(addresstmp);
<> 144:ef7eb2e8f9f7 361 }
<> 144:ef7eb2e8f9f7 362 }
<> 144:ef7eb2e8f9f7 363 else if(pFlash.ProcedureOnGoing == FLASH_PROC_MASSERASE)
<> 144:ef7eb2e8f9f7 364 {
<> 144:ef7eb2e8f9f7 365 /* Operation is completed, disable the MER Bit */
<> 144:ef7eb2e8f9f7 366 CLEAR_BIT(FLASH->CR, FLASH_CR_MER);
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 /* MassErase ended. Return the selected bank */
<> 144:ef7eb2e8f9f7 369 /* FLASH EOP interrupt user callback */
<> 144:ef7eb2e8f9f7 370 HAL_FLASH_EndOfOperationCallback(0);
<> 144:ef7eb2e8f9f7 371
<> 144:ef7eb2e8f9f7 372 /* Stop Mass Erase procedure*/
<> 144:ef7eb2e8f9f7 373 pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
<> 144:ef7eb2e8f9f7 374 }
<> 144:ef7eb2e8f9f7 375 else
<> 144:ef7eb2e8f9f7 376 {
<> 144:ef7eb2e8f9f7 377 /* Nb of 16-bit data to program can be decreased */
<> 144:ef7eb2e8f9f7 378 pFlash.DataRemaining--;
<> 144:ef7eb2e8f9f7 379
<> 144:ef7eb2e8f9f7 380 /* Check if there are still 16-bit data to program */
<> 156:95d6b41a828b 381 if(pFlash.DataRemaining != 0U)
<> 144:ef7eb2e8f9f7 382 {
<> 144:ef7eb2e8f9f7 383 /* Increment address to 16-bit */
<> 144:ef7eb2e8f9f7 384 pFlash.Address += 2;
<> 144:ef7eb2e8f9f7 385 addresstmp = pFlash.Address;
<> 144:ef7eb2e8f9f7 386
<> 144:ef7eb2e8f9f7 387 /* Shift to have next 16-bit data */
<> 156:95d6b41a828b 388 pFlash.Data = (pFlash.Data >> 16U);
<> 144:ef7eb2e8f9f7 389
<> 144:ef7eb2e8f9f7 390 /* Operation is completed, disable the PG Bit */
<> 144:ef7eb2e8f9f7 391 CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
<> 144:ef7eb2e8f9f7 392
<> 144:ef7eb2e8f9f7 393 /*Program halfword (16-bit) at a specified address.*/
<> 144:ef7eb2e8f9f7 394 FLASH_Program_HalfWord(addresstmp, (uint16_t)pFlash.Data);
<> 144:ef7eb2e8f9f7 395 }
<> 144:ef7eb2e8f9f7 396 else
<> 144:ef7eb2e8f9f7 397 {
<> 144:ef7eb2e8f9f7 398 /* Program ended. Return the selected address */
<> 144:ef7eb2e8f9f7 399 /* FLASH EOP interrupt user callback */
<> 144:ef7eb2e8f9f7 400 if (pFlash.ProcedureOnGoing == FLASH_PROC_PROGRAMHALFWORD)
<> 144:ef7eb2e8f9f7 401 {
<> 144:ef7eb2e8f9f7 402 HAL_FLASH_EndOfOperationCallback(pFlash.Address);
<> 144:ef7eb2e8f9f7 403 }
<> 144:ef7eb2e8f9f7 404 else if (pFlash.ProcedureOnGoing == FLASH_PROC_PROGRAMWORD)
<> 144:ef7eb2e8f9f7 405 {
<> 156:95d6b41a828b 406 HAL_FLASH_EndOfOperationCallback(pFlash.Address - 2U);
<> 144:ef7eb2e8f9f7 407 }
<> 144:ef7eb2e8f9f7 408 else
<> 144:ef7eb2e8f9f7 409 {
<> 156:95d6b41a828b 410 HAL_FLASH_EndOfOperationCallback(pFlash.Address - 6U);
<> 144:ef7eb2e8f9f7 411 }
<> 144:ef7eb2e8f9f7 412
<> 144:ef7eb2e8f9f7 413 /* Reset Address and stop Program procedure */
<> 144:ef7eb2e8f9f7 414 pFlash.Address = 0xFFFFFFFFU;
<> 144:ef7eb2e8f9f7 415 pFlash.ProcedureOnGoing = FLASH_PROC_NONE;
<> 144:ef7eb2e8f9f7 416 }
<> 144:ef7eb2e8f9f7 417 }
<> 144:ef7eb2e8f9f7 418 }
<> 144:ef7eb2e8f9f7 419 }
<> 144:ef7eb2e8f9f7 420
<> 144:ef7eb2e8f9f7 421
<> 144:ef7eb2e8f9f7 422 if(pFlash.ProcedureOnGoing == FLASH_PROC_NONE)
<> 144:ef7eb2e8f9f7 423 {
<> 144:ef7eb2e8f9f7 424 /* Operation is completed, disable the PG, PER and MER Bits */
<> 144:ef7eb2e8f9f7 425 CLEAR_BIT(FLASH->CR, (FLASH_CR_PG | FLASH_CR_PER | FLASH_CR_MER));
<> 144:ef7eb2e8f9f7 426
<> 144:ef7eb2e8f9f7 427 /* Disable End of FLASH Operation and Error source interrupts */
<> 144:ef7eb2e8f9f7 428 __HAL_FLASH_DISABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR);
<> 144:ef7eb2e8f9f7 429
<> 144:ef7eb2e8f9f7 430 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 431 __HAL_UNLOCK(&pFlash);
<> 144:ef7eb2e8f9f7 432 }
<> 144:ef7eb2e8f9f7 433 }
<> 144:ef7eb2e8f9f7 434
<> 144:ef7eb2e8f9f7 435 /**
<> 144:ef7eb2e8f9f7 436 * @brief FLASH end of operation interrupt callback
Anna Bridge 180:96ed750bd169 437 * @param ReturnValue The value saved in this parameter depends on the ongoing procedure
<> 144:ef7eb2e8f9f7 438 * - Mass Erase: No return value expected
<> 144:ef7eb2e8f9f7 439 * - Pages Erase: Address of the page which has been erased
<> 144:ef7eb2e8f9f7 440 * (if 0xFFFFFFFF, it means that all the selected pages have been erased)
<> 144:ef7eb2e8f9f7 441 * - Program: Address which was selected for data program
<> 144:ef7eb2e8f9f7 442 * @retval none
<> 144:ef7eb2e8f9f7 443 */
<> 144:ef7eb2e8f9f7 444 __weak void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue)
<> 144:ef7eb2e8f9f7 445 {
<> 144:ef7eb2e8f9f7 446 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 447 UNUSED(ReturnValue);
<> 144:ef7eb2e8f9f7 448
<> 144:ef7eb2e8f9f7 449 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 450 the HAL_FLASH_EndOfOperationCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 451 */
<> 144:ef7eb2e8f9f7 452 }
<> 144:ef7eb2e8f9f7 453
<> 144:ef7eb2e8f9f7 454 /**
<> 144:ef7eb2e8f9f7 455 * @brief FLASH operation error interrupt callback
Anna Bridge 180:96ed750bd169 456 * @param ReturnValue The value saved in this parameter depends on the ongoing procedure
<> 144:ef7eb2e8f9f7 457 * - Mass Erase: No return value expected
<> 144:ef7eb2e8f9f7 458 * - Pages Erase: Address of the page which returned an error
<> 144:ef7eb2e8f9f7 459 * - Program: Address which was selected for data program
<> 144:ef7eb2e8f9f7 460 * @retval none
<> 144:ef7eb2e8f9f7 461 */
<> 144:ef7eb2e8f9f7 462 __weak void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue)
<> 144:ef7eb2e8f9f7 463 {
<> 144:ef7eb2e8f9f7 464 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 465 UNUSED(ReturnValue);
<> 144:ef7eb2e8f9f7 466
<> 144:ef7eb2e8f9f7 467 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 468 the HAL_FLASH_OperationErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 469 */
<> 144:ef7eb2e8f9f7 470 }
<> 144:ef7eb2e8f9f7 471
<> 144:ef7eb2e8f9f7 472 /**
<> 144:ef7eb2e8f9f7 473 * @}
<> 144:ef7eb2e8f9f7 474 */
<> 144:ef7eb2e8f9f7 475
<> 144:ef7eb2e8f9f7 476 /** @defgroup FLASH_Exported_Functions_Group2 Peripheral Control functions
<> 144:ef7eb2e8f9f7 477 * @brief management functions
<> 144:ef7eb2e8f9f7 478 *
<> 144:ef7eb2e8f9f7 479 @verbatim
<> 144:ef7eb2e8f9f7 480 ===============================================================================
<> 144:ef7eb2e8f9f7 481 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 482 ===============================================================================
<> 144:ef7eb2e8f9f7 483 [..]
<> 144:ef7eb2e8f9f7 484 This subsection provides a set of functions allowing to control the FLASH
<> 144:ef7eb2e8f9f7 485 memory operations.
<> 144:ef7eb2e8f9f7 486
<> 144:ef7eb2e8f9f7 487 @endverbatim
<> 144:ef7eb2e8f9f7 488 * @{
<> 144:ef7eb2e8f9f7 489 */
<> 144:ef7eb2e8f9f7 490
<> 144:ef7eb2e8f9f7 491 /**
<> 144:ef7eb2e8f9f7 492 * @brief Unlock the FLASH control register access
<> 144:ef7eb2e8f9f7 493 * @retval HAL Status
<> 144:ef7eb2e8f9f7 494 */
<> 144:ef7eb2e8f9f7 495 HAL_StatusTypeDef HAL_FLASH_Unlock(void)
<> 144:ef7eb2e8f9f7 496 {
<> 144:ef7eb2e8f9f7 497 if (HAL_IS_BIT_SET(FLASH->CR, FLASH_CR_LOCK))
<> 144:ef7eb2e8f9f7 498 {
<> 144:ef7eb2e8f9f7 499 /* Authorize the FLASH Registers access */
<> 144:ef7eb2e8f9f7 500 WRITE_REG(FLASH->KEYR, FLASH_KEY1);
<> 144:ef7eb2e8f9f7 501 WRITE_REG(FLASH->KEYR, FLASH_KEY2);
<> 144:ef7eb2e8f9f7 502 }
<> 144:ef7eb2e8f9f7 503 else
<> 144:ef7eb2e8f9f7 504 {
<> 144:ef7eb2e8f9f7 505 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 506 }
<> 144:ef7eb2e8f9f7 507
<> 144:ef7eb2e8f9f7 508 return HAL_OK;
<> 144:ef7eb2e8f9f7 509 }
<> 144:ef7eb2e8f9f7 510
<> 144:ef7eb2e8f9f7 511 /**
<> 144:ef7eb2e8f9f7 512 * @brief Locks the FLASH control register access
<> 144:ef7eb2e8f9f7 513 * @retval HAL Status
<> 144:ef7eb2e8f9f7 514 */
<> 144:ef7eb2e8f9f7 515 HAL_StatusTypeDef HAL_FLASH_Lock(void)
<> 144:ef7eb2e8f9f7 516 {
<> 144:ef7eb2e8f9f7 517 /* Set the LOCK Bit to lock the FLASH Registers access */
<> 144:ef7eb2e8f9f7 518 SET_BIT(FLASH->CR, FLASH_CR_LOCK);
<> 144:ef7eb2e8f9f7 519
<> 144:ef7eb2e8f9f7 520 return HAL_OK;
<> 144:ef7eb2e8f9f7 521 }
<> 144:ef7eb2e8f9f7 522
<> 144:ef7eb2e8f9f7 523 /**
<> 144:ef7eb2e8f9f7 524 * @brief Unlock the FLASH Option Control Registers access.
<> 144:ef7eb2e8f9f7 525 * @retval HAL Status
<> 144:ef7eb2e8f9f7 526 */
<> 144:ef7eb2e8f9f7 527 HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void)
<> 144:ef7eb2e8f9f7 528 {
<> 144:ef7eb2e8f9f7 529 if (HAL_IS_BIT_CLR(FLASH->CR, FLASH_CR_OPTWRE))
<> 144:ef7eb2e8f9f7 530 {
<> 144:ef7eb2e8f9f7 531 /* Authorizes the Option Byte register programming */
<> 144:ef7eb2e8f9f7 532 WRITE_REG(FLASH->OPTKEYR, FLASH_OPTKEY1);
<> 144:ef7eb2e8f9f7 533 WRITE_REG(FLASH->OPTKEYR, FLASH_OPTKEY2);
<> 144:ef7eb2e8f9f7 534 }
<> 144:ef7eb2e8f9f7 535 else
<> 144:ef7eb2e8f9f7 536 {
<> 144:ef7eb2e8f9f7 537 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 538 }
<> 144:ef7eb2e8f9f7 539
<> 144:ef7eb2e8f9f7 540 return HAL_OK;
<> 144:ef7eb2e8f9f7 541 }
<> 144:ef7eb2e8f9f7 542
<> 144:ef7eb2e8f9f7 543 /**
<> 144:ef7eb2e8f9f7 544 * @brief Lock the FLASH Option Control Registers access.
<> 144:ef7eb2e8f9f7 545 * @retval HAL Status
<> 144:ef7eb2e8f9f7 546 */
<> 144:ef7eb2e8f9f7 547 HAL_StatusTypeDef HAL_FLASH_OB_Lock(void)
<> 144:ef7eb2e8f9f7 548 {
<> 144:ef7eb2e8f9f7 549 /* Clear the OPTWRE Bit to lock the FLASH Option Byte Registers access */
<> 144:ef7eb2e8f9f7 550 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTWRE);
<> 144:ef7eb2e8f9f7 551
<> 144:ef7eb2e8f9f7 552 return HAL_OK;
<> 144:ef7eb2e8f9f7 553 }
<> 144:ef7eb2e8f9f7 554
<> 144:ef7eb2e8f9f7 555 /**
<> 144:ef7eb2e8f9f7 556 * @brief Launch the option byte loading.
<> 144:ef7eb2e8f9f7 557 * @note This function will reset automatically the MCU.
<> 144:ef7eb2e8f9f7 558 * @retval HAL Status
<> 144:ef7eb2e8f9f7 559 */
<> 144:ef7eb2e8f9f7 560 HAL_StatusTypeDef HAL_FLASH_OB_Launch(void)
<> 144:ef7eb2e8f9f7 561 {
<> 144:ef7eb2e8f9f7 562 /* Set the OBL_Launch bit to launch the option byte loading */
<> 144:ef7eb2e8f9f7 563 SET_BIT(FLASH->CR, FLASH_CR_OBL_LAUNCH);
<> 144:ef7eb2e8f9f7 564
<> 144:ef7eb2e8f9f7 565 /* Wait for last operation to be completed */
<> 144:ef7eb2e8f9f7 566 return(FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE));
<> 144:ef7eb2e8f9f7 567 }
<> 144:ef7eb2e8f9f7 568
<> 144:ef7eb2e8f9f7 569 /**
<> 144:ef7eb2e8f9f7 570 * @}
<> 144:ef7eb2e8f9f7 571 */
<> 144:ef7eb2e8f9f7 572
<> 144:ef7eb2e8f9f7 573 /** @defgroup FLASH_Exported_Functions_Group3 Peripheral errors functions
<> 144:ef7eb2e8f9f7 574 * @brief Peripheral errors functions
<> 144:ef7eb2e8f9f7 575 *
<> 144:ef7eb2e8f9f7 576 @verbatim
<> 144:ef7eb2e8f9f7 577 ===============================================================================
<> 144:ef7eb2e8f9f7 578 ##### Peripheral Errors functions #####
<> 144:ef7eb2e8f9f7 579 ===============================================================================
<> 144:ef7eb2e8f9f7 580 [..]
<> 144:ef7eb2e8f9f7 581 This subsection permit to get in run-time errors of the FLASH peripheral.
<> 144:ef7eb2e8f9f7 582
<> 144:ef7eb2e8f9f7 583 @endverbatim
<> 144:ef7eb2e8f9f7 584 * @{
<> 144:ef7eb2e8f9f7 585 */
<> 144:ef7eb2e8f9f7 586
<> 144:ef7eb2e8f9f7 587 /**
<> 144:ef7eb2e8f9f7 588 * @brief Get the specific FLASH error flag.
<> 144:ef7eb2e8f9f7 589 * @retval FLASH_ErrorCode The returned value can be:
<> 144:ef7eb2e8f9f7 590 * @ref FLASH_Error_Codes
<> 144:ef7eb2e8f9f7 591 */
<> 144:ef7eb2e8f9f7 592 uint32_t HAL_FLASH_GetError(void)
<> 144:ef7eb2e8f9f7 593 {
<> 144:ef7eb2e8f9f7 594 return pFlash.ErrorCode;
<> 144:ef7eb2e8f9f7 595 }
<> 144:ef7eb2e8f9f7 596
<> 144:ef7eb2e8f9f7 597 /**
<> 144:ef7eb2e8f9f7 598 * @}
<> 144:ef7eb2e8f9f7 599 */
<> 144:ef7eb2e8f9f7 600
<> 144:ef7eb2e8f9f7 601 /**
<> 144:ef7eb2e8f9f7 602 * @}
<> 144:ef7eb2e8f9f7 603 */
<> 144:ef7eb2e8f9f7 604
<> 144:ef7eb2e8f9f7 605 /** @addtogroup FLASH_Private_Functions
<> 144:ef7eb2e8f9f7 606 * @{
<> 144:ef7eb2e8f9f7 607 */
<> 144:ef7eb2e8f9f7 608
<> 144:ef7eb2e8f9f7 609 /**
<> 144:ef7eb2e8f9f7 610 * @brief Program a half-word (16-bit) at a specified address.
<> 144:ef7eb2e8f9f7 611 * @param Address specify the address to be programmed.
<> 144:ef7eb2e8f9f7 612 * @param Data specify the data to be programmed.
<> 144:ef7eb2e8f9f7 613 * @retval None
<> 144:ef7eb2e8f9f7 614 */
<> 144:ef7eb2e8f9f7 615 static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data)
<> 144:ef7eb2e8f9f7 616 {
<> 144:ef7eb2e8f9f7 617 /* Clean the error context */
<> 144:ef7eb2e8f9f7 618 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
<> 144:ef7eb2e8f9f7 619
<> 144:ef7eb2e8f9f7 620 /* Proceed to program the new data */
<> 144:ef7eb2e8f9f7 621 SET_BIT(FLASH->CR, FLASH_CR_PG);
<> 144:ef7eb2e8f9f7 622
<> 144:ef7eb2e8f9f7 623 /* Write data in the address */
<> 144:ef7eb2e8f9f7 624 *(__IO uint16_t*)Address = Data;
<> 144:ef7eb2e8f9f7 625 }
<> 144:ef7eb2e8f9f7 626
<> 144:ef7eb2e8f9f7 627 /**
<> 144:ef7eb2e8f9f7 628 * @brief Wait for a FLASH operation to complete.
<> 144:ef7eb2e8f9f7 629 * @param Timeout maximum flash operation timeout
<> 144:ef7eb2e8f9f7 630 * @retval HAL Status
<> 144:ef7eb2e8f9f7 631 */
<> 144:ef7eb2e8f9f7 632 HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout)
<> 144:ef7eb2e8f9f7 633 {
<> 144:ef7eb2e8f9f7 634 /* Wait for the FLASH operation to complete by polling on BUSY flag to be reset.
<> 144:ef7eb2e8f9f7 635 Even if the FLASH operation fails, the BUSY flag will be reset and an error
<> 144:ef7eb2e8f9f7 636 flag will be set */
<> 144:ef7eb2e8f9f7 637
<> 144:ef7eb2e8f9f7 638 uint32_t tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 639
<> 144:ef7eb2e8f9f7 640 while(__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY))
<> 144:ef7eb2e8f9f7 641 {
<> 144:ef7eb2e8f9f7 642 if (Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 643 {
<> 156:95d6b41a828b 644 if((Timeout == 0U) || ((HAL_GetTick()-tickstart) > Timeout))
<> 144:ef7eb2e8f9f7 645 {
<> 144:ef7eb2e8f9f7 646 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 647 }
<> 144:ef7eb2e8f9f7 648 }
<> 144:ef7eb2e8f9f7 649 }
<> 144:ef7eb2e8f9f7 650
<> 144:ef7eb2e8f9f7 651 /* Check FLASH End of Operation flag */
<> 144:ef7eb2e8f9f7 652 if (__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP))
<> 144:ef7eb2e8f9f7 653 {
<> 144:ef7eb2e8f9f7 654 /* Clear FLASH End of Operation pending bit */
<> 144:ef7eb2e8f9f7 655 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP);
<> 144:ef7eb2e8f9f7 656 }
<> 144:ef7eb2e8f9f7 657
<> 144:ef7eb2e8f9f7 658 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) ||
<> 144:ef7eb2e8f9f7 659 __HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR))
<> 144:ef7eb2e8f9f7 660 {
<> 144:ef7eb2e8f9f7 661 /*Save the error code*/
<> 144:ef7eb2e8f9f7 662 FLASH_SetErrorCode();
<> 144:ef7eb2e8f9f7 663 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 664 }
<> 144:ef7eb2e8f9f7 665
<> 144:ef7eb2e8f9f7 666 /* There is no error flag set */
<> 144:ef7eb2e8f9f7 667 return HAL_OK;
<> 144:ef7eb2e8f9f7 668 }
<> 144:ef7eb2e8f9f7 669
<> 144:ef7eb2e8f9f7 670
<> 144:ef7eb2e8f9f7 671 /**
<> 144:ef7eb2e8f9f7 672 * @brief Set the specific FLASH error flag.
<> 144:ef7eb2e8f9f7 673 * @retval None
<> 144:ef7eb2e8f9f7 674 */
<> 144:ef7eb2e8f9f7 675 static void FLASH_SetErrorCode(void)
<> 144:ef7eb2e8f9f7 676 {
<> 156:95d6b41a828b 677 uint32_t flags = 0U;
<> 144:ef7eb2e8f9f7 678
<> 144:ef7eb2e8f9f7 679 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR))
<> 144:ef7eb2e8f9f7 680 {
<> 144:ef7eb2e8f9f7 681 pFlash.ErrorCode |= HAL_FLASH_ERROR_WRP;
<> 144:ef7eb2e8f9f7 682 flags |= FLASH_FLAG_WRPERR;
<> 144:ef7eb2e8f9f7 683 }
<> 144:ef7eb2e8f9f7 684 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR))
<> 144:ef7eb2e8f9f7 685 {
<> 144:ef7eb2e8f9f7 686 pFlash.ErrorCode |= HAL_FLASH_ERROR_PROG;
<> 144:ef7eb2e8f9f7 687 flags |= FLASH_FLAG_PGERR;
<> 144:ef7eb2e8f9f7 688 }
<> 144:ef7eb2e8f9f7 689 /* Clear FLASH error pending bits */
<> 144:ef7eb2e8f9f7 690 __HAL_FLASH_CLEAR_FLAG(flags);
<> 144:ef7eb2e8f9f7 691 }
<> 144:ef7eb2e8f9f7 692 /**
<> 144:ef7eb2e8f9f7 693 * @}
<> 144:ef7eb2e8f9f7 694 */
<> 144:ef7eb2e8f9f7 695
<> 144:ef7eb2e8f9f7 696 /**
<> 144:ef7eb2e8f9f7 697 * @}
<> 144:ef7eb2e8f9f7 698 */
<> 144:ef7eb2e8f9f7 699
<> 144:ef7eb2e8f9f7 700 #endif /* HAL_FLASH_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 701
<> 144:ef7eb2e8f9f7 702 /**
<> 144:ef7eb2e8f9f7 703 * @}
<> 144:ef7eb2e8f9f7 704 */
<> 144:ef7eb2e8f9f7 705
<> 144:ef7eb2e8f9f7 706 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/