diff --git a/boards/feather_m0/Cargo.toml b/boards/feather_m0/Cargo.toml
index 81afb47d90b0..85819e374b0f 100644
--- a/boards/feather_m0/Cargo.toml
+++ b/boards/feather_m0/Cargo.toml
@@ -39,7 +39,7 @@ version = "0.3.1"
 
 [dependencies.embedded-sdmmc]
 optional = true
-version = "0.3"
+version = "0.9"
 
 [dev-dependencies]
 cortex-m = "0.7"
@@ -49,8 +49,9 @@ defmt-rtt = "0.4"
 drogue-nom-utils = "0.1"
 embassy-executor = {version = "0.6.2", features = ["arch-cortex-m", "executor-thread", "task-arena-size-64"]}
 embedded-graphics = "0.7.1"
+embedded-hal-bus = "0.3.0"
 heapless = "0.8"
-nom = {version = "5", default-features = false}
+nom = {version = "8", default-features = false}
 panic-halt = "0.2"
 panic-probe = "0.3"
 panic-semihosting = "0.6"
diff --git a/boards/feather_m0/examples/adalogger.rs b/boards/feather_m0/examples/adalogger.rs
index 13dfecc89df8..9681db89f5a0 100644
--- a/boards/feather_m0/examples/adalogger.rs
+++ b/boards/feather_m0/examples/adalogger.rs
@@ -1,17 +1,18 @@
 #![no_std]
 #![no_main]
+#![allow(static_mut_refs)]
 
 #[cfg(not(feature = "use_semihosting"))]
 use panic_halt as _;
 #[cfg(feature = "use_semihosting")]
 use panic_semihosting as _;
 
-use core::fmt::Write;
+use core::cell::OnceCell;
 use core::sync::atomic;
 
-use cortex_m::interrupt::free as disable_interrupts;
 use cortex_m::peripheral::NVIC;
-use embedded_sdmmc::{Controller, SdMmcSpi, VolumeIdx};
+use embedded_hal_bus::spi::ExclusiveDevice;
+use embedded_sdmmc::{SdCard, VolumeIdx, VolumeManager};
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
@@ -26,10 +27,9 @@ use hal::fugit::RateExtU32;
 use hal::pac::{interrupt, CorePeripherals, Peripherals};
 use hal::prelude::*;
 use hal::rtc;
+use hal::timer::TimerCounter;
 use hal::usb::UsbBus;
 
-use heapless::String;
-
 #[entry]
 fn main() -> ! {
     // setup basic peripherals
@@ -48,8 +48,21 @@ fn main() -> ! {
     let timer_clock = clocks
         .configure_gclk_divider_and_source(ClockGenId::Gclk3, 32, ClockSource::Osc32k, true)
         .unwrap();
+
+    // Setup timer clock from
+    let tc45 = &clocks.tc4_tc5(&timer_clock).unwrap();
+
+    // Setup a timer for the SPI driver delay source
+    let timer_spi = TimerCounter::tc4_(tc45, peripherals.tc4, &mut peripherals.pm);
+
+    // Setup a timer for the SPI driver delay source
+    let timer_sdcard = TimerCounter::tc5_(tc45, peripherals.tc5, &mut peripherals.pm);
+
+    // Setup the RTC for the SD card volume time source
     let rtc_clock = clocks.rtc(&timer_clock).unwrap();
-    let timer = rtc::Rtc::clock_mode(peripherals.rtc, rtc_clock.freq(), &mut peripherals.pm);
+    let rtc = rtc::Rtc::clock_mode(peripherals.rtc, rtc_clock.freq(), &mut peripherals.pm);
+
+    // Setup red led
     let pins = bsp::Pins::new(peripherals.port);
     let mut red_led: bsp::RedLed = pin_alias!(pins.red_led).into();
 
@@ -57,19 +70,19 @@ fn main() -> ! {
     delay.delay_ms(500_u32);
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             peripherals.usb,
             &mut clocks,
             &mut peripherals.pm,
             pins.usb_dm,
             pins.usb_dp,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -79,9 +92,8 @@ fn main() -> ! {
                 .device_class(USB_CLASS_CDC)
                 .build(),
         );
-    }
 
-    unsafe {
+        // Enable USB interrupt
         core.NVIC.set_priority(interrupt::USB, 1);
         NVIC::unmask(interrupt::USB);
     }
@@ -91,9 +103,9 @@ fn main() -> ! {
 
     // Now work on the SD peripherals. Slow SPI speed required on init
     let spi_sercom = periph_alias!(peripherals.spi_sercom);
-    let spi = bsp::spi_master(
+    let spi_bus = bsp::spi_master(
         &mut clocks,
-        400_u32.kHz(),
+        4.MHz(),
         spi_sercom,
         &mut peripherals.pm,
         pins.sclk,
@@ -117,87 +129,134 @@ fn main() -> ! {
     }
 
     if sd_cd.is_low().unwrap() {
-        usbserial_write!("No card detected. Waiting...\r\n");
+        serial_writeln!("No card detected. Waiting...");
         while sd_cd.is_low().unwrap() {
             delay.delay_ms(250_u32);
         }
     }
-    usbserial_write!("Card inserted!\r\n");
+    serial_writeln!("Card inserted!");
     delay.delay_ms(250_u32);
 
-    let mut controller = Controller::new(SdMmcSpi::new(spi, sd_cs), timer);
-
-    match controller.device().init() {
-        Ok(_) => {
-            // speed up SPI and read out some info
-            controller
-                .device()
-                .spi()
-                .reconfigure(|c| c.set_baud(4.MHz()));
-            usbserial_write!("OK!\r\nCard size...\r\n");
-            match controller.device().card_size_bytes() {
-                Ok(size) => usbserial_write!("{} bytes\r\n", size),
-                Err(e) => usbserial_write!("Err: {:?}\r\n", e),
-            }
+    let spi_device = ExclusiveDevice::new(spi_bus, sd_cs, timer_spi).unwrap();
+    let sdcard = SdCard::new(spi_device, timer_sdcard);
+
+    match sdcard.num_bytes() {
+        Ok(num_bytes) => {
+            serial_writeln!("OK!\r\nCard size...");
+            serial_writeln!("{} bytes", num_bytes);
+
+            let volume_manager = VolumeManager::new(sdcard, rtc);
 
             for i in 0..=3 {
-                let volume = controller.get_volume(VolumeIdx(i));
-                usbserial_write!("volume {:?}\r\n", volume);
+                let volume = volume_manager.open_volume(VolumeIdx(i));
+                serial_writeln!("volume {:?}", volume);
                 if let Ok(volume) = volume {
-                    let root_dir = controller.open_root_dir(&volume).unwrap();
-                    usbserial_write!("Listing root directory:\r\n");
-                    controller
-                        .iterate_dir(&volume, &root_dir, |x| {
-                            usbserial_write!("\tFound: {:?}\r\n", x);
-                        })
-                        .unwrap();
+                    match volume.open_root_dir() {
+                        Ok(root_dir) => {
+                            serial_writeln!("Listing root directory:");
+                            root_dir
+                                .iterate_dir(|x| {
+                                    serial_writeln!("\tFound: {:?}", x);
+                                })
+                                .unwrap();
+                        }
+                        Err(e) => serial_writeln!("Directory err: {:?}!", e),
+                    }
                 }
             }
         }
-        Err(e) => usbserial_write!("Init err: {:?}!\r\n", e),
+        Err(e) => serial_writeln!("Init err: {:?}!", e),
     }
 
-    usbserial_write!("Done!\r\n");
+    serial_writeln!("Done!");
     loop {
         delay.delay_ms(1_000_u32);
         red_led.toggle().unwrap();
     }
 }
 
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
+static USB_DATA_RECEIVED: atomic::AtomicBool = atomic::AtomicBool::new(false);
+
+/// Borrows the global singleton `UsbSerial` for a brief period with interrupts
+/// disabled
+///
+/// # Arguments
+/// `borrower`: The closure that gets run borrowing the global `UsbSerial`
+///
+/// # Safety
+/// the global singleton `UsbSerial` can be safely borrowed because we disable
+/// interrupts while it is being borrowed, guaranteeing that interrupt handlers
+/// like `USB` cannot mutate `UsbSerial` while we are as well.
+///
+/// # Panic
+/// If `init` has not been called and we haven't initialized our global
+/// singleton `UsbSerial`, we will panic.
+fn usbserial_get<T, R>(borrower: T) -> R
+where
+    T: Fn(&mut SerialPort<UsbBus>) -> R,
+{
+    usb_free(|_| unsafe {
+        let usb_serial = USB_SERIAL.get_mut().expect("UsbSerial not initialized");
+        borrower(usb_serial)
+    })
+}
+
+/// Execute closure `f` in an interrupt-free context.
+///
+/// This as also known as a "critical section".
+#[inline]
+fn usb_free<F, R>(f: F) -> R
+where
+    F: FnOnce(&cortex_m::interrupt::CriticalSection) -> R,
+{
+    NVIC::mask(interrupt::USB);
+
+    let r = f(&unsafe { cortex_m::interrupt::CriticalSection::new() });
+
+    unsafe {
+        NVIC::unmask(interrupt::USB);
+    };
+
+    r
+}
+
 /// Writes the given message out over USB serial.
+///
+/// # Arguments
+/// * println args: variable arguments passed along to `core::write!`
+///
+/// # Warning
+/// as this function deals with a static mut, and it is also accessed in the
+/// USB interrupt handler, we both have unsafe code for unwrapping a static mut
+/// as well as disabling of interrupts while we do so.
+///
+/// # Safety
+/// the only time the static mut is used, we have interrupts disabled so we know
+/// we have sole access
 #[macro_export]
-macro_rules! usbserial_write {
-    ($($tt:tt)*) => {{
-        let mut s: String<1024> = String::new();
-        write!(s, $($tt)*).unwrap();
-        let message_bytes = s.as_bytes();
-        let mut total_written = 0;
-        while total_written < message_bytes.len() {
-            let bytes_written = disable_interrupts(|_| unsafe {
-                match USB_SERIAL.as_mut().unwrap().write(
-                    &message_bytes[total_written..]
-                ) {
-                    Ok(count) => count,
-                    Err(_) => 0,
-                }
-            });
-            total_written += bytes_written;
-        }
+macro_rules! serial_writeln {
+    ($($tt:tt)+) => {{
+        use core::fmt::Write;
+
+        let mut s: heapless::String<256> = heapless::String::new();
+        core::write!(&mut s, $($tt)*).unwrap();
+        usbserial_get(|usbserial| {
+            usbserial.write(s.as_bytes()).ok();
+            usbserial.write("\r\n".as_bytes()).ok();
+        });
     }};
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
-static USB_DATA_RECEIVED: atomic::AtomicBool = atomic::AtomicBool::new(false);
-
 #[interrupt]
 fn USB() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
-                let mut buf = [0u8; 16];
+                let mut buf = [0u8; 64];
                 if let Ok(count) = serial.read(&mut buf) {
                     if count > 0 {
                         USB_DATA_RECEIVED.store(true, atomic::Ordering::Relaxed);
diff --git a/boards/feather_m0/examples/adc.rs b/boards/feather_m0/examples/adc.rs
index 6194e9d26b28..69e4c4ad725e 100644
--- a/boards/feather_m0/examples/adc.rs
+++ b/boards/feather_m0/examples/adc.rs
@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Prescaler},
     clock::GenericClockController,
 };
 
@@ -46,8 +46,8 @@ fn main() -> ! {
     let mut adc_pin = pins.a0.into_alternate();
 
     loop {
-        let res = adc.read(&mut adc_pin);
+        let _res = adc.read(&mut adc_pin);
         #[cfg(feature = "use_semihosting")]
-        cortex_m_semihosting::hprintln!("ADC value: {}", read).unwrap();
+        cortex_m_semihosting::hprintln!("ADC value: {}", _res).unwrap();
     }
 }
diff --git a/boards/feather_m0/examples/async_adc.rs b/boards/feather_m0/examples/async_adc.rs
index 56139256ba01..a2b626b01eea 100644
--- a/boards/feather_m0/examples/async_adc.rs
+++ b/boards/feather_m0/examples/async_adc.rs
@@ -16,7 +16,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Adc0, Prescaler, Resolution},
+    adc::{Accumulation, Adc0, Prescaler},
     clock::GenericClockController,
 };
 
diff --git a/boards/feather_m0/examples/clock.rs b/boards/feather_m0/examples/clock.rs
index f32db4f23b5c..58f362b116f7 100644
--- a/boards/feather_m0/examples/clock.rs
+++ b/boards/feather_m0/examples/clock.rs
@@ -1,16 +1,15 @@
 #![no_std]
 #![no_main]
-
-use core::fmt::Write;
+#![allow(static_mut_refs)]
 
 #[cfg(not(feature = "use_semihosting"))]
 use panic_halt as _;
 #[cfg(feature = "use_semihosting")]
 use panic_semihosting as _;
 
-use cortex_m::interrupt::free as disable_interrupts;
+use core::cell::OnceCell;
+use core::sync::atomic;
 use cortex_m::peripheral::NVIC;
-use heapless::String;
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
@@ -52,23 +51,23 @@ fn main() -> ! {
     let rtc = rtc::Rtc::clock_mode(peripherals.rtc, rtc_clock.freq(), &mut peripherals.pm);
 
     unsafe {
-        RTC = Some(rtc);
+        let _ = RTC.set(rtc);
     }
 
-    // initialize USB
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             peripherals.usb,
             &mut clocks,
             &mut peripherals.pm,
             pins.usb_dm,
             pins.usb_dp,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
+
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -78,74 +77,132 @@ fn main() -> ! {
                 .device_class(USB_CLASS_CDC)
                 .build(),
         );
-    }
-    unsafe {
+
+        // Enable USB interrupt
         core.NVIC.set_priority(interrupt::USB, 1);
         NVIC::unmask(interrupt::USB);
     }
 
+    // Wait to receive something
+    while !USB_DATA_RECEIVED.load(atomic::Ordering::Relaxed) {
+        delay.delay_ms(250_u32);
+        red_led.toggle().unwrap();
+    }
+    red_led.set_high().unwrap();
+
     // Print the time forever!
     loop {
-        red_led.toggle().ok();
-        let time =
-            disable_interrupts(|_| unsafe { RTC.as_mut().map(|rtc| rtc.current_time()) }).unwrap();
-
-        let mut data = String::<16>::new();
-        write!(
-            data,
-            "{:02}:{:02}:{:02}\r\n",
-            time.hours, time.minutes, time.seconds
-        )
-        .ok()
-        .unwrap();
-        write_serial(data.as_bytes());
+        let time = usb_free(|_| unsafe { RTC.get_mut().map(|rtc| rtc.current_time()) }).unwrap();
+
+        serial_writeln!("{:02}:{:02}:{:02}", time.hours, time.minutes, time.seconds);
 
         delay.delay_ms(1_000_u32);
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
-static mut RTC: Option<rtc::Rtc<rtc::ClockMode>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
+static USB_DATA_RECEIVED: atomic::AtomicBool = atomic::AtomicBool::new(false);
+static mut RTC: OnceCell<rtc::Rtc<rtc::ClockMode>> = OnceCell::new();
+
+/// Borrows the global singleton `UsbSerial` for a brief period with interrupts
+/// disabled
+///
+/// # Arguments
+/// `borrower`: The closure that gets run borrowing the global `UsbSerial`
+///
+/// # Safety
+/// the global singleton `UsbSerial` can be safely borrowed because we disable
+/// interrupts while it is being borrowed, guaranteeing that interrupt handlers
+/// like `USB` cannot mutate `UsbSerial` while we are as well.
+///
+/// # Panic
+/// If `init` has not been called and we haven't initialized our global
+/// singleton `UsbSerial`, we will panic.
+fn usbserial_get<T, R>(borrower: T) -> R
+where
+    T: Fn(&mut SerialPort<UsbBus>) -> R,
+{
+    usb_free(|_| unsafe {
+        let usb_serial = USB_SERIAL.get_mut().expect("UsbSerial not initialized");
+        borrower(usb_serial)
+    })
+}
+
+/// Execute closure `f` in an interrupt-free context.
+///
+/// This as also known as a "critical section".
+#[inline]
+fn usb_free<F, R>(f: F) -> R
+where
+    F: FnOnce(&cortex_m::interrupt::CriticalSection) -> R,
+{
+    NVIC::mask(interrupt::USB);
+
+    let r = f(&unsafe { cortex_m::interrupt::CriticalSection::new() });
 
-fn write_serial(bytes: &[u8]) {
     unsafe {
-        if let Some(serial) = USB_SERIAL.as_mut() {
-            serial.write(bytes).unwrap();
-        };
-    }
+        NVIC::unmask(interrupt::USB);
+    };
+
+    r
+}
+
+/// Writes the given message out over USB serial.
+///
+/// # Arguments
+/// * println args: variable arguments passed along to `core::write!`
+///
+/// # Warning
+/// as this function deals with a static mut, and it is also accessed in the
+/// USB interrupt handler, we both have unsafe code for unwrapping a static mut
+/// as well as disabling of interrupts while we do so.
+///
+/// # Safety
+/// the only time the static mut is used, we have interrupts disabled so we know
+/// we have sole access
+#[macro_export]
+macro_rules! serial_writeln {
+    ($($tt:tt)+) => {{
+        use core::fmt::Write;
+
+        let mut s: heapless::String<256> = heapless::String::new();
+        core::write!(&mut s, $($tt)*).unwrap();
+        usbserial_get(|usbserial| {
+            usbserial.write(s.as_bytes()).ok();
+            usbserial.write("\r\n".as_bytes()).ok();
+        });
+    }};
 }
 
+#[inline]
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
-                let mut buf = [0u8; 32];
+                let mut buf = [0u8; 64];
 
                 if let Ok(count) = serial.read(&mut buf) {
                     let mut buffer: &[u8] = &buf[..count];
-                    // echo to terminal
-                    serial.write(buffer).unwrap();
+
+                    if buffer.len() > 0 {
+                        // echo to terminal
+                        serial.write(buffer).unwrap();
+
+                        USB_DATA_RECEIVED.store(true, atomic::Ordering::Relaxed);
+                    }
 
                     // Look for setting of time
                     while buffer.len() > 5 {
-                        match timespec(buffer) {
+                        match Time::parse(core::str::from_utf8(buffer).unwrap()) {
                             Ok((remaining, time)) => {
-                                buffer = remaining;
-                                disable_interrupts(|_| {
-                                    if let Some(rtc) = RTC.as_mut() {
-                                        rtc.set_time(rtc::Datetime {
-                                            seconds: time.second as u8,
-                                            minutes: time.minute as u8,
-                                            hours: time.hour as u8,
-                                            day: 0,
-                                            month: 0,
-                                            year: 0,
-                                        });
-                                    };
-                                });
+                                buffer = remaining.as_bytes();
+
+                                if let Some(rtc) = RTC.get_mut() {
+                                    rtc.set_time(time.into());
+                                };
                             }
                             _ => break,
                         };
@@ -161,29 +218,55 @@ fn USB() {
     poll_usb();
 }
 
-#[derive(Clone)]
+#[derive(Debug)]
 pub struct Time {
-    hour: usize,
-    minute: usize,
-    second: usize,
+    hour: u8,
+    minute: u8,
+    second: u8,
+}
+impl Into<rtc::Datetime> for Time {
+    fn into(self) -> rtc::Datetime {
+        rtc::Datetime {
+            seconds: self.second,
+            minutes: self.minute,
+            hours: self.hour,
+            day: 0,
+            month: 0,
+            year: 0,
+        }
+    }
 }
 
-use drogue_nom_utils::parse_usize;
-use nom::{char, do_parse, named, opt, tag};
-
-named!(
-    pub timespec<Time>,
-    do_parse!(
-        opt!( char!('\r') ) >>
-        tag!("time=") >>
-        hour: parse_usize >>
-        char!(':') >>
-        minute: parse_usize >>
-        char!(':') >>
-        second: parse_usize >>
-        tag!("\r") >>
-        (
-            Time{ hour, minute, second }
+use nom::{
+    bytes::complete::tag,
+    character::complete::{char, u8 as u8p},
+    combinator::{map, opt},
+    IResult, Parser,
+};
+
+impl Time {
+    pub fn parse(input: &str) -> IResult<&str, Self> {
+        map(
+            (
+                opt(char('\r')),
+                tag("time="),
+                u8p,
+                char(':'),
+                u8p,
+                char(':'),
+                u8p,
+                char('\r'),
+            ),
+            |(_, _, hour, _, minute, _, second, _)| Self {
+                hour,
+                minute,
+                second,
+            }, /* |(_, _, h, _, m, _, s, _): (Option<char>, _, u32, _, u32, _, u32, _)| Self {
+                   hour: h.into(),
+                   minute: m.into(),
+                   second: s.into(),
+               }, */
         )
-    )
-);
+        .parse(input)
+    }
+}
diff --git a/boards/feather_m0/examples/usb_echo.rs b/boards/feather_m0/examples/usb_echo.rs
index 3885e2d3833f..a69a73825d91 100644
--- a/boards/feather_m0/examples/usb_echo.rs
+++ b/boards/feather_m0/examples/usb_echo.rs
@@ -1,11 +1,13 @@
 #![no_std]
 #![no_main]
+#![allow(static_mut_refs)]
 
 #[cfg(not(feature = "use_semihosting"))]
 use panic_halt as _;
 #[cfg(feature = "use_semihosting")]
 use panic_semihosting as _;
 
+use core::cell::OnceCell;
 use cortex_m::asm::delay as cycle_delay;
 use cortex_m::peripheral::NVIC;
 use usb_device::bus::UsbBusAllocator;
@@ -36,19 +38,19 @@ fn main() -> ! {
     let mut red_led: bsp::RedLed = pin_alias!(pins.red_led).into();
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             peripherals.usb,
             &mut clocks,
             &mut peripherals.pm,
             pins.usb_dm,
             pins.usb_dp,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -58,9 +60,8 @@ fn main() -> ! {
                 .device_class(USB_CLASS_CDC)
                 .build(),
         );
-    }
 
-    unsafe {
+        // Enable USB interrupt
         core.NVIC.set_priority(interrupt::USB, 1);
         NVIC::unmask(interrupt::USB);
     }
@@ -73,14 +74,15 @@ fn main() -> ! {
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
 
+#[inline]
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
diff --git a/boards/feather_m4/examples/adc.rs b/boards/feather_m4/examples/adc.rs
index b6b892cf43d3..d3f6adfadb74 100644
--- a/boards/feather_m4/examples/adc.rs
+++ b/boards/feather_m4/examples/adc.rs
@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Prescaler},
     clock::v2::{clock_system_at_reset, pclk::Pclk},
 };
 
diff --git a/boards/feather_m4/examples/nvm_dsu.rs b/boards/feather_m4/examples/nvm_dsu.rs
index e73f2f0d0913..e29805f9207d 100644
--- a/boards/feather_m4/examples/nvm_dsu.rs
+++ b/boards/feather_m4/examples/nvm_dsu.rs
@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 #![allow(clippy::bool_comparison)]
+#![allow(static_mut_refs)]
 
 use bsp::ehal;
 use bsp::hal;
@@ -19,6 +20,7 @@ use hal::nvm::{retrieve_bank_size, Bank, Nvm, WriteGranularity, BLOCKSIZE};
 use hal::pac::{interrupt, CorePeripherals, Peripherals};
 use hal::usb::UsbBus;
 
+use core::cell::OnceCell;
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
@@ -45,19 +47,19 @@ fn main() -> ! {
     let mut dsu = Dsu::new(peripherals.dsu, &peripherals.pac).unwrap();
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             pins.usb_dm,
             pins.usb_dp,
             peripherals.usb,
             &mut clocks,
             &mut peripherals.mclk,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -130,9 +132,9 @@ fn main() -> ! {
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
 
 static USER_PRESENT: atomic::AtomicBool = atomic::AtomicBool::new(false);
 
@@ -155,7 +157,7 @@ where
     T: Fn(&mut SerialPort<UsbBus>) -> R,
 {
     usb_free(|_| unsafe {
-        let usb_serial = USB_SERIAL.as_mut().expect("UsbSerial not initialized");
+        let usb_serial = USB_SERIAL.get_mut().expect("UsbSerial not initialized");
         borrower(usb_serial)
     })
 }
@@ -212,8 +214,8 @@ macro_rules! serial_writeln {
 
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
diff --git a/boards/feather_m4/examples/pukcc_test.rs b/boards/feather_m4/examples/pukcc_test.rs
index fc74d9ebc1f5..d0c4784bbf17 100644
--- a/boards/feather_m4/examples/pukcc_test.rs
+++ b/boards/feather_m4/examples/pukcc_test.rs
@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 #![allow(clippy::bool_comparison)]
+#![allow(static_mut_refs)]
 
 use bsp::ehal;
 use bsp::hal;
@@ -17,6 +18,7 @@ use hal::clock::GenericClockController;
 use hal::pac::{interrupt, CorePeripherals, Peripherals};
 use hal::{pukcc::*, usb::UsbBus};
 
+use core::cell::OnceCell;
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
@@ -39,19 +41,19 @@ fn main() -> ! {
     let mut red_led = pins.d13.into_push_pull_output();
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             pins.usb_dm,
             pins.usb_dp,
             peripherals.usb,
             &mut clocks,
             &mut peripherals.mclk,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -220,9 +222,9 @@ fn main() -> ! {
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
 
 /// Borrows the global singleton `UsbSerial` for a brief period with interrupts
 /// disabled
@@ -243,7 +245,7 @@ where
     T: Fn(&mut SerialPort<UsbBus>) -> R,
 {
     usb_free(|_| unsafe {
-        let usb_serial = USB_SERIAL.as_mut().expect("UsbSerial not initialized");
+        let usb_serial = USB_SERIAL.get_mut().expect("UsbSerial not initialized");
         borrower(usb_serial)
     })
 }
@@ -300,8 +302,8 @@ macro_rules! serial_writeln {
 
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
diff --git a/boards/feather_m4/examples/smart_eeprom.rs b/boards/feather_m4/examples/smart_eeprom.rs
index 9a487468aca1..ed8ed52467c5 100644
--- a/boards/feather_m4/examples/smart_eeprom.rs
+++ b/boards/feather_m4/examples/smart_eeprom.rs
@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 #![allow(clippy::bool_comparison)]
+#![allow(static_mut_refs)]
 
 use bsp::ehal;
 use bsp::hal;
@@ -18,6 +19,7 @@ use hal::nvm::{smart_eeprom, Nvm};
 use hal::pac::{interrupt, CorePeripherals, Peripherals};
 use hal::usb::UsbBus;
 
+use core::cell::OnceCell;
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
@@ -43,19 +45,19 @@ fn main() -> ! {
     let mut nvm = Nvm::new(peripherals.nvmctrl);
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             pins.usb_dm,
             pins.usb_dp,
             peripherals.usb,
             &mut clocks,
             &mut peripherals.mclk,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -113,9 +115,9 @@ fn main() -> ! {
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
 
 static USER_PRESENT: atomic::AtomicBool = atomic::AtomicBool::new(false);
 
@@ -138,7 +140,7 @@ where
     T: Fn(&mut SerialPort<UsbBus>) -> R,
 {
     usb_free(|_| unsafe {
-        let usb_serial = USB_SERIAL.as_mut().expect("UsbSerial not initialized");
+        let usb_serial = USB_SERIAL.get_mut().expect("UsbSerial not initialized");
         borrower(usb_serial)
     })
 }
@@ -195,8 +197,8 @@ macro_rules! serial_writeln {
 
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
diff --git a/boards/feather_m4/examples/usb_echo.rs b/boards/feather_m4/examples/usb_echo.rs
index acce79335e41..f1a661215526 100644
--- a/boards/feather_m4/examples/usb_echo.rs
+++ b/boards/feather_m4/examples/usb_echo.rs
@@ -1,5 +1,6 @@
 #![no_std]
 #![no_main]
+#![allow(static_mut_refs)]
 
 use bsp::hal;
 use feather_m4 as bsp;
@@ -15,6 +16,7 @@ use hal::pac::{interrupt, CorePeripherals, Peripherals};
 use hal::prelude::*;
 use hal::usb::UsbBus;
 
+use core::cell::OnceCell;
 use usb_device::bus::UsbBusAllocator;
 use usb_device::prelude::*;
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
@@ -37,19 +39,19 @@ fn main() -> ! {
     let mut red_led: bsp::RedLed = pins.d13.into();
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             pins.usb_dm,
             pins.usb_dp,
             peripherals.usb,
             &mut clocks,
             &mut peripherals.mclk,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -72,21 +74,19 @@ fn main() -> ! {
 
     loop {
         cycle_delay(5 * 1024 * 1024);
-        red_led.set_high().unwrap();
-        cycle_delay(5 * 1024 * 1024);
-        red_led.set_low().unwrap();
+        red_led.toggle().unwrap();
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
 
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
-                usb_dev.poll(&mut [serial]);
+        if let Some(usb_bus) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
+                usb_bus.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
                 if let Ok(count) = serial.read(&mut buf) {
@@ -94,11 +94,11 @@ fn poll_usb() {
                         if i >= count {
                             break;
                         }
-                        serial.write(&[*c]).unwrap();
+                        serial.write(&[*c]).ok();
                     }
                 };
             };
-        };
+        }
     };
 }
 
diff --git a/boards/metro_m0/Cargo.toml b/boards/metro_m0/Cargo.toml
index b485c1154cae..ed22eac6b5ce 100644
--- a/boards/metro_m0/Cargo.toml
+++ b/boards/metro_m0/Cargo.toml
@@ -71,5 +71,9 @@ name = "spi"
 required-features = ["dma"]
 
 [[example]]
-name = "usb_echo"
+name = "usb_echo_basic"
 required-features = ["usb"]
+
+[[example]]
+name = "usb_echo_rtic"
+required-features = ["usb", "rtic"]
diff --git a/boards/metro_m0/examples/usb_echo.rs b/boards/metro_m0/examples/usb_echo_basic.rs
similarity index 78%
rename from boards/metro_m0/examples/usb_echo.rs
rename to boards/metro_m0/examples/usb_echo_basic.rs
index 04d7e49848de..3473b9742362 100644
--- a/boards/metro_m0/examples/usb_echo.rs
+++ b/boards/metro_m0/examples/usb_echo_basic.rs
@@ -1,8 +1,10 @@
 #![no_std]
 #![no_main]
+#![allow(static_mut_refs)]
 
 use panic_halt as _;
 
+use core::cell::OnceCell;
 use cortex_m::asm::delay as cycle_delay;
 use cortex_m::peripheral::NVIC;
 use usb_device::bus::UsbBusAllocator;
@@ -33,19 +35,19 @@ fn main() -> ! {
     let mut red_led: bsp::RedLed = pins.d13.into();
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             peripherals.usb,
             &mut clocks,
             &mut peripherals.pm,
             pins.usb_dm,
             pins.usb_dp,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
             UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
@@ -70,15 +72,15 @@ fn main() -> ! {
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
 
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
-                usb_dev.poll(&mut [serial]);
+        if let Some(usb_bus) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
+                usb_bus.poll(&mut [serial]);
                 let mut buf = [0u8; 64];
 
                 if let Ok(count) = serial.read(&mut buf) {
diff --git a/boards/metro_m0/examples/usb_echo_rtic.rs b/boards/metro_m0/examples/usb_echo_rtic.rs
new file mode 100644
index 000000000000..87baa9ad2545
--- /dev/null
+++ b/boards/metro_m0/examples/usb_echo_rtic.rs
@@ -0,0 +1,123 @@
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs)]
+
+use panic_halt as _;
+
+use core::cell::OnceCell;
+use rtic::app;
+use usb_device::bus::UsbBusAllocator;
+use usb_device::prelude::*;
+use usbd_serial::{SerialPort, USB_CLASS_CDC};
+
+use bsp::hal;
+use metro_m0 as bsp;
+
+use bsp::RedLed;
+use hal::clock::{ClockGenId, ClockSource, GenericClockController};
+use hal::prelude::*;
+use hal::rtc::rtic::rtc_clock;
+use hal::usb::UsbBus;
+
+hal::rtc_monotonic!(Mono, rtc_clock::ClockCustom<2_048>);
+
+#[app(device = bsp::pac, dispatchers = [EVSYS])]
+mod app {
+    use super::*;
+
+    static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+
+    #[local]
+    struct Resources {
+        usb_bus: UsbDevice<'static, UsbBus>,
+        usb_serial: SerialPort<'static, UsbBus>,
+        red_led: RedLed,
+    }
+
+    #[shared]
+    struct Shared {}
+
+    #[init]
+    fn init(ctx: init::Context) -> (Shared, Resources) {
+        let mut peripherals = ctx.device;
+        let mut clocks = GenericClockController::with_internal_32kosc(
+            peripherals.gclk,
+            &mut peripherals.pm,
+            &mut peripherals.sysctrl,
+            &mut peripherals.nvmctrl,
+        );
+        let pins = bsp::Pins::new(peripherals.port);
+        let red_led: bsp::RedLed = pins.d13.into();
+
+        // Set the RTC clock to use a 2.048 kHz clock derived from the external
+        // 32 kHz oscillator.
+        let rtc_clock_src = clocks
+            .configure_gclk_divider_and_source(ClockGenId::Gclk2, 16, ClockSource::Xosc32k, false)
+            .unwrap();
+        clocks.configure_standby(ClockGenId::Gclk2, true);
+        let _ = clocks.rtc(&rtc_clock_src).unwrap();
+
+        // Start the monotonic
+        Mono::start(peripherals.rtc);
+
+        // Setup the USB
+        let bus_allocator = unsafe {
+            let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
+                peripherals.usb,
+                &mut clocks,
+                &mut peripherals.pm,
+                pins.usb_dm,
+                pins.usb_dp,
+            ));
+            USB_ALLOCATOR.get().unwrap()
+        };
+
+        let usb_serial = SerialPort::new(bus_allocator);
+        let usb_bus = UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
+            .strings(&[StringDescriptors::new(LangID::EN)
+                .manufacturer("Fake company")
+                .product("Serial port")
+                .serial_number("TEST")])
+            .expect("Failed to set strings")
+            .device_class(USB_CLASS_CDC)
+            .build();
+
+        // Spawn the LED task
+        blink_led::spawn().unwrap();
+
+        (
+            Shared {},
+            Resources {
+                usb_bus,
+                usb_serial,
+                red_led,
+            },
+        )
+    }
+
+    // Task  to blink the LED
+    #[task(priority = 1, local=[red_led])]
+    async fn blink_led(ctx: blink_led::Context) {
+        loop {
+            ctx.local.red_led.toggle().unwrap();
+            Mono::delay(500u64.millis()).await;
+        }
+    }
+
+    // Polling interrupt handler that simply echoes back whatever bytes were
+    // received
+    #[task(binds = USB, local = [usb_bus, usb_serial])]
+    fn poll(ctx: poll::Context) {
+        ctx.local.usb_bus.poll(&mut [ctx.local.usb_serial]);
+        let mut buf = [0u8; 64];
+
+        if let Ok(count) = ctx.local.usb_serial.read(&mut buf) {
+            for (i, c) in buf.iter().enumerate() {
+                if i >= count {
+                    break;
+                }
+                ctx.local.usb_serial.write(&[*c]).ok();
+            }
+        };
+    }
+}
diff --git a/boards/metro_m4/Cargo.toml b/boards/metro_m4/Cargo.toml
index 79df242185dc..95357b4cad4b 100644
--- a/boards/metro_m4/Cargo.toml
+++ b/boards/metro_m4/Cargo.toml
@@ -14,6 +14,9 @@ version = "0.18.2"
 [package.metadata]
 chip = "ATSAMD51J19A"
 
+[dependencies]
+heapless = "0.9.1"
+
 [dependencies.cortex-m-rt]
 optional = true
 version = "0.7"
diff --git a/boards/metro_m4/examples/adc.rs b/boards/metro_m4/examples/adc.rs
index 56c46bbd97f7..c4b3b5c889d9 100644
--- a/boards/metro_m4/examples/adc.rs
+++ b/boards/metro_m4/examples/adc.rs
@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Prescaler},
     clock::v2::{clock_system_at_reset, pclk::Pclk},
 };
 
diff --git a/boards/metro_m4/examples/async_adc.rs b/boards/metro_m4/examples/async_adc.rs
index 818e395734d7..3931347f8557 100644
--- a/boards/metro_m4/examples/async_adc.rs
+++ b/boards/metro_m4/examples/async_adc.rs
@@ -16,7 +16,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Adc0, Prescaler, Resolution},
+    adc::{Accumulation, Adc0, Prescaler},
     clock::v2::{clock_system_at_reset, pclk::Pclk},
 };
 
diff --git a/boards/metro_m4/examples/usb_logging.rs b/boards/metro_m4/examples/usb_logging.rs
index 7cc2268bff08..c44b231ea05b 100644
--- a/boards/metro_m4/examples/usb_logging.rs
+++ b/boards/metro_m4/examples/usb_logging.rs
@@ -1,5 +1,6 @@
 #![no_std]
 #![no_main]
+#![allow(static_mut_refs)]
 
 use metro_m4 as bsp;
 
@@ -7,6 +8,7 @@ use bsp::ehal;
 use bsp::hal;
 use bsp::pac;
 
+use core::cell::OnceCell;
 use cortex_m::asm::delay as cycle_delay;
 use cortex_m::peripheral::NVIC;
 use ehal::digital::StatefulOutputPin;
@@ -40,20 +42,20 @@ fn main() -> ! {
     let mut red_led: bsp::RedLed = pins.d13.into();
 
     let bus_allocator = unsafe {
-        USB_ALLOCATOR = Some(bsp::usb_allocator(
+        let _ = USB_ALLOCATOR.set(bsp::usb_allocator(
             peripherals.usb,
             &mut clocks,
             &mut peripherals.mclk,
             pins.usb_dm,
             pins.usb_dp,
         ));
-        USB_ALLOCATOR.as_ref().unwrap()
+        USB_ALLOCATOR.get().unwrap()
     };
 
     unsafe {
-        USB_SERIAL = Some(SerialPort::new(bus_allocator));
-        USB_BUS = Some(
-            UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x2222, 0x3333))
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
+            UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
                 .strings(&[StringDescriptors::new(LangID::EN)
                     .manufacturer("Fake company")
                     .product("Serial port")
@@ -65,14 +67,12 @@ fn main() -> ! {
     }
 
     unsafe {
+        core.NVIC.set_priority(interrupt::USB_OTHER, 1);
         core.NVIC.set_priority(interrupt::USB_TRCPT0, 1);
-        NVIC::unmask(interrupt::USB_TRCPT0);
         core.NVIC.set_priority(interrupt::USB_TRCPT1, 1);
-        NVIC::unmask(interrupt::USB_TRCPT1);
-        core.NVIC.set_priority(interrupt::USB_SOF_HSOF, 1);
-        NVIC::unmask(interrupt::USB_SOF_HSOF);
-        core.NVIC.set_priority(interrupt::USB_OTHER, 1);
         NVIC::unmask(interrupt::USB_OTHER);
+        NVIC::unmask(interrupt::USB_TRCPT0);
+        NVIC::unmask(interrupt::USB_TRCPT1);
     }
 
     // Flash the LED in a spin loop to demonstrate that USB is
@@ -80,29 +80,97 @@ fn main() -> ! {
     loop {
         cycle_delay(5 * 1024 * 1024);
         red_led.toggle().unwrap();
-        // Turn off interrupts so we don't fight with the interrupt
-        cortex_m::interrupt::free(|_| unsafe {
-            if USB_BUS.as_mut().is_some() {
-                if let Some(serial) = USB_SERIAL.as_mut() {
-                    let _ = serial.write("Hello USB\n".as_bytes());
-                }
-            }
-        });
+
+        serial_writeln!("Hello USB");
     }
 }
 
-static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
-static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
-static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
+
+/// Borrows the global singleton `UsbSerial` for a brief period with interrupts
+/// disabled
+///
+/// # Arguments
+/// `borrower`: The closure that gets run borrowing the global `UsbSerial`
+///
+/// # Safety
+/// the global singleton `UsbSerial` can be safely borrowed because we disable
+/// interrupts while it is being borrowed, guaranteeing that interrupt handlers
+/// like `USB` cannot mutate `UsbSerial` while we are as well.
+///
+/// # Panic
+/// If `init` has not been called and we haven't initialized our global
+/// singleton `UsbSerial`, we will panic.
+fn usbserial_get<T, R>(borrower: T) -> R
+where
+    T: Fn(&mut SerialPort<UsbBus>) -> R,
+{
+    usb_free(|_| unsafe {
+        let usb_serial = USB_SERIAL.get_mut().expect("UsbSerial not initialized");
+        borrower(usb_serial)
+    })
+}
+
+/// Execute closure `f` in an interrupt-free context.
+///
+/// This as also known as a "critical section".
+#[inline]
+fn usb_free<F, R>(f: F) -> R
+where
+    F: FnOnce(&cortex_m::interrupt::CriticalSection) -> R,
+{
+    NVIC::mask(interrupt::USB_OTHER);
+    NVIC::mask(interrupt::USB_TRCPT0);
+    NVIC::mask(interrupt::USB_TRCPT1);
+
+    let r = f(unsafe { &cortex_m::interrupt::CriticalSection::new() });
+
+    unsafe {
+        NVIC::unmask(interrupt::USB_OTHER);
+        NVIC::unmask(interrupt::USB_TRCPT0);
+        NVIC::unmask(interrupt::USB_TRCPT1);
+    };
+
+    r
+}
+
+/// Writes the given message out over USB serial.
+///
+/// # Arguments
+/// * println args: variable arguments passed along to `core::write!`
+///
+/// # Warning
+/// as this function deals with a static mut, and it is also accessed in the
+/// USB interrupt handler, we both have unsafe code for unwrapping a static mut
+/// as well as disabling of interrupts while we do so.
+///
+/// # Safety
+/// the only time the static mut is used, we have interrupts disabled so we know
+/// we have sole access
+#[macro_export]
+macro_rules! serial_writeln {
+    ($($tt:tt)+) => {{
+        use core::fmt::Write;
+
+        let mut s: heapless::String<256> = heapless::String::new();
+        core::write!(&mut s, $($tt)*).unwrap();
+        usbserial_get(|usbserial| {
+            usbserial.write(s.as_bytes()).ok();
+            usbserial.write("\r\n".as_bytes()).ok();
+        });
+    }};
+}
 
 fn poll_usb() {
     unsafe {
-        if let Some(usb_dev) = USB_BUS.as_mut() {
-            if let Some(serial) = USB_SERIAL.as_mut() {
+        if let Some(usb_dev) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
                 usb_dev.poll(&mut [serial]);
 
                 // Make the other side happy
-                let mut buf = [0u8; 16];
+                let mut buf = [0u8; 64];
                 let _ = serial.read(&mut buf);
             };
         }
@@ -119,11 +187,6 @@ fn USB_TRCPT1() {
     poll_usb();
 }
 
-#[interrupt]
-fn USB_SOF_HSOF() {
-    poll_usb();
-}
-
 #[interrupt]
 fn USB_OTHER() {
     poll_usb();
diff --git a/boards/pygamer/Cargo.toml b/boards/pygamer/Cargo.toml
index 4044a6d164ac..0c73d48425fd 100644
--- a/boards/pygamer/Cargo.toml
+++ b/boards/pygamer/Cargo.toml
@@ -99,5 +99,5 @@ name = "sd_card"
 name = "timer"
 
 [[example]]
-name = "usb_poll"
+name = "usb_echo"
 required-features = ["usb"]
diff --git a/boards/pygamer/examples/usb_echo.rs b/boards/pygamer/examples/usb_echo.rs
new file mode 100644
index 000000000000..dfe59512164a
--- /dev/null
+++ b/boards/pygamer/examples/usb_echo.rs
@@ -0,0 +1,116 @@
+//! Makes the pygamer appear as a USB serial port loop back device.
+//! Repeats back all characters sent to it, but in upper case.
+
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs)]
+
+use core::cell::OnceCell;
+use cortex_m::asm::delay as cycle_delay;
+use cortex_m::peripheral::NVIC;
+#[cfg(not(feature = "panic_led"))]
+use panic_halt as _;
+use usb_device::bus::UsbBusAllocator;
+use usb_device::prelude::*;
+use usbd_serial::{SerialPort, USB_CLASS_CDC};
+
+use pygamer as bsp;
+
+use bsp::{entry, hal, pac, Pins};
+use hal::clock::GenericClockController;
+use hal::prelude::*;
+use hal::usb::UsbBus;
+use pac::{interrupt, CorePeripherals, Peripherals};
+
+#[entry]
+fn main() -> ! {
+    let mut peripherals = Peripherals::take().unwrap();
+    let mut core = CorePeripherals::take().unwrap();
+    let mut clocks = GenericClockController::with_internal_32kosc(
+        peripherals.gclk,
+        &mut peripherals.mclk,
+        &mut peripherals.osc32kctrl,
+        &mut peripherals.oscctrl,
+        &mut peripherals.nvmctrl,
+    );
+    let pins = Pins::new(peripherals.port).split();
+    let mut red_led: bsp::RedLed = pins.led_pin.into();
+
+    let bus_allocator = unsafe {
+        let _ = USB_ALLOCATOR.set(pins.usb.init(
+            peripherals.usb,
+            &mut clocks,
+            &mut peripherals.mclk,
+        ));
+        USB_ALLOCATOR.get().unwrap()
+    };
+
+    unsafe {
+        let _ = USB_SERIAL.set(SerialPort::new(bus_allocator));
+        let _ = USB_BUS.set(
+            UsbDeviceBuilder::new(bus_allocator, UsbVidPid(0x16c0, 0x27dd))
+                .strings(&[StringDescriptors::new(LangID::EN)
+                    .manufacturer("Fake company")
+                    .product("Serial port")
+                    .serial_number("TEST")])
+                .expect("Failed to set strings")
+                .device_class(USB_CLASS_CDC)
+                .build(),
+        );
+    }
+
+    unsafe {
+        core.NVIC.set_priority(interrupt::USB_OTHER, 1);
+        core.NVIC.set_priority(interrupt::USB_TRCPT0, 1);
+        core.NVIC.set_priority(interrupt::USB_TRCPT1, 1);
+        NVIC::unmask(interrupt::USB_OTHER);
+        NVIC::unmask(interrupt::USB_TRCPT0);
+        NVIC::unmask(interrupt::USB_TRCPT1);
+    }
+
+    // Flash the LED in a spin loop to demonstrate that USB is
+    // entirely interrupt driven.
+    loop {
+        cycle_delay(15 * 1024 * 1024);
+        red_led.toggle().ok();
+    }
+}
+
+static mut USB_ALLOCATOR: OnceCell<UsbBusAllocator<UsbBus>> = OnceCell::new();
+static mut USB_BUS: OnceCell<UsbDevice<UsbBus>> = OnceCell::new();
+static mut USB_SERIAL: OnceCell<SerialPort<UsbBus>> = OnceCell::new();
+
+fn poll_usb() {
+    unsafe {
+        if let Some(usb_bus) = USB_BUS.get_mut() {
+            if let Some(serial) = USB_SERIAL.get_mut() {
+                usb_bus.poll(&mut [serial]);
+                let mut buf = [0u8; 64];
+
+                if let Ok(count) = serial.read(&mut buf) {
+                    for (i, c) in buf.iter().enumerate() {
+                        if i >= count {
+                            break;
+                        }
+                        serial.write(&[*c]).ok();
+                    }
+                };
+            };
+        }
+    };
+}
+
+#[interrupt]
+fn USB_OTHER() {
+    poll_usb();
+}
+
+#[interrupt]
+fn USB_TRCPT0() {
+    poll_usb();
+}
+
+#[interrupt]
+fn USB_TRCPT1() {
+    poll_usb();
+}
diff --git a/boards/pygamer/examples/usb_poll.rs b/boards/pygamer/examples/usb_poll.rs
deleted file mode 100644
index 4e252c8639b7..000000000000
--- a/boards/pygamer/examples/usb_poll.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-//! Makes the pygamer appear as a USB serial port loop back device.
-//! Repeats back all characters sent to it, but in upper case.
-
-#![no_std]
-#![no_main]
-
-use bsp::{entry, hal, pac, Pins, RedLed};
-#[cfg(not(feature = "panic_led"))]
-use panic_halt as _;
-use pygamer as bsp;
-
-use hal::clock::GenericClockController;
-use hal::prelude::*;
-use pac::{CorePeripherals, Peripherals};
-use usb_device::prelude::*;
-use usbd_serial::{SerialPort, USB_CLASS_CDC};
-
-#[entry]
-fn main() -> ! {
-    let mut peripherals = Peripherals::take().unwrap();
-    let mut _core = CorePeripherals::take().unwrap();
-    let mut clocks = GenericClockController::with_internal_32kosc(
-        peripherals.gclk,
-        &mut peripherals.mclk,
-        &mut peripherals.osc32kctrl,
-        &mut peripherals.oscctrl,
-        &mut peripherals.nvmctrl,
-    );
-
-    let pins = Pins::new(peripherals.port).split();
-
-    let usb_bus = pins
-        .usb
-        .init(peripherals.usb, &mut clocks, &mut peripherals.mclk);
-
-    let mut serial = SerialPort::new(&usb_bus);
-    let mut led: RedLed = pins.led_pin.into();
-
-    let mut usb_dev = UsbDeviceBuilder::new(&usb_bus, UsbVidPid(0x16c0, 0x27dd))
-        .strings(&[StringDescriptors::new(LangID::EN)
-            .manufacturer("Fake company")
-            .product("Serial port")
-            .serial_number("TEST")])
-        .expect("Failed to set strings")
-        .device_class(USB_CLASS_CDC)
-        .build();
-
-    let mut led_state = false;
-    let _ = led.set_low(); // Turn off
-
-    loop {
-        if !usb_dev.poll(&mut [&mut serial]) {
-            continue;
-        }
-
-        let mut buf = [0u8; 64];
-
-        match serial.read(&mut buf) {
-            Ok(count) if count > 0 => {
-                // Echo back in upper case
-                for c in buf[0..count].iter_mut() {
-                    led_state = if led_state {
-                        let _ = led.set_low(); // Turn off
-                        false
-                    } else {
-                        let _ = led.set_high(); // Turn on
-                        true
-                    };
-
-                    if 0x61 <= *c && *c <= 0x7a {
-                        *c &= !0x20;
-                    }
-                }
-
-                let mut write_offset = 0;
-                while write_offset < count {
-                    match serial.write(&buf[write_offset..count]) {
-                        Ok(len) if len > 0 => {
-                            write_offset += len;
-                        }
-                        _ => {}
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-}
diff --git a/boards/samd11_bare/examples/adc.rs b/boards/samd11_bare/examples/adc.rs
index 8a4416357b2b..55b25237def5 100644
--- a/boards/samd11_bare/examples/adc.rs
+++ b/boards/samd11_bare/examples/adc.rs
@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Prescaler},
     clock::GenericClockController,
 };
 
diff --git a/hal/Cargo.toml b/hal/Cargo.toml
index 4fa93be1cdb4..115df171faca 100644
--- a/hal/Cargo.toml
+++ b/hal/Cargo.toml
@@ -63,7 +63,7 @@ defmt = {version = "1.0.1", optional = true}
 embassy-sync = {version = "0.6.0", optional = true}
 embedded-hal-async = {version = "1.0.0", optional = true}
 embedded-io-async = {version = "0.6.1", optional = true}
-embedded-sdmmc = {version = "0.8.1", optional = true}
+embedded-sdmmc = {version = "0.9.0", optional = true}
 futures = {version = "0.3.31", default-features = false, features = ["async-await"], optional = true}
 jlink_rtt = {version = "0.2", optional = true}
 mcan-core = {version = "0.2", optional = true}