Add a new generic file to be included which provide register access methods for AVR registers which are protected by the configuration change protection (CCP)

Author: G33KatWork

src/config.rs

@@ -79,6 +79,8 @@ pub enum Target {
     XtensaLX,
     #[cfg_attr(feature = "serde", serde(rename = "mips"))]
     Mips,
+    #[cfg_attr(feature = "serde", serde(rename = "avr"))]
+    Avr,
     #[cfg_attr(feature = "serde", serde(rename = "none"))]
     None,
 }
@@ -91,6 +93,7 @@ impl std::fmt::Display for Target {
             Target::RISCV => "riscv",
             Target::XtensaLX => "xtensa-lx",
             Target::Mips => "mips",
+            Target::Avr => "avr",
             Target::None => "none",
         })
     }
@@ -104,6 +107,7 @@ impl Target {
             "riscv" => Target::RISCV,
             "xtensa-lx" => Target::XtensaLX,
             "mips" => Target::Mips,
+            "avr" => Target::Avr,
             "none" => Target::None,
             _ => bail!("unknown target {}", s),
         })

src/generate/device.rs

@@ -139,6 +139,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
     let generic_file = include_str!("generic.rs");
     let generic_reg_file = include_str!("generic_reg_vcell.rs");
     let generic_atomic_file = include_str!("generic_atomic.rs");
+    let avr_ccp_file = include_str!("generic_avr_ccp.rs");
     if config.generic_mod {
         let mut file = File::create(
             config
@@ -155,6 +156,9 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
             }
             writeln!(file, "\n{generic_atomic_file}")?;
         }
+        if config.target == Target::Avr {
+            writeln!(file, "\n{}", avr_ccp_file)?;
+        }
 
         if !config.make_mod {
             out.extend(quote! {
@@ -173,6 +177,9 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
             }
             syn::parse_file(generic_atomic_file)?.to_tokens(&mut tokens);
         }
+        if config.target == Target::Avr {
+            syn::parse_file(avr_ccp_file)?.to_tokens(&mut tokens);
+        }
 
         out.extend(quote! {
             #[allow(unused_imports)]

src/generate/generic_avr_ccp.rs

@@ -0,0 +1,127 @@
+/// Trait implemented by registers that can be used to unlock another
+/// configuration change protected register.
+///
+/// A type reference to an unlock register needs to be defined in every
+/// implementation of a [`Protected`]
+pub trait UnlockRegister {
+    /// A raw pointer to the location of the CCP register in data space
+    const PTR: *mut u8;
+}
+
+/// Trait to mark a register as configuration change protected on xmega based
+/// AVR cores.
+///
+/// To write into a configuration change protected register, the CPU first has
+/// to issue a write a defined magic value to a register called `CCP` in the
+/// `CPU` block of the core. After this write access has been performed, the
+/// protected register has to be written within the next four instruction for
+/// the write to take effect.
+pub trait Protected {
+    /// The CCP [`UnlockRegister`] that needs to be written with the
+    /// [`Self::MAGIC`] value to unlock writes to the protected register.
+    type CcpReg: UnlockRegister;
+
+    /// The magic value that needs to be written into the configuration change
+    /// protection register [`Self::CcpReg`] to unlock writes to the protected
+    /// register
+    const MAGIC: u8;
+}
+
+/// Trait implemented by [`Writable`] and [`Protected`] registers which
+/// allows writing to the protected register by first writing a magic value to
+/// the CCP register.
+pub trait ProtectedWritable<REG>
+where
+    REG: Writable + Protected
+{
+    /// Write to a CCP protected register by unlocking it first.
+    ///
+    /// Refer to [`Reg::write`] for usage.
+    fn write_protected<F>(&self, f: F)
+    where
+        F: FnOnce(&mut W<REG>) -> &mut W<REG>;
+}
+
+impl<REG> ProtectedWritable<REG> for Reg<REG>
+where
+    REG: RegisterSpec<Ux = u8> + Writable + Resettable + Protected
+{
+    /// Unlocks and then writes bits to a `Writable` register.
+    ///
+    /// Refer to [`Reg::write`] for usage.
+    #[inline(always)]
+    fn write_protected<F>(&self, f: F)
+    where
+        F: FnOnce(&mut W<REG>) -> &mut W<REG>
+    {
+        let val = f(&mut W::<REG>::from(W {
+            bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
+                | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
+            _reg: marker::PhantomData,
+        })).bits;
+
+        unsafe {
+            core::arch::asm!(
+                // Write the CCP register with the desired magic
+                "ldi {magicreg}, {magic}",
+                "out {ccpreg}, {magicreg}",
+
+                // Then immediately write the protected register
+                "st X, {perval}",
+
+                magic = const REG::MAGIC,
+                ccpreg = const unsafe { core::mem::transmute::<_, i16>(REG::CcpReg::PTR) as i32 },
+
+                in("X") self.register.as_ptr(),
+                perval = in(reg) val,
+
+                magicreg = out (reg) _   // mark the magicreg as clobbered
+            );
+        }
+    }
+}
+
+impl<REG: RegisterSpec<Ux = u8> + Readable + Writable + Protected> Reg<REG> {
+    /// Modifies the contents of a protected register by reading and then
+    /// unlocking and writing it.
+    ///
+    /// Refer to [`Reg::modify`] for usage.
+    #[inline(always)]
+    pub fn modify_protected<F>(&self, f: F)
+    where
+        for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
+    {
+        let bits = self.register.get();
+        let val = f(
+            &R::<REG>::from(R {
+                bits,
+                _reg: marker::PhantomData,
+            }),
+            &mut W::<REG>::from(W {
+                bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
+                    | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
+                _reg: marker::PhantomData,
+            }),
+        )
+        .bits;
+
+        unsafe {
+            core::arch::asm!(
+                // Write the CCP register with the desired magic
+                "ldi {magicreg}, {magic}",
+                "out {ccpreg}, {magicreg}",
+
+                // Then immediately write the protected register
+                "st X, {perval}",
+
+                magic = const REG::MAGIC,
+                ccpreg = const unsafe { core::mem::transmute::<_, i16>(REG::CcpReg::PTR) as i32 },
+
+                in("X") self.register.as_ptr(),
+                perval = in(reg) val,
+
+                magicreg = out (reg) _   // mark the magicreg as clobbered
+            );
+        }
+    }
+}

src/generate/interrupt.rs

@@ -269,6 +269,7 @@ pub fn render(
             });
         }
         Target::Mips => {}
+        Target::Avr => {}
         Target::None => {}
     }
 
@@ -377,6 +378,7 @@ pub fn render(
             && target != Target::Msp430
             && target != Target::XtensaLX
             && target != Target::Mips
+            && target != Target::Avr
         {
             mod_items.extend(quote! {
                 #[cfg(feature = "rt")]