Merge #673

673: initial_write_value for registers with modifiedWriteValues r=therealprof a=burrbull

Related to #540 

Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Change initial write value for registers with modifiedWriteValues
 - Update `clap` to 4.0, use `irx-config` instead of `clap_conf`
 - Add #[must_use] to prevent hanging field writers
 - Remove explicit deref in `generic.rs` since it's done by auto-deref

src/generate/generic.rs

@@ -3,7 +3,7 @@ use core::marker;
 /// Raw register type
 pub trait RegisterSpec {
     /// Raw register type (`u8`, `u16`, `u32`, ...).
-    type Ux: Copy;
+    type Ux: Copy + Default + core::ops::BitOr<Output=Self::Ux> + core::ops::BitAnd<Output=Self::Ux> + core::ops::Not<Output=Self::Ux>;
 }
 
 /// Trait implemented by readable registers to enable the `read` method.
@@ -22,6 +22,12 @@ pub trait Readable: RegisterSpec {
 pub trait Writable: RegisterSpec {
     /// Writer type argument to `write`, et al.
     type Writer: From<W<Self>> + core::ops::DerefMut<Target = W<Self>>;
+
+    /// Specifies the register bits that are not changed if you pass `1` and are changed if you pass `0`
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
+
+    /// Specifies the register bits that are not changed if you pass `0` and are changed if you pass `1`
+    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
 }
 
 /// Reset value of the register.
@@ -30,7 +36,13 @@ pub trait Writable: RegisterSpec {
 /// register by using the `reset` method.
 pub trait Resettable: RegisterSpec {
     /// Reset value of the register.
-    fn reset_value() -> Self::Ux;
+    const RESET_VALUE: Self::Ux;
+
+    /// Reset value of the register.
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        Self::RESET_VALUE
+    }
 }
 
 /// This structure provides volatile access to registers.
@@ -82,7 +94,7 @@ impl<REG: Resettable + Writable> Reg<REG> {
     /// Resets the register to its initial state.
     #[inline(always)]
     pub fn reset(&self) {
-        self.register.set(REG::reset_value())
+        self.register.set(REG::RESET_VALUE)
     }
 
     /// Writes bits to a `Writable` register.
@@ -115,24 +127,21 @@ impl<REG: Resettable + Writable> Reg<REG> {
     {
         self.register.set(
             f(&mut REG::Writer::from(W {
-                bits: REG::reset_value(),
+                bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
                 _reg: marker::PhantomData,
             }))
             .bits,
         );
     }
 }
 
-impl<REG: Writable> Reg<REG>
-where
-    REG::Ux: Default,
-{
+impl<REG: Writable> Reg<REG> {
     /// Writes 0 to a `Writable` register.
     ///
     /// Similar to `write`, but unused bits will contain 0.
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// Unsafe to use with registers which don't allow to write 0.
     #[inline(always)]
     pub unsafe fn write_with_zero<F>(&self, f: F)
@@ -188,7 +197,7 @@ impl<REG: Readable + Writable> Reg<REG> {
                     _reg: marker::PhantomData,
                 }),
                 &mut REG::Writer::from(W {
-                    bits,
+                    bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
                     _reg: marker::PhantomData,
                 }),
             )
@@ -236,9 +245,9 @@ pub struct W<REG: RegisterSpec + ?Sized> {
 
 impl<REG: RegisterSpec> W<REG> {
     /// Writes raw bits to the register.
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// Read datasheet or reference manual to find what values are allowed to pass.
     #[inline(always)]
     pub unsafe fn bits(&mut self, bits: REG::Ux) -> &mut Self {

src/generate/register.rs

@@ -219,6 +219,9 @@ pub fn render_register_mod(
         methods.push("modify");
     }
 
+    let mut zero_to_modify_fields_bitmap: u64 = 0;
+    let mut one_to_modify_fields_bitmap: u64 = 0;
+
     if let Some(cur_fields) = register.fields.as_ref() {
         // filter out all reserved fields, as we should not generate code for
         // them
@@ -240,6 +243,8 @@ pub fn render_register_mod(
                 &mut mod_items,
                 &mut r_impl_items,
                 &mut w_impl_items,
+                &mut zero_to_modify_fields_bitmap,
+                &mut one_to_modify_fields_bitmap,
                 config,
             )?;
         }
@@ -343,21 +348,25 @@ pub fn render_register_mod(
     if can_write {
         let doc =
             format!("`write(|w| ..)` method takes [{name_snake_case}::W](W) writer structure",);
+
+        let zero_to_modify_fields_bitmap = util::hex(zero_to_modify_fields_bitmap);
+        let one_to_modify_fields_bitmap = util::hex(one_to_modify_fields_bitmap);
+
         mod_items.extend(quote! {
             #[doc = #doc]
             impl crate::Writable for #name_constant_case_spec {
                 type Writer = W;
+                const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = #zero_to_modify_fields_bitmap;
+                const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = #one_to_modify_fields_bitmap;
             }
         });
     }
     if let Some(rv) = properties.reset_value.map(util::hex) {
-        let rv = rv.into_token_stream();
         let doc = format!("`reset()` method sets {} to value {rv}", register.name);
         mod_items.extend(quote! {
             #[doc = #doc]
             impl crate::Resettable for #name_constant_case_spec {
-                #[inline(always)]
-                fn reset_value() -> Self::Ux { #rv }
+                const RESET_VALUE: Self::Ux = #rv;
             }
         });
     }
@@ -377,6 +386,8 @@ pub fn fields(
     mod_items: &mut TokenStream,
     r_impl_items: &mut TokenStream,
     w_impl_items: &mut TokenStream,
+    zero_to_modify_fields_bitmap: &mut u64,
+    one_to_modify_fields_bitmap: &mut u64,
     config: &Config,
 ) -> Result<()> {
     let span = Span::call_site();
@@ -837,19 +848,16 @@ pub fn fields(
             // derive writer structure by type alias to generic write proxy structure.
             if should_derive_writer {
                 let proxy = if width == 1 {
+                    use ModifiedWriteValues::*;
                     let wproxy = Ident::new(
                         match mwv {
-                            ModifiedWriteValues::Modify => "BitWriter",
-                            ModifiedWriteValues::OneToSet | ModifiedWriteValues::Set => {
-                                "BitWriter1S"
-                            }
-                            ModifiedWriteValues::ZeroToClear | ModifiedWriteValues::Clear => {
-                                "BitWriter0C"
-                            }
-                            ModifiedWriteValues::OneToClear => "BitWriter1C",
-                            ModifiedWriteValues::ZeroToSet => "BitWriter0C",
-                            ModifiedWriteValues::OneToToggle => "BitWriter1T",
-                            ModifiedWriteValues::ZeroToToggle => "BitWriter0T",
+                            Modify | Set | Clear => "BitWriter",
+                            OneToSet => "BitWriter1S",
+                            ZeroToClear => "BitWriter0C",
+                            OneToClear => "BitWriter1C",
+                            ZeroToSet => "BitWriter0C",
+                            OneToToggle => "BitWriter1T",
+                            ZeroToToggle => "BitWriter0T",
                         },
                         span,
                     );
@@ -965,6 +973,17 @@ pub fn fields(
                     }
                 });
             }
+            let bitmask = (u64::MAX >> (64 - width)) << offset;
+            use ModifiedWriteValues::*;
+            match mwv {
+                Modify | Set | Clear => {}
+                OneToSet | OneToClear | OneToToggle => {
+                    *one_to_modify_fields_bitmap |= bitmask;
+                }
+                ZeroToClear | ZeroToSet | ZeroToToggle => {
+                    *zero_to_modify_fields_bitmap |= bitmask;
+                }
+            }
         }
     }