dont use mutex on framebuffer

syscalls via call_abi are still not working

Cargo.toml

@@ -1,10 +1,18 @@
 [workspace]
 resolver = "3"
-members = ["pico", "shared", "simulator"]
+members = ["kernel", "abi", "shared", "user-apps/calculator"]
-
 
 [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

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

@@ -1,10 +1,8 @@
 [package]
-name = "simulator"
+name = "abi_sys"
 version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 embedded-graphics = "0.8.1"
-embedded-graphics-simulator = "0.7.0"
-embedded-layout = "0.4.2"
 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

@@ -1,8 +1,15 @@
 [package]
-name = "picocalc-os-rs"
+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"]
@@ -23,9 +30,6 @@ defmt = [
   # "cyw43-pio/defmt",
 ]
 
-[dev-dependencies]
-embedded-graphics-simulator = { version = "0.7.0", default-features = false }
-
 [dependencies]
 embassy-executor = { version = "0.7", features = [
   "arch-cortex-m",
@@ -37,11 +41,11 @@ embassy-rp = { version = "0.4.0", features = [
   "critical-section-impl",
   "unstable-pac",
   "time-driver",
-  "binary-info",
 ] }
+embassy-usb = "0.4.0"
 embassy-futures = "0.1.1"
-embassy-time = "0.4.0"
+embassy-time = { version = "0.4.0", features = ["generic-queue-8"] }
-embassy-embedded-hal = "0.3.0"
+embassy-embedded-hal = "0.3.1"
 embassy-sync = { version = "0.7" }
 trouble-host = { version = "0.1", features = [
   "derive",
@@ -65,12 +69,20 @@ 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-sdmmc = { git = "https://github.com/Be-ing/embedded-sdmmc-rs", branch = "bisync", default-features = false }
+embedded-text = "0.7.2"
-st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", branch = "async" }
+embedded-layout = "0.4.2"
-shared = { path = "../shared" }
 
 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/peripherals/mod.rs

@@ -5,13 +5,10 @@ use embassy_rp::{
     i2c::{Async, I2c},
     peripherals::I2C1,
 };
-use embassy_sync::{
+use embassy_sync::{blocking_mutex::raw::NoopRawMutex, lazy_lock::LazyLock, mutex::Mutex};
-    blocking_mutex::raw::NoopRawMutex, channel::Sender, lazy_lock::LazyLock, mutex::Mutex,
+use embassy_time::Timer;
-};
-use embassy_time::{Duration, Timer};
 
 pub mod keyboard;
-use keyboard::{KeyCode, KeyEvent, KeyState};
 
 use crate::peripherals::keyboard::{configure_keyboard, read_keyboard_fifo};
 
@@ -25,23 +22,18 @@ const REG_ID_VER: u8 = 0x01;
 const REG_ID_RST: u8 = 0x08;
 const REG_ID_INT: u8 = 0x03;
 
-#[embassy_executor::task]
+pub async fn conf_peripherals(i2c: I2CBUS) {
-pub async fn peripherals_task(
-    i2c: I2CBUS,
-    mut keyboard_channel: Sender<'static, NoopRawMutex, KeyEvent, 10>,
-) {
     Timer::after(embassy_time::Duration::from_millis(100)).await;
 
     PERIPHERAL_BUS.get().lock().await.replace(i2c);
 
     configure_keyboard(200, 100).await;
-    set_lcd_backlight(255).await;
-    set_key_backlight(0).await;
 
-    loop {
+    // empty keys
-        Timer::after(Duration::from_millis(200)).await;
+    while read_keyboard_fifo().await.is_some() {}
-        read_keyboard_fifo(&mut keyboard_channel).await;
+
-    }
+    // set_lcd_backlight(255).await;
+    set_key_backlight(0).await;
 }
 
 /// return major & minor mcu version

kernel/src/scsi/mod.rs

@@ -0,0 +1,308 @@
+use crate::format;
+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;
+
+mod scsi_types;
+use scsi_types::*;
+
+use crate::storage::SdCard;
+
+const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
+
+pub struct MassStorageClass<'d, 's, D: Driver<'d>> {
+    sdcard: &'s SdCard,
+    bulk_out: D::EndpointOut,
+    bulk_in: D::EndpointIn,
+}
+
+impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
+    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);
+
+        let bulk_out = alt.endpoint_bulk_out(BULK_ENDPOINT_PACKET_SIZE as u16);
+        let bulk_in = alt.endpoint_bulk_in(BULK_ENDPOINT_PACKET_SIZE as u16);
+
+        Self {
+            bulk_out,
+            bulk_in,
+            sdcard,
+        }
+    }
+
+    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
+                        } else {
+                            self.send_csw_fail(cbw.dCBWTag).await
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    async fn handle_command(&mut self, cbw: &[u8]) -> 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(())
+            }
+            ScsiCommand::Inquiry {
+                evpd,
+                page_code,
+                alloc_len,
+            } => {
+                if !evpd {
+                    response.push(0x00).map_err(|_| ())?; // Direct-access block device
+                    response.push(0x80).map_err(|_| ())?; // Removable
+                    response.push(0x05).map_err(|_| ())?; // SPC-3 compliance
+                    response.push(0x02).map_err(|_| ())?; // Response data format
+                    response.push(0x00).map_err(|_| ())?; // Additional length - edited later
+                    response.push(0x00).map_err(|_| ())?; // FLAGS
+                    response.push(0x00).map_err(|_| ())?; // FLAGS
+                    response.push(0).map_err(|_| ())?; // FLAGS
+                    assert!(response.len() == 8);
+
+                    let vendor = b"LEGTCMPR";
+                    assert!(vendor.len() == 8);
+                    response.extend_from_slice(vendor)?;
+
+                    let product = b"Pico Calc Sdcard";
+                    assert!(product.len() == 16);
+                    response.extend_from_slice(product)?;
+
+                    let version = b"1.00";
+                    assert!(version.len() == 4);
+                    response.extend_from_slice(version)?; // 4-byte firmware version
+
+                    let addl_len = response.len() - 5;
+                    response[4] = addl_len as u8;
+                    assert!(response.len() == 36);
+                } else {
+                    match page_code {
+                        0x00 => {
+                            response
+                                .extend_from_slice(&[
+                                    0x00, // Peripheral Qualifier + Peripheral Device Type (0x00 = Direct-access block device)
+                                    0x00, // Page Code (same as requested: 0x00)
+                                    0x00, 0x03, // Page Length: 3 bytes follow
+                                    0x00, // Supported VPD Page: 0x00 (this one — the "Supported VPD Pages" page itself)
+                                    0x80, // Supported VPD Page: 0x80 (Unit Serial Number)
+                                    0x83, // Supported VPD Page: 0x83 (Device Identification)
+                                ])
+                                .map_err(|_| ())?
+                        }
+                        0x80 => {
+                            let serial = b"Pico Calc";
+                            response.extend_from_slice(&[
+                                0x00, // Peripheral Qualifier & Device Type
+                                0x80, // Page Code = 0x80 (Unit Serial Number)
+                                0x00, // Reserved
+                                serial.len() as u8,
+                            ])?;
+                            response.extend_from_slice(serial)?;
+                        }
+                        0x83 => {
+                            let id = b"SdCard";
+                            response.extend_from_slice(&[
+                                0x00,
+                                0x83, // Page code
+                                0x00,
+                                (4 + id.len()) as u8, // Length
+                                0x02,                 // ASCII identifier
+                                0x01,                 // Identifier type
+                                0x00,                 // Reserved
+                                id.len() as u8,
+                            ])?;
+                            response.extend_from_slice(id)?;
+                        }
+                        _ => (),
+                    }
+                };
+
+                let len = core::cmp::min(alloc_len as usize, response.len());
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::TestUnitReady => {
+                if self.sdcard.is_attached() {
+                    Ok(())
+                } else {
+                    Err(())
+                }
+            }
+            ScsiCommand::RequestSense { desc, alloc_len } => Ok(()),
+            ScsiCommand::ModeSense6 {
+                dbd,
+                page_control,
+                page_code,
+                subpage_code,
+                alloc_len,
+            } => {
+                // DBD=0, no block descriptors; total length = 4
+                let response = [
+                    0x03, // Mode data length (excluding this byte): 3
+                    0x00, // Medium type
+                    0x00, // Device-specific parameter
+                    0x00, // Block descriptor length = 0 (DBD = 1)
+                ];
+
+                let len = alloc_len.min(response.len() as u8) as usize;
+
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::ModeSense10 {
+                dbd,
+                page_control,
+                page_code,
+                subpage_code,
+                alloc_len,
+            } => {
+                let response = [
+                    0x00, 0x06, // Mode data length = 6
+                    0x00, // Medium type
+                    0x00, // Device-specific parameter
+                    0x00, 0x00, // Reserved
+                    0x00, 0x00, // Block descriptor length = 0
+                ];
+
+                let len = alloc_len.min(response.len() as u16) as usize;
+
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::ReadCapacity10 => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
+                let total_blocks = self.sdcard.size() / block_size;
+
+                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+
+                response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
+
+                self.bulk_in.write(&response).await.map_err(|_| ())
+            }
+            ScsiCommand::ReadCapacity16 { alloc_len } => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
+                let total_blocks = self.sdcard.size() / block_size;
+
+                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+
+                response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?; // 4 bytes block length
+                response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
+
+                let len = alloc_len.min(response.len() as u32) as usize;
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::Read { lba, len } => {
+                for i in 0..len {
+                    let block_idx = BlockIdx(lba as u32 + i as u32);
+                    self.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(|_| ())?;
+                    }
+                }
+                Ok(())
+            }
+            ScsiCommand::Write { lba, len } => {
+                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(|_| ())?;
+                    }
+                    self.sdcard.write_blocks(&mut block, block_idx)?;
+                }
+                Ok(())
+            }
+            ScsiCommand::ReadFormatCapacities { alloc_len } => {
+                let block_size = SdCard::BLOCK_SIZE as u32;
+                let num_blocks = (self.sdcard.size() / block_size as u64) as u32;
+
+                let mut response = [0u8; 12];
+
+                // Capacity List Length (8 bytes follows)
+                response[3] = 8;
+
+                // Descriptor
+                response[4..8].copy_from_slice(&num_blocks.to_be_bytes());
+                response[8] = 0x03; // formatted media
+                response[9..12].copy_from_slice(&block_size.to_be_bytes()[1..4]); // only 3 bytes
+
+                let response_len = alloc_len.min(response.len() as u16) as usize;
+                self.bulk_in
+                    .write(&response[..response_len])
+                    .await
+                    .map_err(|_| ())
+            }
+            ScsiCommand::PreventAllowMediumRemoval { prevent: _prevent } => Ok(()),
+            ScsiCommand::StartStopUnit { start, load_eject } => Ok(()),
+        }
+    }
+
+    pub async fn send_csw_success(&mut self, tag: u32) {
+        self.send_csw(tag, 0x00, 0).await;
+    }
+
+    pub async fn send_csw_fail(&mut self, tag: u32) {
+        defmt::error!("Command Failed");
+        self.send_csw(tag, 0x01, 0).await; // 0x01 = Command Failed
+    }
+
+    pub async fn send_csw(&mut self, tag: u32, status: u8, residue: u32) {
+        let mut csw = [0u8; 13];
+        csw[0..4].copy_from_slice(&0x53425355u32.to_le_bytes()); // Signature "USBS"
+        csw[4..8].copy_from_slice(&tag.to_le_bytes());
+        csw[8..12].copy_from_slice(&residue.to_le_bytes());
+        csw[12] = status;
+        let _ = self.bulk_in.write(&csw).await;
+    }
+}
+
+#[repr(C, packed)]
+struct CommandBlockWrapper {
+    dCBWSignature: u32,
+    dCBWTag: u32,
+    dCBWDataTransferLength: u32,
+    bmCBWFlags: u8,
+    bCBWLUN: u8,
+    bCBWCBLength: u8,
+    CBWCB: [u8; 16],
+}
+
+impl CommandBlockWrapper {
+    fn parse(buf: &[u8]) -> Option<Self> {
+        if buf.len() < 31 {
+            return None;
+        }
+        let dCBWSignature = u32::from_le_bytes(buf[0..4].try_into().ok()?);
+        if dCBWSignature != 0x43425355 {
+            return None; // invalid signature
+        }
+        Some(Self {
+            dCBWSignature,
+            dCBWTag: u32::from_le_bytes(buf[4..8].try_into().ok()?),
+            dCBWDataTransferLength: u32::from_le_bytes(buf[8..12].try_into().ok()?),
+            bmCBWFlags: buf[12],
+            bCBWLUN: buf[13],
+            bCBWCBLength: buf[14],
+            CBWCB: buf[15..31].try_into().ok()?,
+        })
+    }
+}

kernel/src/scsi/scsi_types.rs

@@ -0,0 +1,164 @@
+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
+pub const SUBCLASS_SCSI: u8 = 0x06; // SCSI Transparent command set
+
+/* SCSI codes */
+
+/* SPC */
+const TEST_UNIT_READY: u8 = 0x00;
+const REQUEST_SENSE: u8 = 0x03;
+const INQUIRY: u8 = 0x12;
+const MODE_SENSE_6: u8 = 0x1A;
+const MODE_SENSE_10: u8 = 0x5A;
+
+/* SBC */
+const READ_10: u8 = 0x28;
+const READ_16: u8 = 0x88;
+const READ_CAPACITY_10: u8 = 0x25;
+const READ_CAPACITY_16: u8 = 0x9E;
+const WRITE_10: u8 = 0x2A;
+
+/* MMC */
+const READ_FORMAT_CAPACITIES: u8 = 0x23;
+
+const PREVENT_ALLOW_MEDIUM_REMOVAL: u8 = 0x1E;
+const START_STOP_UNIT: u8 = 0x1B;
+
+/// SCSI command
+///
+/// Refer to specifications (SPC,SAM,SBC,MMC,etc.)
+#[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum ScsiCommand {
+    Unknown,
+
+    /* SPC */
+    Inquiry {
+        evpd: bool,
+        page_code: u8,
+        alloc_len: u16,
+    },
+    TestUnitReady,
+    RequestSense {
+        desc: bool,
+        alloc_len: u8,
+    },
+    ModeSense6 {
+        dbd: bool,
+        page_control: PageControl,
+        page_code: u8,
+        subpage_code: u8,
+        alloc_len: u8,
+    },
+    ModeSense10 {
+        dbd: bool,
+        page_control: PageControl,
+        page_code: u8,
+        subpage_code: u8,
+        alloc_len: u16,
+    },
+
+    /* SBC */
+    ReadCapacity10,
+    ReadCapacity16 {
+        alloc_len: u32,
+    },
+    Read {
+        lba: u64,
+        len: u64,
+    },
+    Write {
+        lba: u64,
+        len: u64,
+    },
+
+    /* MMC */
+    ReadFormatCapacities {
+        alloc_len: u16,
+    },
+
+    PreventAllowMediumRemoval {
+        prevent: bool,
+    },
+
+    StartStopUnit {
+        start: bool,
+        load_eject: bool,
+    },
+}
+
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, TryFromPrimitive)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum PageControl {
+    CurrentValues = 0b00,
+    ChangeableValues = 0b01,
+    DefaultValues = 0b10,
+    SavedValues = 0b11,
+}
+
+#[allow(dead_code)]
+pub fn parse_cb(cb: &[u8]) -> ScsiCommand {
+    match cb[0] {
+        TEST_UNIT_READY => ScsiCommand::TestUnitReady,
+        INQUIRY => ScsiCommand::Inquiry {
+            evpd: (cb[1] & 0b00000001) != 0,
+            page_code: cb[2],
+            alloc_len: u16::from_be_bytes([cb[3], cb[4]]),
+        },
+        REQUEST_SENSE => ScsiCommand::RequestSense {
+            desc: (cb[1] & 0b00000001) != 0,
+            alloc_len: cb[4],
+        },
+        READ_CAPACITY_10 => ScsiCommand::ReadCapacity10,
+        READ_CAPACITY_16 => ScsiCommand::ReadCapacity16 {
+            alloc_len: u32::from_be_bytes([cb[10], cb[11], cb[12], cb[13]]),
+        },
+        READ_10 => ScsiCommand::Read {
+            lba: u32::from_be_bytes([cb[2], cb[3], cb[4], cb[5]]) as u64,
+            len: u16::from_be_bytes([cb[7], cb[8]]) as u64,
+        },
+        READ_16 => ScsiCommand::Read {
+            lba: u64::from_be_bytes((&cb[2..10]).try_into().unwrap()),
+            len: u32::from_be_bytes((&cb[10..14]).try_into().unwrap()) as u64,
+        },
+        WRITE_10 => ScsiCommand::Write {
+            lba: u32::from_be_bytes([cb[2], cb[3], cb[4], cb[5]]) as u64,
+            len: u16::from_be_bytes([cb[7], cb[8]]) as u64,
+        },
+        MODE_SENSE_6 => ScsiCommand::ModeSense6 {
+            dbd: (cb[1] & 0b00001000) != 0,
+            page_control: PageControl::try_from_primitive(cb[2] >> 6).unwrap(),
+            page_code: cb[2] & 0b00111111,
+            subpage_code: cb[3],
+            alloc_len: cb[4],
+        },
+        MODE_SENSE_10 => ScsiCommand::ModeSense10 {
+            dbd: (cb[1] & 0b00001000) != 0,
+            page_control: PageControl::try_from_primitive(cb[2] >> 6).unwrap(),
+            page_code: cb[2] & 0b00111111,
+            subpage_code: cb[3],
+            alloc_len: u16::from_be_bytes([cb[7], cb[8]]),
+        },
+        READ_FORMAT_CAPACITIES => ScsiCommand::ReadFormatCapacities {
+            alloc_len: u16::from_be_bytes([cb[7], cb[8]]),
+        },
+        PREVENT_ALLOW_MEDIUM_REMOVAL => ScsiCommand::PreventAllowMediumRemoval {
+            prevent: (cb[1] & 0b00000001) != 0,
+        },
+        START_STOP_UNIT => ScsiCommand::StartStopUnit {
+            start: (cb[4] & 0b00000001) != 0,
+            load_eject: (cb[4] & 0b00000010) != 0,
+        },
+        _ => ScsiCommand::Unknown,
+    }
+}

kernel/src/storage.rs

@@ -0,0 +1,162 @@
+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;
+pub const MAX_VOLUMES: usize = 1;
+
+type Device = ExclusiveDevice<Spi<'static, SPI0, Blocking>, Output<'static>, embassy_time::Delay>;
+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 {
+    fn get_timestamp(&self) -> Timestamp {
+        Timestamp::from_calendar(2022, 1, 1, 0, 0, 0).unwrap()
+    }
+}
+
+#[derive(Clone, PartialEq)]
+pub struct FileName {
+    pub long_name: String,
+    pub short_name: ShortFileName,
+}
+
+pub struct SdCard {
+    det: Input<'static>,
+    volume_mgr: VolMgr,
+}
+
+impl SdCard {
+    pub const BLOCK_SIZE: u16 = 512;
+
+    pub fn new(sdcard: SD, det: Input<'static>) -> Self {
+        let volume_mgr = VolumeManager::<_, _, MAX_DIRS, MAX_FILES, MAX_VOLUMES>::new_with_limits(
+            sdcard,
+            DummyTimeSource {},
+            5000,
+        );
+        Self {
+            det: det,
+            volume_mgr,
+        }
+    }
+
+    /// Returns true if an SD card is inserted.
+    /// The DET pin is active-low via mechanical switch in the socket.
+    pub fn is_attached(&self) -> bool {
+        self.det.is_low()
+    }
+
+    pub fn size(&self) -> u64 {
+        let mut result = 0;
+
+        self.volume_mgr.device(|sd| {
+            result = sd.num_bytes().unwrap_or(0);
+            DummyTimeSource {}
+        });
+
+        result
+    }
+
+    pub fn num_blocks(&self) -> u32 {
+        let mut result = 0;
+
+        self.volume_mgr.device(|sd| {
+            result = sd.num_blocks().unwrap_or(BlockCount(0)).0;
+            DummyTimeSource {}
+        });
+
+        result
+    }
+
+    pub fn read_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
+        let mut res: Result<(), Error> = Ok(());
+        self.volume_mgr.device(|sd| {
+            res = sd.read(blocks, start_block_idx);
+            DummyTimeSource {}
+        });
+        res.map_err(|_| ())
+    }
+
+    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);
+            DummyTimeSource {}
+        });
+        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;
+    }
+}

kernel/src/utils.rs

@@ -0,0 +1,11 @@
+#[macro_export]
+macro_rules! format {
+    ($len:literal, $($arg:tt)*) => {{
+        use heapless::String;
+        use core::fmt::Write;
+
+        let mut s: String<$len> = String::new();
+        let _ = write!(&mut s, $($arg)*);
+        s
+    }}
+}

pico/src/display.rs

@@ -1,61 +0,0 @@
-use defmt::info;
-use embassy_rp::{
-    gpio::{Level, Output},
-    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
-    spi::{Async, Spi},
-};
-use embassy_time::{Delay, Timer};
-use embedded_graphics::{
-    Drawable,
-    mono_font::{MonoFont, MonoTextStyle, ascii::FONT_10X20},
-    pixelcolor::Rgb565,
-    prelude::{Point, WebColors},
-    text::{Baseline, Text, TextStyle},
-};
-use embedded_hal_bus::spi::ExclusiveDevice;
-use st7365p_lcd::{FrameBuffer, ST7365P};
-
-use shared::{SCREEN_HEIGHT, SCREEN_WIDTH, TextBuffer};
-
-type SPI = Spi<'static, SPI1, Async>;
-
-type FRAMEBUFFER = FrameBuffer<
-    SCREEN_WIDTH,
-    SCREEN_HEIGHT,
-    ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
-    Output<'static>,
-    Output<'static>,
->;
-
-#[embassy_executor::task]
-pub async fn display_task(spi: SPI, cs: PIN_13, data: PIN_14, reset: PIN_15) {
-    let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
-    let display = ST7365P::new(
-        spi_device,
-        Output::new(data, Level::Low),
-        Some(Output::new(reset, Level::High)),
-        false,
-        true,
-        SCREEN_WIDTH as u32,
-        SCREEN_HEIGHT as u32,
-    );
-    let mut framebuffer: FRAMEBUFFER = FrameBuffer::new(display);
-
-    framebuffer.init(&mut Delay).await.unwrap();
-    framebuffer.display.set_offset(0, 0);
-    framebuffer
-        .display
-        .set_custom_orientation(0x60)
-        .await
-        .unwrap();
-
-    let mut textbuffer = TextBuffer::new();
-    textbuffer.fill('A');
-    textbuffer.draw(&mut framebuffer);
-    info!("finished rendering");
-
-    loop {
-        framebuffer.draw().await.unwrap();
-        Timer::after_millis(500).await;
-    }
-}

pico/src/main.rs

@@ -1,60 +0,0 @@
-#![feature(impl_trait_in_assoc_type)]
-#![feature(ascii_char)]
-#![no_std]
-#![no_main]
-
-#[cfg(feature = "defmt")]
-use defmt::*;
-use {defmt_rtt as _, panic_probe as _};
-
-use embassy_executor::Spawner;
-use embassy_rp::peripherals::I2C1;
-use embassy_rp::spi::Spi;
-use embassy_rp::{
-    bind_interrupts,
-    gpio::{Level, Output},
-    i2c,
-    i2c::I2c,
-    spi,
-};
-use embassy_sync::blocking_mutex::raw::NoopRawMutex;
-use embassy_sync::channel::Channel;
-use embassy_time::Timer;
-use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::asynchronous::{File, SdCard, ShortFileName, VolumeIdx, VolumeManager};
-use static_cell::StaticCell;
-
-mod peripherals;
-use peripherals::{keyboard::KeyEvent, peripherals_task};
-mod display;
-use display::display_task;
-
-embassy_rp::bind_interrupts!(struct Irqs {
-    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
-});
-
-#[embassy_executor::main]
-async fn main(spawner: Spawner) {
-    let p = embassy_rp::init(Default::default());
-
-    static KEYBOARD_EVENTS: StaticCell<Channel<NoopRawMutex, KeyEvent, 10>> = StaticCell::new();
-    let keyboard_events = KEYBOARD_EVENTS.init(Channel::new());
-
-    // // configure keyboard event handler
-    // let mut config = i2c::Config::default();
-    // config.frequency = 100_000;
-    // let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
-    // spawner
-    //     .spawn(peripherals_task(i2c1, keyboard_events.sender()))
-    //     .unwrap();
-
-    // configure display handler
-    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,
-    );
-    spawner
-        .spawn(display_task(spi1, p.PIN_13, p.PIN_14, p.PIN_15))
-        .unwrap();
-}

pico/src/peripherals/keyboard.rs

@@ -1,207 +0,0 @@
-use defmt::{info, warn};
-use embassy_rp::{
-    i2c::{Async, I2c},
-    peripherals::I2C1,
-};
-use embassy_sync::{
-    blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex},
-    channel::Sender,
-};
-
-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(channel: &mut Sender<'static, NoopRawMutex, KeyEvent, 10>) {
-    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()
-            {
-                channel
-                    .try_send(KeyEvent {
-                        state: KeyState::from(event[0]),
-                        key: KeyCode::from(event[1]),
-                        mods: Modifiers::NONE,
-                    })
-                    .expect("Failed to push key");
-            }
-        }
-    }
-}
-
-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),
-            },
-        }
-    }
-}

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
 channel = "nightly-2025-06-18"
 components = ["rust-src", "rustfmt", "rust-analyzer"]
-targets = ["thumbv6m-none-eabi", "x86_64-unknown-linux-gnu"]
+targets = ["thumbv6m-none-eabi"]

shared/Cargo.toml

@@ -3,8 +3,9 @@ name = "shared"
 version = "0.1.0"
 edition = "2024"
 
+[features]
+defmt = ["dep:defmt"]
+
 [dependencies]
-arrform = "0.1.1"
+bitflags = "2.9.1"
-embedded-graphics = "0.8.1"
+defmt = { version = "1.0.1", optional = true }
-embedded-graphics-core = "0.4.0"
-embedded-layout = "0.4.2"

