7 Commits
Author SHA1 Message Date
ktims fabacf0a04 update workflow with correct target definition, add cli
Build and Release Firmware / firmware (ak4490) (push) Successful in 13s
Build and Release Firmware / firmware (cs4398) (push) Successful in 14s
Build and Release Firmware / firmware (evk) (push) Successful in 13s
Build and Release Firmware / cli (aarch64-unknown-linux-musl) (push) Successful in 1m11s
Build and Release Firmware / cli (x86_64-pc-windows-gnu) (push) Successful in 1m24s
Build and Release Firmware / cli (x86_64-unknown-linux-musl) (push) Successful in 1m14s
Build and Release Firmware / release (push) Successful in 6s
2026-11-05 13:37:31 -07:00
ktims e255636f3a some refactoring and clippies
Build and Release Firmware / build-and-release (push) Failing after 48s
2026-11-05 12:26:48 -07:00
ktims bb7f701f20 fix: immediately re-arm the DMA pipeline when stopping due to nodata
Host hasn't asked us to stop streaming with altSetting, but has stopped
sending data. It may start again at any time without a new altSetting
command to re-arm the DMA. So we should re-arm immediately.

Fixes a bug where in some cases audio is streaming from host, but not
playing out.
2026-11-04 16:30:58 -07:00
ktims 245c45c682 add command channel and reset/bootloader command 2026-11-04 16:29:26 -07:00
ktims 93a20cf8e1 refactor feedback, update telemetry report 2026-08-28 10:44:56 -07:00
ktims 9d66ee6ab8 come back out of stopped if we receive audio data 2026-08-27 11:28:48 -07:00
ktims ef39602b63 add gitea workflow 2026-08-26 15:23:35 -07:00
12 changed files with 636 additions and 337 deletions

No files matched your search

