Reformat code

Author: mvirkkunen

src/bus.rs

@@ -1,9 +1,9 @@
+use crate::endpoint::{Endpoint, EndpointAddress, EndpointDirection, EndpointType};
+use crate::{Result, UsbDirection, UsbError};
 use core::cell::RefCell;
-use core::sync::atomic::{AtomicPtr, Ordering};
 use core::mem;
 use core::ptr;
-use crate::{Result, UsbDirection, UsbError};
-use crate::endpoint::{Endpoint, EndpointDirection, EndpointType, EndpointAddress};
+use core::sync::atomic::{AtomicPtr, Ordering};
 
 /// A trait for device-specific USB peripherals. Implement this to add support for a new hardware
 /// platform.
@@ -41,7 +41,8 @@ pub trait UsbBus: Sync + Sized {
         ep_addr: Option<EndpointAddress>,
         ep_type: EndpointType,
         max_packet_size: u16,
-        interval: u8) -> Result<EndpointAddress>;
+        interval: u8,
+    ) -> Result<EndpointAddress>;
 
     /// 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.
@@ -215,14 +216,11 @@ impl<B: UsbBus> UsbBusAllocator<B> {
         ep_addr: Option<EndpointAddress>,
         ep_type: EndpointType,
         max_packet_size: u16,
-        interval: u8) -> Result<Endpoint<'_, B, D>>
-    {
-        self.bus.borrow_mut()
-            .alloc_ep(
-                D::DIRECTION,
-                ep_addr, ep_type,
-                max_packet_size,
-                interval)
+        interval: u8,
+    ) -> Result<Endpoint<'_, B, D>> {
+        self.bus
+            .borrow_mut()
+            .alloc_ep(D::DIRECTION, ep_addr, ep_type, max_packet_size, interval)
             .map(|a| Endpoint::new(&self.bus_ptr, a, ep_type, max_packet_size, interval))
     }
 
@@ -242,7 +240,8 @@ impl<B: UsbBus> UsbBusAllocator<B> {
     /// feasibly recoverable.
     #[inline]
     pub fn control<D: EndpointDirection>(&self, max_packet_size: u16) -> Endpoint<'_, B, D> {
-        self.alloc(None, EndpointType::Control, max_packet_size, 0).expect("alloc_ep failed")
+        self.alloc(None, EndpointType::Control, max_packet_size, 0)
+            .expect("alloc_ep failed")
     }
 
     /// Allocates a bulk endpoint.
@@ -257,7 +256,8 @@ impl<B: UsbBus> UsbBusAllocator<B> {
     /// feasibly recoverable.
     #[inline]
     pub fn bulk<D: EndpointDirection>(&self, max_packet_size: u16) -> Endpoint<'_, B, D> {
-        self.alloc(None, EndpointType::Bulk, max_packet_size, 0).expect("alloc_ep failed")
+        self.alloc(None, EndpointType::Bulk, max_packet_size, 0)
+            .expect("alloc_ep failed")
     }
 
     /// Allocates an interrupt endpoint.
@@ -269,11 +269,12 @@ impl<B: UsbBus> UsbBusAllocator<B> {
     /// Panics if endpoint allocation fails, because running out of endpoints or memory is not
     /// feasibly recoverable.
     #[inline]
-    pub fn interrupt<D: EndpointDirection>(&self, max_packet_size: u16, interval: u8)
-        -> Endpoint<'_, B, D>
-    {
-        self
-            .alloc(None, EndpointType::Interrupt, max_packet_size, interval)
+    pub fn interrupt<D: EndpointDirection>(
+        &self,
+        max_packet_size: u16,
+        interval: u8,
+    ) -> Endpoint<'_, B, D> {
+        self.alloc(None, EndpointType::Interrupt, max_packet_size, interval)
             .expect("alloc_ep failed")
     }
 }
@@ -283,7 +284,9 @@ impl<B: UsbBus> UsbBusAllocator<B> {
 pub struct InterfaceNumber(u8);
 
 impl From<InterfaceNumber> for u8 {
-    fn from(n: InterfaceNumber) -> u8 { n.0 }
+    fn from(n: InterfaceNumber) -> u8 {
+        n.0
+    }
 }
 
 /// A handle for a USB string descriptor that contains its index.
@@ -297,7 +300,9 @@ impl StringIndex {
 }
 
 impl From<StringIndex> for u8 {
-    fn from(i: StringIndex) -> u8 { i.0 }
+    fn from(i: StringIndex) -> u8 {
+        i.0
+    }
 }
 
 /// Event and incoming packet information returned by [`UsbBus::poll`].
@@ -322,7 +327,7 @@ pub enum PollResult {
 
         /// A SETUP packet has been received. This event should continue to be reported until the
         /// packet is read. The corresponding bit in `ep_out` may also be set but is ignored.
-        ep_setup: u16
+        ep_setup: u16,
     },
 
     /// A USB suspend request has been detected or, in the case of self-powered devices, the device
@@ -332,4 +337,4 @@ pub enum PollResult {
     /// A USB resume request has been detected after being suspended or, in the case of self-powered
     /// devices, the device has been connected to the USB bus.
     Resume,
-}
+}

src/class.rs

@@ -1,9 +1,9 @@
-use crate::{Result, UsbError};
-use crate::bus::{UsbBus, StringIndex};
-use crate::descriptor::{DescriptorWriter, BosWriter};
+use crate::bus::{StringIndex, UsbBus};
 use crate::control;
 use crate::control_pipe::ControlPipe;
+use crate::descriptor::{BosWriter, DescriptorWriter};
 use crate::endpoint::EndpointAddress;
+use crate::{Result, UsbError};
 
 /// A trait for implementing USB classes.
 ///
@@ -21,7 +21,7 @@ pub trait UsbClass<B: UsbBus> {
     /// using `?`.
     fn get_configuration_descriptors(&self, writer: &mut DescriptorWriter) -> Result<()> {
         let _ = writer;
-        Ok (())
+        Ok(())
     }
 
     /// Called when a GET_DESCRIPTOR request is received for a BOS descriptor.
@@ -30,7 +30,7 @@ pub trait UsbClass<B: UsbBus> {
     /// [UsbDevice](crate::device::UsbDevice) and shouldn't be written by classes.
     fn get_bos_descriptors(&self, writer: &mut BosWriter) -> Result<()> {
         let _ = writer;
-        Ok (())
+        Ok(())
     }
 
     /// Gets a class-specific string descriptor.
@@ -49,10 +49,10 @@ pub trait UsbClass<B: UsbBus> {
     }
 
     /// Called after a USB reset after the bus reset sequence is complete.
-    fn reset(&mut self) { }
+    fn reset(&mut self) {}
 
     /// Called whenever the `UsbDevice` is polled.
-    fn poll(&mut self) { }
+    fn poll(&mut self) {}
 
     /// Called when a control request is received with direction HostToDevice.
     ///
@@ -126,7 +126,7 @@ pub struct ControlIn<'a, 'p, 'r, B: UsbBus> {
     req: &'r control::Request,
 }
 
-impl<'a, 'p, 'r, B: UsbBus> ControlIn<'a, 'p, 'r,  B> {
+impl<'a, 'p, 'r, B: UsbBus> ControlIn<'a, 'p, 'r, B> {
     pub(crate) fn new(pipe: &'p mut ControlPipe<'a, B>, req: &'r control::Request) -> Self {
         ControlIn { pipe, req }
     }

src/control.rs

@@ -105,9 +105,11 @@ impl Request {
         Ok(Request {
             direction: rt.into(),
             request_type: unsafe { mem::transmute((rt >> 5) & 0b11) },
-            recipient:
-                if recipient <= 3 { unsafe { mem::transmute(recipient) } }
-                else { Recipient::Reserved },
+            recipient: if recipient <= 3 {
+                unsafe { mem::transmute(recipient) }
+            } else {
+                Recipient::Reserved
+            },
             request: buf[1],
             value: (buf[2] as u16) | ((buf[3] as u16) << 8),
             index: (buf[4] as u16) | ((buf[5] as u16) << 8),

src/control_pipe.rs

@@ -1,8 +1,8 @@
-use core::cmp::min;
-use crate::{Result, UsbDirection, UsbError};
 use crate::bus::UsbBus;
 use crate::control::Request;
 use crate::endpoint::{EndpointIn, EndpointOut};
+use crate::{Result, UsbDirection, UsbError};
+use core::cmp::min;
 
 #[derive(Debug)]
 #[allow(unused)]
@@ -81,17 +81,17 @@ impl<B: UsbBus> ControlPipe<'_, B> {
                 // Failed to parse SETUP packet
                 self.set_error();
                 return None;
-            },
+            }
         };
 
         // Now that we have properly parsed the setup packet, ensure the end-point is no longer in
         // a stalled state.
         self.ep_out.unstall();
 
         /*sprintln!("SETUP {:?} {:?} {:?} req:{} val:{} idx:{} len:{} {:?}",
-            req.direction, req.request_type, req.recipient,
-            req.request, req.value, req.index, req.length,
-            self.state);*/
+        req.direction, req.request_type, req.recipient,
+        req.request, req.value, req.index, req.length,
+        self.state);*/
 
         if req.direction == UsbDirection::Out {
             // OUT transfer
@@ -137,7 +137,7 @@ impl<B: UsbBus> ControlPipe<'_, B> {
                         // sends more data than it indicated in the SETUP request)
                         self.set_error();
                         return None;
-                    },
+                    }
                 };
 
                 self.i += count;
@@ -146,18 +146,18 @@ impl<B: UsbBus> ControlPipe<'_, B> {
                     self.state = ControlState::CompleteOut;
                     return Some(req);
                 }
-            },
+            }
             ControlState::StatusOut => {
                 self.ep_out.read(&mut []).ok();
                 self.state = ControlState::Idle;
-            },
+            }
             _ => {
                 // Discard the packet
                 self.ep_out.read(&mut []).ok();
 
                 // Unexpected OUT packet
                 self.set_error()
-            },
+            }
         }
 
         return None;
@@ -167,7 +167,7 @@ impl<B: UsbBus> ControlPipe<'_, B> {
         match self.state {
             ControlState::DataIn => {
                 self.write_in_chunk();
-            },
+            }
             ControlState::DataInZlp => {
                 if self.ep_in.write(&[]).is_err() {
                     // There isn't much we can do if the write fails, except to wait for another
@@ -176,15 +176,15 @@ impl<B: UsbBus> ControlPipe<'_, B> {
                 }
 
                 self.state = ControlState::DataInLast;
-            },
+            }
             ControlState::DataInLast => {
                 self.ep_out.unstall();
                 self.state = ControlState::StatusOut;
-            },
+            }
             ControlState::StatusIn => {
                 self.state = ControlState::Idle;
                 return true;
-            },
+            }
             _ => {
                 // Unexpected IN packet
                 self.set_error();
@@ -198,7 +198,7 @@ impl<B: UsbBus> ControlPipe<'_, B> {
         let count = min(self.len - self.i, self.ep_in.max_packet_size() as usize);
 
         let buffer = self.static_in_buf.unwrap_or(&self.buf);
-        let count = match self.ep_in.write(&buffer[self.i..(self.i+count)]) {
+        let count = match self.ep_in.write(&buffer[self.i..(self.i + count)]) {
             Ok(c) => c,
             // There isn't much we can do if the write fails, except to wait for another poll or for
             // the host to resend the request.
@@ -220,7 +220,7 @@ impl<B: UsbBus> ControlPipe<'_, B> {
 
     pub fn accept_out(&mut self) -> Result<()> {
         match self.state {
-            ControlState::CompleteOut => {},
+            ControlState::CompleteOut => {}
             _ => return Err(UsbError::InvalidState),
         };