dont use mutex on framebuffer

syscalls via call_abi are still not working

Cargo.lock

@@ -12,6 +12,26 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "abi"
+version = "0.1.0"
+dependencies = [
+ "abi_sys",
+ "embassy-time 0.5.0",
+ "embedded-graphics",
+ "shared",
+ "spin",
+ "talc",
+]
+
+[[package]]
+name = "abi_sys"
+version = "0.1.0"
+dependencies = [
+ "embedded-graphics",
+ "shared",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -169,7 +189,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f377753756ec12e76b52d2dd657437be0448cc9736402ffadd0b8b8b9602c8a1"
 dependencies = [
  "embassy-sync 0.6.2",
- "embassy-time",
+ "embassy-time 0.4.0",
  "embedded-io",
  "embedded-io-async",
  "futures-intrusive",
@@ -195,6 +215,14 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
+[[package]]
+name = "calculator"
+version = "0.1.0"
+dependencies = [
+ "abi",
+ "embedded-graphics",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.1"
@@ -295,7 +323,7 @@ dependencies = [
  "embassy-futures",
  "embassy-net-driver-channel",
  "embassy-sync 0.6.2",
- "embassy-time",
+ "embassy-time 0.4.0",
  "embedded-hal 1.0.0",
  "embedded-io-async",
  "futures",
@@ -469,7 +497,7 @@ dependencies = [
  "embassy-futures",
  "embassy-hal-internal 0.3.0",
  "embassy-sync 0.7.0",
- "embassy-time",
+ "embassy-time 0.4.0",
  "embedded-hal 0.2.7",
  "embedded-hal 1.0.0",
  "embedded-hal-async",
@@ -563,7 +591,7 @@ dependencies = [
  "embassy-futures",
  "embassy-hal-internal 0.2.0",
  "embassy-sync 0.6.2",
- "embassy-time",
+ "embassy-time 0.4.0",
  "embassy-usb-driver",
  "embedded-hal 0.2.7",
  "embedded-hal 1.0.0",
@@ -601,7 +629,7 @@ dependencies = [
  "embassy-futures",
  "embassy-hal-internal 0.2.0",
  "embassy-sync 0.6.2",
- "embassy-time",
+ "embassy-time 0.4.0",
  "embassy-time-driver",
  "embassy-time-queue-utils",
  "embassy-usb-driver",
@@ -617,7 +645,6 @@ dependencies = [
  "nb 1.1.0",
  "pio 0.3.0",
  "rand_core",
- "rp-binary-info",
  "rp-pac",
  "rp2040-boot2",
  "sha2-const-stable",
@@ -672,10 +699,26 @@ dependencies = [
 ]
 
 [[package]]
-name = "embassy-time-driver"
+name = "embassy-time"
-version = "0.2.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d45f5d833b6d98bd2aab0c2de70b18bfaa10faf661a1578fd8e5dfb15eb7eba"
+checksum = "f4fa65b9284d974dad7a23bb72835c4ec85c0b540d86af7fc4098c88cff51d65"
+dependencies = [
+ "cfg-if",
+ "critical-section",
+ "document-features",
+ "embassy-time-driver",
+ "embedded-hal 0.2.7",
+ "embedded-hal 1.0.0",
+ "embedded-hal-async",
+ "futures-core",
+]
+
+[[package]]
+name = "embassy-time-driver"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0a244c7dc22c8d0289379c8d8830cae06bb93d8f990194d0de5efb3b5ae7ba6"
 dependencies = [
  "document-features",
 ]
@@ -801,6 +844,27 @@ dependencies = [
  "embedded-io",
 ]
 
+[[package]]
+name = "embedded-layout"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a90553247f2b05c59ac7894ea13d830636c2b1203fa03bff400eddbd1fa9f52"
+dependencies = [
+ "embedded-graphics",
+ "embedded-layout-macros",
+]
+
+[[package]]
+name = "embedded-layout-macros"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f6e621fe4c7e05b695274b722dc0a60bacd1c8696b58191baa0154713d52400"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
 [[package]]
 name = "embedded-sdmmc"
 version = "0.9.0"
@@ -829,6 +893,17 @@ dependencies = [
  "embedded-storage",
 ]
 
+[[package]]
+name = "embedded-text"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "005680edc0d075af5e02d5788ca291737bd9aba7fc404ae031cc9dfa715e5f7d"
+dependencies = [
+ "az",
+ "embedded-graphics",
+ "object-chain",
+]
+
 [[package]]
 name = "ena"
 version = "0.14.3"
@@ -999,6 +1074,16 @@ dependencies = [
  "wasi",
 ]
 
+[[package]]
+name = "goblin"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e961b33649994dcf69303af6b3a332c1228549e604d455d61ec5d2ab5e68d3a"
+dependencies = [
+ "plain",
+ "scroll",
+]
+
 [[package]]
 name = "half"
 version = "2.6.0"
@@ -1113,6 +1198,46 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "kernel"
+version = "0.1.0"
+dependencies = [
+ "abi_sys",
+ "bitflags 2.9.1",
+ "bt-hci",
+ "cortex-m",
+ "cortex-m-rt",
+ "cyw43",
+ "cyw43-pio",
+ "defmt 0.3.100",
+ "defmt-rtt",
+ "embassy-embedded-hal",
+ "embassy-executor",
+ "embassy-futures",
+ "embassy-rp 0.4.0",
+ "embassy-sync 0.7.0",
+ "embassy-time 0.4.0",
+ "embassy-usb",
+ "embedded-graphics",
+ "embedded-hal 0.2.7",
+ "embedded-hal-async",
+ "embedded-hal-bus",
+ "embedded-layout",
+ "embedded-sdmmc",
+ "embedded-text",
+ "goblin",
+ "heapless",
+ "num_enum 0.7.4",
+ "panic-probe",
+ "portable-atomic",
+ "shared",
+ "spin",
+ "st7365p-lcd",
+ "static_cell",
+ "talc",
+ "trouble-host",
+]
+
 [[package]]
 name = "lalrpop"
 version = "0.19.12"
@@ -1190,9 +1315,9 @@ checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libredox"
-version = "0.1.4"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1580801010e535496706ba011c15f8532df6b42297d2e471fec38ceadd8c0638"
+checksum = "4488594b9328dee448adb906d8b126d9b7deb7cf5c22161ee591610bb1be83c0"
 dependencies = [
  "bitflags 2.9.1",
  "libc",
@@ -1303,6 +1428,12 @@ dependencies = [
  "syn 2.0.104",
 ]
 
+[[package]]
+name = "object-chain"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41af26158b0f5530f7b79955006c2727cd23d0d8e7c3109dc316db0a919784dd"
+
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -1383,41 +1514,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 
-[[package]]
-name = "picocalc-os-rs"
-version = "0.1.0"
-dependencies = [
- "bitflags 2.9.1",
- "bt-hci",
- "cortex-m",
- "cortex-m-rt",
- "cyw43",
- "cyw43-pio",
- "defmt 0.3.100",
- "defmt-rtt",
- "embassy-embedded-hal",
- "embassy-executor",
- "embassy-futures",
- "embassy-rp 0.4.0",
- "embassy-sync 0.7.0",
- "embassy-time",
- "embassy-usb",
- "embedded-graphics",
- "embedded-hal 0.2.7",
- "embedded-hal-async",
- "embedded-hal-bus",
- "embedded-sdmmc",
- "heapless",
- "num_enum 0.7.4",
- "panic-probe",
- "portable-atomic",
- "spin",
- "st7365p-lcd",
- "static_cell",
- "talc",
- "trouble-host",
-]
-
 [[package]]
 name = "pin-project-lite"
 version = "0.2.16"
@@ -1518,6 +1614,12 @@ dependencies = [
  "syn 2.0.104",
 ]
 
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"
@@ -1673,12 +1775,6 @@ dependencies = [
  "bytemuck",
 ]
 
-[[package]]
-name = "rp-binary-info"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ed2051a0bf2c726df01cfce378ed8a367be2a6e402fc183857f429a346d429"
-
 [[package]]
 name = "rp-pac"
 version = "7.0.0"
@@ -1728,6 +1824,12 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "scroll"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add"
+
 [[package]]
 name = "semver"
 version = "0.9.0"
@@ -1779,6 +1881,14 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "shared"
+version = "0.1.0"
+dependencies = [
+ "bitflags 2.9.1",
+ "defmt 1.0.1",
+]
+
 [[package]]
 name = "siphasher"
 version = "1.0.1"
@@ -1831,7 +1941,6 @@ dependencies = [
 [[package]]
 name = "st7365p-lcd"
 version = "0.11.0"
-source = "git+https://github.com/legitcamper/st7365p-lcd-rs?branch=async#87abf450404865dcb535292e9e1a6a2457fd4599"
 dependencies = [
  "bitvec",
  "embedded-graphics-core",
@@ -1998,7 +2107,7 @@ dependencies = [
  "bt-hci",
  "embassy-futures",
  "embassy-sync 0.6.2",
- "embassy-time",
+ "embassy-time 0.4.0",
  "embedded-io",
  "futures",
  "heapless",

Cargo.toml

@@ -1,82 +1,19 @@
-[package]
+[workspace]
-name = "picocalc-os-rs"
+resolver = "3"
-version = "0.1.0"
+members = ["kernel", "abi", "shared", "user-apps/calculator"]
-edition = "2024"
 
 [profile.release]
-debug = 2
+debug = true
+opt-level = "z"
+lto = true
+codegen-units = 1
+
+[profile.release-binary]
+inherits = "release"
+lto = true
+debug = false
+opt-level = "s"
 
 [profile.dev]
 lto = true
 opt-level = "z"
-
-[features]
-default = ["rp235x", "defmt"]
-# rp2040 = ["embassy-rp/rp2040"]
-rp235x = ["embassy-rp/rp235xb"]
-trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
-defmt = [
-  "dep:defmt",
-  "panic-probe/print-defmt",
-  "embassy-executor/defmt",
-  "embassy-time/defmt",
-  "embassy-time/defmt-timestamp-uptime",
-  "embassy-rp/defmt",
-  "embassy-sync/defmt",
-  "embedded-graphics/defmt",
-  "embedded-sdmmc/defmt-log",
-  # "bt-hci/defmt",
-  # "cyw43/defmt",
-  # "cyw43-pio/defmt",
-]
-
-[dependencies]
-embassy-executor = { version = "0.7", features = [
-  "arch-cortex-m",
-  "executor-interrupt",
-  "executor-thread",
-  "nightly",
-] }
-embassy-rp = { version = "0.4.0", features = [
-  "critical-section-impl",
-  "unstable-pac",
-  "time-driver",
-  "binary-info",
-] }
-embassy-futures = "0.1.1"
-embassy-time = { version = "0.4.0", features = ["generic-queue-8"] }
-embassy-embedded-hal = "0.3.1"
-embassy-sync = "0.7"
-embassy-usb = "0.4.0"
-trouble-host = { version = "0.1", features = [
-  "derive",
-  "scan",
-], optional = true }
-bt-hci = { version = "0.2", default-features = false, optional = true }
-cyw43 = { version = "0.3.0", features = [
-  "firmware-logs",
-  "bluetooth",
-], optional = true }
-cyw43-pio = { version = "0.3.0", optional = true }
-
-embedded-hal-bus = { version = "0.3.0", features = ["async"] }
-embedded-hal = "0.2.7"
-embedded-hal-async = "1.0.0"
-cortex-m = { version = "0.7.7" }
-cortex-m-rt = "0.7.5"
-panic-probe = "0.3"
-portable-atomic = { version = "1.11", features = ["critical-section"] }
-
-defmt = { version = "0.3", optional = true }
-defmt-rtt = "0.4.2"
-
-embedded-graphics = { version = "0.8.1" }
-embedded-sdmmc = { version = "0.9", default-features = false }
-st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", branch = "async" }
-
-static_cell = "2.1.1"
-bitflags = "2.9.1"
-talc = "4.4.3"
-spin = "0.10.0"
-heapless = "0.8.0"
-num_enum = { version = "0.7.4", default-features = false }

abi/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "abi"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+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"

abi/src/lib.rs

@@ -0,0 +1,74 @@
+#![no_std]
+
+use abi_sys::draw_iter;
+pub use abi_sys::{get_key, print};
+pub use embassy_time;
+pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+use talc::*;
+
+static mut ARENA: [u8; 10000] = [0; 10000];
+
+#[global_allocator]
+static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
+    Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
+        .lock();
+
+pub mod display {
+    use crate::draw_iter;
+    use embedded_graphics::{
+        Pixel,
+        geometry::{Dimensions, Point},
+        pixelcolor::{Rgb565, RgbColor},
+        prelude::{DrawTarget, Size},
+        primitives::Rectangle,
+    };
+
+    pub const SCREEN_WIDTH: usize = 320;
+    pub const SCREEN_HEIGHT: usize = 320;
+
+    pub type Pixel565 = Pixel<Rgb565>;
+
+    pub struct Display;
+
+    impl Dimensions for Display {
+        fn bounding_box(&self) -> Rectangle {
+            Rectangle {
+                top_left: Point { x: 0, y: 0 },
+                size: Size {
+                    width: SCREEN_WIDTH as u32,
+                    height: SCREEN_HEIGHT as u32,
+                },
+            }
+        }
+    }
+
+    impl DrawTarget for Display {
+        type Color = Rgb565;
+        type Error = ();
+
+        fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
+        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 count = 0;
+            for p in pixels {
+                buf[count] = p;
+                count += 1;
+
+                if count == BUF_SIZE {
+                    draw_iter(&buf[..count]);
+                    count = 0;
+                }
+            }
+
+            if count > 0 {
+                draw_iter(&buf[..count]);
+            }
+
+            Ok(())
+        }
+    }
+}

abi_sys/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "abi_sys"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+embedded-graphics = "0.8.1"
+shared = { path = "../shared" }

abi_sys/src/lib.rs

@@ -0,0 +1,60 @@
+#![no_std]
+
+extern crate alloc;
+use alloc::boxed::Box;
+
+use core::pin::Pin;
+pub use embedded_graphics::{
+    Pixel,
+    geometry::Point,
+    pixelcolor::{Rgb565, RgbColor},
+};
+use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+
+pub type EntryFn = fn() -> Pin<Box<dyn Future<Output = ()>>>;
+
+#[unsafe(no_mangle)]
+#[unsafe(link_section = ".user_reloc")]
+pub static mut CALL_ABI_TABLE: [usize; CallAbiTable::COUNT] = [0; CallAbiTable::COUNT];
+
+#[repr(usize)]
+#[derive(Clone, Copy)]
+pub enum CallAbiTable {
+    Print = 0,
+    DrawIter = 1,
+    GetKey = 2,
+}
+
+impl CallAbiTable {
+    pub const COUNT: usize = 3;
+}
+
+pub type PrintAbi = extern "Rust" fn(msg: &str);
+
+pub fn print(msg: &str) {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallAbiTable::Print as usize];
+        let f: PrintAbi = core::mem::transmute(ptr);
+        f(msg);
+    }
+}
+
+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);
+    }
+}
+
+pub type GetKeyAbi = extern "Rust" fn() -> Option<KeyEvent>;
+
+pub fn get_key() -> Option<KeyEvent> {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallAbiTable::GetKey as usize];
+        let f: GetKeyAbi = core::mem::transmute(ptr);
+        f()
+    }
+}

justfile

@@ -0,0 +1,4 @@
+kernel: calculator
+    cargo run --bin kernel
+calculator:
+    RUSTFLAGS="-C link-arg=--noinhibit-exec" cargo build --bin calculator --profile release-binary

kernel/Cargo.toml

@@ -0,0 +1,88 @@
+[package]
+name = "kernel"
+version = "0.1.0"
+edition = "2024"
+
+[[bin]]
+name = "kernel"
+path = "src/main.rs"
+test = false
+doctest = false
+bench = false
+
+[features]
+default = ["rp235x", "defmt"]
+rp2040 = ["embassy-rp/rp2040"]
+rp235x = ["embassy-rp/rp235xb"]
+trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
+defmt = [
+  "dep:defmt",
+  "panic-probe/print-defmt",
+  "embassy-executor/defmt",
+  "embassy-time/defmt",
+  "embassy-time/defmt-timestamp-uptime",
+  "embassy-rp/defmt",
+  "embassy-sync/defmt",
+  "embedded-graphics/defmt",
+  "embedded-sdmmc/defmt-log",
+  # "bt-hci/defmt",
+  # "cyw43/defmt",
+  # "cyw43-pio/defmt",
+]
+
+[dependencies]
+embassy-executor = { version = "0.7", features = [
+  "arch-cortex-m",
+  "executor-interrupt",
+  "executor-thread",
+  "nightly",
+] }
+embassy-rp = { version = "0.4.0", features = [
+  "critical-section-impl",
+  "unstable-pac",
+  "time-driver",
+] }
+embassy-usb = "0.4.0"
+embassy-futures = "0.1.1"
+embassy-time = { version = "0.4.0", features = ["generic-queue-8"] }
+embassy-embedded-hal = "0.3.1"
+embassy-sync = { version = "0.7" }
+trouble-host = { version = "0.1", features = [
+  "derive",
+  "scan",
+], optional = true }
+bt-hci = { version = "0.2", default-features = false, optional = true }
+cyw43 = { version = "0.3.0", features = [
+  "firmware-logs",
+  "bluetooth",
+], optional = true }
+cyw43-pio = { version = "0.3.0", optional = true }
+
+embedded-hal-bus = { version = "0.3.0", features = ["async"] }
+embedded-hal = "0.2.7"
+embedded-hal-async = "1.0.0"
+cortex-m = { version = "0.7.7" }
+cortex-m-rt = "0.7.5"
+panic-probe = "0.3"
+portable-atomic = { version = "1.11", features = ["critical-section"] }
+
+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 = "87abf450404865dcb535292e9e1a6a2457fd4599" } # async branch
+st7365p-lcd = { path = "../../ST7365P-lcd-rs" } # async branch
+embedded-graphics = { version = "0.8.1" }
+embedded-text = "0.7.2"
+embedded-layout = "0.4.2"
+
+static_cell = "2.1.1"
+bitflags = "2.9.1"
+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"
+
+shared = { path = "../shared" }
+abi_sys = { path = "../abi_sys" }

kernel/memory.x

@@ -1,22 +1,10 @@
 MEMORY {
-    /*
-     * The RP2350 has either external or internal flash.
-     *
-     * 2 MiB is a safe default here, although a Pico 2 has 4 MiB.
-     */
     FLASH : ORIGIN = 0x10000000, LENGTH = 4096K
-    /*
-     * RAM consists of 8 banks, SRAM0-SRAM7, with a striped mapping.
-     * This is usually good for performance, as it distributes load on
-     * those banks evenly.
-     */
     RAM : ORIGIN = 0x20000000, LENGTH = 512K
-    /*
+
-     * RAM banks 8 and 9 use a direct mapping. They can be used to have
+	/* Reserve a block of RAM for the user app */
-     * memory areas dedicated for some specific job, improving predictability
+    USERAPP : ORIGIN = 0x20010000, LENGTH = 192K
-     * of access times.
+
-     * Example: Separate stacks for core0 and core1.
-     */
     SRAM4 : ORIGIN = 0x20080000, LENGTH = 4K
     SRAM5 : ORIGIN = 0x20081000, LENGTH = 4K
 }
@@ -73,3 +61,11 @@ 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

@@ -0,0 +1,34 @@
+use core::pin::Pin;
+
+use abi_sys::{DrawIterAbi, GetKeyAbi, Pixel, PrintAbi};
+use alloc::boxed::Box;
+use defmt::info;
+use embedded_graphics::{
+    Drawable,
+    draw_target::DrawTarget,
+    pixelcolor::Rgb565,
+    prelude::{Point, RgbColor, Size},
+    primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
+};
+use shared::keyboard::KeyEvent;
+
+use crate::{KEY_CACHE, display::framebuffer_mut};
+
+// ensure the abi and the kernel fn signatures are the same
+const _: PrintAbi = print;
+const _: DrawIterAbi = draw_iter;
+const _: GetKeyAbi = get_key;
+
+pub extern "Rust" fn print(msg: &str) {
+    defmt::info!("{:?}", msg);
+}
+
+// TODO: maybe return result
+pub extern "Rust" fn draw_iter(pixels: &[Pixel<Rgb565>]) {
+    let fb = framebuffer_mut();
+    fb.draw_iter(pixels.iter().copied()).unwrap();
+}
+
+pub extern "Rust" fn get_key() -> Option<KeyEvent> {
+    unsafe { KEY_CACHE.dequeue() }
+}

kernel/src/display.rs

@@ -0,0 +1,60 @@
+use embassy_rp::{
+    gpio::{Level, Output},
+    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
+    spi::{Async, Spi},
+};
+use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
+use embassy_time::{Delay, Timer};
+use embedded_hal_bus::spi::ExclusiveDevice;
+use st7365p_lcd::{FrameBuffer, ST7365P};
+use static_cell::StaticCell;
+
+type DISPLAY = ST7365P<
+    ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
+    Output<'static>,
+    Output<'static>,
+    Delay,
+>;
+
+pub const SCREEN_WIDTH: usize = 320;
+pub const SCREEN_HEIGHT: usize = 320;
+
+type FB = FrameBuffer<SCREEN_WIDTH, SCREEN_HEIGHT, { SCREEN_WIDTH * SCREEN_HEIGHT }>;
+static mut FRAMEBUFFER: Option<FB> = None;
+
+pub fn framebuffer_mut() -> &'static mut FB {
+    unsafe { FRAMEBUFFER.as_mut().unwrap() }
+}
+
+pub async fn init_display(
+    spi: Spi<'static, SPI1, Async>,
+    cs: PIN_13,
+    data: PIN_14,
+    reset: PIN_15,
+) -> DISPLAY {
+    let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
+    let mut display = ST7365P::new(
+        spi_device,
+        Output::new(data, Level::Low),
+        Some(Output::new(reset, Level::High)),
+        false,
+        true,
+        Delay,
+    );
+
+    display.init().await.unwrap();
+    display.set_custom_orientation(0x40).await.unwrap();
+    unsafe { FRAMEBUFFER.replace(FrameBuffer::new()) };
+    display.draw(framebuffer_mut()).await.unwrap();
+    display.set_on().await.unwrap();
+
+    display
+}
+
+pub async fn display_handler(mut display: DISPLAY) {
+    let fb = framebuffer_mut();
+    loop {
+        display.partial_draw_batched(fb).await.unwrap();
+        embassy_time::Timer::after_millis(32).await; // 30 fps
+    }
+}

kernel/src/elf.rs

@@ -0,0 +1,204 @@
+#![allow(static_mut_refs)]
+
+use crate::{
+    abi,
+    storage::{File, SDCARD},
+};
+use abi_sys::{CallAbiTable, EntryFn};
+use alloc::{vec, vec::Vec};
+use embedded_sdmmc::ShortFileName;
+use goblin::{
+    elf::{
+        header::header32::Header,
+        program_header::program_header32::{PT_LOAD, ProgramHeader},
+        section_header::SHT_SYMTAB,
+    },
+    elf32::{section_header::SectionHeader, sym::Sym},
+};
+
+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> {
+    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 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();
+
+            let ph = cast_phdr(&program_headers_buf);
+
+            if ph.p_type == PT_LOAD {
+                load_segment(&mut file, &ph).unwrap()
+            }
+        }
+
+        // MUST MATCH ABI EXACTLY
+        let entries: &[(CallAbiTable, usize)] = &[
+            (CallAbiTable::Print, abi::print 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)
+    }
+}
+
+fn patch_abi(
+    entries: &[(CallAbiTable, usize)],
+    elf_header: &Header,
+    file: &mut File,
+) -> Result<(), ()> {
+    for i in 1..=elf_header.e_shnum {
+        let sh = read_section(file, &elf_header, i.into());
+
+        // find the symbol table
+        if sh.sh_type == SHT_SYMTAB {
+            let mut symtab_buf = vec![0u8; sh.sh_size as usize];
+            file.seek_from_start(sh.sh_offset).unwrap();
+            file.read(&mut symtab_buf).unwrap();
+
+            // Cast buffer into symbols
+            let sym_count = sh.sh_size as usize / sh.sh_entsize as usize;
+            for i in 0..sym_count {
+                let sym_bytes =
+                    &symtab_buf[i * sh.sh_entsize as usize..(i + 1) * sh.sh_entsize as usize];
+                let sym = cast_sym(sym_bytes);
+
+                let str_sh = read_section(file, &elf_header, sh.sh_link);
+
+                let mut name = Vec::new();
+                file.seek_from_start(str_sh.sh_offset + sym.st_name)
+                    .unwrap();
+
+                loop {
+                    let mut byte = [0u8; 1];
+                    file.read(&mut byte).unwrap();
+                    if byte[0] == 0 {
+                        break;
+                    }
+                    name.push(byte[0]);
+                }
+
+                let symbol_name = core::str::from_utf8(&name).unwrap();
+                if symbol_name == "CALL_ABI_TABLE" {
+                    let table_base = sym.st_value as *mut usize;
+
+                    for &(abi_idx, func_ptr) in entries {
+                        unsafe {
+                            table_base.add(abi_idx as usize).write(func_ptr);
+                        }
+                    }
+                    return Ok(());
+                }
+            }
+        }
+    }
+    Err(())
+}
+
+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];
+
+    file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
+        .unwrap();
+    file.read(&mut section_header_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(())
+}
+
+fn cast_phdr(buf: &[u8]) -> ProgramHeader {
+    assert!(buf.len() >= core::mem::size_of::<ProgramHeader>());
+    unsafe { core::ptr::read(buf.as_ptr() as *const ProgramHeader) }
+}
+
+fn cast_shdr(buf: &[u8]) -> SectionHeader {
+    assert!(buf.len() >= core::mem::size_of::<SectionHeader>());
+    unsafe { core::ptr::read(buf.as_ptr() as *const SectionHeader) }
+}
+
+fn cast_sym(buf: &[u8]) -> Sym {
+    assert!(buf.len() >= core::mem::size_of::<Sym>());
+    unsafe { core::ptr::read(buf.as_ptr() as *const Sym) }
+}

kernel/src/main.rs

@@ -0,0 +1,268 @@
+#![feature(impl_trait_in_assoc_type)]
+#![feature(type_alias_impl_trait)]
+#![feature(ascii_char)]
+#![cfg_attr(not(test), no_std)]
+#![cfg_attr(not(test), no_main)]
+#![allow(static_mut_refs)]
+
+extern crate alloc;
+
+mod abi;
+mod display;
+mod elf;
+mod peripherals;
+mod scsi;
+mod storage;
+mod ui;
+mod usb;
+mod utils;
+
+use crate::{
+    display::{display_handler, framebuffer_mut, init_display},
+    peripherals::{
+        conf_peripherals,
+        keyboard::{KeyCode, KeyState, read_keyboard_fifo},
+    },
+    storage::{SDCARD, SdCard},
+    ui::{SELECTIONS, ui_handler},
+    usb::usb_handler,
+};
+use abi_sys::{EntryFn, Rgb565, RgbColor};
+use defmt::unwrap;
+use embassy_executor::{Executor, Spawner};
+use embassy_futures::join::{join, join3, join4, join5};
+use embassy_rp::{
+    gpio::{Input, Level, Output, Pull},
+    i2c::{self, I2c},
+    multicore::{Stack, spawn_core1},
+    peripherals::{
+        DMA_CH0, DMA_CH1, I2C1, PIN_6, PIN_7, PIN_10, PIN_11, PIN_12, PIN_13, PIN_14, PIN_15,
+        PIN_16, PIN_17, PIN_18, PIN_19, PIN_22, SPI0, SPI1, USB,
+    },
+    spi::{self, Spi},
+    usb as embassy_rp_usb,
+};
+use embassy_sync::{
+    blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, mutex::Mutex, signal::Signal,
+};
+use embassy_time::{Delay, Timer};
+use embedded_graphics::draw_target::DrawTarget;
+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::*;
+use {defmt_rtt as _, panic_probe as _};
+
+embassy_rp::bind_interrupts!(struct Irqs {
+    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+    USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
+});
+
+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];
+
+#[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)]
+enum TaskState {
+    Ui,
+    Kernel,
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    spawn_core1(
+        p.CORE1,
+        unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
+        move || {
+            let executor1 = EXECUTOR1.init(Executor::new());
+            executor1.run(|spawner| unwrap!(spawner.spawn(userland_task())));
+        },
+    );
+
+    let display = Display {
+        spi: p.SPI1,
+        clk: p.PIN_10,
+        mosi: p.PIN_11,
+        miso: p.PIN_12,
+        dma1: p.DMA_CH0,
+        dma2: p.DMA_CH1,
+        cs: p.PIN_13,
+        data: p.PIN_14,
+        reset: p.PIN_15,
+    };
+    let sd = Sd {
+        spi: p.SPI0,
+        clk: p.PIN_18,
+        mosi: p.PIN_19,
+        miso: p.PIN_16,
+        cs: p.PIN_17,
+        det: p.PIN_22,
+    };
+    let mcu = Mcu {
+        i2c: p.I2C1,
+        clk: p.PIN_7,
+        data: p.PIN_6,
+    };
+    let executor0 = EXECUTOR0.init(Executor::new());
+    executor0.run(|spawner| unwrap!(spawner.spawn(kernel_task(display, sd, mcu, p.USB))));
+}
+
+// One-slot channel to pass EntryFn from core1
+static BINARY_CH: Channel<CriticalSectionRawMutex, EntryFn, 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 bin");
+
+        // disable kernel ui
+        {
+            let mut state = TASK_STATE.lock().await;
+            *state = TaskState::Kernel;
+            TASK_STATE_CHANGED.signal(());
+        }
+
+        {
+            let fb = framebuffer_mut();
+            fb.clear(Rgb565::BLACK).unwrap();
+        }
+
+        defmt::info!("running entry");
+        entry().await;
+
+        // enable kernel ui
+        {
+            let mut state = TASK_STATE.lock().await;
+            *state = TaskState::Ui;
+            TASK_STATE_CHANGED.signal(());
+        }
+    }
+}
+
+struct Display {
+    spi: SPI1,
+    clk: PIN_10,
+    mosi: PIN_11,
+    miso: PIN_12,
+    dma1: DMA_CH0,
+    dma2: DMA_CH1,
+    cs: PIN_13,
+    data: PIN_14,
+    reset: PIN_15,
+}
+
+struct Sd {
+    spi: SPI0,
+    clk: PIN_18,
+    mosi: PIN_19,
+    miso: PIN_16,
+    cs: PIN_17,
+    det: PIN_22,
+}
+
+struct Mcu {
+    i2c: I2C1,
+    clk: PIN_7,
+    data: PIN_6,
+}
+
+#[embassy_executor::task]
+async fn kernel_task(display: Display, sd: Sd, mcu: Mcu, usb: USB) {
+    // MCU i2c bus for peripherals
+    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;
+
+    let mut config = spi::Config::default();
+    config.frequency = 16_000_000;
+    let spi = Spi::new(
+        display.spi,
+        display.clk,
+        display.mosi,
+        display.miso,
+        display.dma1,
+        display.dma2,
+        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
+        }
+    };
+
+    join4(display_fut, ui_fut, binary_search_fut, key_abi_fut).await;
+}
+
+static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();
+
+async fn get_keys() {
+    if let Some(event) = read_keyboard_fifo().await {
+        unsafe {
+            let _ = KEY_CACHE.enqueue(event);
+        }
+    }
+}

