Use Result<T, E> with the interface error type

Every read/write is fallible with interface usage (spi/i2c/etc) so
the returns should be Result<T, E>'s for all write/modify/read calls to
a register.

Author: SpinFast

src/generate/iface/common.rs

@@ -55,34 +55,34 @@ impl<'a, I, K: Copy, V, A: Access> Reg<'a, I, K, V, A> {
 
 impl<'a, I: Interface<K, V>, K: Copy, V: Copy, A: Read> Reg<'a, I, K, V, A> {
     #[inline(always)]
-    pub fn read(&mut self) -> V {
-        self.iface.read(self.addr).unwrap()
+    pub fn read(&mut self) -> Result<V, I::Error> {
+        self.iface.read(self.addr)
     }
 }
 
 impl<'a, I: Interface<K, V>, K: Copy, V: Copy, A: Write> Reg<'a, I, K, V, A> {
     #[inline(always)]
-    pub fn write_value(&mut self, val: V) {
-        self.iface.write(self.addr, val).unwrap()
+    pub fn write_value(&mut self, val: V) -> Result<(), I::Error> {
+        self.iface.write(self.addr, val)
     }
 }
 
 impl<'a, I: Interface<K, V>, K: Copy, V: Default + Copy, A: Write> Reg<'a, I, K, V, A> {
     #[inline(always)]
-    pub fn write<R>(&mut self, f: impl FnOnce(&mut V) -> R) -> R {
+    pub fn write<R>(&mut self, f: impl FnOnce(&mut V) -> R) -> Result<R, I::Error> {
         let mut val = Default::default();
         let res = f(&mut val);
-        self.write_value(val);
-        res
+        self.write_value(val)?;
+        Ok(res)
     }
 }
 
 impl<'a, I: Interface<K, V>, K: Copy, V: Copy, A: Read + Write> Reg<'a, I, K, V, A> {
     #[inline(always)]
-    pub fn modify<R>(&mut self, f: impl FnOnce(&mut V) -> R) -> R {
-        let mut val = self.read();
+    pub fn modify<R>(&mut self, f: impl FnOnce(&mut V) -> R) -> Result<R, I::Error> {
+        let mut val = self.read()?;
         let res = f(&mut val);
-        self.write_value(val);
-        res
+        self.write_value(val)?;
+        Ok(res)
     }
 }