e-h-async: document fixes and inline hints.

Signed-off-by: Zhouqi Jiang <[email protected]>

Author: luojia65

embedded-hal-async/src/delay.rs

@@ -1,6 +1,6 @@
-//! Delays
+//! Delays.
 
-/// Microsecond delay
+/// Microsecond delay.
 pub trait DelayUs {
     /// Pauses execution for at minimum `us` microseconds. Pause can be longer
     /// if the implementation requires it due to precision/timing issues.
@@ -15,10 +15,12 @@ impl<T> DelayUs for &mut T
 where
     T: DelayUs + ?Sized,
 {
+    #[inline]
     async fn delay_us(&mut self, us: u32) {
         T::delay_us(self, us).await
     }
 
+    #[inline]
     async fn delay_ms(&mut self, ms: u32) {
         T::delay_ms(self, ms).await
     }

embedded-hal-async/src/digital.rs

@@ -1,4 +1,4 @@
-//! Asynchronous digital I/O
+//! Asynchronous digital I/O.
 //!
 //! # Example
 //!
@@ -49,22 +49,27 @@ pub trait Wait: embedded_hal::digital::ErrorType {
 }
 
 impl<T: Wait + ?Sized> Wait for &mut T {
+    #[inline]
     async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
         T::wait_for_high(self).await
     }
 
+    #[inline]
     async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
         T::wait_for_low(self).await
     }
 
+    #[inline]
     async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
         T::wait_for_rising_edge(self).await
     }
 
+    #[inline]
     async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
         T::wait_for_falling_edge(self).await
     }
 
+    #[inline]
     async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
         T::wait_for_any_edge(self).await
     }

embedded-hal-async/src/i2c.rs

@@ -1,4 +1,4 @@
-//! Async I2C API
+//! Async I2C API.
 //!
 //! This API supports 7-bit and 10-bit addresses. Traits feature an `AddressMode`
 //! marker type parameter. Two implementation of the `AddressMode` exist:
@@ -21,9 +21,9 @@ pub use embedded_hal::i2c::{
     AddressMode, Error, ErrorKind, ErrorType, NoAcknowledgeSource, SevenBitAddress, TenBitAddress,
 };
 
-/// Async i2c
+/// Async I2c.
 pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
-    /// Reads enough bytes from slave with `address` to fill `buffer`
+    /// Reads enough bytes from slave with `address` to fill `buffer`.
     ///
     /// # I2C Events (contract)
     ///
@@ -41,12 +41,13 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `MAK` = master acknowledge
     /// - `NMAK` = master no acknowledge
     /// - `SP` = stop condition
+    #[inline]
     async fn read(&mut self, address: A, read: &mut [u8]) -> Result<(), Self::Error> {
         self.transaction(address, &mut [Operation::Read(read)])
             .await
     }
 
-    /// Writes bytes to slave with address `address`
+    /// Writes bytes to slave with address `address`.
     ///
     /// # I2C Events (contract)
     ///
@@ -62,6 +63,7 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `SAK` = slave acknowledge
     /// - `Bi` = ith byte of data
     /// - `SP` = stop condition
