Allow the use of EEPROM_IN_RAM on MCUs. (#8376)

Allow the use of EEPROM_IN_RAM on MCUs.

src/main/cli/cli.c

@@ -31,10 +31,6 @@
 // FIXME remove this for targets that don't need a CLI.  Perhaps use a no-op macro when USE_CLI is not enabled
 // signal that we're in cli mode
 uint8_t cliMode = 0;
-#ifndef EEPROM_IN_RAM
-extern uint8_t __config_start;   // configured via linker script when building binaries.
-extern uint8_t __config_end;
-#endif
 
 #ifdef USE_CLI
 
@@ -4280,12 +4276,7 @@ static void cliStatus(char *cmdline)
 #endif
     cliPrintLinefeed();
 
-#ifdef EEPROM_IN_RAM
-#define CONFIG_SIZE EEPROM_SIZE
-#else
-#define CONFIG_SIZE (&__config_end - &__config_start)
-#endif
-    cliPrintLinef("Config size: %d, Max available config: %d", getEEPROMConfigSize(), CONFIG_SIZE);
+    cliPrintLinef("Config size: %d, Max available config: %d", getEEPROMConfigSize(), getEEPROMStorageSize());
 
     // Sensors
 

src/main/config/config_eeprom.c

@@ -36,11 +36,6 @@
 
 #include "drivers/system.h"
 
-#ifndef EEPROM_IN_RAM
-extern uint8_t __config_start;   // configured via linker script when building binaries.
-extern uint8_t __config_end;
-#endif
-
 static uint16_t eepromConfigSize;
 
 typedef enum {
@@ -92,6 +87,10 @@ void initEEPROM(void)
 
     STATIC_ASSERT(sizeof(configFooter_t) == 2, footer_size_failed);
     STATIC_ASSERT(sizeof(configRecord_t) == 6, record_size_failed);
+
+#ifdef EEPROM_IN_FILE
+    FLASH_Unlock(); // load existing config file into eepromData
+#endif
 }
 
 bool isEEPROMVersionValid(void)
@@ -158,6 +157,15 @@ uint16_t getEEPROMConfigSize(void)
     return eepromConfigSize;
 }
 
+size_t getEEPROMStorageSize(void)
+{
+#ifdef EEPROM_IN_RAM
+    return EEPROM_SIZE;
+#else
+    return &__config_end - &__config_start;
+#endif
+}
+
 // find config record for reg + classification (profile info) in EEPROM
 // return NULL when record is not found
 // this function assumes that EEPROM content is valid

src/main/config/config_eeprom.h

@@ -29,4 +29,6 @@ bool isEEPROMVersionValid(void);
 bool isEEPROMStructureValid(void);
 bool loadEEPROM(void);
 void writeConfigToEEPROM(void);
+
 uint16_t getEEPROMConfigSize(void);
+size_t getEEPROMStorageSize(void);

src/main/config/config_streamer.c

@@ -26,11 +26,6 @@
 
 #include "config/config_streamer.h"
 
-#ifndef EEPROM_IN_RAM
-extern uint8_t __config_start;   // configured via linker script when building binaries.
-extern uint8_t __config_end;
-#endif
-
 // @todo this is not strictly correct for F4/F7, where sector sizes are variable
 #if !defined(FLASH_PAGE_SIZE)
 // F1
@@ -83,14 +78,22 @@ void config_streamer_start(config_streamer_t *c, uintptr_t base, int size)
     c->address = base;
     c->size = size;
     if (!c->unlocked) {
+
+#if defined(EEPROM_IN_RAM)
+        // NOP
+#elif defined(EEPROM_IN_FLASH) || defined(EEPROM_IN_FILE)
 #if defined(STM32F7) || defined(STM32H7)
         HAL_FLASH_Unlock();
 #else
         FLASH_Unlock();
+#endif
 #endif
         c->unlocked = true;
     }
 
+#if defined(EEPROM_IN_RAM) || defined(EEPROM_IN_FILE)
+    // NOP
+#elif defined(EEPROM_IN_FLASH)
 #if defined(STM32F10X)
     FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
 #elif defined(STM32F303)
@@ -105,10 +108,14 @@ void config_streamer_start(config_streamer_t *c, uintptr_t base, int size)
     // NOP
 #else
 # error "Unsupported CPU"
+#endif
 #endif
     c->err = 0;
 }
 
