Subversion Repositories DashDisplay

/**

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

  * @file    stm32f1xx_hal_flash_ex.c

  * @author  MCD Application Team

  * @version V1.0.1

  * @date    31-July-2015

  * @brief   Extended FLASH HAL module driver.

  *    

  *          This file provides firmware functions to manage the following

  *          functionalities of the FLASH peripheral:

  *           + Extended Initialization/de-initialization functions

  *           + Extended I/O operation functions

  *           + Extended Peripheral Control functions

  *        

  @verbatim

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

               ##### Flash peripheral extended features  #####

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

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

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

  [..] This driver provides functions to configure and program the FLASH memory

       of all STM32F1xxx devices. It includes

        (++) Set/Reset the write protection

        (++) Program the user Option Bytes

        (++) Get the Read protection Level

  @endverbatim

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

  * @attention

  *

  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>

  *

  * Redistribution and use in source and binary forms, with or without modification,

  * are permitted provided that the following conditions are met:

  *   1. Redistributions of source code must retain the above copyright notice,

  *      this list of conditions and the following disclaimer.

  *   2. Redistributions in binary form must reproduce the above copyright notice,

  *      this list of conditions and the following disclaimer in the documentation

  *      and/or other materials provided with the distribution.

  *   3. Neither the name of STMicroelectronics nor the names of its contributors

  *      may be used to endorse or promote products derived from this software

  *      without specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  *

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

  */

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

#include "stm32f1xx_hal.h"

/** @addtogroup STM32F1xx_HAL_Driver

  * @{

  */

#ifdef HAL_FLASH_MODULE_ENABLED

/** @addtogroup FLASH

  * @{

  */

/** @addtogroup FLASH_Private_Variables

 * @{

 */

/* Variables used for Erase pages under interruption*/

extern FLASH_ProcessTypeDef pFlash;

/**

  * @}

  */

/**

  * @}

  */

/** @defgroup FLASHEx FLASHEx

  * @brief FLASH Extended HAL module driver

  * @{

  */

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

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

/** @defgroup FLASHEx_Private_Constants FLASHEx Private Constants

 * @{

 */

#define FLASH_POSITION_IWDGSW_BIT   (uint32_t)POSITION_VAL(FLASH_OBR_IWDG_SW)

/**

  * @}

  */

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

/** @defgroup FLASHEx_Private_Macros FLASHEx Private Macros

  * @{

  */

/**

  * @}

  */

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

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

/** @defgroup FLASHEx_Private_Functions FLASHEx Private Functions

 * @{

 */

/* Erase operations */

static void              FLASH_MassErase(uint32_t Banks);

/* Option bytes control */

static HAL_StatusTypeDef FLASH_OB_EnableWRP(uint32_t WriteProtectPage);

static HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WriteProtectPage);

static HAL_StatusTypeDef FLASH_OB_RDP_LevelConfig(uint8_t ReadProtectLevel);

static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t UserConfig);

static HAL_StatusTypeDef FLASH_OB_ProgramData(uint32_t Address, uint8_t Data);

static uint32_t          FLASH_OB_GetWRP(void);

static uint32_t          FLASH_OB_GetRDP(void);

static uint8_t           FLASH_OB_GetUser(void);

/**

  * @}

  */

/* Exported functions ---------------------------------------------------------*/

/** @defgroup FLASHEx_Exported_Functions FLASHEx Exported Functions

  * @{

  */

/** @defgroup FLASHEx_Exported_Functions_Group1 Extended Input and Output operation functions

  * @brief      I/O operation functions

  *

@verbatim  

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

                      ##### IO operation functions #####

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

@endverbatim

  * @{

  */

/**

  * @brief  Perform a mass erase or erase the specified FLASH memory pages

  * @note   The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface

  *         The function HAL_FLASH_Lock() should be called after to lock the FLASH interface

  * @param[in]  pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that

  *         contains the configuration information for the erasing.

  *

  * @param[out]  PageError: pointer to variable  that

  *         contains the configuration information on faulty page in case of error

  *         (0xFFFFFFFF means that all the pages have been correctly erased)

  *

  * @retval HAL_StatusTypeDef HAL Status

  */

HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)

