add syscall to get time in ms since application start

Fix fb

.gitignore

@@ -1 +1,3 @@
 /target
+*.uf2
+abi_sys.h

.helix/languages.toml

@@ -0,0 +1,5 @@
+[[language]]
+name = "rust"
+
+[language-server.rust-analyzer.config.check]
+allTargets = false

Cargo.toml

@@ -1,6 +1,12 @@
 [workspace]
 resolver = "3"
-members = ["kernel", "abi", "shared", "user-apps/calculator"]
+members = [
+  "kernel",
+  "abi",
+  "user-apps/calculator",
+  "user-apps/snake",
+  "user-apps/gallery",
+]
 
 [profile.release]
 debug = true

README.md

@@ -0,0 +1,32 @@
+# PicoCalc OS (Rust)
+
+A simple operating system for the **Clockwork PicoCalc**, written in Rust.  
+This project provides a minimal kernel, ABI, and user-space applications to experiment with OS development on constrained hardware.
+
+## Status
+
+Basic synchronous applications are working great.  
+Current focus is on **expanding the ABI syscalls** and **fixing the MSC/USB-SCSI driver** to make application development easier and smoother.
+
+## Project Structure
+
+- **`kernel/`** – The core OS kernel (task scheduling, drivers, memory, etc.)
+- **`abi_sys/`** – Shared application binary interface definitions for kernel ↔ userspace (Repr "C")
+- **`abi/`** – Rust focused ABI helpers and abstractions for easier development
+- **`user-apps/`** – Collection of userspace programs (calculator, snake, etc.)
+
+## Features
+
+- Minimal Rust-based kernel targeting the PicoCalc
+- Custom ABI for safe communication between kernel and applications
+- Support for multiple user-space applications
+- Hardware drivers tailored for the PicoCalc
+
+## Getting Started
+
+```bash
+git clone https://github.com/LegitCamper/picocalc-os-rs.git
+cd picocalc-os-rs
+just userapps
+# copy the build applications from target/thumbv8m.main-none-eabihf/release-binary/application to the sdcard and rename them to app.bin
+just kernel-release # keep in mind that https://github.com/StripedMonkey/elf2uf2-rs version is required until https://github.com/JoNil/elf2uf2-rs/pull/41 is merged

abi/Cargo.toml

@@ -4,9 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+embedded-sdmmc = { version = "0.9.0", default-features = false }
 embedded-graphics = "0.8.1"
-shared = { path = "../shared" }
 abi_sys = { path = "../abi_sys" }
 talc = "4.4.3"
 spin = "0.10.0"
-embassy-time = "0.5.0"
+rand_core = "0.9.3"

abi/src/lib.rs

@@ -1,11 +1,12 @@
 #![no_std]
 
-use abi_sys::draw_iter;
-pub use abi_sys::{get_key, print, sleep};
-pub use embassy_time;
-pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+pub use abi_sys::keyboard;
+use abi_sys::{RngRequest, keyboard::KeyEvent};
+use rand_core::RngCore;
 use talc::*;
 
+extern crate alloc;
+
 static mut ARENA: [u8; 10000] = [0; 10000];
 
 #[global_allocator]
@@ -13,12 +14,24 @@ static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
     Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
         .lock();
 
+pub fn print(msg: &str) {
+    abi_sys::print(msg.as_ptr(), msg.len());
+}
+
+pub fn sleep(ms: u64) {
+    abi_sys::sleep(ms);
+}
+
+pub fn get_key() -> KeyEvent {
+    abi_sys::keyboard::get_key().into()
+}
+
 pub mod display {
-    use crate::draw_iter;
+    use abi_sys::CPixel;
     use embedded_graphics::{
         Pixel,
         geometry::{Dimensions, Point},
-        pixelcolor::{Rgb565, RgbColor},
+        pixelcolor::Rgb565,
         prelude::{DrawTarget, Size},
         primitives::Rectangle,
     };
@@ -28,6 +41,12 @@ pub mod display {
 
     pub type Pixel565 = Pixel<Rgb565>;
 
+    pub fn lock_display(lock: bool) {
+        abi_sys::lock_display(lock);
+    }
+
+    const BUF_SIZE: usize = 1024; // tune this for performance
+
     pub struct Display;
 
     impl Dimensions for Display {
@@ -50,25 +69,79 @@ pub mod display {
         where
             I: IntoIterator<Item = Pixel<Self::Color>>,
         {
-            const BUF_SIZE: usize = 1024; // tune this for performance
-            let mut buf: [Pixel565; BUF_SIZE] = [Pixel(Point::new(0, 0), Rgb565::BLACK); BUF_SIZE];
+            let mut buf: [CPixel; BUF_SIZE] = [CPixel::new(); BUF_SIZE];
 
             let mut count = 0;
             for p in pixels {
-                buf[count] = p;
+                buf[count] = p.into();
                 count += 1;
 
                 if count == BUF_SIZE {
-                    draw_iter(&buf[..count]);
+                    abi_sys::draw_iter(buf.as_ptr(), count);
                     count = 0;
                 }
             }
 
             if count > 0 {
-                draw_iter(&buf[..count]);
+                abi_sys::draw_iter(buf.as_ptr(), count);
             }
 
             Ok(())
         }
     }
 }
+
+fn gen_rand(req: &mut RngRequest) {
+    abi_sys::gen_rand(req);
+}
+
+pub struct Rng;
+
+impl RngCore for Rng {
+    fn next_u32(&mut self) -> u32 {
+        let mut req = RngRequest::U32(0);
+        gen_rand(&mut req);
+        if let RngRequest::U32(i) = req {
+            return i;
+        };
+        0
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        let mut req = RngRequest::U64(0);
+        gen_rand(&mut req);
+        if let RngRequest::U64(i) = req {
+            return i;
+        };
+        0
+    }
+    fn fill_bytes(&mut self, dst: &mut [u8]) {
+        let mut req = RngRequest::Bytes {
+            ptr: dst.as_mut_ptr(),
+            len: dst.len(),
+        };
+        gen_rand(&mut req);
+    }
+}
+
+pub mod fs {
+    use embedded_sdmmc::DirEntry;
+
+    pub fn read_file(file: &str, read_from: usize, buf: &mut [u8]) -> usize {
+        abi_sys::read_file(
+            file.as_ptr(),
+            file.len(),
+            read_from,
+            buf.as_mut_ptr(),
+            buf.len(),
+        )
+    }
+
+    pub fn list_dir(path: &str, files: &mut [Option<DirEntry>]) -> usize {
+        abi_sys::list_dir(path.as_ptr(), path.len(), files.as_mut_ptr(), files.len())
+    }
+
+    pub fn file_len(str: &str) -> usize {
+        abi_sys::file_len(str.as_ptr(), str.len())
+    }
+}

abi_sys/Cargo.toml

@@ -3,6 +3,16 @@ name = "abi_sys"
 version = "0.1.0"
 edition = "2024"
 
+[features]
+default = []
+defmt = ["dep:defmt"]
+
 [dependencies]
+strum = { version = "0.27.2", default-features = false, features = ["derive"] }
+bitflags = "2.9.4"
 embedded-graphics = "0.8.1"
-shared = { path = "../shared" }
+embedded-sdmmc = { version = "0.9.0", default-features = false }
+defmt = { version = "0.3", optional = true }
+
+[build-dependencies]
+cbindgen = "0.24.0"

abi_sys/src/lib.rs

@@ -1,71 +1,412 @@
 #![no_std]
 
-extern crate alloc;
-use alloc::boxed::Box;
-
-use core::pin::Pin;
-pub use embedded_graphics::{
+use embedded_graphics::{
     Pixel,
-    geometry::Point,
-    pixelcolor::{Rgb565, RgbColor},
+    pixelcolor::{Rgb565, raw::RawU16},
+    prelude::{IntoStorage, Point},
 };
-use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+use embedded_sdmmc::DirEntry;
+use strum::EnumIter;
 
-pub type EntryFn = fn() -> Pin<Box<dyn Future<Output = ()>>>;
+pub const ABI_CALL_TABLE_COUNT: usize = 10;
+
+#[derive(Clone, Copy, EnumIter)]
+#[repr(u8)]
+pub enum CallAbiTable {
+    PrintString = 0,
+    SleepMs = 1,
+    GetMs = 2,
+    LockDisplay = 3,
+    DrawIter = 4,
+    GetKey = 5,
+    GenRand = 6,
+    ListDir = 7,
+    ReadFile = 8,
+    FileLen = 9,
+}
+
+pub type EntryFn = fn();
 
 #[unsafe(no_mangle)]
-#[unsafe(link_section = ".user_reloc")]
-pub static mut CALL_ABI_TABLE: [usize; CallAbiTable::COUNT] = [0; CallAbiTable::COUNT];
+#[unsafe(link_section = ".syscall_table")]
+pub static mut CALL_ABI_TABLE: [usize; ABI_CALL_TABLE_COUNT] = [0; ABI_CALL_TABLE_COUNT];
 
-#[repr(usize)]
-#[derive(Clone, Copy)]
-pub enum CallAbiTable {
-    Print = 0,
-    Sleep = 1,
-    DrawIter = 2,
-    GetKey = 3,
+pub type PrintAbi = extern "C" fn(ptr: *const u8, len: usize);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn print(ptr: *const u8, len: usize) {
+    let f: PrintAbi =
+        unsafe { core::mem::transmute(CALL_ABI_TABLE[CallAbiTable::PrintString as usize]) };
+    f(ptr, len);
 }
 
-impl CallAbiTable {
-    pub const COUNT: usize = 4;
+pub type SleepMsAbi = extern "C" fn(ms: u64);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn sleep(ms: u64) {
+    let f: SleepMsAbi =
+        unsafe { core::mem::transmute(CALL_ABI_TABLE[CallAbiTable::SleepMs as usize]) };
+    f(ms);
 }
 
-pub type PrintAbi = extern "Rust" fn(msg: &str);
+pub type GetMsAbi = extern "C" fn() -> u64;
 
-pub fn print(msg: &str) {
-    unsafe {
-        let ptr = CALL_ABI_TABLE[CallAbiTable::Print as usize];
-        let f: PrintAbi = core::mem::transmute(ptr);
-        f(msg);
+#[unsafe(no_mangle)]
+pub extern "C" fn get_ms() -> u64 {
+    let f: GetMsAbi = unsafe { core::mem::transmute(CALL_ABI_TABLE[CallAbiTable::GetMs as usize]) };
+    f()
+}
+
+pub type LockDisplay = extern "C" fn(lock: bool);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn lock_display(lock: bool) {
+    let f: LockDisplay =
+        unsafe { core::mem::transmute(CALL_ABI_TABLE[CallAbiTable::LockDisplay as usize]) };
+    f(lock);
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct CPixel {
+    pub x: i32,
+    pub y: i32,
+    pub color: u16,
+}
+
+impl CPixel {
+    pub fn new() -> Self {
+        Self {
+            x: 0,
+            y: 0,
+            color: 0,
+        }
     }
 }
 
-pub type SleepAbi = extern "Rust" fn(ms: u64);
-
-pub fn sleep(ms: u64) {
-    unsafe {
-        let ptr = CALL_ABI_TABLE[CallAbiTable::Sleep as usize];
-        let f: SleepAbi = core::mem::transmute(ptr);
-        f(ms);
+impl Into<CPixel> for Pixel<Rgb565> {
+    fn into(self) -> CPixel {
+        CPixel {
+            x: self.0.x,
+            y: self.0.y,
+            color: self.1.into_storage(),
+        }
     }
 }
 
-pub type DrawIterAbi = extern "Rust" fn(pixels: &[Pixel<Rgb565>]);
-
-pub fn draw_iter(pixels: &[Pixel<Rgb565>]) {
-    unsafe {
-        let ptr = CALL_ABI_TABLE[CallAbiTable::DrawIter as usize];
-        let f: DrawIterAbi = core::mem::transmute(ptr);
-        f(pixels);
+impl Into<Pixel<Rgb565>> for CPixel {
+    fn into(self) -> Pixel<Rgb565> {
+        Pixel(Point::new(self.x, self.y), RawU16::new(self.color).into())
     }
 }
 
-pub type GetKeyAbi = extern "Rust" fn() -> Option<KeyEvent>;
+pub type DrawIterAbi = extern "C" fn(ptr: *const CPixel, len: usize);
 
-pub fn get_key() -> Option<KeyEvent> {
-    unsafe {
-        let ptr = CALL_ABI_TABLE[CallAbiTable::GetKey as usize];
-        let f: GetKeyAbi = core::mem::transmute(ptr);
+#[unsafe(no_mangle)]
+pub extern "C" fn draw_iter(ptr: *const CPixel, len: usize) {
+    let f: DrawIterAbi =
+        unsafe { core::mem::transmute(CALL_ABI_TABLE[CallAbiTable::DrawIter as usize]) };
+    f(ptr, len);
+}
+
+pub mod keyboard {
+    use crate::{CALL_ABI_TABLE, CallAbiTable};
+
+    bitflags::bitflags! {
+        #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)]
+        #[repr(C)]
+        pub struct Modifiers: u8 {
+            const NONE = 0;
+            const CTRL = 1;
+            const ALT = 2;
+            const LSHIFT = 4;
+            const RSHIFT = 8;
+            const SYM = 16;
+        }
+    }
+
+    #[repr(C)]
+    pub struct KeyEventC {
+        pub key: u8,
+        pub state: KeyState,
+        pub mods: Modifiers,
+    }
+
+    impl Into<KeyEvent> for KeyEventC {
+        fn into(self) -> KeyEvent {
+            KeyEvent {
+                key: self.key.into(),
+                state: self.state,
+                mods: self.mods,
+            }
+        }
+    }
+
+    #[derive(Debug)]
+    pub struct KeyEvent {
+        pub key: KeyCode,
+        pub state: KeyState,
+        pub mods: Modifiers,
+    }
+
+    impl Into<KeyEventC> for KeyEvent {
+        fn into(self) -> KeyEventC {
+            KeyEventC {
+                key: self.key.into(),
+                state: self.state,
+                mods: self.mods,
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    #[repr(C)]
+    pub enum KeyState {
+        Idle = 0,
+        Pressed = 1,
+        Hold = 2,
+        Released = 3,
+    }
+
+    impl From<u8> for KeyState {
+        fn from(value: u8) -> Self {
+            match value {
+                1 => KeyState::Pressed,
+                2 => KeyState::Hold,
+                3 => KeyState::Released,
+                0 | _ => KeyState::Idle,
+            }
+        }
+    }
+
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum KeyCode {
+        JoyUp = 0x01,
+        JoyDown = 0x02,
+        JoyLeft = 0x03,
+        JoyRight = 0x04,
+        JoyCenter = 0x05,
+        BtnLeft1 = 0x06,
+        BtnRight1 = 0x07,
+        BtnLeft2 = 0x11,
+        BtnRight2 = 0x12,
+        Backspace = 0x08,
+        Tab = 0x09,
+        Enter = 0x0A,
+        ModAlt = 0xA1,
+        ModShiftLeft = 0xA2,
+        ModShiftRight = 0xA3,
+        ModSym = 0xA4,
+        ModCtrl = 0xA5,
+        Esc = 0xB1,
+        Left = 0xB4,
+        Up = 0xB5,
+        Down = 0xB6,
+        Right = 0xB7,
+        Break = 0xD0,
+        Insert = 0xD1,
+        Home = 0xD2,
+        Del = 0xD4,
+        End = 0xD5,
+        PageUp = 0xD6,
+        PageDown = 0xD7,
+        CapsLock = 0xC1,
+        F1 = 0x81,
+        F2 = 0x82,
+        F3 = 0x83,
+        F4 = 0x84,
+        F5 = 0x85,
+        F6 = 0x86,
+        F7 = 0x87,
+        F8 = 0x88,
+        F9 = 0x89,
+        F10 = 0x90,
+        Char(char),
+        Unknown(u8),
+    }
+
+    impl Into<u8> for KeyCode {
+        fn into(self) -> u8 {
+            match self {
+                KeyCode::JoyUp => 0x01,
+                KeyCode::JoyDown => 0x02,
+                KeyCode::JoyLeft => 0x03,
+                KeyCode::JoyRight => 0x04,
+                KeyCode::JoyCenter => 0x05,
+                KeyCode::BtnLeft1 => 0x06,
+                KeyCode::BtnRight1 => 0x07,
+                KeyCode::BtnLeft2 => 0x11,
+                KeyCode::BtnRight2 => 0x12,
+                KeyCode::Backspace => 0x08,
+                KeyCode::Tab => 0x09,
+                KeyCode::Enter => 0x0A,
+                KeyCode::ModAlt => 0xA1,
+                KeyCode::ModShiftLeft => 0xA2,
+                KeyCode::ModShiftRight => 0xA3,
+                KeyCode::ModSym => 0xA4,
+                KeyCode::ModCtrl => 0xA5,
+                KeyCode::Esc => 0xB1,
+                KeyCode::Left => 0xB4,
+                KeyCode::Up => 0xB5,
+                KeyCode::Down => 0xB6,
+                KeyCode::Right => 0xB7,
+                KeyCode::Break => 0xD0,
+                KeyCode::Insert => 0xD1,
+                KeyCode::Home => 0xD2,
+                KeyCode::Del => 0xD4,
+                KeyCode::End => 0xD5,
+                KeyCode::PageUp => 0xD6,
+                KeyCode::PageDown => 0xD7,
+                KeyCode::CapsLock => 0xC1,
+                KeyCode::F1 => 0x81,
+                KeyCode::F2 => 0x82,
+                KeyCode::F3 => 0x83,
+                KeyCode::F4 => 0x84,
+                KeyCode::F5 => 0x85,
+                KeyCode::F6 => 0x86,
+                KeyCode::F7 => 0x87,
+                KeyCode::F8 => 0x88,
+                KeyCode::F9 => 0x89,
+                KeyCode::F10 => 0x90,
+                KeyCode::Char(char) => char as u8,
+                KeyCode::Unknown(i) => i,
+            }
+        }
+    }
+
+    impl From<u8> for KeyCode {
+        fn from(value: u8) -> Self {
+            match value {
+                0x01 => Self::JoyUp,
+                0x02 => Self::JoyDown,
+                0x03 => Self::JoyLeft,
+                0x04 => Self::JoyRight,
+                0x05 => Self::JoyCenter,
+                0x06 => Self::BtnLeft1,
+                0x07 => Self::BtnRight1,
+                0x08 => Self::Backspace,
+                0x09 => Self::Tab,
+                0x0A => Self::Enter,
+                0x11 => Self::BtnLeft2,
+                0x12 => Self::BtnRight2,
+                0xA1 => Self::ModAlt,
+                0xA2 => Self::ModShiftLeft,
+                0xA3 => Self::ModShiftRight,
+                0xA4 => Self::ModSym,
+                0xA5 => Self::ModCtrl,
+                0xB1 => Self::Esc,
+                0xB4 => Self::Left,
+                0xB5 => Self::Up,
+                0xB6 => Self::Down,
+                0xB7 => Self::Right,
+                0xC1 => Self::CapsLock,
+                0xD0 => Self::Break,
+                0xD1 => Self::Insert,
+                0xD2 => Self::Home,
+                0xD4 => Self::Del,
+                0xD5 => Self::End,
+                0xD6 => Self::PageUp,
+                0xD7 => Self::PageDown,
+                0x81 => Self::F1,
+                0x82 => Self::F2,
+                0x83 => Self::F3,
+                0x84 => Self::F4,
+                0x85 => Self::F5,
+                0x86 => Self::F6,
+                0x87 => Self::F7,
+                0x88 => Self::F8,
+                0x89 => Self::F9,
+                0x90 => Self::F10,
+                _ => match char::from_u32(value as u32) {
+                    Some(c) => Self::Char(c),
+                    None => Self::Unknown(value),
+                },
+            }
+        }
+    }
+
+    pub type GetKeyAbi = extern "C" fn() -> KeyEventC;
+
+    #[unsafe(no_mangle)]
+    pub extern "C" fn get_key() -> KeyEventC {
+        let f: GetKeyAbi =
+            unsafe { core::mem::transmute(CALL_ABI_TABLE[CallAbiTable::GetKey as usize]) };
         f()
     }
 }
+
+#[repr(C)]
+pub enum RngRequest {
+    U32(u32),
+    U64(u64),
+    Bytes { ptr: *mut u8, len: usize },
+}
+
+pub type GenRand = extern "C" fn(req: &mut RngRequest);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn gen_rand(req: &mut RngRequest) {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallAbiTable::GenRand as usize];
+        let f: GenRand = core::mem::transmute(ptr);
+        f(req)
+    }
+}
+
+pub type ListDir = extern "C" fn(
+    str: *const u8,
+    len: usize,
+    files: *mut Option<DirEntry>,
+    file_len: usize,
+) -> usize;
+
+#[unsafe(no_mangle)]
+pub extern "C" fn list_dir(
+    str: *const u8,
+    len: usize,
+    files: *mut Option<DirEntry>,
+    file_len: usize,
+) -> usize {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallAbiTable::ListDir as usize];
+        let f: ListDir = core::mem::transmute(ptr);
+        f(str, len, files, file_len)
+    }
+}
+
+pub type ReadFile = extern "C" fn(
+    str: *const u8,
+    len: usize,
+    read_from: usize,
+    buf: *mut u8,
+    buf_len: usize,
+) -> usize;
+
+#[unsafe(no_mangle)]
+pub extern "C" fn read_file(
+    str: *const u8,
+    len: usize,
+    read_from: usize,
+    buf: *mut u8,
+    buf_len: usize,
+) -> usize {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallAbiTable::ReadFile as usize];
+        let f: ReadFile = core::mem::transmute(ptr);
+        f(str, len, read_from, buf, buf_len)
+    }
+}
+
+pub type FileLen = extern "C" fn(str: *const u8, len: usize) -> usize;
+
+#[unsafe(no_mangle)]
+pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallAbiTable::FileLen as usize];
+        let f: FileLen = core::mem::transmute(ptr);
+        f(str, len)
+    }
+}

cbindgen.toml

@@ -0,0 +1,4 @@
+language = "C"
+
+[macro_expansion]
+bitflags = true

justfile

@@ -1,4 +1,18 @@
-kernel: calculator
+kernel-dev:
     cargo run --bin kernel
-calculator:
-    RUSTFLAGS="-C link-arg=--noinhibit-exec" cargo build --bin calculator --profile release-binary
+kernel-release:
+    cargo build --bin kernel --release 
+    elf2uf2-rs -d target/thumbv8m.main-none-eabihf/release/kernel
+
+binary-args := "RUSTFLAGS=\"-C link-arg=-pie -C relocation-model=pic\""
+
+cbindgen:
+    cbindgen abi_sys --output abi_sys.h -q
+
+userapp app:
+     {{binary-args}} cargo build --bin {{app}} --profile release-binary
+
+userapps: cbindgen
+    just userapp calculator
+    just userapp snake
+    just userapp gallery

kernel/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kernel"
-version = "0.1.0"
+version = "0.0.1"
 edition = "2024"
 
 [[bin]]
@@ -45,7 +45,7 @@ embassy-rp = { version = "0.8.0", features = [
 embassy-usb = "0.5.1"
 embassy-futures = "0.1.2"
 embassy-time = { version = "0.5.0", features = ["generic-queue-8"] }
-embassy-embedded-hal = "0.3.1"
+embassy-embedded-hal = "0.3.2"
 embassy-sync = { version = "0.7" }
 trouble-host = { version = "0.1", features = [
   "derive",
@@ -72,18 +72,22 @@ defmt = { version = "0.3", optional = true }
 defmt-rtt = "0.4.2"
 
 embedded-sdmmc = { version = "0.9", default-features = false }
-st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", rev = "1d15123929fa7ef73d5d6aead7faf1bba50ce915" } # async branch
+st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", rev = "a784b9e6df0769371dfc522528e770cf8fc6403a" } # async branch
 embedded-graphics = { version = "0.8.1" }
 embedded-text = "0.7.2"
 embedded-layout = "0.4.2"
+kolibri-embedded-gui = "0.1.0"
 
+strum = { version = "0.27.2", default-features = false }
+rand = { version = "0.9.0", default-features = false }
+once_cell = { version = "1.21.3", default-features = false }
 static_cell = "2.1.1"
-bitflags = "2.9.1"
+bitflags = "2.9.4"
 heapless = "0.8.0"
-num_enum = { version = "0.7.4", default-features = false }
-goblin = { version = "0.10.0", default-features = false, features = ["elf32"] }
-talc = "4.4.3"
 spin = "0.10.0"
+num_enum = { version = "0.7.4", default-features = false }
+goblin = { version = "0.10.1", default-features = false, features = ["elf32"] }
+talc = "4.4.3"
+bumpalo = "3.19.0"
 
-shared = { path = "../shared" }
 abi_sys = { path = "../abi_sys" }

kernel/memory.x

@@ -1,10 +1,7 @@
 MEMORY {
     FLASH : ORIGIN = 0x10000000, LENGTH = 4096K
+
     RAM : ORIGIN = 0x20000000, LENGTH = 512K
-
-	/* Reserve a block of RAM for the user app */
-    USERAPP : ORIGIN = 0x20010000, LENGTH = 192K
-
     SRAM4 : ORIGIN = 0x20080000, LENGTH = 4K
     SRAM5 : ORIGIN = 0x20081000, LENGTH = 4K
 }
@@ -61,11 +58,3 @@ SECTIONS {
 
 PROVIDE(start_to_end = __end_block_addr - __start_block_addr);
 PROVIDE(end_to_start = __start_block_addr - __end_block_addr);
-
-SECTIONS {
-	.userapp (NOLOAD) :
-	{
-	    __userapp_start__ = ORIGIN(USERAPP);
-	    __userapp_end__   = ORIGIN(USERAPP) + LENGTH(USERAPP);
-	} > USERAPP
-}

kernel/src/abi.rs

@@ -1,46 +1,224 @@
-use core::{pin::Pin, time::Duration};
-
-use abi_sys::{DrawIterAbi, GetKeyAbi, Pixel, PrintAbi, SleepAbi};
-use alloc::boxed::Box;
-use defmt::info;
-use embassy_futures::block_on;
-use embassy_rp::clocks::clk_sys_freq;
-use embassy_time::Timer;
-use embedded_graphics::{
-    Drawable,
-    draw_target::DrawTarget,
-    pixelcolor::Rgb565,
-    prelude::{Point, RgbColor, Size},
-    primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
+use abi_sys::{
+    CPixel, DrawIterAbi, FileLen, GenRand, GetMsAbi, ListDir, LockDisplay, PrintAbi, ReadFile,
+    RngRequest, SleepMsAbi, keyboard::*,
 };
-use shared::keyboard::KeyEvent;
+use alloc::{string::ToString, vec::Vec};
+use core::sync::atomic::Ordering;
+use embassy_rp::clocks::{RoscRng, clk_sys_freq};
+use embassy_time::Instant;
+use embedded_graphics::draw_target::DrawTarget;
+use embedded_sdmmc::{DirEntry, LfnBuffer};
+use heapless::spsc::Queue;
 
-use crate::{KEY_CACHE, display::FRAMEBUFFER};
+use crate::{
+    display::{FB_PAUSED, FRAMEBUFFER},
+    storage::{Dir, File, SDCARD},
+};
 
-// ensure the abi and the kernel fn signatures are the same
 const _: PrintAbi = print;
-const _: SleepAbi = sleep;
-const _: DrawIterAbi = draw_iter;
-const _: GetKeyAbi = get_key;
+pub extern "C" fn print(ptr: *const u8, len: usize) {
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let slice = unsafe { core::slice::from_raw_parts(ptr, len) };
 
-pub extern "Rust" fn print(msg: &str) {
-    defmt::info!("{:?}", msg);
+    if let Ok(msg) = core::str::from_utf8(slice) {
+        defmt::info!("print: {}", msg);
+    } else {
+        defmt::warn!("print: <invalid utf8>");
+    }
 }
 
-pub extern "Rust" fn sleep(ms: u64) {
+const _: SleepMsAbi = sleep;
+pub extern "C" fn sleep(ms: u64) {
     let cycles_per_ms = clk_sys_freq() / 1000;
-    for _ in 0..ms {
-        for _ in 0..cycles_per_ms {
-            cortex_m::asm::nop();
+    let total_cycles = ms * cycles_per_ms as u64;
+
+    for _ in 0..total_cycles {
+        cortex_m::asm::nop();
+    }
+}
+
+pub static mut MS_SINCE_LAUNCH: Option<Instant> = None;
+
+const _: GetMsAbi = get_ms;
+pub extern "C" fn get_ms() -> u64 {
+    Instant::now()
+        .duration_since(unsafe { MS_SINCE_LAUNCH.unwrap() })
+        .as_millis()
+}
+
+const _: LockDisplay = lock_display;
+pub extern "C" fn lock_display(lock: bool) {
+    FB_PAUSED.store(lock, Ordering::Relaxed);
+}
+
+const _: DrawIterAbi = draw_iter;
+// TODO: maybe return result
+pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) {
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let cpixels = unsafe { core::slice::from_raw_parts(cpixels, len) };
+
+    let iter = cpixels.iter().copied().map(|c: CPixel| c.into());
+    unsafe { FRAMEBUFFER.draw_iter(iter).unwrap() }
+}
+
+pub static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();
+
+const _: GetKeyAbi = get_key;
+pub extern "C" fn get_key() -> KeyEventC {
+    if let Some(event) = unsafe { KEY_CACHE.dequeue() } {
+        event.into()
+    } else {
+        KeyEvent {
+            key: KeyCode::Unknown(0),
+            state: KeyState::Idle,
+            mods: Modifiers::empty(),
+        }
+        .into()
+    }
+}
+
+const _: GenRand = gen_rand;
+pub extern "C" fn gen_rand(req: &mut RngRequest) {
+    let mut rng = RoscRng;
+
+    match req {
+        RngRequest::U32(i) => *i = rng.next_u32(),
+        RngRequest::U64(i) => *i = rng.next_u64(),
+        RngRequest::Bytes { ptr, len } => {
+            // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+            let slice: &mut [u8] = unsafe { core::slice::from_raw_parts_mut(*ptr, *len) };
+            rng.fill_bytes(slice);
         }
     }
 }
 
-// TODO: maybe return result
-pub extern "Rust" fn draw_iter(pixels: &[Pixel<Rgb565>]) {
-    unsafe { FRAMEBUFFER.draw_iter(pixels.iter().copied()).unwrap() }
+fn get_dir_entries(dir: &Dir, files: &mut [Option<DirEntry>]) -> usize {
+    let mut i = 0;
+    dir.iterate_dir(|entry| {
+        if i < files.len() {
+            files[i] = Some(entry.clone());
+            i += 1;
+        }
+    })
+    .unwrap();
+    i
 }
 
-pub extern "Rust" fn get_key() -> Option<KeyEvent> {
-    unsafe { KEY_CACHE.dequeue() }
+fn recurse_dir(dir: &Dir, dirs: &[&str], files: &mut [Option<DirEntry>]) -> usize {
+    if dirs.is_empty() {
+        return get_dir_entries(dir, files);
+    }
+
+    let dir = dir.open_dir(dirs[0]).unwrap();
+    recurse_dir(&dir, &dirs[1..], files)
+}
+
+const _: ListDir = list_dir;
+pub extern "C" fn list_dir(
+    dir: *const u8,
+    len: usize,
+    files: *mut Option<DirEntry>,
+    files_len: usize,
+) -> usize {
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let files = unsafe { core::slice::from_raw_parts_mut(files, files_len) };
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let dir = unsafe { core::str::from_raw_parts(dir, len) };
+    let dirs: Vec<&str> = dir.split('/').collect();
+
+    let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
+    let sd = guard.as_mut().unwrap();
+
+    let mut wrote = 0;
+    sd.access_root_dir(|root| {
+        if dirs[0] == "" && dirs.len() >= 2 {
+            if dir == "/" {
+                wrote = get_dir_entries(&root, files);
+            } else {
+                wrote = recurse_dir(&root, &dirs[1..], files);
+            }
+        }
+    });
+    wrote
+}
+
+fn recurse_file<T>(
+    dir: &Dir,
+    dirs: &[&str],
+    mut access: impl FnMut(&mut File) -> T,
+) -> Result<T, ()> {
+    if dirs.len() == 1 {
+        let mut b = [0_u8; 50];
+        let mut buf = LfnBuffer::new(&mut b);
+        let mut short_name = None;
+        dir.iterate_dir_lfn(&mut buf, |entry, name| {
+            if let Some(name) = name {
+                if name == dirs[0] || entry.name.to_string().as_str() == dirs[0] {
+                    short_name = Some(entry.name.clone());
+                }
+            }
+        })
+        .unwrap();
+        if let Some(name) = short_name {
+            let mut file = dir
+                .open_file_in_dir(name, embedded_sdmmc::Mode::ReadWriteAppend)
+                .map_err(|_| ())?;
+            return Ok(access(&mut file));
+        }
+        return Err(());
+    }
+
+    let dir = dir.open_dir(dirs[0]).unwrap();
+    recurse_file(&dir, &dirs[1..], access)
+}
+
+const _: ReadFile = read_file;
+pub extern "C" fn read_file(
+    str: *const u8,
+    len: usize,
+    start_from: usize,
+    buf: *mut u8,
+    buf_len: usize,
+) -> usize {
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let file = unsafe { core::str::from_raw_parts(str, len) };
+    let file: Vec<&str> = file.split('/').collect();
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let mut buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
+
+    let mut read = 0;
+
+    let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
+    let sd = guard.as_mut().unwrap();
+    if !file.is_empty() {
+        sd.access_root_dir(|root| {
+            if let Ok(result) = recurse_file(&root, &file[1..], |file| {
+                file.seek_from_start(start_from as u32).unwrap();
+                file.read(&mut buf).unwrap()
+            }) {
+                read = result
+            };
+        });
+    }
+    read
+}
+
+const _: FileLen = file_len;
+pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let file = unsafe { core::str::from_raw_parts(str, len) };
+    let file: Vec<&str> = file.split('/').collect();
+
+    let mut len = 0;
+
+    let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
+    let sd = guard.as_mut().unwrap();
+    if !file.is_empty() {
+        sd.access_root_dir(|root| {
+            if let Ok(result) = recurse_file(&root, &file[1..], |file| file.length()) {
+                len = result
+            }
+        });
+    }
+    len as usize
 }

kernel/src/display.rs

@@ -1,3 +1,5 @@
+use core::sync::atomic::{AtomicBool, Ordering};
+
 use crate::framebuffer::AtomicFrameBuffer;
 use embassy_rp::{
     Peri,
@@ -6,11 +8,6 @@ use embassy_rp::{
     spi::{Async, Spi},
 };
 use embassy_time::{Delay, Timer};
-use embedded_graphics::{
-    draw_target::DrawTarget,
-    pixelcolor::{Rgb565, RgbColor},
-    prelude::Dimensions,
-};
 use embedded_hal_bus::spi::ExclusiveDevice;
 use st7365p_lcd::ST7365P;
 
@@ -25,6 +22,7 @@ pub const SCREEN_WIDTH: usize = 320;
 pub const SCREEN_HEIGHT: usize = 320;
 
 pub static mut FRAMEBUFFER: AtomicFrameBuffer = AtomicFrameBuffer::new();
+pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
 
 pub async fn init_display(
     spi: Spi<'static, SPI1, Async>,
@@ -49,22 +47,18 @@ pub async fn init_display(
     display
 }
 
-pub fn clear_fb() {
-    let bounds = unsafe { FRAMEBUFFER.bounding_box() };
-    unsafe {
-        let _ = FRAMEBUFFER.fill_solid(&bounds, Rgb565::BLACK);
-    }
-}
-
+#[embassy_executor::task]
 pub async fn display_handler(mut display: DISPLAY) {
     loop {
-        unsafe {
-            FRAMEBUFFER
-                .partial_draw_batched(&mut display)
-                .await
-                .unwrap()
+        if !FB_PAUSED.load(Ordering::Acquire) {
+            unsafe {
+                FRAMEBUFFER
+                    .partial_draw_batched(&mut display)
+                    .await
+                    .unwrap()
+            }
         }
 
-        Timer::after_millis(32).await; // 30 fps
+        Timer::after_millis(10).await;
     }
 }

kernel/src/elf.rs

@@ -1,83 +1,160 @@
-#![allow(static_mut_refs)]
-
 use crate::{
     abi,
     storage::{File, SDCARD},
 };
-use abi_sys::{CallAbiTable, EntryFn};
+use abi_sys::CallAbiTable;
+use abi_sys::EntryFn;
 use alloc::{vec, vec::Vec};
+use bumpalo::Bump;
+use core::ptr;
 use embedded_sdmmc::ShortFileName;
 use goblin::{
     elf::{
         header::header32::Header,
         program_header::program_header32::{PT_LOAD, ProgramHeader},
-        section_header::SHT_SYMTAB,
+        reloc::R_ARM_RELATIVE,
+        section_header::{SHT_REL, SHT_SYMTAB},
     },
-    elf32::{section_header::SectionHeader, sym::Sym},
+    elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym},
 };
+use strum::IntoEnumIterator;
 
 const ELF32_HDR_SIZE: usize = 52;
 
-// userland ram region defined in memory.x
-unsafe extern "C" {
-    static __userapp_start__: u8;
-    static __userapp_end__: u8;
-}
-
-pub async unsafe fn load_binary(name: &ShortFileName) -> Result<EntryFn, &str> {
+pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> {
     let mut sd_lock = SDCARD.get().lock().await;
     let sd = sd_lock.as_mut().unwrap();
 
-    let mut error = "";
-    let mut entry = 0;
-
     let mut header_buf = [0; ELF32_HDR_SIZE];
 
-    sd.read_file(name, |mut file| {
-        file.read(&mut header_buf).unwrap();
-        let elf_header = Header::from_bytes(&header_buf);
+    let (entry, bump) = sd
+        .read_file(name, |mut file| {
+            file.read(&mut header_buf).unwrap();
+            let elf_header = Header::from_bytes(&header_buf);
 
-        let mut program_headers_buf = vec![0_u8; elf_header.e_phentsize as usize];
-        for i in 1..=elf_header.e_phnum {
-            file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-                .unwrap();
-            file.read(&mut program_headers_buf).unwrap();
+            // reject non-PIE
+            if elf_header.e_type != header::ET_DYN {
+                return None;
+            }
 
-            let ph = cast_phdr(&program_headers_buf);
+            let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize];
 
-            if ph.p_type == PT_LOAD {
-                load_segment(&mut file, &ph).unwrap()
+            let (total_size, min_vaddr, _max_vaddr) =
+                total_loadable_size(&mut file, &elf_header, &mut ph_buf);
+
+            let bump = Bump::with_capacity(total_size);
+            let base = bump.alloc_slice_fill_default::<u8>(total_size);
+
+            // load each segment into bump, relative to base_ptr
+            for i in 0..elf_header.e_phnum {
+                file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
+                    .unwrap();
+                file.read(&mut ph_buf).unwrap();
+                let ph = cast_phdr(&ph_buf);
+
+                let seg_offset = (ph.p_vaddr - min_vaddr) as usize;
+                let mut segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
+
+                if ph.p_type == PT_LOAD {
+                    load_segment(&mut file, &ph, &mut segment).unwrap();
+                }
+            }
+
+            for i in 0..elf_header.e_shnum {
+                let sh = read_section(&mut file, elf_header, i.into());
+
+                match sh.sh_type {
+                    SHT_REL => {
+                        apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap();
+                    }
+                    _ => {}
+                }
+            }
+
+            patch_abi(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap();
+
+            // entry pointer is base_ptr + (entry - min_vaddr)
+            let entry_ptr: EntryFn = unsafe {
+                core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize))
+            };
+
+            Some((entry_ptr, bump))
+        })
+        .await
+        .expect("Failed to read file")?;
+
+    Some((entry, bump))
+}
+
+fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), ()> {
+    let filesz = ph.p_filesz as usize;
+    let memsz = ph.p_memsz as usize;
+
+    // read file contents
+    let mut remaining = filesz;
+    let mut dst_offset = 0;
+    let mut file_offset = ph.p_offset;
+    let mut buf = [0u8; 512];
+
+    while remaining > 0 {
+        let to_read = core::cmp::min(remaining, buf.len());
+        file.seek_from_start(file_offset).unwrap();
+        file.read(&mut buf[..to_read]).unwrap();
+
+        segment[dst_offset..dst_offset + to_read].copy_from_slice(&buf[..to_read]);
+
+        remaining -= to_read;
+        dst_offset += to_read;
+        file_offset += to_read as u32;
+    }
+
+    // zero BSS if needed
+    if memsz > filesz {
+        segment[filesz..].fill(0);
+    }
+
+    Ok(())
+}
+
+fn apply_relocations(
+    sh: &SectionHeader,
+    min_vaddr: u32,
+    base: *mut u8,
+    file: &mut File,
+) -> Result<(), ()> {
+    let mut reloc = [0_u8; 8];
+
+    let num_relocs = sh.sh_size as usize / sh.sh_entsize as usize;
+
+    for i in 0..num_relocs {
+        file.seek_from_start(sh.sh_offset + (i as u32 * 8)).unwrap();
+        file.read(&mut reloc).unwrap();
+
+        let rel = cast_rel(&reloc);
+
+        let reloc_type = rel.r_info & 0xff;
+        let reloc_addr = unsafe { base.add((rel.r_offset - min_vaddr) as usize) as *mut u32 };
+
+        match reloc_type {
+            R_ARM_RELATIVE => {
+                // REL: add base to the word already stored there
+                unsafe {
+                    let val = ptr::read_unaligned(reloc_addr);
+                    ptr::write_unaligned(reloc_addr, val.wrapping_add(base as u32));
+                }
+            }
+            _ => {
+                return Err(());
             }
         }
-
-        // MUST MATCH ABI EXACTLY
-        let entries: &[(CallAbiTable, usize)] = &[
-            (CallAbiTable::Print, abi::print as usize),
-            (CallAbiTable::Sleep, abi::sleep as usize),
-            (CallAbiTable::DrawIter, abi::draw_iter as usize),
-            (CallAbiTable::GetKey, abi::get_key as usize),
-        ];
-        assert!(entries.len() == CallAbiTable::COUNT);
-
-        patch_abi(entries, &elf_header, &mut file).unwrap();
-
-        // TODO: dynamically search for abi table
-
-        entry = elf_header.e_entry as u32;
-    })
-    .await
-    .unwrap();
-
-    if entry != 0 {
-        Ok(unsafe { core::mem::transmute(entry) })
-    } else {
-        Err(error)
     }
+    Ok(())
 }
 
 fn patch_abi(
-    entries: &[(CallAbiTable, usize)],
     elf_header: &Header,
+    base: *mut u8,
+    min_vaddr: u32,
     file: &mut File,
 ) -> Result<(), ()> {
     for i in 1..=elf_header.e_shnum {
@@ -113,11 +190,25 @@ fn patch_abi(
 
                 let symbol_name = core::str::from_utf8(&name).unwrap();
                 if symbol_name == "CALL_ABI_TABLE" {
-                    let table_base = sym.st_value as *mut usize;
+                    let table_base =
+                        unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) }
+                            as *mut usize;
 
-                    for &(abi_idx, func_ptr) in entries {
+                    for (idx, call) in CallAbiTable::iter().enumerate() {
+                        let ptr = match call {
+                            CallAbiTable::PrintString => abi::print as usize,
+                            CallAbiTable::SleepMs => abi::sleep as usize,
+                            CallAbiTable::GetMs => abi::get_ms as usize,
+                            CallAbiTable::LockDisplay => abi::lock_display as usize,
+                            CallAbiTable::DrawIter => abi::draw_iter as usize,
+                            CallAbiTable::GetKey => abi::get_key as usize,
+                            CallAbiTable::GenRand => abi::gen_rand as usize,
+                            CallAbiTable::ListDir => abi::list_dir as usize,
+                            CallAbiTable::ReadFile => abi::read_file as usize,
+                            CallAbiTable::FileLen => abi::file_len as usize,
+                        };
                         unsafe {
-                            table_base.add(abi_idx as usize).write(func_ptr);
+                            table_base.add(idx as usize).write(ptr);
                         }
                     }
                     return Ok(());
@@ -128,65 +219,41 @@ fn patch_abi(
     Err(())
 }
 
+fn total_loadable_size(
+    file: &mut File,
+    elf_header: &Header,
+    ph_buf: &mut [u8],
+) -> (usize, u32, u32) {
+    let mut min_vaddr = u32::MAX;
+    let mut max_vaddr = 0u32;
+    for i in 0..elf_header.e_phnum {
+        file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
+            .unwrap();
+        file.read(ph_buf).unwrap();
+        let ph = cast_phdr(&ph_buf);
+
+        if ph.p_type == PT_LOAD {
+            if ph.p_vaddr < min_vaddr {
+                min_vaddr = ph.p_vaddr;
+            }
+            if ph.p_vaddr + ph.p_memsz > max_vaddr {
+                max_vaddr = ph.p_vaddr + ph.p_memsz;
+            }
+        }
+    }
+
+    let total_size = (max_vaddr - min_vaddr) as usize;
+    (total_size, min_vaddr, max_vaddr)
+}
+
 fn read_section(file: &mut File, elf_header: &Header, section: u32) -> SectionHeader {
-    let mut section_header_buf = vec![0_u8; elf_header.e_shentsize as usize];
+    let mut sh_buf = vec![0_u8; elf_header.e_shentsize as usize];
 
     file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
         .unwrap();
-    file.read(&mut section_header_buf).unwrap();
+    file.read(&mut sh_buf).unwrap();
 
-    cast_shdr(&section_header_buf)
-}
-
-fn load_segment(file: &mut File, ph: &ProgramHeader) -> Result<(), ()> {
-    let dst_start = ph.p_vaddr as *mut u8;
-    let filesz = ph.p_filesz as usize;
-    let memsz = ph.p_memsz as usize;
-    let vaddr = ph.p_vaddr as usize;
-    let mut remaining = filesz;
-    let mut dst_ptr = dst_start;
-    let mut file_offset = ph.p_offset;
-
-    let seg_start = vaddr;
-    let seg_end = vaddr + memsz;
-
-    // Bounds check: make sure segment fits inside payload region
-    let user_start = unsafe { &__userapp_start__ as *const u8 as usize };
-    let user_end = unsafe { &__userapp_end__ as *const u8 as usize };
-    if seg_start < user_start || seg_end > user_end {
-        panic!(
-            "Segment out of bounds: {:x}..{:x} not within {:x}..{:x}",
-            seg_start, seg_end, user_start, user_end
-        );
-    }
-
-    // Buffer for chunked reads (512 bytes is typical SD sector size)
-    let mut buf = [0u8; 512];
-
-    while remaining > 0 {
-        let to_read = core::cmp::min(remaining, buf.len());
-        // Read chunk from file
-        file.seek_from_start(file_offset).unwrap();
-        file.read(&mut buf[..to_read]).unwrap();
-
-        unsafe {
-            // Copy chunk directly into destination memory
-            core::ptr::copy_nonoverlapping(buf.as_ptr(), dst_ptr, to_read);
-            dst_ptr = dst_ptr.add(to_read);
-        }
-
-        remaining -= to_read;
-        file_offset += to_read as u32;
-    }
-
-    // Zero BSS (memsz - filesz)
-    if memsz > filesz {
-        unsafe {
-            core::ptr::write_bytes(dst_ptr, 0, memsz - filesz);
-        }
-    }
-
-    Ok(())
+    cast_shdr(&sh_buf)
 }
 
 fn cast_phdr(buf: &[u8]) -> ProgramHeader {
@@ -203,3 +270,8 @@ fn cast_sym(buf: &[u8]) -> Sym {
     assert!(buf.len() >= core::mem::size_of::<Sym>());
     unsafe { core::ptr::read(buf.as_ptr() as *const Sym) }
 }
+
+fn cast_rel(buf: &[u8]) -> Rel {
+    assert!(buf.len() >= core::mem::size_of::<Rel>());
+    unsafe { core::ptr::read(buf.as_ptr() as *const Rel) }
+}

kernel/src/framebuffer.rs

@@ -13,7 +13,7 @@ use embedded_graphics::{
 use embedded_hal_2::digital::OutputPin;
 use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
 use heapless::Vec;
-use st7365p_lcd::{FrameBuffer, ST7365P};
+use st7365p_lcd::ST7365P;
 
 pub const TILE_SIZE: usize = 16; // 16x16 tile
 pub const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
@@ -26,7 +26,7 @@ const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
 
 static mut BUFFER: [u16; SIZE] = [0; SIZE];
 
-static mut DIRTY_TILES: LazyLock<Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
+static mut DIRTY_TILES: LazyLock<heapless::Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
     let mut tiles = Vec::new();
     for _ in 0..TILE_COUNT {
         tiles.push(AtomicBool::new(true)).unwrap();
@@ -71,10 +71,10 @@ impl AtomicFrameBuffer {
         ey: u16,
         colors: P,
     ) -> Result<(), ()> {
-        if sx >= self.size().width as u16 - 1
-            || ex >= self.size().width as u16 - 1
-            || sy >= self.size().height as u16 - 1
-            || ey >= self.size().height as u16 - 1
+        if sx >= self.size().width as u16
+            || ex >= self.size().width as u16
+            || sy >= self.size().height as u16
+            || ey >= self.size().height as u16
         {
             return Err(()); // Bounds check
         }
@@ -101,7 +101,7 @@ impl AtomicFrameBuffer {
 
     // walk the dirty tiles and mark groups of tiles(meta-tiles) for batched updates
     fn find_meta_tiles(&mut self, tiles_x: usize, tiles_y: usize) -> MetaTileVec {
-        let mut meta_tiles: MetaTileVec = Vec::new();
+        let mut meta_tiles: MetaTileVec = heapless::Vec::new();
 
         for ty in 0..tiles_y {
             let mut tx = 0;
@@ -184,69 +184,6 @@ impl AtomicFrameBuffer {
         Ok(())
     }
 
-    /// Sends only dirty tiles (16x16px) individually to the display without batching
-    pub async fn partial_draw<SPI, DC, RST, DELAY: DelayNs>(
-        &mut self,
-        display: &mut ST7365P<SPI, DC, RST, DELAY>,
-    ) -> Result<(), ()>
-    where
-        SPI: SpiDevice,
-        DC: OutputPin,
-        RST: OutputPin,
-    {
-        if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
-            let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
-            let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
-
-            let mut tile_buffer = [0u16; TILE_SIZE * TILE_SIZE];
-
-            for ty in 0..tiles_y {
-                for tx in 0..tiles_x {
-                    if unsafe { !DIRTY_TILES.get()[ty * tiles_x + tx].load(Ordering::Acquire) } {
-                        continue;
-                    }
-
-                    let x = tx * TILE_SIZE;
-                    let y = ty * TILE_SIZE;
-
-                    // Copy pixels for the tile into tile_buffer
-                    for row in 0..TILE_SIZE {
-                        for col in 0..TILE_SIZE {
-                            let actual_x = x + col;
-                            let actual_y = y + row;
-
-                            if actual_x < SCREEN_WIDTH && actual_y < SCREEN_HEIGHT {
-                                let idx = actual_y * SCREEN_WIDTH + actual_x;
-                                tile_buffer[row * TILE_SIZE + col] = unsafe { BUFFER[idx] };
-                            } else {
-                                // Out of bounds, fill with zero (or background)
-                                tile_buffer[row * TILE_SIZE + col] = 0;
-                            }
-                        }
-                    }
-
-                    // Send the tile's pixel data to the display
-                    display
-                        .set_pixels_buffered(
-                            x as u16,
-                            y as u16,
-                            (x + TILE_SIZE - 1).min(SCREEN_WIDTH - 1) as u16,
-                            (y + TILE_SIZE - 1).min(SCREEN_HEIGHT - 1) as u16,
-                            &tile_buffer,
-                        )
-                        .await?;
-
-                    // Mark tile as clean
-                    unsafe {
-                        DIRTY_TILES.get_mut()[ty * tiles_x + tx].store(false, Ordering::Release)
-                    };
-                }
-            }
-        }
-
-        Ok(())
-    }
-
     /// Sends only dirty tiles (16x16px) in batches to the display
     pub async fn partial_draw_batched<SPI, DC, RST, DELAY>(
         &mut self,
@@ -415,10 +352,8 @@ impl DrawTarget for AtomicFrameBuffer {
                 .take((self.size().width * self.size().height) as usize),
         )?;
 
-        unsafe {
-            for tile in DIRTY_TILES.get_mut().iter() {
-                tile.store(true, Ordering::Relaxed);
-            }
+        for tile in unsafe { DIRTY_TILES.get_mut() }.iter() {
+            tile.store(true, Ordering::Release);
         }
 
         Ok(())

kernel/src/main.rs

@@ -1,6 +1,5 @@
 #![feature(impl_trait_in_assoc_type)]
-#![feature(type_alias_impl_trait)]
-#![feature(ascii_char)]
+#![feature(str_from_raw_parts)]
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(not(test), no_main)]
 #![allow(static_mut_refs)]
@@ -19,24 +18,29 @@ mod usb;
 mod utils;
 
 use crate::{
-    display::{FRAMEBUFFER, clear_fb, display_handler, init_display},
-    elf::load_binary,
+    abi::{KEY_CACHE, MS_SINCE_LAUNCH},
+    display::{FRAMEBUFFER, display_handler, init_display},
     peripherals::{
         conf_peripherals,
-        keyboard::{KeyCode, KeyState, read_keyboard_fifo},
+        keyboard::{KeyState, read_keyboard_fifo},
     },
+    scsi::MSC_SHUTDOWN,
     storage::{SDCARD, SdCard},
-    ui::{SELECTIONS, ui_handler},
-    usb::usb_handler,
+    ui::{SELECTIONS, clear_selection, ui_handler},
 };
 use abi_sys::EntryFn;
+use bumpalo::Bump;
+use embedded_graphics::{
+    pixelcolor::Rgb565,
+    prelude::{DrawTarget, RgbColor},
+};
 
 use {defmt_rtt as _, panic_probe as _};
 
-use assign_resources::assign_resources;
+use core::sync::atomic::{AtomicBool, Ordering};
 use defmt::unwrap;
 use embassy_executor::{Executor, Spawner};
-use embassy_futures::join::{join, join3, join4, join5};
+use embassy_futures::{join::join, select::select};
 use embassy_rp::{
     Peri,
     gpio::{Input, Level, Output, Pull},
@@ -50,13 +54,11 @@ use embassy_rp::{
     usb as embassy_rp_usb,
 };
 use embassy_sync::{
-    blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, mutex::Mutex, signal::Signal,
+    blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, signal::Signal,
 };
-use embassy_time::{Delay, Timer};
+use embassy_time::{Delay, Instant, Timer};
 use embedded_hal_bus::spi::ExclusiveDevice;
 use embedded_sdmmc::SdCard as SdmmcSdCard;
-use heapless::spsc::Queue;
-use shared::keyboard::KeyEvent;
 use static_cell::StaticCell;
 use talc::*;
 
@@ -69,21 +71,15 @@ static mut CORE1_STACK: Stack<16384> = Stack::new();
 static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
 static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
 
-static mut ARENA: [u8; 10 * 1024] = [0; 10 * 1024];
+static mut ARENA: [u8; 200 * 1024] = [0; 200 * 1024];
 
 #[global_allocator]
 static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
     Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
         .lock();
 
-static TASK_STATE: Mutex<CriticalSectionRawMutex, TaskState> = Mutex::new(TaskState::Ui);
-static TASK_STATE_CHANGED: Signal<CriticalSectionRawMutex, ()> = Signal::new();
-
-#[derive(Copy, Clone, PartialEq)]
-enum TaskState {
-    Ui,
-    Kernel,
-}
+static ENABLE_UI: AtomicBool = AtomicBool::new(true);
+static UI_CHANGE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
@@ -123,35 +119,41 @@ async fn main(_spawner: Spawner) {
         data: p.PIN_6,
     };
     let executor0 = EXECUTOR0.init(Executor::new());
-    executor0.run(|spawner| unwrap!(spawner.spawn(kernel_task(display, sd, mcu, p.USB))));
+    executor0.run(|spawner| unwrap!(spawner.spawn(kernel_task(spawner, display, sd, mcu, p.USB))));
 }
 
 // One-slot channel to pass EntryFn from core1
-static BINARY_CH: Channel<CriticalSectionRawMutex, EntryFn, 1> = Channel::new();
+static BINARY_CH: Channel<CriticalSectionRawMutex, (EntryFn, Bump), 1> = Channel::new();
 
 // runs dynamically loaded elf files
 #[embassy_executor::task]
 async fn userland_task() {
     let recv = BINARY_CH.receiver();
     loop {
-        let entry = recv.receive().await;
-        defmt::info!("Got Entry");
+        let (entry, _bump) = recv.receive().await;
 
         // disable kernel ui
         {
-            let mut state = TASK_STATE.lock().await;
-            *state = TaskState::Kernel;
+            ENABLE_UI.store(false, Ordering::Release);
+            UI_CHANGE.signal(());
+
+            clear_selection().await;
+
+            MSC_SHUTDOWN.signal(());
         }
 
-        // clear_fb();
-
+        unsafe { MS_SINCE_LAUNCH = Some(Instant::now()) };
         defmt::info!("Executing Binary");
-        entry().await;
+        entry();
 
         // enable kernel ui
         {
-            let mut state = TASK_STATE.lock().await;
-            *state = TaskState::Ui;
+            ENABLE_UI.store(true, Ordering::Release);
+            UI_CHANGE.signal(());
+            unsafe { FRAMEBUFFER.clear(Rgb565::BLACK).unwrap() };
+
+            let mut selections = SELECTIONS.lock().await;
+            selections.set_changed(true);
         }
     }
 }
@@ -181,16 +183,15 @@ struct Mcu {
     data: Peri<'static, PIN_6>,
 }
 
-#[embassy_executor::task]
-async fn kernel_task(display: Display, sd: Sd, mcu: Mcu, usb: Peri<'static, USB>) {
-    // MCU i2c bus for peripherals
+async fn setup_mcu(mcu: Mcu) {
+    // MCU i2c bus for peripherals( keyboard)
     let mut config = i2c::Config::default();
     config.frequency = 400_000;
     let i2c1 = I2c::new_async(mcu.i2c, mcu.clk, mcu.data, Irqs, config);
     conf_peripherals(i2c1).await;
+}
 
-    Timer::after_millis(250).await;
-
+async fn setup_display(display: Display, spawner: Spawner) {
     let mut config = spi::Config::default();
     config.frequency = 16_000_000;
     let spi = Spi::new(
@@ -203,66 +204,77 @@ async fn kernel_task(display: Display, sd: Sd, mcu: Mcu, usb: Peri<'static, USB>
         config,
     );
     let display = init_display(spi, display.cs, display.data, display.reset).await;
-
-    let display_fut = display_handler(display);
-
-    let ui_fut = ui_handler();
-
-    let binary_search_fut = async {
-        loop {
-            {
-                let mut guard = SDCARD.get().lock().await;
-
-                if let Some(sd) = guard.as_mut() {
-                    let files = sd.list_files_by_extension(".bin").unwrap();
-                    let mut select = SELECTIONS.lock().await;
-
-                    if select.selections != files {
-                        select.selections = files;
-                        select.reset();
-                    }
-                }
-            }
-            Timer::after_secs(5).await;
-        }
-    };
-
-    {
-        let mut config = spi::Config::default();
-        config.frequency = 400_000;
-        let spi = Spi::new_blocking(sd.spi, sd.clk, sd.mosi, sd.miso, config.clone());
-        let cs = Output::new(sd.cs, Level::High);
-        let det = Input::new(sd.det, Pull::None);
-
-        let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
-        let sdcard = SdmmcSdCard::new(device, Delay);
-
-        config.frequency = 32_000_000;
-        sdcard.spi(|dev| dev.bus_mut().set_config(&config));
-        SDCARD.get().lock().await.replace(SdCard::new(sdcard, det));
-    };
-
-    let usb = embassy_rp_usb::Driver::new(usb, Irqs);
-    let usb_fut = usb_handler(usb);
-
-    let key_abi_fut = async {
-        loop {
-            Timer::after_millis(100).await;
-            get_keys().await
-        }
-    };
-
-    join5(display_fut, ui_fut, usb_fut, binary_search_fut, key_abi_fut).await;
+    spawner.spawn(display_handler(display)).unwrap();
 }
 
-static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();
+async fn setup_sd(sd: Sd) {
+    let mut config = spi::Config::default();
+    config.frequency = 400_000;
+    let spi = Spi::new_blocking(sd.spi, sd.clk, sd.mosi, sd.miso, config.clone());
+    let cs = Output::new(sd.cs, Level::High);
+    let det = Input::new(sd.det, Pull::None);
 
-async fn get_keys() {
-    if let Some(event) = read_keyboard_fifo().await {
-        if let KeyState::Pressed = event.state {
-            unsafe {
-                let _ = KEY_CACHE.enqueue(event);
-            }
+    let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
+    let sdcard = SdmmcSdCard::new(device, Delay);
+
+    config.frequency = 32_000_000;
+    sdcard.spi(|dev| dev.bus_mut().set_config(&config));
+    SDCARD.get().lock().await.replace(SdCard::new(sdcard, det));
+}
+
+#[embassy_executor::task]
+async fn kernel_task(
+    spawner: Spawner,
+    display: Display,
+    sd: Sd,
+    mcu: Mcu,
+    usb: Peri<'static, USB>,
+) {
+    setup_mcu(mcu).await;
+    Timer::after_millis(250).await;
+    setup_display(display, spawner).await;
+    setup_sd(sd).await;
+
+    let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
+    // spawner.spawn(usb_handler(usb)).unwrap();
+
+    loop {
+        let ui_enabled = ENABLE_UI.load(Ordering::Relaxed);
+        if ui_enabled {
+            select(join(ui_handler(), prog_search_handler()), UI_CHANGE.wait()).await;
+        } else {
+            select(key_handler(), UI_CHANGE.wait()).await;
         }
     }
 }
+
+async fn prog_search_handler() {
+    loop {
+        {
+            let mut guard = SDCARD.get().lock().await;
+            let sd = guard.as_mut().unwrap();
+
+            let files = sd.list_files_by_extension(".bin").unwrap();
+            let mut select = SELECTIONS.lock().await;
+
+            if *select.selections() != files {
+                select.update_selections(files);
+                select.reset();
+            }
+        }
+        Timer::after_secs(5).await;
+    }
+}
+
+async fn key_handler() {
+    loop {
+        if let Some(event) = read_keyboard_fifo().await {
+            if let KeyState::Pressed = event.state {
+                unsafe {
+                    let _ = KEY_CACHE.enqueue(event);
+                }
+            }
+        }
+        Timer::after_millis(50).await;
+    }
+}

kernel/src/peripherals/keyboard.rs

@@ -1,5 +1,5 @@
 use crate::peripherals::PERIPHERAL_BUS;
-pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+pub use abi_sys::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
 
 const REG_ID_KEY: u8 = 0x04;
 const REG_ID_FIF: u8 = 0x09;

kernel/src/scsi/mod.rs

@@ -1,7 +1,9 @@
-use crate::format;
+use embassy_futures::select::select;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::lazy_lock::LazyLock;
+use embassy_sync::signal::Signal;
+use embassy_usb::Builder;
 use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
-use embassy_usb::types::StringIndex;
-use embassy_usb::{Builder, Config};
 use embedded_sdmmc::{Block, BlockIdx};
 use heapless::Vec;
 
@@ -12,13 +14,24 @@ use crate::storage::{SDCARD, SdCard};
 
 const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
 
+pub static MSC_SHUTDOWN: Signal<CriticalSectionRawMutex, ()> = Signal::new();
+
+// number of blocks to read from sd at once
+// higher is better, but is larger. Size is BLOCKS * 512 bytes
+const BLOCKS: usize = 32;
+static mut BLOCK_BUF: LazyLock<[Block; BLOCKS]> =
+    LazyLock::new(|| core::array::from_fn(|_| Block::new()));
+
 pub struct MassStorageClass<'d, D: Driver<'d>> {
+    temp_sd: Option<SdCard>, // temporary owns sdcard when scsi is running
+    ejected: bool,
+    pending_eject: bool,
     bulk_out: D::EndpointOut,
     bulk_in: D::EndpointIn,
 }
 
 impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
-    pub fn new(builder: &mut Builder<'d, D>) -> Self {
+    pub fn new(builder: &mut Builder<'d, D>, temp_sd: Option<SdCard>) -> Self {
         let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
         let mut interface = function.interface();
         let mut alt = interface.alt_setting(0x08, SUBCLASS_SCSI, 0x50, None);
@@ -26,20 +39,62 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         let bulk_out = alt.endpoint_bulk_out(None, BULK_ENDPOINT_PACKET_SIZE as u16);
         let bulk_in = alt.endpoint_bulk_in(None, BULK_ENDPOINT_PACKET_SIZE as u16);
 
-        Self { bulk_out, bulk_in }
+        Self {
+            temp_sd,
+            pending_eject: false,
+            ejected: false,
+            bulk_out,
+            bulk_in,
+        }
     }
 
     pub async fn poll(&mut self) {
         loop {
-            let mut cbw_buf = [0u8; 31];
-            if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
-                if n == 31 {
-                    if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
-                        // TODO: validate cbw
-                        if self.handle_command(&cbw.CBWCB).await.is_ok() {
-                            self.send_csw_success(cbw.dCBWTag).await
+            if !self.ejected {
+                select(self.handle_cbw(), MSC_SHUTDOWN.wait()).await;
+
+                if MSC_SHUTDOWN.signaled() {
+                    defmt::info!("MSC shutting down");
+
+                    if self.temp_sd.is_some() {
+                        let mut guard = SDCARD.get().lock().await;
+                        guard.replace(self.temp_sd.take().unwrap()).unwrap();
+                    }
+
+                    self.ejected = true;
+
+                    return;
+                }
+            }
+        }
+    }
+
+    async fn handle_cbw(&mut self) {
+        let mut cbw_buf = [0u8; 31];
+        if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
+            if n == 31 {
+                if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
+                    // Take sdcard to increase speed
+                    if self.temp_sd.is_none() {
+                        let mut guard = SDCARD.get().lock().await;
+                        if let Some(sd) = guard.take() {
+                            self.temp_sd = Some(sd);
                         } else {
-                            self.send_csw_fail(cbw.dCBWTag).await
+                            defmt::warn!("Tried to take SDCARD but it was already taken");
+                            return;
+                        }
+                    }
+
+                    let command = parse_cb(&cbw.CBWCB);
+                    if self.handle_command(command).await.is_ok() {
+                        self.send_csw_success(cbw.dCBWTag).await
+                    } else {
+                        self.send_csw_fail(cbw.dCBWTag).await
+                    }
+
+                    if self.pending_eject {
+                        if let ScsiCommand::Write { lba: _, len: _ } = command {
+                            MSC_SHUTDOWN.signal(());
                         }
                     }
                 }
@@ -47,16 +102,11 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         }
     }
 
-    async fn handle_command(&mut self, cbw: &[u8]) -> Result<(), ()> {
+    async fn handle_command(&mut self, command: ScsiCommand) -> Result<(), ()> {
         let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
-        let mut block = [Block::new(); 1];
 
-        match parse_cb(cbw) {
-            ScsiCommand::Unknown => {
-                #[cfg(feature = "defmt")]
-                defmt::warn!("Got unexpected scsi command: {}", cbw);
-                Err(())
-            }
+        match command {
+            ScsiCommand::Unknown => Err(()),
             ScsiCommand::Inquiry {
                 evpd,
                 page_code,
@@ -134,20 +184,21 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
             ScsiCommand::TestUnitReady => {
-                let guard = SDCARD.get().lock().await;
-                let sdcard = guard.as_ref().unwrap();
-                if sdcard.is_attached() {
+                if self.temp_sd.as_ref().unwrap().is_attached() {
                     Ok(())
                 } else {
                     Err(())
                 }
             }
-            ScsiCommand::RequestSense { desc, alloc_len } => Ok(()),
+            ScsiCommand::RequestSense {
+                desc: _,
+                alloc_len: _,
+            } => Ok(()),
             ScsiCommand::ModeSense6 {
-                dbd,
-                page_control,
-                page_code,
-                subpage_code,
+                dbd: _,
+                page_control: _,
+                page_code: _,
+                subpage_code: _,
                 alloc_len,
             } => {
                 // DBD=0, no block descriptors; total length = 4
@@ -163,10 +214,10 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
             ScsiCommand::ModeSense10 {
-                dbd,
-                page_control,
-                page_code,
-                subpage_code,
+                dbd: _,
+                page_control: _,
+                page_code: _,
+                subpage_code: _,
                 alloc_len,
             } => {
                 let response = [
@@ -182,11 +233,8 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
             ScsiCommand::ReadCapacity10 => {
-                let guard = SDCARD.get().lock().await;
-                let sdcard = guard.as_ref().unwrap();
-
                 let block_size = SdCard::BLOCK_SIZE as u64;
-                let total_blocks = sdcard.size() / block_size;
+                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
 
                 let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
 
@@ -196,11 +244,8 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response).await.map_err(|_| ())
             }
             ScsiCommand::ReadCapacity16 { alloc_len } => {
-                let guard = SDCARD.get().lock().await;
-                let sdcard = guard.as_ref().unwrap();
-
                 let block_size = SdCard::BLOCK_SIZE as u64;
-                let total_blocks = sdcard.size() / block_size;
+                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
 
                 let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
 
@@ -212,40 +257,80 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
             ScsiCommand::Read { lba, len } => {
-                let guard = SDCARD.get().lock().await;
-                let sdcard = guard.as_ref().unwrap();
+                let sdcard = self.temp_sd.as_ref().unwrap();
+                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
+                let mut blocks = len;
+                let mut idx = lba;
 
-                for i in 0..len {
-                    let block_idx = BlockIdx(lba as u32 + i as u32);
-                    sdcard.read_blocks(&mut block, block_idx)?;
-                    for chunk in block[0].contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                        self.bulk_in.write(chunk).await.map_err(|_| ())?;
+                while blocks > 0 {
+                    if blocks >= block_buf.len() as u64 {
+                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
+
+                        for block in &mut *block_buf {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
+                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
+                            }
+                        }
+
+                        blocks -= block_buf.len() as u64;
+                        idx += block_buf.len() as u64;
+                    } else {
+                        sdcard
+                            .read_blocks(&mut block_buf[..blocks as usize], BlockIdx(idx as u32))?;
+
+                        for block in &block_buf[..blocks as usize] {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
+                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
+                            }
+                        }
+
+                        idx += blocks;
+                        blocks = 0;
                     }
                 }
                 Ok(())
             }
             ScsiCommand::Write { lba, len } => {
-                let guard = SDCARD.get().lock().await;
-                let sdcard = guard.as_ref().unwrap();
+                let sdcard = self.temp_sd.as_ref().unwrap();
+                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
+                let mut blocks = len;
+                let mut idx = lba;
 
-                for i in 0..len {
-                    let block_idx = BlockIdx(lba as u32 + i as u32);
-                    for chunk in block[0]
-                        .contents
-                        .chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
-                    {
-                        self.bulk_out.read(chunk).await.map_err(|_| ())?;
+                while blocks > 0 {
+                    if blocks >= block_buf.len() as u64 {
+                        for block in block_buf.as_mut() {
+                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
+                            {
+                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
+                            }
+                        }
+
+                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
+
+                        blocks -= block_buf.len() as u64;
+                        idx += block_buf.len() as u64;
+                    } else {
+                        for block in block_buf[..blocks as usize].as_mut() {
+                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
+                            {
+                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
+                            }
+                        }
+
+                        sdcard.write_blocks(
+                            &mut block_buf[..blocks as usize],
+                            BlockIdx(idx as u32),
+                        )?;
+
+                        idx += blocks;
+                        blocks = 0;
                     }
-                    sdcard.write_blocks(&mut block, block_idx)?;
                 }
                 Ok(())
             }
             ScsiCommand::ReadFormatCapacities { alloc_len } => {
-                let guard = SDCARD.get().lock().await;
-                let sdcard = guard.as_ref().unwrap();
-
                 let block_size = SdCard::BLOCK_SIZE as u32;
-                let num_blocks = (sdcard.size() / block_size as u64) as u32;
+                let num_blocks = (self.temp_sd.as_ref().unwrap().size() / block_size as u64) as u32;
 
                 let mut response = [0u8; 12];
 
@@ -264,7 +349,12 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                     .map_err(|_| ())
             }
             ScsiCommand::PreventAllowMediumRemoval { prevent: _prevent } => Ok(()),
-            ScsiCommand::StartStopUnit { start, load_eject } => Ok(()),
+            ScsiCommand::StartStopUnit { start, load_eject } => {
+                if !start && load_eject {
+                    self.pending_eject = true;
+                }
+                Ok(())
+            }
         }
     }
 
@@ -273,7 +363,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
     }
 
     pub async fn send_csw_fail(&mut self, tag: u32) {
-        defmt::error!("Command Failed");
+        defmt::error!("Command Failed: {}", tag);
         self.send_csw(tag, 0x01, 0).await; // 0x01 = Command Failed
     }
 
@@ -288,6 +378,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 }
 
 #[repr(C, packed)]
+#[allow(non_snake_case)]
 struct CommandBlockWrapper {
     dCBWSignature: u32,
     dCBWTag: u32,
@@ -298,6 +389,7 @@ struct CommandBlockWrapper {
     CBWCB: [u8; 16],
 }
 
+#[allow(non_snake_case)]
 impl CommandBlockWrapper {
     fn parse(buf: &[u8]) -> Option<Self> {
         if buf.len() < 31 {

kernel/src/scsi/scsi_types.rs

@@ -1,10 +1,5 @@
 use num_enum::TryFromPrimitive;
 
-#[derive(Debug, Clone, Copy)]
-pub enum ScsiError {
-    NotReady,
-}
-
 /// THE CODE BELOW ORIGINATES FROM: https://github.com/apohrebniak/usbd-storage/blob/master/usbd-storage/src/subclass/scsi.rs
 
 /// SCSI device subclass code

kernel/src/storage.rs

@@ -22,7 +22,7 @@ type Device = ExclusiveDevice<Spi<'static, SPI0, Blocking>, Output<'static>, emb
 type SD = SdmmcSdCard<Device, Delay>;
 type VolMgr = VolumeManager<SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
 type Vol<'a> = Volume<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
-type Dir<'a> = Directory<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
+pub type Dir<'a> = Directory<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
 pub type File<'a> = SdFile<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
 
 pub static SDCARD: LazyLock<Mutex<CriticalSectionRawMutex, Option<SdCard>>> =
@@ -101,7 +101,7 @@ impl SdCard {
     pub fn write_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
         let mut res: Result<(), Error> = Ok(());
         self.volume_mgr.device(|sd| {
-            let res = sd.write(blocks, start_block_idx);
+            res = sd.write(blocks, start_block_idx);
             DummyTimeSource {}
         });
         res.map_err(|_| ())
@@ -114,16 +114,15 @@ impl SdCard {
         access(root_dir);
     }
 
-    pub async fn read_file(
+    pub async fn read_file<T>(
         &mut self,
         name: &ShortFileName,
-        mut access: impl FnMut(File),
-    ) -> Result<(), ()> {
+        mut access: impl FnMut(File) -> T,
+    ) -> Result<T, ()> {
         let mut res = Err(());
         self.access_root_dir(|root_dir| {
             if let Ok(file) = root_dir.open_file_in_dir(name, Mode::ReadOnly) {
-                res = Ok(());
-                access(file);
+                res = Ok(access(file));
             }
         });
 

kernel/src/ui.rs

@@ -1,85 +1,93 @@
 use crate::{
-    BINARY_CH, TASK_STATE, TaskState,
-    display::{FRAMEBUFFER, SCREEN_HEIGHT, SCREEN_WIDTH},
+    BINARY_CH,
+    display::{FB_PAUSED, FRAMEBUFFER},
     elf::load_binary,
-    format,
     peripherals::keyboard,
     storage::FileName,
 };
-use alloc::{string::String, vec::Vec};
-use core::{fmt::Debug, str::FromStr, sync::atomic::Ordering};
-use embassy_sync::{
-    blocking_mutex::raw::{CriticalSectionRawMutex, ThreadModeRawMutex},
-    mutex::Mutex,
-};
+use abi_sys::keyboard::{KeyCode, KeyState};
+use alloc::{str::FromStr, string::String, vec::Vec};
+use core::sync::atomic::Ordering;
+use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
 use embedded_graphics::{
     Drawable,
-    mono_font::{MonoTextStyle, ascii::FONT_9X15},
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
     pixelcolor::Rgb565,
-    prelude::{Dimensions, Point, RgbColor, Size},
-    primitives::Rectangle,
+    prelude::{Dimensions, Point, Primitive, RgbColor, Size},
+    primitives::{PrimitiveStyle, Rectangle},
     text::Text,
 };
 use embedded_layout::{
     align::{horizontal, vertical},
-    layout::linear::LinearLayout,
-    object_chain::Chain,
+    layout::linear::{FixedMargin, LinearLayout},
     prelude::*,
 };
 use embedded_text::TextBox;
-use shared::keyboard::{KeyCode, KeyState};
 
 pub static SELECTIONS: Mutex<CriticalSectionRawMutex, SelectionList> =
     Mutex::new(SelectionList::new());
 
 pub async fn ui_handler() {
     loop {
-        if let TaskState::Ui = *TASK_STATE.lock().await {
-            if let Some(event) = keyboard::read_keyboard_fifo().await {
-                if let KeyState::Pressed = event.state {
-                    match event.key {
-                        KeyCode::JoyUp => {
-                            let mut selections = SELECTIONS.lock().await;
-                            selections.up();
-                        }
-                        KeyCode::JoyDown => {
-                            let mut selections = SELECTIONS.lock().await;
-                            selections.down();
-                        }
-                        KeyCode::Enter | KeyCode::JoyRight => {
-                            let selections = SELECTIONS.lock().await;
-                            let selection = selections.selections
-                                [selections.current_selection as usize - 1]
-                                .clone();
-
-                            let entry =
-                                unsafe { load_binary(&selection.short_name).await.unwrap() };
-                            BINARY_CH.send(entry).await;
-                        }
-                        _ => (),
+        if let Some(event) = keyboard::read_keyboard_fifo().await {
+            if let KeyState::Pressed = event.state {
+                match event.key {
+                    KeyCode::Up => {
+                        let mut selections = SELECTIONS.lock().await;
+                        selections.up();
                     }
+                    KeyCode::Down => {
+                        let mut selections = SELECTIONS.lock().await;
+                        selections.down();
+                    }
+                    KeyCode::Enter | KeyCode::Right => {
+                        let selections = SELECTIONS.lock().await;
+                        let selection =
+                            selections.selections[selections.current_selection as usize].clone();
+
+                        let entry = unsafe {
+                            load_binary(&selection.short_name)
+                                .await
+                                .expect("unable to load binary")
+                        };
+                        BINARY_CH.send(entry).await;
+                    }
+                    _ => (),
                 }
             }
+        }
 
+        let changed = SELECTIONS.lock().await.changed;
+        if changed {
+            clear_selection().await;
             draw_selection().await;
-        } else {
-            embassy_time::Timer::after_millis(50).await;
         }
     }
 }
 
-async fn draw_selection() {
-    let file_names: Vec<FileName> = {
-        let guard = SELECTIONS.lock().await;
-        guard.selections.clone()
-    };
+pub async fn clear_selection() {
+    let sel = SELECTIONS.lock().await;
 
-    let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
+    if let Some(area) = sel.last_bounds {
+        Rectangle::new(area.top_left, area.size)
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(unsafe { &mut FRAMEBUFFER })
+            .unwrap();
+    }
+}
+
+async fn draw_selection() {
+    let mut guard = SELECTIONS.lock().await;
+    let file_names = &guard.selections.clone();
+
+    let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
     let display_area = unsafe { FRAMEBUFFER.bounding_box() };
 
     const NO_BINS: &str = "No Programs found on SD Card. Ensure programs end with '.bin', and are located in the root directory";
     let no_bins = String::from_str(NO_BINS).unwrap();
 
+    FB_PAUSED.store(true, Ordering::Release); // ensure all elements show up at once
+
     if file_names.is_empty() {
         TextBox::new(
             &no_bins,
@@ -92,61 +100,89 @@ async fn draw_selection() {
         .draw(unsafe { &mut FRAMEBUFFER })
         .unwrap();
     } else {
-        let mut file_names = file_names.iter();
-        let Some(first) = file_names.next() else {
-            Text::new(NO_BINS, Point::zero(), text_style)
-                .draw(unsafe { &mut FRAMEBUFFER })
-                .unwrap();
+        let mut views: alloc::vec::Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
 
-            return;
-        };
+        for i in file_names {
+            views.push(Text::new(&i.long_name, Point::zero(), text_style));
+        }
 
-        let chain = Chain::new(Text::new(&first.long_name, Point::zero(), text_style));
+        let views_group = Views::new(views.as_mut_slice());
 
-        // for _ in 0..file_names.len() {
-        //     let chain = chain.append(Text::new(
-        //         file_names.next().unwrap(),
-        //         Point::zero(),
-        //         text_style,
-        //     ));
-        // }
-
-        LinearLayout::vertical(chain)
+        let layout = LinearLayout::vertical(views_group)
             .with_alignment(horizontal::Center)
+            .with_spacing(FixedMargin(5))
             .arrange()
-            .align_to(&display_area, horizontal::Center, vertical::Center)
+            .align_to(&display_area, horizontal::Center, vertical::Center);
+
+        // draw selected box
+        let selected_bounds = layout
+            .inner()
+            .get(guard.current_selection as usize)
+            .expect("Selected binary missing")
+            .bounding_box();
+        Rectangle::new(selected_bounds.top_left, selected_bounds.size)
+            .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
             .draw(unsafe { &mut FRAMEBUFFER })
             .unwrap();
+
+        guard.last_bounds = Some(layout.bounds());
+
+        layout.draw(unsafe { &mut FRAMEBUFFER }).unwrap();
     }
+
+    guard.changed = false;
+    FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
 }
 
 #[derive(Clone)]
 pub struct SelectionList {
+    // allows easy clearing of selection ui,
+    // based on previous bounds
+    last_bounds: Option<Rectangle>,
     current_selection: u16,
-    pub selections: Vec<FileName>,
+    selections: Vec<FileName>,
+    changed: bool,
 }
 
 impl SelectionList {
     pub const fn new() -> Self {
         Self {
+            last_bounds: None,
             selections: Vec::new(),
             current_selection: 0,
+            changed: false,
         }
     }
 
+    pub fn set_changed(&mut self, changed: bool) {
+        self.changed = changed
+    }
+
+    pub fn update_selections(&mut self, selections: Vec<FileName>) {
+        self.selections = selections;
+        self.changed = true;
+    }
+
+    pub fn selections(&self) -> &Vec<FileName> {
+        &self.selections
+    }
+
     pub fn reset(&mut self) {
-        self.current_selection = 1
+        self.current_selection = 0;
+        self.changed = true;
+    }
+
+    fn up(&mut self) {
+        if self.current_selection > 0 {
+            self.current_selection -= 1;
+            self.changed = true;
+        }
     }
 
     fn down(&mut self) {
         if self.current_selection + 1 < self.selections.len() as u16 {
-            self.current_selection += 1
-        }
-    }
-
-    fn up(&mut self) {
-        if self.current_selection > self.selections.len() as u16 {
-            self.current_selection -= 1
+            self.current_selection += 1;
+            self.changed = true;
         }
     }
 }

kernel/src/usb.rs

@@ -1,11 +1,12 @@
-use crate::{TASK_STATE, TASK_STATE_CHANGED, TaskState, scsi::MassStorageClass};
-use embassy_futures::{
-    join::join,
-    select::{select, select3},
-};
+use crate::{scsi::MassStorageClass, storage::SdCard};
+use core::sync::atomic::{AtomicBool, Ordering};
+use embassy_futures::select::select;
 use embassy_rp::{peripherals::USB, usb::Driver};
-use embassy_usb::{Builder, Config};
+use embassy_usb::{Builder, Config, UsbDevice};
 
+pub static USB_ACTIVE: AtomicBool = AtomicBool::new(false);
+
+#[embassy_executor::task]
 pub async fn usb_handler(driver: Driver<'static, USB>) {
     let mut config = Config::new(0xc0de, 0xbabe);
     config.manufacturer = Some("LegitCamper");
@@ -27,17 +28,18 @@ pub async fn usb_handler(driver: Driver<'static, USB>) {
         &mut control_buf,
     );
 
-    let mut scsi = MassStorageClass::new(&mut builder);
-    let mut usb = builder.build();
+    let temp_sd: Option<SdCard> = None;
+    let mut scsi = MassStorageClass::new(&mut builder, temp_sd);
+    let usb = builder.build();
 
+    select(run(usb), scsi.poll()).await;
+}
+
+async fn run<'d>(mut usb: UsbDevice<'d, Driver<'d, USB>>) -> ! {
     loop {
-        defmt::info!("in: {}", *TASK_STATE.lock().await as u32);
-        if *TASK_STATE.lock().await == TaskState::Ui {
-            defmt::info!("running scsi and usb");
-            select(join(usb.run(), scsi.poll()), TASK_STATE_CHANGED.wait()).await;
-        } else {
-            defmt::info!("not in ui state");
-            TASK_STATE_CHANGED.wait().await;
-        }
+        usb.wait_resume().await;
+        USB_ACTIVE.store(true, Ordering::Release);
+        usb.run_until_suspend().await;
+        USB_ACTIVE.store(false, Ordering::Release);
     }
 }

shared/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "shared"
-version = "0.1.0"
-edition = "2024"
-
-[features]
-defmt = ["dep:defmt"]
-
-[dependencies]
-bitflags = "2.9.1"
-defmt = { version = "1.0.1", optional = true }

shared/src/lib.rs

@@ -1,142 +0,0 @@
-#![no_std]
-
-pub mod keyboard {
-    bitflags::bitflags! {
-        #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)]
-        pub struct Modifiers: u8 {
-            const NONE = 0;
-            const CTRL = 1;
-            const ALT = 2;
-            const LSHIFT = 4;
-            const RSHIFT = 8;
-            const SYM = 16;
-        }
-    }
-
-    #[derive(Debug)]
-    pub struct KeyEvent {
-        pub key: KeyCode,
-        pub state: KeyState,
-        pub mods: Modifiers,
-    }
-
-    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-    pub enum KeyState {
-        Idle = 0,
-        Pressed = 1,
-        Hold = 2,
-        Released = 3,
-    }
-
-    impl From<u8> for KeyState {
-        fn from(value: u8) -> Self {
-            match value {
-                1 => KeyState::Pressed,
-                2 => KeyState::Hold,
-                3 => KeyState::Released,
-                0 | _ => KeyState::Idle,
-            }
-        }
-    }
-
-    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-    #[repr(C)]
-    #[repr(u8)]
-    pub enum KeyCode {
-        JoyUp = 0x01,
-        JoyDown = 0x02,
-        JoyLeft = 0x03,
-        JoyRight = 0x04,
-        JoyCenter = 0x05,
-        BtnLeft1 = 0x06,
-        BtnRight1 = 0x07,
-        BtnLeft2 = 0x11,
-        BtnRight2 = 0x12,
-        Backspace = 0x08,
-        Tab = 0x09,
-        Enter = 0x0A,
-        ModAlt = 0xA1,
-        ModShiftLeft = 0xA2,
-        ModShiftRight = 0xA3,
-        ModSym = 0xA4,
-        ModCtrl = 0xA5,
-        Esc = 0xB1,
-        Left = 0xB4,
-        Up = 0xB5,
-        Down = 0xB6,
-        Right = 0xB7,
-        Break = 0xD0,
-        Insert = 0xD1,
-        Home = 0xD2,
-        Del = 0xD4,
-        End = 0xD5,
-        PageUp = 0xD6,
-        PageDown = 0xD7,
-        CapsLock = 0xC1,
-        F1 = 0x81,
-        F2 = 0x82,
-        F3 = 0x83,
-        F4 = 0x84,
-        F5 = 0x85,
-        F6 = 0x86,
-        F7 = 0x87,
-        F8 = 0x88,
-        F9 = 0x89,
-        F10 = 0x90,
-        Char(char),
-        Unknown(u8),
-    }
-
-    impl From<u8> for KeyCode {
-        fn from(value: u8) -> Self {
-            match value {
-                0x01 => Self::JoyUp,
-                0x02 => Self::JoyDown,
-                0x03 => Self::JoyLeft,
-                0x04 => Self::JoyRight,
-                0x05 => Self::JoyCenter,
-                0x06 => Self::BtnLeft1,
-                0x07 => Self::BtnRight1,
-                0x08 => Self::Backspace,
-                0x09 => Self::Tab,
-                0x0A => Self::Enter,
-                0x11 => Self::BtnLeft2,
-                0x12 => Self::BtnRight2,
-                0xA1 => Self::ModAlt,
-                0xA2 => Self::ModShiftLeft,
-                0xA3 => Self::ModShiftRight,
-                0xA4 => Self::ModSym,
-                0xA5 => Self::ModCtrl,
-                0xB1 => Self::Esc,
-                0xB4 => Self::Left,
-                0xB5 => Self::Up,
-                0xB6 => Self::Down,
-                0xB7 => Self::Right,
-                0xC1 => Self::CapsLock,
-                0xD0 => Self::Break,
-                0xD1 => Self::Insert,
-                0xD2 => Self::Home,
-                0xD4 => Self::Del,
-                0xD5 => Self::End,
-                0xD6 => Self::PageUp,
-                0xD7 => Self::PageDown,
-                0x81 => Self::F1,
-                0x82 => Self::F2,
-                0x83 => Self::F3,
-                0x84 => Self::F4,
-                0x85 => Self::F5,
-                0x86 => Self::F6,
-                0x87 => Self::F7,
-                0x88 => Self::F8,
-                0x89 => Self::F9,
-                0x90 => Self::F10,
-                _ => match char::from_u32(value as u32) {
-                    Some(c) => Self::Char(c),
-                    None => Self::Unknown(value),
-                },
-            }
-        }
-    }
-}

user-apps/calculator/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 abi = { path = "../../abi" }
 embedded-graphics = "0.8.1"
+embedded-layout = "0.4.2"

user-apps/calculator/src/main.rs

@@ -2,76 +2,206 @@
 #![no_main]
 
 extern crate alloc;
-use abi::{KeyCode, display::Display, embassy_time, get_key, print, sleep};
-use alloc::{boxed::Box, string::String, vec};
-use core::{panic::PanicInfo, pin::Pin};
+use abi::{
+    display::{Display, lock_display},
+    get_key,
+    keyboard::{KeyCode, KeyState},
+    print,
+};
+use alloc::{format, string::String, vec, vec::Vec};
+use core::panic::PanicInfo;
 use embedded_graphics::{
     Drawable,
     geometry::{Dimensions, Point},
-    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    mono_font::{MonoTextStyle, ascii::FONT_7X14, iso_8859_1::FONT_10X20},
     pixelcolor::Rgb565,
-    prelude::{Primitive, RgbColor, Size},
+    prelude::{Primitive, RgbColor},
     primitives::{PrimitiveStyle, Rectangle},
-    text::{Alignment, Text},
+    text::Text,
+};
+use embedded_layout::{
+    View,
+    align::{Align, horizontal, vertical},
+    layout::linear::LinearLayout,
+    prelude::Chain,
 };
 
 #[panic_handler]
-fn panic(_info: &PanicInfo) -> ! {
+fn panic(info: &PanicInfo) -> ! {
+    print(&format!(
+        "user panic: {} @ {:?}",
+        info.message(),
+        info.location(),
+    ));
     loop {}
 }
 
-pub async fn main() {
-    print("Starting Async Calculator app");
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+pub fn main() {
+    print("Starting Calculator app");
     let mut display = Display;
 
-    let character_style = MonoTextStyle::new(&FONT_6X10, Rgb565::RED);
-
-    let mut text = vec!['T', 'y', 'p', 'e'];
+    let mut input = vec!['e', 'x', 'p', 'r', ':', ' '];
+    let input_min = input.len();
     let mut dirty = true;
-    let mut last_bounds: Option<Rectangle> = None;
+    let mut last_area: Option<(Rectangle, Rectangle)> = None;
+
+    LinearLayout::vertical(Chain::new(Text::new(
+        "Calculator!",
+        Point::zero(),
+        MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE),
+    )))
+    .arrange()
+    .align_to(&display.bounding_box(), horizontal::Center, vertical::Top)
+    .draw(&mut display)
+    .expect("Failed to draw title");
 
     loop {
         if dirty {
-            if let Some(bounds) = last_bounds {
-                Rectangle::new(bounds.top_left, bounds.size)
-                    .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            lock_display(true);
+
+            let style = PrimitiveStyle::with_fill(Rgb565::BLACK);
+            if let Some(area) = last_area {
+                Rectangle::new(area.0.top_left, area.0.size)
+                    .into_styled(style)
+                    .draw(&mut display)
+                    .unwrap();
+
+                Rectangle::new(area.1.top_left, area.1.size)
+                    .into_styled(style)
                     .draw(&mut display)
                     .unwrap();
             }
 
-            let text = text.iter().cloned().collect::<String>();
-            let aligned_text = Text::with_alignment(
+            let text = input.iter().cloned().collect::<String>();
+
+            let style = MonoTextStyle::new(&FONT_7X14, Rgb565::WHITE);
+            let expr_layout = LinearLayout::vertical(Chain::new(Text::new(
                 &text,
                 display.bounding_box().center(),
-                character_style,
-                Alignment::Center,
-            );
-            last_bounds = Some(aligned_text.bounding_box());
+                style,
+            )))
+            .arrange()
+            .align_to(&display.bounding_box(), horizontal::Left, vertical::Center);
+
+            let result = if let Ok(result) = evaluate(&input[input_min..]) {
+                &format!(" = {}", result)
+            } else {
+                " = Error"
+            };
+
+            let eq_layout = LinearLayout::vertical(Chain::new(Text::new(
+                result,
+                display.bounding_box().center(),
+                style,
+            )))
+            .arrange()
+            .align_to(&display.bounding_box(), horizontal::Right, vertical::Center);
+
+            last_area = Some((expr_layout.bounds(), eq_layout.bounds()));
+            expr_layout.draw(&mut display).unwrap();
+            eq_layout.draw(&mut display).unwrap();
 
-            aligned_text.draw(&mut display).unwrap();
             dirty = false;
+            lock_display(false);
         }
 
-        if let Some(event) = get_key() {
-            dirty = true;
+        let event = get_key();
+        if event.state != KeyState::Idle {
             match event.key {
                 KeyCode::Char(ch) => {
-                    text.push(ch);
+                    input.push(ch);
                 }
                 KeyCode::Del => {
-                    text.clear();
+                    input.truncate(input_min);
                 }
                 KeyCode::Backspace => {
-                    text.pop();
+                    if input.len() > input_min {
+                        input.pop();
+                    }
                 }
                 KeyCode::Esc => return,
                 _ => (),
             }
+            dirty = true;
         }
     }
 }
 
-#[unsafe(no_mangle)]
-pub extern "Rust" fn _start() -> Pin<Box<dyn Future<Output = ()>>> {
-    Box::pin(async { main().await })
+fn get_int(int: &[char]) -> Result<i32, ()> {
+    let mut output: i32 = 0;
+    for &c in int {
+        let digit = c.to_digit(10).ok_or(())? as i32;
+        output = output
+            .checked_mul(10)
+            .and_then(|v| v.checked_add(digit))
+            .ok_or(())?;
+    }
+    Ok(output)
+}
+
+fn primary(input: &[char], pos: &mut usize) -> Result<i32, ()> {
+    let mut digits = Vec::new();
+    while *pos < input.len() && input[*pos].is_ascii_digit() {
+        digits.push(input[*pos]);
+        *pos += 1;
+    }
+    if digits.is_empty() {
+        return Err(());
+    }
+    get_int(&digits)
+}
+
+fn mul_div(input: &[char], pos: &mut usize) -> Result<i32, ()> {
+    let mut value = primary(input, pos)?;
+    while *pos < input.len() {
+        let op = input[*pos];
+        if op != '*' && op != '/' {
+            break;
+        }
+        *pos += 1;
+        let rhs = primary(input, pos)?;
+        value = match op {
+            '*' => value.checked_mul(rhs).ok_or(())?,
+            '/' => {
+                if rhs == 0 {
+                    return Err(());
+                }
+                value.checked_div(rhs).ok_or(())?
+            }
+            _ => unreachable!(),
+        };
+    }
+    Ok(value)
+}
+
+fn add_sub(input: &[char], pos: &mut usize) -> Result<i32, ()> {
+    let mut value = mul_div(input, pos)?;
+    while *pos < input.len() {
+        let op = input[*pos];
+        if op != '+' && op != '-' {
+            break;
+        }
+        *pos += 1;
+        let rhs = mul_div(input, pos)?;
+        value = match op {
+            '+' => value.checked_add(rhs).ok_or(())?,
+            '-' => value.checked_sub(rhs).ok_or(())?,
+            _ => unreachable!(),
+        };
+    }
+    Ok(value)
+}
+
+fn evaluate(input: &[char]) -> Result<i32, ()> {
+    let mut pos = 0;
+    let result = add_sub(input, &mut pos)?;
+    if pos != input.len() {
+        return Err(());
+    }
+    Ok(result)
 }

user-apps/gallery/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "gallery"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+abi = { path = "../../abi" }
+embedded-graphics = "0.8.1"
+tinybmp = "0.6.0"

user-apps/gallery/build.rs

@@ -0,0 +1,28 @@
+//! This build script copies the `memory.x` file from the crate root into
+//! a directory where the linker can always find it at build time.
+//! For many projects this is optional, as the linker always searches the
+//! project root directory -- wherever `Cargo.toml` is. However, if you
+//! are using a workspace or have a more complicated build setup, this
+//! build script becomes required. Additionally, by requesting that
+//! Cargo re-run the build script whenever `memory.x` is changed,
+//! updating `memory.x` ensures a rebuild of the application with the
+//! new memory settings.
+
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put `memory.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("../memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    println!("cargo:rerun-if-changed=memory.x");
+    println!("cargo:rustc-link-arg-bins=-Tmemory.x");
+}

