Add an object for managing the TPA.

Also involves moving the filesystem code, and a new command called "loadf" which can load applications from Flash.

Author: thejpster

neotron-flash-0002.ld

@@ -32,7 +32,11 @@ MEMORY
 
 /* # Entry point = what the BIOS calls to start the OS */
 ENTRY(main);
-EXTERN(__RESET_VECTOR);
+
+/*
+Where the Transient Program Area starts.
+*/
+_tpa_start = ORIGIN(RAM) + LENGTH(RAM);
 
 /* # Sections */
 SECTIONS

neotron-flash-0802.ld

@@ -32,7 +32,11 @@ MEMORY
 
 /* # Entry point = what the BIOS calls to start the OS */
 ENTRY(main);
-EXTERN(__RESET_VECTOR);
+
+/*
+Where the Transient Program Area starts.
+*/
+_tpa_start = ORIGIN(RAM) + LENGTH(RAM);
 
 /* # Sections */
 SECTIONS

neotron-flash-1002.ld

@@ -23,16 +23,24 @@ MEMORY
 {
     /* The first 128 KiB is for the BIOS. We get the rest. */
     FLASH (rx)  : ORIGIN = 0x10020000, LENGTH = 128K
+
     /*
-     * We get the bottom 4KB of RAM. Anything above that is for applications
-     * (up to wherever the BIOS tells us we can use.)
+     * The RAM reserved for the OS. Above this is the Transient Program Area.
+     *
+     * This is defined by the Neotron specification for a given platform. On this
+     * Cortex-M based platform, it's the start of Cortex-M SRAM, plus 4 KiB, or
+     * 0x2000_1000.
      */
     RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 4K
 }
 
 /* # Entry point = what the BIOS calls to start the OS */
 ENTRY(main);
-EXTERN(__RESET_VECTOR);
+
+/*
+Where the Transient Program Area starts.
+*/
+_tpa_start = ORIGIN(RAM) + LENGTH(RAM);
 
 /* # Sections */
 SECTIONS

src/bin/flash0002.rs

@@ -13,4 +13,4 @@
 /// of our portion of Flash.
 #[link_section = ".entry_point"]
 #[used]
-pub static ENTRY_POINT_ADDR: extern "C" fn(*const neotron_common_bios::Api) -> ! = neotron_os::main;
+pub static ENTRY_POINT_ADDR: extern "C" fn(&neotron_common_bios::Api) -> ! = neotron_os::main;

src/bin/flash0802.rs

@@ -13,4 +13,4 @@
 /// of our portion of Flash.
 #[link_section = ".entry_point"]
 #[used]
-pub static ENTRY_POINT_ADDR: extern "C" fn(*const neotron_common_bios::Api) -> ! = neotron_os::main;
+pub static ENTRY_POINT_ADDR: extern "C" fn(&neotron_common_bios::Api) -> ! = neotron_os::main;

src/bin/flash1002.rs

@@ -13,4 +13,4 @@
 /// of our portion of Flash.
 #[link_section = ".entry_point"]
 #[used]
-pub static ENTRY_POINT_ADDR: extern "C" fn(*const neotron_common_bios::Api) -> ! = neotron_os::main;
+pub static ENTRY_POINT_ADDR: extern "C" fn(&neotron_common_bios::Api) -> ! = neotron_os::main;

src/commands/config.rs