{

  HAL_StatusTypeDef status = HAL_ERROR;

  uint32_t address = 0;

  /* Process Locked */

  __HAL_LOCK(&pFlash);

  /* Check the parameters */

  assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));

  if (pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)

  {

#if defined(FLASH_BANK2_END)

    if (pEraseInit->Banks == FLASH_BANK_BOTH)

    {

      /* Mass Erase requested for Bank1 and Bank2 */

      /* Wait for last operation to be completed */

      if ((FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK) && \

          (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK))

      {

        /*Mass erase to be done*/

        FLASH_MassErase(FLASH_BANK_BOTH);

        /* Wait for last operation to be completed */

        if ((FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK) && \

            (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK))

        {

          status = HAL_OK;

        }

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

        CLEAR_BIT(FLASH->CR, FLASH_CR_MER);

        CLEAR_BIT(FLASH->CR2, FLASH_CR2_MER);

      }

    }

    else if (pEraseInit->Banks == FLASH_BANK_2)

    {

      /* Mass Erase requested for Bank2 */

      /* Wait for last operation to be completed */

      if (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)

      {

        /*Mass erase to be done*/

        FLASH_MassErase(FLASH_BANK_2);

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE);

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

        CLEAR_BIT(FLASH->CR2, FLASH_CR2_MER);

      }

    }

    else

#endif /* FLASH_BANK2_END */

    {

      /* Mass Erase requested for Bank1 */

      /* Wait for last operation to be completed */

      if (FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)

      {

        /*Mass erase to be done*/

        FLASH_MassErase(FLASH_BANK_1);

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

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

        CLEAR_BIT(FLASH->CR, FLASH_CR_MER);

      }

    }

  }

  else

  {

    /* Page Erase is requested */

    /* Check the parameters */

    assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));

    assert_param(IS_FLASH_NB_PAGES(pEraseInit->PageAddress, pEraseInit->NbPages));

#if defined(FLASH_BANK2_END)

    /* Page Erase requested on address located on bank2 */

    if(pEraseInit->PageAddress > FLASH_BANK1_END)

    {  

      /* Wait for last operation to be completed */

      if (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)

      {

        /*Initialization of PageError variable*/

        *PageError = 0xFFFFFFFF;

        /* Erase by page by page to be done*/

        for(address = pEraseInit->PageAddress;

            address < (pEraseInit->PageAddress + (pEraseInit->NbPages)*FLASH_PAGE_SIZE);

            address += FLASH_PAGE_SIZE)

        {

          FLASH_PageErase(address);

          /* Wait for last operation to be completed */

          status = FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE);

          /* If the erase operation is completed, disable the PER Bit */

          CLEAR_BIT(FLASH->CR2, FLASH_CR2_PER);

          if (status != HAL_OK)

          {

            /* In case of error, stop erase procedure and return the faulty address */

            *PageError = address;

            break;

          }

        }

      }

    }

    else

#endif /* FLASH_BANK2_END */

    {

      /* Page Erase requested on address located on bank1 */

      /* Wait for last operation to be completed */

      if (FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)

      {

        /*Initialization of PageError variable*/

        *PageError = 0xFFFFFFFF;

        /* Erase by page by page to be done*/

        for(address = pEraseInit->PageAddress;

            address < (pEraseInit->PageAddress + (pEraseInit->NbPages)*FLASH_PAGE_SIZE);

            address += FLASH_PAGE_SIZE)

        {

          FLASH_PageErase(address);

          /* Wait for last operation to be completed */

          status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

          /* If the erase operation is completed, disable the PER Bit */

          CLEAR_BIT(FLASH->CR, FLASH_CR_PER);

          if (status != HAL_OK)

          {

            /* In case of error, stop erase procedure and return the faulty address */

            *PageError = address;

            break;

          }

        }

      }

    }

  }

  /* Process Unlocked */

  __HAL_UNLOCK(&pFlash);

  return status;

}

/**

  * @brief  Perform a mass erase or erase the specified FLASH memory sectors with interrupt enabled

  * @note   The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface

  *         The function HAL_FLASH_Lock() should be called after to lock the FLASH interface

  * @param  pEraseInit: pointer to an FLASH_EraseInitTypeDef structure that

  *         contains the configuration information for the erasing.

  *

  * @retval HAL_StatusTypeDef HAL Status

  */