shared/src/lib.rs

@@ -1,77 +1,142 @@
-pub mod screen {
+#![no_std]
-    use arrform::{ArrForm, arrform};
-    use embedded_graphics::{
-        Drawable,
-        draw_target::DrawTarget,
-        mono_font::{
-            MonoTextStyle,
-            ascii::{FONT_6X10, FONT_9X15, FONT_10X20},
-        },
-        pixelcolor::Rgb565,
-        prelude::{Point, RgbColor, Size},
-        primitives::Rectangle,
-        text::Text,
-    };
-    use embedded_layout::{
-        align::{horizontal, vertical},
-        layout::linear::LinearLayout,
-        prelude::*,
-    };
 
-    pub const SCREEN_WIDTH: usize = 320;
+pub mod keyboard {
-    pub const SCREEN_HEIGHT: usize = 320;
+    bitflags::bitflags! {
-
+        #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)]
-    pub const STATUS_BAR_WIDTH: usize = 320;
+        pub struct Modifiers: u8 {
-    pub const STATUS_BAR_HEIGHT: usize = 40;
+            const NONE = 0;
-
+            const CTRL = 1;
-    pub struct UI {
+            const ALT = 2;
-        pub status_bar: StatusBar,
+            const LSHIFT = 4;
+            const RSHIFT = 8;
+            const SYM = 16;
+        }
     }
 
-    impl UI {
+    #[derive(Debug)]
-        pub fn new() -> Self {
+    pub struct KeyEvent {
-            Self {
+        pub key: KeyCode,
-                status_bar: StatusBar {
+        pub state: KeyState,
-                    battery: 100,
+        pub mods: Modifiers,
-                    backlight: 100,
+    }
-                    volume: 100,
+
+    #[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),
                 },
             }
         }
-
-        pub fn draw_status_bar<D: DrawTarget<Color = Rgb565>>(&mut self, target: &mut D) {
-            let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
-
-            let status_bar = Rectangle::new(
-                Point::new(0, 0),
-                Size::new(STATUS_BAR_WIDTH as u32, STATUS_BAR_HEIGHT as u32),
-            );
-            let _ = LinearLayout::horizontal(
-                Chain::new(Text::new(
-                    arrform!(20, "Bat: {}", self.status_bar.battery).as_str(),
-                    Point::zero(),
-                    text_style,
-                ))
-                .append(Text::new(
-                    arrform!(20, "Lght: {}", self.status_bar.backlight).as_str(),
-                    Point::zero(),
-                    text_style,
-                ))
-                .append(Text::new(
-                    arrform!(20, "Vol: {}", self.status_bar.volume).as_str(),
-                    Point::zero(),
-                    text_style,
-                )),
-            )
-            .arrange()
-            .align_to(&status_bar, horizontal::Center, vertical::Center)
-            .draw(target);
-        }
-    }
-
-    pub struct StatusBar {
-        pub battery: u8,
-        pub backlight: u8,
-        pub volume: u8,
     }
 }

simulator/src/main.rs

@@ -1,20 +0,0 @@
-use embedded_graphics::{pixelcolor::Rgb565, prelude::Size};
-use embedded_graphics_simulator::{
-    BinaryColorTheme, OutputSettingsBuilder, SimulatorDisplay, Window,
-};
-
-use shared::screen::{SCREEN_HEIGHT, SCREEN_WIDTH, UI};
-
-fn main() -> Result<(), core::convert::Infallible> {
-    let mut display =
-        SimulatorDisplay::<Rgb565>::new(Size::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32));
-
-    let mut ui = UI::new();
-
-    ui.draw_status_bar(&mut display);
-
-    let output_settings = OutputSettingsBuilder::new().build();
-    Window::new("Hello World", &output_settings).show_static(&display);
-
-    Ok(())
-}

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
+}