small fixes

probe

.cargo/config.toml

@@ -1,5 +1,5 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-runner = "probe-rs run --chip RP2350"
+runner = "probe-rs run --chip RP2350xa"
 # runner = "elf2uf2-rs -d"
 
 [build]

.gitmodules

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

Cargo.lock

@@ -110,6 +110,26 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags 2.10.0",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.10.5",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.110",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -246,12 +266,42 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "cc"
+version = "1.2.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37521ac7aabe3d13122dc382493e20c9416f299d2ccd5b3a5340a2570cdeb0f3"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
 [[package]]
 name = "clap"
 version = "3.2.25"
@@ -1077,6 +1127,12 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+
 [[package]]
 name = "fixed"
 version = "1.29.0"
@@ -1214,6 +1270,17 @@ dependencies = [
  "userlib",
 ]
 
+[[package]]
+name = "gboy"
+version = "0.1.0"
+dependencies = [
+ "bindgen",
+ "cc",
+ "embedded-graphics",
+ "selection_ui",
+ "userlib",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -1257,6 +1324,12 @@ dependencies = [
  "userlib",
 ]
 
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "goblin"
 version = "0.10.3"
@@ -1549,6 +1622,16 @@ version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.10"
@@ -1604,6 +1687,12 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815"
 
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "nb"
 version = "0.1.3"
@@ -1625,6 +1714,16 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1888,6 +1987,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
+[[package]]
+name = "prettyplease"
+version = "0.2.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.110",
+]
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -2077,6 +2186,12 @@ dependencies = [
  "crc-any",
 ]
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "rustc_version"
 version = "0.2.3"
@@ -2216,6 +2331,12 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "siphasher"
 version = "1.0.1"

Cargo.toml

@@ -10,6 +10,7 @@ members = [
   "user_apps/gallery",
   "user_apps/gif",
   "user_apps/wav_player",
+  "user_apps/gboy",
 ]
 
 [profile.release]

README.md

@@ -14,7 +14,7 @@ Current focus is on exanding applications and porting software, finding bugs in
 - **`userlib_sys/`** – C FFI bindings for kernel syscall
 - **`userlib/`** – Rust wrapper on top of `userlib_sys` 
 - **`picolib/`** – Built with ```just newlib```, and provides libc symbols when linking with C libraries 
-- **`user-apps/`** – Collection of userspace programs (gif player, wav player, calculator, snake, etc.)
+- **`user_apps/`** – Collection of userspace programs (gif player, wav player, calculator, snake, etc.)
 
 ## Features
 

justfile

@@ -1,7 +1,7 @@
 target := "thumbv8m.main-none-eabihf"
 
 kernel-dev board:
-    cargo run --bin kernel --features {{board}}  --features fps
+    cargo run --bin kernel --features {{board}}  --features fps --features defmt
 kernel-release-probe board:
     cargo run --bin kernel --profile release --features {{board}} --features fps
 kernel-release board:
@@ -42,6 +42,7 @@ userapps: cbindgen
     just userapp gallery
     just userapp gif
     just userapp wav_player
+    just userapp gboy
 
 copy-userapp app:
     cp ./target/{{target}}/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin
@@ -54,6 +55,7 @@ copy-userapps:
     just copy-userapp gallery
     just copy-userapp gif
     just copy-userapp wav_player
+    just copy-userapp gboy
 
     DEV=$(lsblk -o LABEL,NAME -nr | awk -v L="PICOCALC" '$1==L {print "/dev/" $2}')
     udisksctl unmount -b "$DEV"

kernel/Cargo.toml

@@ -10,11 +10,14 @@ test = false
 doctest = false
 bench = false
 
+[profile.release]
+debug = true
+
 [features]
-default = ["rp235x", "defmt"]
+default = ["rp235xa"]
-pimoroni2w = ["rp235x", "psram"]
+pimoroni2w = ["rp235xa", "psram"]
 # rp2040 = ["embassy-rp/rp2040"] # unsupported, ram too small for fb
-rp235x = ["embassy-rp/rp235xb"]
+rp235xa = ["embassy-rp/rp235xa"]
 trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
 psram = ["dep:embedded-alloc"]
 overclock = []
@@ -63,15 +66,16 @@ cyw43 = { version = "0.3.0", features = [
 cyw43-pio = { version = "0.3.0", optional = true }
 
 critical-section = "1.2.0"
+cortex-m = { version = "0.7.7", features = ["inline-asm"] }
+cortex-m-rt = "0.7.5"
+panic-probe = { version = "0.3", features = ["print-defmt"] }
+portable-atomic = { version = "1.11", features = ["critical-section"] }
+assign-resources = "0.5.0"
+
 embedded-hal-bus = { version = "0.3.0", features = ["async"] }
 embedded-hal = "0.2.7"
 embedded-hal_2 = { package = "embedded-hal", version = "1.0.0" }
 embedded-hal-async = "1.0.0"
-cortex-m = { version = "0.7.7" }
-cortex-m-rt = "0.7.5"
-panic-probe = "0.3"
-portable-atomic = { version = "1.11", features = ["critical-section"] }
-assign-resources = "0.5.0"
 
 defmt = { version = "1.0.1", optional = true }
 defmt-rtt = "1.1.0"

kernel/build.rs

@@ -14,7 +14,7 @@ use std::io::Write;
 use std::path::PathBuf;
 
 #[cfg(all(feature = "rp235x", not(feature = "pimoroni2w")))]
-const MEMORY: &'static [u8] = include_bytes!("rp2350.x");
+const MEMORY: &[u8] = include_bytes!("rp2350.x");
 #[cfg(feature = "pimoroni2w")]
 const MEMORY: &'static [u8] = include_bytes!("rp2350.x");
 

kernel/src/audio.rs

@@ -1,6 +1,6 @@
 use crate::Audio;
-use core::sync::atomic::{AtomicBool, Ordering};
+use core::sync::atomic::{AtomicBool, AtomicU32, Ordering};
-use embassy_futures::join::join;
+use embassy_futures::{join::join, yield_now};
 use embassy_rp::{
     Peri,
     clocks::clk_sys_freq,
@@ -17,31 +17,65 @@ pub const SAMPLE_RATE_HZ: u32 = 22_050;
 const AUDIO_BUFFER_SAMPLES: usize = 1024;
 const _: () = assert!(AUDIO_BUFFER_SAMPLES == userlib_sys::AUDIO_BUFFER_SAMPLES);
 
-// 8bit stereo interleaved PCM audio buffers
+const SILENCE: u8 = u8::MAX / 2;
-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];
 
+// 8bit stereo interleaved PCM audio buffers
+pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2];
+static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2];
+
+// atomics for user applications to signal changes to audio buffers
 pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true);
+pub static AUDIO_BUFFER_WRITTEN: AtomicBool = AtomicBool::new(false);
+pub static AUDIO_BUFFER_SAMPLE_RATE: AtomicU32 = AtomicU32::new(SAMPLE_RATE_HZ);
+
+/// resets audio buffers after user applications are unloaded
+pub fn clear_audio_buffers() {
+    unsafe {
+        AUDIO_BUFFER.fill(SILENCE);
+        AUDIO_BUFFER_1.fill(SILENCE);
+    }
+}
 
 #[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 {
+    // enable sms at the same time to ensure they are synced
-        write_samples(&mut pwm_pio_left, &mut pwm_pio_right, unsafe {
+    audio.pio.apply_sm_batch(|pio| {
-            &AUDIO_BUFFER_1
+        pio.set_enable(&mut pwm_pio_right.sm, true);
-        })
+        pio.set_enable(&mut pwm_pio_left.sm, true);
-        .await;
+    });
-        unsafe { &mut AUDIO_BUFFER_1 }.fill(SILENCE_VALUE);
 
-        unsafe { core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1) };
+    let mut sample_rate = SAMPLE_RATE_HZ;
+
+    loop {
+        unsafe {
+            let new_sample_rate = AUDIO_BUFFER_SAMPLE_RATE.load(Ordering::Acquire);
+            if new_sample_rate != sample_rate {
+                sample_rate = new_sample_rate;
+                pwm_pio_left.reconfigure(sample_rate);
+                pwm_pio_right.reconfigure(sample_rate);
+
+                // restart sms at the same time to ensure they are synced
+                audio.pio.apply_sm_batch(|pio| {
+                    pio.restart(&mut pwm_pio_right.sm);
+                    pio.restart(&mut pwm_pio_left.sm);
+                });
+            }
+
+            if AUDIO_BUFFER_WRITTEN.load(Ordering::Acquire) {
+                write_samples(&mut pwm_pio_left, &mut pwm_pio_right, &AUDIO_BUFFER_1).await;
+                AUDIO_BUFFER_1.fill(SILENCE);
+                core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1);
                 AUDIO_BUFFER_READY.store(true, Ordering::Release)
+            } else {
+                yield_now().await;
+            }
+        }
     }
 }
 
