expand doom memory for pimoroni

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "user-apps/doom/doomgeneric"]
+	path = user-apps/doom/doomgeneric
+	url = https://github.com/ozkl/doomgeneric

Cargo.lock

@@ -18,6 +18,7 @@ version = "0.1.0"
 dependencies = [
  "abi_sys",
  "embedded-graphics",
+ "embedded-sdmmc",
  "once_cell",
  "rand_core 0.9.3",
 ]
@@ -30,6 +31,7 @@ dependencies = [
  "cbindgen",
  "defmt 0.3.100",
  "embedded-graphics",
+ "embedded-sdmmc",
  "strum",
 ]
 
@@ -131,6 +133,26 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags 2.9.4",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.10.5",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.104",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -273,12 +295,42 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "cc"
+version = "1.2.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "739eb0f94557554b3ca9a86d2d37bebd49c5e6d0c1d2bda35ba5bdac830befc2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
 [[package]]
 name = "clap"
 version = "3.2.25"
@@ -562,6 +614,16 @@ dependencies = [
  "litrs",
 ]
 
+[[package]]
+name = "doom"
+version = "0.1.0"
+dependencies = [
+ "abi",
+ "bindgen",
+ "cc",
+ "embedded-graphics",
+]
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -1105,6 +1167,12 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+
 [[package]]
 name = "fixed"
 version = "1.29.0"
@@ -1287,10 +1355,15 @@ version = "0.1.0"
 dependencies = [
  "abi",
  "embedded-graphics",
- "selection_ui",
  "tinygif",
 ]
 
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "goblin"
 version = "0.10.2"
@@ -1603,6 +1676,16 @@ version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.4"
@@ -1659,6 +1742,12 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815"
 
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "nb"
 version = "0.1.3"
@@ -1680,6 +1769,16 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1943,6 +2042,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
+[[package]]
+name = "prettyplease"
+version = "0.2.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.104",
+]
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -2135,6 +2244,12 @@ dependencies = [
  "crc-any",
 ]
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "rustc_version"
 version = "0.2.3"
@@ -2190,16 +2305,6 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add"
 
-[[package]]
-name = "selection_ui"
-version = "0.1.0"
-dependencies = [
- "abi",
- "embedded-graphics",
- "embedded-layout",
- "embedded-text",
-]
-
 [[package]]
 name = "semver"
 version = "0.9.0"
@@ -2274,6 +2379,12 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "siphasher"
 version = "1.0.1"
@@ -2842,6 +2953,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
 [[package]]
 name = "windows-sys"
 version = "0.59.0"

Cargo.toml

@@ -4,11 +4,11 @@ members = [
   "kernel",
   "abi_sys",
   "abi",
-  "selection_ui",
   "user-apps/calculator",
   "user-apps/snake",
   "user-apps/gallery",
   "user-apps/gif",
+  "user-apps/doom",
 ]
 
 [profile.release]
@@ -27,4 +27,4 @@ panic = "abort"
 
 [profile.dev]
 lto = true
-opt-level = "s"
+opt-level = "z"

abi/Cargo.toml

@@ -4,7 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-abi_sys = { path = "../abi_sys" }
+embedded-sdmmc = { version = "0.9.0", default-features = false }
 embedded-graphics = "0.8.1"
+abi_sys = { path = "../abi_sys" }
 once_cell = { version = "1", default-features = false }
 rand_core = "0.9.3"

abi/src/lib.rs

@@ -140,9 +140,7 @@ impl RngCore for Rng {
 }
 
 pub mod fs {
-    use core::fmt::Display;
+    use embedded_sdmmc::DirEntry;
-
-    use alloc::{format, vec::Vec};
 
     pub fn read_file(file: &str, read_from: usize, buf: &mut [u8]) -> usize {
         abi_sys::read_file(
@@ -154,85 +152,8 @@ pub mod fs {
         )
     }
 
-    pub struct FileName<'a> {
+    pub fn list_dir(path: &str, files: &mut [Option<DirEntry>]) -> usize {
-        full: &'a str,
+        abi_sys::list_dir(path.as_ptr(), path.len(), files.as_mut_ptr(), files.len())
-        base: &'a str,
-        ext: Option<&'a str>,
-    }
-
-    impl<'a> FileName<'a> {
-        pub fn full_name(&self) -> &str {
-            self.full
-        }
-
-        pub fn base(&self) -> &str {
-            self.base
-        }
-
-        pub fn extension(&self) -> Option<&str> {
-            self.ext
-        }
-    }
-
-    impl<'a> Display for FileName<'a> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-            write!(f, "{}", self.full_name())
-        }
-    }
-
-    impl<'a> From<&'a str> for FileName<'a> {
-        fn from(s: &'a str) -> FileName<'a> {
-            let full = s;
-
-            // Split on last dot for extension
-            let (base, ext) = match s.rfind('.') {
-                Some(idx) => (&s[..idx], Some(&s[idx + 1..])),
-                None => (s, None),
-            };
-
-            FileName { full, base, ext }
-        }
-    }
-
-    const MAX_ENTRY_NAME_LEN: usize = 25;
-    const MAX_ENTRIES: usize = 25;
-
-    #[derive(Clone, Copy)]
-    pub struct Entries([[u8; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]);
-
-    impl Entries {
-        pub fn new() -> Self {
-            Self([[0; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES])
-        }
-
-        /// Get list of file names after listing
-        pub fn entries<'a>(&'a self) -> Vec<FileName<'a>> {
-            self.0
-                .iter()
-                .filter_map(|buf| {
-                    let nul_pos = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
-                    Some(core::str::from_utf8(&buf[..nul_pos]).ok()?.into())
-                })
-                .collect()
-        }
-
-        fn as_ptrs(&mut self) -> [*mut u8; MAX_ENTRIES] {
-            let mut ptrs: [*mut u8; MAX_ENTRIES] = [core::ptr::null_mut(); MAX_ENTRIES];
-            for (i, buf) in self.0.iter_mut().enumerate() {
-                ptrs[i] = buf.as_mut_ptr();
-            }
-            ptrs
-        }
-    }
-
-    pub fn list_dir(path: &str, entries: &mut Entries) -> usize {
-        abi_sys::list_dir(
-            path.as_ptr(),
-            path.len(),
-            entries.as_ptrs().as_mut_ptr(),
-            MAX_ENTRIES,
-            MAX_ENTRY_NAME_LEN,
-        )
     }
 
     pub fn file_len(str: &str) -> usize {

abi_sys/Cargo.toml

@@ -12,6 +12,7 @@ defmt = ["dep:defmt"]
 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]

abi_sys/src/lib.rs

@@ -1,13 +1,14 @@
 #![no_std]
+
 #[cfg(feature = "alloc")]
 use core::alloc::Layout;
 
-use core::ffi::c_char;
 use embedded_graphics::{
     Pixel,
     pixelcolor::{Rgb565, raw::RawU16},
     prelude::{IntoStorage, Point},
 };
+use embedded_sdmmc::DirEntry;
 use strum::{EnumCount, EnumIter};
 
 pub type EntryFn = fn();
@@ -395,23 +396,21 @@ pub extern "C" fn gen_rand(req: &mut RngRequest) {
 pub type ListDir = extern "C" fn(
     str: *const u8,
     len: usize,
-    entries: *mut *mut c_char,
+    files: *mut Option<DirEntry>,
     file_len: usize,
-    max_entry_str_len: usize,
 ) -> usize;
 
 #[unsafe(no_mangle)]
 pub extern "C" fn list_dir(
     str: *const u8,
     len: usize,
-    entries: *mut *mut c_char,
+    files: *mut Option<DirEntry>,
-    entry_count: usize,
+    file_len: usize,
-    max_entry_str_len: usize,
 ) -> usize {
     unsafe {
         let ptr = CALL_ABI_TABLE[CallTable::ListDir as usize];
         let f: ListDir = core::mem::transmute(ptr);
-        f(str, len, entries, entry_count, max_entry_str_len)
+        f(str, len, files, file_len)
     }
 }
 

justfile

@@ -17,3 +17,4 @@ userapps: cbindgen
     just userapp snake
     just userapp gallery
     just userapp gif
+    just userapp doom

kernel/src/abi.rs

@@ -3,11 +3,11 @@ use abi_sys::{
     PrintAbi, ReadFile, RngRequest, SleepMsAbi, keyboard::*,
 };
 use alloc::{string::ToString, vec::Vec};
-use core::{alloc::GlobalAlloc, ffi::c_char, ptr, sync::atomic::Ordering};
+use core::{alloc::GlobalAlloc, sync::atomic::Ordering};
 use embassy_rp::clocks::{RoscRng, clk_sys_freq};
 use embassy_time::Instant;
 use embedded_graphics::draw_target::DrawTarget;
-use embedded_sdmmc::LfnBuffer;
+use embedded_sdmmc::{DirEntry, LfnBuffer};
 use heapless::spsc::Queue;
 
 use crate::{
@@ -116,27 +116,11 @@ pub extern "C" fn gen_rand(req: &mut RngRequest) {
     }
 }
 
-unsafe fn copy_entry_to_user_buf(name: &[u8], dest: *mut c_char, max_str_len: usize) {
+fn get_dir_entries(dir: &Dir, files: &mut [Option<DirEntry>]) -> usize {
-    if !dest.is_null() {
-        let len = name.len().min(max_str_len - 1);
-        unsafe {
-            ptr::copy_nonoverlapping(name.as_ptr(), dest as *mut u8, len);
-            *dest.add(len) = 0; // nul terminator
-        }
-    }
-}
-
-unsafe fn get_dir_entries(dir: &Dir, entries: &mut [*mut c_char], max_str_len: usize) -> usize {
-    let mut b = [0; 25];
-    let mut buf = LfnBuffer::new(&mut b);
     let mut i = 0;
-    dir.iterate_dir_lfn(&mut buf, |entry, lfn_name| {
+    dir.iterate_dir(|entry| {
-        if i < entries.len() {
+        if i < files.len() {
-            if let Some(name) = lfn_name {
+            files[i] = Some(entry.clone());
-                unsafe { copy_entry_to_user_buf(name.as_bytes(), entries[i], max_str_len) };
-            } else {
-                unsafe { copy_entry_to_user_buf(entry.name.base_name(), entries[i], max_str_len) };
-            }
             i += 1;
         }
     })
@@ -144,30 +128,24 @@ unsafe fn get_dir_entries(dir: &Dir, entries: &mut [*mut c_char], max_str_len: u
     i
 }
 
-unsafe fn recurse_dir(
+fn recurse_dir(dir: &Dir, dirs: &[&str], files: &mut [Option<DirEntry>]) -> usize {
-    dir: &Dir,
-    dirs: &[&str],
-    entries: &mut [*mut c_char],
-    max_str_len: usize,
-) -> usize {
     if dirs.is_empty() {
-        return unsafe { get_dir_entries(dir, entries, max_str_len) };
+        return get_dir_entries(dir, files);
     }
 
     let dir = dir.open_dir(dirs[0]).unwrap();
-    unsafe { recurse_dir(&dir, &dirs[1..], entries, max_str_len) }
+    recurse_dir(&dir, &dirs[1..], files)
 }
 
 const _: ListDir = list_dir;
 pub extern "C" fn list_dir(
     dir: *const u8,
     len: usize,
-    entries: *mut *mut c_char,
+    files: *mut Option<DirEntry>,
     files_len: usize,
-    max_entry_str_len: usize,
 ) -> usize {
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
-    let files = unsafe { core::slice::from_raw_parts_mut(entries, files_len) };
+    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();
@@ -178,12 +156,10 @@ pub extern "C" fn list_dir(
     let mut wrote = 0;
     sd.access_root_dir(|root| {
         if dirs[0] == "" && dirs.len() >= 2 {
-            unsafe {
+            if dir == "/" {
-                if dir == "/" {
+                wrote = get_dir_entries(&root, files);
-                    wrote = get_dir_entries(&root, files, max_entry_str_len);
+            } else {
-                } else {
+                wrote = recurse_dir(&root, &dirs[1..], files);
-                    wrote = recurse_dir(&root, &dirs[1..], files, max_entry_str_len);
-                }
             }
         }
     });

kernel/src/display.rs

@@ -84,7 +84,7 @@ pub async fn display_handler(mut display: DISPLAY) {
                 FRAMEBUFFER
                     .as_mut()
                     .unwrap()
-                    .partial_draw(&mut display)
+                    .safe_draw(&mut display)
                     .await
                     .unwrap()
             };

kernel/src/framebuffer.rs

@@ -1,5 +1,6 @@
 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::{
@@ -13,33 +14,32 @@ use embedded_hal_2::digital::OutputPin;
 use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
 use st7365p_lcd::ST7365P;
 
-const TILE_SIZE: usize = 16; // 16x16 tile
+pub const TILE_SIZE: usize = 16; // 16x16 tile
-const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
+pub const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
-const NUM_TILE_ROWS: usize = SCREEN_WIDTH / TILE_SIZE;
-const NUM_TILE_COLS: usize = SCREEN_WIDTH / TILE_SIZE;
 
-const MAX_BATCH_TILES: usize = (SCREEN_WIDTH / TILE_SIZE) * 2;
+// Group of tiles for batching
-type BatchTileBuf = [u16; MAX_BATCH_TILES * TILE_SIZE * TILE_SIZE];
+pub const MAX_META_TILES: usize = (SCREEN_WIDTH / TILE_SIZE) * 2; // max number of meta tiles in buffer
+type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
 
 pub const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
 
 pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
 
+static mut DIRTY_TILES: LazyLock<heapless::Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
+    let mut tiles = heapless::Vec::new();
+    for _ in 0..TILE_COUNT {
+        tiles.push(AtomicBool::new(true)).unwrap();
+    }
+    tiles
+});
+
 #[allow(dead_code)]
-pub struct AtomicFrameBuffer<'a> {
+pub struct AtomicFrameBuffer<'a>(&'a mut [u16]);
-    fb: &'a mut [u16],
-    dirty_tiles: [AtomicBool; TILE_COUNT],
-    batch_tile_buf: BatchTileBuf,
-}
 
 impl<'a> AtomicFrameBuffer<'a> {
     pub fn new(buffer: &'a mut [u16]) -> Self {
         assert!(buffer.len() == SIZE);
-        Self {
+        Self(buffer)
-            fb: buffer,
-            dirty_tiles: core::array::from_fn(|_| AtomicBool::new(true)),
-            batch_tile_buf: [0; MAX_BATCH_TILES * TILE_SIZE * TILE_SIZE],
-        }
     }
 
     fn mark_tiles_dirty(&mut self, rect: Rectangle) {
@@ -52,7 +52,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         for ty in start_ty..=end_ty {
             for tx in start_tx..=end_tx {
                 let tile_idx = ty * tiles_x + tx;
-                self.dirty_tiles[tile_idx].store(true, Ordering::Release);
+                unsafe { DIRTY_TILES.get_mut()[tile_idx].store(true, Ordering::Release) };
             }
         }
     }
@@ -78,7 +78,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         for y in sy..=ey {
             for x in sx..=ex {
                 if let Some(color) = color_iter.next() {
-                    self.fb[(y as usize * SCREEN_WIDTH) + x as usize] = color;
+                    self.0[(y as usize * SCREEN_WIDTH) + x as usize] = color;
                 } else {
                     return Err(()); // Not enough data
                 }
@@ -93,17 +93,60 @@ impl<'a> AtomicFrameBuffer<'a> {
         Ok(())
     }
 
-    // Checks if a full draw would be faster than individual tile batches
+    // walk the dirty tiles and mark groups of tiles(meta-tiles) for batched updates
-    fn should_full_draw(&self) -> bool {
+    fn find_meta_tiles(&mut self, tiles_x: usize, tiles_y: usize) -> MetaTileVec {
-        let threshold_pixels = SIZE * 80 / 100;
+        let mut meta_tiles: MetaTileVec = heapless::Vec::new();
-        let mut dirty_pixels = 0;
 
-        self.dirty_tiles.iter().any(|tile| {
+        for ty in 0..tiles_y {
-            if tile.load(Ordering::Acquire) {
+            let mut tx = 0;
-                dirty_pixels += TILE_SIZE * TILE_SIZE;
+            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::Acquire)
+                    }
+                    && (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;
             }
-            dirty_pixels >= threshold_pixels
+        }
-        })
+
+        meta_tiles
     }
 
     /// Sends the entire framebuffer to the display
@@ -122,40 +165,71 @@ impl<'a> AtomicFrameBuffer<'a> {
                 0,
                 self.size().width as u16 - 1,
                 self.size().height as u16 - 1,
-                &self.fb[..],
+                &self.0[..],
             )
             .await?;
 
-        for tile in self.dirty_tiles.iter() {
+        unsafe {
-            tile.store(false, Ordering::Release);
+            for tile in DIRTY_TILES.get_mut().iter() {
+                tile.store(false, Ordering::Release);
+            }
+        };
+
+        Ok(())
+    }
+
+    pub async fn safe_draw<SPI, DC, RST, DELAY>(
+        &mut self,
+        display: &mut ST7365P<SPI, DC, RST, DELAY>,
+    ) -> Result<(), ()>
+    where
+        SPI: SpiDevice,
+        DC: OutputPin,
+        RST: OutputPin,
+        DELAY: DelayNs,
+    {
+        let tiles_x = SCREEN_WIDTH / TILE_SIZE;
+        let _tiles_y = SCREEN_HEIGHT / TILE_SIZE;
+
+        let tiles = unsafe { DIRTY_TILES.get_mut() };
+        let mut pixel_buffer: heapless::Vec<u16, { TILE_SIZE * TILE_SIZE }> = heapless::Vec::new();
+
+        for tile_idx in 0..TILE_COUNT {
+            if tiles[tile_idx].swap(false, Ordering::AcqRel) {
+                let tx = tile_idx % tiles_x;
+                let ty = tile_idx / tiles_x;
+
+                let x_start = tx * TILE_SIZE;
+                let y_start = ty * TILE_SIZE;
+
+                let x_end = (x_start + TILE_SIZE).min(SCREEN_WIDTH);
+                let y_end = (y_start + TILE_SIZE).min(SCREEN_HEIGHT);
+
+                pixel_buffer.clear();
+
+                for y in y_start..y_end {
+                    let start = y * SCREEN_WIDTH + x_start;
+                    let end = y * SCREEN_WIDTH + x_end;
+                    pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
+                }
+
+                display
+                    .set_pixels_buffered(
+                        x_start as u16,
+                        y_start as u16,
+                        (x_end - 1) as u16,
+                        (y_end - 1) as u16,
+                        &pixel_buffer,
+                    )
+                    .await
+                    .unwrap();
+            }
         }
 
         Ok(())
     }
 
-    // copy N tiles horizontally to the right into batch tile buf
+    /// Sends only dirty tiles (16x16px) in batches to the display
-    fn append_tiles_to_batch(
-        &mut self,
-        tile_x: u16,
-        tile_y: u16,
-        total_tiles: u16, // number of tiles being written to buf
-    ) {
-        debug_assert!(total_tiles as usize <= NUM_TILE_COLS);
-        for batch_row_num in 0..TILE_SIZE {
-            let batch_row_offset = batch_row_num * total_tiles as usize * TILE_SIZE;
-            let batch_row = &mut self.batch_tile_buf
-                [batch_row_offset..batch_row_offset + (total_tiles as usize * TILE_SIZE)];
-
-            let fb_row_offset = (tile_y as usize * TILE_SIZE + batch_row_num) * SCREEN_WIDTH
-                + tile_x as usize * TILE_SIZE;
-            let fb_row =
-                &self.fb[fb_row_offset..fb_row_offset + (total_tiles as usize * TILE_SIZE)];
-
-            batch_row.copy_from_slice(fb_row);
-        }
-    }
-
-    // Pushes tiles to the display in batches to avoid full frame pushes (unless needed)
     pub async fn partial_draw<SPI, DC, RST, DELAY>(
         &mut self,
         display: &mut ST7365P<SPI, DC, RST, DELAY>,
@@ -166,53 +240,55 @@ impl<'a> AtomicFrameBuffer<'a> {
         RST: OutputPin,
         DELAY: DelayNs,
     {
-        if self.should_full_draw() {
+        if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
-            return self.draw(display).await;
+            let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
-        }
+            let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
 
-        for tile_row in 0..NUM_TILE_ROWS {
+            let meta_tiles = self.find_meta_tiles(tiles_x, tiles_y);
-            let row_start_idx = tile_row * NUM_TILE_COLS;
-            let mut col = 0;
 
-            while col < NUM_TILE_COLS {
+            // buffer for copying meta tiles before sending to display
-                // Check for dirty tile
+            let mut pixel_buffer: heapless::Vec<u16, { MAX_META_TILES * TILE_SIZE * TILE_SIZE }> =
-                if self.dirty_tiles[row_start_idx + col].swap(false, Ordering::Acquire) {
+                heapless::Vec::new();
-                    let run_start = col;
-                    let mut run_len = 1;
 
-                    // Extend run while contiguous dirty tiles and within MAX_BATCH_TILES
+            for rect in meta_tiles {
-                    while col + 1 < NUM_TILE_COLS
+                let rect_width = rect.size.width as usize;
-                        && self.dirty_tiles[row_start_idx + col + 1].load(Ordering::Acquire)
+                let rect_height = rect.size.height as usize;
-                        && run_len < MAX_BATCH_TILES
+                let rect_x = rect.top_left.x as usize;
-                    {
+                let rect_y = rect.top_left.y as usize;
-                        col += 1;
-                        run_len += 1;
-                    }
 
-                    // Copy the whole horizontal run into the batch buffer in one call
+                pixel_buffer.clear();
-                    let tile_x = run_start;
-                    let tile_y = tile_row;
-                    self.append_tiles_to_batch(tile_x as u16, tile_y as u16, run_len as u16);
 
-                    // Compute coordinates for display write
+                for row in 0..rect_height {
-                    let start_x = tile_x * TILE_SIZE;
+                    let y = rect_y + row;
-                    let end_x = start_x + run_len * TILE_SIZE - 1;
+                    let start = y * SCREEN_WIDTH + rect_x;
-                    let start_y = tile_y * TILE_SIZE;
+                    let end = start + rect_width;
-                    let end_y = start_y + TILE_SIZE - 1;
 
-                    // Send batch to display
+                    // Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
-                    display
+                    pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
-                        .set_pixels_buffered(
-                            start_x as u16,
-                            start_y as u16,
-                            end_x as u16,
-                            end_y as u16,
-                            &self.batch_tile_buf[..run_len * TILE_SIZE * TILE_SIZE],
-                        )
-                        .await?;
                 }
 
-                col += 1;
+                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) };
+                    }
+                }
             }
         }
 
@@ -233,14 +309,14 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
 
         for Pixel(coord, color) in pixels {
             if coord.x >= 0 && coord.y >= 0 {
-                let x = coord.x;
+                let x = coord.x as i32;
-                let y = coord.y;
+                let y = coord.y as i32;
 
                 if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
                     let idx = (y as usize) * SCREEN_WIDTH + (x as usize);
                     let raw_color = RawU16::from(color).into_inner();
-                    if self.fb[idx] != raw_color {
+                    if self.0[idx] != raw_color {
-                        self.fb[idx] = raw_color;
+                        self.0[idx] = raw_color;
                         changed = true;
                     }
 
@@ -289,8 +365,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                         if let Some(color) = colors.next() {
                             let idx = (p.y as usize * SCREEN_WIDTH) + (p.x as usize);
                             let raw_color = RawU16::from(color).into_inner();
-                            if self.fb[idx] != raw_color {
+                            if self.0[idx] != raw_color {
-                                self.fb[idx] = raw_color;
+                                self.0[idx] = raw_color;
                                 changed = true;
                             }
                         } else {
@@ -328,7 +404,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                 .take((self.size().width * self.size().height) as usize),
         )?;
 
-        for tile in self.dirty_tiles.iter() {
+        for tile in unsafe { DIRTY_TILES.get_mut() }.iter() {
             tile.store(true, Ordering::Release);
         }
 

kernel/src/main.rs

@@ -12,10 +12,8 @@ mod abi;
 mod display;
 mod elf;
 mod framebuffer;
-#[allow(unused)]
 mod heap;
 mod peripherals;
-#[allow(unused)]
 mod psram;
 mod scsi;
 mod storage;
@@ -24,22 +22,25 @@ mod usb;
 mod utils;
 
 #[cfg(feature = "pimoroni2w")]
-use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram_qmi};
+use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi};
 
 use crate::{
     abi::{KEY_CACHE, MS_SINCE_LAUNCH},
-    display::{display_handler, init_display},
+    display::{FRAMEBUFFER, display_handler, init_display},
-    elf::load_binary,
     peripherals::{
         conf_peripherals,
         keyboard::{KeyState, read_keyboard_fifo},
     },
     psram::init_psram,
+    scsi::MSC_SHUTDOWN,
     storage::{SDCARD, SdCard},
-    ui::{clear_screen, ui_handler},
+    ui::{SELECTIONS, clear_selection, ui_handler},
-    usb::usb_handler,
 };
+use abi_sys::EntryFn;
+use bumpalo::Bump;
+use core::sync::atomic::{AtomicBool, Ordering};
 use embassy_executor::{Executor, Spawner};
+use embassy_futures::{join::join, select::select};
 use embassy_rp::{
     Peri,
     gpio::{Input, Level, Output, Pull},
@@ -59,8 +60,12 @@ use embassy_sync::{
     blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, signal::Signal,
 };
 use embassy_time::{Delay, Duration, Instant, Ticker, Timer};
+use embedded_graphics::{
+    pixelcolor::Rgb565,
+    prelude::{DrawTarget, RgbColor},
+};
 use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::{SdCard as SdmmcSdCard, ShortFileName};
+use embedded_sdmmc::SdCard as SdmmcSdCard;
 use static_cell::StaticCell;
 use talc::*;
 use {defmt_rtt as _, panic_probe as _};
@@ -105,6 +110,9 @@ async fn watchdog_task(mut watchdog: Watchdog) {
     }
 }
 
+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());
@@ -162,25 +170,39 @@ async fn main(_spawner: Spawner) {
 }
 
 // One-slot channel to pass EntryFn from core1
-static BINARY_CH: Channel<CriticalSectionRawMutex, ShortFileName, 1> = Channel::new();
+static BINARY_CH: Channel<CriticalSectionRawMutex, (EntryFn, Bump), 1> = Channel::new();
 
 // runs dynamically loaded elf files
 #[embassy_executor::task]
 async fn userland_task() {
     let recv = BINARY_CH.receiver();
     loop {
-        let name = recv.receive().await;
+        let (entry, _bump) = recv.receive().await;
-        let (entry, _bump) = unsafe { load_binary(&name).await.expect("unable to load binary") };
 
-        clear_screen().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()) };
         #[cfg(feature = "defmt")]
         defmt::info!("Executing Binary");
         entry();
 
-        STOP_KEY_HANDLER.signal(());
+        // enable kernel ui
-        clear_screen().await;
+        {
+            ENABLE_UI.store(true, Ordering::Release);
+            UI_CHANGE.signal(());
+            unsafe { FRAMEBUFFER.as_mut().unwrap().clear(Rgb565::BLACK).unwrap() };
+
+            let mut selections = SELECTIONS.lock().await;
+            selections.set_changed(true);
+        }
     }
 }
 
@@ -203,7 +225,6 @@ struct Sd {
     cs: Peri<'static, PIN_17>,
     det: Peri<'static, PIN_22>,
 }
-#[allow(dead_code)]
 struct Psram {
     pio: Peri<'static, PIO0>,
     sclk: Peri<'static, PIN_21>,
@@ -245,7 +266,6 @@ async fn setup_display(display: Display, spawner: Spawner) {
 
 // psram is kind of useless on the pico calc
 // ive opted to use the pimoroni with on onboard xip psram instead
-#[allow(unused)]
 async fn setup_psram(psram: Psram) {
     let psram = init_psram(
         psram.pio, psram.sclk, psram.mosi, psram.miso, psram.cs, psram.dma1, psram.dma2,
@@ -287,7 +307,7 @@ async fn setup_sd(sd: Sd) {
     let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
     let sdcard = SdmmcSdCard::new(device, Delay);
 
-    config.frequency = 64_000_000;
+    config.frequency = 32_000_000;
     sdcard.spi(|dev| dev.bus_mut().set_config(&config));
     SDCARD.get().lock().await.replace(SdCard::new(sdcard, det));
 }
@@ -298,7 +318,7 @@ async fn kernel_task(
     watchdog: Peri<'static, WATCHDOG>,
     display: Display,
     sd: Sd,
-    _psram: Psram,
+    psram: Psram,
     mcu: Mcu,
     usb: Peri<'static, USB>,
 ) {
@@ -308,39 +328,46 @@ async fn kernel_task(
 
     setup_mcu(mcu).await;
 
-    defmt::info!("setting up psram");
-    Timer::after_millis(100).await;
-
     // setup_psram(psram).await;
     #[cfg(feature = "pimoroni2w")]
     setup_qmi_psram().await;
 
-    Timer::after_millis(100).await;
     setup_display(display, spawner).await;
     setup_sd(sd).await;
 
-    let usb_driver = embassy_rp_usb::Driver::new(usb, Irqs);
+    let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
-    spawner.spawn(usb_handler(usb_driver)).unwrap();
+    // spawner.spawn(usb_handler(usb)).unwrap();
 
-    let mut ui_enabled = true;
     loop {
+        let ui_enabled = ENABLE_UI.load(Ordering::Relaxed);
         if ui_enabled {
-            ui_handler().await;
+            select(join(ui_handler(), prog_search_handler()), UI_CHANGE.wait()).await;
         } else {
-            key_handler().await;
+            select(key_handler(), UI_CHANGE.wait()).await;
         }
-        ui_enabled ^= true // flip bool
     }
 }
 
-static STOP_KEY_HANDLER: Signal<CriticalSectionRawMutex, ()> = Signal::new();
+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 STOP_KEY_HANDLER.try_take().is_some() {
-            break;
-        }
-
         if let Some(event) = read_keyboard_fifo().await {
             if let KeyState::Pressed = event.state {
                 unsafe {

kernel/src/psram.rs

@@ -549,13 +549,13 @@ pub fn init_psram_qmi(
     let min_deselect: u32 = ((18 * 1_000_000 + (clock_period_fs - 1)) / clock_period_fs
         - u64::from(divisor + 1) / 2) as u32;
 
-    // #[cfg(feature = "defmt")]
+    #[cfg(feature = "defmt")]
-    // defmt::info!(
+    defmt::info!(
-    //     "clock_period_fs={} max_select={} min_deselect={}",
+        "clock_period_fs={} max_select={} min_deselect={}",
-    //     clock_period_fs,
+        clock_period_fs,
-    //     max_select,
+        max_select,
-    //     min_deselect
+        min_deselect
-    // );
+    );
 
     qmi.direct_csr().write(|w| {
         w.set_clkdiv(10);

kernel/src/scsi/error.rs

@@ -1,100 +0,0 @@
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[derive(Clone, Copy, Debug)]
-pub struct ScsiSense {
-    pub key: u8,
-    pub asc: u8,
-    pub ascq: u8,
-}
-
-impl ScsiSense {
-    pub const fn new(key: u8, asc: u8, ascq: u8) -> Self {
-        Self { key, asc, ascq }
-    }
-
-    // --- Sense Key constants ---
-    pub const KEY_NO_SENSE: u8 = 0x00;
-    pub const KEY_RECOVERED_ERROR: u8 = 0x01;
-    pub const KEY_NOT_READY: u8 = 0x02;
-    pub const KEY_MEDIUM_ERROR: u8 = 0x03;
-    pub const KEY_HARDWARE_ERROR: u8 = 0x04;
-    pub const KEY_ILLEGAL_REQUEST: u8 = 0x05;
-    pub const KEY_UNIT_ATTENTION: u8 = 0x06;
-    pub const KEY_DATA_PROTECT: u8 = 0x07;
-    pub const KEY_BLANK_CHECK: u8 = 0x08;
-    pub const KEY_VENDOR_SPECIFIC: u8 = 0x09;
-    pub const KEY_COPY_ABORTED: u8 = 0x0A;
-    pub const KEY_ABORTED_COMMAND: u8 = 0x0B;
-    pub const KEY_VOLUME_OVERFLOW: u8 = 0x0D;
-    pub const KEY_MISCOMPARE: u8 = 0x0E;
-
-    // --- Common ASC/ASCQ pairs (subset of most-used codes) ---
-    pub const ASC_NO_ADDITIONAL_SENSE: u8 = 0x00;
-
-    // Medium errors
-    pub const ASC_UNRECOVERED_READ_ERROR: u8 = 0x11;
-    pub const ASCQ_UNRECOVERED_READ_ERROR: u8 = 0x00;
-    pub const ASC_UNRECOVERED_WRITE_ERROR: u8 = 0x03;
-    pub const ASCQ_UNRECOVERED_WRITE_ERROR: u8 = 0x01;
-    pub const ASC_WRITE_FAULT: u8 = 0x03;
-    pub const ASC_ID_CRC_ERROR: u8 = 0x10;
-
-    // Illegal requests
-    pub const ASC_INVALID_COMMAND_OPERATION_CODE: u8 = 0x20;
-    pub const ASC_LBA_OUT_OF_RANGE: u8 = 0x21;
-    pub const ASC_INVALID_FIELD_IN_CDB: u8 = 0x24;
-
-    // Not ready
-    pub const ASC_LOGICAL_UNIT_NOT_READY: u8 = 0x04;
-    pub const ASC_MEDIUM_NOT_PRESENT: u8 = 0x3A;
-
-    // Unit attention
-    pub const ASC_POWER_ON_RESET_OCCURRED: u8 = 0x29;
-    pub const ASC_MEDIUM_CHANGED: u8 = 0x28;
-
-    // Data protect
-    pub const ASC_WRITE_PROTECTED: u8 = 0x27;
-
-    // Aborted command
-    pub const ASC_COMMAND_ABORTED: u8 = 0x47;
-
-    // --- Helpers for common conditions ---
-    pub const fn no_sense() -> Self {
-        Self::new(Self::KEY_NO_SENSE, Self::ASC_NO_ADDITIONAL_SENSE, 0x00)
-    }
-
-    pub const fn invalid_cdb() -> Self {
-        Self::new(
-            Self::KEY_ILLEGAL_REQUEST,
-            Self::ASC_INVALID_FIELD_IN_CDB,
-            0x00,
-        )
-    }
-
-    pub const fn lba_out_of_range() -> Self {
-        Self::new(Self::KEY_ILLEGAL_REQUEST, Self::ASC_LBA_OUT_OF_RANGE, 0x00)
-    }
-
-    pub const fn medium_not_present() -> Self {
-        Self::new(Self::KEY_NOT_READY, Self::ASC_MEDIUM_NOT_PRESENT, 0x00)
-    }
-
-    pub const fn unrecovered_read_error() -> Self {
-        Self::new(
-            Self::KEY_MEDIUM_ERROR,
-            Self::ASC_UNRECOVERED_READ_ERROR,
-            Self::ASCQ_UNRECOVERED_READ_ERROR,
-        )
-    }
-
-    pub const fn unrecovered_write_error() -> Self {
-        Self::new(
-            Self::KEY_MEDIUM_ERROR,
-            Self::ASC_UNRECOVERED_WRITE_ERROR,
-            Self::ASCQ_UNRECOVERED_WRITE_ERROR,
-        )
-    }
-
-    pub const fn write_protected() -> Self {
-        Self::new(Self::KEY_DATA_PROTECT, Self::ASC_WRITE_PROTECTED, 0x00)
-    }
-}

kernel/src/scsi/mod.rs

@@ -1,6 +1,7 @@
-use crate::storage::{SDCARD, SdCard};
+use embassy_futures::select::select;
-use core::sync::atomic::{AtomicBool, Ordering};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy_time::Timer;
+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};
@@ -8,32 +9,29 @@ use heapless::Vec;
 
 mod scsi_types;
 use scsi_types::*;
-#[allow(unused)]
+
-mod error;
+use crate::storage::{SDCARD, SdCard};
-use error::ScsiSense;
 
 const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
 
-// indicates that a scsi transaction is occurring and is
+pub static MSC_SHUTDOWN: Signal<CriticalSectionRawMutex, ()> = Signal::new();
-// NOT safe to disable usb, or acquire sdcard
-pub static SCSI_BUSY: AtomicBool = AtomicBool::new(false);
 
-// stop scsi and return sdcard when safe to do so
+// number of blocks to read from sd at once
-pub static SCSI_HALT: AtomicBool = AtomicBool::new(false);
+// higher is better, but is larger. Size is BLOCKS * 512 bytes
-
+const BLOCKS: usize = 32;
-pub static SCSI_EJECTED: AtomicBool = AtomicBool::new(false);
+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,
-    last_sense: ScsiSense,
-    prevent_removal: bool,
-    pending_eject: bool,
 }
 
 impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
-    pub fn new(builder: &mut Builder<'d, D>) -> Self {
+    pub fn new(builder: &mut Builder<'d, D>, temp_sd: Option<SdCard>) -> Self {
         let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
         let mut interface = function.interface();
         let mut alt = interface.alt_setting(0x08, SUBCLASS_SCSI, 0x50, None);
@@ -42,56 +40,32 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         let bulk_in = alt.endpoint_bulk_in(None, BULK_ENDPOINT_PACKET_SIZE as u16);
 
         Self {
-            temp_sd: None,
+            temp_sd,
+            pending_eject: false,
+            ejected: false,
             bulk_out,
             bulk_in,
-            last_sense: ScsiSense::no_sense(),
-            prevent_removal: false,
-            pending_eject: false,
-        }
-    }
-
-    // Take sdcard to increase speed
-    pub async fn take_sdcard(&mut self) {
-        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 {
-                panic!("Tried to take SDCARD but it was already taken");
-            }
-        }
-    }
-
-    // return sdcard to global, so other tasks can use it
-    pub async fn return_sdcard(&mut self) {
-        if let Some(card) = self.temp_sd.take() {
-            let mut guard = SDCARD.get().lock().await;
-            *guard = Some(card);
         }
     }
 
     pub async fn poll(&mut self) {
         loop {
-            if !self.prevent_removal && (SCSI_HALT.load(Ordering::Acquire) || self.pending_eject) {
+            if !self.ejected {
-                if self.temp_sd.is_some() {
+                select(self.handle_cbw(), MSC_SHUTDOWN.wait()).await;
-                    self.return_sdcard().await;
+
-                    SCSI_BUSY.store(false, Ordering::Release);
+                if MSC_SHUTDOWN.signaled() {
-                    self.pending_eject = false;
+                    #[cfg(feature = "defmt")]
+                    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;
                 }
-            } else {
-                self.handle_cbw().await;
-            }
-
-            if SCSI_EJECTED.load(Ordering::Acquire) {
-                Timer::after_millis(100).await;
-                continue;
-            }
-
-            if SCSI_BUSY.load(Ordering::Relaxed) {
-                Timer::after_millis(1).await;
-            } else {
-                Timer::after_millis(100).await;
             }
         }
     }
@@ -101,19 +75,31 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         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 {
+                            #[cfg(feature = "defmt")]
+                            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
                     }
-                } else {
+
-                    self.last_sense = ScsiSense::invalid_cdb();
+                    if self.pending_eject {
-                    self.send_csw_fail(0).await;
+                        if let ScsiCommand::Write { lba: _, len: _ } = command {
+                            MSC_SHUTDOWN.signal(());
+                        }
+                    }
                 }
-            } else {
-                self.last_sense = ScsiSense::invalid_cdb();
-                self.send_csw_fail(0).await;
             }
         }
     }
@@ -121,12 +107,6 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
     async fn handle_command(&mut self, command: ScsiCommand) -> Result<(), ()> {
         let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
 
-        const BLOCK_SIZE: usize = 512;
-        // number of blocks to read from sd at once
-        // higher is better, but is larger. Size is BLOCKS * 512 bytes
-        const BLOCKS: usize = 10;
-        let mut block_buf: [Block; BLOCKS] = core::array::from_fn(|_| Block::new());
-
         match command {
             ScsiCommand::Unknown => Err(()),
             ScsiCommand::Inquiry {
@@ -206,41 +186,16 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
             ScsiCommand::TestUnitReady => {
-                if !SCSI_EJECTED.load(Ordering::Acquire) && self.temp_sd.is_none() {
+                if self.temp_sd.as_ref().unwrap().is_attached() {
-                    SCSI_BUSY.store(true, Ordering::Release);
+                    Ok(())
-                    self.take_sdcard().await;
+                } else {
-                }
+                    Err(())
-
-                match &self.temp_sd {
-                    Some(sd) => {
-                        if sd.is_attached() {
-                            Ok(())
-                        } else {
-                            self.last_sense = ScsiSense::medium_not_present();
-                            Err(())
-                        }
-                    }
-                    None => {
-                        self.last_sense = ScsiSense::medium_not_present();
-                        Err(())
-                    }
                 }
             }
-            ScsiCommand::RequestSense { desc: _, alloc_len } => {
+            ScsiCommand::RequestSense {
-                // Prepare the buffer
+                desc: _,
-                let mut buf = [0u8; 18];
+                alloc_len: _,
-
+            } => Ok(()),
-                // Fixed format sense data
-                buf[0] = 0x70; // Response code, current errors
-                buf[2] = self.last_sense.key; // Sense Key
-                buf[7] = 0x0A; // Additional sense length (n-8)
-                buf[12] = self.last_sense.asc; // Additional Sense Code
-                buf[13] = self.last_sense.ascq; // Additional Sense Code Qualifier
-
-                let len = core::cmp::min(buf.len(), alloc_len as usize);
-                self.last_sense = ScsiSense::no_sense();
-                self.bulk_in.write(&buf[..len]).await.map_err(|_| ())
-            }
             ScsiCommand::ModeSense6 {
                 dbd: _,
                 page_control: _,
@@ -279,183 +234,125 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
-            ScsiCommand::ReadCapacity10 => match self.temp_sd.as_ref() {
+            ScsiCommand::ReadCapacity10 => {
-                Some(sd) => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
-                    let total_blocks = sd.size() / 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);
+                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(&(last_lba as u32).to_be_bytes())?;
-                    response.extend_from_slice(&(BLOCK_SIZE as u32).to_be_bytes())?;
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
 
-                    self.bulk_in.write(&response).await.map_err(|_| ())
+                self.bulk_in.write(&response).await.map_err(|_| ())
-                }
+            }
-                None => {
+            ScsiCommand::ReadCapacity16 { alloc_len } => {
-                    self.last_sense = ScsiSense::medium_not_present();
+                let block_size = SdCard::BLOCK_SIZE as u64;
-                    Err(())
+                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
-                }
-            },
-            ScsiCommand::ReadCapacity16 { alloc_len } => match self.temp_sd.as_ref() {
-                Some(sd) => {
-                    let total_blocks = sd.size() / BLOCK_SIZE as u64;
 
-                    let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+                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(&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(&(block_size as u32).to_be_bytes())?; // 4 bytes block length
-                    response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
+                response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
 
-                    let len = alloc_len.min(response.len() as u32) as usize;
+                let len = alloc_len.min(response.len() as u32) as usize;
-                    self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
-                }
+            }
-                None => {
+            ScsiCommand::Read { lba, len } => {
-                    self.last_sense = ScsiSense::medium_not_present();
+                let sdcard = self.temp_sd.as_ref().unwrap();
-                    Err(())
+                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
-                }
+                let mut blocks = len;
-            },
+                let mut idx = lba;
-            ScsiCommand::Read { lba, len } => match self.temp_sd.as_ref() {
-                Some(sd) => {
-                    let mut blocks = len;
-                    let mut idx = lba;
 
-                    let mut error_occurred = false;
+                while blocks > 0 {
+                    if blocks >= block_buf.len() as u64 {
+                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
 
-                    while blocks > 0 {
+                        for block in &mut *block_buf {
-                        if blocks >= block_buf.len() as u64 {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                            sd.read_blocks(&mut block_buf, BlockIdx(idx as u32))?;
+                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
-
-                            for block in &mut block_buf {
-                                for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into())
-                                {
-                                    if self.bulk_in.write(chunk).await.map_err(|_| ()).is_err() {
-                                        error_occurred = true
-                                    }
-                                }
                             }
-
-                            blocks -= block_buf.len() as u64;
-                            idx += block_buf.len() as u64;
-                        } else {
-                            sd.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())
-                                {
-                                    if self.bulk_in.write(chunk).await.map_err(|_| ()).is_err() {
-                                        error_occurred = true
-                                    }
-                                }
-                            }
-
-                            idx += blocks;
-                            blocks = 0;
                         }
-                    }
 
-                    if error_occurred {
+                        blocks -= block_buf.len() as u64;
-                        self.last_sense = ScsiSense::unrecovered_read_error();
+                        idx += block_buf.len() as u64;
-                        return Err(());
+                    } else {
-                    }
+                        sdcard
+                            .read_blocks(&mut block_buf[..blocks as usize], BlockIdx(idx as u32))?;
 
-                    Ok(())
+                        for block in &block_buf[..blocks as usize] {
-                }
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                None => {
+                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
-                    self.last_sense = ScsiSense::medium_not_present();
-                    Err(())
-                }
-            },
-            ScsiCommand::Write { lba, len } => match self.temp_sd.as_ref() {
-                Some(sd) => {
-                    let mut blocks = len;
-                    let mut idx = lba;
-
-                    let mut error_occurred = false;
-
-                    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())
-                                {
-                                    if self.bulk_out.read(chunk).await.map_err(|_| ()).is_err() {
-                                        error_occurred = true
-                                    }
-                                }
                             }
-
-                            sd.read_blocks(&mut 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())
-                                {
-                                    if self.bulk_out.read(chunk).await.map_err(|_| ()).is_err() {
-                                        error_occurred = true
-                                    }
-                                }
-                            }
-
-                            sd.write_blocks(
-                                &mut block_buf[..blocks as usize],
-                                BlockIdx(idx as u32),
-                            )?;
-
-                            idx += blocks;
-                            blocks = 0;
                         }
+
+                        idx += blocks;
+                        blocks = 0;
                     }
-
-                    if error_occurred {
-                        self.last_sense = ScsiSense::unrecovered_write_error();
-                        return Err(());
-                    }
-
-                    Ok(())
                 }
-                None => {
-                    self.last_sense = ScsiSense::medium_not_present();
-                    Err(())
-                }
-            },
-            ScsiCommand::ReadFormatCapacities { alloc_len } => match self.temp_sd.as_ref() {
-                Some(sd) => {
-                    let block_size = SdCard::BLOCK_SIZE as u32;
-                    let num_blocks = (sd.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(|_| ())
-                }
-                None => {
-                    self.last_sense = ScsiSense::medium_not_present();
-                    Err(())
-                }
-            },
-            ScsiCommand::PreventAllowMediumRemoval { prevent } => {
-                self.prevent_removal = prevent;
                 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 {
-                    SCSI_EJECTED.store(true, Ordering::Release);
                     self.pending_eject = true;
                 }
                 Ok(())
@@ -469,9 +366,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
     pub async fn send_csw_fail(&mut self, tag: u32) {
         #[cfg(feature = "defmt")]
-        if tag != 0 {
+        defmt::error!("Command Failed: {}", tag);
-            defmt::error!("Command Failed: {}", tag);
-        }
         self.send_csw(tag, 0x01, 0).await; // 0x01 = Command Failed
     }
 

kernel/src/ui.rs

@@ -1,26 +1,18 @@
 use crate::{
-    BINARY_CH,
+    BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
-    display::FRAMEBUFFER,
+    peripherals::keyboard, storage::FileName,
-    framebuffer::FB_PAUSED,
-    peripherals::keyboard,
-    scsi::SCSI_BUSY,
-    storage::{FileName, SDCARD},
 };
 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 embassy_time::Timer;
 use embedded_graphics::{
     Drawable,
-    mono_font::{
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
-        MonoTextStyle,
-        ascii::{FONT_4X6, FONT_10X20},
-    },
     pixelcolor::Rgb565,
     prelude::{Dimensions, Point, Primitive, RgbColor, Size},
     primitives::{PrimitiveStyle, Rectangle},
-    text::{Alignment, Text},
+    text::Text,
 };
 use embedded_layout::{
     align::{horizontal, vertical},
@@ -29,240 +21,167 @@ use embedded_layout::{
 };
 use embedded_text::TextBox;
 
+pub static SELECTIONS: Mutex<CriticalSectionRawMutex, SelectionList> =
+    Mutex::new(SelectionList::new());
+
 pub async fn ui_handler() {
-    let mut ui = UiState { page: UiPage::Menu };
-    let mut menu = MenuPage {
-        last_bounds: None,
-        selection: 0,
-        changed: true,
-    };
-    let mut scsi = ScsiPage { last_bounds: None };
-    update_selections().await;
-
     loop {
-        // reset page, if usb was disabled internally
+        if let Some(event) = keyboard::read_keyboard_fifo().await {
-        if ui.page == UiPage::Scsi && !SCSI_BUSY.load(Ordering::Acquire) {
+            if let KeyState::Pressed = event.state {
-            scsi.clear().await;
+                match event.key {
-            ui.page = UiPage::Menu;
+                    KeyCode::Up => {
-        } else if ui.page == UiPage::Menu && SCSI_BUSY.load(Ordering::Acquire) {
+                        let mut selections = SELECTIONS.lock().await;
-            menu.clear().await;
+                        selections.up();
-            ui.page = UiPage::Scsi;
+                    }
-        }
+                    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();
 
-        if input_handler(&mut ui, &mut menu, &mut scsi).await {
+                        let entry = unsafe {
-            return;
+                            load_binary(&selection.short_name)
-        }
+                                .await
-        match ui.page {
+                                .expect("unable to load binary")
-            UiPage::Menu => menu.draw().await,
+                        };
-            UiPage::Scsi => scsi.draw().await,
+                        BINARY_CH.send(entry).await;
-        }
+                    }
-        Timer::after_millis(5).await;
+                    _ => (),
-    }
+                }
-}
-
-async fn input_handler(ui: &mut UiState, menu: &mut MenuPage, scsi: &mut ScsiPage) -> bool {
-    if let Some(event) = keyboard::read_keyboard_fifo().await {
-        if event.state == KeyState::Pressed {
-            match (&mut ui.page, event.key) {
-                (UiPage::Menu, _) => return menu.handle_input(event.key).await,
-                (UiPage::Scsi, _) => return scsi.handle_input(event.key).await,
             }
         }
-    }
-    false
-}
 
-#[derive(PartialEq)]
+        let changed = SELECTIONS.lock().await.changed;
-enum UiPage {
+        if changed {
-    Menu,
+            clear_selection().await;
-    Scsi,
+            draw_selection().await;
-}
-
-struct UiState {
-    page: UiPage,
-}
-
-trait Page {
-    async fn draw(&mut self);
-    async fn handle_input(&mut self, key: KeyCode) -> bool;
-    async fn clear(&mut self);
-}
-
-struct ScsiPage {
-    last_bounds: Option<Rectangle>,
-}
-
-impl Page for ScsiPage {
-    async fn draw(&mut self) {
-        let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
-        let fb = unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() };
-        let bounds = fb.bounding_box();
-
-        let text = Text::with_alignment(
-            "Usb Mass storage enabled",
-            bounds.center(),
-            text_style,
-            Alignment::Center,
-        );
-
-        self.last_bounds = Some(text.bounds());
-        text.draw(fb).unwrap();
-    }
-
-    async fn handle_input(&mut self, _key: KeyCode) -> bool {
-        false
-    }
-
-    async fn clear(&mut self) {
-        if let Some(rect) = self.last_bounds {
-            clear_rect(rect).await;
         }
-        self.last_bounds = None;
     }
 }
 
-static SELECTIONS: Mutex<CriticalSectionRawMutex, Vec<FileName>> = Mutex::new(Vec::new());
+pub async fn clear_selection() {
-static mut SELECTIONS_CHANGED: bool = true;
+    let sel = SELECTIONS.lock().await;
 
-async fn update_selections() {
+    if let Some(area) = sel.last_bounds {
-    while SCSI_BUSY.load(Ordering::Acquire) {
+        Rectangle::new(area.top_left, area.size)
-        Timer::after_millis(100).await;
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-    }
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
-    let mut guard = SDCARD.get().lock().await;
+            .unwrap();
-    let sd = guard.as_mut().unwrap();
-
-    let files = sd.list_files_by_extension(".bin").unwrap();
-    let mut selections = SELECTIONS.lock().await;
-
-    if *selections != files {
-        *selections = files;
-        unsafe { SELECTIONS_CHANGED = true }
     }
 }
-struct MenuPage {
+
+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.as_mut().unwrap().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.as_mut().unwrap() })
+        .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.as_mut().unwrap() })
+            .unwrap();
+
+        guard.last_bounds = Some(layout.bounds());
+
+        layout
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
+            .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>,
-    selection: usize,
+    current_selection: u16,
+    selections: Vec<FileName>,
     changed: bool,
 }
 
-impl Page for MenuPage {
+impl SelectionList {
-    async fn draw(&mut self) {
+    pub const fn new() -> Self {
-        if self.changed {
+        Self {
-            self.clear().await;
+            last_bounds: None,
+            selections: Vec::new(),
+            current_selection: 0,
+            changed: false,
         }
-
-        let guard = SELECTIONS.lock().await;
-        let file_names = &guard.clone();
-
-        let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
-        let display_area = unsafe { FRAMEBUFFER.as_mut().unwrap().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.as_mut().unwrap() })
-            .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(self.selection)
-                .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.as_mut().unwrap() })
-                .unwrap();
-
-            self.last_bounds = Some(layout.bounds());
-
-            layout
-                .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
-                .unwrap();
-        }
-
-        self.changed = false;
-        FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
     }
 
-    async fn handle_input(&mut self, key: KeyCode) -> bool {
+    pub fn set_changed(&mut self, changed: bool) {
-        match key {
+        self.changed = changed
-            KeyCode::Enter | KeyCode::Right => {
+    }
-                let selections = SELECTIONS.lock().await;
-                let selection = selections[self.selection].clone();
 
-                self.clear().await;
+    pub fn update_selections(&mut self, selections: Vec<FileName>) {
-                BINARY_CH.send(selection.short_name).await;
+        self.selections = selections;
-                return true;
-            }
-            KeyCode::Up => {
-                if self.selection > 0 {
-                    self.selection -= 1;
-                } else {
-                    let len = SELECTIONS.lock().await.len();
-                    if len > 0 {
-                        self.selection = len - 1;
-                    }
-                }
-            }
-            KeyCode::Down => {
-                if self.selection + 1 < SELECTIONS.lock().await.len() {
-                    self.selection += 1;
-                } else {
-                    self.selection = 0; // wrap to top
-                }
-            }
-            _ => (),
-        }
         self.changed = true;
-        false
     }
 
-    async fn clear(&mut self) {
+    pub fn selections(&self) -> &Vec<FileName> {
-        if let Some(rect) = self.last_bounds {
+        &self.selections
-            clear_rect(rect).await;
+    }
+
+    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;
         }
-        self.last_bounds = None;
     }
 }
-
-pub async fn clear_screen() {
-    clear_rect(Rectangle {
-        top_left: Point::zero(),
-        size: Size::new(320, 320),
-    })
-    .await
-}
-
-async fn clear_rect(rect: Rectangle) {
-    let fb = unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() };
-    Rectangle::new(rect.top_left, rect.size)
-        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-        .draw(fb)
-        .unwrap();
-}

kernel/src/usb.rs

@@ -1,8 +1,10 @@
-use crate::scsi::{MassStorageClass, SCSI_EJECTED};
+use crate::{scsi::MassStorageClass, storage::SdCard};
-use core::sync::atomic::Ordering;
+use core::sync::atomic::{AtomicBool, Ordering};
-use embassy_futures::join::join;
+use embassy_futures::select::select;
 use embassy_rp::{peripherals::USB, usb::Driver};
-use embassy_usb::{Builder, Config};
+use embassy_usb::{Builder, Config, UsbDevice};
+
+pub static USB_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 #[embassy_executor::task]
 pub async fn usb_handler(driver: Driver<'static, USB>) {
@@ -26,18 +28,18 @@ pub async fn usb_handler(driver: Driver<'static, USB>) {
         &mut control_buf,
     );
 
-    let mut scsi = MassStorageClass::new(&mut builder);
+    let temp_sd: Option<SdCard> = None;
-    let mut usb = builder.build();
+    let mut scsi = MassStorageClass::new(&mut builder, temp_sd);
+    let usb = builder.build();
 
-    join(
+    select(run(usb), scsi.poll()).await;
-        async {
+}
-            loop {
+
-                usb.wait_resume().await;
+async fn run<'d>(mut usb: UsbDevice<'d, Driver<'d, USB>>) -> ! {
-                SCSI_EJECTED.store(false, Ordering::Release);
+    loop {
-                usb.run_until_suspend().await;
+        usb.wait_resume().await;
-            }
+        USB_ACTIVE.store(true, Ordering::Release);
-        },
+        usb.run_until_suspend().await;
-        scsi.poll(),
+        USB_ACTIVE.store(false, Ordering::Release);
-    )
+    }
-    .await;
 }

selection_ui/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "selection_ui"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-abi = { path = "../abi" }
-embedded-graphics = "0.8.1"
-embedded-layout = "0.4.2"
-embedded-text = "0.7.3"

selection_ui/src/lib.rs

@@ -1,119 +0,0 @@
-#![no_std]
-
-extern crate alloc;
-
-use abi::{
-    display::Display,
-    get_key,
-    keyboard::{KeyCode, KeyState},
-    print, sleep,
-};
-use alloc::vec::Vec;
-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 struct SelectionUi<'a> {
-    selection: usize,
-    items: &'a [&'a str],
-    error: &'a str,
-    last_bounds: Option<Rectangle>,
-}
-
-impl<'a> SelectionUi<'a> {
-    pub fn new(items: &'a [&'a str], error: &'a str) -> Self {
-        Self {
-            selection: 0,
-            items,
-            error,
-            last_bounds: None,
-        }
-    }
-
-    pub fn run_selection_ui(&mut self, display: &mut Display) -> Result<Option<usize>, ()> {
-        self.draw(display)?;
-        let selection;
-        loop {
-            let key = get_key();
-            if key.state == KeyState::Pressed {
-                print!("Got Key press: {:?}", key.key);
-                if let Some(s) = self.update(display, key.key)? {
-                    selection = Some(s);
-                    break;
-                }
-            }
-        }
-        Ok(selection)
-    }
-
-    /// updates the display with a new keypress.
-    /// returns selection idx if selected
-    pub fn update(&mut self, display: &mut Display, key: KeyCode) -> Result<Option<usize>, ()> {
-        match key {
-            KeyCode::JoyUp => {
-                self.selection = self.selection.saturating_sub(1);
-            }
-            KeyCode::JoyDown => {
-                self.selection = self.selection.saturating_add(1);
-            }
-            KeyCode::Enter | KeyCode::JoyRight => return Ok(Some(self.selection)),
-            _ => return Ok(Some(self.selection)),
-        };
-        self.draw(display)?;
-        Ok(None)
-    }
-
-    fn draw(&mut self, display: &mut Display) -> Result<(), ()> {
-        let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
-        let display_area = display.bounding_box();
-
-        if self.items.is_empty() {
-            TextBox::new(
-                &self.error,
-                Rectangle::new(
-                    Point::new(25, 25),
-                    Size::new(display_area.size.width - 50, display_area.size.width - 50),
-                ),
-                text_style,
-            )
-            .draw(display)
-            .unwrap();
-        }
-
-        let mut views: Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
-
-        for i in self.items {
-            views.push(Text::new(i, 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(self.selection).ok_or(())?.bounding_box();
-        Rectangle::new(selected_bounds.top_left, selected_bounds.size)
-            .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
-            .draw(display)?;
-
-        self.last_bounds = Some(layout.bounds());
-
-        layout.draw(display)?;
-        Ok(())
-    }
-}

user-apps/doom/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "doom"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+abi = { path = "../../abi" }
+embedded-graphics = "0.8.1"
+
+[build-dependencies]
+bindgen = "0.71.0"
+cc = "1.0"

user-apps/doom/build.rs

@@ -0,0 +1,126 @@
+//! 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::{Path, PathBuf};
+use std::process::Command;
+
+fn main() {
+    build_newlib();
+    build_doom();
+
+    // 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");
+}
+
+// TODO: use target to change newlib build - only workds for rp2350 right now
+fn build_newlib() {
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    let picolibc_dir = format!("{}/picolibc", out_dir);
+
+    if !Path::new(&picolibc_dir).exists() {
+        let status = Command::new("git")
+            .args(&[
+                "clone",
+                "https://github.com/picolibc/picolibc",
+                &picolibc_dir,
+            ])
+            .status()
+            .expect("Failed to clone picolibc");
+        assert!(status.success());
+    }
+
+    let build_dir = format!("{}/build", picolibc_dir);
+    std::fs::create_dir_all(&build_dir).unwrap();
+
+    let status = Command::new(&format!("{picolibc_dir}/scripts/do-configure"))
+        .current_dir(&build_dir)
+        .args(&[
+            "thumbv8m_main_fp-none-eabi",
+            "--buildtype=minsize",
+            "-Dtests=true",
+            "-Dtinystdio=false",
+            "-Dsingle-thread=true",
+            "-Db_pie=true",
+            "-Ddefault_library=static",
+            "-Dtinystdio=false",
+            "-Dmultilib=false",
+            ".",
+        ])
+        .status()
+        .expect("Failed to run Meson configure");
+    assert!(status.success());
+
+    let status = Command::new("ninja")
+        .current_dir(&build_dir)
+        .status()
+        .expect("Failed to run Ninja build");
+    assert!(status.success());
+
+    println!("cargo:rustc-link-search={}/newlib", build_dir);
+    println!("cargo:rustc-link-lib=c");
+    println!("cargo:rustc-link-lib=m");
+}
+
+fn build_doom() {
+    let ref dg_src_dir = std::path::PathBuf::from("doomgeneric/doomgeneric");
+    let mut dg_c_paths = vec![];
+    let mut dg_h_paths = vec![];
+
+    // Find most c and h files
+    for entry in std::fs::read_dir(dg_src_dir).unwrap() {
+        let entry = entry.unwrap();
+        if let Some(filename) = entry.file_name().to_str() {
+            if filename.starts_with("doomgeneric")
+                || filename.contains("_allegro")
+                || filename.contains("_sdl")
+                || filename.contains("net_")
+                || filename == "i_main.c"
+            {
+                continue;
+            }
+
+            if filename.ends_with(".h") {
+                dg_h_paths.push(dg_src_dir.join(filename));
+            } else if filename.ends_with(".c") {
+                dg_c_paths.push(dg_src_dir.join(filename));
+            }
+        }
+    }
+    dg_c_paths
+        .iter()
+        .chain(dg_h_paths.iter())
+        .for_each(|path| println!("cargo:rerun-if-changed={}", path.to_str().unwrap()));
+
+    cc::Build::new()
+        .compiler("arm-none-eabi-gcc")
+        .flag("-w") // silence warnings
+        .flag("-Os") // optimize for size
+        .flag("-ffunction-sections")
+        .flag("-fdata-sections")
+        .define("CMAP256", None)
+        .define("DOOMGENERIC_RESX", Some("320"))
+        .define("DOOMGENERIC_RESY", Some("200"))
+        .flag_if_supported("-std=gnu99")
+        .define("_POSIX_C_SOURCE", Some("200809L"))
+        .files(dg_c_paths)
+        .compile("doomgeneric");
+}

user-apps/doom/memory.x

@@ -0,0 +1,31 @@
+MEMORY
+{
+  RAM : ORIGIN = 0x0, LENGTH = 400K
+}
+
+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/doom/src/doom.rs

@@ -0,0 +1,112 @@
+use abi::{
+    abi_sys::{get_ms, sleep},
+    display::Display,
+};
+use core::ffi::{c_int, c_uchar};
+use embedded_graphics::{
+    Drawable, Pixel,
+    draw_target::DrawTarget,
+    pixelcolor::Rgb565,
+    prelude::{Point, RgbColor},
+};
+
+#[unsafe(no_mangle)]
+#[allow(non_snake_case)]
+static mut DG_ScreenBuffer: *const u8 = core::ptr::null();
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct RGBA {
+    pub b: u8,
+    pub g: u8,
+    pub r: u8,
+    pub a: u8,
+}
+
+unsafe extern "C" {
+    fn D_DoomMain();
+    fn doomgeneric_Tick();
+    fn M_FindResponseFile();
+
+    pub static colors: [RGBA; 256];
+}
+
+pub fn tick() {
+    unsafe { doomgeneric_Tick() };
+}
+
+pub struct ScreenBuffer<const RESX: usize, const RESY: usize, const SIZE: usize>(pub [u8; SIZE]);
+
+impl<const RESX: usize, const RESY: usize, const SIZE: usize> ScreenBuffer<RESX, RESY, SIZE> {
+    #[allow(dead_code)]
+    const NA: () = assert!(SIZE == RESX * RESY);
+
+    pub const fn new() -> Self {
+        Self([0_u8; SIZE])
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn DG_SetWindowTitle() {}
+
+pub fn create<const RESX: usize, const RESY: usize, const SIZE: usize>(
+    screenbuffer: &ScreenBuffer<RESX, RESY, SIZE>,
+) {
+    unsafe {
+        M_FindResponseFile();
+
+        DG_ScreenBuffer = screenbuffer.0.as_ptr();
+
+        D_DoomMain();
+    }
+}
+
+const X: usize = 320;
+const Y: usize = 200;
+const SIZE: usize = X * Y;
+
+pub static mut DISPLAY: Option<Display> = None;
+pub static mut SCREEN_BUFFER: ScreenBuffer<X, Y, SIZE> = ScreenBuffer::new();
+
+#[unsafe(no_mangle)]
+extern "C" fn DG_DrawFrame() {
+    let palette565: [Rgb565; 256] = unsafe {
+        colors.map(|c| {
+            Rgb565::new(
+                ((c.r as u16 * 31) / 255) as u8, // red 5 bits
+                ((c.g as u16 * 63) / 255) as u8, // green 6 bits
+                ((c.b as u16 * 31) / 255) as u8, // blue 5 bits
+            )
+        })
+    };
+    let buf = unsafe { &SCREEN_BUFFER.0 };
+
+    let display = unsafe { DISPLAY.as_mut().unwrap() };
+    display.clear(Rgb565::BLACK).unwrap();
+
+    for y in 0..Y {
+        for x in 0..X {
+            let idx = y * X + x;
+            let color = palette565[buf[idx] as usize];
+
+            Pixel(Point::new(x as i32, y as i32), color)
+                .draw(display)
+                .unwrap();
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn DG_GetTicksMs() -> u32 {
+    get_ms() as u32
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn DG_GetKey(pressed: *mut c_int, key: *mut c_uchar) -> c_int {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn DG_SleepMs(ms: u32) {
+    sleep(ms.into());
+}

user-apps/doom/src/libc.rs

@@ -0,0 +1,118 @@
+use core::ffi::{c_char, c_int, c_uchar, c_void};
+use core::ptr;
+
+#[unsafe(no_mangle)]
+pub static _ctype_: [c_uchar; 256] = [0u8; 256];
+
+#[repr(C)]
+pub struct Reent {
+    pub errno: c_int,
+    _reserved: [u8; 32],
+}
+
+#[unsafe(no_mangle)]
+pub static mut _reent_data: Reent = Reent {
+    errno: 0,
+    _reserved: [0; 32],
+};
+
+#[unsafe(no_mangle)]
+pub static mut _impure_ptr: *mut Reent = unsafe { &mut _reent_data as *mut Reent };
+
+#[unsafe(no_mangle)]
+pub extern "C" fn __errno() -> *mut c_int {
+    unsafe { &mut (*_impure_ptr).errno as *mut c_int }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn exit(_status: i32) -> ! {
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn close(_file: i32) -> i32 {
+    -1
+}
+
+#[repr(C)]
+pub struct Stat {
+    st_mode: u32,
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn fstat(_file: i32, st: *mut Stat) -> i32 {
+    unsafe {
+        if !st.is_null() {
+            (*st).st_mode = 0x2000; // S_IFCHR
+        }
+    }
+    0
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn isatty(_file: i32) -> i32 {
+    1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn lseek(_file: i32, _ptr: i32, _dir: i32) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn lseek64(_fd: c_int, _offset: i64, _whence: c_int) -> i64 {
+    0
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn open(_name: *const u8, _flags: i32, _mode: i32) -> i32 {
+    -1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn read(_file: i32, _ptr: *mut u8, len: usize) -> i32 {
+    len as i32
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn write(_file: i32, _ptr: *const u8, len: usize) -> i32 {
+    len as i32
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn rename(_old: *const c_char, _new: *const c_char) -> c_int {
+    -1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn kill(_pid: i32, _sig: i32) -> i32 {
+    -1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn getpid() -> i32 {
+    1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn link(_old: *const u8, _new: *const u8) -> i32 {
+    -1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn unlink(_name: *const u8) -> i32 {
+    -1
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn mkdir(_path: *const u8, _mode: u32) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn sbrk(incr: isize) -> *mut c_void {
+    core::ptr::null_mut()
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn fini() {}

user-apps/doom/src/main.rs

@@ -0,0 +1,43 @@
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs)]
+#![feature(c_variadic)]
+
+extern crate alloc;
+use abi::{
+    display::Display,
+    fs::{file_len, read_file},
+    get_key, get_ms,
+    keyboard::{KeyCode, KeyState},
+    print, sleep,
+};
+use alloc::vec;
+use core::panic::PanicInfo;
+use embedded_graphics::{pixelcolor::Rgb565, prelude::Point};
+
+mod doom;
+use crate::doom::{DISPLAY, SCREEN_BUFFER, create, tick};
+mod libc;
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+pub fn main() {
+    print!("Starting Doom app");
+    let display = Display;
+    unsafe { DISPLAY = Some(display) };
+
+    unsafe { create(&SCREEN_BUFFER) };
+
+    loop {
+        tick();
+    }
+}

user-apps/gallery/src/main.rs

@@ -5,12 +5,12 @@
 extern crate alloc;
 use abi::{
     display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
-    fs::{Entries, list_dir, read_file},
+    fs::{list_dir, read_file},
     get_key,
     keyboard::{KeyCode, KeyState},
     print,
 };
-use alloc::{format, vec};
+use alloc::{format, string::ToString, vec};
 use core::panic::PanicInfo;
 use embedded_graphics::{
     Drawable, image::Image, mono_font::MonoTextStyle, mono_font::ascii::FONT_6X10,
@@ -34,6 +34,7 @@ pub fn main() {
     let mut bmp_buf = vec![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;
@@ -41,44 +42,50 @@ pub fn main() {
 
     let mut images_drawn = 0;
 
-    let mut entries = Entries::new();
+    let mut files = [const { None }; 18];
-    let files_num = list_dir("/images", &mut entries);
+    let files_num = list_dir("/images", &mut files);
 
-    for file in &entries.entries()[2..files_num] {
+    for file in &files[2..files_num] {
         if images_drawn >= grid_cols * grid_rows {
             break; // only draw 3x3
         }
 
-        print!("file: {}", file);
+        if let Some(f) = file {
-        if file.extension().unwrap_or("") == "bmp" || file.extension().unwrap_or("") == "BMP" {
+            print!("file: {}", f.name);
-            let file_path = format!("/images/{}", file);
+            if f.name.extension() == b"bmp" || f.name.extension() == b"BMP" {
+                let file = format!("/images/{}", f.name);
 
-            let read = read_file(&file_path, 0, &mut &mut bmp_buf[..]);
+                let read = read_file(&file, 0, &mut &mut bmp_buf[..]);
-            if read > 0 {
+                if read > 0 {
-                let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
+                    let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
 
-                let row = images_drawn / grid_cols;
+                    let row = images_drawn / grid_cols;
-                let col = images_drawn % grid_cols;
+                    let col = images_drawn % grid_cols;
-                let cell_x = col * cell_width;
+                    let cell_x = col * cell_width;
-                let cell_y = row * cell_height;
+                    let cell_y = row * cell_height;
 
-                // Center image inside cell
+                    // Center image inside cell
-                let bmp_w = bmp.size().width as i32;
+                    let bmp_w = bmp.size().width as i32;
-                let bmp_h = bmp.size().height as i32;
+                    let bmp_h = bmp.size().height as i32;
-                let x = cell_x + (cell_width - bmp_w) / 2;
+                    let x = cell_x + (cell_width - bmp_w) / 2;
-                let y = cell_y + 5; // 5px top margin
+                    let y = cell_y + 5; // 5px top margin
 
-                Image::new(&bmp, Point::new(x, y))
+                    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();
 
-                let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+                    images_drawn += 1;
-                let text_y = y + bmp_h + 2; // 2px gap under image
+                }
-                Text::new(&file.base(), Point::new(cell_x + 2, text_y), text_style)
-                    .draw(&mut display)
-                    .unwrap();
-
-                images_drawn += 1;
             }
         }
     }

user-apps/gif/Cargo.toml

@@ -6,5 +6,4 @@ edition = "2024"
 [dependencies]
 abi = { path = "../../abi" }
 embedded-graphics = "0.8.1"
-selection_ui = { path = "../../selection_ui" }
 tinygif = { git = "https://github.com/LegitCamper/tinygif" }

user-apps/gif/src/main.rs

@@ -4,17 +4,16 @@
 extern crate alloc;
 use abi::{
     display::Display,
-    fs::{Entries, file_len, list_dir, read_file},
+    fs::{file_len, read_file},
     get_key, get_ms,
     keyboard::{KeyCode, KeyState},
     print, sleep,
 };
-use alloc::{format, vec, vec::Vec};
+use alloc::vec;
 use core::panic::PanicInfo;
 use embedded_graphics::{
     image::ImageDrawable, pixelcolor::Rgb565, prelude::Point, transform::Transform,
 };
-use selection_ui::SelectionUi;
 use tinygif::Gif;
 
 #[panic_handler]
@@ -32,27 +31,13 @@ pub fn main() {
     print!("Starting Gif app");
     let mut display = Display;
 
-    let mut entries = Entries::new();
+    let size = file_len("/gifs/bad_apple.gif");
-    list_dir("/gifs", &mut entries);
-
-    let mut files = entries.entries();
-    files.retain(|e| e.extension().unwrap_or("") == "gif");
-    let gifs = &files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
-
-    let mut selection_ui = SelectionUi::new(&gifs, "No Gif files found in /gifs");
-    let selection = selection_ui
-        .run_selection_ui(&mut display)
-        .expect("failed to draw")
-        .expect("Failed to get user selection");
-
-    let file_name = format!("/gifs/{}", gifs[selection]);
-    let size = file_len(&file_name);
     let mut buf = vec![0_u8; size];
-    let read = read_file(&file_name, 0, &mut buf);
+    let read = read_file("/gifs/bad_apple.gif", 0, &mut buf);
     print!("read: {}, file size: {}", read, size);
     assert!(read == size);
 
-    let gif = Gif::<Rgb565>::from_slice(&buf).expect("Failed to parse gif");
+    let gif = Gif::<Rgb565>::from_slice(&buf).unwrap();
     let height = gif.height();
 
     let mut frame_num = 0;
@@ -66,14 +51,11 @@ pub fn main() {
                 .unwrap();
             frame_num += 1;
 
-            if frame_num % 5 == 0 {
+            if frame_num % 100 == 0 {
                 let event = get_key();
                 if event.state != KeyState::Idle {
                     match event.key {
-                        KeyCode::Esc => {
+                        KeyCode::Esc => return,
-                            drop(buf);
-                            return;
-                        }
                         _ => (),
                     };
                 };