+#if defined(EEPROM_IN_RAM)
+// No flash sector method required.
+#elif defined(EEPROM_IN_FLASH)
 #if defined(STM32F745xx) || defined(STM32F746xx) || defined(STM32F765xx)
 /*
 Sector 0    0x08000000 - 0x08007FFF 32 Kbytes
@@ -333,12 +340,42 @@ static void getFLASHSectorForEEPROM(uint32_t *bank, uint32_t *sector)
     }
 }
 #endif
+#endif
 
 static int write_word(config_streamer_t *c, config_streamer_buffer_align_type_t *buffer)
 {
     if (c->err != 0) {
         return c->err;
     }
+#if defined(EEPROM_IN_RAM)
+    if (c->address == (uintptr_t)&eepromData[0]) {
+        memset(eepromData, 0, sizeof(eepromData));
+    }
+
+    uint64_t *dest_addr = (uint64_t *)c->address;
+    uint64_t *src_addr = (uint64_t*)buffer;
+    uint8_t row_index = 4;
+    /* Program the 256 bits flash word */
+    do
+    {
+      *dest_addr++ = *src_addr++;
+    } while (--row_index != 0);
+
+#elif defined(EEPROM_IN_FILE)
+
+    if (c->address % FLASH_PAGE_SIZE == 0) {
+        const FLASH_Status status = FLASH_ErasePage(c->address);
+        if (status != FLASH_COMPLETE) {
+            return -1;
+        }
+    }
+    const FLASH_Status status = FLASH_ProgramWord(c->address, *buffer);
+    if (status != FLASH_COMPLETE) {
+        return -2;
+    }
+
+#elif defined(EEPROM_IN_FLASH)
+
 #if defined(STM32H7)
     if (c->address % FLASH_PAGE_SIZE == 0) {
         FLASH_EraseInitTypeDef EraseInitStruct = {
@@ -385,7 +422,7 @@ static int write_word(config_streamer_t *c, config_streamer_buffer_align_type_t
     if (c->address % FLASH_PAGE_SIZE == 0) {
 #if defined(STM32F4)
         const FLASH_Status status = FLASH_EraseSector(getFLASHSectorForEEPROM(), VoltageRange_3); //0x08080000 to 0x080A0000
-#else // STM32F3 or STM32F1
+#else // STM32F3, STM32F1
         const FLASH_Status status = FLASH_ErasePage(c->address);
 #endif
         if (status != FLASH_COMPLETE) {
@@ -396,6 +433,7 @@ static int write_word(config_streamer_t *c, config_streamer_buffer_align_type_t
     if (status != FLASH_COMPLETE) {
         return -2;
     }
+#endif
 #endif
     c->address += CONFIG_STREAMER_BUFFER_SIZE;
     return 0;
@@ -432,10 +470,16 @@ int config_streamer_flush(config_streamer_t *c)
 int config_streamer_finish(config_streamer_t *c)
 {
     if (c->unlocked) {
+#if defined(EEPROM_IN_RAM)
+        // NOP
+#elif defined(EEPROM_IN_FILE)
+        FLASH_Lock();
+#elif defined(EEPROM_IN_FLASH)
 #if defined(STM32F7) || defined(STM32H7)
         HAL_FLASH_Lock();
 #else
         FLASH_Lock();
+#endif
 #endif
         c->unlocked = false;
     }

src/main/target/SITL/target.c

@@ -212,7 +212,6 @@ void systemInit(void) {
     printf("[system]Init...\n");
 
     SystemCoreClock = 500 * 1e6; // fake 500MHz
-    FLASH_Unlock();
 
     if (pthread_mutex_init(&updateLock, NULL) != 0) {
         printf("Create updateLock error!\n");

src/main/target/SITL/target.h

@@ -42,7 +42,7 @@
 
 // file name to save config
 #define EEPROM_FILENAME "eeprom.bin"
-#define EEPROM_IN_RAM
+#define EEPROM_IN_FILE
 #define EEPROM_SIZE     32768
 
 #define U_ID_0 0
@@ -144,15 +144,6 @@
 
 extern uint32_t SystemCoreClock;
 
-#ifdef EEPROM_IN_RAM
-extern uint8_t eepromData[EEPROM_SIZE];
-#define __config_start (*eepromData)
-#define __config_end (*ARRAYEND(eepromData))
-#else
-extern uint8_t __config_start;   // configured via linker script when building binaries.
-extern uint8_t __config_end;
-#endif
-
 typedef enum
 {
     Mode_TEST = 0x0,
@@ -263,3 +254,5 @@ uint64_t micros64(void);
 uint64_t millis64(void);
 
 int lockMainPID(void);
+
+

src/main/target/common_post.h

@@ -337,3 +337,18 @@
 #ifdef STM32F7
 #undef USE_ESCSERIAL
 #endif
+
+#if defined(EEPROM_IN_RAM) || defined(EEPROM_IN_FILE)
+#ifndef EEPROM_SIZE
+#define EEPROM_SIZE     4096
+#endif
+extern uint8_t eepromData[EEPROM_SIZE];
+#define __config_start (*eepromData)
+#define __config_end (*ARRAYEND(eepromData))
+#else
+#ifndef EEPROM_IN_FLASH
+#define EEPROM_IN_FLASH
+#endif
+extern uint8_t __config_start;   // configured via linker script when building binaries.
+extern uint8_t __config_end;
+#endif

src/test/unit/cli_unittest.cc

@@ -225,6 +225,10 @@ uint8_t getMotorCount() {
     return 4;
 }
 
+size_t getEEPROMStorageSize() {
+    return 0;
+}
+
 
 void setPrintfSerialPort(struct serialPort_s) {}