@@ -51,12 +85,13 @@ async fn write_samples<PIO: Instance>(
     buf: &[u8],
 ) {
     // pack two samples per word
-    let mut packed_buf_left: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2];
+    static mut PACKED_BUF_L: [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];
+    static mut PACKED_BUF_R: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2];
 
-    for ((pl, pr), sample) in packed_buf_left
+    unsafe {
+        for ((pl, pr), sample) in PACKED_BUF_L
             .iter_mut()
-        .zip(packed_buf_right.iter_mut())
+            .zip(PACKED_BUF_R.iter_mut())
             .zip(buf.chunks(4))
         {
             *pl = pack_u8_samples(sample[0], sample[2]);
@@ -66,14 +101,15 @@ async fn write_samples<PIO: Instance>(
         let left_fut = left
             .sm
             .tx()
-        .dma_push(left.dma.reborrow(), &packed_buf_left, false);
+            .dma_push(left.dma.reborrow(), &PACKED_BUF_L, false);
 
         let right_fut = right
             .sm
             .tx()
-        .dma_push(right.dma.reborrow(), &packed_buf_right, false);
+            .dma_push(right.dma.reborrow(), &PACKED_BUF_R, false);
 
         join(left_fut, right_fut).await;
+    }
 }
 
 struct PioPwmAudioProgram8Bit<'d, PIO: Instance>(LoadedProgram<'d, PIO>);
@@ -81,17 +117,29 @@ 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
+        // only uses 16 bits top for pwm high, bottom for pwm low
-        // allows two samples per word
+        // allows storing two samples per word
         let prg = pio_asm!(
-            "out x, 8", // pwm high time
+            ".side_set 1",
-            "out y, 8", // pwm low time
+
+            "set x, 0 side 1",
+            "set y, 0 side 0",
+            ".wrap_target",
+
+            "check:",
+            "pull ifempty noblock side 1", // gets new osr or loads 0 into x, gets second sample if osr not empty
+            "out x, 8 side 0", // pwm high time
+            "out y, 8 side 1", // pwm low time
+            "jmp x!=y play_sample side 0", // x & y are never equal unless osr was empty
+            "set x, 1 side 1",
+            "set y, 1 side 0",
+
+            "play_sample:"
             "loop_high:",
-            "set pins, 1",       // keep pin high
+            "jmp x-- loop_high side 1", // keep pwm high, decrement X until 0
-            "jmp x-- loop_high", // decrement X until 0
             "loop_low:",
-            "set pins, 0",      // keep pin low
+            "jmp y-- loop_low side 0", // keep pwm low, decrement Y until 0
-            "jmp y-- loop_low", // decrement Y until 0
+            ".wrap"
         );
 
         let prg = common.load_program(&prg.program);
@@ -106,6 +154,11 @@ struct PioPwmAudio<'d, PIO: Instance, const SM: usize> {
 }
 
 impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> {
+    fn get_sm_divider(sample_rate: u32) -> u32 {
+        let target_clock = (u8::MAX as u32 + 1) * sample_rate;
+        clk_sys_freq() / target_clock
+    }
+
     fn new(
         dma: Peri<'d, impl Channel>,
         pio: &mut Common<'d, PIO>,
@@ -118,25 +171,27 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> {
         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();
+        let shift_cfg = ShiftConfig {
-        shift_cfg.auto_fill = true;
+            auto_fill: false,
+            ..Default::default()
+        };
         cfg.shift_out = shift_cfg;
-        cfg.use_program(&prg.0, &[]);
+        cfg.use_program(&prg.0, &[&pin]);
         sm.set_config(&cfg);
 
-        let target_clock = (u8::MAX as u32 + 1) * SAMPLE_RATE_HZ;
+        sm.set_clock_divider(Self::get_sm_divider(SAMPLE_RATE_HZ).to_fixed());
-        let divider = (clk_sys_freq() / (target_clock * 2)).to_fixed();
-        sm.set_clock_divider(divider);
-
-        sm.set_enable(true);
 
         Self {
             dma: dma.into(),
             sm,
         }
     }
+
+    fn reconfigure(&mut self, sample_rate: u32) {
+        self.sm
+            .set_clock_divider(Self::get_sm_divider(sample_rate).to_fixed());
+    }
 }
 
 /// packs two u8 samples into 32bit word

kernel/src/display.rs

@@ -1,5 +1,4 @@
 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::{
@@ -9,17 +8,20 @@ use embassy_rp::{
     spi::{Async, Spi},
 };
 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 = "psram")]
+use core::alloc::{GlobalAlloc, Layout};
+#[cfg(feature = "psram")]
+use embedded_graphics::{draw_target::DrawTarget, pixelcolor::Rgb565, prelude::RgbColor};
 
 #[cfg(feature = "fps")]
 pub use framebuffer::fps::{FPS_CANVAS, FPS_COUNTER};
 
-type DISPLAY = ST7365P<
+type Display = ST7365P<
     ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
     Output<'static>,
     Output<'static>,
