AMiRo-OS

/**

  ******************************************************************************

  * @file    stm32f4xx_flash.c

  * @author  MCD Application Team

  * @version V1.1.0

  * @date    11-January-2013

  * @brief   This file provides firmware functions to manage the following 

  *          functionalities of the FLASH peripheral:

  *            + FLASH Interface configuration

  *            + FLASH Memory Programming

  *            + Option Bytes Programming

  *            + Interrupts and flags management

  *  

 @verbatim    

 ===============================================================================

                        ##### How to use this driver #####

 ===============================================================================

    [..]                             

      This driver provides functions to configure and program the FLASH memory 

      of all STM32F4xx devices. These functions are split in 4 groups:

      (#) FLASH Interface configuration functions: this group includes the

          management of the following features:

        (++) Set the latency

        (++) Enable/Disable the prefetch buffer

        (++) Enable/Disable the Instruction cache and the Data cache

        (++) Reset the Instruction cache and the Data cache

      (#) FLASH Memory Programming functions: this group includes all needed

          functions to erase and program the main memory:

        (++) Lock and Unlock the FLASH interface

        (++) Erase function: Erase sector, erase all sectors

        (++) Program functions: byte, half word, word and double word

      (#) Option Bytes Programming functions: this group includes all needed

          functions to manage the Option Bytes:

        (++) Set/Reset the write protection

        (++) Set the Read protection Level

        (++) Set the BOR level

        (++) Program the user Option Bytes

        (++) Launch the Option Bytes loader

      (#) Interrupts and flags management functions: this group 

          includes all needed functions to:

        (++) Enable/Disable the FLASH interrupt sources

        (++) Get flags status

        (++) Clear flags

        (++) Get FLASH operation status

        (++) Wait for last FLASH operation   

 @endverbatim                      

  ******************************************************************************

  * @attention

  *

  * <h2><center>&copy; COPYRIGHT 2013 STMicroelectronics</center></h2>

  *

  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");

  * You may not use this file except in compliance with the License.

  * You may obtain a copy of the License at:

  *

  *        http://www.st.com/software_license_agreement_liberty_v2

  *

  * Unless required by applicable law or agreed to in writing, software 

  * distributed under the License is distributed on an "AS IS" BASIS, 

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  *

  ******************************************************************************

  */

/* Includes ------------------------------------------------------------------*/

#include "stm32f4xx_flash.h"

/** @addtogroup STM32F4xx_StdPeriph_Driver

  * @{

  */

/** @defgroup FLASH 

  * @brief FLASH driver modules

  * @{

  */ 

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/ 

#define SECTOR_MASK               ((uint32_t)0xFFFFFF07)

/* Private macro -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/

/* Private functions ---------------------------------------------------------*/

/** @defgroup FLASH_Private_Functions

  * @{

  */ 

/** @defgroup FLASH_Group1 FLASH Interface configuration functions

  *  @brief   FLASH Interface configuration functions 

 *

@verbatim   

 ===============================================================================

              ##### FLASH Interface configuration functions #####

 ===============================================================================

    [..]

      This group includes the following functions:

      (+) void FLASH_SetLatency(uint32_t FLASH_Latency)

          To correctly read data from FLASH memory, the number of wait states (LATENCY) 

          must be correctly programmed according to the frequency of the CPU clock 

          (HCLK) and the supply voltage of the device.

 +-------------------------------------------------------------------------------------+     

 | Latency       |                HCLK clock frequency (MHz)                           |

 |               |---------------------------------------------------------------------|     

 |               | voltage range  | voltage range  | voltage range   | voltage range   |

 |               | 2.7 V - 3.6 V  | 2.4 V - 2.7 V  | 2.1 V - 2.4 V   | 1.8 V - 2.1 V   |

 |---------------|----------------|----------------|-----------------|-----------------|              

 |0WS(1CPU cycle)|0 < HCLK <= 30  |0 < HCLK <= 24  |0 < HCLK <= 22   |0 < HCLK <= 20   |

 |---------------|----------------|----------------|-----------------|-----------------|   

 |1WS(2CPU cycle)|30 < HCLK <= 60 |24 < HCLK <= 48 |22 < HCLK <= 44  |20 < HCLK <= 40  | 

 |---------------|----------------|----------------|-----------------|-----------------|   

 |2WS(3CPU cycle)|60 < HCLK <= 90 |48 < HCLK <= 72 |44 < HCLK <= 66  |40 < HCLK <= 60  |

 |---------------|----------------|----------------|-----------------|-----------------| 

 |3WS(4CPU cycle)|90 < HCLK <= 120|72 < HCLK <= 96 |66 < HCLK <= 88  |60 < HCLK <= 80  |

 |---------------|----------------|----------------|-----------------|-----------------| 

 |4WS(5CPU cycle)|120< HCLK <= 150|96 < HCLK <= 120|88 < HCLK <= 110 |80 < HCLK <= 100 |

 |---------------|----------------|----------------|-----------------|-----------------| 

 |5WS(6CPU cycle)|120< HCLK <= 168|120< HCLK <= 144|110 < HCLK <= 132|100 < HCLK <= 120| 

 |---------------|----------------|----------------|-----------------|-----------------| 

 |6WS(7CPU cycle)|      NA        |144< HCLK <= 168|132 < HCLK <= 154|120 < HCLK <= 140| 

 |---------------|----------------|----------------|-----------------|-----------------| 

 |7WS(8CPU cycle)|      NA        |      NA        |154 < HCLK <= 168|140 < HCLK <= 160|

 +-------------------------------------------------------------------------------------+ 

 [..]

 +-------------------------------------------------------------------------------------------------------------------+

 |               | voltage range  | voltage range  | voltage range   | voltage range   | voltage range 2.7 V - 3.6 V |

 |               | 2.7 V - 3.6 V  | 2.4 V - 2.7 V  | 2.1 V - 2.4 V   | 1.8 V - 2.1 V   | with External Vpp = 9V      |

 |---------------|----------------|----------------|-----------------|-----------------|-----------------------------| 

 |Max Parallelism|      x32       |               x16                |       x8        |          x64                |              

 |---------------|----------------|----------------|-----------------|-----------------|-----------------------------|   

 |PSIZE[1:0]     |      10        |               01                 |       00        |           11                |

 +-------------------------------------------------------------------------------------------------------------------+  

      -@- When VOS bit (in PWR_CR register) is reset to 0 , the maximum value of HCLK is 144 MHz.

          You can use PWR_MainRegulatorModeConfig() function to set or reset this bit.

      -@- On STM32F40xx/41xx devices: 

           (++) when VOS = '0', the maximum value of fHCLK = 144MHz. 

           (++) when VOS = '1', the maximum value of fHCLK = 168MHz. 

          [..] 

          On STM32F427x/437x devices:

           (++) when VOS[1:0] = '0x01', the maximum value of fHCLK is 120MHz.

           (++) when VOS[1:0] = '0x10', the maximum value of fHCLK is 144MHz.

           (++) when VOS[1:0] = '0x11', the maximum value of f  is 168MHz  

           You can use PWR_MainRegulatorModeConfig() function to control VOS bits.

      (+) void FLASH_PrefetchBufferCmd(FunctionalState NewState)

      (+) void FLASH_InstructionCacheCmd(FunctionalState NewState)

      (+) void FLASH_DataCacheCmd(FunctionalState NewState)

      (+) void FLASH_InstructionCacheReset(void)

      (+) void FLASH_DataCacheReset(void)

    [..]   

      The unlock sequence is not needed for these functions.

@endverbatim

  * @{

  */

/**

  * @brief  Sets the code latency value.  

  * @param  FLASH_Latency: specifies the FLASH Latency value.

  *          This parameter can be one of the following values:

  *            @arg FLASH_Latency_0: FLASH Zero Latency cycle

  *            @arg FLASH_Latency_1: FLASH One Latency cycle

  *            @arg FLASH_Latency_2: FLASH Two Latency cycles

  *            @arg FLASH_Latency_3: FLASH Three Latency cycles

  *            @arg FLASH_Latency_4: FLASH Four Latency cycles 

  *            @arg FLASH_Latency_5: FLASH Five Latency cycles 

  *            @arg FLASH_Latency_6: FLASH Six Latency cycles

  *            @arg FLASH_Latency_7: FLASH Seven Latency cycles  

  *          For STM32F40xx/41xx and STM32F427x/437x devices this parameter can be   

  *          a value between FLASH_Latency_0 and FLASH_Latency_7.   

  * @retval None

  */

void FLASH_SetLatency(uint32_t FLASH_Latency)

