add command channel and reset/bootloader command

This commit is contained in:
ktims committed 2026-11-04 16:29:26 -07:00
1 parent 93a20cf8e1
commit 245c45c682
7 files changed
+196 -44

No files matched your search

Generated
+1 -1
View File
@@ -760,11 +760,11 @@ version = "0.2.0"
dependencies = [ dependencies = [
"atomic", "atomic",
"bbqueue", "bbqueue",
"bytemuck",
"cortex-m", "cortex-m",
"cortex-m-rt", "cortex-m-rt",
"defmt 1.1.1", "defmt 1.1.1",
"defmt-rtt", "defmt-rtt",
"deku",
"embedded-hal", "embedded-hal",
"embedded-io", "embedded-io",
"log-to-defmt", "log-to-defmt",
+1 -1
View File
@@ -12,4 +12,4 @@ deku = "0.20.3"
futures-lite = "2.6.1" futures-lite = "2.6.1"
log = { version = "0.4.29", features = ["std"] } log = { version = "0.4.29", features = ["std"] }
pollster = { version = "0.4.0", features = ["macro"] } pollster = { version = "0.4.0", features = ["macro"] }
shared = { path = "../shared", features = ["serde"] } shared = { path = "../shared", features = ["serde", "std"] }
+68 -23
View File
@@ -1,10 +1,13 @@
use std::io; use std::io;
use async_hid::{AsyncHidRead, HidBackend, HidResult}; use async_hid::{AsyncHidRead, AsyncHidWrite, Device, HidBackend, HidResult};
use clap::{Parser, ValueEnum}; use clap::{Parser, Subcommand, ValueEnum};
use deku::DekuContainerRead; use deku::DekuContainerRead;
use futures_lite::StreamExt; 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)] #[derive(Clone, Copy, Debug, ValueEnum)]
enum Format { enum Format {
@@ -12,11 +15,22 @@ enum Format {
Csv, Csv,
} }
#[derive(Subcommand, Clone, Copy, Debug)]
enum Command {
Monitor,
Reset {
#[arg(short, long, default_value_t = false)]
bootloader: bool,
},
}
#[derive(Parser, Debug)] #[derive(Parser, Debug)]
#[command(version, about)] #[command(version, about)]
struct Args { struct Args {
#[arg(short, long, default_value = "debug")] #[arg(short, long, default_value = "debug")]
format: Format, format: Format,
#[command(subcommand)]
command: Option<Command>,
} }
trait StateEmitter<W: io::Write> { trait StateEmitter<W: io::Write> {
@@ -35,7 +49,7 @@ impl<W: io::Write> StateEmitter<W> for DebugEmitter<W> {
Self { writer } Self { writer }
} }
fn emit(&mut self, r: &AudioTelemetrySnapshot) { fn emit(&mut self, r: &AudioTelemetrySnapshot) {
writeln!(self.writer, "{r:?}"); writeln!(self.writer, "{r:?}").ok();
} }
} }
@@ -58,31 +72,62 @@ impl<W: io::Write> StateEmitter<W> for CsvEmitter<W> {
} }
} }
/// The device exposes one vendor HID interface per usage; pick the one we need.
async fn find_device(usage_id: u16) -> HidResult<Device> {
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] #[pollster::main]
async fn main() -> HidResult<()> { async fn main() -> HidResult<()> {
colog::init(); colog::init();
let args = Args::parse(); 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<dyn StateEmitter<_>> = 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::<AudioTelemetryReport>()]; match &args.command {
while let Ok(r) = reader.read_input_report(&mut buf).await { Some(Command::Monitor) => {
log::debug!("read {}: {:?}", r, &buf[..r]); let dev = find_device(USAGE_TELEMETRY).await?;
let buf = &buf[..r]; let mut reader = dev.open_readable().await?;
match AudioTelemetryReport::from_bytes((buf, 0)) { let mut writer: Box<dyn StateEmitter<_>> = match args.format {
Ok((_, r)) => writer.emit(&r.into()), Format::Debug => Box::new(DebugEmitter::from_writer(io::stdout())),
Err(e) => eprintln!("Unable to parse report: {:?}", e), Format::Csv => Box::new(CsvEmitter::from_writer(io::stdout())),
};
let mut buf = [0u8; core::mem::size_of::<AudioTelemetryReport>()];
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::<AudioDeviceCommandReport>()];
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(()) Ok(())
+6 -5
View File
@@ -9,18 +9,19 @@ ak4490 = []
cs4398 = [] cs4398 = []
nodac = [] nodac = []
wm8904 = [] wm8904 = []
hid = [ "dep:usbd-hid" ] hid = ["dep:usbd-hid", "dep:deku"]
evk = [ "wm8904" ] evk = ["wm8904"]
[dependencies] [dependencies]
shared = { path="../shared" } shared = { path = "../shared" }
atomic = "0.6.1" atomic = "0.6.1"
bbqueue = "0.7.0" 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 = { version = "0.7.7", features = ["critical-section-single-core"] }
cortex-m-rt = "0.7.5" cortex-m-rt = "0.7.5"
defmt = "1.0.1" defmt = "1.0.1"
defmt-rtt = "1.1.0" defmt-rtt = "1.1.0"
deku = { version = "0.20.3", optional = true, default-features = false }
embedded-hal = "0.2.7" embedded-hal = "0.2.7"
embedded-io = "0.7.1" embedded-io = "0.7.1"
log-to-defmt = "0.1.0" log-to-defmt = "0.1.0"
@@ -32,7 +33,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
static_cell = "2.1.1" static_cell = "2.1.1"
usb-device = { version = "0.3", features = ["control-buffer-256"] } usb-device = { version = "0.3", features = ["control-buffer-256"] }
usbd-hid = { version = "0.10.0", optional = true } 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] [profile.release]
opt-level = "z" opt-level = "z"
+67 -11
View File
@@ -10,7 +10,7 @@ fn panic() -> ! {
use atomic::Atomic; use atomic::Atomic;
use core::ptr; use core::ptr;
use core::sync::atomic::AtomicPtr; 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 cortex_m_rt::entry;
use defmt; use defmt;
use defmt::debug; use defmt::debug;
@@ -44,7 +44,7 @@ use crate::hw::led1;
use crate::hw::led2; use crate::hw::led2;
use crate::traits::Dac; use crate::traits::Dac;
use shared::AudioState; use shared::AudioState;
use shared::hid::AudioTelemetryReport; use shared::hid::{AudioDeviceCommandReport, AudioTelemetryReport};
#[cfg(feature = "ak4490")] #[cfg(feature = "ak4490")]
pub mod dac { 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 NODATA_TIMEOUT_FRAMES: usize = SAMPLE_RATE as usize / 100; // ~100ms
const HID_INTERVAL_MS: u8 = 10; const HID_INTERVAL_MS: u8 = 10;
const HID_CMD_INTERVAL_MS: u8 = 100;
struct CodecPins { struct CodecPins {
reset: Pin<pins::Pio0_3, Gpio<Output>>, reset: Pin<pins::Pio0_3, Gpio<Output>>,
@@ -174,6 +175,19 @@ static PERF: PerfCounters = PerfCounters {
// fb: AtomicI32::new(0), // 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<D: Dac<I>, I>( fn build_telemetry_report<D: Dac<I>, I>(
perf: &PerfCounters, perf: &PerfCounters,
audio: &Audio<D, I>, audio: &Audio<D, I>,
@@ -907,7 +921,17 @@ fn main() -> ! {
); );
let mut uac2 = config.build(&usb_bus).unwrap(); let mut uac2 = config.build(&usb_bus).unwrap();
#[cfg(feature = "hid")] #[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)) let mut usb_dev = usbd_uac2::builder(&usb_bus, UsbVidPid(0x1209, 0xcc1d))
.strings(&[StringDescriptors::default() .strings(&[StringDescriptors::default()
@@ -934,7 +958,7 @@ fn main() -> ! {
let mut poll_all = move || { let mut poll_all = move || {
// Poll active USB classes // Poll active USB classes
#[cfg(feature = "hid")] #[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"))] #[cfg(not(feature = "hid"))]
usb_dev.poll(&mut [&mut uac2]); usb_dev.poll(&mut [&mut uac2]);
@@ -948,15 +972,47 @@ fn main() -> ! {
} }
#[cfg(feature = "hid")] #[cfg(feature = "hid")]
if hid_update_timer.wait().is_ok() { {
let report = build_telemetry_report(&PERF, uac2.handler()); use deku::DekuContainerRead;
if let Err(e) = hid.push_input(&report) { use shared::AudioDeviceCommand;
if e != UsbError::WouldBlock {
defmt::error!("Failed to send HID report: {:?}", e); 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::<AudioDeviceCommandReport>()];
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),
}
} }
}; };
+1 -1
View File
@@ -3,7 +3,7 @@ name = "shared"
edition = "2024" edition = "2024"
[features] [features]
std = [] std = ["deku/alloc"]
serde = ["dep:serde"] serde = ["dep:serde"]
[dependencies] [dependencies]
+52 -2
View File
@@ -1,6 +1,9 @@
#![no_std] #![no_std]
use bytemuck::NoUninit; use bytemuck::NoUninit;
use deku::DekuRead;
#[cfg(feature = "std")]
use deku::DekuWrite;
use num_enum::TryFromPrimitive; use num_enum::TryFromPrimitive;
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
@@ -103,14 +106,34 @@ pub struct AudioTelemetrySnapshot {
pub fb_rate_estimate: f32, 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 { pub mod hid {
use deku::DekuRead; use deku::{DekuContainerRead, DekuError, DekuRead};
#[cfg(feature = "std")]
use deku::{DekuContainerWrite, DekuWrite};
use usbd_hid::descriptor::generator_prelude::*; use usbd_hid::descriptor::generator_prelude::*;
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
use serde::{Deserialize, Serialize}; 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)] #[derive(DekuRead)]
#[deku(endian = "little")] #[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<AudioDeviceCommandReport> for AudioDeviceCommand {
type Error = DekuError;
fn try_from(value: AudioDeviceCommandReport) -> Result<Self, Self::Error> {
Ok(AudioDeviceCommand::from_bytes((value.cmd.as_slice(), 0))?.1)
}
}
#[cfg(feature = "std")]
impl From<AudioDeviceCommand> for AudioDeviceCommandReport {
fn from(value: AudioDeviceCommand) -> Self {
let mut buf = [0u8; core::mem::size_of::<Self>()];
value.to_slice(&mut buf).unwrap();
Self { cmd: buf }
}
}
} }