Proof of concept for post OTA 1st boot erase config.

esp8266 · mhightower83 · Dec 28, 2019 · Dec 30, 2019 · Dec 30, 2019 · Dec 30, 2019
commit 6fde10f0bbfc3af62418aac38d0feb0a09e7d219
diff --git a/cores/esp8266/Arduino.h b/cores/esp8266/Arduino.h
@@ -39,6 +39,7 @@ extern "C" {
 #include "twi.h"
 #include "core_esp8266_features.h"
 #include "core_esp8266_version.h"
+#include "erase_config.h"
 
 #define HIGH 0x1
 #define LOW  0x0

diff --git a/cores/esp8266/Esp.cpp b/cores/esp8266/Esp.cpp
@@ -502,6 +502,11 @@ struct rst_info * EspClass::getResetInfoPtr(void) {
     return &resetInfo;
 }
 
+#ifdef ERASE_CONFIG_H
+bool EspClass::eraseConfig(const uint32_t flash_erase_mask) {
+    return erase_config(flash_erase_mask);
+}
+#else
 bool EspClass::eraseConfig(void) {
     const size_t cfgSize = 0x4000;
     size_t cfgAddr = ESP.getFlashChipSize() - cfgSize;
@@ -514,6 +519,7 @@ bool EspClass::eraseConfig(void) {
 
     return true;
 }
+#endif
 
 uint32_t EspClass::getSketchSize() {
     static uint32_t result = 0;

diff --git a/cores/esp8266/Esp.h b/cores/esp8266/Esp.h
@@ -191,7 +191,11 @@ class EspClass {
         String getResetInfo();
         struct rst_info * getResetInfoPtr();
 
+#ifdef ERASE_CONFIG_H
+        bool eraseConfig(const uint32_t flash_erase_mask = ERASE_CONFIG_SDK_DATA);
+#else
         bool eraseConfig();
+#endif
 
 #ifndef CORE_MOCK
         inline uint32_t getCycleCount() __attribute__((always_inline));

diff --git a/cores/esp8266/Updater.cpp b/cores/esp8266/Updater.cpp
@@ -1,6 +1,7 @@
 #include "Updater.h"
 #include "eboot_command.h"
 #include <esp8266_peri.h>
+#include <erase_config.h>
 
 //#define DEBUG_UPDATER Serial
 
@@ -34,6 +35,9 @@ UpdaterClass::UpdaterClass()
 , _startAddress(0)
 , _currentAddress(0)
 , _command(U_FLASH)
+#ifdef ERASE_CONFIG_H
+, _eraseConfigOption(ERASE_CONFIG_BLANK_BIN)
+#endif
 , _hash(nullptr)
 , _verify(nullptr)
 , _progress_callback(nullptr)
@@ -84,7 +88,7 @@ bool UpdaterClass::begin(size_t size, int command, int ledPin, uint8_t ledOn) {
     _setError(UPDATE_ERROR_BOOTSTRAP);
     return false;
   }
-  
+
 #ifdef DEBUG_UPDATER
   if (command == U_FS) {
     DEBUG_UPDATER.println(F("[begin] Update Filesystem."));
@@ -127,7 +131,7 @@ bool UpdaterClass::begin(size_t size, int command, int ledPin, uint8_t ledOn) {
 
     //make sure that the size of both sketches is less than the total space (updateEndAddress)
     if(updateStartAddress < currentSketchSize) {
-      _setError(UPDATE_ERROR_SPACE);    
+      _setError(UPDATE_ERROR_SPACE);
       return false;
     }
   }
@@ -284,10 +288,17 @@ bool UpdaterClass::end(bool evenIfRemaining){
 
   if (_command == U_FLASH) {
     eboot_command ebcmd;
+    memset(&ebcmd, 0, sizeof(ebcmd));
     ebcmd.action = ACTION_COPY_RAW;
     ebcmd.args[0] = _startAddress;
     ebcmd.args[1] = 0x00000;
     ebcmd.args[2] = _size;
+#ifdef ERASE_CONFIG_H
+    ebcmd.args[4] =  _eraseConfigOption;
+    ebcmd.args[5] = ~_eraseConfigOption;
+    ebcmd.args[6] =  _eraseConfigOption;
+    ebcmd.args[7] = ~_eraseConfigOption;
+#endif
     eboot_command_write(&ebcmd);
 
 #ifdef DEBUG_UPDATER
@@ -297,6 +308,7 @@ bool UpdaterClass::end(bool evenIfRemaining){
   else if (_command == U_FS) {
 #ifdef ATOMIC_FS_UPDATE
     eboot_command ebcmd;
+    memset(&ebcmd, 0, sizeof(ebcmd));
     ebcmd.action = ACTION_COPY_RAW;
     ebcmd.args[0] = _startAddress;
     ebcmd.args[1] = (uintptr_t)&_FS_start - 0x40200000;
@@ -345,7 +357,7 @@ bool UpdaterClass::_writeBuffer(){
       modifyFlashMode = true;
     }
   }
-  
+
   if (eraseResult) {
     if(!_async) yield();
     writeResult = ESP.flashWrite(_currentAddress, (uint32_t*) _buffer, _bufferLen);
@@ -431,7 +443,7 @@ bool UpdaterClass::_verifyEnd() {
         uint8_t buf[4];
         if(!ESP.flashRead(_startAddress, (uint32_t *) &buf[0], 4)) {
             _currentAddress = (_startAddress);
-            _setError(UPDATE_ERROR_READ);            
+            _setError(UPDATE_ERROR_READ);
             return false;
         }
 
@@ -443,7 +455,7 @@ bool UpdaterClass::_verifyEnd() {
             return true;
         } else if (buf[0] != 0xE9) {
             _currentAddress = (_startAddress);
-            _setError(UPDATE_ERROR_MAGIC_BYTE);            
+            _setError(UPDATE_ERROR_MAGIC_BYTE);
             return false;
         }
 
@@ -452,7 +464,7 @@ bool UpdaterClass::_verifyEnd() {
         // check if new bin fits to SPI flash
         if(bin_flash_size > ESP.getFlashChipRealSize()) {
             _currentAddress = (_startAddress);
-            _setError(UPDATE_ERROR_NEW_FLASH_CONFIG);            
+            _setError(UPDATE_ERROR_NEW_FLASH_CONFIG);
             return false;
         }
 

diff --git a/cores/esp8266/Updater.h b/cores/esp8266/Updater.h
@@ -51,7 +51,7 @@ class UpdaterVerifyClass {
 class UpdaterClass {
   public:
     typedef std::function<void(size_t, size_t)> THandlerFunction_Progress;
-  
+
     UpdaterClass();
 
     /* Optionally add a cryptographic signature verification hash and method */
@@ -63,6 +63,13 @@ class UpdaterClass {
     */
     bool begin(size_t size, int command = U_FLASH, int ledPin = -1, uint8_t ledOn = LOW);
 
+#ifdef ERASE_CONFIG_H
+    /*
+    */
+    inline void setEraseConfigOption(ERASE_CONFIG_MASK_t eraseOption) {
+      _eraseConfigOption = eraseOption;
+    }
+#endif
     /*
       Run Updater from asynchronous callbacs
     */
@@ -179,7 +186,7 @@ class UpdaterClass {
     bool _verifyHeader(uint8_t data);
     bool _verifyEnd();
 
-    void _setError(int error);    
+    void _setError(int error);
 
     bool _async;
     uint8_t _error;
@@ -197,6 +204,8 @@ class UpdaterClass {
     int _ledPin;
     uint8_t _ledOn;
 
+    uint32_t _eraseConfigOption;
+
     // Optional signed binary verification
     UpdaterHashClass *_hash;
     UpdaterVerifyClass *_verify;

diff --git a/cores/esp8266/erase_config.cpp b/cores/esp8266/erase_config.cpp
@@ -0,0 +1,60 @@
+#include <Arduino.h>
+#include <flash_utils.h>
+#include <eboot_command.h>
+#include <spi_flash.h>
+
+#ifdef ERASE_CONFIG_H
+
+extern "C" {
+#include "user_interface.h"
+
+bool erase_config(const uint32_t flash_erase_mask) {
+    // This is really the active configured size
+    uint32_t flash_size = flashchip->chip_size;
+    uint32_t erase_mask = (flash_erase_mask & (uint32_t)ERASE_CONFIG_ALL_DATA);
+    uint32_t sector = flash_size/SPI_FLASH_SEC_SIZE - 1U;
+
+    for (; !!erase_mask; erase_mask >>= 1U, sector--) {
+        if ((erase_mask & 1U)) {
+            if (0 != spi_flash_erase_sector(sector)) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+bool check_and_erase_config(void) {
+  // This should work since each element of the structure is a word.
+  eboot_command volatile * ebcmd = (eboot_command volatile *)RTC_MEM;
+
+  // We want to run after an OTA has completed and the bin has been moved to its
+  // final resting place in flash. We want to catch the moment of the 1st boot
+  // of this new sketch. Then verify we have a valid erase option.
+  if (0U == ebcmd->magic &&
+      0U == ebcmd->crc32 &&
+      ACTION_COPY_RAW == ebcmd->action &&
+      ebcmd->args[4] ==  ebcmd->args[6] &&
+      ebcmd->args[5] ==  ebcmd->args[7] &&
+      ebcmd->args[4] == ~ebcmd->args[5] &&
+      0U == (ebcmd->args[4] & ~ERASE_CONFIG_ALL_DATA)) {
+
+    uint32_t erase_flash_option = ebcmd->args[4];

+    // Make sure we don't repeat
+    for (size_t i=4; i<=7; i++)
+      ebcmd->args[i] = 0U;
+
+    if (erase_flash_option) {
+      erase_config(erase_flash_option);
+      system_restart();
+      while(true){}
+    }
+  }
+  return true;
+}
+
+};
+
+#endif // ERASE_CONFIG_H
diff --git a/cores/esp8266/erase_config.h b/cores/esp8266/erase_config.h
@@ -0,0 +1,43 @@
+#ifndef ERASE_CONFIG_H
+#define ERASE_CONFIG_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum ERASE_CONFIG {
+// Note, The Arduino ESP8266 flash memory map differs from Espressif's.
+// Espressive has separate sectors for PHY init data and RF_CAL. In Arduino
+// ESP8266 RF_CAL and PHY INIT share the same sector. Between two RF init user
+// calls the PHY init data is overlayed. Thus avoiding the waste of a 4K sector
+// to store only 128 bytes.
+//
+// Mapping of Sectors at end of Flash, adapted for the Arduino ESP8266.
+// Defaults to using the IDE configured flash size for placement
+//_______________________________________________________________________________________
+//_Bit_number_for_Mask______|_____4_____|_____3_____|_____2_____|_____1_____|_____0_____|
+//                          |           |  RF_CAL   |        SDK Parameter Area         |
+// Overlay at RF init       |           | PHY INIT  |           |           |           |
+// Persistant data          |           |           |           |  SSID/PW  |           |
+// User storage             |   EEPROM  |           |           |           |           |
+// Often shown downloaded   |           | BLANK.BIN |           | BLANK.BIN |           |
+//__________________________|___________|___________|___________|___________|___________|
+ERASE_CONFIG_NONE = 0,    //|           |           |           |           |           |
+ERASE_CONFIG_EEPROM       = (   BIT(4)                                                  ),
+ERASE_CONFIG_RF_CAL       = (              BIT(3)                                       ),
+ERASE_CONFIG_PERSISTANT   = (                                       BIT(1)              ),
+ERASE_CONFIG_BLANK_BIN    = (              BIT(3)   |               BIT(1)              ),
+ERASE_CONFIG_SDK_DATA     = (              BIT(3)   |   BIT(2)  |   BIT(1)  |   BIT(0)  ),
+ERASE_CONFIG_ALL_DATA     = (   BIT(4)  |  BIT(3)   |   BIT(2)  |   BIT(1)  |   BIT(0)  )
+//__________________________|___________|___________|___________|___________|___________|
+} ERASE_CONFIG_MASK_t; // Use one of these with eraseConfig
+
+bool check_and_erase_config(void);
+bool erase_config(const uint32_t flash_erase_mask);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif