Support cached internal flash on the H743

Author: hierophect

ports/stm/Makefile

@@ -187,10 +187,7 @@ SRC_STM32 = $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES_LOWER)xx_,\
 	ll_rcc.c \
 	ll_utils.c \
 	ll_exti.c \
-	)
-#removed:
-# hal_flash_ramfunc.c \
-# ll_fsmc.c \
+)
 
 SRC_STM32 += system_stm32$(MCU_SERIES_LOWER)xx.c
 

ports/stm/boards/stm32h743zi_discovery/board.c renamed to ports/stm/boards/stm32h743zi2_discovery/board.c

@@ -2,9 +2,9 @@ USB_VID = 0x239A #REPLACE
 USB_PID = 0x808A #REPLACE
 USB_PRODUCT = "STM32H743ZI Discovery Board - CPy"
 USB_MANUFACTURER = "STMicroelectronics"
-USB_DEVICES = "CDC,HID"
+USB_DEVICES = "CDC,MSC"
 
-DISABLE_FILESYSTEM = 1
+INTERNAL_FLASH_FILESYSTEM = 1
 
 MCU_SERIES = H7
 MCU_VARIANT = STM32H743xx

ports/stm/boards/stm32h743zi_discovery/mpconfigboard.h renamed to ports/stm/boards/stm32h743zi2_discovery/mpconfigboard.h

@@ -86,7 +86,7 @@ STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_DAC1), MP_ROM_PTR(&pin_PA04) },
     { MP_ROM_QSTR(MP_QSTR_DAC2), MP_ROM_PTR(&pin_PA05) },
     { MP_ROM_QSTR(MP_QSTR_LED1), MP_ROM_PTR(&pin_PB00) },
-    { MP_ROM_QSTR(MP_QSTR_LED2), MP_ROM_PTR(&pin_PB07) },
+    { MP_ROM_QSTR(MP_QSTR_LED2), MP_ROM_PTR(&pin_PE01) },
     { MP_ROM_QSTR(MP_QSTR_LED3), MP_ROM_PTR(&pin_PB14) },
     { MP_ROM_QSTR(MP_QSTR_SW), MP_ROM_PTR(&pin_PC13) },
     { MP_ROM_QSTR(MP_QSTR_I2C1_SDA), MP_ROM_PTR(&pin_PB09) },

ports/stm/boards/stm32h743zi_discovery/mpconfigboard.mk renamed to ports/stm/boards/stm32h743zi2_discovery/mpconfigboard.mk

@@ -33,12 +33,12 @@
 #include STM32_HAL_H
 #include "pins.h"
 
-// PERIPH
+// Comm Peripherals
 
 typedef struct {
-    uint8_t periph_index:4; // Index of the I2C unit (1 to 3)
-    uint8_t altfn_index:4; //Index of the altfn for this pin (0 to 15)
-    const mcu_pin_obj_t * pin;
+    uint8_t periph_index:4;     // Index of the peripheral instance
+    uint8_t altfn_index:4;      // Index of the altfn for this pin (0 to 15)
+    const mcu_pin_obj_t * pin;  // Pin Object
 } mcu_periph_obj_t;
 
 #define PERIPH(index, alt, p_pin)       \
@@ -48,7 +48,8 @@ typedef struct {
     .pin = p_pin, \
 }
 