{

  /* Check the parameters */

  assert_param(IS_FLASH_LATENCY(FLASH_Latency));

  /* Perform Byte access to FLASH_ACR[8:0] to set the Latency value */

  *(__IO uint8_t *)ACR_BYTE0_ADDRESS = (uint8_t)FLASH_Latency;

}

/**

  * @brief  Enables or disables the Prefetch Buffer.

  * @param  NewState: new state of the Prefetch Buffer.

  *          This parameter  can be: ENABLE or DISABLE.

  * @retval None

  */

void FLASH_PrefetchBufferCmd(FunctionalState NewState)

{

  /* Check the parameters */

  assert_param(IS_FUNCTIONAL_STATE(NewState));

  /* Enable or disable the Prefetch Buffer */

  if(NewState != DISABLE)

  {

    FLASH->ACR |= FLASH_ACR_PRFTEN;

  }

  else

  {

    FLASH->ACR &= (~FLASH_ACR_PRFTEN);

  }

}

/**

  * @brief  Enables or disables the Instruction Cache feature.

  * @param  NewState: new state of the Instruction Cache.

  *          This parameter  can be: ENABLE or DISABLE.

  * @retval None

  */

void FLASH_InstructionCacheCmd(FunctionalState NewState)

{

  /* Check the parameters */

  assert_param(IS_FUNCTIONAL_STATE(NewState));

  if(NewState != DISABLE)

  {

    FLASH->ACR |= FLASH_ACR_ICEN;

  }

  else

  {

    FLASH->ACR &= (~FLASH_ACR_ICEN);

  }

}

/**

  * @brief  Enables or disables the Data Cache feature.

  * @param  NewState: new state of the Data Cache.

  *          This parameter  can be: ENABLE or DISABLE.

  * @retval None

  */

void FLASH_DataCacheCmd(FunctionalState NewState)

{

  /* Check the parameters */

  assert_param(IS_FUNCTIONAL_STATE(NewState));

  if(NewState != DISABLE)

  {

    FLASH->ACR |= FLASH_ACR_DCEN;

  }

  else

  {

    FLASH->ACR &= (~FLASH_ACR_DCEN);

  }

}

/**

  * @brief  Resets the Instruction Cache.

  * @note   This function must be used only when the Instruction Cache is disabled.  

  * @param  None

  * @retval None

  */

void FLASH_InstructionCacheReset(void)

{

  FLASH->ACR |= FLASH_ACR_ICRST;

}

/**

  * @brief  Resets the Data Cache.

  * @note   This function must be used only when the Data Cache is disabled.  

  * @param  None

  * @retval None

  */

void FLASH_DataCacheReset(void)

{

  FLASH->ACR |= FLASH_ACR_DCRST;

}

/**

  * @}

  */

/** @defgroup FLASH_Group2 FLASH Memory Programming functions

 *  @brief   FLASH Memory Programming functions

 *

@verbatim   

 ===============================================================================

                ##### FLASH Memory Programming functions #####

 ===============================================================================   

    [..]

      This group includes the following functions:

      (+) void FLASH_Unlock(void)

      (+) void FLASH_Lock(void)

      (+) FLASH_Status FLASH_EraseSector(uint32_t FLASH_Sector, uint8_t VoltageRange)

      (+) FLASH_Status FLASH_EraseAllSectors(uint8_t VoltageRange)       

      (+) FLASH_Status FLASH_ProgramDoubleWord(uint32_t Address, uint64_t Data)

      (+) FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data)

      (+) FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)

      (+) FLASH_Status FLASH_ProgramByte(uint32_t Address, uint8_t Data)  

    [..]   

      Any operation of erase or program should follow these steps:

      (#) Call the FLASH_Unlock() function to enable the FLASH control register access

      (#) Call the desired function to erase sector(s) or program data

      (#) Call the FLASH_Lock() function to disable the FLASH control register access

          (recommended to protect the FLASH memory against possible unwanted operation)

@endverbatim

  * @{

  */

/**

  * @brief  Unlocks the FLASH control register access

  * @param  None

  * @retval None

  */

void FLASH_Unlock(void)

{

  if((FLASH->CR & FLASH_CR_LOCK) != RESET)

  {

    /* Authorize the FLASH Registers access */

    FLASH->KEYR = FLASH_KEY1;

    FLASH->KEYR = FLASH_KEY2;

  }  

}

/**

  * @brief  Locks the FLASH control register access

  * @param  None

  * @retval None

  */

void FLASH_Lock(void)

