Trait for UsbSupply

Eliminated a signal by using a simpler trait method that returns whether VBus power is available. Also includes a UsbSupply that can be signalled for use with the nRF softdevice. Includes the requirement for waiting for power to become available.

embassy-nrf/src/usb.rs

@@ -25,63 +25,163 @@ static EP0_WAKER: AtomicWaker = NEW_AW;
 static EP_IN_WAKERS: [AtomicWaker; 8] = [NEW_AW; 8];
 static EP_OUT_WAKERS: [AtomicWaker; 8] = [NEW_AW; 8];
 static READY_ENDPOINTS: AtomicU32 = AtomicU32::new(0);
-static POWER_AVAILABLE: AtomicBool = AtomicBool::new(false);
 
-pub struct Driver<'d, T: Instance> {
+/// There are multiple ways to detect USB power. The behavior
+/// here provides a hook into determining whether it is.
+pub trait UsbSupply {
+    fn is_usb_detected(&self) -> bool;
+
+    type UsbPowerReadyFuture<'a>: Future<Output = Result<(), ()>> + 'a
+    where
+        Self: 'a;
+    fn wait_power_ready(&mut self) -> Self::UsbPowerReadyFuture<'_>;
+}
+
+pub struct Driver<'d, T: Instance, P: UsbSupply> {
     phantom: PhantomData<&'d mut T>,
     alloc_in: Allocator,
     alloc_out: Allocator,
+    usb_supply: P,
 }
 