-//Timers
+// Timer Peripheral
+
 typedef struct {
     uint8_t tim_index:4; 
     uint8_t altfn_index:4; 

ports/stm/boards/stm32h743zi_discovery/pins.c renamed to ports/stm/boards/stm32h743zi2_discovery/pins.c

@@ -4,7 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2019 Lucian Copeland for Adafruit Industries
+ * Copyright (c) 2020 Lucian Copeland for Adafruit Industries
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -35,6 +35,7 @@
 #include "py/obj.h"
 #include "py/runtime.h"
 #include "lib/oofatfs/ff.h"
+#include "supervisor/shared/safe_mode.h"
 
 typedef struct {
     uint32_t base_address;
@@ -46,7 +47,9 @@ typedef struct {
 /* Internal Flash API
  *------------------------------------------------------------------*/
 
-static const flash_layout_t flash_layout[] = {
+#if defined(STM32F4)
+
+STATIC const flash_layout_t flash_layout[] = {
     { 0x08000000, 0x04000, 4 },
     { 0x08010000, 0x10000, 1 },
     { 0x08020000, 0x20000, 3 },
@@ -59,12 +62,45 @@ static const flash_layout_t flash_layout[] = {
     { 0x08120000, 0x20000, 7 },
     #endif
 };
+STATIC uint8_t  _flash_cache[0x4000] __attribute__((aligned(4)));
+
+#elif defined(STM32H7)
+
+STATIC const flash_layout_t flash_layout[] = {
+    { 0x08000000, 0x20000, 16 },
+};
+STATIC uint8_t  _flash_cache[0x20000] __attribute__((aligned(4)));
+
+#else
+    #error Unsupported processor
+#endif
 
 #define NO_CACHE        0xffffffff
 #define MAX_CACHE       0x4000
 
-static uint8_t  _flash_cache[0x4000] __attribute__((aligned(4)));
-static uint32_t _cache_flash_addr = NO_CACHE;
+
+STATIC uint32_t _cache_flash_addr = NO_CACHE;
+
+#if defined(STM32H7)
+// get the bank of a given flash address
+STATIC uint32_t get_bank(uint32_t addr) {
+    if (READ_BIT(FLASH->OPTCR, FLASH_OPTCR_SWAP_BANK) == 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;
+        }
+    }
+}
+#endif
 
 //Return the sector of a given flash address. 
 uint32_t flash_get_sector_info(uint32_t addr, uint32_t *start_addr, uint32_t *size) {
@@ -105,50 +141,98 @@ uint32_t supervisor_flash_get_block_count(void) {
 void supervisor_flash_flush(void) {
     if (_cache_flash_addr == NO_CACHE) return;
 
+    #if defined(STM32H7)
+    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS_BANK1 | FLASH_FLAG_ALL_ERRORS_BANK2);
+    #else
+    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
+                           FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
+    #endif
+
+    // set up for erase
+    FLASH_EraseInitTypeDef EraseInitStruct;
+    EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
+    EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V
+    // get the sector information
+    uint32_t sector_size;
+    uint32_t sector_start_addr;
+    #if defined(STM32H7)
+    EraseInitStruct.Banks = get_bank(_cache_flash_addr);
+    #endif
+    EraseInitStruct.Sector = flash_get_sector_info(_cache_flash_addr, &sector_start_addr, &sector_size);
+    EraseInitStruct.NbSectors = 1;
+    if (sector_size > sizeof(_flash_cache)) {
+        __ASM volatile ("bkpt");
+        mp_printf(&mp_plat_print, "FLASH ERR: invalid sector\n");
+        reset_into_safe_mode(FLASH_WRITE_FAIL);
+    }
+
     // Skip if data is the same
-    if (memcmp(_flash_cache, (void *)_flash_page_addr, FLASH_PAGE_SIZE) != 0) {
+    if (memcmp(_flash_cache, (void *)_cache_flash_addr, sector_size) != 0) {
         // unlock flash
         HAL_FLASH_Unlock();
 
-        // set up for erase
-        FLASH_EraseInitTypeDef EraseInitStruct;
-        EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
-        EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V
-        // get the sector information
-        uint32_t sector_size;
-        uint32_t sector_start_addr;
-        EraseInitStruct.Sector = flash_get_sector_info(_cache_flash_addr, &sector_start_addr, &sector_size);
-        EraseInitStruct.NbSectors = 1;
-        if (sector_size>0x4000) return false;
-
         // erase the sector
         uint32_t SectorError = 0;
         if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) {
             // error occurred during sector erase
             HAL_FLASH_Lock(); // lock the flash
-            mp_printf(&mp_plat_print, "FLASH SECTOR ERASE ERROR");
-            return false;
+            __ASM volatile ("bkpt");
+            mp_printf(&mp_plat_print, "FLASH ERR: erase failure\n");
+            reset_into_safe_mode(FLASH_WRITE_FAIL);
         }
 
-        __HAL_FLASH_DATA_CACHE_DISABLE();
-        __HAL_FLASH_INSTRUCTION_CACHE_DISABLE();
-
-        __HAL_FLASH_DATA_CACHE_RESET();
-        __HAL_FLASH_INSTRUCTION_CACHE_RESET();
-
-        __HAL_FLASH_INSTRUCTION_CACHE_ENABLE();
-        __HAL_FLASH_DATA_CACHE_ENABLE();
+        // __HAL_FLASH_DATA_CACHE_DISABLE();
+        // __HAL_FLASH_INSTRUCTION_CACHE_DISABLE();
+
+        // __HAL_FLASH_DATA_CACHE_RESET();
+        // __HAL_FLASH_INSTRUCTION_CACHE_RESET();
+
+        // __HAL_FLASH_INSTRUCTION_CACHE_ENABLE();
+        // __HAL_FLASH_DATA_CACHE_ENABLE();
+
+        // // reprogram the sector
+        // for (uint32_t i = 0; i < sector_size; i++) {
+        //     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, sector_start_addr, (uint64_t)_flash_cache[i]) != HAL_OK) {
+        //         // error occurred during flash write
+        //         HAL_FLASH_Lock(); // lock the flash
+        //         mp_printf(&mp_plat_print, "FLASH WRITE ERROR");
+        //     }
+        //     sector_start_addr += 1;
+        // }
+
+        uint32_t * cache_addr = (uint32_t*)_flash_cache;
+
+        #if defined(STM32H7)
+        for (uint32_t i = 0; i < (sector_size / 32); i++) {
+            // Note that the STM32H7 HAL interface differs by taking an address, not 64 bit data
+            // This is because ST's code is written by a large room of chimpanzees
+            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, sector_start_addr, 
+                                  (uint32_t)cache_addr) != HAL_OK) {
+                // error occurred during flash write
+                HAL_FLASH_Lock(); // lock the flash
+                __ASM volatile ("bkpt");
+                reset_into_safe_mode(FLASH_WRITE_FAIL);
+            }
+            // RAM memory is by word (4 byte), but flash memory is by byte
+            cache_addr += 8;
+            sector_start_addr += 32;
+        }
 
-        // reprogram the sector
-        for (uint32_t i = 0; i < sector_size; i++) {
-            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, sector_start_addr, (uint64_t)_flash_cache[i]) != HAL_OK) {
+        #else // STM32F4
+        // program the flash word by word
+        for (uint32_t i = 0; i < sector_size / 4; i++) {
+            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, sector_start_addr, 
+                                  (uint64_t)*cache_addr) != HAL_OK) {
                 // error occurred during flash write
                 HAL_FLASH_Lock(); // lock the flash
-                mp_printf(&mp_plat_print, "FLASH WRITE ERROR");
-                return false;
+                __ASM volatile ("bkpt");
+                reset_into_safe_mode(FLASH_WRITE_FAIL);
             }
-            sector_start_addr += 1;
+            // RAM memory is by word (4 byte), but flash memory is by byte
+            cache_addr += 1;
+            sector_start_addr += 4;
         }
+        #endif
 
         // lock the flash
         HAL_FLASH_Lock();
@@ -165,6 +249,9 @@ static int32_t convert_block_to_flash_addr(uint32_t block) {
 }
 
 mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block, uint32_t num_blocks) {
+    // Must write out anything in cache before trying to read.
+    supervisor_flash_flush();
+
     int32_t src = convert_block_to_flash_addr(block);
     if (src == -1) {
         // bad block number
@@ -174,103 +261,33 @@ mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block, uint32_t n
     return 0; // success
 }
 
-bool supervisor_flash_write_block(const uint8_t *src, uint32_t block) {
-    int32_t dest = convert_block_to_flash_addr(block);
-    if (dest == -1) {
-        // bad block number
-        mp_printf(&mp_plat_print, "BAD FLASH BLOCK ERROR");
-        return false;
-    }
-
-    // unlock flash
-    HAL_FLASH_Unlock();
-
-    // set up for erase
-    FLASH_EraseInitTypeDef EraseInitStruct;
-    EraseInitStruct.TypeErase = TYPEERASE_SECTORS;
-    EraseInitStruct.VoltageRange = VOLTAGE_RANGE_3; // voltage range needs to be 2.7V to 3.6V
-    // get the sector information
-    uint32_t sector_size;
-    uint32_t sector_start_addr;
-    EraseInitStruct.Sector = flash_get_sector_info(dest, &sector_start_addr, &sector_size);
-    EraseInitStruct.NbSectors = 1;
-    if (sector_size>0x4000) return false;
-
-    // copy the sector
-    memcpy(sector_copy,(void *)sector_start_addr,sector_size);
-
-    // // overwrite sector data
-    memcpy(sector_copy+(dest-sector_start_addr),src,FILESYSTEM_BLOCK_SIZE);
-
-    // find end address, subtract for number of sectors
-    // Shouldn't be required since blocks will always fit in a single sector, they should never overlap
-    //EraseInitStruct.NbSectors = flash_get_sector_info(dest + FILESYSTEM_BLOCK_SIZE - 1, NULL, NULL) - EraseInitStruct.Sector + 1;
-
-    // erase the sector
-    uint32_t SectorError = 0;
-    if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) {
-        // error occurred during sector erase
-        HAL_FLASH_Lock(); // lock the flash
-        mp_printf(&mp_plat_print, "FLASH SECTOR ERASE ERROR");
-        return false;
-    }
-
-    __HAL_FLASH_DATA_CACHE_DISABLE();
-    __HAL_FLASH_INSTRUCTION_CACHE_DISABLE();
-
-    __HAL_FLASH_DATA_CACHE_RESET();
-    __HAL_FLASH_INSTRUCTION_CACHE_RESET();
-
-    __HAL_FLASH_INSTRUCTION_CACHE_ENABLE();
-    __HAL_FLASH_DATA_CACHE_ENABLE();
-
-    // reprogram the sector
-    for (uint32_t i = 0; i < sector_size; i++) {
-        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, sector_start_addr, (uint64_t)sector_copy[i]) != HAL_OK) {
-            // error occurred during flash write
-            HAL_FLASH_Lock(); // lock the flash
-            mp_printf(&mp_plat_print, "FLASH WRITE ERROR");
-            return false;
-        }
-        sector_start_addr += 1;
-    }
-
-    // lock the flash
-    HAL_FLASH_Lock();
-
-    return true;
-}
-
-// mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks) {
-
-//     for (size_t i = 0; i < num_blocks; i++) {
-//         if (!supervisor_flash_write_block(src + i * FILESYSTEM_BLOCK_SIZE, block_num + i)) {
-//             return 1; // error
-//         }
-//     }
-//     return 0; // success
-// }
-
 mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks) {
     while (num_blocks) {
-        int32_t dest = convert_block_to_flash_addr(block);
+        int32_t dest = convert_block_to_flash_addr(block_num);
         if (dest == -1) {
             // bad block number
+            __ASM volatile ("bkpt");
             mp_printf(&mp_plat_print, "BAD FLASH BLOCK ERROR");
             return false;
         }
 
         // unlock flash
         HAL_FLASH_Unlock();
 
+        uint32_t sector_size;
+        uint32_t sector_start_addr;
         flash_get_sector_info(dest, &sector_start_addr, &sector_size);
 
         // Fail for any sector outside the 16k ones for now
-        if (sector_size > 0x4000) return false;
+        if (sector_size > sizeof(_flash_cache)) {
+            __ASM volatile ("bkpt");
+            mp_printf(&mp_plat_print, "FLASH ERR: invalid sector\n");
+            reset_into_safe_mode(FLASH_WRITE_FAIL);
+        }
 
         // Find how many blocks are left in the sector
         uint32_t count = (sector_size - (dest - sector_start_addr))/FILESYSTEM_BLOCK_SIZE;
-        count = MIN(num_blocks, count); `
+        count = MIN(num_blocks, count);
 
         if (_cache_flash_addr != sector_start_addr) {
             // Write out anything in cache before overwriting it.