diff --git a/Cargo.lock b/Cargo.lock index 8d3ee58..7d2c01e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -760,11 +760,11 @@ version = "0.2.0" dependencies = [ "atomic", "bbqueue", - "bytemuck", "cortex-m", "cortex-m-rt", "defmt 1.1.1", "defmt-rtt", + "deku", "embedded-hal", "embedded-io", "log-to-defmt", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index cb4d852..c2572eb 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -12,4 +12,4 @@ deku = "0.20.3" futures-lite = "2.6.1" log = { version = "0.4.29", features = ["std"] } pollster = { version = "0.4.0", features = ["macro"] } -shared = { path = "../shared", features = ["serde"] } +shared = { path = "../shared", features = ["serde", "std"] } diff --git a/cli/src/main.rs b/cli/src/main.rs index dd5b313..211a686 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -1,10 +1,13 @@ use std::io; -use async_hid::{AsyncHidRead, HidBackend, HidResult}; -use clap::{Parser, ValueEnum}; +use async_hid::{AsyncHidRead, AsyncHidWrite, Device, HidBackend, HidResult}; +use clap::{Parser, Subcommand, ValueEnum}; use deku::DekuContainerRead; use futures_lite::StreamExt; -use shared::{AudioTelemetrySnapshot, hid::AudioTelemetryReport}; +use shared::{ + AudioDeviceCommand, AudioTelemetrySnapshot, + hid::{AudioDeviceCommandReport, AudioTelemetryReport, USAGE_COMMAND, USAGE_TELEMETRY}, +}; #[derive(Clone, Copy, Debug, ValueEnum)] enum Format { @@ -12,11 +15,22 @@ enum Format { Csv, } +#[derive(Subcommand, Clone, Copy, Debug)] +enum Command { + Monitor, + Reset { + #[arg(short, long, default_value_t = false)] + bootloader: bool, + }, +} + #[derive(Parser, Debug)] #[command(version, about)] struct Args { #[arg(short, long, default_value = "debug")] format: Format, + #[command(subcommand)] + command: Option, } trait StateEmitter { @@ -35,7 +49,7 @@ impl StateEmitter for DebugEmitter { Self { writer } } fn emit(&mut self, r: &AudioTelemetrySnapshot) { - writeln!(self.writer, "{r:?}"); + writeln!(self.writer, "{r:?}").ok(); } } @@ -58,31 +72,62 @@ impl StateEmitter for CsvEmitter { } } +/// The device exposes one vendor HID interface per usage; pick the one we need. +async fn find_device(usage_id: u16) -> HidResult { + Ok(HidBackend::default() + .enumerate() + .await? + .find(|d| d.product_id == 0xcc1d && d.vendor_id == 0x1209 && d.usage_id == usage_id) + .await + .expect("GUAC device not found or not accessible (try as root?)")) +} + #[pollster::main] async fn main() -> HidResult<()> { colog::init(); let args = Args::parse(); - let usbhid = HidBackend::default(); - let dev = usbhid - .enumerate() - .await? - .find(|d| d.product_id == 0xcc1d && d.vendor_id == 0x1209) - .await - .expect("GUAC device not found or not accessible (try as root?)"); - let mut reader = dev.open_readable().await?; - let mut writer: Box> = match args.format { - Format::Debug => Box::new(DebugEmitter::from_writer(io::stdout())), - Format::Csv => Box::new(CsvEmitter::from_writer(io::stdout())), - }; - let mut buf = [0u8; core::mem::size_of::()]; - while let Ok(r) = reader.read_input_report(&mut buf).await { - log::debug!("read {}: {:?}", r, &buf[..r]); - let buf = &buf[..r]; - match AudioTelemetryReport::from_bytes((buf, 0)) { - Ok((_, r)) => writer.emit(&r.into()), - Err(e) => eprintln!("Unable to parse report: {:?}", e), + match &args.command { + Some(Command::Monitor) => { + let dev = find_device(USAGE_TELEMETRY).await?; + let mut reader = dev.open_readable().await?; + let mut writer: Box> = match args.format { + Format::Debug => Box::new(DebugEmitter::from_writer(io::stdout())), + Format::Csv => Box::new(CsvEmitter::from_writer(io::stdout())), + }; + + let mut buf = [0u8; core::mem::size_of::()]; + while let Ok(r) = reader.read_input_report(&mut buf).await { + log::debug!("read {}: {:?}", r, &buf[..r]); + let buf = &buf[..r]; + match AudioTelemetryReport::from_bytes((buf, 0)) { + Ok((_, r)) => writer.emit(&r.into()), + Err(e) => eprintln!("Unable to parse report: {:?}", e), + } + } } + Some(Command::Reset { bootloader }) => { + let dev = find_device(USAGE_COMMAND).await?; + let mut dev_writer = dev.open_writeable().await?; + let cmd = if *bootloader { + print!("Rebooting into bootloader..."); + AudioDeviceCommand::Bootloader + } else { + print!("Rebooting..."); + AudioDeviceCommand::Reset + }; + log::debug!("writing command: {:?}", &cmd); + let report: AudioDeviceCommandReport = cmd.into(); + log::debug!(" report: {:?}", &report); + // Our descriptor has no report IDs, so hidraw expects a leading 0x00 that it strips + let mut buf = [0u8; 1 + core::mem::size_of::()]; + buf[1..].copy_from_slice(&report.cmd); + match dev_writer.write_output_report(&buf).await { + Ok(_) => println!("write succeeded - reboot failed"), + Err(_) => println!("lost device - reboot successful"), + } + } + None => {} } Ok(()) diff --git a/firmware/Cargo.toml b/firmware/Cargo.toml index c7254c6..3967f35 100644 --- a/firmware/Cargo.toml +++ b/firmware/Cargo.toml @@ -9,18 +9,19 @@ ak4490 = [] cs4398 = [] nodac = [] wm8904 = [] -hid = [ "dep:usbd-hid" ] -evk = [ "wm8904" ] +hid = ["dep:usbd-hid", "dep:deku"] +evk = ["wm8904"] [dependencies] -shared = { path="../shared" } +shared = { path = "../shared" } atomic = "0.6.1" bbqueue = "0.7.0" -bytemuck = { version = "1.25.0", features = ["derive"] } +# bytemuck = { version = "1.25.0", features = ["derive"] } cortex-m = { version = "0.7.7", features = ["critical-section-single-core"] } cortex-m-rt = "0.7.5" defmt = "1.0.1" defmt-rtt = "1.1.0" +deku = { version = "0.20.3", optional = true, default-features = false } embedded-hal = "0.2.7" embedded-io = "0.7.1" log-to-defmt = "0.1.0" @@ -32,7 +33,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] } static_cell = "2.1.1" usb-device = { version = "0.3", features = ["control-buffer-256"] } usbd-hid = { version = "0.10.0", optional = true } -usbd-uac2 = { version = "0.1.2", features = ["defmt"]} +usbd-uac2 = { version = "0.1.2", features = ["defmt"] } [profile.release] opt-level = "z" diff --git a/firmware/src/main.rs b/firmware/src/main.rs index 04b91be..21c9b26 100644 --- a/firmware/src/main.rs +++ b/firmware/src/main.rs @@ -10,7 +10,7 @@ fn panic() -> ! { use atomic::Atomic; use core::ptr; use core::sync::atomic::AtomicPtr; -use core::sync::atomic::{AtomicBool, AtomicI32, AtomicUsize, Ordering}; +use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use cortex_m_rt::entry; use defmt; use defmt::debug; @@ -44,7 +44,7 @@ use crate::hw::led1; use crate::hw::led2; use crate::traits::Dac; use shared::AudioState; -use shared::hid::AudioTelemetryReport; +use shared::hid::{AudioDeviceCommandReport, AudioTelemetryReport}; #[cfg(feature = "ak4490")] pub mod dac { @@ -107,6 +107,7 @@ const USB_FRAME_RATE: u32 = 8000; // microframe rate: 8000 for HS, 1000 for FS // const NODATA_TIMEOUT_FRAMES: usize = SAMPLE_RATE as usize / 100; // ~100ms const HID_INTERVAL_MS: u8 = 10; +const HID_CMD_INTERVAL_MS: u8 = 100; struct CodecPins { reset: Pin>, @@ -174,6 +175,19 @@ static PERF: PerfCounters = PerfCounters { // fb: AtomicI32::new(0), }; +fn boot_to_bootloader() -> ! { + cortex_m::interrupt::disable(); + unsafe { + let pmc = &*pac::PMC::ptr(); + // https://community.nxp.com/t5/LPC-Microcontrollers/Configure-LPC55-to-enter-re-invoke-ROM-Bootloader-from/m-p/966990?profile.language=en + // If you write the following register, it will be set to boot from the ROM: + // PMC->AOREG1 |= (0x0A << 16); //Set to boot from ROM + // NVIC_SystemReset(); //Reset‍‍ + pmc.aoreg1.modify(|r, w| w.bits(r.bits() | (0x0a << 16))); + } + cortex_m::peripheral::SCB::sys_reset() +} + fn build_telemetry_report, I>( perf: &PerfCounters, audio: &Audio, @@ -907,7 +921,17 @@ fn main() -> ! { ); let mut uac2 = config.build(&usb_bus).unwrap(); #[cfg(feature = "hid")] - let mut hid = HIDClass::new_ep_in(&usb_bus, AudioTelemetryReport::desc(), HID_INTERVAL_MS); + let (mut hid, mut hid_cmd) = { + let hid = HIDClass::new_ep_in(&usb_bus, AudioTelemetryReport::desc(), HID_INTERVAL_MS); + // Linux's usbhid refuses to bind an interface without an interrupt IN endpoint + // (no hidraw node), so the command interface needs one even though it is unused. + let hid_cmd = HIDClass::new( + &usb_bus, + AudioDeviceCommandReport::desc(), + HID_CMD_INTERVAL_MS, + ); + (hid, hid_cmd) + }; let mut usb_dev = usbd_uac2::builder(&usb_bus, UsbVidPid(0x1209, 0xcc1d)) .strings(&[StringDescriptors::default() @@ -934,7 +958,7 @@ fn main() -> ! { let mut poll_all = move || { // Poll active USB classes #[cfg(feature = "hid")] - usb_dev.poll(&mut [&mut uac2, &mut hid]); + usb_dev.poll(&mut [&mut uac2, &mut hid, &mut hid_cmd]); #[cfg(not(feature = "hid"))] usb_dev.poll(&mut [&mut uac2]); @@ -948,15 +972,47 @@ fn main() -> ! { } #[cfg(feature = "hid")] - if hid_update_timer.wait().is_ok() { - let report = build_telemetry_report(&PERF, uac2.handler()); - if let Err(e) = hid.push_input(&report) { - if e != UsbError::WouldBlock { - defmt::error!("Failed to send HID report: {:?}", e); + { + use deku::DekuContainerRead; + use shared::AudioDeviceCommand; + + fn handle_cmd(cmd: AudioDeviceCommand) { + use shared::AudioDeviceCommand; + + match cmd { + AudioDeviceCommand::Noop => {} + AudioDeviceCommand::Reset => { + cortex_m::interrupt::disable(); + cortex_m::peripheral::SCB::sys_reset(); + } + AudioDeviceCommand::Bootloader => boot_to_bootloader(), } } - // LPC55 CTIMER is not periodic; restart manually - hid_update_timer.start(Microseconds::new(HID_INTERVAL_MS as u32 * 1000)); + + if hid_update_timer.wait().is_ok() { + let report = build_telemetry_report(&PERF, uac2.handler()); + if let Err(e) = hid.push_input(&report) { + if e != UsbError::WouldBlock { + defmt::error!("Failed to send HID report: {:?}", e); + } + } + // LPC55 CTIMER is not periodic; restart manually + hid_update_timer.start(Microseconds::new(HID_INTERVAL_MS as u32 * 1000)); + } + let mut cmd_report_buf = [0u8; core::mem::size_of::()]; + match hid_cmd.pull_raw_output(&mut cmd_report_buf) { + Ok(len) => { + if let Ok((_left, cmd)) = + AudioDeviceCommandReport::from_bytes((&cmd_report_buf[0..len], 0)) + { + if let Ok(cmd) = cmd.try_into() { + handle_cmd(cmd) + } + } + } + Err(UsbError::WouldBlock) => {} + Err(e) => defmt::error!("Invalid report: {:?}", e), + } } }; diff --git a/shared/Cargo.toml b/shared/Cargo.toml index b1a02c7..bfd5ab3 100644 --- a/shared/Cargo.toml +++ b/shared/Cargo.toml @@ -3,7 +3,7 @@ name = "shared" edition = "2024" [features] -std = [] +std = ["deku/alloc"] serde = ["dep:serde"] [dependencies] diff --git a/shared/src/lib.rs b/shared/src/lib.rs index 2bcb36e..294a990 100644 --- a/shared/src/lib.rs +++ b/shared/src/lib.rs @@ -1,6 +1,9 @@ #![no_std] use bytemuck::NoUninit; +use deku::DekuRead; +#[cfg(feature = "std")] +use deku::DekuWrite; use num_enum::TryFromPrimitive; #[cfg(feature = "serde")] @@ -11,7 +14,7 @@ use serde::{Deserialize, Serialize}; #[repr(u8)] pub enum AudioState { /// Knowingly stopped, ie. AltSetting=0. DAC muted, I2S disabled. - /// + /// /// AltSetting = 1 -> ARMED Stopped = 0, /// Waiting for data. DAC muted, I2S running sending 0s (FIFO not serviced). @@ -103,14 +106,34 @@ pub struct AudioTelemetrySnapshot { pub fb_rate_estimate: f32, } +// Writing is host-side only (needs deku's `alloc`, enabled by the `std` feature) +#[derive(Debug, DekuRead, Clone)] +#[cfg_attr(feature = "std", derive(DekuWrite))] +#[deku(id_type = "u8")] +pub enum AudioDeviceCommand { + #[deku(id = 0)] + Noop, + #[deku(id = 1)] + Reset, + #[deku(id = 2)] + Bootloader, +} + pub mod hid { - use deku::DekuRead; + use deku::{DekuContainerRead, DekuError, DekuRead}; + #[cfg(feature = "std")] + use deku::{DekuContainerWrite, DekuWrite}; use usbd_hid::descriptor::generator_prelude::*; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; - use crate::{AudioState, AudioTelemetrySnapshot}; + use crate::{AudioDeviceCommand, AudioState, AudioTelemetrySnapshot}; + + /// HID usage IDs identifying each vendor interface. `gen_hid_descriptor` only accepts + /// literals, so the descriptors below repeat these values; keep them in sync. + pub const USAGE_TELEMETRY: u16 = 0x01; + pub const USAGE_COMMAND: u16 = 0x02; #[derive(DekuRead)] #[deku(endian = "little")] @@ -153,4 +176,31 @@ pub mod hid { } } } + + #[derive(DekuRead)] + #[cfg_attr(feature = "std", derive(DekuWrite))] + #[deku(endian = "little")] + #[gen_hid_descriptor((collection = APPLICATION, usage_page = VENDOR_DEFINED_START, usage = 0x02, ) = { + cmd=output; + })] + #[repr(C, packed)] + pub struct AudioDeviceCommandReport { + pub cmd: [u8; 32], + } + + impl TryFrom for AudioDeviceCommand { + type Error = DekuError; + fn try_from(value: AudioDeviceCommandReport) -> Result { + Ok(AudioDeviceCommand::from_bytes((value.cmd.as_slice(), 0))?.1) + } + } + + #[cfg(feature = "std")] + impl From for AudioDeviceCommandReport { + fn from(value: AudioDeviceCommand) -> Self { + let mut buf = [0u8; core::mem::size_of::()]; + value.to_slice(&mut buf).unwrap(); + Self { cmd: buf } + } + } }