Can load files from disk.

Author: jonathanpallant

src/commands/fs.rs

@@ -14,6 +14,18 @@ pub static DIR_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Dir the root directory on block device 0"),
 };
 
+pub static LOAD_ITEM: menu::Item<Ctx> = menu::Item {
+    item_type: menu::ItemType::Callback {
+        function: load,
+        parameters: &[menu::Parameter::Mandatory {
+            parameter_name: "file",
+            help: Some("The file to load"),
+        }],
+    },
+    command: "load",
+    help: Some("Load a file into the application area"),
+};
+
 struct BiosBlock();
 
 impl embedded_sdmmc::BlockDevice for BiosBlock {
@@ -91,7 +103,7 @@ impl embedded_sdmmc::TimeSource for BiosTime {
     }
 }
 
-/// Called when the "lsblk" command is executed.
+/// Called when the "dir" command is executed.
 fn dir(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &mut Ctx) {
     fn work() -> Result<(), embedded_sdmmc::Error<bios::Error>> {
         println!("Listing files on Block Device 0, /");
@@ -150,3 +162,38 @@ fn dir(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &
         }
     }
 }
+
+/// Called when the "load" command is executed.
+#[cfg(target_os = "none")]
+fn load(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], _ctx: &mut Ctx) {
+    fn work(args: &[&str]) -> Result<(), embedded_sdmmc::Error<bios::Error>> {
+        println!("Loading /{} from Block Device 0", args[0]);
+        let bios_block = BiosBlock();
+        let time = BiosTime();
+        let mut mgr = embedded_sdmmc::VolumeManager::new(bios_block, time);
+        // Open the first partition
+        let mut volume = mgr.get_volume(VolumeIdx(0))?;
+        let root_dir = mgr.open_root_dir(&volume)?;
+        let mut file = mgr.open_file_in_dir(
+            &mut volume,
+            &root_dir,
+            args[0],
+            embedded_sdmmc::Mode::ReadOnly,
+        )?;
+        let file_length = file.length();
+        // Application space starts 4K into Cortex-M SRAM
+        const APPLICATION_START_ADDR: usize = 0x2000_1000;
+        let application_ram: &'static mut [u8] = unsafe {
+            core::slice::from_raw_parts_mut(APPLICATION_START_ADDR as *mut u8, file_length as usize)
+        };
+        mgr.read(&mut volume, &mut file, application_ram)?;
+        Ok(())
+    }
+
+    match work(args) {
+        Ok(_) => {}
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
+    }
+}

src/commands/mod.rs

@@ -23,9 +23,10 @@ pub static OS_MENU: menu::Menu<Ctx> = menu::Menu {
         &fs::DIR_ITEM,
         &hardware::LSHW_ITEM,
         &ram::HEXDUMP_ITEM,
-        &ram::LOAD_ITEM,
         #[cfg(target_os = "none")]
         &ram::RUN_ITEM,
+        #[cfg(target_os = "none")]
+        &fs::LOAD_ITEM,
         &screen::CLEAR_ITEM,
         &screen::BENCH_ITEM,
         &screen::FILL_ITEM,

src/commands/ram.rs

@@ -20,24 +20,6 @@ pub static HEXDUMP_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Dump the contents of RAM as hex"),
 };
 
-pub static LOAD_ITEM: menu::Item<Ctx> = menu::Item {
-    item_type: menu::ItemType::Callback {
-        function: load,
-        parameters: &[
-            menu::Parameter::Mandatory {
-                parameter_name: "address",
-                help: Some("Start address"),
-            },
-            menu::Parameter::Mandatory {
-                parameter_name: "hex",
-                help: Some("Bytes as hex string"),
-            },
-        ],
-    },
-    command: "load",
-    help: Some("Load hex bytes into RAM from stdin"),
-};
-
 #[cfg(target_os = "none")]
 pub static RUN_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
@@ -99,44 +81,6 @@ fn hexdump(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], _ctx
     println!();
 }
 
-/// Called when the "load" command is executed.
-fn load(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], _ctx: &mut Ctx) {
-    let Some(address_str) = args.get(0) else {
-        println!("No address");
-        return;
-    };
-    let Ok(address) = parse_usize(address_str) else {
-        println!("Bad address");
-        return;
-    };
-    let Some(mut hex_str) = args.get(1).cloned() else {
-        println!("No hex");
-        return;
-    };
-
-    let mut address = address as *mut u8;
-    let mut count = 0;
-    loop {
-        let Some(hex_byte) = hex_str.get(0..2) else {
-            println!("Bad hex from {:?}", hex_str);
-            return;
-        };
-        hex_str = &hex_str[2..];
-        let Ok(byte)  = u8::from_str_radix(hex_byte, 16) else {
-            println!("Bad hex {:?}", hex_byte);
-            return;
-        };
-
-        unsafe {
-            address.write_volatile(byte);
-            address = address.offset(1);
-        }
-        count += 1;
-
-        println!("Loaded {} bytes", count);
-    }
-}
-
 #[allow(unused)]
 #[repr(C)]
 pub struct Api {
@@ -170,6 +114,7 @@ fn run(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &
         let code: extern "C" fn(*const Api) -> u32 = ::core::mem::transmute(start_ptr);
         code(&CALLBACK_TABLE)
     };
+    println!();
     if result != 0 {
         println!("Got error code {}", result);
     }