lib/main/STM32F4/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_flash.c

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