Support registers without a defined reset value

In case no reset value is defined for a register, we suppress generation
of the `write`, `reset`, and `reset_value` functions. Register values can still be
safely changed using `modify`.

Author: ecstatic-morse

src/generate.rs

@@ -759,19 +759,6 @@ pub fn register(
     }
 
     if access == Access::WriteOnly || access == Access::ReadWrite {
-        reg_impl_items.push(quote! {
-            /// Writes to the register
-            #[inline]
-            pub fn write<F>(&self, f: F)
-            where
-                F: FnOnce(&mut W) -> &mut W
-            {
-                let mut w = W::reset_value();
-                f(&mut w);
-                self.register.set(w.bits);
-            }
-        });
-
         mod_items.push(quote! {
             /// Value to write to the register
             pub struct W {
@@ -782,16 +769,42 @@ pub fn register(
         let rv = register
             .reset_value
             .or(defs.reset_value)
-            .map(|rv| util::hex(rv))
-            .ok_or_else(|| format!("Register {} has no reset value", register.name))?;
+            .map(|rv| util::hex(rv));
 
-        w_impl_items.push(quote! {
-            /// Reset value of the register
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: #rv }
+        if let Some(rv) = rv {
+            reg_impl_items.push(quote! {
+                /// Writes to the register
+                #[inline]
+                pub fn write<F>(&self, f: F)
+                where
+                    F: FnOnce(&mut W) -> &mut W
+                {
+                    let mut w = W::reset_value();
+                    f(&mut w);
+                    self.register.set(w.bits);
+                }
+            });
+
+            w_impl_items.push(quote! {
+                /// Reset value of the register
+                #[inline]
+                pub fn reset_value() -> W {
+                    W { bits: #rv }
+                }
+            });
+
+            if access == Access::ReadWrite {
+                reg_impl_items.push(quote! {
+                    /// Writes the reset value to the register
+                    #[inline]
+                    pub fn reset(&self) {
+                        self.write(|w| w)
+                    }
+                })
             }
+        }
 
+        w_impl_items.push(quote! {
             /// Writes raw bits to the register
             #[inline]
             pub #unsafety fn bits(&mut self, bits: #rty) -> &mut Self {
@@ -801,16 +814,6 @@ pub fn register(
         });
     }
 
-    if access == Access::ReadWrite {
-        reg_impl_items.push(quote! {
-            /// Writes the reset value to the register
-            #[inline]
-            pub fn reset(&self) {
-                self.write(|w| w)
-            }
-        })
-    }
-
     mod_items.push(quote! {
         impl super::#name_pc {
             #(#reg_impl_items)*