+    #[inline]
     async fn write(&mut self, address: A, write: &[u8]) -> Result<(), Self::Error> {
         self.transaction(address, &mut [Operation::Write(write)])
             .await
@@ -89,6 +91,7 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `MAK` = master acknowledge
     /// - `NMAK` = master no acknowledge
     /// - `SP` = stop condition
+    #[inline]
     async fn write_read(
         &mut self,
         address: A,
@@ -123,14 +126,17 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
 }
 
 impl<A: AddressMode, T: I2c<A> + ?Sized> I2c<A> for &mut T {
+    #[inline]
     async fn read(&mut self, address: A, read: &mut [u8]) -> Result<(), Self::Error> {
         T::read(self, address, read).await
     }
 
+    #[inline]
     async fn write(&mut self, address: A, write: &[u8]) -> Result<(), Self::Error> {
         T::write(self, address, write).await
     }
 
+    #[inline]
     async fn write_read(
         &mut self,
         address: A,
@@ -140,6 +146,7 @@ impl<A: AddressMode, T: I2c<A> + ?Sized> I2c<A> for &mut T {
         T::write_read(self, address, write, read).await
     }
 
+    #[inline]
     async fn transaction(
         &mut self,
         address: A,

embedded-hal-async/src/spi.rs

@@ -4,7 +4,7 @@ pub use embedded_hal::spi::{
     Error, ErrorKind, ErrorType, Mode, Operation, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3,
 };
 
-/// SPI device trait
+/// SPI device trait.
 ///
 /// `SpiDevice` represents ownership over a single SPI device on a (possibly shared) bus, selected
 /// with a CS (Chip Select) pin.
@@ -36,6 +36,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     /// This is a convenience method equivalent to `device.read_transaction(&mut [buf])`.
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiDevice::read`]
+    #[inline]
     async fn read(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::Read(buf)]).await
     }
@@ -45,6 +46,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     /// This is a convenience method equivalent to `device.write_transaction(&mut [buf])`.
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiDevice::write`]
+    #[inline]
     async fn write(&mut self, buf: &[Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::Write(buf)]).await
     }
@@ -54,6 +56,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     /// This is a convenience method equivalent to `device.transaction(|bus| bus.transfer(read, write))`.
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiBus::transfer`]
+    #[inline]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::Transfer(read, write)])
             .await
@@ -64,38 +67,44 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     /// This is a convenience method equivalent to `device.transaction(|bus| bus.transfer_in_place(buf))`.
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiBus::transfer_in_place`]
+    #[inline]
     async fn transfer_in_place(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::TransferInPlace(buf)])
             .await
     }
 }
 
 impl<Word: Copy + 'static, T: SpiDevice<Word> + ?Sized> SpiDevice<Word> for &mut T {
+    #[inline]
     async fn transaction(
         &mut self,
         operations: &mut [Operation<'_, Word>],
     ) -> Result<(), Self::Error> {
         T::transaction(self, operations).await
     }
 
+    #[inline]
     async fn read(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         T::read(self, buf).await
     }
 
+    #[inline]
     async fn write(&mut self, buf: &[Word]) -> Result<(), Self::Error> {
         T::write(self, buf).await
     }
 
+    #[inline]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error> {
         T::transfer(self, read, write).await
     }
 
+    #[inline]
     async fn transfer_in_place(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         T::transfer_in_place(self, buf).await
     }
 }
 
-/// SPI bus
+/// SPI bus.
 ///
 /// `SpiBus` represents **exclusive ownership** over the whole SPI bus, with SCK, MOSI and MISO pins.
 ///
@@ -110,7 +119,7 @@ pub trait SpiBus<Word: 'static + Copy = u8>: ErrorType {
     /// complete. See (the docs on embedded-hal)[embedded_hal::spi] for details on flushing.
     async fn read(&mut self, words: &mut [Word]) -> Result<(), Self::Error>;
 
-    /// Write `words` to the slave, ignoring all the incoming words
+    /// Write `words` to the slave, ignoring all the incoming words.
     ///
     /// Implementations are allowed to return before the operation is
     /// complete. See (the docs on embedded-hal)[embedded_hal::spi] for details on flushing.
@@ -144,22 +153,27 @@ pub trait SpiBus<Word: 'static + Copy = u8>: ErrorType {
 }
 
 impl<T: SpiBus<Word> + ?Sized, Word: 'static + Copy> SpiBus<Word> for &mut T {
+    #[inline]
     async fn read(&mut self, words: &mut [Word]) -> Result<(), Self::Error> {
         T::read(self, words).await
     }
 
+    #[inline]
     async fn write(&mut self, words: &[Word]) -> Result<(), Self::Error> {
         T::write(self, words).await
     }
 
+    #[inline]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error> {
         T::transfer(self, read, write).await
     }
 
+    #[inline]
     async fn transfer_in_place(&mut self, words: &mut [Word]) -> Result<(), Self::Error> {
         T::transfer_in_place(self, words).await
     }
 
+    #[inline]
     async fn flush(&mut self) -> Result<(), Self::Error> {
         T::flush(self).await
     }