Cargo.lock

@@ -586,6 +586,7 @@ checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
 [[package]]
 name = "pio"
 version = "0.1.0"
+source = "git+https://github.com/rp-rs/pio-rs.git?branch=main#8c12d426685ac23cac975341e728fc0a50ebfd6c"
 dependencies = [
  "arrayvec",
  "num_enum",
@@ -595,6 +596,7 @@ dependencies = [
 [[package]]
 name = "pio-parser"
 version = "0.1.0"
+source = "git+https://github.com/rp-rs/pio-rs.git?branch=main#8c12d426685ac23cac975341e728fc0a50ebfd6c"
 dependencies = [
  "lalrpop",
  "lalrpop-util",
@@ -604,6 +606,7 @@ dependencies = [
 [[package]]
 name = "pio-proc"
 version = "0.1.0"
+source = "git+https://github.com/rp-rs/pio-rs.git?branch=main#8c12d426685ac23cac975341e728fc0a50ebfd6c"
 dependencies = [
  "codespan-reporting",
  "lalrpop-util",

Cargo.toml

@@ -14,14 +14,14 @@ embedded-hal ="0.2.5"
 embedded-time = "0.12.0"
 nb = "1.0"
 panic-halt = "0.2.0"
-pio = { path = "../pio-rs" }
-pio-proc = { path = "../pio-rs/pio-proc" }
+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= "0.2.8"
+usb-device = { version = "0.2.8", features = ["control-buffer-256"] }
 void = { version = "*", default_features = false }
 
 [patch.crates-io]

src/usb.rs

@@ -1,4 +1,4 @@
-use crate::audio_buffer::WriteBuffer;
+use crate::audio_buffer::{WriteBuffer, WritePacket};
 use crate::usb_audio::UsbAudioClass;
 use rp2040_hal::pac::USBCTRL_REGS;
 use rp2040_hal::timer::Timer;
@@ -6,9 +6,11 @@ use rp2040_hal::usb::UsbBus;
 use usb_device::{class_prelude::*, prelude::*};
 
 pub struct Usb {
-    usb_audio: UsbAudioClass<'static, UsbBus>,
+    usb_audio: UsbAudioClass<'static, UsbBus, WritePacket<4>>,
     usb_dev: UsbDevice<'static, UsbBus>,
     in_buffer: WriteBuffer<4>,
+
+    timer: Timer,
 }
 
 impl Usb {
@@ -17,7 +19,7 @@ impl Usb {
         in_buffer: WriteBuffer<4>,
         timer: Timer,
     ) -> Usb {
-        let usb_audio = UsbAudioClass::new(bus, 64);
+        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
@@ -33,6 +35,7 @@ impl Usb {
             usb_audio,
             usb_dev,
             in_buffer,
+            timer,
         }
     }
 
@@ -41,13 +44,19 @@ impl Usb {
         // using the USB peripheral at this time.
         let sof = unsafe { (&*USBCTRL_REGS::ptr()).intr.read().dev_sof().bit_is_set() };
         if sof {
-            let mut buffer = [0u8; 64];
+            // 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);
+            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

@@ -3,12 +3,290 @@
 //! 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 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, BUS: UsbBus> {
+pub struct UsbAudioClass<'a, B: UsbBus, OUTBUF: AsRef<[u32]>> {
     audio_control: InterfaceNumber,
+    audio_streaming_inactive: InterfaceNumber,
     audio_streaming: InterfaceNumber,
-    audio_streaming: InterfaceNumber,
-    // TODO
+    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<()> {
+        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)
+        })?;*/
+
+        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::*;