chore: Bus move default impls to device & uninit device

Signed-off-by: Lachezar Lechev <elpiel93@gmail.com>

src/bus/mod.rs

@@ -23,109 +23,6 @@ pub trait Bus {
     fn read_frame(&mut self, block: u8, address: u16, data: &mut [u8]) -> Result<(), Self::Error>;
 
     fn write_frame(&mut self, block: u8, address: u16, data: &[u8]) -> Result<(), Self::Error>;
-
-    /// Reset the device
-    #[inline]
-    fn reset(&mut self) -> Result<(), Self::Error> {
-        self.write_frame(
-            register::COMMON,
-            register::common::MODE,
-            &register::common::Mode::Reset.to_register(),
-        )?;
-
-        Ok(())
-    }
-
-    #[inline]
-    fn set_mode(&mut self, mode_options: register::common::Mode) -> Result<(), Self::Error> {
-        self.write_frame(
-            register::COMMON,
-            register::common::MODE,
-            &mode_options.to_register(),
-        )?;
-        Ok(())
-    }
-
-    #[inline]
-    fn version(&mut self) -> Result<u8, Self::Error> {
-        let mut version_register = [0_u8];
-        self.read_frame(
-            register::COMMON,
-            register::common::VERSION,
-            &mut version_register,
-        )?;
-
-        Ok(version_register[0])
-    }
-
-    /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
-    ///
-    /// # Example
-    /// ```
-    /// use w5500::register::common::RetryTime;
-    ///
-    /// let default = RetryTime::from_millis(200);
-    /// assert_eq!(RetryTime::default(), default);
-    ///
-    /// // E.g. 4000 (register) = 400ms
-    /// let four_hundred_ms = RetryTime::from_millis(400);
-    /// assert_eq!(four_hundred_ms.to_u16(), 4000);
-    /// ```
-    #[inline]
-    fn set_retry_timeout(&mut self, retry_time_value: RetryTime) -> Result<(), Self::Error> {
-        self.write_frame(
-            register::COMMON,
-            register::common::RETRY_TIME,
-            &retry_time_value.to_register(),
-        )?;
-
-        Ok(())
-    }
-
-    /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
-    ///
-    /// E.g. 4000 = 400ms
-    #[inline]
-    fn current_retry_timeout(&mut self) -> Result<RetryTime, Self::Error> {
-        let mut retry_time_register: [u8; 2] = [0, 0];
-        self.read_frame(
-            register::COMMON,
-            register::common::RETRY_TIME,
-            &mut retry_time_register,
-        )?;
-
-        Ok(RetryTime::from_register(retry_time_register))
-    }
-
-    /// Set a new value for the Retry Count register.
-    ///
-    /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
-    fn set_retry_count(&mut self, retry_count: RetryCount) -> Result<(), Self::Error> {
-        self.write_frame(
-            register::COMMON,
-            register::common::RETRY_COUNT,
-            &retry_count.to_register(),
-        )?;
-
-        Ok(())
-    }
-
-    /// Get the current Retry Count value
-    /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
-    ///
-    /// E.g. In case of errors it will retry for 7 times:
-    /// `RCR = 0x0007`
-    #[inline]
-    fn current_retry_count(&mut self) -> Result<RetryCount, Self::Error> {
-        let mut retry_count_register: [u8; 1] = [0];
-        self.read_frame(
-            register::COMMON,
-            register::common::RETRY_COUNT,
-            &mut retry_count_register,
-        )?;
-
-        Ok(RetryCount::from_register(retry_count_register))
-    }
 }
 
 pub struct BusRef<'a, B: Bus>(pub &'a mut B);

src/device.rs