{

  /* Set the LOCK Bit to lock the FLASH Registers access */

  FLASH->CR |= FLASH_CR_LOCK;

}

/**

  * @brief  Erases a specified FLASH Sector.

  *

  * @note   If an erase and a program operations are requested simustaneously,    

  *         the erase operation is performed before the program one.

  *   

  * @param  FLASH_Sector: The Sector number to be erased.

  *          For STM32F40xx/41xx devices this parameter can be a value between  

  *          FLASH_Sector_0 and FLASH_Sector_11.

  *          For STM32F427x/437x devices this parameter can be a value between 

  *          FLASH_Sector_0 and FLASH_Sector_23.          

  *    

  * @param  VoltageRange: The device voltage range which defines the erase parallelism.  

  *          This parameter can be one of the following values:

  *            @arg VoltageRange_1: when the device voltage range is 1.8V to 2.1V, 

  *                                  the operation will be done by byte (8-bit) 

  *            @arg VoltageRange_2: when the device voltage range is 2.1V to 2.7V,

  *                                  the operation will be done by half word (16-bit)

  *            @arg VoltageRange_3: when the device voltage range is 2.7V to 3.6V,

  *                                  the operation will be done by word (32-bit)

  *            @arg VoltageRange_4: when the device voltage range is 2.7V to 3.6V + External Vpp, 

  *                                  the operation will be done by double word (64-bit)

  *       

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_EraseSector(uint32_t FLASH_Sector, uint8_t VoltageRange)

{

  uint32_t tmp_psize = 0x0;

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_FLASH_SECTOR(FLASH_Sector));

  assert_param(IS_VOLTAGERANGE(VoltageRange));

  if(VoltageRange == VoltageRange_1)

  {

     tmp_psize = FLASH_PSIZE_BYTE;

  }

  else if(VoltageRange == VoltageRange_2)

  {

    tmp_psize = FLASH_PSIZE_HALF_WORD;

  }

  else if(VoltageRange == VoltageRange_3)

  {

    tmp_psize = FLASH_PSIZE_WORD;

  }

  else

  {

    tmp_psize = FLASH_PSIZE_DOUBLE_WORD;

  }

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  { 

    /* if the previous operation is completed, proceed to erase the sector */

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= tmp_psize;

    FLASH->CR &= SECTOR_MASK;

    FLASH->CR |= FLASH_CR_SER | FLASH_Sector;

    FLASH->CR |= FLASH_CR_STRT;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the erase operation is completed, disable the SER Bit */

    FLASH->CR &= (~FLASH_CR_SER);

    FLASH->CR &= SECTOR_MASK; 

  }

  /* Return the Erase Status */

  return status;

}

/**

  * @brief  Erases all FLASH Sectors.

  *

  * @note   If an erase and a program operations are requested simustaneously,    

  *         the erase operation is performed before the program one.

  *  

  * @param  VoltageRange: The device voltage range which defines the erase parallelism.  

  *          This parameter can be one of the following values:

  *            @arg VoltageRange_1: when the device voltage range is 1.8V to 2.1V, 

  *                                  the operation will be done by byte (8-bit) 

  *            @arg VoltageRange_2: when the device voltage range is 2.1V to 2.7V,

  *                                  the operation will be done by half word (16-bit)

  *            @arg VoltageRange_3: when the device voltage range is 2.7V to 3.6V,

  *                                  the operation will be done by word (32-bit)

  *            @arg VoltageRange_4: when the device voltage range is 2.7V to 3.6V + External Vpp, 

  *                                  the operation will be done by double word (64-bit)

  *       

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_EraseAllSectors(uint8_t VoltageRange)

{

#if defined (STM32F427X)  || (STM32F40XX)

  uint32_t tmp_psize = 0x0;

#endif

  FLASH_Status status = FLASH_COMPLETE;

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  assert_param(IS_VOLTAGERANGE(VoltageRange));

#if defined (STM32F427X)  || (STM32F40XX)

  if(VoltageRange == VoltageRange_1)

  {

     tmp_psize = FLASH_PSIZE_BYTE;

  }

  else if(VoltageRange == VoltageRange_2)

  {

    tmp_psize = FLASH_PSIZE_HALF_WORD;

  }

  else if(VoltageRange == VoltageRange_3)

  {

    tmp_psize = FLASH_PSIZE_WORD;

  }

  else

  {

    tmp_psize = FLASH_PSIZE_DOUBLE_WORD;

  }  

#endif

  if(status == FLASH_COMPLETE)

  {

    /* if the previous operation is completed, proceed to erase all sectors */

