mbed-src - mbed library sources

Users » moirans2 » Code » mbed-src

gabriel della-monica / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_flash_ex.c@354:e67efb2aab0e, 2014-10-16 (annotated)

Committer:: mbed_official
Date:: Thu Oct 16 15:00:10 2014 +0100
Revision:: 354:e67efb2aab0e

Synchronized with git revision 36a8882a54cbf25645fa6e11af937c8b8048e184

Full URL: https://github.com/mbedmicro/mbed/commit/36a8882a54cbf25645fa6e11af937c8b8048e184/

Targets: NUCLEO_L152RE - Migration to STM32Cube driver (CMSIS and HAL)

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	14 Jan 2015
Imports:	4
Forks:	0
Commits:	446
Dependents:	0
Dependencies:	0
Followers:	1

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_flash_ex.c@354:e67efb2aab0e, 2014-10-16 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning