Add usb-device support to arduino-micro

Fixes #40.

When using `usb-device`, there are three main components to be aware of:

* For `avr-hal`, the main thing we care about is `UsbBus`. This trait is
  a hardware abstraction layer for the actual USB hardware. We implement
  this trait in `mcu/atmega-hal/src/usb.rs`.

* The `UsbClass` trait is used to implement support for each different
  type of USB device (e.g. speaker, keyboard, or serial port). These
  implementations are portable, so we can just use existing
  implementations from other crates. For `micro-usb-serial.rs`, we
  create a serial port using `usbd-serial`'s implementation of
  `UsbClass`.

  `usbd-serial` was chosen simply because it is the only serial class
  implementation that is mentioned in `usb-device`'s readme file.

* `UsbDevice` is used by our users (and our example code) to actually
  configure the USB device. Basically, to create `UsbDevice` the user just
  needs to combine our `UsbBus` implementation with the list of
  `UsbClass`es that they want to use.

Author: Ivan-Johnson

.gitmodules

@@ -190,6 +190,26 @@ pub mod eeprom {
 #[cfg(feature = "board-selected")]
 pub use eeprom::Eeprom;
 
+#[doc(no_inline)]
+#[cfg(any(
+    feature = "arduino-micro",
+    feature = "arduino-leonardo",
+    feature = "sparkfun-promicro"
+))]
+pub use atmega_hal::default_usb_bus_with_pll;
+
+#[cfg(any(
+    feature = "arduino-micro",
+    feature = "arduino-leonardo",
+    feature = "sparkfun-promicro"
+))]
+#[macro_export]
+macro_rules! default_usb_bus_with_pll_macro {
+    ($p:expr) => {
+        $crate::default_usb_bus_with_pll::<$crate::DefaultClock>($p.USB_DEVICE, $p.PLL)
+    };
+}
+
 #[cfg(feature = "board-selected")]
 pub mod simple_pwm {
     #[cfg(feature = "mcu-atmega")]

arduino-hal/src/lib.rs

@@ -8,6 +8,8 @@ publish = false
 panic-halt = "1.0.0"
 ufmt = "0.2.0"
 nb = "1.1.0"
+usb-device = "0.3.2"
+usbd-serial = "0.2.2"
 
 [dependencies.arduino-hal]
 path = "../../arduino-hal/"

examples/arduino-micro/Cargo.toml

@@ -0,0 +1,75 @@
+#![no_std]
+#![no_main]
+use arduino_hal::prelude::*;
+use arduino_hal::Peripherals;
+use panic_halt as _;
+use usb_device::bus::UsbBusAllocator;
+use usb_device::device::StringDescriptors;
+use usb_device::device::UsbDeviceBuilder;
+use usb_device::device::UsbVidPid;
+use usb_device::LangID;
+use usbd_serial::SerialPort;
+
+#[arduino_hal::entry]
+fn main() -> ! {
+    let dp: Peripherals = Peripherals::take().unwrap();
+    let pins = arduino_hal::pins!(dp);
+    let mut serial_hw = arduino_hal::default_serial!(dp, pins, 57600);
+    ufmt::uwriteln!(&mut serial_hw, "Hello from Arduino!").unwrap_infallible();
+
+    let usb_bus = arduino_hal::default_usb_bus_with_pll_macro!(dp);
+    let usb_bus_allocator = UsbBusAllocator::new(usb_bus);
+
+    let mut serial_usb = SerialPort::new(&usb_bus_allocator);
+
+    let string_descriptors = StringDescriptors::new(LangID::EN_US)
+        .manufacturer("test manufacturer")
+        .product("test product")
+        .serial_number("test serial number");
+
+    let rand_ids = UsbVidPid(0x1ea7, 0x4a09);
+
+    let mut usb_dev = UsbDeviceBuilder::new(&usb_bus_allocator, rand_ids)
+        .strings(&[string_descriptors])
+        .unwrap()
+        .max_packet_size_0(64)
+        .unwrap()
+        .device_class(usbd_serial::USB_CLASS_CDC)
+        .build();
+
+    // TODO: only in dev builds
+    usb_dev.force_reset().unwrap();
+
+    loop {
+        // Wait until we have data
+        if !usb_dev.poll(&mut [&mut serial_usb]) {
+            continue;
+        }
+
+        // Read the data into this buffer
+        let mut read_buf = [0u8; 10];
+        let Ok(read_count) = serial_usb.read(&mut read_buf) else {
+            continue;
+        };
+        if read_count == 0 {
+            continue;
+        }
+
+        // Ideally we want to do something like this:
+        //
+        // ```
+        // let mut write_buf = [0u8; 20];
+        // let write_count = ufmt::uwriteln!(&mut write_buf, "Got: {}", &write_buf);
+        // ```
+        //
+        // TODO: Figure out how to get the above code to compile. It seems like
+        // I might need to manually implement the uDebug trait? That doesn't seem
+        // right... In the meantime, simply echo the string back
+
+        // TODO: is this `.expect()` safe?
+        let len = serial_usb
+            .write(&read_buf[0..read_count])
+            .expect("The host should be reading data faster than the arduino can write it");
+        assert_eq!(len, read_count);
+    }
+}

examples/arduino-micro/src/bin/micro-usb-serial.rs

@@ -21,7 +21,7 @@ atmega168 = ["avr-device/atmega168", "device-selected"]
 atmega328p = ["avr-device/atmega328p", "device-selected"]
 atmega328pb = ["avr-device/atmega328pb", "device-selected"]
 atmega32a = ["avr-device/atmega32a", "device-selected"]
-atmega32u4 = ["avr-device/atmega32u4", "device-selected"]
+atmega32u4 = ["avr-device/atmega32u4", "device-selected", "usb-device", "embedded-hal"]
 atmega2560 = ["avr-device/atmega2560", "device-selected"]
 atmega128a = ["avr-device/atmega128a", "device-selected"]
 atmega1280 = ["avr-device/atmega1280", "device-selected"]
@@ -37,6 +37,8 @@ docsrs = ["atmega328p"]
 
 [dependencies]
 avr-hal-generic = { path = "../../avr-hal-generic/" }
+embedded-hal = { version = "1.0", optional = true }
+usb-device = { version = "0.3.2", optional = true }
 
 [dependencies.avr-device]
 version = "0.8.1"

mcu/atmega-hal/Cargo.toml

@@ -1,4 +1,5 @@
 #![no_std]
+#![feature(asm_experimental_arch)]
 
 //! `atmega-hal`
 //! =============
@@ -119,6 +120,87 @@ pub use avr_hal_generic::clock;
 pub use avr_hal_generic::delay;
 pub use avr_hal_generic::prelude;
 
+#[cfg(feature = "atmega32u4")]
+mod usb;
+
+// TODO: fix bad usb-device::UsbBus link
+/// This function provides a safe abstraction layer over the USB hardware, by way of the
+/// [UsbBus](usb-device::UsbBus) trait.
+///
+/// There are a few notable limitations, however:
+///
+/// * This implementation requires exclusive access to the PLL, even though on a hardware
+///   level it is possible for the PLL output to be used by both the USB controller and
+///   the high-speed timer (TC4) simultaneously. Refer to GitHub issue #TBD for details.
+///
+///   TODO if Rahix agrees that this limitation isn't something we need to worry about
+///   as part of PR, then create a GitHub issue so that someone else can fix it later:
+///
+///   > **Title**
+///   >
+///   > Allow the USB and TC4 hardware to both use the PLL output simultaneously
+///   >
+///   > **Description**
+///   >
+///   > Our current UsbBus implementation prevents TC4 from using PLL output, even though
+///   > the hardware supports it. There are two main
+///   > problems that we need to solve first:
+///   >
+///   > 1. The current UsbBus implementation sets the PLL output to 48MHz. This could
+///   >    cause problems if the user has already configured TC4 to expect a different
+///   >    clock speed from the PLL.
+///   >
+///   > 2. We need to make the USB suspend state configurable. Currently when the USB
+///   >    bus is idle for 3ms or longer, it will disable the PLL to reduce power usage.
+///   >    However, this may not be desirable if TC4 is also using the PLL.
+///   >
+///   > **Comment**
+///   >
+///   > I think we *might* be able to solve this by splitting the constructor's
+///   > argument into two separate parts. Instead of passing ownership of the entire PLL
+///   > configuration (`pll: avr_device::atmega32u4::PLL`), we'd have one argument for
+///   > the registers that config the PLL clock speed (e.g. `pll_config: &PLLFRQ`) and one
+///   > optional argument for the registers that we use to turn the PLL on and off
+///   > (e.g. `pll_suspend: Option<&mut pllcsr>`). A value of `None` would indicate that
+///   > the user wants us to keep the PLL running while USB is idle.
+///   >
+///   > A few disclaimers:
+///   >
+///   > * This is a simplification. Instead of `pll_suspend: Option<&mut pllcsr>` we'd
+///   >   probably want to define a new trait,
+///   >   similar to what is done [in the `agausmann/atmega-usbd` repo](https://github.com/agausmann/atmega-usbd/blob/5fc68ca813ce0a37dab65dd4d66efe1ec125f2a8/src/lib.rs#L590-L618).
+///   >
+///   > * This is just one possible solution; there are others.
+///   >
+///   > * I've not spent much time investigating this, so this proposed solution might not work.
+///
+/// * The current implementation does not attempt to minimize power usage. For details,
+///   see GitHub issue #TBD.
+///
+///   TODO if Rahix agrees that this limitation isn't something we need to worry about
+///   as part of PR, then create a GitHub issue so that someone else can fix it later:
+///
+///   * Add support for using interrupts, in addition to polling.
+///     Similar to `agausmann/atmega-usbd`.
+///
+///   * Shutdown the PLL when the USB module is suspended (TODO: do in this PR?)
+///
+///   * and more?
+///
+/// * The underlying struct that implements `UsbBus` is private. This is done intentionally
+///   in order to make it easier to address the other issues without breaking backwards
+///   compatibility.
+#[cfg(feature = "atmega32u4")]
+pub fn default_usb_bus_with_pll<CLOCKUSB: ClockUSB>(
+    usb: avr_device::atmega32u4::USB_DEVICE,
+    pll: avr_device::atmega32u4::PLL,
+) -> impl usb_device::class_prelude::UsbBus
+where
+    avr_hal_generic::delay::Delay<CLOCKUSB>: embedded_hal::delay::DelayNs,
+{
+    return usb::UsbdBus::<CLOCKUSB>::new(usb, pll);
+}
+
 #[cfg(feature = "device-selected")]
 pub mod adc;
 #[cfg(feature = "device-selected")]
@@ -149,6 +231,8 @@ pub use usart::Usart;
 
 #[cfg(feature = "device-selected")]
 pub mod wdt;
+#[cfg(feature = "atmega32u4")]
+use usb::ClockUSB;
 #[cfg(feature = "device-selected")]
 pub use wdt::Wdt;