| /* |
| * This file is part of the MicroPython project, http://micropython.org/ |
| * |
| * The MIT License (MIT) |
| * |
| * Copyright (c) 2013, 2014 Damien P. George |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| |
| #include "py/mpconfig.h" |
| #include "py/misc.h" |
| #include "flash.h" |
| |
| typedef struct { |
| uint32_t base_address; |
| uint32_t sector_size; |
| uint32_t sector_count; |
| } flash_layout_t; |
| |
| #if defined(MCU_SERIES_F4) |
| |
| static const flash_layout_t flash_layout[] = { |
| { 0x08000000, 0x04000, 4 }, |
| { 0x08010000, 0x10000, 1 }, |
| { 0x08020000, 0x20000, 3 }, |
| #if defined(FLASH_SECTOR_8) |
| { 0x08080000, 0x20000, 4 }, |
| #endif |
| #if defined(FLASH_SECTOR_12) |
| { 0x08100000, 0x04000, 4 }, |
| { 0x08110000, 0x10000, 1 }, |
| { 0x08120000, 0x20000, 7 }, |
| #endif |
| }; |
| |
| #elif defined(MCU_SERIES_F7) |
| |
| // FLASH_FLAG_PGSERR (Programming Sequence Error) was renamed to |
| // FLASH_FLAG_ERSERR (Erasing Sequence Error) in STM32F7 |
| #define FLASH_FLAG_PGSERR FLASH_FLAG_ERSERR |
| |
| static const flash_layout_t flash_layout[] = { |
| { 0x08000000, 0x08000, 4 }, |
| { 0x08020000, 0x20000, 1 }, |
| { 0x08040000, 0x40000, 3 }, |
| }; |
| |
| #elif defined(MCU_SERIES_L4) |
| |
| static const flash_layout_t flash_layout[] = { |
| { (uint32_t)FLASH_BASE, (uint32_t)FLASH_PAGE_SIZE, 512 }, |
| }; |
| |
| #else |
| #error Unsupported processor |
| #endif |
| |
| #if defined(MCU_SERIES_L4) |
| |
| // get the bank of a given flash address |
| static uint32_t get_bank(uint32_t addr) { |
| if (READ_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_FB_MODE) == 0) { |
| // no bank swap |
| if (addr < (FLASH_BASE + FLASH_BANK_SIZE)) { |
| return FLASH_BANK_1; |
| } else { |
| return FLASH_BANK_2; |
| } |
| } else { |
| // bank swap |
| if (addr < (FLASH_BASE + FLASH_BANK_SIZE)) { |
| return FLASH_BANK_2; |
| } else { |
| return FLASH_BANK_1; |
| } |
| } |
| } |
| |
| // get the page of a given flash address |
| static uint32_t get_page(uint32_t addr) { |
| if (addr < (FLASH_BASE + FLASH_BANK_SIZE)) { |
| // bank 1 |
| return (addr - FLASH_BASE) / FLASH_PAGE_SIZE; |
| } else { |
| // bank 2 |
| return (addr - (FLASH_BASE + FLASH_BANK_SIZE)) / FLASH_PAGE_SIZE; |
| } |
| } |
| |
| #endif |
| |
| uint32_t flash_get_sector_info(uint32_t addr, uint32_t *start_addr, uint32_t *size) { |
| if (addr >= flash_layout[0].base_address) { |
| uint32_t sector_index = 0; |
| for (int i = 0; i < MP_ARRAY_SIZE(flash_layout); ++i) { |
| for (int j = 0; j < flash_layout[i].sector_count; ++j) { |
| uint32_t sector_start_next = flash_layout[i].base_address |
| + (j + 1) * flash_layout[i].sector_size; |
| if (addr < sector_start_next) { |
| if (start_addr != NULL) { |
| *start_addr = flash_layout[i].base_address |
| + j * flash_layout[i].sector_size; |
| } |
| if (size != NULL) { |
| *size = flash_layout[i].sector_size; |
| } |
| return sector_index; |
| } |
| ++sector_index; |
| } |
| } |
| } |
| return 0; |
| } |
| |
| void flash_erase(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) { |
| // check there is something to write |
| if (num_word32 == 0) { |
| return; |
| } |
| |
| // unlock |
| HAL_FLASH_Unlock(); |
| |
| FLASH_EraseInitTypeDef EraseInitStruct; |
| |
| #if defined(MCU_SERIES_L4) |
| __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS); |
| |
| // erase the sector(s) |
| // The sector returned by flash_get_sector_info can not be used |
| // as the flash has on each bank 0/1 pages 0..255 |
| EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES; |
| EraseInitStruct.Banks = get_bank(flash_dest); |
| EraseInitStruct.Page = get_page(flash_dest); |
| EraseInitStruct.NbPages = get_page(flash_dest + 4 * num_word32 - 1) - EraseInitStruct.Page + 1;; |
| #else |
| // Clear pending flags (if any) |
| __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | |
| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); |
| |
| // erase the sector(s) |
| EraseInitStruct.TypeErase = TYPEERASE_SECTORS; |
| EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V |
| EraseInitStruct.Sector = flash_get_sector_info(flash_dest, NULL, NULL); |
| EraseInitStruct.NbSectors = flash_get_sector_info(flash_dest + 4 * num_word32 - 1, NULL, NULL) - EraseInitStruct.Sector + 1; |
| #endif |
| |
| uint32_t SectorError = 0; |
| if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) { |
| // error occurred during sector erase |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| } |
| |
| /* |
| // erase the sector using an interrupt |
| void flash_erase_it(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) { |
| // check there is something to write |
| if (num_word32 == 0) { |
| return; |
| } |
| |
| // unlock |
| HAL_FLASH_Unlock(); |
| |
| // Clear pending flags (if any) |
| __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | |
| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); |
| |
| // erase the sector(s) |
| FLASH_EraseInitTypeDef EraseInitStruct; |
| EraseInitStruct.TypeErase = TYPEERASE_SECTORS; |
| EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V |
| EraseInitStruct.Sector = flash_get_sector_info(flash_dest, NULL, NULL); |
| EraseInitStruct.NbSectors = flash_get_sector_info(flash_dest + 4 * num_word32 - 1, NULL, NULL) - EraseInitStruct.Sector + 1; |
| if (HAL_FLASHEx_Erase_IT(&EraseInitStruct) != HAL_OK) { |
| // error occurred during sector erase |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| } |
| */ |
| |
| void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) { |
| #if defined(MCU_SERIES_L4) |
| |
| // program the flash uint64 by uint64 |
| for (int i = 0; i < num_word32 / 2; i++) { |
| uint64_t val = *(uint64_t*)src; |
| if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, flash_dest, val) != HAL_OK) { |
| // error occurred during flash write |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| flash_dest += 8; |
| src += 2; |
| } |
| if ((num_word32 & 0x01) == 1) { |
| uint64_t val = *(uint64_t*)flash_dest; |
| val = (val & 0xffffffff00000000uL) | (*src); |
| if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, flash_dest, val) != HAL_OK) { |
| // error occurred during flash write |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| } |
| |
| #else |
| |
| // program the flash word by word |
| for (int i = 0; i < num_word32; i++) { |
| if (HAL_FLASH_Program(TYPEPROGRAM_WORD, flash_dest, *src) != HAL_OK) { |
| // error occurred during flash write |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| flash_dest += 4; |
| src += 1; |
| } |
| |
| #endif |
| |
| // lock the flash |
| HAL_FLASH_Lock(); |
| } |
| |
| /* |
| use erase, then write |
| void flash_erase_and_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) { |
| // check there is something to write |
| if (num_word32 == 0) { |
| return; |
| } |
| |
| // unlock |
| HAL_FLASH_Unlock(); |
| |
| // Clear pending flags (if any) |
| __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | |
| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); |
| |
| // erase the sector(s) |
| FLASH_EraseInitTypeDef EraseInitStruct; |
| EraseInitStruct.TypeErase = TYPEERASE_SECTORS; |
| EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V |
| EraseInitStruct.Sector = flash_get_sector_info(flash_dest, NULL, NULL); |
| EraseInitStruct.NbSectors = flash_get_sector_info(flash_dest + 4 * num_word32 - 1, NULL, NULL) - EraseInitStruct.Sector + 1; |
| uint32_t SectorError = 0; |
| if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) { |
| // error occurred during sector erase |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| |
| // program the flash word by word |
| for (int i = 0; i < num_word32; i++) { |
| if (HAL_FLASH_Program(TYPEPROGRAM_WORD, flash_dest, *src) != HAL_OK) { |
| // error occurred during flash write |
| HAL_FLASH_Lock(); // lock the flash |
| return; |
| } |
| flash_dest += 4; |
| src += 1; |
| } |
| |
| // lock the flash |
| HAL_FLASH_Lock(); |
| } |
| */ |