#if defined (STM32F427X)   

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= tmp_psize;

    FLASH->CR |= (FLASH_CR_MER1 | FLASH_CR_MER2);

    FLASH->CR |= FLASH_CR_STRT;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the erase operation is completed, disable the MER Bit */

    FLASH->CR &= ~(FLASH_CR_MER1 | FLASH_CR_MER2);

#endif /* STM32F427X */

#ifdef STM32F40XX

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= tmp_psize;

    FLASH->CR |= FLASH_CR_MER;

    FLASH->CR |= FLASH_CR_STRT;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the erase operation is completed, disable the MER Bit */

    FLASH->CR &= (~FLASH_CR_MER);

#endif /* STM32F40XX */

  }   

  /* Return the Erase Status */

  return status;

}

/**

  * @brief  Programs a double word (64-bit) at a specified address.

  * @note   This function must be used when the device voltage range is from

  *         2.7V to 3.6V and an External Vpp is present.

  *

  * @note   If an erase and a program operations are requested simustaneously,    

  *         the erase operation is performed before the program one.

  *  

  * @param  Address: specifies the address to be programmed.

  * @param  Data: specifies the data to be programmed.

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_ProgramDoubleWord(uint32_t Address, uint64_t Data)

{

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_FLASH_ADDRESS(Address));

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  {

    /* if the previous operation is completed, proceed to program the new data */

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= FLASH_PSIZE_DOUBLE_WORD;

    FLASH->CR |= FLASH_CR_PG;

    *(__IO uint64_t*)Address = Data;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the program operation is completed, disable the PG Bit */

    FLASH->CR &= (~FLASH_CR_PG);

  } 

  /* Return the Program Status */

  return status;

}

/**

  * @brief  Programs a word (32-bit) at a specified address.

  *

  * @note   This function must be used when the device voltage range is from 2.7V to 3.6V. 

  *

  * @note   If an erase and a program operations are requested simustaneously,    

  *         the erase operation is performed before the program one.

  *  

  * @param  Address: specifies the address to be programmed.

  *         This parameter can be any address in Program memory zone or in OTP zone.  

  * @param  Data: specifies the data to be programmed.

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data)

{

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_FLASH_ADDRESS(Address));

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  {

    /* if the previous operation is completed, proceed to program the new data */

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= FLASH_PSIZE_WORD;

    FLASH->CR |= FLASH_CR_PG;

    *(__IO uint32_t*)Address = Data;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the program operation is completed, disable the PG Bit */

    FLASH->CR &= (~FLASH_CR_PG);

  } 

  /* Return the Program Status */

  return status;

}

/**

  * @brief  Programs a half word (16-bit) at a specified address. 

  * @note   This function must be used when the device voltage range is from 2.1V to 3.6V. 

  *

  * @note   If an erase and a program operations are requested simustaneously,    

  *         the erase operation is performed before the program one.

  * 

  * @param  Address: specifies the address to be programmed.

  *         This parameter can be any address in Program memory zone or in OTP zone.  

  * @param  Data: specifies the data to be programmed.

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)

{

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_FLASH_ADDRESS(Address));

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  {

    /* if the previous operation is completed, proceed to program the new data */

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= FLASH_PSIZE_HALF_WORD;

    FLASH->CR |= FLASH_CR_PG;

    *(__IO uint16_t*)Address = Data;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the program operation is completed, disable the PG Bit */

    FLASH->CR &= (~FLASH_CR_PG);

  } 

  /* Return the Program Status */

  return status;

}

/**

  * @brief  Programs a byte (8-bit) at a specified address.

  * @note   This function can be used within all the device supply voltage ranges.  

  *

  * @note   If an erase and a program operations are requested simustaneously,    

  *         the erase operation is performed before the program one.

  * 

  * @param  Address: specifies the address to be programmed.

  *         This parameter can be any address in Program memory zone or in OTP zone.  

  * @param  Data: specifies the data to be programmed.

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_ProgramByte(uint32_t Address, uint8_t Data)

{

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_FLASH_ADDRESS(Address));

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  {

    /* if the previous operation is completed, proceed to program the new data */

    FLASH->CR &= CR_PSIZE_MASK;

    FLASH->CR |= FLASH_PSIZE_BYTE;

    FLASH->CR |= FLASH_CR_PG;

    *(__IO uint8_t*)Address = Data;

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation();

    /* if the program operation is completed, disable the PG Bit */

    FLASH->CR &= (~FLASH_CR_PG);

  } 

  /* Return the Program Status */

  return status;

}

/**

  * @}

  */

/** @defgroup FLASH_Group3 Option Bytes Programming functions

 *  @brief   Option Bytes Programming functions 

 *

@verbatim   

 ===============================================================================

                ##### Option Bytes Programming functions #####

 ===============================================================================  

    [..]

      This group includes the following functions:

      (+) void FLASH_OB_Unlock(void)

      (+) void FLASH_OB_Lock(void)

      (+) void FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState)

      (+) void FLASH_OB_WRP1Config(uint32_t OB_WRP, FunctionalState NewState)  

      (+) void FLASH_OB_RDPConfig(uint8_t OB_RDP)

      (+) void FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)

      (+) void FLASH_OB_BORConfig(uint8_t OB_BOR)

      (+) FLASH_Status FLASH_ProgramOTP(uint32_t Address, uint32_t Data)                                                        

      (+) FLASH_Status FLASH_OB_Launch(void)

      (+) uint32_t FLASH_OB_GetUser(void)                                                

      (+) uint8_t FLASH_OB_GetWRP(void)

      (+) uint8_t FLASH_OB_GetWRP1(void)                                                  

      (+) uint8_t FLASH_OB_GetRDP(void)                                                        

      (+) uint8_t FLASH_OB_GetBOR(void)

    [..]   

     Any operation of erase or program should follow these steps:

      (#) Call the FLASH_OB_Unlock() function to enable the FLASH option control 

          register access

      (#) Call one or several functions to program the desired Option Bytes:

        (++) void FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState) 

             => to Enable/Disable the desired sector write protection

        (++) void FLASH_OB_RDPConfig(uint8_t OB_RDP) => to set the desired read 

             Protection Level

        (++) void FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY) 

             => to configure the user Option Bytes.

        (++) void FLASH_OB_BORConfig(uint8_t OB_BOR) => to set the BOR Level                          

      (#) Once all needed Option Bytes to be programmed are correctly written, 

          call the FLASH_OB_Launch() function to launch the Option Bytes 

          programming process.

      -@- When changing the IWDG mode from HW to SW or from SW to HW, a system 

          reset is needed to make the change effective.  

      (#) Call the FLASH_OB_Lock() function to disable the FLASH option control 

          register access (recommended to protect the Option Bytes against 

          possible unwanted operations)

@endverbatim

  * @{

  */

/**

  * @brief  Unlocks the FLASH Option Control Registers access.

  * @param  None

  * @retval None

  */

void FLASH_OB_Unlock(void)

{

  if((FLASH->OPTCR & FLASH_OPTCR_OPTLOCK) != RESET)

  {

    /* Authorizes the Option Byte register programming */

    FLASH->OPTKEYR = FLASH_OPT_KEY1;

    FLASH->OPTKEYR = FLASH_OPT_KEY2;

  }  

}

/**

  * @brief  Locks the FLASH Option Control Registers access.

  * @param  None

  * @retval None

  */

void FLASH_OB_Lock(void)

{

  /* Set the OPTLOCK Bit to lock the FLASH Option Byte Registers access */

  FLASH->OPTCR |= FLASH_OPTCR_OPTLOCK;

}

/**

  * @brief  Enables or disables the write protection of the desired sectors

  *

  * @note   When the memory read protection level is selected (RDP level = 1), 

  *         it is not possible to program or erase the flash sector i if CortexM4  

  *         debug features are connected or boot code is executed in RAM, even if nWRPi = 1 

  * @note   Active value of nWRPi bits is inverted when PCROP mode is active (SPRMOD =1).   

  * 

  * @param  OB_WRP: specifies the sector(s) to be write protected or unprotected.

  *          This parameter can be one of the following values:

  *            @arg OB_WRP: A value between OB_WRP_Sector0 and OB_WRP_Sector11                      

  *            @arg OB_WRP_Sector_All

  * @param  Newstate: new state of the Write Protection.

  *          This parameter can be: ENABLE or DISABLE.

  * @retval None  

  */

void FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState)

{ 

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_OB_WRP(OB_WRP));

  assert_param(IS_FUNCTIONAL_STATE(NewState));

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  { 

    if(NewState != DISABLE)

    {

      *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS &= (~OB_WRP);

    }

    else

    {

      *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS |= (uint16_t)OB_WRP;

    }

  }

}

/**

  * @brief  Enables or disables the write protection of the desired sectors

  * @note   This function can be used only for STM32F427x/437x devices.

  * @note   When the memory read out protection is selected (RDP level = 1), 

  *         it is not possible to program or erase the flash sector i if CortexM4  

  *         debug features are connected or boot code is executed in RAM, even if nWRPi = 1 

  * @note   Active value of nWRPi bits is inverted when PCROP mode is active (SPRMOD =1).      

  * 

  * @param  OB_WRP: specifies the sector(s) to be write protected or unprotected.

  *          This parameter can be one of the following values:

  *            @arg OB_WRP: A value between OB_WRP_Sector12 and OB_WRP_Sector23

  *            @arg OB_WRP_Sector_All                        

  * @param  Newstate: new state of the Write Protection.

  *          This parameter can be: ENABLE or DISABLE.

  * @retval None  

  */

void FLASH_OB_WRP1Config(uint32_t OB_WRP, FunctionalState NewState)

{ 

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_OB_WRP(OB_WRP));

  assert_param(IS_FUNCTIONAL_STATE(NewState));

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  { 

    if(NewState != DISABLE)

    {

      *(__IO uint16_t*)OPTCR1_BYTE2_ADDRESS &= (~OB_WRP);

    }

    else

    {

      *(__IO uint16_t*)OPTCR1_BYTE2_ADDRESS |= (uint16_t)OB_WRP;

    }

  }

}

/**

  * @brief  Sets the read protection level.

  * @param  OB_RDP: specifies the read protection level.

  *          This parameter can be one of the following values:

  *            @arg OB_RDP_Level_0: No protection

  *            @arg OB_RDP_Level_1: Read protection of the memory

  *            @arg OB_RDP_Level_2: Full chip protection

  *   

  * !!!Warning!!! When enabling OB_RDP level 2 it's no more possible to go back to level 1 or 0

  *    

  * @retval None

  */

void FLASH_OB_RDPConfig(uint8_t OB_RDP)

{

  FLASH_Status status = FLASH_COMPLETE;

  /* Check the parameters */

  assert_param(IS_OB_RDP(OB_RDP));

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  {

    *(__IO uint8_t*)OPTCR_BYTE1_ADDRESS = OB_RDP;

  }

}

/**

  * @brief  Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY.    

  * @param  OB_IWDG: Selects the IWDG mode

  *          This parameter can be one of the following values:

  *            @arg OB_IWDG_SW: Software IWDG selected

  *            @arg OB_IWDG_HW: Hardware IWDG selected

  * @param  OB_STOP: Reset event when entering STOP mode.

  *          This parameter  can be one of the following values:

  *            @arg OB_STOP_NoRST: No reset generated when entering in STOP

  *            @arg OB_STOP_RST: Reset generated when entering in STOP

  * @param  OB_STDBY: Reset event when entering Standby mode.

  *          This parameter  can be one of the following values:

  *            @arg OB_STDBY_NoRST: No reset generated when entering in STANDBY

  *            @arg OB_STDBY_RST: Reset generated when entering in STANDBY

  * @retval None

  */

void FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)

{

  uint8_t optiontmp = 0xFF;

  FLASH_Status status = FLASH_COMPLETE; 

  /* Check the parameters */

  assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));

  assert_param(IS_OB_STOP_SOURCE(OB_STOP));

  assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  if(status == FLASH_COMPLETE)

  { 

    /* Mask OPTLOCK, OPTSTRT and BOR_LEV bits */

    optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS) & (uint8_t)0x0F); 

    /* Update User Option Byte */

    *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS = OB_IWDG | (uint8_t)(OB_STDBY | (uint8_t)(OB_STOP | ((uint8_t)optiontmp))); 

  }  

}

/**

  * @brief  Sets the BOR Level. 

  * @param  OB_BOR: specifies the Option Bytes BOR Reset Level.

  *          This parameter can be one of the following values:

  *            @arg OB_BOR_LEVEL3: Supply voltage ranges from 2.7 to 3.6 V

  *            @arg OB_BOR_LEVEL2: Supply voltage ranges from 2.4 to 2.7 V

  *            @arg OB_BOR_LEVEL1: Supply voltage ranges from 2.1 to 2.4 V

  *            @arg OB_BOR_OFF: Supply voltage ranges from 1.62 to 2.1 V

  * @retval None

  */