-impl<'d, T: Instance> Driver<'d, T> {
+/// Uses the POWER peripheral to detect when power is available
-    pub fn new(_usb: impl Unborrow<Target = T> + 'd, irq: impl Unborrow<Target = T::Interrupt> + 'd) -> Self {
+/// for USB. Unsuitable for usage with the nRF softdevice.
-        Self::with_power_state(_usb, irq, true)
+#[cfg(not(feature = "_nrf5340-app"))]
+pub struct PowerUsb {}
+
+/// Can be used to signal that power is available. Particularly suited for
+/// use with the nRF softdevice.
+pub struct SignalledSupply {
+    usb_detected: AtomicBool,
+    power_ready: AtomicBool,
+}
+
+static POWER_WAKER: AtomicWaker = NEW_AW;
+
+#[cfg(not(feature = "_nrf5340-app"))]
+impl PowerUsb {
+    pub fn new(power_irq: impl Interrupt) -> Self {
+        let regs = unsafe { &*pac::POWER::ptr() };
+
+        power_irq.set_handler(Self::on_interrupt);
+        power_irq.unpend();
+        power_irq.enable();
+
+        regs.intenset
+            .write(|w| w.usbdetected().set().usbremoved().set().usbpwrrdy().set());
+
+        Self {}
     }
 
-    /// Establish a new device that then puts the USB device into an initial power state.
+    #[cfg(not(feature = "_nrf5340-app"))]
-    /// Required when using the nRF softdevice where power is unavailable until
+    fn on_interrupt(_: *mut ()) {
-    /// notified by it, at which time the the [`Self::power()`] method should then be called.
+        let regs = unsafe { &*pac::POWER::ptr() };
-    pub fn with_power_state(
+
+        if regs.events_usbdetected.read().bits() != 0 {
+            regs.events_usbdetected.reset();
+            BUS_WAKER.wake();
+        }
+
+        if regs.events_usbremoved.read().bits() != 0 {
+            regs.events_usbremoved.reset();
+            BUS_WAKER.wake();
+            POWER_WAKER.wake();
+        }
+
+        if regs.events_usbpwrrdy.read().bits() != 0 {
+            regs.events_usbpwrrdy.reset();
+            POWER_WAKER.wake();
+        }
+    }
+}
+
+#[cfg(not(feature = "_nrf5340-app"))]
+impl UsbSupply for PowerUsb {
+    fn is_usb_detected(&self) -> bool {
+        let regs = unsafe { &*pac::POWER::ptr() };
+        regs.usbregstatus.read().vbusdetect().is_vbus_present()
+    }
+
+    type UsbPowerReadyFuture<'a> = impl Future<Output = Result<(), ()>> + 'a where Self: 'a;
+    fn wait_power_ready(&mut self) -> Self::UsbPowerReadyFuture<'_> {
+        poll_fn(move |cx| {
+            POWER_WAKER.register(cx.waker());
+            let regs = unsafe { &*pac::POWER::ptr() };
+
+            if regs.usbregstatus.read().outputrdy().is_ready() {
+                Poll::Ready(Ok(()))
+            } else if !self.is_usb_detected() {
+                Poll::Ready(Err(()))
+            } else {
+                Poll::Pending
+            }
+        })
+    }
+}
+
+impl SignalledSupply {
+    pub fn new(usb_detected: bool, power_ready: bool) -> Self {
+        BUS_WAKER.wake();
+
+        Self {
+            usb_detected: AtomicBool::new(usb_detected),
+            power_ready: AtomicBool::new(power_ready),
+        }
+    }
+
+    pub fn detected(&self, detected: bool) {
+        self.usb_detected.store(detected, Ordering::Relaxed);
+        self.power_ready.store(false, Ordering::Relaxed);
+        BUS_WAKER.wake();
+        POWER_WAKER.wake();
+    }
+
+    pub fn ready(&self) {
+        self.power_ready.store(true, Ordering::Relaxed);
+        POWER_WAKER.wake();
+    }
+}
+
+impl UsbSupply for SignalledSupply {
+    fn is_usb_detected(&self) -> bool {
+        self.usb_detected.load(Ordering::Relaxed)
+    }
+
+    type UsbPowerReadyFuture<'a> = impl Future<Output = Result<(), ()>> + 'a where Self: 'a;
+    fn wait_power_ready(&mut self) -> Self::UsbPowerReadyFuture<'_> {
+        poll_fn(move |cx| {
+            POWER_WAKER.register(cx.waker());
+
+            if self.power_ready.load(Ordering::Relaxed) {
+                Poll::Ready(Ok(()))
+            } else if !self.usb_detected.load(Ordering::Relaxed) {
+                Poll::Ready(Err(()))
+            } else {
+                Poll::Pending
+            }
+        })
+    }
+}
+
+impl<'d, T: Instance, P: UsbSupply> Driver<'d, T, P> {
+    pub fn new(
         _usb: impl Unborrow<Target = T> + 'd,
         irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        power_available: bool,
+        usb_supply: P,
     ) -> Self {
         unborrow!(irq);
         irq.set_handler(Self::on_interrupt);
         irq.unpend();
         irq.enable();
 
-        // Initialize the bus so that it signals that power is available.
-        // Not required when using with_power_management as we then rely on the irq.
-        POWER_AVAILABLE.store(power_available, Ordering::Relaxed);
-        BUS_WAKER.wake();
-
         Self {
             phantom: PhantomData,
             alloc_in: Allocator::new(),
             alloc_out: Allocator::new(),
+            usb_supply,
         }
     }
 
-    /// Establish a new device that then uses the POWER peripheral to
-    /// detect USB power detected/removed events are handled.
-    #[cfg(not(feature = "_nrf5340-app"))]
-    pub fn with_power_management(
-        _usb: impl Unborrow<Target = T> + 'd,
-        irq: impl Unborrow<Target = T::Interrupt> + 'd,
-        power_irq: impl Interrupt,
-    ) -> Self {
-        let regs = unsafe { &*pac::POWER::ptr() };
-
-        power_irq.set_handler(Self::on_power_interrupt);
-        power_irq.unpend();
-        power_irq.enable();
-
-        regs.intenset.write(|w| w.usbdetected().set().usbremoved().set());
-
-        Self::with_power_state(_usb, irq, regs.usbregstatus.read().vbusdetect().is_vbus_present())
-    }
-
     fn on_interrupt(_: *mut ()) {
         let regs = T::regs();
 
@@ -131,46 +231,13 @@ impl<'d, T: Instance> Driver<'d, T> {
             }
         }
     }
-
-    #[cfg(not(feature = "_nrf5340-app"))]
-    fn on_power_interrupt(_: *mut ()) {
-        let regs = unsafe { &*pac::POWER::ptr() };
-
-        let mut power_changed = false;
-        let mut power_available = false;
-
-        if regs.events_usbdetected.read().bits() != 0 {
-            regs.events_usbdetected.reset();
-            power_changed = true;
-            power_available = true;
-        }
-
-        if regs.events_usbremoved.read().bits() != 0 {
-            regs.events_usbremoved.reset();
-            power_changed = true;
-            power_available = false;
-        }
-
-        if power_changed {
-            POWER_AVAILABLE.store(power_available, Ordering::Relaxed);
-            BUS_WAKER.wake();
-        }
-    }
-
-    /// Manually declare that USB power is available or unavailable.
-    /// Useful in scenarios where power management cannot be managed
-    /// automatically e.g. when dealing with the nrf-softdevice.
-    pub fn power(available: bool) {
-        POWER_AVAILABLE.store(available, Ordering::Relaxed);
-        BUS_WAKER.wake();
-    }
 }
 
-impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
+impl<'d, T: Instance, P: UsbSupply + 'd> driver::Driver<'d> for Driver<'d, T, P> {
     type EndpointOut = Endpoint<'d, T, Out>;
     type EndpointIn = Endpoint<'d, T, In>;
     type ControlPipe = ControlPipe<'d, T>;
-    type Bus = Bus<'d, T>;
+    type Bus = Bus<'d, T, P>;
 
     fn alloc_endpoint_in(
         &mut self,
@@ -209,6 +276,7 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
             Bus {
                 phantom: PhantomData,
                 power_available: false,
+                usb_supply: self.usb_supply,
             },
             ControlPipe {
                 _phantom: PhantomData,
@@ -218,12 +286,13 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
     }
 }
 
-pub struct Bus<'d, T: Instance> {
+pub struct Bus<'d, T: Instance, P: UsbSupply> {
     phantom: PhantomData<&'d mut T>,
     power_available: bool,
+    usb_supply: P,
 }
 
-impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
+impl<'d, T: Instance, P: UsbSupply> driver::Bus for Bus<'d, T, P> {
     type EnableFuture<'a> = impl Future<Output = ()> + 'a where Self: 'a;
     type DisableFuture<'a> = impl Future<Output = ()> + 'a where Self: 'a;
     type PollFuture<'a> = impl Future<Output = Event> + 'a where Self: 'a;
@@ -260,9 +329,14 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
                 w.epdata().set_bit();
                 w
             });
+
+            if self.usb_supply.wait_power_ready().await.is_ok() {
                 // Enable the USB pullup, allowing enumeration.
                 regs.usbpullup.write(|w| w.connect().enabled());
                 trace!("enabled");
+            } else {
+                trace!("usb power not ready due to usb removal");
+            }
         }
     }
 
@@ -318,7 +392,7 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
                 trace!("USB event: ready");
             }
 