HAL_StatusTypeDef HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef *pEraseInit)

{

  HAL_StatusTypeDef status = HAL_OK;

  /* Process Locked */

  __HAL_LOCK(&pFlash);

  /* If procedure already ongoing, reject the next one */

  if (pFlash.ProcedureOnGoing != FLASH_PROC_NONE)

  {

    return HAL_ERROR;

  }

  /* Check the parameters */

  assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));

  /* Enable End of FLASH Operation and Error source interrupts */

  __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR);

#if defined(FLASH_BANK2_END)

  /* Enable End of FLASH Operation and Error source interrupts */

  __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP_BANK2 | FLASH_IT_ERR_BANK2);

#endif

  if (pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)

  {

    /*Mass erase to be done*/

    pFlash.ProcedureOnGoing = FLASH_PROC_MASSERASE;

        FLASH_MassErase(pEraseInit->Banks);

  }

  else

  {

    /* Erase by page to be done*/

    /* Check the parameters */

    assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));

    assert_param(IS_FLASH_NB_PAGES(pEraseInit->PageAddress, pEraseInit->NbPages));

    pFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE;

    pFlash.DataRemaining = pEraseInit->NbPages;

    pFlash.Address = pEraseInit->PageAddress;

    /*Erase 1st page and wait for IT*/

    FLASH_PageErase(pEraseInit->PageAddress);

  }

  return status;

}

/**

  * @}

  */

/** @defgroup FLASHEx_Exported_Functions_Group2 Extended Peripheral Control functions

  * @brief      Peripheral Control functions

  *

@verbatim  

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

                      ##### Peripheral Control functions #####

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

    [..]

    This subsection provides a set of functions allowing to control the FLASH

    memory operations.

@endverbatim

  * @{

  */

/**

  * @brief  Erases the FLASH option bytes.

  * @note   This functions erases all option bytes except the Read protection (RDP).

  *         The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface

  *         The function HAL_FLASH_OB_Unlock() should be called before to unlock the options bytes

  *         The function HAL_FLASH_OB_Launch() should be called after to force the reload of the options bytes

  *         (system reset will occur)

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_FLASHEx_OBErase(void)

{

  uint8_t rdptmp = OB_RDP_LEVEL_0;

  HAL_StatusTypeDef status = HAL_ERROR;

  /* Get the actual read protection Option Byte value */

  rdptmp = FLASH_OB_GetRDP();

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

  if(status == HAL_OK)

  {

    /* Clean the error context */

    pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;

    /* If the previous operation is completed, proceed to erase the option bytes */

    SET_BIT(FLASH->CR, FLASH_CR_OPTER);

    SET_BIT(FLASH->CR, FLASH_CR_STRT);

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

    /* If the erase operation is completed, disable the OPTER Bit */

    CLEAR_BIT(FLASH->CR, FLASH_CR_OPTER);

    if(status == HAL_OK)

    {

      /* Restore the last read protection Option Byte value */

      status = FLASH_OB_RDP_LevelConfig(rdptmp);

    }

  }

  /* Return the erase status */

  return status;

}

/**

  * @brief  Program option bytes

  * @note   The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface

  *         The function HAL_FLASH_OB_Unlock() should be called before to unlock the options bytes

  *         The function HAL_FLASH_OB_Launch() should be called after to force the reload of the options bytes

  *         (system reset will occur)

  *

  * @param  pOBInit: pointer to an FLASH_OBInitStruct structure that

  *         contains the configuration information for the programming.

  *

  * @retval HAL_StatusTypeDef HAL Status

  */

HAL_StatusTypeDef HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef *pOBInit)