kernel/src/peripherals/keyboard.rs

@@ -0,0 +1,59 @@
+use crate::peripherals::PERIPHERAL_BUS;
+pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+
+const REG_ID_KEY: u8 = 0x04;
+const REG_ID_FIF: u8 = 0x09;
+
+const KEY_CAPSLOCK: u8 = 1 << 5;
+const KEY_NUMLOCK: u8 = 1 << 6;
+const KEY_COUNT_MASK: u8 = 0x1F; // 0x1F == 31
+
+pub async fn read_keyboard_fifo() -> Option<KeyEvent> {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let mut key_status = [0_u8; 1];
+
+    if i2c
+        .write_read_async(super::MCU_ADDR, [REG_ID_KEY], &mut key_status)
+        .await
+        .is_ok()
+    {
+        let _caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
+        let _num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
+        let fifo_count = key_status[0] & KEY_COUNT_MASK;
+
+        if fifo_count >= 1 {
+            let mut event = [0_u8; 2];
+
+            if i2c
+                .write_read_async(super::MCU_ADDR, [REG_ID_FIF], &mut event)
+                .await
+                .is_ok()
+            {
+                return Some(KeyEvent {
+                    state: KeyState::from(event[0]),
+                    key: KeyCode::from(event[1]),
+                    mods: Modifiers::NONE,
+                });
+            }
+        }
+    }
+    None
+}
+
+const REG_ID_DEB: u8 = 0x06;
+const REG_ID_FRQ: u8 = 0x07;
+
+pub async fn configure_keyboard(debounce: u8, poll_freq: u8) {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let _ = i2c
+        .write_read_async(super::MCU_ADDR, [REG_ID_DEB], &mut [debounce])
+        .await;
+
+    let _ = i2c
+        .write_read_async(super::MCU_ADDR, [REG_ID_FRQ], &mut [poll_freq])
+        .await;
+}

kernel/src/scsi/mod.rs

@@ -12,14 +12,14 @@ use crate::storage::SdCard;
 
 const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
 
-pub struct MassStorageClass<'d, D: Driver<'d>> {
+pub struct MassStorageClass<'d, 's, D: Driver<'d>> {
-    sdcard: SdCard,
+    sdcard: &'s SdCard,
     bulk_out: D::EndpointOut,
     bulk_in: D::EndpointIn,
 }
 
-impl<'d, D: Driver<'d>> MassStorageClass<'d, D> {
+impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
-    pub fn new(builder: &mut Builder<'d, D>, sdcard: SdCard) -> Self {
+    pub fn new(builder: &mut Builder<'d, D>, sdcard: &'s 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);

kernel/src/storage.rs

@@ -1,12 +1,18 @@
+use alloc::{string::String, vec::Vec};
+use core::str::FromStr;
 use embassy_rp::gpio::{Input, Output};
 use embassy_rp::peripherals::SPI0;
 use embassy_rp::spi::{Blocking, Spi};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::lazy_lock::LazyLock;
+use embassy_sync::mutex::Mutex;
 use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use embedded_sdmmc::{
     Block, BlockCount, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource,
     Timestamp, Volume, VolumeIdx, VolumeManager, sdcard::Error,
 };
+use embedded_sdmmc::{File as SdFile, LfnBuffer, Mode, ShortFileName};
 
 pub const MAX_DIRS: usize = 4;
 pub const MAX_FILES: usize = 5;
@@ -17,6 +23,10 @@ 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 File<'a> = SdFile<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
+
+pub static SDCARD: LazyLock<Mutex<NoopRawMutex, Option<SdCard>>> =
+    LazyLock::new(|| Mutex::new(None));
 
 pub struct DummyTimeSource {}
 impl TimeSource for DummyTimeSource {
@@ -25,6 +35,12 @@ impl TimeSource for DummyTimeSource {
     }
 }
 
+#[derive(Clone, PartialEq)]
+pub struct FileName {
+    pub long_name: String,
+    pub short_name: ShortFileName,
+}
+
 pub struct SdCard {
     det: Input<'static>,
     volume_mgr: VolMgr,
@@ -51,13 +67,6 @@ impl SdCard {
         self.det.is_low()
     }
 
-    pub fn open_volume(&mut self) -> Result<Vol<'_>, ()> {
-        if self.is_attached() {
-            return Ok(self.volume_mgr.open_volume(VolumeIdx(0)).map_err(|_| ())?);
-        }
-        Err(())
-    }
-
     pub fn size(&self) -> u64 {
         let mut result = 0;
 
@@ -97,4 +106,57 @@ impl SdCard {
         });
         res.map_err(|_| ())
     }