user-apps/gallery/src/main.rs

@@ -0,0 +1,109 @@
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs)]
+
+extern crate alloc;
+use abi::{
+    display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH, lock_display},
+    fs::{list_dir, read_file},
+    get_key,
+    keyboard::{KeyCode, KeyState},
+    print,
+};
+use alloc::{format, string::ToString};
+use core::panic::PanicInfo;
+use embedded_graphics::{
+    Drawable, image::Image, mono_font::MonoTextStyle, mono_font::ascii::FONT_6X10,
+    pixelcolor::Rgb565, prelude::*, text::Text,
+};
+use tinybmp::Bmp;
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    print(&format!(
+        "user panic: {} @ {:?}",
+        info.message(),
+        info.location(),
+    ));
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+pub fn main() {
+    print("Starting Gallery app");
+    static mut BMP_BUF: [u8; 100_000] = [0_u8; 100_000];
+    let mut display = Display;
+
+    // Grid parameters
+    let grid_cols = 3;
+    let grid_rows = 3;
+    let cell_width = SCREEN_WIDTH as i32 / grid_cols;
+    let cell_height = SCREEN_HEIGHT as i32 / grid_rows;
+
+    let mut images_drawn = 0;
+
+    let mut files = [const { None }; 18];
+    let files_num = list_dir("/images", &mut files);
+
+    for file in &files[2..files_num] {
+        if images_drawn >= grid_cols * grid_rows {
+            break; // only draw 3x3
+        }
+
+        if let Some(f) = file {
+            print(&format!("file: {}", f.name));
+            if f.name.extension() == b"bmp" || f.name.extension() == b"BMP" {
+                let file = format!("/images/{}", f.name);
+
+                let read = read_file(&file, 0, &mut unsafe { &mut BMP_BUF[..] });
+                if read > 0 {
+                    let bmp = Bmp::from_slice(unsafe { &BMP_BUF }).expect("failed to parse bmp");
+
+                    let row = images_drawn / grid_cols;
+                    let col = images_drawn % grid_cols;
+                    let cell_x = col * cell_width;
+                    let cell_y = row * cell_height;
+
+                    // Center image inside cell
+                    let bmp_w = bmp.size().width as i32;
+                    let bmp_h = bmp.size().height as i32;
+                    let x = cell_x + (cell_width - bmp_w) / 2;
+                    let y = cell_y + 5; // 5px top margin
+
+                    lock_display(true);
+                    Image::new(&bmp, Point::new(x, y))
+                        .draw(&mut display)
+                        .unwrap();
+
+                    let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+                    let text_y = y + bmp_h + 2; // 2px gap under image
+                    Text::new(
+                        f.name.to_string().as_str(),
+                        Point::new(cell_x + 2, text_y),
+                        text_style,
+                    )
+                    .draw(&mut display)
+                    .unwrap();
+
+                    lock_display(false);
+
+                    images_drawn += 1;
+                }
+            }
+        }
+    }
+
+    loop {
+        let event = get_key();
+        if event.state != KeyState::Idle {
+            match event.key {
+                KeyCode::Esc => return,
+                _ => (),
+            }
+        };
+    }
+}

