1 /**
2 ******************************************************************************
3 * @file stm32f1xx_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 FLASH peripheral:
9 * + Extended Initialization/de-initialization functions
10 * + Extended I/O operation functions
11 * + Extended Peripheral Control functions
12 *
13 @verbatim
14 ==============================================================================
15 ##### Flash peripheral extended features #####
16 ==============================================================================
17
18 ##### How to use this driver #####
19 ==============================================================================
20 [..] This driver provides functions to configure and program the FLASH memory
21 of all STM32F1xxx devices. It includes
22
23 (++) Set/Reset the write protection
24 (++) Program the user Option Bytes
25 (++) Get the Read protection Level
26
27 @endverbatim
28 ******************************************************************************
29 * @attention
30 *
31 * <h2><center>© Copyright (c) 2016 STMicroelectronics.
32 * All rights reserved.</center></h2>
33 *
34 * This software component is licensed by ST under BSD 3-Clause license,
35 * the "License"; You may not use this file except in compliance with the
36 * License. You may obtain a copy of the License at:
37 * opensource.org/licenses/BSD-3-Clause
38 *
39 ******************************************************************************
40 */
41
42 /* Includes ------------------------------------------------------------------*/
43 #include "stm32f1xx_hal.h"
44
45 /** @addtogroup STM32F1xx_HAL_Driver
46 * @{
47 */
48 #ifdef HAL_FLASH_MODULE_ENABLED
49
50 /** @addtogroup FLASH
51 * @{
52 */
53 /** @addtogroup FLASH_Private_Variables
54 * @{
55 */
56 /* Variables used for Erase pages under interruption*/
57 extern FLASH_ProcessTypeDef pFlash;
58 /**
59 * @}
60 */
61
62 /**
63 * @}
64 */
65
66 /** @defgroup FLASHEx FLASHEx
67 * @brief FLASH HAL Extension module driver
68 * @{
69 */
70
71 /* Private typedef -----------------------------------------------------------*/
72 /* Private define ------------------------------------------------------------*/
73 /** @defgroup FLASHEx_Private_Constants FLASHEx Private Constants
74 * @{
75 */
76 #define FLASH_POSITION_IWDGSW_BIT FLASH_OBR_IWDG_SW_Pos
77 #define FLASH_POSITION_OB_USERDATA0_BIT FLASH_OBR_DATA0_Pos
78 #define FLASH_POSITION_OB_USERDATA1_BIT FLASH_OBR_DATA1_Pos
79 /**
80 * @}
81 */
82
83 /* Private macro -------------------------------------------------------------*/
84 /** @defgroup FLASHEx_Private_Macros FLASHEx Private Macros
85 * @{
86 */
87 /**
88 * @}
89 */
90
91 /* Private variables ---------------------------------------------------------*/
92 /* Private function prototypes -----------------------------------------------*/
93 /** @defgroup FLASHEx_Private_Functions FLASHEx Private Functions
94 * @{
95 */
96 /* Erase operations */
97 static void FLASH_MassErase(uint32_t Banks);
98 void FLASH_PageErase(uint32_t PageAddress);
99
100 /* Option bytes control */
101 static HAL_StatusTypeDef FLASH_OB_EnableWRP(uint32_t WriteProtectPage);
102 static HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WriteProtectPage);
103 static HAL_StatusTypeDef FLASH_OB_RDP_LevelConfig(uint8_t ReadProtectLevel);
104 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t UserConfig);
105 static HAL_StatusTypeDef FLASH_OB_ProgramData(uint32_t Address, uint8_t Data);
106 static uint32_t FLASH_OB_GetWRP(void);
107 static uint32_t FLASH_OB_GetRDP(void);
108 static uint8_t FLASH_OB_GetUser(void);
109
110 /**
111 * @}
112 */
113
114 /* Exported functions ---------------------------------------------------------*/
115 /** @defgroup FLASHEx_Exported_Functions FLASHEx Exported Functions
116 * @{
117 */
118
119 /** @defgroup FLASHEx_Exported_Functions_Group1 FLASHEx Memory Erasing functions
120 * @brief FLASH Memory Erasing functions
121 *
122 @verbatim
123 ==============================================================================
124 ##### FLASH Erasing Programming functions #####
125 ==============================================================================
126
127 [..] The FLASH Memory Erasing functions, includes the following functions:
128 (+) @ref HAL_FLASHEx_Erase: return only when erase has been done
129 (+) @ref HAL_FLASHEx_Erase_IT: end of erase is done when @ref HAL_FLASH_EndOfOperationCallback
130 is called with parameter 0xFFFFFFFF
131
132 [..] Any operation of erase should follow these steps:
133 (#) Call the @ref HAL_FLASH_Unlock() function to enable the flash control register and
134 program memory access.
135 (#) Call the desired function to erase page.
136 (#) Call the @ref HAL_FLASH_Lock() to disable the flash program memory access
137 (recommended to protect the FLASH memory against possible unwanted operation).
138
139 @endverbatim
140 * @{
141 */
142
143
144 /**
145 * @brief Perform a mass erase or erase the specified FLASH memory pages
146 * @note To correctly run this function, the @ref HAL_FLASH_Unlock() function
147 * must be called before.
148 * Call the @ref HAL_FLASH_Lock() to disable the flash memory access
149 * (recommended to protect the FLASH memory against possible unwanted operation)
150 * @param[in] pEraseInit pointer to an FLASH_EraseInitTypeDef structure that
151 * contains the configuration information for the erasing.
152 *
153 * @param[out] PageError pointer to variable that
154 * contains the configuration information on faulty page in case of error
155 * (0xFFFFFFFF means that all the pages have been correctly erased)
156 *
157 * @retval HAL_StatusTypeDef HAL Status
158 */
HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef * pEraseInit,uint32_t * PageError)159 HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)
160 {
161 HAL_StatusTypeDef status = HAL_ERROR;
162 uint32_t address = 0U;
163
164 /* Process Locked */
165 __HAL_LOCK(&pFlash);
166
167 /* Check the parameters */
168 assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
169
170 if (pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
171 {
172 #if defined(FLASH_BANK2_END)
173 if (pEraseInit->Banks == FLASH_BANK_BOTH)
174 {
175 /* Mass Erase requested for Bank1 and Bank2 */
176 /* Wait for last operation to be completed */
177 if ((FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK) && \
178 (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK))
179 {
180 /*Mass erase to be done*/
181 FLASH_MassErase(FLASH_BANK_BOTH);
182
183 /* Wait for last operation to be completed */
184 if ((FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK) && \
185 (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK))
186 {
187 status = HAL_OK;
188 }
189
190 /* If the erase operation is completed, disable the MER Bit */
191 CLEAR_BIT(FLASH->CR, FLASH_CR_MER);
192 CLEAR_BIT(FLASH->CR2, FLASH_CR2_MER);
193 }
194 }
195 else if (pEraseInit->Banks == FLASH_BANK_2)
196 {
197 /* Mass Erase requested for Bank2 */
198 /* Wait for last operation to be completed */
199 if (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)
200 {
201 /*Mass erase to be done*/
202 FLASH_MassErase(FLASH_BANK_2);
203
204 /* Wait for last operation to be completed */
205 status = FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE);
206
207 /* If the erase operation is completed, disable the MER Bit */
208 CLEAR_BIT(FLASH->CR2, FLASH_CR2_MER);
209 }
210 }
211 else
212 #endif /* FLASH_BANK2_END */
213 {
214 /* Mass Erase requested for Bank1 */
215 /* Wait for last operation to be completed */
216 if (FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)
217 {
218 /*Mass erase to be done*/
219 FLASH_MassErase(FLASH_BANK_1);
220
221 /* Wait for last operation to be completed */
222 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
223
224 /* If the erase operation is completed, disable the MER Bit */
225 CLEAR_BIT(FLASH->CR, FLASH_CR_MER);
226 }
227 }
228 }
229 else
230 {
231 /* Page Erase is requested */
232 /* Check the parameters */
233 assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));
234 assert_param(IS_FLASH_NB_PAGES(pEraseInit->PageAddress, pEraseInit->NbPages));
235
236 #if defined(FLASH_BANK2_END)
237 /* Page Erase requested on address located on bank2 */
238 if(pEraseInit->PageAddress > FLASH_BANK1_END)
239 {
240 /* Wait for last operation to be completed */
241 if (FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)
242 {
243 /*Initialization of PageError variable*/
244 *PageError = 0xFFFFFFFFU;
245
246 /* Erase by page by page to be done*/
247 for(address = pEraseInit->PageAddress;
248 address < (pEraseInit->PageAddress + (pEraseInit->NbPages)*FLASH_PAGE_SIZE);
249 address += FLASH_PAGE_SIZE)
250 {
251 FLASH_PageErase(address);
252
253 /* Wait for last operation to be completed */
254 status = FLASH_WaitForLastOperationBank2((uint32_t)FLASH_TIMEOUT_VALUE);
255
256 /* If the erase operation is completed, disable the PER Bit */
257 CLEAR_BIT(FLASH->CR2, FLASH_CR2_PER);
258
259 if (status != HAL_OK)
260 {
261 /* In case of error, stop erase procedure and return the faulty address */
262 *PageError = address;
263 break;
264 }
265 }
266 }
267 }
268 else
269 #endif /* FLASH_BANK2_END */
270 {
271 /* Page Erase requested on address located on bank1 */
272 /* Wait for last operation to be completed */
273 if (FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE) == HAL_OK)
274 {
275 /*Initialization of PageError variable*/
276 *PageError = 0xFFFFFFFFU;
277
278 /* Erase page by page to be done*/
279 for(address = pEraseInit->PageAddress;
280 address < ((pEraseInit->NbPages * FLASH_PAGE_SIZE) + pEraseInit->PageAddress);
281 address += FLASH_PAGE_SIZE)
282 {
283 FLASH_PageErase(address);
284
285 /* Wait for last operation to be completed */
286 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
287
288 /* If the erase operation is completed, disable the PER Bit */
289 CLEAR_BIT(FLASH->CR, FLASH_CR_PER);
290
291 if (status != HAL_OK)
292 {
293 /* In case of error, stop erase procedure and return the faulty address */
294 *PageError = address;
295 break;
296 }
297 }
298 }
299 }
300 }
301
302 /* Process Unlocked */
303 __HAL_UNLOCK(&pFlash);
304
305 return status;
306 }
307
308 /**
309 * @brief Perform a mass erase or erase the specified FLASH memory pages with interrupt enabled
310 * @note To correctly run this function, the @ref HAL_FLASH_Unlock() function
311 * must be called before.
312 * Call the @ref HAL_FLASH_Lock() to disable the flash memory access
313 * (recommended to protect the FLASH memory against possible unwanted operation)
314 * @param pEraseInit pointer to an FLASH_EraseInitTypeDef structure that
315 * contains the configuration information for the erasing.
316 *
317 * @retval HAL_StatusTypeDef HAL Status
318 */
HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef * pEraseInit)319 HAL_StatusTypeDef HAL_FLASHEx_Erase_IT(FLASH_EraseInitTypeDef *pEraseInit)
320 {
321 HAL_StatusTypeDef status = HAL_OK;
322
323 /* Process Locked */
324 __HAL_LOCK(&pFlash);
325
326 /* If procedure already ongoing, reject the next one */
327 if (pFlash.ProcedureOnGoing != FLASH_PROC_NONE)
328 {
329 return HAL_ERROR;
330 }
331
332 /* Check the parameters */
333 assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
334
335 /* Enable End of FLASH Operation and Error source interrupts */
336 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR);
337
338 #if defined(FLASH_BANK2_END)
339 /* Enable End of FLASH Operation and Error source interrupts */
340 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP_BANK2 | FLASH_IT_ERR_BANK2);
341
342 #endif
343 if (pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
344 {
345 /*Mass erase to be done*/
346 pFlash.ProcedureOnGoing = FLASH_PROC_MASSERASE;
347 FLASH_MassErase(pEraseInit->Banks);
348 }
349 else
350 {
351 /* Erase by page to be done*/
352
353 /* Check the parameters */
354 assert_param(IS_FLASH_PROGRAM_ADDRESS(pEraseInit->PageAddress));
355 assert_param(IS_FLASH_NB_PAGES(pEraseInit->PageAddress, pEraseInit->NbPages));
356
357 pFlash.ProcedureOnGoing = FLASH_PROC_PAGEERASE;
358 pFlash.DataRemaining = pEraseInit->NbPages;
359 pFlash.Address = pEraseInit->PageAddress;
360
361 /*Erase 1st page and wait for IT*/
362 FLASH_PageErase(pEraseInit->PageAddress);
363 }
364
365 return status;
366 }
367
368 /**
369 * @}
370 */
371
372 /** @defgroup FLASHEx_Exported_Functions_Group2 Option Bytes Programming functions
373 * @brief Option Bytes Programming functions
374 *
375 @verbatim
376 ==============================================================================
377 ##### Option Bytes Programming functions #####
378 ==============================================================================
379 [..]
380 This subsection provides a set of functions allowing to control the FLASH
381 option bytes operations.
382
383 @endverbatim
384 * @{
385 */
386
387 /**
388 * @brief Erases the FLASH option bytes.
389 * @note This functions erases all option bytes except the Read protection (RDP).
390 * The function @ref HAL_FLASH_Unlock() should be called before to unlock the FLASH interface
391 * The function @ref HAL_FLASH_OB_Unlock() should be called before to unlock the options bytes
392 * The function @ref HAL_FLASH_OB_Launch() should be called after to force the reload of the options bytes
393 * (system reset will occur)
394 * @retval HAL status
395 */
396
HAL_FLASHEx_OBErase(void)397 HAL_StatusTypeDef HAL_FLASHEx_OBErase(void)
398 {
399 uint8_t rdptmp = OB_RDP_LEVEL_0;
400 HAL_StatusTypeDef status = HAL_ERROR;
401
402 /* Get the actual read protection Option Byte value */
403 rdptmp = FLASH_OB_GetRDP();
404
405 /* Wait for last operation to be completed */
406 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
407
408 if(status == HAL_OK)
409 {
410 /* Clean the error context */
411 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
412
413 /* If the previous operation is completed, proceed to erase the option bytes */
414 SET_BIT(FLASH->CR, FLASH_CR_OPTER);
415 SET_BIT(FLASH->CR, FLASH_CR_STRT);
416
417 /* Wait for last operation to be completed */
418 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
419
420 /* If the erase operation is completed, disable the OPTER Bit */
421 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTER);
422
423 if(status == HAL_OK)
424 {
425 /* Restore the last read protection Option Byte value */
426 status = FLASH_OB_RDP_LevelConfig(rdptmp);
427 }
428 }
429
430 /* Return the erase status */
431 return status;
432 }
433
434 /**
435 * @brief Program option bytes
436 * @note The function @ref HAL_FLASH_Unlock() should be called before to unlock the FLASH interface
437 * The function @ref HAL_FLASH_OB_Unlock() should be called before to unlock the options bytes
438 * The function @ref HAL_FLASH_OB_Launch() should be called after to force the reload of the options bytes
439 * (system reset will occur)
440 *
441 * @param pOBInit pointer to an FLASH_OBInitStruct structure that
442 * contains the configuration information for the programming.
443 *
444 * @retval HAL_StatusTypeDef HAL Status
445 */
HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef * pOBInit)446 HAL_StatusTypeDef HAL_FLASHEx_OBProgram(FLASH_OBProgramInitTypeDef *pOBInit)
447 {
448 HAL_StatusTypeDef status = HAL_ERROR;
449
450 /* Process Locked */
451 __HAL_LOCK(&pFlash);
452
453 /* Check the parameters */
454 assert_param(IS_OPTIONBYTE(pOBInit->OptionType));
455
456 /* Write protection configuration */
457 if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP)
458 {
459 assert_param(IS_WRPSTATE(pOBInit->WRPState));
460 if (pOBInit->WRPState == OB_WRPSTATE_ENABLE)
461 {
462 /* Enable of Write protection on the selected page */
463 status = FLASH_OB_EnableWRP(pOBInit->WRPPage);
464 }
465 else
466 {
467 /* Disable of Write protection on the selected page */
468 status = FLASH_OB_DisableWRP(pOBInit->WRPPage);
469 }
470 if (status != HAL_OK)
471 {
472 /* Process Unlocked */
473 __HAL_UNLOCK(&pFlash);
474 return status;
475 }
476 }
477
478 /* Read protection configuration */
479 if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP)
480 {
481 status = FLASH_OB_RDP_LevelConfig(pOBInit->RDPLevel);
482 if (status != HAL_OK)
483 {
484 /* Process Unlocked */
485 __HAL_UNLOCK(&pFlash);
486 return status;
487 }
488 }
489
490 /* USER configuration */
491 if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER)
492 {
493 status = FLASH_OB_UserConfig(pOBInit->USERConfig);
494 if (status != HAL_OK)
495 {
496 /* Process Unlocked */
497 __HAL_UNLOCK(&pFlash);
498 return status;
499 }
500 }
501
502 /* DATA configuration*/
503 if((pOBInit->OptionType & OPTIONBYTE_DATA) == OPTIONBYTE_DATA)
504 {
505 status = FLASH_OB_ProgramData(pOBInit->DATAAddress, pOBInit->DATAData);
506 if (status != HAL_OK)
507 {
508 /* Process Unlocked */
509 __HAL_UNLOCK(&pFlash);
510 return status;
511 }
512 }
513
514 /* Process Unlocked */
515 __HAL_UNLOCK(&pFlash);
516
517 return status;
518 }
519
520 /**
521 * @brief Get the Option byte configuration
522 * @param pOBInit pointer to an FLASH_OBInitStruct structure that
523 * contains the configuration information for the programming.
524 *
525 * @retval None
526 */
HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef * pOBInit)527 void HAL_FLASHEx_OBGetConfig(FLASH_OBProgramInitTypeDef *pOBInit)
528 {
529 pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER;
530
531 /*Get WRP*/
532 pOBInit->WRPPage = FLASH_OB_GetWRP();
533
534 /*Get RDP Level*/
535 pOBInit->RDPLevel = FLASH_OB_GetRDP();
536
537 /*Get USER*/
538 pOBInit->USERConfig = FLASH_OB_GetUser();
539 }
540
541 /**
542 * @brief Get the Option byte user data
543 * @param DATAAdress Address of the option byte DATA
544 * This parameter can be one of the following values:
545 * @arg @ref OB_DATA_ADDRESS_DATA0
546 * @arg @ref OB_DATA_ADDRESS_DATA1
547 * @retval Value programmed in USER data
548 */
HAL_FLASHEx_OBGetUserData(uint32_t DATAAdress)549 uint32_t HAL_FLASHEx_OBGetUserData(uint32_t DATAAdress)
550 {
551 uint32_t value = 0;
552
553 if (DATAAdress == OB_DATA_ADDRESS_DATA0)
554 {
555 /* Get value programmed in OB USER Data0 */
556 value = READ_BIT(FLASH->OBR, FLASH_OBR_DATA0) >> FLASH_POSITION_OB_USERDATA0_BIT;
557 }
558 else
559 {
560 /* Get value programmed in OB USER Data1 */
561 value = READ_BIT(FLASH->OBR, FLASH_OBR_DATA1) >> FLASH_POSITION_OB_USERDATA1_BIT;
562 }
563
564 return value;
565 }
566
567 /**
568 * @}
569 */
570
571 /**
572 * @}
573 */
574
575 /** @addtogroup FLASHEx_Private_Functions
576 * @{
577 */
578
579 /**
580 * @brief Full erase of FLASH memory Bank
581 * @param Banks Banks to be erased
582 * This parameter can be one of the following values:
583 * @arg @ref FLASH_BANK_1 Bank1 to be erased
584 @if STM32F101xG
585 * @arg @ref FLASH_BANK_2 Bank2 to be erased
586 * @arg @ref FLASH_BANK_BOTH Bank1 and Bank2 to be erased
587 @endif
588 @if STM32F103xG
589 * @arg @ref FLASH_BANK_2 Bank2 to be erased
590 * @arg @ref FLASH_BANK_BOTH Bank1 and Bank2 to be erased
591 @endif
592 *
593 * @retval None
594 */
FLASH_MassErase(uint32_t Banks)595 static void FLASH_MassErase(uint32_t Banks)
596 {
597 /* Check the parameters */
598 assert_param(IS_FLASH_BANK(Banks));
599
600 /* Clean the error context */
601 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
602
603 #if defined(FLASH_BANK2_END)
604 if(Banks == FLASH_BANK_BOTH)
605 {
606 /* bank1 & bank2 will be erased*/
607 SET_BIT(FLASH->CR, FLASH_CR_MER);
608 SET_BIT(FLASH->CR2, FLASH_CR2_MER);
609 SET_BIT(FLASH->CR, FLASH_CR_STRT);
610 SET_BIT(FLASH->CR2, FLASH_CR2_STRT);
611 }
612 else if(Banks == FLASH_BANK_2)
613 {
614 /*Only bank2 will be erased*/
615 SET_BIT(FLASH->CR2, FLASH_CR2_MER);
616 SET_BIT(FLASH->CR2, FLASH_CR2_STRT);
617 }
618 else
619 {
620 #endif /* FLASH_BANK2_END */
621 #if !defined(FLASH_BANK2_END)
622 /* Prevent unused argument(s) compilation warning */
623 UNUSED(Banks);
624 #endif /* FLASH_BANK2_END */
625 /* Only bank1 will be erased*/
626 SET_BIT(FLASH->CR, FLASH_CR_MER);
627 SET_BIT(FLASH->CR, FLASH_CR_STRT);
628 #if defined(FLASH_BANK2_END)
629 }
630 #endif /* FLASH_BANK2_END */
631 }
632
633 /**
634 * @brief Enable the write protection of the desired pages
635 * @note An option byte erase is done automatically in this function.
636 * @note When the memory read protection level is selected (RDP level = 1),
637 * it is not possible to program or erase the flash page i if
638 * debug features are connected or boot code is executed in RAM, even if nWRPi = 1
639 *
640 * @param WriteProtectPage specifies the page(s) to be write protected.
641 * The value of this parameter depend on device used within the same series
642 * @retval HAL status
643 */
FLASH_OB_EnableWRP(uint32_t WriteProtectPage)644 static HAL_StatusTypeDef FLASH_OB_EnableWRP(uint32_t WriteProtectPage)
645 {
646 HAL_StatusTypeDef status = HAL_OK;
647 uint16_t WRP0_Data = 0xFFFF;
648 #if defined(FLASH_WRP1_WRP1)
649 uint16_t WRP1_Data = 0xFFFF;
650 #endif /* FLASH_WRP1_WRP1 */
651 #if defined(FLASH_WRP2_WRP2)
652 uint16_t WRP2_Data = 0xFFFF;
653 #endif /* FLASH_WRP2_WRP2 */
654 #if defined(FLASH_WRP3_WRP3)
655 uint16_t WRP3_Data = 0xFFFF;
656 #endif /* FLASH_WRP3_WRP3 */
657
658 /* Check the parameters */
659 assert_param(IS_OB_WRP(WriteProtectPage));
660
661 /* Get current write protected pages and the new pages to be protected ******/
662 WriteProtectPage = (uint32_t)(~((~FLASH_OB_GetWRP()) | WriteProtectPage));
663
664 #if defined(OB_WRP_PAGES0TO15MASK)
665 WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO15MASK);
666 #elif defined(OB_WRP_PAGES0TO31MASK)
667 WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO31MASK);
668 #endif /* OB_WRP_PAGES0TO31MASK */
669
670 #if defined(OB_WRP_PAGES16TO31MASK)
671 WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES16TO31MASK) >> 8U);
672 #elif defined(OB_WRP_PAGES32TO63MASK)
673 WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO63MASK) >> 8U);
674 #endif /* OB_WRP_PAGES32TO63MASK */
675
676 #if defined(OB_WRP_PAGES64TO95MASK)
677 WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES64TO95MASK) >> 16U);
678 #endif /* OB_WRP_PAGES64TO95MASK */
679 #if defined(OB_WRP_PAGES32TO47MASK)
680 WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO47MASK) >> 16U);
681 #endif /* OB_WRP_PAGES32TO47MASK */
682
683 #if defined(OB_WRP_PAGES96TO127MASK)
684 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES96TO127MASK) >> 24U);
685 #elif defined(OB_WRP_PAGES48TO255MASK)
686 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO255MASK) >> 24U);
687 #elif defined(OB_WRP_PAGES48TO511MASK)
688 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO511MASK) >> 24U);
689 #elif defined(OB_WRP_PAGES48TO127MASK)
690 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO127MASK) >> 24U);
691 #endif /* OB_WRP_PAGES96TO127MASK */
692
693 /* Wait for last operation to be completed */
694 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
695
696 if(status == HAL_OK)
697 {
698 /* Clean the error context */
699 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
700
701 /* To be able to write again option byte, need to perform a option byte erase */
702 status = HAL_FLASHEx_OBErase();
703 if (status == HAL_OK)
704 {
705 /* Enable write protection */
706 SET_BIT(FLASH->CR, FLASH_CR_OPTPG);
707
708 #if defined(FLASH_WRP0_WRP0)
709 if(WRP0_Data != 0xFFU)
710 {
711 OB->WRP0 &= WRP0_Data;
712
713 /* Wait for last operation to be completed */
714 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
715 }
716 #endif /* FLASH_WRP0_WRP0 */
717
718 #if defined(FLASH_WRP1_WRP1)
719 if((status == HAL_OK) && (WRP1_Data != 0xFFU))
720 {
721 OB->WRP1 &= WRP1_Data;
722
723 /* Wait for last operation to be completed */
724 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
725 }
726 #endif /* FLASH_WRP1_WRP1 */
727
728 #if defined(FLASH_WRP2_WRP2)
729 if((status == HAL_OK) && (WRP2_Data != 0xFFU))
730 {
731 OB->WRP2 &= WRP2_Data;
732
733 /* Wait for last operation to be completed */
734 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
735 }
736 #endif /* FLASH_WRP2_WRP2 */
737
738 #if defined(FLASH_WRP3_WRP3)
739 if((status == HAL_OK) && (WRP3_Data != 0xFFU))
740 {
741 OB->WRP3 &= WRP3_Data;
742
743 /* Wait for last operation to be completed */
744 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
745 }
746 #endif /* FLASH_WRP3_WRP3 */
747
748 /* if the program operation is completed, disable the OPTPG Bit */
749 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);
750 }
751 }
752
753 return status;
754 }
755
756 /**
757 * @brief Disable the write protection of the desired pages
758 * @note An option byte erase is done automatically in this function.
759 * @note When the memory read protection level is selected (RDP level = 1),
760 * it is not possible to program or erase the flash page i if
761 * debug features are connected or boot code is executed in RAM, even if nWRPi = 1
762 *
763 * @param WriteProtectPage specifies the page(s) to be write unprotected.
764 * The value of this parameter depend on device used within the same series
765 * @retval HAL status
766 */
FLASH_OB_DisableWRP(uint32_t WriteProtectPage)767 static HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WriteProtectPage)
768 {
769 HAL_StatusTypeDef status = HAL_OK;
770 uint16_t WRP0_Data = 0xFFFF;
771 #if defined(FLASH_WRP1_WRP1)
772 uint16_t WRP1_Data = 0xFFFF;
773 #endif /* FLASH_WRP1_WRP1 */
774 #if defined(FLASH_WRP2_WRP2)
775 uint16_t WRP2_Data = 0xFFFF;
776 #endif /* FLASH_WRP2_WRP2 */
777 #if defined(FLASH_WRP3_WRP3)
778 uint16_t WRP3_Data = 0xFFFF;
779 #endif /* FLASH_WRP3_WRP3 */
780
781 /* Check the parameters */
782 assert_param(IS_OB_WRP(WriteProtectPage));
783
784 /* Get current write protected pages and the new pages to be unprotected ******/
785 WriteProtectPage = (FLASH_OB_GetWRP() | WriteProtectPage);
786
787 #if defined(OB_WRP_PAGES0TO15MASK)
788 WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO15MASK);
789 #elif defined(OB_WRP_PAGES0TO31MASK)
790 WRP0_Data = (uint16_t)(WriteProtectPage & OB_WRP_PAGES0TO31MASK);
791 #endif /* OB_WRP_PAGES0TO31MASK */
792
793 #if defined(OB_WRP_PAGES16TO31MASK)
794 WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES16TO31MASK) >> 8U);
795 #elif defined(OB_WRP_PAGES32TO63MASK)
796 WRP1_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO63MASK) >> 8U);
797 #endif /* OB_WRP_PAGES32TO63MASK */
798
799 #if defined(OB_WRP_PAGES64TO95MASK)
800 WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES64TO95MASK) >> 16U);
801 #endif /* OB_WRP_PAGES64TO95MASK */
802 #if defined(OB_WRP_PAGES32TO47MASK)
803 WRP2_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES32TO47MASK) >> 16U);
804 #endif /* OB_WRP_PAGES32TO47MASK */
805
806 #if defined(OB_WRP_PAGES96TO127MASK)
807 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES96TO127MASK) >> 24U);
808 #elif defined(OB_WRP_PAGES48TO255MASK)
809 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO255MASK) >> 24U);
810 #elif defined(OB_WRP_PAGES48TO511MASK)
811 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO511MASK) >> 24U);
812 #elif defined(OB_WRP_PAGES48TO127MASK)
813 WRP3_Data = (uint16_t)((WriteProtectPage & OB_WRP_PAGES48TO127MASK) >> 24U);
814 #endif /* OB_WRP_PAGES96TO127MASK */
815
816
817 /* Wait for last operation to be completed */
818 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
819
820 if(status == HAL_OK)
821 {
822 /* Clean the error context */
823 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
824
825 /* To be able to write again option byte, need to perform a option byte erase */
826 status = HAL_FLASHEx_OBErase();
827 if (status == HAL_OK)
828 {
829 SET_BIT(FLASH->CR, FLASH_CR_OPTPG);
830
831 #if defined(FLASH_WRP0_WRP0)
832 if(WRP0_Data != 0xFFU)
833 {
834 OB->WRP0 |= WRP0_Data;
835
836 /* Wait for last operation to be completed */
837 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
838 }
839 #endif /* FLASH_WRP0_WRP0 */
840
841 #if defined(FLASH_WRP1_WRP1)
842 if((status == HAL_OK) && (WRP1_Data != 0xFFU))
843 {
844 OB->WRP1 |= WRP1_Data;
845
846 /* Wait for last operation to be completed */
847 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
848 }
849 #endif /* FLASH_WRP1_WRP1 */
850
851 #if defined(FLASH_WRP2_WRP2)
852 if((status == HAL_OK) && (WRP2_Data != 0xFFU))
853 {
854 OB->WRP2 |= WRP2_Data;
855
856 /* Wait for last operation to be completed */
857 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
858 }
859 #endif /* FLASH_WRP2_WRP2 */
860
861 #if defined(FLASH_WRP3_WRP3)
862 if((status == HAL_OK) && (WRP3_Data != 0xFFU))
863 {
864 OB->WRP3 |= WRP3_Data;
865
866 /* Wait for last operation to be completed */
867 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
868 }
869 #endif /* FLASH_WRP3_WRP3 */
870
871 /* if the program operation is completed, disable the OPTPG Bit */
872 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);
873 }
874 }
875 return status;
876 }
877
878 /**
879 * @brief Set the read protection level.
880 * @param ReadProtectLevel specifies the read protection level.
881 * This parameter can be one of the following values:
882 * @arg @ref OB_RDP_LEVEL_0 No protection
883 * @arg @ref OB_RDP_LEVEL_1 Read protection of the memory
884 * @retval HAL status
885 */
FLASH_OB_RDP_LevelConfig(uint8_t ReadProtectLevel)886 static HAL_StatusTypeDef FLASH_OB_RDP_LevelConfig(uint8_t ReadProtectLevel)
887 {
888 HAL_StatusTypeDef status = HAL_OK;
889
890 /* Check the parameters */
891 assert_param(IS_OB_RDP_LEVEL(ReadProtectLevel));
892
893 /* Wait for last operation to be completed */
894 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
895
896 if(status == HAL_OK)
897 {
898 /* Clean the error context */
899 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
900
901 /* If the previous operation is completed, proceed to erase the option bytes */
902 SET_BIT(FLASH->CR, FLASH_CR_OPTER);
903 SET_BIT(FLASH->CR, FLASH_CR_STRT);
904
905 /* Wait for last operation to be completed */
906 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
907
908 /* If the erase operation is completed, disable the OPTER Bit */
909 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTER);
910
911 if(status == HAL_OK)
912 {
913 /* Enable the Option Bytes Programming operation */
914 SET_BIT(FLASH->CR, FLASH_CR_OPTPG);
915
916 WRITE_REG(OB->RDP, ReadProtectLevel);
917
918 /* Wait for last operation to be completed */
919 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
920
921 /* if the program operation is completed, disable the OPTPG Bit */
922 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);
923 }
924 }
925
926 return status;
927 }
928
929 /**
930 * @brief Program the FLASH User Option Byte.
931 * @note Programming of the OB should be performed only after an erase (otherwise PGERR occurs)
932 * @param UserConfig The FLASH User Option Bytes values FLASH_OBR_IWDG_SW(Bit2),
933 * FLASH_OBR_nRST_STOP(Bit3),FLASH_OBR_nRST_STDBY(Bit4).
934 * And BFBF2(Bit5) for STM32F101xG and STM32F103xG .
935 * @retval HAL status
936 */
FLASH_OB_UserConfig(uint8_t UserConfig)937 static HAL_StatusTypeDef FLASH_OB_UserConfig(uint8_t UserConfig)
938 {
939 HAL_StatusTypeDef status = HAL_OK;
940
941 /* Check the parameters */
942 assert_param(IS_OB_IWDG_SOURCE((UserConfig&OB_IWDG_SW)));
943 assert_param(IS_OB_STOP_SOURCE((UserConfig&OB_STOP_NO_RST)));
944 assert_param(IS_OB_STDBY_SOURCE((UserConfig&OB_STDBY_NO_RST)));
945 #if defined(FLASH_BANK2_END)
946 assert_param(IS_OB_BOOT1((UserConfig&OB_BOOT1_SET)));
947 #endif /* FLASH_BANK2_END */
948
949 /* Wait for last operation to be completed */
950 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
951
952 if(status == HAL_OK)
953 {
954 /* Clean the error context */
955 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
956
957 /* Enable the Option Bytes Programming operation */
958 SET_BIT(FLASH->CR, FLASH_CR_OPTPG);
959
960 #if defined(FLASH_BANK2_END)
961 OB->USER = (UserConfig | 0xF0U);
962 #else
963 OB->USER = (UserConfig | 0x88U);
964 #endif /* FLASH_BANK2_END */
965
966 /* Wait for last operation to be completed */
967 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
968
969 /* if the program operation is completed, disable the OPTPG Bit */
970 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);
971 }
972
973 return status;
974 }
975
976 /**
977 * @brief Programs a half word at a specified Option Byte Data address.
978 * @note The function @ref HAL_FLASH_Unlock() should be called before to unlock the FLASH interface
979 * The function @ref HAL_FLASH_OB_Unlock() should be called before to unlock the options bytes
980 * The function @ref HAL_FLASH_OB_Launch() should be called after to force the reload of the options bytes
981 * (system reset will occur)
982 * Programming of the OB should be performed only after an erase (otherwise PGERR occurs)
983 * @param Address specifies the address to be programmed.
984 * This parameter can be 0x1FFFF804 or 0x1FFFF806.
985 * @param Data specifies the data to be programmed.
986 * @retval HAL status
987 */
FLASH_OB_ProgramData(uint32_t Address,uint8_t Data)988 static HAL_StatusTypeDef FLASH_OB_ProgramData(uint32_t Address, uint8_t Data)
989 {
990 HAL_StatusTypeDef status = HAL_ERROR;
991
992 /* Check the parameters */
993 assert_param(IS_OB_DATA_ADDRESS(Address));
994
995 /* Wait for last operation to be completed */
996 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
997
998 if(status == HAL_OK)
999 {
1000 /* Clean the error context */
1001 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
1002
1003 /* Enables the Option Bytes Programming operation */
1004 SET_BIT(FLASH->CR, FLASH_CR_OPTPG);
1005 *(__IO uint16_t*)Address = Data;
1006
1007 /* Wait for last operation to be completed */
1008 status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
1009
1010 /* If the program operation is completed, disable the OPTPG Bit */
1011 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTPG);
1012 }
1013 /* Return the Option Byte Data Program Status */
1014 return status;
1015 }
1016
1017 /**
1018 * @brief Return the FLASH Write Protection Option Bytes value.
1019 * @retval The FLASH Write Protection Option Bytes value
1020 */
FLASH_OB_GetWRP(void)1021 static uint32_t FLASH_OB_GetWRP(void)
1022 {
1023 /* Return the FLASH write protection Register value */
1024 return (uint32_t)(READ_REG(FLASH->WRPR));
1025 }
1026
1027 /**
1028 * @brief Returns the FLASH Read Protection level.
1029 * @retval FLASH RDP level
1030 * This parameter can be one of the following values:
1031 * @arg @ref OB_RDP_LEVEL_0 No protection
1032 * @arg @ref OB_RDP_LEVEL_1 Read protection of the memory
1033 */
FLASH_OB_GetRDP(void)1034 static uint32_t FLASH_OB_GetRDP(void)
1035 {
1036 uint32_t readstatus = OB_RDP_LEVEL_0;
1037 uint32_t tmp_reg = 0U;
1038
1039 /* Read RDP level bits */
1040 tmp_reg = READ_BIT(FLASH->OBR, FLASH_OBR_RDPRT);
1041
1042 if (tmp_reg == FLASH_OBR_RDPRT)
1043 {
1044 readstatus = OB_RDP_LEVEL_1;
1045 }
1046 else
1047 {
1048 readstatus = OB_RDP_LEVEL_0;
1049 }
1050
1051 return readstatus;
1052 }
1053
1054 /**
1055 * @brief Return the FLASH User Option Byte value.
1056 * @retval The FLASH User Option Bytes values: FLASH_OBR_IWDG_SW(Bit2),
1057 * FLASH_OBR_nRST_STOP(Bit3),FLASH_OBR_nRST_STDBY(Bit4).
1058 * And FLASH_OBR_BFB2(Bit5) for STM32F101xG and STM32F103xG .
1059 */
FLASH_OB_GetUser(void)1060 static uint8_t FLASH_OB_GetUser(void)
1061 {
1062 /* Return the User Option Byte */
1063 return (uint8_t)((READ_REG(FLASH->OBR) & FLASH_OBR_USER) >> FLASH_POSITION_IWDGSW_BIT);
1064 }
1065
1066 /**
1067 * @}
1068 */
1069
1070 /**
1071 * @}
1072 */
1073
1074 /** @addtogroup FLASH
1075 * @{
1076 */
1077
1078 /** @addtogroup FLASH_Private_Functions
1079 * @{
1080 */
1081
1082 /**
1083 * @brief Erase the specified FLASH memory page
1084 * @param PageAddress FLASH page to erase
1085 * The value of this parameter depend on device used within the same series
1086 *
1087 * @retval None
1088 */
FLASH_PageErase(uint32_t PageAddress)1089 void FLASH_PageErase(uint32_t PageAddress)
1090 {
1091 /* Clean the error context */
1092 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
1093
1094 #if defined(FLASH_BANK2_END)
1095 if(PageAddress > FLASH_BANK1_END)
1096 {
1097 /* Proceed to erase the page */
1098 SET_BIT(FLASH->CR2, FLASH_CR2_PER);
1099 WRITE_REG(FLASH->AR2, PageAddress);
1100 SET_BIT(FLASH->CR2, FLASH_CR2_STRT);
1101 }
1102 else
1103 {
1104 #endif /* FLASH_BANK2_END */
1105 /* Proceed to erase the page */
1106 SET_BIT(FLASH->CR, FLASH_CR_PER);
1107 WRITE_REG(FLASH->AR, PageAddress);
1108 SET_BIT(FLASH->CR, FLASH_CR_STRT);
1109 #if defined(FLASH_BANK2_END)
1110 }
1111 #endif /* FLASH_BANK2_END */
1112 }
1113
1114 /**
1115 * @}
1116 */
1117
1118 /**
1119 * @}
1120 */
1121
1122 #endif /* HAL_FLASH_MODULE_ENABLED */
1123 /**
1124 * @}
1125 */
1126
1127 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
1128