@@ -56,7 +58,7 @@ pub async fn init_display(
     cs: Peri<'static, PIN_13>,
     data: Peri<'static, PIN_14>,
     reset: Peri<'static, PIN_15>,
-) -> DISPLAY {
+) -> Display {
     init_fb();
 
     let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
@@ -84,7 +86,7 @@ pub async fn init_display(
 }
 
 #[embassy_executor::task]
-pub async fn display_handler(mut display: DISPLAY) {
+pub async fn display_handler(mut display: Display) {
     use embassy_time::{Instant, Timer};
 
     // Target ~60 Hz refresh (≈16.67 ms per frame)
@@ -111,7 +113,7 @@ pub async fn display_handler(mut display: DISPLAY) {
             }
         }
 
-        let elapsed = start.elapsed().as_millis() as u64;
+        let elapsed = start.elapsed().as_millis();
         if elapsed < FRAME_TIME_MS {
             Timer::after_millis(FRAME_TIME_MS - elapsed).await;
         } else {

kernel/src/elf.rs

@@ -8,38 +8,45 @@ use core::ptr;
 use embedded_sdmmc::ShortFileName;
 use goblin::{
     elf::{
-        header::header32::Header,
+        header::{EM_ARM, ET_DYN, EV_CURRENT, header32::Header},
         program_header::program_header32::{PT_LOAD, ProgramHeader},
         reloc::R_ARM_RELATIVE,
         section_header::{SHT_REL, SHT_SYMTAB},
     },
-    elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym},
+    elf32::{reloc::Rel, section_header::SectionHeader, sym::Sym},
 };
 use strum::IntoEnumIterator;
 use userlib_sys::{EntryFn, SyscallTable};
 
 const ELF32_HDR_SIZE: usize = 52;
 
-pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> {
+#[derive(Debug)]
+pub enum LoadError {
+    WrongMachine,
+    InvalidElf,
+    FailedToReadFile,
+    ElfIsNotPie,
+    UnknownRelocationType,
+    SyscallTableNotFound,
+}
+
+pub async unsafe fn load_binary(name: &ShortFileName) -> Result<(EntryFn, Bump), LoadError> {
     let mut sd_lock = SDCARD.get().lock().await;
-    let sd = sd_lock.as_mut().unwrap();
+    let sd = sd_lock.as_mut().expect("Sdcard locked");
 
     let mut header_buf = [0; ELF32_HDR_SIZE];
 
-    let (entry, bump) = sd
+    sd.read_file(name, |mut file| {
-        .read_file(name, |mut file| {
+        file.read(&mut header_buf)
-            file.read(&mut header_buf).unwrap();
+            .map_err(|_| LoadError::FailedToReadFile)?;
         let elf_header = Header::from_bytes(&header_buf);
 
-            // reject non-PIE
+        validate_header(&elf_header)?;
-            if elf_header.e_type != header::ET_DYN {
-                return None;
-            }
 
         let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize];
 
         let (total_size, min_vaddr, _max_vaddr) =
-                total_loadable_size(&mut file, &elf_header, &mut ph_buf);
+            total_loadable_size(&mut file, elf_header, &mut ph_buf)?;
 
         let bump = Bump::with_capacity(total_size);
         let base = bump.alloc_slice_fill_default::<u8>(total_size);
@@ -47,45 +54,54 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)>
         // load each segment into bump, relative to base_ptr
         for i in 0..elf_header.e_phnum {
             file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-                    .unwrap();
+                .map_err(|_| LoadError::FailedToReadFile)?;
-                file.read(&mut ph_buf).unwrap();
+            file.read(&mut ph_buf)
+                .map_err(|_| LoadError::FailedToReadFile)?;
             let ph = cast_phdr(&ph_buf);
 
             let seg_offset = (ph.p_vaddr - min_vaddr) as usize;
-                let mut segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
+            let segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize];
 
             if ph.p_type == PT_LOAD {
-                    load_segment(&mut file, &ph, &mut segment).unwrap();
+                load_segment(&mut file, &ph, segment)?;
             }
         }
 
         for i in 0..elf_header.e_shnum {
-                let sh = read_section(&mut file, elf_header, i.into());
+            let sh = read_section(&mut file, elf_header, i.into())?;
 
-                match sh.sh_type {
+            if sh.sh_type == SHT_REL {
-                    SHT_REL => {
+                apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file)?;
-                        apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap();
-                    }
-                    _ => {}
             }
         }
 
-            patch_syscalls(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap();
+        patch_syscalls(elf_header, base.as_mut_ptr(), min_vaddr, &mut file)?;
 
         // entry pointer is base_ptr + (entry - min_vaddr)
         let entry_ptr: EntryFn = unsafe {
             core::mem::transmute(base.as_ptr().add((elf_header.e_entry - min_vaddr) as usize))
         };
 
-            Some((entry_ptr, bump))
+        Ok((entry_ptr, bump))
     })
     .await
-        .expect("Failed to read file")?;
+    .map_err(|_| LoadError::FailedToReadFile)?
-
-    Some((entry, bump))
 }
 
-fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), ()> {
+fn validate_header(h: &Header) -> Result<(), LoadError> {
+    if h.e_type != ET_DYN {
+        return Err(LoadError::ElfIsNotPie);
+    }
+    if h.e_machine != EM_ARM {
+        return Err(LoadError::WrongMachine);
+    }
+    if h.e_version as u8 != EV_CURRENT {
+        return Err(LoadError::InvalidElf);
+    }
+    Ok(())
+}
+
+fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Result<(), LoadError> {
     let filesz = ph.p_filesz as usize;
     let memsz = ph.p_memsz as usize;
 
@@ -97,8 +113,10 @@ fn load_segment(file: &mut File, ph: &ProgramHeader, segment: &mut [u8]) -> Resu
 
     while remaining > 0 {
         let to_read = core::cmp::min(remaining, buf.len());
-        file.seek_from_start(file_offset).unwrap();
+        file.seek_from_start(file_offset)
-        file.read(&mut buf[..to_read]).unwrap();
+            .map_err(|_| LoadError::FailedToReadFile)?;
+        file.read(&mut buf[..to_read])
+            .map_err(|_| LoadError::FailedToReadFile)?;
 
         segment[dst_offset..dst_offset + to_read].copy_from_slice(&buf[..to_read]);
 
@@ -120,14 +138,16 @@ fn apply_relocations(
     min_vaddr: u32,
     base: *mut u8,
     file: &mut File,
-) -> Result<(), ()> {
+) -> Result<(), LoadError> {
     let mut reloc = [0_u8; 8];
 
     let num_relocs = sh.sh_size as usize / sh.sh_entsize as usize;
 
     for i in 0..num_relocs {
-        file.seek_from_start(sh.sh_offset + (i as u32 * 8)).unwrap();
+        file.seek_from_start(sh.sh_offset + (i as u32 * 8))
-        file.read(&mut reloc).unwrap();
+            .map_err(|_| LoadError::FailedToReadFile)?;
+        file.read(&mut reloc)
+            .map_err(|_| LoadError::FailedToReadFile)?;
 
         let rel = cast_rel(&reloc);
 
@@ -143,7 +163,7 @@ fn apply_relocations(
                 }
             }
             _ => {
-                return Err(());
+                return Err(LoadError::UnknownRelocationType);
             }
         }
     }
@@ -155,15 +175,17 @@ fn patch_syscalls(
     base: *mut u8,
     min_vaddr: u32,
     file: &mut File,
-) -> Result<(), ()> {
+) -> Result<(), LoadError> {
     for i in 1..=elf_header.e_shnum {
-        let sh = read_section(file, &elf_header, i.into());
+        let sh = read_section(file, elf_header, i.into())?;
 
         // find the symbol table
         if sh.sh_type == SHT_SYMTAB {
             let mut symtab_buf = vec![0u8; sh.sh_size as usize];
-            file.seek_from_start(sh.sh_offset).unwrap();
+            file.seek_from_start(sh.sh_offset)
-            file.read(&mut symtab_buf).unwrap();
+                .map_err(|_| LoadError::FailedToReadFile)?;
+            file.read(&mut symtab_buf)
+                .map_err(|_| LoadError::FailedToReadFile)?;
 
             // Cast buffer into symbols
             let sym_count = sh.sh_size as usize / sh.sh_entsize as usize;
@@ -172,22 +194,23 @@ fn patch_syscalls(
                     &symtab_buf[i * sh.sh_entsize as usize..(i + 1) * sh.sh_entsize as usize];
                 let sym = cast_sym(sym_bytes);
 
-                let str_sh = read_section(file, &elf_header, sh.sh_link);
+                let str_sh = read_section(file, elf_header, sh.sh_link)?;
 
                 let mut name = Vec::new();
                 file.seek_from_start(str_sh.sh_offset + sym.st_name)
-                    .unwrap();
+                    .map_err(|_| LoadError::FailedToReadFile)?;
 
                 loop {
                     let mut byte = [0u8; 1];
-                    file.read(&mut byte).unwrap();
+                    file.read(&mut byte)
+                        .map_err(|_| LoadError::FailedToReadFile)?;
                     if byte[0] == 0 {
                         break;
                     }
                     name.push(byte[0]);
                 }
 
-                let symbol_name = core::str::from_utf8(&name).unwrap();
+                let symbol_name = core::str::from_utf8(&name).expect("symbol was not utf8");
                 if symbol_name == stringify!(SYS_CALL_TABLE) {
                     let table_base =
                         unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) }
@@ -207,11 +230,14 @@ fn patch_syscalls(
                             SyscallTable::ReadFile => syscalls::read_file as usize,
                             SyscallTable::WriteFile => syscalls::write_file as usize,
                             SyscallTable::FileLen => syscalls::file_len as usize,
+                            SyscallTable::ReconfigureAudioSampleRate => {
+                                syscalls::reconfigure_audio_sample_rate as usize
+                            }
                             SyscallTable::AudioBufferReady => syscalls::audio_buffer_ready as usize,
                             SyscallTable::SendAudioBuffer => syscalls::send_audio_buffer as usize,
                         };
                         unsafe {
-                            table_base.add(idx as usize).write(ptr);
+                            table_base.add(idx).write(ptr);
                         }
                     }
                     return Ok(());
@@ -219,21 +245,21 @@ fn patch_syscalls(
             }
         }
     }
-    Err(())
+    Err(LoadError::SyscallTableNotFound)
 }
 
 fn total_loadable_size(
     file: &mut File,
     elf_header: &Header,
     ph_buf: &mut [u8],
-) -> (usize, u32, u32) {
+) -> Result<(usize, u32, u32), LoadError> {
     let mut min_vaddr = u32::MAX;
     let mut max_vaddr = 0u32;
     for i in 0..elf_header.e_phnum {
         file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
-            .unwrap();
+            .map_err(|_| LoadError::FailedToReadFile)?;
-        file.read(ph_buf).unwrap();
+        file.read(ph_buf).map_err(|_| LoadError::FailedToReadFile)?;
-        let ph = cast_phdr(&ph_buf);
+        let ph = cast_phdr(ph_buf);
 
         if ph.p_type == PT_LOAD {
             if ph.p_vaddr < min_vaddr {
@@ -246,17 +272,22 @@ fn total_loadable_size(
     }
 
     let total_size = (max_vaddr - min_vaddr) as usize;
-    (total_size, min_vaddr, max_vaddr)
+    Ok((total_size, min_vaddr, max_vaddr))
 }
 
-fn read_section(file: &mut File, elf_header: &Header, section: u32) -> SectionHeader {
+fn read_section(
+    file: &mut File,
+    elf_header: &Header,
+    section: u32,
+) -> Result<SectionHeader, LoadError> {
     let mut sh_buf = vec![0_u8; elf_header.e_shentsize as usize];
 
     file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
-        .unwrap();
+        .map_err(|_| LoadError::FailedToReadFile)?;
-    file.read(&mut sh_buf).unwrap();
+    file.read(&mut sh_buf)
+        .map_err(|_| LoadError::FailedToReadFile)?;
 
-    cast_shdr(&sh_buf)
+    Ok(cast_shdr(&sh_buf))
 }
 
 fn cast_phdr(buf: &[u8]) -> ProgramHeader {

kernel/src/framebuffer.rs

@@ -46,7 +46,7 @@ impl<'a> AtomicFrameBuffer<'a> {
     }
 
     fn mark_tiles_dirty(&mut self, rect: Rectangle) {
-        let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
+        let tiles_x = SCREEN_WIDTH.div_ceil(TILE_SIZE);
         let start_tx = (rect.top_left.x as usize) / TILE_SIZE;
         let end_tx = ((rect.top_left.x + rect.size.width as i32 - 1) as usize) / TILE_SIZE;
         let start_ty = (rect.top_left.y as usize) / TILE_SIZE;
@@ -261,14 +261,15 @@ impl<'a> AtomicFrameBuffer<'a> {
                 // Check for dirty tile
                 if self.dirty_tiles[row_start_idx + col].swap(false, Ordering::Acquire) {
                     let run_start = col;
+                    let mut scan_col = col;
                     let mut run_len = 1;
 
                     // Extend run while contiguous dirty tiles and within MAX_BATCH_TILES
-                    while col + 1 < NUM_TILE_COLS
+                    while scan_col + 1 < NUM_TILE_COLS
                         && self.dirty_tiles[row_start_idx + col + 1].load(Ordering::Acquire)
                         && run_len < MAX_BATCH_TILES
                     {
-                        col += 1;
+                        scan_col += 1;
                         run_len += 1;
                     }
 
@@ -293,6 +294,8 @@ impl<'a> AtomicFrameBuffer<'a> {
                             &self.batch_tile_buf[..run_len * TILE_SIZE * TILE_SIZE],
                         )
                         .await?;
+
+                    col = scan_col;
                 }
 
                 col += 1;
@@ -346,11 +349,9 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
             }
         }
 
-        if changed {
+        if changed && let Some(rect) = dirty_rect {
-            if let Some(rect) = dirty_rect {
             self.mark_tiles_dirty(rect);
         }
-        }
 
         Ok(())
     }
@@ -402,7 +403,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
     fn fill_solid(&mut self, area: &Rectangle, color: Self::Color) -> Result<(), Self::Error> {
         self.fill_contiguous(
             area,
-            core::iter::repeat(color).take((self.size().width * self.size().height) as usize),
+            core::iter::repeat_n(color, (self.size().width * self.size().height) as usize),
         )
     }
 
@@ -412,8 +413,10 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
             0,
             self.size().width as u16 - 1,
             self.size().height as u16 - 1,
-            core::iter::repeat(RawU16::from(color).into_inner())
+            core::iter::repeat_n(
-                .take((self.size().width * self.size().height) as usize),
+                RawU16::from(color).into_inner(),
+                (self.size().width * self.size().height) as usize,
+            ),
         )?;
 
         for tile in self.dirty_tiles.iter() {

kernel/src/heap.rs

@@ -23,7 +23,7 @@ impl Region {
     fn contains(&self, address: usize) -> bool {
         let start = self.start.load(Ordering::Relaxed);
         let end = start + self.size.load(Ordering::Relaxed);
-        (start..start + end).contains(&address)
+        (start..end).contains(&address)
     }
 
     fn new(start: usize, size: usize) -> Self {

kernel/src/main.rs

@@ -5,6 +5,9 @@
 #![allow(static_mut_refs)]
 #![feature(allocator_api)]
 #![feature(slice_ptr_get)]
+#![deny(warnings)]
+#![deny(clippy::redundant_clone)]
+#![deny(clippy::unwrap_used)]
 
 extern crate alloc;
 
@@ -12,11 +15,15 @@ mod audio;
 mod display;
 mod elf;
 mod framebuffer;
+// TODO: NEED TO UPDATE MCU TO TEST BATTERY READS
+#[allow(unused)]
 mod peripherals;
+#[allow(unused)]
 mod scsi;
 mod storage;
 mod syscalls;
 mod ui;
+#[allow(unused)]
 mod usb;
 mod utils;
 
@@ -28,10 +35,10 @@ mod heap;
 mod psram;
 
 #[cfg(feature = "psram")]
-use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram, psram::init_psram_qmi};
+use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi};
 
 use crate::{
-    audio::audio_handler,
+    audio::{AUDIO_BUFFER_WRITTEN, audio_handler, clear_audio_buffers},
     display::{FRAMEBUFFER, display_handler, init_display},
     peripherals::{conf_peripherals, keyboard::read_keyboard_fifo},
     scsi::MSC_SHUTDOWN,
@@ -102,7 +109,7 @@ async fn watchdog_task(mut watchdog: Watchdog) {
             ResetReason::Forced => "forced",
             ResetReason::TimedOut => "timed out",
         };
-        #[cfg(feature = "debug")]
+        #[cfg(feature = "defmt")]
         defmt::error!("Watchdog reset reason: {}", _reason);
     }
 
@@ -222,6 +229,9 @@ async fn userland_task() {
 
         // enable kernel ui
         {
+            AUDIO_BUFFER_WRITTEN.store(false, Ordering::Release);
+            clear_audio_buffers();
+
             ENABLE_UI.store(true, Ordering::Release);
             UI_CHANGE.signal(());
             unsafe { FRAMEBUFFER.as_mut().unwrap().clear(Rgb565::BLACK).unwrap() };
@@ -321,7 +331,7 @@ async fn setup_display(display: Display, spawner: Spawner) {
 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);
-    #[cfg(feature = "debug")]
+    #[cfg(feature = "defmt")]
     defmt::info!("size:  {}", psram_qmi_size);
     Timer::after_millis(100).await;
 
@@ -363,7 +373,7 @@ async fn kernel_task(
         .spawn(watchdog_task(Watchdog::new(watchdog)))
         .unwrap();
 
-    #[cfg(feature = "debug")]
+    #[cfg(feature = "defmt")]
     defmt::info!("Clock: {}", embassy_rp::clocks::clk_sys_freq());
 
     setup_mcu(mcu).await;

kernel/src/psram.rs

@@ -526,7 +526,7 @@ pub fn init_psram_qmi(
     let psram_size = detect_psram_qmi(qmi);
 
     if psram_size == 0 {
-        #[cfg(feature = "debug")]
+        #[cfg(feature = "defmt")]
         defmt::error!("qmi psram size 0");
         return 0;
     }

kernel/src/scsi/mod.rs

@@ -30,7 +30,7 @@ pub struct MassStorageClass<'d, D: Driver<'d>> {
     bulk_in: D::EndpointIn,
 }
 
-impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
+impl<'d, D: Driver<'d>> MassStorageClass<'d, D> {
     pub fn new(builder: &mut Builder<'d, D>, temp_sd: Option<SdCard>) -> Self {
         let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
         let mut interface = function.interface();
@@ -72,9 +72,10 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
     async fn handle_cbw(&mut self) {
         let mut cbw_buf = [0u8; 31];
-        if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
+        if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await
-            if n == 31 {
+            && n == 31
-                if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
+            && 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;
@@ -94,15 +95,13 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.send_csw_fail(cbw.dCBWTag).await
             }
 
-                    if self.pending_eject {
+            if self.pending_eject
-                        if let ScsiCommand::Write { lba: _, len: _ } = command {
+                && let ScsiCommand::Write { lba: _, len: _ } = command
+            {
                 MSC_SHUTDOWN.signal(());
             }
         }
     }
-            }
-        }
-    }
 
     async fn handle_command(&mut self, command: ScsiCommand) -> Result<(), ()> {
         let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
@@ -238,7 +237,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 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.saturating_sub(1);
 
                 response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
                 response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
@@ -249,7 +248,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 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.saturating_sub(1);
 
                 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
@@ -269,7 +268,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                         sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
 
                         for block in &mut *block_buf {
-                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE) {
                                 self.bulk_in.write(chunk).await.map_err(|_| ())?;
                             }
                         }
@@ -281,7 +280,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                             .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()) {
+                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE) {
                                 self.bulk_in.write(chunk).await.map_err(|_| ())?;
                             }
                         }
@@ -301,8 +300,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 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())
+                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE) {
-                            {
                                 self.bulk_out.read(chunk).await.map_err(|_| ())?;
                             }
                         }
@@ -313,8 +311,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                         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())
+                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE) {
-                            {
                                 self.bulk_out.read(chunk).await.map_err(|_| ())?;
                             }
                         }

kernel/src/scsi/scsi_types.rs

@@ -1,7 +1,7 @@
 use num_enum::TryFromPrimitive;
 
 /// THE CODE BELOW ORIGINATES FROM: https://github.com/apohrebniak/usbd-storage/blob/master/usbd-storage/src/subclass/scsi.rs
-
+///
 /// SCSI device subclass code
 pub const SUBCLASS_SCSI: u8 = 0x06; // SCSI Transparent command set
 
@@ -91,6 +91,7 @@ pub enum ScsiCommand {
     },
 }
 
+#[allow(clippy::enum_variant_names)]
 #[repr(u8)]
 #[derive(Copy, Clone, Debug, TryFromPrimitive)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]

kernel/src/storage.rs

@@ -9,8 +9,8 @@ use embassy_sync::mutex::Mutex;
 use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use embedded_sdmmc::{
-    Block, BlockCount, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource,
+    Block, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource, Timestamp,
-    Timestamp, Volume, VolumeIdx, VolumeManager, sdcard::Error,
+    VolumeIdx, VolumeManager, sdcard::Error,
 };
 use embedded_sdmmc::{File as SdFile, LfnBuffer, Mode, ShortFileName};
 
@@ -21,7 +21,6 @@ pub const MAX_VOLUMES: usize = 1;
 type Device = ExclusiveDevice<Spi<'static, SPI0, Blocking>, Output<'static>, embassy_time::Delay>;
 type SD = SdmmcSdCard<Device, Delay>;
 type VolMgr = VolumeManager<SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
-type Vol<'a> = Volume<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
 pub type Dir<'a> = Directory<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
 pub type File<'a> = SdFile<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
 
@@ -43,7 +42,7 @@ pub struct FileName {
 
 impl PartialOrd for FileName {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        Some(self.long_name.cmp(&other.long_name))
+        Some(self.cmp(other))
     }
 }
 
@@ -53,6 +52,13 @@ impl Ord for FileName {
     }
 }
 
+#[derive(Debug)]
+pub enum SdCardError {
+    Volume0Missing,
+    RootDirMissing,
+    FileOpenFailed,
+}
+
 pub struct SdCard {
     det: Input<'static>,
     volume_mgr: VolMgr,
@@ -67,10 +73,7 @@ impl SdCard {
             DummyTimeSource {},
             5000,
         );
-        Self {
+        Self { det, volume_mgr }
-            det: det,
-            volume_mgr,
-        }
     }
 
     /// Returns true if an SD card is inserted.
@@ -90,17 +93,6 @@ impl SdCard {
         result
     }
 
-    pub fn num_blocks(&self) -> u32 {
-        let mut result = 0;
-
-        self.volume_mgr.device(|sd| {
-            result = sd.num_blocks().unwrap_or(BlockCount(0)).0;
-            DummyTimeSource {}
-        });
-
-        result
-    }
-
     pub fn read_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
         let mut res: Result<(), Error> = Ok(());
         self.volume_mgr.device(|sd| {
@@ -119,30 +111,37 @@ impl SdCard {
         res.map_err(|_| ())
     }
 
-    pub fn access_root_dir(&mut self, mut access: impl FnMut(Dir)) {
+    pub fn access_root_dir<R>(
-        let volume0 = self.volume_mgr.open_volume(VolumeIdx(0)).unwrap();
+        &mut self,
-        let root_dir = volume0.open_root_dir().unwrap();
+        mut access: impl FnMut(Dir) -> R,
+    ) -> Result<R, SdCardError> {
+        let volume0 = self
+            .volume_mgr
+            .open_volume(VolumeIdx(0))
+            .map_err(|_| SdCardError::Volume0Missing)?;
+        let root_dir = volume0
+            .open_root_dir()
+            .map_err(|_| SdCardError::RootDirMissing)?;
 
-        access(root_dir);
+        Ok(access(root_dir))
     }
 
-    pub async fn read_file<T>(
+    pub async fn read_file<R>(
         &mut self,
         name: &ShortFileName,
-        mut access: impl FnMut(File) -> T,
+        mut access: impl FnMut(File) -> R,
-    ) -> Result<T, ()> {
+    ) -> Result<R, SdCardError> {
-        let mut res = Err(());
         self.access_root_dir(|root_dir| {
-            if let Ok(file) = root_dir.open_file_in_dir(name, Mode::ReadOnly) {
+            let file = root_dir
-                res = Ok(access(file));
+                .open_file_in_dir(name, Mode::ReadOnly)
-            }
+                .map_err(|_| SdCardError::FileOpenFailed)?;
-        });
 
-        res
+            Ok(access(file))
+        })?
     }
 
     /// Returns a Vec of file names (long format) that match the given extension (e.g., "BIN")
-    pub fn list_files_by_extension(&mut self, ext: &str) -> Result<Vec<FileName>, ()> {
+    pub fn list_files_by_extension(&mut self, ext: &str) -> Result<Vec<FileName>, SdCardError> {
         let mut result = Vec::new();
 
         // Only proceed if card is inserted
@@ -166,7 +165,7 @@ impl SdCard {
                 }
             })
             .unwrap()
-        });
+        })?;
 
         Ok(result)
     }

kernel/src/syscalls.rs

@@ -7,8 +7,8 @@ use embedded_sdmmc::LfnBuffer;
 use heapless::spsc::Queue;
 use userlib_sys::{
     AUDIO_BUFFER_SAMPLES, Alloc, AudioBufferReady, CLayout, CPixel, Dealloc, DrawIter, FileLen,
-    GenRand, GetMs, ListDir, Print, ReadFile, RngRequest, SendAudioBuffer, SleepMs, WriteFile,
+    GenRand, GetMs, ListDir, Print, ReadFile, ReconfigureAudioSampleRate, RngRequest,
-    keyboard::*,
+    SendAudioBuffer, SleepMs, WriteFile, keyboard::*,
 };
 
 #[cfg(feature = "psram")]
@@ -18,7 +18,7 @@ use crate::heap::HEAP;
 use core::alloc::GlobalAlloc;
 
 use crate::{
-    audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY},
+    audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_SAMPLE_RATE, AUDIO_BUFFER_WRITTEN},
     display::FRAMEBUFFER,
     framebuffer::FB_PAUSED,
     storage::{Dir, File, SDCARD},
@@ -35,7 +35,7 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
 
         #[cfg(not(feature = "psram"))]
         {
-            return alloc::alloc::alloc(layout.into());
+            alloc::alloc::alloc(layout.into())
         }
     }
 }
@@ -134,7 +134,7 @@ unsafe fn copy_entry_to_user_buf(name: &[u8], dest: *mut c_char, max_str_len: us
     if !dest.is_null() {
         let len = name.len().min(max_str_len - 1);
         unsafe {
-            ptr::copy_nonoverlapping(name.as_ptr(), dest as *mut u8, len);
+            ptr::copy_nonoverlapping(name.as_ptr(), dest, len);
             *dest.add(len) = 0; // nul terminator
         }
     }
@@ -190,8 +190,8 @@ pub extern "C" fn list_dir(
     let sd = guard.as_mut().unwrap();
 
     let mut wrote = 0;
-    sd.access_root_dir(|root| {
+    let _ = sd.access_root_dir(|root| {
-        if dirs[0] == "" && dirs.len() >= 2 {
+        if dirs[0].is_empty() && dirs.len() >= 2 {
             unsafe {
                 if dir == "/" {
                     wrote = get_dir_entries(&root, files, max_entry_str_len);
@@ -214,11 +214,11 @@ fn recurse_file<T>(
         let mut buf = LfnBuffer::new(&mut b);
         let mut short_name = None;
         dir.iterate_dir_lfn(&mut buf, |entry, name| {
-            if let Some(name) = name {
+            if let Some(name) = name
-                if name == dirs[0] || entry.name.to_string().as_str() == dirs[0] {
+                && (name == dirs[0] || entry.name.to_string().as_str() == dirs[0])
+            {
                 short_name = Some(entry.name.clone());
             }
-            }
         })
         .expect("Failed to iterate dir");
 
@@ -257,17 +257,17 @@ pub extern "C" fn read_file(
     }
 
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
-    let mut buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
+    let buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
 
     let mut read = 0;
 
     let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
     let sd = guard.as_mut().unwrap();
     if !file.is_empty() {
-        sd.access_root_dir(|root| {
+        let _ = sd.access_root_dir(|root| {
             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()
+                file.read(buf).unwrap()
             }) {
                 read = result
             };
@@ -303,10 +303,10 @@ pub extern "C" fn write_file(
     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| {
+        let _ = 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()
+                file.write(buf).unwrap()
             })
             .unwrap_or(())
         });
@@ -324,7 +324,7 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     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| {
+        let _ = sd.access_root_dir(|root| {
             if let Ok(result) = recurse_file(&root, &file[1..], |file| file.length()) {
                 len = result
             }
@@ -333,6 +333,11 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     len as usize
 }
 
+const _: ReconfigureAudioSampleRate = reconfigure_audio_sample_rate;
+pub extern "C" fn reconfigure_audio_sample_rate(sample_rate: u32) {
+    AUDIO_BUFFER_SAMPLE_RATE.store(sample_rate, Ordering::Release);
+}
+
 const _: AudioBufferReady = audio_buffer_ready;
 pub extern "C" fn audio_buffer_ready() -> bool {
     AUDIO_BUFFER_READY.load(Ordering::Acquire)
@@ -343,11 +348,14 @@ 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) {}
+    while !AUDIO_BUFFER_READY.load(Ordering::Acquire) {
+        core::hint::spin_loop();
+    }
 
     if buf.len() == AUDIO_BUFFER_SAMPLES * 2 {
         AUDIO_BUFFER_READY.store(false, Ordering::Release);
         unsafe { AUDIO_BUFFER.copy_from_slice(buf) };
+        AUDIO_BUFFER_WRITTEN.store(true, Ordering::Release);
     } else {
         #[cfg(feature = "defmt")]
         defmt::warn!(

kernel/src/ui.rs

@@ -2,7 +2,6 @@ use crate::{
     BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
     peripherals::keyboard, storage::FileName,
 };
-use userlib_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};
@@ -20,14 +19,16 @@ use embedded_layout::{
     prelude::*,
 };
 use embedded_text::TextBox;
+use userlib_sys::keyboard::{KeyCode, KeyState};
 
 pub static SELECTIONS: Mutex<CriticalSectionRawMutex, SelectionList> =
     Mutex::new(SelectionList::new());
 
 pub async fn ui_handler() {
     loop {
-        if let Some(event) = keyboard::read_keyboard_fifo().await {
+        if let Some(event) = keyboard::read_keyboard_fifo().await
-            if let KeyState::Pressed = event.state {
+            && let KeyState::Pressed = event.state
+        {
             match event.key {
                 KeyCode::Up => {
                     let mut selections = SELECTIONS.lock().await;
@@ -43,16 +44,16 @@ pub async fn ui_handler() {
                         selections.selections[selections.current_selection as usize].clone();
 
                     let entry = unsafe {
-                            load_binary(&selection.short_name)
+                        match load_binary(&selection.short_name).await {
-                                .await
+                            Ok(entry) => entry,
-                                .expect("unable to load binary")
+                            Err(e) => panic!("unable to load binary: {:?}", e),
+                        }
                     };
                     BINARY_CH.send(entry).await;
                 }
                 _ => (),
             }
         }
-        }
 
         let changed = SELECTIONS.lock().await.changed;
         if changed {

selection_ui/src/lib.rs

@@ -51,16 +51,15 @@ impl<'a> SelectionUi<'a> {
         let selection;
         loop {
             let key = get_key();
-            if key.state == KeyState::Pressed {
+            if key.state == KeyState::Pressed
-                if let Some(s) = self.update(display, key.key)? {
+                && let Some(s) = self.update(display, key.key)? {
                     selection = Some(s);
                     display
                         .clear(Rgb565::BLACK)
-                        .map_err(|e| SelectionUiError::DisplayError(e))?;
+                        .map_err(SelectionUiError::DisplayError)?;
                     break;
                 }
         }
-        }
         Ok(selection)
     }
 
@@ -100,7 +99,7 @@ impl<'a> SelectionUi<'a> {
             Rectangle::new(bounds.top_left, bounds.size)
                 .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
                 .draw(display)
-                .map_err(|e| SelectionUiError::DisplayError(e))?;
+                .map_err(SelectionUiError::DisplayError)?;
         }
 
         let mut views: Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
@@ -119,7 +118,7 @@ impl<'a> SelectionUi<'a> {
 
         layout
             .draw(display)
-            .map_err(|e| SelectionUiError::DisplayError(e))?;
+            .map_err(SelectionUiError::DisplayError)?;
 
         // draw selected box
         if let Some(selected_bounds) = layout.inner().get(self.selection) {
@@ -127,7 +126,7 @@ impl<'a> SelectionUi<'a> {
             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))?;
+                .map_err(SelectionUiError::DisplayError)?;
 
             self.last_bounds = Some(selected_bounds);
         }
@@ -136,9 +135,9 @@ impl<'a> SelectionUi<'a> {
     }
 }
 
-pub fn draw_text_center<'a, S>(
+pub fn draw_text_center<S>(
     display: &mut Display,
-    text: &'a str,
+    text: &str,
     style: S,
 ) -> Result<Point, <Display as DrawTarget>::Error>
 where

user_apps/calculator/src/main.rs

@@ -83,7 +83,7 @@ pub fn main() {
             .align_to(&display.bounding_box(), horizontal::Left, vertical::Center);
 
             let result = if let Ok(result) = evaluate(&input[input_min..]) {
-                &format!(" = {}", result)
+                &format!(" = {result}")
             } else {
                 " = Error"
             };

user_apps/gallery/src/main.rs

@@ -51,9 +51,9 @@ pub fn main() {
 
         println!("file: {}", file);
         if file.extension().unwrap_or("") == "bmp" || file.extension().unwrap_or("") == "BMP" {
-            let file_path = format!("/images/{}", file);
+            let file_path = format!("/images/{file}");
 
-            let read = read_file(&file_path, 0, &mut &mut bmp_buf[..]);
+            let read = read_file(&file_path, 0, &mut bmp_buf[..]);
             if read > 0 {
                 let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
 
@@ -74,7 +74,7 @@ pub fn main() {
 
                 let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
                 let text_y = y + bmp_h + 2; // 2px gap under image
-                Text::new(&file.base(), Point::new(cell_x + 2, text_y), text_style)
+                Text::new(file.base(), Point::new(cell_x + 2, text_y), text_style)
                     .draw(&mut display)
                     .unwrap();
 
@@ -85,11 +85,8 @@ pub fn main() {
 
     loop {
         let event = get_key();
-        if event.state != KeyState::Idle {
+        if event.state != KeyState::Idle && event.key == KeyCode::Esc {
-            match event.key {
+            return;
-                KeyCode::Esc => return,
-                _ => (),
         }
-        };
     }
 }

user_apps/gboy/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "gboy"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+bindgen = "0.71.0"
+cc = "1.2.44"
+
+[dependencies]
+userlib = { path = "../../userlib" }
+selection_ui = { path = "../../selection_ui" }
+embedded-graphics = "0.8.1"

user_apps/gboy/build.rs

@@ -0,0 +1,67 @@
+//! 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() {
+    bindgen();
+
+    // 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");
+}
+
+fn bindgen() {
+    let bindings = bindgen::Builder::default()
+        .header("Peanut-GB/peanut_gb.h")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .disable_nested_struct_naming()
+        .clang_arg("-I../../picolibc/newlib/libc/include/")
+        .clang_arg("-I../../picolibc/build/")
+        .use_core()
+        .generate()
+        .expect("Unable to generate bindings");
+
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+
+    cc::Build::new()
+        .define("PEANUT_GB_IS_LITTLE_ENDIAN", None)
+        .define("ENABLE_LCD", None)
+        .file("peanut_gb_stub.c")
+        .include("Peanut-GB")
+        .include("../../picolibc/newlib/libc/include")
+        .include("../../picolibc/build/newlib/libc/include")
+        .include("../../picolibc/build")
+        // optimization flags
+        .flag("-Ofast")
+        .flag("-fdata-sections")
+        .flag("-ffunction-sections")
+        .flag("-mcpu=cortex-m33")
+        .flag("-mthumb")
+        .flag("-g0")
+        .compile("peanut_gb");
+
+    println!("cargo:rustc-link-search=Peanut-GB");
+    println!("cargo:rustc-link-lib=peanut_gb");
+}

user_apps/gboy/peanut_gb_stub.c

@@ -0,0 +1 @@
+#include <peanut_gb.h>

user_apps/gboy/src/main.rs

@@ -0,0 +1,206 @@
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs)]
+
+extern crate alloc;
+use alloc::{vec, vec::Vec};
+use core::{cell::LazyCell, mem::MaybeUninit, panic::PanicInfo};
+use embedded_graphics::{
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    pixelcolor::Rgb565,
+    prelude::RgbColor,
+};
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
+use userlib::{
+    display::Display,
+    format,
+    fs::{Entries, file_len, list_dir, read_file, write_file},
+    get_key,
+    keyboard::{KeyCode, KeyState},
+    println,
+};
+
+mod peanut;
+use peanut::gb_run_frame;
+
+use crate::peanut::{
+    JOYPAD_A, JOYPAD_B, JOYPAD_DOWN, JOYPAD_LEFT, JOYPAD_RIGHT, JOYPAD_SELECT, JOYPAD_START,
+    JOYPAD_UP, gb_cart_ram_read, gb_cart_ram_write, gb_error, gb_get_rom_name, gb_get_save_size,
+    gb_init, gb_init_lcd, gb_reset, gb_rom_read, gb_s, lcd_draw_line,
+};
+
+static mut DISPLAY: LazyCell<Display> = LazyCell::new(|| Display::take().unwrap());
+
+const RAM_SIZE: usize = 32 * 1024; // largest ram size is 32k
+static mut RAM: [u8; RAM_SIZE] = [0; RAM_SIZE];
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+const GAME_PATH: &'static str = "/games/gameboy";
+
+static mut GAME_ROM: Option<Vec<u8>> = None;
+
+pub fn main() {
+    println!("Starting Gameboy app");
+
+    let mut entries = Entries::new();
+    list_dir(GAME_PATH, &mut entries);
+
+    let mut files = entries.entries();
+    files.retain(|e| {
+        let ext = e.extension().unwrap_or("");
+        ext == "gb" || ext == "GB"
+    });
+    let mut roms = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
+    roms.sort();
+
+    let selection = {
+        let display = unsafe { &mut *DISPLAY };
+        let mut selection_ui = SelectionUi::new(&roms);
+        match selection_ui.run_selection_ui(display) {
+            Ok(maybe_sel) => maybe_sel,
+            Err(e) => match e {
+                SelectionUiError::SelectionListEmpty => {
+                    draw_text_center(
+                        display,
+                        &format!("No Roms were found in {}", GAME_PATH),
+                        MonoTextStyle::new(&FONT_6X10, Rgb565::RED),
+                    )
+                    .expect("Display Error");
+                    None
+                }
+                SelectionUiError::DisplayError(_) => panic!("Display Error"),
+            },
+        }
+    };
+
+    assert!(selection.is_some());
+
+    let file_name = format!("{}/{}", GAME_PATH, roms[selection.unwrap()]);
+    let size = file_len(&file_name);
+    unsafe { GAME_ROM = Some(vec![0_u8; size]) };
+    let read = read_file(&file_name, 0, unsafe { GAME_ROM.as_mut().unwrap() });
+    assert!(size == read);
+    println!("Rom size: {}", read);
+
+    let mut gb = MaybeUninit::<gb_s>::uninit();
+
+    let init_status = unsafe {
+        gb_init(
+            gb.as_mut_ptr(),
+            Some(gb_rom_read),
+            Some(gb_cart_ram_read),
+            Some(gb_cart_ram_write),
+            Some(gb_error),
+            core::ptr::null_mut(),
+        )
+    };
+    println!("gb init status: {}", init_status);
+
+    unsafe {
+        load_save(&mut gb.assume_init());
+    }
+
+    unsafe {
+        gb_init_lcd(gb.as_mut_ptr(), Some(lcd_draw_line));
+
+        // enable frame skip
+        // gb.assume_init().direct.set_frame_skip(!true); // active low
+    };
+
+    loop {
+        let event = get_key();
+        let button = match event.key {
+            KeyCode::Esc => {
+                unsafe { write_save(&mut gb.assume_init()) };
+                break;
+            }
+            KeyCode::Char('r') => {
+                unsafe { gb_reset(gb.as_mut_ptr()) };
+                continue;
+            }
+            KeyCode::Tab => JOYPAD_START as u8,
+            KeyCode::Del => JOYPAD_SELECT as u8,
+            KeyCode::Enter => JOYPAD_A as u8,
+            KeyCode::Backspace => JOYPAD_B as u8,
+            KeyCode::Up => JOYPAD_UP as u8,
+            KeyCode::Down => JOYPAD_DOWN as u8,
+            KeyCode::Left => JOYPAD_LEFT as u8,
+            KeyCode::Right => JOYPAD_RIGHT as u8,
+            _ => 0,
+        };
+
+        if button != 0 {
+            unsafe {
+                // bindgen incorrectly generates direct so manual manipulation is required :(
+                let direct_ptr = &mut gb.assume_init().direct as *mut _ as *mut u8;
+                let joypad_ptr = direct_ptr.add(2); // this is the joypad bitfield byte
+
+                if let KeyState::Pressed = event.state {
+                    *joypad_ptr &= !button;
+                } else if let KeyState::Released = event.state {
+                    *joypad_ptr |= button;
+                }
+
+                println!("joypad: {:b}", *joypad_ptr);
+            }
+        }
+
+        unsafe {
+            gb_run_frame(gb.as_mut_ptr());
+        }
+    }
+}
+
+unsafe fn load_save(gb: &mut gb_s) {
+    let mut buf = [0; 16];
+
+    unsafe {
+        gb_get_rom_name(gb, buf.as_mut_ptr());
+
+        let save_size = gb_get_save_size(gb);
+
+        if save_size > 0 {
+            read_file(
+                &format!(
+                    "{}/saves/{}.sav",
+                    GAME_PATH,
+                    str::from_utf8(&buf).expect("bad rom name")
+                ),
+                0,
+                &mut RAM,
+            );
+        }
+    }
+}
+
+unsafe fn write_save(gb: &mut gb_s) {
+    let mut buf = [0; 16];
+
+    unsafe {
+        gb_get_rom_name(gb, buf.as_mut_ptr());
+
+        let save_size = gb_get_save_size(gb);
+
+        if save_size > 0 {
+            write_file(
+                &format!(
+                    "{}/saves/{}.sav",
+                    GAME_PATH,
+                    str::from_utf8(&buf).expect("bad rom name")
+                ),
+                0,
+                &mut RAM,
+            );
+        }
+    }
+}

user_apps/gboy/src/peanut.rs

@@ -0,0 +1,102 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+use crate::{DISPLAY, GAME_ROM, RAM};
+
+#[allow(unused)]
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+use embedded_graphics::{pixelcolor::Rgb565, prelude::Point, Drawable};
+use userlib::{display::Pixel565, println};
+
+pub const GBOY_WIDTH: usize = 160;
+pub const GBOY_HEIGHT: usize = 144;
+
+pub unsafe extern "C" fn gb_rom_read(_gb: *mut gb_s, addr: u32) -> u8 {
+    unsafe { GAME_ROM.as_ref().unwrap()[addr as usize] }
+}
+
+pub unsafe extern "C" fn gb_cart_ram_read(_gb: *mut gb_s, addr: u32) -> u8 {
+    unsafe { RAM[addr as usize] }
+}
+
+pub unsafe extern "C" fn gb_cart_ram_write(_gb: *mut gb_s, addr: u32, val: u8) {
+    unsafe { RAM[addr as usize] = val }
+}
+
+pub unsafe extern "C" fn gb_error(_gb: *mut gb_s, err: gb_error_e, addr: u16) {
+    let e = match err {
+        0 => "UNKNOWN ERROR",
+        1 => "INVALID OPCODE",
+        2 => "INVALID READ",
+        3 => "INVALID WRITE",
+        4 => "HALT FOREVER",
+        5 => "INVALID MAX",
+        _ => unreachable!(),
+    };
+
+    println!("PeanutGB error: {}, addr: {}", e, addr);
+}
+
+const NUM_PALETTES: usize = 3;
+const SHADES_PER_PALETTE: usize = 4;
+
+const PALETTES: [[Rgb565; SHADES_PER_PALETTE]; NUM_PALETTES] = [
+    [
+        Rgb565::new(8, 24, 32),
+        Rgb565::new(52, 104, 86),
+        Rgb565::new(136, 192, 112),
+        Rgb565::new(224, 248, 208),
+    ], // BG
+    [
+        Rgb565::new(8, 24, 32),
+        Rgb565::new(52, 104, 86),
+        Rgb565::new(136, 192, 112),
+        Rgb565::new(224, 248, 208),
+    ], // OBJ0
+    [
+        Rgb565::new(8, 24, 32),
+        Rgb565::new(52, 104, 86),
+        Rgb565::new(136, 192, 112),
+        Rgb565::new(224, 248, 208),
+    ], // OBJ1
+];
+
+pub unsafe extern "C" fn lcd_draw_line(_gb: *mut gb_s, pixels: *const u8, line: u8) {
+    if line < GBOY_HEIGHT as u8 {
+        let pixels = unsafe { core::slice::from_raw_parts(pixels, GBOY_WIDTH) };
+        let y = line as u16;
+
+        for (x, &p) in pixels.iter().enumerate() {
+            let palette_idx = ((p & 0xF0) >> 4) as usize;
+            let shade_idx = (p & 0x03) as usize;
+
+            let color = PALETTES
+                .get(palette_idx)
+                .and_then(|pal| pal.get(shade_idx))
+                .copied()
+                .unwrap_or(Rgb565::new(0, 0, 0));
+
+            // let sx = (x as u16) * 2;
+            // let sy = y * 2;
+
+            // draw_color(color, sx, sy);
+            // draw_color(color, sx + 1, sy);
+            // draw_color(color, sx, sy + 1);
+            // draw_color(color, sx + 1, sy + 1);
+            //
+            draw_color(color, x as u16, y as u16);
+        }
+    }
+}
+
+fn draw_color(color: Rgb565, x: u16, y: u16) {
+    let mut pixel = Pixel565::default();
+    pixel.0 = Point::new(x.into(), y.into());
+    pixel.1 = color;
+
+    unsafe {
+        pixel.draw(&mut *DISPLAY).unwrap();
+    }
+}

user_apps/gif/src/main.rs

@@ -6,16 +6,16 @@ use alloc::{format, vec, vec::Vec};
 use core::panic::PanicInfo;
 use embedded_graphics::{
     image::ImageDrawable,
-    mono_font::{ascii::FONT_6X10, MonoTextStyle},
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
     pixelcolor::Rgb565,
     prelude::{Point, RgbColor},
     transform::Transform,
 };
-use selection_ui::{draw_text_center, SelectionUi, SelectionUiError};
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
 use tinygif::Gif;
 use userlib::{
     display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
-    fs::{file_len, list_dir, read_file, Entries},
+    fs::{Entries, file_len, list_dir, read_file},
     get_key, get_ms,
     keyboard::{KeyCode, KeyState},
     println, sleep,
@@ -44,7 +44,7 @@ pub fn main() {
     let mut gifs = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
     gifs.sort();
 
-    let mut selection_ui = SelectionUi::new(&mut gifs);
+    let mut selection_ui = SelectionUi::new(&gifs);
     let selection = match selection_ui.run_selection_ui(&mut display) {
         Ok(maybe_sel) => maybe_sel,
         Err(e) => match e {
@@ -87,14 +87,9 @@ pub fn main() {
 
             if frame_num % 5 == 0 {
                 let event = get_key();
-                if event.state != KeyState::Idle {
+                if event.state != KeyState::Idle && event.key == KeyCode::Esc {
-                    match event.key {
-                        KeyCode::Esc => {
                     drop(buf);
                     return;
-                        }
-                        _ => (),
-                    };
                 };
             }
             sleep(((frame.delay_centis as u64) * 10).saturating_sub(start));

user_apps/wav_player/src/main.rs

@@ -4,18 +4,18 @@
 extern crate alloc;
 use alloc::{string::String, vec::Vec};
 use core::panic::PanicInfo;
-use embedded_audio::{wav::Wav, AudioFile, PlatformFile, PlatformFileError};
+use embedded_audio::{AudioFile, PlatformFile, PlatformFileError, wav::Wav};
 use embedded_graphics::{
-    mono_font::{ascii::FONT_6X10, MonoTextStyle},
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
     pixelcolor::Rgb565,
     prelude::RgbColor,
 };
-use selection_ui::{draw_text_center, SelectionUi, SelectionUiError};
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
 use userlib::{
-    audio::{audio_buffer_ready, send_audio_buffer, AUDIO_BUFFER_LEN},
+    audio::{AUDIO_BUFFER_LEN, audio_buffer_ready, send_audio_buffer},
     display::Display,
     format,
-    fs::{file_len, list_dir, read_file, Entries},
+    fs::{Entries, file_len, list_dir, read_file},
     get_key,
     keyboard::{KeyCode, KeyState},
     println,
@@ -45,7 +45,7 @@ pub fn main() {
         let mut wavs = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
         wavs.sort();
 
-        let mut selection_ui = SelectionUi::new(&mut wavs);
+        let mut selection_ui = SelectionUi::new(&wavs);
         let selection = match selection_ui.run_selection_ui(&mut display) {
             Ok(maybe_sel) => maybe_sel,
             Err(e) => match e {
@@ -72,7 +72,7 @@ pub fn main() {
         .expect("Display Error");
 
         let file_name = format!("/music/{}", wavs[selection.unwrap()]);
-        let file = File::new(String::from(file_name));
+        let file = File::new(file_name);
         let mut wav = Wav::new(file).unwrap();
         println!("sample rate: {}", wav.sample_rate());
         println!("channels: {:?}", wav.channels() as u8);
@@ -90,11 +90,8 @@ pub fn main() {
             }
 
             let event = get_key();
-            if event.state == KeyState::Released {
+            if event.state == KeyState::Released && event.key == KeyCode::Esc {
-                match event.key {
+                return;
-                    KeyCode::Esc => return,
-                    _ => (),
-                }
             }
         }
     }

userlib/src/lib.rs

@@ -228,6 +228,12 @@ pub mod fs {
     #[derive(Clone, Copy, Debug)]
     pub struct Entries([[u8; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]);
 
+    impl Default for Entries {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
     impl Entries {
         pub fn new() -> Self {
             Self([[0; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES])

userlib_sys/src/lib.rs

@@ -12,7 +12,7 @@ use strum::{EnumCount, EnumIter};
 
 pub type EntryFn = fn();
 
-pub const SYS_CALL_TABLE_COUNT: usize = 14;
+pub const SYS_CALL_TABLE_COUNT: usize = 15;
 const _: () = assert!(SYS_CALL_TABLE_COUNT == SyscallTable::COUNT);
 
 #[derive(Clone, Copy, EnumIter, EnumCount)]
@@ -30,8 +30,9 @@ pub enum SyscallTable {
     ReadFile = 9,
     WriteFile = 10,
     FileLen = 11,
-    AudioBufferReady = 12,
+    ReconfigureAudioSampleRate = 12,
-    SendAudioBuffer = 13,
+    AudioBufferReady = 13,
+    SendAudioBuffer = 14,
 }
 
 #[unsafe(no_mangle)]
@@ -46,9 +47,9 @@ pub struct CLayout {
 }
 
 #[cfg(feature = "alloc")]
-impl Into<Layout> for CLayout {
+impl From<CLayout> for Layout {
-    fn into(self) -> Layout {
+    fn from(val: CLayout) -> Self {
-        unsafe { Layout::from_size_align_unchecked(self.size, self.alignment) }
+        unsafe { Layout::from_size_align_unchecked(val.size, val.alignment) }
     }
 }
 
@@ -106,7 +107,7 @@ pub extern "C" fn get_ms() -> u64 {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Default, Copy, Clone)]
 pub struct CPixel {
     pub x: i32,
     pub y: i32,
@@ -123,19 +124,22 @@ impl CPixel {
     }
 }
 
-impl Into<CPixel> for Pixel<Rgb565> {
+impl From<CPixel> for Pixel<Rgb565> {
-    fn into(self) -> CPixel {
+    fn from(value: CPixel) -> Self {
-        CPixel {
+        Pixel(
-            x: self.0.x,
+            Point::new(value.x, value.y),
-            y: self.0.y,
+            RawU16::new(value.color).into(),
-            color: self.1.into_storage(),
+        )
-        }
     }
 }
 
-impl Into<Pixel<Rgb565>> for CPixel {
+impl From<Pixel<Rgb565>> for CPixel {
-    fn into(self) -> Pixel<Rgb565> {
+    fn from(value: Pixel<Rgb565>) -> Self {
-        Pixel(Point::new(self.x, self.y), RawU16::new(self.color).into())
+        CPixel {
+            x: value.0.x,
+            y: value.0.y,
+            color: value.1.into_storage(),
+        }
     }
 }
 
@@ -171,12 +175,12 @@ pub mod keyboard {
         pub mods: Modifiers,
     }
 
-    impl Into<KeyEvent> for KeyEventC {
+    impl From<KeyEventC> for KeyEvent {
-        fn into(self) -> KeyEvent {
+        fn from(val: KeyEventC) -> Self {
             KeyEvent {
-                key: self.key.into(),
+                key: val.key.into(),
-                state: self.state,
+                state: val.state,
-                mods: self.mods,
+                mods: val.mods,
             }
         }
     }
@@ -188,12 +192,12 @@ pub mod keyboard {
         pub mods: Modifiers,
     }
 
-    impl Into<KeyEventC> for KeyEvent {
+    impl From<KeyEvent> for KeyEventC {
-        fn into(self) -> KeyEventC {
+        fn from(val: KeyEvent) -> Self {
             KeyEventC {
-                key: self.key.into(),
+                key: val.key.into(),
-                state: self.state,
+                state: val.state,
-                mods: self.mods,
+                mods: val.mods,
             }
         }
     }
@@ -214,7 +218,7 @@ pub mod keyboard {
                 1 => KeyState::Pressed,
                 2 => KeyState::Hold,
                 3 => KeyState::Released,
-                0 | _ => KeyState::Idle,
+                _ => KeyState::Idle,
             }
         }
     }
@@ -267,9 +271,9 @@ pub mod keyboard {
         Unknown(u8),
     }
 
-    impl Into<u8> for KeyCode {
+    impl From<KeyCode> for u8 {
-        fn into(self) -> u8 {
+        fn from(val: KeyCode) -> Self {
-            match self {
+            match val {
                 KeyCode::JoyUp => 0x01,
                 KeyCode::JoyDown => 0x02,
                 KeyCode::JoyLeft => 0x03,
@@ -470,6 +474,17 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
     }
 }
 
+pub type ReconfigureAudioSampleRate = extern "C" fn(sample_rate: u32);
+
+#[allow(unused)]
+pub fn reconfigure_audio_sample_rate(sample_rate: u32) {
+    unsafe {
+        let ptr = SYS_CALL_TABLE[SyscallTable::ReconfigureAudioSampleRate as usize];
+        let f: ReconfigureAudioSampleRate = core::mem::transmute(ptr);
+        f(sample_rate)
+    }
+}
+
 pub type AudioBufferReady = extern "C" fn() -> bool;
 
 #[allow(unused)]