Fix ota, use MMU to determine running partition, use RMW wrapper for ota_data partition (littelfs handles this internally, so it was no problem prior)

Software/MainBoard/rust/src/hal/esp.rs

@@ -21,11 +21,10 @@ use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::mutex::{Mutex, MutexGuard};
 use embassy_sync::once_lock::OnceLock;
 use embassy_time::{Duration, Timer, WithTimeout};
-use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash};
+use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash, RmwNorFlashStorage};
 use esp_bootloader_esp_idf::ota::OtaImageState::Valid;
 use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
 use esp_bootloader_esp_idf::partitions::{AppPartitionSubType, FlashRegion};
-use esp_hal::Blocking;
 use esp_hal::gpio::{Input, RtcPinWithResistors};
 use esp_hal::rng::Rng;
 use esp_hal::rtc_cntl::{
@@ -34,6 +33,7 @@ use esp_hal::rtc_cntl::{
 };
 use esp_hal::system::software_reset;
 use esp_hal::uart::Uart;
+use esp_hal::Blocking;
 use esp_println::println;
 use esp_radio::wifi::{
     AccessPointConfig, AccessPointInfo, AuthMethod, ClientConfig, ModeConfig, ScanConfig,
@@ -130,7 +130,7 @@ pub struct Esp<'a> {
     pub wake_gpio1: esp_hal::peripherals::GPIO1<'static>,
     pub uart0: Uart<'a, Blocking>,
 
-    pub ota: Ota<'static, MutexFlashStorage>,
+    pub ota: Ota<'static, RmwNorFlashStorage<'static, &'static mut MutexFlashStorage>>,
     pub ota_target: &'static mut FlashRegion<'static, MutexFlashStorage>,
     pub current: AppPartitionSubType,
     pub slot0_state: OtaImageState,
@@ -155,7 +155,6 @@ macro_rules! mk_static {
 }
 
 impl Esp<'_> {
-
     pub(crate) async fn read_serial_line(&mut self) -> FatResult<Option<alloc::string::String>> {
         let mut buf = [0u8; 1];
         let mut line = String::new();
@@ -171,7 +170,7 @@ impl Esp<'_> {
                     }
                     line.push(c);
                 }
-                Err(error  ) => {
+                Err(error) => {
                     if line.is_empty() {
                         return Ok(None);
                     } else {
@@ -252,6 +251,7 @@ impl Esp<'_> {
 
     pub(crate) async fn write_ota(&mut self, offset: u32, buf: &[u8]) -> Result<(), FatError> {
         let _ = check_erase(self.ota_target, offset, offset + 4096);
+        info!("erasing and writing block 0x{offset:x}");
         self.ota_target.erase(offset, offset + 4096)?;
 
         let mut temp = vec![0; buf.len()];
@@ -288,8 +288,6 @@ impl Esp<'_> {
         info!("switched state for new partition");
         let state_new = self.ota.current_ota_state()?;
         info!("state on new partition now {state_new:?}");
-        //determine nextslot crc
-
         self.set_restart_to_conf(true);
         Ok(())
     }
@@ -597,10 +595,13 @@ impl Esp<'_> {
         // Mark the current OTA image as valid if we reached here while in pending verify.
         if let Ok(cur) = self.ota.current_ota_state() {
             if cur == OtaImageState::PendingVerify {
+                info!("Marking OTA image as valid");
                 self.ota
                     .set_current_ota_state(Valid)
                     .expect("Could not set image to valid");
             }
+        } else {
+            info!("No OTA image to mark as valid");
         }
 
         if duration_in_ms == 0 {