{

  HAL_StatusTypeDef status = HAL_ERROR;

  /* Check the parameters */

  assert_param(IS_OPTIONBYTE(pOBInit->OptionType));

  /* Write protection configuration */

  if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP)

  {

    assert_param(IS_WRPSTATE(pOBInit->WRPState));

    if (pOBInit->WRPState == OB_WRPSTATE_ENABLE)

    {

      /* Enable of Write protection on the selected page */

      status = FLASH_OB_EnableWRP(pOBInit->WRPPage);

    }

    else

    {

      /* Disable of Write protection on the selected page */

      status = FLASH_OB_DisableWRP(pOBInit->WRPPage);

    }

  }

  /* Read protection configuration */

  if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP)

  {

    status = FLASH_OB_RDP_LevelConfig(pOBInit->RDPLevel);

  }

  /* USER configuration */

  if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER)

  {

    status = FLASH_OB_UserConfig(pOBInit->USERConfig);

  }

  /* DATA configuration*/

  if((pOBInit->OptionType & OPTIONBYTE_DATA) == OPTIONBYTE_DATA)

  {

    status = FLASH_OB_ProgramData(pOBInit->DATAAddress, pOBInit->DATAData);

  }

  return status;

}

/**

  * @brief  Get the Option byte configuration

  * @param  pOBInit: pointer to an FLASH_OBInitStruct structure that

  *         contains the configuration information for the programming.

  *

  * @retval None

  */

void HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef *pOBInit)

{

  pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER;

  /*Get WRP*/

  pOBInit->WRPPage = FLASH_OB_GetWRP();

  /*Get RDP Level*/

  pOBInit->RDPLevel = FLASH_OB_GetRDP();

  /*Get USER*/

  pOBInit->USERConfig = FLASH_OB_GetUser();

}

/**

  * @}

  */

/**

  * @}

  */

/** @addtogroup FLASHEx_Private_Functions

 * @{

 */

/**

  * @brief  Full erase of FLASH memory Bank

  * @param  Banks: Banks to be erased

  *          This parameter can be one of the following values:

  *            @arg FLASH_BANK_1: Bank1 to be erased

  *            @arg FLASH_BANK_2: Bank2 to be erased

  *            @arg FLASH_BANK_BOTH: Bank1 and Bank2 to be erased

  *

  * @retval None

  */

static void FLASH_MassErase(uint32_t Banks)

{

  /* Check the parameters */

  assert_param(IS_FLASH_BANK(Banks));

  /* Clean the error context */

  pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;

#if defined(FLASH_BANK2_END)

  if(Banks == FLASH_BANK_BOTH)

  {

    /* bank1 & bank2 will be erased*/

    SET_BIT(FLASH->CR, FLASH_CR_MER);

    SET_BIT(FLASH->CR2, FLASH_CR2_MER);

    SET_BIT(FLASH->CR, FLASH_CR_STRT);

    SET_BIT(FLASH->CR2, FLASH_CR2_STRT);

  }

  else if(Banks == FLASH_BANK_2)

  {

    /*Only bank2 will be erased*/

    SET_BIT(FLASH->CR2, FLASH_CR2_MER);

    SET_BIT(FLASH->CR2, FLASH_CR2_STRT);

  }

  else

  {

#endif /* FLASH_BANK2_END */

    /* Only bank1 will be erased*/

    SET_BIT(FLASH->CR, FLASH_CR_MER);

    SET_BIT(FLASH->CR, FLASH_CR_STRT);

#if defined(FLASH_BANK2_END)

  }

#endif /* FLASH_BANK2_END */

}

/**

  * @brief  Enable the write protection of the desired pages

  * @note   An option byte erase is done automatically in this function.

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

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

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

  *

  * @param  WriteProtectPage: specifies the page(s) to be write protected.

  *         The value of this parameter depend on device used within the same series

  * @retval HAL status

  */

static HAL_StatusTypeDef FLASH_OB_EnableWRP(uint32_t WriteProtectPage)

{

  HAL_StatusTypeDef status = HAL_OK;

  uint16_t WRP0_Data = 0xFFFF;

#if defined(FLASH_WRP1_WRP1)

  uint16_t WRP1_Data = 0xFFFF;

#endif /* FLASH_WRP1_WRP1 */

#if defined(FLASH_WRP2_WRP2)

  uint16_t WRP2_Data = 0xFFFF;

#endif /* FLASH_WRP2_WRP2 */

#if defined(FLASH_WRP3_WRP3)

  uint16_t WRP3_Data = 0xFFFF;

#endif /* FLASH_WRP3_WRP3 */

  /* Check the parameters */

  assert_param(IS_OB_WRP(WriteProtectPage));

  /* Get current write protected pages and the new pages to be protected ******/

  WriteProtectPage = (uint32_t)(~((~FLASH_OB_GetWRP()) | WriteProtectPage));

#if defined(OB_WRP_PAGES0TO15MASK)

  WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO15MASK);