@@ -22,7 +22,7 @@ pub static COMMAND_ITEM: menu::Item<Ctx> = menu::Item {
 
 /// Called when the "config" command is executed.
 fn command(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], ctx: &mut Ctx) {
-    let command = args.get(0).cloned().unwrap_or("print");
+    let command = args.first().cloned().unwrap_or("print");
     match command {
         "reset" => match config::Config::load() {
             Ok(new_config) => {

src/commands/fs.rs

@@ -1,9 +1,8 @@
 //! File Systems related commands for Neotron OS
 
-use chrono::{Datelike, Timelike};
 use embedded_sdmmc::VolumeIdx;
 
-use crate::{bios, print, println, Ctx, API};
+use crate::{bios, print, println, Ctx};
 
 pub static DIR_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
@@ -14,7 +13,6 @@ pub static DIR_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Dir the root directory on block device 0"),
 };
 
-#[cfg(target_os = "none")]
 pub static LOAD_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
         function: load,
@@ -27,89 +25,12 @@ pub static LOAD_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Load a file into the application area"),
 };
 
-struct BiosBlock();
-
-impl embedded_sdmmc::BlockDevice for BiosBlock {
-    type Error = bios::Error;
-
-    fn read(
-        &self,
-        blocks: &mut [embedded_sdmmc::Block],
-        start_block_idx: embedded_sdmmc::BlockIdx,
-        _reason: &str,
-    ) -> Result<(), Self::Error> {
-        let api = API.get();
-        let byte_slice = unsafe {
-            core::slice::from_raw_parts_mut(
-                blocks.as_mut_ptr() as *mut u8,
-                blocks.len() * embedded_sdmmc::Block::LEN,
-            )
-        };
-        match (api.block_read)(
-            0,
-            bios::block_dev::BlockIdx(u64::from(start_block_idx.0)),
-            blocks.len() as u8,
-            bios::ApiBuffer::new(byte_slice),
-        ) {
-            bios::Result::Ok(_) => Ok(()),
-            bios::Result::Err(e) => Err(e),
-        }
-    }
-
-    fn write(
-        &self,
-        blocks: &[embedded_sdmmc::Block],
-        start_block_idx: embedded_sdmmc::BlockIdx,
-    ) -> Result<(), Self::Error> {
-        let api = API.get();
-        let byte_slice = unsafe {
-            core::slice::from_raw_parts(
-                blocks.as_ptr() as *const u8,
-                blocks.len() * embedded_sdmmc::Block::LEN,
-            )
-        };
-        match (api.block_write)(
-            0,
-            bios::block_dev::BlockIdx(u64::from(start_block_idx.0)),
-            blocks.len() as u8,
-            bios::ApiByteSlice::new(byte_slice),
-        ) {
-            bios::Result::Ok(_) => Ok(()),
-            bios::Result::Err(e) => Err(e),
-        }
-    }
-
-    fn num_blocks(&self) -> Result<embedded_sdmmc::BlockCount, Self::Error> {
-        let api = API.get();
-        match (api.block_dev_get_info)(0) {
-            bios::Option::Some(info) => Ok(embedded_sdmmc::BlockCount(info.num_blocks as u32)),
-            bios::Option::None => Err(bios::Error::InvalidDevice),
-        }
-    }
-}
-
-struct BiosTime();
-
-impl embedded_sdmmc::TimeSource for BiosTime {
-    fn get_timestamp(&self) -> embedded_sdmmc::Timestamp {
-        let time = API.get_time();
-        embedded_sdmmc::Timestamp {
-            year_since_1970: (time.year() - 1970) as u8,
-            zero_indexed_month: time.month0() as u8,
-            zero_indexed_day: time.day0() as u8,
-            hours: time.hour() as u8,
-            minutes: time.minute() as u8,
-            seconds: time.second() as u8,
-        }
-    }
-}
-
 /// 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, /");
-        let bios_block = BiosBlock();
-        let time = BiosTime();
+        let bios_block = crate::fs::BiosBlock();
+        let time = crate::fs::BiosTime();
         let mut mgr = embedded_sdmmc::VolumeManager::new(bios_block, time);
         // Open the first partition
         let volume = mgr.get_volume(VolumeIdx(0))?;
@@ -165,33 +86,12 @@ 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) {
+fn load(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], ctx: &mut Ctx) {
+    let Some(filename) = args.first() else {
+        println!("Need a filename");
+        return;
+    };
+    match ctx.tpa.load_program(filename) {
         Ok(_) => {}
         Err(e) => {
             println!("Error: {:?}", e);

src/commands/mod.rs

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

src/commands/ram.rs

@@ -20,7 +20,6 @@ pub static HEXDUMP_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Dump the contents of RAM as hex"),
 };
 
-#[cfg(target_os = "none")]
 pub static RUN_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
         function: run,
@@ -30,13 +29,31 @@ pub static RUN_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Jump to start of application area"),
 };
 
+pub static LOAD_ITEM: menu::Item<Ctx> = menu::Item {
+    item_type: menu::ItemType::Callback {
+        function: loadf,
+        parameters: &[
+            menu::Parameter::Mandatory {
+                parameter_name: "address",
+                help: Some("The address to load from"),
+            },
+            menu::Parameter::Mandatory {
+                parameter_name: "length",
+                help: Some("The number of bytes to load"),
+            },
+        ],
+    },
+    command: "loadf",
+    help: Some("Copy a program from ROM/RAM into the application area"),
+};
+
 fn parse_usize(input: &str) -> Result<usize, core::num::ParseIntError> {
     if let Some(digits) = input.strip_prefix("0x") {
         // Parse as hex
         usize::from_str_radix(digits, 16)
     } else {
         // Parse as decimal
-        usize::from_str_radix(input, 10)
+        input.parse::<usize>()
     }
 }
 
@@ -47,7 +64,7 @@ fn parse_usize(input: &str) -> Result<usize, core::num::ParseIntError> {
 fn hexdump(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], _ctx: &mut Ctx) {
     const BYTES_PER_LINE: usize = 16;
 
-    let Some(address_str) = args.get(0) else {
+    let Some(address_str) = args.first() else {
         println!("No address");
         return;
     };
@@ -81,43 +98,51 @@ fn hexdump(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], _ctx
     println!();
 }
 
-#[allow(unused)]
-#[repr(C)]
-pub struct Api {
-    pub print: extern "C" fn(data: *const u8, len: usize),
-}
-
-#[allow(unused)]
-static CALLBACK_TABLE: Api = Api { print: print_fn };
-
-#[allow(unused)]
-extern "C" fn print_fn(data: *const u8, len: usize) {
-    let slice = unsafe { core::slice::from_raw_parts(data, len) };
-    if let Ok(s) = core::str::from_utf8(slice) {
-        print!("{}", s);
-    } else {
-        // Ignore App output - not UTF-8
+/// Called when the "run" command is executed.
+fn run(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], ctx: &mut Ctx) {
+    match ctx.tpa.execute() {
+        Ok(0) => {
+            println!();
+        }
+        Ok(n) => {
+            println!("\nError Code: {}", n);
+        }
+        Err(e) => {
+            println!("\nFailed to execute: {:?}", e);
+        }
     }
 }
 
-/// Called when the "run" command is executed.
-#[cfg(target_os = "none")]
-fn run(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &mut Ctx) {
-    use core::convert::TryInto;
-    const APPLICATION_START_ADDR: usize = 0x2000_1000;
-    const APPLICATION_LEN: usize = 4096;
-    // Application space starts 4K into Cortex-M SRAM
-    let application_ram: &'static mut [u8] = unsafe {
-        core::slice::from_raw_parts_mut(APPLICATION_START_ADDR as *mut u8, APPLICATION_LEN)
+/// Called when the "loadf" command is executed.
+///
+/// If you ask for an address that generates a HardFault, the OS will crash. So
+/// don't.
+fn loadf(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], ctx: &mut Ctx) {
+    let Some(address_str) = args.first() else {
+        println!("No address");
+        return;
     };
-    let start_word: [u8; 4] = (&application_ram[0..4]).try_into().unwrap();
-    let start_ptr = usize::from_le_bytes(start_word) as *const ();
-    let result = unsafe {
-        let code: extern "C" fn(*const Api) -> u32 = ::core::mem::transmute(start_ptr);
-        code(&CALLBACK_TABLE)
+    let Ok(address) = parse_usize(address_str) else {
+        println!("Bad address");
+        return;
     };
-    println!();
-    if result != 0 {
-        println!("Got error code {}", result);
+    let Some(len_str) = args.get(1) else {
+        println!("No length");
+        return;
+    };
+    let Ok(len) = parse_usize(len_str) else {
+        println!("Bad length");
+        return;
+    };
+
+    let src_slice = unsafe { core::slice::from_raw_parts(address as *const u8, len) };
+
+    match ctx.tpa.copy_program(src_slice) {
+        Ok(_) => {
+            println!("Ok");
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
     }
 }