feat: erase_apps

Signed-off-by: addrian-77 <lunguadrian30@gmail.com>

Author: addrian-77

tockloader-cli/src/cli.rs

@@ -53,6 +53,11 @@ fn get_subcommands() -> Vec<Command> {
             .args(get_app_args())
             .args(get_channel_args())
             .arg_required_else_help(false),
+        Command::new("erase-apps")
+            .about("Erase apps")
+            .args(get_app_args())
+            .args(get_channel_args())
+            .arg_required_else_help(false),
     ]
 }
 

tockloader-cli/src/main.rs

@@ -18,7 +18,7 @@ use tockloader_lib::connection::{
 use tockloader_lib::known_boards::KnownBoard;
 use tockloader_lib::tabs::tab::Tab;
 use tockloader_lib::{
-    list_debug_probes, list_serial_ports, CommandInfo, CommandInstall, CommandList,
+    list_debug_probes, list_serial_ports, CommandInfo, CommandInstall, CommandList, CommandEraseApps,
 };
 
 fn get_serial_target_info(user_options: &ArgMatches) -> SerialTargetInfo {
@@ -228,6 +228,15 @@ async fn main() -> Result<()> {
                 .await
                 .context("Failed to install app.")?;
         }
+        Some(("erase-apps", sub_matches)) => {
+            cli::validate(&mut cmd, sub_matches);
+            let mut conn = open_connection(sub_matches).await?;
+            let settings = get_board_settings(sub_matches);
+
+            conn.erase_apps(&settings)
+                .await
+                .context("Failed to erase apps.")?; 
+        }
         _ => {
             println!("Could not run the provided subcommand.");
             _ = make_cli().print_help();

tockloader-lib/src/command_impl/generalized.rs

@@ -6,7 +6,7 @@ use crate::board_settings::BoardSettings;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
 use crate::tabs::tab::Tab;
-use crate::{CommandInfo, CommandInstall, CommandList};
+use crate::{CommandInfo, CommandInstall, CommandList, CommandEraseApps};
 
 #[async_trait]
 impl CommandList for TockloaderConnection {
@@ -47,3 +47,16 @@ impl CommandInstall for TockloaderConnection {
         }
     }
 }
+
+#[async_trait]
+impl CommandEraseApps for TockloaderConnection {
+    async fn erase_apps(
+        &mut self,
+        settings: &BoardSettings,
+    ) -> Result<(), TockloaderError> {
+        match self {
+            TockloaderConnection::ProbeRS(conn) => conn.erase_apps(settings).await,
+            TockloaderConnection::Serial(_conn) => todo!(),
+        }
+    }
+}

tockloader-lib/src/command_impl/probers/erase_apps.rs

@@ -0,0 +1,72 @@
+use async_trait::async_trait;
+use probe_rs::flashing::DownloadOptions;
+use probe_rs::{MemoryInterface};
+use tbf_parser::parse::{parse_tbf_header_lengths};
+
+use crate::board_settings::BoardSettings;
+use crate::connection::{Connection, ProbeRSConnection};
+use crate::errors::{InternalError, TockloaderError};
+use crate::CommandEraseApps;
+
+#[async_trait]
+impl CommandEraseApps for ProbeRSConnection {
+    async fn erase_apps(
+        &mut self,
+        settings: &BoardSettings,
+    ) -> Result<(), TockloaderError> {
+        if !self.is_open() {
+            return Err(InternalError::ConnectionNotOpen.into());
+        }
+        let session = self.session.as_mut().expect("Board must be open");
+
+        let mut appaddr: u64 = settings.start_address;
+        // All applications are stored sequentially in memory, so we read until
+        // we fail to parse.
+        let mut total_size: u32 = 0;
+        loop {
+            let mut board_core = session.core(self.target_info.core)?;
+            let mut appdata = vec![0u8; 8];
+
+            board_core.read(appaddr, &mut appdata)?;
+
+            let app_size: u32;
+
+            // The first 8 bytes of the application data contain the TBF header
+            // lengths and version.
+            //
+            // Note on expect: `read` always fills up the entire buffer, which
+            // was previously declared as 8 bytes.
+            log::info!("app data? {:?}", appdata);
+            match parse_tbf_header_lengths(
+                &appdata
+                    .try_into()
+                    .expect("Buffer length must be at least 8 bytes long."),
+            ) {
+                Ok(data) => {
+                    app_size = data.2;
+                }
+                _ => break,
+            };
+
+            appaddr += app_size as u64;
+            total_size += app_size;
+        }
+
+        let mut loader = session.target().flash_loader();
+
+        let address = settings.start_address;
+        // (adi): fill the memory with total_size values of 0xFF
+        let buffer = [0x0].repeat(total_size as usize);
+        loader.add_data(
+            (address as u32).into(),
+            &buffer
+        )?;
+        
+        let mut options = DownloadOptions::default();
+        options.keep_unwritten_bytes = true;
+        
+        // Finally, the data can be programmed
+        loader.commit(session, options)?;
+        Ok(())
+    }
+}

tockloader-lib/src/command_impl/probers/mod.rs

@@ -1,3 +1,4 @@
+pub mod erase_apps;
 pub mod info;
 pub mod install;
-pub mod list;
+pub mod list;

tockloader-lib/src/lib.rs

@@ -59,3 +59,11 @@ pub trait CommandInstall {
         tab_file: Tab,
     ) -> Result<(), TockloaderError>;
 }
+
+#[async_trait]
+pub trait CommandEraseApps {
+    async fn erase_apps(
+        &mut self,
+        settings: &BoardSettings,
+    ) -> Result<(), TockloaderError>;
+}