WebSVN – DashDisplay – Blame – /branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_flash_ex.c

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

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_flash_ex.c – Rev 77