fix font size

.gitignore

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

.helix/languages.toml

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

Cargo.toml

@@ -1,24 +1,10 @@
 [workspace]
 resolver = "3"
-members = [
-  "kernel",
-  "abi",
-  "user-apps/calculator",
-  "user-apps/snake",
-  "user-apps/gallery",
-]
+members = ["pico", "shared", "simulator"]
+
 
 [profile.release]
-debug = true
-opt-level = "z"
-lto = true
-codegen-units = 1
-
-[profile.release-binary]
-inherits = "release"
-lto = true
-debug = false
-opt-level = "s"
+debug = 2
 
 [profile.dev]
 lto = true

README.md

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

abi/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "abi"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-embedded-sdmmc = { version = "0.9.0", default-features = false }
-embedded-graphics = "0.8.1"
-abi_sys = { path = "../abi_sys" }
-talc = "4.4.3"
-spin = "0.10.0"
-rand_core = "0.9.3"

abi/src/lib.rs

@@ -1,147 +0,0 @@
-#![no_std]
-
-pub use abi_sys::keyboard;
-use abi_sys::{RngRequest, keyboard::KeyEvent};
-use rand_core::RngCore;
-use talc::*;
-
-extern crate alloc;
-
-static mut ARENA: [u8; 10000] = [0; 10000];
-
-#[global_allocator]
-static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
-    Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
-        .lock();
-
-pub fn print(msg: &str) {
-    abi_sys::print(msg.as_ptr(), msg.len());
-}
-
-pub fn sleep(ms: u64) {
-    abi_sys::sleep(ms);
-}
-
-pub fn get_key() -> KeyEvent {
-    abi_sys::keyboard::get_key().into()
-}
-
-pub mod display {
-    use abi_sys::CPixel;
-    use embedded_graphics::{
-        Pixel,
-        geometry::{Dimensions, Point},
-        pixelcolor::Rgb565,
-        prelude::{DrawTarget, Size},
-        primitives::Rectangle,
-    };
-
-    pub const SCREEN_WIDTH: usize = 320;
-    pub const SCREEN_HEIGHT: usize = 320;
-
-    pub type Pixel565 = Pixel<Rgb565>;
-
-    pub fn lock_display(lock: bool) {
-        abi_sys::lock_display(lock);
-    }
-
-    const BUF_SIZE: usize = 1024; // tune this for performance
-
-    pub struct Display;
-
-    impl Dimensions for Display {
-        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>>,
-        {
-            let mut buf: [CPixel; BUF_SIZE] = [CPixel::new(); BUF_SIZE];
-
-            let mut count = 0;
-            for p in pixels {
-                buf[count] = p.into();
-                count += 1;
-
-                if count == BUF_SIZE {
-                    abi_sys::draw_iter(buf.as_ptr(), count);
-                    count = 0;
-                }
-            }
-
-            if count > 0 {
-                abi_sys::draw_iter(buf.as_ptr(), count);
-            }
-
-            Ok(())
-        }
-    }
-}
-
-fn gen_rand(req: &mut RngRequest) {
-    abi_sys::gen_rand(req);
-}
-
-pub struct Rng;
-
-impl RngCore for Rng {
-    fn next_u32(&mut self) -> u32 {
-        let mut req = RngRequest::U32(0);
-        gen_rand(&mut req);
-        if let RngRequest::U32(i) = req {
-            return i;
-        };
-        0
-    }
-
-    fn next_u64(&mut self) -> u64 {
-        let mut req = RngRequest::U64(0);
-        gen_rand(&mut req);
-        if let RngRequest::U64(i) = req {
-            return i;
-        };
-        0
-    }
-    fn fill_bytes(&mut self, dst: &mut [u8]) {
-        let mut req = RngRequest::Bytes {
-            ptr: dst.as_mut_ptr(),
-            len: dst.len(),
-        };
-        gen_rand(&mut req);
-    }
-}
-
-pub mod fs {
-    use embedded_sdmmc::DirEntry;
-
-    pub fn read_file(file: &str, read_from: usize, buf: &mut [u8]) -> usize {
-        abi_sys::read_file(
-            file.as_ptr(),
-            file.len(),
-            read_from,
-            buf.as_mut_ptr(),
-            buf.len(),
-        )
-    }
-
-    pub fn list_dir(path: &str, files: &mut [Option<DirEntry>]) -> usize {
-        abi_sys::list_dir(path.as_ptr(), path.len(), files.as_mut_ptr(), files.len())
-    }
-
-    pub fn file_len(str: &str) -> usize {
-        abi_sys::file_len(str.as_ptr(), str.len())
-    }
-}

abi_sys/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "abi_sys"
-version = "0.1.0"
-edition = "2024"
-
-[features]
-default = []
-defmt = ["dep:defmt"]
-
-[dependencies]
-strum = { version = "0.27.2", default-features = false, features = ["derive"] }
-bitflags = "2.9.4"
-embedded-graphics = "0.8.1"
-embedded-sdmmc = { version = "0.9.0", default-features = false }
-defmt = { version = "0.3", optional = true }
-
-[build-dependencies]
-cbindgen = "0.24.0"

abi_sys/src/lib.rs

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

cbindgen.toml

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

justfile

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

kernel/src/abi.rs

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

kernel/src/display.rs

@@ -1,64 +0,0 @@
-use core::sync::atomic::{AtomicBool, Ordering};
-
-use crate::framebuffer::AtomicFrameBuffer;
-use embassy_rp::{
-    Peri,
-    gpio::{Level, Output},
-    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
-    spi::{Async, Spi},
-};
-use embassy_time::{Delay, Timer};
-use embedded_hal_bus::spi::ExclusiveDevice;
-use st7365p_lcd::ST7365P;
-
-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;
-
-pub static mut FRAMEBUFFER: AtomicFrameBuffer = AtomicFrameBuffer::new();
-pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
-
-pub async fn init_display(
-    spi: Spi<'static, SPI1, Async>,
-    cs: Peri<'static, PIN_13>,
-    data: Peri<'static, PIN_14>,
-    reset: Peri<'static, 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.draw(&mut display).await.unwrap() }
-    display.set_on().await.unwrap();
-
-    display
-}
-
-#[embassy_executor::task]
-pub async fn display_handler(mut display: DISPLAY) {
-    loop {
-        if !FB_PAUSED.load(Ordering::Acquire) {
-            unsafe {
-                FRAMEBUFFER
-                    .partial_draw_batched(&mut display)
-                    .await
-                    .unwrap()
-            }
-        }
-
-        Timer::after_millis(10).await;
-    }
-}

kernel/src/elf.rs

@@ -1,277 +0,0 @@
-use crate::{
-    abi,
-    storage::{File, SDCARD},
-};
-use abi_sys::CallAbiTable;
-use abi_sys::EntryFn;
-use alloc::{vec, vec::Vec};
-use bumpalo::Bump;
-use core::ptr;
-use embedded_sdmmc::ShortFileName;
-use goblin::{
-    elf::{
-        header::header32::Header,
-        program_header::program_header32::{PT_LOAD, ProgramHeader},
-        reloc::R_ARM_RELATIVE,
-        section_header::{SHT_REL, SHT_SYMTAB},
-    },
-    elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym},
-};
-use strum::IntoEnumIterator;
-
-const ELF32_HDR_SIZE: usize = 52;
-
-pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> {
-    let mut sd_lock = SDCARD.get().lock().await;
-    let sd = sd_lock.as_mut().unwrap();
-
-    let mut header_buf = [0; ELF32_HDR_SIZE];
-
-    let (entry, bump) = sd
-        .read_file(name, |mut file| {
-            file.read(&mut header_buf).unwrap();
-            let elf_header = Header::from_bytes(&header_buf);
-
-            // reject non-PIE
-            if elf_header.e_type != header::ET_DYN {
-                return None;
-            }
-
-            let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize];
-
-            let (total_size, min_vaddr, _max_vaddr) =
-                total_loadable_size(&mut file, &elf_header, &mut ph_buf);
-
-            let bump = Bump::with_capacity(total_size);
-            let base = bump.alloc_slice_fill_default::<u8>(total_size);
-
-            // load each segment into bump, relative to base_ptr
-            for i in 0..elf_header.e_phnum {
-                file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-                    .unwrap();
-                file.read(&mut ph_buf).unwrap();
-                let ph = cast_phdr(&ph_buf);
-
-                let seg_offset = (ph.p_vaddr - min_vaddr) as usize;
-                let mut segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
-
-                if ph.p_type == PT_LOAD {
-                    load_segment(&mut file, &ph, &mut segment).unwrap();
-                }
-            }
-
-            for i in 0..elf_header.e_shnum {
-                let sh = read_section(&mut file, elf_header, i.into());
-
-                match sh.sh_type {
-                    SHT_REL => {
-                        apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap();
-                    }
-                    _ => {}
-                }
-            }
-
-            patch_abi(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap();
-
-            // entry pointer is base_ptr + (entry - min_vaddr)
-            let entry_ptr: EntryFn = unsafe {
-                core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize))
-            };
-
-            Some((entry_ptr, bump))
-        })
-        .await
-        .expect("Failed to read file")?;
-
-    Some((entry, bump))
-}
-
-fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), ()> {
-    let filesz = ph.p_filesz as usize;
-    let memsz = ph.p_memsz as usize;
-
-    // read file contents
-    let mut remaining = filesz;
-    let mut dst_offset = 0;
-    let mut file_offset = ph.p_offset;
-    let mut buf = [0u8; 512];
-
-    while remaining > 0 {
-        let to_read = core::cmp::min(remaining, buf.len());
-        file.seek_from_start(file_offset).unwrap();
-        file.read(&mut buf[..to_read]).unwrap();
-
-        segment[dst_offset..dst_offset + to_read].copy_from_slice(&buf[..to_read]);
-
-        remaining -= to_read;
-        dst_offset += to_read;
-        file_offset += to_read as u32;
-    }
-
-    // zero BSS if needed
-    if memsz > filesz {
-        segment[filesz..].fill(0);
-    }
-
-    Ok(())
-}
-
-fn apply_relocations(
-    sh: &SectionHeader,
-    min_vaddr: u32,
-    base: *mut u8,
-    file: &mut File,
-) -> Result<(), ()> {
-    let mut reloc = [0_u8; 8];
-
-    let num_relocs = sh.sh_size as usize / sh.sh_entsize as usize;
-
-    for i in 0..num_relocs {
-        file.seek_from_start(sh.sh_offset + (i as u32 * 8)).unwrap();
-        file.read(&mut reloc).unwrap();
-
-        let rel = cast_rel(&reloc);
-
-        let reloc_type = rel.r_info & 0xff;
-        let reloc_addr = unsafe { base.add((rel.r_offset - min_vaddr) as usize) as *mut u32 };
-
-        match reloc_type {
-            R_ARM_RELATIVE => {
-                // REL: add base to the word already stored there
-                unsafe {
-                    let val = ptr::read_unaligned(reloc_addr);
-                    ptr::write_unaligned(reloc_addr, val.wrapping_add(base as u32));
-                }
-            }
-            _ => {
-                return Err(());
-            }
-        }
-    }
-    Ok(())
-}
-
-fn patch_abi(
-    elf_header: &Header,
-    base: *mut u8,
-    min_vaddr: u32,
-    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 =
-                        unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) }
-                            as *mut usize;
-
-                    for (idx, call) in CallAbiTable::iter().enumerate() {
-                        let ptr = match call {
-                            CallAbiTable::PrintString => abi::print as usize,
-                            CallAbiTable::SleepMs => abi::sleep as usize,
-                            CallAbiTable::GetMs => abi::get_ms as usize,
-                            CallAbiTable::LockDisplay => abi::lock_display as usize,
-                            CallAbiTable::DrawIter => abi::draw_iter as usize,
-                            CallAbiTable::GetKey => abi::get_key as usize,
-                            CallAbiTable::GenRand => abi::gen_rand as usize,
-                            CallAbiTable::ListDir => abi::list_dir as usize,
-                            CallAbiTable::ReadFile => abi::read_file as usize,
-                            CallAbiTable::FileLen => abi::file_len as usize,
-                        };
-                        unsafe {
-                            table_base.add(idx as usize).write(ptr);
-                        }
-                    }
-                    return Ok(());
-                }
-            }
-        }
-    }
-    Err(())
-}
-
-fn total_loadable_size(
-    file: &mut File,
-    elf_header: &Header,
-    ph_buf: &mut [u8],
-) -> (usize, u32, u32) {
-    let mut min_vaddr = u32::MAX;
-    let mut max_vaddr = 0u32;
-    for i in 0..elf_header.e_phnum {
-        file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-            .unwrap();
-        file.read(ph_buf).unwrap();
-        let ph = cast_phdr(&ph_buf);
-
-        if ph.p_type == PT_LOAD {
-            if ph.p_vaddr < min_vaddr {
-                min_vaddr = ph.p_vaddr;
-            }
-            if ph.p_vaddr + ph.p_memsz > max_vaddr {
-                max_vaddr = ph.p_vaddr + ph.p_memsz;
-            }
-        }
-    }
-
-    let total_size = (max_vaddr - min_vaddr) as usize;
-    (total_size, min_vaddr, max_vaddr)
-}
-
-fn read_section(file: &mut File, elf_header: &Header, section: u32) -> SectionHeader {
-    let mut sh_buf = vec![0_u8; elf_header.e_shentsize as usize];
-
-    file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
-        .unwrap();
-    file.read(&mut sh_buf).unwrap();
-
-    cast_shdr(&sh_buf)
-}
-
-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) }
-}
-
-fn cast_rel(buf: &[u8]) -> Rel {
-    assert!(buf.len() >= core::mem::size_of::<Rel>());
-    unsafe { core::ptr::read(buf.as_ptr() as *const Rel) }
-}

kernel/src/framebuffer.rs

@@ -1,367 +0,0 @@
-use crate::display::{SCREEN_HEIGHT, SCREEN_WIDTH};
-use core::sync::atomic::{AtomicBool, Ordering};
-use embassy_sync::lazy_lock::LazyLock;
-use embedded_graphics::{
-    draw_target::DrawTarget,
-    pixelcolor::{
-        Rgb565,
-        raw::{RawData, RawU16},
-    },
-    prelude::*,
-    primitives::Rectangle,
-};
-use embedded_hal_2::digital::OutputPin;
-use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
-use heapless::Vec;
-use st7365p_lcd::ST7365P;
-
-pub const TILE_SIZE: usize = 16; // 16x16 tile
-pub const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
-
-// Group of tiles for batching
-pub const MAX_META_TILES: usize = SCREEN_WIDTH / TILE_SIZE; // max number of meta tiles in buffer
-type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
-
-const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
-
-static mut BUFFER: [u16; SIZE] = [0; SIZE];
-
-static mut DIRTY_TILES: LazyLock<heapless::Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
-    let mut tiles = Vec::new();
-    for _ in 0..TILE_COUNT {
-        tiles.push(AtomicBool::new(true)).unwrap();
-    }
-    tiles
-});
-
-#[allow(dead_code)]
-pub struct AtomicFrameBuffer;
-
-impl AtomicFrameBuffer {
-    pub const fn new() -> Self {
-        Self
-    }
-
-    fn mark_tiles_dirty(&mut self, rect: Rectangle) {
-        let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
-        let start_tx = (rect.top_left.x as usize) / TILE_SIZE;
-        let end_tx = ((rect.top_left.x + rect.size.width as i32 - 1) as usize) / TILE_SIZE;
-        let start_ty = (rect.top_left.y as usize) / TILE_SIZE;
-        let end_ty = ((rect.top_left.y + rect.size.height as i32 - 1) as usize) / TILE_SIZE;
-
-        for ty in start_ty..=end_ty {
-            for tx in start_tx..=end_tx {
-                let tile_idx = ty * tiles_x + tx;
-                unsafe { DIRTY_TILES.get_mut()[tile_idx].store(true, Ordering::Relaxed) };
-            }
-        }
-    }
-
-    fn set_pixel(&mut self, x: u16, y: u16, color: u16) -> Result<(), ()> {
-        unsafe { BUFFER[(y as usize * SCREEN_WIDTH) + x as usize] = color };
-
-        Ok(())
-    }
-
-    fn set_pixels_buffered<P: IntoIterator<Item = u16>>(
-        &mut self,
-        sx: u16,
-        sy: u16,
-        ex: u16,
-        ey: u16,
-        colors: P,
-    ) -> Result<(), ()> {
-        if sx >= self.size().width as u16
-            || ex >= self.size().width as u16
-            || sy >= self.size().height as u16
-            || ey >= self.size().height as u16
-        {
-            return Err(()); // Bounds check
-        }
-
-        let mut color_iter = colors.into_iter();
-
-        for y in sy..=ey {
-            for x in sx..=ex {
-                if let Some(color) = color_iter.next() {
-                    unsafe { BUFFER[(y as usize * SCREEN_WIDTH) + x as usize] = color };
-                } else {
-                    return Err(()); // Not enough data
-                }
-            }
-        }
-
-        // Optional: check that we consumed *exactly* the right amount
-        if color_iter.next().is_some() {
-            return Err(()); // Too much data
-        }
-
-        Ok(())
-    }
-
-    // walk the dirty tiles and mark groups of tiles(meta-tiles) for batched updates
-    fn find_meta_tiles(&mut self, tiles_x: usize, tiles_y: usize) -> MetaTileVec {
-        let mut meta_tiles: MetaTileVec = heapless::Vec::new();
-
-        for ty in 0..tiles_y {
-            let mut tx = 0;
-            while tx < tiles_x {
-                let idx = ty * tiles_x + tx;
-                if !unsafe { DIRTY_TILES.get()[idx].load(Ordering::Acquire) } {
-                    tx += 1;
-                    continue;
-                }
-
-                // Start meta-tile at this tile
-                let mut width_tiles = 1;
-                let height_tiles = 1;
-
-                // Grow horizontally, but keep under MAX_TILES_PER_METATILE
-                while tx + width_tiles < tiles_x
-                    && unsafe {
-                        DIRTY_TILES.get()[ty * tiles_x + tx + width_tiles].load(Ordering::Relaxed)
-                    }
-                    && (width_tiles + height_tiles) <= MAX_META_TILES
-                {
-                    width_tiles += 1;
-                }
-
-                // TODO: for simplicity, skipped vertical growth
-
-                for x_off in 0..width_tiles {
-                    unsafe {
-                        DIRTY_TILES.get()[ty * tiles_x + tx + x_off]
-                            .store(false, Ordering::Release);
-                    };
-                }
-
-                // new meta-tile pos
-                let rect = Rectangle::new(
-                    Point::new((tx * TILE_SIZE) as i32, (ty * TILE_SIZE) as i32),
-                    Size::new(
-                        (width_tiles * TILE_SIZE) as u32,
-                        (height_tiles * TILE_SIZE) as u32,
-                    ),
-                );
-
-                if meta_tiles.push(rect).is_err() {
-                    return meta_tiles;
-                };
-
-                tx += width_tiles;
-            }
-        }
-
-        meta_tiles
-    }
-
-    /// Sends the entire framebuffer to the display
-    pub async fn draw<SPI, DC, RST, DELAY: DelayNs>(
-        &mut self,
-        display: &mut ST7365P<SPI, DC, RST, DELAY>,
-    ) -> Result<(), ()>
-    where
-        SPI: SpiDevice,
-        DC: OutputPin,
-        RST: OutputPin,
-    {
-        display
-            .set_pixels_buffered(
-                0,
-                0,
-                self.size().width as u16 - 1,
-                self.size().height as u16 - 1,
-                unsafe { &BUFFER },
-            )
-            .await?;
-
-        unsafe {
-            for tile in DIRTY_TILES.get_mut().iter() {
-                tile.store(false, Ordering::Release);
-            }
-        };
-
-        Ok(())
-    }
-
-    /// Sends only dirty tiles (16x16px) in batches to the display
-    pub async fn partial_draw_batched<SPI, DC, RST, DELAY>(
-        &mut self,
-        display: &mut ST7365P<SPI, DC, RST, DELAY>,
-    ) -> Result<(), ()>
-    where
-        SPI: SpiDevice,
-        DC: OutputPin,
-        RST: OutputPin,
-        DELAY: DelayNs,
-    {
-        if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
-            let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
-            let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
-
-            let meta_tiles = self.find_meta_tiles(tiles_x, tiles_y);
-
-            // buffer for copying meta tiles before sending to display
-            let mut pixel_buffer: heapless::Vec<u16, { MAX_META_TILES * TILE_SIZE * TILE_SIZE }> =
-                Vec::new();
-
-            for rect in meta_tiles {
-                let rect_width = rect.size.width as usize;
-                let rect_height = rect.size.height as usize;
-                let rect_x = rect.top_left.x as usize;
-                let rect_y = rect.top_left.y as usize;
-
-                pixel_buffer.clear();
-
-                for row in 0..rect_height {
-                    let y = rect_y + row;
-                    let start = y * SCREEN_WIDTH + rect_x;
-                    let end = start + rect_width;
-
-                    // Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
-                    pixel_buffer
-                        .extend_from_slice(unsafe { &BUFFER[start..end] })
-                        .unwrap();
-                }
-
-                display
-                    .set_pixels_buffered(
-                        rect_x as u16,
-                        rect_y as u16,
-                        (rect_x + rect_width - 1) as u16,
-                        (rect_y + rect_height - 1) as u16,
-                        &pixel_buffer,
-                    )
-                    .await?;
-
-                // walk the meta-tile and set as clean
-                let start_tx = rect_x / TILE_SIZE;
-                let start_ty = rect_y / TILE_SIZE;
-                let end_tx = (rect_x + rect_width - 1) / TILE_SIZE;
-                let end_ty = (rect_y + rect_height - 1) / TILE_SIZE;
-
-                for ty in start_ty..=end_ty {
-                    for tx in start_tx..=end_tx {
-                        let tile_idx = ty * tiles_x + tx;
-                        unsafe { DIRTY_TILES.get_mut()[tile_idx].store(false, Ordering::Release) };
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl DrawTarget for AtomicFrameBuffer {
-    type Error = ();
-    type Color = Rgb565;
-
-    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
-    where
-        I: IntoIterator<Item = Pixel<Self::Color>>,
-    {
-        let mut dirty_rect: Option<Rectangle> = None;
-
-        for Pixel(coord, color) in pixels {
-            if coord.x >= 0 && coord.y >= 0 {
-                let x = coord.x as i32;
-                let y = coord.y as i32;
-
-                if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
-                    unsafe {
-                        BUFFER[(y as usize) * SCREEN_WIDTH + (x as usize)] =
-                            RawU16::from(color).into_inner()
-                    };
-
-                    if let Some(ref mut rect) = dirty_rect {
-                        rect.top_left.x = rect.top_left.x.min(x);
-                        rect.top_left.y = rect.top_left.y.min(y);
-                        let max_x = (rect.top_left.x + rect.size.width as i32 - 1).max(x);
-                        let max_y = (rect.top_left.y + rect.size.height as i32 - 1).max(y);
-                        rect.size.width = (max_x - rect.top_left.x + 1) as u32;
-                        rect.size.height = (max_y - rect.top_left.y + 1) as u32;
-                    } else {
-                        dirty_rect = Some(Rectangle::new(Point::new(x, y), Size::new(1, 1)));
-                    }
-                }
-            }
-        }
-
-        if let Some(rect) = dirty_rect {
-            self.mark_tiles_dirty(rect);
-        }
-
-        Ok(())
-    }
-
-    fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
-    where
-        I: IntoIterator<Item = Self::Color>,
-    {
-        let drawable_area = area.intersection(&Rectangle::new(Point::zero(), self.size()));
-
-        if drawable_area.size != Size::zero() {
-            // We assume that `colors` iterator is in row-major order for the original `area`
-            // So we must skip rows/pixels that are clipped
-            let area_width = area.size.width;
-            let area_height = area.size.height;
-            let mut colors = colors.into_iter();
-
-            for y in 0..area_height {
-                for x in 0..area_width {
-                    let p = area.top_left + Point::new(x as i32, y as i32);
-
-                    if drawable_area.contains(p) {
-                        if let Some(color) = colors.next() {
-                            self.set_pixel(
-                                p.x as u16,
-                                p.y as u16,
-                                RawU16::from(color).into_inner(),
-                            )?;
-                        } else {
-                            break;
-                        }
-                    } else {
-                        // Still need to consume the color even if not used!
-                        let _ = colors.next();
-                    }
-                }
-            }
-
-            self.mark_tiles_dirty(*area);
-        }
-
-        Ok(())
-    }
-
-    fn fill_solid(&mut self, area: &Rectangle, color: Self::Color) -> Result<(), Self::Error> {
-        self.fill_contiguous(
-            area,
-            core::iter::repeat(color).take((self.size().width * self.size().height) as usize),
-        )
-    }
-
-    fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
-        self.set_pixels_buffered(
-            0,
-            0,
-            self.size().width as u16 - 1,
-            self.size().height as u16 - 1,
-            core::iter::repeat(RawU16::from(color).into_inner())
-                .take((self.size().width * self.size().height) as usize),
-        )?;
-
-        for tile in unsafe { DIRTY_TILES.get_mut() }.iter() {
-            tile.store(true, Ordering::Release);
-        }
-
-        Ok(())
-    }
-}
-
-impl OriginDimensions for AtomicFrameBuffer {
-    fn size(&self) -> Size {
-        Size::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32)
-    }
-}

kernel/src/main.rs

@@ -1,320 +0,0 @@
-#![feature(impl_trait_in_assoc_type)]
-#![feature(str_from_raw_parts)]
-#![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 framebuffer;
-mod peripherals;
-mod psram;
-mod scsi;
-mod storage;
-mod ui;
-mod usb;
-mod utils;
-
-use crate::{
-    abi::{KEY_CACHE, MS_SINCE_LAUNCH},
-    display::{FRAMEBUFFER, display_handler, init_display},
-    peripherals::{
-        conf_peripherals,
-        keyboard::{KeyState, read_keyboard_fifo},
-    },
-    psram::init_psram,
-    scsi::MSC_SHUTDOWN,
-    storage::{SDCARD, SdCard},
-    ui::{SELECTIONS, clear_selection, ui_handler},
-};
-use abi_sys::EntryFn;
-use bumpalo::Bump;
-use embedded_graphics::{
-    pixelcolor::Rgb565,
-    prelude::{DrawTarget, RgbColor},
-};
-
-use {defmt_rtt as _, panic_probe as _};
-
-use core::sync::atomic::{AtomicBool, Ordering};
-use defmt::unwrap;
-use embassy_executor::{Executor, Spawner};
-use embassy_futures::{join::join, select::select};
-use embassy_rp::{
-    Peri,
-    gpio::{Input, Level, Output, Pull},
-    i2c::{self, I2c},
-    multicore::{Stack, spawn_core1},
-    peripherals::{
-        DMA_CH0, DMA_CH1, DMA_CH3, DMA_CH4, I2C1, PIN_2, PIN_3, 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_20, PIN_21, PIN_22,
-        PIO0, SPI0, SPI1, USB,
-    },
-    pio,
-    spi::{self, Spi},
-    usb as embassy_rp_usb,
-};
-use embassy_sync::{
-    blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, signal::Signal,
-};
-use embassy_time::{Delay, Instant, Timer};
-use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::SdCard as SdmmcSdCard;
-use static_cell::StaticCell;
-use talc::*;
-
-embassy_rp::bind_interrupts!(struct Irqs {
-    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
-    USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
-    PIO0_IRQ_0 => pio::InterruptHandler<PIO0>;
-});
-
-static mut CORE1_STACK: Stack<16384> = Stack::new();
-static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
-static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
-
-static mut ARENA: [u8; 200 * 1024] = [0; 200 * 1024];
-
-#[global_allocator]
-static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
-    Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
-        .lock();
-
-static ENABLE_UI: AtomicBool = AtomicBool::new(true);
-static UI_CHANGE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
-
-#[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 psram = Psram {
-        pio: p.PIO0,
-        sclk: p.PIN_21,
-        mosi: p.PIN_2,
-        miso: p.PIN_3,
-        cs: p.PIN_20,
-        dma1: p.DMA_CH3,
-        dma2: p.DMA_CH4,
-    };
-    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(spawner, display, sd, psram, mcu, p.USB)))
-    });
-}
-
-// One-slot channel to pass EntryFn from core1
-static BINARY_CH: Channel<CriticalSectionRawMutex, (EntryFn, Bump), 1> = Channel::new();
-
-// runs dynamically loaded elf files
-#[embassy_executor::task]
-async fn userland_task() {
-    let recv = BINARY_CH.receiver();
-    loop {
-        let (entry, _bump) = recv.receive().await;
-
-        // disable kernel ui
-        {
-            ENABLE_UI.store(false, Ordering::Release);
-            UI_CHANGE.signal(());
-
-            clear_selection().await;
-
-            MSC_SHUTDOWN.signal(());
-        }
-
-        unsafe { MS_SINCE_LAUNCH = Some(Instant::now()) };
-        defmt::info!("Executing Binary");
-        entry();
-
-        // enable kernel ui
-        {
-            ENABLE_UI.store(true, Ordering::Release);
-            UI_CHANGE.signal(());
-            unsafe { FRAMEBUFFER.clear(Rgb565::BLACK).unwrap() };
-
-            let mut selections = SELECTIONS.lock().await;
-            selections.set_changed(true);
-        }
-    }
-}
-
-struct Display {
-    spi: Peri<'static, SPI1>,
-    clk: Peri<'static, PIN_10>,
-    mosi: Peri<'static, PIN_11>,
-    miso: Peri<'static, PIN_12>,
-    dma1: Peri<'static, DMA_CH0>,
-    dma2: Peri<'static, DMA_CH1>,
-    cs: Peri<'static, PIN_13>,
-    data: Peri<'static, PIN_14>,
-    reset: Peri<'static, PIN_15>,
-}
-struct Sd {
-    spi: Peri<'static, SPI0>,
-    clk: Peri<'static, PIN_18>,
-    mosi: Peri<'static, PIN_19>,
-    miso: Peri<'static, PIN_16>,
-    cs: Peri<'static, PIN_17>,
-    det: Peri<'static, PIN_22>,
-}
-struct Psram {
-    pio: Peri<'static, PIO0>,
-    sclk: Peri<'static, PIN_21>,
-    mosi: Peri<'static, PIN_2>,
-    miso: Peri<'static, PIN_3>,
-    cs: Peri<'static, PIN_20>,
-    dma1: Peri<'static, DMA_CH3>,
-    dma2: Peri<'static, DMA_CH4>,
-}
-struct Mcu {
-    i2c: Peri<'static, I2C1>,
-    clk: Peri<'static, PIN_7>,
-    data: Peri<'static, PIN_6>,
-}
-
-async fn setup_mcu(mcu: Mcu) {
-    // MCU i2c bus for peripherals( keyboard)
-    let mut config = i2c::Config::default();
-    config.frequency = 400_000;
-    let i2c1 = I2c::new_async(mcu.i2c, mcu.clk, mcu.data, Irqs, config);
-    conf_peripherals(i2c1).await;
-}
-
-async fn setup_display(display: Display, spawner: Spawner) {
-    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;
-    spawner.spawn(display_handler(display)).unwrap();
-}
-
-async fn setup_psram(psram: Psram) {
-    let psram = init_psram(
-        psram.pio, psram.sclk, psram.mosi, psram.miso, psram.cs, psram.dma1, psram.dma2,
-    )
-    .await;
-
-    defmt::info!("psram size: {}", psram.size);
-
-    if psram.size == 0 {
-        defmt::info!("\u{1b}[1mExternal PSRAM was NOT found!\u{1b}[0m");
-    }
-}
-
-async fn setup_sd(sd: Sd) {
-    let mut config = spi::Config::default();
-    config.frequency = 400_000;
-    let spi = Spi::new_blocking(sd.spi, sd.clk, sd.mosi, sd.miso, config.clone());
-    let cs = Output::new(sd.cs, Level::High);
-    let det = Input::new(sd.det, Pull::None);
-
-    let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
-    let sdcard = SdmmcSdCard::new(device, Delay);
-
-    config.frequency = 32_000_000;
-    sdcard.spi(|dev| dev.bus_mut().set_config(&config));
-    SDCARD.get().lock().await.replace(SdCard::new(sdcard, det));
-}
-
-#[embassy_executor::task]
-async fn kernel_task(
-    spawner: Spawner,
-    display: Display,
-    sd: Sd,
-    psram: Psram,
-    mcu: Mcu,
-    usb: Peri<'static, USB>,
-) {
-    setup_mcu(mcu).await;
-    Timer::after_millis(250).await;
-    setup_display(display, spawner).await;
-    setup_psram(psram).await;
-    setup_sd(sd).await;
-
-    let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
-    // spawner.spawn(usb_handler(usb)).unwrap();
-
-    loop {
-        let ui_enabled = ENABLE_UI.load(Ordering::Relaxed);
-        if ui_enabled {
-            select(join(ui_handler(), prog_search_handler()), UI_CHANGE.wait()).await;
-        } else {
-            select(key_handler(), UI_CHANGE.wait()).await;
-        }
-    }
-}
-
-async fn prog_search_handler() {
-    loop {
-        {
-            let mut guard = SDCARD.get().lock().await;
-            let sd = guard.as_mut().unwrap();
-
-            let files = sd.list_files_by_extension(".bin").unwrap();
-            let mut select = SELECTIONS.lock().await;
-
-            if *select.selections() != files {
-                select.update_selections(files);
-                select.reset();
-            }
-        }
-        Timer::after_secs(5).await;
-    }
-}
-
-async fn key_handler() {
-    loop {
-        if let Some(event) = read_keyboard_fifo().await {
-            if let KeyState::Pressed = event.state {
-                unsafe {
-                    let _ = KEY_CACHE.enqueue(event);
-                }
-            }
-        }
-        Timer::after_millis(50).await;
-    }
-}

