Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_flash.c (29013B)
1 /** 2 ****************************************************************************** 3 * @file stm32f1xx_hal_flash.c 4 * @author MCD Application Team 5 * @brief FLASH HAL module driver. 6 * This file provides firmware functions to manage the following 7 * functionalities of the internal FLASH memory: 8 * + Program operations functions 9 * + Memory Control functions 10 * + Peripheral State functions 11 * 12 @verbatim 13 ============================================================================== 14 ##### FLASH peripheral features ##### 15 ============================================================================== 16 [..] The Flash memory interface manages CPU AHB I-Code and D-Code accesses 17 to the Flash memory. It implements the erase and program Flash memory operations 18 and the read and write protection mechanisms. 19 20 [..] The Flash memory interface accelerates code execution with a system of instruction 21 prefetch. 22 23 [..] The FLASH main features are: 24 (+) Flash memory read operations 25 (+) Flash memory program/erase operations 26 (+) Read / write protections 27 (+) Prefetch on I-Code 28 (+) Option Bytes programming 29 30 31 ##### How to use this driver ##### 32 ============================================================================== 33 [..] 34 This driver provides functions and macros to configure and program the FLASH 35 memory of all STM32F1xx devices. 36 37 (#) FLASH Memory I/O Programming functions: this group includes all needed 38 functions to erase and program the main memory: 39 (++) Lock and Unlock the FLASH interface 40 (++) Erase function: Erase page, erase all pages 41 (++) Program functions: half word, word and doubleword 42 (#) FLASH Option Bytes Programming functions: this group includes all needed 43 functions to manage the Option Bytes: 44 (++) Lock and Unlock the Option Bytes 45 (++) Set/Reset the write protection 46 (++) Set the Read protection Level 47 (++) Program the user Option Bytes 48 (++) Launch the Option Bytes loader 49 (++) Erase Option Bytes 50 (++) Program the data Option Bytes 51 (++) Get the Write protection. 52 (++) Get the user option bytes. 53 54 (#) Interrupts and flags management functions : this group 55 includes all needed functions to: 56 (++) Handle FLASH interrupts 57 (++) Wait for last FLASH operation according to its status 58 (++) Get error flag status 59 60 [..] In addition to these function, this driver includes a set of macros allowing 61 to handle the following operations: 62 63 (+) Set/Get the latency 64 (+) Enable/Disable the prefetch buffer 65 (+) Enable/Disable the half cycle access 66 (+) Enable/Disable the FLASH interrupts 67 (+) Monitor the FLASH flags status 68 69 @endverbatim 70 ****************************************************************************** 71 * @attention 72 * 73 * Copyright (c) 2016 STMicroelectronics. 74 * All rights reserved. 75 * 76 * This software is licensed under terms that can be found in the LICENSE file in 77 * the root directory of this software component. 78 * If no LICENSE file comes with this software, it is provided AS-IS. 79 ****************************************************************************** 80 */ 81 82 /* Includes ------------------------------------------------------------------*/ 83 #include "stm32f1xx_hal.h" 84 85 /** @addtogroup STM32F1xx_HAL_Driver 86 * @{ 87 */ 88 89 #ifdef HAL_FLASH_MODULE_ENABLED 90 91 /** @defgroup FLASH FLASH 92 * @brief FLASH HAL module driver 93 * @{ 94 */ 95 96 /* Private typedef -----------------------------------------------------------*/ 97 /* Private define ------------------------------------------------------------*/ 98 /** @defgroup FLASH_Private_Constants FLASH Private Constants 99 * @{ 100 */ 101 /** 102 * @} 103 */ 104 105 /* Private macro ---------------------------- ---------------------------------*/ 106 /** @defgroup FLASH_Private_Macros FLASH Private Macros 107 * @{ 108 */ 109 110 /** 111 * @} 112 */ 113 114 /* Private variables ---------------------------------------------------------*/ 115 /** @defgroup FLASH_Private_Variables FLASH Private Variables 116 * @{ 117 */ 118 /* Variables used for Erase pages under interruption*/ 119 FLASH_ProcessTypeDef pFlash; 120 /** 121 * @} 122 */ 123 124 /* Private function prototypes -----------------------------------------------*/ 125 /** @defgroup FLASH_Private_Functions FLASH Private Functions 126 * @{ 127 */ 128 static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data); 129 static void FLASH_SetErrorCode(void); 130 extern void FLASH_PageErase(uint32_t PageAddress); 131 /** 132 * @} 133 */ 134 135 /* Exported functions ---------------------------------------------------------*/ 136 /** @defgroup FLASH_Exported_Functions FLASH Exported Functions 137 * @{ 138 */ 139 140 /** @defgroup FLASH_Exported_Functions_Group1 Programming operation functions 141 * @brief Programming operation functions 142 * 143 @verbatim 144 @endverbatim 145 * @{ 146 */ 147 148 /** 149 * @brief Program halfword, word or double word at a specified address 150 * @note The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface 151 * The function HAL_FLASH_Lock() should be called after to lock the FLASH interface 152 * 153 * @note If an erase and a program operations are requested simultaneously, 154 * the erase operation is performed before the program one. 155 * 156 * @note FLASH should be previously erased before new programmation (only exception to this 157 * is when 0x0000 is programmed) 158 * 159 * @param TypeProgram: Indicate the way to program at a specified address. 160 * This parameter can be a value of @ref FLASH_Type_Program 161 * @param Address: Specifies the address to be programmed. 162 * @param Data: Specifies the data to be programmed 163 * 164 * @retval HAL_StatusTypeDef HAL Status 165 */ 166 HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint64_t Data) 167 { 168 HAL_StatusTypeDef status = HAL_ERROR; 169 uint8_t index = 0; 170 uint8_t nbiterations = 0; 171 172 /* Process Locked */ 173 __HAL_LOCK(&pFlash); 174 175 /* Check the parameters */ 176 assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram)); 177 assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); 178 179 #if defined(FLASH_BANK2_END) 180 if(Address <= FLASH_BANK1_END) 181 { 182 #endif /* FLASH_BANK2_END */ 183 /* Wait for last operation to be completed */ 184 status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); 185 #if defined(FLASH_BANK2_END) 186 } 187 else 188 { 189 /* Wait for last operation to be completed */ 190 status = FLASH_WaitForLastOperationBank2(FLASH_TIMEOUT_VALUE); 191 } 192 #endif /* FLASH_BANK2_END */ 193 194 if(status == HAL_OK) 195 { 196 if(TypeProgram == FLASH_TYPEPROGRAM_HALFWORD) 197 { 198 /* Program halfword (16-bit) at a specified address. */ 199 nbiterations = 1U; 200 } 201 else if(TypeProgram == FLASH_TYPEPROGRAM_WORD) 202 { 203 /* Program word (32-bit = 2*16-bit) at a specified address. */ 204 nbiterations = 2U; 205 } 206 else 207 { 208 /* Program double word (64-bit = 4*16-bit) at a specified address. */ 209 nbiterations = 4U; 210 } 211 212 for (index = 0U; index < nbiterations; index++) 213 { 214 FLASH_Program_HalfWord((Address + (2U*index)), (uint16_t)(Data >> (16U*index))); 215 216 #if defined(FLASH_BANK2_END) 217 if(Address <= FLASH_BANK1_END) 218 { 219 #endif /* FLASH_BANK2_END */ 220 /* Wait for last operation to be completed */ 221 status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); 222 223 /* If the program operation is completed, disable the PG Bit */ 224 CLEAR_BIT(FLASH->CR, FLASH_CR_PG); 225 #if defined(FLASH_BANK2_END) 226 } 227 else 228 { 229 /* Wait for last operation to be completed */ 230 status = FLASH_WaitForLastOperationBank2(FLASH_TIMEOUT_VALUE); 231 232 /* If the program operation is completed, disable the PG Bit */ 233 CLEAR_BIT(FLASH->CR2, FLASH_CR2_PG); 234 } 235 #endif /* FLASH_BANK2_END */ 236 /* In case of error, stop programation procedure */ 237 if (status != HAL_OK) 238 { 239 break; 240 } 241 } 242 } 243 244 /* Process Unlocked */ 245 __HAL_UNLOCK(&pFlash); 246 247 return status; 248 } 249 250 /** 251 * @brief Program halfword, word or double word at a specified address with interrupt enabled. 252 * @note The function HAL_FLASH_Unlock() should be called before to unlock the FLASH interface 253 * The function HAL_FLASH_Lock() should be called after to lock the FLASH interface 254 * 255 * @note If an erase and a program operations are requested simultaneously, 256 * the erase operation is performed before the program one. 257 * 258 * @param TypeProgram: Indicate the way to program at a specified address. 259 * This parameter can be a value of @ref FLASH_Type_Program 260 * @param Address: Specifies the address to be programmed. 261 * @param Data: Specifies the data to be programmed 262 * 263 * @retval HAL_StatusTypeDef HAL Status 264 */ 265 HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint64_t Data) 266 { 267 HAL_StatusTypeDef status = HAL_OK; 268 269 /* Check the parameters */ 270 assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram)); 271 assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); 272 273 #if defined(FLASH_BANK2_END) 274 /* If procedure already ongoing, reject the next one */ 275 if (pFlash.ProcedureOnGoing != FLASH_PROC_NONE) 276 { 277 return HAL_ERROR; 278 } 279 280 if(Address <= FLASH_BANK1_END) 281 { 282 /* Enable End of FLASH Operation and Error source interrupts */ 283 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP_BANK1 | FLASH_IT_ERR_BANK1); 284 285 }else 286 { 287 /* Enable End of FLASH Operation and Error source interrupts */ 288 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP_BANK2 | FLASH_IT_ERR_BANK2); 289 } 290 #else 291 /* Enable End of FLASH Operation and Error source interrupts */ 292 __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR); 293 #endif /* FLASH_BANK2_END */ 294 295 pFlash.Address = Address; 296 pFlash.Data = Data; 297 298 if(TypeProgram == FLASH_TYPEPROGRAM_HALFWORD) 299 { 300 pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAMHALFWORD; 301 /* Program halfword (16-bit) at a specified address. */ 302 pFlash.DataRemaining = 1U; 303 } 304 else if(TypeProgram == FLASH_TYPEPROGRAM_WORD) 305 { 306 pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAMWORD; 307 /* Program word (32-bit : 2*16-bit) at a specified address. */ 308 pFlash.DataRemaining = 2U; 309 } 310 else 311 { 312 pFlash.ProcedureOnGoing = FLASH_PROC_PROGRAMDOUBLEWORD; 313 /* Program double word (64-bit : 4*16-bit) at a specified address. */ 314 pFlash.DataRemaining = 4U; 315 } 316 317 /* Program halfword (16-bit) at a specified address. */ 318 FLASH_Program_HalfWord(Address, (uint16_t)Data); 319 320 return status; 321 } 322 323 /** 324 * @brief This function handles FLASH interrupt request. 325 * @retval None 326 */ 327 void HAL_FLASH_IRQHandler(void) 328 { 329 uint32_t addresstmp = 0U; 330 331 /* Check FLASH operation error flags */ 332 #if defined(FLASH_BANK2_END) 333 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR_BANK1) || __HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR_BANK1) || \ 334 (__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR_BANK2) || __HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR_BANK2))) 335 #else 336 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) ||__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR)) 337 #endif /* FLASH_BANK2_END */ 338 { 339 /* Return the faulty address */ 340 addresstmp = pFlash.Address; 341 /* Reset address */ 342 pFlash.Address = 0xFFFFFFFFU; 343 344 /* Save the Error code */ 345 FLASH_SetErrorCode(); 346 347 /* FLASH error interrupt user callback */ 348 HAL_FLASH_OperationErrorCallback(addresstmp); 349 350 /* Stop the procedure ongoing */ 351 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 352 } 353 354 /* Check FLASH End of Operation flag */ 355 #if defined(FLASH_BANK2_END) 356 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP_BANK1)) 357 { 358 /* Clear FLASH End of Operation pending bit */ 359 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP_BANK1); 360 #else 361 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP)) 362 { 363 /* Clear FLASH End of Operation pending bit */ 364 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP); 365 #endif /* FLASH_BANK2_END */ 366 367 /* Process can continue only if no error detected */ 368 if(pFlash.ProcedureOnGoing != FLASH_PROC_NONE) 369 { 370 if(pFlash.ProcedureOnGoing == FLASH_PROC_PAGEERASE) 371 { 372 /* Nb of pages to erased can be decreased */ 373 pFlash.DataRemaining--; 374 375 /* Check if there are still pages to erase */ 376 if(pFlash.DataRemaining != 0U) 377 { 378 addresstmp = pFlash.Address; 379 /*Indicate user which sector has been erased */ 380 HAL_FLASH_EndOfOperationCallback(addresstmp); 381 382 /*Increment sector number*/ 383 addresstmp = pFlash.Address + FLASH_PAGE_SIZE; 384 pFlash.Address = addresstmp; 385 386 /* If the erase operation is completed, disable the PER Bit */ 387 CLEAR_BIT(FLASH->CR, FLASH_CR_PER); 388 389 FLASH_PageErase(addresstmp); 390 } 391 else 392 { 393 /* No more pages to Erase, user callback can be called. */ 394 /* Reset Sector and stop Erase pages procedure */ 395 pFlash.Address = addresstmp = 0xFFFFFFFFU; 396 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 397 /* FLASH EOP interrupt user callback */ 398 HAL_FLASH_EndOfOperationCallback(addresstmp); 399 } 400 } 401 else if(pFlash.ProcedureOnGoing == FLASH_PROC_MASSERASE) 402 { 403 /* Operation is completed, disable the MER Bit */ 404 CLEAR_BIT(FLASH->CR, FLASH_CR_MER); 405 406 #if defined(FLASH_BANK2_END) 407 /* Stop Mass Erase procedure if no pending mass erase on other bank */ 408 if (HAL_IS_BIT_CLR(FLASH->CR2, FLASH_CR2_MER)) 409 { 410 #endif /* FLASH_BANK2_END */ 411 /* MassErase ended. Return the selected bank */ 412 /* FLASH EOP interrupt user callback */ 413 HAL_FLASH_EndOfOperationCallback(0U); 414 415 /* Stop Mass Erase procedure*/ 416 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 417 } 418 #if defined(FLASH_BANK2_END) 419 } 420 #endif /* FLASH_BANK2_END */ 421 else 422 { 423 /* Nb of 16-bit data to program can be decreased */ 424 pFlash.DataRemaining--; 425 426 /* Check if there are still 16-bit data to program */ 427 if(pFlash.DataRemaining != 0U) 428 { 429 /* Increment address to 16-bit */ 430 pFlash.Address += 2U; 431 addresstmp = pFlash.Address; 432 433 /* Shift to have next 16-bit data */ 434 pFlash.Data = (pFlash.Data >> 16U); 435 436 /* Operation is completed, disable the PG Bit */ 437 CLEAR_BIT(FLASH->CR, FLASH_CR_PG); 438 439 /*Program halfword (16-bit) at a specified address.*/ 440 FLASH_Program_HalfWord(addresstmp, (uint16_t)pFlash.Data); 441 } 442 else 443 { 444 /* Program ended. Return the selected address */ 445 /* FLASH EOP interrupt user callback */ 446 if (pFlash.ProcedureOnGoing == FLASH_PROC_PROGRAMHALFWORD) 447 { 448 HAL_FLASH_EndOfOperationCallback(pFlash.Address); 449 } 450 else if (pFlash.ProcedureOnGoing == FLASH_PROC_PROGRAMWORD) 451 { 452 HAL_FLASH_EndOfOperationCallback(pFlash.Address - 2U); 453 } 454 else 455 { 456 HAL_FLASH_EndOfOperationCallback(pFlash.Address - 6U); 457 } 458 459 /* Reset Address and stop Program procedure */ 460 pFlash.Address = 0xFFFFFFFFU; 461 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 462 } 463 } 464 } 465 } 466 467 #if defined(FLASH_BANK2_END) 468 /* Check FLASH End of Operation flag */ 469 if(__HAL_FLASH_GET_FLAG( FLASH_FLAG_EOP_BANK2)) 470 { 471 /* Clear FLASH End of Operation pending bit */ 472 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP_BANK2); 473 474 /* Process can continue only if no error detected */ 475 if(pFlash.ProcedureOnGoing != FLASH_PROC_NONE) 476 { 477 if(pFlash.ProcedureOnGoing == FLASH_PROC_PAGEERASE) 478 { 479 /* Nb of pages to erased can be decreased */ 480 pFlash.DataRemaining--; 481 482 /* Check if there are still pages to erase*/ 483 if(pFlash.DataRemaining != 0U) 484 { 485 /* Indicate user which page address has been erased*/ 486 HAL_FLASH_EndOfOperationCallback(pFlash.Address); 487 488 /* Increment page address to next page */ 489 pFlash.Address += FLASH_PAGE_SIZE; 490 addresstmp = pFlash.Address; 491 492 /* Operation is completed, disable the PER Bit */ 493 CLEAR_BIT(FLASH->CR2, FLASH_CR2_PER); 494 495 FLASH_PageErase(addresstmp); 496 } 497 else 498 { 499 /*No more pages to Erase*/ 500 501 /*Reset Address and stop Erase pages procedure*/ 502 pFlash.Address = 0xFFFFFFFFU; 503 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 504 505 /* FLASH EOP interrupt user callback */ 506 HAL_FLASH_EndOfOperationCallback(pFlash.Address); 507 } 508 } 509 else if(pFlash.ProcedureOnGoing == FLASH_PROC_MASSERASE) 510 { 511 /* Operation is completed, disable the MER Bit */ 512 CLEAR_BIT(FLASH->CR2, FLASH_CR2_MER); 513 514 if (HAL_IS_BIT_CLR(FLASH->CR, FLASH_CR_MER)) 515 { 516 /* MassErase ended. Return the selected bank*/ 517 /* FLASH EOP interrupt user callback */ 518 HAL_FLASH_EndOfOperationCallback(0U); 519 520 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 521 } 522 } 523 else 524 { 525 /* Nb of 16-bit data to program can be decreased */ 526 pFlash.DataRemaining--; 527 528 /* Check if there are still 16-bit data to program */ 529 if(pFlash.DataRemaining != 0U) 530 { 531 /* Increment address to 16-bit */ 532 pFlash.Address += 2U; 533 addresstmp = pFlash.Address; 534 535 /* Shift to have next 16-bit data */ 536 pFlash.Data = (pFlash.Data >> 16U); 537 538 /* Operation is completed, disable the PG Bit */ 539 CLEAR_BIT(FLASH->CR2, FLASH_CR2_PG); 540 541 /*Program halfword (16-bit) at a specified address.*/ 542 FLASH_Program_HalfWord(addresstmp, (uint16_t)pFlash.Data); 543 } 544 else 545 { 546 /*Program ended. Return the selected address*/ 547 /* FLASH EOP interrupt user callback */ 548 if (pFlash.ProcedureOnGoing == FLASH_PROC_PROGRAMHALFWORD) 549 { 550 HAL_FLASH_EndOfOperationCallback(pFlash.Address); 551 } 552 else if (pFlash.ProcedureOnGoing == FLASH_PROC_PROGRAMWORD) 553 { 554 HAL_FLASH_EndOfOperationCallback(pFlash.Address-2U); 555 } 556 else 557 { 558 HAL_FLASH_EndOfOperationCallback(pFlash.Address-6U); 559 } 560 561 /* Reset Address and stop Program procedure*/ 562 pFlash.Address = 0xFFFFFFFFU; 563 pFlash.ProcedureOnGoing = FLASH_PROC_NONE; 564 } 565 } 566 } 567 } 568 #endif 569 570 if(pFlash.ProcedureOnGoing == FLASH_PROC_NONE) 571 { 572 #if defined(FLASH_BANK2_END) 573 /* Operation is completed, disable the PG, PER and MER Bits for both bank */ 574 CLEAR_BIT(FLASH->CR, (FLASH_CR_PG | FLASH_CR_PER | FLASH_CR_MER)); 575 CLEAR_BIT(FLASH->CR2, (FLASH_CR2_PG | FLASH_CR2_PER | FLASH_CR2_MER)); 576 577 /* Disable End of FLASH Operation and Error source interrupts for both banks */ 578 __HAL_FLASH_DISABLE_IT(FLASH_IT_EOP_BANK1 | FLASH_IT_ERR_BANK1 | FLASH_IT_EOP_BANK2 | FLASH_IT_ERR_BANK2); 579 #else 580 /* Operation is completed, disable the PG, PER and MER Bits */ 581 CLEAR_BIT(FLASH->CR, (FLASH_CR_PG | FLASH_CR_PER | FLASH_CR_MER)); 582 583 /* Disable End of FLASH Operation and Error source interrupts */ 584 __HAL_FLASH_DISABLE_IT(FLASH_IT_EOP | FLASH_IT_ERR); 585 #endif /* FLASH_BANK2_END */ 586 587 } 588 } 589 590 /** 591 * @brief FLASH end of operation interrupt callback 592 * @param ReturnValue: The value saved in this parameter depends on the ongoing procedure 593 * - Mass Erase: No return value expected 594 * - Pages Erase: Address of the page which has been erased 595 * (if 0xFFFFFFFF, it means that all the selected pages have been erased) 596 * - Program: Address which was selected for data program 597 * @retval none 598 */ 599 __weak void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue) 600 { 601 /* Prevent unused argument(s) compilation warning */ 602 UNUSED(ReturnValue); 603 604 /* NOTE : This function Should not be modified, when the callback is needed, 605 the HAL_FLASH_EndOfOperationCallback could be implemented in the user file 606 */ 607 } 608 609 /** 610 * @brief FLASH operation error interrupt callback 611 * @param ReturnValue: The value saved in this parameter depends on the ongoing procedure 612 * - Mass Erase: No return value expected 613 * - Pages Erase: Address of the page which returned an error 614 * - Program: Address which was selected for data program 615 * @retval none 616 */ 617 __weak void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue) 618 { 619 /* Prevent unused argument(s) compilation warning */ 620 UNUSED(ReturnValue); 621 622 /* NOTE : This function Should not be modified, when the callback is needed, 623 the HAL_FLASH_OperationErrorCallback could be implemented in the user file 624 */ 625 } 626 627 /** 628 * @} 629 */ 630 631 /** @defgroup FLASH_Exported_Functions_Group2 Peripheral Control functions 632 * @brief management functions 633 * 634 @verbatim 635 =============================================================================== 636 ##### Peripheral Control functions ##### 637 =============================================================================== 638 [..] 639 This subsection provides a set of functions allowing to control the FLASH 640 memory operations. 641 642 @endverbatim 643 * @{ 644 */ 645 646 /** 647 * @brief Unlock the FLASH control register access 648 * @retval HAL Status 649 */ 650 HAL_StatusTypeDef HAL_FLASH_Unlock(void) 651 { 652 HAL_StatusTypeDef status = HAL_OK; 653 654 if(READ_BIT(FLASH->CR, FLASH_CR_LOCK) != RESET) 655 { 656 /* Authorize the FLASH Registers access */ 657 WRITE_REG(FLASH->KEYR, FLASH_KEY1); 658 WRITE_REG(FLASH->KEYR, FLASH_KEY2); 659 660 /* Verify Flash is unlocked */ 661 if(READ_BIT(FLASH->CR, FLASH_CR_LOCK) != RESET) 662 { 663 status = HAL_ERROR; 664 } 665 } 666 #if defined(FLASH_BANK2_END) 667 if(READ_BIT(FLASH->CR2, FLASH_CR2_LOCK) != RESET) 668 { 669 /* Authorize the FLASH BANK2 Registers access */ 670 WRITE_REG(FLASH->KEYR2, FLASH_KEY1); 671 WRITE_REG(FLASH->KEYR2, FLASH_KEY2); 672 673 /* Verify Flash BANK2 is unlocked */ 674 if(READ_BIT(FLASH->CR2, FLASH_CR2_LOCK) != RESET) 675 { 676 status = HAL_ERROR; 677 } 678 } 679 #endif /* FLASH_BANK2_END */ 680 681 return status; 682 } 683 684 /** 685 * @brief Locks the FLASH control register access 686 * @retval HAL Status 687 */ 688 HAL_StatusTypeDef HAL_FLASH_Lock(void) 689 { 690 /* Set the LOCK Bit to lock the FLASH Registers access */ 691 SET_BIT(FLASH->CR, FLASH_CR_LOCK); 692 693 #if defined(FLASH_BANK2_END) 694 /* Set the LOCK Bit to lock the FLASH BANK2 Registers access */ 695 SET_BIT(FLASH->CR2, FLASH_CR2_LOCK); 696 697 #endif /* FLASH_BANK2_END */ 698 return HAL_OK; 699 } 700 701 /** 702 * @brief Unlock the FLASH Option Control Registers access. 703 * @retval HAL Status 704 */ 705 HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void) 706 { 707 if (HAL_IS_BIT_CLR(FLASH->CR, FLASH_CR_OPTWRE)) 708 { 709 /* Authorizes the Option Byte register programming */ 710 WRITE_REG(FLASH->OPTKEYR, FLASH_OPTKEY1); 711 WRITE_REG(FLASH->OPTKEYR, FLASH_OPTKEY2); 712 } 713 else 714 { 715 return HAL_ERROR; 716 } 717 718 return HAL_OK; 719 } 720 721 /** 722 * @brief Lock the FLASH Option Control Registers access. 723 * @retval HAL Status 724 */ 725 HAL_StatusTypeDef HAL_FLASH_OB_Lock(void) 726 { 727 /* Clear the OPTWRE Bit to lock the FLASH Option Byte Registers access */ 728 CLEAR_BIT(FLASH->CR, FLASH_CR_OPTWRE); 729 730 return HAL_OK; 731 } 732 733 /** 734 * @brief Launch the option byte loading. 735 * @note This function will reset automatically the MCU. 736 * @retval None 737 */ 738 void HAL_FLASH_OB_Launch(void) 739 { 740 /* Initiates a system reset request to launch the option byte loading */ 741 HAL_NVIC_SystemReset(); 742 } 743 744 /** 745 * @} 746 */ 747 748 /** @defgroup FLASH_Exported_Functions_Group3 Peripheral errors functions 749 * @brief Peripheral errors functions 750 * 751 @verbatim 752 =============================================================================== 753 ##### Peripheral Errors functions ##### 754 =============================================================================== 755 [..] 756 This subsection permit to get in run-time errors of the FLASH peripheral. 757 758 @endverbatim 759 * @{ 760 */ 761 762 /** 763 * @brief Get the specific FLASH error flag. 764 * @retval FLASH_ErrorCode The returned value can be: 765 * @ref FLASH_Error_Codes 766 */ 767 uint32_t HAL_FLASH_GetError(void) 768 { 769 return pFlash.ErrorCode; 770 } 771 772 /** 773 * @} 774 */ 775 776 /** 777 * @} 778 */ 779 780 /** @addtogroup FLASH_Private_Functions 781 * @{ 782 */ 783 784 /** 785 * @brief Program a half-word (16-bit) at a specified address. 786 * @param Address specify the address to be programmed. 787 * @param Data specify the data to be programmed. 788 * @retval None 789 */ 790 static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data) 791 { 792 /* Clean the error context */ 793 pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; 794 795 #if defined(FLASH_BANK2_END) 796 if(Address <= FLASH_BANK1_END) 797 { 798 #endif /* FLASH_BANK2_END */ 799 /* Proceed to program the new data */ 800 SET_BIT(FLASH->CR, FLASH_CR_PG); 801 #if defined(FLASH_BANK2_END) 802 } 803 else 804 { 805 /* Proceed to program the new data */ 806 SET_BIT(FLASH->CR2, FLASH_CR2_PG); 807 } 808 #endif /* FLASH_BANK2_END */ 809 810 /* Write data in the address */ 811 *(__IO uint16_t*)Address = Data; 812 } 813 814 /** 815 * @brief Wait for a FLASH operation to complete. 816 * @param Timeout maximum flash operation timeout 817 * @retval HAL Status 818 */ 819 HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout) 820 { 821 /* Wait for the FLASH operation to complete by polling on BUSY flag to be reset. 822 Even if the FLASH operation fails, the BUSY flag will be reset and an error 823 flag will be set */ 824 825 uint32_t tickstart = HAL_GetTick(); 826 827 while(__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY)) 828 { 829 if (Timeout != HAL_MAX_DELAY) 830 { 831 if((Timeout == 0U) || ((HAL_GetTick()-tickstart) > Timeout)) 832 { 833 return HAL_TIMEOUT; 834 } 835 } 836 } 837 838 /* Check FLASH End of Operation flag */ 839 if (__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP)) 840 { 841 /* Clear FLASH End of Operation pending bit */ 842 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP); 843 } 844 845 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) || 846 __HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERR) || 847 __HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR)) 848 { 849 /*Save the error code*/ 850 FLASH_SetErrorCode(); 851 return HAL_ERROR; 852 } 853 854 /* There is no error flag set */ 855 return HAL_OK; 856 } 857 858 #if defined(FLASH_BANK2_END) 859 /** 860 * @brief Wait for a FLASH BANK2 operation to complete. 861 * @param Timeout maximum flash operation timeout 862 * @retval HAL_StatusTypeDef HAL Status 863 */ 864 HAL_StatusTypeDef FLASH_WaitForLastOperationBank2(uint32_t Timeout) 865 { 866 /* Wait for the FLASH BANK2 operation to complete by polling on BUSY flag to be reset. 867 Even if the FLASH BANK2 operation fails, the BUSY flag will be reset and an error 868 flag will be set */ 869 870 uint32_t tickstart = HAL_GetTick(); 871 872 while(__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY_BANK2)) 873 { 874 if (Timeout != HAL_MAX_DELAY) 875 { 876 if((Timeout == 0U) || ((HAL_GetTick()-tickstart) > Timeout)) 877 { 878 return HAL_TIMEOUT; 879 } 880 } 881 } 882 883 /* Check FLASH End of Operation flag */ 884 if (__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP_BANK2)) 885 { 886 /* Clear FLASH End of Operation pending bit */ 887 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP_BANK2); 888 } 889 890 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR_BANK2) || __HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR_BANK2)) 891 { 892 /*Save the error code*/ 893 FLASH_SetErrorCode(); 894 return HAL_ERROR; 895 } 896 897 /* If there is an error flag set */ 898 return HAL_OK; 899 900 } 901 #endif /* FLASH_BANK2_END */ 902 903 /** 904 * @brief Set the specific FLASH error flag. 905 * @retval None 906 */ 907 static void FLASH_SetErrorCode(void) 908 { 909 uint32_t flags = 0U; 910 911 #if defined(FLASH_BANK2_END) 912 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR) || __HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR_BANK2)) 913 #else 914 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_WRPERR)) 915 #endif /* FLASH_BANK2_END */ 916 { 917 pFlash.ErrorCode |= HAL_FLASH_ERROR_WRP; 918 #if defined(FLASH_BANK2_END) 919 flags |= FLASH_FLAG_WRPERR | FLASH_FLAG_WRPERR_BANK2; 920 #else 921 flags |= FLASH_FLAG_WRPERR; 922 #endif /* FLASH_BANK2_END */ 923 } 924 #if defined(FLASH_BANK2_END) 925 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR) || __HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR_BANK2)) 926 #else 927 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_PGERR)) 928 #endif /* FLASH_BANK2_END */ 929 { 930 pFlash.ErrorCode |= HAL_FLASH_ERROR_PROG; 931 #if defined(FLASH_BANK2_END) 932 flags |= FLASH_FLAG_PGERR | FLASH_FLAG_PGERR_BANK2; 933 #else 934 flags |= FLASH_FLAG_PGERR; 935 #endif /* FLASH_BANK2_END */ 936 } 937 if(__HAL_FLASH_GET_FLAG(FLASH_FLAG_OPTVERR)) 938 { 939 pFlash.ErrorCode |= HAL_FLASH_ERROR_OPTV; 940 __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR); 941 } 942 943 /* Clear FLASH error pending bits */ 944 __HAL_FLASH_CLEAR_FLAG(flags); 945 } 946 /** 947 * @} 948 */ 949 950 /** 951 * @} 952 */ 953 954 #endif /* HAL_FLASH_MODULE_ENABLED */ 955 956 /** 957 * @} 958 */ 959