eepy: add tickv and overhaul intercore communication

Cargo.toml

···
 serialport = "4.7"
 tar = "0.4"
 zstd = "0.13"
-strum = { version = "0.26", default-features = false, features = ["derive"] }
+strum = { version = "0.26", default-features = false, features = ["derive"] }
+tickv = "2.0"
+siphasher = "1.0"

eepy-example-app/src/main.rs

···
 use eepy_gui::element::button::Button;
 use eepy_gui::element::{Gui, DEFAULT_TEXT_STYLE};
 use eepy_sys::header::ProgramSlotHeader;
-use eepy_sys::image::RefreshBlockMode;
 use eepy_sys::input::{has_event, next_event, set_touch_enabled};
+use eepy_sys::kv_store;
 
 #[link_section = ".header"]
 #[used]
 static HEADER: ProgramSlotHeader = ProgramSlotHeader::partial(
     "ExampleApp",
     env!("CARGO_PKG_VERSION"),
-    entry,
+    main,
 );
 
-#[no_mangle]
-pub extern "C" fn entry() {
+fn load_counter() -> u32 {
+    let mut buf = [0u8; size_of::<i32>()];
+    match kv_store::get(b"counter", &mut buf) {
+        Ok(_) => u32::from_ne_bytes(buf),
+        Err(_) => 0,
+    }
+}
+
+fn save_counter(counter: u32) {
+    let _ = kv_store::put(b"counter", &counter.to_ne_bytes());
+}
+
+fn render_counter(draw_target: &mut EpdDrawTarget, counter: u32) {
+    let mut s = String::<16>::new();
+    write!(s, "{counter}").unwrap();
+    Text::new(&s, Point::new(10, 80), DEFAULT_TEXT_STYLE)
+        .draw(draw_target)
+        .unwrap();
+}
+
+extern "C" fn main() {
     set_touch_enabled(true);
 
     let mut draw_target = EpdDrawTarget::default();
···
     let mut button = Button::with_default_style_auto_sized(Point::new(10, 40), "Click me", true);
     let mut exit_button = Button::with_default_style_auto_sized(Point::new(10, 386), "Exit", false);
 
+    let mut counter = load_counter();
+
     text.draw(&mut draw_target).unwrap();
     button.draw_init(&mut draw_target);
     exit_button.draw_init(&mut draw_target);
-    draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+    render_counter(&mut draw_target, counter);
+    draw_target.refresh(false);
 
-    let mut counter = 0;
 
     loop {
         while let Some(ev) = next_event() {
             if exit_button.tick(&mut draw_target, ev).clicked {
+                save_counter(counter);
                 return;
             }
 
···
                 exit_button.draw_init(&mut draw_target);
 
                 counter += 1;
-                let mut s = String::<16>::new();
-                write!(s, "{counter}").unwrap();
-                Text::new(&s, Point::new(10, 80), DEFAULT_TEXT_STYLE)
-                    .draw(&mut draw_target)
-                    .unwrap();
+                render_counter(&mut draw_target, counter);
                 needs_refresh = true;
             }
             needs_refresh |= response.needs_refresh;
 
             if needs_refresh {
-                draw_target.refresh(true, RefreshBlockMode::NonBlocking);
+                draw_target.maybe_refresh(true);
             }
         }
 

eepy-gui/src/draw_target.rs

···
 use embedded_graphics::Pixel;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::primitives::Rectangle;
-use eepy_sys::image::{refresh, write_image, RefreshBlockMode};
+use eepy_sys::image::{maybe_refresh, refresh};
 use tp370pgh01::{DIM_X, DIM_Y, IMAGE_BYTES};
 
 pub struct EpdDrawTarget {
···
 }
 
 impl EpdDrawTarget {
-    pub fn refresh(&self, fast_refresh: bool, block_mode: RefreshBlockMode) {
-        write_image(&self.framebuffer);
-        refresh(fast_refresh, block_mode);
+    pub fn refresh(&self, fast_refresh: bool) {
+        refresh(&self.framebuffer, fast_refresh);
+    }
+
+    pub fn maybe_refresh(&self, fast_refresh: bool) {
+        maybe_refresh(&self.framebuffer, fast_refresh);
     }
 }

eepy-launcher/src/main.rs

···
 use eepy_gui::element::Gui;
 use eepy_gui::element::slider::Slider;
 use eepy_sys::exec::exec;
-use eepy_sys::image::RefreshBlockMode;
 use eepy_sys::input::{has_event, next_event, set_touch_enabled};
 use eepy_sys::input_common::{Event, TouchEventType};
 use eepy_sys::header::{ProgramSlotHeader, Programs};
···
 static HEADER: ProgramSlotHeader = ProgramSlotHeader::partial(
     "Launcher",
     env!("CARGO_PKG_VERSION"),
-    entry,
+    main,
 );
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
···
         if s.clicked {
             return Some(Page::ScratchpadPage);
         } else if s.needs_refresh {
-            draw_target.refresh(true, RefreshBlockMode::BlockAcknowledge);
+            draw_target.refresh(true);
         }
 
         for b in &mut self.app_buttons {
···
         }
 
         if needs_refresh {
-            draw_target.refresh(true, RefreshBlockMode::NonBlocking);
+            draw_target.refresh(true);
         }
 
         None
···
     }
 
     fn tick(&mut self, draw_target: &mut EpdDrawTarget, ev: Event) -> Self::Output {
-        let mut refresh: Option<RefreshBlockMode> = None;
+        let mut refresh = false;
+        let mut maybe_refresh = false;
         let mut handle_drawing: bool = true;
 
         let e = self.exit_button.tick(draw_target, ev);
         if e.clicked {
             return Some(Page::MainPage);
         }
-        if e.needs_refresh {
-            refresh = Some(RefreshBlockMode::BlockAcknowledge);
-        }
+        refresh |= e.needs_refresh;
 
         let c = self.clear_button.tick(draw_target, ev);
         if c.clicked {
             draw_target.clear(BinaryColor::Off).unwrap();
             self.draw_init(draw_target);
-            draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+            draw_target.refresh(false);
             return None;
         }
-        if c.needs_refresh {
-            refresh = Some(RefreshBlockMode::BlockAcknowledge);
-        }
+        refresh |= c.needs_refresh;
 
         let t = self.toggle_button.tick(draw_target, ev);
         if t.clicked {
             self.eraser = !self.eraser;
             self.toggle_button.label = if self.eraser { "Pen" } else { "Eraser" };
-            refresh = Some(RefreshBlockMode::NonBlocking);
         }
-        if t.needs_refresh {
-            refresh = Some(RefreshBlockMode::BlockAcknowledge);
-        }
+        maybe_refresh |= t.clicked;
+        refresh |= t.needs_refresh;
 
         if self.slider.tick(draw_target, ev) {
-            refresh = Some(RefreshBlockMode::NonBlocking);
+            maybe_refresh = true;
             handle_drawing = false;
         }
 
···
 
                     self.draw_init(draw_target);
 
-                    if refresh.is_none() {
-                        refresh = Some(RefreshBlockMode::NonBlocking);
-                    }
+                    maybe_refresh = true;
                 }
             }
 
···
             }
         }
 