+
+    pub fn access_root_dir(&mut self, mut access: impl FnMut(Dir)) {
+        let volume0 = self.volume_mgr.open_volume(VolumeIdx(0)).unwrap();
+        let root_dir = volume0.open_root_dir().unwrap();
+
+        access(root_dir);
+    }
+
+    pub async fn read_file(
+        &mut self,
+        name: &ShortFileName,
+        mut access: impl FnMut(File),
+    ) -> Result<(), ()> {
+        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
+    }
+
+    /// Returns a Vec of file names (long format) that match the given extension (e.g., "BIN")
+    pub fn list_files_by_extension(&mut self, ext: &str) -> Result<Vec<FileName>, ()> {
+        let mut result = Vec::new();
+
+        // Only proceed if card is inserted
+        if !self.is_attached() {
+            return Ok(result);
+        }
+
+        let mut lfn_storage = [0; 50];
+        let mut lfn_buffer = LfnBuffer::new(&mut lfn_storage);
+
+        self.access_root_dir(|dir| {
+            dir.iterate_dir_lfn(&mut lfn_buffer, |entry, name| {
+                if let Some(name) = name {
+                    let name = String::from_str(name).unwrap();
+                    if name.contains(ext) {
+                        result.push(FileName {
+                            long_name: name,
+                            short_name: entry.name.clone(),
+                        });
+                    }
+                }
+            })
+            .unwrap()
+        });
+
+        Ok(result)
+    }
 }