@@ -56,7 +56,7 @@ impl<SpiBus: Bus, HostImpl: Host> Device<SpiBus, HostImpl> {
 
     fn clear_mode(&mut self) -> Result<(), SpiBus::Error> {
         // Set RST common register of the w5500
-        self.bus.reset()
+        self.as_mut().reset()
     }
 
     #[inline]
@@ -102,6 +102,7 @@ impl<SpiBus: Bus, HostImpl: Host> Device<SpiBus, HostImpl> {
     /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
     ///
     /// # Example
+    ///
     /// ```
     /// use w5500::register::common::RetryTime;
     ///
@@ -228,28 +229,38 @@ impl<SpiBus: Bus, HostImpl: Host> DeviceRefMut<'_, SpiBus, HostImpl> {
         Ok(phy[0].into())
     }
 
-    pub fn version(&mut self) -> Result<u8, SpiBus::Error> {
+    /// Reset the device
-        let mut version = [0u8];
-        self.bus
-            .read_frame(register::COMMON, register::common::VERSION, &mut version)?;
-        Ok(version[0])
-    }
-
-    /// Get the currently set Retry Time-value Register.
-    ///
-    /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
-    ///
-    /// E.g. 4000 = 400ms
     #[inline]
-    pub fn current_retry_timeout(&mut self) -> Result<RetryTime, SpiBus::Error> {
+    fn reset(&mut self) -> Result<(), SpiBus::Error> {
-        self.bus.current_retry_timeout()
+        self.set_mode(register::common::Mode::Reset)
+    }
+
+    #[inline]
+    fn set_mode(&mut self, mode_options: register::common::Mode) -> Result<(), SpiBus::Error> {
+        self.bus.write_frame(
+            register::COMMON,
+            register::common::MODE,
+            &mode_options.to_register(),
+        )?;
+        Ok(())
+    }
+
+    #[inline]
+    fn version(&mut self) -> Result<u8, SpiBus::Error> {
+        let mut version_register = [0_u8];
+        self.bus.read_frame(
+            register::COMMON,
+            register::common::VERSION,
+            &mut version_register,
+        )?;
+
+        Ok(version_register[0])
     }
 
-    /// Set a new value for the Retry Time-value Register.
-    ///
     /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
     ///
     /// # Example
+    ///
     /// ```
     /// use w5500::register::common::RetryTime;
     ///
@@ -261,26 +272,58 @@ impl<SpiBus: Bus, HostImpl: Host> DeviceRefMut<'_, SpiBus, HostImpl> {
     /// assert_eq!(four_hundred_ms.to_u16(), 4000);
     /// ```
     #[inline]
-    pub fn set_retry_timeout(&mut self, retry_time_value: RetryTime) -> Result<(), SpiBus::Error> {
+    fn set_retry_timeout(&mut self, retry_time_value: RetryTime) -> Result<(), SpiBus::Error> {
-        self.bus.set_retry_timeout(retry_time_value)
+        self.bus.write_frame(
+            register::COMMON,
+            register::common::RETRY_TIME,
+            &retry_time_value.to_register(),
+        )?;
+
+        Ok(())
     }
 
-    /// Get the current Retry Count Register value.
+    /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
     ///
-    /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
+    /// E.g. 4000 = 400ms
-    ///
-    /// E.g. In case of errors it will retry for 7 times:
-    /// `RCR = 0x0007`
     #[inline]
-    pub fn current_retry_count(&mut self) -> Result<RetryCount, SpiBus::Error> {
+    fn current_retry_timeout(&mut self) -> Result<RetryTime, SpiBus::Error> {
-        self.bus.current_retry_count()
+        let mut retry_time_register: [u8; 2] = [0, 0];
+        self.bus.read_frame(
+            register::COMMON,
+            register::common::RETRY_TIME,
+            &mut retry_time_register,
+        )?;
+
+        Ok(RetryTime::from_register(retry_time_register))
     }
 
     /// Set a new value for the Retry Count register.
     ///
     /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
+    fn set_retry_count(&mut self, retry_count: RetryCount) -> Result<(), SpiBus::Error> {
+        self.bus.write_frame(
+            register::COMMON,
+            register::common::RETRY_COUNT,
+            &retry_count.to_register(),
+        )?;
+
+        Ok(())
+    }
+
+    /// Get the current Retry Count value
+    /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
+    ///
+    /// E.g. In case of errors it will retry for 7 times:
+    /// `RCR = 0x0007`
     #[inline]
-    pub fn set_retry_count(&mut self, retry_count: RetryCount) -> Result<(), SpiBus::Error> {
+    fn current_retry_count(&mut self) -> Result<RetryCount, SpiBus::Error> {
-        self.bus.set_retry_count(retry_count)
+        let mut retry_count_register: [u8; 1] = [0];
+        self.bus.read_frame(
+            register::COMMON,
+            register::common::RETRY_COUNT,
+            &mut retry_count_register,
+        )?;
+
+        Ok(RetryCount::from_register(retry_count_register))
     }
 }

src/uninitialized_device.rs

@@ -99,7 +99,7 @@ impl<SpiBus: Bus> UninitializedDevice<SpiBus> {
         // RESET
         self.reset()?;
 
-        self.set_mode(mode_options)?;
+        self.set_mode(mode_options.into())?;
         host.refresh(&mut self.bus)?;
         Ok(Device::new(self.bus, host))
     }
@@ -118,21 +118,38 @@ impl<SpiBus: Bus> UninitializedDevice<SpiBus> {
         RawDevice::new(self.bus)
     }
 
-    /// Get the currently set Retry Time-value Register.
+    /// Reset the device
-    ///
-    /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
-    ///
-    /// E.g. 4000 = 400ms
     #[inline]
-    pub fn current_retry_timeout(&mut self) -> Result<RetryTime, SpiBus::Error> {
+    fn reset(&mut self) -> Result<(), SpiBus::Error> {
-        self.bus.current_retry_timeout()
+        self.set_mode(register::common::Mode::Reset)
+    }
+
+    #[inline]
+    fn set_mode(&mut self, mode_options: register::common::Mode) -> Result<(), SpiBus::Error> {
+        self.bus.write_frame(
+            register::COMMON,
+            register::common::MODE,
+            &mode_options.to_register(),
+        )?;
+        Ok(())
+    }
+
+    #[inline]
+    fn version(&mut self) -> Result<u8, SpiBus::Error> {
+        let mut version_register = [0_u8];
+        self.bus.read_frame(
+            register::COMMON,
+            register::common::VERSION,
+            &mut version_register,
+        )?;
+
+        Ok(version_register[0])
     }
 
-    /// Set a new value for the Retry Time-value Register.
-    ///
     /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
     ///
     /// # Example
+    ///
     /// ```
     /// use w5500::register::common::RetryTime;
     ///
@@ -144,27 +161,59 @@ impl<SpiBus: Bus> UninitializedDevice<SpiBus> {
     /// assert_eq!(four_hundred_ms.to_u16(), 4000);
     /// ```
     #[inline]
-    pub fn set_retry_timeout(&mut self, retry_time_value: RetryTime) -> Result<(), SpiBus::Error> {
+    fn set_retry_timeout(&mut self, retry_time_value: RetryTime) -> Result<(), SpiBus::Error> {
-        self.bus.set_retry_timeout(retry_time_value)
+        self.bus.write_frame(
+            register::COMMON,
+            register::common::RETRY_TIME,
+            &retry_time_value.to_register(),
+        )?;
+
+        Ok(())
     }
 
-    /// Get the current Retry Count Register value.
+    /// RTR (Retry Time-value Register) [R/W] [0x0019 – 0x001A] [0x07D0]
     ///
-    /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
+    /// E.g. 4000 = 400ms
-    ///
-    /// E.g. In case of errors it will retry for 7 times:
-    /// `RCR = 0x0007`
     #[inline]
-    pub fn current_retry_count(&mut self) -> Result<RetryCount, SpiBus::Error> {
+    fn current_retry_timeout(&mut self) -> Result<RetryTime, SpiBus::Error> {
-        self.bus.current_retry_count()
+        let mut retry_time_register: [u8; 2] = [0, 0];
+        self.bus.read_frame(
+            register::COMMON,
+            register::common::RETRY_TIME,
+            &mut retry_time_register,
+        )?;
+
+        Ok(RetryTime::from_register(retry_time_register))
     }
 
     /// Set a new value for the Retry Count register.
     ///
     /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
+    fn set_retry_count(&mut self, retry_count: RetryCount) -> Result<(), SpiBus::Error> {
+        self.bus.write_frame(
+            register::COMMON,
+            register::common::RETRY_COUNT,
+            &retry_count.to_register(),
+        )?;
+
+        Ok(())
+    }
+
+    /// Get the current Retry Count value
+    /// RCR (Retry Count Register) [R/W] [0x001B] [0x08]
+    ///
+    /// E.g. In case of errors it will retry for 7 times:
+    /// `RCR = 0x0007`
     #[inline]
-    pub fn set_retry_count(&mut self, retry_count: RetryCount) -> Result<(), SpiBus::Error> {
+    fn current_retry_count(&mut self) -> Result<RetryCount, SpiBus::Error> {
-        self.bus.set_retry_count(retry_count)
+        let mut retry_count_register: [u8; 1] = [0];
+        self.bus.read_frame(
+            register::COMMON,
+            register::common::RETRY_COUNT,
+            &mut retry_count_register,
+        )?;
+
+        Ok(RetryCount::from_register(retry_count_register))
     }
 
     #[cfg(not(feature = "no-chip-version-assertion"))]
@@ -172,7 +221,7 @@ impl<SpiBus: Bus> UninitializedDevice<SpiBus> {
         &mut self,
         expected_version: u8,
     ) -> Result<(), InitializeError<SpiBus::Error>> {
-        let version = self.bus.version()?;
+        let version = self.version()?;
 
         if version != expected_version {
             Err(InitializeError::ChipNotConnected)
@@ -180,15 +229,6 @@ impl<SpiBus: Bus> UninitializedDevice<SpiBus> {
             Ok(())
         }
     }
-
-    /// RESET
-    fn reset(&mut self) -> Result<(), SpiBus::Error> {
-        self.bus.reset()
-    }
-
-    fn set_mode(&mut self, mode_options: Mode) -> Result<(), SpiBus::Error> {
-        self.bus.set_mode(mode_options.into())
-    }
 }
 
 impl<Spi: Transfer<u8> + Write<u8>, ChipSelect: OutputPin>