yield display to audio

fix release

.gitignore

@@ -2,3 +2,5 @@
 *.uf2
 abi_sys.h
 assets/gif/bad_apple.gif
+picolibc
+user-apps/gboy/Peanut-GB

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "picolibc"]
+	path = picolibc
+	url = https://github.com/picolibc/picolibc
+[submodule "user-apps/gboy/Peanut-GB"]
+	path = user-apps/gboy/Peanut-GB
+	url = https://github.com/deltabeard/Peanut-GB

Cargo.toml

@@ -9,6 +9,7 @@ members = [
   "user-apps/snake",
   "user-apps/gallery",
   "user-apps/gif",
+  "user-apps/wav_player",
 ]
 
 [profile.release]
@@ -23,7 +24,7 @@ codegen-units = 1
 lto = true
 debug = false
 opt-level = "z"
-panic = "abort"
+panic = "unwind"
 
 [profile.dev]
 lto = true

abi/src/lib.rs

@@ -3,8 +3,8 @@
 
 extern crate alloc;
 
-pub use abi_sys::{self, keyboard};
-use abi_sys::{RngRequest, alloc, dealloc, keyboard::KeyEvent};
+use abi_sys::{RngRequest, keyboard::KeyEvent};
+pub use abi_sys::{keyboard, print};
 pub use alloc::format;
 use core::alloc::{GlobalAlloc, Layout};
 use rand_core::RngCore;
@@ -16,19 +16,19 @@ struct Alloc;
 
 unsafe impl GlobalAlloc for Alloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        alloc(layout.into())
+        abi_sys::alloc(layout.into())
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        dealloc(ptr, layout.into());
+        abi_sys::dealloc(ptr, layout.into());
     }
 }
 
 #[macro_export]
-macro_rules! print {
+macro_rules! println {
     ($($arg:tt)*) => {{
         let s = $crate::format!($($arg)*);
-        $crate::abi_sys::print(s.as_ptr(), s.len());
+        $crate::print(s.as_ptr(), s.len());
     }};
 }
 
@@ -45,6 +45,8 @@ pub fn get_key() -> KeyEvent {
 }
 
 pub mod display {
+    use core::sync::atomic::{AtomicBool, Ordering};
+
     use abi_sys::CPixel;
     use embedded_graphics::{
         Pixel,
@@ -59,12 +61,28 @@ pub mod display {
 
     pub type Pixel565 = Pixel<Rgb565>;
 
-    const BUF_SIZE: usize = 15 * 1024; // tune this for performance
+    const BUF_SIZE: usize = 1024;
     static mut BUF: [CPixel; BUF_SIZE] = [CPixel::new(); BUF_SIZE];
-    // const BUF_SIZE: usize = 250 * 1024; // tune this for performance
-    // static mut BUF: Lazy<Vec<CPixel>> = Lazy::new(|| vec![const { CPixel::new() }; BUF_SIZE]);
 
-    pub struct Display;
+    static DISPLAY_TAKEN: AtomicBool = AtomicBool::new(false);
+
+    pub struct Display {
+        _private: (),
+    }
+
+    impl Display {
+        /// Only one instance of Display can be taken
+        pub fn take() -> Option<Display> {
+            if DISPLAY_TAKEN
+                .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+                .is_ok()
+            {
+                Some(Self { _private: () })
+            } else {
+                None
+            }
+        }
+    }
 
     impl Dimensions for Display {
         fn bounding_box(&self) -> Rectangle {
@@ -140,20 +158,30 @@ impl RngCore for Rng {
 }
 
 pub mod fs {
+    use alloc::vec::Vec;
     use core::fmt::Display;
 
-    use alloc::{format, vec::Vec};
-
-    pub fn read_file(file: &str, read_from: usize, buf: &mut [u8]) -> usize {
+    pub fn read_file(file: &str, start_from: usize, buf: &mut [u8]) -> usize {
         abi_sys::read_file(
             file.as_ptr(),
             file.len(),
-            read_from,
+            start_from,
             buf.as_mut_ptr(),
             buf.len(),
         )
     }
 
+    pub fn write_file(file: &str, start_from: usize, buf: &[u8]) {
+        abi_sys::write_file(
+            file.as_ptr(),
+            file.len(),
+            start_from,
+            buf.as_ptr(),
+            buf.len(),
+        )
+    }
+
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
     pub struct FileName<'a> {
         full: &'a str,
         base: &'a str,
@@ -197,7 +225,7 @@ pub mod fs {
     const MAX_ENTRY_NAME_LEN: usize = 25;
     const MAX_ENTRIES: usize = 25;
 
-    #[derive(Clone, Copy)]
+    #[derive(Clone, Copy, Debug)]
     pub struct Entries([[u8; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]);
 
     impl Entries {
@@ -239,3 +267,11 @@ pub mod fs {
         abi_sys::file_len(str.as_ptr(), str.len())
     }
 }
+
+pub mod audio {
+    pub use abi_sys::{AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES, audio_buffer_ready};
+
+    pub fn send_audio_buffer(buf: &[u8]) {
+        abi_sys::send_audio_buffer(buf.as_ptr(), buf.len())
+    }
+}

abi_sys/src/lib.rs

@@ -12,7 +12,7 @@ use strum::{EnumCount, EnumIter};
 
 pub type EntryFn = fn();
 
-pub const ABI_CALL_TABLE_COUNT: usize = 11;
+pub const ABI_CALL_TABLE_COUNT: usize = 14;
 const _: () = assert!(ABI_CALL_TABLE_COUNT == CallTable::COUNT);
 
 #[derive(Clone, Copy, EnumIter, EnumCount)]
@@ -28,7 +28,10 @@ pub enum CallTable {
     GenRand = 7,
     ListDir = 8,
     ReadFile = 9,
-    FileLen = 10,
+    WriteFile = 10,
+    FileLen = 11,
+    AudioBufferReady = 12,
+    SendAudioBuffer = 13,
 }
 
 #[unsafe(no_mangle)]
@@ -438,6 +441,24 @@ pub extern "C" fn read_file(
     }
 }
 
+pub type WriteFile =
+    extern "C" fn(str: *const u8, len: usize, write_from: usize, buf: *const u8, buf_len: usize);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn write_file(
+    str: *const u8,
+    len: usize,
+    write_from: usize,
+    buf: *const u8,
+    buf_len: usize,
+) {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallTable::WriteFile as usize];
+        let f: WriteFile = core::mem::transmute(ptr);
+        f(str, len, write_from, buf, buf_len)
+    }
+}
+
 pub type FileLen = extern "C" fn(str: *const u8, len: usize) -> usize;
 
 #[unsafe(no_mangle)]
@@ -448,3 +469,28 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
         f(str, len)
     }
 }
+
+pub type AudioBufferReady = extern "C" fn() -> bool;
+
+#[allow(unused)]
+pub fn audio_buffer_ready() -> bool {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallTable::AudioBufferReady as usize];
+        let f: AudioBufferReady = core::mem::transmute(ptr);
+        f()
+    }
+}
+
+pub const AUDIO_BUFFER_SAMPLES: usize = 1024;
+pub const AUDIO_BUFFER_LEN: usize = AUDIO_BUFFER_SAMPLES * 2;
+
+pub type SendAudioBuffer = extern "C" fn(ptr: *const u8, len: usize);
+
+#[allow(unused)]
+pub fn send_audio_buffer(buf: *const u8, len: usize) {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallTable::SendAudioBuffer as usize];
+        let f: SendAudioBuffer = core::mem::transmute(ptr);
+        f(buf, len)
+    }
+}

justfile

@@ -1,5 +1,7 @@
 kernel-dev board:
-    cargo run --bin kernel --features {{board}}
+    cargo run --bin kernel --features {{board}}  --features fps
+kernel-release-probe board:
+    cargo run --bin kernel --profile release --features {{board}}  --features fps
 kernel-release board:
     cargo build --bin kernel --release --no-default-features --features {{board}}
     elf2uf2-rs -d target/thumbv8m.main-none-eabihf/release/kernel
@@ -9,6 +11,26 @@ binary-args := "RUSTFLAGS=\"-C link-arg=-pie -C relocation-model=pic\""
 cbindgen:
     cbindgen abi_sys --output abi_sys.h -q
 
+newlib:
+    #!/bin/bash
+    cd picolibc
+    mkdir build
+    cd build
+    CONFIG_PICOLIBC=true ../scripts/do-configure thumbv8m_main_fp-none-eabi \
+        --buildtype=minsize \
+        -Dtests=true \
+        -Dtinystdio=false \
+        -Dsingle-thread=true \
+        -Db_pie=true \
+        -Ddefault_library=static \
+        -Dtinystdio=false \
+        -Dnewlib-nano-malloc=true \
+        -Dmultilib=false \
+        -Dpicolib=true \
+        "$@" 
+    DESTDIR=./install meson install
+    ninja
+
 userapp app:
      {{binary-args}} cargo build --bin {{app}} --profile release-binary
 
@@ -17,3 +39,20 @@ userapps: cbindgen
     just userapp snake
     just userapp gallery
     just userapp gif
+    just userapp wav_player
+
+copy-userapp app:
+    cp ./target/thumbv8m.main-none-eabihf/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin
+
+copy-userapps:
+    #!/bin/bash
+    just userapps
+    just copy-userapp calculator
+    just copy-userapp snake
+    just copy-userapp gallery
+    just copy-userapp gif
+    just copy-userapp wav_player
+
+    DEV=$(lsblk -o LABEL,NAME -nr | awk -v L="PICOCALC" '$1==L {print "/dev/" $2}')
+    udisksctl unmount -b "$DEV"
+    udisksctl power-off -b "$DEV"    

kernel/Cargo.toml

@@ -12,10 +12,13 @@ bench = false
 
 [features]
 default = ["rp235x", "defmt"]
-pimoroni2w = ["rp235x"]
-rp2040 = ["embassy-rp/rp2040"]
+pimoroni2w = ["rp235x", "psram"]
+# rp2040 = ["embassy-rp/rp2040"] # unsupported, ram too small for fb
 rp235x = ["embassy-rp/rp235xb"]
 trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
+psram = ["dep:embedded-alloc"]
+overclock = []
+fps = []
 defmt = [
   "dep:defmt",
   "panic-probe/print-defmt",
@@ -70,16 +73,17 @@ panic-probe = "0.3"
 portable-atomic = { version = "1.11", features = ["critical-section"] }
 assign-resources = "0.5.0"
 
-defmt = { version = "0.3", optional = true }
-defmt-rtt = "0.4.2"
+defmt = { version = "1.0.1", optional = true }
+defmt-rtt = "1.1.0"
 
 embedded-sdmmc = { version = "0.9", default-features = false }
 st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", rev = "a784b9e6df0769371dfc522528e770cf8fc6403a" } # async branch
 embedded-graphics = { version = "0.8.1" }
 embedded-text = "0.7.2"
 embedded-layout = "0.4.2"
-kolibri-embedded-gui = "0.1.0"
 
+micromath = "2.1.0"
+fixed = "1.29.0"
 strum = { version = "0.27.2", default-features = false }
 rand = { version = "0.9.0", default-features = false }
 once_cell = { version = "1.21.3", default-features = false }
@@ -90,7 +94,9 @@ spin = "0.10.0"
 num_enum = { version = "0.7.4", default-features = false }
 goblin = { version = "0.10.1", default-features = false, features = ["elf32"] }
 talc = "4.4.3"
-embedded-alloc = { version = "0.6.0", features = ["allocator_api"] }
+embedded-alloc = { version = "0.6.0", features = [
+  "allocator_api",
+], optional = true }
 bumpalo = "3.19.0"
 
 abi_sys = { path = "../abi_sys" }

kernel/src/abi.rs

@@ -1,16 +1,24 @@
 use abi_sys::{
-    AllocAbi, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen, GenRand, GetMsAbi, ListDir,
-    PrintAbi, ReadFile, RngRequest, SleepMsAbi, keyboard::*,
+    AUDIO_BUFFER_SAMPLES, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi,
+    FileLen, GenRand, GetMsAbi, ListDir, PrintAbi, ReadFile, RngRequest, SendAudioBuffer,
+    SleepMsAbi, WriteFile, keyboard::*,
 };
 use alloc::{string::ToString, vec::Vec};
-use core::{alloc::GlobalAlloc, ffi::c_char, ptr, sync::atomic::Ordering};
+use core::{ffi::c_char, ptr, 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 heapless::spsc::Queue;
 
+#[cfg(feature = "psram")]
+use crate::heap::HEAP;
+
+#[cfg(feature = "psram")]
+use core::alloc::GlobalAlloc;
+
 use crate::{
+    audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY},
     display::FRAMEBUFFER,
     framebuffer::FB_PAUSED,
     storage::{Dir, File, SDCARD},
@@ -20,10 +28,14 @@ const _: AllocAbi = alloc;
 pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
     // SAFETY: caller guarantees layout is valid
     unsafe {
-        if cfg!(feature = "pimoroni2w") {
-            crate::heap::HEAP.alloc(layout.into())
-        } else {
-            alloc::alloc::alloc(layout.into())
+        #[cfg(feature = "psram")]
+        {
+            return HEAP.alloc(layout.into());
+        }
+
+        #[cfg(not(feature = "psram"))]
+        {
+            return alloc::alloc::alloc(layout.into());
         }
     }
 }
@@ -31,12 +43,14 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
 const _: DeallocAbi = dealloc;
 pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) {
     // SAFETY: caller guarantees ptr and layout are valid
-    unsafe {
-        if cfg!(feature = "pimoroni2w") {
-            crate::heap::HEAP.dealloc(ptr, layout.into())
-        } else {
-            alloc::alloc::dealloc(ptr, layout.into())
-        }
+    #[cfg(feature = "psram")]
+    {
+        unsafe { HEAP.dealloc(ptr, layout.into()) }
+    }
+
+    #[cfg(not(feature = "psram"))]
+    {
+        unsafe { alloc::alloc::dealloc(ptr, layout.into()) }
     }
 }
 
@@ -206,7 +220,8 @@ fn recurse_file<T>(
                 }
             }
         })
-        .unwrap();
+        .expect("Failed to iterate dir");
+
         if let Some(name) = short_name {
             let mut file = dir
                 .open_file_in_dir(name, embedded_sdmmc::Mode::ReadWriteAppend)
@@ -230,7 +245,17 @@ pub extern "C" fn read_file(
 ) -> usize {
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let file = unsafe { core::str::from_raw_parts(str, len) };
-    let file: Vec<&str> = file.split('/').collect();
+
+    let mut components: [&str; 8] = [""; 8];
+    let mut count = 0;
+    for part in file.split('/') {
+        if count >= components.len() {
+            break;
+        }
+        components[count] = part;
+        count += 1;
+    }
+
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let mut buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
 
@@ -240,8 +265,8 @@ pub extern "C" fn read_file(
     let sd = guard.as_mut().unwrap();
     if !file.is_empty() {
         sd.access_root_dir(|root| {
-            if let Ok(result) = recurse_file(&root, &file[1..], |file| {
-                file.seek_from_start(start_from as u32).unwrap();
+            if let Ok(result) = recurse_file(&root, &components[1..count], |file| {
+                file.seek_from_start(start_from as u32).unwrap_or(());
                 file.read(&mut buf).unwrap()
             }) {
                 read = result
@@ -251,9 +276,46 @@ pub extern "C" fn read_file(
     read
 }
 
+const _: WriteFile = write_file;
+pub extern "C" fn write_file(
+    str: *const u8,
+    len: usize,
+    start_from: usize,
+    buf: *const u8,
+    buf_len: usize,
+) {
+    // SAFETY: caller guarantees str ptr is valid for `len` bytes
+    let file = unsafe { core::str::from_raw_parts(str, len) };
+
+    let mut components: [&str; 8] = [""; 8];
+    let mut count = 0;
+    for part in file.split('/') {
+        if count >= components.len() {
+            break;
+        }
+        components[count] = part;
+        count += 1;
+    }
+
+    // SAFETY: caller guarantees buf ptr is valid for `buf_len` bytes
+    let buf = unsafe { core::slice::from_raw_parts(buf, buf_len) };
+
+    let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
+    let sd = guard.as_mut().unwrap();
+    if !file.is_empty() {
+        sd.access_root_dir(|root| {
+            recurse_file(&root, &components[1..count], |file| {
+                file.seek_from_start(start_from as u32).unwrap();
+                file.write(&buf).unwrap()
+            })
+            .unwrap_or(())
+        });
+    };
+}
+
 const _: FileLen = file_len;
 pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
-    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    // SAFETY: caller guarantees str ptr is valid for `len` bytes
     let file = unsafe { core::str::from_raw_parts(str, len) };
     let file: Vec<&str> = file.split('/').collect();
 
@@ -270,3 +332,28 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     }
     len as usize
 }
+
+const _: AudioBufferReady = audio_buffer_ready;
+pub extern "C" fn audio_buffer_ready() -> bool {
+    AUDIO_BUFFER_READY.load(Ordering::Acquire)
+}
+
+const _: SendAudioBuffer = send_audio_buffer;
+pub extern "C" fn send_audio_buffer(ptr: *const u8, len: usize) {
+    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    let buf = unsafe { core::slice::from_raw_parts(ptr, len) };
+
+    while !AUDIO_BUFFER_READY.load(Ordering::Acquire) {}
+
+    if buf.len() == AUDIO_BUFFER_SAMPLES * 2 {
+        AUDIO_BUFFER_READY.store(false, Ordering::Release);
+        unsafe { AUDIO_BUFFER.copy_from_slice(buf) };
+    } else {
+        #[cfg(feature = "defmt")]
+        defmt::warn!(
+            "user audio stream was wrong size: {} should be {}",
+            buf.len(),
+            AUDIO_BUFFER_SAMPLES * 2
+        )
+    }
+}

kernel/src/audio.rs

@@ -0,0 +1,149 @@
+use crate::Audio;
+use core::sync::atomic::{AtomicBool, Ordering};
+use embassy_futures::join::join;
+use embassy_rp::{
+    Peri,
+    clocks::clk_sys_freq,
+    dma::{AnyChannel, Channel},
+    gpio::Level,
+    pio::{
+        Common, Config, Direction, FifoJoin, Instance, LoadedProgram, PioPin, ShiftConfig,
+        StateMachine, program::pio_asm,
+    },
+};
+use fixed::traits::ToFixed;
+
+pub const SAMPLE_RATE_HZ: u32 = 22_050;
+const AUDIO_BUFFER_SAMPLES: usize = 1024;
+const _: () = assert!(AUDIO_BUFFER_SAMPLES == abi_sys::AUDIO_BUFFER_SAMPLES);
+
+// 8bit stereo interleaved PCM audio buffers
+pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2];
+static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2];
+
+pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true);
+
+#[embassy_executor::task]
+pub async fn audio_handler(mut audio: Audio) {
+    const SILENCE_VALUE: u8 = u8::MAX / 2;
+
+    let prg = PioPwmAudioProgram8Bit::new(&mut audio.pio);
+    let mut pwm_pio_left =
+        PioPwmAudio::new(audio.dma0, &mut audio.pio, audio.sm0, audio.left, &prg);
+    let mut pwm_pio_right =
+        PioPwmAudio::new(audio.dma1, &mut audio.pio, audio.sm1, audio.right, &prg);
+
+    loop {
+        write_samples(&mut pwm_pio_left, &mut pwm_pio_right, unsafe {
+            &AUDIO_BUFFER_1
+        })
+        .await;
+        unsafe { &mut AUDIO_BUFFER_1 }.fill(SILENCE_VALUE);
+
+        unsafe { core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1) };
+        AUDIO_BUFFER_READY.store(true, Ordering::Release)
+    }
+}
+
+async fn write_samples<PIO: Instance>(
+    left: &mut PioPwmAudio<'static, PIO, 0>,
+    right: &mut PioPwmAudio<'static, PIO, 1>,
+    buf: &[u8],
+) {
+    // pack two samples per word
+    let mut packed_buf_left: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2];
+    let mut packed_buf_right: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2];
+
+    for ((pl, pr), sample) in packed_buf_left
+        .iter_mut()
+        .zip(packed_buf_right.iter_mut())
+        .zip(buf.chunks(4))
+    {
+        *pl = pack_u8_samples(sample[0], sample[2]);
+        *pr = pack_u8_samples(sample[1], sample[3]);
+    }
+
+    let left_fut = left
+        .sm
+        .tx()
+        .dma_push(left.dma.reborrow(), &packed_buf_left, false);
+
+    let right_fut = right
+        .sm
+        .tx()
+        .dma_push(right.dma.reborrow(), &packed_buf_right, false);
+
+    join(left_fut, right_fut).await;
+}
+
+struct PioPwmAudioProgram8Bit<'d, PIO: Instance>(LoadedProgram<'d, PIO>);
+
+/// Writes one sample to pwm as high and low time
+impl<'d, PIO: Instance> PioPwmAudioProgram8Bit<'d, PIO> {
+    fn new(common: &mut Common<'d, PIO>) -> Self {
+        // only uses 16 bits top for high, bottom for low
+        // allows two samples per word
+        let prg = pio_asm!(
+            "out x, 8", // pwm high time
+            "out y, 8", // pwm low time
+            "loop_high:",
+            "set pins, 1",       // keep pin high
+            "jmp x-- loop_high", // decrement X until 0
+            "loop_low:",
+            "set pins, 0",      // keep pin low
+            "jmp y-- loop_low", // decrement Y until 0
+        );
+
+        let prg = common.load_program(&prg.program);
+
+        Self(prg)
+    }
+}
+
+struct PioPwmAudio<'d, PIO: Instance, const SM: usize> {
+    dma: Peri<'d, AnyChannel>,
+    sm: StateMachine<'d, PIO, SM>,
+}
+
+impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> {
+    fn new(
+        dma: Peri<'d, impl Channel>,
+        pio: &mut Common<'d, PIO>,
+        mut sm: StateMachine<'d, PIO, SM>,
+        pin: Peri<'d, impl PioPin>,
+        prg: &PioPwmAudioProgram8Bit<'d, PIO>,
+    ) -> Self {
+        let pin = pio.make_pio_pin(pin);
+        sm.set_pins(Level::High, &[&pin]);
+        sm.set_pin_dirs(Direction::Out, &[&pin]);
+
+        let mut cfg = Config::default();
+        cfg.set_set_pins(&[&pin]);
+        cfg.fifo_join = FifoJoin::TxOnly;
+        let mut shift_cfg = ShiftConfig::default();
+        shift_cfg.auto_fill = true;
+        cfg.shift_out = shift_cfg;
+        cfg.use_program(&prg.0, &[]);
+        sm.set_config(&cfg);
+
+        let target_clock = (u8::MAX as u32 + 1) * SAMPLE_RATE_HZ;
+        let divider = (clk_sys_freq() / (target_clock * 2)).to_fixed();
+        sm.set_clock_divider(divider);
+
+        sm.set_enable(true);
+
+        Self {
+            dma: dma.into(),
+            sm,
+        }
+    }
+}
+
+/// packs two u8 samples into 32bit word
+fn pack_u8_samples(sample1: u8, sample2: u8) -> u32 {
+    (u8_pcm_to_pwm(sample1) as u32) << 16 | u8_pcm_to_pwm(sample2) as u32
+}
+
+fn u8_pcm_to_pwm(sample: u8) -> u16 {
+    ((sample as u16) << 8) | ((u8::MAX - sample) as u16)
+}

kernel/src/display.rs

@@ -1,20 +1,24 @@
 use crate::framebuffer::{self, AtomicFrameBuffer, FB_PAUSED};
 use core::alloc::{GlobalAlloc, Layout};
 use core::sync::atomic::Ordering;
+use embassy_futures::yield_now;
 use embassy_rp::{
     Peri,
     gpio::{Level, Output},
     peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
     spi::{Async, Spi},
 };
-use embassy_time::{Delay, Timer};
-use embedded_graphics::{
-    pixelcolor::Rgb565,
-    prelude::{DrawTarget, RgbColor},
-};
+use embassy_time::Delay;
+use embedded_graphics::{draw_target::DrawTarget, pixelcolor::Rgb565, prelude::RgbColor};
 use embedded_hal_bus::spi::ExclusiveDevice;
 use st7365p_lcd::ST7365P;
 
+#[cfg(feature = "psram")]
+use crate::heap::HEAP;
+
+#[cfg(feature = "fps")]
+pub use framebuffer::fps::{FPS_CANVAS, FPS_COUNTER};
+
 type DISPLAY = ST7365P<
     ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
     Output<'static>,
@@ -29,18 +33,21 @@ pub static mut FRAMEBUFFER: Option<AtomicFrameBuffer> = None;
 
 fn init_fb() {
     unsafe {
-        FRAMEBUFFER = Some(if cfg!(not(feature = "pimoroni2w")) {
-            static mut BUF: [u16; framebuffer::SIZE] = [0; framebuffer::SIZE];
-            AtomicFrameBuffer::new(&mut BUF)
-        } else {
-            let slab = crate::heap::HEAP.alloc(Layout::array::<u16>(framebuffer::SIZE).unwrap())
-                as *mut u16;
+        #[cfg(feature = "psram")]
+        {
+            let slab = HEAP.alloc(Layout::array::<u16>(framebuffer::SIZE).unwrap()) as *mut u16;
             let buf = core::slice::from_raw_parts_mut(slab, framebuffer::SIZE);
 
             let mut fb = AtomicFrameBuffer::new(buf);
             fb.clear(Rgb565::BLACK).unwrap();
-            fb
-        });
+            FRAMEBUFFER = Some(fb);
+        }
+
+        #[cfg(not(feature = "psram"))]
+        {
+            static mut BUF: [u16; framebuffer::SIZE] = [0; framebuffer::SIZE];
+            FRAMEBUFFER = Some(AtomicFrameBuffer::new(&mut BUF));
+        }
     }
 }
 
@@ -78,7 +85,21 @@ pub async fn init_display(
 
 #[embassy_executor::task]
 pub async fn display_handler(mut display: DISPLAY) {
+    use embassy_time::{Instant, Timer};
+
+    // Target ~60 Hz refresh (≈16.67 ms per frame)
+    const FRAME_TIME_MS: u64 = 1000 / 60;
+
     loop {
+        let start = Instant::now();
+
+        #[cfg(feature = "fps")]
+        unsafe {
+            if FPS_COUNTER.should_draw() {
+                FPS_CANVAS.draw_fps().await;
+            }
+        }
+
         if !FB_PAUSED.load(Ordering::Acquire) {
             unsafe {
                 FRAMEBUFFER
@@ -86,11 +107,15 @@ pub async fn display_handler(mut display: DISPLAY) {
                     .unwrap()
                     .partial_draw(&mut display)
                     .await
-                    .unwrap()
-            };
+                    .unwrap();
+            }
         }
 
-        // small yield to allow other tasks to run
-        Timer::after_nanos(500).await;
+        let elapsed = start.elapsed().as_millis() as u64;
+        if elapsed < FRAME_TIME_MS {
+            Timer::after_millis(FRAME_TIME_MS - elapsed).await;
+        } else {
+            yield_now().await;
+        }
     }
 }

kernel/src/elf.rs

@@ -2,8 +2,7 @@ use crate::{
     abi,
     storage::{File, SDCARD},
 };
-use abi_sys::CallTable;
-use abi_sys::EntryFn;
+use abi_sys::{CallTable, EntryFn};
 use alloc::{vec, vec::Vec};
 use bumpalo::Bump;
 use core::ptr;
@@ -206,7 +205,10 @@ fn patch_abi(
                             CallTable::GenRand => abi::gen_rand as usize,
                             CallTable::ListDir => abi::list_dir as usize,
                             CallTable::ReadFile => abi::read_file as usize,
+                            CallTable::WriteFile => abi::write_file as usize,
                             CallTable::FileLen => abi::file_len as usize,
+                            CallTable::AudioBufferReady => abi::audio_buffer_ready as usize,
+                            CallTable::SendAudioBuffer => abi::send_audio_buffer as usize,
                         };
                         unsafe {
                             table_base.add(idx as usize).write(ptr);

kernel/src/framebuffer.rs

@@ -13,6 +13,9 @@ use embedded_hal_2::digital::OutputPin;
 use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
 use st7365p_lcd::ST7365P;
 
+#[cfg(feature = "fps")]
+use fps::{FPS_CANVAS, FPS_CANVAS_HEIGHT, FPS_CANVAS_WIDTH, FPS_CANVAS_X, FPS_CANVAS_Y};
+
 const TILE_SIZE: usize = 16; // 16x16 tile
 const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
 const NUM_TILE_ROWS: usize = SCREEN_WIDTH / TILE_SIZE;
@@ -130,9 +133,34 @@ impl<'a> AtomicFrameBuffer<'a> {
             tile.store(false, Ordering::Release);
         }
 
+        #[cfg(feature = "fps")]
+        unsafe {
+            crate::display::FPS_COUNTER.measure()
+        }
+
         Ok(())
     }
 
+    // used when doing a full screen refresh fps must be drawn into fb
+    // unfortunately it is not garenteed to not be drawn over before
+    // being pushed to the display
+    #[cfg(feature = "fps")]
+    pub fn draw_fps_into_fb(&mut self) {
+        unsafe {
+            let canvas = &FPS_CANVAS.canvas;
+
+            for y in 0..FPS_CANVAS_HEIGHT {
+                let fb_y = FPS_CANVAS_Y + y;
+                let fb_row_start = fb_y * SCREEN_WIDTH + FPS_CANVAS_X;
+                let canvas_row_start = y * FPS_CANVAS_WIDTH;
+
+                self.fb[fb_row_start..fb_row_start + FPS_CANVAS_WIDTH].copy_from_slice(
+                    &canvas[canvas_row_start..canvas_row_start + FPS_CANVAS_WIDTH],
+                );
+            }
+        }
+    }
+
     // copy N tiles horizontally to the right into batch tile buf
     fn append_tiles_to_batch(
         &mut self,
@@ -152,6 +180,45 @@ impl<'a> AtomicFrameBuffer<'a> {
                 &self.fb[fb_row_offset..fb_row_offset + (total_tiles as usize * TILE_SIZE)];
 
             batch_row.copy_from_slice(fb_row);
+
+            // override fps pixel region with fps
+            // avoids writing to fps, and having it overridden before draw
+            #[cfg(feature = "fps")]
+            {
+                let global_y = tile_y as usize * TILE_SIZE + batch_row_num;
+
+                if global_y >= FPS_CANVAS_Y && global_y < FPS_CANVAS_Y + FPS_CANVAS_HEIGHT {
+                    let start_x = tile_x as usize * TILE_SIZE;
+                    let end_x = start_x + (total_tiles as usize * TILE_SIZE);
+
+                    // horizontal overlap check
+                    let fps_x0 = FPS_CANVAS_X;
+                    let fps_x1 = FPS_CANVAS_X + FPS_CANVAS_WIDTH;
+
+                    let x0 = start_x.max(fps_x0);
+                    let x1 = end_x.min(fps_x1);
+
+                    if x1 > x0 {
+                        let row_in_fps = global_y - FPS_CANVAS_Y;
+                        let fps_off = row_in_fps
+                            .checked_mul(FPS_CANVAS_WIDTH)
+                            .and_then(|v| v.checked_add(x0 - fps_x0));
+                        let batch_off = x0 - start_x;
+                        let len = x1 - x0;
+
+                        if let Some(fps_off) = fps_off {
+                            let fps_len_ok = fps_off + len <= unsafe { FPS_CANVAS.canvas.len() };
+                            let batch_len_ok = batch_off + len <= batch_row.len();
+
+                            if fps_len_ok && batch_len_ok {
+                                batch_row[batch_off..batch_off + len].copy_from_slice(unsafe {
+                                    &FPS_CANVAS.canvas[fps_off..fps_off + len]
+                                });
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 
@@ -167,9 +234,25 @@ impl<'a> AtomicFrameBuffer<'a> {
         DELAY: DelayNs,
     {
         if self.should_full_draw() {
+            #[cfg(feature = "fps")]
+            self.draw_fps_into_fb();
             return self.draw(display).await;
         }
 
+        #[cfg(feature = "fps")]
+        {
+            let fps_tile_x = FPS_CANVAS_X / TILE_SIZE;
+            let fps_tile_y = FPS_CANVAS_Y / TILE_SIZE;
+            let fps_tile_w = (FPS_CANVAS_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
+            let fps_tile_h = (FPS_CANVAS_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
+
+            for ty in fps_tile_y..fps_tile_y + fps_tile_h {
+                for tx in fps_tile_x..fps_tile_x + fps_tile_w {
+                    self.dirty_tiles[ty * NUM_TILE_COLS + tx].store(true, Ordering::Release);
+                }
+            }
+        }
+
         for tile_row in 0..NUM_TILE_ROWS {
             let row_start_idx = tile_row * NUM_TILE_COLS;
             let mut col = 0;
@@ -216,6 +299,11 @@ impl<'a> AtomicFrameBuffer<'a> {
             }
         }
 
+        #[cfg(feature = "fps")]
+        unsafe {
+            crate::display::FPS_COUNTER.measure()
+        }
+
         Ok(())
     }
 }
@@ -341,3 +429,146 @@ impl<'a> OriginDimensions for AtomicFrameBuffer<'a> {
         Size::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32)
     }
 }
+
+#[cfg(feature = "fps")]
+pub mod fps {
+    use crate::display::SCREEN_WIDTH;
+    use core::fmt::Write;
+    use embassy_time::{Duration, Instant};
+    use embedded_graphics::{
+        Drawable, Pixel,
+        draw_target::DrawTarget,
+        geometry::Point,
+        mono_font::{MonoTextStyle, ascii::FONT_8X13},
+        pixelcolor::Rgb565,
+        prelude::{IntoStorage, OriginDimensions, RgbColor, Size},
+        text::{Alignment, Text},
+    };
+
+    pub static mut FPS_COUNTER: FpsCounter = FpsCounter::new();
+    pub static mut FPS_CANVAS: FpsCanvas = FpsCanvas::new();
+
+    // "FPS: 120" = 8 len
+    const FPS_LEN: usize = 8;
+    pub const FPS_CANVAS_WIDTH: usize = (FONT_8X13.character_size.width + 4) as usize * FPS_LEN;
+    pub const FPS_CANVAS_HEIGHT: usize = FONT_8X13.character_size.height as usize;
+
+    // puts canvas in the top right of the display
+    // top left point of canvas
+    pub const FPS_CANVAS_X: usize = SCREEN_WIDTH - FPS_CANVAS_WIDTH;
+    pub const FPS_CANVAS_Y: usize = 0;
+
+    pub struct FpsCanvas {
+        pub canvas: [u16; FPS_CANVAS_HEIGHT * FPS_CANVAS_WIDTH],
+    }
+
+    impl FpsCanvas {
+        const fn new() -> Self {
+            Self {
+                canvas: [0; FPS_CANVAS_HEIGHT * FPS_CANVAS_WIDTH],
+            }
+        }
+
+        fn clear(&mut self) {
+            for p in &mut self.canvas {
+                *p = 0;
+            }
+        }
+
+        pub async fn draw_fps(&mut self) {
+            let mut buf: heapless::String<FPS_LEN> = heapless::String::new();
+            let fps = unsafe { FPS_COUNTER.smoothed };
+            let _ = write!(buf, "FPS: {}", fps as u8);
+
+            self.clear();
+            let text_style = MonoTextStyle::new(&FONT_8X13, Rgb565::WHITE);
+            Text::with_alignment(
+                buf.as_str(),
+                Point::new(
+                    FPS_CANVAS_WIDTH as i32 / 2,
+                    (FPS_CANVAS_HEIGHT as i32 + 8) / 2,
+                ),
+                text_style,
+                Alignment::Center,
+            )
+            .draw(self)
+            .unwrap();
+        }
+    }
+
+    impl DrawTarget for FpsCanvas {
+        type Error = ();
+        type Color = Rgb565;
+
+        fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
+        where
+            I: IntoIterator<Item = Pixel<Self::Color>>,
+        {
+            for Pixel(point, color) in pixels {
+                if point.x < 0
+                    || point.x >= FPS_CANVAS_WIDTH as i32
+                    || point.y < 0
+                    || point.y >= FPS_CANVAS_HEIGHT as i32
+                {
+                    continue;
+                }
+
+                let index = (point.y as usize) * FPS_CANVAS_WIDTH + point.x as usize;
+                self.canvas[index] = color.into_storage();
+            }
+            Ok(())
+        }
+    }
+
+    impl OriginDimensions for FpsCanvas {
+        fn size(&self) -> Size {
+            Size::new(FPS_CANVAS_WIDTH as u32, FPS_CANVAS_HEIGHT as u32)
+        }
+    }
+
+    pub struct FpsCounter {
+        last_frame: Option<Instant>,
+        smoothed: f32,
+        last_draw: Option<Instant>,
+    }
+
+    impl FpsCounter {
+        pub const fn new() -> Self {
+            Self {
+                last_frame: None,
+                smoothed: 0.0,
+                last_draw: None,
+            }
+        }
+
+        // Is called once per frame or partial frame to update FPS
+        pub fn measure(&mut self) {
+            let now = Instant::now();
+
+            if let Some(last) = self.last_frame {
+                let dt_us = (now - last).as_micros() as f32;
+                if dt_us > 0.0 {
+                    let current = 1_000_000.0 / dt_us;
+                    self.smoothed = if self.smoothed == 0.0 {
+                        current
+                    } else {
+                        0.9 * self.smoothed + 0.1 * current
+                    };
+                }
+            }
+
+            self.last_frame = Some(now);
+        }
+
+        pub fn should_draw(&mut self) -> bool {
+            let now = Instant::now();
+            match self.last_draw {
+                Some(last) if now - last < Duration::from_millis(200) => false,
+                _ => {
+                    self.last_draw = Some(now);
+                    true
+                }
+            }
+        }
+    }
+}

kernel/src/main.rs

@@ -9,48 +9,57 @@
 extern crate alloc;
 
 mod abi;
+mod audio;
 mod display;
 mod elf;
 mod framebuffer;
-#[allow(unused)]
-mod heap;
 mod peripherals;
-#[allow(unused)]
-mod psram;
 mod scsi;
 mod storage;
 mod ui;
 mod usb;
 mod utils;
 
-#[cfg(feature = "pimoroni2w")]
-use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram_qmi};
+#[cfg(feature = "psram")]
+#[allow(unused)]
+mod heap;
+#[cfg(feature = "psram")]
+#[allow(unused)]
+mod psram;
+
+#[cfg(feature = "psram")]
+use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram, psram::init_psram_qmi};
 
 use crate::{
     abi::{KEY_CACHE, MS_SINCE_LAUNCH},
-    display::{display_handler, init_display},
-    elf::load_binary,
+    audio::audio_handler,
+    display::{FRAMEBUFFER, display_handler, init_display},
     peripherals::{
         conf_peripherals,
         keyboard::{KeyState, read_keyboard_fifo},
     },
-    psram::init_psram,
+    scsi::MSC_SHUTDOWN,
     storage::{SDCARD, SdCard},
-    ui::{clear_screen, ui_handler},
-    usb::usb_handler,
+    ui::{SELECTIONS, clear_selection, ui_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,
+    clocks::ClockConfig,
+    config::Config,
     gpio::{Input, Level, Output, Pull},
     i2c::{self, I2c},
     multicore::{Stack, spawn_core1},
     peripherals::{
         DMA_CH0, DMA_CH1, DMA_CH3, DMA_CH4, I2C1, PIN_2, PIN_3, PIN_6, PIN_7, PIN_10, PIN_11,
         PIN_12, PIN_13, PIN_14, PIN_15, PIN_16, PIN_17, PIN_18, PIN_19, PIN_20, PIN_21, PIN_22,
-        PIO0, SPI0, SPI1, USB, WATCHDOG,
+        PIN_26, PIN_27, PIO0, SPI0, SPI1, USB, WATCHDOG,
     },
-    pio,
+    pio::{self, Common, Pio, StateMachine},
     spi::{self, Spi},
     usb as embassy_rp_usb,
     watchdog::{ResetReason, Watchdog},
@@ -59,8 +68,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,9 +118,20 @@ async fn watchdog_task(mut watchdog: Watchdog) {
     }
 }
 
+static ENABLE_UI: AtomicBool = AtomicBool::new(true);
+static UI_CHANGE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
+
+const OVERCLOCK: u32 = 300_000_000;
+
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_rp::init(Default::default());
+    let p = if cfg!(feature = "overclock") {
+        let clocks = ClockConfig::system_freq(OVERCLOCK).unwrap();
+        let config = Config::new(clocks);
+        embassy_rp::init(config)
+    } else {
+        embassy_rp::init(Default::default())
+    };
 
     spawn_core1(
         p.CORE1,
@@ -129,6 +153,19 @@ async fn main(_spawner: Spawner) {
         data: p.PIN_14,
         reset: p.PIN_15,
     };
+    let Pio {
+        common, sm0, sm1, ..
+    } = Pio::new(p.PIO0, Irqs);
+
+    let audio = Audio {
+        pio: common,
+        sm0,
+        dma0: p.DMA_CH3,
+        left: p.PIN_26,
+        sm1,
+        dma1: p.DMA_CH4,
+        right: p.PIN_27,
+    };
     let sd = Sd {
         spi: p.SPI0,
         clk: p.PIN_18,
@@ -137,15 +174,15 @@ async fn main(_spawner: Spawner) {
         cs: p.PIN_17,
         det: p.PIN_22,
     };
-    let psram = Psram {
-        pio: p.PIO0,
-        sclk: p.PIN_21,
-        mosi: p.PIN_2,
-        miso: p.PIN_3,
-        cs: p.PIN_20,
-        dma1: p.DMA_CH3,
-        dma2: p.DMA_CH4,
-    };
+    // let psram = Psram {
+    //     pio: p.PIO0,
+    //     sclk: p.PIN_21,
+    //     mosi: p.PIN_2,
+    //     miso: p.PIN_3,
+    //     cs: p.PIN_20,
+    //     dma1: p.DMA_CH3,
+    //     dma2: p.DMA_CH4,
+    // };
     let mcu = Mcu {
         i2c: p.I2C1,
         clk: p.PIN_7,
@@ -155,32 +192,46 @@ async fn main(_spawner: Spawner) {
     executor0.run(|spawner| {
         spawner
             .spawn(kernel_task(
-                spawner, p.WATCHDOG, display, sd, psram, mcu, p.USB,
+                spawner, p.WATCHDOG, display, audio, sd, mcu, p.USB,
             ))
             .unwrap()
     });
 }
 
 // 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) = unsafe { load_binary(&name).await.expect("unable to load binary") };
+        let (entry, _bump) = recv.receive().await;
 
-        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(());
-        clear_screen().await;
+        // enable kernel ui
+        {
+            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);
+        }
     }
 }
 
@@ -195,6 +246,15 @@ struct Display {
     data: Peri<'static, PIN_14>,
     reset: Peri<'static, PIN_15>,
 }
+struct Audio {
+    pio: Common<'static, PIO0>,
+    dma0: Peri<'static, DMA_CH3>,
+    sm0: StateMachine<'static, PIO0, 0>,
+    left: Peri<'static, PIN_26>,
+    dma1: Peri<'static, DMA_CH4>,
+    sm1: StateMachine<'static, PIO0, 1>,
+    right: Peri<'static, PIN_27>,
+}
 struct Sd {
     spi: Peri<'static, SPI0>,
     clk: Peri<'static, PIN_18>,
@@ -229,7 +289,7 @@ async fn setup_mcu(mcu: Mcu) {
 
 async fn setup_display(display: Display, spawner: Spawner) {
     let mut config = spi::Config::default();
-    config.frequency = 64_000_000;
+    config.frequency = 192_000_000;
     let spi = Spi::new(
         display.spi,
         display.clk,
@@ -245,23 +305,22 @@ 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,
-    )
-    .await;
+// async fn setup_psram(psram: Psram) {
+//     let psram = init_psram(
+//         psram.pio, psram.sclk, psram.mosi, psram.miso, psram.cs, psram.dma1, psram.dma2,
+//     )
+//     .await;
 
-    #[cfg(feature = "defmt")]
-    defmt::info!("psram size: {}", psram.size);
+//     #[cfg(feature = "defmt")]
+//     defmt::info!("psram size: {}", psram.size);
 
-    if psram.size == 0 {
-        #[cfg(feature = "defmt")]
-        defmt::info!("\u{1b}[1mExternal PSRAM was NOT found!\u{1b}[0m");
-    }
-}
+//     if psram.size == 0 {
+//         #[cfg(feature = "defmt")]
+//         defmt::info!("\u{1b}[1mExternal PSRAM was NOT found!\u{1b}[0m");
+//     }
+// }
 
-#[cfg(feature = "pimoroni2w")]
+#[cfg(feature = "psram")]
 async fn setup_qmi_psram() {
     Timer::after_millis(250).await;
     let psram_qmi_size = init_psram_qmi(&embassy_rp::pac::QMI, &embassy_rp::pac::XIP_CTRL);
@@ -287,7 +346,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));
 }
@@ -297,8 +356,9 @@ async fn kernel_task(
     spawner: Spawner,
     watchdog: Peri<'static, WATCHDOG>,
     display: Display,
+    audio: Audio,
     sd: Sd,
-    _psram: Psram,
+    // _psram: Psram,
     mcu: Mcu,
     usb: Peri<'static, USB>,
 ) {
@@ -306,46 +366,62 @@ async fn kernel_task(
         .spawn(watchdog_task(Watchdog::new(watchdog)))
         .unwrap();
 
+    #[cfg(feature = "debug")]
+    defmt::info!("Clock: {}", embassy_rp::clocks::clk_sys_freq());
+
     setup_mcu(mcu).await;
 
+    #[cfg(feature = "defmt")]
     defmt::info!("setting up psram");
     Timer::after_millis(100).await;
 
     // setup_psram(psram).await;
-    #[cfg(feature = "pimoroni2w")]
+    #[cfg(feature = "psram")]
     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);
-    spawner.spawn(usb_handler(usb_driver)).unwrap();
+    spawner.spawn(audio_handler(audio)).unwrap();
+
+    let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
+    // 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 mut files = sd.list_files_by_extension(".bin").unwrap();
+            files.sort();
+            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 {
-                    let _ = KEY_CACHE.enqueue(event);
-                }
+            unsafe {
+                let _ = KEY_CACHE.enqueue(event);
             }
         }
         Timer::after_millis(50).await;

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 core::sync::atomic::{AtomicBool, Ordering};
-use embassy_time::Timer;
+use embassy_futures::select::select;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::lazy_lock::LazyLock;
+use embassy_sync::signal::Signal;
 use embassy_usb::Builder;
 use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
 use embedded_sdmmc::{Block, BlockIdx};
@@ -8,32 +9,29 @@ use heapless::Vec;
 
 mod scsi_types;
 use scsi_types::*;
-#[allow(unused)]
-mod error;
-use error::ScsiSense;
+
+use crate::storage::{SDCARD, SdCard};
 
 const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
 
-// indicates that a scsi transaction is occurring and is
-// NOT safe to disable usb, or acquire sdcard
-pub static SCSI_BUSY: AtomicBool = AtomicBool::new(false);
+pub static MSC_SHUTDOWN: Signal<CriticalSectionRawMutex, ()> = Signal::new();
 
-// stop scsi and return sdcard when safe to do so
-pub static SCSI_HALT: AtomicBool = AtomicBool::new(false);
-
-pub static SCSI_EJECTED: AtomicBool = AtomicBool::new(false);
+// number of blocks to read from sd at once
+// higher is better, but is larger. Size is BLOCKS * 512 bytes
+const BLOCKS: usize = 32;
+static mut BLOCK_BUF: LazyLock<[Block; BLOCKS]> =
+    LazyLock::new(|| core::array::from_fn(|_| Block::new()));
 
 pub struct MassStorageClass<'d, D: Driver<'d>> {
     temp_sd: Option<SdCard>, // temporary owns sdcard when scsi is running
+    ejected: bool,
+    pending_eject: bool,
     bulk_out: D::EndpointOut,
     bulk_in: D::EndpointIn,
-    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.temp_sd.is_some() {
-                    self.return_sdcard().await;
-                    SCSI_BUSY.store(false, Ordering::Release);
-                    self.pending_eject = false;
+            if !self.ejected {
+                select(self.handle_cbw(), MSC_SHUTDOWN.wait()).await;
+
+                if MSC_SHUTDOWN.signaled() {
+                    #[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();
-                    self.send_csw_fail(0).await;
+
+                    if self.pending_eject {
+                        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() {
-                    SCSI_BUSY.store(true, Ordering::Release);
-                    self.take_sdcard().await;
-                }
-
-                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(())
-                    }
+                if self.temp_sd.as_ref().unwrap().is_attached() {
+                    Ok(())
+                } else {
+                    Err(())
                 }
             }
-            ScsiCommand::RequestSense { desc: _, alloc_len } => {
-                // Prepare the buffer
-                let mut buf = [0u8; 18];
-
-                // 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::RequestSense {
+                desc: _,
+                alloc_len: _,
+            } => Ok(()),
             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() {
-                Some(sd) => {
-                    let total_blocks = sd.size() / BLOCK_SIZE as u64;
+            ScsiCommand::ReadCapacity10 => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
+                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
 
-                    let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
 
-                    response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
-                    response.extend_from_slice(&(BLOCK_SIZE as u32).to_be_bytes())?;
+                response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
 
-                    self.bulk_in.write(&response).await.map_err(|_| ())
-                }
-                None => {
-                    self.last_sense = ScsiSense::medium_not_present();
-                    Err(())
-                }
-            },
-            ScsiCommand::ReadCapacity16 { alloc_len } => match self.temp_sd.as_ref() {
-                Some(sd) => {
-                    let total_blocks = sd.size() / BLOCK_SIZE as u64;
+                self.bulk_in.write(&response).await.map_err(|_| ())
+            }
+            ScsiCommand::ReadCapacity16 { alloc_len } => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
+                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
 
-                    let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
 
-                    response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
-                    response.extend_from_slice(&(BLOCK_SIZE as u32).to_be_bytes())?; // 4 bytes block length
-                    response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
+                response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?; // 4 bytes block length
+                response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
 
-                    let len = alloc_len.min(response.len() as u32) as usize;
-                    self.bulk_in.write(&response[..len]).await.map_err(|_| ())
-                }
-                None => {
-                    self.last_sense = ScsiSense::medium_not_present();
-                    Err(())
-                }
-            },
-            ScsiCommand::Read { lba, len } => match self.temp_sd.as_ref() {
-                Some(sd) => {
-                    let mut blocks = len;
-                    let mut idx = lba;
+                let len = alloc_len.min(response.len() as u32) as usize;
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::Read { lba, len } => {
+                let sdcard = self.temp_sd.as_ref().unwrap();
+                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
+                let mut blocks = len;
+                let mut idx = lba;
 
-                    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 {
-                        if blocks >= block_buf.len() as u64 {
-                            sd.read_blocks(&mut block_buf, BlockIdx(idx as u32))?;
-
-                            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
-                                    }
-                                }
+                        for block in &mut *block_buf {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
+                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
                             }
-
-                            blocks -= block_buf.len() as u64;
-                            idx += block_buf.len() as u64;
-                        } else {
-                            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 {
-                        self.last_sense = ScsiSense::unrecovered_read_error();
-                        return Err(());
-                    }
+                        blocks -= block_buf.len() as u64;
+                        idx += block_buf.len() as u64;
+                    } else {
+                        sdcard
+                            .read_blocks(&mut block_buf[..blocks as usize], BlockIdx(idx as u32))?;
 
-                    Ok(())
-                }
-                None => {
-                    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
-                                    }
-                                }
+                        for block in &block_buf[..blocks as usize] {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
+                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
                             }
-
-                            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/storage.rs

@@ -35,12 +35,24 @@ impl TimeSource for DummyTimeSource {
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct FileName {
     pub long_name: String,
     pub short_name: ShortFileName,
 }
 
+impl PartialOrd for FileName {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.long_name.cmp(&other.long_name))
+    }
+}
+
+impl Ord for FileName {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        self.long_name.cmp(&other.long_name)
+    }
+}
+
 pub struct SdCard {
     det: Input<'static>,
     volume_mgr: VolMgr,

kernel/src/ui.rs

@@ -1,26 +1,18 @@
 use crate::{
-    BINARY_CH,
-    display::FRAMEBUFFER,
-    framebuffer::FB_PAUSED,
-    peripherals::keyboard,
-    scsi::SCSI_BUSY,
-    storage::{FileName, SDCARD},
+    BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
+    peripherals::keyboard, storage::FileName,
 };
 use abi_sys::keyboard::{KeyCode, KeyState};
 use alloc::{str::FromStr, string::String, vec::Vec};
 use core::sync::atomic::Ordering;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
-use embassy_time::Timer;
 use embedded_graphics::{
     Drawable,
-    mono_font::{
-        MonoTextStyle,
-        ascii::{FONT_4X6, FONT_10X20},
-    },
+    mono_font::{MonoTextStyle, ascii::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 ui.page == UiPage::Scsi && !SCSI_BUSY.load(Ordering::Acquire) {
-            scsi.clear().await;
-            ui.page = UiPage::Menu;
-        } else if ui.page == UiPage::Menu && SCSI_BUSY.load(Ordering::Acquire) {
-            menu.clear().await;
-            ui.page = UiPage::Scsi;
-        }
+        if let Some(event) = keyboard::read_keyboard_fifo().await {
+            if let KeyState::Pressed = event.state {
+                match event.key {
+                    KeyCode::Up => {
+                        let mut selections = SELECTIONS.lock().await;
+                        selections.up();
+                    }
+                    KeyCode::Down => {
+                        let mut selections = SELECTIONS.lock().await;
+                        selections.down();
+                    }
+                    KeyCode::Enter | KeyCode::Right => {
+                        let selections = SELECTIONS.lock().await;
+                        let selection =
+                            selections.selections[selections.current_selection as usize].clone();
 
-        if input_handler(&mut ui, &mut menu, &mut scsi).await {
-            return;
-        }
-        match ui.page {
-            UiPage::Menu => menu.draw().await,
-            UiPage::Scsi => scsi.draw().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,
+                        let entry = unsafe {
+                            load_binary(&selection.short_name)
+                                .await
+                                .expect("unable to load binary")
+                        };
+                        BINARY_CH.send(entry).await;
+                    }
+                    _ => (),
+                }
             }
         }
-    }
-    false
-}
 
-#[derive(PartialEq)]
-enum UiPage {
-    Menu,
-    Scsi,
-}
-
-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;
+        let changed = SELECTIONS.lock().await.changed;
+        if changed {
+            clear_selection().await;
+            draw_selection().await;
         }
-        self.last_bounds = None;
     }
 }
 
-static SELECTIONS: Mutex<CriticalSectionRawMutex, Vec<FileName>> = Mutex::new(Vec::new());
-static mut SELECTIONS_CHANGED: bool = true;
+pub async fn clear_selection() {
+    let sel = SELECTIONS.lock().await;
 
-async fn update_selections() {
-    while SCSI_BUSY.load(Ordering::Acquire) {
-        Timer::after_millis(100).await;
-    }
-    let mut guard = SDCARD.get().lock().await;
-    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 }
+    if let Some(area) = sel.last_bounds {
+        Rectangle::new(area.top_left, area.size)
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
+            .unwrap();
     }
 }
-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 {
-    async fn draw(&mut self) {
-        if self.changed {
-            self.clear().await;
+impl SelectionList {
+    pub const fn new() -> Self {
+        Self {
+            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 {
-        match key {
-            KeyCode::Enter | KeyCode::Right => {
-                let selections = SELECTIONS.lock().await;
-                let selection = selections[self.selection].clone();
+    pub fn set_changed(&mut self, changed: bool) {
+        self.changed = changed
+    }
 
-                self.clear().await;
-                BINARY_CH.send(selection.short_name).await;
-                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
-                }
-            }
-            _ => (),
-        }
+    pub fn update_selections(&mut self, selections: Vec<FileName>) {
+        self.selections = selections;
         self.changed = true;
-        false
     }
 
-    async fn clear(&mut self) {
-        if let Some(rect) = self.last_bounds {
-            clear_rect(rect).await;
+    pub fn selections(&self) -> &Vec<FileName> {
+        &self.selections
+    }
+
+    pub fn reset(&mut self) {
+        self.current_selection = 0;
+        self.changed = true;
+    }
+
+    fn up(&mut self) {
+        if self.current_selection > 0 {
+            self.current_selection -= 1;
+            self.changed = true;
+        }
+    }
+
+    fn down(&mut self) {
+        if self.current_selection + 1 < self.selections.len() as u16 {
+            self.current_selection += 1;
+            self.changed = true;
         }
-        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 core::sync::atomic::Ordering;
-use embassy_futures::join::join;
+use crate::{scsi::MassStorageClass, storage::SdCard};
+use core::sync::atomic::{AtomicBool, Ordering};
+use embassy_futures::select::select;
 use embassy_rp::{peripherals::USB, usb::Driver};
-use embassy_usb::{Builder, Config};
+use embassy_usb::{Builder, Config, UsbDevice};
+
+pub static USB_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 #[embassy_executor::task]
 pub async fn usb_handler(driver: Driver<'static, USB>) {
@@ -26,18 +28,18 @@ pub async fn usb_handler(driver: Driver<'static, USB>) {
         &mut control_buf,
     );
 
-    let mut scsi = MassStorageClass::new(&mut builder);
-    let mut usb = builder.build();
+    let temp_sd: Option<SdCard> = None;
+    let mut scsi = MassStorageClass::new(&mut builder, temp_sd);
+    let usb = builder.build();
 
-    join(
-        async {
-            loop {
-                usb.wait_resume().await;
-                SCSI_EJECTED.store(false, Ordering::Release);
-                usb.run_until_suspend().await;
-            }
-        },
-        scsi.poll(),
-    )
-    .await;
+    select(run(usb), scsi.poll()).await;
+}
+
+async fn run<'d>(mut usb: UsbDevice<'d, Driver<'d, USB>>) -> ! {
+    loop {
+        usb.wait_resume().await;
+        USB_ACTIVE.store(true, Ordering::Release);
+        usb.run_until_suspend().await;
+        USB_ACTIVE.store(false, Ordering::Release);
+    }
 }

selection_ui/src/lib.rs

@@ -6,50 +6,57 @@ 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},
+    prelude::{Dimensions, DrawTarget, Point, Primitive, RgbColor},
     primitives::{PrimitiveStyle, Rectangle},
-    text::Text,
+    text::{Alignment, Text, renderer::TextRenderer},
 };
 use embedded_layout::{
     align::{horizontal, vertical},
     layout::linear::{FixedMargin, LinearLayout},
     prelude::*,
 };
-use embedded_text::TextBox;
+
+#[derive(Debug)]
+pub enum SelectionUiError<DisplayError> {
+    SelectionListEmpty,
+    DisplayError(DisplayError),
+}
 
 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 {
+    pub fn new(items: &'a [&'a str]) -> Self {
         Self {
             selection: 0,
             items,
-            error,
             last_bounds: None,
         }
     }
 
-    pub fn run_selection_ui(&mut self, display: &mut Display) -> Result<Option<usize>, ()> {
+    pub fn run_selection_ui(
+        &mut self,
+        display: &mut Display,
+    ) -> Result<Option<usize>, SelectionUiError<<Display as DrawTarget>::Error>> {
         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);
+                    display
+                        .clear(Rgb565::BLACK)
+                        .map_err(|e| SelectionUiError::DisplayError(e))?;
                     break;
                 }
             }
@@ -59,36 +66,41 @@ impl<'a> SelectionUi<'a> {
 
     /// 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>, ()> {
+    pub fn update(
+        &mut self,
+        display: &mut Display,
+        key: KeyCode,
+    ) -> Result<Option<usize>, SelectionUiError<<Display as DrawTarget>::Error>> {
         match key {
-            KeyCode::JoyUp => {
+            KeyCode::Down => {
+                self.selection = (self.selection + 1).min(self.items.len() - 1);
+            }
+            KeyCode::Up => {
                 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)),
+            KeyCode::Enter | KeyCode::Right => return Ok(Some(self.selection)),
+            _ => return Ok(None),
         };
         self.draw(display)?;
         Ok(None)
     }
 
-    fn draw(&mut self, display: &mut Display) -> Result<(), ()> {
+    fn draw(
+        &mut self,
+        display: &mut Display,
+    ) -> Result<(), SelectionUiError<<Display as DrawTarget>::Error>> {
         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();
+            return Err(SelectionUiError::SelectionListEmpty);
+        }
+
+        if let Some(bounds) = self.last_bounds {
+            Rectangle::new(bounds.top_left, bounds.size)
+                .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+                .draw(display)
+                .map_err(|e| SelectionUiError::DisplayError(e))?;
         }
 
         let mut views: Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
@@ -105,15 +117,32 @@ impl<'a> SelectionUi<'a> {
             .arrange()
             .align_to(&display_area, horizontal::Center, vertical::Center);
 
+        layout
+            .draw(display)
+            .map_err(|e| SelectionUiError::DisplayError(e))?;
+
         // 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)?;
+        if let Some(selected_bounds) = layout.inner().get(self.selection) {
+            let selected_bounds = selected_bounds.bounding_box();
+            Rectangle::new(selected_bounds.top_left, selected_bounds.size)
+                .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
+                .draw(display)
+                .map_err(|e| SelectionUiError::DisplayError(e))?;
 
-        self.last_bounds = Some(layout.bounds());
+            self.last_bounds = Some(selected_bounds);
+        }
 
-        layout.draw(display)?;
         Ok(())
     }
 }
+
+pub fn draw_text_center<'a, S>(
+    display: &mut Display,
+    text: &'a str,
+    style: S,
+) -> Result<Point, <Display as DrawTarget>::Error>
+where
+    S: TextRenderer<Color = <Display as DrawTarget>::Color>,
+{
+    Text::with_alignment(text, Point::zero(), style, Alignment::Center).draw(display)
+}

user-apps/calculator/src/main.rs

@@ -6,7 +6,7 @@ use abi::{
     display::Display,
     get_key,
     keyboard::{KeyCode, KeyState},
-    print,
+    println,
 };
 use alloc::{format, string::String, vec, vec::Vec};
 use core::panic::PanicInfo;
@@ -28,7 +28,7 @@ use embedded_layout::{
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
     loop {}
 }
 
@@ -38,8 +38,8 @@ pub extern "Rust" fn _start() {
 }
 
 pub fn main() {
-    print!("Starting Calculator app");
-    let mut display = Display;
+    println!("Starting Calculator app");
+    let mut display = Display::take().unwrap();
 
     let mut input = vec!['e', 'x', 'p', 'r', ':', ' '];
     let input_min = input.len();
@@ -104,7 +104,7 @@ pub fn main() {
         }
 
         let event = get_key();
-        if event.state != KeyState::Idle {
+        if event.state == KeyState::Released {
             match event.key {
                 KeyCode::Char(ch) => {
                     input.push(ch);

user-apps/gallery/src/main.rs

@@ -8,7 +8,7 @@ use abi::{
     fs::{Entries, list_dir, read_file},
     get_key,
     keyboard::{KeyCode, KeyState},
-    print,
+    println,
 };
 use alloc::{format, vec};
 use core::panic::PanicInfo;
@@ -20,7 +20,7 @@ use tinybmp::Bmp;
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location());
+    println!("user panic: {} @ {:?}", info.message(), info.location());
     loop {}
 }
 
@@ -30,9 +30,9 @@ pub extern "Rust" fn _start() {
 }
 
 pub fn main() {
-    print!("Starting Gallery app");
+    println!("Starting Gallery app");
     let mut bmp_buf = vec![0_u8; 100_000];
-    let mut display = Display;
+    let mut display = Display::take().unwrap();
 
     let grid_cols = 3;
     let grid_rows = 3;
@@ -49,7 +49,7 @@ pub fn main() {
             break; // only draw 3x3
         }
 
-        print!("file: {}", file);
+        println!("file: {}", file);
         if file.extension().unwrap_or("") == "bmp" || file.extension().unwrap_or("") == "BMP" {
             let file_path = format!("/images/{}", file);
 

user-apps/gif/Cargo.toml

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

user-apps/gif/src/main.rs

@@ -3,23 +3,27 @@
 
 extern crate alloc;
 use abi::{
-    display::Display,
+    display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
     fs::{Entries, file_len, list_dir, read_file},
     get_key, get_ms,
     keyboard::{KeyCode, KeyState},
-    print, sleep,
+    println, sleep,
 };
 use alloc::{format, vec, vec::Vec};
 use core::panic::PanicInfo;
 use embedded_graphics::{
-    image::ImageDrawable, pixelcolor::Rgb565, prelude::Point, transform::Transform,
+    image::ImageDrawable,
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    pixelcolor::Rgb565,
+    prelude::{Point, RgbColor},
+    transform::Transform,
 };
-use selection_ui::SelectionUi;
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
 use tinygif::Gif;
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
     loop {}
 }
 
@@ -29,41 +33,56 @@ pub extern "Rust" fn _start() {
 }
 
 pub fn main() {
-    print!("Starting Gif app");
-    let mut display = Display;
+    println!("Starting Gif app");
+    let mut display = Display::take().unwrap();
 
     let mut entries = Entries::new();
     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 gifs = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
+    gifs.sort();
 
-    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 mut selection_ui = SelectionUi::new(&mut gifs);
+    let selection = match selection_ui.run_selection_ui(&mut display) {
+        Ok(maybe_sel) => maybe_sel,
+        Err(e) => match e {
+            SelectionUiError::SelectionListEmpty => {
+                draw_text_center(
+                    &mut display,
+                    "No Gifs were found in /gifs",
+                    MonoTextStyle::new(&FONT_6X10, Rgb565::RED),
+                )
+                .expect("Display Error");
+                None
+            }
+            SelectionUiError::DisplayError(_) => panic!("Display Error"),
+        },
+    };
 
-    let file_name = format!("/gifs/{}", gifs[selection]);
+    assert!(selection.is_some());
+
+    let file_name = format!("/gifs/{}", gifs[selection.unwrap()]);
     let size = file_len(&file_name);
     let mut buf = vec![0_u8; size];
     let read = read_file(&file_name, 0, &mut buf);
-    print!("read: {}, file size: {}", read, size);
+    println!("read: {}, file size: {}", read, size);
     assert!(read == size);
 
     let gif = Gif::<Rgb565>::from_slice(&buf).expect("Failed to parse gif");
-    let height = gif.height();
+
+    let translation = Point::new(
+        (SCREEN_WIDTH as i32 - gif.width() as i32) / 2,
+        (SCREEN_HEIGHT as i32 - gif.height() as i32) / 2,
+    );
 
     let mut frame_num = 0;
     loop {
         for mut frame in gif.frames() {
             let start = get_ms();
 
-            frame
-                .translate_mut(Point::new(0, (320 - height as i32) / 2))
-                .draw(&mut display)
-                .unwrap();
+            frame.translate_mut(translation).draw(&mut display).unwrap();
             frame_num += 1;
 
             if frame_num % 5 == 0 {

user-apps/snake/src/main.rs

@@ -7,7 +7,7 @@ use abi::{
     display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
     get_key,
     keyboard::{KeyCode, KeyState},
-    print, sleep,
+    println, sleep,
 };
 use core::panic::PanicInfo;
 use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor};
@@ -15,7 +15,7 @@ use embedded_snake::{Direction, SnakeGame};
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
     loop {}
 }
 
@@ -27,8 +27,8 @@ pub extern "Rust" fn _start() {
 const CELL_SIZE: usize = 8;
 
 pub fn main() {
-    print!("Starting Snake app");
-    let mut display = Display;
+    println!("Starting Snake app");
+    let mut display = Display::take().unwrap();
 
     let mut game = SnakeGame::<100, Rgb565, Rng>::new(
         SCREEN_WIDTH as u16,

user-apps/wav_player/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "wav_player"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+abi = { path = "../../abi" }
+selection_ui = { path = "../../selection_ui" }
+embedded-graphics = "0.8.1"
+rand = { version = "0.9.0", default-features = false }
+embedded-audio = { git = "https://github.com/LegitCamper/embedded-audio" }

user-apps/wav_player/build.rs

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

user-apps/wav_player/src/main.rs

@@ -0,0 +1,139 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+use abi::{
+    audio::{AUDIO_BUFFER_LEN, audio_buffer_ready, send_audio_buffer},
+    display::Display,
+    format,
+    fs::{Entries, file_len, list_dir, read_file},
+    get_key,
+    keyboard::{KeyCode, KeyState},
+    println,
+};
+use alloc::{string::String, vec::Vec};
+use core::panic::PanicInfo;
+use embedded_audio::{AudioFile, PlatformFile, PlatformFileError, wav::Wav};
+use embedded_graphics::{
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    pixelcolor::Rgb565,
+    prelude::RgbColor,
+};
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+pub fn main() {
+    println!("Starting Wav player app");
+    let mut display = Display::take().unwrap();
+
+    loop {
+        let mut entries = Entries::new();
+        list_dir("/music", &mut entries);
+
+        let mut files = entries.entries();
+        files.retain(|e| e.extension().unwrap_or("") == "wav");
+        let mut wavs = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
+        wavs.sort();
+
+        let mut selection_ui = SelectionUi::new(&mut wavs);
+        let selection = match selection_ui.run_selection_ui(&mut display) {
+            Ok(maybe_sel) => maybe_sel,
+            Err(e) => match e {
+                SelectionUiError::SelectionListEmpty => {
+                    draw_text_center(
+                        &mut display,
+                        "No Wavs were found in /gifs",
+                        MonoTextStyle::new(&FONT_6X10, Rgb565::RED),
+                    )
+                    .expect("Display Error");
+                    None
+                }
+                SelectionUiError::DisplayError(_) => panic!("Display Error"),
+            },
+        };
+
+        assert!(selection.is_some());
+
+        let file_name = format!("/music/{}", wavs[selection.unwrap()]);
+        let file = File::new(String::from(file_name));
+        let mut wav = Wav::new(file).unwrap();
+        println!("sample rate: {}", wav.sample_rate());
+        println!("channels: {:?}", wav.channels() as u8);
+
+        let mut buf = [0_u8; AUDIO_BUFFER_LEN];
+
+        loop {
+            if audio_buffer_ready() {
+                if wav.is_eof() {
+                    break;
+                }
+
+                let _read = wav.read(&mut buf).unwrap();
+                send_audio_buffer(&buf);
+            }
+
+            let event = get_key();
+            if event.state == KeyState::Released {
+                match event.key {
+                    KeyCode::Esc => return,
+                    _ => (),
+                }
+            }
+        }
+    }
+}
+
+struct File {
+    current_pos: usize,
+    file: String,
+}
+
+impl File {
+    fn new(file: String) -> Self {
+        Self {
+            current_pos: 0,
+            file,
+        }
+    }
+}
+
+impl PlatformFile for File {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, PlatformFileError> {
+        let read = read_file(&self.file, self.current_pos, buf);
+        self.current_pos += read;
+        Ok(read)
+    }
+
+    fn seek_from_current(&mut self, offset: i64) -> Result<(), PlatformFileError> {
+        if offset.is_positive() {
+            self.current_pos += offset as usize;
+        } else {
+            self.current_pos -= offset as usize;
+        }
+        Ok(())
+    }
+
+    fn seek_from_start(&mut self, offset: usize) -> Result<(), PlatformFileError> {
+        self.current_pos = offset;
+        Ok(())
+    }
+
+    fn seek_from_end(&mut self, offset: usize) -> Result<(), PlatformFileError> {
+        self.current_pos = self.length() - offset;
+        Ok(())
+    }
+
+    fn length(&mut self) -> usize {
+        file_len(&self.file)
+    }
+}