-            if POWER_AVAILABLE.load(Ordering::Relaxed) != self.power_available {
+            if self.usb_supply.is_usb_detected() != self.power_available {
                 self.power_available = !self.power_available;
                 if self.power_available {
                     trace!("Power event: available");

examples/nrf/src/bin/usb_ethernet.rs

@@ -15,14 +15,14 @@ use embassy::util::Forever;
 use embassy_net::tcp::TcpSocket;
 use embassy_net::{PacketBox, PacketBoxExt, PacketBuf, Stack, StackResources};
 use embassy_nrf::rng::Rng;
-use embassy_nrf::usb::Driver;
+use embassy_nrf::usb::{Driver, PowerUsb};
 use embassy_nrf::{interrupt, pac, peripherals, Peripherals};
 use embassy_usb::{Builder, Config, UsbDevice};
 use embassy_usb_ncm::{CdcNcmClass, Receiver, Sender, State};
 use embedded_io::asynch::{Read, Write};
 use {defmt_rtt as _, panic_probe as _};
 
-type MyDriver = Driver<'static, peripherals::USBD>;
+type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
 
 macro_rules! forever {
     ($val:expr) => {{
@@ -84,19 +84,15 @@ async fn net_task(stack: &'static Stack<Device>) -> ! {
 #[embassy::main]
 async fn main(spawner: Spawner, p: Peripherals) {
     let clock: pac::CLOCK = unsafe { mem::transmute(()) };
-    let power: pac::POWER = unsafe { mem::transmute(()) };
 
     info!("Enabling ext hfosc...");
     clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
     while clock.events_hfclkstarted.read().bits() != 1 {}
 
-    info!("Waiting for vbus...");
-    while !power.usbregstatus.read().vbusdetect().is_vbus_present() {}
-    info!("vbus OK");
-
     // Create the driver, from the HAL.
     let irq = interrupt::take!(USBD);
-    let driver = Driver::new(p.USBD, irq);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
 
     // Create embassy-usb Config
     let mut config = Config::new(0xc0de, 0xcafe);

examples/nrf/src/bin/usb_hid_keyboard.rs

@@ -10,10 +10,9 @@ use defmt::*;
 use embassy::channel::signal::Signal;
 use embassy::executor::Spawner;
 use embassy::time::Duration;
-use embassy::util::{select, select3, Either, Either3};
+use embassy::util::{select, Either};
 use embassy_nrf::gpio::{Input, Pin, Pull};
-use embassy_nrf::interrupt::InterruptExt;
+use embassy_nrf::usb::{Driver, PowerUsb};
-use embassy_nrf::usb::Driver;
 use embassy_nrf::{interrupt, pac, Peripherals};
 use embassy_usb::control::OutResponse;
 use embassy_usb::{Builder, Config, DeviceStateHandler};
@@ -22,29 +21,11 @@ use futures::future::join;
 use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
 use {defmt_rtt as _, panic_probe as _};
 
-static ENABLE_USB: Signal<bool> = Signal::new();
 static SUSPENDED: AtomicBool = AtomicBool::new(false);
 
-fn on_power_interrupt(_: *mut ()) {
-    let regs = unsafe { &*pac::POWER::ptr() };
-
-    if regs.events_usbdetected.read().bits() != 0 {
-        regs.events_usbdetected.reset();
-        info!("Vbus detected, enabling USB...");
-        ENABLE_USB.signal(true);
-    }
-
-    if regs.events_usbremoved.read().bits() != 0 {
-        regs.events_usbremoved.reset();
-        info!("Vbus removed, disabling USB...");
-        ENABLE_USB.signal(false);
-    }
-}
-
 #[embassy::main]
 async fn main(_spawner: Spawner, p: Peripherals) {
     let clock: pac::CLOCK = unsafe { mem::transmute(()) };
-    let power: pac::POWER = unsafe { mem::transmute(()) };
 
     info!("Enabling ext hfosc...");
     clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
@@ -52,7 +33,8 @@ async fn main(_spawner: Spawner, p: Peripherals) {
 
     // Create the driver, from the HAL.
     let irq = interrupt::take!(USBD);
-    let driver = Driver::new(p.USBD, irq);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
 
     // Create embassy-usb Config
     let mut config = Config::new(0xc0de, 0xcafe);
@@ -100,31 +82,11 @@ async fn main(_spawner: Spawner, p: Peripherals) {
 
     // Run the USB device.
     let usb_fut = async {
-        enable_command().await;
         loop {
-            match select(usb.run_until_suspend(), ENABLE_USB.wait()).await {
+            usb.run_until_suspend().await;
-                Either::First(_) => {}
+            match select(usb.wait_resume(), remote_wakeup.wait()).await {
-                Either::Second(enable) => {
+                Either::First(_) => (),
-                    if enable {
+                Either::Second(_) => unwrap!(usb.remote_wakeup().await),
-                        warn!("Enable when already enabled!");
-                    } else {
-                        usb.disable().await;
-                        enable_command().await;
-                    }
-                }
-            }
-
-            match select3(usb.wait_resume(), ENABLE_USB.wait(), remote_wakeup.wait()).await {
-                Either3::First(_) => (),
-                Either3::Second(enable) => {
-                    if enable {
-                        warn!("Enable when already enabled!");
-                    } else {
-                        usb.disable().await;
-                        enable_command().await;
-                    }
-                }
-                Either3::Third(_) => unwrap!(usb.remote_wakeup().await),
             }
         }
     };
@@ -174,28 +136,11 @@ async fn main(_spawner: Spawner, p: Peripherals) {
         reader.run(false, &request_handler).await;
     };
 
-    let power_irq = interrupt::take!(POWER_CLOCK);
-    power_irq.set_handler(on_power_interrupt);
-    power_irq.unpend();
-    power_irq.enable();
-
-    power.intenset.write(|w| w.usbdetected().set().usbremoved().set());
-
     // Run everything concurrently.
     // If we had made everything `'static` above instead, we could do this using separate tasks instead.
     join(usb_fut, join(in_fut, out_fut)).await;
 }
 
-async fn enable_command() {
-    loop {
-        if ENABLE_USB.wait().await {
-            break;
-        } else {
-            warn!("Received disable signal when already disabled!");
-        }
-    }
-}
-
 struct MyRequestHandler {}
 
 impl RequestHandler for MyRequestHandler {

examples/nrf/src/bin/usb_hid_mouse.rs

@@ -8,7 +8,7 @@ use core::mem;
 use defmt::*;
 use embassy::executor::Spawner;
 use embassy::time::{Duration, Timer};
-use embassy_nrf::usb::Driver;
+use embassy_nrf::usb::{Driver, PowerUsb};
 use embassy_nrf::{interrupt, pac, Peripherals};
 use embassy_usb::control::OutResponse;
 use embassy_usb::{Builder, Config};
@@ -20,19 +20,15 @@ use {defmt_rtt as _, panic_probe as _};
 #[embassy::main]
 async fn main(_spawner: Spawner, p: Peripherals) {
     let clock: pac::CLOCK = unsafe { mem::transmute(()) };
-    let power: pac::POWER = unsafe { mem::transmute(()) };
 
     info!("Enabling ext hfosc...");
     clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
     while clock.events_hfclkstarted.read().bits() != 1 {}
 
-    info!("Waiting for vbus...");
-    while !power.usbregstatus.read().vbusdetect().is_vbus_present() {}
-    info!("vbus OK");
-
     // Create the driver, from the HAL.
     let irq = interrupt::take!(USBD);
-    let driver = Driver::new(p.USBD, irq);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
 
     // Create embassy-usb Config
     let mut config = Config::new(0xc0de, 0xcafe);

examples/nrf/src/bin/usb_serial.rs

@@ -7,7 +7,7 @@ use core::mem;
 
 use defmt::{info, panic};
 use embassy::executor::Spawner;
-use embassy_nrf::usb::{Driver, Instance};
+use embassy_nrf::usb::{Driver, Instance, PowerUsb, UsbSupply};
 use embassy_nrf::{interrupt, pac, Peripherals};
 use embassy_usb::driver::EndpointError;
 use embassy_usb::{Builder, Config};
@@ -26,7 +26,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
     // Create the driver, from the HAL.
     let irq = interrupt::take!(USBD);
     let power_irq = interrupt::take!(POWER_CLOCK);
-    let driver = Driver::with_power_management(p.USBD, irq, power_irq);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
 
     // Create embassy-usb Config
     let mut config = Config::new(0xc0de, 0xcafe);
@@ -97,7 +97,9 @@ impl From<EndpointError> for Disconnected {
     }
 }
 
-async fn echo<'d, T: Instance + 'd>(class: &mut CdcAcmClass<'d, Driver<'d, T>>) -> Result<(), Disconnected> {
+async fn echo<'d, T: Instance + 'd, P: UsbSupply + 'd>(
+    class: &mut CdcAcmClass<'d, Driver<'d, T, P>>,
+) -> Result<(), Disconnected> {
     let mut buf = [0; 64];
     loop {
         let n = class.read_packet(&mut buf).await?;

examples/nrf/src/bin/usb_serial_multitask.rs

@@ -8,14 +8,14 @@ use core::mem;
 use defmt::{info, panic, unwrap};
 use embassy::executor::Spawner;
 use embassy::util::Forever;
-use embassy_nrf::usb::Driver;
+use embassy_nrf::usb::{Driver, PowerUsb};
 use embassy_nrf::{interrupt, pac, peripherals, Peripherals};
 use embassy_usb::driver::EndpointError;
 use embassy_usb::{Builder, Config, UsbDevice};
 use embassy_usb_serial::{CdcAcmClass, State};
 use {defmt_rtt as _, panic_probe as _};
 
-type MyDriver = Driver<'static, peripherals::USBD>;
+type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
 
 #[embassy::task]
 async fn usb_task(mut device: UsbDevice<'static, MyDriver>) {
@@ -35,19 +35,14 @@ async fn echo_task(mut class: CdcAcmClass<'static, MyDriver>) {
 #[embassy::main]
 async fn main(spawner: Spawner, p: Peripherals) {
     let clock: pac::CLOCK = unsafe { mem::transmute(()) };
-    let power: pac::POWER = unsafe { mem::transmute(()) };
 
     info!("Enabling ext hfosc...");
     clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
     while clock.events_hfclkstarted.read().bits() != 1 {}
-
-    info!("Waiting for vbus...");
-    while !power.usbregstatus.read().vbusdetect().is_vbus_present() {}
-    info!("vbus OK");
-
     // Create the driver, from the HAL.
     let irq = interrupt::take!(USBD);
-    let driver = Driver::new(p.USBD, irq);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
 
     // Create embassy-usb Config
     let mut config = Config::new(0xc0de, 0xcafe);