WIP.

.cargo/config

@@ -0,0 +1,14 @@
+[build]
+# Instruction set of Cortex-M0+
+target = "thumbv6m-none-eabi"
+
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+rustflags = [
+    "-C", "link-arg=--nmagic",
+    "-C", "link-arg=-Tlink.x",
+    "-C", "inline-threshold=5",
+    "-C", "no-vectorize-loops",
+]
+#runner = "elf2uf2-rs -d"
+runner = "arm-none-eabi-gdb -x openocd.gdb"
+

.gitignore

@@ -0,0 +1,2 @@
+/target
+*.swp

Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "rp2040-usb-sound-card"
+version = "0.1.0"
+edition = "2018"
+resolver = "2"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.7.2"
+cortex-m-rt = "0.7"
+cortex-m-rtic = "0.6.0-alpha.5"
+cortex-m-semihosting = "0.3.7"
+embedded-hal ="0.2.5"
+embedded-time = "0.12.0"
+nb = "1.0"
+#panic-halt = "0.2.0"
+panic-semihosting = "0.5"
+#panic-write = "0.1.0"
+pio = { git = "https://github.com/rp-rs/pio-rs.git", branch = "main" }
+pio-proc = { git = "https://github.com/rp-rs/pio-rs.git", branch = "main" }
+#rp2040-hal = { git = "https://github.com/rp-rs/rp-hal.git", features = ["rt"] }
+rp2040-hal = { path = "../rp-hal/rp2040-hal", features = ["rt"] }
+rp2040-boot2 = "0.1.2"
+stable_deref_trait = { version = "1.2.0", default-features = false }
+systick-monotonic = "0.1.0-alpha.0"
+usb-device = { version = "0.2.8", features = ["control-buffer-256"] }
+void = { version = "*", default_features = false }
+
+[patch.crates-io]
+usb-device = { path = "../usb-device" }
+
+[profile]
+[profile.release]
+debug = true
+lto = true

build.rs

@@ -0,0 +1,31 @@
+//! 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());
+
+    // By default, Cargo will re-run a build script whenever
+    // any file in the project changes. By specifying `memory.x`
+    // here, we ensure the build script is only re-run when
+    // `memory.x` is changed.
+    println!("cargo:rerun-if-changed=memory.x");
+}

memory.x

@@ -0,0 +1,13 @@
+MEMORY {
+    BOOT2 : ORIGIN = 0x10000000, LENGTH = 0x100
+    FLASH : ORIGIN = 0x10000100, LENGTH = 2048K - 0x100
+    RAM   : ORIGIN = 0x20000000, LENGTH = 256K
+}
+
+SECTIONS {
+    /* ### Boot loader */
+    .boot2 ORIGIN(BOOT2) :
+    {
+        KEEP(*(.boot2));
+    } > BOOT2
+} INSERT BEFORE .text;

openocd.cfg

@@ -0,0 +1,6 @@
+source [find interface/cmsis-dap.cfg]
+transport select swd
+
+adapter speed 100
+source [find target/rp2040.cfg]
+

openocd.gdb

@@ -0,0 +1,26 @@
+set history save on
+set confirm off
+target extended-remote :3333
+monitor arm semihosting enable
+monitor reset halt
+
+# print demangled symbols
+set print asm-demangle on
+
+# set backtrace limit to not have infinite backtrace loops
+set backtrace limit 32
+
+# detect unhandled exceptions, hard faults and panics
+break DefaultHandler
+break HardFault
+#break rust_begin_unwind
+
+#break main
+
+load
+run
+# continue
+# monitor verify
+# monitor reset
+# quit
+

src/audio_buffer.rs

@@ -0,0 +1,205 @@
+//! Audio buffer type to transfer audio data within different software/hardware components.
+#![warn(missing_docs)]
+
+use core::cell::{Cell, UnsafeCell};
+use core::ops::Deref;
+
+use cortex_m::interrupt::{CriticalSection, Mutex};
+use stable_deref_trait::StableDeref;
+
+/// Each packet contains 1 millisecond of audio data (48 samples at 48000kHz).
+///
+/// This translates two twice the number of values, as each sample contains two channels.
+pub const SAMPLES_PER_PACKET: usize = 48;
+/// Number of channels for all audio data.
+pub const CHANNELS: usize = 2;
+
+/// Buffer for a single packet with audio data.
+pub type Packet = [u32; SAMPLES_PER_PACKET * CHANNELS];
+
+/// Type for audio packet buffering.
+///
+/// The audio packets always contain two channels with 32-bit samples. The type contains a number
+/// of buffers each containing the same fixed number of samples.
+pub struct AudioBuffer<const PACKETS: usize> {
+    mutex: Mutex<AudioBufferInner<PACKETS>>,
+}
+
+struct AudioBufferInner<const PACKETS: usize> {
+    /// Packet contents.
+    packets: [UnsafeCell<Packet>; PACKETS],
+    /// Bitmask of packets which contain valid data and are not currently being read.
+    valid: Cell<u32>,
+    /// Bitmask of packets which do not contain valid data and which are not currently being
+    /// written.
+    invalid: Cell<u32>,
+    /// Bitmask of all packets which are currently borrowed via `borrow_read()`.
+    reading: Cell<u32>,
+    /// Bitmask of all packets which are currently borrowed via `borrow_write()`.
+    writing: Cell<u32>,
+}
+
+impl AudioBuffer<4> {
+    /// Creates a new audio buffer.
+    pub const fn new() -> Self {
+        const PACKETS: usize = 4;
+        // Initially, all packet contents are invalid and no packets are currently being read or
+        // written.
+        AudioBuffer {
+            mutex: Mutex::new(AudioBufferInner {
+                packets: [
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                ],
+                valid: Cell::new(0),
+                invalid: Cell::new(((1 << PACKETS) - 1) as u32),
+                reading: Cell::new(0),
+                writing: Cell::new(0),
+            }),
+        }
+    }
+}
+
+impl<const PACKETS: usize> AudioBuffer<PACKETS> {
+    /// Returns an interface to read packets from this buffer.
+    pub fn read(&'static self) -> ReadBuffer<PACKETS> {
+        ReadBuffer { buffer: self }
+    }
+
+    /// Returns an interface to write packets to this buffer.
+    pub fn write(&'static self) -> WriteBuffer<PACKETS> {
+        WriteBuffer { buffer: self }
+    }
+}
+
+/// Interface to read packets from a buffer.
+pub struct ReadBuffer<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+}
+
+impl<const PACKETS: usize> ReadBuffer<PACKETS> {
+    /// Returns whether there are any buffers with valid data ready for reading.
+    pub fn can_read(&self, cs: &CriticalSection) -> bool {
+        let inner = self.buffer.mutex.borrow(cs);
+        inner.valid.get() != 0
+    }
+
+    /// Borrows a single buffer for reading, returns `None` if no buffer with valid data is
+    /// available.
+    ///
+    /// The caller needs to return the buffer via `read_finished()` once the data has been
+    /// processed.
+    pub fn borrow_read(&self, cs: &CriticalSection) -> Option<ReadPacket<PACKETS>> {
+        let inner = self.buffer.mutex.borrow(cs);
+        let valid = inner.valid.get();
+        if valid == 0 {
+            return None;
+        }
+        let index = valid.trailing_zeros();
+        inner.valid.set(valid & !(1 << index));
+        inner.reading.set(inner.reading.get() | (1 << index));
+
+        let index = index as usize;
+        Some(ReadPacket {
+            buffer: self.buffer,
+            data: unsafe { &*inner.packets[index].get() },
+            index,
+        })
+    }
+
+    /// Returns a buffer that was allocated via `borrow_read()` and marks it as empty.
+    pub fn read_finished(&self, packet: ReadPacket<PACKETS>, cs: &CriticalSection) {
+        assert!((self.buffer as *const _) == (packet.buffer as *const _));
+        let inner = self.buffer.mutex.borrow(cs);
+        let index = packet.index;
+        inner.reading.set(inner.reading.get() & !(1 << index));
+        inner.invalid.set(inner.invalid.get() | (1 << index));
+    }
+}
+
+/// Interface to write packets to a buffer.
+pub struct WriteBuffer<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+}
+
+impl<const PACKETS: usize> WriteBuffer<PACKETS> {
+    /// Returns whether there are any empty buffers ready for writing.
+    pub fn can_write(&self, cs: &CriticalSection) -> bool {
+        let inner = self.buffer.mutex.borrow(cs);
+        inner.invalid.get() != 0
+    }
+
+    /// Borrows a single buffer for writing, returns `None` if no empty buffer is available.
+    ///
+    /// The caller needs to return the buffer via `write_finished()` once it was filled with data.
+    pub fn borrow_write(&self, cs: &CriticalSection) -> Option<WritePacket<PACKETS>> {
+        let inner = self.buffer.mutex.borrow(cs);
+        let invalid = inner.invalid.get();
+        if invalid == 0 {
+            return None;
+        }
+        let index = invalid.trailing_zeros();
+        inner.invalid.set(invalid & !(1 << index));
+        inner.writing.set(inner.writing.get() | (1 << index));
+
+        let index = index as usize;
+        Some(WritePacket {
+            buffer: self.buffer,
+            data: unsafe { &mut *inner.packets[index].get() },
+            index,
+        })
+    }
+
+    /// Returns a buffer that was allocated via `borrow_write()` and marks it as ready for reading.
+    pub fn write_finished(&self, packet: WritePacket<PACKETS>, cs: &CriticalSection) {
+        assert!((self.buffer as *const _) == (packet.buffer as *const _));
+        let inner = self.buffer.mutex.borrow(cs);
+        let index = packet.index;
+        inner.writing.set(inner.writing.get() & !(1 << index));
+        inner.valid.set(inner.valid.get() | (1 << index));
+    }
+}
+
+/// Packet buffer that has been borrowed for reading (i.e., the buffer contains valid data).
+pub struct ReadPacket<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+    data: &'static Packet,
+    index: usize,
+}
+
+impl<const PACKETS: usize> AsRef<[u32]> for ReadPacket<PACKETS> {
+    fn as_ref(&self) -> &[u32] {
+        self.data
+    }
+}
+
+impl<const PACKETS: usize> Deref for ReadPacket<PACKETS> {
+    type Target = Packet;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+unsafe impl<const PACKETS: usize> StableDeref for ReadPacket<PACKETS> {}
+
+/// Packet buffer that has been borrowed for writing (i.e., the buffer was previously empty).
+pub struct WritePacket<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+    data: &'static mut Packet,
+    index: usize,
+}
+
+impl<const PACKETS: usize> AsRef<[u32]> for WritePacket<PACKETS> {
+    fn as_ref(&self) -> &[u32] {
+        self.data
+    }
+}
+
+impl<const PACKETS: usize> AsMut<[u32]> for WritePacket<PACKETS> {
+    fn as_mut(&mut self) -> &mut [u32] {
+        self.data
+    }
+}

src/i2s_master.rs