-        if let Some(mode) = refresh {
-            draw_target.refresh(true, mode);
+        if refresh {
+            draw_target.refresh(true);
+        } else if maybe_refresh {
+            draw_target.maybe_refresh(true);
         }
 
         None
···
             self.current_page = page;
             draw_target.clear(BinaryColor::Off).unwrap();
             self.draw_init(draw_target);
-            draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+            draw_target.refresh(false);
         }
     }
 }
···
     }
 }
 
-#[no_mangle]
-pub extern "C" fn entry() {
+extern "C" fn main() {
     #[allow(static_mut_refs)]
     unsafe {
         let bus = UsbBusAllocator::new(UsbBus::init());
···
     set_touch_enabled(true);
     let mut gui = MainGui::new();
     gui.draw_init(&mut draw_target);
-    draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+    draw_target.refresh(false);
 
     loop {
         if !HOST_APP.load(Ordering::Relaxed) {
···
                 gui.main_page.refresh_buttons();
                 if gui.current_page == Page::MainPage {
                     gui.draw_init(&mut draw_target);
-                    draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+                    draw_target.refresh(false);
                 }
             } else if NEEDS_REFRESH.swap(false, Ordering::Relaxed) {
                 gui.draw_init(&mut draw_target);
-                draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+                draw_target.refresh(false);
             } else if !has_event() {
                 // has_event() is a syscall. The SVCall exception is a WFE wakeup event, so we need two
                 // WFEs so we don't immediately wake up.

eepy-launcher/src/serial.rs

···
 use usbd_serial::SerialPort;
 use eepy_serial::{Response, SerialCommand};
 use eepy_sys::flash::erase_and_program;
-use eepy_sys::image::{refresh, write_image, RefreshBlockMode};
+use eepy_sys::image::refresh;
 use eepy_sys::IMAGE_BYTES;
 use eepy_sys::input::{next_event, set_touch_enabled};
 use eepy_sys::misc::{debug, info, trace};
···
                             },
                             Ok(SerialCommand::EnterHostApp) => {
                                 HOST_APP.store(true, Ordering::Relaxed);
-                                write_image(&[0u8; IMAGE_BYTES]);
-                                refresh(false, RefreshBlockMode::NonBlocking);
+                                refresh(&[0u8; IMAGE_BYTES], false);
                                 set_touch_enabled(false);
                                 write_all(serial, &[Response::Ack as u8]);
                             },
···
                 if let Ok(count) = serial.read(&mut buf[*index..]) {
                     *index += count;
                     if *index == IMAGE_BYTES {
-                        write_image(buf);
-                        refresh(*fast_refresh, RefreshBlockMode::NonBlocking);
+                        refresh(buf, *fast_refresh);
                         write_all(serial, &[Response::Ack as u8]);
                         *state = SerialState::ReadyForCommand;
                     }

eepy-sys/Cargo.toml

···
 critical-section = { workspace = true, optional = true }
 once_cell = { workspace = true, optional = true }
 strum.workspace = true
+tickv = { workspace = true, optional = true }
 
 [features]
 defmt = ["dep:defmt", "usb-device/defmt"]

eepy-sys/src/image.rs

···
 #[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum ImageSyscall {
-    WriteImage = 0,
-    Refresh = 1,
-}
-
-#[repr(usize)]
-#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub enum RefreshBlockMode {
-    NonBlocking = 0,
-    BlockAcknowledge = 1,
-    BlockFinish = 2,
+    Refresh = 0,
+    MaybeRefresh = 1,
 }
 
-pub fn write_image(image: &[u8; IMAGE_BYTES]) {
+pub fn refresh(image: &[u8; IMAGE_BYTES], fast_refresh: bool) {
     unsafe {
         syscall!(
             SyscallNumber::Image,
-            in ImageSyscall::WriteImage,
+            in ImageSyscall::Refresh,
+            in fast_refresh,
             in &raw const *image,
         );
     }
 }
 
-pub fn refresh(fast_refresh: bool, refresh_block_mode: RefreshBlockMode) {
+pub fn maybe_refresh(image: &[u8; IMAGE_BYTES], fast_refresh: bool) {
     unsafe {
         syscall!(
             SyscallNumber::Image,
-            in ImageSyscall::Refresh,
+            in ImageSyscall::MaybeRefresh,
             in fast_refresh,
-            in refresh_block_mode,
+            in &raw const *image,
         );
     }
 }

eepy-sys/src/kv_store.rs

···
+use core::mem::MaybeUninit;
+use crate::{syscall, SafeResult};
+use crate::syscall::SyscallNumber;
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum KvStoreSyscall {
+    ReadKey = 0,
+    AppendKey = 1,
+    PutKey = 2,
+    InvalidateKey = 3,
+    ZeroiseKey = 4,
+}
+
+#[repr(C)]
+pub struct ReadKeyArgs {
+    pub key_len: usize,
+    pub key_ptr: *const u8,
+    pub buf_len: usize,
+    pub buf_ptr: *mut u8,
+}
+
+#[repr(C)]
+pub struct WriteKeyArgs {
+    pub key_len: usize,
+    pub key_ptr: *const u8,
+    pub value_len: usize,
+    pub value_ptr: *const u8,
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ReadKeyError {
+    FlashCorrupt,
+    InvalidChecksum,
+    NotFound,
+    BufferTooSmall(usize),
+}
+
+#[cfg(feature = "tickv")]
+impl TryFrom<tickv::ErrorCode> for ReadKeyError {
+    type Error = tickv::ErrorCode;
+
+    fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
+        use tickv::ErrorCode as E;
+
+        match value {
+            E::CorruptData => Ok(Self::FlashCorrupt),
+            E::InvalidCheckSum => Ok(Self::InvalidChecksum),
+            E::KeyNotFound => Ok(Self::NotFound),
+            E::BufferTooSmall(size) => Ok(Self::BufferTooSmall(size)),
+            _ => Err(value),
+        }
+    }
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum AppendKeyError {
+    FlashCorrupt,
+    AlreadyExists,
+    RegionFull,
+    FlashFull,
+}
+
+#[cfg(feature = "tickv")]
+impl TryFrom<tickv::ErrorCode> for AppendKeyError {
+    type Error = tickv::ErrorCode;
+
+    fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
+        use tickv::ErrorCode as E;
+
+        match value {
+            E::CorruptData => Ok(Self::FlashCorrupt),
+            E::KeyAlreadyExists => Ok(Self::AlreadyExists),
+            E::RegionFull => Ok(Self::RegionFull),
+            E::FlashFull => Ok(Self::FlashFull),
+            _ => Err(value),
+        }
+    }
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum PutKeyError {
+    FlashCorrupt,
+    RegionFull,
+    FlashFull,
+}
+
+#[cfg(feature = "tickv")]
+impl TryFrom<tickv::ErrorCode> for PutKeyError {
+    type Error = tickv::ErrorCode;
+
+    fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
+        use tickv::ErrorCode as E;
+
+        match value {
+            E::CorruptData => Ok(Self::FlashCorrupt),
+            E::RegionFull => Ok(Self::RegionFull),
+            E::FlashFull => Ok(Self::FlashFull),
+            _ => Err(value),
+        }
+    }
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum DeleteKeyError {
+    FlashCorrupt,
+    NotFound,
+}
+
+#[cfg(feature = "tickv")]
+impl TryFrom<tickv::ErrorCode> for DeleteKeyError {
+    type Error = tickv::ErrorCode;
+
+    fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
+        use tickv::ErrorCode as E;
+
+        match value {
+            E::CorruptData => Ok(Self::FlashCorrupt),
+            E::KeyNotFound => Ok(Self::NotFound),
+            _ => Err(value),
+        }
+    }
+}
+
+pub fn get(key: &[u8], buf: &mut [u8]) -> Result<usize, ReadKeyError> {
+    let args = ReadKeyArgs {
+        key_len: key.len(),
+        key_ptr: key.as_ptr(),
+        buf_len: buf.len(),
+        buf_ptr: buf.as_mut_ptr(),
+    };
+    let mut res: MaybeUninit<SafeResult<usize, ReadKeyError>> = MaybeUninit::uninit();
+
+    unsafe {
+        syscall!(
+            SyscallNumber::KvStore,
+            in KvStoreSyscall::ReadKey,
+            in &raw const args,
+            in res.as_mut_ptr(),
+        );
+
+        res.assume_init().into()
+    }
+}
+
+pub fn append(key: &[u8], value: &[u8]) -> Result<(), AppendKeyError> {
+    let args = WriteKeyArgs {
+        key_len: key.len(),
+        key_ptr: key.as_ptr(),
+        value_len: value.len(),
+        value_ptr: value.as_ptr(),
+    };
+    let mut res: MaybeUninit<SafeResult<(), AppendKeyError>> = MaybeUninit::uninit();
+
+    unsafe {
+        syscall!(
+            SyscallNumber::KvStore,
+            in KvStoreSyscall::AppendKey,
+            in &raw const args,
+            in res.as_mut_ptr(),
+        );
+
+        res.assume_init().into()
+    }
+}
+
+pub fn put(key: &[u8], value: &[u8]) -> Result<(), PutKeyError> {
+    let args = WriteKeyArgs {
+        key_len: key.len(),
+        key_ptr: key.as_ptr(),
+        value_len: value.len(),
+        value_ptr: value.as_ptr(),
+    };
+    let mut res: MaybeUninit<SafeResult<(), PutKeyError>> = MaybeUninit::uninit();
+
+    unsafe {
+        syscall!(
+            SyscallNumber::KvStore,
+            in KvStoreSyscall::PutKey,
+            in &raw const args,
+            in res.as_mut_ptr(),
+        );
+
+        res.assume_init().into()
+    }
+}
+
+pub fn invalidate(key: &[u8]) -> Result<(), DeleteKeyError> {
+    let mut res: MaybeUninit<SafeResult<(), DeleteKeyError>> = MaybeUninit::uninit();
+
+    unsafe {
+        syscall!(
+            SyscallNumber::KvStore,
+            in KvStoreSyscall::InvalidateKey,
+            in key.as_ptr(),
+            in key.len(),
+            in res.as_mut_ptr(),
+        );
+
+        res.assume_init().into()
+    }
+}
+
+pub fn zeroise(key: &[u8]) -> Result<(), DeleteKeyError> {
+    let mut res: MaybeUninit<SafeResult<(), DeleteKeyError>> = MaybeUninit::uninit();
+
+    unsafe {
+        syscall!(
+            SyscallNumber::KvStore,
+            in KvStoreSyscall::ZeroiseKey,
+            in key.as_ptr(),
+            in key.len(),
+            in res.as_mut_ptr(),
+        );
+
+        res.assume_init().into()
+    }
+}

eepy-sys/src/lib.rs

···
 pub mod critical_section;
 #[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod flash;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
+pub mod kv_store;
+
 pub mod input_common;
 
 

eepy-sys/src/syscall.rs

···
     Exec = 4,
     CriticalSection = 5,
     Flash = 6,
+    KvStore = 7,
 }
 
 /// Perform a raw system call.

eepy/Cargo.toml

···
 
 [dependencies]
 fw16-epd-bsp = { path = "../fw16-epd-bsp", features = ["defmt"] }
-eepy-sys = { path = "../eepy-sys", features = ["defmt"] }
+eepy-sys = { path = "../eepy-sys", features = ["defmt", "tickv"] }
 tp370pgh01 = { path = "../tp370pgh01", features = ["rp2040", "defmt"] }
 cortex-m.workspace = true
 cortex-m-rt.workspace = true
···
 portable-atomic.workspace = true
 usb-device = { workspace = true, features = ["defmt"] }
 once_cell.workspace = true
-mcp9808.workspace = true
+mcp9808.workspace = true
+tickv.workspace = true
+siphasher.workspace = true
+strum.workspace = true

eepy/core1.gdbinit

···
+target extended-remote :3334
+
+define mri
+monitor reset init
+end

eepy/src/core1.rs

···
+use core::cell::RefCell;
+use core::sync::atomic::{AtomicBool, Ordering};
+use critical_section::Mutex;
+use defmt::{trace, warn};
+use eepy_sys::input_common::Event;
+use fw16_epd_bsp::hal::gpio::bank0::Gpio11;
+use fw16_epd_bsp::hal::gpio::{FunctionSioOutput, PullNone};
+use fw16_epd_bsp::hal::{Sio, Timer};
+use fw16_epd_bsp::{pac, EpdBusy, EpdCs, EpdDc, EpdReset, EpdSck};
+use fw16_epd_bsp::hal::sio::SioFifo;
+use fw16_epd_bsp::pac::interrupt;
+use tp370pgh01::{Tp370pgh01, IMAGE_BYTES};
+use tp370pgh01::rp2040::{IoPin, Rp2040PervasiveSpiDelays};
+use crate::{EVENT_QUEUE, IMAGE_BUFFER, TEMP};
+
+type SdaIo = IoPin<Gpio11, FunctionSioOutput, PullNone>;
+type Epd = Tp370pgh01<EpdCs, SdaIo, EpdSck, EpdDc, EpdBusy, EpdReset, Timer, Rp2040PervasiveSpiDelays>;
+
+pub(crate) static GLOBAL_EPD: Mutex<RefCell<Option<Epd>>> = Mutex::new(RefCell::new(None));
+
+pub(crate) static IDLE: AtomicBool = AtomicBool::new(true);
+
+/// Function in RAM to be executed by core1 whilst flashing programs (core1 cannot be executing code
+/// from flash whilst writing/erasing flash)
+#[link_section = ".data.ram_func"]
+fn core1_flash_wait(fifo: &mut SioFifo) {
+    cortex_m::interrupt::free(|_cs| {
+        fifo.write_blocking(ToCore0Message::FlashAck as u32);
+        trace!("core1 waiting for flash operation");
+
+        while fifo.read_blocking() != ToCore1Message::FlashFinished as u32 {
+            warn!("Received message other than FlashFinished while in flashing state");
+        }
+    });
+}
+
+pub(crate) fn core1_main() {
+    unsafe {
+        pac::NVIC::unmask(interrupt::SIO_IRQ_PROC1);
+    }
+
+    loop {
+        cortex_m::asm::wfi();
+    }
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, defmt::Format, strum::FromRepr)]
+pub(crate) enum ToCore1Message {
+    FlashWait,
+    FlashFinished,
+    HardResetEpd,
+    RefreshNormal,
+    MaybeRefreshNormal,
+    RefreshFast,
+    MaybeRefreshFast,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, defmt::Format, strum::FromRepr)]
+pub(crate) enum ToCore0Message {
+    FlashAck,
+    RefreshAck,
+}
+
+fn refresh(fast: bool, image: &mut [u8; IMAGE_BYTES], prev_image: &mut [u8; IMAGE_BYTES], epd: &mut Epd) {
+    if fast {
+        prev_image.copy_from_slice(image);
+        critical_section::with(|cs| image.copy_from_slice(IMAGE_BUFFER.borrow_ref(cs).as_ref()));
+        epd.soft_reset().unwrap();
+        epd.refresh_fast(image, prev_image, TEMP.load(Ordering::Relaxed)).unwrap();
+    } else {
+        critical_section::with(|cs| image.copy_from_slice(IMAGE_BUFFER.borrow_ref(cs).as_ref()));
+        epd.soft_reset().unwrap();
+        epd.refresh(image, TEMP.load(Ordering::Relaxed)).unwrap();
+    }
+
+    critical_section::with(|cs| EVENT_QUEUE.borrow_ref_mut(cs).push(Event::RefreshFinished));
+    cortex_m::asm::sev();
+}
+
+#[interrupt]
+fn SIO_IRQ_PROC1() {
+    static mut EPD: Option<Epd> = None;
+    static mut IMAGE: [u8; IMAGE_BYTES] = [0u8; IMAGE_BYTES];
+    static mut PREV_IMAGE: [u8; IMAGE_BYTES] = [0u8; IMAGE_BYTES];
+
+    trace!("SIO_IRQ_PROC1");
+
+    IDLE.store(false, Ordering::Relaxed);
+
+    if EPD.is_none() {
+        critical_section::with(|cs| *EPD = GLOBAL_EPD.borrow(cs).take());
+    }
+    let epd = EPD.as_mut().unwrap();
+
+    let sio = unsafe { pac::Peripherals::steal() }.SIO;
+    unsafe { sio.fifo_st().write_with_zero(|x| x) };
+    let mut fifo = Sio::new(sio).fifo;
+
+    while let Some(val) = fifo.read() {
+        let message = ToCore1Message::from_repr(val);
+        match message {
+            Some(ToCore1Message::FlashWait) => core1_flash_wait(&mut fifo),
+            Some(ToCore1Message::FlashFinished) => warn!("Received FlashFinished but wasn't in flashing state"),
+            Some(ToCore1Message::HardResetEpd) => epd.hard_reset().unwrap(),
+            Some(ToCore1Message::RefreshNormal) => {
+                fifo.write_blocking(ToCore0Message::RefreshAck as u32);
+                refresh(false, IMAGE, PREV_IMAGE, epd);
+            },
+            Some(ToCore1Message::MaybeRefreshNormal) => {
+                if !fifo.is_read_ready() {
+                    refresh(false, IMAGE, PREV_IMAGE, epd);
+                }
+            },
+            Some(ToCore1Message::RefreshFast) => {
+                fifo.write_blocking(ToCore0Message::RefreshAck as u32);
+                refresh(true, IMAGE, PREV_IMAGE, epd);
+            },
+            Some(ToCore1Message::MaybeRefreshFast) => {
+                if !fifo.is_read_ready() {
+                    refresh(true, IMAGE, PREV_IMAGE, epd);
+                }
+            },
+            None => warn!("core1 received unknown FIFO message {}", val),
+        }
+    }
+
+    IDLE.store(true, Ordering::Relaxed);
+}

eepy/src/flash.rs

···
+use defmt::{trace, warn};
+use eepy_sys::header::XIP_BASE;
+use fw16_epd_bsp::hal::Sio;
+use fw16_epd_bsp::pac;
+use crate::core1::{ToCore0Message, ToCore1Message};
+
+fn flash_op(f: impl FnOnce()) {
+    let mut fifo = Sio::new(unsafe { pac::Peripherals::steal() }.SIO).fifo;
+
+    fifo.write_blocking(ToCore1Message::FlashWait as u32);
+    // Wait until core1 has acknowledged that it is now in RAM code
+    while fifo.read_blocking() != ToCore0Message::FlashAck as u32 {
+        warn!("received incorrect message");
+    }
+
+    trace!("core1 is in safe state, performing flash operation...");
+    cortex_m::interrupt::free(|_cs| f());
+
+    // Wake up core1
+    fifo.write_blocking(ToCore1Message::FlashFinished as u32);
+}
+
+fn flush_cache_range(start_addr: u32, len: u32) {
+    // RP2040 Datasheet 2.6.3.2:
+    // "A write to the 0x10… mirror will look up the addressed location in the cache, and delete
+    // any matching entry found. Writing to all word-aligned locations in an address range (e.g.
+    // a flash sector that has just been erased and reprogrammed) therefore eliminates the
+    // possibility of stale cached data in this range, without suffering the effects of a
+    // complete cache flush."
+
+    unsafe {
+        let start_ptr: *mut u32 = XIP_BASE.add(start_addr as usize).cast_mut().cast();
+        let words = len / 4;
+        for _ in 0..words {
+            start_ptr.add(words as usize).write_volatile(0);
+        }
+    }
+}
+
+pub(crate) unsafe fn erase(start_addr: u32, len: u32) {
+    trace!("flash erasing start {} len {}", start_addr, len);
+    flash_op(|| rp2040_flash::flash::flash_range_erase(start_addr, len, true));
+    flush_cache_range(start_addr, len);
+}
+
+pub(crate) unsafe fn program(start_addr: u32, data: &[u8]) {
+    trace!("flash programming start {} len {}", start_addr, data.len());
+    flash_op(|| rp2040_flash::flash::flash_range_program(start_addr, data, true));
+    flush_cache_range(start_addr, data.len() as u32);
+}
+
+pub(crate) unsafe fn erase_and_program(start_addr: u32, data: &[u8]) {
+    trace!("flash programming and erasing start {} len {}", start_addr, data.len());
+    flash_op(|| rp2040_flash::flash::flash_range_erase_and_program(start_addr, data, true));
+    flush_cache_range(start_addr, data.len() as u32);
+}

eepy/src/main.rs

···
 mod launcher;
 mod usb;
 mod exception;
+mod tickv;
+mod flash;
+mod core1;
 
 extern crate panic_probe;
 extern crate defmt_rtt;
···
 use eepy_sys::input_common::{Event, TouchEvent, TouchEventType};
 use tp370pgh01::rp2040::{Rp2040PervasiveSpiDelays, IoPin};
 use tp370pgh01::{Tp370pgh01, IMAGE_BYTES};
+use crate::core1::{core1_main, ToCore1Message, GLOBAL_EPD, IDLE};
 use crate::ringbuffer::RingBuffer;
 
 const SRAM_END: *mut u8 = 0x20042000 as *mut u8;
···
 static GLOBAL_ALARM0: Mutex<RefCell<Option<Alarm0>>> = Mutex::new(RefCell::new(None));
 
 static IMAGE_BUFFER: Mutex<RefCell<[u8; IMAGE_BYTES]>> = Mutex::new(RefCell::new([0; IMAGE_BYTES]));
-static DO_REFRESH: AtomicBool = AtomicBool::new(false);
-static FAST_REFRESH: AtomicBool = AtomicBool::new(false);
-static REFRESHING: AtomicBool = AtomicBool::new(false);
-static EPD_NEEDS_HARD_RESET: AtomicBool = AtomicBool::new(true);
 static TEMP: AtomicU8 = AtomicU8::new(20);
 static SERIAL_NUMBER: OnceCell<[u8; 16]> = OnceCell::new();
 
 static EVENT_QUEUE: Mutex<RefCell<RingBuffer<Event>>> = Mutex::new(RefCell::new(RingBuffer::new()));
 static TOUCH_ENABLED: AtomicBool = AtomicBool::new(false);
-
-static FLASHING: AtomicBool = AtomicBool::new(false);
-static FLASHING_ACK: AtomicBool = AtomicBool::new(false);
-
-/// Function in RAM to be executed by core1 whilst flashing programs (core1 cannot be executing code
-/// from flash whilst writing/erasing flash)
-///
-/// To exit this function from core0, set [FLASHING] to false and SEV
-#[link_section = ".data.ram_func"]
-fn core1_flash_wait() {
-    cortex_m::interrupt::disable();
-    FLASHING_ACK.store(true, Ordering::Relaxed);
-
-    while FLASHING.load(Ordering::Relaxed) {
-        cortex_m::asm::wfe();
-    }
-
-    FLASHING_ACK.store(false, Ordering::Relaxed);
-    unsafe { cortex_m::interrupt::enable() };
-}
 
 #[entry]
 fn main() -> ! {
···
         core.NVIC.set_priority(interrupt::USBCTRL_IRQ, 0b11000000);
     }
 
+    let epd = Tp370pgh01::new(cs, IoPin::new(sda), sck, dc, busy, rst, timer, Rp2040PervasiveSpiDelays);
+    critical_section::with(|cs| GLOBAL_EPD.borrow_ref_mut(cs).replace(epd));
     let mut mc = Multicore::new(&mut pac.PSM, &mut pac.PPB, &mut sio.fifo);
     let core1 = &mut mc.cores()[1];
-    core1.spawn(CORE1_STACK.take().unwrap(), move || {
-        info!("core1 init");
-
-        let mut epd = Tp370pgh01::new(cs, IoPin::new(sda), sck, dc, busy, rst, timer, Rp2040PervasiveSpiDelays);
-
-        let mut prev_image = [0u8; IMAGE_BYTES];
-        let mut image = [0u8; IMAGE_BYTES];
-
-        loop {
-            cortex_m::asm::wfe();
-
-            if FLASHING.load(Ordering::Relaxed) {
-                core1_flash_wait();
-                continue;
-            }
-
-            if EPD_NEEDS_HARD_RESET.swap(false, Ordering::Relaxed) {
-                epd.hard_reset().unwrap();
-            }
-
-            REFRESHING.store(true, Ordering::Relaxed);
-
-            if DO_REFRESH.swap(false, Ordering::Relaxed) {
-                if FAST_REFRESH.load(Ordering::Relaxed) {
-                    prev_image.copy_from_slice(&image);
-                    critical_section::with(|cs| image.copy_from_slice(IMAGE_BUFFER.borrow_ref(cs).as_ref()));
-                    epd.soft_reset().unwrap();
-                    epd.refresh_fast(&image, &prev_image, TEMP.load(Ordering::Relaxed)).unwrap();
-                } else {
-                    critical_section::with(|cs| image.copy_from_slice(IMAGE_BUFFER.borrow_ref(cs).as_ref()));
-                    epd.soft_reset().unwrap();
-                    epd.refresh(&image, TEMP.load(Ordering::Relaxed)).unwrap();
-                }
-
-                critical_section::with(|cs| EVENT_QUEUE.borrow_ref_mut(cs).push(Event::RefreshFinished));
-                cortex_m::asm::sev();
-            }
-
-            REFRESHING.store(false, Ordering::Relaxed);
-        }
-    }).unwrap();
+    core1.spawn(CORE1_STACK.take().unwrap(), core1_main).unwrap();
+    sio.fifo.write_blocking(ToCore1Message::HardResetEpd as u32);
 
     unsafe {
         core.NVIC.set_priority(interrupt::IO_IRQ_BANK0, 0);
···
             }
 
             // Wait until refresh has finished
-            while REFRESHING.load(Ordering::Relaxed) {}
+            while !IDLE.load(Ordering::Relaxed) {}
 
             // Power down temp sensor
             if let Some(i2c) = &mut i2c {
···
                 power_pin.set_low().unwrap();
             }
 
-            EPD_NEEDS_HARD_RESET.store(true, Ordering::Relaxed);
+            let mut fifo = Sio::new(unsafe { pac::Peripherals::steal() }.SIO).fifo;
+            fifo.write_blocking(ToCore1Message::HardResetEpd as u32);
 
             if let Some(reset) = TOUCH_RESET_PIN {
                 cortex_m::asm::delay(1000000);

eepy/src/syscall.rs

···
         Some(SyscallNumber::Exec) => handle_exec(stack_values, using_psp),
         Some(SyscallNumber::CriticalSection) => cs::handle_cs(stack_values),
         Some(SyscallNumber::Flash) => flash::handle_flash(stack_values),
+        Some(SyscallNumber::KvStore) => kv_store::handle_kv_store(stack_values),
         None => panic!("illegal syscall"),
     }
 }
···
 }
 
 mod image {
-    use core::sync::atomic::Ordering;
-    use eepy_sys::image::{ImageSyscall, RefreshBlockMode};
+    use eepy_sys::image::ImageSyscall;
+    use fw16_epd_bsp::hal::Sio;
+    use fw16_epd_bsp::pac;
     use tp370pgh01::IMAGE_BYTES;
-    use crate::{DO_REFRESH, FAST_REFRESH, IMAGE_BUFFER, REFRESHING};
+    use crate::IMAGE_BUFFER;
+    use crate::core1::{ToCore0Message, ToCore1Message};
     use super::StackFrame;
 
     pub(super) fn handle_image(stack_values: &mut StackFrame) {
         match ImageSyscall::from_repr(stack_values.r0) {
-            Some(ImageSyscall::WriteImage) => handle_write_image(stack_values),
             Some(ImageSyscall::Refresh) => handle_refresh(stack_values),
+            Some(ImageSyscall::MaybeRefresh) => handle_maybe_refresh(stack_values),
             None => panic!("illegal syscall"),
         }
     }
 
-    fn handle_write_image(stack_values: &mut StackFrame) {
-        let image: &[u8; IMAGE_BYTES] = unsafe { &*(stack_values.r1 as *const [u8; IMAGE_BYTES]) };
-        critical_section::with(|cs| IMAGE_BUFFER.borrow_ref_mut(cs).copy_from_slice(image));
-    }
-
     fn handle_refresh(stack_values: &mut StackFrame) {
         let fast_refresh = stack_values.r1 != 0;
-        let blocking_mode = RefreshBlockMode::from_repr(stack_values.r2).expect("illegal refresh blocking mode");
+        let image: &[u8; IMAGE_BYTES] = unsafe { &*(stack_values.r2 as *const [u8; IMAGE_BYTES]) };
+        critical_section::with(|cs| IMAGE_BUFFER.borrow_ref_mut(cs).copy_from_slice(image));
 
-        DO_REFRESH.store(true, Ordering::Relaxed);
-        FAST_REFRESH.store(fast_refresh, Ordering::Relaxed);
-        cortex_m::asm::sev();
+        let mut fifo = Sio::new(unsafe { pac::Peripherals::steal() }.SIO).fifo;
+        let message = if fast_refresh { ToCore1Message::RefreshFast } else { ToCore1Message::RefreshNormal };
+        fifo.write_blocking(message as u32);
 
-        if matches!(blocking_mode, RefreshBlockMode::BlockAcknowledge | RefreshBlockMode::BlockFinish) {
-            while DO_REFRESH.load(Ordering::Relaxed) {}
+        if fifo.read_blocking() != ToCore0Message::RefreshAck as u32 {
+            panic!("received incorrect message");
         }
+    }
+
+    fn handle_maybe_refresh(stack_values: &mut StackFrame) {
+        let fast_refresh = stack_values.r1 != 0;
+        let image: &[u8; IMAGE_BYTES] = unsafe { &*(stack_values.r2 as *const [u8; IMAGE_BYTES]) };
+        critical_section::with(|cs| IMAGE_BUFFER.borrow_ref_mut(cs).copy_from_slice(image));
 
-        if matches!(blocking_mode, RefreshBlockMode::BlockFinish) {
-            while REFRESHING.load(Ordering::Relaxed) {}
+        let mut fifo = Sio::new(unsafe { pac::Peripherals::steal() }.SIO).fifo;
+        let message = if fast_refresh { ToCore1Message::MaybeRefreshFast } else { ToCore1Message::MaybeRefreshNormal };
+        if fifo.is_write_ready() {
+            fifo.write(message as u32);
         }
     }
 }
···
 }
 
 mod flash {
-    use core::sync::atomic::Ordering;
     use eepy_sys::flash::FlashSyscall;
     use eepy_sys::header::{SLOT_SIZE, XIP_BASE};
     use crate::exception::StackFrame;
-    use crate::{FLASHING, FLASHING_ACK};
+    use crate::flash::{erase, erase_and_program, program};
 
     pub(super) fn handle_flash(stack_values: &mut StackFrame) {
         match FlashSyscall::from_repr(stack_values.r0) {
···
         }
     }
 
-    fn begin() {
-        // Make sure core1 is running code from RAM with interrupts disabled
-        FLASHING.store(true, Ordering::Relaxed);
-        cortex_m::asm::sev();
-        // Wait until core1 has acknowledged that it is now in RAM code
-        while !FLASHING_ACK.load(Ordering::Relaxed) {}
-        // Disable interrupts on this core
-        cortex_m::interrupt::disable();
-    }
-
-    fn end() {
-        // Enable interrupts
-        unsafe { cortex_m::interrupt::enable() }
-        // Wake up core1
-        FLASHING.store(false, Ordering::Relaxed);
-        cortex_m::asm::sev();
-    }
-
-    fn flush_cache_range(start_addr: u32, len: u32) {
-        // RP2040 Datasheet 2.6.3.2:
-        // "A write to the 0x10… mirror will look up the addressed location in the cache, and delete
-        // any matching entry found. Writing to all word-aligned locations in an address range (e.g.
-        // a flash sector that has just been erased and reprogrammed) therefore eliminates the
-        // possibility of stale cached data in this range, without suffering the effects of a
-        // complete cache flush."
-
-        unsafe {
-            let start_ptr: *mut u32 = XIP_BASE.add(start_addr as usize).cast_mut().cast();
-            let words = len / 4;
-            for _ in 0..words {
-                start_ptr.add(words as usize).write_volatile(0);
-            }
-        }
-    }
-
     fn handle_erase(stack_values: &mut StackFrame) {
         let start_addr = stack_values.r1 as u32;
         let len = stack_values.r2 as u32;
···
             panic!("unaligned flash erase");
         }
 
-        begin();
         unsafe {
-            rp2040_flash::flash::flash_range_erase(start_addr, len, true);
-            flush_cache_range(start_addr, len);
+            erase(start_addr, len);
         }
-        end();
     }
 
     fn handle_program(stack_values: &mut StackFrame) {
···
             panic!("unaligned flash program");
         }
 
-        begin();
         unsafe {
-            rp2040_flash::flash::flash_range_program(start_addr, data, true);
-            flush_cache_range(start_addr, data.len() as u32);
+            program(start_addr, data);
         }
-        end();
     }
 
     fn handle_erase_and_program(stack_values: &mut StackFrame) {
···
             panic!("unaligned flash erase");
         }
 
-        begin();
         unsafe {
-            rp2040_flash::flash::flash_range_erase_and_program(start_addr, data, true);
-            flush_cache_range(start_addr, data.len() as u32);
+            erase_and_program(start_addr, data);
         }
-        end();
+    }
+}
+
+mod kv_store {
+    use core::hash::Hasher;
+    use siphasher::sip::SipHasher;
+    use tickv::{ErrorCode, TicKV};
+    use eepy_sys::header::{slot, SLOT_SIZE};
+    use eepy_sys::kv_store::{AppendKeyError, DeleteKeyError, KvStoreSyscall, PutKeyError, ReadKeyArgs, ReadKeyError, WriteKeyArgs};
+    use eepy_sys::SafeResult;
+    use crate::exception::StackFrame;
+    use crate::tickv::{with_tickv, EepyFlashController};
+
+    pub(super) fn handle_kv_store(stack_values: &mut StackFrame) {
+        match KvStoreSyscall::from_repr(stack_values.r0) {
+            Some(KvStoreSyscall::ReadKey) => handle_kv_get(stack_values),
+            Some(KvStoreSyscall::AppendKey) => handle_kv_append(stack_values),
+            Some(KvStoreSyscall::PutKey) => handle_kv_put(stack_values),
+            Some(KvStoreSyscall::InvalidateKey) => handle_kv_invalidate(stack_values),
+            Some(KvStoreSyscall::ZeroiseKey) => handle_kv_zeroise(stack_values),
+            None => panic!("illegal syscall"),
+        }
+    }
+
+    fn hash(stack_values: &mut StackFrame, key: &[u8]) -> u64 {
+        let slot_number = (stack_values.pc as usize) / SLOT_SIZE;
+        let slot_header = unsafe { slot(slot_number as u8) };
+        let program_name = unsafe { core::slice::from_raw_parts((*slot_header).name_ptr, (*slot_header).name_len) };
+
+        let mut hasher = SipHasher::new();
+        hasher.write(program_name);
+        hasher.write(key);
+        hasher.finish()
+    }
+
+    fn append_key_gc(tickv: &TicKV<EepyFlashController, 4096>, key: u64, value: &[u8]) -> Result<(), ErrorCode> {
+        let mut res = tickv.append_key(key, value).map(|_| ());
+        if let Err(ErrorCode::RegionFull | ErrorCode::FlashFull) = res {
+            res = tickv.garbage_collect().map(|_| ());
+            if res.is_ok() {
+                res = tickv.append_key(key, value).map(|_| ());
+            }
+        }
+        res
+    }
+
+    fn handle_kv_get(stack_values: &mut StackFrame) {
+        let args = stack_values.r1 as *const ReadKeyArgs;
+        let key = unsafe { core::slice::from_raw_parts((*args).key_ptr, (*args).key_len) };
+        let buf = unsafe { core::slice::from_raw_parts_mut((*args).buf_ptr, (*args).buf_len) };
+
+        let hashed_key = hash(stack_values, key);
+        let res = unsafe { with_tickv(|tickv| tickv.get_key(hashed_key, buf)) };
+
+        let res_ptr = stack_values.r2 as *mut SafeResult<usize, ReadKeyError>;
+        let res: SafeResult<usize, ReadKeyError> = res
+            .map(|(_, read)| read)
+            .map_err(|e| e.try_into().unwrap())
+            .into();
+        unsafe { res_ptr.write(res) };
+    }
+
+    fn handle_kv_append(stack_values: &mut StackFrame) {
+        let args = stack_values.r1 as *const WriteKeyArgs;
+        let key = unsafe { core::slice::from_raw_parts((*args).key_ptr, (*args).key_len) };
+        let value = unsafe { core::slice::from_raw_parts((*args).value_ptr, (*args).value_len) };
+
+        let hashed_key = hash(stack_values, key);
+        let res = unsafe { with_tickv(|tickv| append_key_gc(tickv, hashed_key, value)) };
+
+        let res_ptr = stack_values.r2 as *mut SafeResult<(), AppendKeyError>;
+        let res: SafeResult<(), AppendKeyError> = res
+            .map(|_| ())
+            .map_err(|e| e.try_into().unwrap())
+            .into();
+        unsafe { res_ptr.write(res) };
+    }
+
+    fn handle_kv_put(stack_values: &mut StackFrame) {
+        let args = stack_values.r1 as *const WriteKeyArgs;
+        let key = unsafe { core::slice::from_raw_parts((*args).key_ptr, (*args).key_len) };
+        let value = unsafe { core::slice::from_raw_parts((*args).value_ptr, (*args).value_len) };
+
+        let hashed_key = hash(stack_values, key);
+        let mut res = unsafe { with_tickv(|tickv| append_key_gc(tickv, hashed_key, value)) };
+
+        // if there is already a value for this key, invalidate it and write the new value
+        if let Err(ErrorCode::KeyAlreadyExists) = res {
+            res = unsafe { with_tickv(|tickv| tickv.invalidate_key(hashed_key).map(|_| ())) };
+            if res.is_ok() {
+                res = unsafe { with_tickv(|tickv| append_key_gc(tickv, hashed_key, value)) };
+            }
+        }
+
+        let res_ptr = stack_values.r2 as *mut SafeResult<(), PutKeyError>;
+        let res: SafeResult<(), PutKeyError> = res
+            .map(|_| ())
+            .map_err(|e| e.try_into().unwrap())
+            .into();
+        unsafe { res_ptr.write(res) };
+    }
+
+    fn handle_kv_invalidate(stack_values: &mut StackFrame) {
+        let key = unsafe { core::slice::from_raw_parts(stack_values.r1 as *const u8, stack_values.r2) };
+        let hashed_key = hash(stack_values, key);
+        let res = unsafe { with_tickv(|tickv| tickv.invalidate_key(hashed_key)) };
+
+        let res_ptr = stack_values.r3 as *mut SafeResult<(), DeleteKeyError>;
+        let res: SafeResult<(), DeleteKeyError> = res
+            .map(|_| ())
+            .map_err(|e| e.try_into().unwrap())
+            .into();
+        unsafe { res_ptr.write(res) };
+    }
+
+    fn handle_kv_zeroise(stack_values: &mut StackFrame) {
+        let key = unsafe { core::slice::from_raw_parts(stack_values.r1 as *const u8, stack_values.r2) };
+        let hashed_key = hash(stack_values, key);
+        let res = unsafe { with_tickv(|tickv| tickv.zeroise_key(hashed_key)) };
+
+        let res_ptr = stack_values.r3 as *mut SafeResult<(), DeleteKeyError>;
+        let res: SafeResult<(), DeleteKeyError> = res
+            .map(|_| ())
+            .map_err(|e| e.try_into().unwrap())
+            .into();
+        unsafe { res_ptr.write(res) };
     }
 }