void FLASH_OB_BORConfig(uint8_t OB_BOR)

{

  /* Check the parameters */

  assert_param(IS_OB_BOR(OB_BOR));

  /* Set the BOR Level */

  *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS &= (~FLASH_OPTCR_BOR_LEV);

  *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= OB_BOR;

}

/**

  * @brief  Launch the option byte loading.

  * @param  None

  * @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PROGRAM,

  *                       FLASH_ERROR_WRP, FLASH_ERROR_OPERATION or FLASH_COMPLETE.

  */

FLASH_Status FLASH_OB_Launch(void)

{

  FLASH_Status status = FLASH_COMPLETE;

  /* Set the OPTSTRT bit in OPTCR register */

  *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT;

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation();

  return status;

}

/**

  * @brief  Returns the FLASH User Option Bytes values.

  * @param  None

  * @retval The FLASH User Option Bytes values: IWDG_SW(Bit0), RST_STOP(Bit1)

  *         and RST_STDBY(Bit2).

  */

uint8_t FLASH_OB_GetUser(void)

{

  /* Return the User Option Byte */

  return (uint8_t)(FLASH->OPTCR >> 5);

}

/**

  * @brief  Returns the FLASH Write Protection Option Bytes value.

  * @param  None

  * @retval The FLASH Write Protection  Option Bytes value

  */

uint16_t FLASH_OB_GetWRP(void)

{

  /* Return the FLASH write protection Register value */

  return (*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS));

}

/**

  * @brief  Returns the FLASH Write Protection Option Bytes value.

  * @note   This function can be used only for STM32F427x/437x devices.  

  * @param  None

  * @retval The FLASH Write Protection  Option Bytes value

  */

uint16_t FLASH_OB_GetWRP1(void)

{

  /* Return the FLASH write protection Register value */

  return (*(__IO uint16_t *)(OPTCR1_BYTE2_ADDRESS));

}

/**

  * @brief  Returns the FLASH Read Protection level.

  * @param  None

  * @retval FLASH ReadOut Protection Status:

  *           - SET, when OB_RDP_Level_1 or OB_RDP_Level_2 is set

  *           - RESET, when OB_RDP_Level_0 is set

  */

FlagStatus FLASH_OB_GetRDP(void)

{

  FlagStatus readstatus = RESET;

  if ((*(__IO uint8_t*)(OPTCR_BYTE1_ADDRESS) != (uint8_t)OB_RDP_Level_0))

  {

    readstatus = SET;

  }

  else

  {

    readstatus = RESET;

  }

  return readstatus;

}

/**

  * @brief  Returns the FLASH BOR level.

  * @param  None

  * @retval The FLASH BOR level:

  *           - OB_BOR_LEVEL3: Supply voltage ranges from 2.7 to 3.6 V

  *           - OB_BOR_LEVEL2: Supply voltage ranges from 2.4 to 2.7 V

  *           - OB_BOR_LEVEL1: Supply voltage ranges from 2.1 to 2.4 V

  *           - OB_BOR_OFF   : Supply voltage ranges from 1.62 to 2.1 V  

  */

uint8_t FLASH_OB_GetBOR(void)

{

  /* Return the FLASH BOR level */

  return (uint8_t)(*(__IO uint8_t *)(OPTCR_BYTE0_ADDRESS) & (uint8_t)0x0C);

}

/**

  * @}

  */

/** @defgroup FLASH_Group4 Interrupts and flags management functions

 *  @brief   Interrupts and flags management functions

 *

@verbatim   

 ===============================================================================

              ##### Interrupts and flags management functions #####

 ===============================================================================  

@endverbatim

  * @{

  */

/**

  * @brief  Enables or disables the specified FLASH interrupts.

  * @param  FLASH_IT: specifies the FLASH interrupt sources to be enabled or disabled.

  *          This parameter can be any combination of the following values:

  *            @arg FLASH_IT_ERR: FLASH Error Interrupt

  *            @arg FLASH_IT_EOP: FLASH end of operation Interrupt

  * @retval None 

  */

void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState)

{

  /* Check the parameters */

  assert_param(IS_FLASH_IT(FLASH_IT)); 

  assert_param(IS_FUNCTIONAL_STATE(NewState));