@@ -0,0 +1,121 @@
+use crate::audio_buffer::{ReadBuffer, ReadPacket};
+use core::marker::PhantomData;
+use cortex_m::interrupt;
+use rp2040_hal::dma::{Channel, ChannelIndex, SingleBuffering, SingleBufferingConfig};
+use rp2040_hal::gpio::bank0::{Gpio0, Gpio1, Gpio3, Gpio6};
+use rp2040_hal::gpio::{Function, Pin, Pio0};
+use rp2040_hal::pac::PIO0;
+use rp2040_hal::pio::{
+    PIOBuilder, PIOExt, StateMachineIndex, Tx, UninitStateMachine, ValidStateMachine, PIO,
+};
+
+pub trait PinConfig {
+    type PIO;
+
+    const OUT_MASK: u32;
+}
+
+impl PinConfig
+    for (
+        Pin<Gpio0, Function<Pio0>>,
+        Pin<Gpio1, Function<Pio0>>,
+        Pin<Gpio6, Function<Pio0>>,
+        Pin<Gpio3, Function<Pio0>>,
+    )
+{
+    type PIO = PIO0;
+
+    const OUT_MASK: u32 = 0x4b;
+}
+
+pub struct I2sMaster<SM: ValidStateMachine, DMACH: ChannelIndex, LRCLK, BCLK, SDO, SDI> {
+    tx: Option<SingleBuffering<Channel<DMACH>, ReadPacket<4>, Tx<SM>>>,
+    out_buffer: ReadBuffer<4>,
+    _phantom: PhantomData<(SM, LRCLK, BCLK, SDO, SDI)>,
+}
+
+impl<P: PIOExt, SM: StateMachineIndex, DMACH: ChannelIndex, LRCLK, BCLK, SDO, SDI>
+    I2sMaster<(P, SM), DMACH, LRCLK, BCLK, SDO, SDI>
+where
+    (LRCLK, BCLK, SDO, SDI): PinConfig,
+{
+    pub fn init(
+        pio: &mut PIO<P>,
+        sm: UninitStateMachine<(P, SM)>,
+        dma: Channel<DMACH>,
+        out_buffer: ReadBuffer<4>,
+        _lrclk: LRCLK,
+        _bclk: BCLK,
+        _sdo: SDO,
+        _sdi: SDI,
+    ) -> Self {
+        let program = pio_proc::pio!(
+            32,
+            "
+        .side_set 2
+
+        .wrap_target
+            pull noblock      side 0b11 [0]
+            set x, 14         side 0b11 [0]
+
+        leftloop:
+            out pins, 1       side 0b00 [6]
+            in pins, 1        side 0b01 [5]
+            jmp x-- leftloop  side 0b01 [0]
+
+            out pins, 1       side 0b00 [6]
+            in pins, 1        side 0b01 [5]
+            set x, 14         side 0b01 [0]
+        rightloop:
+            out pins, 1       side 0b10 [6]
+            in pins, 1        side 0b11 [5]
+            jmp x-- rightloop side 0b11 [0]
+
+            out pins, 1       side 0b10 [6]
+            in pins, 1        side 0b11 [3]
+            push noblock      side 0b11 [0]
+        .wrap
+                    "
+        );
+
+        let installed = pio.install(&program.program).unwrap();
+        let (mut sm, _rx, tx) = PIOBuilder::from_program(installed)
+            .side_set_pin_base(0)
+            //.set_pins(6, 1)
+            .out_pins(6, 1)
+            .in_pin_base(3)
+            .clock_divisor(4.0)
+            .build(sm);
+        sm.set_pindirs_with_mask(
+            <(LRCLK, BCLK, SDO, SDI)>::OUT_MASK,
+            <(LRCLK, BCLK, SDO, SDI)>::OUT_MASK,
+        );
+
+        // Start the first DMA transfer.
+        let packet = interrupt::free(|cs| out_buffer.borrow_read(cs).unwrap());
+        let tx = SingleBufferingConfig::new(dma, packet, tx).start();
+
+        // Start I2S.
+        // TODO: Synchronized start of multiple I2S instances?
+        sm.start();
+
+        I2sMaster {
+            tx: Some(tx),
+            out_buffer,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn next_packet(&mut self) {
+        if !self.tx.as_mut().unwrap().check_irq0() {
+            return;
+        }
+
+        let (dma, prev_packet, tx) = self.tx.take().unwrap().wait();
+        let packet = interrupt::free(|cs| {
+            self.out_buffer.read_finished(prev_packet, cs);
+            self.out_buffer.borrow_read(cs).unwrap()
+        });
+        self.tx = Some(SingleBufferingConfig::new(dma, packet, tx).start());
+    }
+}

src/main.rs

@@ -0,0 +1,278 @@
+#![no_std]
+#![no_main]
+
+//use panic_halt as _;
+use cortex_m::interrupt::CriticalSection;
+use panic_semihosting as _;
+use rp2040_hal::pac::UART0;
+use rp2040_hal::uart;
+
+mod audio_buffer;
+mod i2s_master;
+mod usb;
+mod usb_audio;
+
+#[link_section = ".boot2"]
+#[used]
+pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER;
+
+/*pub fn uart<'cs>(cs: &'cs CriticalSection) -> &'cs mut uart::UartPeripheral<uart::Enabled, UART0> {
+    use panic_write::PanicHandler;
+
+    unsafe {
+        let panic_handler = app::PANIC_HANDLER.borrow(cs).get();
+        let panic_handler_ref = core::mem::transmute::<
+            *mut Option<core::pin::Pin<PanicHandler<uart::UartPeripheral<uart::Enabled, UART0>>>>,
+            &mut Option<core::pin::Pin<PanicHandler<uart::UartPeripheral<uart::Enabled, UART0>>>>,
+        >(panic_handler);
+        panic_handler_ref.as_mut().unwrap()
+    }
+}*/
+
+#[rtic::app(device = rp2040_hal::pac, peripherals = true, dispatchers = [RTC_IRQ, XIP_IRQ])]
+mod app {
+    use embedded_hal::digital::v2::OutputPin;
+    use embedded_time::duration::Milliseconds;
+    use embedded_time::rate::{Extensions, Megahertz};
+    use rp2040_hal::clocks::ClocksManager;
+    use rp2040_hal::gpio;
+    //use rp2040_hal::pio::{PIOBuilder, PIOExt};
+    use crate::audio_buffer::AudioBuffer;
+    use crate::i2s_master::I2sMaster;
+    use crate::usb::Usb;
+    //use core::cell::UnsafeCell;
+    use core::fmt::Write;
+    use cortex_m::interrupt::{self, Mutex};
+    //use panic_write::PanicHandler;
+    use rp2040_hal::dma::{DMAExt, SingleChannel, CH0};
+    use rp2040_hal::gpio::bank0::{Gpio0, Gpio1, Gpio3, Gpio6};
+    use rp2040_hal::gpio::{Function, FunctionUart, Pin, Pio0};
+    use rp2040_hal::pac::UART0;
+    use rp2040_hal::pio::{PIOExt, PIO0SM0};
+    use rp2040_hal::pll::common_configs::PLL_USB_48MHZ;
+    use rp2040_hal::pll::{setup_pll_blocking, PLLConfig};
+    use rp2040_hal::sio::Sio;
+    use rp2040_hal::timer::Timer;
+    //use rp2040_hal::uart;
+    use rp2040_hal::usb::UsbBus;
+    use rp2040_hal::watchdog::Watchdog;
+    use rp2040_hal::xosc::setup_xosc_blocking;
+    use systick_monotonic::Systick;
+    use usb_device::class_prelude::*;
+
+    const XOSC_CRYSTAL_FREQ: u32 = 12_000_000;
+    pub const PLL_SYS_86MHZ: PLLConfig<Megahertz> = PLLConfig {
+        vco_freq: Megahertz(1032),
+        refdiv: 1,
+        post_div1: 6,
+        post_div2: 2,
+    };
+
+    static AUDIO_BUFFER: AudioBuffer<4> = AudioBuffer::new();
+    /*pub static UART: Mutex<
+        MaybeUninit<Option<&'static mut uart::UartPeripheral<uart::Enabled, UART0>>>,
+    > = Mutex::new(UnsafeCell::new(None));*/
+    /*pub static mut PANIC_HANDLER: Mutex<
+        UnsafeCell<
+            Option<core::pin::Pin<PanicHandler<uart::UartPeripheral<uart::Enabled, UART0>>>>,
+        >,
+    > = Mutex::new(UnsafeCell::new(None));*/
+
+    #[monotonic(binds = SysTick, default = true)]
+    type SystickMono = Systick<100>;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        led: gpio::Pin<gpio::pin::bank0::Gpio25, gpio::PushPullOutput>,
+        i2s: I2sMaster<
+            PIO0SM0,
+            CH0,
+            Pin<Gpio0, Function<Pio0>>,
+            Pin<Gpio1, Function<Pio0>>,
+            Pin<Gpio6, Function<Pio0>>,
+            Pin<Gpio3, Function<Pio0>>,
+        >,
+        usb: Usb,
+    }
+
+    #[init]
+    fn init(c: init::Context) -> (Shared, Local, init::Monotonics) {
+        let mut resets = c.device.RESETS;
+
+        // The timer needs a 1MHz input from the watchdog.
+        let mut watchdog = Watchdog::new(c.device.WATCHDOG);
+        watchdog.enable_tick_generation((XOSC_CRYSTAL_FREQ / 1000000) as u8);
+
+        // We let an LED blink to show that the system is still alive.
+        let sio = Sio::new(c.device.SIO);
+        let pins = gpio::Pins::new(
+            c.device.IO_BANK0,
+            c.device.PADS_BANK0,
+            sio.gpio_bank0,
+            &mut resets,
+        );
+
+        // We select a 86 MHz system clock as that lets us generate a clean and precise 12.288 MHz
+        // master clock by dividing the system clock by 7.
+        // TODO: Select 123 MHz instead (0.1% deviation, whereas 86 MHz results in 0.02%
+        // deviation), or look for an even better frequency that is not a multiple of 1MHz.
+        let mut clocks = ClocksManager::new(c.device.CLOCKS);
+        let xosc = setup_xosc_blocking(c.device.XOSC, XOSC_CRYSTAL_FREQ.Hz())
+            .ok()
+            .unwrap();
+        let pll_sys = setup_pll_blocking(
+            c.device.PLL_SYS,
+            xosc.operating_frequency().into(),
+            PLL_SYS_86MHZ,
+            &mut clocks,
+            &mut resets,
+        )
+        .ok()
+        .unwrap();
+        let pll_usb = setup_pll_blocking(
+            c.device.PLL_USB,
+            xosc.operating_frequency().into(),
+            PLL_USB_48MHZ,
+            &mut clocks,
+            &mut resets,
+        )
+        .ok()
+        .unwrap();
+        let _clocks = clocks.init_default(&xosc, &pll_sys, &pll_usb).ok().unwrap();
+
+        let mut led = pins.gpio25.into_push_pull_output();
+        led.set_low().ok().unwrap();
+
+        /*// We need a UART to debug panics.
+        let mut uart = uart::UartPeripheral::<_, _>::enable(
+            c.device.UART0,
+            &mut resets,
+            uart::common_configs::_115200_8_N_1,
+            clocks.peripheral_clock.into(),
+        )
+        .unwrap();
+        let _tx_pin = pins.gpio16.into_mode::<FunctionUart>();
+        let _rx_pin = pins.gpio17.into_mode::<FunctionUart>();
+        writeln!(&mut uart, "Initializing...\r").unwrap();
+        interrupt::free(|cs| unsafe {
+            let panic_handler = PANIC_HANDLER.borrow(cs);
+            *panic_handler.get() = Some(PanicHandler::new(uart));
+            writeln!(super::uart(cs), "Panic handler installed.\r").unwrap();
+        });*/
+
+        // We need a timer so that we can determine the USB SOF frequency for asynchronous USB
+        // audio.
+        let timer = Timer::new(c.device.TIMER, &mut resets);
+
+        // We initialize the output audio buffers with some data. As the I2S input buffers are
+        // filled at the same rate as the I2S output buffers, this initial state ensures that the
+        // output buffers never run empty (note that the USB audio interface performs its own
+        // adaptive synchronization).
+        interrupt::free(|cs| {
+            let write = AUDIO_BUFFER.write();
+            for _ in 0..2 {
+                let mut packet = write.borrow_write(cs).unwrap();
+                let data = packet.as_mut();
+                for i in 0..data.len() {
+                    //data[i] = 0x80000000; // "0"
+                    data[i] = 0xa5a5aa55;
+                }
+                write.write_finished(packet, cs);
+            }
+        });
+
+        // Configure USB audio.
+        static mut USB_BUS: Option<UsbBusAllocator<UsbBus>> = None;
+        unsafe {
+            USB_BUS = Some(UsbBusAllocator::new(UsbBus::new(
+                c.device.USBCTRL_REGS,
+                c.device.USBCTRL_DPRAM,
+                clocks.usb_clock,
+                true,
+                &mut resets,
+            )))
+        };
+
+        let usb = Usb::init(
+            unsafe { USB_BUS.as_ref().unwrap() },
+            AUDIO_BUFFER.write(),
+            timer,
+        );
+
+        // Configure the PIO unit and start I2S.
+        let mut dma = c.device.DMA.split(&mut resets);
+        let (mut pio, sm0, _sm1, _sm2, _sm3) = c.device.PIO0.split(&mut resets);
+        dma.ch0.listen_irq0();
+        let i2s = I2sMaster::init(
+            &mut pio,
+            sm0,
+            dma.ch0,
+            AUDIO_BUFFER.read(),
+            pins.gpio0.into_mode(),
+            pins.gpio1.into_mode(),
+            pins.gpio6.into_mode(),
+            pins.gpio3.into_mode(),
+        );
+
+        // A speaker amplifier (TAS5760) is connected to I2S - we need to configure it via I2C.
+        // TODO
+        // TODO: I2C stuff should happen in a low-priority task as we do not want to make data
+        // streaming to I2S wait.
+
+        let systick = c.core.SYST;
+        let mono = Systick::new(systick, 86_000_000);
+        blink::spawn().ok().unwrap();
+        (Shared {}, Local { led, i2s, usb }, init::Monotonics(mono))
+    }
+
+    #[task(shared = [], local = [led, state: bool = false])]
+    fn blink(ctx: blink::Context) {
+        blink::spawn_after(Milliseconds(500_u32)).ok().unwrap();
+        *ctx.local.state = !*ctx.local.state;
+        if *ctx.local.state {
+            ctx.local.led.set_high().ok().unwrap();
+        } else {
+            ctx.local.led.set_low().ok().unwrap();
+        }
+    }
+
+    /*/// DMA interrupt handler.
+    ///
+    /// DMA interrupts need to have highest priority as we need to quickly restart the DMA transfer
+    /// to ensure that the PIO FIFO always contains data.
+    #[task(binds = DMA_IRQ_0, priority = 3, local = [i2s])]
+    fn dma(ctx: dma::Context) {
+        ctx.local.i2s.next_packet();
+        process_buffers::spawn().unwrap();
+    }
+
+    #[task]
+    fn process_buffers(_: process_buffers::Context) {
+        interrupt::free(|cs| {
+            // If we have run out of data from USB, insert a packet filled with zeros.
+            // TODO
+
+            let write = AUDIO_BUFFER.write();
+            let mut packet = write.borrow_write(cs).unwrap();
+            let data = packet.as_mut();
+            for i in 0..data.len() {
+                //data[i] = 0x80000000; // "0"
+                data[i] = 0xa5a5aa55;
+            }
+            write.write_finished(packet, cs);
+        });
+    }*/
+
+    /// USB interrupt handler.
+    ///
+    /// USB interrupts have a high priority (albeit not as high as DMA) so that we can precisely
+    /// measure the SOF frequency relative to our system clock. The frequency ratio is required for
+    /// asynchronous USB audio.
+    #[task(binds = USBCTRL_IRQ, priority = 2, local = [usb])]
+    fn usb(ctx: usb::Context) {
+        ctx.local.usb.poll();
+    }
+}

src/usb.rs

@@ -0,0 +1,66 @@
+use crate::audio_buffer::{WriteBuffer, WritePacket};
+use crate::usb_audio::UsbAudioClass;
+use rp2040_hal::pac::USBCTRL_REGS;
+use rp2040_hal::timer::Timer;
+use rp2040_hal::usb::UsbBus;
+use usb_device::{class_prelude::*, prelude::*};
+
+pub struct Usb {
+    usb_audio: UsbAudioClass<'static, UsbBus, WritePacket<4>>,
+    usb_dev: UsbDevice<'static, UsbBus>,
+    in_buffer: WriteBuffer<4>,
+
+    timer: Timer,
+}
+
+impl Usb {
+    pub fn init(
+        bus: &'static UsbBusAllocator<UsbBus>,
+        in_buffer: WriteBuffer<4>,
+        timer: Timer,
+    ) -> Usb {
+        let usb_audio = UsbAudioClass::new(bus);
+
+        // This PID/VID combination is selected from the pid.codes PID space and only intended for
+        // software development. It is not universally unique and should not be used outside of
+        // test environments!
+        let usb_dev = UsbDeviceBuilder::new(bus, UsbVidPid(0x1209, 0x000d))
+            .manufacturer("TEST")
+            .product("USB audio test")
+            .serial_number("TEST")
+            .build();
+
+        // TODO
+        Usb {
+            usb_audio,
+            usb_dev,
+            in_buffer,
+            timer,
+        }
+    }
+
+    pub fn poll(&mut self) {
+        // Safety: The read access does not have any side effect, and this function is the only one
+        // using the USB peripheral at this time.
+        let sof = unsafe { (&*USBCTRL_REGS::ptr()).intr.read().dev_sof().bit_is_set() };
+        if sof {
+            // Clear the SOF IRQ.
+            unsafe { (&*USBCTRL_REGS::ptr()).sof_rd.read() };
+
+            // Calculate the frequency difference (frames versus 1kHz derived from the system
+            // clock) and update the synchronization data for the USB audio class accordingly.
+            // Also, add a correction factor if the buffers are running low or high.
+            // TODO
+
+            /*let mut buffer = [0u8; 64];
+            for i in 0..64 {
+                buffer[i] = i as u8 * 4;
+            }
+            let _err = self.usb_audio.write_packet(&buffer);*/
+        }
+        if self.usb_dev.poll(&mut [&mut self.usb_audio]) {
+            // If we received audio data, move it into the buffer.
+            // TODO
+        }
+    }
+}

src/usb_audio.rs

@@ -0,0 +1,576 @@
+//! USB audio class for asynchronous, bidirectional (microphone + speakers) 48kHz audio.
+//!
+//! See "Universal Serial Bus Device Class Definition for Audio Devices", release 1.0 (March 18,
+//! 1998) for a specification of the USB audio class.
+use cortex_m::interrupt;
+use usb_device::class_prelude::*;
+use usb_device::endpoint::{IsochronousSynchronizationType, IsochronousUsageType};
+use usb_device::Result;
+
+const DEVICE_CLASS_AUDIO: u8 = 0x01;
+const AUDIO_SUBCLASS_CONTROL: u8 = 0x01;
+const AUDIO_SUBCLASS_STREAMING: u8 = 0x02;
+const AUDIO_PROTOCOL_NONE: u8 = 0x00;
+
+const AUDIO_INTERFACE_DESC_TYPE: u8 = 0x24;
+const AUDIO_ENDPOINT_DESC_TYPE: u8 = 0x25;
+
+const AUDIO_CONTROL_HEADER: u8 = 0x01;
+const AUDIO_CONTROL_INPUT_TERMINAL: u8 = 0x02;
+const AUDIO_CONTROL_OUTPUT_TERMINAL: u8 = 0x03;
+const AUDIO_CONTROL_FEATURE_UNIT: u8 = 0x06;
+
+const AUDIO_STREAMING_GENERAL: u8 = 0x01;
+const AUDIO_STREAMING_FORMAT_TYPE: u8 = 0x02;
+
+const AUDIO_ENDPOINT_GENERAL: u8 = 0x01;
+
+// TODO: Update bDelay.
+
+pub struct UsbAudioClass<'a, B: UsbBus, OUTBUF: AsRef<[u32]>> {
+    audio_control: InterfaceNumber,
+    audio_streaming_inactive: InterfaceNumber,
+    audio_streaming: InterfaceNumber,
+    audio_out: EndpointOut<'a, B>,
+    //audio_out_sync: EndpointIn<'a, B>,
+    //audio_in: EndpointIn<'a, B>,
+    samples_per_frame: [u8; 3],
+
+    audio_out_buf: Option<OUTBUF>,
+}
+
+impl<'a, B: UsbBus, OUTBUF: AsRef<[u32]>> UsbAudioClass<'a, B, OUTBUF> {
+    pub fn new(bus_alloc: &'a UsbBusAllocator<B>) -> Self {
+        UsbAudioClass {
+            audio_control: bus_alloc.interface(),
+            audio_streaming_inactive: bus_alloc.interface(),
+            audio_streaming: bus_alloc.interface(),
+            // 48kHz * 2 * 16bit = 192B per packet. We allocate a bit more in case the device clock
+            // is faster than the host clock.
+            /*audio_out: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Asynchronous,
+                IsochronousUsageType::Data,
+                256,
+                1,
+            ),*/
+            audio_out: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Synchronous,
+                IsochronousUsageType::Data,
+                256,
+                1,
+            ),
+            /*audio_out_sync: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Asynchronous,
+                IsochronousUsageType::Feedback,
+                3,
+                1,
+            ),*/
+            /*audio_in: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Asynchronous,
+                IsochronousUsageType::Data,
+                256,
+                1,
+            ),*/
+            samples_per_frame: [48 >> 2, 48 << 6, 0], // 48 kHz
+            audio_out_buf: None,
+        }
+    }
+
+    // TODO: Functions to read and write data?
+}
+
+impl<B: UsbBus, OUTBUF: AsRef<[u32]>> UsbClass<B> for UsbAudioClass<'_, B, OUTBUF> {
+    fn get_configuration_descriptors(&self, writer: &mut DescriptorWriter) -> Result<()> {
+        /*interrupt::free(|cs| {
+            writeln!(crate::uart(cs), "A\r").unwrap();
+        });*/
+        writer.iad(
+            self.audio_control,
+            2,   // Two interfaces (control + streaming).
+            0x0, // Each interface specifies its own class.
+            0x0, // Each interface specifies its own subclass.
+            0x0, // No class-specific protocols for this device.
+        )?;
+
+        // Audio control interface.
+        writer.interface(
+            self.audio_control,
+            DEVICE_CLASS_AUDIO,
+            AUDIO_SUBCLASS_CONTROL,
+            AUDIO_PROTOCOL_NONE,
+        )?;
+
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_HEADER,        // bDescriptorSubtype
+                0x00,                        // bcdADC
+                0x01,                        //
+                37,                          // wTotalLength
+                0,                           //
+                0x01,                        // bInCollection
+                self.audio_streaming.into(), // baInterfaceNr
+            ],
+        )?;
+
+        // Input terminal (USB streaming).
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_INPUT_TERMINAL, // bDescriptorSubtype
+                0x01,                         // bTerminalID
+                0x01,                         // wTerminalType
+                0x01,                         //
+                0x00,                         // bAssocTerminal
+                0x02,                         // bNrChannels
+                0x03,                         // wChannelConfig
+                0x00,                         //
+                0x00,                         // iChannelNames
+                0x00,                         // iTerminal
+            ],
+        )?;
+
+        // Feature unit (volume and mute).
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_FEATURE_UNIT, // bDescriptorSubtype
+                0x02,                       // bUnitID
+                0x01,                       // bSourceID
+                0x01,                       // bControlSize
+                0x03,                       // bmaControls(0)
+                0x00,                       // iFeature
+            ],
+        )?;
+
+        // Output terminal (speaker).
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_OUTPUT_TERMINAL, // bDescriptorSubtype
+                0x03,                          // bTerminalID
+                0x01,                          // wTerminalType
+                0x03,                          //
+                0x00,                          // bAssocTerminal
+                0x02,                          // bSourceID
+                0x00,                          // iTerminal
+            ],
+        )?;
+
+        // Audio streaming interface (zero-bandwidth).
+        writer.interface(
+            self.audio_streaming_inactive,
+            DEVICE_CLASS_AUDIO,
+            AUDIO_SUBCLASS_STREAMING,
+            AUDIO_PROTOCOL_NONE,
+        )?;
+
+        // Audio streaming interface (operational).
+        writer.interface_alt(
+            self.audio_streaming,
+            1,
+            DEVICE_CLASS_AUDIO,
+            AUDIO_SUBCLASS_STREAMING,
+            AUDIO_PROTOCOL_NONE,
+            None,
+        )?;
+
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_STREAMING_GENERAL, // bDescriptorSubtype
+                0x01,                    // bTerminalLink
+                0x03,                    // bDelay
+                0x01,                    // wFormatTag
+                0x00,                    //
+            ],
+        )?;
+
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_STREAMING_FORMAT_TYPE, // bDescriptorSubtype
+                0x01,                        // bFormatType
+                0x02,                        // bNrChannels
+                0x02,                        // bSubframeSize
+                0x10,                        // bBitResolution
+                0x01,                        // bSamFreqType
+            ],
+        )?;
+
+        /*writer.endpoint_ex(&self.audio_out, |data| {
+            // TODO: Faster refresh
+            data[0] = 0x09; // bRefresh
+            data[1] = self.audio_out_sync.address().into(); // bSynchAddress
+            Ok(2)
+        })?;*/
+        writer.endpoint(&self.audio_out)?;
+
+        writer.write(
+            AUDIO_ENDPOINT_DESC_TYPE,
+            &[
+                AUDIO_ENDPOINT_GENERAL, // bDescriptorSubtype
+                0x00,                   // bmAttributes
+                0x01,                   // bLockDelayUnits
+                0x00,                   // wLockDelay
+                0x00,
+            ],
+        )?;
+
+        /*writer.endpoint_ex(&self.audio_out_sync, |data| {
+            data[0] = 0x00; // bRefresh
+            data[1] = 0x00; // bSynchAddress
+            Ok(2)
+        })?;*/
+
+        /*interrupt::free(|cs| {
+            writeln!(crate::uart(cs), "B\r").unwrap();
+        });*/
+
+        Ok(())
+    }
+
+    fn get_string(&self, _index: StringIndex, _lang_id: u16) -> Option<&str> {
+        // TODO
+        None
+    }
+
+    fn reset(&mut self) {
+        // Start sending synchronization data.
+        //self.endpoint_in_complete(self.audio_out_sync.address());
+    }
+
+    fn control_out(&mut self, xfer: ControlOut<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control) as u16)
+        {
+            return;
+        }
+
+        match req.request {
+            // TODO
+            _ => {
+                xfer.reject().ok();
+            }
+        };
+    }
+
+    fn control_in(&mut self, xfer: ControlIn<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control) as u16)
+        {
+            return;
+        }
+
+        match req.request {
+            // TODO
+            _ => {
+                xfer.reject().ok();
+            }
+        };
+    }
+
+    /*fn endpoint_out(&mut self, addr: EndpointAddress) {
+        if addr == self.audio_out.address() {
+            if self.audio_out_buf.is_some() {
+                // TODO: Write data into buffer, move buffer somewhere else.
+            } else {
+                // TODO
+            }
+            // TODO: Process incoming audio data.
+            let mut buffer = [0u8; 256];
+            self.audio_out.read(&mut buffer);
+        }
+    }
+
+    fn endpoint_in_complete(&mut self, addr: EndpointAddress) {
+        if addr == self.audio_out_sync.address() {
+            // Immediately write the next sync value.
+            //self.audio_out_sync.write(&self.samples_per_frame).unwrap();
+        }
+    }*/
+}
+
+/*use usb_device::class_prelude::*;
+use usb_device::endpoint::{IsochronousSynchronizationType, IsochronousUsageType};
+use usb_device::Result;
+
+/// This should be used as `device_class` when building the `UsbDevice`.
+pub const USB_INTERFACE_CLASS_AUDIO: u8 = 0x01;
+
+const USB_AUDIO_SUBCLASS_UNDEFINED: u8 = 0x0;
+const USB_AUDIO_SUBCLASS_AUDIOCONTROL: u8 = 0x01;
+const USB_AUDIO_SUBCLASS_AUDIOSTREAMING: u8 = 0x02;
+const USB_AUDIO_SUBCLASS_MIDISTREAMING: u8 = 0x03;
+
+const USB_CLASS_CDC_DATA: u8 = 0x0a;
+const CDC_SUBCLASS_ACM: u8 = 0x02;
+const USB_AUDIO_PROTOCOL_NONE: u8 = 0x00;
+
+const CS_DEVICE: u8 = 0x21;
+const CS_CONFIGURATION: u8 = 0x22;
+const CS_STRING: u8 = 0x23;
+const CS_INTERFACE: u8 = 0x24;
+const CS_ENDPOINT: u8 = 0x25;
+
+const EP_GENERAL: u8 = 0x1;
+
+const AC_DESC_TYPE_HEADER: u8 = 0x1;
+const AC_DESC_TYPE_INPUT_TERMINAL: u8 = 0x2;
+const AC_DESC_TYPE_OUTPUT_TERMINAL: u8 = 0x3;
+const AC_DESC_TYPE_MIXER_UNIT: u8 = 0x4;
+const AC_DESC_TYPE_SELECTOR_UNIT: u8 = 0x5;
+const AC_DESC_TYPE_FEATURE_UNIT: u8 = 0x6;
+const AC_DESC_TYPE_PROCESSING_UNIT: u8 = 0x7;
+const AC_DESC_TYPE_EXTENSION_UNIT: u8 = 0x8;
+
+const AC_DESC_ST_GENERAL: u8 = 0x1;
+const AC_DESC_ST_FORMAT_TYPE: u8 = 0x2;
+const AC_DESC_ST_FORMAT_SPECIFIC: u8 = 0x3;
+
+const AUDIO_SUB_TYPE_HEADER: u8 = 0x01;
+const AUDIO_SUB_TYPE_INPUT_TERMINAL: u8 = 0x02;
+const AUDIO_SUB_TYPE_FEATURE_UNIT: u8 = 0x06;
+const AUDIO_SUB_TYPE_OUTPUT_TERMINAL: u8 = 0x03;
+const AUDIO_SUB_TYPE_AS_GENERAL: u8 = 0x01;
+const AUDIO_SUB_TYPE_FORMAT_TYPE: u8 = 0x02;
+
+pub struct UsbAudioClass<'a, B: UsbBus> {
+    audio_control_if: InterfaceNumber,
+    audio_stream: InterfaceNumber,
+    alt_audio_stream: InterfaceNumber,
+    audio_in_ep: EndpointIn<'a, B>,
+}
+
+impl<B: UsbBus> UsbAudioClass<'_, B> {
+    /// Creates a new UsbAudioClass with the provided UsbBus and max_packet_size in bytes. For
+    /// full-speed devices, max_packet_size has to be one of 8, 16, 32 or 64.
+    pub fn new(alloc: &UsbBusAllocator<B>, max_packet_size: u16) -> UsbAudioClass<'_, B> {
+        UsbAudioClass {
+            audio_control_if: alloc.interface(),
+            audio_stream: alloc.interface(),
+            alt_audio_stream: alloc.interface(),
+            audio_in_ep: alloc.isochronous(
+                IsochronousSynchronizationType::Synchronous,
+                IsochronousUsageType::Data,
+                max_packet_size,
+                4,
+            ),
+        }
+    }
+
+    /// Gets the maximum packet size in bytes.
+    pub fn max_packet_size(&self) -> u16 {
+        self.audio_in_ep.max_packet_size()
+    }
+
+    /// Writes a single packet into the IN endpoint.
+    pub fn write_packet(&mut self, data: &[u8]) -> Result<usize> {
+        //defmt::info!("write_packet");
+        self.audio_in_ep.write(data)
+    }
+
+    /// Gets the address of the IN endpoint.
+    pub(crate) fn write_ep_address(&self) -> EndpointAddress {
+        self.audio_in_ep.address()
+    }
+}
+
+impl<B: UsbBus> UsbClass<B> for UsbAudioClass<'_, B> {
+    fn get_configuration_descriptors(&self, writer: &mut DescriptorWriter) -> Result<()> {
+        writer.iad(
+            self.audio_control_if,
+            3,
+            0x0, // device defined at interface level
+            0x0, // subclass unused
+            USB_AUDIO_PROTOCOL_NONE,
+        )?;
+
+        writer.interface(
+            self.audio_control_if,
+            USB_INTERFACE_CLASS_AUDIO,
+            USB_AUDIO_SUBCLASS_AUDIOCONTROL,
+            USB_AUDIO_PROTOCOL_NONE,
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_HEADER, // bDescriptorSubtype
+                0x00,
+                0x1, // bcdADC (1.0),
+                43,
+                0,    // wTotalLength (Compute this!)
+                0x01, // bInCollection (1 streaming interface)
+                0x01, // baInterfaceNr (Interface 1 is stream)
+            ],
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_INPUT_TERMINAL, // bDescriptorSubtype
+                0x01,                          // bTerminalID 1,
+                0x10,
+                0x07, // wTerminalType (radio receiver)
+                0x00, // bAssocTerminal (none)
+                0x02, // bNrChannels - 2 for I and Q
+                0x03,
+                0x00, // wChannelConfig (left, right)
+                0x00, // iChannelNames (none)
+                0x00, // iTerminal (none)
+            ],
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_FEATURE_UNIT, // bDescriptorSubtype
+                0x02,                        // bUnitID,
+                0x01,                        // bSourceID (input terminal 1)
+                0x02,                        // bControlSize (2 bytes)
+                0x01,
+                0x00, // Master controls
+                0x00,
+                0x00, // Channel 0 controls
+                0x00,
+                0x00, // Channel 1 controls
+                0x00, // iFeature (none)
+            ],
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_OUTPUT_TERMINAL, // bDescriptorSubtype
+                0x03,                           // bTerminalID,
+                0x01,
+                0x01, // wTerminalType (USB Streaming)
+                0x00, // bAssocTerminal (none)
+                0x02, // bSourceID (feature unit 2)
+                0x00, // iTerminal (none)
+            ],
+        )?;
+
+        writer.interface(
+            self.audio_stream,
+            USB_INTERFACE_CLASS_AUDIO,
+            USB_AUDIO_SUBCLASS_AUDIOSTREAMING,
+            USB_AUDIO_PROTOCOL_NONE,
+        )?;
+
+        //alternate audio stream
+        /*writer.interface_alt(
+            self.alt_audio_stream,
+            1,
+            USB_INTERFACE_CLASS_AUDIO,
+            USB_AUDIO_SUBCLASS_AUDIOSTREAMING,
+            USB_AUDIO_PROTOCOL_NONE,
+            None,
+        )?;*/
+
+        // Audio Stream Audio Class Descriptor
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_AS_GENERAL, // bDescriptorSubtype
+                0x03,                      // bTerminalID,
+                0x00,                      // bDelay
+                0x01,
+                0x00, // wFormatTag (PCM Format)
+            ],
+        )?;
+
+        // Format Type Audio Descriptor
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_FORMAT_TYPE, // bDescriptorSubtype
+                0x01,                       // bFormatType (TYPE_I)
+                0x02,                       // bNrChannels (2)
+                0x02,                       // bSubFrameSize (2)
+                0x10,                       // bBitResolution (16 bits)
+                0x01,                       // bSamFreqType (1 sample frequency)
+                0x80,                       // 8*2 = 16 KHz byte 0
+                0x3E,                       // 8*2 = 16 KHz byte 1
+                0x00,                       // 8*2 = 16 KHz byte 2
+            ],
+        )?;
+
+        // TODO: Set the necessary flags for Isochronous
+        writer.endpoint(&self.audio_in_ep)?;
+
+        // Isochronous endpoint Audio Class descriptor
+        writer.write(
+            CS_ENDPOINT,
+            &[
+                EP_GENERAL, // bDescriptorSubtype
+                0x00,       // bmAttributes (none)
+                0x02,       // bLockDelayUnits (PCM Samples)
+                0x00, 0x00, // wLockDelay (0)  - should be zero for asynchronous
+            ],
+        )?;
+        Ok(())
+    }
+
+    fn reset(&mut self) {}
+
+    fn control_in(&mut self, xfer: ControlIn<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control_if) as u16)
+        {
+            return;
+        }
+
+        //defmt::info!("control_in - req : {:?}", req.request);
+        match req.request {
+            /*
+            REQ_GET_LINE_CODING if req.length == 7 => {
+                xfer.accept(|data| {
+                    data[0..4].copy_from_slice(&self.line_coding.data_rate.to_le_bytes());
+                    data[4] = self.line_coding.stop_bits as u8;
+                    data[5] = self.line_coding.parity_type as u8;
+                    data[6] = self.line_coding.data_bits;
+
+                    Ok(7)
+                }).ok();
+            },
+            */
+            _ => {
+                xfer.reject().ok();
+            }
+        }
+    }
+
+    fn control_out(&mut self, xfer: ControlOut<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control_if) as u16)
+        {
+            return;
+        }
+
+        match req.request {
+            /*
+            REQ_SEND_ENCAPSULATED_COMMAND => {
+                // We don't actually support encapsulated commands but pretend we do for standards
+                // compatibility.
+                xfer.accept().ok();
+            },*/
+            _ => {
+                xfer.reject().ok();
+            }
+        };
+    }
+}*/