From 5b3d5f57aff724450a7d704855c994e946d175d3 Mon Sep 17 00:00:00 2001
From: Andreas Galauner <andreas@galauner.de>
Date: Sun, 10 Dec 2023 07:03:51 +0100
Subject: [PATCH 1/2] 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)

---
 src/config.rs                   |   4 +
 src/generate/device.rs          |   7 ++
 src/generate/generic_avr_ccp.rs | 127 ++++++++++++++++++++++++++++++++
 src/generate/interrupt.rs       |   2 +
 4 files changed, 140 insertions(+)
 create mode 100644 src/generate/generic_avr_ccp.rs

diff --git a/src/config.rs b/src/config.rs
index e7b224fc..ef7e8b9e 100644
--- a/src/config.rs
+++ b/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),
         })
diff --git a/src/generate/device.rs b/src/generate/device.rs
index e21d249d..a4e4c3f0 100644
--- a/src/generate/device.rs
+++ b/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)]
diff --git a/src/generate/generic_avr_ccp.rs b/src/generate/generic_avr_ccp.rs
new file mode 100644
index 00000000..7cee702a
--- /dev/null
+++ b/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
+            );
+        }
+    }
+}
diff --git a/src/generate/interrupt.rs b/src/generate/interrupt.rs
index 1e9420fb..b0381e93 100644
--- a/src/generate/interrupt.rs
+++ b/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")]

From d8be92cd783468cf7d5813d88d91abede555dc50 Mon Sep 17 00:00:00 2001
From: Andreas Galauner <andreas@galauner.de>
Date: Sun, 10 Dec 2023 07:33:10 +0100
Subject: [PATCH 2/2] Add AVR CCP feature in Changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8dc1d6f1..4136faa0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Update `irx-config`
 - Fix register array derive regression
 - Sanitize `gen` keyword (new in Rust 2024 edition)
+- Add an `AVR` target which includes generic code to access configuration change protected registers in a more convenient way
 
 ## [v0.36.0] - 2025-03-09