user-apps/memory.x

@@ -1,19 +1,10 @@
 MEMORY
 {
-  /* Must match the USERAPP region in the kernel linker script */
-  RAM : ORIGIN = 0x20010000, LENGTH = 192K
+  RAM : ORIGIN = 0x0, LENGTH = 150K
 }
 
 SECTIONS
 {
-  /* Reserve first 1KB for patchable symbols */
-  .user_reloc (NOLOAD) : ALIGN(4)
-  {
-      __user_reloc_start = .;
-      KEEP(*(.user_reloc*));
-      __user_reloc_end = .;
-  } > RAM
-
   .text : ALIGN(4)
   {
       *(.text .text.*);
@@ -30,4 +21,11 @@ SECTIONS
       *(.bss .bss.*);
       *(COMMON);
   } > RAM
+
+  .syscall_table (NOLOAD) : ALIGN(4)
+  {
+      __user_reloc_start = .;
+      KEEP(*(.user_reloc*));
+      __user_reloc_end = .;
+  } > RAM
 }

user-apps/snake/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "snake"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+abi = { path = "../../abi" }
+embedded-graphics = "0.8.1"
+embedded-snake = { path = "../../../embedded-snake-rs" }
+rand = { version = "0.9.0", default-features = false }

user-apps/snake/build.rs

