generic register rebase on master

Author: burrbull

CHANGELOG.md

@@ -11,7 +11,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - `variant()` method for field reader and `Variant` enum for fields with reserved values
 
-- Field readers and writers use one enum where it is possible
+### Changed
+
+  - Field readers and writers use one enum where it is possible
+
+  - Replace register and its reader/writer by generic types
 
 ## [v0.15.2] - 2019-07-29
 

src/generate/generic.rs

@@ -10,6 +10,25 @@ pub fn render() -> Result<Vec<Tokens>> {
     generic_items.push(quote! {
         use core::marker;
 
+        ///This trait shows that register has `read` method
+        ///
+        ///Registers marked with `Writable` can be also `modify`'ed
+        pub trait Readable {}
+
+        ///This trait shows that register has `write`, `write_with_zero` and `reset` method
+        ///
+        ///Registers marked with `Readable` can be also `modify`'ed
+        pub trait Writable {}
+
+        ///Reset value of the register
+        ///
+        ///This value is initial value for `write` method.
+        ///It can be also directly writed to register by `reset` method.
+        pub trait ResetValue<U> {
+            ///Reset value of the register
+            fn reset_value() -> U;
+        }
+
         ///Converting enumerated values to bits
         pub trait ToBits<N> {
             ///Conversion method
@@ -18,23 +37,105 @@ pub fn render() -> Result<Vec<Tokens>> {
     });
 
     generic_items.push(quote! {
-        ///Value read from the register
-        pub struct FR<U, T> {
-            pub(crate) bits: U,
-            _reg: marker::PhantomData<T>,
+        ///This structure provides volatile access to register
+        pub struct Reg<U, REG> {
+            register: vcell::VolatileCell<U>,
+            _marker: marker::PhantomData<REG>,
         }
 
-        impl<U, T, FI> PartialEq<FI> for FR<U, T>
+        unsafe impl<U: Send, REG> Send for Reg<U, REG> { }
+
+        impl<U, REG> Reg<U, REG>
         where
-            U: PartialEq,
-            FI: ToBits<U>
+            Self: Readable,
+            U: Copy
         {
-            fn eq(&self, other: &FI) -> bool {
-                self.bits.eq(&other._bits())
+            ///Reads the contents of `Readable` register
+            ///
+            ///See [reading](https://rust-embedded.github.io/book/start/registers.html#reading) in book.
+            #[inline(always)]
+            pub fn read(&self) -> R<U, Self> {
+                R {bits: self.register.get(), _reg: marker::PhantomData}
+            }
+        }
+
+        impl<U, REG> Reg<U, REG>
+        where
+            Self: ResetValue<U> + Writable,
+            U: Copy,
+        {
+            ///Writes the reset value to `Writable` register
+            #[inline(always)]
+            pub fn reset(&self) {
+                self.register.set(Self::reset_value())
+            }
+        }
+    });
+
+    generic_items.push(quote! {
+        impl<U, REG> Reg<U, REG>
+        where
+            Self: ResetValue<U> + Writable,
+            U: Copy
+        {
+            ///Writes bits to `Writable` register
+            ///
+            ///See [writing](https://rust-embedded.github.io/book/start/registers.html#writing) in book.
+            #[inline(always)]
+            pub fn write<F>(&self, f: F)
+            where
+                F: FnOnce(&mut W<U, Self>) -> &mut W<U, Self>
+            {
+                self.register.set(f(&mut W {bits: Self::reset_value(), _reg: marker::PhantomData}).bits);
+            }
+        }
+    });
+
+    generic_items.push(quote! {
+        impl<U, REG> Reg<U, REG>
+        where
+            Self: Writable,
+            U: Copy + Default
+        {
+            ///Writes Zero to `Writable` register
+            #[inline(always)]
+            pub fn write_with_zero<F>(&self, f: F)
+            where
+                F: FnOnce(&mut W<U, Self>) -> &mut W<U, Self>
+            {
+                self.register.set(f(&mut W {bits: U::default(), _reg: marker::PhantomData }).bits);
             }
         }
+    });
+
+    generic_items.push(quote! {
+        impl<U, REG> Reg<U, REG>
+        where
+            Self: Readable + Writable,
+            U: Copy,
+        {
+            ///Modifies the contents of the register
+            ///
+            ///See [modifying](https://rust-embedded.github.io/book/start/registers.html#modifying) in book.
+            #[inline(always)]
+            pub fn modify<F>(&self, f: F)
+            where
+                for<'w> F: FnOnce(&R<U, Self>, &'w mut W<U, Self>) -> &'w mut W<U, Self>
+            {
+                let bits = self.register.get();
+                self.register.set(f(&R {bits, _reg: marker::PhantomData}, &mut W {bits, _reg: marker::PhantomData}).bits);
+            }
+        }
+    });
 
-        impl<U, T> FR<U, T>
+    generic_items.push(quote! {
+        ///Register/field reader
+        pub struct R<U, T> {
+            pub(crate) bits: U,
+            _reg: marker::PhantomData<T>,
+        }
+
+        impl<U, T> R<U, T>
         where
             U: Copy
         {
@@ -46,7 +147,7 @@ pub fn render() -> Result<Vec<Tokens>> {
                     _reg: marker::PhantomData,
                 }
             }
-            ///Read raw bits from field
+            ///Read raw bits from register/field
             #[inline(always)]
             pub fn bits(&self) -> U {
                 self.bits
@@ -55,7 +156,19 @@ pub fn render() -> Result<Vec<Tokens>> {
     });
 
     generic_items.push(quote! {
-        impl<FI> FR<bool, FI> {
+        impl<U, T, FI> PartialEq<FI> for R<U, T>
+        where
+            U: PartialEq,
+            FI: ToBits<U>
+        {
+            fn eq(&self, other: &FI) -> bool {
+                self.bits.eq(&other._bits())
+            }
+        }
+    });
+
+    generic_items.push(quote! {
+        impl<FI> R<bool, FI> {
             ///Value of the field as raw bits
             #[inline(always)]
             pub fn bit(&self) -> bool {
@@ -74,6 +187,27 @@ pub fn render() -> Result<Vec<Tokens>> {
         }
     });
 
+    generic_items.push(quote! {
+        ///Register writer
+        pub struct W<U, REG> {
+            ///Writable bits
+            pub bits: U,
+            _reg: marker::PhantomData<REG>,
+        }
+    });
+
+    generic_items.push(quote! {
+        impl<U, REG> W<U, REG> {
+            ///Writes raw bits to the register
+            #[inline(always)]
+            pub fn bits(&mut self, bits: U) -> &mut Self {
+                self.bits = bits;
+                self
+            }
+        }
+    });
+
+
     generic_items.push(quote! {
         ///Used if enumerated values cover not the whole range
         #[derive(Clone,Copy,PartialEq)]
@@ -88,7 +222,7 @@ pub fn render() -> Result<Vec<Tokens>> {
     code.push(quote! {
         #[allow(unused_imports)]
         use generic::*;
-        /// Common register and bit access and modify traits
+        ///Common register and bit access and modify traits
         pub mod generic {
             #(#generic_items)*
         }