Change Nvmc backing storage to [u8]

Author: ia0

examples/nvmc-demo/memory.x

@@ -2,8 +2,8 @@ MEMORY
 {
   /* NOTE 1 K = 1 KiB = 1024 bytes */
   FLASH : ORIGIN = 0x00000000, LENGTH = 1024K - 16K
-  /* We use 4 pages of 4 KiB each, so 16 KiB */
-  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = 16K
+  /* We use 6 pages of 4 KiB each */
+  CONFIG : ORIGIN = ORIGIN(FLASH) + LENGTH(FLASH), LENGTH = 6 * 4K
   RAM : ORIGIN = 0x20000000, LENGTH = 256K
 }
 

examples/nvmc-demo/src/main.rs

@@ -14,13 +14,12 @@ use hal::pac::NVMC;
 use panic_probe as _;
 use rtt_target::{rprintln, rtt_init_print};
 
-// We use 4 pages to use non-zero offsets.
+const NUM_PAGES: usize = 6;
 const PAGE_SIZE: u32 = 4 * 1024;
 const LAST_PAGE: u32 = 3 * PAGE_SIZE;
-const CONFIG_SIZE: usize = 4 * PAGE_SIZE as usize / 4;
 extern "C" {
     #[link_name = "_config"]
-    static mut CONFIG: [u32; CONFIG_SIZE];
+    static mut CONFIG: [u8; NUM_PAGES * PAGE_SIZE as usize];
 }
 
 // To run this example:
@@ -88,9 +87,7 @@ fn read<const LENGTH: usize>(nvmc: &mut Nvmc<NVMC>, offset: u32) -> [u8; LENGTH]
 }
 
 unsafe fn direct_read<const LENGTH: usize>(offset: u32) -> [u8; LENGTH] {
-    let ptr = &CONFIG as *const u32 as *const u8;
-    let slice = core::slice::from_raw_parts(ptr, CONFIG_SIZE * 4);
-    slice[offset as usize..][..LENGTH].try_into().unwrap()
+    CONFIG[offset as usize..][..LENGTH].try_into().unwrap()
 }
 
 fn erase_if_needed(nvmc: &mut Nvmc<NVMC>, offset: u32) {

nrf-hal-common/src/nvmc.rs

@@ -14,23 +14,31 @@ use crate::pac::NVMC_NS as NVMC;
 use core::convert::TryInto;
 use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
 
+type WORD = u32;
+const WORD_SIZE: usize = core::mem::size_of::<WORD>();
+const PAGE_SIZE: usize = 4 * 1024;
+
 /// Interface to an NVMC instance.
 pub struct Nvmc<T: Instance> {
     nvmc: T,
-    storage: &'static mut [u32],
+    storage: &'static mut [u8],
 }
 
 impl<T> Nvmc<T>
 where
     T: Instance,
 {
     /// Takes ownership of the peripheral and storage area.
-    pub fn new(nvmc: T, storage: &'static mut [u32]) -> Nvmc<T> {
+    ///
+    /// The storage area must be page-aligned.
+    pub fn new(nvmc: T, storage: &'static mut [u8]) -> Nvmc<T> {
+        assert!(storage.as_ptr() as usize % PAGE_SIZE == 0);
+        assert!(storage.len() % PAGE_SIZE == 0);
         Self { nvmc, storage }
     }
 
     /// Consumes `self` and returns back the raw peripheral and associated storage.
-    pub fn free(self) -> (T, &'static mut [u32]) {
+    pub fn free(self) -> (T, &'static mut [u8]) {
         (self.nvmc, self.storage)
     }
 
@@ -68,28 +76,36 @@ where
 
     #[cfg(not(any(feature = "9160", feature = "5340-app")))]
     #[inline]
-    fn erase_page(&mut self, offset: usize) {
-        let bits = &mut (self.storage[offset as usize >> 2]) as *mut _ as u32;
+    fn erase_page(&mut self, page_offset: usize) {
+        let bits = &mut (self.storage[page_offset * PAGE_SIZE]) as *mut _ as u32;
         self.nvmc.erasepage().write(|w| unsafe { w.bits(bits) });
         self.wait_ready();
     }
 
     #[cfg(any(feature = "9160", feature = "5340-app"))]
     #[inline]
-    fn erase_page(&mut self, offset: usize) {
-        self.storage[offset as usize >> 2] = 0xffffffff;
+    fn erase_page(&mut self, page_offset: usize) {
+        self.direct_write_word(page_offset * PAGE_SIZE, 0xffffffff);
         self.wait_ready();
     }
 
     #[inline]
-    fn write_word(&mut self, offset: usize, word: u32) {
+    fn write_word(&mut self, word_offset: usize, word: u32) {
         #[cfg(not(any(feature = "9160", feature = "5340-app")))]
         self.wait_ready();
         #[cfg(any(feature = "9160", feature = "5340-app"))]
         self.wait_write_ready();
-        self.storage[offset] = word;
+        self.direct_write_word(word_offset, word);
         cortex_m::asm::dmb();
     }
+
+    #[inline]
+    fn direct_write_word(&mut self, word_offset: usize, word: u32) {
+        let target: &mut [u8] = &mut self.storage[word_offset * WORD_SIZE..][..WORD_SIZE];
+        let target: &mut [u8; WORD_SIZE] = target.try_into().unwrap();
+        let target: &mut u32 = unsafe { core::mem::transmute(target) };
+        *target = word;
+    }
 }
 
 impl<T> ReadNorFlash for Nvmc<T>
@@ -100,62 +116,41 @@ where
 
     const READ_SIZE: usize = 1;
 
-    fn read(&mut self, offset: u32, mut bytes: &mut [u8]) -> Result<(), Self::Error> {
-        let mut offset = offset as usize;
+    fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
+        let offset = offset as usize;
         if bytes.len() > self.capacity() || offset > self.capacity() - bytes.len() {
             return Err(NvmcError::OutOfBounds);
         }
         self.wait_ready();
-        if offset & 3 != 0 {
-            let word = self.storage[offset >> 2].to_ne_bytes();
-            let start = offset & 3;
-            let length = 4 - start;
-            if length > bytes.len() {
-                bytes.copy_from_slice(&word[start..start + bytes.len()]);
-                return Ok(());
-            }
-            bytes[..length].copy_from_slice(&word[start..]);
-            offset = offset + length;
-            bytes = &mut bytes[length..];
-        }
-        let mut word_offset = offset >> 2;
-        let mut chunks = bytes.chunks_exact_mut(4);
-        for bytes in &mut chunks {
-            bytes.copy_from_slice(&self.storage[word_offset].to_ne_bytes());
-            word_offset += 1;
-        }
-        let bytes = chunks.into_remainder();
-        if !bytes.is_empty() {
-            bytes.copy_from_slice(&self.storage[word_offset].to_ne_bytes()[..bytes.len()]);
-        }
+        bytes.copy_from_slice(&self.storage[offset..][..bytes.len()]);
         Ok(())
     }
 
     fn capacity(&self) -> usize {
-        self.storage.len() << 2
+        self.storage.len()
     }
 }
 
 impl<T> NorFlash for Nvmc<T>
 where
     T: Instance,
 {
-    const WRITE_SIZE: usize = 4;
+    const WRITE_SIZE: usize = WORD_SIZE;
 
-    const ERASE_SIZE: usize = 4 * 1024;
+    const ERASE_SIZE: usize = PAGE_SIZE;
 
     fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
-        let from = from as usize;
-        let to = to as usize;
+        let (from, to) = (from as usize, to as usize);
         if from > to || to > self.capacity() {
             return Err(NvmcError::OutOfBounds);
         }
-        if from % Self::ERASE_SIZE != 0 || to % Self::ERASE_SIZE != 0 {
+        if from % PAGE_SIZE != 0 || to % PAGE_SIZE != 0 {
             return Err(NvmcError::Unaligned);
         }
+        let (page_from, page_to) = (from / PAGE_SIZE, to / PAGE_SIZE);
         self.enable_erase();
-        for offset in (from..to).step_by(Self::ERASE_SIZE) {
-            self.erase_page(offset);
+        for page_offset in page_from..page_to {
+            self.erase_page(page_offset);
         }
         self.enable_read();
         Ok(())
@@ -166,15 +161,13 @@ where
         if bytes.len() > self.capacity() || offset as usize > self.capacity() - bytes.len() {
             return Err(NvmcError::OutOfBounds);
         }
-        if offset % Self::WRITE_SIZE != 0 || bytes.len() % Self::WRITE_SIZE != 0 {
+        if offset % WORD_SIZE != 0 || bytes.len() % WORD_SIZE != 0 {
             return Err(NvmcError::Unaligned);
         }
+        let word_offset = offset / WORD_SIZE;
         self.enable_write();
-        let mut word_offset = offset >> 2;
-        for bytes in bytes.chunks_exact(4) {
-            // The unwrap is correct because chunks_exact always returns the correct size.
+        for (word_offset, bytes) in (word_offset..).zip(bytes.chunks_exact(WORD_SIZE)) {
             self.write_word(word_offset, u32::from_ne_bytes(bytes.try_into().unwrap()));
-            word_offset += 1;
         }
         self.enable_read();
         Ok(())