From 4fbae4969b22a9d9eaf7a7fd4ab55f0b1f4a4708 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 5 Aug 2025 23:00:28 +0800 Subject: [PATCH] add baremetal RRAM API this works in baremetal environment. Needs to be modified/augmented for xous... --- libs/cramium-hal/src/rram.rs | 139 +++++++++++++++++++++++++++++++++++ 1 file changed, 139 insertions(+) create mode 100644 libs/cramium-hal/src/rram.rs diff --git a/libs/cramium-hal/src/rram.rs b/libs/cramium-hal/src/rram.rs new file mode 100644 index 000000000..d26c87e85 --- /dev/null +++ b/libs/cramium-hal/src/rram.rs @@ -0,0 +1,139 @@ +use utralib::{CSR, utra}; + +pub struct Reram { + csr: CSR, + array: &'static mut [u32], +} + +/// Matches the alignment requirement of the RRC write buffer +const ALIGNMENT: usize = 32; +#[repr(align(4))] +struct AlignedBuffer([u8; ALIGNMENT]); +impl AlignedBuffer { + pub fn as_slice_u32(&self) -> &[u32] { + // safety: this is safe because the #repr(align) ensures that our alignment is correct, + // and the length of the internal data structure is set correctly by design. Furthermore, + // all values in both the source and destination transmutation are representable and valid. + unsafe { core::slice::from_raw_parts(self.0.as_ptr() as *const u32, self.0.len() / 4) } + } +} + +/// This is the code that enables the security modes. Must be written into +/// RRCR on every update - kind of dangerous design, because it is too easy +/// to overlook setting this in a compound register. +const SECURITY_MODE: u32 = 0b1111_1100_0000_0000; +const RRC_LOAD_BUFFER: u32 = 0x5200; +const RRC_WRITE_BUFFER: u32 = 0x9528; +const RRC_CR_NORMAL: u32 = 0; +#[allow(dead_code)] +const RRC_CR_POWERDOWN: u32 = 1; +#[allow(dead_code)] +const RRC_CR_WRITE_DATA: u32 = 0; +const RRC_CR_WRITE_CMD: u32 = 2; + +impl Reram { + pub fn new() -> Self { + Reram { + csr: CSR::new(utra::rrc::HW_RRC_BASE as *mut u32), + array: unsafe { + core::slice::from_raw_parts_mut( + utralib::HW_RERAM_MEM as *mut u32, + utralib::HW_RERAM_MEM_LEN / core::mem::size_of::(), + ) + }, + } + } + + pub fn read_slice(&self) -> &[u32] { self.array } + + /// This is a crappy "unsafe" initial version that requires the write + /// destination address to be aligned to a 256-bit boundary, and the data + /// to be exactly 256 bits long. + pub unsafe fn write_u32_aligned(&mut self, addr: usize, data: &[u32]) { + assert!(addr % 0x20 == 0, "unaligned destination address!"); + assert!(data.len() % 8 == 0, "unaligned source data!"); + // crate::print!("@ {:x} > ", addr); + for (outer, d) in data.chunks_exact(8).enumerate() { + // write the data to the buffer + for (inner, &datum) in d.iter().enumerate() { + // crate::print!(" {:x}", datum); + self.array + .as_mut_ptr() + .add(addr / core::mem::size_of::() + outer * 8 + inner) + .write_volatile(datum); + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + } + // crate::println!(""); + + self.csr.rmwf(utra::rrc::SFR_RRCCR_SFR_RRCCR, RRC_CR_WRITE_CMD | SECURITY_MODE); + self.array + .as_mut_ptr() + .add(addr / core::mem::size_of::() + outer * 8) + .write_volatile(RRC_LOAD_BUFFER); + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + self.array + .as_mut_ptr() + .add(addr / core::mem::size_of::() + outer * 8) + .write_volatile(RRC_WRITE_BUFFER); + core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst); + self.csr.rmwf(utra::rrc::SFR_RRCCR_SFR_RRCCR, RRC_CR_NORMAL | SECURITY_MODE); + } + crate::cache_flush(); + } + + /// This is a general unaligned write primitive for the RRAM that can handle any length + /// slice and alignment of data. + pub fn write_slice(&mut self, offset: usize, data: &[u8]) { + let mut buffer = AlignedBuffer([0u8; ALIGNMENT]); + + // ragged start + let start_len = ALIGNMENT - (offset % ALIGNMENT); + if start_len != 0 { + let start_offset = offset & !(ALIGNMENT - 1); + let dest_slice = unsafe { + core::slice::from_raw_parts( + (start_offset + utralib::HW_RERAM_MEM) as *const u8, + buffer.0.len(), + ) + }; + // populate from old data first + buffer.0.copy_from_slice(&dest_slice); + buffer.0[offset % ALIGNMENT..].copy_from_slice(&data[..start_len]); + // safe because alignment and buffer sizes are guaranteed + unsafe { + self.write_u32_aligned(start_offset, buffer.as_slice_u32()); + } + } + + // aligned middle & end + let mut cur_offset = offset + start_len; + if data.len() - start_len > 0 { + for chunk in data[start_len..].chunks(buffer.0.len()) { + // full chunk + if chunk.len() == buffer.0.len() { + buffer.0.copy_from_slice(&chunk); + // safe because alignment and buffer sizes are guaranteed + unsafe { + self.write_u32_aligned(cur_offset, &buffer.as_slice_u32()); + } + } else { + let dest_slice = unsafe { + core::slice::from_raw_parts( + (cur_offset + utralib::HW_RERAM_MEM) as *const u8, + buffer.0.len(), + ) + }; + // read in the destination full contents + buffer.0.copy_from_slice(&dest_slice); + // now overwrite the "ragged end" + buffer.0[..chunk.len()].copy_from_slice(&chunk); + // safe because alignment and buffer sizes are guaranteed + unsafe { + self.write_u32_aligned(cur_offset, &buffer.as_slice_u32()); + } + } + cur_offset += chunk.len(); + } + } + } +}