#elif defined(OB_WRP_PAGES0TO31MASK)

  WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO31MASK);

#endif /* OB_WRP_PAGES0TO31MASK */

#if defined(OB_WRP_PAGES16TO31MASK)

  WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES16TO31MASK) >> 8);

#elif defined(OB_WRP_PAGES32TO63MASK)

  WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO63MASK) >> 8);

#endif /* OB_WRP_PAGES32TO63MASK */

#if defined(OB_WRP_PAGES64TO95MASK)

  WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES64TO95MASK) >> 16);

#endif /* OB_WRP_PAGES64TO95MASK */

#if defined(OB_WRP_PAGES32TO47MASK)

  WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO47MASK) >> 16);

#endif /* OB_WRP_PAGES32TO47MASK */

#if defined(OB_WRP_PAGES96TO127MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES96TO127MASK) >> 24);

#elif defined(OB_WRP_PAGES48TO255MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO255MASK) >> 24);

#elif defined(OB_WRP_PAGES48TO511MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO511MASK) >> 24);

#elif defined(OB_WRP_PAGES48TO127MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO127MASK) >> 24);

#endif /* OB_WRP_PAGES96TO127MASK */

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

  if(status == HAL_OK)

  {

    /* Clean the error context */

    pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;

    /* To be able to write again option byte, need to perform a option byte erase */

    status = HAL_FLASHEx_OBErase();

    if (status == HAL_OK)  

    {

      /* Enable write protection */

      SET_BIT(FLASH->CR, FLASH_CR_OPTPG);

#if defined(FLASH_WRP0_WRP0)

      if(WRP0_Data != 0xFF)

      {

        OB->WRP0 &= WRP0_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP0_WRP0 */

#if defined(FLASH_WRP1_WRP1)

      if((status == HAL_OK) && (WRP1_Data != 0xFF))

      {

        OB->WRP1 &= WRP1_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP1_WRP1 */

#if defined(FLASH_WRP2_WRP2)

      if((status == HAL_OK) && (WRP2_Data != 0xFF))

      {

        OB->WRP2 &= WRP2_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP2_WRP2 */

#if defined(FLASH_WRP3_WRP3)

      if((status == HAL_OK) && (WRP3_Data != 0xFF))

      {

        OB->WRP3 &= WRP3_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP3_WRP3 */

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

      CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);

    }

  }

  return status;

}

/**

  * @brief  Disable the write protection of the desired pages

  * @note   An option byte erase is done automatically in this function.

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

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

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

  *

  * @param  WriteProtectPage: specifies the page(s) to be write unprotected.

  *         The value of this parameter depend on device used within the same series

  * @retval HAL status

  */

static HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WriteProtectPage)

{

  HAL_StatusTypeDef status = HAL_OK;

  uint16_t WRP0_Data = 0xFFFF;

#if defined(FLASH_WRP1_WRP1)

  uint16_t WRP1_Data = 0xFFFF;

#endif /* FLASH_WRP1_WRP1 */

#if defined(FLASH_WRP2_WRP2)

  uint16_t WRP2_Data = 0xFFFF;

#endif /* FLASH_WRP2_WRP2 */

#if defined(FLASH_WRP3_WRP3)

  uint16_t WRP3_Data = 0xFFFF;

#endif /* FLASH_WRP3_WRP3 */

  /* Check the parameters */

  assert_param(IS_OB_WRP(WriteProtectPage));

  /* Get current write protected pages and the new pages to be unprotected ******/

  WriteProtectPage = (FLASH_OB_GetWRP() | WriteProtectPage);

#if defined(OB_WRP_PAGES0TO15MASK)

  WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO15MASK);

#elif defined(OB_WRP_PAGES0TO31MASK)

  WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO31MASK);

#endif /* OB_WRP_PAGES0TO31MASK */

#if defined(OB_WRP_PAGES16TO31MASK)

  WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES16TO31MASK) >> 8);