eepy/src/tickv.rs

···
+use once_cell::unsync::OnceCell;
+use defmt::trace;
+use siphasher::sip::SipHasher;
+use tickv::{ErrorCode, FlashController, TicKV, MAIN_KEY};
+
+const TICKV_START_XIP: *const u8 = 0x10040000 as *const u8;
+const TICKV_START_FLASH: usize = 0x40000;
+const TICKV_SIZE: usize = 256 * 1024;
+
+pub(crate) struct EepyFlashController;
+
+impl FlashController<4096> for EepyFlashController {
+    fn read_region(&self, region_number: usize, buf: &mut [u8; 4096]) -> Result<(), ErrorCode> {
+        trace!("kv read_region");
+
+        unsafe {
+            let start_addr = TICKV_START_XIP.add(region_number * 4096);
+            let slice = core::slice::from_raw_parts(start_addr, 4096);
+            buf.copy_from_slice(slice);
+            Ok(())
+        }
+    }
+
+    fn write(&self, mut address: usize, mut buf: &[u8]) -> Result<(), ErrorCode> {
+        trace!("kv write");
+
+        // If the address is unaligned, read-modify-write the first part
+        if address % 256 != 0 {
+            let write_len = usize::min(buf.len(), 256 - (address % 256));
+            let block_start = address & !(256 - 1);
+
+            let mut write_buf = [0u8; 256];
+            unsafe {
+                write_buf.copy_from_slice(core::slice::from_raw_parts(TICKV_START_XIP.add(block_start), 256));
+            }
+            write_buf[address % 256..address % 256 + write_len].copy_from_slice(&buf[..write_len]);
+
+            unsafe {
+                crate::flash::program((TICKV_START_FLASH + block_start) as u32, &write_buf);
+            }
+
+            buf = &buf[write_len..];
+            address += write_len;
+        }
+
+        let blocks = buf.len() / 256;
+        if blocks > 0 {
+            unsafe {
+                crate::flash::program((TICKV_START_FLASH + address) as u32, &buf[..blocks * 256]);
+            }
+        }
+        address += blocks * 256;
+        buf = &buf[blocks * 256..];
+
+        if buf.len() > 0 {
+            let mut write_buf = [0u8; 256];
+            write_buf[..buf.len()].copy_from_slice(buf);
+            unsafe {
+                write_buf[buf.len()..].copy_from_slice(core::slice::from_raw_parts(TICKV_START_XIP.add(address), 256 - buf.len()));
+            }
+
+            unsafe {
+                crate::flash::program((TICKV_START_FLASH + address) as u32, &write_buf);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn erase_region(&self, region_number: usize) -> Result<(), ErrorCode> {
+        trace!("kv erase_region");
+
+        unsafe {
+            crate::flash::erase((TICKV_START_FLASH + region_number * 4096) as u32, 4096);
+        }
+        Ok(())
+    }
+}
+
+static mut TICKV_BUFFER: [u8; 4096] = [0u8; 4096];
+static mut TICKV: OnceCell<TicKV<EepyFlashController, 4096>> = OnceCell::new();
+
+/// SAFETY: this must only be called once
+unsafe fn init_tickv() -> TicKV<'static, EepyFlashController, 4096> {
+    // SAFETY: this is only called once, so we can't have aliased mutable references
+    #[allow(static_mut_refs)]
+    let read_buffer = unsafe { &mut TICKV_BUFFER };
+
+    let tickv = TicKV::new(EepyFlashController, read_buffer, TICKV_SIZE);
+
+    let hasher = SipHasher::new();
+    tickv.initialise(hasher.hash(MAIN_KEY)).expect("Failed to initialise TicKV");
+    tickv
+}
+
+#[allow(static_mut_refs)]
+pub(crate) unsafe fn with_tickv<R>(f: impl FnOnce(&TicKV<EepyFlashController, 4096>) -> R) -> R {
+    f(TICKV.get_or_init(|| init_tickv()))
+}

memory.x

···
     BOOT2 : ORIGIN = 0x10000000, LENGTH = 0x100
     FLASH : ORIGIN = 0x10000100, LENGTH = 128K - 0x100
     LAUNCHER: ORIGIN = 0x10020000, LENGTH = 128K
-    RESERVED: ORIGIN = 0x10040000, LENGTH = 256K
+    TICKV: ORIGIN = 0x10040000, LENGTH = 256K
     SLOTS: ORIGIN = 0x10080000, LENGTH = 16M - 512K
     RAM   : ORIGIN = 0x20000000, LENGTH = 128K
     PROGRAM_RAM : ORIGIN = 0x20020000, LENGTH = 136K