kernel/src/ui.rs

@@ -0,0 +1,188 @@
+use crate::{
+    BINARY_CH, TASK_STATE, TaskState,
+    display::{SCREEN_HEIGHT, SCREEN_WIDTH, framebuffer_mut},
+    elf::load_binary,
+    format,
+    peripherals::keyboard,
+    storage::FileName,
+    usb::RESTART_USB,
+};
+use alloc::{string::String, vec::Vec};
+use core::{fmt::Debug, str::FromStr, sync::atomic::Ordering};
+use defmt::info;
+use embassy_rp::{
+    gpio::{Level, Output},
+    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
+    spi::{Async, Spi},
+};
+use embassy_sync::{
+    blocking_mutex::raw::{CriticalSectionRawMutex, ThreadModeRawMutex},
+    mutex::Mutex,
+    signal::Signal,
+};
+use embassy_time::{Delay, Timer};
+use embedded_graphics::{
+    Drawable,
+    draw_target::DrawTarget,
+    mono_font::{
+        MonoTextStyle,
+        ascii::{FONT_6X9, FONT_6X10, FONT_9X15, FONT_10X20},
+    },
+    pixelcolor::Rgb565,
+    prelude::{Dimensions, Point, Primitive, RgbColor, Size},
+    primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
+    text::Text,
+};
+use embedded_hal_async::spi::SpiDevice;
+use embedded_hal_bus::spi::{ExclusiveDevice, NoDelay};
+use embedded_layout::{
+    align::{horizontal, vertical},
+    layout::linear::LinearLayout,
+    object_chain::Chain,
+    prelude::*,
+};
+use embedded_text::TextBox;
+use shared::keyboard::{KeyCode, KeyState};
+
+pub static SELECTIONS: Mutex<CriticalSectionRawMutex, SelectionList> =
+    Mutex::new(SelectionList::new());
+
+pub async fn run_selected() {
+    info!("Getting selections lock");
+    let selections = SELECTIONS.lock().await;
+    info!("Got selections lock");
+    let selection = selections.selections[selections.current_selection as usize - 1].clone();
+
+    let entry = unsafe { load_binary(&selection.short_name).await.unwrap() };
+    info!("loaded binary");
+    BINARY_CH.send(entry).await;
+    info!("sent bin");
+}
+
+pub async fn ui_handler() {
+    loop {
+        let state = *TASK_STATE.lock().await;
+        if let TaskState::Ui = state {
+            let mut redraw = false;
+
+            if let Some(event) = keyboard::read_keyboard_fifo().await {
+                if event.state == KeyState::Pressed {
+                    match event.key {
+                        KeyCode::JoyUp => {
+                            let mut selections = SELECTIONS.lock().await;
+                            selections.up();
+                            redraw = true;
+                        }
+                        KeyCode::JoyDown => {
+                            let mut selections = SELECTIONS.lock().await;
+                            selections.down();
+                            redraw = true;
+                        }
+                        KeyCode::Enter | KeyCode::JoyRight => run_selected().await,
+                        _ => {}
+                    }
+                }
+            }
+
+            {
+                let mut selections = SELECTIONS.lock().await;
+                redraw |= selections.take_changed();
+            }
+
+            if redraw {
+                draw_selection().await;
+            }
+        }
+    }
+}
+
+async fn draw_selection() {
+    let file_names: Vec<FileName> = {
+        let guard = SELECTIONS.lock().await;
+        guard.selections.clone()
+    };
+
+    let fb = framebuffer_mut();
+    let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
+    let display_area = fb.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();
+
+    if file_names.is_empty() {
+        TextBox::new(
+            &no_bins,
+            Rectangle::new(
+                Point::new(25, 25),
+                Size::new(display_area.size.width - 50, display_area.size.width - 50),
+            ),
+            text_style,
+        )
+        .draw(fb)
+        .unwrap();
+    } else {
+        let mut file_names = file_names.iter();
+        let Some(first) = file_names.next() else {
+            Text::new("No Programs found on SD Card\nEnsure programs end with '.bin',\nand are located in the root directory",
+                Point::zero(), text_style).draw(fb).unwrap();
+
+            return;
+        };
+
+        let chain = Chain::new(Text::new(&first.long_name, Point::zero(), text_style));
+
+        // for _ in 0..file_names.len() {
+        //     let chain = chain.append(Text::new(
+        //         file_names.next().unwrap(),
+        //         Point::zero(),
+        //         text_style,
+        //     ));
+        // }
+
+        LinearLayout::vertical(chain)
+            .with_alignment(horizontal::Center)
+            .arrange()
+            .align_to(&display_area, horizontal::Center, vertical::Center)
+            .draw(fb)
+            .unwrap();
+    };
+}
+
+#[derive(Clone)]
+pub struct SelectionList {
+    current_selection: u16,
+    pub selections: Vec<FileName>,
+    has_changed: bool,
+}
+
+impl SelectionList {
+    pub const fn new() -> Self {
+        Self {
+            selections: Vec::new(),
+            current_selection: 0,
+            has_changed: true,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.current_selection = 1
+    }
+
+    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
+        }
+    }
+
+    pub fn take_changed(&mut self) -> bool {
+        let changed = self.has_changed;
+        self.has_changed = false;
+        changed
+    }
+}

