mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_flash_ex.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 354:e67efb2aab0e 1 /**
mbed_official 354:e67efb2aab0e 2 ******************************************************************************
mbed_official 354:e67efb2aab0e 3 * @file stm32l1xx_hal_flash_ex.c
mbed_official 354:e67efb2aab0e 4 * @author MCD Application Team
mbed_official 354:e67efb2aab0e 5 * @version V1.0.0
mbed_official 354:e67efb2aab0e 6 * @date 5-September-2014
mbed_official 354:e67efb2aab0e 7 * @brief FLASH HAL module driver.
mbed_official 354:e67efb2aab0e 8 * This file provides firmware functions to manage the following
mbed_official 354:e67efb2aab0e 9 * functionalities of the internal FLASH memory:
mbed_official 354:e67efb2aab0e 10 * + FLASH Interface configuration
mbed_official 354:e67efb2aab0e 11 * + FLASH Memory Erasing
mbed_official 354:e67efb2aab0e 12 * + DATA EEPROM Programming/Erasing
mbed_official 354:e67efb2aab0e 13 * + Option Bytes Programming
mbed_official 354:e67efb2aab0e 14 * + Interrupts management
mbed_official 354:e67efb2aab0e 15 *
mbed_official 354:e67efb2aab0e 16 * @verbatim
mbed_official 354:e67efb2aab0e 17 ==============================================================================
mbed_official 354:e67efb2aab0e 18 ##### Flash peripheral Extended features #####
mbed_official 354:e67efb2aab0e 19 ==============================================================================
mbed_official 354:e67efb2aab0e 20
mbed_official 354:e67efb2aab0e 21 [..] Comparing to other products, the FLASH interface for STM32L1xx
mbed_official 354:e67efb2aab0e 22 devices contains the following additional features
mbed_official 354:e67efb2aab0e 23 (+) Erase functions
mbed_official 354:e67efb2aab0e 24 (+) DATA_EEPROM memory management
mbed_official 354:e67efb2aab0e 25 (+) BOOT option bit configuration
mbed_official 354:e67efb2aab0e 26 (+) PCROP protection for all sectors
mbed_official 354:e67efb2aab0e 27
mbed_official 354:e67efb2aab0e 28 ##### How to use this driver #####
mbed_official 354:e67efb2aab0e 29 ==============================================================================
mbed_official 354:e67efb2aab0e 30 [..] This driver provides functions to configure and program the FLASH memory
mbed_official 354:e67efb2aab0e 31 of all STM32L1xx. It includes:
mbed_official 354:e67efb2aab0e 32 (+) Full DATA_EEPROM erase and program management
mbed_official 354:e67efb2aab0e 33 (+) Boot activation
mbed_official 354:e67efb2aab0e 34 (+) PCROP protection configuration and control for all pages
mbed_official 354:e67efb2aab0e 35
mbed_official 354:e67efb2aab0e 36 @endverbatim
mbed_official 354:e67efb2aab0e 37 ******************************************************************************
mbed_official 354:e67efb2aab0e 38 * @attention
mbed_official 354:e67efb2aab0e 39 *
mbed_official 354:e67efb2aab0e 40 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 354:e67efb2aab0e 41 *
mbed_official 354:e67efb2aab0e 42 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 354:e67efb2aab0e 43 * are permitted provided that the following conditions are met:
mbed_official 354:e67efb2aab0e 44 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 354:e67efb2aab0e 45 * this list of conditions and the following disclaimer.
mbed_official 354:e67efb2aab0e 46 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 354:e67efb2aab0e 47 * this list of conditions and the following disclaimer in the documentation
mbed_official 354:e67efb2aab0e 48 * and/or other materials provided with the distribution.
mbed_official 354:e67efb2aab0e 49 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 354:e67efb2aab0e 50 * may be used to endorse or promote products derived from this software
mbed_official 354:e67efb2aab0e 51 * without specific prior written permission.
mbed_official 354:e67efb2aab0e 52 *
mbed_official 354:e67efb2aab0e 53 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 354:e67efb2aab0e 54 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 354:e67efb2aab0e 55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 354:e67efb2aab0e 56 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 354:e67efb2aab0e 57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 354:e67efb2aab0e 58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 354:e67efb2aab0e 59 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 354:e67efb2aab0e 60 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 354:e67efb2aab0e 61 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 354:e67efb2aab0e 62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 354:e67efb2aab0e 63 *
mbed_official 354:e67efb2aab0e 64 ******************************************************************************
mbed_official 354:e67efb2aab0e 65 */
mbed_official 354:e67efb2aab0e 66
mbed_official 354:e67efb2aab0e 67 /* Includes ------------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 68 #include "stm32l1xx_hal.h"
mbed_official 354:e67efb2aab0e 69
mbed_official 354:e67efb2aab0e 70 /** @addtogroup STM32L1xx_HAL_Driver
mbed_official 354:e67efb2aab0e 71 * @{
mbed_official 354:e67efb2aab0e 72 */
mbed_official 354:e67efb2aab0e 73
mbed_official 354:e67efb2aab0e 74 /** @defgroup FLASHEx FLASHEx
mbed_official 354:e67efb2aab0e 75 * @brief FLASH HAL Extension module driver
mbed_official 354:e67efb2aab0e 76 * @{
mbed_official 354:e67efb2aab0e 77 */
mbed_official 354:e67efb2aab0e 78
mbed_official 354:e67efb2aab0e 79 #ifdef HAL_FLASH_MODULE_ENABLED
mbed_official 354:e67efb2aab0e 80
mbed_official 354:e67efb2aab0e 81 /* Private typedef -----------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 82 /* Private define ------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 83 /* Private macro -------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 84 /* Private variables ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 85 /* Private function prototypes -----------------------------------------------*/
mbed_official 354:e67efb2aab0e 86 static void FLASH_SetErrorCode(void);
mbed_official 354:e67efb2aab0e 87 static void FLASH_ErasePage(uint32_t PageAddress);
mbed_official 354:e67efb2aab0e 88
mbed_official 354:e67efb2aab0e 89 static HAL_StatusTypeDef FLASH_OB_WRPConfig(FLASH_OBProgramInitTypeDef *pOBInit, FunctionalState NewState);
mbed_official 354:e67efb2aab0e 90 static void FLASH_OB_WRPConfigWRP1OrPCROP1(uint32_t WRP1OrPCROP1, FunctionalState NewState);
mbed_official 354:e67efb2aab0e 91 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 92 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 93 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 94 static void FLASH_OB_WRPConfigWRP2OrPCROP2(uint32_t WRP2OrPCROP2, FunctionalState NewState);
mbed_official 354:e67efb2aab0e 95 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 96 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 97 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 98 static void FLASH_OB_WRPConfigWRP3(uint32_t WRP3, FunctionalState NewState);
mbed_official 354:e67efb2aab0e 99 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 100 #if defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 101 static void FLASH_OB_WRPConfigWRP4(uint32_t WRP4, FunctionalState NewState);
mbed_official 354:e67efb2aab0e 102 #endif /* STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 103 static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP);
mbed_official 354:e67efb2aab0e 104 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY);
mbed_official 354:e67efb2aab0e 105 static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR);
mbed_official 354:e67efb2aab0e 106 static uint8_t FLASH_OB_GetRDP(void);
mbed_official 354:e67efb2aab0e 107 static uint8_t FLASH_OB_GetUser(void);
mbed_official 354:e67efb2aab0e 108 static uint8_t FLASH_OB_GetBOR(void);
mbed_official 354:e67efb2aab0e 109 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 110 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 111 static HAL_StatusTypeDef FLASH_OB_PCROPConfig(FLASH_AdvOBProgramInitTypeDef *pAdvOBInit, FunctionalState NewState);
mbed_official 354:e67efb2aab0e 112 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 113 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 114 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 115 static HAL_StatusTypeDef FLASH_OB_BootConfig(uint8_t OB_BOOT);
mbed_official 354:e67efb2aab0e 116 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 117
mbed_official 354:e67efb2aab0e 118 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramByte(uint32_t Address, uint8_t Data);
mbed_official 354:e67efb2aab0e 119 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramHalfWord(uint32_t Address, uint16_t Data);
mbed_official 354:e67efb2aab0e 120 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramWord(uint32_t Address, uint32_t Data);
mbed_official 354:e67efb2aab0e 121 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramWord(uint32_t Address, uint32_t Data);
mbed_official 354:e67efb2aab0e 122 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramHalfWord(uint32_t Address, uint16_t Data);
mbed_official 354:e67efb2aab0e 123 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramByte(uint32_t Address, uint8_t Data);
mbed_official 354:e67efb2aab0e 124
mbed_official 354:e67efb2aab0e 125 /* Exported functions ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 126
mbed_official 354:e67efb2aab0e 127 /** @defgroup FLASHEx_Exported_Functions FLASHEx Exported functions
mbed_official 354:e67efb2aab0e 128 * @{
mbed_official 354:e67efb2aab0e 129 */
mbed_official 354:e67efb2aab0e 130
mbed_official 354:e67efb2aab0e 131 /** @defgroup FLASHEx_Exported_Functions_Group1 FLASH Memory Erasing functions
mbed_official 354:e67efb2aab0e 132 * @brief FLASH Memory Erasing functions
mbed_official 354:e67efb2aab0e 133 *
mbed_official 354:e67efb2aab0e 134 @verbatim
mbed_official 354:e67efb2aab0e 135 ==============================================================================
mbed_official 354:e67efb2aab0e 136 ##### FLASH Erasing Programming functions #####
mbed_official 354:e67efb2aab0e 137 ==============================================================================
mbed_official 354:e67efb2aab0e 138
mbed_official 354:e67efb2aab0e 139 [..] The FLASH Memory Erasing functions, includes the following functions:
mbed_official 354:e67efb2aab0e 140 (+) HAL_FLASHEx_Erase: return only when erase has been done
mbed_official 354:e67efb2aab0e 141 (+) HAL_FLASHEx_Erase_IT: end of erase is done when HAL_FLASH_EndOfOperationCallback is called with parameter
mbed_official 354:e67efb2aab0e 142 0xFFFFFFFF
mbed_official 354:e67efb2aab0e 143
mbed_official 354:e67efb2aab0e 144 [..] Any operation of erase should follow these steps:
mbed_official 354:e67efb2aab0e 145 (#) Call the HAL_FLASH_Unlock() function to enable the flash control register and
mbed_official 354:e67efb2aab0e 146 program memory access.
mbed_official 354:e67efb2aab0e 147 (#) Call the desired function to erase page.
mbed_official 354:e67efb2aab0e 148 (#) Call the HAL_FLASH_Lock() to disable the flash program memory access
mbed_official 354:e67efb2aab0e 149 (recommended to protect the FLASH memory against possible unwanted operation).
mbed_official 354:e67efb2aab0e 150
mbed_official 354:e67efb2aab0e 151 @endverbatim
mbed_official 354:e67efb2aab0e 152 * @{
mbed_official 354:e67efb2aab0e 153 */
mbed_official 354:e67efb2aab0e 154
mbed_official 354:e67efb2aab0e 155 /**
mbed_official 354:e67efb2aab0e 156 * @brief Erase the specified FLASH memory Pages
mbed_official 354:e67efb2aab0e 157 * @note To correctly run this function, the HAL_FLASH_Unlock() function
mbed_official 354:e67efb2aab0e 158 * must be called before.
mbed_official 354:e67efb2aab0e 159 * Call the HAL_FLASH_Lock() to disable the flash memory access
mbed_official 354:e67efb2aab0e 160 * (recommended to protect the FLASH memory against possible unwanted operation)
mbed_official 354:e67efb2aab0e 161 * @param[in] pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that
mbed_official 354:e67efb2aab0e 162 * contains the configuration information for the erasing.
mbed_official 354:e67efb2aab0e 163 *
mbed_official 354:e67efb2aab0e 164 * @param[out] PageError: pointer to variable that
mbed_official 354:e67efb2aab0e 165 * contains the configuration information on faulty sector in case of error
mbed_official 354:e67efb2aab0e 166 * (0xFFFFFFFF means that all the sectors have been correctly erased)
mbed_official 354:e67efb2aab0e 167 *
mbed_official 354:e67efb2aab0e 168 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 169 */
mbed_official 354:e67efb2aab0e 170 HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)
mbed_official 354:e67efb2aab0e 171 {
mbed_official 354:e67efb2aab0e 172 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 354:e67efb2aab0e 173 uint32_t index = 0;
mbed_official 354:e67efb2aab0e 174
mbed_official 354:e67efb2aab0e 175 /* Process Locked */
mbed_official 354:e67efb2aab0e 176 __HAL_LOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 177
mbed_official 354:e67efb2aab0e 178 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 179 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 180
mbed_official 354:e67efb2aab0e 181 if (status == HAL_OK)
mbed_official 354:e67efb2aab0e 182 {
mbed_official 354:e67efb2aab0e 183 /*Initialization of PageError variable*/
mbed_official 354:e67efb2aab0e 184 *PageError = 0xFFFFFFFF;
mbed_official 354:e67efb2aab0e 185
mbed_official 354:e67efb2aab0e 186 /* Check the parameters */
mbed_official 354:e67efb2aab0e 187 assert_param(IS_NBPAGES(pEraseInit->NbPages));
mbed_official 354:e67efb2aab0e 188 assert_param(IS_TYPEERASE(pEraseInit->TypeErase));
mbed_official 354:e67efb2aab0e 189 assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));
mbed_official 354:e67efb2aab0e 190 assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1));
mbed_official 354:e67efb2aab0e 191
mbed_official 354:e67efb2aab0e 192 /* Erase by sector by sector to be done*/
mbed_official 354:e67efb2aab0e 193 for(index = pEraseInit->PageAddress; index < ((pEraseInit->NbPages * FLASH_PAGE_SIZE)+ pEraseInit->PageAddress); index += FLASH_PAGE_SIZE)
mbed_official 354:e67efb2aab0e 194 {
mbed_official 354:e67efb2aab0e 195 FLASH_ErasePage(index);
mbed_official 354:e67efb2aab0e 196
mbed_official 354:e67efb2aab0e 197 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 198 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 199
mbed_official 354:e67efb2aab0e 200 /* If the erase operation is completed, disable the ERASE Bit */
mbed_official 354:e67efb2aab0e 201 CLEAR_BIT(FLASH->PECR, FLASH_PECR_PROG);
mbed_official 354:e67efb2aab0e 202 CLEAR_BIT(FLASH->PECR, FLASH_PECR_ERASE);
mbed_official 354:e67efb2aab0e 203
mbed_official 354:e67efb2aab0e 204 if (status != HAL_OK)
mbed_official 354:e67efb2aab0e 205 {
mbed_official 354:e67efb2aab0e 206 /* In case of error, stop erase procedure and return the faulty sector*/
mbed_official 354:e67efb2aab0e 207 *PageError = index;
mbed_official 354:e67efb2aab0e 208 break;
mbed_official 354:e67efb2aab0e 209 }
mbed_official 354:e67efb2aab0e 210 }
mbed_official 354:e67efb2aab0e 211 }
mbed_official 354:e67efb2aab0e 212
mbed_official 354:e67efb2aab0e 213 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 214 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 215
mbed_official 354:e67efb2aab0e 216 return status;
mbed_official 354:e67efb2aab0e 217 }
mbed_official 354:e67efb2aab0e 218
mbed_official 354:e67efb2aab0e 219 /**
mbed_official 354:e67efb2aab0e 220 * @brief Perform a page erase of the specified FLASH memory pages with interrupt enabled
mbed_official 354:e67efb2aab0e 221 * @note To correctly run this function, the HAL_FLASH_Unlock() function
mbed_official 354:e67efb2aab0e 222 * must be called before.
mbed_official 354:e67efb2aab0e 223 * Call the HAL_FLASH_Lock() to disable the flash memory access
mbed_official 354:e67efb2aab0e 224 * (recommended to protect the FLASH memory against possible unwanted operation)
mbed_official 354:e67efb2aab0e 225 * @param pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that
mbed_official 354:e67efb2aab0e 226 * contains the configuration information for the erasing.
mbed_official 354:e67efb2aab0e 227 *
mbed_official 354:e67efb2aab0e 228 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 229 */
mbed_official 354:e67efb2aab0e 230 HAL_StatusTypeDef HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef *pEraseInit)
mbed_official 354:e67efb2aab0e 231 {
mbed_official 354:e67efb2aab0e 232 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 233
mbed_official 354:e67efb2aab0e 234 /* Process Locked */
mbed_official 354:e67efb2aab0e 235 __HAL_LOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 236
mbed_official 354:e67efb2aab0e 237 /* Enable End of FLASH Operation interrupt */
mbed_official 354:e67efb2aab0e 238 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP);
mbed_official 354:e67efb2aab0e 239
mbed_official 354:e67efb2aab0e 240 /* Enable Error source interrupt */
mbed_official 354:e67efb2aab0e 241 __HAL_FLASH_ENABLE_IT(FLASH_IT_ERR);
mbed_official 354:e67efb2aab0e 242
mbed_official 354:e67efb2aab0e 243 /* Clear pending flags (if any) */
mbed_official 354:e67efb2aab0e 244 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_MASK);
mbed_official 354:e67efb2aab0e 245
mbed_official 354:e67efb2aab0e 246 /* Check the parameters */
mbed_official 354:e67efb2aab0e 247 assert_param(IS_NBPAGES(pEraseInit->NbPages));
mbed_official 354:e67efb2aab0e 248 assert_param(IS_TYPEERASE(pEraseInit->TypeErase));
mbed_official 354:e67efb2aab0e 249 assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));
mbed_official 354:e67efb2aab0e 250 assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1));
mbed_official 354:e67efb2aab0e 251
mbed_official 354:e67efb2aab0e 252 ProcFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE;
mbed_official 354:e67efb2aab0e 253 ProcFlash.NbPagesToErase = pEraseInit->NbPages;
mbed_official 354:e67efb2aab0e 254 ProcFlash.Page = pEraseInit->PageAddress;
mbed_official 354:e67efb2aab0e 255
mbed_official 354:e67efb2aab0e 256 /*Erase 1st page and wait for IT*/
mbed_official 354:e67efb2aab0e 257 FLASH_ErasePage(pEraseInit->PageAddress);
mbed_official 354:e67efb2aab0e 258
mbed_official 354:e67efb2aab0e 259 return status;
mbed_official 354:e67efb2aab0e 260 }
mbed_official 354:e67efb2aab0e 261
mbed_official 354:e67efb2aab0e 262 /**
mbed_official 354:e67efb2aab0e 263 * @}
mbed_official 354:e67efb2aab0e 264 */
mbed_official 354:e67efb2aab0e 265
mbed_official 354:e67efb2aab0e 266
mbed_official 354:e67efb2aab0e 267 /** @defgroup FLASHEx_Exported_Functions_Group2 Option Bytes Programming functions
mbed_official 354:e67efb2aab0e 268 * @brief Option Bytes Programming functions
mbed_official 354:e67efb2aab0e 269 *
mbed_official 354:e67efb2aab0e 270 @verbatim
mbed_official 354:e67efb2aab0e 271 ==============================================================================
mbed_official 354:e67efb2aab0e 272 ##### Option Bytes Programming functions #####
mbed_official 354:e67efb2aab0e 273 ==============================================================================
mbed_official 354:e67efb2aab0e 274
mbed_official 354:e67efb2aab0e 275 [..] Any operation of erase or program should follow these steps:
mbed_official 354:e67efb2aab0e 276 (#) Call the HAL_FLASH_OB_Unlock() function to enable the Flash option control
mbed_official 354:e67efb2aab0e 277 register access.
mbed_official 354:e67efb2aab0e 278 (#) Call following function to program the desired option bytes.
mbed_official 354:e67efb2aab0e 279 (++) HAL_FLASHEx_OBProgram:
mbed_official 354:e67efb2aab0e 280 - To Enable/Disable the desired sector write protection.
mbed_official 354:e67efb2aab0e 281 - To set the desired read Protection Level.
mbed_official 354:e67efb2aab0e 282 - To configure the user option Bytes: IWDG, STOP and the Standby.
mbed_official 354:e67efb2aab0e 283 - To Set the BOR level.
mbed_official 354:e67efb2aab0e 284 (#) Once all needed option bytes to be programmed are correctly written, call the
mbed_official 354:e67efb2aab0e 285 HAL_FLASH_OB_Launch(void) function to launch the Option Bytes programming process.
mbed_official 354:e67efb2aab0e 286 (#) Call the HAL_FLASH_OB_Lock() to disable the Flash option control register access (recommended
mbed_official 354:e67efb2aab0e 287 to protect the option Bytes against possible unwanted operations).
mbed_official 354:e67efb2aab0e 288
mbed_official 354:e67efb2aab0e 289 [..] Proprietary code Read Out Protection (PcROP):
mbed_official 354:e67efb2aab0e 290 (#) The PcROP sector is selected by using the same option bytes as the Write
mbed_official 354:e67efb2aab0e 291 protection (nWRPi bits). As a result, these 2 options are exclusive each other.
mbed_official 354:e67efb2aab0e 292 (#) In order to activate the PcROP (change the function of the nWRPi option bits),
mbed_official 354:e67efb2aab0e 293 the SPRMOD option bit must be activated.
mbed_official 354:e67efb2aab0e 294 (#) The active value of nWRPi bits is inverted when PCROP mode is active, this
mbed_official 354:e67efb2aab0e 295 means: if SPRMOD = 1 and nWRPi = 1 (default value), then the user sector "i"
mbed_official 354:e67efb2aab0e 296 is read/write protected.
mbed_official 354:e67efb2aab0e 297 (#) To activate PCROP mode for Flash sector(s), you need to call the following function:
mbed_official 354:e67efb2aab0e 298 (++) HAL_FLASHEx_AdvOBProgram in selecting sectors to be read/write protected
mbed_official 354:e67efb2aab0e 299 (++) HAL_FLASHEx_OB_SelectPCROP to enable the read/write protection
mbed_official 354:e67efb2aab0e 300 (#) PcROP is available only in STM32L151xBA, STM32L152xBA, STM32L151xC, STM32L152xC & STM32L162xC devices.
mbed_official 354:e67efb2aab0e 301
mbed_official 354:e67efb2aab0e 302 @endverbatim
mbed_official 354:e67efb2aab0e 303 * @{
mbed_official 354:e67efb2aab0e 304 */
mbed_official 354:e67efb2aab0e 305
mbed_official 354:e67efb2aab0e 306 /**
mbed_official 354:e67efb2aab0e 307 * @brief Program option bytes
mbed_official 354:e67efb2aab0e 308 * @param pOBInit: pointer to an FLASH_OBInitStruct structure that
mbed_official 354:e67efb2aab0e 309 * contains the configuration information for the programming.
mbed_official 354:e67efb2aab0e 310 *
mbed_official 354:e67efb2aab0e 311 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 312 */
mbed_official 354:e67efb2aab0e 313 HAL_StatusTypeDef HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef *pOBInit)
mbed_official 354:e67efb2aab0e 314 {
mbed_official 354:e67efb2aab0e 315 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 354:e67efb2aab0e 316
mbed_official 354:e67efb2aab0e 317 /* Process Locked */
mbed_official 354:e67efb2aab0e 318 __HAL_LOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 319
mbed_official 354:e67efb2aab0e 320 /* Check the parameters */
mbed_official 354:e67efb2aab0e 321 assert_param(IS_OPTIONBYTE(pOBInit->OptionType));
mbed_official 354:e67efb2aab0e 322
mbed_official 354:e67efb2aab0e 323 /*Write protection configuration*/
mbed_official 354:e67efb2aab0e 324 if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP)
mbed_official 354:e67efb2aab0e 325 {
mbed_official 354:e67efb2aab0e 326 assert_param(IS_WRPSTATE(pOBInit->WRPState));
mbed_official 354:e67efb2aab0e 327 if (pOBInit->WRPState == WRPSTATE_ENABLE)
mbed_official 354:e67efb2aab0e 328 {
mbed_official 354:e67efb2aab0e 329 /* Enable of Write protection on the selected Sector*/
mbed_official 354:e67efb2aab0e 330 status = FLASH_OB_WRPConfig(pOBInit, ENABLE);
mbed_official 354:e67efb2aab0e 331 }
mbed_official 354:e67efb2aab0e 332 else
mbed_official 354:e67efb2aab0e 333 {
mbed_official 354:e67efb2aab0e 334 /* Disable of Write protection on the selected Sector*/
mbed_official 354:e67efb2aab0e 335 status = FLASH_OB_WRPConfig(pOBInit, DISABLE);
mbed_official 354:e67efb2aab0e 336 }
mbed_official 354:e67efb2aab0e 337 if (status != HAL_OK)
mbed_official 354:e67efb2aab0e 338 {
mbed_official 354:e67efb2aab0e 339 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 340 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 341 return status;
mbed_official 354:e67efb2aab0e 342 }
mbed_official 354:e67efb2aab0e 343 }
mbed_official 354:e67efb2aab0e 344
mbed_official 354:e67efb2aab0e 345 /* Read protection configuration*/
mbed_official 354:e67efb2aab0e 346 if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP)
mbed_official 354:e67efb2aab0e 347 {
mbed_official 354:e67efb2aab0e 348 status = FLASH_OB_RDPConfig(pOBInit->RDPLevel);
mbed_official 354:e67efb2aab0e 349 if (status != HAL_OK)
mbed_official 354:e67efb2aab0e 350 {
mbed_official 354:e67efb2aab0e 351 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 352 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 353 return status;
mbed_official 354:e67efb2aab0e 354 }
mbed_official 354:e67efb2aab0e 355 }
mbed_official 354:e67efb2aab0e 356
mbed_official 354:e67efb2aab0e 357 /* USER configuration*/
mbed_official 354:e67efb2aab0e 358 if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER)
mbed_official 354:e67efb2aab0e 359 {
mbed_official 354:e67efb2aab0e 360 status = FLASH_OB_UserConfig(pOBInit->USERConfig & OB_IWDG_SW,
mbed_official 354:e67efb2aab0e 361 pOBInit->USERConfig & OB_STOP_NORST,
mbed_official 354:e67efb2aab0e 362 pOBInit->USERConfig & OB_STDBY_NORST);
mbed_official 354:e67efb2aab0e 363 if (status != HAL_OK)
mbed_official 354:e67efb2aab0e 364 {
mbed_official 354:e67efb2aab0e 365 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 366 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 367 return status;
mbed_official 354:e67efb2aab0e 368 }
mbed_official 354:e67efb2aab0e 369 }
mbed_official 354:e67efb2aab0e 370
mbed_official 354:e67efb2aab0e 371 /* BOR Level configuration*/
mbed_official 354:e67efb2aab0e 372 if((pOBInit->OptionType & OPTIONBYTE_BOR) == OPTIONBYTE_BOR)
mbed_official 354:e67efb2aab0e 373 {
mbed_official 354:e67efb2aab0e 374 status = FLASH_OB_BORConfig(pOBInit->BORLevel);
mbed_official 354:e67efb2aab0e 375 }
mbed_official 354:e67efb2aab0e 376 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 377 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 378
mbed_official 354:e67efb2aab0e 379 return status;
mbed_official 354:e67efb2aab0e 380 }
mbed_official 354:e67efb2aab0e 381
mbed_official 354:e67efb2aab0e 382 /**
mbed_official 354:e67efb2aab0e 383 * @brief Get the Option byte configuration
mbed_official 354:e67efb2aab0e 384 * @param pOBInit: pointer to an FLASH_OBInitStruct structure that
mbed_official 354:e67efb2aab0e 385 * contains the configuration information for the programming.
mbed_official 354:e67efb2aab0e 386 *
mbed_official 354:e67efb2aab0e 387 * @retval None
mbed_official 354:e67efb2aab0e 388 */
mbed_official 354:e67efb2aab0e 389 void HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef *pOBInit)
mbed_official 354:e67efb2aab0e 390 {
mbed_official 354:e67efb2aab0e 391 pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER | OPTIONBYTE_BOR;
mbed_official 354:e67efb2aab0e 392
mbed_official 354:e67efb2aab0e 393 /*Get WRP1*/
mbed_official 354:e67efb2aab0e 394 pOBInit->WRPSector0To31 = (uint32_t)(FLASH->WRPR1);
mbed_official 354:e67efb2aab0e 395
mbed_official 354:e67efb2aab0e 396 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 397 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 398 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 399
mbed_official 354:e67efb2aab0e 400 /*Get WRP2*/
mbed_official 354:e67efb2aab0e 401 pOBInit->WRPSector32To63 = (uint32_t)(FLASH->WRPR2);
mbed_official 354:e67efb2aab0e 402
mbed_official 354:e67efb2aab0e 403 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 404
mbed_official 354:e67efb2aab0e 405 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 406 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 407
mbed_official 354:e67efb2aab0e 408 /*Get WRP3*/
mbed_official 354:e67efb2aab0e 409 pOBInit->WRPSector64To95 = (uint32_t)(FLASH->WRPR3);
mbed_official 354:e67efb2aab0e 410
mbed_official 354:e67efb2aab0e 411 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 412
mbed_official 354:e67efb2aab0e 413 #if defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 414
mbed_official 354:e67efb2aab0e 415 /*Get WRP4*/
mbed_official 354:e67efb2aab0e 416 pOBInit->WRPSector96To127 = (uint32_t)(FLASH->WRPR4);
mbed_official 354:e67efb2aab0e 417
mbed_official 354:e67efb2aab0e 418 #endif /* STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 419
mbed_official 354:e67efb2aab0e 420 /*Get RDP Level*/
mbed_official 354:e67efb2aab0e 421 pOBInit->RDPLevel = FLASH_OB_GetRDP();
mbed_official 354:e67efb2aab0e 422
mbed_official 354:e67efb2aab0e 423 /*Get USER*/
mbed_official 354:e67efb2aab0e 424 pOBInit->USERConfig = FLASH_OB_GetUser();
mbed_official 354:e67efb2aab0e 425
mbed_official 354:e67efb2aab0e 426 /*Get BOR Level*/
mbed_official 354:e67efb2aab0e 427 pOBInit->BORLevel = FLASH_OB_GetBOR();
mbed_official 354:e67efb2aab0e 428
mbed_official 354:e67efb2aab0e 429 }
mbed_official 354:e67efb2aab0e 430
mbed_official 354:e67efb2aab0e 431 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 432 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 433 defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 434 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 435
mbed_official 354:e67efb2aab0e 436 /**
mbed_official 354:e67efb2aab0e 437 * @brief Program option bytes
mbed_official 354:e67efb2aab0e 438 * @note This function can be used only for Cat2 & Cat3 devices for PCROP and Cat4 & Cat5 for BFB2.
mbed_official 354:e67efb2aab0e 439 * @param pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
mbed_official 354:e67efb2aab0e 440 * contains the configuration information for the programming.
mbed_official 354:e67efb2aab0e 441 *
mbed_official 354:e67efb2aab0e 442 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 443 */
mbed_official 354:e67efb2aab0e 444 HAL_StatusTypeDef HAL_FLASHEx_AdvOBProgram (FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
mbed_official 354:e67efb2aab0e 445 {
mbed_official 354:e67efb2aab0e 446 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 354:e67efb2aab0e 447
mbed_official 354:e67efb2aab0e 448 /* Check the parameters */
mbed_official 354:e67efb2aab0e 449 assert_param(IS_OBEX(pAdvOBInit->OptionType));
mbed_official 354:e67efb2aab0e 450
mbed_official 354:e67efb2aab0e 451 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 452 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 453
mbed_official 354:e67efb2aab0e 454 /* Cat2 & Cat3 devices only */
mbed_official 354:e67efb2aab0e 455 /*Program PCROP option byte*/
mbed_official 354:e67efb2aab0e 456 if ((pAdvOBInit->OptionType & OBEX_PCROP) == OBEX_PCROP)
mbed_official 354:e67efb2aab0e 457 {
mbed_official 354:e67efb2aab0e 458 /* Check the parameters */
mbed_official 354:e67efb2aab0e 459 assert_param(IS_PCROPSTATE(pAdvOBInit->PCROPState));
mbed_official 354:e67efb2aab0e 460 if (pAdvOBInit->PCROPState == PCROPSTATE_ENABLE)
mbed_official 354:e67efb2aab0e 461 {
mbed_official 354:e67efb2aab0e 462 /*Enable of Write protection on the selected Sector*/
mbed_official 354:e67efb2aab0e 463 status = FLASH_OB_PCROPConfig(pAdvOBInit, ENABLE);
mbed_official 354:e67efb2aab0e 464 if (status != HAL_OK)
mbed_official 354:e67efb2aab0e 465 {
mbed_official 354:e67efb2aab0e 466 return status;
mbed_official 354:e67efb2aab0e 467 }
mbed_official 354:e67efb2aab0e 468 }
mbed_official 354:e67efb2aab0e 469 else
mbed_official 354:e67efb2aab0e 470 {
mbed_official 354:e67efb2aab0e 471 /*Disable of Write protection on the selected Sector*/
mbed_official 354:e67efb2aab0e 472 status = FLASH_OB_PCROPConfig(pAdvOBInit, DISABLE);
mbed_official 354:e67efb2aab0e 473 if (status != HAL_OK)
mbed_official 354:e67efb2aab0e 474 {
mbed_official 354:e67efb2aab0e 475 return status;
mbed_official 354:e67efb2aab0e 476 }
mbed_official 354:e67efb2aab0e 477 }
mbed_official 354:e67efb2aab0e 478 }
mbed_official 354:e67efb2aab0e 479
mbed_official 354:e67efb2aab0e 480 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 481
mbed_official 354:e67efb2aab0e 482 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 483 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 484
mbed_official 354:e67efb2aab0e 485 /* Cat4 & Cat5 devices only */
mbed_official 354:e67efb2aab0e 486 /*Program BOOT config option byte*/
mbed_official 354:e67efb2aab0e 487 if ((pAdvOBInit->OptionType & OBEX_BOOTCONFIG) == OBEX_BOOTCONFIG)
mbed_official 354:e67efb2aab0e 488 {
mbed_official 354:e67efb2aab0e 489 status = FLASH_OB_BootConfig(pAdvOBInit->BootConfig);
mbed_official 354:e67efb2aab0e 490 }
mbed_official 354:e67efb2aab0e 491
mbed_official 354:e67efb2aab0e 492 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 493
mbed_official 354:e67efb2aab0e 494 return status;
mbed_official 354:e67efb2aab0e 495 }
mbed_official 354:e67efb2aab0e 496
mbed_official 354:e67efb2aab0e 497 /**
mbed_official 354:e67efb2aab0e 498 * @brief Get the OBEX byte configuration
mbed_official 354:e67efb2aab0e 499 * @note This function can be used only for Cat2 & Cat3 devices for PCROP and Cat4 & Cat5 for BFB2.
mbed_official 354:e67efb2aab0e 500 * @param pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
mbed_official 354:e67efb2aab0e 501 * contains the configuration information for the programming.
mbed_official 354:e67efb2aab0e 502 *
mbed_official 354:e67efb2aab0e 503 * @retval None
mbed_official 354:e67efb2aab0e 504 */
mbed_official 354:e67efb2aab0e 505 void HAL_FLASHEx_AdvOBGetConfig(FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
mbed_official 354:e67efb2aab0e 506 {
mbed_official 354:e67efb2aab0e 507 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 508 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 509
mbed_official 354:e67efb2aab0e 510 pAdvOBInit->OptionType = OBEX_PCROP;
mbed_official 354:e67efb2aab0e 511
mbed_official 354:e67efb2aab0e 512 /*Get PCROP state */
mbed_official 354:e67efb2aab0e 513 pAdvOBInit->PCROPState = (FLASH->OBR & FLASH_OBR_SPRMOD) >> POSITION_VAL(FLASH_OBR_SPRMOD);
mbed_official 354:e67efb2aab0e 514
mbed_official 354:e67efb2aab0e 515 /*Get PCROP protected sector from 0 to 31 */
mbed_official 354:e67efb2aab0e 516 pAdvOBInit->PCROPSector0To31 = FLASH->WRPR1;
mbed_official 354:e67efb2aab0e 517
mbed_official 354:e67efb2aab0e 518 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 519
mbed_official 354:e67efb2aab0e 520 /*Get PCROP protected sector from 32 to 63 */
mbed_official 354:e67efb2aab0e 521 pAdvOBInit->PCROPSector32To63 = FLASH->WRPR2;
mbed_official 354:e67efb2aab0e 522
mbed_official 354:e67efb2aab0e 523 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 524
mbed_official 354:e67efb2aab0e 525 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 526
mbed_official 354:e67efb2aab0e 527 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 528 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 529
mbed_official 354:e67efb2aab0e 530 pAdvOBInit->OptionType = OBEX_BOOTCONFIG;
mbed_official 354:e67efb2aab0e 531
mbed_official 354:e67efb2aab0e 532 /*Get Boot config OB*/
mbed_official 354:e67efb2aab0e 533 pAdvOBInit->BootConfig = (FLASH->OBR & 0x80000000) >> 24;
mbed_official 354:e67efb2aab0e 534
mbed_official 354:e67efb2aab0e 535 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 536 }
mbed_official 354:e67efb2aab0e 537
mbed_official 354:e67efb2aab0e 538 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 539
mbed_official 354:e67efb2aab0e 540 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 541 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 542
mbed_official 354:e67efb2aab0e 543 /**
mbed_official 354:e67efb2aab0e 544 * @brief Select the Protection Mode (SPRMOD).
mbed_official 354:e67efb2aab0e 545 * @note This function can be used only for STM32L151xBA, STM32L152xBA, STM32L151xC, STM32L152xC & STM32L162xC devices
mbed_official 354:e67efb2aab0e 546 * @note Once SPRMOD bit is active, unprotection of a protected sector is not possible
mbed_official 354:e67efb2aab0e 547 * @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
mbed_official 354:e67efb2aab0e 548 * @retval HAL status
mbed_official 354:e67efb2aab0e 549 */
mbed_official 354:e67efb2aab0e 550 HAL_StatusTypeDef HAL_FLASHEx_OB_SelectPCROP(void)
mbed_official 354:e67efb2aab0e 551 {
mbed_official 354:e67efb2aab0e 552 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 553 uint16_t tmp1 = 0;
mbed_official 354:e67efb2aab0e 554 uint32_t tmp2 = 0;
mbed_official 354:e67efb2aab0e 555 uint8_t optiontmp = 0;
mbed_official 354:e67efb2aab0e 556 uint16_t optiontmp2 = 0;
mbed_official 354:e67efb2aab0e 557
mbed_official 354:e67efb2aab0e 558 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 559
mbed_official 354:e67efb2aab0e 560 /* Mask RDP Byte */
mbed_official 354:e67efb2aab0e 561 optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE));
mbed_official 354:e67efb2aab0e 562
mbed_official 354:e67efb2aab0e 563 /* Update Option Byte */
mbed_official 354:e67efb2aab0e 564 optiontmp2 = (uint16_t)(OB_PCROP_SELECTED | optiontmp);
mbed_official 354:e67efb2aab0e 565
mbed_official 354:e67efb2aab0e 566 /* calculate the option byte to write */
mbed_official 354:e67efb2aab0e 567 tmp1 = (uint16_t)(~(optiontmp2 ));
mbed_official 354:e67efb2aab0e 568 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16)) | ((uint32_t)optiontmp2));
mbed_official 354:e67efb2aab0e 569
mbed_official 354:e67efb2aab0e 570 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 571 {
mbed_official 354:e67efb2aab0e 572 /* program PCRop */
mbed_official 354:e67efb2aab0e 573 OB->RDP = tmp2;
mbed_official 354:e67efb2aab0e 574 }
mbed_official 354:e67efb2aab0e 575
mbed_official 354:e67efb2aab0e 576 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 577 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 578
mbed_official 354:e67efb2aab0e 579 /* Return the Read protection operation Status */
mbed_official 354:e67efb2aab0e 580 return status;
mbed_official 354:e67efb2aab0e 581 }
mbed_official 354:e67efb2aab0e 582
mbed_official 354:e67efb2aab0e 583 /**
mbed_official 354:e67efb2aab0e 584 * @brief Deselect the Protection Mode (SPRMOD).
mbed_official 354:e67efb2aab0e 585 * @note This function can be used only for STM32L151xBA, STM32L152xBA, STM32L151xC, STM32L152xC & STM32L162xC devices
mbed_official 354:e67efb2aab0e 586 * @note Once SPRMOD bit is active, unprotection of a protected sector is not possible
mbed_official 354:e67efb2aab0e 587 * @note Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
mbed_official 354:e67efb2aab0e 588 * @retval HAL status
mbed_official 354:e67efb2aab0e 589 */
mbed_official 354:e67efb2aab0e 590 HAL_StatusTypeDef HAL_FLASHEx_OB_DeSelectPCROP(void)
mbed_official 354:e67efb2aab0e 591 {
mbed_official 354:e67efb2aab0e 592 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 593 uint16_t tmp1 = 0;
mbed_official 354:e67efb2aab0e 594 uint32_t tmp2 = 0;
mbed_official 354:e67efb2aab0e 595 uint8_t optiontmp = 0;
mbed_official 354:e67efb2aab0e 596 uint16_t optiontmp2 = 0;
mbed_official 354:e67efb2aab0e 597
mbed_official 354:e67efb2aab0e 598 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 599
mbed_official 354:e67efb2aab0e 600 /* Mask RDP Byte */
mbed_official 354:e67efb2aab0e 601 optiontmp = (uint8_t)(*(__IO uint8_t *)(OB_BASE));
mbed_official 354:e67efb2aab0e 602
mbed_official 354:e67efb2aab0e 603 /* Update Option Byte */
mbed_official 354:e67efb2aab0e 604 optiontmp2 = (uint16_t)(OB_PCROP_DESELECTED | optiontmp);
mbed_official 354:e67efb2aab0e 605
mbed_official 354:e67efb2aab0e 606 /* calculate the option byte to write */
mbed_official 354:e67efb2aab0e 607 tmp1 = (uint16_t)(~(optiontmp2 ));
mbed_official 354:e67efb2aab0e 608 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16)) | ((uint32_t)optiontmp2));
mbed_official 354:e67efb2aab0e 609
mbed_official 354:e67efb2aab0e 610 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 611 {
mbed_official 354:e67efb2aab0e 612 /* program PCRop */
mbed_official 354:e67efb2aab0e 613 OB->RDP = tmp2;
mbed_official 354:e67efb2aab0e 614 }
mbed_official 354:e67efb2aab0e 615
mbed_official 354:e67efb2aab0e 616 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 617 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 618
mbed_official 354:e67efb2aab0e 619 /* Return the Read protection operation Status */
mbed_official 354:e67efb2aab0e 620 return status;
mbed_official 354:e67efb2aab0e 621 }
mbed_official 354:e67efb2aab0e 622
mbed_official 354:e67efb2aab0e 623 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 624
mbed_official 354:e67efb2aab0e 625 /**
mbed_official 354:e67efb2aab0e 626 * @}
mbed_official 354:e67efb2aab0e 627 */
mbed_official 354:e67efb2aab0e 628
mbed_official 354:e67efb2aab0e 629 /** @defgroup FLASHEx_Exported_Functions_Group3 DATA EEPROM Programming functions
mbed_official 354:e67efb2aab0e 630 * @brief DATA EEPROM Programming functions
mbed_official 354:e67efb2aab0e 631 *
mbed_official 354:e67efb2aab0e 632 @verbatim
mbed_official 354:e67efb2aab0e 633 ===============================================================================
mbed_official 354:e67efb2aab0e 634 ##### DATA EEPROM Programming functions #####
mbed_official 354:e67efb2aab0e 635 ===============================================================================
mbed_official 354:e67efb2aab0e 636
mbed_official 354:e67efb2aab0e 637 [..] Any operation of erase or program should follow these steps:
mbed_official 354:e67efb2aab0e 638 (#) Call the HAL_FLASHEx_DATAEEPROM_Unlock() function to enable the data EEPROM access
mbed_official 354:e67efb2aab0e 639 and Flash program erase control register access.
mbed_official 354:e67efb2aab0e 640 (#) Call the desired function to erase or program data.
mbed_official 354:e67efb2aab0e 641 (#) Call the HAL_FLASHEx_DATAEEPROM_Lock() to disable the data EEPROM access
mbed_official 354:e67efb2aab0e 642 and Flash program erase control register access(recommended
mbed_official 354:e67efb2aab0e 643 to protect the DATA_EEPROM against possible unwanted operation).
mbed_official 354:e67efb2aab0e 644
mbed_official 354:e67efb2aab0e 645 @endverbatim
mbed_official 354:e67efb2aab0e 646 * @{
mbed_official 354:e67efb2aab0e 647 */
mbed_official 354:e67efb2aab0e 648
mbed_official 354:e67efb2aab0e 649 /**
mbed_official 354:e67efb2aab0e 650 * @brief Unlocks the data memory and FLASH_PECR register access.
mbed_official 354:e67efb2aab0e 651 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 652 */
mbed_official 354:e67efb2aab0e 653 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Unlock(void)
mbed_official 354:e67efb2aab0e 654 {
mbed_official 354:e67efb2aab0e 655 if((FLASH->PECR & FLASH_PECR_PELOCK) != RESET)
mbed_official 354:e67efb2aab0e 656 {
mbed_official 354:e67efb2aab0e 657 /* Unlocking the Data memory and FLASH_PECR register access*/
mbed_official 354:e67efb2aab0e 658 FLASH->PEKEYR = FLASH_PEKEY1;
mbed_official 354:e67efb2aab0e 659 FLASH->PEKEYR = FLASH_PEKEY2;
mbed_official 354:e67efb2aab0e 660 }
mbed_official 354:e67efb2aab0e 661 else
mbed_official 354:e67efb2aab0e 662 {
mbed_official 354:e67efb2aab0e 663 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 664 }
mbed_official 354:e67efb2aab0e 665 return HAL_OK;
mbed_official 354:e67efb2aab0e 666 }
mbed_official 354:e67efb2aab0e 667
mbed_official 354:e67efb2aab0e 668 /**
mbed_official 354:e67efb2aab0e 669 * @brief Locks the Data memory and FLASH_PECR register access.
mbed_official 354:e67efb2aab0e 670 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 671 */
mbed_official 354:e67efb2aab0e 672 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Lock(void)
mbed_official 354:e67efb2aab0e 673 {
mbed_official 354:e67efb2aab0e 674 /* Set the PELOCK Bit to lock the data memory and FLASH_PECR register access */
mbed_official 354:e67efb2aab0e 675 SET_BIT(FLASH->PECR, FLASH_PECR_PELOCK);
mbed_official 354:e67efb2aab0e 676
mbed_official 354:e67efb2aab0e 677 return HAL_OK;
mbed_official 354:e67efb2aab0e 678 }
mbed_official 354:e67efb2aab0e 679
mbed_official 354:e67efb2aab0e 680 /**
mbed_official 354:e67efb2aab0e 681 * @brief Erase a word in data memory.
mbed_official 354:e67efb2aab0e 682 * @param Address: specifies the address to be erased.
mbed_official 354:e67efb2aab0e 683 * @param TypeErase: Indicate the way to erase at a specified address.
mbed_official 354:e67efb2aab0e 684 * This parameter can be a value of @ref FLASH_Type_Program
mbed_official 354:e67efb2aab0e 685 * @note To correctly run this function, the DATA_EEPROM_Unlock() function
mbed_official 354:e67efb2aab0e 686 * must be called before.
mbed_official 354:e67efb2aab0e 687 * Call the DATA_EEPROM_Lock() to the data EEPROM access
mbed_official 354:e67efb2aab0e 688 * and Flash program erase control register access(recommended to protect
mbed_official 354:e67efb2aab0e 689 * the DATA_EEPROM against possible unwanted operation).
mbed_official 354:e67efb2aab0e 690 * @retval FLASH Status: The returned value can be:
mbed_official 354:e67efb2aab0e 691 * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
mbed_official 354:e67efb2aab0e 692 */
mbed_official 354:e67efb2aab0e 693 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t TypeErase, uint32_t Address)
mbed_official 354:e67efb2aab0e 694 {
mbed_official 354:e67efb2aab0e 695 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 696
mbed_official 354:e67efb2aab0e 697 /* Check the parameters */
mbed_official 354:e67efb2aab0e 698 assert_param(IS_TYPEPROGRAMDATA(TypeErase));
mbed_official 354:e67efb2aab0e 699 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 700
mbed_official 354:e67efb2aab0e 701 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 702 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 703
mbed_official 354:e67efb2aab0e 704 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 705 {
mbed_official 354:e67efb2aab0e 706 if(TypeErase == TYPEERASEDATA_WORD)
mbed_official 354:e67efb2aab0e 707 {
mbed_official 354:e67efb2aab0e 708 /* Write 00000000h to valid address in the data memory */
mbed_official 354:e67efb2aab0e 709 *(__IO uint32_t *) Address = 0x00000000;
mbed_official 354:e67efb2aab0e 710 }
mbed_official 354:e67efb2aab0e 711
mbed_official 354:e67efb2aab0e 712 if(TypeErase == TYPEERASEDATA_HALFWORD)
mbed_official 354:e67efb2aab0e 713 {
mbed_official 354:e67efb2aab0e 714 /* Write 0000h to valid address in the data memory */
mbed_official 354:e67efb2aab0e 715 *(__IO uint16_t *) Address = (uint16_t)0x0000;
mbed_official 354:e67efb2aab0e 716 }
mbed_official 354:e67efb2aab0e 717
mbed_official 354:e67efb2aab0e 718 if(TypeErase == TYPEERASEDATA_BYTE)
mbed_official 354:e67efb2aab0e 719 {
mbed_official 354:e67efb2aab0e 720 /* Write 00h to valid address in the data memory */
mbed_official 354:e67efb2aab0e 721 *(__IO uint8_t *) Address = (uint8_t)0x00;
mbed_official 354:e67efb2aab0e 722 }
mbed_official 354:e67efb2aab0e 723 }
mbed_official 354:e67efb2aab0e 724
mbed_official 354:e67efb2aab0e 725 /* Return the erase status */
mbed_official 354:e67efb2aab0e 726 return status;
mbed_official 354:e67efb2aab0e 727 }
mbed_official 354:e67efb2aab0e 728
mbed_official 354:e67efb2aab0e 729 /**
mbed_official 354:e67efb2aab0e 730 * @brief Program word at a specified address
mbed_official 354:e67efb2aab0e 731 * @note To correctly run this function, the HAL_FLASH_EEPROM_Unlock() function
mbed_official 354:e67efb2aab0e 732 * must be called before.
mbed_official 354:e67efb2aab0e 733 * Call the HAL_FLASHEx_DATAEEPROM_Unlock() to he data EEPROM access
mbed_official 354:e67efb2aab0e 734 * and Flash program erase control register access(recommended to protect
mbed_official 354:e67efb2aab0e 735 * the DATA_EEPROM against possible unwanted operation).
mbed_official 354:e67efb2aab0e 736 * @note The function HAL_FLASHEx_DATAEEPROM_EnableFixedTimeProgram() can be called before
mbed_official 354:e67efb2aab0e 737 * this function to configure the Fixed Time Programming.
mbed_official 354:e67efb2aab0e 738 * @param TypeProgram: Indicate the way to program at a specified address.
mbed_official 354:e67efb2aab0e 739 * This parameter can be a value of @ref FLASHEx_Type_Program_Data
mbed_official 354:e67efb2aab0e 740 * @param Address: specifies the address to be programmed.
mbed_official 354:e67efb2aab0e 741 * @param Data: specifies the data to be programmed
mbed_official 354:e67efb2aab0e 742 *
mbed_official 354:e67efb2aab0e 743 * @retval HAL_StatusTypeDef HAL Status
mbed_official 354:e67efb2aab0e 744 */
mbed_official 354:e67efb2aab0e 745
mbed_official 354:e67efb2aab0e 746 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)
mbed_official 354:e67efb2aab0e 747 {
mbed_official 354:e67efb2aab0e 748 HAL_StatusTypeDef status = HAL_ERROR;
mbed_official 354:e67efb2aab0e 749
mbed_official 354:e67efb2aab0e 750 /* Process Locked */
mbed_official 354:e67efb2aab0e 751 __HAL_LOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 752
mbed_official 354:e67efb2aab0e 753 /* Check the parameters */
mbed_official 354:e67efb2aab0e 754 assert_param(IS_TYPEPROGRAMDATA(TypeProgram));
mbed_official 354:e67efb2aab0e 755
mbed_official 354:e67efb2aab0e 756 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 757 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 758
mbed_official 354:e67efb2aab0e 759 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 760 {
mbed_official 354:e67efb2aab0e 761 if(TypeProgram == TYPEPROGRAMDATA_FASTBYTE)
mbed_official 354:e67efb2aab0e 762 {
mbed_official 354:e67efb2aab0e 763 /*Program word (8-bit) at a specified address.*/
mbed_official 354:e67efb2aab0e 764 FLASH_DATAEEPROM_FastProgramByte(Address, (uint8_t) Data);
mbed_official 354:e67efb2aab0e 765 }
mbed_official 354:e67efb2aab0e 766
mbed_official 354:e67efb2aab0e 767 if(TypeProgram == TYPEPROGRAMDATA_FASTHALFWORD)
mbed_official 354:e67efb2aab0e 768 {
mbed_official 354:e67efb2aab0e 769 /*Program word (16-bit) at a specified address.*/
mbed_official 354:e67efb2aab0e 770 FLASH_DATAEEPROM_FastProgramHalfWord(Address, (uint16_t) Data);
mbed_official 354:e67efb2aab0e 771 }
mbed_official 354:e67efb2aab0e 772
mbed_official 354:e67efb2aab0e 773 if(TypeProgram == TYPEPROGRAMDATA_FASTWORD)
mbed_official 354:e67efb2aab0e 774 {
mbed_official 354:e67efb2aab0e 775 /*Program word (32-bit) at a specified address.*/
mbed_official 354:e67efb2aab0e 776 FLASH_DATAEEPROM_FastProgramWord(Address, (uint32_t) Data);
mbed_official 354:e67efb2aab0e 777 }
mbed_official 354:e67efb2aab0e 778
mbed_official 354:e67efb2aab0e 779 if(TypeProgram == TYPEPROGRAMDATA_WORD)
mbed_official 354:e67efb2aab0e 780 {
mbed_official 354:e67efb2aab0e 781 /*Program word (32-bit) at a specified address.*/
mbed_official 354:e67efb2aab0e 782 FLASH_DATAEEPROM_ProgramWord(Address, (uint32_t) Data);
mbed_official 354:e67efb2aab0e 783 }
mbed_official 354:e67efb2aab0e 784
mbed_official 354:e67efb2aab0e 785 if(TypeProgram == TYPEPROGRAMDATA_HALFWORD)
mbed_official 354:e67efb2aab0e 786 {
mbed_official 354:e67efb2aab0e 787 /*Program word (16-bit) at a specified address.*/
mbed_official 354:e67efb2aab0e 788 FLASH_DATAEEPROM_ProgramHalfWord(Address, (uint16_t) Data);
mbed_official 354:e67efb2aab0e 789 }
mbed_official 354:e67efb2aab0e 790
mbed_official 354:e67efb2aab0e 791 if(TypeProgram == TYPEPROGRAMDATA_BYTE)
mbed_official 354:e67efb2aab0e 792 {
mbed_official 354:e67efb2aab0e 793 /*Program word (8-bit) at a specified address.*/
mbed_official 354:e67efb2aab0e 794 FLASH_DATAEEPROM_ProgramByte(Address, (uint8_t) Data);
mbed_official 354:e67efb2aab0e 795 }
mbed_official 354:e67efb2aab0e 796
mbed_official 354:e67efb2aab0e 797 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 798 status = FLASH_WaitForLastOperation((uint32_t)HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 799 }
mbed_official 354:e67efb2aab0e 800
mbed_official 354:e67efb2aab0e 801 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 802 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 803
mbed_official 354:e67efb2aab0e 804 return status;
mbed_official 354:e67efb2aab0e 805 }
mbed_official 354:e67efb2aab0e 806
mbed_official 354:e67efb2aab0e 807 /**
mbed_official 354:e67efb2aab0e 808 * @brief Enable DATA EEPROM fixed Time programming (2*Tprog).
mbed_official 354:e67efb2aab0e 809 * @retval None
mbed_official 354:e67efb2aab0e 810 */
mbed_official 354:e67efb2aab0e 811 void HAL_FLASHEx_DATAEEPROM_EnableFixedTimeProgram(void)
mbed_official 354:e67efb2aab0e 812 {
mbed_official 354:e67efb2aab0e 813 SET_BIT(FLASH->PECR, FLASH_PECR_FTDW);
mbed_official 354:e67efb2aab0e 814 }
mbed_official 354:e67efb2aab0e 815
mbed_official 354:e67efb2aab0e 816 /**
mbed_official 354:e67efb2aab0e 817 * @brief Disables DATA EEPROM fixed Time programming (2*Tprog).
mbed_official 354:e67efb2aab0e 818 * @retval None
mbed_official 354:e67efb2aab0e 819 */
mbed_official 354:e67efb2aab0e 820 void HAL_FLASHEx_DATAEEPROM_DisableFixedTimeProgram(void)
mbed_official 354:e67efb2aab0e 821 {
mbed_official 354:e67efb2aab0e 822 CLEAR_BIT(FLASH->PECR, FLASH_PECR_FTDW);
mbed_official 354:e67efb2aab0e 823 }
mbed_official 354:e67efb2aab0e 824
mbed_official 354:e67efb2aab0e 825 /**
mbed_official 354:e67efb2aab0e 826 * @}
mbed_official 354:e67efb2aab0e 827 */
mbed_official 354:e67efb2aab0e 828
mbed_official 354:e67efb2aab0e 829 /**
mbed_official 354:e67efb2aab0e 830 * @}
mbed_official 354:e67efb2aab0e 831 */
mbed_official 354:e67efb2aab0e 832
mbed_official 354:e67efb2aab0e 833 /** @defgroup FLASHEx_Private_Functions FLASHEx Private functions
mbed_official 354:e67efb2aab0e 834 * @{
mbed_official 354:e67efb2aab0e 835 */
mbed_official 354:e67efb2aab0e 836
mbed_official 354:e67efb2aab0e 837 /*
mbed_official 354:e67efb2aab0e 838 ==============================================================================
mbed_official 354:e67efb2aab0e 839 ##### FLASH STATIC functions #####
mbed_official 354:e67efb2aab0e 840 ==============================================================================
mbed_official 354:e67efb2aab0e 841 */
mbed_official 354:e67efb2aab0e 842
mbed_official 354:e67efb2aab0e 843 /*
mbed_official 354:e67efb2aab0e 844 ==============================================================================
mbed_official 354:e67efb2aab0e 845 FLASH
mbed_official 354:e67efb2aab0e 846 ==============================================================================
mbed_official 354:e67efb2aab0e 847 */
mbed_official 354:e67efb2aab0e 848
mbed_official 354:e67efb2aab0e 849 /**
mbed_official 354:e67efb2aab0e 850 * @brief Set the specific FLASH error flag.
mbed_official 354:e67efb2aab0e 851 * @retval None
mbed_official 354:e67efb2aab0e 852 */
mbed_official 354:e67efb2aab0e 853 static void FLASH_SetErrorCode(void)
mbed_official 354:e67efb2aab0e 854 {
mbed_official 354:e67efb2aab0e 855 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) != RESET)
mbed_official 354:e67efb2aab0e 856 {
mbed_official 354:e67efb2aab0e 857 ProcFlash.ErrorCode = FLASH_ERROR_WRP;
mbed_official 354:e67efb2aab0e 858 }
mbed_official 354:e67efb2aab0e 859
mbed_official 354:e67efb2aab0e 860 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGAERR) != RESET)
mbed_official 354:e67efb2aab0e 861 {
mbed_official 354:e67efb2aab0e 862 ProcFlash.ErrorCode |= FLASH_ERROR_PGA;
mbed_official 354:e67efb2aab0e 863 }
mbed_official 354:e67efb2aab0e 864
mbed_official 354:e67efb2aab0e 865 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_SIZERR) != RESET)
mbed_official 354:e67efb2aab0e 866 {
mbed_official 354:e67efb2aab0e 867 ProcFlash.ErrorCode |= FLASH_ERROR_SIZE;
mbed_official 354:e67efb2aab0e 868 }
mbed_official 354:e67efb2aab0e 869
mbed_official 354:e67efb2aab0e 870 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERR) != RESET)
mbed_official 354:e67efb2aab0e 871 {
mbed_official 354:e67efb2aab0e 872 ProcFlash.ErrorCode |= FLASH_ERROR_OPTV;
mbed_official 354:e67efb2aab0e 873 }
mbed_official 354:e67efb2aab0e 874
mbed_official 354:e67efb2aab0e 875 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 876 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 877 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_RDERR) != RESET)
mbed_official 354:e67efb2aab0e 878 {
mbed_official 354:e67efb2aab0e 879 ProcFlash.ErrorCode |= FLASH_ERROR_RD;
mbed_official 354:e67efb2aab0e 880 }
mbed_official 354:e67efb2aab0e 881 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 882
mbed_official 354:e67efb2aab0e 883 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 884 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 885 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 886 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERRUSR) != RESET)
mbed_official 354:e67efb2aab0e 887 {
mbed_official 354:e67efb2aab0e 888 ProcFlash.ErrorCode |= FLASH_ERROR_OPTVUSR;
mbed_official 354:e67efb2aab0e 889 }
mbed_official 354:e67efb2aab0e 890 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 891 }
mbed_official 354:e67efb2aab0e 892
mbed_official 354:e67efb2aab0e 893 /**
mbed_official 354:e67efb2aab0e 894 * @brief Erases a specified page in program memory.
mbed_official 354:e67efb2aab0e 895 * @param PageAddress: The page address in program memory to be erased.
mbed_official 354:e67efb2aab0e 896 * @note A Page is erased in the Program memory only if the address to load
mbed_official 354:e67efb2aab0e 897 * is the start address of a page (multiple of 256 bytes).
mbed_official 354:e67efb2aab0e 898 * @retval None
mbed_official 354:e67efb2aab0e 899 */
mbed_official 354:e67efb2aab0e 900 static void FLASH_ErasePage(uint32_t PageAddress)
mbed_official 354:e67efb2aab0e 901 {
mbed_official 354:e67efb2aab0e 902 /* Set the ERASE bit */
mbed_official 354:e67efb2aab0e 903 SET_BIT(FLASH->PECR, FLASH_PECR_ERASE);
mbed_official 354:e67efb2aab0e 904
mbed_official 354:e67efb2aab0e 905 /* Set PROG bit */
mbed_official 354:e67efb2aab0e 906 SET_BIT(FLASH->PECR, FLASH_PECR_PROG);
mbed_official 354:e67efb2aab0e 907
mbed_official 354:e67efb2aab0e 908 /* Write 00000000h to the first word of the program page to erase */
mbed_official 354:e67efb2aab0e 909 *(__IO uint32_t *)PageAddress = 0x00000000;
mbed_official 354:e67efb2aab0e 910 }
mbed_official 354:e67efb2aab0e 911
mbed_official 354:e67efb2aab0e 912
mbed_official 354:e67efb2aab0e 913 /*
mbed_official 354:e67efb2aab0e 914 ==============================================================================
mbed_official 354:e67efb2aab0e 915 OPTIONS BYTES
mbed_official 354:e67efb2aab0e 916 ==============================================================================
mbed_official 354:e67efb2aab0e 917 */
mbed_official 354:e67efb2aab0e 918 /**
mbed_official 354:e67efb2aab0e 919 * @brief Enables or disables the read out protection.
mbed_official 354:e67efb2aab0e 920 * @note To correctly run this function, the HAL_FLASH_OB_Unlock() function
mbed_official 354:e67efb2aab0e 921 * must be called before.
mbed_official 354:e67efb2aab0e 922 * @param OB_RDP: specifies the read protection level.
mbed_official 354:e67efb2aab0e 923 * This parameter can be:
mbed_official 354:e67efb2aab0e 924 * @arg OB_RDP_LEVEL0: No protection
mbed_official 354:e67efb2aab0e 925 * @arg OB_RDP_LEVEL1: Read protection of the memory
mbed_official 354:e67efb2aab0e 926 * @arg OB_RDP_LEVEL2: Chip protection
mbed_official 354:e67efb2aab0e 927 *
mbed_official 354:e67efb2aab0e 928 * !!!Warning!!! When enabling OB_RDP_LEVEL2 it's no more possible to go back to level 1 or 0
mbed_official 354:e67efb2aab0e 929 *
mbed_official 354:e67efb2aab0e 930 * @retval HAL status
mbed_official 354:e67efb2aab0e 931 */
mbed_official 354:e67efb2aab0e 932 static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP)
mbed_official 354:e67efb2aab0e 933 {
mbed_official 354:e67efb2aab0e 934 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 935 uint32_t tmp1 = 0, tmp2 = 0, sprmod = 0;
mbed_official 354:e67efb2aab0e 936
mbed_official 354:e67efb2aab0e 937 /* Check the parameters */
mbed_official 354:e67efb2aab0e 938 assert_param(IS_OB_RDP(OB_RDP));
mbed_official 354:e67efb2aab0e 939
mbed_official 354:e67efb2aab0e 940 /* According to errata sheet, DocID022054 Rev 5, par2.1.5
mbed_official 354:e67efb2aab0e 941 Before setting Level0 in the RDP register, check that the current level is not equal to Level0.
mbed_official 354:e67efb2aab0e 942 If the current level is not equal to Level0, Level0 can be activated.
mbed_official 354:e67efb2aab0e 943 If the current level is Level0 then the RDP register must not be written again with Level0. */
mbed_official 354:e67efb2aab0e 944 tmp1 = (uint32_t)(OB->RDP & 0x000000FF);
mbed_official 354:e67efb2aab0e 945
mbed_official 354:e67efb2aab0e 946 if ((tmp1 == OB_RDP_LEVEL0) && (OB_RDP == OB_RDP_LEVEL0))
mbed_official 354:e67efb2aab0e 947 {
mbed_official 354:e67efb2aab0e 948 /*current level is Level0 then the RDP register must not be written again with Level0. */
mbed_official 354:e67efb2aab0e 949 status = HAL_ERROR;
mbed_official 354:e67efb2aab0e 950 }
mbed_official 354:e67efb2aab0e 951 else
mbed_official 354:e67efb2aab0e 952 {
mbed_official 354:e67efb2aab0e 953 /* Mask SPRMOD bit */
mbed_official 354:e67efb2aab0e 954 sprmod = (uint32_t)(OB->RDP & 0x00000100);
mbed_official 354:e67efb2aab0e 955
mbed_official 354:e67efb2aab0e 956 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 957
mbed_official 354:e67efb2aab0e 958 /* calculate the option byte to write */
mbed_official 354:e67efb2aab0e 959 tmp1 = (~((uint32_t)(OB_RDP | sprmod)));
mbed_official 354:e67efb2aab0e 960 tmp2 = (uint32_t)(((uint32_t)((uint32_t)(tmp1) << 16)) | ((uint32_t)(OB_RDP | sprmod)));
mbed_official 354:e67efb2aab0e 961
mbed_official 354:e67efb2aab0e 962 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 963 {
mbed_official 354:e67efb2aab0e 964 /* program read protection level */
mbed_official 354:e67efb2aab0e 965 OB->RDP = tmp2;
mbed_official 354:e67efb2aab0e 966 }
mbed_official 354:e67efb2aab0e 967
mbed_official 354:e67efb2aab0e 968 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 969 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 970 }
mbed_official 354:e67efb2aab0e 971
mbed_official 354:e67efb2aab0e 972 /* Return the Read protection operation Status */
mbed_official 354:e67efb2aab0e 973 return status;
mbed_official 354:e67efb2aab0e 974 }
mbed_official 354:e67efb2aab0e 975
mbed_official 354:e67efb2aab0e 976 /**
mbed_official 354:e67efb2aab0e 977 * @brief Programs the FLASH brownout reset threshold level Option Byte.
mbed_official 354:e67efb2aab0e 978 * @param OB_BOR: Selects the brownout reset threshold level.
mbed_official 354:e67efb2aab0e 979 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 980 * @arg OB_BOR_OFF: BOR is disabled at power down, the reset is asserted when the VDD
mbed_official 354:e67efb2aab0e 981 * power supply reaches the PDR(Power Down Reset) threshold (1.5V)
mbed_official 354:e67efb2aab0e 982 * @arg OB_BOR_LEVEL1: BOR Reset threshold levels for 1.7V - 1.8V VDD power supply
mbed_official 354:e67efb2aab0e 983 * @arg OB_BOR_LEVEL2: BOR Reset threshold levels for 1.9V - 2.0V VDD power supply
mbed_official 354:e67efb2aab0e 984 * @arg OB_BOR_LEVEL3: BOR Reset threshold levels for 2.3V - 2.4V VDD power supply
mbed_official 354:e67efb2aab0e 985 * @arg OB_BOR_LEVEL4: BOR Reset threshold levels for 2.55V - 2.65V VDD power supply
mbed_official 354:e67efb2aab0e 986 * @arg OB_BOR_LEVEL5: BOR Reset threshold levels for 2.8V - 2.9V VDD power supply
mbed_official 354:e67efb2aab0e 987 * @retval HAL status
mbed_official 354:e67efb2aab0e 988 */
mbed_official 354:e67efb2aab0e 989 static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR)
mbed_official 354:e67efb2aab0e 990 {
mbed_official 354:e67efb2aab0e 991 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 992 uint32_t tmp = 0, tmp1 = 0;
mbed_official 354:e67efb2aab0e 993
mbed_official 354:e67efb2aab0e 994 /* Check the parameters */
mbed_official 354:e67efb2aab0e 995 assert_param(IS_OB_BOR_LEVEL(OB_BOR));
mbed_official 354:e67efb2aab0e 996
mbed_official 354:e67efb2aab0e 997 /* Get the User Option byte register */
mbed_official 354:e67efb2aab0e 998 tmp1 = (FLASH->OBR & (FLASH_OBR_USER)) >> 16;
mbed_official 354:e67efb2aab0e 999
mbed_official 354:e67efb2aab0e 1000 /* Calculate the option byte to write - [0xFF | nUSER | 0x00 | USER]*/
mbed_official 354:e67efb2aab0e 1001 tmp = (uint32_t)~((OB_BOR | tmp1)) << 16;
mbed_official 354:e67efb2aab0e 1002 tmp |= (OB_BOR | tmp1);
mbed_official 354:e67efb2aab0e 1003
mbed_official 354:e67efb2aab0e 1004 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1005 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1006
mbed_official 354:e67efb2aab0e 1007 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1008 {
mbed_official 354:e67efb2aab0e 1009 /* Write the BOR Option Byte */
mbed_official 354:e67efb2aab0e 1010 OB->USER = tmp;
mbed_official 354:e67efb2aab0e 1011 }
mbed_official 354:e67efb2aab0e 1012
mbed_official 354:e67efb2aab0e 1013 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1014 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1015
mbed_official 354:e67efb2aab0e 1016 /* Return the Option Byte program Status */
mbed_official 354:e67efb2aab0e 1017 return status;
mbed_official 354:e67efb2aab0e 1018 }
mbed_official 354:e67efb2aab0e 1019
mbed_official 354:e67efb2aab0e 1020 /**
mbed_official 354:e67efb2aab0e 1021 * @brief Returns the FLASH User Option Bytes values.
mbed_official 354:e67efb2aab0e 1022 * @retval The FLASH User Option Bytes.
mbed_official 354:e67efb2aab0e 1023 */
mbed_official 354:e67efb2aab0e 1024 static uint8_t FLASH_OB_GetUser(void)
mbed_official 354:e67efb2aab0e 1025 {
mbed_official 354:e67efb2aab0e 1026 /* Return the User Option Byte */
mbed_official 354:e67efb2aab0e 1027 return (uint8_t)((FLASH->OBR & FLASH_OBR_USER) >> POSITION_VAL(FLASH_OBR_USER));
mbed_official 354:e67efb2aab0e 1028 }
mbed_official 354:e67efb2aab0e 1029
mbed_official 354:e67efb2aab0e 1030 /**
mbed_official 354:e67efb2aab0e 1031 * @brief Checks whether the FLASH Read out Protection Status is set or not.
mbed_official 354:e67efb2aab0e 1032 * @retval FLASH ReadOut Protection
mbed_official 354:e67efb2aab0e 1033 */
mbed_official 354:e67efb2aab0e 1034 static uint8_t FLASH_OB_GetRDP(void)
mbed_official 354:e67efb2aab0e 1035 {
mbed_official 354:e67efb2aab0e 1036 return (uint8_t)(FLASH->OBR & FLASH_OBR_RDPRT);
mbed_official 354:e67efb2aab0e 1037 }
mbed_official 354:e67efb2aab0e 1038
mbed_official 354:e67efb2aab0e 1039 /**
mbed_official 354:e67efb2aab0e 1040 * @brief Returns the FLASH BOR level.
mbed_official 354:e67efb2aab0e 1041 * @retval The FLASH User Option Bytes.
mbed_official 354:e67efb2aab0e 1042 */
mbed_official 354:e67efb2aab0e 1043 static uint8_t FLASH_OB_GetBOR(void)
mbed_official 354:e67efb2aab0e 1044 {
mbed_official 354:e67efb2aab0e 1045 /* Return the BOR level */
mbed_official 354:e67efb2aab0e 1046 return (uint8_t)((FLASH->OBR & (uint32_t)FLASH_OBR_BOR_LEV) >> POSITION_VAL(FLASH_OBR_BOR_LEV));
mbed_official 354:e67efb2aab0e 1047 }
mbed_official 354:e67efb2aab0e 1048
mbed_official 354:e67efb2aab0e 1049 /**
mbed_official 354:e67efb2aab0e 1050 * @brief Write protects the desired pages of the first 64KB of the Flash.
mbed_official 354:e67efb2aab0e 1051 * @param pOBInit: pointer to an FLASH_OBInitStruct structure that
mbed_official 354:e67efb2aab0e 1052 * contains WRP parameters.
mbed_official 354:e67efb2aab0e 1053 * @param NewState: new state of the specified FLASH Pages Wtite protection.
mbed_official 354:e67efb2aab0e 1054 * This parameter can be: ENABLE or DISABLE.
mbed_official 354:e67efb2aab0e 1055 * @retval HAL_StatusTypeDef
mbed_official 354:e67efb2aab0e 1056 */
mbed_official 354:e67efb2aab0e 1057 static HAL_StatusTypeDef FLASH_OB_WRPConfig(FLASH_OBProgramInitTypeDef *pOBInit, FunctionalState NewState)
mbed_official 354:e67efb2aab0e 1058 {
mbed_official 354:e67efb2aab0e 1059 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1060
mbed_official 354:e67efb2aab0e 1061 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1062 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1063
mbed_official 354:e67efb2aab0e 1064 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1065 {
mbed_official 354:e67efb2aab0e 1066 /* WRP for sector between 0 to 31 */
mbed_official 354:e67efb2aab0e 1067 if (pOBInit->WRPSector0To31 != 0)
mbed_official 354:e67efb2aab0e 1068 {
mbed_official 354:e67efb2aab0e 1069 FLASH_OB_WRPConfigWRP1OrPCROP1(pOBInit->WRPSector0To31, NewState);
mbed_official 354:e67efb2aab0e 1070 }
mbed_official 354:e67efb2aab0e 1071
mbed_official 354:e67efb2aab0e 1072 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 1073 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1074 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1075
mbed_official 354:e67efb2aab0e 1076 /* Pages for Cat3, Cat4 & Cat5 devices*/
mbed_official 354:e67efb2aab0e 1077 /* WRP for sector between 32 to 63 */
mbed_official 354:e67efb2aab0e 1078 if (pOBInit->WRPSector32To63 != 0)
mbed_official 354:e67efb2aab0e 1079 {
mbed_official 354:e67efb2aab0e 1080 FLASH_OB_WRPConfigWRP2OrPCROP2(pOBInit->WRPSector32To63, NewState);
mbed_official 354:e67efb2aab0e 1081 }
mbed_official 354:e67efb2aab0e 1082
mbed_official 354:e67efb2aab0e 1083 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1084
mbed_official 354:e67efb2aab0e 1085 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1086 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1087
mbed_official 354:e67efb2aab0e 1088 /* Pages for devices with FLASH >= 256KB*/
mbed_official 354:e67efb2aab0e 1089 /* WRP for sector between 64 to 95 */
mbed_official 354:e67efb2aab0e 1090 if (pOBInit->WRPSector64To95 != 0)
mbed_official 354:e67efb2aab0e 1091 {
mbed_official 354:e67efb2aab0e 1092 FLASH_OB_WRPConfigWRP3(pOBInit->WRPSector64To95, NewState);
mbed_official 354:e67efb2aab0e 1093 }
mbed_official 354:e67efb2aab0e 1094
mbed_official 354:e67efb2aab0e 1095 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1096
mbed_official 354:e67efb2aab0e 1097 #if defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1098
mbed_official 354:e67efb2aab0e 1099 /* Pages for Cat5 devices*/
mbed_official 354:e67efb2aab0e 1100 /* WRP for sector between 96 to 127 */
mbed_official 354:e67efb2aab0e 1101 if (pOBInit->WRPSector96To127 != 0)
mbed_official 354:e67efb2aab0e 1102 {
mbed_official 354:e67efb2aab0e 1103 FLASH_OB_WRPConfigWRP4(pOBInit->WRPSector96To127, NewState);
mbed_official 354:e67efb2aab0e 1104 }
mbed_official 354:e67efb2aab0e 1105
mbed_official 354:e67efb2aab0e 1106 #endif /* STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1107
mbed_official 354:e67efb2aab0e 1108 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1109 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1110 }
mbed_official 354:e67efb2aab0e 1111
mbed_official 354:e67efb2aab0e 1112 /* Return the write protection operation Status */
mbed_official 354:e67efb2aab0e 1113 return status;
mbed_official 354:e67efb2aab0e 1114 }
mbed_official 354:e67efb2aab0e 1115
mbed_official 354:e67efb2aab0e 1116 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 1117 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 1118 /**
mbed_official 354:e67efb2aab0e 1119 * @brief Enables the read/write protection (PCROP) of the desired
mbed_official 354:e67efb2aab0e 1120 * sectors.
mbed_official 354:e67efb2aab0e 1121 * @note This function can be used only for Cat2 & Cat3 devices
mbed_official 354:e67efb2aab0e 1122 * @param pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
mbed_official 354:e67efb2aab0e 1123 * contains PCROP parameters.
mbed_official 354:e67efb2aab0e 1124 * @param NewState: new state of the specified FLASH Pages read/Write protection.
mbed_official 354:e67efb2aab0e 1125 * This parameter can be: ENABLE or DISABLE.
mbed_official 354:e67efb2aab0e 1126 * @retval HAL status
mbed_official 354:e67efb2aab0e 1127 */
mbed_official 354:e67efb2aab0e 1128 static HAL_StatusTypeDef FLASH_OB_PCROPConfig(FLASH_AdvOBProgramInitTypeDef *pAdvOBInit, FunctionalState NewState)
mbed_official 354:e67efb2aab0e 1129 {
mbed_official 354:e67efb2aab0e 1130 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1131 FunctionalState pcropstate = DISABLE;
mbed_official 354:e67efb2aab0e 1132
mbed_official 354:e67efb2aab0e 1133 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1134 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1135
mbed_official 354:e67efb2aab0e 1136 /* Invert state to use same function of WRP */
mbed_official 354:e67efb2aab0e 1137 if (NewState == DISABLE)
mbed_official 354:e67efb2aab0e 1138 {
mbed_official 354:e67efb2aab0e 1139 pcropstate = ENABLE;
mbed_official 354:e67efb2aab0e 1140 }
mbed_official 354:e67efb2aab0e 1141
mbed_official 354:e67efb2aab0e 1142 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1143 {
mbed_official 354:e67efb2aab0e 1144 /* Pages for Cat2 devices*/
mbed_official 354:e67efb2aab0e 1145 /* PCROP for sector between 0 to 31 */
mbed_official 354:e67efb2aab0e 1146 if (pAdvOBInit->PCROPSector0To31 != 0)
mbed_official 354:e67efb2aab0e 1147 {
mbed_official 354:e67efb2aab0e 1148 FLASH_OB_WRPConfigWRP1OrPCROP1(pAdvOBInit->PCROPSector0To31, pcropstate);
mbed_official 354:e67efb2aab0e 1149 }
mbed_official 354:e67efb2aab0e 1150
mbed_official 354:e67efb2aab0e 1151 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 1152
mbed_official 354:e67efb2aab0e 1153 /* Pages for Cat3 devices*/
mbed_official 354:e67efb2aab0e 1154 /* WRP for sector between 32 to 63 */
mbed_official 354:e67efb2aab0e 1155 if (pAdvOBInit->PCROPSector32To63 != 0)
mbed_official 354:e67efb2aab0e 1156 {
mbed_official 354:e67efb2aab0e 1157 FLASH_OB_WRPConfigWRP2OrPCROP2(pAdvOBInit->PCROPSector32To63, pcropstate);
mbed_official 354:e67efb2aab0e 1158 }
mbed_official 354:e67efb2aab0e 1159
mbed_official 354:e67efb2aab0e 1160 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 1161
mbed_official 354:e67efb2aab0e 1162 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1163 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1164 }
mbed_official 354:e67efb2aab0e 1165
mbed_official 354:e67efb2aab0e 1166 /* Return the write protection operation Status */
mbed_official 354:e67efb2aab0e 1167 return status;
mbed_official 354:e67efb2aab0e 1168 }
mbed_official 354:e67efb2aab0e 1169 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 1170
mbed_official 354:e67efb2aab0e 1171 /**
mbed_official 354:e67efb2aab0e 1172 * @brief Write protects the desired pages of the first 128KB of the Flash.
mbed_official 354:e67efb2aab0e 1173 * @param WRP1OrPCROP1: specifies the address of the pages to be write protected.
mbed_official 354:e67efb2aab0e 1174 * This parameter can be:
mbed_official 354:e67efb2aab0e 1175 * @arg value between OB_WRP1/PCROP1_PAGES0TO15 and OB_WRP1/PCROP1_PAGES496TO511
mbed_official 354:e67efb2aab0e 1176 * @arg OB_WRP1/PCROP1_ALLPAGES
mbed_official 354:e67efb2aab0e 1177 * @param NewState: new state of the specified FLASH Pages Wtite protection.
mbed_official 354:e67efb2aab0e 1178 * This parameter can be: ENABLE or DISABLE.
mbed_official 354:e67efb2aab0e 1179 * @retval None
mbed_official 354:e67efb2aab0e 1180 */
mbed_official 354:e67efb2aab0e 1181 static void FLASH_OB_WRPConfigWRP1OrPCROP1(uint32_t WRP1OrPCROP1, FunctionalState NewState)
mbed_official 354:e67efb2aab0e 1182 {
mbed_official 354:e67efb2aab0e 1183 uint32_t wrp01data = 0, wrp23data = 0;
mbed_official 354:e67efb2aab0e 1184
mbed_official 354:e67efb2aab0e 1185 uint32_t tmp1 = 0, tmp2 = 0;
mbed_official 354:e67efb2aab0e 1186
mbed_official 354:e67efb2aab0e 1187 if (NewState != DISABLE)
mbed_official 354:e67efb2aab0e 1188 {
mbed_official 354:e67efb2aab0e 1189 wrp01data = (uint16_t)(((WRP1OrPCROP1 & WRP_MASK_LOW) | OB->WRP01));
mbed_official 354:e67efb2aab0e 1190 wrp23data = (uint16_t)((((WRP1OrPCROP1 & WRP_MASK_HIGH)>>16 | OB->WRP23)));
mbed_official 354:e67efb2aab0e 1191 tmp1 = (uint32_t)(~(wrp01data) << 16)|(wrp01data);
mbed_official 354:e67efb2aab0e 1192 OB->WRP01 = tmp1;
mbed_official 354:e67efb2aab0e 1193
mbed_official 354:e67efb2aab0e 1194 tmp2 = (uint32_t)(~(wrp23data) << 16)|(wrp23data);
mbed_official 354:e67efb2aab0e 1195 OB->WRP23 = tmp2;
mbed_official 354:e67efb2aab0e 1196 }
mbed_official 354:e67efb2aab0e 1197 else
mbed_official 354:e67efb2aab0e 1198 {
mbed_official 354:e67efb2aab0e 1199 wrp01data = (uint16_t)(~WRP1OrPCROP1 & (WRP_MASK_LOW & OB->WRP01));
mbed_official 354:e67efb2aab0e 1200 wrp23data = (uint16_t)((((~WRP1OrPCROP1 & WRP_MASK_HIGH)>>16 & OB->WRP23)));
mbed_official 354:e67efb2aab0e 1201
mbed_official 354:e67efb2aab0e 1202 tmp1 = (uint32_t)((~wrp01data) << 16)|(wrp01data);
mbed_official 354:e67efb2aab0e 1203 OB->WRP01 = tmp1;
mbed_official 354:e67efb2aab0e 1204
mbed_official 354:e67efb2aab0e 1205 tmp2 = (uint32_t)((~wrp23data) << 16)|(wrp23data);
mbed_official 354:e67efb2aab0e 1206 OB->WRP23 = tmp2;
mbed_official 354:e67efb2aab0e 1207 }
mbed_official 354:e67efb2aab0e 1208 }
mbed_official 354:e67efb2aab0e 1209
mbed_official 354:e67efb2aab0e 1210 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 1211 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1212 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1213 /**
mbed_official 354:e67efb2aab0e 1214 * @brief Enable Write protects the desired pages of the second 128KB of the Flash.
mbed_official 354:e67efb2aab0e 1215 * @note This function can be used only for Cat3, Cat4 & Cat5 devices.
mbed_official 354:e67efb2aab0e 1216 * @param WRP2OrPCROP2: specifies the address of the pages to be write protected.
mbed_official 354:e67efb2aab0e 1217 * This parameter can be:
mbed_official 354:e67efb2aab0e 1218 * @arg value between OB_WRP2/PCROP2_PAGES512TO527 and OB_WRP2/PCROP2_PAGES1008TO1023
mbed_official 354:e67efb2aab0e 1219 * @arg OB_WRP2/PCROP2_ALLPAGES
mbed_official 354:e67efb2aab0e 1220 * @param NewState: new state of the specified FLASH Pages Wtite protection.
mbed_official 354:e67efb2aab0e 1221 * This parameter can be: ENABLE or DISABLE.
mbed_official 354:e67efb2aab0e 1222 * @retval None
mbed_official 354:e67efb2aab0e 1223 */
mbed_official 354:e67efb2aab0e 1224 static void FLASH_OB_WRPConfigWRP2OrPCROP2(uint32_t WRP2OrPCROP2, FunctionalState NewState)
mbed_official 354:e67efb2aab0e 1225 {
mbed_official 354:e67efb2aab0e 1226 uint32_t wrp45data = 0, wrp67data = 0;
mbed_official 354:e67efb2aab0e 1227
mbed_official 354:e67efb2aab0e 1228 uint32_t tmp1 = 0, tmp2 = 0;
mbed_official 354:e67efb2aab0e 1229
mbed_official 354:e67efb2aab0e 1230 if (NewState != DISABLE)
mbed_official 354:e67efb2aab0e 1231 {
mbed_official 354:e67efb2aab0e 1232 wrp45data = (uint16_t)(((WRP2OrPCROP2 & WRP_MASK_LOW) | OB->WRP45));
mbed_official 354:e67efb2aab0e 1233 wrp67data = (uint16_t)((((WRP2OrPCROP2 & WRP_MASK_HIGH)>>16 | OB->WRP67)));
mbed_official 354:e67efb2aab0e 1234 tmp1 = (uint32_t)(~(wrp45data) << 16)|(wrp45data);
mbed_official 354:e67efb2aab0e 1235 OB->WRP45 = tmp1;
mbed_official 354:e67efb2aab0e 1236
mbed_official 354:e67efb2aab0e 1237 tmp2 = (uint32_t)(~(wrp67data) << 16)|(wrp67data);
mbed_official 354:e67efb2aab0e 1238 OB->WRP67 = tmp2;
mbed_official 354:e67efb2aab0e 1239 }
mbed_official 354:e67efb2aab0e 1240 else
mbed_official 354:e67efb2aab0e 1241 {
mbed_official 354:e67efb2aab0e 1242 wrp45data = (uint16_t)(~WRP2OrPCROP2 & (WRP_MASK_LOW & OB->WRP45));
mbed_official 354:e67efb2aab0e 1243 wrp67data = (uint16_t)((((~WRP2OrPCROP2 & WRP_MASK_HIGH)>>16 & OB->WRP67)));
mbed_official 354:e67efb2aab0e 1244
mbed_official 354:e67efb2aab0e 1245 tmp1 = (uint32_t)((~wrp45data) << 16)|(wrp45data);
mbed_official 354:e67efb2aab0e 1246 OB->WRP45 = tmp1;
mbed_official 354:e67efb2aab0e 1247
mbed_official 354:e67efb2aab0e 1248 tmp2 = (uint32_t)((~wrp67data) << 16)|(wrp67data);
mbed_official 354:e67efb2aab0e 1249 OB->WRP67 = tmp2;
mbed_official 354:e67efb2aab0e 1250 }
mbed_official 354:e67efb2aab0e 1251 }
mbed_official 354:e67efb2aab0e 1252 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1253
mbed_official 354:e67efb2aab0e 1254 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1255 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1256 /**
mbed_official 354:e67efb2aab0e 1257 * @brief Enable Write protects the desired pages of the third 128KB of the Flash.
mbed_official 354:e67efb2aab0e 1258 * @note This function can be used only for STM32L151xD, STM32L152xD, STM32L162xD & Cat5 devices.
mbed_official 354:e67efb2aab0e 1259 * @param WRP3: specifies the address of the pages to be write protected.
mbed_official 354:e67efb2aab0e 1260 * This parameter can be:
mbed_official 354:e67efb2aab0e 1261 * @arg value between WRP3_PAGES1024TO1039 and OB_WRP3_PAGES1520TO1535
mbed_official 354:e67efb2aab0e 1262 * @arg OB_WRP3_ALLPAGES
mbed_official 354:e67efb2aab0e 1263 * @param NewState: new state of the specified FLASH Pages Wtite protection.
mbed_official 354:e67efb2aab0e 1264 * This parameter can be: ENABLE or DISABLE.
mbed_official 354:e67efb2aab0e 1265 * @retval None
mbed_official 354:e67efb2aab0e 1266 */
mbed_official 354:e67efb2aab0e 1267 static void FLASH_OB_WRPConfigWRP3(uint32_t WRP3, FunctionalState NewState)
mbed_official 354:e67efb2aab0e 1268 {
mbed_official 354:e67efb2aab0e 1269 uint32_t wrp89data = 0, wrp1011data = 0;
mbed_official 354:e67efb2aab0e 1270
mbed_official 354:e67efb2aab0e 1271 uint32_t tmp1 = 0, tmp2 = 0;
mbed_official 354:e67efb2aab0e 1272
mbed_official 354:e67efb2aab0e 1273 if (NewState != DISABLE)
mbed_official 354:e67efb2aab0e 1274 {
mbed_official 354:e67efb2aab0e 1275 wrp89data = (uint16_t)(((WRP3 & WRP_MASK_LOW) | OB->WRP89));
mbed_official 354:e67efb2aab0e 1276 wrp1011data = (uint16_t)((((WRP3 & WRP_MASK_HIGH)>>16 | OB->WRP1011)));
mbed_official 354:e67efb2aab0e 1277 tmp1 = (uint32_t)(~(wrp89data) << 16)|(wrp89data);
mbed_official 354:e67efb2aab0e 1278 OB->WRP89 = tmp1;
mbed_official 354:e67efb2aab0e 1279
mbed_official 354:e67efb2aab0e 1280 tmp2 = (uint32_t)(~(wrp1011data) << 16)|(wrp1011data);
mbed_official 354:e67efb2aab0e 1281 OB->WRP1011 = tmp2;
mbed_official 354:e67efb2aab0e 1282 }
mbed_official 354:e67efb2aab0e 1283 else
mbed_official 354:e67efb2aab0e 1284 {
mbed_official 354:e67efb2aab0e 1285 wrp89data = (uint16_t)(~WRP3 & (WRP_MASK_LOW & OB->WRP89));
mbed_official 354:e67efb2aab0e 1286 wrp1011data = (uint16_t)((((~WRP3 & WRP_MASK_HIGH)>>16 & OB->WRP1011)));
mbed_official 354:e67efb2aab0e 1287
mbed_official 354:e67efb2aab0e 1288 tmp1 = (uint32_t)((~wrp89data) << 16)|(wrp89data);
mbed_official 354:e67efb2aab0e 1289 OB->WRP89 = tmp1;
mbed_official 354:e67efb2aab0e 1290
mbed_official 354:e67efb2aab0e 1291 tmp2 = (uint32_t)((~wrp1011data) << 16)|(wrp1011data);
mbed_official 354:e67efb2aab0e 1292 OB->WRP1011 = tmp2;
mbed_official 354:e67efb2aab0e 1293 }
mbed_official 354:e67efb2aab0e 1294 }
mbed_official 354:e67efb2aab0e 1295 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1296
mbed_official 354:e67efb2aab0e 1297 #if defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1298 /**
mbed_official 354:e67efb2aab0e 1299 * @brief Enable Write protects the desired pages of the Fourth 128KB of the Flash.
mbed_official 354:e67efb2aab0e 1300 * @note This function can be used only for Cat5 devices.
mbed_official 354:e67efb2aab0e 1301 * @param WRP4: specifies the address of the pages to be write protected.
mbed_official 354:e67efb2aab0e 1302 * This parameter can be:
mbed_official 354:e67efb2aab0e 1303 * @arg value between OB_WRP4_PAGES1536TO1551 and OB_WRP4_PAGES2032TO2047
mbed_official 354:e67efb2aab0e 1304 * @arg OB_WRP4_ALLPAGES
mbed_official 354:e67efb2aab0e 1305 * @param NewState: new state of the specified FLASH Pages Wtite protection.
mbed_official 354:e67efb2aab0e 1306 * This parameter can be: ENABLE or DISABLE.
mbed_official 354:e67efb2aab0e 1307 * @retval None
mbed_official 354:e67efb2aab0e 1308 */
mbed_official 354:e67efb2aab0e 1309 static void FLASH_OB_WRPConfigWRP4(uint32_t WRP4, FunctionalState NewState)
mbed_official 354:e67efb2aab0e 1310 {
mbed_official 354:e67efb2aab0e 1311 uint32_t wrp1213data = 0, wrp1415data = 0;
mbed_official 354:e67efb2aab0e 1312
mbed_official 354:e67efb2aab0e 1313 uint32_t tmp1 = 0, tmp2 = 0;
mbed_official 354:e67efb2aab0e 1314
mbed_official 354:e67efb2aab0e 1315 if (NewState != DISABLE)
mbed_official 354:e67efb2aab0e 1316 {
mbed_official 354:e67efb2aab0e 1317 wrp1213data = (uint16_t)(((WRP4 & WRP_MASK_LOW) | OB->WRP1213));
mbed_official 354:e67efb2aab0e 1318 wrp1415data = (uint16_t)((((WRP4 & WRP_MASK_HIGH)>>16 | OB->WRP1415)));
mbed_official 354:e67efb2aab0e 1319 tmp1 = (uint32_t)(~(wrp1213data) << 16)|(wrp1213data);
mbed_official 354:e67efb2aab0e 1320 OB->WRP1213 = tmp1;
mbed_official 354:e67efb2aab0e 1321
mbed_official 354:e67efb2aab0e 1322 tmp2 = (uint32_t)(~(wrp1415data) << 16)|(wrp1415data);
mbed_official 354:e67efb2aab0e 1323 OB->WRP1415 = tmp2;
mbed_official 354:e67efb2aab0e 1324 }
mbed_official 354:e67efb2aab0e 1325 else
mbed_official 354:e67efb2aab0e 1326 {
mbed_official 354:e67efb2aab0e 1327 wrp1213data = (uint16_t)(~WRP4 & (WRP_MASK_LOW & OB->WRP1213));
mbed_official 354:e67efb2aab0e 1328 wrp1415data = (uint16_t)((((~WRP4 & WRP_MASK_HIGH)>>16 & OB->WRP1415)));
mbed_official 354:e67efb2aab0e 1329
mbed_official 354:e67efb2aab0e 1330 tmp1 = (uint32_t)((~wrp1213data) << 16)|(wrp1213data);
mbed_official 354:e67efb2aab0e 1331 OB->WRP1213 = tmp1;
mbed_official 354:e67efb2aab0e 1332
mbed_official 354:e67efb2aab0e 1333 tmp2 = (uint32_t)((~wrp1415data) << 16)|(wrp1415data);
mbed_official 354:e67efb2aab0e 1334 OB->WRP1415 = tmp2;
mbed_official 354:e67efb2aab0e 1335 }
mbed_official 354:e67efb2aab0e 1336 }
mbed_official 354:e67efb2aab0e 1337 #endif /* STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1338
mbed_official 354:e67efb2aab0e 1339 /**
mbed_official 354:e67efb2aab0e 1340 * @brief Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY.
mbed_official 354:e67efb2aab0e 1341 * @param OB_IWDG: Selects the WDG mode.
mbed_official 354:e67efb2aab0e 1342 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 1343 * @arg OB_IWDG_SW: Software WDG selected
mbed_official 354:e67efb2aab0e 1344 * @arg OB_IWDG_HW: Hardware WDG selected
mbed_official 354:e67efb2aab0e 1345 * @param OB_STOP: Reset event when entering STOP mode.
mbed_official 354:e67efb2aab0e 1346 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 1347 * @arg OB_STOP_NORST: No reset generated when entering in STOP
mbed_official 354:e67efb2aab0e 1348 * @arg OB_STOP_RST: Reset generated when entering in STOP
mbed_official 354:e67efb2aab0e 1349 * @param OB_STDBY: Reset event when entering Standby mode.
mbed_official 354:e67efb2aab0e 1350 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 1351 * @arg OB_STDBY_NORST: No reset generated when entering in STANDBY
mbed_official 354:e67efb2aab0e 1352 * @arg OB_STDBY_RST: Reset generated when entering in STANDBY
mbed_official 354:e67efb2aab0e 1353 * @retval HAL status
mbed_official 354:e67efb2aab0e 1354 */
mbed_official 354:e67efb2aab0e 1355 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)
mbed_official 354:e67efb2aab0e 1356 {
mbed_official 354:e67efb2aab0e 1357 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1358 uint32_t tmp = 0, tmp1 = 0;
mbed_official 354:e67efb2aab0e 1359
mbed_official 354:e67efb2aab0e 1360 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1361 assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));
mbed_official 354:e67efb2aab0e 1362 assert_param(IS_OB_STOP_SOURCE(OB_STOP));
mbed_official 354:e67efb2aab0e 1363 assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));
mbed_official 354:e67efb2aab0e 1364
mbed_official 354:e67efb2aab0e 1365 /* Get the User Option byte register */
mbed_official 354:e67efb2aab0e 1366 tmp1 = (FLASH->OBR & FLASH_OBR_BOR_LEV) >> 16;
mbed_official 354:e67efb2aab0e 1367
mbed_official 354:e67efb2aab0e 1368 /* Calculate the user option byte to write */
mbed_official 354:e67efb2aab0e 1369 tmp = (uint32_t)(((uint32_t)~((uint32_t)((uint32_t)(OB_IWDG) | (uint32_t)(OB_STOP) | (uint32_t)(OB_STDBY) | tmp1))) << 16);
mbed_official 354:e67efb2aab0e 1370 tmp |= ((uint32_t)(OB_IWDG) | ((uint32_t)OB_STOP) | (uint32_t)(OB_STDBY) | tmp1);
mbed_official 354:e67efb2aab0e 1371
mbed_official 354:e67efb2aab0e 1372 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1373 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1374
mbed_official 354:e67efb2aab0e 1375 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1376 {
mbed_official 354:e67efb2aab0e 1377 /* Write the User Option Byte */
mbed_official 354:e67efb2aab0e 1378 OB->USER = tmp;
mbed_official 354:e67efb2aab0e 1379 }
mbed_official 354:e67efb2aab0e 1380
mbed_official 354:e67efb2aab0e 1381 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1382 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1383
mbed_official 354:e67efb2aab0e 1384 /* Return the Option Byte program Status */
mbed_official 354:e67efb2aab0e 1385 return status;
mbed_official 354:e67efb2aab0e 1386 }
mbed_official 354:e67efb2aab0e 1387
mbed_official 354:e67efb2aab0e 1388 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1389 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1390 /**
mbed_official 354:e67efb2aab0e 1391 * @brief Configures to boot from Bank1 or Bank2.
mbed_official 354:e67efb2aab0e 1392 * @param OB_BOOT: select the FLASH Bank to boot from.
mbed_official 354:e67efb2aab0e 1393 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 1394 * @arg OB_BOOT_BANK2: At startup, if boot pins are set in boot from user Flash
mbed_official 354:e67efb2aab0e 1395 * position and this parameter is selected the device will boot from Bank2 or Bank1,
mbed_official 354:e67efb2aab0e 1396 * depending on the activation of the bank. The active banks are checked in
mbed_official 354:e67efb2aab0e 1397 * the following order: Bank2, followed by Bank1.
mbed_official 354:e67efb2aab0e 1398 * The active bank is recognized by the value programmed at the base address
mbed_official 354:e67efb2aab0e 1399 * of the respective bank (corresponding to the initial stack pointer value
mbed_official 354:e67efb2aab0e 1400 * in the interrupt vector table).
mbed_official 354:e67efb2aab0e 1401 * @arg OB_BOOT_BANK1: At startup, if boot pins are set in boot from user Flash
mbed_official 354:e67efb2aab0e 1402 * position and this parameter is selected the device will boot from Bank1(Default).
mbed_official 354:e67efb2aab0e 1403 * For more information, please refer to AN2606 from www.st.com.
mbed_official 354:e67efb2aab0e 1404 * @retval HAL status
mbed_official 354:e67efb2aab0e 1405 */
mbed_official 354:e67efb2aab0e 1406 static HAL_StatusTypeDef FLASH_OB_BootConfig(uint8_t OB_BOOT)
mbed_official 354:e67efb2aab0e 1407 {
mbed_official 354:e67efb2aab0e 1408 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1409 uint32_t tmp = 0, tmp1 = 0;
mbed_official 354:e67efb2aab0e 1410
mbed_official 354:e67efb2aab0e 1411 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1412 assert_param(IS_OB_BOOT_BANK(OB_BOOT));
mbed_official 354:e67efb2aab0e 1413
mbed_official 354:e67efb2aab0e 1414 /* Get the User Option byte register and BOR Level*/
mbed_official 354:e67efb2aab0e 1415 tmp1 = (FLASH->OBR & (FLASH_OBR_nRST_STDBY | FLASH_OBR_nRST_STOP | FLASH_OBR_IWDG_SW | FLASH_OBR_BOR_LEV)) >> 16;
mbed_official 354:e67efb2aab0e 1416
mbed_official 354:e67efb2aab0e 1417 /* Calculate the option byte to write */
mbed_official 354:e67efb2aab0e 1418 tmp = (uint32_t)~(OB_BOOT | tmp1) << 16;
mbed_official 354:e67efb2aab0e 1419 tmp |= (OB_BOOT | tmp1);
mbed_official 354:e67efb2aab0e 1420
mbed_official 354:e67efb2aab0e 1421 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1422 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1423
mbed_official 354:e67efb2aab0e 1424 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1425 {
mbed_official 354:e67efb2aab0e 1426 /* Write the BOOT Option Byte */
mbed_official 354:e67efb2aab0e 1427 OB->USER = tmp;
mbed_official 354:e67efb2aab0e 1428 }
mbed_official 354:e67efb2aab0e 1429
mbed_official 354:e67efb2aab0e 1430 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1431 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1432
mbed_official 354:e67efb2aab0e 1433 /* Return the Option Byte program Status */
mbed_official 354:e67efb2aab0e 1434 return status;
mbed_official 354:e67efb2aab0e 1435 }
mbed_official 354:e67efb2aab0e 1436
mbed_official 354:e67efb2aab0e 1437 #endif /* STM32L151xD || STM32L152xD || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1438
mbed_official 354:e67efb2aab0e 1439 /*
mbed_official 354:e67efb2aab0e 1440 ==============================================================================
mbed_official 354:e67efb2aab0e 1441 DATA
mbed_official 354:e67efb2aab0e 1442 ==============================================================================
mbed_official 354:e67efb2aab0e 1443 */
mbed_official 354:e67efb2aab0e 1444
mbed_official 354:e67efb2aab0e 1445 /**
mbed_official 354:e67efb2aab0e 1446 * @brief Write a Byte at a specified address in data memory.
mbed_official 354:e67efb2aab0e 1447 * @param Address: specifies the address to be written.
mbed_official 354:e67efb2aab0e 1448 * @param Data: specifies the data to be written.
mbed_official 354:e67efb2aab0e 1449 * @note This function assumes that the is data word is already erased.
mbed_official 354:e67efb2aab0e 1450 * @retval HAL status
mbed_official 354:e67efb2aab0e 1451 */
mbed_official 354:e67efb2aab0e 1452 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramByte(uint32_t Address, uint8_t Data)
mbed_official 354:e67efb2aab0e 1453 {
mbed_official 354:e67efb2aab0e 1454 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1455 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1456 uint32_t tmp = 0, tmpaddr = 0;
mbed_official 354:e67efb2aab0e 1457 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1458
mbed_official 354:e67efb2aab0e 1459 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1460 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 1461
mbed_official 354:e67efb2aab0e 1462 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1463 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1464
mbed_official 354:e67efb2aab0e 1465 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1466 {
mbed_official 354:e67efb2aab0e 1467 /* Clear the FTDW bit */
mbed_official 354:e67efb2aab0e 1468 CLEAR_BIT(FLASH->PECR, FLASH_PECR_FTDW);
mbed_official 354:e67efb2aab0e 1469
mbed_official 354:e67efb2aab0e 1470 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1471 /* Possible only on Cat1 devices */
mbed_official 354:e67efb2aab0e 1472 if(Data != (uint8_t)0x00)
mbed_official 354:e67efb2aab0e 1473 {
mbed_official 354:e67efb2aab0e 1474 /* If the previous operation is completed, proceed to write the new Data */
mbed_official 354:e67efb2aab0e 1475 *(__IO uint8_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1476
mbed_official 354:e67efb2aab0e 1477 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1478 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1479 }
mbed_official 354:e67efb2aab0e 1480 else
mbed_official 354:e67efb2aab0e 1481 {
mbed_official 354:e67efb2aab0e 1482 tmpaddr = Address & 0xFFFFFFFC;
mbed_official 354:e67efb2aab0e 1483 tmp = * (__IO uint32_t *) tmpaddr;
mbed_official 354:e67efb2aab0e 1484 tmpaddr = 0xFF << ((uint32_t) (0x8 * (Address & 0x3)));
mbed_official 354:e67efb2aab0e 1485 tmp &= ~tmpaddr;
mbed_official 354:e67efb2aab0e 1486 status = HAL_FLASHEx_DATAEEPROM_Erase(TYPEERASEDATA_WORD, Address & 0xFFFFFFFC);
mbed_official 354:e67efb2aab0e 1487 status = HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTWORD, (Address & 0xFFFFFFFC), tmp);
mbed_official 354:e67efb2aab0e 1488 }
mbed_official 354:e67efb2aab0e 1489 #else /*!Cat1*/
mbed_official 354:e67efb2aab0e 1490 /* If the previous operation is completed, proceed to write the new Data */
mbed_official 354:e67efb2aab0e 1491 *(__IO uint8_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1492
mbed_official 354:e67efb2aab0e 1493 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1494 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1495 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1496 }
mbed_official 354:e67efb2aab0e 1497 /* Return the Write Status */
mbed_official 354:e67efb2aab0e 1498 return status;
mbed_official 354:e67efb2aab0e 1499 }
mbed_official 354:e67efb2aab0e 1500
mbed_official 354:e67efb2aab0e 1501 /**
mbed_official 354:e67efb2aab0e 1502 * @brief Writes a half word at a specified address in data memory.
mbed_official 354:e67efb2aab0e 1503 * @param Address: specifies the address to be written.
mbed_official 354:e67efb2aab0e 1504 * @param Data: specifies the data to be written.
mbed_official 354:e67efb2aab0e 1505 * @note This function assumes that the is data word is already erased.
mbed_official 354:e67efb2aab0e 1506 * @retval HAL status
mbed_official 354:e67efb2aab0e 1507 */
mbed_official 354:e67efb2aab0e 1508 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramHalfWord(uint32_t Address, uint16_t Data)
mbed_official 354:e67efb2aab0e 1509 {
mbed_official 354:e67efb2aab0e 1510 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1511 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1512 uint32_t tmp = 0, tmpaddr = 0;
mbed_official 354:e67efb2aab0e 1513 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1514
mbed_official 354:e67efb2aab0e 1515 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1516 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 1517
mbed_official 354:e67efb2aab0e 1518 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1519 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1520
mbed_official 354:e67efb2aab0e 1521 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1522 {
mbed_official 354:e67efb2aab0e 1523 /* Clear the FTDW bit */
mbed_official 354:e67efb2aab0e 1524 CLEAR_BIT(FLASH->PECR, FLASH_PECR_FTDW);
mbed_official 354:e67efb2aab0e 1525
mbed_official 354:e67efb2aab0e 1526 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1527 /* Possible only on Cat1 devices */
mbed_official 354:e67efb2aab0e 1528 if(Data != (uint16_t)0x0000)
mbed_official 354:e67efb2aab0e 1529 {
mbed_official 354:e67efb2aab0e 1530 /* If the previous operation is completed, proceed to write the new data */
mbed_official 354:e67efb2aab0e 1531 *(__IO uint16_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1532
mbed_official 354:e67efb2aab0e 1533 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1534 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1535 }
mbed_official 354:e67efb2aab0e 1536 else
mbed_official 354:e67efb2aab0e 1537 {
mbed_official 354:e67efb2aab0e 1538 if((Address & 0x3) != 0x3)
mbed_official 354:e67efb2aab0e 1539 {
mbed_official 354:e67efb2aab0e 1540 tmpaddr = Address & 0xFFFFFFFC;
mbed_official 354:e67efb2aab0e 1541 tmp = * (__IO uint32_t *) tmpaddr;
mbed_official 354:e67efb2aab0e 1542 tmpaddr = 0xFFFF << ((uint32_t) (0x8 * (Address & 0x3)));
mbed_official 354:e67efb2aab0e 1543 tmp &= ~tmpaddr;
mbed_official 354:e67efb2aab0e 1544 status = HAL_FLASHEx_DATAEEPROM_Erase(TYPEERASEDATA_WORD, Address & 0xFFFFFFFC);
mbed_official 354:e67efb2aab0e 1545 status = HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTWORD, (Address & 0xFFFFFFFC), tmp);
mbed_official 354:e67efb2aab0e 1546 }
mbed_official 354:e67efb2aab0e 1547 else
mbed_official 354:e67efb2aab0e 1548 {
mbed_official 354:e67efb2aab0e 1549 HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTBYTE, Address, 0x00);
mbed_official 354:e67efb2aab0e 1550 HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTBYTE, Address + 1, 0x00);
mbed_official 354:e67efb2aab0e 1551 }
mbed_official 354:e67efb2aab0e 1552 }
mbed_official 354:e67efb2aab0e 1553 #else /* !Cat1 */
mbed_official 354:e67efb2aab0e 1554 /* If the previous operation is completed, proceed to write the new data */
mbed_official 354:e67efb2aab0e 1555 *(__IO uint16_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1556
mbed_official 354:e67efb2aab0e 1557 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1558 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1559 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1560 }
mbed_official 354:e67efb2aab0e 1561 /* Return the Write Status */
mbed_official 354:e67efb2aab0e 1562 return status;
mbed_official 354:e67efb2aab0e 1563 }
mbed_official 354:e67efb2aab0e 1564
mbed_official 354:e67efb2aab0e 1565 /**
mbed_official 354:e67efb2aab0e 1566 * @brief Programs a word at a specified address in data memory.
mbed_official 354:e67efb2aab0e 1567 * @param Address: specifies the address to be written.
mbed_official 354:e67efb2aab0e 1568 * @param Data: specifies the data to be written.
mbed_official 354:e67efb2aab0e 1569 * @note This function assumes that the is data word is already erased.
mbed_official 354:e67efb2aab0e 1570 * @retval HAL status
mbed_official 354:e67efb2aab0e 1571 */
mbed_official 354:e67efb2aab0e 1572 static HAL_StatusTypeDef FLASH_DATAEEPROM_FastProgramWord(uint32_t Address, uint32_t Data)
mbed_official 354:e67efb2aab0e 1573 {
mbed_official 354:e67efb2aab0e 1574 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1575
mbed_official 354:e67efb2aab0e 1576 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1577 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 1578
mbed_official 354:e67efb2aab0e 1579 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1580 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1581
mbed_official 354:e67efb2aab0e 1582 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1583 {
mbed_official 354:e67efb2aab0e 1584 /* Clear the FTDW bit */
mbed_official 354:e67efb2aab0e 1585 CLEAR_BIT(FLASH->PECR, FLASH_PECR_FTDW);
mbed_official 354:e67efb2aab0e 1586
mbed_official 354:e67efb2aab0e 1587 /* If the previous operation is completed, proceed to program the new data */
mbed_official 354:e67efb2aab0e 1588 *(__IO uint32_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1589
mbed_official 354:e67efb2aab0e 1590 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1591 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1592 }
mbed_official 354:e67efb2aab0e 1593 /* Return the Write Status */
mbed_official 354:e67efb2aab0e 1594 return status;
mbed_official 354:e67efb2aab0e 1595 }
mbed_official 354:e67efb2aab0e 1596
mbed_official 354:e67efb2aab0e 1597 /**
mbed_official 354:e67efb2aab0e 1598 * @brief Write a Byte at a specified address in data memory without erase.
mbed_official 354:e67efb2aab0e 1599 * @param Address: specifies the address to be written.
mbed_official 354:e67efb2aab0e 1600 * @param Data: specifies the data to be written.
mbed_official 354:e67efb2aab0e 1601 * @retval HAL status
mbed_official 354:e67efb2aab0e 1602 */
mbed_official 354:e67efb2aab0e 1603 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramByte(uint32_t Address, uint8_t Data)
mbed_official 354:e67efb2aab0e 1604 {
mbed_official 354:e67efb2aab0e 1605 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1606 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1607 uint32_t tmp = 0, tmpaddr = 0;
mbed_official 354:e67efb2aab0e 1608 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1609
mbed_official 354:e67efb2aab0e 1610 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1611 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 1612
mbed_official 354:e67efb2aab0e 1613 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1614 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1615
mbed_official 354:e67efb2aab0e 1616 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1617 {
mbed_official 354:e67efb2aab0e 1618 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1619 if(Data != (uint8_t) 0x00)
mbed_official 354:e67efb2aab0e 1620 {
mbed_official 354:e67efb2aab0e 1621 *(__IO uint8_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1622
mbed_official 354:e67efb2aab0e 1623 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1624 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1625
mbed_official 354:e67efb2aab0e 1626 }
mbed_official 354:e67efb2aab0e 1627 else
mbed_official 354:e67efb2aab0e 1628 {
mbed_official 354:e67efb2aab0e 1629 tmpaddr = Address & 0xFFFFFFFC;
mbed_official 354:e67efb2aab0e 1630 tmp = * (__IO uint32_t *) tmpaddr;
mbed_official 354:e67efb2aab0e 1631 tmpaddr = 0xFF << ((uint32_t) (0x8 * (Address & 0x3)));
mbed_official 354:e67efb2aab0e 1632 tmp &= ~tmpaddr;
mbed_official 354:e67efb2aab0e 1633 status = HAL_FLASHEx_DATAEEPROM_Erase(TYPEERASEDATA_WORD, Address & 0xFFFFFFFC);
mbed_official 354:e67efb2aab0e 1634 status = HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTWORD, (Address & 0xFFFFFFFC), tmp);
mbed_official 354:e67efb2aab0e 1635 }
mbed_official 354:e67efb2aab0e 1636 #else /* Not Cat1*/
mbed_official 354:e67efb2aab0e 1637 *(__IO uint8_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1638
mbed_official 354:e67efb2aab0e 1639 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1640 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1641 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1642 }
mbed_official 354:e67efb2aab0e 1643 /* Return the Write Status */
mbed_official 354:e67efb2aab0e 1644 return status;
mbed_official 354:e67efb2aab0e 1645 }
mbed_official 354:e67efb2aab0e 1646
mbed_official 354:e67efb2aab0e 1647 /**
mbed_official 354:e67efb2aab0e 1648 * @brief Writes a half word at a specified address in data memory without erase.
mbed_official 354:e67efb2aab0e 1649 * @param Address: specifies the address to be written.
mbed_official 354:e67efb2aab0e 1650 * @param Data: specifies the data to be written.
mbed_official 354:e67efb2aab0e 1651 * @retval HAL status
mbed_official 354:e67efb2aab0e 1652 */
mbed_official 354:e67efb2aab0e 1653 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramHalfWord(uint32_t Address, uint16_t Data)
mbed_official 354:e67efb2aab0e 1654 {
mbed_official 354:e67efb2aab0e 1655 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1656 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1657 uint32_t tmp = 0, tmpaddr = 0;
mbed_official 354:e67efb2aab0e 1658 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1659
mbed_official 354:e67efb2aab0e 1660 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1661 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 1662
mbed_official 354:e67efb2aab0e 1663 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1664 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1665
mbed_official 354:e67efb2aab0e 1666 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1667 {
mbed_official 354:e67efb2aab0e 1668 #if defined(STM32L100xB) || defined (STM32L151xB) || defined (STM32L152xB)
mbed_official 354:e67efb2aab0e 1669 if(Data != (uint16_t)0x0000)
mbed_official 354:e67efb2aab0e 1670 {
mbed_official 354:e67efb2aab0e 1671 *(__IO uint16_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1672
mbed_official 354:e67efb2aab0e 1673 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1674 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1675 }
mbed_official 354:e67efb2aab0e 1676 else
mbed_official 354:e67efb2aab0e 1677 {
mbed_official 354:e67efb2aab0e 1678 if((Address & 0x3) != 0x3)
mbed_official 354:e67efb2aab0e 1679 {
mbed_official 354:e67efb2aab0e 1680 tmpaddr = Address & 0xFFFFFFFC;
mbed_official 354:e67efb2aab0e 1681 tmp = * (__IO uint32_t *) tmpaddr;
mbed_official 354:e67efb2aab0e 1682 tmpaddr = 0xFFFF << ((uint32_t) (0x8 * (Address & 0x3)));
mbed_official 354:e67efb2aab0e 1683 tmp &= ~tmpaddr;
mbed_official 354:e67efb2aab0e 1684 status = HAL_FLASHEx_DATAEEPROM_Erase(TYPEERASEDATA_WORD, Address & 0xFFFFFFFC);
mbed_official 354:e67efb2aab0e 1685 status = HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTWORD, (Address & 0xFFFFFFFC), tmp);
mbed_official 354:e67efb2aab0e 1686 }
mbed_official 354:e67efb2aab0e 1687 else
mbed_official 354:e67efb2aab0e 1688 {
mbed_official 354:e67efb2aab0e 1689 HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTBYTE, Address, 0x00);
mbed_official 354:e67efb2aab0e 1690 HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAMDATA_FASTBYTE, Address + 1, 0x00);
mbed_official 354:e67efb2aab0e 1691 }
mbed_official 354:e67efb2aab0e 1692 }
mbed_official 354:e67efb2aab0e 1693 #else /* Not Cat1*/
mbed_official 354:e67efb2aab0e 1694 *(__IO uint16_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1695
mbed_official 354:e67efb2aab0e 1696 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1697 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1698 #endif /* STM32L100xB || STM32L151xB || STM32L152xB */
mbed_official 354:e67efb2aab0e 1699 }
mbed_official 354:e67efb2aab0e 1700 /* Return the Write Status */
mbed_official 354:e67efb2aab0e 1701 return status;
mbed_official 354:e67efb2aab0e 1702 }
mbed_official 354:e67efb2aab0e 1703
mbed_official 354:e67efb2aab0e 1704 /**
mbed_official 354:e67efb2aab0e 1705 * @brief Programs a word at a specified address in data memory without erase.
mbed_official 354:e67efb2aab0e 1706 * @param Address: specifies the address to be written.
mbed_official 354:e67efb2aab0e 1707 * @param Data: specifies the data to be written.
mbed_official 354:e67efb2aab0e 1708 * @retval HAL status
mbed_official 354:e67efb2aab0e 1709 */
mbed_official 354:e67efb2aab0e 1710 static HAL_StatusTypeDef FLASH_DATAEEPROM_ProgramWord(uint32_t Address, uint32_t Data)
mbed_official 354:e67efb2aab0e 1711 {
mbed_official 354:e67efb2aab0e 1712 HAL_StatusTypeDef status = HAL_OK;
mbed_official 354:e67efb2aab0e 1713
mbed_official 354:e67efb2aab0e 1714 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1715 assert_param(IS_FLASH_DATA_ADDRESS(Address));
mbed_official 354:e67efb2aab0e 1716
mbed_official 354:e67efb2aab0e 1717 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1718 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1719
mbed_official 354:e67efb2aab0e 1720 if(status == HAL_OK)
mbed_official 354:e67efb2aab0e 1721 {
mbed_official 354:e67efb2aab0e 1722 *(__IO uint32_t *)Address = Data;
mbed_official 354:e67efb2aab0e 1723
mbed_official 354:e67efb2aab0e 1724 /* Wait for last operation to be completed */
mbed_official 354:e67efb2aab0e 1725 status = FLASH_WaitForLastOperation(HAL_FLASH_TIMEOUT_VALUE);
mbed_official 354:e67efb2aab0e 1726 }
mbed_official 354:e67efb2aab0e 1727 /* Return the Write Status */
mbed_official 354:e67efb2aab0e 1728 return status;
mbed_official 354:e67efb2aab0e 1729 }
mbed_official 354:e67efb2aab0e 1730
mbed_official 354:e67efb2aab0e 1731 /**
mbed_official 354:e67efb2aab0e 1732 * @}
mbed_official 354:e67efb2aab0e 1733 */
mbed_official 354:e67efb2aab0e 1734
mbed_official 354:e67efb2aab0e 1735 /**
mbed_official 354:e67efb2aab0e 1736 * @}
mbed_official 354:e67efb2aab0e 1737 */
mbed_official 354:e67efb2aab0e 1738
mbed_official 354:e67efb2aab0e 1739 /** @addtogroup FLASH
mbed_official 354:e67efb2aab0e 1740 * @{
mbed_official 354:e67efb2aab0e 1741 */
mbed_official 354:e67efb2aab0e 1742
mbed_official 354:e67efb2aab0e 1743 /** @addtogroup FLASH_Exported_Functions
mbed_official 354:e67efb2aab0e 1744 * @{
mbed_official 354:e67efb2aab0e 1745 */
mbed_official 354:e67efb2aab0e 1746
mbed_official 354:e67efb2aab0e 1747 /** @addtogroup FLASH_Exported_Functions_Group1
mbed_official 354:e67efb2aab0e 1748 * @brief Interrupts functions
mbed_official 354:e67efb2aab0e 1749 *
mbed_official 354:e67efb2aab0e 1750 @verbatim
mbed_official 354:e67efb2aab0e 1751 ==============================================================================
mbed_official 354:e67efb2aab0e 1752 ##### Interrupts functions #####
mbed_official 354:e67efb2aab0e 1753 ==============================================================================
mbed_official 354:e67efb2aab0e 1754
mbed_official 354:e67efb2aab0e 1755 @endverbatim
mbed_official 354:e67efb2aab0e 1756 * @{
mbed_official 354:e67efb2aab0e 1757 */
mbed_official 354:e67efb2aab0e 1758
mbed_official 354:e67efb2aab0e 1759 /**
mbed_official 354:e67efb2aab0e 1760 * @brief This function handles FLASH interrupt request.
mbed_official 354:e67efb2aab0e 1761 * @retval None
mbed_official 354:e67efb2aab0e 1762 */
mbed_official 354:e67efb2aab0e 1763 void HAL_FLASH_IRQHandler(void)
mbed_official 354:e67efb2aab0e 1764 {
mbed_official 354:e67efb2aab0e 1765 uint32_t temp;
mbed_official 354:e67efb2aab0e 1766
mbed_official 354:e67efb2aab0e 1767 /* If the program operation is completed, disable the PROG Bit */
mbed_official 354:e67efb2aab0e 1768 CLEAR_BIT(FLASH->PECR, FLASH_PECR_PROG);
mbed_official 354:e67efb2aab0e 1769
mbed_official 354:e67efb2aab0e 1770 /* If the erase operation is completed, disable the ERASE Bit */
mbed_official 354:e67efb2aab0e 1771 CLEAR_BIT(FLASH->PECR, FLASH_PECR_ERASE);
mbed_official 354:e67efb2aab0e 1772
mbed_official 354:e67efb2aab0e 1773 /* Check FLASH End of Operation flag */
mbed_official 354:e67efb2aab0e 1774 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP) != RESET)
mbed_official 354:e67efb2aab0e 1775 {
mbed_official 354:e67efb2aab0e 1776 if(ProcFlash.ProcedureOnGoing == FLASH_PROC_PAGEERASE)
mbed_official 354:e67efb2aab0e 1777 {
mbed_official 354:e67efb2aab0e 1778 /*Nb of sector to erased can be decreased*/
mbed_official 354:e67efb2aab0e 1779 ProcFlash.NbPagesToErase--;
mbed_official 354:e67efb2aab0e 1780
mbed_official 354:e67efb2aab0e 1781 /* Check if there are still sectors to erase*/
mbed_official 354:e67efb2aab0e 1782 if(ProcFlash.NbPagesToErase != 0)
mbed_official 354:e67efb2aab0e 1783 {
mbed_official 354:e67efb2aab0e 1784 temp = ProcFlash.Page;
mbed_official 354:e67efb2aab0e 1785 /*Indicate user which sector has been erased*/
mbed_official 354:e67efb2aab0e 1786 HAL_FLASH_EndOfOperationCallback(temp);
mbed_official 354:e67efb2aab0e 1787
mbed_official 354:e67efb2aab0e 1788 /* Clear pending flags (if any) */
mbed_official 354:e67efb2aab0e 1789 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_MASK);
mbed_official 354:e67efb2aab0e 1790
mbed_official 354:e67efb2aab0e 1791 /*Increment sector number*/
mbed_official 354:e67efb2aab0e 1792 temp = ProcFlash.Page + FLASH_PAGE_SIZE;
mbed_official 354:e67efb2aab0e 1793 ProcFlash.Page = ProcFlash.Page + FLASH_PAGE_SIZE;
mbed_official 354:e67efb2aab0e 1794 FLASH_ErasePage(temp);
mbed_official 354:e67efb2aab0e 1795 }
mbed_official 354:e67efb2aab0e 1796 else
mbed_official 354:e67efb2aab0e 1797 {
mbed_official 354:e67efb2aab0e 1798 /*No more sectors to Erase, user callback can be called.*/
mbed_official 354:e67efb2aab0e 1799 /*Reset Sector and stop Erase sectors procedure*/
mbed_official 354:e67efb2aab0e 1800 ProcFlash.Page = temp = 0xFFFFFFFF;
mbed_official 354:e67efb2aab0e 1801 ProcFlash.ProcedureOnGoing = FLASH_PROC_NONE;
mbed_official 354:e67efb2aab0e 1802 /* FLASH EOP interrupt user callback */
mbed_official 354:e67efb2aab0e 1803 HAL_FLASH_EndOfOperationCallback(temp);
mbed_official 354:e67efb2aab0e 1804 /* Clear FLASH End of Operation pending bit */
mbed_official 354:e67efb2aab0e 1805 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP);
mbed_official 354:e67efb2aab0e 1806 }
mbed_official 354:e67efb2aab0e 1807 }
mbed_official 354:e67efb2aab0e 1808 else
mbed_official 354:e67efb2aab0e 1809 {
mbed_official 354:e67efb2aab0e 1810 if(ProcFlash.ProcedureOnGoing == FLASH_PROC_PROGRAM)
mbed_official 354:e67efb2aab0e 1811 {
mbed_official 354:e67efb2aab0e 1812 /*Program ended. Return the selected address*/
mbed_official 354:e67efb2aab0e 1813 /* FLASH EOP interrupt user callback */
mbed_official 354:e67efb2aab0e 1814 HAL_FLASH_EndOfOperationCallback(ProcFlash.Address);
mbed_official 354:e67efb2aab0e 1815 }
mbed_official 354:e67efb2aab0e 1816 ProcFlash.ProcedureOnGoing = FLASH_PROC_NONE;
mbed_official 354:e67efb2aab0e 1817 /* Clear FLASH End of Operation pending bit */
mbed_official 354:e67efb2aab0e 1818 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP);
mbed_official 354:e67efb2aab0e 1819 }
mbed_official 354:e67efb2aab0e 1820
mbed_official 354:e67efb2aab0e 1821 }
mbed_official 354:e67efb2aab0e 1822
mbed_official 354:e67efb2aab0e 1823 /* Check FLASH operation error flags */
mbed_official 354:e67efb2aab0e 1824 if( (__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1825 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGAERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1826 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_SIZERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1827 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 1828 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 1829 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_RDERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1830 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 1831 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 1832 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1833 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1834 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERRUSR) != RESET) ||
mbed_official 354:e67efb2aab0e 1835 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1836 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERR) != RESET) )
mbed_official 354:e67efb2aab0e 1837 {
mbed_official 354:e67efb2aab0e 1838 if(ProcFlash.ProcedureOnGoing == FLASH_PROC_PAGEERASE)
mbed_official 354:e67efb2aab0e 1839 {
mbed_official 354:e67efb2aab0e 1840 /*return the faulty sector*/
mbed_official 354:e67efb2aab0e 1841 temp = ProcFlash.Page;
mbed_official 354:e67efb2aab0e 1842 ProcFlash.Page = 0xFFFFFFFF;
mbed_official 354:e67efb2aab0e 1843 }
mbed_official 354:e67efb2aab0e 1844 else
mbed_official 354:e67efb2aab0e 1845 {
mbed_official 354:e67efb2aab0e 1846 /*retrun the faulty address*/
mbed_official 354:e67efb2aab0e 1847 temp = ProcFlash.Address;
mbed_official 354:e67efb2aab0e 1848 }
mbed_official 354:e67efb2aab0e 1849
mbed_official 354:e67efb2aab0e 1850 /*Save the Error code*/
mbed_official 354:e67efb2aab0e 1851 FLASH_SetErrorCode();
mbed_official 354:e67efb2aab0e 1852
mbed_official 354:e67efb2aab0e 1853 /* FLASH error interrupt user callback */
mbed_official 354:e67efb2aab0e 1854 HAL_FLASH_OperationErrorCallback(temp);
mbed_official 354:e67efb2aab0e 1855
mbed_official 354:e67efb2aab0e 1856 /* Clear FLASH error pending bits */
mbed_official 354:e67efb2aab0e 1857 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_MASK);
mbed_official 354:e67efb2aab0e 1858
mbed_official 354:e67efb2aab0e 1859 /*Stop the procedure ongoing*/
mbed_official 354:e67efb2aab0e 1860 ProcFlash.ProcedureOnGoing = FLASH_PROC_NONE;
mbed_official 354:e67efb2aab0e 1861 }
mbed_official 354:e67efb2aab0e 1862
mbed_official 354:e67efb2aab0e 1863 if(ProcFlash.ProcedureOnGoing == FLASH_PROC_NONE)
mbed_official 354:e67efb2aab0e 1864 {
mbed_official 354:e67efb2aab0e 1865 /* Disable End of FLASH Operation interrupt */
mbed_official 354:e67efb2aab0e 1866 __HAL_FLASH_DISABLE_IT(FLASH_IT_EOP);
mbed_official 354:e67efb2aab0e 1867
mbed_official 354:e67efb2aab0e 1868 /* Disable Error source interrupt */
mbed_official 354:e67efb2aab0e 1869 __HAL_FLASH_DISABLE_IT(FLASH_IT_ERR);
mbed_official 354:e67efb2aab0e 1870
mbed_official 354:e67efb2aab0e 1871 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1872 __HAL_UNLOCK(&ProcFlash);
mbed_official 354:e67efb2aab0e 1873 }
mbed_official 354:e67efb2aab0e 1874
mbed_official 354:e67efb2aab0e 1875 }
mbed_official 354:e67efb2aab0e 1876
mbed_official 354:e67efb2aab0e 1877 /**
mbed_official 354:e67efb2aab0e 1878 * @}
mbed_official 354:e67efb2aab0e 1879 */
mbed_official 354:e67efb2aab0e 1880
mbed_official 354:e67efb2aab0e 1881 /**
mbed_official 354:e67efb2aab0e 1882 * @}
mbed_official 354:e67efb2aab0e 1883 */
mbed_official 354:e67efb2aab0e 1884
mbed_official 354:e67efb2aab0e 1885 /** @defgroup FLASH_Internal_Functions FLASH Internal function
mbed_official 354:e67efb2aab0e 1886 * @{
mbed_official 354:e67efb2aab0e 1887 */
mbed_official 354:e67efb2aab0e 1888
mbed_official 354:e67efb2aab0e 1889 /**
mbed_official 354:e67efb2aab0e 1890 * @brief Wait for a FLASH operation to complete.
mbed_official 354:e67efb2aab0e 1891 * @param Timeout: maximum flash operationtimeout
mbed_official 354:e67efb2aab0e 1892 * @retval HAL status
mbed_official 354:e67efb2aab0e 1893 */
mbed_official 354:e67efb2aab0e 1894 HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout)
mbed_official 354:e67efb2aab0e 1895 {
mbed_official 354:e67efb2aab0e 1896 /* Wait for the FLASH operation to complete by polling on BUSY flag to be reset.
mbed_official 354:e67efb2aab0e 1897 Even if the FLASH operation fails, the BUSY flag will be reset and an error
mbed_official 354:e67efb2aab0e 1898 flag will be set */
mbed_official 354:e67efb2aab0e 1899
mbed_official 354:e67efb2aab0e 1900 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1901
mbed_official 354:e67efb2aab0e 1902 while(__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY) != RESET)
mbed_official 354:e67efb2aab0e 1903 {
mbed_official 354:e67efb2aab0e 1904 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 1905 {
mbed_official 354:e67efb2aab0e 1906 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 1907 {
mbed_official 354:e67efb2aab0e 1908 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1909 }
mbed_official 354:e67efb2aab0e 1910 }
mbed_official 354:e67efb2aab0e 1911 }
mbed_official 354:e67efb2aab0e 1912
mbed_official 354:e67efb2aab0e 1913 if( (__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1914 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGAERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1915 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_SIZERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1916 #if defined (STM32L151xBA) || defined (STM32L152xBA) || \
mbed_official 354:e67efb2aab0e 1917 defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC)
mbed_official 354:e67efb2aab0e 1918 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_RDERR) != RESET) ||
mbed_official 354:e67efb2aab0e 1919 #endif /* STM32L151xBA || STM32L152xBA || STM32L151xC || STM32L152xC || STM32L162xC */
mbed_official 354:e67efb2aab0e 1920 #if defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || \
mbed_official 354:e67efb2aab0e 1921 defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || \
mbed_official 354:e67efb2aab0e 1922 defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1923 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERRUSR) != RESET) ||
mbed_official 354:e67efb2aab0e 1924 #endif /* STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1925 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERR) != RESET) )
mbed_official 354:e67efb2aab0e 1926 {
mbed_official 354:e67efb2aab0e 1927 /*Save the error code*/
mbed_official 354:e67efb2aab0e 1928 FLASH_SetErrorCode();
mbed_official 354:e67efb2aab0e 1929 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 1930 }
mbed_official 354:e67efb2aab0e 1931
mbed_official 354:e67efb2aab0e 1932 /* There is no error flag set */
mbed_official 354:e67efb2aab0e 1933 return HAL_OK;
mbed_official 354:e67efb2aab0e 1934 }
mbed_official 354:e67efb2aab0e 1935
mbed_official 354:e67efb2aab0e 1936
mbed_official 354:e67efb2aab0e 1937 /**
mbed_official 354:e67efb2aab0e 1938 * @}
mbed_official 354:e67efb2aab0e 1939 */
mbed_official 354:e67efb2aab0e 1940
mbed_official 354:e67efb2aab0e 1941 #endif /* HAL_FLASH_MODULE_ENABLED */
mbed_official 354:e67efb2aab0e 1942
mbed_official 354:e67efb2aab0e 1943 /**
mbed_official 354:e67efb2aab0e 1944 * @}
mbed_official 354:e67efb2aab0e 1945 */
mbed_official 354:e67efb2aab0e 1946
mbed_official 354:e67efb2aab0e 1947 /**
mbed_official 354:e67efb2aab0e 1948 * @}
mbed_official 354:e67efb2aab0e 1949 */
mbed_official 354:e67efb2aab0e 1950
mbed_official 354:e67efb2aab0e 1951 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 354:e67efb2aab0e 1952