kernel/src/peripherals/keyboard.rs

@@ -1,59 +0,0 @@
-use crate::peripherals::PERIPHERAL_BUS;
-pub use abi_sys::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/psram.rs

@@ -1,385 +0,0 @@
-// This whole file was taken from
-// <https://github.com/wezterm/picocalc-wezterm/blob/8dcf8aae0598afdeaf0ed2ba50c39dea6e30c011/src/psram.rs>
-//
-use crate::Irqs;
-use embassy_futures::yield_now;
-use embassy_rp::Peri;
-use embassy_rp::gpio::{Drive, SlewRate};
-use embassy_rp::peripherals::{DMA_CH3, DMA_CH4, PIN_2, PIN_3, PIN_20, PIN_21, PIO0};
-use embassy_rp::pio::program::pio_asm;
-use embassy_rp::pio::{Config, Direction, Pio, ShiftDirection};
-use embassy_rp::pio_programs::clock_divider::calculate_pio_clock_divider;
-use embassy_time::{Duration, Instant, Timer};
-
-// The physical connections in the picocalc schematic are:
-// LABEL     PICO      ESP-PSRAM64H
-// RAM_CS  - PIN_20    CE                    (pulled up to 3v3 via 10kOhm)
-// RAM_SCK - PIN_21    SCLK
-// RAM_TX  - PIN_2     SI/SIO0
-// RAM_RX  - PIN_3     SO/SIO1
-// RAM_IO2 - PIN_4     SIO2     (QPI Mode)
-// RAM_IO3 - PIN_5     SIO3     (QPI Mode)
-
-#[allow(unused)]
-const PSRAM_CMD_READ_ID: u8 = 0x9F;
-const PSRAM_CMD_RSTEN: u8 = 0x66;
-const PSRAM_CMD_RST: u8 = 0x99;
-const PSRAM_CMD_WRITE: u8 = 0x02;
-const PSRAM_CMD_FAST_READ: u8 = 0x0B;
-#[allow(unused)]
-const PSRAM_CMD_NOOP: u8 = 0xFF;
-#[allow(unused)]
-const PSRAM_KNOWN_GOOD_DIE_PASS: u8 = 0x5d;
-
-const SPEED: u32 = 133_000_000;
-
-pub struct PsRam {
-    sm: embassy_rp::pio::StateMachine<'static, PIO0, 0>,
-    tx_ch: Peri<'static, DMA_CH3>,
-    rx_ch: Peri<'static, DMA_CH4>,
-    pub size: u32,
-}
-
-impl PsRam {
-    pub async fn send_command(&mut self, cmd: &[u8], out: &mut [u8]) {
-        if out.is_empty() {
-            self.sm
-                .tx()
-                .dma_push(self.tx_ch.reborrow(), cmd, false)
-                .await;
-        } else {
-            let (rx, tx) = self.sm.rx_tx();
-            tx.dma_push(self.tx_ch.reborrow(), cmd, false).await;
-            rx.dma_pull(self.rx_ch.reborrow(), out, false).await;
-        }
-    }
-
-    pub async fn write(&mut self, mut addr: u32, mut data: &[u8]) {
-        // I haven't seen this work reliably over 24 bytes
-        const MAX_CHUNK: usize = 24;
-        while data.len() > 0 {
-            let to_write = data.len().min(MAX_CHUNK);
-            //defmt::info!("writing {to_write} @ {addr}");
-
-            #[rustfmt::skip]
-            let mut to_send = [
-                32 + (to_write as u8 * 8), // write address + data
-                0,                         // read 0 bits
-                PSRAM_CMD_WRITE,
-                ((addr >> 16) & 0xff) as u8,
-                ((addr >> 8) & 0xff) as u8,
-                (addr & 0xff) as u8,
-                // This sequence must be MAX_CHUNK in length
-                0, 0, 0, 0,
-                0, 0, 0, 0,
-                0, 0, 0, 0,
-                0, 0, 0, 0,
-                0, 0, 0, 0,
-                0, 0, 0, 0,
-            ];
-
-            for (src, dst) in data.iter().zip(to_send.iter_mut().skip(6)) {
-                *dst = *src;
-            }
-
-            self.send_command(&to_send[0..6 + to_write], &mut []).await;
-            addr += to_write as u32;
-            data = &data[to_write..];
-        }
-    }
-
-    pub async fn read_id(&mut self) -> [u8; 3] {
-        let mut id = [0u8; 3];
-        #[rustfmt::skip]
-        self.send_command(
-            &[
-                32,    // write 32 bits
-                3 * 8, // read 8 bytes = 64 bits
-                PSRAM_CMD_READ_ID,
-                // don't care: 24-bit "address"
-                0, 0, 0,
-            ],
-            &mut id,
-        )
-        .await;
-        id
-    }
-
-    pub async fn read(&mut self, mut addr: u32, mut out: &mut [u8]) {
-        // Cannot get reliable reads above 4 bytes at a time.
-        // out[4] will always have a bit error
-        const MAX_CHUNK: usize = 4;
-        while out.len() > 0 {
-            let to_read = out.len().min(MAX_CHUNK);
-            //defmt::info!("reading {to_read} @ {addr}");
-            self.send_command(
-                &[
-                    40,                // write 40 bits
-                    to_read as u8 * 8, // read n bytes
-                    PSRAM_CMD_FAST_READ,
-                    ((addr >> 16) & 0xff) as u8,
-                    ((addr >> 8) & 0xff) as u8,
-                    (addr & 0xff) as u8,
-                    0, // 8 cycle delay by sending 8 bits of don't care data
-                ],
-                &mut out[0..to_read],
-            )
-            .await;
-            addr += to_read as u32;
-            out = &mut out[to_read..];
-        }
-    }
-
-    #[allow(unused)]
-    pub async fn write8(&mut self, addr: u32, data: u8) {
-        //defmt::info!("write8 addr {addr} <- {data:x}");
-        self.send_command(
-            &[
-                40, // write 40 bits
-                0,  // read 0 bits
-                PSRAM_CMD_WRITE,
-                ((addr >> 16) & 0xff) as u8,
-                ((addr >> 8) & 0xff) as u8,
-                (addr & 0xff) as u8,
-                data,
-            ],
-            &mut [],
-        )
-        .await;
-    }
-
-    #[allow(unused)]
-    pub async fn read8(&mut self, addr: u32) -> u8 {
-        let mut buf = [0u8];
-        self.send_command(
-            &[
-                40, // write 40 bits
-                8,  // read 8 bits
-                PSRAM_CMD_FAST_READ,
-                ((addr >> 16) & 0xff) as u8,
-                ((addr >> 8) & 0xff) as u8,
-                (addr & 0xff) as u8,
-                0, // 8 cycle delay
-            ],
-            &mut buf,
-        )
-        .await;
-        buf[0]
-    }
-}
-
-pub async fn init_psram(
-    pio: Peri<'static, PIO0>,
-    sclk: Peri<'static, PIN_21>,
-    mosi: Peri<'static, PIN_2>,
-    miso: Peri<'static, PIN_3>,
-    cs: Peri<'static, PIN_20>,
-    dma1: Peri<'static, DMA_CH3>,
-    dma2: Peri<'static, DMA_CH4>,
-) -> PsRam {
-    let mut pio = Pio::new(pio, Irqs);
-
-    let divider = calculate_pio_clock_divider(SPEED);
-
-    // This pio program was taken from
-    // <https://github.com/polpo/rp2040-psram/blob/7786c93ec8d02dbb4f94a2e99645b25fb4abc2db/psram_spi.pio>
-    // which is Copyright © 2023 Ian Scott, reproduced here under the MIT license
-
-    let p = pio_asm!(
-        r#"
-.side_set 2                        ; sideset bit 1 is SCK, bit 0 is CS
-begin:
-    out x, 8            side 0b01  ; x = number of bits to output. CS deasserted
-    out y, 8            side 0b01  ; y = number of bits to input
-    jmp x--, writeloop  side 0b01  ; Pre-decement x by 1 so loop has correct number of iterations
-writeloop:
-    out pins, 1         side 0b00  ; Write value on pin, lower clock. CS asserted
-    jmp x--, writeloop  side 0b10  ; Raise clock: this is when PSRAM reads the value. Loop if we have more to write
-    jmp !y,  done       side 0b00  ; If this is a write-only operation, jump back to beginning
-    nop                 side 0b10  ; Fudge factor of extra clock cycle; the PSRAM needs 1 extra for output to start appearing
-    jmp readloop_mid    side 0b00  ; Jump to middle of readloop to decrement y and get right clock phase
-readloop:
-    in pins, 1          side 0b00  ; Read value on pin, lower clock. Datasheet says to read on falling edge > 83MHz
-readloop_mid:
-    jmp y--, readloop   side 0b10  ; Raise clock. Loop if we have more to read
-done:
-    nop                 side 0b11  ; CS deasserted
-    "#
-    );
-    let prog = pio.common.load_program(&p.program);
-
-    let mut cfg = Config::default();
-
-    let mut cs = pio.common.make_pio_pin(cs);
-    let mut sclk = pio.common.make_pio_pin(sclk);
-    let mut mosi = pio.common.make_pio_pin(mosi);
-    let mut miso = pio.common.make_pio_pin(miso);
-
-    sclk.set_slew_rate(SlewRate::Fast);
-    mosi.set_slew_rate(SlewRate::Fast);
-
-    cs.set_drive_strength(Drive::_4mA);
-    sclk.set_drive_strength(Drive::_4mA);
-    mosi.set_drive_strength(Drive::_4mA);
-    miso.set_drive_strength(Drive::_4mA);
-
-    cfg.use_program(&prog, &[&cs, &sclk]);
-    cfg.set_out_pins(&[&mosi]);
-    cfg.set_in_pins(&[&miso]);
-
-    cfg.shift_out.direction = ShiftDirection::Left;
-    cfg.shift_out.auto_fill = true;
-    cfg.shift_out.threshold = 8;
-
-    cfg.shift_in = cfg.shift_out;
-    cfg.clock_divider = divider;
-
-    let mut sm = pio.sm0;
-    sm.restart();
-    sm.set_pin_dirs(Direction::Out, &[&cs, &sclk]);
-    sm.set_pin_dirs(Direction::Out, &[&mosi]);
-    sm.set_pin_dirs(Direction::In, &[&miso]);
-    miso.set_input_sync_bypass(true);
-
-    sm.set_config(&cfg);
-    sm.set_enable(true);
-
-    let mut psram = PsRam {
-        sm,
-        tx_ch: dma1,
-        rx_ch: dma2,
-        size: 0,
-    };
-
-    // Issue a reset command
-    psram.send_command(&[8, 0, PSRAM_CMD_RSTEN], &mut []).await;
-    Timer::after(Duration::from_micros(50)).await;
-    psram.send_command(&[8, 0, PSRAM_CMD_RST], &mut []).await;
-    Timer::after(Duration::from_micros(100)).await;
-
-    defmt::info!("Verifying 1 byte write and read...");
-    for i in 0..10u8 {
-        psram.write8(i as u32, i).await;
-    }
-    for i in 0..10u32 {
-        let n = psram.read8(i as u32).await;
-        if n as u32 != i {}
-    }
-    defmt::info!("testing read again @ 0");
-    let mut got = [0u8; 8];
-    psram.read(0, &mut got).await;
-    const EXPECT: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7];
-    if got != EXPECT {
-        defmt::warn!("Got Read error");
-    }
-
-    const DEADBEEF: &[u8] = &[0xd, 0xe, 0xa, 0xd, 0xb, 0xe, 0xe, 0xf];
-    defmt::info!("testing write of deadbeef at 0");
-    psram.write(0, DEADBEEF).await;
-
-    defmt::info!("testing read of deadbeef from 0");
-    psram.read(0, &mut got).await;
-    if got != DEADBEEF {
-        for addr in 0..DEADBEEF.len() {
-            let bad = got[addr];
-            if bad != DEADBEEF[addr] {
-                let x = psram.read8(addr as u32).await;
-                defmt::info!("read addr: {}, got: {:X}", addr, x);
-            }
-        }
-    }
-
-    const TEST_STRING: &[u8] = b"hello there, this is a test, how is it?";
-    psram.write(16, TEST_STRING).await;
-
-    let mut buffer = [0u8; 42];
-    psram.read(16, &mut buffer).await;
-
-    let got = &buffer[0..TEST_STRING.len()];
-
-    if got != TEST_STRING {}
-
-    defmt::info!("PSRAM test complete");
-
-    let id = psram.read_id().await;
-    defmt::info!("psram id: {}", id);
-    // id: [d, 5d, 53, 15, 49, e3, 7c, 7b]
-    // id[0] -- manufacturer id
-    // id[1] -- "known good die" status
-    if id[1] == PSRAM_KNOWN_GOOD_DIE_PASS {
-        // See <https://github.com/espressif/esp-idf/blob/1c468f68259065ef51afd114605d9122f13d9d72/components/esp_psram/esp32/esp_psram_impl_quad.c#L67-L86>
-        // for information on deciding the size of ESP PSRAM chips,
-        // such as the one used in the picocalc
-        let size = match (id[2] >> 5) & 0x7 {
-            0 => 16,
-            1 => 32,
-            2 => 64,
-            _ => 0,
-        };
-        psram.size = size * 1024 * 1024 / 8;
-    }
-
-    psram
-}
-
-#[allow(unused)]
-pub async fn test_psram(psram: &mut PsRam) -> bool {
-    const REPORT_CHUNK: u32 = 256 * 1024;
-    const BLOCK_SIZE: usize = 8;
-    let limit = psram.size; //.min(4 * 1024 * 1024);
-
-    let start = Instant::now();
-
-    fn expect(addr: u32) -> [u8; BLOCK_SIZE] {
-        [
-            !((addr >> 24 & 0xff) as u8),
-            !((addr >> 16 & 0xff) as u8),
-            !((addr >> 8 & 0xff) as u8),
-            !((addr & 0xff) as u8),
-            ((addr >> 24 & 0xff) as u8),
-            ((addr >> 16 & 0xff) as u8),
-            ((addr >> 8 & 0xff) as u8),
-            ((addr & 0xff) as u8),
-        ]
-    }
-
-    for i in 0..limit / BLOCK_SIZE as u32 {
-        let addr = i * BLOCK_SIZE as u32;
-        let data = expect(addr);
-        psram.write(addr, &data).await;
-        if addr > 0 && addr % REPORT_CHUNK == 0 {
-            if start.elapsed() > Duration::from_secs(5) {}
-        }
-        // Yield so that the watchdog doesn't kick in
-        yield_now().await;
-    }
-    let writes_took = start.elapsed();
-
-    defmt::info!("Starting reads...");
-    Timer::after(Duration::from_millis(200)).await;
-
-    let start = Instant::now();
-    let mut bad_count = 0;
-    let mut data = [0u8; BLOCK_SIZE];
-    for i in 0..limit / BLOCK_SIZE as u32 {
-        let addr = i * BLOCK_SIZE as u32;
-        let expect = expect(addr);
-        psram.read(addr, &mut data).await;
-        if addr == 0 {
-            Timer::after(Duration::from_millis(200)).await;
-        }
-        if data != expect {
-            bad_count += 1;
-            if bad_count < 50 {}
-        }
-        if addr > 0 && addr % REPORT_CHUNK == 0 {
-            if start.elapsed() > Duration::from_secs(5) {}
-        }
-
-        // Yield so that the watchdog doesn't kick in
-        yield_now().await;
-    }
-    let reads_took = start.elapsed();
-
-    bad_count == 0
-}

