diff --git a/CHANGELOG.md b/CHANGELOG.md
index 878d2f1f..65b1533a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+- Add `raw-access` options
 - Refactor `Accessor`
 
 ## [v0.33.3] - 2024-05-10
diff --git a/src/generate/device.rs b/src/generate/device.rs
index 25d6bdd2..86c40abd 100644
--- a/src/generate/device.rs
+++ b/src/generate/device.rs
@@ -63,8 +63,12 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
 
     out.extend(quote! {
         use core::ops::Deref;
-        use core::marker::PhantomData;
     });
+    if !config.raw_access {
+        out.extend(quote! {
+            use core::marker::PhantomData;
+        });
+    }
 
     // Retaining the previous assumption
     let mut fpu_present = true;
@@ -140,6 +144,11 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
     }
 
     let generic_file = include_str!("generic.rs");
+    let generic_reg_file = if config.raw_access {
+        include_str!("generic_reg_raw.rs")
+    } else {
+        include_str!("generic_reg_vcell.rs")
+    };
     let generic_atomic_file = include_str!("generic_atomic.rs");
     if config.generic_mod {
         let mut file = File::create(
@@ -150,6 +159,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                 .join("generic.rs"),
         )?;
         writeln!(file, "{generic_file}")?;
+        writeln!(file, "{generic_reg_file}")?;
         if config.atomics {
             if let Some(atomics_feature) = config.atomics_feature.as_ref() {
                 writeln!(file, "#[cfg(feature = \"{atomics_feature}\")]")?;
@@ -167,6 +177,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
         }
     } else {
         let mut tokens = syn::parse_file(generic_file)?.into_token_stream();
+        syn::parse_file(generic_reg_file)?.to_tokens(&mut tokens);
         if config.atomics {
             if let Some(atomics_feature) = config.atomics_feature.as_ref() {
                 quote!(#[cfg(feature = #atomics_feature)]).to_tokens(&mut tokens);
@@ -246,9 +257,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                     #feature_attribute
                     pub #p_singleton: #p_ty,
                 });
-                exprs.extend(
-                    quote!(#feature_attribute #p_singleton: #p_ty { _marker: PhantomData },),
-                );
+                exprs.extend(quote!(#feature_attribute #p_singleton: unsafe { #p_ty::steal() },));
             }
             Peripheral::Array(p, dim_element) => {
                 for p_name in names(p, dim_element) {
@@ -264,7 +273,7 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                         pub #p_singleton: #p_ty,
                     });
                     exprs.extend(
-                        quote!(#feature_attribute #p_singleton: #p_ty { _marker: PhantomData },),
+                        quote!(#feature_attribute #p_singleton: unsafe { #p_ty::steal() },),
                     );
                 }
             }
diff --git a/src/generate/generic.rs b/src/generate/generic.rs
index 6921b5ab..2f8d6f7b 100644
--- a/src/generate/generic.rs
+++ b/src/generate/generic.rs
@@ -95,178 +95,6 @@ pub trait Resettable: RegisterSpec {
     }
 }
 
-/// This structure provides volatile access to registers.
-#[repr(transparent)]
-pub struct Reg<REG: RegisterSpec> {
-    register: vcell::VolatileCell<REG::Ux>,
-    _marker: marker::PhantomData<REG>,
-}
-
-unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}
-
-impl<REG: RegisterSpec> Reg<REG> {
-    /// Returns the underlying memory address of register.
-    ///
-    /// ```ignore
-    /// let reg_ptr = periph.reg.as_ptr();
-    /// ```
-    #[inline(always)]
-    pub fn as_ptr(&self) -> *mut REG::Ux {
-        self.register.as_ptr()
-    }
-}
-
-impl<REG: Readable> Reg<REG> {
-    /// Reads the contents of a `Readable` register.
-    ///
-    /// You can read the raw contents of a register by using `bits`:
-    /// ```ignore
-    /// let bits = periph.reg.read().bits();
-    /// ```
-    /// or get the content of a particular field of a register:
-    /// ```ignore
-    /// let reader = periph.reg.read();
-    /// let bits = reader.field1().bits();
-    /// let flag = reader.field2().bit_is_set();
-    /// ```
-    #[inline(always)]
-    pub fn read(&self) -> R<REG> {
-        R {
-            bits: self.register.get(),
-            _reg: marker::PhantomData,
-        }
-    }
-}
-
-impl<REG: Resettable + Writable> Reg<REG> {
-    /// Writes the reset value to `Writable` register.
-    ///
-    /// Resets the register to its initial state.
-    #[inline(always)]
-    pub fn reset(&self) {
-        self.register.set(REG::RESET_VALUE)
-    }
-
-    /// Writes bits to a `Writable` register.
-    ///
-    /// You can write raw bits into a register:
-    /// ```ignore
-    /// periph.reg.write(|w| unsafe { w.bits(rawbits) });
-    /// ```
-    /// or write only the fields you need:
-    /// ```ignore
-    /// periph.reg.write(|w| w
-    ///     .field1().bits(newfield1bits)
-    ///     .field2().set_bit()
-    ///     .field3().variant(VARIANT)
-    /// );
-    /// ```
-    /// or an alternative way of saying the same:
-    /// ```ignore
-    /// periph.reg.write(|w| {
-    ///     w.field1().bits(newfield1bits);
-    ///     w.field2().set_bit();
-    ///     w.field3().variant(VARIANT)
-    /// });
-    /// ```
-    /// In the latter case, other fields will be set to their reset value.
-    #[inline(always)]
-    pub fn write<F>(&self, f: F)
-    where
-        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
-    {
-        self.register.set(
-            f(&mut W {
-                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> {
-    /// 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)
-    where
-        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
-    {
-        self.register.set(
-            f(&mut W {
-                bits: REG::Ux::default(),
-                _reg: marker::PhantomData,
-            })
-            .bits,
-        );
-    }
-}
-
-impl<REG: Readable + Writable> Reg<REG> {
-    /// Modifies the contents of the register by reading and then writing it.
-    ///
-    /// E.g. to do a read-modify-write sequence to change parts of a register:
-    /// ```ignore
-    /// periph.reg.modify(|r, w| unsafe { w.bits(
-    ///    r.bits() | 3
-    /// ) });
-    /// ```
-    /// or
-    /// ```ignore
-    /// periph.reg.modify(|_, w| w
-    ///     .field1().bits(newfield1bits)
-    ///     .field2().set_bit()
-    ///     .field3().variant(VARIANT)
-    /// );
-    /// ```
-    /// or an alternative way of saying the same:
-    /// ```ignore
-    /// periph.reg.modify(|_, w| {
-    ///     w.field1().bits(newfield1bits);
-    ///     w.field2().set_bit();
-    ///     w.field3().variant(VARIANT)
-    /// });
-    /// ```
-    /// Other fields will have the value they had before the call to `modify`.
-    #[inline(always)]
-    pub fn modify<F>(&self, f: F)
-    where
-        for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
-    {
-        let bits = self.register.get();
-        self.register.set(
-            f(
-                &R {
-                    bits,
-                    _reg: marker::PhantomData,
-                },
-                &mut W {
-                    bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
-                        | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
-                    _reg: marker::PhantomData,
-                },
-            )
-            .bits,
-        );
-    }
-}
-
-impl<REG: Readable> core::fmt::Debug for crate::generic::Reg<REG>
-where
-    R<REG>: core::fmt::Debug
-{
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        core::fmt::Debug::fmt(&self.read(), f)
-    }
-}
-
 #[doc(hidden)]
 pub mod raw {
     use super::{marker, BitM, FieldSpec, RegisterSpec, Unsafe, Writable};
diff --git a/src/generate/generic_reg_raw.rs b/src/generate/generic_reg_raw.rs
new file mode 100644
index 00000000..39e741d3
--- /dev/null
+++ b/src/generate/generic_reg_raw.rs
@@ -0,0 +1,177 @@
+/// This structure provides unsafe volatile access to registers.
+pub struct Reg<REG: RegisterSpec> {
+    ptr: *mut u8,
+    _marker: marker::PhantomData<REG>,
+}
+
+unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}
+
+impl<REG: RegisterSpec> Reg<REG> {
+    #[inline(always)]
+    pub const fn new(ptr: *mut u8) -> Self {
+        Self {
+            ptr,
+            _marker: marker::PhantomData,
+        }
+    }
+    /// Returns the underlying memory address of register.
+    ///
+    /// ```ignore
+    /// let reg_ptr = periph.reg.as_ptr();
+    /// ```
+    #[inline(always)]
+    pub const fn as_ptr(&self) -> *mut REG::Ux {
+        self.ptr.cast()
+    }
+}
+
+impl<REG: Readable> Reg<REG> {
+    /// Reads the contents of a `Readable` register.
+    ///
+    /// You can read the raw contents of a register by using `bits`:
+    /// ```ignore
+    /// let bits = periph.reg.read().bits();
+    /// ```
+    /// or get the content of a particular field of a register:
+    /// ```ignore
+    /// let reader = periph.reg.read();
+    /// let bits = reader.field1().bits();
+    /// let flag = reader.field2().bit_is_set();
+    /// ```
+    #[inline(always)]
+    pub unsafe fn read(&self) -> R<REG> {
+        R {
+            bits: self.as_ptr().read_volatile(),
+            _reg: marker::PhantomData,
+        }
+    }
+}
+
+impl<REG: Resettable + Writable> Reg<REG> {
+    /// Writes the reset value to `Writable` register.
+    ///
+    /// Resets the register to its initial state.
+    #[inline(always)]
+    pub unsafe fn reset(&self) {
+        self.as_ptr().write_volatile(REG::RESET_VALUE)
+    }
+
+    /// Writes bits to a `Writable` register.
+    ///
+    /// You can write raw bits into a register:
+    /// ```ignore
+    /// periph.reg.write(|w| unsafe { w.bits(rawbits) });
+    /// ```
+    /// or write only the fields you need:
+    /// ```ignore
+    /// periph.reg.write(|w| w
+    ///     .field1().bits(newfield1bits)
+    ///     .field2().set_bit()
+    ///     .field3().variant(VARIANT)
+    /// );
+    /// ```
+    /// or an alternative way of saying the same:
+    /// ```ignore
+    /// periph.reg.write(|w| {
+    ///     w.field1().bits(newfield1bits);
+    ///     w.field2().set_bit();
+    ///     w.field3().variant(VARIANT)
+    /// });
+    /// ```
+    /// In the latter case, other fields will be set to their reset value.
+    #[inline(always)]
+    pub unsafe fn write<F>(&self, f: F)
+    where
+        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
+    {
+        self.as_ptr().write_volatile(
+            f(&mut W {
+                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> {
+    /// 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)
+    where
+        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
+    {
+        self.as_ptr().write_volatile(
+            f(&mut W {
+                bits: REG::Ux::default(),
+                _reg: marker::PhantomData,
+            })
+            .bits,
+        );
+    }
+}
+
+impl<REG: Readable + Writable> Reg<REG> {
+    /// Modifies the contents of the register by reading and then writing it.
+    ///
+    /// E.g. to do a read-modify-write sequence to change parts of a register:
+    /// ```ignore
+    /// periph.reg.modify(|r, w| unsafe { w.bits(
+    ///    r.bits() | 3
+    /// ) });
+    /// ```
+    /// or
+    /// ```ignore
+    /// periph.reg.modify(|_, w| w
+    ///     .field1().bits(newfield1bits)
+    ///     .field2().set_bit()
+    ///     .field3().variant(VARIANT)
+    /// );
+    /// ```
+    /// or an alternative way of saying the same:
+    /// ```ignore
+    /// periph.reg.modify(|_, w| {
+    ///     w.field1().bits(newfield1bits);
+    ///     w.field2().set_bit();
+    ///     w.field3().variant(VARIANT)
+    /// });
+    /// ```
+    /// Other fields will have the value they had before the call to `modify`.
+    #[inline(always)]
+    pub unsafe fn modify<F>(&self, f: F)
+    where
+        for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
+    {
+        let bits = self.as_ptr().read_volatile();
+        self.as_ptr().write_volatile(
+            f(
+                &R {
+                    bits,
+                    _reg: marker::PhantomData,
+                },
+                &mut W {
+                    bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
+                        | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
+                    _reg: marker::PhantomData,
+                },
+            )
+            .bits,
+        );
+    }
+}
+
+impl<REG: Readable> core::fmt::Debug for crate::generic::Reg<REG>
+where
+    R<REG>: core::fmt::Debug,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        unsafe { core::fmt::Debug::fmt(&self.read(), f) }
+    }
+}
diff --git a/src/generate/generic_reg_vcell.rs b/src/generate/generic_reg_vcell.rs
new file mode 100644
index 00000000..5081ae20
--- /dev/null
+++ b/src/generate/generic_reg_vcell.rs
@@ -0,0 +1,171 @@
+/// This structure provides volatile access to registers.
+#[repr(transparent)]
+pub struct Reg<REG: RegisterSpec> {
+    register: vcell::VolatileCell<REG::Ux>,
+    _marker: marker::PhantomData<REG>,
+}
+
+unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}
+
+impl<REG: RegisterSpec> Reg<REG> {
+    /// Returns the underlying memory address of register.
+    ///
+    /// ```ignore
+    /// let reg_ptr = periph.reg.as_ptr();
+    /// ```
+    #[inline(always)]
+    pub fn as_ptr(&self) -> *mut REG::Ux {
+        self.register.as_ptr()
+    }
+}
+
+impl<REG: Readable> Reg<REG> {
+    /// Reads the contents of a `Readable` register.
+    ///
+    /// You can read the raw contents of a register by using `bits`:
+    /// ```ignore
+    /// let bits = periph.reg.read().bits();
+    /// ```
+    /// or get the content of a particular field of a register:
+    /// ```ignore
+    /// let reader = periph.reg.read();
+    /// let bits = reader.field1().bits();
+    /// let flag = reader.field2().bit_is_set();
+    /// ```
+    #[inline(always)]
+    pub fn read(&self) -> R<REG> {
+        R {
+            bits: self.register.get(),
+            _reg: marker::PhantomData,
+        }
+    }
+}
+
+impl<REG: Resettable + Writable> Reg<REG> {
+    /// Writes the reset value to `Writable` register.
+    ///
+    /// Resets the register to its initial state.
+    #[inline(always)]
+    pub fn reset(&self) {
+        self.register.set(REG::RESET_VALUE)
+    }
+
+    /// Writes bits to a `Writable` register.
+    ///
+    /// You can write raw bits into a register:
+    /// ```ignore
+    /// periph.reg.write(|w| unsafe { w.bits(rawbits) });
+    /// ```
+    /// or write only the fields you need:
+    /// ```ignore
+    /// periph.reg.write(|w| w
+    ///     .field1().bits(newfield1bits)
+    ///     .field2().set_bit()
+    ///     .field3().variant(VARIANT)
+    /// );
+    /// ```
+    /// or an alternative way of saying the same:
+    /// ```ignore
+    /// periph.reg.write(|w| {
+    ///     w.field1().bits(newfield1bits);
+    ///     w.field2().set_bit();
+    ///     w.field3().variant(VARIANT)
+    /// });
+    /// ```
+    /// In the latter case, other fields will be set to their reset value.
+    #[inline(always)]
+    pub fn write<F>(&self, f: F)
+    where
+        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
+    {
+        self.register.set(
+            f(&mut W {
+                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> {
+    /// 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)
+    where
+        F: FnOnce(&mut W<REG>) -> &mut W<REG>,
+    {
+        self.register.set(
+            f(&mut W {
+                bits: REG::Ux::default(),
+                _reg: marker::PhantomData,
+            })
+            .bits,
+        );
+    }
+}
+
+impl<REG: Readable + Writable> Reg<REG> {
+    /// Modifies the contents of the register by reading and then writing it.
+    ///
+    /// E.g. to do a read-modify-write sequence to change parts of a register:
+    /// ```ignore
+    /// periph.reg.modify(|r, w| unsafe { w.bits(
+    ///    r.bits() | 3
+    /// ) });
+    /// ```
+    /// or
+    /// ```ignore
+    /// periph.reg.modify(|_, w| w
+    ///     .field1().bits(newfield1bits)
+    ///     .field2().set_bit()
+    ///     .field3().variant(VARIANT)
+    /// );
+    /// ```
+    /// or an alternative way of saying the same:
+    /// ```ignore
+    /// periph.reg.modify(|_, w| {
+    ///     w.field1().bits(newfield1bits);
+    ///     w.field2().set_bit();
+    ///     w.field3().variant(VARIANT)
+    /// });
+    /// ```
+    /// Other fields will have the value they had before the call to `modify`.
+    #[inline(always)]
+    pub fn modify<F>(&self, f: F)
+    where
+        for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
+    {
+        let bits = self.register.get();
+        self.register.set(
+            f(
+                &R {
+                    bits,
+                    _reg: marker::PhantomData,
+                },
+                &mut W {
+                    bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
+                        | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
+                    _reg: marker::PhantomData,
+                },
+            )
+            .bits,
+        );
+    }
+}
+
+impl<REG: Readable> core::fmt::Debug for crate::generic::Reg<REG>
+where
+    R<REG>: core::fmt::Debug
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&self.read(), f)
+    }
+}
diff --git a/src/generate/peripheral.rs b/src/generate/peripheral.rs
index 60da97f6..2a244c9c 100644
--- a/src/generate/peripheral.rs
+++ b/src/generate/peripheral.rs
@@ -61,7 +61,7 @@ pub fn render(p_original: &Peripheral, index: &Index, config: &Config) -> Result
         feature_attribute.extend(quote! { #[cfg(feature = #feature_name)] });
     };
 
-    let steal_fn = quote! {
+    let steal_docs = quote! {
         /// Steal an instance of this peripheral
         ///
         /// # Safety
@@ -75,9 +75,6 @@ pub fn render(p_original: &Peripheral, index: &Index, config: &Config) -> Result
         /// Additionally, other software such as HALs may rely on only one
         /// peripheral instance existing to ensure memory safety; ensure
         /// no stolen instances are passed to such software.
-        pub unsafe fn steal() -> Self {
-            Self { _marker: PhantomData }
-        }
     };
 
     match &p {
@@ -97,39 +94,74 @@ pub fn render(p_original: &Peripheral, index: &Index, config: &Config) -> Result
                     feature_attribute_n.extend(quote! { #[cfg(feature = #p_feature)] })
                 };
                 // Insert the peripherals structure
-                out.extend(quote! {
-                    #[doc = #description]
-                    #doc_alias
-                    #feature_attribute_n
-                    pub struct #p_ty { _marker: PhantomData<*const ()> }
+                out.extend(if config.raw_access {
+                    quote! {
+                        #[doc = #description]
+                        #doc_alias
+                        #feature_attribute_n
+                        pub struct #p_ty { rb: #base::RegisterBlock }
+
+                        #feature_attribute_n
+                        unsafe impl Send for #p_ty {}
+
+                        #feature_attribute_n
+                        impl #p_ty {
+                            #steal_docs
+                            pub unsafe fn steal() -> Self {
+                                Self { rb: #base::RegisterBlock::new(#address as *mut u8) }
+                            }
+                        }
 
-                    #feature_attribute_n
-                    unsafe impl Send for #p_ty {}
+                        #feature_attribute_n
+                        impl Deref for #p_ty {
+                            type Target = #base::RegisterBlock;
 
-                    #feature_attribute_n
-                    impl #p_ty {
-                        ///Pointer to the register block
-                        pub const PTR: *const #base::RegisterBlock = #address as *const _;
-
-                        ///Return the pointer to the register block
-                        #[inline(always)]
-                        pub const fn ptr() -> *const #base::RegisterBlock {
-                            Self::PTR
+                            #[inline(always)]
+                            fn deref(&self) -> &Self::Target {
+                                &self.rb
+                            }
                         }
-
-                        #steal_fn
                     }
+                } else {
+                    quote! {
+                        #[doc = #description]
+                        #doc_alias
+                        #feature_attribute_n
+                        pub struct #p_ty { _marker: PhantomData<*const ()> }
+
+                        #feature_attribute_n
+                        unsafe impl Send for #p_ty {}
+
+                        #feature_attribute_n
+                        impl #p_ty {
+                            ///Pointer to the register block
+                            pub const PTR: *const #base::RegisterBlock = #address as *const _;
+
+                            ///Return the pointer to the register block
+                            #[inline(always)]
+                            pub const fn ptr() -> *const #base::RegisterBlock {
+                                Self::PTR
+                            }
 
-                    #feature_attribute_n
-                    impl Deref for #p_ty {
-                        type Target = #base::RegisterBlock;
+                            #steal_docs
+                            pub unsafe fn steal() -> Self {
+                                Self { _marker: PhantomData }
+                            }
+                        }
 
-                        #[inline(always)]
-                        fn deref(&self) -> &Self::Target {
-                            unsafe { &*Self::PTR }
+                        #feature_attribute_n
+                        impl Deref for #p_ty {
+                            type Target = #base::RegisterBlock;
+
+                            #[inline(always)]
+                            fn deref(&self) -> &Self::Target {
+                                unsafe { &*Self::PTR }
+                            }
                         }
                     }
+                });
 
+                out.extend(quote! {
                     #feature_attribute_n
                     impl core::fmt::Debug for #p_ty {
                         fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -159,38 +191,72 @@ pub fn render(p_original: &Peripheral, index: &Index, config: &Config) -> Result
                 feature_attribute.extend(quote! { #[cfg(feature = #p_feature)] })
             };
             // Insert the peripheral structure
-            out.extend(quote! {
-                #[doc = #description]
-                #feature_attribute
-                pub struct #p_ty { _marker: PhantomData<*const ()> }
+            out.extend(if config.raw_access {
+                quote! {
+                    #[doc = #description]
+                    #feature_attribute
+                    #[repr(transparent)]
+                    pub struct #p_ty { rb: #base::RegisterBlock }
 
-                #feature_attribute
-                unsafe impl Send for #p_ty {}
+                    #feature_attribute
+                    unsafe impl Send for #p_ty {}
 
-                #feature_attribute
-                impl #p_ty {
-                    ///Pointer to the register block
-                    pub const PTR: *const #base::RegisterBlock = #address as *const _;
-
-                    ///Return the pointer to the register block
-                    #[inline(always)]
-                    pub const fn ptr() -> *const #base::RegisterBlock {
-                        Self::PTR
+                    #feature_attribute
+                    impl #p_ty {
+                        #steal_docs
+                        pub unsafe fn steal() -> Self {
+                            Self { rb: #base::RegisterBlock::new(#address as *mut u8) }
+                        }
                     }
 
-                    #steal_fn
+                    #feature_attribute
+                    impl Deref for #p_ty {
+                        type Target = #base::RegisterBlock;
+
+                        #[inline(always)]
+                        fn deref(&self) -> &Self::Target {
+                            &self.rb
+                        }
+                    }
                 }
+            } else {
+                quote! {
+                    #[doc = #description]
+                    #feature_attribute
+                    pub struct #p_ty { _marker: PhantomData<*const ()> }
 
-                #feature_attribute
-                impl Deref for #p_ty {
-                    type Target = #base::RegisterBlock;
+                    #feature_attribute
+                    unsafe impl Send for #p_ty {}
+
+                    #feature_attribute
+                    impl #p_ty {
+                        ///Pointer to the register block
+                        pub const PTR: *const #base::RegisterBlock = #address as *const _;
+
+                        ///Return the pointer to the register block
+                        #[inline(always)]
+                        pub const fn ptr() -> *const #base::RegisterBlock {
+                            Self::PTR
+                        }
 
-                    #[inline(always)]
-                    fn deref(&self) -> &Self::Target {
-                        unsafe { &*Self::PTR }
+                        #steal_docs
+                        pub unsafe fn steal() -> Self {
+                            Self { _marker: PhantomData }
+                        }
                     }
-                }
 
+                    #feature_attribute
+                    impl Deref for #p_ty {
+                        type Target = #base::RegisterBlock;
+
+                        #[inline(always)]
+                        fn deref(&self) -> &Self::Target {
+                            unsafe { &*Self::PTR }
+                        }
+                    }
+                }
+            });
+            out.extend(quote! {
                 #feature_attribute
                 impl core::fmt::Debug for #p_ty {
                     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -649,6 +715,18 @@ fn register_or_cluster_block(
         Ident::new("RegisterBlock", span)
     };
 
+    if config.raw_access {
+        accessors.extend(quote! {
+            pub(crate) const fn new(ptr: *mut u8) -> Self {
+                Self { ptr }
+            }
+            #[inline(always)]
+            pub const fn ptr(&self) -> *mut u8 {
+                self.ptr
+            }
+        })
+    }
+
     let accessors = (!accessors.is_empty()).then(|| {
         quote! {
             impl #block_ty {
@@ -657,16 +735,31 @@ fn register_or_cluster_block(
         }
     });
 
-    Ok(quote! {
-        #[repr(C)]
-        #derive_debug
-        #[doc = #doc]
-        #doc_alias
-        pub struct #block_ty {
-            #rbfs
+    Ok(if config.raw_access {
+        quote! {
+            #[doc = #doc]
+            #[repr(C)]
+            #derive_debug
+            #doc_alias
+            #[non_exhaustive]
+            pub struct #block_ty {
+                ptr: *mut u8,
+            }
+
+            #accessors
         }
+    } else {
+        quote! {
+            #[doc = #doc]
+            #[repr(C)]
+            #derive_debug
+            #doc_alias
+            pub struct #block_ty {
+                #rbfs
+            }
 
-        #accessors
+            #accessors
+        }
     })
 }
 
@@ -1009,7 +1102,7 @@ fn expand_cluster(cluster: &Cluster, config: &Config) -> Result<Vec<RegisterBloc
                 ty,
                 offset: unsuffixed(info.address_offset),
             })
-            .raw_if(config.raw_access);
+            .ptr_or_rawref_if(config.raw_access, false);
             cluster_expanded.push(RegisterBlockField {
                 syn_field,
                 offset: info.address_offset,
@@ -1070,7 +1163,7 @@ fn expand_cluster(cluster: &Cluster, config: &Config) -> Result<Vec<RegisterBloc
                         dim: unsuffixed(array_info.dim),
                         increment: unsuffixed(array_info.dim_increment),
                     })
-                    .raw_if(config.raw_access || !array_convertible),
+                    .ptr_or_rawref_if(config.raw_access, !array_convertible),
                 );
                 if !sequential_indexes_from0 || !ends_with_index {
                     for (i, ci) in svd::cluster::expand(info, array_info).enumerate() {
@@ -1089,7 +1182,7 @@ fn expand_cluster(cluster: &Cluster, config: &Config) -> Result<Vec<RegisterBloc
                                 basename: accessor_name.clone(),
                                 i,
                             })
-                            .raw_if(false),
+                            .ptr_or_rawref_if(config.raw_access, false),
                         );
                     }
                 }
@@ -1125,7 +1218,7 @@ fn expand_cluster(cluster: &Cluster, config: &Config) -> Result<Vec<RegisterBloc
                         ty: ty.clone(),
                         offset: unsuffixed(info.address_offset),
                     })
-                    .raw_if(config.raw_access);
+                    .ptr_or_rawref_if(config.raw_access, false);
                     cluster_expanded.push(RegisterBlockField {
                         syn_field,
                         offset: ci.address_offset,
@@ -1177,7 +1270,7 @@ fn expand_register(
                 ty,
                 offset: unsuffixed(info.address_offset),
             })
-            .raw_if(config.raw_access);
+            .ptr_or_rawref_if(config.raw_access, false);
             register_expanded.push(RegisterBlockField {
                 syn_field,
                 offset: info.address_offset,
@@ -1253,7 +1346,7 @@ fn expand_register(
                         dim: unsuffixed(array_info.dim),
                         increment: unsuffixed(array_info.dim_increment),
                     })
-                    .raw_if(config.raw_access || !array_convertible),
+                    .ptr_or_rawref_if(config.raw_access, !array_convertible),
                 );
                 if !sequential_indexes_from0 || !ends_with_index {
                     for (i, ri) in svd::register::expand(info, array_info).enumerate() {
@@ -1277,7 +1370,7 @@ fn expand_register(
                                 basename: accessor_name.clone(),
                                 i,
                             })
-                            .raw_if(false),
+                            .ptr_or_rawref_if(config.raw_access, false),
                         );
                     }
                 };
@@ -1313,7 +1406,7 @@ fn expand_register(
                         ty: ty.clone(),
                         offset: unsuffixed(info.address_offset),
                     })
-                    .raw_if(config.raw_access);
+                    .ptr_or_rawref_if(config.raw_access, false);
                     register_expanded.push(RegisterBlockField {
                         syn_field,
                         offset: ri.address_offset,
diff --git a/src/generate/peripheral/accessor.rs b/src/generate/peripheral/accessor.rs
index d30576c0..951033a5 100644
--- a/src/generate/peripheral/accessor.rs
+++ b/src/generate/peripheral/accessor.rs
@@ -12,11 +12,14 @@ pub enum Accessor {
 pub enum AccessType {
     Ref(Accessor),
     RawRef(Accessor),
+    Ptr(Accessor),
 }
 
 impl Accessor {
-    pub fn raw_if(self, flag: bool) -> AccessType {
-        if flag {
+    pub fn ptr_or_rawref_if(self, ptr_flag: bool, raw_flag: bool) -> AccessType {
+        if ptr_flag {
+            AccessType::Ptr(self)
+        } else if raw_flag {
             AccessType::RawRef(self)
         } else {
             AccessType::Ref(self)
@@ -27,7 +30,7 @@ impl Accessor {
 impl AccessType {
     pub fn raw(self) -> Self {
         match self {
-            Self::RawRef(_) => self,
+            Self::RawRef(_) | Self::Ptr(_) => self,
             Self::Ref(a) => Self::RawRef(a),
         }
     }
@@ -59,6 +62,20 @@ impl ToTokens for AccessType {
                     }
                 }
             }
+            Self::Ptr(Accessor::Reg(RegAccessor {
+                doc,
+                name,
+                ty,
+                offset,
+            })) => {
+                quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub const fn #name(&self) -> #ty {
+                        #ty::new(unsafe { self.ptr().add(#offset) })
+                    }
+                }
+            }
             Self::Ref(Accessor::Array(ArrayAccessor { doc, name, ty, .. })) => {
                 let name_iter = Ident::new(&format!("{name}_iter"), Span::call_site());
                 quote! {
@@ -101,6 +118,32 @@ impl ToTokens for AccessType {
                     }
                 }
             }
+            Self::Ptr(Accessor::Array(ArrayAccessor {
+                doc,
+                name,
+                ty,
+                offset,
+                dim,
+                increment,
+            })) => {
+                let name_iter = Ident::new(&format!("{name}_iter"), Span::call_site());
+                let cast = quote! { #ty::new(unsafe { self.ptr().add(#offset).add(#increment * n) }) };
+                quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub const fn #name(&self, n: usize) -> #ty {
+                        #[allow(clippy::no_effect)]
+                        [(); #dim][n];
+                        #cast
+                    }
+                    #[doc = "Iterator for array of:"]
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub fn #name_iter(&self) -> impl Iterator<Item=#ty> + '_ {
+                        (0..#dim).map(move |n| #cast)
+                    }
+                }
+            }
             Self::RawRef(Accessor::ArrayElem(elem)) | Self::Ref(Accessor::ArrayElem(elem)) => {
                 let ArrayElemAccessor {
                     doc,
@@ -117,6 +160,21 @@ impl ToTokens for AccessType {
                     }
                 }
             }
+            Self::Ptr(Accessor::ArrayElem(ArrayElemAccessor {
+                    doc,
+                    name,
+                    ty,
+                    basename,
+                    i,
+                })) => {
+                quote! {
+                    #[doc = #doc]
+                    #[inline(always)]
+                    pub const fn #name(&self) -> #ty {
+                        self.#basename(#i)
+                    }
+                }
+            }
         }
         .to_tokens(tokens);
     }