From 8785fbc6f1a1227115d3ffa6a6c19035bed6ef8c Mon Sep 17 00:00:00 2001 From: huntc Date: Sat, 9 Jul 2022 16:40:10 +1000 Subject: [PATCH] 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 | 224 ++++++++++++------- examples/nrf/src/bin/usb_ethernet.rs | 12 +- examples/nrf/src/bin/usb_hid_keyboard.rs | 71 +----- examples/nrf/src/bin/usb_hid_mouse.rs | 10 +- examples/nrf/src/bin/usb_serial.rs | 8 +- examples/nrf/src/bin/usb_serial_multitask.rs | 13 +- 6 files changed, 173 insertions(+), 165 deletions(-) diff --git a/embassy-nrf/src/usb.rs b/embassy-nrf/src/usb.rs index 973fe16f8..9b6e6e83d 100644 --- a/embassy-nrf/src/usb.rs +++ b/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> + '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> { - pub fn new(_usb: impl Unborrow + 'd, irq: impl Unborrow + 'd) -> Self { - Self::with_power_state(_usb, irq, true) +/// Uses the POWER peripheral to detect when power is available +/// for USB. Unsuitable for usage with the nRF softdevice. +#[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. - /// Required when using the nRF softdevice where power is unavailable until - /// notified by it, at which time the the [`Self::power()`] method should then be called. - pub fn with_power_state( + #[cfg(not(feature = "_nrf5340-app"))] + fn on_interrupt(_: *mut ()) { + let regs = unsafe { &*pac::POWER::ptr() }; + + 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> + '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> + '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 + 'd, irq: impl Unborrow + '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 + 'd, - irq: impl Unborrow + '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 + 'a where Self: 'a; type DisableFuture<'a> = impl Future + 'a where Self: 'a; type PollFuture<'a> = impl Future + 'a where Self: 'a; @@ -260,9 +329,14 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> { w.epdata().set_bit(); w }); - // Enable the USB pullup, allowing enumeration. - regs.usbpullup.write(|w| w.connect().enabled()); - trace!("enabled"); + + 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"); diff --git a/examples/nrf/src/bin/usb_ethernet.rs b/examples/nrf/src/bin/usb_ethernet.rs index a20321fe8..e57cdaf63 100644 --- a/examples/nrf/src/bin/usb_ethernet.rs +++ b/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) -> ! { #[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); diff --git a/examples/nrf/src/bin/usb_hid_keyboard.rs b/examples/nrf/src/bin/usb_hid_keyboard.rs index 97ec861d8..539ae6f16 100644 --- a/examples/nrf/src/bin/usb_hid_keyboard.rs +++ b/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; +use embassy_nrf::usb::{Driver, PowerUsb}; 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 = 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 { - Either::First(_) => {} - Either::Second(enable) => { - if enable { - 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), + usb.run_until_suspend().await; + match select(usb.wait_resume(), remote_wakeup.wait()).await { + Either::First(_) => (), + Either::Second(_) => 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 { diff --git a/examples/nrf/src/bin/usb_hid_mouse.rs b/examples/nrf/src/bin/usb_hid_mouse.rs index 9c44e5cc8..516e7ea95 100644 --- a/examples/nrf/src/bin/usb_hid_mouse.rs +++ b/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); diff --git a/examples/nrf/src/bin/usb_serial.rs b/examples/nrf/src/bin/usb_serial.rs index 7c1d8cbb8..d2200dc5d 100644 --- a/examples/nrf/src/bin/usb_serial.rs +++ b/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 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?; diff --git a/examples/nrf/src/bin/usb_serial_multitask.rs b/examples/nrf/src/bin/usb_serial_multitask.rs index dc503e67c..3806da5a0 100644 --- a/examples/nrf/src/bin/usb_serial_multitask.rs +++ b/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);