kernel/src/usb.rs

@@ -0,0 +1,63 @@
+use core::sync::atomic::Ordering;
+
+use crate::{
+    scsi::MassStorageClass,
+    storage::{SDCARD, SdCard},
+};
+use embassy_futures::{
+    join::join,
+    select::{select, select3},
+};
+use embassy_rp::{peripherals::USB, usb::Driver};
+use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, signal::Signal};
+use embassy_usb::{Builder, Config};
+use portable_atomic::AtomicBool;
+
+pub static RESTART_USB: Signal<ThreadModeRawMutex, ()> = Signal::new();
+pub static ENABLE_SCSI: AtomicBool = AtomicBool::new(false);
+
+pub async fn usb_handler(driver: Driver<'static, USB>) {
+    let mut config = Config::new(0xc0de, 0xbabe);
+    config.manufacturer = Some("LegitCamper");
+    config.product = Some("PicoCalc");
+    config.serial_number = Some("01001100");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 64];
+    let mut control_buf = [0; 64];
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut [],
+        &mut control_buf,
+    );
+
+    let lock = SDCARD.get().lock().await;
+    let sdcard = lock.as_ref().unwrap();
+
+    let mut scsi = MassStorageClass::new(&mut builder, &sdcard);
+    let mut usb = builder.build();
+
+    loop {
+        select3(
+            async {
+                loop {
+                    RESTART_USB.wait().await;
+                    return;
+                }
+            },
+            usb.run(),
+            async {
+                if ENABLE_SCSI.load(Ordering::Acquire) {
+                    scsi.poll().await
+                }
+            },
+        )
+        .await;
+    }
+}

shared/Cargo.toml

@@ -0,0 +1,11 @@
+[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

@@ -0,0 +1,142 @@
+#![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),
+                },
+            }
+        }
+    }
+}

src/display.rs

@@ -1,68 +0,0 @@
-use core::sync::atomic::Ordering;
-
-use defmt::info;
-use embassy_rp::{
-    gpio::{Level, Output},
-    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
-    spi::{Async, Spi},
-};
-use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, signal::Signal};
-use embassy_time::{Delay, Instant, Timer};
-use embedded_graphics::{
-    Drawable,
-    draw_target::DrawTarget,
-    mono_font::{MonoTextStyle, ascii::FONT_10X20},
-    pixelcolor::Rgb565,
-    prelude::{Dimensions, Point, RgbColor, Size},
-    primitives::Rectangle,
-    text::{Alignment, Text},
-};
-use embedded_hal_bus::spi::ExclusiveDevice;
-use portable_atomic::AtomicBool;
-use st7365p_lcd::{FrameBuffer, ST7365P};
-
-const SCREEN_WIDTH: usize = 320;
-const SCREEN_HEIGHT: usize = 320;
-
-pub static DISPLAY_SIGNAL: Signal<ThreadModeRawMutex, ()> = Signal::new();
-
-pub async fn display_handler(
-    spi: Spi<'static, SPI1, Async>,
-    cs: PIN_13,
-    data: PIN_14,
-    reset: PIN_15,
-) {
-    let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
-    let mut display = ST7365P::new(
-        spi_device,
-        Output::new(data, Level::Low),
-        Some(Output::new(reset, Level::High)),
-        false,
-        true,
-        Delay,
-    );
-    let mut framebuffer: FrameBuffer<
-        SCREEN_WIDTH,
-        SCREEN_HEIGHT,
-        { SCREEN_WIDTH * SCREEN_HEIGHT },
-    > = FrameBuffer::new();
-    display.init().await.unwrap();
-    display.set_custom_orientation(0x40).await.unwrap();
-    framebuffer.draw(&mut display).await.unwrap();
-    display.set_on().await.unwrap();
-
-    DISPLAY_SIGNAL.signal(());
-
-    loop {
-        DISPLAY_SIGNAL.wait().await;
-
-        // text.draw(&mut framebuffer).unwrap();
-
-        let start = Instant::now();
-        framebuffer
-            .partial_draw_batched(&mut display)
-            .await
-            .unwrap();
-        info!("Elapsed {}ms", start.elapsed().as_millis());
-    }
-}

src/main.rs