@@ -0,0 +1,28 @@
+//! This build script copies the `memory.x` file from the crate root into
+//! a directory where the linker can always find it at build time.
+//! For many projects this is optional, as the linker always searches the
+//! project root directory -- wherever `Cargo.toml` is. However, if you
+//! are using a workspace or have a more complicated build setup, this
+//! build script becomes required. Additionally, by requesting that
+//! Cargo re-run the build script whenever `memory.x` is changed,
+//! updating `memory.x` ensures a rebuild of the application with the
+//! new memory settings.
+
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put `memory.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("../memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    println!("cargo:rerun-if-changed=memory.x");
+    println!("cargo:rustc-link-arg-bins=-Tmemory.x");
+}

user-apps/snake/src/main.rs

@@ -0,0 +1,72 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+use abi::{
+    Rng,
+    display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH, lock_display},
+    get_key,
+    keyboard::{KeyCode, KeyState},
+    print, sleep,
+};
+use alloc::format;
+use core::panic::PanicInfo;
+use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor};
+use embedded_snake::{Direction, SnakeGame};
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    print(&format!(
+        "user panic: {} @ {:?}",
+        info.message(),
+        info.location(),
+    ));
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+const CELL_SIZE: usize = 8;
+
+pub fn main() {
+    print("Starting Snake app");
+    let mut display = Display;
+
+    let mut game = SnakeGame::<100, Rgb565, Rng>::new(
+        SCREEN_WIDTH as u16,
+        SCREEN_HEIGHT as u16,
+        CELL_SIZE as u16,
+        CELL_SIZE as u16,
+        Rng,
+        Rgb565::BLACK,
+        Rgb565::GREEN,
+        Rgb565::RED,
+        50,
+    );
+
+    loop {
+        let event = get_key();
+        if event.state != KeyState::Idle {
+            let direction = match event.key {
+                KeyCode::Up => Direction::Up,
+                KeyCode::Down => Direction::Down,
+                KeyCode::Right => Direction::Right,
+                KeyCode::Left => Direction::Left,
+                KeyCode::Esc => return,
+                _ => Direction::None,
+            };
+            game.set_direction(direction);
+        };
+
+        // ensure all draws show up at once
+        lock_display(true);
+        game.pre_draw(&mut display);
+        game.draw(&mut display);
+        lock_display(false);
+
+        sleep(15);
+    }
+}