NaxdyOrg/embassy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Trait for UsbSupply

Browse source 
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.
This commit is contained in:
huntc 2022-07-09 16:40:10 +10:00
parent 81796d29b4
commit 8785fbc6f1
6 changed files with 173 additions and 165 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

218
embassy-nrf/src/usb.rs
View file

@ -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> {
pub fn new(_usb: impl Unborrow<Target = T> + 'd, irq: impl Unborrow<Target = T::Interrupt> + '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,
}
/// 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(
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 {}
}
#[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<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");

12
examples/nrf/src/bin/usb_ethernet.rs
View file

@ -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);

71
examples/nrf/src/bin/usb_hid_keyboard.rs
View file

@ -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<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 {
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 {

10
examples/nrf/src/bin/usb_hid_mouse.rs
View file

@ -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);

8
examples/nrf/src/bin/usb_serial.rs
View file

@ -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?;

13
examples/nrf/src/bin/usb_serial_multitask.rs
View file

@ -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);