@@ -1,88 +0,0 @@
-#![feature(impl_trait_in_assoc_type)]
-#![feature(ascii_char)]
-#![no_std]
-#![no_main]
-
-use crate::{
-    display::DISPLAY_SIGNAL,
-    peripherals::keyboard::{KeyCode, KeyState, read_keyboard_fifo},
-    storage::SdCard,
-    usb::usb_handler,
-};
-
-use {defmt_rtt as _, panic_probe as _};
-
-use core::cell::RefCell;
-use embassy_executor::Spawner;
-use embassy_futures::join::join;
-use embassy_rp::{
-    gpio::{Input, Level, Output, Pull},
-    peripherals::{I2C1, USB},
-    spi::Spi,
-    usb as embassy_rp_usb,
-};
-use embassy_rp::{i2c, i2c::I2c, spi};
-use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
-use embassy_sync::mutex::Mutex;
-use embassy_time::{Delay, Timer};
-use embedded_graphics::primitives::Rectangle;
-use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::SdCard as SdmmcSdCard;
-use heapless::String;
-
-mod peripherals;
-use peripherals::conf_peripherals;
-mod display;
-use display::display_handler;
-mod scsi;
-mod storage;
-mod usb;
-mod utils;
-
-embassy_rp::bind_interrupts!(struct Irqs {
-    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
-    USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
-});
-
-#[embassy_executor::main]
-async fn main(_spawner: Spawner) {
-    let p = embassy_rp::init(Default::default());
-
-    // MCU i2c bus for peripherals
-    let mut config = i2c::Config::default();
-    config.frequency = 400_000;
-    let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
-    conf_peripherals(i2c1).await;
-
-    // SPI1 bus display
-    let mut config = spi::Config::default();
-    config.frequency = 16_000_000;
-    let spi1 = spi::Spi::new(
-        p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, p.DMA_CH0, p.DMA_CH1, config,
-    );
-
-    let usb = embassy_rp_usb::Driver::new(p.USB, Irqs);
-
-    let sdcard = {
-        let mut config = spi::Config::default();
-        config.frequency = 400_000;
-        let spi = Spi::new_blocking(
-            p.SPI0,
-            p.PIN_18, // clk
-            p.PIN_19, // mosi
-            p.PIN_16, // miso
-            config.clone(),
-        );
-        let cs = Output::new(p.PIN_17, Level::High);
-        let det = Input::new(p.PIN_22, 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::new(sdcard, det)
-    };
-
-    usb_handler(usb, sdcard).await;
-}

src/peripherals/keyboard.rs

@@ -1,197 +0,0 @@
-
-use crate::peripherals::PERIPHERAL_BUS;
-
-const REG_ID_KEY: u8 = 0x04;
-const REG_ID_FIF: u8 = 0x09;
-
-const KEY_CAPSLOCK: u8 = 1 << 5;
-const KEY_NUMLOCK: u8 = 1 << 6;
-const KEY_COUNT_MASK: u8 = 0x1F; // 0x1F == 31
-
-pub async fn read_keyboard_fifo() -> Option<KeyEvent> {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let mut key_status = [0_u8; 1];
-
-    if i2c
-        .write_read_async(super::MCU_ADDR, [REG_ID_KEY], &mut key_status)
-        .await
-        .is_ok()
-    {
-        let _caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
-        let _num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
-        let fifo_count = key_status[0] & KEY_COUNT_MASK;
-
-        if fifo_count >= 1 {
-            let mut event = [0_u8; 2];
-
-            if i2c
-                .write_read_async(super::MCU_ADDR, [REG_ID_FIF], &mut event)
-                .await
-                .is_ok()
-            {
-                return Some(KeyEvent {
-                    state: KeyState::from(event[0]),
-                    key: KeyCode::from(event[1]),
-                    mods: Modifiers::NONE,
-                });
-            }
-        }
-    }
-    None
-}
-
-const REG_ID_DEB: u8 = 0x06;
-const REG_ID_FRQ: u8 = 0x07;
-
-pub async fn configure_keyboard(debounce: u8, poll_freq: u8) {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let _ = i2c
-        .write_read_async(super::MCU_ADDR, [REG_ID_DEB], &mut [debounce])
-        .await;
-
-    let _ = i2c
-        .write_read_async(super::MCU_ADDR, [REG_ID_FRQ], &mut [poll_freq])
-        .await;
-}
-
-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(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),
-            },
-        }
-    }
-}

src/usb.rs

@@ -1,36 +0,0 @@
-use crate::{scsi::MassStorageClass, storage::SdCard};
-use embassy_futures::select::select;
-use embassy_rp::{peripherals::USB, usb::Driver};
-use embassy_usb::{Builder, Config};
-
-pub async fn usb_handler(driver: Driver<'static, USB>, sdcard: SdCard) {
-    let mut config = Config::new(0xc0de, 0xcafe);
-    config.manufacturer = Some("LegitCamper");
-    config.product = Some("PicoCalc");
-    config.serial_number = Some("01001100");
-    config.max_power = 100;
-    config.max_packet_size_0 = 64;
-
-    let mut config_descriptor = [0; 256];
-    let mut bos_descriptor = [0; 64];
-    let mut control_buf = [0; 64];
-
-    let mut builder = Builder::new(
-        driver,
-        config,
-        &mut config_descriptor,
-        &mut bos_descriptor,
-        &mut [],
-        &mut control_buf,
-    );
-
-    let mut scsi = MassStorageClass::new(&mut builder, sdcard);
-    let mut usb = builder.build();
-
-    loop {
-        select(usb.run(), scsi.poll()).await;
-
-        defmt::warn!("rebuilding usb");
-        usb.disable().await;
-    }
-}

user-apps/calculator/Cargo.toml

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

user-apps/calculator/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/calculator/src/main.rs

@@ -0,0 +1,58 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+use abi::{KeyCode, display::Display, embassy_time, get_key, print};
+use alloc::{boxed::Box, string::String, vec};
+use core::{panic::PanicInfo, pin::Pin};
+use embedded_graphics::{
+    Drawable,
+    geometry::{Dimensions, Point},
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    pixelcolor::Rgb565,
+    prelude::RgbColor,
+    text::{Alignment, Text},
+};
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {}
+}
+
+pub async fn main() {
+    print("Starting Async Calculator app");
+    let mut display = Display;
+
+    let character_style = MonoTextStyle::new(&FONT_6X10, Rgb565::RED);
+
+    let mut text = vec!['H', 'E', 'L', 'L', 'O'];
+
+    // loop {
+    Text::with_alignment(
+        &text.iter().cloned().collect::<String>(),
+        display.bounding_box().center() + Point::new(0, 15),
+        character_style,
+        Alignment::Center,
+    )
+    .draw(&mut display)
+    .unwrap();
+
+    if let Some(event) = get_key() {
+        print("User got event");
+        match event.key {
+            KeyCode::Char(ch) => {
+                text.push(ch);
+            }
+            KeyCode::Backspace => {
+                text.pop();
+            }
+            _ => (),
+        }
+    }
+    // }
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() -> Pin<Box<dyn Future<Output = ()>>> {
+    Box::pin(async { main().await })
+}

user-apps/memory.x

@@ -0,0 +1,33 @@
+MEMORY
+{
+  /* Must match the USERAPP region in the kernel linker script */
+  RAM : ORIGIN = 0x20010000, LENGTH = 192K
+}
+
+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.*);
+      *(.rodata .rodata.*);
+  } > RAM
+
+  .data : ALIGN(4)
+  {
+      *(.data .data.*);
+  } > RAM
+
+  .bss : ALIGN(4)
+  {
+      *(.bss .bss.*);
+      *(COMMON);
+  } > RAM
+}