| /** |
| ****************************************************************************** |
| * @file stm32g0xx_hal_flash.c |
| * @author MCD Application Team |
| * @brief FLASH HAL module driver. |
| * This file provides firmware functions to manage the following |
| * functionalities of the internal FLASH memory: |
| * + Program operations functions |
| * + Memory Control functions |
| * + Peripheral Errors functions |
| * |
| @verbatim |
| ============================================================================== |
| ##### FLASH peripheral features ##### |
| ============================================================================== |
| |
| [..] The Flash memory interface manages CPU AHB I-Code and D-Code accesses |
| to the Flash memory. It implements the erase and program Flash memory operations |
| and the read and write protection mechanisms. |
| |
| [..] The Flash memory interface accelerates code execution with a system of instruction |
| prefetch and cache lines. |
| |
| [..] The FLASH main features are: |
| (+) Flash memory read operations |
| (+) Flash memory program/erase operations |
| (+) Read / write protections |
| (+) Option bytes programming |
| (+) Prefetch on I-Code |
| (+) 32 cache lines of 4*64 bits on I-Code |
| (+) Error code correction (ECC) : Data in flash are 72-bits word |
| (8 bits added per double word) |
| |
| ##### How to use this driver ##### |
| ============================================================================== |
| [..] |
| This driver provides functions and macros to configure and program the FLASH |
| memory of all STM32G0xx devices. |
| |
| (#) Flash Memory IO Programming functions: |
| (++) Lock and Unlock the FLASH interface using HAL_FLASH_Unlock() and |
| HAL_FLASH_Lock() functions |
| (++) Program functions: double word and fast program (full row programming) |
| (++) There are two modes of programming: |
| (+++) Polling mode using HAL_FLASH_Program() function |
| (+++) Interrupt mode using HAL_FLASH_Program_IT() function |
| |
| (#) Interrupts and flags management functions: |
| (++) Handle FLASH interrupts by calling HAL_FLASH_IRQHandler() |
| (++) Callback functions are called when the flash operations are finished : |
| HAL_FLASH_EndOfOperationCallback() when everything is ok, otherwise |
| HAL_FLASH_OperationErrorCallback() |
| (++) Get error flag status by calling HAL_GetError() |
| |
| (#) Option bytes management functions : |
| (++) Lock and Unlock the option bytes using HAL_FLASH_OB_Unlock() and |
| HAL_FLASH_OB_Lock() functions |
| (++) Launch the reload of the option bytes using HAL_FLASH_OB_Launch() function. |
| In this case, a reset is generated |
| |
| [..] |
| In addition to these functions, this driver includes a set of macros allowing |
| to handle the following operations: |
| (+) Set the latency |
| (+) Enable/Disable the prefetch buffer |
| (+) Enable/Disable the Instruction cache |
| (+) Reset the Instruction cache |
| (+) Enable/Disable the Flash power-down during low-power run and sleep modes |
| (+) Enable/Disable the Flash interrupts |
| (+) Monitor the Flash flags status |
| |
| @endverbatim |
| ****************************************************************************** |
| * @attention |
| * |
| * <h2><center>© Copyright (c) 2018 STMicroelectronics. |
| * All rights reserved.</center></h2> |
| * |
| * This software component is licensed by ST under BSD 3-Clause license, |
| * the "License"; You may not use this file except in compliance with the |
| * License. You may obtain a copy of the License at: |
| * opensource.org/licenses/BSD-3-Clause |
| * |
| ****************************************************************************** |
| */ |
| |
| /* Includes ------------------------------------------------------------------*/ |
| #include "stm32g0xx_hal.h" |
| |
| /** @addtogroup STM32G0xx_HAL_Driver |
| * @{ |
| */ |
| |
| /** @defgroup FLASH FLASH |
| * @brief FLASH HAL module driver |
| * @{ |
| */ |
| |
| #ifdef HAL_FLASH_MODULE_ENABLED |
| |
| /* Private typedef -----------------------------------------------------------*/ |
| /* Private defines -----------------------------------------------------------*/ |
| /* Private macros ------------------------------------------------------------*/ |
| /* Private variables ---------------------------------------------------------*/ |
| /** @defgroup FLASH_Private_Variables FLASH Private Variables |
| * @{ |
| */ |
| /** |
| * @brief Variable used for Program/Erase sectors under interruption |
| */ |
| FLASH_ProcessTypeDef pFlash = {.Lock = HAL_UNLOCKED, \ |
| .ErrorCode = HAL_FLASH_ERROR_NONE, \ |
| .ProcedureOnGoing = FLASH_TYPENONE, \ |
| .Address = 0U, \ |
| .Page = 0U, \ |
| .NbPagesToErase = 0U |
| }; |
| /** |
| * @} |
| */ |
| |
| /* Private function prototypes -----------------------------------------------*/ |
| /** @defgroup FLASH_Private_Functions FLASH Private Functions |
| * @{ |
| */ |
| static void FLASH_Program_DoubleWord(uint32_t Address, uint64_t Data); |
| static void FLASH_Program_Fast(uint32_t Address, uint32_t DataAddress); |
| /** |
| * @} |
| */ |
| |
| /* Exported functions --------------------------------------------------------*/ |
| /** @defgroup FLASH_Exported_Functions FLASH Exported Functions |
| * @{ |
| */ |
| |
| /** @defgroup FLASH_Exported_Functions_Group1 Programming operation functions |
| * @brief Programming operation functions |
| * |
| @verbatim |
| =============================================================================== |
| ##### Programming operation functions ##### |
| =============================================================================== |
| [..] |
| This subsection provides a set of functions allowing to manage the FLASH |
| program operations. |
| |
| @endverbatim |
| * @{ |
| */ |
| |
| /** |
| * @brief Program double word or fast program of a row at a specified address. |
| * @param TypeProgram Indicate the way to program at a specified address. |
| * This parameter can be a value of @ref FLASH_Type_Program |
| * @param Address Specifies the address to be programmed. |
| * @param Data Specifies the data to be programmed |
| * This parameter is the data for the double word program and the address where |
| * are stored the data for the row fast program. |
| * |
| * @retval HAL_StatusTypeDef HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint64_t Data) |
| { |
| HAL_StatusTypeDef status; |
| |
| /* Check the parameters */ |
| assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram)); |
| assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); |
| |
| /* Process Locked */ |
| __HAL_LOCK(&pFlash); |
| |
| /* Reset error code */ |
| pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; |
| |
| /* Wait for last operation to be completed */ |
| status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); |
| |
| if (status == HAL_OK) |
| { |
| if (TypeProgram == FLASH_TYPEPROGRAM_DOUBLEWORD) |
| { |
| /* Check the parameters */ |
| assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); |
| |
| /* Program double-word (64-bit) at a specified address */ |
| FLASH_Program_DoubleWord(Address, Data); |
| } |
| else |
| { |
| /* Check the parameters */ |
| assert_param(IS_FLASH_FAST_PROGRAM_ADDRESS(Address)); |
| |
| /* Fast program a 32 row double-word (64-bit) at a specified address */ |
| FLASH_Program_Fast(Address, (uint32_t)Data); |
| } |
| |
| /* Wait for last operation to be completed */ |
| status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); |
| |
| /* If the program operation is completed, disable the PG or FSTPG Bit */ |
| CLEAR_BIT(FLASH->CR, TypeProgram); |
| } |
| |
| /* Process Unlocked */ |
| __HAL_UNLOCK(&pFlash); |
| |
| /* return status */ |
| return status; |
| } |
| |
| /** |
| * @brief Program double word or fast program of a row at a specified address with interrupt enabled. |
| * @param TypeProgram Indicate the way to program at a specified address. |
| * This parameter can be a value of @ref FLASH_Type_Program |
| * @param Address Specifies the address to be programmed. |
| * @param Data Specifies the data to be programmed |
| * This parameter is the data for the double word program and the address where |
| * are stored the data for the row fast program. |
| * |
| * @retval HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint64_t Data) |
| { |
| HAL_StatusTypeDef status; |
| |
| /* Check the parameters */ |
| assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram)); |
| assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); |
| |
| /* Process Locked */ |
| __HAL_LOCK(&pFlash); |
| |
| /* Reset error code */ |
| pFlash.ErrorCode = HAL_FLASH_ERROR_NONE; |
| |
| /* Wait for last operation to be completed */ |
| status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE); |
| |
| if (status != HAL_OK) |
| { |
| /* Process Unlocked */ |
| __HAL_UNLOCK(&pFlash); |
| } |
| else |
| { |
| /* Set internal variables used by the IRQ handler */ |
| pFlash.ProcedureOnGoing = TypeProgram; |
| pFlash.Address = Address; |
| |
| /* Enable End of Operation and Error interrupts */ |
| __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP | FLASH_IT_OPERR | FLASH_IT_ECCC); |
| |
| if (TypeProgram == FLASH_TYPEPROGRAM_DOUBLEWORD) |
| { |
| /* Check the parameters */ |
| assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); |
| |
| /* Program double-word (64-bit) at a specified address */ |
| FLASH_Program_DoubleWord(Address, Data); |
| } |
| else |
| { |
| /* Check the parameters */ |
| assert_param(IS_FLASH_FAST_PROGRAM_ADDRESS(Address)); |
| |
| /* Fast program a 32 row double-word (64-bit) at a specified address */ |
| FLASH_Program_Fast(Address, (uint32_t)Data); |
| } |
| } |
| |
| /* return status */ |
| return status; |
| } |
| |
| /** |
| * @brief Handle FLASH interrupt request. |
| * @retval None |
| */ |
| void HAL_FLASH_IRQHandler(void) |
| { |
| uint32_t param = 0xFFFFFFFFU; |
| uint32_t error; |
| |
| /* Save flash errors. Only ECC detection can be checked here as ECCC |
| generates NMI */ |
| error = (FLASH->SR & FLASH_FLAG_SR_ERROR); |
| error |= (FLASH->ECCR & FLASH_FLAG_ECCC); |
| |
| CLEAR_BIT(FLASH->CR, pFlash.ProcedureOnGoing); |
| |
| /* A] Set parameter for user or error callbacks */ |
| /* check operation was a program or erase */ |
| if ((pFlash.ProcedureOnGoing & (FLASH_TYPEPROGRAM_DOUBLEWORD | FLASH_TYPEPROGRAM_FAST)) != 0x00U) |
| { |
| /* return adress being programmed */ |
| param = pFlash.Address; |
| } |
| else if ((pFlash.ProcedureOnGoing & (FLASH_TYPEERASE_MASS | FLASH_TYPEERASE_PAGES)) != 0x00U) |
| { |
| /* return page number being erased (0 for mass erase) */ |
| param = pFlash.Page; |
| } |
| else |
| { |
| /* Nothing to do */ |
| } |
| |
| /* B] Check errors */ |
| if (error != 0x00U) |
| { |
| /*Save the error code*/ |
| pFlash.ErrorCode |= error; |
| |
| /* clear error flags */ |
| __HAL_FLASH_CLEAR_FLAG(error); |
| |
| /*Stop the procedure ongoing*/ |
| pFlash.ProcedureOnGoing = FLASH_TYPENONE; |
| |
| /* Error callback */ |
| HAL_FLASH_OperationErrorCallback(param); |
| } |
| |
| /* C] Check FLASH End of Operation flag */ |
| if (__HAL_FLASH_GET_FLAG(FLASH_FLAG_EOP) != 0x00U) |
| { |
| /* Clear FLASH End of Operation pending bit */ |
| __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP); |
| |
| if (pFlash.ProcedureOnGoing == FLASH_TYPEERASE_PAGES) |
| { |
| /* Nb of pages to erased can be decreased */ |
| pFlash.NbPagesToErase--; |
| |
| /* Check if there are still pages to erase*/ |
| if (pFlash.NbPagesToErase != 0x00U) |
| { |
| /* Increment page number */ |
| pFlash.Page++; |
| FLASH_PageErase(pFlash.Page); |
| } |
| else |
| { |
| /* No more pages to erase: stop erase pages procedure */ |
| pFlash.ProcedureOnGoing = FLASH_TYPENONE; |
| } |
| } |
| else |
| { |
| /*Stop the ongoing procedure */ |
| pFlash.ProcedureOnGoing = FLASH_TYPENONE; |
| } |
| |
| /* User callback */ |
| HAL_FLASH_EndOfOperationCallback(param); |
| } |
| |
| if (pFlash.ProcedureOnGoing == FLASH_TYPENONE) |
| { |
| /* Disable End of Operation and Error interrupts */ |
| __HAL_FLASH_DISABLE_IT(FLASH_IT_EOP | FLASH_IT_OPERR | FLASH_IT_ECCC); |
| |
| /* Process Unlocked */ |
| __HAL_UNLOCK(&pFlash); |
| } |
| } |
| |
| /** |
| * @brief FLASH end of operation interrupt callback. |
| * @param ReturnValue The value saved in this parameter depends on the ongoing procedure |
| * Mass Erase: 0 |
| * Page Erase: Page which has been erased |
| * Program: Address which was selected for data program |
| * @retval None |
| */ |
| __weak void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue) |
| { |
| /* Prevent unused argument(s) compilation warning */ |
| UNUSED(ReturnValue); |
| |
| /* NOTE : This function should not be modified, when the callback is needed, |
| the HAL_FLASH_EndOfOperationCallback could be implemented in the user file |
| */ |
| } |
| |
| /** |
| * @brief FLASH operation error interrupt callback. |
| * @param ReturnValue The value saved in this parameter depends on the ongoing procedure |
| * Mass Erase: 0 |
| * Page Erase: Page number which returned an error |
| * Program: Address which was selected for data program |
| * @retval None |
| */ |
| __weak void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue) |
| { |
| /* Prevent unused argument(s) compilation warning */ |
| UNUSED(ReturnValue); |
| |
| /* NOTE : This function should not be modified, when the callback is needed, |
| the HAL_FLASH_OperationErrorCallback could be implemented in the user file |
| */ |
| } |
| |
| /** |
| * @} |
| */ |
| |
| /** @defgroup FLASH_Exported_Functions_Group2 Peripheral Control functions |
| * @brief Management functions |
| * |
| @verbatim |
| =============================================================================== |
| ##### Peripheral Control functions ##### |
| =============================================================================== |
| [..] |
| This subsection provides a set of functions allowing to control the FLASH |
| memory operations. |
| |
| @endverbatim |
| * @{ |
| */ |
| |
| /** |
| * @brief Unlock the FLASH control register access. |
| * @retval HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_Unlock(void) |
| { |
| HAL_StatusTypeDef status = HAL_OK; |
| |
| if (READ_BIT(FLASH->CR, FLASH_CR_LOCK) != 0x00U) |
| { |
| /* Authorize the FLASH Registers access */ |
| WRITE_REG(FLASH->KEYR, FLASH_KEY1); |
| WRITE_REG(FLASH->KEYR, FLASH_KEY2); |
| |
| /* verify Flash is unlock */ |
| if (READ_BIT(FLASH->CR, FLASH_CR_LOCK) != 0x00U) |
| { |
| status = HAL_ERROR; |
| } |
| } |
| |
| return status; |
| } |
| |
| /** |
| * @brief Lock the FLASH control register access. |
| * @retval HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_Lock(void) |
| { |
| HAL_StatusTypeDef status = HAL_ERROR; |
| |
| /* Set the LOCK Bit to lock the FLASH Registers access */ |
| SET_BIT(FLASH->CR, FLASH_CR_LOCK); |
| |
| /* verify Flash is locked */ |
| if (READ_BIT(FLASH->CR, FLASH_CR_LOCK) != 0x00u) |
| { |
| status = HAL_OK; |
| } |
| |
| return status; |
| } |
| |
| /** |
| * @brief Unlock the FLASH Option Bytes Registers access. |
| * @retval HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void) |
| { |
| HAL_StatusTypeDef status = HAL_ERROR; |
| |
| if (READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) != 0x00U) |
| { |
| /* Authorizes the Option Byte register programming */ |
| WRITE_REG(FLASH->OPTKEYR, FLASH_OPTKEY1); |
| WRITE_REG(FLASH->OPTKEYR, FLASH_OPTKEY2); |
| |
| /* verify option bytes are unlocked */ |
| if (READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) == 0x00U) |
| { |
| status = HAL_OK; |
| } |
| } |
| |
| return status; |
| } |
| |
| /** |
| * @brief Lock the FLASH Option Bytes Registers access. |
| * @retval HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_OB_Lock(void) |
| { |
| HAL_StatusTypeDef status = HAL_ERROR; |
| |
| /* Set the OPTLOCK Bit to lock the FLASH Option Byte Registers access */ |
| SET_BIT(FLASH->CR, FLASH_CR_OPTLOCK); |
| |
| /* verify option bytes are locked */ |
| if (READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) != 0x00u) |
| { |
| status = HAL_OK; |
| } |
| |
| return status; |
| } |
| |
| /** |
| * @brief Launch the option byte loading. |
| * @retval HAL Status |
| */ |
| HAL_StatusTypeDef HAL_FLASH_OB_Launch(void) |
| { |
| /* Set the bit to force the option byte reloading */ |
| SET_BIT(FLASH->CR, FLASH_CR_OBL_LAUNCH); |
| |
| /* We should not reach here : Option byte launch generates Option byte reset |
| so return error */ |
| return HAL_ERROR; |
| } |
| |
| /** |
| * @} |
| */ |
| |
| /** @defgroup FLASH_Exported_Functions_Group3 Peripheral State and Errors functions |
| * @brief Peripheral Errors functions |
| * |
| @verbatim |
| =============================================================================== |
| ##### Peripheral Errors functions ##### |
| =============================================================================== |
| [..] |
| This subsection permits to get in run-time Errors of the FLASH peripheral. |
| |
| @endverbatim |
| * @{ |
| */ |
| |
| /** |
| * @brief Get the specific FLASH error flag. |
| * @retval FLASH_ErrorCode The returned value can be |
| * @arg @ref HAL_FLASH_ERROR_NONE No error set |
| * @arg @ref HAL_FLASH_ERROR_OP FLASH Operation error |
| * @arg @ref HAL_FLASH_ERROR_PROG FLASH Programming error |
| * @arg @ref HAL_FLASH_ERROR_WRP FLASH Write protection error |
| * @arg @ref HAL_FLASH_ERROR_PGA FLASH Programming alignment error |
| * @arg @ref HAL_FLASH_ERROR_SIZ FLASH Size error |
| * @arg @ref HAL_FLASH_ERROR_PGS FLASH Programming sequence error |
| * @arg @ref HAL_FLASH_ERROR_MIS FLASH Fast programming data miss error |
| * @arg @ref HAL_FLASH_ERROR_FAST FLASH Fast programming error |
| * @arg @ref HAL_FLASH_ERROR_RD FLASH Read Protection error (PCROP)(*) |
| * @arg @ref HAL_FLASH_ERROR_OPTV FLASH Option validity error |
| * @arg @ref HAL_FLASH_ERROR_ECCD FLASH two ECC errors have been detected |
| * @note (*) availability depends on devices |
| */ |
| uint32_t HAL_FLASH_GetError(void) |
| { |
| return pFlash.ErrorCode; |
| } |
| |
| /** |
| * @} |
| */ |
| |
| /** |
| * @} |
| */ |
| |
| /* Private functions ---------------------------------------------------------*/ |
| |
| /** @addtogroup FLASH_Private_Functions |
| * @{ |
| */ |
| |
| /** |
| * @brief Wait for a FLASH operation to complete. |
| * @param Timeout maximum flash operation timeout |
| * @retval HAL_StatusTypeDef HAL Status |
| */ |
| HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout) |
| { |
| uint32_t error; |
| /* Wait for the FLASH operation to complete by polling on BUSY flag to be reset. |
| Even if the FLASH operation fails, the BUSY flag will be reset and an error |
| flag will be set */ |
| uint32_t timeout = HAL_GetTick() + Timeout; |
| |
| /* Wait if any operation is ongoing */ |
| while (__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY) != 0x00U) |
| { |
| if (HAL_GetTick() >= timeout) |
| { |
| return HAL_TIMEOUT; |
| } |
| } |
| |
| /* check flash errors. Only ECC correction can be checked here as ECCD |
| generates NMI */ |
| error = (FLASH->SR & FLASH_FLAG_SR_ERROR); |
| error |= (FLASH->ECCR & FLASH_FLAG_ECCC); |
| |
| /* clear error flags */ |
| __HAL_FLASH_CLEAR_FLAG(error); |
| |
| if (error != 0x00U) |
| { |
| /*Save the error code*/ |
| pFlash.ErrorCode = error; |
| |
| return HAL_ERROR; |
| } |
| |
| /* Wait for control register to be written */ |
| timeout = HAL_GetTick() + Timeout; |
| |
| while (__HAL_FLASH_GET_FLAG(FLASH_FLAG_CFGBSY) != 0x00U) |
| { |
| if (HAL_GetTick() >= timeout) |
| { |
| return HAL_TIMEOUT; |
| } |
| } |
| |
| return HAL_OK; |
| } |
| |
| /** |
| * @brief Program double-word (64-bit) at a specified address. |
| * @param Address Specifies the address to be programmed. |
| * @param Data Specifies the data to be programmed. |
| * @retval None |
| */ |
| static void FLASH_Program_DoubleWord(uint32_t Address, uint64_t Data) |
| { |
| /* Set PG bit */ |
| SET_BIT(FLASH->CR, FLASH_CR_PG); |
| |
| /* Program first word */ |
| *(uint32_t *)Address = (uint32_t)Data; |
| |
| /* Barrier to ensure programming is performed in 2 steps, in right order |
| (independently of compiler optimization behavior) */ |
| __ISB(); |
| |
| /* Program second word */ |
| *(uint32_t *)(Address + 4U) = (uint32_t)(Data >> 32U); |
| } |
| |
| /** |
| * @brief Fast program a 32 row double-word (64-bit) at a specified address. |
| * @param Address Specifies the address to be programmed. |
| * @param DataAddress Specifies the address where the data are stored. |
| * @retval None |
| */ |
| static __RAM_FUNC void FLASH_Program_Fast(uint32_t Address, uint32_t DataAddress) |
| { |
| uint8_t index = 0; |
| uint32_t dest = Address; |
| uint32_t src = DataAddress; |
| uint32_t primask_bit; |
| |
| /* Set FSTPG bit */ |
| SET_BIT(FLASH->CR, FLASH_CR_FSTPG); |
| |
| /* Enter critical section: row programming should not be longer than 7 ms */ |
| primask_bit = __get_PRIMASK(); |
| __disable_irq(); |
| |
| /* Fast Program : 64 words */ |
| while (index < 64U) |
| { |
| *(uint32_t *)dest = *(uint32_t *)src; |
| src += 4U; |
| dest += 4U; |
| index++; |
| } |
| |
| /* wait for BSY1 in order to be sure that flash operation is ended befoire |
| allowing prefetch in flash. Timeout does not return status, as it will |
| be anyway done later */ |
| while ((FLASH->SR & FLASH_SR_BSY1) != 0x00U) |
| { |
| } |
| |
| /* Exit critical section: restore previous priority mask */ |
| __set_PRIMASK(primask_bit); |
| } |
| |
| /** |
| * @} |
| */ |
| |
| #endif /* HAL_FLASH_MODULE_ENABLED */ |
| |
| /** |
| * @} |
| */ |
| |
| /** |
| * @} |
| */ |
| |
| /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |