Merge #711
711: Add DeviceStateHandler, DeviceCommand channel, and remote wakeup support r=Dirbaio a=alexmoon Apologies for the size of this PR. Once I started getting into the Vbus power management side of my device I found a couple of areas of functionality missing from embassy-usb. Specifically, I need the application to be able to respond to changes in the USB device state in order to properly control the amount of power I'm drawing from Vbus. I also wanted to enable remote wakeup support for my device. In order to enable device state monitoring, I've created a `DeviceStateHandler` trait and made it possible to pass in an optional reference a handler implementing that trait when creating the `UsbDeviceBuilder`. Remote wakeup required a way to send commands to the bus which is exclusively owned by the `UsbDevice::run` method. This is the same problem we were discussing for enabling/disabling the device on Vbus power events. My solution is to allow an optional `Channel` to be provided to the `UsbDeviceBuilder` (via `UsbDeviceBuilder::new_with_channel`), allowing the application to send commands into the `run` method. Right now it supports enable, disable and remote wakeup commands. Since there's now a way to dynamically enable and disable the device, I also added `Config::start_enabled` to control whether or not the `UsbDevice` should start in the enabled state. That also allowed me to make `UsbDeviceBuilder::build` sync again and move enabling the bus into `UsbDevice::run`. This led to a few driver changes: 1. `Driver::enable` became `Driver::into_bus` 2. `Bus::enable`, `Bus::disable`, and `Bus::remote_wakeup` were added 3. I removed `Bus::reset`, `Bus::suspend`, and `Bus::resume` because they were only ever called based on the result of `Bus::poll`. It made more sense to me to have `Bus::poll` handle the driver-specific state management itself. I've updated the `usb_hid_keyboard` example to take advantage of all these additional features. Let me know what you think. Thanks! Co-authored-by: alexmoon <alex.r.moon@gmail.com>
This commit is contained in:
bors[bot]
GitHub
commit
3a90a8eb4a
@ -10,7 +10,7 @@ use embassy::util::Unborrow;
|
||||
use embassy::waitqueue::AtomicWaker;
|
||||
use embassy_hal_common::unborrow;
|
||||
use embassy_usb::control::Request;
|
||||
use embassy_usb::driver::{self, EndpointError, Event};
|
||||
use embassy_usb::driver::{self, EndpointError, Event, Unsupported};
|
||||
use embassy_usb::types::{EndpointAddress, EndpointInfo, EndpointType, UsbDirection};
|
||||
use futures::future::poll_fn;
|
||||
use futures::Future;
|
||||
@ -140,7 +140,6 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
|
||||
type EndpointIn = Endpoint<'d, T, In>;
|
||||
type ControlPipe = ControlPipe<'d, T>;
|
||||
type Bus = Bus<'d, T>;
|
||||
type EnableFuture = impl Future<Output = Self::Bus> + 'd;
|
||||
|
||||
fn alloc_endpoint_in(
|
||||
&mut self,
|
||||
@ -192,7 +191,28 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
|
||||
})
|
||||
}
|
||||
|
||||
fn enable(self) -> Self::EnableFuture {
|
||||
fn into_bus(self) -> Self::Bus {
|
||||
Bus {
|
||||
phantom: PhantomData,
|
||||
alloc_in: self.alloc_in,
|
||||
alloc_out: self.alloc_out,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Bus<'d, T: Instance> {
|
||||
phantom: PhantomData<&'d mut T>,
|
||||
alloc_in: Allocator,
|
||||
alloc_out: Allocator,
|
||||
}
|
||||
|
||||
impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
|
||||
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;
|
||||
type RemoteWakeupFuture<'a> = impl Future<Output = Result<(), Unsupported>> + 'a where Self: 'a;
|
||||
|
||||
fn enable(&mut self) -> Self::EnableFuture<'_> {
|
||||
async move {
|
||||
let regs = T::regs();
|
||||
|
||||
@ -226,33 +246,25 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
|
||||
// Enable the USB pullup, allowing enumeration.
|
||||
regs.usbpullup.write(|w| w.connect().enabled());
|
||||
trace!("enabled");
|
||||
|
||||
Bus {
|
||||
phantom: PhantomData,
|
||||
alloc_in: self.alloc_in,
|
||||
alloc_out: self.alloc_out,
|
||||
}
|
||||
}
|
||||
|
||||
fn disable(&mut self) -> Self::DisableFuture<'_> {
|
||||
async move {
|
||||
let regs = T::regs();
|
||||
regs.enable.write(|x| x.enable().disabled());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Bus<'d, T: Instance> {
|
||||
phantom: PhantomData<&'d mut T>,
|
||||
alloc_in: Allocator,
|
||||
alloc_out: Allocator,
|
||||
}
|
||||
|
||||
impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
|
||||
type PollFuture<'a> = impl Future<Output = Event> + 'a where Self: 'a;
|
||||
|
||||
fn poll<'a>(&'a mut self) -> Self::PollFuture<'a> {
|
||||
poll_fn(|cx| {
|
||||
poll_fn(move |cx| {
|
||||
BUS_WAKER.register(cx.waker());
|
||||
let regs = T::regs();
|
||||
|
||||
if regs.events_usbreset.read().bits() != 0 {
|
||||
regs.events_usbreset.reset();
|
||||
regs.intenset.write(|w| w.usbreset().set());
|
||||
self.set_configured(false);
|
||||
return Poll::Ready(Event::Reset);
|
||||
}
|
||||
|
||||
@ -268,11 +280,12 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
|
||||
}
|
||||
if r.suspend().bit() {
|
||||
regs.eventcause.write(|w| w.suspend().set_bit());
|
||||
trace!("USB event: suspend");
|
||||
regs.lowpower.write(|w| w.lowpower().low_power());
|
||||
return Poll::Ready(Event::Suspend);
|
||||
}
|
||||
if r.resume().bit() {
|
||||
regs.eventcause.write(|w| w.resume().set_bit());
|
||||
trace!("USB event: resume");
|
||||
return Poll::Ready(Event::Resume);
|
||||
}
|
||||
if r.ready().bit() {
|
||||
regs.eventcause.write(|w| w.ready().set_bit());
|
||||
@ -283,11 +296,6 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn reset(&mut self) {
|
||||
self.set_configured(false);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn set_configured(&mut self, configured: bool) {
|
||||
let regs = T::regs();
|
||||
@ -343,18 +351,43 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn suspend(&mut self) {
|
||||
let regs = T::regs();
|
||||
regs.lowpower.write(|w| w.lowpower().low_power());
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn resume(&mut self) {
|
||||
fn remote_wakeup(&mut self) -> Self::RemoteWakeupFuture<'_> {
|
||||
async move {
|
||||
let regs = T::regs();
|
||||
|
||||
if regs.lowpower.read().lowpower().is_low_power() {
|
||||
errata::pre_wakeup();
|
||||
|
||||
regs.lowpower.write(|w| w.lowpower().force_normal());
|
||||
|
||||
poll_fn(|cx| {
|
||||
BUS_WAKER.register(cx.waker());
|
||||
let regs = T::regs();
|
||||
let r = regs.eventcause.read();
|
||||
|
||||
if regs.events_usbreset.read().bits() != 0 {
|
||||
Poll::Ready(())
|
||||
} else if r.resume().bit() {
|
||||
Poll::Ready(())
|
||||
} else if r.usbwuallowed().bit() {
|
||||
regs.eventcause.write(|w| w.usbwuallowed().set_bit());
|
||||
|
||||
regs.dpdmvalue.write(|w| w.state().resume());
|
||||
regs.tasks_dpdmdrive
|
||||
.write(|w| w.tasks_dpdmdrive().set_bit());
|
||||
|
||||
Poll::Ready(())
|
||||
} else {
|
||||
Poll::Pending
|
||||
}
|
||||
})
|
||||
.await;
|
||||
|
||||
errata::post_wakeup();
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -834,17 +867,20 @@ macro_rules! impl_usb {
|
||||
mod errata {
|
||||
|
||||
/// Writes `val` to `addr`. Used to apply Errata workarounds.
|
||||
#[cfg(any(feature = "nrf52840", feature = "nrf52833", feature = "nrf52820"))]
|
||||
unsafe fn poke(addr: u32, val: u32) {
|
||||
(addr as *mut u32).write_volatile(val);
|
||||
}
|
||||
|
||||
/// Reads 32 bits from `addr`.
|
||||
#[cfg(feature = "nrf52840")]
|
||||
unsafe fn peek(addr: u32) -> u32 {
|
||||
(addr as *mut u32).read_volatile()
|
||||
}
|
||||
|
||||
pub fn pre_enable() {
|
||||
// Works around Erratum 187 on chip revisions 1 and 2.
|
||||
#[cfg(any(feature = "nrf52840", feature = "nrf52833", feature = "nrf52820"))]
|
||||
unsafe {
|
||||
poke(0x4006EC00, 0x00009375);
|
||||
poke(0x4006ED14, 0x00000003);
|
||||
@ -858,6 +894,7 @@ mod errata {
|
||||
post_wakeup();
|
||||
|
||||
// Works around Erratum 187 on chip revisions 1 and 2.
|
||||
#[cfg(any(feature = "nrf52840", feature = "nrf52833", feature = "nrf52820"))]
|
||||
unsafe {
|
||||
poke(0x4006EC00, 0x00009375);
|
||||
poke(0x4006ED14, 0x00000000);
|
||||
@ -868,6 +905,7 @@ mod errata {
|
||||
pub fn pre_wakeup() {
|
||||
// Works around Erratum 171 on chip revisions 1 and 2.
|
||||
|
||||
#[cfg(feature = "nrf52840")]
|
||||
unsafe {
|
||||
if peek(0x4006EC00) == 0x00000000 {
|
||||
poke(0x4006EC00, 0x00009375);
|
||||
@ -881,6 +919,7 @@ mod errata {
|
||||
pub fn post_wakeup() {
|
||||
// Works around Erratum 171 on chip revisions 1 and 2.
|
||||
|
||||
#[cfg(feature = "nrf52840")]
|
||||
unsafe {
|
||||
if peek(0x4006EC00) == 0x00000000 {
|
||||
poke(0x4006EC00, 0x00009375);
|
||||
|
||||
@ -4,6 +4,7 @@ use super::control::ControlHandler;
|
||||
use super::descriptor::{BosWriter, DescriptorWriter};
|
||||
use super::driver::{Driver, EndpointAllocError};
|
||||
use super::types::*;
|
||||
use super::DeviceStateHandler;
|
||||
use super::UsbDevice;
|
||||
use super::MAX_INTERFACE_COUNT;
|
||||
|
||||
@ -119,6 +120,7 @@ impl<'a> Config<'a> {
|
||||
/// Used to build new [`UsbDevice`]s.
|
||||
pub struct UsbDeviceBuilder<'d, D: Driver<'d>> {
|
||||
config: Config<'d>,
|
||||
handler: Option<&'d dyn DeviceStateHandler>,
|
||||
interfaces: Vec<(u8, &'d mut dyn ControlHandler), MAX_INTERFACE_COUNT>,
|
||||
control_buf: &'d mut [u8],
|
||||
|
||||
@ -145,6 +147,7 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
|
||||
config_descriptor_buf: &'d mut [u8],
|
||||
bos_descriptor_buf: &'d mut [u8],
|
||||
control_buf: &'d mut [u8],
|
||||
handler: Option<&'d dyn DeviceStateHandler>,
|
||||
) -> Self {
|
||||
// Magic values specified in USB-IF ECN on IADs.
|
||||
if config.composite_with_iads
|
||||
@ -174,6 +177,7 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
|
||||
|
||||
UsbDeviceBuilder {
|
||||
driver,
|
||||
handler,
|
||||
config,
|
||||
interfaces: Vec::new(),
|
||||
control_buf,
|
||||
@ -187,20 +191,20 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
|
||||
}
|
||||
|
||||
/// Creates the [`UsbDevice`] instance with the configuration in this builder.
|
||||
pub async fn build(mut self) -> UsbDevice<'d, D> {
|
||||
pub fn build(mut self) -> UsbDevice<'d, D> {
|
||||
self.config_descriptor.end_configuration();
|
||||
self.bos_descriptor.end_bos();
|
||||
|
||||
UsbDevice::build(
|
||||
self.driver,
|
||||
self.config,
|
||||
self.handler,
|
||||
self.device_descriptor.into_buf(),
|
||||
self.config_descriptor.into_buf(),
|
||||
self.bos_descriptor.writer.into_buf(),
|
||||
self.interfaces,
|
||||
self.control_buf,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
/// Allocates a new interface number.
|
||||
|
||||
@ -11,7 +11,6 @@ pub trait Driver<'a> {
|
||||
type EndpointIn: EndpointIn + 'a;
|
||||
type ControlPipe: ControlPipe + 'a;
|
||||
type Bus: Bus + 'a;
|
||||
type EnableFuture: Future<Output = Self::Bus> + 'a;
|
||||
|
||||
/// Allocates an endpoint and specified endpoint parameters. This method is called by the device
|
||||
/// and class implementations to allocate endpoints, and can only be called before
|
||||
@ -47,7 +46,7 @@ pub trait Driver<'a> {
|
||||
|
||||
/// Enables and initializes the USB peripheral. Soon after enabling the device will be reset, so
|
||||
/// there is no need to perform a USB reset in this method.
|
||||
fn enable(self) -> Self::EnableFuture;
|
||||
fn into_bus(self) -> Self::Bus;
|
||||
|
||||
/// Indicates that `set_device_address` must be called before accepting the corresponding
|
||||
/// control transfer, not after.
|
||||
@ -57,19 +56,28 @@ pub trait Driver<'a> {
|
||||
}
|
||||
|
||||
pub trait Bus {
|
||||
type EnableFuture<'a>: Future<Output = ()> + 'a
|
||||
where
|
||||
Self: 'a;
|
||||
type DisableFuture<'a>: Future<Output = ()> + 'a
|
||||
where
|
||||
Self: 'a;
|
||||
type PollFuture<'a>: Future<Output = Event> + 'a
|
||||
where
|
||||
Self: 'a;
|
||||
type RemoteWakeupFuture<'a>: Future<Output = Result<(), Unsupported>> + 'a
|
||||
where
|
||||
Self: 'a;
|
||||
|
||||
/// Enables the USB peripheral. Soon after enabling the device will be reset, so
|
||||
/// there is no need to perform a USB reset in this method.
|
||||
fn enable(&mut self) -> Self::EnableFuture<'_>;
|
||||
|
||||
/// Disables and powers down the USB peripheral.
|
||||
fn disable(&mut self) -> Self::DisableFuture<'_>;
|
||||
|
||||
fn poll<'a>(&'a mut self) -> Self::PollFuture<'a>;
|
||||
|
||||
/// Called when the host resets the device. This will be soon called after
|
||||
/// [`poll`](crate::device::UsbDevice::poll) returns [`PollResult::Reset`]. This method should
|
||||
/// reset the state of all endpoints and peripheral flags back to a state suitable for
|
||||
/// enumeration, as well as ensure that all endpoints previously allocated with alloc_ep are
|
||||
/// initialized as specified.
|
||||
fn reset(&mut self);
|
||||
|
||||
/// Sets the device USB address to `addr`.
|
||||
fn set_device_address(&mut self, addr: u8);
|
||||
|
||||
@ -83,17 +91,6 @@ pub trait Bus {
|
||||
/// Gets whether the STALL condition is set for an endpoint. Only used during control transfers.
|
||||
fn is_stalled(&mut self, ep_addr: EndpointAddress) -> bool;
|
||||
|
||||
/// Causes the USB peripheral to enter USB suspend mode, lowering power consumption and
|
||||
/// preparing to detect a USB wakeup event. This will be called after
|
||||
/// [`poll`](crate::device::UsbDevice::poll) returns [`PollResult::Suspend`]. The device will
|
||||
/// continue be polled, and it shall return a value other than `Suspend` from `poll` when it no
|
||||
/// longer detects the suspend condition.
|
||||
fn suspend(&mut self);
|
||||
|
||||
/// Resumes from suspend mode. This may only be called after the peripheral has been previously
|
||||
/// suspended.
|
||||
fn resume(&mut self);
|
||||
|
||||
/// Simulates a disconnect from the USB bus, causing the host to reset and re-enumerate the
|
||||
/// device.
|
||||
///
|
||||
@ -106,6 +103,14 @@ pub trait Bus {
|
||||
fn force_reset(&mut self) -> Result<(), Unsupported> {
|
||||
Err(Unsupported)
|
||||
}
|
||||
|
||||
/// Initiates a remote wakeup of the host by the device.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * [`Unsupported`](crate::UsbError::Unsupported) - This UsbBus implementation doesn't support
|
||||
/// remote wakeup or it has not been enabled at creation time.
|
||||
fn remote_wakeup(&mut self) -> Self::RemoteWakeupFuture<'_>;
|
||||
}
|
||||
|
||||
pub trait Endpoint {
|
||||
|
||||
@ -10,15 +10,14 @@ pub mod control;
|
||||
pub mod descriptor;
|
||||
pub mod driver;
|
||||
pub mod types;
|
||||
mod util;
|
||||
|
||||
use embassy::util::{select, Either};
|
||||
use heapless::Vec;
|
||||
|
||||
use self::control::*;
|
||||
use self::descriptor::*;
|
||||
use self::driver::{Bus, Driver, Event};
|
||||
use self::types::*;
|
||||
use self::util::*;
|
||||
|
||||
pub use self::builder::Config;
|
||||
pub use self::builder::UsbDeviceBuilder;
|
||||
@ -28,8 +27,12 @@ pub use self::builder::UsbDeviceBuilder;
|
||||
/// In general class traffic is only possible in the `Configured` state.
|
||||
#[repr(u8)]
|
||||
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
pub enum UsbDeviceState {
|
||||
/// The USB device has just been created or reset.
|
||||
/// The USB device is disabled.
|
||||
Disabled,
|
||||
|
||||
/// The USB device has just been enabled or reset.
|
||||
Default,
|
||||
|
||||
/// The USB device has received an address from the host.
|
||||
@ -37,9 +40,19 @@ pub enum UsbDeviceState {
|
||||
|
||||
/// The USB device has been configured and is fully functional.
|
||||
Configured,
|
||||
}
|
||||
|
||||
/// The USB device has been suspended by the host or it has been unplugged from the USB bus.
|
||||
Suspend,
|
||||
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
pub enum RemoteWakeupError {
|
||||
InvalidState,
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
impl From<driver::Unsupported> for RemoteWakeupError {
|
||||
fn from(_: driver::Unsupported) -> Self {
|
||||
RemoteWakeupError::Unsupported
|
||||
}
|
||||
}
|
||||
|
||||
/// The bConfiguration value for the not configured state.
|
||||
@ -53,8 +66,30 @@ pub const DEFAULT_ALTERNATE_SETTING: u8 = 0;
|
||||
|
||||
pub const MAX_INTERFACE_COUNT: usize = 4;
|
||||
|
||||
/// A handler trait for changes in the device state of the [UsbDevice].
|
||||
pub trait DeviceStateHandler {
|
||||
/// Called when the USB device has been enabled or disabled.
|
||||
fn enabled(&self, _enabled: bool) {}
|
||||
|
||||
/// Called when the host resets the device.
|
||||
fn reset(&self) {}
|
||||
|
||||
/// Called when the host has set the address of the device to `addr`.
|
||||
fn addressed(&self, _addr: u8) {}
|
||||
|
||||
/// Called when the host has enabled or disabled the configuration of the device.
|
||||
fn configured(&self, _configured: bool) {}
|
||||
|
||||
/// Called when the bus has entered or exited the suspend state.
|
||||
fn suspended(&self, _suspended: bool) {}
|
||||
|
||||
/// Called when remote wakeup feature is enabled or disabled.
|
||||
fn remote_wakeup_enabled(&self, _enabled: bool) {}
|
||||
}
|
||||
|
||||
pub struct UsbDevice<'d, D: Driver<'d>> {
|
||||
bus: D::Bus,
|
||||
handler: Option<&'d dyn DeviceStateHandler>,
|
||||
control: ControlPipe<D::ControlPipe>,
|
||||
|
||||
config: Config<'d>,
|
||||
@ -64,6 +99,7 @@ pub struct UsbDevice<'d, D: Driver<'d>> {
|
||||
control_buf: &'d mut [u8],
|
||||
|
||||
device_state: UsbDeviceState,
|
||||
suspended: bool,
|
||||
remote_wakeup_enabled: bool,
|
||||
self_powered: bool,
|
||||
pending_address: u8,
|
||||
@ -72,9 +108,10 @@ pub struct UsbDevice<'d, D: Driver<'d>> {
|
||||
}
|
||||
|
||||
impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
|
||||
pub(crate) async fn build(
|
||||
pub(crate) fn build(
|
||||
mut driver: D,
|
||||
config: Config<'d>,
|
||||
handler: Option<&'d dyn DeviceStateHandler>,
|
||||
device_descriptor: &'d [u8],
|
||||
config_descriptor: &'d [u8],
|
||||
bos_descriptor: &'d [u8],
|
||||
@ -87,17 +124,19 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
|
||||
|
||||
// Enable the USB bus.
|
||||
// This prevent further allocation by consuming the driver.
|
||||
let bus = driver.enable().await;
|
||||
let bus = driver.into_bus();
|
||||
|
||||
Self {
|
||||
bus,
|
||||
config,
|
||||
handler,
|
||||
control: ControlPipe::new(control),
|
||||
device_descriptor,
|
||||
config_descriptor,
|
||||
bos_descriptor,
|
||||
control_buf,
|
||||
device_state: UsbDeviceState::Default,
|
||||
device_state: UsbDeviceState::Disabled,
|
||||
suspended: false,
|
||||
remote_wakeup_enabled: false,
|
||||
self_powered: false,
|
||||
pending_address: 0,
|
||||
@ -105,37 +144,130 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run(&mut self) {
|
||||
/// Runs the `UsbDevice` forever.
|
||||
///
|
||||
/// This future may leave the bus in an invalid state if it is dropped.
|
||||
/// After dropping the future, [`UsbDevice::disable()`] should be called
|
||||
/// before calling any other `UsbDevice` methods to fully reset the
|
||||
/// peripheral.
|
||||
pub async fn run(&mut self) -> ! {
|
||||
loop {
|
||||
self.run_until_suspend().await;
|
||||
self.wait_resume().await;
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs the `UsbDevice` until the bus is suspended.
|
||||
///
|
||||
/// This future may leave the bus in an invalid state if it is dropped.
|
||||
/// After dropping the future, [`UsbDevice::disable()`] should be called
|
||||
/// before calling any other `UsbDevice` methods to fully reset the
|
||||
/// peripheral.
|
||||
pub async fn run_until_suspend(&mut self) -> () {
|
||||
if self.device_state == UsbDeviceState::Disabled {
|
||||
self.bus.enable().await;
|
||||
self.device_state = UsbDeviceState::Default;
|
||||
|
||||
if let Some(h) = &self.handler {
|
||||
h.enabled(true);
|
||||
}
|
||||
}
|
||||
|
||||
loop {
|
||||
let control_fut = self.control.setup();
|
||||
let bus_fut = self.bus.poll();
|
||||
match select(bus_fut, control_fut).await {
|
||||
Either::Left(evt) => match evt {
|
||||
Either::First(evt) => {
|
||||
self.handle_bus_event(evt);
|
||||
if self.suspended {
|
||||
return;
|
||||
}
|
||||
}
|
||||
Either::Second(req) => match req {
|
||||
Setup::DataIn(req, stage) => self.handle_control_in(req, stage).await,
|
||||
Setup::DataOut(req, stage) => self.handle_control_out(req, stage).await,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Disables the USB peripheral.
|
||||
pub async fn disable(&mut self) {
|
||||
if self.device_state != UsbDeviceState::Disabled {
|
||||
self.bus.disable().await;
|
||||
self.device_state = UsbDeviceState::Disabled;
|
||||
self.suspended = false;
|
||||
self.remote_wakeup_enabled = false;
|
||||
|
||||
if let Some(h) = &self.handler {
|
||||
h.enabled(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Waits for a resume condition on the USB bus.
|
||||
///
|
||||
/// This future is cancel-safe.
|
||||
pub async fn wait_resume(&mut self) {
|
||||
while self.suspended {
|
||||
let evt = self.bus.poll().await;
|
||||
self.handle_bus_event(evt);
|
||||
}
|
||||
}
|
||||
|
||||
/// Initiates a device remote wakeup on the USB bus.
|
||||
///
|
||||
/// If the bus is not suspended or remote wakeup is not enabled, an error
|
||||
/// will be returned.
|
||||
///
|
||||
/// This future may leave the bus in an inconsistent state if dropped.
|
||||
/// After dropping the future, [`UsbDevice::disable()`] should be called
|
||||
/// before calling any other `UsbDevice` methods to fully reset the peripheral.
|
||||
pub async fn remote_wakeup(&mut self) -> Result<(), RemoteWakeupError> {
|
||||
if self.suspended && self.remote_wakeup_enabled {
|
||||
self.bus.remote_wakeup().await?;
|
||||
self.suspended = false;
|
||||
|
||||
if let Some(h) = &self.handler {
|
||||
h.suspended(false);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
} else {
|
||||
Err(RemoteWakeupError::InvalidState)
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_bus_event(&mut self, evt: Event) {
|
||||
match evt {
|
||||
Event::Reset => {
|
||||
trace!("usb: reset");
|
||||
self.bus.reset();
|
||||
|
||||
self.device_state = UsbDeviceState::Default;
|
||||
self.suspended = false;
|
||||
self.remote_wakeup_enabled = false;
|
||||
self.pending_address = 0;
|
||||
|
||||
for (_, h) in self.interfaces.iter_mut() {
|
||||
h.reset();
|
||||
}
|
||||
|
||||
if let Some(h) = &self.handler {
|
||||
h.reset();
|
||||
}
|
||||
}
|
||||
Event::Resume => {
|
||||
trace!("usb: resume");
|
||||
self.suspended = false;
|
||||
if let Some(h) = &self.handler {
|
||||
h.suspended(false);
|
||||
}
|
||||
}
|
||||
Event::Suspend => {
|
||||
trace!("usb: suspend");
|
||||
self.bus.suspend();
|
||||
self.device_state = UsbDeviceState::Suspend;
|
||||
self.suspended = true;
|
||||
if let Some(h) = &self.handler {
|
||||
h.suspended(true);
|
||||
}
|
||||
},
|
||||
Either::Right(req) => match req {
|
||||
Setup::DataIn(req, stage) => self.handle_control_in(req, stage).await,
|
||||
Setup::DataOut(req, stage) => self.handle_control_out(req, stage).await,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -156,20 +288,33 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
|
||||
(RequestType::Standard, Recipient::Device) => match (req.request, req.value) {
|
||||
(Request::CLEAR_FEATURE, Request::FEATURE_DEVICE_REMOTE_WAKEUP) => {
|
||||
self.remote_wakeup_enabled = false;
|
||||
if let Some(h) = &self.handler {
|
||||
h.remote_wakeup_enabled(false);
|
||||
}
|
||||
self.control.accept(stage)
|
||||
}
|
||||
(Request::SET_FEATURE, Request::FEATURE_DEVICE_REMOTE_WAKEUP) => {
|
||||
self.remote_wakeup_enabled = true;
|
||||
if let Some(h) = &self.handler {
|
||||
h.remote_wakeup_enabled(true);
|
||||
}
|
||||
self.control.accept(stage)
|
||||
}
|
||||
(Request::SET_ADDRESS, addr @ 1..=127) => {
|
||||
self.pending_address = addr as u8;
|
||||
self.bus.set_device_address(self.pending_address);
|
||||
self.device_state = UsbDeviceState::Addressed;
|
||||
if let Some(h) = &self.handler {
|
||||
h.addressed(self.pending_address);
|
||||
}
|
||||
self.control.accept(stage)
|
||||
}
|
||||
(Request::SET_CONFIGURATION, CONFIGURATION_VALUE_U16) => {
|
||||
self.device_state = UsbDeviceState::Configured;
|
||||
self.bus.set_configured(true);
|
||||
if let Some(h) = &self.handler {
|
||||
h.configured(true);
|
||||
}
|
||||
self.control.accept(stage)
|
||||
}
|
||||
(Request::SET_CONFIGURATION, CONFIGURATION_NONE_U16) => match self.device_state {
|
||||
@ -177,6 +322,9 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
|
||||
_ => {
|
||||
self.device_state = UsbDeviceState::Addressed;
|
||||
self.bus.set_configured(false);
|
||||
if let Some(h) = &self.handler {
|
||||
h.configured(false);
|
||||
}
|
||||
self.control.accept(stage)
|
||||
}
|
||||
},
|
||||
|
||||
@ -1,45 +0,0 @@
|
||||
use core::future::Future;
|
||||
use core::pin::Pin;
|
||||
use core::task::{Context, Poll};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Either<A, B> {
|
||||
Left(A),
|
||||
Right(B),
|
||||
}
|
||||
|
||||
pub fn select<A, B>(a: A, b: B) -> Select<A, B>
|
||||
where
|
||||
A: Future,
|
||||
B: Future,
|
||||
{
|
||||
Select { a, b }
|
||||
}
|
||||
|
||||
pub struct Select<A, B> {
|
||||
a: A,
|
||||
b: B,
|
||||
}
|
||||
|
||||
impl<A: Unpin, B: Unpin> Unpin for Select<A, B> {}
|
||||
|
||||
impl<A, B> Future for Select<A, B>
|
||||
where
|
||||
A: Future,
|
||||
B: Future,
|
||||
{
|
||||
type Output = Either<A::Output, B::Output>;
|
||||
|
||||
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
let this = unsafe { self.get_unchecked_mut() };
|
||||
let a = unsafe { Pin::new_unchecked(&mut this.a) };
|
||||
let b = unsafe { Pin::new_unchecked(&mut this.b) };
|
||||
match a.poll(cx) {
|
||||
Poll::Ready(x) => Poll::Ready(Either::Left(x)),
|
||||
Poll::Pending => match b.poll(cx) {
|
||||
Poll::Ready(x) => Poll::Ready(Either::Right(x)),
|
||||
Poll::Pending => Poll::Pending,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -4,16 +4,20 @@
|
||||
#![feature(type_alias_impl_trait)]
|
||||
|
||||
use core::mem;
|
||||
use core::sync::atomic::{AtomicBool, Ordering};
|
||||
use defmt::*;
|
||||
use embassy::channel::Signal;
|
||||
use embassy::executor::Spawner;
|
||||
use embassy::interrupt::InterruptExt;
|
||||
use embassy::time::Duration;
|
||||
use embassy::util::{select, select3, Either, Either3};
|
||||
use embassy_nrf::gpio::{Input, Pin, Pull};
|
||||
use embassy_nrf::interrupt;
|
||||
use embassy_nrf::pac;
|
||||
use embassy_nrf::usb::Driver;
|
||||
use embassy_nrf::Peripherals;
|
||||
use embassy_usb::control::OutResponse;
|
||||
use embassy_usb::{Config, UsbDeviceBuilder};
|
||||
use embassy_usb::{Config, DeviceStateHandler, UsbDeviceBuilder};
|
||||
use embassy_usb_hid::{HidClass, ReportId, RequestHandler, State};
|
||||
use futures::future::join;
|
||||
use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
|
||||
@ -21,6 +25,25 @@ use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
|
||||
use defmt_rtt as _; // global logger
|
||||
use 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(()) };
|
||||
@ -30,10 +53,6 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
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);
|
||||
@ -45,6 +64,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
config.serial_number = Some("12345678");
|
||||
config.max_power = 100;
|
||||
config.max_packet_size_0 = 64;
|
||||
config.supports_remote_wakeup = true;
|
||||
|
||||
// Create embassy-usb DeviceBuilder using the driver and config.
|
||||
// It needs some buffers for building the descriptors.
|
||||
@ -53,6 +73,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
let mut bos_descriptor = [0; 256];
|
||||
let mut control_buf = [0; 16];
|
||||
let request_handler = MyRequestHandler {};
|
||||
let device_state_handler = MyDeviceStateHandler::new();
|
||||
|
||||
let mut state = State::<8, 1>::new();
|
||||
|
||||
@ -63,6 +84,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
&mut config_descriptor,
|
||||
&mut bos_descriptor,
|
||||
&mut control_buf,
|
||||
Some(&device_state_handler),
|
||||
);
|
||||
|
||||
// Create classes on the builder.
|
||||
@ -76,10 +98,40 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
);
|
||||
|
||||
// Build the builder.
|
||||
let mut usb = builder.build().await;
|
||||
let mut usb = builder.build();
|
||||
|
||||
let remote_wakeup = Signal::new();
|
||||
|
||||
// Run the USB device.
|
||||
let usb_fut = usb.run();
|
||||
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),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let mut button = Input::new(p.P0_11.degrade(), Pull::Up);
|
||||
|
||||
@ -90,6 +142,11 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
loop {
|
||||
button.wait_for_low().await;
|
||||
info!("PRESSED");
|
||||
|
||||
if SUSPENDED.load(Ordering::Acquire) {
|
||||
info!("Triggering remote wakeup");
|
||||
remote_wakeup.signal(());
|
||||
} else {
|
||||
let report = KeyboardReport {
|
||||
keycodes: [4, 0, 0, 0, 0, 0],
|
||||
leds: 0,
|
||||
@ -100,6 +157,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
Ok(()) => {}
|
||||
Err(e) => warn!("Failed to send report: {:?}", e),
|
||||
};
|
||||
}
|
||||
|
||||
button.wait_for_high().await;
|
||||
info!("RELEASED");
|
||||
@ -119,11 +177,31 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
let out_fut = async {
|
||||
hid_out.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 {
|
||||
@ -146,3 +224,64 @@ impl RequestHandler for MyRequestHandler {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
struct MyDeviceStateHandler {
|
||||
configured: AtomicBool,
|
||||
}
|
||||
|
||||
impl MyDeviceStateHandler {
|
||||
fn new() -> Self {
|
||||
MyDeviceStateHandler {
|
||||
configured: AtomicBool::new(false),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DeviceStateHandler for MyDeviceStateHandler {
|
||||
fn enabled(&self, enabled: bool) {
|
||||
self.configured.store(false, Ordering::Relaxed);
|
||||
SUSPENDED.store(false, Ordering::Release);
|
||||
if enabled {
|
||||
info!("Device enabled");
|
||||
} else {
|
||||
info!("Device disabled");
|
||||
}
|
||||
}
|
||||
|
||||
fn reset(&self) {
|
||||
self.configured.store(false, Ordering::Relaxed);
|
||||
info!("Bus reset, the Vbus current limit is 100mA");
|
||||
}
|
||||
|
||||
fn addressed(&self, addr: u8) {
|
||||
self.configured.store(false, Ordering::Relaxed);
|
||||
info!("USB address set to: {}", addr);
|
||||
}
|
||||
|
||||
fn configured(&self, configured: bool) {
|
||||
self.configured.store(configured, Ordering::Relaxed);
|
||||
if configured {
|
||||
info!(
|
||||
"Device configured, it may now draw up to the configured current limit from Vbus."
|
||||
)
|
||||
} else {
|
||||
info!("Device is no longer configured, the Vbus current limit is 100mA.");
|
||||
}
|
||||
}
|
||||
|
||||
fn suspended(&self, suspended: bool) {
|
||||
if suspended {
|
||||
info!("Device suspended, the Vbus current limit is 500µA (or 2.5mA for high-power devices with remote wakeup enabled).");
|
||||
SUSPENDED.store(true, Ordering::Release);
|
||||
} else {
|
||||
SUSPENDED.store(false, Ordering::Release);
|
||||
if self.configured.load(Ordering::Relaxed) {
|
||||
info!(
|
||||
"Device resumed, it may now draw up to the configured current limit from Vbus"
|
||||
);
|
||||
} else {
|
||||
info!("Device resumed, the Vbus current limit is 100mA");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -61,6 +61,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
&mut config_descriptor,
|
||||
&mut bos_descriptor,
|
||||
&mut control_buf,
|
||||
None,
|
||||
);
|
||||
|
||||
// Create classes on the builder.
|
||||
@ -74,7 +75,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
);
|
||||
|
||||
// Build the builder.
|
||||
let mut usb = builder.build().await;
|
||||
let mut usb = builder.build();
|
||||
|
||||
// Run the USB device.
|
||||
let usb_fut = usb.run();
|
||||
|
||||
@ -54,13 +54,14 @@ async fn main(_spawner: Spawner, p: Peripherals) {
|
||||
&mut config_descriptor,
|
||||
&mut bos_descriptor,
|
||||
&mut control_buf,
|
||||
None,
|
||||
);
|
||||
|
||||
// Create classes on the builder.
|
||||
let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
|
||||
|
||||
// Build the builder.
|
||||
let mut usb = builder.build().await;
|
||||
let mut usb = builder.build();
|
||||
|
||||
// Run the USB device.
|
||||
let usb_fut = usb.run();
|
||||
|
||||
@ -79,13 +79,14 @@ async fn main(spawner: Spawner, p: Peripherals) {
|
||||
&mut res.config_descriptor,
|
||||
&mut res.bos_descriptor,
|
||||
&mut res.control_buf,
|
||||
None,
|
||||
);
|
||||
|
||||
// Create classes on the builder.
|
||||
let class = CdcAcmClass::new(&mut builder, &mut res.serial_state, 64);
|
||||
|
||||
// Build the builder.
|
||||
let usb = builder.build().await;
|
||||
let usb = builder.build();
|
||||
|
||||
unwrap!(spawner.spawn(usb_task(usb)));
|
||||
unwrap!(spawner.spawn(echo_task(class)));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user