Merge pull request #4745 from embassy-rs/io07

Update to embedded-io 0.7

1 files changed, 45 insertions, 6 deletions

diff --git a/embassy-usb/src/class/cdc_acm.rs b/embassy-usb/src/class/cdc_acm.rs
index ab2311f4e..56acdb2a6 100644
--- a/embassy-usb/src/class/cdc_acm.rs
+++ b/embassy-usb/src/class/cdc_acm.rs
@@ -33,6 +33,30 @@ const REQ_SET_LINE_CODING: u8 = 0x20;
 const REQ_GET_LINE_CODING: u8 = 0x21;
 const REQ_SET_CONTROL_LINE_STATE: u8 = 0x22;
 
+/// CDC ACM error.
+#[derive(Clone, Debug)]
+pub enum CdcAcmError {
+    /// USB is not connected.
+    NotConnected,
+}
+
+impl core::fmt::Display for CdcAcmError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            Self::NotConnected => f.write_str("NotConnected"),
+        }
+    }
+}
+
+impl core::error::Error for CdcAcmError {}
+impl embedded_io_async::Error for CdcAcmError {
+    fn kind(&self) -> embedded_io_async::ErrorKind {
+        match *self {
+            Self::NotConnected => embedded_io_async::ErrorKind::NotConnected,
+        }
+    }
+}
+
 /// Internal state for CDC-ACM
 pub struct State<'a> {
     control: MaybeUninit<Control<'a>>,
@@ -421,14 +445,21 @@ impl<'d, D: Driver<'d>> Sender<'d, D> {
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::ErrorType for Sender<'d, D> {
-    type Error = EndpointError;
+    type Error = CdcAcmError;
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::Write for Sender<'d, D> {
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         let len = core::cmp::min(buf.len(), self.max_packet_size() as usize);
-        self.write_packet(&buf[..len]).await?;
-        Ok(len)
+        match self.write_packet(&buf[..len]).await {
+            Ok(()) => Ok(len),
+            Err(EndpointError::BufferOverflow) => unreachable!(),
+            Err(EndpointError::Disabled) => Err(CdcAcmError::NotConnected),
+        }
+    }
+
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
     }
 }
 
@@ -539,7 +570,7 @@ impl<'d, D: Driver<'d>> BufferedReceiver<'d, D> {
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::ErrorType for BufferedReceiver<'d, D> {
-    type Error = EndpointError;
+    type Error = CdcAcmError;
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::Read for BufferedReceiver<'d, D> {
@@ -552,14 +583,22 @@ impl<'d, D: Driver<'d>> embedded_io_async::Read for BufferedReceiver<'d, D> {
         // If the caller's buffer is large enough to contain an entire packet, read directly into
         // that instead of buffering the packet internally.
         if buf.len() > self.receiver.max_packet_size() as usize {
-            return self.receiver.read_packet(buf).await;
+            return match self.receiver.read_packet(buf).await {
+                Ok(n) => Ok(n),
+                Err(EndpointError::BufferOverflow) => unreachable!(),
+                Err(EndpointError::Disabled) => Err(CdcAcmError::NotConnected),
+            };
         }
 
         // Otherwise read a packet into the internal buffer, and return some of it to the caller.
         //
         // It's important that `start` and `end` be updated in this order so they're left in a
         // consistent state if the `read` future is dropped mid-execution, e.g. from a timeout.
-        self.end = self.receiver.read_packet(&mut self.buffer).await?;
+        match self.receiver.read_packet(&mut self.buffer).await {
+            Ok(n) => self.end = n,
+            Err(EndpointError::BufferOverflow) => unreachable!(),
+            Err(EndpointError::Disabled) => return Err(CdcAcmError::NotConnected),
+        }
         self.start = 0;
         return Ok(self.read_from_buffer(buf));
     }