From 5b29fce6514df53ed1439a00c966723362b424b3 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 3 May 2022 01:12:48 +0800 Subject: [PATCH] add AtomicCsr type for hw blocks that have to implement Send trait --- svd2utra/src/generate.rs | 89 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/svd2utra/src/generate.rs b/svd2utra/src/generate.rs index a8fef689f..387f86f23 100644 --- a/svd2utra/src/generate.rs +++ b/svd2utra/src/generate.rs @@ -479,6 +479,7 @@ fn print_header(out: &mut U) -> std::io::Result<()> { let s = r####" #![allow(dead_code)] use core::convert::TryInto; +use core::sync::atomic::AtomicPtr; #[derive(Debug, Copy, Clone)] pub struct Register { @@ -640,6 +641,94 @@ where .unwrap_or_default() } } + +#[derive(Debug)] +pub struct AtomicCsr { + pub base: AtomicPtr, +} +impl AtomicCsr +where + T: core::convert::TryFrom + core::convert::TryInto + core::default::Default, +{ + pub fn new(base: *mut T) -> Self { + AtomicCsr { + base: AtomicPtr::new(base) + } + } + /// Read the contents of this register + pub fn r(&mut self, reg: Register) -> T { + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.get_mut()) }; + unsafe { usize_base.add(reg.offset).read_volatile() } + .try_into() + .unwrap_or_default() + } + /// Read a field from this CSR + pub fn rf(&mut self, field: Field) -> T { + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.get_mut()) }; + ((unsafe { usize_base.add(field.register.offset).read_volatile() } >> field.offset) + & field.mask) + .try_into() + .unwrap_or_default() + } + /// Read-modify-write a given field in this CSR + pub fn rmwf(&mut self, field: Field, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.get_mut()) }; + let value_as_usize: usize = value.try_into().unwrap_or_default() << field.offset; + let previous = + unsafe { usize_base.add(field.register.offset).read_volatile() } & !(field.mask << field.offset); + unsafe { + usize_base + .add(field.register.offset) + .write_volatile(previous | value_as_usize) + }; + // prevent re-ordering + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Write a given field without reading it first + pub fn wfo(&mut self, field: Field, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.get_mut()) }; + let value_as_usize: usize = (value.try_into().unwrap_or_default() & field.mask) << field.offset; + unsafe { + usize_base + .add(field.register.offset) + .write_volatile(value_as_usize) + }; + // Ensure the compiler doesn't re-order the write. + // We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before + // *reads*, but this method only *writes* to the locations. + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Write the entire contents of a register without reading it first + pub fn wo(&mut self, reg: Register, value: T) { + let usize_base: *mut usize = unsafe { core::mem::transmute(self.base.get_mut()) }; + let value_as_usize: usize = value.try_into().unwrap_or_default(); + unsafe { usize_base.add(reg.offset).write_volatile(value_as_usize) }; + // Ensure the compiler doesn't re-order the write. + // We use `SeqCst`, because `Acquire` only prevents later accesses from being reordered before + // *reads*, but this method only *writes* to the locations. + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + /// Zero a field from a provided value + pub fn zf(&self, field: Field, value: T) -> T { + let value_as_usize: usize = value.try_into().unwrap_or_default(); + (value_as_usize & !(field.mask << field.offset)) + .try_into() + .unwrap_or_default() + } + /// Shift & mask a value to its final field position + pub fn ms(&self, field: Field, value: T) -> T { + let value_as_usize: usize = value.try_into().unwrap_or_default(); + ((value_as_usize & field.mask) << field.offset) + .try_into() + .unwrap_or_default() + } +} "####; out.write_all(s.as_bytes()) }