tmk_core/tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_flash_ex.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32l0xx_hal_flash_ex.c
   4   * @author  MCD Application Team
   5   * @version V1.2.0
   6   * @date    06-February-2015
   7   * @brief   FLASH HAL module driver.
   8   *          This file provides firmware functions to manage the following
   9   *          functionalities of the internal FLASH memory:
  10   *            + FLASH Interface configuration
  11   *            + FLASH Memory Erasing
  12   *            + DATA EEPROM Programming/Erasing
  13   *            + Option Bytes Programming
  14   *            + Interrupts management
  15   *
  16   *  @verbatim
  17   ==============================================================================
  18                ##### Flash peripheral Extended features  #####
  19   ==============================================================================
  20
  21   [..] Comparing to other products, the FLASH interface for STM32L0xx
  22        devices contains the following additional features
  23        (+) Erase functions
  24        (+) DATA_EEPROM memory management
  25        (+) BOOT option bit configuration
  26        (+) PCROP protection for all sectors
  27
  28                       ##### How to use this driver #####
  29   ==============================================================================
  30   [..] This driver provides functions to configure and program the FLASH memory
  31        of all STM32L0xx. It includes:
  32        (+) Full DATA_EEPROM erase and program management
  33        (+) Boot activation
  34        (+) PCROP protection configuration and control for all sectors
  35
  36   @endverbatim
  37   ******************************************************************************
  38   * @attention
  39   *
  40   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
  41   *
  42   * Redistribution and use in source and binary forms, with or without modification,
  43   * are permitted provided that the following conditions are met:
  44   *   1. Redistributions of source code must retain the above copyright notice,
  45   *      this list of conditions and the following disclaimer.
  46   *   2. Redistributions in binary form must reproduce the above copyright notice,
  47   *      this list of conditions and the following disclaimer in the documentation
  48   *      and/or other materials provided with the distribution.
  49   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  50   *      may be used to endorse or promote products derived from this software
  51   *      without specific prior written permission.
  52   *
  53   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  54   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  55   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  56   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  57   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  58   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  59   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  60   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  61   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  62   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  63   *
  64   ******************************************************************************
  65   */
  66
  67 /* Includes ------------------------------------------------------------------*/
  68 #include "stm32l0xx_hal.h"
  69
  70 /** @addtogroup STM32L0xx_HAL_Driver
  71   * @{
  72   */
  73
  74 /** @addtogroup FLASHEx
  75   * @brief FLASH HAL Extension module driver
  76   * @{
  77   */
  78
  79 #ifdef HAL_FLASH_MODULE_ENABLED
  80
  81 /* Private typedef -----------------------------------------------------------*/
  82 /* Private define ------------------------------------------------------------*/
  83 /* Private macro -------------------------------------------------------------*/
  84 /* Private variables ---------------------------------------------------------*/
  85 /* Private function prototypes -----------------------------------------------*/
  86 static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP);
  87 static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR);
  88 static uint8_t           FLASH_OB_GetUser(void);
  89 static uint8_t           FLASH_OB_GetRDP(void);
  90 static uint8_t           FLASH_OB_GetBOR(void);
  91 static uint8_t           FLASH_OB_GetBOOTBit1(void);
  92 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
  93 static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t Sector2, uint32_t NewState);
  94 #else
  95 static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t NewState);
  96 #endif
  97 static HAL_StatusTypeDef  FLASH_OB_PCROPSelectionConfig(uint32_t WPRMOD);
  98 static uint32_t          FLASH_OB_GetWRP(void);
  99 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 100 static uint32_t          FLASH_OB_GetWRP2(void);
 101 #endif
 102 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY);
 103 static HAL_StatusTypeDef FLASH_OB_BOOTBit1Config(uint8_t OB_BOOT_Bit1);
 104 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 105 static HAL_StatusTypeDef FLASH_OB_BFB2Config(uint8_t OB_BFB2);
 106 #endif
 107
 108 /* Exported functions ---------------------------------------------------------*/
 109
 110 /** @addtogroup FLASHEx_Exported_Functions
 111   * @{
 112   */
 113
 114 /** @addtogroup FLASHEx_Exported_Functions_Group1
 115  *  @brief   FLASH Memory Erasing functions
 116  *
 117 @verbatim
 118   ==============================================================================
 119                 ##### FLASH Erasing Programming functions #####
 120   ==============================================================================
 121
 122     [..] The FLASH Memory Erasing functions, includes the following functions:
 123     (+) HAL_FLASHEx_Erase: return only when erase has been done
 124     (+) HAL_FLASHEx_Erase_IT: end of erase is done when HAL_FLASH_EndOfOperationCallback is called with parameter
 125         0xFFFFFFFF
 126
 127     [..] Any operation of erase should follow these steps:
 128     (#) Call the HAL_FLASH_Unlock() function to enable the flash control register and
 129         program memory access.
 130     (#) Call the desired function to erase page.
 131     (#) Call the HAL_FLASH_Lock() to disable the flash program memory access
 132        (recommended to protect the FLASH memory against possible unwanted operation).
 133
 134 @endverbatim
 135   * @{
 136   */
 137
 138 /**
 139   * @brief  Erase the specified FLASH memory Pages
 140   * @note   To correctly run this function, the HAL_FLASH_Unlock() function
 141   *         must be called before.
 142   *         Call the HAL_FLASH_Lock() to disable the flash memory access
 143   *         (recommended to protect the FLASH memory against possible unwanted operation)
 144   * @param[in]  pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that
 145   *         contains the configuration information for the erasing.
 146   *
 147   * @param[out]  PageError: pointer to variable  that
 148   *         contains the configuration information on faulty sector in case of error
 149   *         (0xFFFFFFFF means that all the sectors have been correctly erased)
 150   *
 151   * @retval HAL_StatusTypeDef HAL Status
 152   */
 153 HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)
 154 {
 155   HAL_StatusTypeDef status = HAL_ERROR;
 156   uint32_t index = 0;
 157
 158   /* Process Locked */
 159   __HAL_LOCK(&ProcFlash);
 160
 161   /* Wait for last operation to be completed */
 162   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 163
 164   if (status == HAL_OK)
 165   {
 166     /* Clean the error context */
 167     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 168
 169     /*Initialization of PageError variable*/
 170     *PageError = 0xFFFFFFFF;
 171
 172     /* Check the parameters */
 173     assert_param(IS_NBPAGES(pEraseInit->NbPages));
 174     assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
 175     assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));
 176     assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1));
 177
 178     /* Erase by sector by sector to be done*/
 179     for(index = pEraseInit->PageAddress; index < ((pEraseInit->NbPages * FLASH_PAGE_SIZE)+ pEraseInit->PageAddress); index += FLASH_PAGE_SIZE)
 180     {
 181       FLASH_ErasePage(index);
 182
 183       /* Wait for last operation to be completed */
 184       status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 185
 186       /* If the erase operation is completed, disable the ERASE Bit */
 187       CLEAR_BIT(FLASH->PECR, FLASH_PECR_PROG);
 188       CLEAR_BIT(FLASH->PECR, FLASH_PECR_ERASE);
 189
 190       if (status != HAL_OK)
 191       {
 192         /* In case of error, stop erase procedure and return the faulty sector*/
 193         *PageError = index;
 194         break;
 195       }
 196     }
 197   }
 198
 199   /* Process Unlocked */
 200   __HAL_UNLOCK(&ProcFlash);
 201
 202   return status;
 203 }
 204
 205 /**
 206   * @brief  Perform a page erase of the specified FLASH memory pages  with interrupt enabled
 207   * @note   To correctly run this function, the HAL_FLASH_Unlock() function
 208   *         must be called before.
 209   *         Call the HAL_FLASH_Lock() to disable the flash memory access
 210   *         (recommended to protect the FLASH memory against possible unwanted operation).
 211             End of erase is done when HAL_FLASH_EndOfOperationCallback is called with parameter
 212             0xFFFFFFFF
 213   * @param  pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that
 214   *         contains the configuration information for the erasing.
 215   *
 216   * @retval HAL_StatusTypeDef HAL Status
 217   */
 218 HAL_StatusTypeDef HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef *pEraseInit)
 219 {
 220   HAL_StatusTypeDef status = HAL_OK;
 221
 222   /* Process Locked */
 223   __HAL_LOCK(&ProcFlash);
 224
 225   /* Enable End of FLASH Operation interrupt */
 226   __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP);
 227
 228   /* Enable Error source interrupt */
 229   __HAL_FLASH_ENABLE_IT(FLASH_IT_ERR);
 230
 231   /* Check the parameters */
 232   assert_param(IS_NBPAGES(pEraseInit->NbPages));
 233   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
 234   assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));
 235   assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress + pEraseInit->NbPages * FLASH_PAGE_SIZE - 1));
 236
 237   /* Clean the error context */
 238   ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 239   ProcFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE;
 240   ProcFlash.NbPagesToErase = pEraseInit->NbPages;
 241   ProcFlash.Page = pEraseInit->PageAddress;
 242
 243   /* Erase 1st page and wait for IT */
 244   FLASH_ErasePage(pEraseInit->PageAddress);
 245   return status;
 246 }
 247
 248 /**
 249   * @}
 250   */
 251
 252
 253 /** @addtogroup FLASHEx_Exported_Functions_Group2
 254  *  @brief   Option Bytes Programming functions
 255  *
 256 @verbatim
 257   ==============================================================================
 258                 ##### Option Bytes Programming functions #####
 259   ==============================================================================
 260
 261     [..] Any operation of erase or program should follow these steps:
 262     (#) Call the HAL_FLASH_OB_Unlock() function to enable the Flash option control
 263         register access.
 264     (#) Call following function to program the desired option bytes.
 265         (++) HAL_FLASHEx_OBProgram:
 266          - To Enable/Disable the desired sector write protection.
 267          - To set the desired read Protection Level.
 268          - To configure the user option Bytes: IWDG, STOP and the Standby.
 269          - To Set the BOR level.
 270     (#) Once all needed option bytes to be programmed are correctly written, call the
 271         HAL_FLASH_OB_Launch(void) function to launch the Option Bytes programming process.
 272     (#) Call the HAL_FLASH_OB_Lock() to disable the Flash option control register access (recommended
 273         to protect the option Bytes against possible unwanted operations).
 274
 275     [..] Proprietary code Read Out Protection (PcROP):
 276     (#) The PcROP sector is selected by using the same option bytes as the Write
 277         protection (nWRPi bits). As a result, these 2 options are exclusive each other.
 278     (#) In order to activate the PcROP (change the function of the nWRPi option bits),
 279         the WPRMOD option bit must be activated.
 280     (#) The active value of nWRPi bits is inverted when PCROP mode is active, this
 281         means: if WPRMOD = 1 and nWRPi = 1 (default value), then the user sector "i"
 282         is read/write protected.
 283     (#) To activate PCROP mode for Flash sector(s), you need to call the following function:
 284         (++) HAL_FLASHEx_AdvOBProgram in selecting sectors to be read/write protected
 285         (++) HAL_FLASHEx_OB_SelectPCROP to enable the read/write protection
 286 @endverbatim
 287   * @{
 288   */
 289
 290 /**
 291   * @brief  Program option bytes
 292   * @param  pOBInit: pointer to an FLASH_OBInitStruct structure that
 293   *         contains the configuration information for the programming.
 294   *
 295   * @retval HAL_StatusTypeDef HAL Status
 296   */
 297 HAL_StatusTypeDef HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef *pOBInit)
 298 {
 299   HAL_StatusTypeDef status = HAL_ERROR;
 300
 301   /* Process Locked */
 302   __HAL_LOCK(&ProcFlash);
 303
 304   /* Check the parameters */
 305   assert_param(IS_OPTIONBYTE(pOBInit->OptionType));
 306
 307   /* Write protection configuration */
 308   if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP)
 309   {
 310     assert_param(IS_WRPSTATE(pOBInit->WRPState));
 311 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 312     status = FLASH_OB_ProtectedSectorsConfig(pOBInit->WRPSector, pOBInit->WRPSector2, pOBInit->WRPState);
 313 #else
 314     status = FLASH_OB_ProtectedSectorsConfig(pOBInit->WRPSector, pOBInit->WRPState);
 315 #endif
 316     if (status != HAL_OK)
 317     {
 318       /* Process Unlocked */
 319       __HAL_UNLOCK(&ProcFlash);
 320       return status;
 321     }
 322   }
 323
 324   /* Read protection configuration */
 325   if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP)
 326   {
 327     status = FLASH_OB_RDPConfig(pOBInit->RDPLevel);
 328     if (status != HAL_OK)
 329     {
 330       /* Process Unlocked */
 331       __HAL_UNLOCK(&ProcFlash);
 332       return status;
 333     }
 334   }
 335
 336   /* USER  configuration */
 337   if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER)
 338   {
 339     status = FLASH_OB_UserConfig(pOBInit->USERConfig & OB_IWDG_SW,
 340                                  pOBInit->USERConfig & OB_STOP_NORST,
 341                                  pOBInit->USERConfig & OB_STDBY_NORST);
 342     if (status != HAL_OK)
 343     {
 344       /* Process Unlocked */
 345       __HAL_UNLOCK(&ProcFlash);
 346       return status;
 347     }
 348   }
 349
 350   /* BOR Level  configuration */
 351   if((pOBInit->OptionType & OPTIONBYTE_BOR) == OPTIONBYTE_BOR)
 352   {
 353     status = FLASH_OB_BORConfig(pOBInit->BORLevel);
 354   }
 355
 356   /* Program BOOT Bit1 config option byte */
 357   if ((pOBInit->OptionType & OPTIONBYTE_BOOT_BIT1) == OPTIONBYTE_BOOT_BIT1)
 358   {
 359     status = FLASH_OB_BOOTBit1Config(pOBInit->BOOTBit1Config);
 360   }
 361
 362   /* Process Unlocked */
 363   __HAL_UNLOCK(&ProcFlash);
 364   return status;
 365 }
 366
 367 /**
 368   * @brief   Get the Option byte configuration
 369   * @param  pOBInit: pointer to an FLASH_OBInitStruct structure that
 370   *         contains the configuration information for the programming.
 371   *
 372   * @retval None
 373   */
 374 void HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef *pOBInit)
 375 {
 376   pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER | OPTIONBYTE_BOR;
 377
 378   /* Get WRP sector */
 379   pOBInit->WRPSector = FLASH_OB_GetWRP();
 380
 381 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 382   pOBInit->WRPSector2 = FLASH_OB_GetWRP2();
 383 #endif
 384
 385   /* Get RDP Level */
 386   pOBInit->RDPLevel = FLASH_OB_GetRDP();
 387
 388   /* Get USER */
 389   pOBInit->USERConfig = FLASH_OB_GetUser();
 390
 391   /* Get BOR Level */
 392   pOBInit->BORLevel = FLASH_OB_GetBOR();
 393
 394   /* Get BOOT bit 1 config OB */
 395   pOBInit->BOOTBit1Config = FLASH_OB_GetBOOTBit1();
 396
 397 }
 398
 399 /**
 400   * @brief  Program option bytes
 401   * @param  pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
 402   *         contains the configuration information for the programming.
 403   *
 404   * @retval HAL_StatusTypeDef HAL Status
 405   */
 406 HAL_StatusTypeDef HAL_FLASHEx_AdvOBProgram (FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
 407 {
 408   HAL_StatusTypeDef status = HAL_ERROR;
 409
 410   /* Check the parameters */
 411   assert_param(IS_OBEX(pAdvOBInit->OptionType));
 412
 413   /* Program PCROP option byte */
 414   if ((pAdvOBInit->OptionType & OPTIONBYTE_PCROP) == OPTIONBYTE_PCROP)
 415   {
 416     /* Check the parameters */
 417     assert_param(IS_PCROPSTATE(pAdvOBInit->PCROPState));
 418 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 419     status = FLASH_OB_ProtectedSectorsConfig(pAdvOBInit->PCROPSector, pAdvOBInit->PCROPSector2, pAdvOBInit->PCROPState);
 420 #else
 421     status = FLASH_OB_ProtectedSectorsConfig(pAdvOBInit->PCROPSector, pAdvOBInit->PCROPState);
 422 #endif
 423   }
 424 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 425   if ((pAdvOBInit->OptionType & OPTIONBYTE_BOOTCONFIG) == OPTIONBYTE_BOOTCONFIG)
 426   {
 427     status = FLASH_OB_BFB2Config(pAdvOBInit->BootConfig);
 428   }
 429 #endif
 430
 431   return status;
 432 }
 433
 434 /**
 435   * @brief   Get the OBEX byte configuration
 436   * @param  pAdvOBInit: pointer to an FLASH_AdvOBProgramInitTypeDef structure that
 437   *         contains the configuration information for the programming.
 438   *
 439   * @retval None
 440   */
 441 void HAL_FLASHEx_AdvOBGetConfig(FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
 442 {
 443 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 444   pAdvOBInit->OptionType = OPTIONBYTE_PCROP| OPTIONBYTE_BOOTCONFIG;
 445 #else
 446   pAdvOBInit->OptionType = OPTIONBYTE_PCROP;
 447 #endif
 448   /* Get PCROP state */
 449   pAdvOBInit->PCROPState = (FLASH->OPTR & FLASH_OPTR_WPRMOD) >> 8;
 450   /* Get PCROP protected sector */
 451   pAdvOBInit->PCROPSector = FLASH->WRPR;
 452
 453 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 454   /* Get PCROP protected sector */
 455   pAdvOBInit->PCROPSector2 = FLASH->WRPR2;
 456
 457   /* Get boot bank config */
 458   pAdvOBInit->BootConfig = (FLASH->OPTR & FLASH_OPTR_BFB2) >> 23;
 459 #endif
 460 }
 461
 462 /**
 463   * @brief  Select the Protection Mode (WPRMOD).
 464   * @note   Once WPRMOD bit is active, unprotection of a protected sector is not possible
 465   * @note   Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
 466   * @param  None
 467   * @retval HAL status
 468   */
 469 HAL_StatusTypeDef HAL_FLASHEx_OB_SelectPCROP(void)
 470 {
 471   return (FLASH_OB_PCROPSelectionConfig(1));
 472 }
 473
 474 /**
 475   * @brief  Deselect the Protection Mode (WPRMOD).
 476   * @note   Once WPRMOD bit is active, unprotection of a protected sector is not possible
 477   * @note   Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
 478   * @param  None
 479   * @retval HAL status
 480   */
 481 HAL_StatusTypeDef HAL_FLASHEx_OB_DeSelectPCROP(void)
 482 {
 483   return (FLASH_OB_PCROPSelectionConfig(0));
 484 }
 485
 486 /**
 487   * @}
 488   */
 489
 490 /** @addtogroup FLASHEx_Exported_Functions_Group3
 491  *  @brief   DATA EEPROM Programming functions
 492  *
 493 @verbatim
 494  ===============================================================================
 495                      ##### DATA EEPROM Programming functions #####
 496  ===============================================================================
 497
 498     [..] The FLASH_DATAEEPROM Programming_Functions, includes the following functions:
 499         (+) HAL_FLASHEx_DATAEEPROM_Unlock(void);
 500         (+) HAL_FLASHEx_DATAEEPROM_Lock(void);
 501         (+) HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
 502         (+) HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)
 503
 504     [..] Any operation of erase or program should follow these steps:
 505     (#) Call the HAL_FLASHEx_DATAEEPROM_Unlock() function to enable the data EEPROM access
 506         and Flash program erase control register access.
 507     (#) Call the desired function to erase or program data.
 508     (#) Call the HAL_FLASHEx_DATAEEPROM_Lock() to disable the data EEPROM access
 509         and Flash program erase control register access(recommended
 510         to protect the DATA_EEPROM against possible unwanted operation).
 511
 512 @endverbatim
 513   * @{
 514   */
 515 /**
 516   * @brief  Unlocks the data memory and FLASH_PECR register access.
 517   * @param  None
 518   * @retval HAL_StatusTypeDef HAL Status
 519   */
 520 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Unlock(void)
 521 {
 522   if((FLASH->PECR & FLASH_PECR_PELOCK) != RESET)
 523   {
 524     /* Unlocking the Data memory and FLASH_PECR register access */
 525     FLASH->PEKEYR = FLASH_PEKEY1;
 526     FLASH->PEKEYR = FLASH_PEKEY2;
 527     return HAL_OK;
 528   }
 529   else
 530   {
 531     return HAL_ERROR;
 532   }
 533 }
 534
 535 /**
 536   * @brief  Locks the Data memory and FLASH_PECR register access.
 537   * @param  None
 538   * @retval HAL_StatusTypeDef HAL Status
 539   */
 540 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Lock(void)
 541 {
 542   /* Set the PELOCK Bit to lock the data memory and FLASH_PECR register access */
 543   SET_BIT(FLASH->PECR, FLASH_PECR_PELOCK);
 544   return HAL_OK;
 545 }
 546
 547 /**
 548   * @brief  Erase a word in data memory.
 549   * @param  Address: specifies the address to be erased.
 550   * @note   To correctly run this function, the HAL_FLASHEx_DATAEEPROM_Unlock() function
 551   *         must be called before.
 552   *         Call the HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
 553   *         and Flash program erase control register access(recommended to protect
 554   *         the DATA_EEPROM against possible unwanted operation).
 555   * @retval HAL status
 556   */
 557 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
 558 {
 559   HAL_StatusTypeDef status = HAL_OK;
 560
 561   /* Check the parameters */
 562   assert_param(IS_FLASH_DATA_ADDRESS(Address));
 563
 564   /* Wait for last operation to be completed */
 565   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 566
 567   if(status == HAL_OK)
 568   {
 569     /* Clean the error context */
 570     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 571
 572     /* Write "00000000h" to valid address in the data memory" */
 573       *(__IO uint32_t *) Address = 0x00000000;
 574     }
 575   return status;
 576 }
 577
 578 /**
 579   * @brief  Program word at a specified address
 580   * @param  TypeProgram:  Indicate the way to program at a specified address.
 581   *                           This parameter can be a value of @ref FLASHEx_Type_Program_Data
 582   * @param  Address:  specifies the address to be programmed.
 583   * @param  Data: specifies the data to be programmed
 584   *
 585   * @retval HAL_StatusTypeDef HAL Status
 586   */
 587
 588 HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)
 589 {
 590   HAL_StatusTypeDef status = HAL_ERROR;
 591
 592   /* Process Locked */
 593   __HAL_LOCK(&ProcFlash);
 594
 595   /* Check the parameters */
 596   assert_param(IS_TYPEPROGRAMDATA(TypeProgram));
 597   assert_param(IS_FLASH_DATA_ADDRESS(Address));
 598
 599   /* Wait for last operation to be completed */
 600   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 601
 602   if(status == HAL_OK)
 603   {
 604     /* Clean the error context */
 605     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 606
 607     if(TypeProgram == FLASH_TYPEPROGRAMDATA_WORD)
 608     {
 609       /* Program word (32-bit) at a specified address */
 610       *(__IO uint32_t *)Address = Data;
 611     }
 612     else if(TypeProgram == FLASH_TYPEPROGRAMDATA_HALFWORD)
 613     {
 614       /* Program word (16-bit) at a specified address */
 615       *(__IO uint16_t *)Address = (uint16_t) Data;
 616     }
 617     else if(TypeProgram == FLASH_TYPEPROGRAMDATA_BYTE)
 618     {
 619       /*Program word (8-bit) at a specified address */
 620       *(__IO uint8_t *)Address = (uint8_t) Data;
 621     }
 622     else
 623     {
 624       status = HAL_ERROR;
 625     }
 626
 627     /* Wait for last operation to be completed */
 628     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 629   }
 630   /* Process Unlocked */
 631   __HAL_UNLOCK(&ProcFlash);
 632   return status;
 633 }
 634
 635 /**
 636   * @brief  Enable DATA EEPROM fixed Time programming (2*Tprog).
 637   * @retval None
 638   */
 639 void HAL_FLASHEx_DATAEEPROM_EnableFixedTimeProgram(void)
 640 {
 641   SET_BIT(FLASH->PECR, FLASH_PECR_FIX);
 642 }
 643
 644 /**
 645   * @brief  Disables DATA EEPROM fixed Time programming (2*Tprog).
 646   * @retval None
 647   */
 648 void HAL_FLASHEx_DATAEEPROM_DisableFixedTimeProgram(void)
 649 {
 650   CLEAR_BIT(FLASH->PECR, FLASH_PECR_FIX);
 651 }
 652
 653 /**
 654   * @}
 655   */
 656
 657 /**
 658   * @brief  Returns the FLASH User Option Bytes values.
 659   * @param  None
 660   * @retval The FLASH User Option Bytes.
 661   */
 662 static uint8_t FLASH_OB_GetUser(void)
 663 {
 664   /* Return the User Option Byte */
 665   return (uint8_t)((FLASH->OPTR & FLASH_OPTR_USER) >> 16);
 666 }
 667
 668 /**
 669   * @brief  Returns the FLASH Read out Protection Level.
 670   * @param  None
 671   * @retval FLASH RDP level.
 672   */
 673 static uint8_t FLASH_OB_GetRDP(void)
 674 {
 675   return (uint8_t)(FLASH->OPTR & FLASH_OPTR_RDPROT);
 676 }
 677
 678 /**
 679   * @brief  Returns the FLASH BOR level.
 680   * @param  None
 681   * @retval The BOR level Option Bytes.
 682   */
 683 static uint8_t FLASH_OB_GetBOR(void)
 684 {
 685   /* Return the BOR level */
 686   return (uint8_t)((FLASH->OPTR & (uint32_t)FLASH_OPTR_BOR_LEV) >> 16);
 687 }
 688
 689 /**
 690   * @brief  Returns the FLASH BOOT bit1 value.
 691   * @param  None
 692   * @retval The BOOT bit 1 value Option Bytes.
 693   */
 694 static uint8_t FLASH_OB_GetBOOTBit1(void)
 695 {
 696   /* Return the BOR level */
 697   return (FLASH->OPTR & FLASH_OPTR_BOOT1) >> 31;
 698
 699 }
 700
 701 /**
 702   * @brief  Returns the FLASH Write Protection Option Bytes value.
 703   * @param  None
 704   * @retval The FLASH Write Protection Option Bytes value.
 705   */
 706 static uint32_t FLASH_OB_GetWRP(void)
 707 {
 708   /* Return the FLASH write protection Register value */
 709   return (uint32_t)(FLASH->WRPR);
 710 }
 711
 712 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 713 /**
 714   * @brief  Returns the FLASH Write Protection Option Bytes value.
 715   * @param  None
 716   * @retval The FLASH Write Protection Option Bytes value.
 717   */
 718 static uint32_t FLASH_OB_GetWRP2(void)
 719 {
 720   /* Return the FLASH write protection Register value */
 721   return (uint32_t)(FLASH->WRPR2);
 722 }
 723 #endif /* STM32L071xx || STM32L072xx || STM32L073xx || STM32L081xx || STM32L082xx || STM32L083xx */
 724
 725 /**
 726   * @brief  Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY.
 727   * @param  OB_IWDG: Selects the WDG mode.
 728   *   This parameter can be one of the following values:
 729   *     @arg OB_IWDG_SW: Software WDG selected
 730   *     @arg OB_IWDG_HW: Hardware WDG selected
 731   * @param  OB_STOP: Reset event when entering STOP mode.
 732   *   This parameter can be one of the following values:
 733   *     @arg OB_STOP_NoRST: No reset generated when entering in STOP
 734   *     @arg OB_STOP_RST: Reset generated when entering in STOP
 735   * @param  OB_STDBY: Reset event when entering Standby mode.
 736   *   This parameter can be one of the following values:
 737   *     @arg OB_STDBY_NORST: No reset generated when entering in STANDBY
 738   *     @arg OB_STDBY_RST: Reset generated when entering in STANDBY
 739   * @retval HAL status
 740   */
 741 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)
 742 {
 743   HAL_StatusTypeDef status = HAL_OK;
 744   uint32_t tmp = 0, tmp1 = 0, OB_Bits = (uint32_t) (OB_IWDG | OB_STOP | OB_STDBY);
 745
 746   /* Check the parameters */
 747   assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));
 748   assert_param(IS_OB_STOP_SOURCE(OB_STOP));
 749   assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));
 750
 751   /* Clean the error context */
 752   ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 753
 754   /* Get the User Option byte register */
 755   tmp1 = OB->USER & ((~FLASH_OPTR_USER) >> 16);
 756
 757   /* Calculate the user option byte to write */
 758   tmp = (~(OB_Bits | tmp1)) << 16;
 759   tmp |= OB_Bits | tmp1;
 760
 761   /* Wait for last operation to be completed */
 762   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 763
 764   if(status == HAL_OK)
 765   {
 766     /* Clean the error context */
 767     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 768     /* Program OB */
 769     OB->USER = tmp;
 770     /* Wait for last operation to be completed */
 771     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 772   }
 773   return status;
 774 }
 775
 776 /**
 777   * @brief  Enables or disables the read out protection.
 778   * @note   To correctly run this function, the FLASH_OB_Unlock() function
 779   *         must be called before.
 780   * @param  OB_RDP: specifies the read protection level.
 781   *   This parameter can be:
 782   *     @arg OB_RDP_LEVEL0: No protection
 783   *     @arg OB_RDP_LEVEL1: Read protection of the memory
 784   *     @arg OB_RDP_LEVEL2: Chip protection
 785   *
 786   *  !!!Warning!!! When enabling OB_RDP_LEVEL2 it's no more possible to go back to level 1 or 0
 787   *
 788   * @retval HAL status
 789   */
 790 static HAL_StatusTypeDef FLASH_OB_RDPConfig(uint8_t OB_RDP)
 791 {
 792   HAL_StatusTypeDef status;
 793   uint32_t tmp = 0, tmp1 = 0, OB_Bits = (uint32_t) OB_RDP;
 794
 795   /* Check the parameters */
 796   assert_param(IS_OB_RDP(OB_RDP));
 797
 798   /* Calculate the option byte to write */
 799   tmp = (OB->RDP & ((~FLASH_OPTR_RDPROT) & 0x0000FFFF)) | OB_Bits;
 800   tmp1 = (~tmp << 16) | tmp;
 801
 802   /* Wait for last operation to be completed */
 803   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 804
 805   if(status == HAL_OK)
 806   {
 807     /* Clean the error context */
 808     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 809     /* Program OB */
 810     OB->RDP = tmp1;
 811     /* Wait for last operation to be completed */
 812     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 813   }
 814   return status;
 815 }
 816
 817 /**
 818   * @brief  Programs the FLASH brownout reset threshold level Option Byte.
 819   * @param  OB_BOR: Selects the brownout reset threshold level.
 820   *   This parameter can be one of the following values:
 821   *     @arg OB_BOR_OFF: BOR is disabled at power down, the reset is asserted when the VDD
 822   *                      power supply reaches the PDR(Power Down Reset) threshold (1.5V)
 823   *     @arg OB_BOR_LEVEL1: BOR Reset threshold levels for 1.7V - 1.8V VDD power supply
 824   *     @arg OB_BOR_LEVEL2: BOR Reset threshold levels for 1.9V - 2.0V VDD power supply
 825   *     @arg OB_BOR_LEVEL3: BOR Reset threshold levels for 2.3V - 2.4V VDD power supply
 826   *     @arg OB_BOR_LEVEL4: BOR Reset threshold levels for 2.55V - 2.65V VDD power supply
 827   *     @arg OB_BOR_LEVEL5: BOR Reset threshold levels for 2.8V - 2.9V VDD power supply
 828   * @retval HAL status
 829   */
 830 static HAL_StatusTypeDef FLASH_OB_BORConfig(uint8_t OB_BOR)
 831 {
 832   HAL_StatusTypeDef status = HAL_OK;
 833   uint32_t tmp = 0, tmp1 = 0, OB_Bits = (uint32_t) OB_BOR;
 834
 835   /* Check the parameters */
 836   assert_param(IS_OB_BOR_LEVEL(OB_BOR));
 837
 838   /* Get the User Option byte register */
 839   tmp1 = OB->USER & ((~FLASH_OPTR_BOR_LEV) >> 16);
 840
 841   /* Calculate the user option byte to write */
 842   tmp = (~(OB_Bits | tmp1)) << 16;
 843   tmp |= OB_Bits | tmp1;
 844
 845   /* Wait for last operation to be completed */
 846   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 847
 848   if(status == HAL_OK)
 849   {
 850     /* Clean the error context */
 851     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 852     /* Program OB */
 853     OB->USER = tmp;
 854     /* Wait for last operation to be completed */
 855     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 856   }
 857
 858   return status;
 859 }
 860
 861 /**
 862   * @brief  Sets or resets the BOOT bit1 option bit.
 863   * @param  OB_BOOT_BIT1: Set or Reset the BOOT bit1 option bit.
 864   *          This parameter can be one of the following values:
 865   *             @arg OB_BOOT_BIT1_RESET: BOOT1 option bit reset
 866   *             @arg OB_BOOT_BIT1_SET: BOOT1 option bit set
 867   * @retval HAL status
 868   */
 869 static HAL_StatusTypeDef FLASH_OB_BOOTBit1Config(uint8_t OB_BOOT_BIT1)
 870 {
 871   HAL_StatusTypeDef status = HAL_OK;
 872   uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) OB_BOOT_BIT1) << 15;
 873
 874   /* Check the parameters */
 875   assert_param(IS_OB_BOOT1(OB_BOOT_BIT1));
 876
 877   /* Get the User Option byte register */
 878   tmp1 = OB->USER & ((~FLASH_OPTR_BOOT1) >> 16);
 879
 880   /* Calculate the user option byte to write */
 881   tmp = (~(OB_Bits | tmp1)) << 16;
 882   tmp |= OB_Bits | tmp1;
 883
 884   /* Wait for last operation to be completed */
 885   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 886
 887   if(status == HAL_OK)
 888   {
 889     /* Clean the error context */
 890     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 891     /* Program OB */
 892     OB->USER = tmp;
 893     /* Wait for last operation to be completed */
 894     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 895   }
 896
 897   return status;
 898 }
 899
 900 /**
 901   * @brief  Select the Protection Mode (WPRMOD).
 902   * @note   Once WPRMOD bit is active, unprotection of a protected sector is not possible
 903   * @note   Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag
 904   * @param  OB_PcROP: Select the Protection Mode of WPR bits.
 905   *   This parameter can be:
 906   *     @arg OB_PCROP_SELECTED: nWRP control the  read&write protection (PcROP) of respective user sectors.
 907   *     @arg OB_PCROP_DESELECTED: nWRP control the write protection of respective user sectors.
 908   * @retval HAL status
 909   */
 910 static HAL_StatusTypeDef FLASH_OB_PCROPSelectionConfig(uint32_t WPRMOD)
 911 {
 912   HAL_StatusTypeDef status;
 913   uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) WPRMOD) << 8;
 914
 915   /* Get the User Option byte register */
 916   tmp1 = OB->USER & ((~FLASH_OPTR_WPRMOD) >> 16);
 917
 918   /* Calculate the user option byte to write */
 919   tmp = (~(OB_Bits | tmp1)) << 16;
 920   tmp |= OB_Bits | tmp1;
 921
 922     /* Wait for last operation to be completed */
 923   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 924
 925   if(status == HAL_OK)
 926   {
 927     /* Clean the error context */
 928     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 929    /* Program OB */
 930     OB->RDP = tmp;
 931     /* Wait for last operation to be completed */
 932     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 933   }
 934
 935   return status;
 936 }
 937
 938 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 939 /**
 940   * @brief  Sets or resets the BFB2 option bit.
 941   * @param  BFB2: Set or Reset the BFB2 option bit.
 942   *          This parameter can be one of the following values:
 943   *             @arg OB_BOOT_BANK1: BFB2 option bit reset
 944   *             @arg OB_BOOT_BANK2: BFB2 option bit set
 945   * @retval None
 946   */
 947 static HAL_StatusTypeDef FLASH_OB_BFB2Config(uint8_t OB_BFB2)
 948 {
 949   HAL_StatusTypeDef status = HAL_OK;
 950   uint32_t tmp = 0, tmp1 = 0, OB_Bits = ((uint32_t) OB_BFB2) << 7;
 951
 952   /* Check the parameters */
 953   assert_param(IS_OB_BOOT_BANK(OB_BFB2));
 954
 955   /* Get the User Option byte register */
 956   tmp1 = OB->USER & ((~FLASH_OPTR_BFB2) >> 16);
 957
 958   /* Calculate the user option byte to write */
 959   tmp = (~(OB_Bits | tmp1)) << 16;
 960   tmp |= OB_Bits | tmp1;
 961
 962   /* Wait for last operation to be completed */
 963   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 964
 965   if(status == HAL_OK)
 966   {
 967     /* Clean the error context */
 968     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
 969
 970     /* Program OB */
 971     OB->USER = tmp;
 972
 973     /* Wait for last operation to be completed */
 974     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
 975   }
 976   return status;
 977 }
 978 #endif
 979
 980 /**
 981   * @brief  Write Option Byte of the desired pages of the Flash.
 982   * @param  Sector: specifies the sectors to be write protected.
 983   * @param  Sector2: specifies the sectors to be write protected only stm32l07xxx and stm32l08xxx devices
 984   * @param  NewState: new state of the specified FLASH Pages Wite protection.
 985   *   This parameter can be: ENABLE or DISABLE.
 986   * @retval HAL_StatusTypeDef
 987   */
 988 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
 989 static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t Sector2, uint32_t NewState)
 990 #else
 991 static HAL_StatusTypeDef FLASH_OB_ProtectedSectorsConfig(uint32_t Sector, uint32_t NewState)
 992 #endif
 993 {
 994   HAL_StatusTypeDef status = HAL_OK;
 995   uint32_t WRP_Data = 0;
 996   uint32_t OB_WRP = Sector;
 997
 998   /* Check the parameters */
 999   assert_param(IS_FUNCTIONAL_STATE(NewState));
1000
1001   /* Wait for last operation to be completed */
1002   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
1003
1004   if(status == HAL_OK)
1005   {
1006     /* Clean the error context */
1007     ProcFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
1008
1009     if (OB_WRP & 0x0000FFFF)
1010     {
1011       if (NewState != OB_WRPSTATE_DISABLE)
1012       {
1013         WRP_Data = (uint16_t)(((OB_WRP & WRP_MASK_LOW) | OB->WRP01));
1014         OB->WRP01 = (uint32_t)(~(WRP_Data) << 16) | (WRP_Data);
1015       }
1016       else
1017       {
1018         WRP_Data = (uint16_t)(~OB_WRP & (WRP_MASK_LOW & OB->WRP01));
1019         OB->WRP01 =  (uint32_t)((~WRP_Data) << 16) | (WRP_Data);
1020       }
1021     }
1022 #if defined(STM32L071xx) || defined(STM32L072xx) || defined(STM32L073xx) || defined(STM32L081xx) || defined(STM32L082xx) || defined(STM32L083xx)
1023     if (OB_WRP & 0xFFFF0000)
1024     {
1025       if (NewState != OB_WRPSTATE_DISABLE)
1026       {
1027         WRP_Data = (uint16_t)((((OB_WRP & WRP_MASK_HIGH) >> 16 | OB->WRP23)));
1028         OB->WRP23 = (uint32_t)(~(WRP_Data) << 16) | (WRP_Data);
1029       }
1030       else
1031       {
1032         WRP_Data = (uint16_t)((((~OB_WRP & WRP_MASK_HIGH) >> 16 & OB->WRP23)));
1033         OB->WRP23 = (uint32_t)((~WRP_Data) << 16) | (WRP_Data);
1034       }
1035     }
1036
1037     OB_WRP = Sector2;
1038     if (OB_WRP & 0x0000FFFF)
1039     {
1040       if (NewState != OB_WRPSTATE_DISABLE)
1041       {
1042         WRP_Data = (uint16_t)(((OB_WRP & WRP_MASK_LOW) | OB->WRP45));
1043         OB->WRP45 =(uint32_t)(~(WRP_Data) << 16) | (WRP_Data);
1044       }
1045       else
1046       {
1047         WRP_Data = (uint16_t)(~OB_WRP & (WRP_MASK_LOW & OB->WRP45));
1048         OB->WRP45 = (uint32_t)((~WRP_Data) << 16) | (WRP_Data);
1049       }
1050     }
1051 #endif /* STM32L071xx || STM32L072xx || STM32L073xx || STM32L081xx || STM32L082xx || STM32L083xx */
1052   }
1053   /* Wait for last operation to be completed */
1054   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
1055
1056   /* Return the write protection operation Status */
1057   return status;
1058 }
1059
1060 /**
1061   * @}
1062   */
1063 #endif /* HAL_FLASH_MODULE_ENABLED */
1064
1065 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/