#elif defined(OB_WRP_PAGES32TO63MASK)

  WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO63MASK) >> 8);

#endif /* OB_WRP_PAGES32TO63MASK */

#if defined(OB_WRP_PAGES64TO95MASK)

  WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES64TO95MASK) >> 16);

#endif /* OB_WRP_PAGES64TO95MASK */

#if defined(OB_WRP_PAGES32TO47MASK)

  WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO47MASK) >> 16);

#endif /* OB_WRP_PAGES32TO47MASK */

#if defined(OB_WRP_PAGES96TO127MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES96TO127MASK) >> 24);

#elif defined(OB_WRP_PAGES48TO255MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO255MASK) >> 24);

#elif defined(OB_WRP_PAGES48TO511MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO511MASK) >> 24);

#elif defined(OB_WRP_PAGES48TO127MASK)

  WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO127MASK) >> 24);

#endif /* OB_WRP_PAGES96TO127MASK */

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

  if(status == HAL_OK)

  {

    /* Clean the error context */

    pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;

    /* To be able to write again option byte, need to perform a option byte erase */

    status = HAL_FLASHEx_OBErase();

    if (status == HAL_OK)  

    {

      SET_BIT(FLASH->CR, FLASH_CR_OPTPG);

#if defined(FLASH_WRP0_WRP0)

      if(WRP0_Data != 0xFF)

      {

        OB->WRP0 |= WRP0_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP0_WRP0 */

#if defined(FLASH_WRP1_WRP1)

      if((status == HAL_OK) && (WRP1_Data != 0xFF))

      {

        OB->WRP1 |= WRP1_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP1_WRP1 */

#if defined(FLASH_WRP2_WRP2)

      if((status == HAL_OK) && (WRP2_Data != 0xFF))

      {

        OB->WRP2 |= WRP2_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP2_WRP2 */

#if defined(FLASH_WRP3_WRP3)

      if((status == HAL_OK) && (WRP3_Data != 0xFF))

      {

        OB->WRP3 |= WRP3_Data;

        /* Wait for last operation to be completed */

        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

      }

#endif /* FLASH_WRP3_WRP3 */

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

      CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);

    }

  }

  return status;

}

/**

  * @brief  Set the read protection level.

  * @param  ReadProtectLevel: 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

  * @retval HAL status

  */

static HAL_StatusTypeDef FLASH_OB_RDP_LevelConfig(uint8_t ReadProtectLevel)

{

  HAL_StatusTypeDef status = HAL_OK;

  /* Check the parameters */

  assert_param(IS_OB_RDP_LEVEL(ReadProtectLevel));

  /* Wait for last operation to be completed */

  status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

  if(status == HAL_OK)

  {

    /* Clean the error context */

    pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;

    /* If the previous operation is completed, proceed to erase the option bytes */

    SET_BIT(FLASH->CR, FLASH_CR_OPTER);

    SET_BIT(FLASH->CR, FLASH_CR_STRT);

    /* Wait for last operation to be completed */

    status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

    /* If the erase operation is completed, disable the OPTER Bit */

    CLEAR_BIT(FLASH->CR, FLASH_CR_OPTER);

    if(status == HAL_OK)

    {

      /* Enable the Option Bytes Programming operation */

      SET_BIT(FLASH->CR, FLASH_CR_OPTPG);

      WRITE_REG(OB->RDP, ReadProtectLevel);

      /* Wait for last operation to be completed */

      status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);

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

      CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);

    }

  }

  return status;

}

/**

  * @brief  Program the FLASH User Option Byte.    

  * @note   Programming of the OB should be performed only after an erase (otherwise PGERR occurs)

  * @param  UserConfig: The FLASH User Option Bytes values: FLASH_OBR_IWDG_SW(Bit2),

  *         FLASH_OBR_nRST_STOP(Bit3),FLASH_OBR_nRST_STDBY(Bit4).

  *         And BFBF2(Bit5) for STM32F101xG and STM32F103xG .

  * @retval HAL status

  */

static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t UserConfig)

{

  HAL_StatusTypeDef status = HAL_OK;

  /* Check the parameters */

  assert_param(IS_OB_IWDG_SOURCE((UserConfig&OB_IWDG_SW)));