diff --git a/.gitignore b/.gitignore index 62db18b..573ce9b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,6 @@ /target *.uf2 -abi_sys.h +userlib_sys.h assets/gif/bad_apple.gif picolibc user-apps/gboy/Peanut-GB diff --git a/.gitmodules b/.gitmodules index 26531ce..73d0428 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,6 @@ [submodule "picolibc"] path = picolibc url = https://github.com/picolibc/picolibc -[submodule "user-apps/gboy/Peanut-GB"] - path = user-apps/gboy/Peanut-GB +[submodule "user_apps/gboy/Peanut-GB"] + path = user_apps/gboy/Peanut-GB url = https://github.com/deltabeard/Peanut-GB diff --git a/Cargo.lock b/Cargo.lock index 8a5a333..f939e61 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12,27 +12,6 @@ dependencies = [ "regex", ] -[[package]] -name = "abi" -version = "0.1.0" -dependencies = [ - "abi_sys", - "embedded-graphics", - "once_cell", - "rand_core 0.9.3", -] - -[[package]] -name = "abi_sys" -version = "0.1.0" -dependencies = [ - "bitflags 2.10.0", - "cbindgen", - "defmt 0.3.100", - "embedded-graphics", - "strum", -] - [[package]] name = "ahash" version = "0.8.12" @@ -263,9 +242,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" name = "calculator" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "embedded-layout", + "userlib", ] [[package]] @@ -427,9 +406,9 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" [[package]] name = "crypto-common" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" dependencies = [ "generic-array", "typenum", @@ -948,6 +927,14 @@ dependencies = [ "rlsf", ] +[[package]] +name = "embedded-audio" +version = "0.1.0" +source = "git+https://github.com/LegitCamper/embedded-audio#087784644d810b94dd659a03dbed4795dfb0bd24" +dependencies = [ + "heapless", +] + [[package]] name = "embedded-graphics" version = "0.8.1" @@ -1278,27 +1265,27 @@ dependencies = [ name = "gallery" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "tinybmp", + "userlib", ] [[package]] name = "gboy" version = "0.1.0" dependencies = [ - "abi", "bindgen", "cc", "embedded-graphics", "selection_ui", + "userlib", ] [[package]] name = "generic-array" -version = "0.14.9" +version = "0.14.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", @@ -1331,10 +1318,10 @@ dependencies = [ name = "gif" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "selection_ui", "tinygif", + "userlib", ] [[package]] @@ -1515,7 +1502,6 @@ dependencies = [ name = "kernel" version = "0.0.1" dependencies = [ - "abi_sys", "assign-resources", "bitflags 2.10.0", "bt-hci", @@ -1543,8 +1529,10 @@ dependencies = [ "embedded-layout", "embedded-sdmmc", "embedded-text", + "fixed", "goblin", "heapless", + "micromath", "num_enum 0.7.5", "once_cell", "panic-probe", @@ -1556,6 +1544,7 @@ dependencies = [ "strum", "talc", "trouble-host", + "userlib_sys", ] [[package]] @@ -2262,10 +2251,10 @@ checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add" name = "selection_ui" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "embedded-layout", "embedded-text", + "userlib", ] [[package]] @@ -2382,10 +2371,10 @@ dependencies = [ name = "snake" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "embedded-snake", "rand", + "userlib", ] [[package]] @@ -2758,6 +2747,27 @@ dependencies = [ "usbd-hid-descriptors", ] +[[package]] +name = "userlib" +version = "0.1.0" +dependencies = [ + "embedded-graphics", + "once_cell", + "rand_core 0.9.3", + "userlib_sys", +] + +[[package]] +name = "userlib_sys" +version = "0.1.0" +dependencies = [ + "bitflags 2.10.0", + "cbindgen", + "defmt 0.3.100", + "embedded-graphics", + "strum", +] + [[package]] name = "uuid" version = "1.18.1" @@ -2865,6 +2875,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wav_player" +version = "0.1.0" +dependencies = [ + "embedded-audio", + "embedded-graphics", + "rand", + "selection_ui", + "userlib", +] + [[package]] name = "winapi" version = "0.3.9" diff --git a/Cargo.toml b/Cargo.toml index 7a25a5c..60e9dc7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,14 +2,15 @@ resolver = "3" members = [ "kernel", - "abi_sys", - "abi", + "userlib_sys", + "userlib", "selection_ui", - "user-apps/calculator", - "user-apps/snake", - "user-apps/gallery", - "user-apps/gif", - "user-apps/gboy", + "user_apps/calculator", + "user_apps/snake", + "user_apps/gallery", + "user_apps/gif", + "user_apps/wav_player", + "user_apps/gboy", ] [profile.release] diff --git a/README.md b/README.md index 2d4d4e0..9e1f265 100644 --- a/README.md +++ b/README.md @@ -1,26 +1,27 @@ # PicoCalc OS (Rust) -A simple operating system for the **Clockwork PicoCalc**, written in Rust. -This project provides a minimal kernel, ABI, and user-space applications to experiment with OS development on constrained hardware. +A simple kernel and applications for the **Clockwork PicoCalc**, written in Rust. +This project provides a minimal kernel, syscall table, and user-space applications to experiment with kernel development on constrained hardware. ## Status Basic synchronous applications are working great. -Current focus is on **expanding the ABI syscalls** and **fixing the MSC/USB-SCSI driver** to make application development easier and smoother. +Current focus is on exanding applications and porting software, finding bugs in ffi, and making sure the kernel is as stable as possible. ## Project Structure -- **`kernel/`** – The core OS kernel (task scheduling, drivers, memory, etc.) -- **`abi_sys/`** – Shared application binary interface definitions for kernel ↔ userspace (Repr "C") -- **`abi/`** – Rust focused ABI helpers and abstractions for easier development -- **`user-apps/`** – Collection of userspace programs (calculator, snake, etc.) +- **`kernel/`** – The core OS kernel +- **`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.) ## Features - Minimal Rust-based kernel targeting the PicoCalc -- Custom ABI for safe communication between kernel and applications +- Custom ABI for *Mostly* safe communication between kernel and applications - Support for multiple user-space applications -- Hardware drivers tailored for the PicoCalc +- Hardware drivers tailored for the PicoCalc( Audio, Display, Keyboard, ans Storage ) ## Getting Started diff --git a/justfile b/justfile index b4e1be4..d620e7c 100644 --- a/justfile +++ b/justfile @@ -1,15 +1,17 @@ +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 + 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 + elf2uf2-rs -d target/{{target}}/release/kernel binary-args := "RUSTFLAGS=\"-C link-arg=-pie -C relocation-model=pic\"" cbindgen: - cbindgen abi_sys --output abi_sys.h -q + cbindgen userlib_sys --output userlib_sys.h -q newlib: #!/bin/bash @@ -39,10 +41,11 @@ userapps: cbindgen just userapp snake just userapp gallery just userapp gif + just userapp wav_player just userapp gboy copy-userapp app: - cp ./target/thumbv8m.main-none-eabihf/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin + cp ./target/{{target}}/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin copy-userapps: #!/bin/bash @@ -51,6 +54,8 @@ copy-userapps: just copy-userapp snake 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" diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index a7229b6..5c03af9 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -11,7 +11,7 @@ doctest = false bench = false [features] -default = ["rp235x", "defmt"] +default = ["rp235x"] pimoroni2w = ["rp235x", "psram"] # rp2040 = ["embassy-rp/rp2040"] # unsupported, ram too small for fb rp235x = ["embassy-rp/rp235xb"] @@ -82,6 +82,8 @@ embedded-graphics = { version = "0.8.1" } embedded-text = "0.7.2" embedded-layout = "0.4.2" +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 } @@ -97,4 +99,4 @@ embedded-alloc = { version = "0.6.0", features = [ ], optional = true } bumpalo = "3.19.0" -abi_sys = { path = "../abi_sys" } +userlib_sys = { path = "../userlib_sys" } diff --git a/kernel/build.rs b/kernel/build.rs index 8220df0..a3a1b63 100644 --- a/kernel/build.rs +++ b/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"); diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs new file mode 100644 index 0000000..088c272 --- /dev/null +++ b/kernel/src/audio.rs @@ -0,0 +1,204 @@ +use crate::Audio; +use core::sync::atomic::{AtomicBool, AtomicU32, Ordering}; +use embassy_futures::{join::join, yield_now}; +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 == userlib_sys::AUDIO_BUFFER_SAMPLES); + +const SILENCE: u8 = u8::MAX / 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) { + 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); + + // enable sms at the same time to ensure they are synced + audio.pio.apply_sm_batch(|pio| { + pio.set_enable(&mut pwm_pio_right.sm, true); + pio.set_enable(&mut pwm_pio_left.sm, true); + }); + + 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; + } + } + } +} + +async fn write_samples( + left: &mut PioPwmAudio<'static, PIO, 0>, + right: &mut PioPwmAudio<'static, PIO, 1>, + buf: &[u8], +) { + // pack two samples per word + static mut PACKED_BUF_L: [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]; + + unsafe { + for ((pl, pr), sample) in PACKED_BUF_L + .iter_mut() + .zip(PACKED_BUF_R.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_L, false); + + let right_fut = right + .sm + .tx() + .dma_push(right.dma.reborrow(), &PACKED_BUF_R, 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 pwm high, bottom for pwm low + // allows storing two samples per word + let prg = pio_asm!( + ".side_set 1", + + "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:", + "jmp x-- loop_high side 1", // keep pwm high, decrement X until 0 + "loop_low:", + "jmp y-- loop_low side 0", // keep pwm low, decrement Y until 0 + ".wrap" + ); + + 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 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>, + 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.fifo_join = FifoJoin::TxOnly; + let shift_cfg = ShiftConfig { + auto_fill: false, + ..Default::default() + }; + cfg.shift_out = shift_cfg; + cfg.use_program(&prg.0, &[&pin]); + sm.set_config(&cfg); + + sm.set_clock_divider(Self::get_sm_divider(SAMPLE_RATE_HZ).to_fixed()); + + 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 +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) +} diff --git a/kernel/src/display.rs b/kernel/src/display.rs index 86c693f..cca521b 100644 --- a/kernel/src/display.rs +++ b/kernel/src/display.rs @@ -1,27 +1,27 @@ 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_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, Output<'static>, Delay>, Output<'static>, Output<'static>, @@ -58,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(); @@ -86,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) @@ -113,11 +113,11 @@ 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 { - Timer::after_millis(1).await; + yield_now().await; } } } diff --git a/kernel/src/elf.rs b/kernel/src/elf.rs index ec180a4..680396a 100644 --- a/kernel/src/elf.rs +++ b/kernel/src/elf.rs @@ -1,9 +1,7 @@ use crate::{ - abi, storage::{File, SDCARD}, + syscalls, }; -use abi_sys::CallTable; -use abi_sys::EntryFn; use alloc::{vec, vec::Vec}; use bumpalo::Bump; use core::ptr; @@ -18,6 +16,7 @@ use goblin::{ elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym}, }; use strum::IntoEnumIterator; +use userlib_sys::{EntryFn, SyscallTable}; const ELF32_HDR_SIZE: usize = 52; @@ -40,7 +39,7 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> 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::(total_size); @@ -53,25 +52,22 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> 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).unwrap(); } } for i in 0..elf_header.e_shnum { let sh = read_section(&mut file, elf_header, i.into()); - match sh.sh_type { - SHT_REL => { - apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap(); - } - _ => {} + if sh.sh_type == SHT_REL { + apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap(); } } - patch_abi(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); + patch_syscalls(elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); // entry pointer is base_ptr + (entry - min_vaddr) let entry_ptr: EntryFn = unsafe { @@ -151,14 +147,14 @@ fn apply_relocations( Ok(()) } -fn patch_abi( +fn patch_syscalls( elf_header: &Header, base: *mut u8, min_vaddr: u32, file: &mut File, ) -> Result<(), ()> { for i in 1..=elf_header.e_shnum { - let sh = read_section(file, &elf_header, i.into()); + let sh = read_section(file, elf_header, i.into()); // find the symbol table if sh.sh_type == SHT_SYMTAB { @@ -173,7 +169,7 @@ fn patch_abi( &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) @@ -189,28 +185,33 @@ fn patch_abi( } let symbol_name = core::str::from_utf8(&name).unwrap(); - if symbol_name == "CALL_ABI_TABLE" { + if symbol_name == stringify!(SYS_CALL_TABLE) { let table_base = unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) } as *mut usize; - for (idx, call) in CallTable::iter().enumerate() { + for (idx, call) in SyscallTable::iter().enumerate() { let ptr = match call { - CallTable::Alloc => abi::alloc as usize, - CallTable::Dealloc => abi::dealloc as usize, - CallTable::PrintString => abi::print as usize, - CallTable::SleepMs => abi::sleep as usize, - CallTable::GetMs => abi::get_ms as usize, - CallTable::DrawIter => abi::draw_iter as usize, - CallTable::GetKey => abi::get_key as usize, - 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, + SyscallTable::Alloc => syscalls::alloc as usize, + SyscallTable::Dealloc => syscalls::dealloc as usize, + SyscallTable::PrintString => syscalls::print as usize, + SyscallTable::SleepMs => syscalls::sleep as usize, + SyscallTable::GetMs => syscalls::get_ms as usize, + SyscallTable::DrawIter => syscalls::draw_iter as usize, + SyscallTable::GetKey => syscalls::get_key as usize, + SyscallTable::GenRand => syscalls::gen_rand as usize, + SyscallTable::ListDir => syscalls::list_dir as usize, + 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(()); @@ -232,7 +233,7 @@ fn total_loadable_size( file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32) .unwrap(); file.read(ph_buf).unwrap(); - let ph = cast_phdr(&ph_buf); + let ph = cast_phdr(ph_buf); if ph.p_type == PT_LOAD { if ph.p_vaddr < min_vaddr { diff --git a/kernel/src/framebuffer.rs b/kernel/src/framebuffer.rs index 994b4b4..64469d3 100644 --- a/kernel/src/framebuffer.rs +++ b/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,10 +349,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> { } } - if changed { - if let Some(rect) = dirty_rect { - self.mark_tiles_dirty(rect); - } + if changed && 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()) - .take((self.size().width * self.size().height) as usize), + core::iter::repeat_n( + RawU16::from(color).into_inner(), + (self.size().width * self.size().height) as usize, + ), )?; for tile in self.dirty_tiles.iter() { diff --git a/kernel/src/heap.rs b/kernel/src/heap.rs index 2b1de30..f736cdd 100644 --- a/kernel/src/heap.rs +++ b/kernel/src/heap.rs @@ -22,8 +22,8 @@ impl Region { fn contains(&self, address: usize) -> bool { let start = self.start.load(Ordering::Relaxed); - let end = self.start.load(Ordering::Relaxed); - (start..start + end).contains(&address) + let end = start + self.size.load(Ordering::Relaxed); + (start..end).contains(&address) } fn new(start: usize, size: usize) -> Self { diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 8c1c757..39c270e 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -8,14 +8,19 @@ extern crate alloc; -mod abi; +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; @@ -27,20 +32,17 @@ 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::{ - abi::{KEY_CACHE, MS_SINCE_LAUNCH}, + audio::{AUDIO_BUFFER_WRITTEN, audio_handler, clear_audio_buffers}, display::{FRAMEBUFFER, display_handler, init_display}, - peripherals::{ - conf_peripherals, - keyboard::{KeyState, read_keyboard_fifo}, - }, + peripherals::{conf_peripherals, keyboard::read_keyboard_fifo}, scsi::MSC_SHUTDOWN, storage::{SDCARD, SdCard}, + syscalls::{KEY_CACHE, MS_SINCE_LAUNCH}, ui::{SELECTIONS, clear_selection, ui_handler}, }; -use abi_sys::EntryFn; use bumpalo::Bump; use core::sync::atomic::{AtomicBool, Ordering}; use embassy_executor::{Executor, Spawner}; @@ -55,9 +57,9 @@ use embassy_rp::{ 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}, @@ -74,6 +76,7 @@ use embedded_hal_bus::spi::ExclusiveDevice; use embedded_sdmmc::SdCard as SdmmcSdCard; use static_cell::StaticCell; use talc::*; +use userlib_sys::EntryFn; use {defmt_rtt as _, panic_probe as _}; embassy_rp::bind_interrupts!(struct Irqs { @@ -103,7 +106,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); } @@ -119,10 +122,12 @@ async fn watchdog_task(mut watchdog: Watchdog) { static ENABLE_UI: AtomicBool = AtomicBool::new(true); static UI_CHANGE: Signal = Signal::new(); +const OVERCLOCK: u32 = 300_000_000; + #[embassy_executor::main] async fn main(_spawner: Spawner) { let p = if cfg!(feature = "overclock") { - let clocks = ClockConfig::system_freq(300_000_000).unwrap(); + let clocks = ClockConfig::system_freq(OVERCLOCK).unwrap(); let config = Config::new(clocks); embassy_rp::init(config) } else { @@ -149,6 +154,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, @@ -157,15 +175,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, @@ -175,7 +193,7 @@ 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() }); @@ -208,6 +226,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() }; @@ -229,6 +250,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>, @@ -298,7 +328,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; @@ -330,8 +360,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>, ) { @@ -339,7 +370,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; @@ -356,6 +387,8 @@ async fn kernel_task( setup_display(display, spawner).await; setup_sd(sd).await; + spawner.spawn(audio_handler(audio)).unwrap(); + let _usb = embassy_rp_usb::Driver::new(usb, Irqs); // spawner.spawn(usb_handler(usb)).unwrap(); diff --git a/kernel/src/peripherals/keyboard.rs b/kernel/src/peripherals/keyboard.rs index 28b65e7..77d60a8 100644 --- a/kernel/src/peripherals/keyboard.rs +++ b/kernel/src/peripherals/keyboard.rs @@ -1,5 +1,5 @@ use crate::peripherals::PERIPHERAL_BUS; -pub use abi_sys::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers}; +pub use userlib_sys::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers}; const REG_ID_KEY: u8 = 0x04; const REG_ID_FIF: u8 = 0x09; diff --git a/kernel/src/psram.rs b/kernel/src/psram.rs index 91d447a..4a0d3ec 100644 --- a/kernel/src/psram.rs +++ b/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; } diff --git a/kernel/src/scsi/mod.rs b/kernel/src/scsi/mod.rs index 9618563..faf3ec9 100644 --- a/kernel/src/scsi/mod.rs +++ b/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) -> Self { let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class let mut interface = function.interface(); @@ -72,35 +72,34 @@ 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 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 - } - - if self.pending_eject { - if let ScsiCommand::Write { lba: _, len: _ } = command { - MSC_SHUTDOWN.signal(()); - } - } + if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await + && n == 31 + && 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 + } + + if self.pending_eject + && let ScsiCommand::Write { lba: _, len: _ } = command + { + MSC_SHUTDOWN.signal(()); + } } } @@ -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(|_| ())?; } } diff --git a/kernel/src/scsi/scsi_types.rs b/kernel/src/scsi/scsi_types.rs index 76bbb8a..2d64d80 100644 --- a/kernel/src/scsi/scsi_types.rs +++ b/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))] diff --git a/kernel/src/storage.rs b/kernel/src/storage.rs index 0632fa5..c77974b 100644 --- a/kernel/src/storage.rs +++ b/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, - Timestamp, Volume, VolumeIdx, VolumeManager, sdcard::Error, + Block, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource, Timestamp, + 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, Output<'static>, embassy_time::Delay>; type SD = SdmmcSdCard; type VolMgr = VolumeManager; -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 { - Some(self.long_name.cmp(&other.long_name)) + Some(self.cmp(other)) } } @@ -67,10 +66,7 @@ impl SdCard { DummyTimeSource {}, 5000, ); - Self { - det: det, - volume_mgr, - } + Self { det, volume_mgr } } /// Returns true if an SD card is inserted. @@ -90,17 +86,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| { diff --git a/kernel/src/abi.rs b/kernel/src/syscalls.rs similarity index 80% rename from kernel/src/abi.rs rename to kernel/src/syscalls.rs index 5e17d76..357d7e6 100644 --- a/kernel/src/abi.rs +++ b/kernel/src/syscalls.rs @@ -1,7 +1,3 @@ -use abi_sys::{ - AllocAbi, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen, GenRand, GetMsAbi, ListDir, - PrintAbi, ReadFile, RngRequest, SleepMsAbi, WriteFile, keyboard::*, -}; use alloc::{string::ToString, vec::Vec}; use core::{ffi::c_char, ptr, sync::atomic::Ordering}; use embassy_rp::clocks::{RoscRng, clk_sys_freq}; @@ -9,6 +5,11 @@ use embassy_time::Instant; use embedded_graphics::draw_target::DrawTarget; 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, ReconfigureAudioSampleRate, RngRequest, + SendAudioBuffer, SleepMs, WriteFile, keyboard::*, +}; #[cfg(feature = "psram")] use crate::heap::HEAP; @@ -17,12 +18,13 @@ use crate::heap::HEAP; use core::alloc::GlobalAlloc; use crate::{ + audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_SAMPLE_RATE, AUDIO_BUFFER_WRITTEN}, display::FRAMEBUFFER, framebuffer::FB_PAUSED, storage::{Dir, File, SDCARD}, }; -const _: AllocAbi = alloc; +const _: Alloc = alloc; pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { // SAFETY: caller guarantees layout is valid unsafe { @@ -33,12 +35,12 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { #[cfg(not(feature = "psram"))] { - return alloc::alloc::alloc(layout.into()); + alloc::alloc::alloc(layout.into()) } } } -const _: DeallocAbi = dealloc; +const _: Dealloc = dealloc; pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) { // SAFETY: caller guarantees ptr and layout are valid #[cfg(feature = "psram")] @@ -52,7 +54,7 @@ pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) { } } -const _: PrintAbi = print; +const _: Print = print; pub extern "C" fn print(ptr: *const u8, len: usize) { // SAFETY: caller guarantees `ptr` is valid for `len` bytes let slice = unsafe { core::slice::from_raw_parts(ptr, len) }; @@ -66,7 +68,7 @@ pub extern "C" fn print(ptr: *const u8, len: usize) { } } -const _: SleepMsAbi = sleep; +const _: SleepMs = sleep; pub extern "C" fn sleep(ms: u64) { let cycles_per_ms = clk_sys_freq() / 1000; let total_cycles = ms * cycles_per_ms as u64; @@ -78,14 +80,14 @@ pub extern "C" fn sleep(ms: u64) { pub static mut MS_SINCE_LAUNCH: Option = None; -const _: GetMsAbi = get_ms; +const _: GetMs = get_ms; pub extern "C" fn get_ms() -> u64 { Instant::now() .duration_since(unsafe { MS_SINCE_LAUNCH.unwrap() }) .as_millis() } -const _: DrawIterAbi = draw_iter; +const _: DrawIter = draw_iter; pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) { // SAFETY: caller guarantees `ptr` is valid for `len` bytes let cpixels = unsafe { core::slice::from_raw_parts(cpixels, len) }; @@ -99,7 +101,7 @@ pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) { pub static mut KEY_CACHE: Queue = Queue::new(); -const _: GetKeyAbi = get_key; +const _: GetKey = get_key; pub extern "C" fn get_key() -> KeyEventC { if let Some(event) = unsafe { KEY_CACHE.dequeue() } { event.into() @@ -132,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 } } @@ -189,7 +191,7 @@ pub extern "C" fn list_dir( let mut wrote = 0; 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); @@ -207,16 +209,15 @@ fn recurse_file( dirs: &[&str], mut access: impl FnMut(&mut File) -> T, ) -> Result { - defmt::info!("dir: {}, dirs: {}", dir, dirs); if dirs.len() == 1 { let mut b = [0_u8; 50]; let mut buf = LfnBuffer::new(&mut b); let mut short_name = None; dir.iterate_dir_lfn(&mut buf, |entry, name| { - if let Some(name) = name { - if name == dirs[0] || entry.name.to_string().as_str() == dirs[0] { - short_name = Some(entry.name.clone()); - } + if let Some(name) = name + && (name == dirs[0] || entry.name.to_string().as_str() == dirs[0]) + { + short_name = Some(entry.name.clone()); } }) .expect("Failed to iterate dir"); @@ -256,7 +257,7 @@ 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; @@ -266,7 +267,7 @@ pub extern "C" fn read_file( 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 }; @@ -305,7 +306,7 @@ pub extern "C" fn write_file( 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(()) }); @@ -331,3 +332,36 @@ 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) +} + +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) { + 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!( + "user audio stream was wrong size: {} should be {}", + buf.len(), + AUDIO_BUFFER_SAMPLES * 2 + ) + } +} diff --git a/kernel/src/ui.rs b/kernel/src/ui.rs index 2a304a9..675ad86 100644 --- a/kernel/src/ui.rs +++ b/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 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}; @@ -20,37 +19,38 @@ use embedded_layout::{ prelude::*, }; use embedded_text::TextBox; +use userlib_sys::keyboard::{KeyCode, KeyState}; pub static SELECTIONS: Mutex = Mutex::new(SelectionList::new()); pub async fn ui_handler() { loop { - if let Some(event) = keyboard::read_keyboard_fifo().await { - if let KeyState::Pressed = event.state { - match event.key { - KeyCode::Up => { - let mut selections = SELECTIONS.lock().await; - selections.up(); - } - KeyCode::Down => { - let mut selections = SELECTIONS.lock().await; - selections.down(); - } - KeyCode::Enter | KeyCode::Right => { - let selections = SELECTIONS.lock().await; - let selection = - selections.selections[selections.current_selection as usize].clone(); - - let entry = unsafe { - load_binary(&selection.short_name) - .await - .expect("unable to load binary") - }; - BINARY_CH.send(entry).await; - } - _ => (), + if let Some(event) = keyboard::read_keyboard_fifo().await + && let KeyState::Pressed = event.state + { + match event.key { + KeyCode::Up => { + let mut selections = SELECTIONS.lock().await; + selections.up(); } + KeyCode::Down => { + let mut selections = SELECTIONS.lock().await; + selections.down(); + } + KeyCode::Enter | KeyCode::Right => { + let selections = SELECTIONS.lock().await; + let selection = + selections.selections[selections.current_selection as usize].clone(); + + let entry = unsafe { + load_binary(&selection.short_name) + .await + .expect("unable to load binary") + }; + BINARY_CH.send(entry).await; + } + _ => (), } } diff --git a/selection_ui/Cargo.toml b/selection_ui/Cargo.toml index 263d6e3..1aa0ac7 100644 --- a/selection_ui/Cargo.toml +++ b/selection_ui/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../abi" } +userlib = { path = "../userlib" } embedded-graphics = "0.8.1" embedded-layout = "0.4.2" embedded-text = "0.7.3" diff --git a/selection_ui/src/lib.rs b/selection_ui/src/lib.rs index ac4e9ab..f0639c5 100644 --- a/selection_ui/src/lib.rs +++ b/selection_ui/src/lib.rs @@ -2,25 +2,25 @@ extern crate alloc; -use abi::{ - display::Display, - get_key, - keyboard::{KeyCode, KeyState}, -}; use alloc::vec::Vec; use embedded_graphics::{ - Drawable, - mono_font::{MonoTextStyle, ascii::FONT_10X20}, + mono_font::{ascii::FONT_10X20, MonoTextStyle}, pixelcolor::Rgb565, prelude::{Dimensions, DrawTarget, Point, Primitive, RgbColor}, primitives::{PrimitiveStyle, Rectangle}, - text::{Alignment, Text, renderer::TextRenderer}, + text::{renderer::TextRenderer, Alignment, Text}, + Drawable, }; use embedded_layout::{ align::{horizontal, vertical}, layout::linear::{FixedMargin, LinearLayout}, prelude::*, }; +use userlib::{ + display::Display, + get_key, + keyboard::{KeyCode, KeyState}, +}; #[derive(Debug)] pub enum SelectionUiError { @@ -51,15 +51,14 @@ impl<'a> SelectionUi<'a> { let selection; loop { let key = get_key(); - if key.state == KeyState::Pressed { - if let Some(s) = self.update(display, key.key)? { + if key.state == KeyState::Pressed + && 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>> = 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,13 +135,19 @@ impl<'a> SelectionUi<'a> { } } -pub fn draw_text_center<'a, S>( +pub fn draw_text_center( display: &mut Display, - text: &'a str, + text: &str, style: S, ) -> Result::Error> where S: TextRenderer::Color>, { - Text::with_alignment(text, Point::zero(), style, Alignment::Center).draw(display) + Text::with_alignment( + text, + display.bounding_box().center(), + style, + Alignment::Center, + ) + .draw(display) } diff --git a/user-apps/gboy/Peanut-GB b/user-apps/gboy/Peanut-GB deleted file mode 160000 index a528665..0000000 --- a/user-apps/gboy/Peanut-GB +++ /dev/null @@ -1 +0,0 @@ -Subproject commit a52866507f6697cffa14b7e399dae695a0425a14 diff --git a/user-apps/calculator/Cargo.toml b/user_apps/calculator/Cargo.toml similarity index 78% rename from user-apps/calculator/Cargo.toml rename to user_apps/calculator/Cargo.toml index 19115f3..8d210d1 100644 --- a/user-apps/calculator/Cargo.toml +++ b/user_apps/calculator/Cargo.toml @@ -4,6 +4,6 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } embedded-graphics = "0.8.1" embedded-layout = "0.4.2" diff --git a/user-apps/calculator/build.rs b/user_apps/calculator/build.rs similarity index 100% rename from user-apps/calculator/build.rs rename to user_apps/calculator/build.rs diff --git a/user-apps/calculator/src/main.rs b/user_apps/calculator/src/main.rs similarity index 99% rename from user-apps/calculator/src/main.rs rename to user_apps/calculator/src/main.rs index 0b42eb9..a758dc1 100644 --- a/user-apps/calculator/src/main.rs +++ b/user_apps/calculator/src/main.rs @@ -2,12 +2,6 @@ #![no_main] extern crate alloc; -use abi::{ - display::Display, - get_key, - keyboard::{KeyCode, KeyState}, - println, -}; use alloc::{format, string::String, vec, vec::Vec}; use core::panic::PanicInfo; use embedded_graphics::{ @@ -25,6 +19,12 @@ use embedded_layout::{ layout::linear::LinearLayout, prelude::Chain, }; +use userlib::{ + display::Display, + get_key, + keyboard::{KeyCode, KeyState}, + println, +}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { @@ -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" }; diff --git a/user-apps/gallery/Cargo.toml b/user_apps/gallery/Cargo.toml similarity index 77% rename from user-apps/gallery/Cargo.toml rename to user_apps/gallery/Cargo.toml index 610805a..f9f06f7 100644 --- a/user-apps/gallery/Cargo.toml +++ b/user_apps/gallery/Cargo.toml @@ -4,6 +4,6 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } embedded-graphics = "0.8.1" tinybmp = "0.6.0" diff --git a/user-apps/gallery/build.rs b/user_apps/gallery/build.rs similarity index 100% rename from user-apps/gallery/build.rs rename to user_apps/gallery/build.rs diff --git a/user-apps/gallery/src/main.rs b/user_apps/gallery/src/main.rs similarity index 86% rename from user-apps/gallery/src/main.rs rename to user_apps/gallery/src/main.rs index 17c5dfc..0efeec4 100644 --- a/user-apps/gallery/src/main.rs +++ b/user_apps/gallery/src/main.rs @@ -3,13 +3,6 @@ #![allow(static_mut_refs)] extern crate alloc; -use abi::{ - display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, - fs::{Entries, list_dir, read_file}, - get_key, - keyboard::{KeyCode, KeyState}, - println, -}; use alloc::{format, vec}; use core::panic::PanicInfo; use embedded_graphics::{ @@ -17,6 +10,13 @@ use embedded_graphics::{ pixelcolor::Rgb565, prelude::*, text::Text, }; use tinybmp::Bmp; +use userlib::{ + display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, + fs::{Entries, list_dir, read_file}, + get_key, + keyboard::{KeyCode, KeyState}, + println, +}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { @@ -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 { - match event.key { - KeyCode::Esc => return, - _ => (), - } - }; + if event.state != KeyState::Idle && event.key == KeyCode::Esc { + return; + } } } diff --git a/user-apps/gboy/Cargo.toml b/user_apps/gboy/Cargo.toml similarity index 84% rename from user-apps/gboy/Cargo.toml rename to user_apps/gboy/Cargo.toml index 81408d7..8a3b134 100644 --- a/user-apps/gboy/Cargo.toml +++ b/user_apps/gboy/Cargo.toml @@ -8,6 +8,6 @@ bindgen = "0.71.0" cc = "1.2.44" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } selection_ui = { path = "../../selection_ui" } embedded-graphics = "0.8.1" diff --git a/user_apps/gboy/Peanut-GB b/user_apps/gboy/Peanut-GB new file mode 160000 index 0000000..c13c99c --- /dev/null +++ b/user_apps/gboy/Peanut-GB @@ -0,0 +1 @@ +Subproject commit c13c99cd967d72dbd9e600795cd66169ca3945c7 diff --git a/user-apps/gboy/build.rs b/user_apps/gboy/build.rs similarity index 100% rename from user-apps/gboy/build.rs rename to user_apps/gboy/build.rs diff --git a/user-apps/gboy/peanut_gb_stub.c b/user_apps/gboy/peanut_gb_stub.c similarity index 100% rename from user-apps/gboy/peanut_gb_stub.c rename to user_apps/gboy/peanut_gb_stub.c diff --git a/user-apps/gboy/src/main.rs b/user_apps/gboy/src/main.rs similarity index 99% rename from user-apps/gboy/src/main.rs rename to user_apps/gboy/src/main.rs index 2a05df8..4f8b12d 100644 --- a/user-apps/gboy/src/main.rs +++ b/user_apps/gboy/src/main.rs @@ -3,14 +3,6 @@ #![allow(static_mut_refs)] extern crate alloc; -use abi::{ - display::Display, - format, - fs::{Entries, file_len, list_dir, read_file, write_file}, - get_key, - keyboard::{KeyCode, KeyState}, - println, -}; use alloc::{vec, vec::Vec}; use core::{cell::LazyCell, mem::MaybeUninit, panic::PanicInfo}; use embedded_graphics::{ @@ -19,6 +11,14 @@ use embedded_graphics::{ 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; diff --git a/user-apps/gboy/src/peanut.rs b/user_apps/gboy/src/peanut.rs similarity index 96% rename from user-apps/gboy/src/peanut.rs rename to user_apps/gboy/src/peanut.rs index 4300f13..6e48def 100644 --- a/user-apps/gboy/src/peanut.rs +++ b/user_apps/gboy/src/peanut.rs @@ -7,8 +7,8 @@ use crate::{DISPLAY, GAME_ROM, RAM}; #[allow(unused)] include!(concat!(env!("OUT_DIR"), "/bindings.rs")); -use abi::{display::Pixel565, println}; -use embedded_graphics::{Drawable, pixelcolor::Rgb565, prelude::Point}; +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; diff --git a/user-apps/gif/Cargo.toml b/user_apps/gif/Cargo.toml similarity index 85% rename from user-apps/gif/Cargo.toml rename to user_apps/gif/Cargo.toml index cc45976..fb9d4bd 100644 --- a/user-apps/gif/Cargo.toml +++ b/user_apps/gif/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } selection_ui = { path = "../../selection_ui" } embedded-graphics = "0.8.1" tinygif = { git = "https://github.com/LegitCamper/tinygif" } diff --git a/user-apps/gif/build.rs b/user_apps/gif/build.rs similarity index 100% rename from user-apps/gif/build.rs rename to user_apps/gif/build.rs diff --git a/user-apps/gif/src/main.rs b/user_apps/gif/src/main.rs similarity index 88% rename from user-apps/gif/src/main.rs rename to user_apps/gif/src/main.rs index e449096..a912fb5 100644 --- a/user-apps/gif/src/main.rs +++ b/user_apps/gif/src/main.rs @@ -2,13 +2,6 @@ #![no_main] extern crate alloc; -use abi::{ - display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, - fs::{Entries, file_len, list_dir, read_file}, - get_key, get_ms, - keyboard::{KeyCode, KeyState}, - println, sleep, -}; use alloc::{format, vec, vec::Vec}; use core::panic::PanicInfo; use embedded_graphics::{ @@ -20,6 +13,13 @@ use embedded_graphics::{ }; use selection_ui::{SelectionUi, SelectionUiError, draw_text_center}; use tinygif::Gif; +use userlib::{ + display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, + fs::{Entries, file_len, list_dir, read_file}, + get_key, get_ms, + keyboard::{KeyCode, KeyState}, + println, sleep, +}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { @@ -44,7 +44,7 @@ pub fn main() { let mut gifs = files.iter().map(|e| e.full_name()).collect::>(); 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 { - match event.key { - KeyCode::Esc => { - drop(buf); - return; - } - _ => (), - }; + if event.state != KeyState::Idle && event.key == KeyCode::Esc { + drop(buf); + return; }; } sleep(((frame.delay_centis as u64) * 10).saturating_sub(start)); diff --git a/user-apps/memory.x b/user_apps/memory.x similarity index 100% rename from user-apps/memory.x rename to user_apps/memory.x diff --git a/user-apps/snake/Cargo.toml b/user_apps/snake/Cargo.toml similarity index 86% rename from user-apps/snake/Cargo.toml rename to user_apps/snake/Cargo.toml index 7eb0d67..7d1a6ae 100644 --- a/user-apps/snake/Cargo.toml +++ b/user_apps/snake/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } embedded-graphics = "0.8.1" embedded-snake = { git = "https://github.com/LegitCamper/embedded-snake-rs" } rand = { version = "0.9.0", default-features = false } diff --git a/user-apps/snake/build.rs b/user_apps/snake/build.rs similarity index 100% rename from user-apps/snake/build.rs rename to user_apps/snake/build.rs diff --git a/user-apps/snake/src/main.rs b/user_apps/snake/src/main.rs similarity index 99% rename from user-apps/snake/src/main.rs rename to user_apps/snake/src/main.rs index a1e078a..2beda43 100644 --- a/user-apps/snake/src/main.rs +++ b/user_apps/snake/src/main.rs @@ -2,16 +2,16 @@ #![no_main] extern crate alloc; -use abi::{ +use core::panic::PanicInfo; +use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor}; +use embedded_snake::{Direction, SnakeGame}; +use userlib::{ Rng, display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, get_key, keyboard::{KeyCode, KeyState}, println, sleep, }; -use core::panic::PanicInfo; -use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor}; -use embedded_snake::{Direction, SnakeGame}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { diff --git a/user_apps/wav_player/Cargo.toml b/user_apps/wav_player/Cargo.toml new file mode 100644 index 0000000..ca309d7 --- /dev/null +++ b/user_apps/wav_player/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "wav_player" +version = "0.1.0" +edition = "2024" + +[dependencies] +userlib = { path = "../../userlib" } +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" } diff --git a/user_apps/wav_player/build.rs b/user_apps/wav_player/build.rs new file mode 100644 index 0000000..332a55b --- /dev/null +++ b/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"); +} diff --git a/user_apps/wav_player/src/main.rs b/user_apps/wav_player/src/main.rs new file mode 100644 index 0000000..09e9d9e --- /dev/null +++ b/user_apps/wav_player/src/main.rs @@ -0,0 +1,143 @@ +#![no_std] +#![no_main] + +extern crate alloc; +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}; +use userlib::{ + 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, +}; + +#[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::>(); + wavs.sort(); + + 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 { + SelectionUiError::SelectionListEmpty => { + draw_text_center( + &mut display, + "No Wavs were found in /music", + MonoTextStyle::new(&FONT_6X10, Rgb565::RED), + ) + .expect("Display Error"); + None + } + SelectionUiError::DisplayError(_) => panic!("Display Error"), + }, + }; + + assert!(selection.is_some()); + + draw_text_center( + &mut display, + &format!("Now playing {}", wavs[selection.unwrap()]), + MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE), + ) + .expect("Display Error"); + + let file_name = format!("/music/{}", wavs[selection.unwrap()]); + 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); + + 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 && 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 { + 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) + } +} diff --git a/abi/Cargo.toml b/userlib/Cargo.toml similarity index 73% rename from abi/Cargo.toml rename to userlib/Cargo.toml index 591ddaa..7555aa3 100644 --- a/abi/Cargo.toml +++ b/userlib/Cargo.toml @@ -1,10 +1,10 @@ [package] -name = "abi" +name = "userlib" version = "0.1.0" edition = "2024" [dependencies] -abi_sys = { path = "../abi_sys" } +userlib_sys = { path = "../userlib_sys" } embedded-graphics = "0.8.1" once_cell = { version = "1", default-features = false } rand_core = "0.9.3" diff --git a/abi/src/lib.rs b/userlib/src/lib.rs similarity index 86% rename from abi/src/lib.rs rename to userlib/src/lib.rs index 97805a6..6db95e9 100644 --- a/abi/src/lib.rs +++ b/userlib/src/lib.rs @@ -3,11 +3,11 @@ extern crate alloc; -use abi_sys::{RngRequest, alloc, dealloc, keyboard::KeyEvent}; -pub use abi_sys::{keyboard, print}; pub use alloc::format; use core::alloc::{GlobalAlloc, Layout}; use rand_core::RngCore; +use userlib_sys::{RngRequest, keyboard::KeyEvent}; +pub use userlib_sys::{keyboard, print}; #[global_allocator] static ALLOC: Alloc = Alloc; @@ -16,11 +16,11 @@ struct Alloc; unsafe impl GlobalAlloc for Alloc { unsafe fn alloc(&self, layout: Layout) -> *mut u8 { - alloc(layout.into()) + userlib_sys::alloc(layout.into()) } unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { - dealloc(ptr, layout.into()); + userlib_sys::dealloc(ptr, layout.into()); } } @@ -33,21 +33,20 @@ macro_rules! println { } pub fn sleep(ms: u64) { - abi_sys::sleep(ms); + userlib_sys::sleep(ms); } pub fn get_ms() -> u64 { - abi_sys::get_ms() + userlib_sys::get_ms() } pub fn get_key() -> KeyEvent { - abi_sys::keyboard::get_key().into() + userlib_sys::keyboard::get_key().into() } pub mod display { use core::sync::atomic::{AtomicBool, Ordering}; - use abi_sys::CPixel; use embedded_graphics::{ Pixel, geometry::{Dimensions, Point}, @@ -55,6 +54,7 @@ pub mod display { prelude::{DrawTarget, Size}, primitives::Rectangle, }; + use userlib_sys::CPixel; pub const SCREEN_WIDTH: usize = 320; pub const SCREEN_HEIGHT: usize = 320; @@ -110,13 +110,13 @@ pub mod display { count += 1; if count == BUF_SIZE - 1 { - abi_sys::draw_iter(unsafe { BUF.as_ptr() }, count); + userlib_sys::draw_iter(unsafe { BUF.as_ptr() }, count); count = 0; } } if count > 0 { - abi_sys::draw_iter(unsafe { BUF.as_ptr() }, count); + userlib_sys::draw_iter(unsafe { BUF.as_ptr() }, count); } Ok(()) @@ -125,7 +125,7 @@ pub mod display { } fn gen_rand(req: &mut RngRequest) { - abi_sys::gen_rand(req); + userlib_sys::gen_rand(req); } pub struct Rng; @@ -162,7 +162,7 @@ pub mod fs { use core::fmt::Display; pub fn read_file(file: &str, start_from: usize, buf: &mut [u8]) -> usize { - abi_sys::read_file( + userlib_sys::read_file( file.as_ptr(), file.len(), start_from, @@ -172,7 +172,7 @@ pub mod fs { } pub fn write_file(file: &str, start_from: usize, buf: &[u8]) { - abi_sys::write_file( + userlib_sys::write_file( file.as_ptr(), file.len(), start_from, @@ -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]) @@ -254,7 +260,7 @@ pub mod fs { } pub fn list_dir(path: &str, entries: &mut Entries) -> usize { - abi_sys::list_dir( + userlib_sys::list_dir( path.as_ptr(), path.len(), entries.as_ptrs().as_mut_ptr(), @@ -264,6 +270,14 @@ pub mod fs { } pub fn file_len(str: &str) -> usize { - abi_sys::file_len(str.as_ptr(), str.len()) + userlib_sys::file_len(str.as_ptr(), str.len()) + } +} + +pub mod audio { + pub use userlib_sys::{AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES, audio_buffer_ready}; + + pub fn send_audio_buffer(buf: &[u8]) { + userlib_sys::send_audio_buffer(buf.as_ptr(), buf.len()) } } diff --git a/abi_sys/Cargo.toml b/userlib_sys/Cargo.toml similarity index 94% rename from abi_sys/Cargo.toml rename to userlib_sys/Cargo.toml index 5a83d0b..c16eb9a 100644 --- a/abi_sys/Cargo.toml +++ b/userlib_sys/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "abi_sys" +name = "userlib_sys" version = "0.1.0" edition = "2024" diff --git a/abi_sys/src/lib.rs b/userlib_sys/src/lib.rs similarity index 70% rename from abi_sys/src/lib.rs rename to userlib_sys/src/lib.rs index af05c58..97ab22d 100644 --- a/abi_sys/src/lib.rs +++ b/userlib_sys/src/lib.rs @@ -12,12 +12,12 @@ use strum::{EnumCount, EnumIter}; pub type EntryFn = fn(); -pub const ABI_CALL_TABLE_COUNT: usize = 12; -const _: () = assert!(ABI_CALL_TABLE_COUNT == CallTable::COUNT); +pub const SYS_CALL_TABLE_COUNT: usize = 15; +const _: () = assert!(SYS_CALL_TABLE_COUNT == SyscallTable::COUNT); #[derive(Clone, Copy, EnumIter, EnumCount)] #[repr(u8)] -pub enum CallTable { +pub enum SyscallTable { Alloc = 0, Dealloc = 1, PrintString = 2, @@ -30,11 +30,14 @@ pub enum CallTable { ReadFile = 9, WriteFile = 10, FileLen = 11, + ReconfigureAudioSampleRate = 12, + AudioBufferReady = 13, + SendAudioBuffer = 14, } #[unsafe(no_mangle)] #[unsafe(link_section = ".syscall_table")] -pub static mut CALL_ABI_TABLE: [usize; ABI_CALL_TABLE_COUNT] = [0; ABI_CALL_TABLE_COUNT]; +pub static mut SYS_CALL_TABLE: [usize; SYS_CALL_TABLE_COUNT] = [0; SYS_CALL_TABLE_COUNT]; #[cfg(feature = "alloc")] #[repr(C)] @@ -44,9 +47,9 @@ pub struct CLayout { } #[cfg(feature = "alloc")] -impl Into for CLayout { - fn into(self) -> Layout { - unsafe { Layout::from_size_align_unchecked(self.size, self.alignment) } +impl From for Layout { + fn from(val: CLayout) -> Self { + unsafe { Layout::from_size_align_unchecked(val.size, val.alignment) } } } @@ -60,51 +63,51 @@ impl From for CLayout { } } -pub type AllocAbi = extern "C" fn(layout: CLayout) -> *mut u8; +pub type Alloc = extern "C" fn(layout: CLayout) -> *mut u8; #[unsafe(no_mangle)] pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { - let f: AllocAbi = unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::Alloc as usize]) }; + let f: Alloc = unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::Alloc as usize]) }; f(layout) } -pub type DeallocAbi = extern "C" fn(ptr: *mut u8, layout: CLayout); +pub type Dealloc = extern "C" fn(ptr: *mut u8, layout: CLayout); #[unsafe(no_mangle)] pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) { - let f: DeallocAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::Dealloc as usize]) }; + let f: Dealloc = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::Dealloc as usize]) }; f(ptr, layout) } -pub type PrintAbi = extern "C" fn(ptr: *const u8, len: usize); +pub type Print = extern "C" fn(ptr: *const u8, len: usize); #[unsafe(no_mangle)] pub extern "C" fn print(ptr: *const u8, len: usize) { - let f: PrintAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::PrintString as usize]) }; + let f: Print = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::PrintString as usize]) }; f(ptr, len); } -pub type SleepMsAbi = extern "C" fn(ms: u64); +pub type SleepMs = extern "C" fn(ms: u64); #[unsafe(no_mangle)] pub extern "C" fn sleep(ms: u64) { - let f: SleepMsAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::SleepMs as usize]) }; + let f: SleepMs = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::SleepMs as usize]) }; f(ms); } -pub type GetMsAbi = extern "C" fn() -> u64; +pub type GetMs = extern "C" fn() -> u64; #[unsafe(no_mangle)] pub extern "C" fn get_ms() -> u64 { - let f: GetMsAbi = unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::GetMs as usize]) }; + let f: GetMs = unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::GetMs as usize]) }; f() } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Default, Copy, Clone)] pub struct CPixel { pub x: i32, pub y: i32, @@ -121,33 +124,36 @@ impl CPixel { } } -impl Into for Pixel { - fn into(self) -> CPixel { +impl From for Pixel { + fn from(value: CPixel) -> Self { + Pixel( + Point::new(value.x, value.y), + RawU16::new(value.color).into(), + ) + } +} + +impl From> for CPixel { + fn from(value: Pixel) -> Self { CPixel { - x: self.0.x, - y: self.0.y, - color: self.1.into_storage(), + x: value.0.x, + y: value.0.y, + color: value.1.into_storage(), } } } -impl Into> for CPixel { - fn into(self) -> Pixel { - Pixel(Point::new(self.x, self.y), RawU16::new(self.color).into()) - } -} - -pub type DrawIterAbi = extern "C" fn(ptr: *const CPixel, len: usize); +pub type DrawIter = extern "C" fn(ptr: *const CPixel, len: usize); #[unsafe(no_mangle)] pub extern "C" fn draw_iter(ptr: *const CPixel, len: usize) { - let f: DrawIterAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::DrawIter as usize]) }; + let f: DrawIter = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::DrawIter as usize]) }; f(ptr, len); } pub mod keyboard { - use crate::{CALL_ABI_TABLE, CallTable}; + use crate::{SYS_CALL_TABLE, SyscallTable}; bitflags::bitflags! { #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)] @@ -169,12 +175,12 @@ pub mod keyboard { pub mods: Modifiers, } - impl Into for KeyEventC { - fn into(self) -> KeyEvent { + impl From for KeyEvent { + fn from(val: KeyEventC) -> Self { KeyEvent { - key: self.key.into(), - state: self.state, - mods: self.mods, + key: val.key.into(), + state: val.state, + mods: val.mods, } } } @@ -186,12 +192,12 @@ pub mod keyboard { pub mods: Modifiers, } - impl Into for KeyEvent { - fn into(self) -> KeyEventC { + impl From for KeyEventC { + fn from(val: KeyEvent) -> Self { KeyEventC { - key: self.key.into(), - state: self.state, - mods: self.mods, + key: val.key.into(), + state: val.state, + mods: val.mods, } } } @@ -212,7 +218,7 @@ pub mod keyboard { 1 => KeyState::Pressed, 2 => KeyState::Hold, 3 => KeyState::Released, - 0 | _ => KeyState::Idle, + _ => KeyState::Idle, } } } @@ -265,9 +271,9 @@ pub mod keyboard { Unknown(u8), } - impl Into for KeyCode { - fn into(self) -> u8 { - match self { + impl From for u8 { + fn from(val: KeyCode) -> Self { + match val { KeyCode::JoyUp => 0x01, KeyCode::JoyDown => 0x02, KeyCode::JoyLeft => 0x03, @@ -365,12 +371,12 @@ pub mod keyboard { } } - pub type GetKeyAbi = extern "C" fn() -> KeyEventC; + pub type GetKey = extern "C" fn() -> KeyEventC; #[unsafe(no_mangle)] pub extern "C" fn get_key() -> KeyEventC { - let f: GetKeyAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::GetKey as usize]) }; + let f: GetKey = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::GetKey as usize]) }; f() } } @@ -387,7 +393,7 @@ pub type GenRand = extern "C" fn(req: &mut RngRequest); #[unsafe(no_mangle)] pub extern "C" fn gen_rand(req: &mut RngRequest) { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::GenRand as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::GenRand as usize]; let f: GenRand = core::mem::transmute(ptr); f(req) } @@ -410,7 +416,7 @@ pub extern "C" fn list_dir( max_entry_str_len: usize, ) -> usize { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::ListDir as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::ListDir as usize]; let f: ListDir = core::mem::transmute(ptr); f(str, len, entries, entry_count, max_entry_str_len) } @@ -433,7 +439,7 @@ pub extern "C" fn read_file( buf_len: usize, ) -> usize { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::ReadFile as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::ReadFile as usize]; let f: ReadFile = core::mem::transmute(ptr); f(str, len, read_from, buf, buf_len) } @@ -451,7 +457,7 @@ pub extern "C" fn write_file( buf_len: usize, ) { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::WriteFile as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::WriteFile as usize]; let f: WriteFile = core::mem::transmute(ptr); f(str, len, write_from, buf, buf_len) } @@ -462,8 +468,44 @@ pub type FileLen = extern "C" fn(str: *const u8, len: usize) -> usize; #[unsafe(no_mangle)] pub extern "C" fn file_len(str: *const u8, len: usize) -> usize { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::FileLen as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::FileLen as usize]; let f: FileLen = core::mem::transmute(ptr); f(str, len) } } + +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)] +pub fn audio_buffer_ready() -> bool { + unsafe { + let ptr = SYS_CALL_TABLE[SyscallTable::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 = SYS_CALL_TABLE[SyscallTable::SendAudioBuffer as usize]; + let f: SendAudioBuffer = core::mem::transmute(ptr); + f(buf, len) + } +}