diff options
Diffstat (limited to 'keyboards/matrix/noah/eeprom_f4.c')
-rw-r--r-- | keyboards/matrix/noah/eeprom_f4.c | 822 |
1 files changed, 822 insertions, 0 deletions
diff --git a/keyboards/matrix/noah/eeprom_f4.c b/keyboards/matrix/noah/eeprom_f4.c new file mode 100644 index 0000000000..3333d7d939 --- /dev/null +++ b/keyboards/matrix/noah/eeprom_f4.c @@ -0,0 +1,822 @@ +/** + ****************************************************************************** + * @file EEPROM/EEPROM_Emulation/src/eeprom.c + * @author MCD Application Team + * @brief This file provides all the EEPROM emulation firmware functions. + ****************************************************************************** + * @attention + * + * <h2><center>© Copyright � 2017 STMicroelectronics International N.V. + * All rights reserved.</center></h2> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted, provided that the following conditions are met: + * + * 1. Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of STMicroelectronics nor the names of other + * contributors to this software may be used to endorse or promote products + * derived from this software without specific written permission. + * 4. This software, including modifications and/or derivative works of this + * software, must execute solely and exclusively on microcontroller or + * microprocessor devices manufactured by or for STMicroelectronics. + * 5. Redistribution and use of this software other than as permitted under + * this license is void and will automatically terminate your rights under + * this license. + * + * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY + * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT + * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************** + */ +/** @addtogroup EEPROM_Emulation + * @{ + */ + +/* Includes ------------------------------------------------------------------*/ +#include "eeprom_f4.h" + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ + +/* Global variable used to store variable value in read sequence */ +uint16_t DataVar = 0; + +/* Virtual address defined by the user: 0xFFFF value is prohibited */ +extern uint16_t VirtAddVarTab[NB_OF_VAR]; + +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ +static HAL_StatusTypeDef EE_Format(void); +static uint16_t EE_FindValidPage(uint8_t Operation); +static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data); +static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data); +static uint16_t EE_VerifyPageFullyErased(uint32_t Address); + +/** + * @brief Restore the pages to a known good state in case of page's status + * corruption after a power loss. + * @param None. + * @retval - Flash error code: on write Flash error + * - FLASH_COMPLETE: on success + */ +uint16_t EE_Init(void) +{ + uint16_t PageStatus0 = 6, PageStatus1 = 6; + uint16_t VarIdx = 0; + uint16_t EepromStatus = 0, ReadStatus = 0; + int16_t x = -1; + HAL_StatusTypeDef FlashStatus; + + FLASH_UnlockF4(); + + /* Get Page0 status */ + PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS); + /* Get Page1 status */ + PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS); + + /* Check for invalid header states and repair if necessary */ + switch (PageStatus0) + { + case ERASED: + if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */ + { + /* Erase Page0 */ + if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE0_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + } + else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */ + { + /* Erase Page0 */ + if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE1_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + /* Mark Page1 as valid */ + FlashStatus = FLASH_ProgramHalfWordF4(PAGE1_BASE_ADDRESS, VALID_PAGE); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */ + { + /* Erase both Page0 and Page1 and set Page0 as valid page */ + FlashStatus = EE_Format(); + /* If erase/program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + break; + + case RECEIVE_DATA: + if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */ + { + /* Transfer data from Page1 to Page0 */ + for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) + { + if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx]) + { + x = VarIdx; + } + if (VarIdx != x) + { + /* Read the last variables' updates */ + ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); + /* In case variable corresponding to the virtual address was found */ + if (ReadStatus != 0x1) + { + /* Transfer the variable to the Page0 */ + EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); + /* If program operation was failed, a Flash error code is returned */ + if (EepromStatus != HAL_OK) + { + return EepromStatus; + } + } + } + } + /* Mark Page0 as valid */ + FlashStatus = FLASH_ProgramHalfWordF4(PAGE0_BASE_ADDRESS, VALID_PAGE); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + /* Erase Page1 */ + if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE1_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + } + else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */ + { + /* Erase Page1 */ + if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE1_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + /* Mark Page0 as valid */ + FlashStatus = FLASH_ProgramHalfWordF4(PAGE0_BASE_ADDRESS, VALID_PAGE); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + else /* Invalid state -> format eeprom */ + { + /* Erase both Page0 and Page1 and set Page0 as valid page */ + FlashStatus = EE_Format(); + /* If erase/program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + break; + + case VALID_PAGE: + if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */ + { + /* Erase both Page0 and Page1 and set Page0 as valid page */ + FlashStatus = EE_Format(); + /* If erase/program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */ + { + /* Erase Page1 */ + if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE1_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + } + else /* Page0 valid, Page1 receive */ + { + /* Transfer data from Page0 to Page1 */ + for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) + { + if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx]) + { + x = VarIdx; + } + if (VarIdx != x) + { + /* Read the last variables' updates */ + ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); + /* In case variable corresponding to the virtual address was found */ + if (ReadStatus != 0x1) + { + /* Transfer the variable to the Page1 */ + EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); + /* If program operation was failed, a Flash error code is returned */ + if (EepromStatus != HAL_OK) + { + return EepromStatus; + } + } + } + } + /* Mark Page1 as valid */ + FlashStatus = FLASH_ProgramHalfWordF4(PAGE1_BASE_ADDRESS, VALID_PAGE); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + /* Erase Page0 */ + if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE0_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + } + break; + + default: /* Any other state -> format eeprom */ + /* Erase both Page0 and Page1 and set Page0 as valid page */ + FlashStatus = EE_Format(); + /* If erase/program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + break; + } + + return HAL_OK; +} + +/** + * @brief Verify if specified page is fully erased. + * @param Address: page address + * This parameter can be one of the following values: + * @arg PAGE0_BASE_ADDRESS: Page0 base address + * @arg PAGE1_BASE_ADDRESS: Page1 base address + * @retval page fully erased status: + * - 0: if Page not erased + * - 1: if Page erased + */ +uint16_t EE_VerifyPageFullyErased(uint32_t Address) +{ + uint32_t ReadStatus = 1; + uint16_t AddressValue = 0x5555; + + /* Check each active page address starting from end */ + while (Address <= PAGE0_END_ADDRESS) + { + /* Get the current location content to be compared with virtual address */ + AddressValue = (*(__IO uint16_t*)Address); + + /* Compare the read address with the virtual address */ + if (AddressValue != ERASED) + { + + /* In case variable value is read, reset ReadStatus flag */ + ReadStatus = 0; + + break; + } + /* Next address location */ + Address = Address + 4; + } + + /* Return ReadStatus value: (0: Page not erased, 1: Sector erased) */ + return ReadStatus; +} + +/** + * @brief Returns the last stored variable data, if found, which correspond to + * the passed virtual address + * @param VirtAddress: Variable virtual address + * @param Data: Global variable contains the read variable value + * @retval Success or error status: + * - 0: if variable was found + * - 1: if the variable was not found + * - NO_VALID_PAGE: if no valid page was found. + */ +uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) +{ + uint16_t ValidPage = PAGE0; + uint16_t AddressValue = 0x5555, ReadStatus = 1; + uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS; + + /* Get active Page for read operation */ + ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE); + + /* Check if there is no valid page */ + if (ValidPage == NO_VALID_PAGE) + { + return NO_VALID_PAGE; + } + + /* Get the valid Page start Address */ + PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE)); + + /* Get the valid Page end Address */ + Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE)); + + /* Check each active page address starting from end */ + while (Address > (PageStartAddress + 2)) + { + /* Get the current location content to be compared with virtual address */ + AddressValue = (*(__IO uint16_t*)Address); + + /* Compare the read address with the virtual address */ + if (AddressValue == VirtAddress) + { + /* Get content of Address-2 which is variable value */ + *Data = (*(__IO uint16_t*)(Address - 2)); + + /* In case variable value is read, reset ReadStatus flag */ + ReadStatus = 0; + + break; + } + else + { + /* Next address location */ + Address = Address - 4; + } + } + + /* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */ + return ReadStatus; +} + +/** + * @brief Writes/upadtes variable data in EEPROM. + * @param VirtAddress: Variable virtual address + * @param Data: 16 bit data to be written + * @retval Success or error status: + * - FLASH_COMPLETE: on success + * - PAGE_FULL: if valid page is full + * - NO_VALID_PAGE: if no valid page was found + * - Flash error code: on write Flash error + */ +uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data) +{ + uint16_t Status = 0; + + /* Write the variable virtual address and value in the EEPROM */ + Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data); + + /* In case the EEPROM active page is full */ + if (Status == PAGE_FULL) + { + /* Perform Page transfer */ + Status = EE_PageTransfer(VirtAddress, Data); + } + + /* Return last operation status */ + return Status; +} + +/** + * @brief Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE + * @param None + * @retval Status of the last operation (Flash write or erase) done during + * EEPROM formating + */ +static HAL_StatusTypeDef EE_Format(void) +{ + HAL_StatusTypeDef FlashStatus = HAL_OK; + + /* Erase Page0 */ + if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE0_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */ + FlashStatus = FLASH_ProgramHalfWordF4(PAGE0_BASE_ADDRESS, VALID_PAGE); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + + /* Erase Page1 */ + if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) + { + FlashStatus = FLASH_EraseSectorF4(PAGE1_ID); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + } + + return HAL_OK; +} + +/** + * @brief Find valid Page for write or read operation + * @param Operation: operation to achieve on the valid page. + * This parameter can be one of the following values: + * @arg READ_FROM_VALID_PAGE: read operation from valid page + * @arg WRITE_IN_VALID_PAGE: write operation from valid page + * @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case + * of no valid page was found + */ +static uint16_t EE_FindValidPage(uint8_t Operation) +{ + uint16_t PageStatus0 = 6, PageStatus1 = 6; + + /* Get Page0 actual status */ + PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS); + + /* Get Page1 actual status */ + PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS); + + /* Write or read operation */ + switch (Operation) + { + case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */ + if (PageStatus1 == VALID_PAGE) + { + /* Page0 receiving data */ + if (PageStatus0 == RECEIVE_DATA) + { + return PAGE0; /* Page0 valid */ + } + else + { + return PAGE1; /* Page1 valid */ + } + } + else if (PageStatus0 == VALID_PAGE) + { + /* Page1 receiving data */ + if (PageStatus1 == RECEIVE_DATA) + { + return PAGE1; /* Page1 valid */ + } + else + { + return PAGE0; /* Page0 valid */ + } + } + else + { + return NO_VALID_PAGE; /* No valid Page */ + } + + case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */ + if (PageStatus0 == VALID_PAGE) + { + return PAGE0; /* Page0 valid */ + } + else if (PageStatus1 == VALID_PAGE) + { + return PAGE1; /* Page1 valid */ + } + else + { + return NO_VALID_PAGE ; /* No valid Page */ + } + + default: + return PAGE0; /* Page0 valid */ + } +} + +/** + * @brief Verify if active page is full and Writes variable in EEPROM. + * @param VirtAddress: 16 bit virtual address of the variable + * @param Data: 16 bit data to be written as variable value + * @retval Success or error status: + * - FLASH_COMPLETE: on success + * - PAGE_FULL: if valid page is full + * - NO_VALID_PAGE: if no valid page was found + * - Flash error code: on write Flash error + */ +static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data) +{ + HAL_StatusTypeDef FlashStatus = HAL_OK; + uint16_t ValidPage = PAGE0; + uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE; + + /* Get valid Page for write operation */ + ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE); + + /* Check if there is no valid page */ + if (ValidPage == NO_VALID_PAGE) + { + return NO_VALID_PAGE; + } + + /* Get the valid Page start Address */ + Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE)); + + /* Get the valid Page end Address */ + PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 1) + (uint32_t)((ValidPage + 1) * PAGE_SIZE)); + + /* Check each active page address starting from begining */ + while (Address < PageEndAddress) + { + /* Verify if Address and Address+2 contents are 0xFFFFFFFF */ + if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF) + { + /* Set variable data */ + FlashStatus = FLASH_ProgramHalfWordF4(Address, Data); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + /* Set variable virtual address */ + FlashStatus = FLASH_ProgramHalfWordF4(Address + 2, VirtAddress); + /* Return program operation status */ + return FlashStatus; + } + else + { + /* Next address location */ + Address = Address + 4; + } + } + + /* Return PAGE_FULL in case the valid page is full */ + return PAGE_FULL; +} + +/** + * @brief Transfers last updated variables data from the full Page to + * an empty one. + * @param VirtAddress: 16 bit virtual address of the variable + * @param Data: 16 bit data to be written as variable value + * @retval Success or error status: + * - FLASH_COMPLETE: on success + * - PAGE_FULL: if valid page is full + * - NO_VALID_PAGE: if no valid page was found + * - Flash error code: on write Flash error + */ +static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data) +{ + HAL_StatusTypeDef FlashStatus = HAL_OK; + uint32_t NewPageAddress = EEPROM_START_ADDRESS; + uint16_t OldPageId=0; + uint16_t ValidPage = PAGE0, VarIdx = 0; + uint16_t EepromStatus = 0, ReadStatus = 0; + + /* Get active Page for read operation */ + ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE); + + if (ValidPage == PAGE1) /* Page1 valid */ + { + /* New page address where variable will be moved to */ + NewPageAddress = PAGE0_BASE_ADDRESS; + + /* Old page ID where variable will be taken from */ + OldPageId = PAGE1_ID; + } + else if (ValidPage == PAGE0) /* Page0 valid */ + { + /* New page address where variable will be moved to */ + NewPageAddress = PAGE1_BASE_ADDRESS; + + /* Old page ID where variable will be taken from */ + OldPageId = PAGE0_ID; + } + else + { + return NO_VALID_PAGE; /* No valid Page */ + } + + /* Set the new Page status to RECEIVE_DATA status */ + FlashStatus = FLASH_ProgramHalfWordF4(NewPageAddress, RECEIVE_DATA); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + + /* Write the variable passed as parameter in the new active page */ + EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data); + /* If program operation was failed, a Flash error code is returned */ + if (EepromStatus != HAL_OK) + { + return EepromStatus; + } + + /* Transfer process: transfer variables from old to the new active page */ + for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) + { + if (VirtAddVarTab[VarIdx] != VirtAddress) /* Check each variable except the one passed as parameter */ + { + /* Read the other last variable updates */ + ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); + /* In case variable corresponding to the virtual address was found */ + if (ReadStatus != 0x1) + { + /* Transfer the variable to the new active page */ + EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); + /* If program operation was failed, a Flash error code is returned */ + if (EepromStatus != HAL_OK) + { + return EepromStatus; + } + } + } + } + + /* Erase the old Page: Set old Page status to ERASED status */ + FlashStatus = FLASH_EraseSectorF4(OldPageId); + /* If erase operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + + /* Set new Page status to VALID_PAGE status */ + FlashStatus = FLASH_ProgramHalfWordF4(NewPageAddress, VALID_PAGE); + /* If program operation was failed, a Flash error code is returned */ + if (FlashStatus != HAL_OK) + { + return FlashStatus; + } + + /* Return last operation flash status */ + return FlashStatus; +} + +/* flash operation */ + +#define EraseTimeout ((uint32_t)0x00000FFF) +#define ProgramTimeout ((uint32_t)0x0000001F) + +#define FLASH_PSIZE_BYTE 0 +#define FLASH_PSIZE_HFWORD FLASH_CR_PSIZE_0 +#define FLASH_PSIZE_WORD FLASH_CR_PSIZE_1 +#define FLASH_CR_SNB_Pos 3 +#define FLASH_KEY1_F4 0x45670123 +#define FLASH_KEY2_F4 0xCDEF89AB + +#define ASSERT(exp) (void)((0)) + +static void Flash_Delay(void) +{ + __IO uint32_t i = 0; + for(i = 0xFF; i != 0; i--) { } +} + +static HAL_StatusTypeDef FLASH_GetStatus(void) +{ + if ((FLASH->SR & FLASH_SR_BSY) == FLASH_SR_BSY) + return HAL_BUSY; + + if ((FLASH->SR & (FLASH_SR_PGSERR|FLASH_SR_PGPERR|FLASH_SR_PGAERR)) != 0) + return HAL_ERROR; + + if ((FLASH->SR & FLASH_SR_WRPERR) != 0 ) + return HAL_ERROR; + + if ((FLASH->SR & FLASH_SR_SOP) != 0 ) + return HAL_ERROR; + + return HAL_OK; +} + +static HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t timeout) +{ + /* Check for the Flash Status */ + HAL_StatusTypeDef status = FLASH_GetStatus(); + /* Wait for a Flash operation to complete or a TIMEOUT to occur */ + while ((status == HAL_BUSY) && (timeout != 0x00)) + { + Flash_Delay(); + status = FLASH_GetStatus(); + timeout--; + } + if (timeout == 0) + status = HAL_TIMEOUT; + + return status; +} +HAL_StatusTypeDef FLASH_UnlockF4(void) +{ + FLASH->KEYR = FLASH_KEY1_F4; + FLASH->KEYR = FLASH_KEY2_F4; + return HAL_OK; +} + +HAL_StatusTypeDef FLASH_EraseSectorF4(uint32_t sector) +{ + HAL_StatusTypeDef status = HAL_OK; + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(EraseTimeout); + + if(status == HAL_OK) { + /* if the previous operation is completed, proceed to erase the page */ + CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE); + FLASH->CR |= FLASH_PSIZE_WORD; + CLEAR_BIT(FLASH->CR, FLASH_CR_SNB); + FLASH->CR |= FLASH_CR_SER | (sector << FLASH_CR_SNB_Pos); + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(EraseTimeout); + if(status != HAL_TIMEOUT) + { + /* if the erase operation is completed, disable the PER Bit */ + FLASH->CR &= ~FLASH_CR_SNB; + FLASH->CR &= ~FLASH_CR_SER; + } + + FLASH->SR = (FLASH_SR_EOP | FLASH_SR_SOP | FLASH_SR_WRPERR); + } + /* Return the Erase Status */ + return status; +} + +HAL_StatusTypeDef FLASH_ProgramHalfWordF4(uint32_t address, uint16_t data) +{ + HAL_StatusTypeDef status = HAL_ERROR; + + if (IS_FLASH_ADDRESS(address)) + { + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(ProgramTimeout); + if(status == HAL_OK) { + // set size to byte + FLASH->CR &= ~FLASH_CR_PSIZE; + FLASH->CR |= FLASH_PSIZE_HFWORD; + FLASH->CR |= FLASH_CR_PG; + + *(__IO uint16_t*)address = data; + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(ProgramTimeout); + if(status != HAL_TIMEOUT) + { + /* if the program operation is completed, disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + FLASH->SR = (FLASH_SR_EOP | FLASH_SR_SOP | FLASH_SR_PGSERR | FLASH_SR_PGPERR | FLASH_SR_PGAERR | FLASH_SR_WRPERR); + } + } + return status; +} + +/** + * @} + */ + +/******************* (C) COPYRIGHT 2017 STMicroelectronics *****END OF FILE****/ |