+123 -34
View File
@@ -7,60 +7,149 @@ on:
env: env:
TARGET: thumbv8m.main-none-eabihf TARGET: thumbv8m.main-none-eabihf
# The catthehacker image installs rust here and only symlinks ~/.rustup and ~/.cargo to it.
# actions/cache archives the symlink, not its contents, so point at the real paths.
RUSTUP_HOME: /usr/share/rust/.rustup
CARGO_HOME: /usr/share/rust/.cargo
jobs: jobs:
build-and-release: firmware:
runs-on: ubuntu-latest runs-on: ubuntu-latest
container: container:
image: catthehacker/ubuntu:act-latest image: catthehacker/ubuntu:rust-latest
defaults: strategy:
run: fail-fast: true
shell: bash matrix:
variant: [cs4398, ak4490, evk]
env:
FEATURES: ${{ matrix.variant }},hid
steps: steps:
- name: Checkout repository - name: Checkout repository
uses: actions/checkout@v4 uses: actions/checkout@v4
- name: Cache rustup
uses: actions/cache@v4
with:
path: ${{ env.RUSTUP_HOME }}
key: rustup-firmware-${{ env.TARGET }}-${{ runner.os }}
- name: Install Rust Toolchain - name: Install Rust Toolchain
uses: dtolnay/rust-toolchain@stable
- name: Install cargo-binutils
run: cargo install cargo-binutils
- name: Build Firmware Binaries
run: | run: |
cd firmware rustup target install ${{ env.TARGET }}
rustup component add llvm-tools
# Array of "variant_name:features" - name: Cache cargo
VARIANTS=( uses: Swatinem/rust-cache@v2
"cs4398:cs4398,hid" with:
"ak4490:ak4490,hid" shared-key: firmware-${{ matrix.variant }}
"evk:evk,hid"
)
mkdir -p ../dist - name: Install cargo-binutils
run: cargo binstall -y --locked cargo-binutils
for entry in "${VARIANTS[@]}"; do - name: Build firmware (${{ matrix.variant }})
IFS=":" read -r name features <<< "$entry" working-directory: firmware
echo "Building variant: $name with features: $features" run: cargo build --release --target ${{ env.TARGET }} --no-default-features --features "${{ env.FEATURES }}"
# 1. Compile release binary - name: Create hex file
cargo build --release --target ${{ env.TARGET }} --no-default-features --features "$features" working-directory: firmware
run: cargo objcopy --release --target ${{ env.TARGET }} --no-default-features --features "${{ env.FEATURES }}" -- -O ihex ../target/${{ env.TARGET }}/release/guac-${{ matrix.variant }}.hex
# 2. Paths setup - name: Package
ELF_PATH="../target/${{ env.TARGET }}/release/guac" run: |
HEX_PATH="../target/${{ env.TARGET }}/release/guac-${name}.hex" out=target/${{ env.TARGET }}/release
RENAMED_ELF="../target/${{ env.TARGET }}/release/guac-${name}.elf" cp "$out/guac" "$out/guac-${{ matrix.variant }}.elf"
mkdir -p dist
zip -j "dist/guac-firmware-${{ matrix.variant }}.zip" "$out/guac-${{ matrix.variant }}.elf" "$out/guac-${{ matrix.variant }}.hex"
# 3. Create .hex file via rust-objcopy - name: Upload artifact
cargo objcopy --release --target ${{ env.TARGET }} --no-default-features --features "$features" -- -O ihex "$HEX_PATH" uses: actions/upload-artifact@v3
cp "$ELF_PATH" "$RENAMED_ELF" with:
name: firmware-${{ matrix.variant }}
path: dist/*.zip
# 4. Package ELF and HEX into target-specific ZIP cli:
ZIP_NAME="guac-firmware-${name}.zip" runs-on: ubuntu-latest
zip -j "../dist/${ZIP_NAME}" "$RENAMED_ELF" "$HEX_PATH" container:
done image: catthehacker/ubuntu:rust-latest
strategy:
fail-fast: true
matrix:
target:
- aarch64-unknown-linux-musl
- x86_64-pc-windows-gnu
- x86_64-unknown-linux-musl
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Cache rustup
uses: actions/cache@v4
with:
path: ${{ env.RUSTUP_HOME }}
key: rustup-cli-${{ matrix.target }}-${{ runner.os }}
- name: Install Rust Toolchain
run: rustup target install ${{ matrix.target }}
- name: Cache cargo
uses: Swatinem/rust-cache@v2
with:
shared-key: cli-${{ matrix.target }}
- name: Cache zigbuild install
uses: actions/cache@v4
with:
path: /opt/zigvenv
key: zigbuild-venv-${{ runner.os }}
# compiled libc/compiler-rt are per target, so these stay keyed on it
- name: Cache zig build artifacts
uses: actions/cache@v4
with:
path: |
~/.cache/zig
~/.cache/cargo-zigbuild
key: zigbuild-cache-${{ matrix.target }}-${{ runner.os }}
- name: Install cargo-zigbuild Toolchain
run: |
# venv keeps cargo-zigbuild and ziglang in one relocatable-by-path directory we can cache
[ -d /opt/zigvenv ] || python3 -m venv /opt/zigvenv
/opt/zigvenv/bin/pip install cargo-zigbuild
echo /opt/zigvenv/bin >> "$GITHUB_PATH"
- name: Build cli (${{ matrix.target }})
working-directory: cli
run: cargo zigbuild --release --target ${{ matrix.target }}
- name: Package
run: |
bin=cli
[[ "${{ matrix.target }}" == *windows* ]] && bin=cli.exe
mkdir -p dist
zip -j "dist/guac-cli-${{ matrix.target }}.zip" "target/${{ matrix.target }}/release/$bin"
shell: bash
- name: Upload artifact
uses: actions/upload-artifact@v3
with:
name: cli-${{ matrix.target }}
path: dist/*.zip
release:
needs: [firmware, cli]
runs-on: ubuntu-latest
container:
image: catthehacker/ubuntu:act-latest
steps:
- name: Download artifacts
uses: actions/download-artifact@v3
with:
path: dist
- name: Create Gitea Release - name: Create Gitea Release
uses: akkuman/gitea-release-action@v1 uses: akkuman/gitea-release-action@v1
with: with:
files: dist/*.zip files: dist/**/*.zip
draft: false draft: false
prerelease: false prerelease: false
Generated
+15 -3
View File
@@ -173,6 +173,17 @@ version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d7e60934ceec538daadb9d8432424ed043a904d8e0243f3c6446bce549a46ac" checksum = "2d7e60934ceec538daadb9d8432424ed043a904d8e0243f3c6446bce549a46ac"
[[package]]
name = "bitfield-struct"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ca6739863c590881f038d033a146c51ddae239186a4327014839fd864f44ed5"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "bitflags" name = "bitflags"
version = "1.3.2" version = "1.3.2"
@@ -325,7 +336,7 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
[[package]] [[package]]
name = "cli" name = "cli"
version = "0.1.0" version = "0.3.0"
dependencies = [ dependencies = [
"async-hid", "async-hid",
"clap", "clap",
@@ -756,15 +767,16 @@ dependencies = [
[[package]] [[package]]
name = "guac" name = "guac"
version = "0.2.0" version = "0.3.0"
dependencies = [ dependencies = [
"atomic", "atomic",
"bbqueue", "bbqueue",
"bytemuck", "bitfield-struct",
"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",
+2 -2
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "cli" name = "cli"
version = "0.1.0" version = "0.3.0"
edition = "2024" edition = "2024"
[dependencies] [dependencies]
@@ -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(())
+7 -6
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "guac" name = "guac"
version = "0.2.0" version = "0.3.0"
edition = "2024" edition = "2024"
[features] [features]
@@ -9,18 +9,18 @@ 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"] }
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 +32,8 @@ 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"] }
bitfield-struct = "0.13.0"
[profile.release] [profile.release]
opt-level = "z" opt-level = "z"
+78 -66
View File
@@ -1,3 +1,4 @@
use bitfield_struct::bitfield;
use hal::Syscon; use hal::Syscon;
use hal::peripherals::syscon::ClockControl; use hal::peripherals::syscon::ClockControl;
@@ -7,8 +8,6 @@ use core::convert::Infallible;
use core::ptr::copy_nonoverlapping; use core::ptr::copy_nonoverlapping;
use core::sync::atomic::{AtomicUsize, Ordering, compiler_fence}; use core::sync::atomic::{AtomicUsize, Ordering, compiler_fence};
pub const DMA0_FLEXCOMM7_TX: u8 = 19;
#[repr(C)] #[repr(C)]
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
pub struct DmaDescriptor { pub struct DmaDescriptor {
@@ -18,6 +17,56 @@ pub struct DmaDescriptor {
pub next: *const DmaDescriptor, pub next: *const DmaDescriptor,
} }
const fn encode_transfers(transfers: u32) -> u16 {
(transfers.saturating_sub(1) & 0x3ff) as u16
}
const fn decode_transfers(raw_bits: u16) -> u32 {
(raw_bits as u32) + 1
}
/// WIDTH code: 0 = 8-bit, 1 = 16-bit, 2 = 32-bit
const fn encode_width(width_bytes: u8) -> u8 {
match width_bytes {
2 => 1,
4 => 2,
_ => 0,
}
}
const fn decode_width(raw_bits: u8) -> u8 {
match raw_bits {
1 => 2,
2 => 4,
_ => 1,
}
}
#[bitfield(u32)]
#[derive(PartialEq, Eq)]
pub struct XferCfg {
pub cfgvalid: bool, // Bit 0
pub reload: bool, // Bit 1
pub swtrig: bool, // Bit 2
pub clrtrig: bool, // Bit 3
pub inta: bool, // Bit 4
pub intb: bool, // Bit 5
#[bits(2)]
_pad1: u8, // Bits 6-7 (unused padding)
#[bits(2, from = decode_width, into = encode_width)]
pub width: u8, // Bits 8-9, in bytes (1/2/4)
#[bits(2)]
_pad2: u8, // Bits 10-11 (unused padding)
#[bits(2)]
pub src_inc: u8, // Bits 12-13
#[bits(2)]
pub dst_inc: u8, // Bits 14-15
#[bits(10, from = decode_transfers, into = encode_transfers)]
pub transfers: u32, // Bits 16-25 (fits 0x3FF max)
#[bits(6)]
_pad3: u8, // Bits 26-31 (unused padding)
}
impl defmt::Format for DmaDescriptor { impl defmt::Format for DmaDescriptor {
fn format(&self, fmt: defmt::Formatter) { fn format(&self, fmt: defmt::Formatter) {
defmt::write!( defmt::write!(
@@ -48,7 +97,7 @@ pub struct PushResult {
pub dropped: usize, pub dropped: usize,
} }
#[derive(Debug, Copy, Clone, Eq, PartialEq)] #[derive(Debug, Copy, Clone, defmt::Format, Eq, PartialEq)]
pub enum ConfigError { pub enum ConfigError {
SlotTooLarge, SlotTooLarge,
SlotTooSmall, SlotTooSmall,
@@ -78,7 +127,7 @@ pub struct DmaRing<const N: usize, const MAX_SLOT_BYTES: usize> {
/// Effective bytes per slot (atomic for interior mutability) /// Effective bytes per slot (atomic for interior mutability)
slot_bytes: AtomicUsize, slot_bytes: AtomicUsize,
word_bytes: usize, word_bytes: u8,
write_slot: UnsafeCell<usize>, write_slot: UnsafeCell<usize>,
write_off: UnsafeCell<usize>, write_off: UnsafeCell<usize>,
@@ -97,7 +146,7 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
dma: pac::DMA0, dma: pac::DMA0,
syscon: &mut Syscon, syscon: &mut Syscon,
dst_reg: *mut u32, dst_reg: *mut u32,
word_bytes: usize, word_bytes: u8,
) -> Result<Self, ConfigError> { ) -> Result<Self, ConfigError> {
if word_bytes != 1 && word_bytes != 2 && word_bytes != 4 { if word_bytes != 1 && word_bytes != 2 && word_bytes != 4 {
return Err(ConfigError::UnsupportedWidth); return Err(ConfigError::UnsupportedWidth);
@@ -107,7 +156,7 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
Ok(Self { Ok(Self {
dma, dma,
dst_reg: dst_reg, dst_reg,
channel_desc: UnsafeCell::new(DescriptorTable { channel_desc: UnsafeCell::new(DescriptorTable {
d: [DmaDescriptor { d: [DmaDescriptor {
xfercfg: 0, xfercfg: 0,
@@ -138,6 +187,7 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
} }
/// Optional: adjust safety gap (defaults to 1 empty slot). /// Optional: adjust safety gap (defaults to 1 empty slot).
#[allow(dead_code)]
pub fn set_safety_gap(&mut self, gap_slots: usize) { pub fn set_safety_gap(&mut self, gap_slots: usize) {
self.safety_gap = gap_slots.min(N); self.safety_gap = gap_slots.min(N);
} }
@@ -152,7 +202,7 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
if slot_bytes > MAX_SLOT_BYTES { if slot_bytes > MAX_SLOT_BYTES {
return Err(ConfigError::SlotTooLarge); return Err(ConfigError::SlotTooLarge);
} }
if slot_bytes % self.word_bytes != 0 { if !slot_bytes.is_multiple_of(self.word_bytes as usize) {
return Err(ConfigError::SlotNotAligned); return Err(ConfigError::SlotNotAligned);
} }
@@ -253,7 +303,7 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
let remaining_bytes = if reg_1 == 0x3FF { let remaining_bytes = if reg_1 == 0x3FF {
0 0
} else { } else {
(reg_1 as usize + 1) * self.word_bytes (reg_1 as usize + 1) * self.word_bytes as usize
}; };
// Active slot consumed calculation accounts for dynamic slot size // Active slot consumed calculation accounts for dynamic slot size
@@ -294,6 +344,8 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
} }
pub fn run(&self) { pub fn run(&self) {
self.dma.inta0.write(|w| unsafe { w.bits(1 << 19) });
self.dma.errint0.write(|w| unsafe { w.bits(1 << 19) });
self.dma.enableset0.write(|w| unsafe { w.bits(1 << 19) }); self.dma.enableset0.write(|w| unsafe { w.bits(1 << 19) });
} }
@@ -331,30 +383,30 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
let chan_desc = unsafe { &mut *self.channel_desc.get() }; let chan_desc = unsafe { &mut *self.channel_desc.get() };
// Pre-fill active slot regions with silence // Pre-fill active slot regions with silence
for i in 0..N { for slot in slots.iter_mut() {
slots[i][..slot_bytes].fill(0); slot.fill(0);
} }
let transfers = (slot_bytes / self.word_bytes) as u32; let transfers = (slot_bytes / self.word_bytes as usize) as u32;
for i in 0..N { for (i, slot) in slots.iter().enumerate() {
let src_start = slots[i].as_ptr() as usize; let src_start = slot.as_ptr() as usize;
let src_end = (src_start + slot_bytes - self.word_bytes) as *const u8; let src_end = (src_start + slot_bytes - self.word_bytes as usize) as *const u8;
let next = &desc.d[(i + 1) % N] as *const DmaDescriptor; let next = &desc.d[(i + 1) % N] as *const DmaDescriptor;
desc.d[i] = DmaDescriptor { desc.d[i] = DmaDescriptor {
xfercfg: encode_xfercfg( xfercfg: XferCfg::new()
true, // valid .with_cfgvalid(true) // valid
true, // reload .with_reload(true) // reload
false, // swtrig .with_swtrig(false) // swtrig
false, // clrtrig .with_clrtrig(false) // clrtrig
true, // intA .with_inta(true) // intA
false, // intB .with_intb(false) // intB
self.word_bytes as u32, .with_width(self.word_bytes)
1, // src_inc .with_src_inc(1) // src_inc
0, // dst_inc .with_dst_inc(0) // dst_inc
transfers, .with_transfers(transfers)
), .into_bits(),
src_end, src_end,
dst_end: self.dst_reg, dst_end: self.dst_reg,
next, next,
@@ -372,43 +424,3 @@ impl<const N: usize, const MAX_SLOT_BYTES: usize> DmaRing<N, MAX_SLOT_BYTES> {
} }
unsafe impl<const N: usize, const MAX_SLOT_BYTES: usize> Sync for DmaRing<N, MAX_SLOT_BYTES> {} unsafe impl<const N: usize, const MAX_SLOT_BYTES: usize> Sync for DmaRing<N, MAX_SLOT_BYTES> {}
/// XFERCFG encoding follows the common LPC DMA layout:
/// - SETINTA at bit4, SETINTB at bit5
/// - WIDTH at bits 9:8
/// - SRCINC at bits 13:12
/// - DSTINC at bits 15:14
/// - XFERCOUNT at bits 25:16
/// This layout is shown in LPC DMA examples. [5](https://www.kernel.org/doc/html/latest/core-api/dma-api-howto.html)
fn encode_xfercfg(
cfgvalid: bool,
reload: bool,
swtrig: bool,
clrtrig: bool,
inta: bool,
intb: bool,
width_bytes: u32,
src_inc: u32,
dst_inc: u32,
transfers: u32,
) -> u32 {
let width_code = match width_bytes {
1 => 0,
2 => 1,
4 => 2,
_ => 0,
};
let count_field = transfers.saturating_sub(1) & 0x3FF;
((cfgvalid as u32) << 0)
| ((reload as u32) << 1)
| ((swtrig as u32) << 2)
| ((clrtrig as u32) << 3)
| ((inta as u32) << 4)
| ((intb as u32) << 5)
| ((width_code & 0x3) << 8)
| ((src_inc & 0x3) << 12)
| ((dst_inc & 0x3) << 14)
| (count_field << 16)
}
+9 -5
View File
@@ -4,7 +4,7 @@ use core::mem::MaybeUninit;
use crate::hal; use crate::hal;
use crate::pac; use crate::pac;
use defmt::{debug, info}; use defmt::debug;
use hal::{ use hal::{
Enabled, Iocon, Pin, Enabled, Iocon, Pin,
drivers::pins, drivers::pins,
@@ -124,13 +124,16 @@ pub(crate) fn init_sys_pll1() {
syscon.mainclkselb.modify(|_, w| w.sel().enum_0x2()); // pll1 syscon.mainclkselb.modify(|_, w| w.sel().enum_0x2()); // pll1
} }
// Fo = M/(N*2*P) * Fin
// Fo = 3072/(125*2*8) * 16MHz = 24.576MHz
const AUDIO_PLL: PllConstants = PllConstants::new(125, 3072, 8);
// Set PLL0 to 24.576MHz, start, and wait for lock // Set PLL0 to 24.576MHz, start, and wait for lock
// This is not exposed by lpc55-hal, unfortunately. Copy their implementation here. // This is not exposed by lpc55-hal, unfortunately. Copy their implementation here.
#[cfg(feature = "evk")]
pub(crate) fn init_audio_pll() { pub(crate) fn init_audio_pll() {
use defmt::info;
// Fo = M/(N*2*P) * Fin
// Fo = 3072/(125*2*8) * 16MHz = 24.576MHz
const AUDIO_PLL: PllConstants = PllConstants::new(125, 3072, 8);
let syscon = unsafe { &*pac::SYSCON::ptr() }; let syscon = unsafe { &*pac::SYSCON::ptr() };
let pmc = unsafe { &*pac::PMC::ptr() }; let pmc = unsafe { &*pac::PMC::ptr() };
let anactrl = unsafe { &*pac::ANACTRL::ptr() }; let anactrl = unsafe { &*pac::ANACTRL::ptr() };
@@ -200,6 +203,7 @@ pub struct SharedLed<T: OutputPin> {
inner: UnsafeCell<T>, inner: UnsafeCell<T>,
} }
unsafe impl<T: OutputPin> Sync for SharedLed<T> {} unsafe impl<T: OutputPin> Sync for SharedLed<T> {}
#[allow(dead_code)]
impl<T: OutputPin> SharedLed<T> { impl<T: OutputPin> SharedLed<T> {
pub fn new(inner: T) -> Self { pub fn new(inner: T) -> Self {
Self { Self {
+269 -167
View File
@@ -8,9 +8,10 @@ fn panic() -> ! {
} }
use atomic::Atomic; use atomic::Atomic;
use core::sync::atomic::{AtomicBool, AtomicI32, AtomicUsize, Ordering}; use core::ptr;
use core::sync::atomic::AtomicPtr;
use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use cortex_m_rt::entry; use cortex_m_rt::entry;
use defmt;
use defmt::debug; use defmt::debug;
use defmt_rtt as _; use defmt_rtt as _;
use hal::Pin; use hal::Pin;
@@ -42,7 +43,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 {
@@ -105,8 +106,10 @@ 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 {
#[allow(dead_code)]
reset: Pin<pins::Pio0_3, Gpio<Output>>, reset: Pin<pins::Pio0_3, Gpio<Output>>,
} }
@@ -117,47 +120,29 @@ struct ClockSelPins {
#[derive(Default)] #[derive(Default)]
struct PerfCounters { struct PerfCounters {
state: Atomic<AudioState>, // state: Atomic<AudioState>,
received_frames: AtomicUsize, received_frames: AtomicUsize,
played_frames: AtomicUsize, played_frames: AtomicUsize,
min_fill: AtomicUsize, // min_fill: AtomicUsize,
avg_fill: AtomicUsize, // avg_fill: AtomicUsize,
queue_underflows: AtomicUsize, queue_underflows: AtomicUsize,
queue_overflows: AtomicUsize, queue_overflows: AtomicUsize,
audio_underflows: AtomicUsize, audio_underflows: AtomicUsize,
integrator: AtomicI32, // p: AtomicI32,
p: AtomicI32, // fb: AtomicI32,
i: AtomicI32,
fb: AtomicI32,
} }
impl PerfCounters { impl PerfCounters {
fn reset(&self) { fn reset(&self) {
self.received_frames.store(0, Ordering::Relaxed); self.received_frames.store(0, Ordering::Relaxed);
self.played_frames.store(0, Ordering::Relaxed); self.played_frames.store(0, Ordering::Relaxed);
self.min_fill // self.min_fill
.store(N_SLOTS * MAX_BYTES_PER_SLOT, Ordering::Relaxed); // .store(N_SLOTS * MAX_BYTES_PER_SLOT, Ordering::Relaxed);
self.avg_fill.store(0 as usize, Ordering::Relaxed); // self.avg_fill.store(0 as usize, Ordering::Relaxed);
self.queue_underflows.store(0, Ordering::Relaxed); self.queue_underflows.store(0, Ordering::Relaxed);
self.queue_overflows.store(0, Ordering::Relaxed); self.queue_overflows.store(0, Ordering::Relaxed);
self.audio_underflows.store(0, Ordering::Relaxed); self.audio_underflows.store(0, Ordering::Relaxed);
self.p.store(0, Ordering::Relaxed); // self.p.store(0, Ordering::Relaxed);
self.i.store(0, Ordering::Relaxed);
// FB loop will have to take care of the fb value
}
fn build_report(&self) -> AudioTelemetryReport {
AudioTelemetryReport {
state: self.state.load(Ordering::Relaxed) as u8,
average_buffer_fill: self.avg_fill.load(Ordering::Relaxed) as u16,
frame_count: self.played_frames.load(Ordering::Relaxed) as i32,
dac_underflow_count: self.audio_underflows.load(Ordering::Relaxed) as u16,
usb_underflow_count: self.queue_underflows.load(Ordering::Relaxed) as u16,
dac_overflow_count: self.queue_overflows.load(Ordering::Relaxed) as u16,
integrator: self.integrator.load(Ordering::Relaxed),
p: self.p.load(Ordering::Relaxed),
i: self.i.load(Ordering::Relaxed),
fb: u32::cast_signed(self.fb.load(Ordering::Relaxed) as u32),
}
} }
} }
@@ -165,11 +150,11 @@ impl defmt::Format for PerfCounters {
fn format(&self, fmt: defmt::Formatter) { fn format(&self, fmt: defmt::Formatter) {
defmt::write!( defmt::write!(
fmt, fmt,
"frames: {}/{} min_fill: {} avg fill: {} a_underflows: {} q_underflows: {} q_overflows: {}", "frames: {}/{} a_underflows: {} q_underflows: {} q_overflows: {}",
self.played_frames.load(Ordering::Relaxed), self.played_frames.load(Ordering::Relaxed),
self.received_frames.load(Ordering::Relaxed), self.received_frames.load(Ordering::Relaxed),
self.min_fill.load(Ordering::Relaxed), // self.min_fill.load(Ordering::Relaxed),
self.avg_fill.load(Ordering::Relaxed), // self.avg_fill.load(Ordering::Relaxed),
self.audio_underflows.load(Ordering::Relaxed), self.audio_underflows.load(Ordering::Relaxed),
self.queue_underflows.load(Ordering::Relaxed), self.queue_underflows.load(Ordering::Relaxed),
self.queue_overflows.load(Ordering::Relaxed) self.queue_overflows.load(Ordering::Relaxed)
@@ -178,27 +163,154 @@ impl defmt::Format for PerfCounters {
} }
static PERF: PerfCounters = PerfCounters { static PERF: PerfCounters = PerfCounters {
state: Atomic::new(AudioState::Stopped), // state: Atomic::new(AudioState::Stopped),
received_frames: AtomicUsize::new(0), // received from USB received_frames: AtomicUsize::new(0), // received from USB
played_frames: AtomicUsize::new(0), // played audio frames played_frames: AtomicUsize::new(0), // played audio frames
min_fill: AtomicUsize::new(0), // not recording this for now, need to figure out how to make it meaningful, since the queue starts empty // min_fill: AtomicUsize::new(0), // not recording this for now, need to figure out how to make it meaningful, since the queue starts empty
avg_fill: AtomicUsize::new(0), // avg_fill: AtomicUsize::new(0),
queue_underflows: AtomicUsize::new(0), // ditto here, since we underflow at startup, but we record this one as it can be trended queue_underflows: AtomicUsize::new(0), // ditto here, since we underflow at startup, but we record this one as it can be trended
queue_overflows: AtomicUsize::new(0), queue_overflows: AtomicUsize::new(0),
audio_underflows: AtomicUsize::new(0), audio_underflows: AtomicUsize::new(0),
integrator: AtomicI32::new(0), // p: AtomicI32::new(0),
p: AtomicI32::new(0), // fb: AtomicI32::new(0),
i: 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>(
perf: &PerfCounters,
audio: &Audio<D, I>,
) -> AudioTelemetryReport {
AudioTelemetryReport {
state: audio.state.load(Ordering::Relaxed) as u8,
average_buffer_fill: audio.fb.avg_fill as u16,
frame_count: perf.played_frames.load(Ordering::Relaxed).cast_signed() as i32,
dac_underflow_count: perf.audio_underflows.load(Ordering::Relaxed) as u16,
usb_underflow_count: perf.queue_underflows.load(Ordering::Relaxed) as u16,
dac_overflow_count: perf.queue_overflows.load(Ordering::Relaxed) as u16,
cur_rate: audio.cur_rate.cast_signed(),
fb_rate_estimate: audio.fb.current_freq_estimate() as i32,
}
}
#[derive(Clone, Copy, Debug)]
pub struct FeedbackConfig {
/// Nominal USB rate in Q12.13 fixed-point format (or target sample rate context).
pub nominal_rate: u32,
/// Target ring buffer fill level in bytes.
pub target_fill_bytes: i32,
/// Deadband threshold in bytes (e.g., 4).
pub deadband_bytes: i32,
/// Maximum allowed feedback deviation permille denominator (e.g., 500 => 0.2%).
pub max_deviation_divider: i32,
/// Master toggle for feedback correction.
pub correction_enabled: bool,
}
impl FeedbackConfig {
pub fn new(nominal_rate: u32, target_fill_bytes: usize) -> Self {
Self {
nominal_rate,
target_fill_bytes: target_fill_bytes as i32,
deadband_bytes: 4,
max_deviation_divider: 500, // 0.2%
correction_enabled: true,
}
}
pub fn for_rate(nominal_rate: u32) -> Self {
let target_fill_bytes = (bytes_per_slot(nominal_rate) * N_SLOTS) / 2;
Self::new(nominal_rate, target_fill_bytes)
}
}
pub struct FeedbackLoop {
pub config: FeedbackConfig,
pub avg_fill: usize,
last_freq: u32,
}
impl FeedbackLoop {
pub fn new(config: FeedbackConfig) -> Self {
Self {
config,
avg_fill: config.target_fill_bytes as usize,
last_freq: config.nominal_rate,
}
}
pub fn reset(&mut self) {
self.avg_fill = self.config.target_fill_bytes as usize;
self.last_freq = self.config.nominal_rate
}
pub fn update_config(&mut self, config: FeedbackConfig) {
self.config = config;
self.reset();
}
pub fn compute(
&mut self,
nominal_rate: UsbIsochronousFeedback,
current_fill_bytes: usize,
) -> UsbIsochronousFeedback {
if !self.config.correction_enabled {
return nominal_rate;
}
let current_bytes = current_fill_bytes as i32;
if current_bytes == 0 {
defmt::error!("[fb] dma underrun detected!");
PERF.queue_underflows.fetch_add(1, Ordering::Relaxed);
return nominal_rate;
}
self.avg_fill = ((self.avg_fill << 6) - self.avg_fill + current_bytes as usize) >> 6;
let target_fill = self.config.target_fill_bytes;
let raw_error = current_bytes - target_fill;
let nominal_v = nominal_rate.to_u32_12_13() as i32;
let max_allowed_deviation = nominal_v / self.config.max_deviation_divider;
let error_permille = (raw_error * 1000) / target_fill;
let p_term = (-((error_permille as i64) * (nominal_v as i64)) / (10 * 256000)) as i32;
let mut v = nominal_v + p_term;
v = v.clamp(
nominal_v - max_allowed_deviation,
nominal_v + max_allowed_deviation,
);
self.last_freq = v as u32;
UsbIsochronousFeedback::new(v as u32)
}
pub fn current_freq_estimate(&self) -> f32 {
// Divides by 8 (frame-to-microframe) and 65536.0 (Q16.16 shift)
(self.last_freq as f32 / (65536.0)) * USB_FRAME_RATE as f32
}
}
static NODATA_FLAG: AtomicBool = AtomicBool::new(false); static NODATA_FLAG: AtomicBool = AtomicBool::new(false);
static DMA_RING: StaticCell<DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT>> = StaticCell::new(); static DMA_RING: StaticCell<DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT>> = StaticCell::new();
static mut DMA_RING_REF: Option<&'static DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT>> = None; static DMA_RING_PTR: AtomicPtr<DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT>> =
AtomicPtr::new(ptr::null_mut());
#[inline] #[inline]
fn dma_ring() -> &'static DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT> { fn dma_ring() -> &'static DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT> {
unsafe { DMA_RING_REF.unwrap() } let ptr = DMA_RING_PTR.load(Ordering::Acquire);
unsafe { &*ptr }
} }
fn cur_fill() -> usize { fn cur_fill() -> usize {
@@ -209,14 +321,16 @@ fn cur_fill() -> usize {
produced_bytes.wrapping_sub(consumed_bytes) as usize produced_bytes.wrapping_sub(consumed_bytes) as usize
} }
fn cur_fill_target() -> i32 { /// frames per slot (based on current slot size)
(dma_ring().slot_size() * N_SLOTS) as i32 / 2
}
fn frames_per_slot() -> usize { fn frames_per_slot() -> usize {
dma_ring().slot_size() / BYTES_PER_FRAME dma_ring().slot_size() / BYTES_PER_FRAME
} }
/// bytes per slot (based on provided rate)
fn bytes_per_slot(rate: u32) -> usize {
(rate as usize / DMA_RATE) * BYTES_PER_FRAME
}
// 50% // 50%
fn queue_running_up_threshold() -> usize { fn queue_running_up_threshold() -> usize {
(frames_per_slot() * N_SLOTS) / 2 (frames_per_slot() * N_SLOTS) / 2
@@ -276,39 +390,13 @@ fn FLEXCOMM7() {
.modify(|_, w| w.txerr().set_bit()) .modify(|_, w| w.txerr().set_bit())
} }
struct FeedbackState {
correction_enabled: AtomicBool,
integrator: AtomicI32,
filtered_fill: AtomicI32,
}
impl FeedbackState {
fn start(&mut self) {
self.correction_enabled.store(true, Ordering::Relaxed);
}
fn reset(&mut self) {
self.correction_enabled.store(false, Ordering::Relaxed);
self.integrator.store(0, Ordering::Relaxed);
self.filtered_fill
.store(cur_fill_target(), Ordering::Relaxed);
}
}
impl Default for FeedbackState {
fn default() -> Self {
Self {
correction_enabled: AtomicBool::new(false),
integrator: AtomicI32::new(0),
filtered_fill: AtomicI32::new(cur_fill_target()),
}
}
}
struct Audio<'a, D: Dac<I>, I> { struct Audio<'a, D: Dac<I>, I> {
state: Atomic<AudioState>, state: Atomic<AudioState>,
alt_setting: u8, alt_setting: u8,
i2s: I2sTx, i2s: I2sTx,
dac: D, dac: D,
dma: &'a DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT>, dma: &'a DmaRing<N_SLOTS, MAX_BYTES_PER_SLOT>,
fb: FeedbackState, fb: FeedbackLoop,
nodata_timeout_frame: AtomicUsize, nodata_timeout_frame: AtomicUsize,
cur_rate: u32, cur_rate: u32,
clock_pins: ClockSelPins, clock_pins: ClockSelPins,
@@ -332,8 +420,8 @@ impl<D: Dac<I>, I> Audio<'_, D, I> {
AudioState::NoData => self.nodata(), AudioState::NoData => self.nodata(),
AudioState::Stopping => self.stopping(), AudioState::Stopping => self.stopping(),
} }
self.state.store(state, Ordering::SeqCst); self.state.store(state, Ordering::Release);
PERF.state.store(state, Ordering::Relaxed); // PERF.state.store(state, Ordering::Relaxed);
} }
fn init(&mut self) { fn init(&mut self) {
@@ -376,6 +464,7 @@ impl<D: Dac<I>, I> Audio<'_, D, I> {
}); });
unsafe { pac::NVIC::unmask(pac::Interrupt::FLEXCOMM7) }; unsafe { pac::NVIC::unmask(pac::Interrupt::FLEXCOMM7) };
self.dac.init(); self.dac.init();
} }
///Transition -> Stopped: ///Transition -> Stopped:
@@ -415,7 +504,7 @@ impl<D: Dac<I>, I> Audio<'_, D, I> {
///Transition -> Running ///Transition -> Running
///Unmask I2S ISR, start feedback ///Unmask I2S ISR, start feedback
fn run(&mut self) { fn run(&mut self) {
self.fb.start(); self.i2s.i2s.fifostat.write(|w| w.txerr().set_bit());
// FIFO threshold trigger enable // FIFO threshold trigger enable
self.i2s self.i2s
.i2s .i2s
@@ -425,14 +514,14 @@ impl<D: Dac<I>, I> Audio<'_, D, I> {
.i2s .i2s
.fifocfg .fifocfg
.modify(|_, w| w.enabletx().enabled().dmatx().enabled()); .modify(|_, w| w.enabletx().enabled().dmatx().enabled());
dma_ring().run();
// clear tx error status
self.i2s.i2s.fifostat.write(|w| w.txerr().set_bit());
// enable tx error interrupt
self.i2s.i2s.fifointenset.write(|w| w.txerr().enabled());
unsafe { unsafe {
pac::NVIC::unmask(pac::Interrupt::DMA0); pac::NVIC::unmask(pac::Interrupt::DMA0);
} }
dma_ring().run();
// clear tx error status
// self.i2s.i2s.fifostat.write(|w| w.txerr().set_bit());
// enable tx error interrupt
self.i2s.i2s.fifointenset.write(|w| w.txerr().enabled());
} }
///Transition->NoData ///Transition->NoData
///store framecount at transition so we can time out recovery ///store framecount at transition so we can time out recovery
@@ -472,13 +561,18 @@ impl<D: Dac<I>, I> ClockSource for Audio<'_, D, I> {
sample_rate: u32, sample_rate: u32,
) -> core::result::Result<(), usbd_uac2::UsbAudioClassError> { ) -> core::result::Result<(), usbd_uac2::UsbAudioClassError> {
defmt::info!("[clock] changing rate to {}", sample_rate); defmt::info!("[clock] changing rate to {}", sample_rate);
if self.state.load(Ordering::SeqCst) != AudioState::Stopped { if self.state.load(Ordering::Acquire) != AudioState::Stopped {
defmt::warn!("[clock] changing rate when not stopped, stopping first"); defmt::warn!("[clock] changing rate when not stopped, stopping first");
self.stop(); self.stop();
} }
let slot_bytes = (self.cur_rate as usize / DMA_RATE) * BYTES_PER_FRAME;
dma_ring().set_slot_size(slot_bytes);
self.cur_rate = sample_rate; self.cur_rate = sample_rate;
let slot_bytes = bytes_per_slot(self.cur_rate);
if let Err(e) = dma_ring().set_slot_size(slot_bytes) {
defmt::error!("Error configuring dma: {}", e);
return Err(UsbAudioClassError::Other);
}
self.fb
.update_config(FeedbackConfig::for_rate(self.cur_rate));
if 24_576_000u32.is_multiple_of(sample_rate) { if 24_576_000u32.is_multiple_of(sample_rate) {
defmt::info!("[clock] 24M osc selected"); defmt::info!("[clock] 24M osc selected");
self.clock_pins.sel_22m.set_low().ok(); self.clock_pins.sel_22m.set_low().ok();
@@ -506,7 +600,7 @@ impl<D: Dac<I>, I> ClockSource for Audio<'_, D, I> {
} }
impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> { impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
fn alternate_setting_changed(&mut self, _terminal: usb_device::UsbDirection, alt_setting: u8) { fn alternate_setting_changed(&mut self, _terminal: usb_device::UsbDirection, alt_setting: u8) {
let state = self.state.load(Ordering::Relaxed); let state = self.state.load(Ordering::Acquire);
match (alt_setting, state) { match (alt_setting, state) {
(0, AudioState::Armed | AudioState::Prefill | AudioState::NoData) => { (0, AudioState::Armed | AudioState::Prefill | AudioState::NoData) => {
self.transition(AudioState::Stopped) self.transition(AudioState::Stopped)
@@ -525,7 +619,7 @@ impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
&mut self, &mut self,
ep: &usb_device::endpoint::Endpoint<'_, B, usb_device::endpoint::Out>, ep: &usb_device::endpoint::Endpoint<'_, B, usb_device::endpoint::Out>,
) { ) {
let state = self.state.load(Ordering::Relaxed); let state = self.state.load(Ordering::Acquire);
let mut buf = let mut buf =
[0; (MAX_SAMPLE_RATE.div_ceil(USB_FRAME_RATE) + 1) as usize * BYTES_PER_FRAME]; [0; (MAX_SAMPLE_RATE.div_ceil(USB_FRAME_RATE) + 1) as usize * BYTES_PER_FRAME];
let len = match ep.read(&mut buf) { let len = match ep.read(&mut buf) {
@@ -556,7 +650,8 @@ impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
// Valid states here are Armed, Prefill, Running, Draining and NoData // Valid states here are Armed, Prefill, Running, Draining and NoData
match state { match state {
AudioState::Stopped | AudioState::Stopping => { AudioState::Stopped | AudioState::Stopping => {
defmt::error!("Received audio data when stopped/stopping") defmt::warn!("Received audio data when stopped/stopping");
self.transition(AudioState::Prefill);
} }
// When armed, data rx goes to prefill // When armed, data rx goes to prefill
AudioState::Armed => self.transition(AudioState::Prefill), AudioState::Armed => self.transition(AudioState::Prefill),
@@ -572,7 +667,7 @@ impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
AudioState::Running => {} AudioState::Running => {}
// If draining, check cur_fill, if it rises above QUEUE_RUNNING_UP, move back to running. If it drops to 0, move to NoData or Stopped // If draining, check cur_fill, if it rises above QUEUE_RUNNING_UP, move back to running. If it drops to 0, move to NoData or Stopped
AudioState::LowData => { AudioState::LowData => {
let fill = cur_fill() as usize; let fill = cur_fill();
// Do we check alt setting here? We shouldn't be receiving data at all if we are not in altSetting 1 // Do we check alt setting here? We shouldn't be receiving data at all if we are not in altSetting 1
if fill >= queue_running_up_threshold() { if fill >= queue_running_up_threshold() {
self.transition(AudioState::Running); self.transition(AudioState::Running);
@@ -583,7 +678,7 @@ impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
} }
} }
// Any data in NoData moves us into LowData. But maybe it should be more like prefill? // Any data in NoData moves us into LowData. But maybe it should be more like prefill?
AudioState::NoData => self.transition(AudioState::LowData), AudioState::NoData => self.transition(AudioState::Prefill),
} }
} }
fn audio_data_tx( fn audio_data_tx(
@@ -592,11 +687,7 @@ impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
) { ) {
} }
fn feedback(&mut self, nominal_rate: UsbIsochronousFeedback) -> Option<UsbIsochronousFeedback> { fn feedback(&mut self, nominal_rate: UsbIsochronousFeedback) -> Option<UsbIsochronousFeedback> {
if !self.fb.correction_enabled.load(Ordering::Relaxed) { let current_bytes = cur_fill();
return Some(nominal_rate);
}
let current_bytes = cur_fill() as i32;
if current_bytes == 0 { if current_bytes == 0 {
defmt::error!("[fb] dma underrun detected!"); defmt::error!("[fb] dma underrun detected!");
@@ -604,44 +695,11 @@ impl<D: Dac<I>, I, B: bus::UsbBus> AudioHandler<'_, B> for Audio<'_, D, I> {
return Some(nominal_rate); return Some(nominal_rate);
} }
PERF.avg_fill let v = self.fb.compute(nominal_rate, current_bytes);
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |v| { // PERF.avg_fill.store(self.fb.avg_fill, Ordering::Relaxed);
Some(((v << 6) - v + current_bytes as usize) >> 6) // PERF.fb.store(v as i32, Ordering::Relaxed);
})
.ok();
let raw_error = current_bytes - cur_fill_target(); Some(v)
let i_error = if raw_error.abs() <= 4 { 0 } else { raw_error }; // deadband
let current_i = self.fb.integrator.load(Ordering::Relaxed);
let leak = current_i >> 7;
let new_i = current_i
.saturating_sub(leak)
.saturating_add(i_error)
.clamp(-5000, 5000);
self.fb.integrator.store(new_i, Ordering::Relaxed);
PERF.integrator.store(new_i, Ordering::Relaxed);
let nominal_v = nominal_rate.to_u32_12_13() as i32;
let max_allowed_deviation = nominal_v / 500; // 0.2%
// 3. SEPARATE GAINS FOR P AND I
// For P: Keep your working math (converting raw error to a permille equivalent scale)
let error_permille = (raw_error * 1000) / cur_fill_target();
let p_term = (-((error_permille as i64) * (nominal_v as i64)) / (10 * 256000)) as i32;
let i_term = (-((new_i as i64) * (nominal_v as i64)) / (256000 * 1000)) as i32;
let i_term = 0;
PERF.p.store(p_term, Ordering::Relaxed);
PERF.i.store(i_term, Ordering::Relaxed);
let mut v = nominal_v + p_term + i_term;
v = v.clamp(
nominal_v - max_allowed_deviation,
nominal_v + max_allowed_deviation,
);
PERF.fb.store(v, Ordering::Relaxed);
Some(UsbIsochronousFeedback::new(v as u32))
} }
} }
@@ -752,7 +810,7 @@ fn main() -> ! {
pins::Pio1_20::take().unwrap().into_i2c4_scl_pin(&mut iocon), pins::Pio1_20::take().unwrap().into_i2c4_scl_pin(&mut iocon),
pins::Pio1_21::take().unwrap().into_i2c4_sda_pin(&mut iocon), pins::Pio1_21::take().unwrap().into_i2c4_sda_pin(&mut iocon),
); );
let codec_i2s_pins = ( let _codec_i2s_pins = (
pins::Pio0_21::take().unwrap().into_spi7_sck_pin(&mut iocon), pins::Pio0_21::take().unwrap().into_spi7_sck_pin(&mut iocon),
pins::Pio0_20::take().unwrap().into_i2s7_sda_pin(&mut iocon), pins::Pio0_20::take().unwrap().into_i2s7_sda_pin(&mut iocon),
pins::Pio0_19::take().unwrap().into_i2s7_ws_pin(&mut iocon), pins::Pio0_19::take().unwrap().into_i2s7_ws_pin(&mut iocon),
@@ -831,15 +889,17 @@ fn main() -> ! {
) )
.unwrap(); .unwrap();
let dma_ref = DMA_RING.init(dma); let dma_ref = DMA_RING.init(dma);
unsafe { DMA_RING_REF = Some(dma_ref) }; DMA_RING_PTR.store(dma_ref as *const _ as *mut _, Ordering::Release);
// unsafe { DMA_RING_PTR = Some(dma_ref) };
defmt::info!("audio init"); defmt::info!("audio init");
let mut audio = Audio { let mut audio = Audio {
state: Atomic::new(AudioState::Stopped), state: Atomic::new(AudioState::Stopped),
i2s: i2s_peripheral, i2s: i2s_peripheral,
dac: dac_impl, dac: dac_impl,
dma: dma_ring(), dma: dma_ring(),
fb: FeedbackState::default(), fb: FeedbackLoop::new(FeedbackConfig::for_rate(SAMPLE_RATES[0].min)),
alt_setting: 0, alt_setting: 0,
nodata_timeout_frame: AtomicUsize::new(0), nodata_timeout_frame: AtomicUsize::new(0),
cur_rate: SAMPLE_RATES[0].min, cur_rate: SAMPLE_RATES[0].min,
@@ -859,7 +919,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()
@@ -870,47 +940,80 @@ fn main() -> ! {
.unwrap() .unwrap()
.build(); .build();
// 1. Initialize the HID timer conditionally outside the closure
#[cfg(feature = "hid")] #[cfg(feature = "hid")]
let mut poll_all = { let mut hid_update_timer = {
let mut hid_update_timer = Timer::new( let mut timer = Timer::new(
hal.ctimer hal.ctimer
.1 .1
.enabled(&mut syscon, clocks.support_1mhz_fro_token().unwrap()), .enabled(&mut syscon, clocks.support_1mhz_fro_token().unwrap()),
); );
hid_update_timer.start(Microseconds::new(HID_INTERVAL_MS as u32 * 1000)); timer.start(Microseconds::new(HID_INTERVAL_MS as u32 * 1000));
timer
};
move || { // 2. Single consolidated poll_all closure
usb_dev.poll(&mut [&mut uac2, &mut hid]); let mut poll_all = move || {
// DMA ring is empty; if altsetting = 0 then -> stopped else NoData // Poll active USB classes
// TODO: handle NoData state #[cfg(feature = "hid")]
if NODATA_FLAG.swap(false, Ordering::Acquire) { usb_dev.poll(&mut [&mut uac2, &mut hid, &mut hid_cmd]);
match uac2.handler().state.load(Ordering::Acquire) {
AudioState::Stopping => uac2.handler().transition(AudioState::Stopped), #[cfg(not(feature = "hid"))]
_ => uac2.handler().transition(AudioState::Stopped), usb_dev.poll(&mut [&mut uac2]);
}
} // TODO: we should handle unexpected NODATA differently from 'Stopping'
if hid_update_timer.wait().is_ok() { if NODATA_FLAG.swap(false, Ordering::AcqRel) {
let report = PERF.build_report(); let audio = uac2.handler();
match hid.push_input(&report) { audio.transition(AudioState::Stopped);
Ok(_) => {} // The host is still streaming (alt setting 1) so no alt setting change will
Err(UsbError::WouldBlock) => {} // re-arm us; re-arm now so the DMA channel is re-initialised before more data
Err(e) => defmt::error!("Failed to send HID report: {:?}", e), // arrives.
} if audio.alt_setting == 1 {
// lpc55 ctimer is not Periodic, so restart it audio.transition(AudioState::Armed);
hid_update_timer.start(Microseconds::new(HID_INTERVAL_MS as u32 * 1000));
} }
} }
};
#[cfg(not(feature = "hid"))] #[cfg(feature = "hid")]
let mut poll_all = { {
move || { use deku::DekuContainerRead;
usb_dev.poll(&mut [&mut uac2]); use shared::AudioDeviceCommand;
if NODATA_FLAG.swap(false, Ordering::Acquire) {
match uac2.handler().state.load(Ordering::Acquire) { fn handle_cmd(cmd: AudioDeviceCommand) {
AudioState::Stopping => uac2.handler().transition(AudioState::Stopped), use shared::AudioDeviceCommand;
_ => uac2.handler().transition(AudioState::Stopped),
match cmd {
AudioDeviceCommand::Noop => {}
AudioDeviceCommand::Reset => {
cortex_m::interrupt::disable();
cortex_m::peripheral::SCB::sys_reset();
}
AudioDeviceCommand::Bootloader => boot_to_bootloader(),
} }
} }
if hid_update_timer.wait().is_ok() {
let report = build_telemetry_report(&PERF, uac2.handler());
if let Err(e) = hid.push_input(&report)
&& 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))
&& let Ok(cmd) = cmd.try_into()
{
handle_cmd(cmd)
}
}
Err(UsbError::WouldBlock) => {}
Err(e) => defmt::error!("Invalid report: {:?}", e),
}
} }
}; };
@@ -918,6 +1021,5 @@ fn main() -> ! {
loop { loop {
poll_all(); poll_all();
// usb_dev.poll(&mut [&mut uac2]);
} }
} }
+1
View File
@@ -5,6 +5,7 @@ pub trait Dac<T> {
fn init(&mut self); fn init(&mut self);
fn change_rate(&mut self, new_rate: u32); fn change_rate(&mut self, new_rate: u32);
#[allow(unused_variables)] #[allow(unused_variables)]
#[allow(dead_code)]
fn set_volume(&mut self, left: u8, right: u8) {} fn set_volume(&mut self, left: u8, right: u8) {}
fn mute(&mut self); fn mute(&mut self);
fn unmute(&mut self); fn unmute(&mut self);
-4
View File
@@ -1,4 +0,0 @@
[toolchain]
channel = "1.95.0"
targets = ["thumbv8m.main-none-eabihf"]
components = ["llvm-tools-preview"]
+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]
+63 -26
View File
@@ -1,18 +1,22 @@
#![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")]
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, NoUninit, Eq, PartialEq, TryFromPrimitive)] #[derive(Clone, Copy, Debug, Default, NoUninit, Eq, PartialEq, TryFromPrimitive)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[repr(u8)] #[repr(u8)]
pub enum AudioState { pub enum AudioState {
/// Knowingly stopped, ie. AltSetting=0. DAC muted, I2S disabled. /// Knowingly stopped, ie. AltSetting=0. DAC muted, I2S disabled.
/// ///
/// AltSetting = 1 -> ARMED /// AltSetting = 1 -> ARMED
#[default]
Stopped = 0, Stopped = 0,
/// Waiting for data. DAC muted, I2S running sending 0s (FIFO not serviced). /// Waiting for data. DAC muted, I2S running sending 0s (FIFO not serviced).
/// ///
@@ -49,11 +53,6 @@ pub enum AudioState {
Stopping = 6, Stopping = 6,
} }
impl Default for AudioState {
fn default() -> Self {
AudioState::Stopped
}
}
impl defmt::Format for AudioState { impl defmt::Format for AudioState {
fn format(&self, fmt: defmt::Formatter) { fn format(&self, fmt: defmt::Formatter) {
defmt::write!( defmt::write!(
@@ -99,19 +98,35 @@ pub struct AudioTelemetrySnapshot {
pub dac_underflow_count: u16, pub dac_underflow_count: u16,
pub usb_underflow_count: u16, pub usb_underflow_count: u16,
pub dac_overflow_count: u16, pub dac_overflow_count: u16,
pub p: i32, pub cur_rate: u32,
pub i: i32, pub fb_rate_estimate: f32,
pub fb: i32, }
// 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")] use crate::{AudioDeviceCommand, AudioState, AudioTelemetrySnapshot};
use serde::{Deserialize, Serialize};
use crate::{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")]
@@ -123,10 +138,8 @@ pub mod hid {
dac_underflow_count=input; dac_underflow_count=input;
usb_underflow_count=input; usb_underflow_count=input;
dac_overflow_count=input; dac_overflow_count=input;
p=input; cur_rate=input;
i=input; fb_rate_estimate=input;
fb=input;
integrator=input;
} }
)] )]
#[repr(C, packed)] #[repr(C, packed)]
@@ -138,10 +151,8 @@ pub mod hid {
pub dac_underflow_count: u16, pub dac_underflow_count: u16,
pub usb_underflow_count: u16, pub usb_underflow_count: u16,
pub dac_overflow_count: u16, pub dac_overflow_count: u16,
pub p: i32, pub cur_rate: i32,
pub i: i32, pub fb_rate_estimate: i32,
pub fb: i32,
pub integrator: i32,
} }
impl From<AudioTelemetryReport> for AudioTelemetrySnapshot { impl From<AudioTelemetryReport> for AudioTelemetrySnapshot {
@@ -149,14 +160,40 @@ pub mod hid {
AudioTelemetrySnapshot { AudioTelemetrySnapshot {
state: AudioState::try_from(value.state).expect("Invalid AudioState"), state: AudioState::try_from(value.state).expect("Invalid AudioState"),
average_buffer_fill: value.average_buffer_fill, average_buffer_fill: value.average_buffer_fill,
frame_count: i32::cast_unsigned(value.frame_count), // on firmware side is usize == u32 frame_count: value.frame_count.cast_unsigned(), // on firmware side is usize == u32
dac_underflow_count: value.dac_underflow_count, dac_underflow_count: value.dac_underflow_count,
usb_underflow_count: value.usb_underflow_count, usb_underflow_count: value.usb_underflow_count,
dac_overflow_count: value.dac_overflow_count, dac_overflow_count: value.dac_overflow_count,
p: value.p, cur_rate: value.cur_rate.cast_unsigned(),
i: value.i, fb_rate_estimate: (value.fb_rate_estimate as f32),
fb: value.fb,
} }
} }
} }
#[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 }
}
}
} }