Support reading/saving config.

Author: jonathanpallant

src/config.rs

@@ -8,8 +8,8 @@ use serde::{Deserialize, Serialize};
 /// Represents our configuration information that we ask the BIOS to serialise
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Config {
-    vga_console_on: bool,
-    serial_console_on: bool,
+    vga_console: bool,
+    serial_console: bool,
     serial_baud: u32,
 }
 
@@ -29,18 +29,26 @@ impl Config {
         let api = API.get();
         let mut buffer = [0u8; 64];
         let slice = postcard::to_slice(self, &mut buffer).map_err(|_e| "Failed to parse config")?;
-        (api.configuration_set)(bios::ApiByteSlice::new(slice));
-        Ok(())
+        match (api.configuration_set)(bios::ApiByteSlice::new(slice)) {
+            bios::Result::Ok(_) => Ok(()),
+            bios::Result::Err(bios::Error::Unimplemented) => Err("BIOS doesn't support this (yet)"),
+            bios::Result::Err(_) => Err("BIOS reported an error"),
+        }
     }
 
     /// Should this system use the VGA console?
-    pub fn has_vga_console(&self) -> bool {
-        self.vga_console_on
+    pub fn get_vga_console(&self) -> bool {
+        self.vga_console
+    }
+
+    // Set whether this system should use the VGA console.
+    pub fn set_vga_console(&mut self, new_value: bool) {
+        self.vga_console = new_value;
     }
 
     /// Should this system use the UART console?
-    pub fn has_serial_console(&self) -> Option<(u8, bios::serial::Config)> {
-        if self.serial_console_on {
+    pub fn get_serial_console(&self) -> Option<(u8, bios::serial::Config)> {
+        if self.serial_console {
             Some((
                 0,
                 bios::serial::Config {
@@ -55,13 +63,25 @@ impl Config {
             None
         }
     }
+
+    /// Turn the serial console off
+    pub fn set_serial_console_off(&mut self) {
+        self.serial_console = false;
+        self.serial_baud = 0;
+    }
+
+    /// Turn the serial console on
+    pub fn set_serial_console_on(&mut self, serial_baud: u32) {
+        self.serial_console = true;
+        self.serial_baud = serial_baud;
+    }
 }
 
 impl core::default::Default for Config {
     fn default() -> Config {
         Config {
-            vga_console_on: true,
-            serial_console_on: false,
+            vga_console: true,
+            serial_console: false,
             serial_baud: 115200,
         }
     }

src/lib.rs

@@ -10,6 +10,7 @@
 
 // Imports
 use core::fmt::Write;
+use core::sync::atomic::{AtomicBool, Ordering};
 use neotron_common_bios as bios;
 
 mod config;
@@ -31,6 +32,11 @@ static mut VGA_CONSOLE: Option<vgaconsole::VgaConsole> = None;
 /// We store our VGA console here.
 static mut SERIAL_CONSOLE: Option<SerialConsole> = None;
 
+/// Note if we are panicking right now.
+///
+/// If so, don't panic if a serial write fails.
+static IS_PANIC: AtomicBool = AtomicBool::new(false);
+
 static OS_MENU: menu::Menu<Ctx> = menu::Menu {
     label: "root",
     items: &[
@@ -58,6 +64,23 @@ static OS_MENU: menu::Menu<Ctx> = menu::Menu {
             command: "fill",
             help: Some("Fill the screen with characters"),
         },
+        &menu::Item {
+            item_type: menu::ItemType::Callback {
+                function: cmd_config,
+                parameters: &[
+                    menu::Parameter::Optional {
+                        parameter_name: "command",
+                        help: Some("Which operation to perform (try help)"),
+                    },
+                    menu::Parameter::Optional {
+                        parameter_name: "value",
+                        help: Some("new value for the setting"),
+                    },
+                ],
+            },
+            command: "config",
+            help: Some("Handle non-volatile OS configuration"),
+        },
     ],
     entry: None,
     exit: None,
@@ -121,20 +144,25 @@ struct SerialConsole(u8);
 impl core::fmt::Write for SerialConsole {
     fn write_str(&mut self, data: &str) -> core::fmt::Result {
         let api = API.get();
-        (api.serial_write)(
+        let is_panic = IS_PANIC.load(Ordering::SeqCst);
+        let res = (api.serial_write)(
             // Which port
             self.0,
             // Data
             bios::ApiByteSlice::new(data.as_bytes()),
             // No timeout
             bios::Option::None,
-        )
-        .unwrap();
+        );
+        if !is_panic {
+            res.unwrap();
+        }
         Ok(())
     }
 }
 
-struct Ctx;
+struct Ctx {
+    config: config::Config,
+}
 
 impl core::fmt::Write for Ctx {
     fn write_str(&mut self, data: &str) -> core::fmt::Result {
@@ -191,7 +219,7 @@ pub extern "C" fn main(api: *const bios::Api) -> ! {
 
     let config = config::Config::load().unwrap_or_default();
 
-    if config.has_vga_console() {
+    if config.get_vga_console() {
         // Try and set 80x30 mode for maximum compatibility
         (api.video_set_mode)(bios::video::Mode::new(
             bios::video::Timing::T640x480,
@@ -215,7 +243,7 @@ pub extern "C" fn main(api: *const bios::Api) -> ! {
         }
     }
 
-    if let Some((idx, serial_config)) = config.has_serial_console() {
+    if let Some((idx, serial_config)) = config.get_serial_console() {
         let _ignored = (api.serial_configure)(idx, serial_config);
         unsafe { SERIAL_CONSOLE = Some(SerialConsole(idx)) };
         println!("Configured Serial console on Serial {}", idx);
@@ -225,29 +253,14 @@ pub extern "C" fn main(api: *const bios::Api) -> ! {
     println!("Welcome to {}!", OS_VERSION);
     println!("Copyright © Jonathan 'theJPster' Pallant and the Neotron Developers, 2022");
 
-    let mut found;
-
-    println!("Serial Ports:");
-    found = false;
-    for device_idx in 0..=255 {
-        if let bios::Option::Some(serial) = (api.serial_get_info)(device_idx) {
-            println!("Serial Device {}: {:?}", device_idx, serial);
-            found = true;
-        } else {
-            // Ran out of serial devices (we assume they are consecutive)
-            break;
-        }
-    }
-    if !found {
-        println!("None.");
-    }
+    let ctx = Ctx { config };
 
     let mut keyboard = pc_keyboard::EventDecoder::new(
         pc_keyboard::layouts::AnyLayout::Uk105Key(pc_keyboard::layouts::Uk105Key),
         pc_keyboard::HandleControl::MapLettersToUnicode,
     );
     let mut buffer = [0u8; 256];
-    let mut menu = menu::Runner::new(&OS_MENU, &mut buffer, Ctx);
+    let mut menu = menu::Runner::new(&OS_MENU, &mut buffer, ctx);
 
     loop {
         match (api.hid_get_event)() {
@@ -343,10 +356,82 @@ fn cmd_fill(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _c
     }
 }
 
+/// Called when the "config" command is executed.
+fn cmd_config(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], context: &mut Ctx) {
+    let command = args.get(0).cloned().unwrap_or("print");
+    match command {
+        "reset" => match config::Config::load() {
+            Ok(new_config) => {
+                context.config = new_config;
+                println!("Loaded OK.");
+            }
+            Err(e) => {
+                println!("Error loading; {}", e);
+            }
+        },
+        "save" => match context.config.save() {
+            Ok(_) => {
+                println!("Saved OK.");
+            }
+            Err(e) => {
+                println!("Error saving: {}", e);
+            }
+        },
+        "vga" => match args.get(1).cloned() {
+            Some("on") => {
+                context.config.set_vga_console(true);
+                println!("VGA now on");
+            }
+            Some("off") => {
+                context.config.set_vga_console(false);
+                println!("VGA now off");
+            }
+            _ => {
+                println!("Give on or off as argument");
+            }
+        },
+        "serial" => match (args.get(1).cloned(), args.get(1).map(|s| s.parse::<u32>())) {
+            (_, Some(Ok(baud))) => {
+                println!("Turning serial console on at {} bps", baud);
+                context.config.set_serial_console_on(baud);
+            }
+            (Some("off"), _) => {
+                println!("Turning serial console off");
+                context.config.set_serial_console_off();
+            }
+            _ => {
+                println!("Give off or an integer as argument");
+            }
+        },
+        "print" => {
+            println!("VGA   : {}", context.config.get_vga_console());
+            match context.config.get_serial_console() {
+                None => {
+                    println!("Serial: off");
+                }
+                Some((_port, config)) => {
+                    println!("Serial: {} bps", config.data_rate_bps);
+                }
+            }
+        }
+        _ => {
+            println!("config print - print the config");
+            println!("config help - print this help text");
+            println!("config reset - load config from BIOS store");
+            println!("config save - save config to BIOS store");
+            println!("config vga on - turn VGA on");
+            println!("config vga off - turn VGA off");
+            println!("config serial off - turn serial console off");
+            println!("config serial <baud> - turn serial console on with given baud rate");
+        }
+    }
+}
+
 /// Called when we have a panic.
 #[inline(never)]
 #[panic_handler]
 fn panic(info: &core::panic::PanicInfo) -> ! {
+    IS_PANIC.store(true, Ordering::SeqCst);
     println!("PANIC!\n{:#?}", info);
     let api = API.get();
     loop {