Make Driver::disable async and fix comment

embassy-nrf/src/usb.rs

@@ -208,6 +208,7 @@ pub struct Bus<'d, T: Instance> {
 
 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;
 
@@ -248,10 +249,12 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
         }
     }
 
-    fn disable(&mut self) {
+    fn disable(&mut self) -> Self::DisableFuture<'_> {
+        async move {
             let regs = T::regs();
             regs.enable.write(|x| x.enable().disabled());
         }
+    }
 
     fn poll<'a>(&'a mut self) -> Self::PollFuture<'a> {
         poll_fn(move |cx| {

embassy-usb/src/driver.rs

@@ -57,6 +57,9 @@ 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
@@ -71,7 +74,7 @@ pub trait Bus {
     fn enable(&mut self) -> Self::EnableFuture<'_>;
 
     /// Disables and powers down the USB peripheral.
-    fn disable(&mut self);
+    fn disable(&mut self) -> Self::DisableFuture<'_>;
 
     fn poll<'a>(&'a mut self) -> Self::PollFuture<'a>;
 
@@ -103,8 +106,6 @@ pub trait Bus {
 
     /// Initiates a remote wakeup of the host by the device.
     ///
-    /// The default implementation just returns `Unsupported`.
-    ///
     /// # Errors
     ///
     /// * [`Unsupported`](crate::UsbError::Unsupported) - This UsbBus implementation doesn't support

embassy-usb/src/lib.rs

@@ -198,7 +198,7 @@ impl<'d, D: Driver<'d>, M: RawMutex> UsbDevice<'d, D, M> {
                     DeviceCommand::Enable => warn!("usb: Enable command received while enabled."),
                     DeviceCommand::Disable => {
                         trace!("usb: disable");
-                        self.bus.disable();
+                        self.bus.disable().await;
                         self.device_state = UsbDeviceState::Disabled;
                         if let Some(h) = &self.handler {
                             h.disabled();