kernel/src/scsi/mod.rs

@@ -1,412 +0,0 @@
-use embassy_futures::select::select;
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy_sync::lazy_lock::LazyLock;
-use embassy_sync::signal::Signal;
-use embassy_usb::Builder;
-use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
-use embedded_sdmmc::{Block, BlockIdx};
-use heapless::Vec;
-
-mod scsi_types;
-use scsi_types::*;
-
-use crate::storage::{SDCARD, SdCard};
-
-const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
-
-pub static MSC_SHUTDOWN: Signal<CriticalSectionRawMutex, ()> = Signal::new();
-
-// number of blocks to read from sd at once
-// higher is better, but is larger. Size is BLOCKS * 512 bytes
-const BLOCKS: usize = 32;
-static mut BLOCK_BUF: LazyLock<[Block; BLOCKS]> =
-    LazyLock::new(|| core::array::from_fn(|_| Block::new()));
-
-pub struct MassStorageClass<'d, D: Driver<'d>> {
-    temp_sd: Option<SdCard>, // temporary owns sdcard when scsi is running
-    ejected: bool,
-    pending_eject: bool,
-    bulk_out: D::EndpointOut,
-    bulk_in: D::EndpointIn,
-}
-
-impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
-    pub fn new(builder: &mut Builder<'d, D>, temp_sd: Option<SdCard>) -> Self {
-        let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
-        let mut interface = function.interface();
-        let mut alt = interface.alt_setting(0x08, SUBCLASS_SCSI, 0x50, None);
-
-        let bulk_out = alt.endpoint_bulk_out(None, BULK_ENDPOINT_PACKET_SIZE as u16);
-        let bulk_in = alt.endpoint_bulk_in(None, BULK_ENDPOINT_PACKET_SIZE as u16);
-
-        Self {
-            temp_sd,
-            pending_eject: false,
-            ejected: false,
-            bulk_out,
-            bulk_in,
-        }
-    }
-
-    pub async fn poll(&mut self) {
-        loop {
-            if !self.ejected {
-                select(self.handle_cbw(), MSC_SHUTDOWN.wait()).await;
-
-                if MSC_SHUTDOWN.signaled() {
-                    defmt::info!("MSC shutting down");
-
-                    if self.temp_sd.is_some() {
-                        let mut guard = SDCARD.get().lock().await;
-                        guard.replace(self.temp_sd.take().unwrap()).unwrap();
-                    }
-
-                    self.ejected = true;
-
-                    return;
-                }
-            }
-        }
-    }
-
-    async fn handle_cbw(&mut self) {
-        let mut cbw_buf = [0u8; 31];
-        if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
-            if n == 31 {
-                if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
-                    // Take sdcard to increase speed
-                    if self.temp_sd.is_none() {
-                        let mut guard = SDCARD.get().lock().await;
-                        if let Some(sd) = guard.take() {
-                            self.temp_sd = Some(sd);
-                        } else {
-                            defmt::warn!("Tried to take SDCARD but it was already taken");
-                            return;
-                        }
-                    }
-
-                    let command = parse_cb(&cbw.CBWCB);
-                    if self.handle_command(command).await.is_ok() {
-                        self.send_csw_success(cbw.dCBWTag).await
-                    } else {
-                        self.send_csw_fail(cbw.dCBWTag).await
-                    }
-
-                    if self.pending_eject {
-                        if let ScsiCommand::Write { lba: _, len: _ } = command {
-                            MSC_SHUTDOWN.signal(());
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    async fn handle_command(&mut self, command: ScsiCommand) -> Result<(), ()> {
-        let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
-
-        match command {
-            ScsiCommand::Unknown => 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.temp_sd.as_ref().unwrap().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.temp_sd.as_ref().unwrap().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.temp_sd.as_ref().unwrap().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 } => {
-                let sdcard = self.temp_sd.as_ref().unwrap();
-                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
-                let mut blocks = len;
-                let mut idx = lba;
-
-                while blocks > 0 {
-                    if blocks >= block_buf.len() as u64 {
-                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
-
-                        for block in &mut *block_buf {
-                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        blocks -= block_buf.len() as u64;
-                        idx += block_buf.len() as u64;
-                    } else {
-                        sdcard
-                            .read_blocks(&mut block_buf[..blocks as usize], BlockIdx(idx as u32))?;
-
-                        for block in &block_buf[..blocks as usize] {
-                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        idx += blocks;
-                        blocks = 0;
-                    }
-                }
-                Ok(())
-            }
-            ScsiCommand::Write { lba, len } => {
-                let sdcard = self.temp_sd.as_ref().unwrap();
-                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
-                let mut blocks = len;
-                let mut idx = lba;
-
-                while blocks > 0 {
-                    if blocks >= block_buf.len() as u64 {
-                        for block in block_buf.as_mut() {
-                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
-                            {
-                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
-
-                        blocks -= block_buf.len() as u64;
-                        idx += block_buf.len() as u64;
-                    } else {
-                        for block in block_buf[..blocks as usize].as_mut() {
-                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
-                            {
-                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        sdcard.write_blocks(
-                            &mut block_buf[..blocks as usize],
-                            BlockIdx(idx as u32),
-                        )?;
-
-                        idx += blocks;
-                        blocks = 0;
-                    }
-                }
-                Ok(())
-            }
-            ScsiCommand::ReadFormatCapacities { alloc_len } => {
-                let block_size = SdCard::BLOCK_SIZE as u32;
-                let num_blocks = (self.temp_sd.as_ref().unwrap().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 } => {
-                if !start && load_eject {
-                    self.pending_eject = true;
-                }
-                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: {}", tag);
-        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)]
-#[allow(non_snake_case)]
-struct CommandBlockWrapper {
-    dCBWSignature: u32,
-    dCBWTag: u32,
-    dCBWDataTransferLength: u32,
-    bmCBWFlags: u8,
-    bCBWLUN: u8,
-    bCBWCBLength: u8,
-    CBWCB: [u8; 16],
-}
-
-#[allow(non_snake_case)]
-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

@@ -1,159 +0,0 @@
-use num_enum::TryFromPrimitive;
-
-/// 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

@@ -1,161 +0,0 @@
-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::CriticalSectionRawMutex;
-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>;
-pub type Dir<'a> = Directory<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
-pub type File<'a> = SdFile<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
-
-pub static SDCARD: LazyLock<Mutex<CriticalSectionRawMutex, Option<SdCard>>> =
-    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| {
-            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<T>(
-        &mut self,
-        name: &ShortFileName,
-        mut access: impl FnMut(File) -> T,
-    ) -> Result<T, ()> {
-        let mut res = Err(());
-        self.access_root_dir(|root_dir| {
-            if let Ok(file) = root_dir.open_file_in_dir(name, Mode::ReadOnly) {
-                res = Ok(access(file));
-            }
-        });
-
-        res
-    }
-
-    /// 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

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

kernel/src/usb.rs

@@ -1,45 +0,0 @@
-use crate::{scsi::MassStorageClass, storage::SdCard};
-use core::sync::atomic::{AtomicBool, Ordering};
-use embassy_futures::select::select;
-use embassy_rp::{peripherals::USB, usb::Driver};
-use embassy_usb::{Builder, Config, UsbDevice};
-
-pub static USB_ACTIVE: AtomicBool = AtomicBool::new(false);
-
-#[embassy_executor::task]
-pub async fn usb_handler(driver: Driver<'static, USB>) {
-    let mut config = Config::new(0xc0de, 0xbabe);
-    config.manufacturer = Some("LegitCamper");
-    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 temp_sd: Option<SdCard> = None;
-    let mut scsi = MassStorageClass::new(&mut builder, temp_sd);
-    let usb = builder.build();
-
-    select(run(usb), scsi.poll()).await;
-}
-
-async fn run<'d>(mut usb: UsbDevice<'d, Driver<'d, USB>>) -> ! {
-    loop {
-        usb.wait_resume().await;
-        USB_ACTIVE.store(true, Ordering::Release);
-        usb.run_until_suspend().await;
-        USB_ACTIVE.store(false, Ordering::Release);
-    }
-}

kernel/src/utils.rs

@@ -1,11 +0,0 @@
-#[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/Cargo.toml

@@ -1,15 +1,8 @@
 [package]
-name = "kernel"
-version = "0.0.1"
+name = "picocalc-os-rs"
+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"]
@@ -30,22 +23,25 @@ defmt = [
   # "cyw43-pio/defmt",
 ]
 
+[dev-dependencies]
+embedded-graphics-simulator = { version = "0.7.0", default-features = false }
+
 [dependencies]
-embassy-executor = { version = "0.9", features = [
+embassy-executor = { version = "0.7", features = [
   "arch-cortex-m",
   "executor-interrupt",
   "executor-thread",
   "nightly",
 ] }
-embassy-rp = { version = "0.8.0", features = [
+embassy-rp = { version = "0.4.0", features = [
   "critical-section-impl",
   "unstable-pac",
   "time-driver",
+  "binary-info",
 ] }
-embassy-usb = "0.5.1"
-embassy-futures = "0.1.2"
-embassy-time = { version = "0.5.0", features = ["generic-queue-8"] }
-embassy-embedded-hal = "0.3.2"
+embassy-futures = "0.1.1"
+embassy-time = "0.4.0"
+embassy-embedded-hal = "0.3.0"
 embassy-sync = { version = "0.7" }
 trouble-host = { version = "0.1", features = [
   "derive",
@@ -58,37 +54,23 @@ cyw43 = { version = "0.3.0", features = [
 ], optional = true }
 cyw43-pio = { version = "0.3.0", optional = true }
 
-critical-section = "1.2.0"
 embedded-hal-bus = { version = "0.3.0", features = ["async"] }
 embedded-hal = "0.2.7"
-embedded-hal_2 = { package = "embedded-hal", version = "1.0.0" }
 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"] }
-assign-resources = "0.5.0"
 
 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 = "a784b9e6df0769371dfc522528e770cf8fc6403a" } # async branch
 embedded-graphics = { version = "0.8.1" }
-embedded-text = "0.7.2"
-embedded-layout = "0.4.2"
-kolibri-embedded-gui = "0.1.0"
+embedded-sdmmc = { git = "https://github.com/Be-ing/embedded-sdmmc-rs", branch = "bisync", default-features = false }
+st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", branch = "async" }
+shared = { path = "../shared" }
 
-strum = { version = "0.27.2", default-features = false }
-rand = { version = "0.9.0", default-features = false }
-once_cell = { version = "1.21.3", default-features = false }
 static_cell = "2.1.1"
-bitflags = "2.9.4"
-heapless = "0.8.0"
-spin = "0.10.0"
-num_enum = { version = "0.7.4", default-features = false }
-goblin = { version = "0.10.1", default-features = false, features = ["elf32"] }
+bitflags = "2.9.1"
 talc = "4.4.3"
-bumpalo = "3.19.0"
-
-abi_sys = { path = "../abi_sys" }
+spin = "0.10.0"

pico/memory.x

@@ -1,7 +1,22 @@
 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
+     * memory areas dedicated for some specific job, improving predictability
+     * of access times.
+     * Example: Separate stacks for core0 and core1.
+     */
     SRAM4 : ORIGIN = 0x20080000, LENGTH = 4K
     SRAM5 : ORIGIN = 0x20081000, LENGTH = 4K
 }

pico/src/display.rs

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

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

@@ -0,0 +1,207 @@
+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),
+            },
+        }
+    }
+}

pico/src/peripherals/mod.rs

@@ -6,36 +6,42 @@ use embassy_rp::{
     peripherals::I2C1,
 };
 use embassy_sync::{
-    blocking_mutex::raw::CriticalSectionRawMutex, 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};
 
 const MCU_ADDR: u8 = 0x1F;
 
 type I2CBUS = I2c<'static, I2C1, Async>;
-pub static PERIPHERAL_BUS: LazyLock<Mutex<CriticalSectionRawMutex, Option<I2CBUS>>> =
+pub static PERIPHERAL_BUS: LazyLock<Mutex<NoopRawMutex, Option<I2CBUS>>> =
     LazyLock::new(|| Mutex::new(None));
 
 const REG_ID_VER: u8 = 0x01;
 const REG_ID_RST: u8 = 0x08;
 const REG_ID_INT: u8 = 0x03;
 
-pub async fn conf_peripherals(i2c: I2CBUS) {
+#[embassy_executor::task]
+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;
-
-    // empty keys
-    while read_keyboard_fifo().await.is_some() {}
-
-    // set_lcd_backlight(255).await;
+    set_lcd_backlight(255).await;
     set_key_backlight(0).await;
+
+    loop {
+        Timer::after(Duration::from_millis(200)).await;
+        read_keyboard_fifo(&mut keyboard_channel).await;
+    }
 }
 
 /// return major & minor mcu version

rust-toolchain.toml

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

shared/Cargo.toml

@@ -1,9 +1,10 @@
 [package]
-name = "calculator"
+name = "shared"
 version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-abi = { path = "../../abi" }
+arrform = "0.1.1"
 embedded-graphics = "0.8.1"
+embedded-graphics-core = "0.4.0"
 embedded-layout = "0.4.2"

shared/src/lib.rs

@@ -0,0 +1,77 @@
+pub mod screen {
+    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 const SCREEN_HEIGHT: usize = 320;
+
+    pub const STATUS_BAR_WIDTH: usize = 320;
+    pub const STATUS_BAR_HEIGHT: usize = 40;
+
+    pub struct UI {
+        pub status_bar: StatusBar,
+    }
+
+    impl UI {
+        pub fn new() -> Self {
+            Self {
+                status_bar: StatusBar {
+                    battery: 100,
+                    backlight: 100,
+                    volume: 100,
+                },
+            }
+        }
+
+        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/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "simulator"
+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" }

simulator/src/main.rs

@@ -0,0 +1,20 @@
+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/build.rs

@@ -1,28 +0,0 @@
-//! 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

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

user-apps/gallery/Cargo.toml

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

user-apps/gallery/build.rs

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

user-apps/gallery/src/main.rs

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

user-apps/memory.x

@@ -1,31 +0,0 @@
-MEMORY
-{
-  RAM : ORIGIN = 0x0, LENGTH = 150K
-}
-
-SECTIONS
-{
-  .text : ALIGN(4)
-  {
-      *(.text .text.*);
-      *(.rodata .rodata.*);
-  } > RAM
-
-  .data : ALIGN(4)
-  {
-      *(.data .data.*);
-  } > RAM
-
-  .bss : ALIGN(4)
-  {
-      *(.bss .bss.*);
-      *(COMMON);
-  } > RAM
-
-  .syscall_table (NOLOAD) : ALIGN(4)
-  {
-      __user_reloc_start = .;
-      KEEP(*(.user_reloc*));
-      __user_reloc_end = .;
-  } > RAM
-}

user-apps/snake/Cargo.toml

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

user-apps/snake/build.rs

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

user-apps/snake/src/main.rs

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