fuck

abi/src/lib.rs

@@ -46,7 +46,7 @@ pub fn get_key() -> KeyEvent {
 
 pub mod display {
     use abi_sys::CPixel;
-    use alloc::{vec, vec::Vec};
+    // use alloc::{vec, vec::Vec};
     use embedded_graphics::{
         Pixel,
         geometry::{Dimensions, Point},
@@ -54,7 +54,7 @@ pub mod display {
         prelude::{DrawTarget, Size},
         primitives::Rectangle,
     };
-    use once_cell::unsync::Lazy;
+    // use once_cell::unsync::Lazy;
 
     pub const SCREEN_WIDTH: usize = 320;
     pub const SCREEN_HEIGHT: usize = 320;

abi_sys/src/lib.rs

@@ -46,7 +46,7 @@ pub struct CLayout {
 #[cfg(feature = "alloc")]
 impl Into<Layout> for CLayout {
     fn into(self) -> Layout {
-        unsafe { Layout::from_size_align_unchecked(self.size, self.alignment) }
+        Layout::from_size_align(self.size, self.alignment).unwrap()
     }
 }
 

kernel/src/abi.rs

@@ -3,7 +3,7 @@ use abi_sys::{
     PrintAbi, ReadFile, RngRequest, SleepMsAbi, keyboard::*,
 };
 use alloc::{string::ToString, vec::Vec};
-use core::{alloc::GlobalAlloc, sync::atomic::Ordering};
+use core::{alloc::GlobalAlloc, ops::DerefMut, sync::atomic::Ordering};
 use embassy_rp::clocks::{RoscRng, clk_sys_freq};
 use embassy_time::Instant;
 use embedded_graphics::draw_target::DrawTarget;
@@ -11,8 +11,7 @@ use embedded_sdmmc::{DirEntry, LfnBuffer};
 use heapless::spsc::Queue;
 
 use crate::{
-    display::FRAMEBUFFER,
-    framebuffer::FB_PAUSED,
+    display::{FRAMEBUFFER, FRAMEBUFFER2, WRITE_FRAMEBUFFER2},
     storage::{Dir, File, SDCARD},
 };
 
@@ -80,9 +79,19 @@ pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) {
 
     let iter = cpixels.iter().copied().map(|c: CPixel| c.into());
 
-    FB_PAUSED.store(true, Ordering::Release);
-    unsafe { FRAMEBUFFER.draw_iter(iter).unwrap() }
-    FB_PAUSED.store(false, Ordering::Release);
+    let fb = if cfg!(feature = "pimoroni2w") {
+        if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
+            unsafe { FRAMEBUFFER2.deref_mut() }
+        } else {
+            unsafe { &mut FRAMEBUFFER }
+        }
+    } else {
+        unsafe { &mut FRAMEBUFFER }
+    };
+
+    fb.draw_iter(iter).unwrap();
+
+    WRITE_FRAMEBUFFER2.fetch_not(Ordering::AcqRel);
 }
 
 pub static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();

kernel/src/display.rs

@@ -1,6 +1,10 @@
 use crate::framebuffer::{self, AtomicFrameBuffer};
 use alloc::vec;
-use core::sync::atomic::{AtomicBool, Ordering};
+use core::alloc::GlobalAlloc;
+use core::alloc::Layout;
+#[cfg(feature = "pimoroni2w")]
+use core::sync::atomic::AtomicBool;
+use core::sync::atomic::Ordering;
 use embassy_rp::{
     Peri,
     gpio::{Level, Output},
@@ -22,11 +26,34 @@ type DISPLAY = ST7365P<
 pub const SCREEN_WIDTH: usize = 320;
 pub const SCREEN_HEIGHT: usize = 320;
 
+// used to switch which fb is being used for read/write
+#[cfg(feature = "pimoroni2w")]
+pub static WRITE_FRAMEBUFFER2: AtomicBool = AtomicBool::new(false);
+
+// the default screen buffer - the only one on boards without extra ram or psram
 pub static mut FRAMEBUFFER: Lazy<AtomicFrameBuffer> = Lazy::new(|| {
     static mut BUF: [u16; framebuffer::SIZE] = [0; framebuffer::SIZE];
     AtomicFrameBuffer::new(unsafe { &mut BUF })
 });
 
+#[cfg(feature = "pimoroni2w")]
+pub static mut FRAMEBUFFER2: Lazy<AtomicFrameBuffer> = Lazy::new(|| {
+    use embedded_graphics::{
+        pixelcolor::Rgb565,
+        prelude::{DrawTarget, RgbColor},
+    };
+
+    let buf = unsafe {
+        let slab =
+            crate::heap::HEAP.alloc(Layout::array::<u16>(framebuffer::SIZE).unwrap()) as *mut u16;
+        core::slice::from_raw_parts_mut(slab, framebuffer::SIZE)
+    };
+    let mut fb = AtomicFrameBuffer::new(buf);
+    fb.set_all_tiles(false);
+    fb.clear(Rgb565::BLACK).unwrap();
+    fb
+});
+
 pub async fn init_display(
     spi: Spi<'static, SPI1, Async>,
     cs: Peri<'static, PIN_13>,
@@ -53,7 +80,16 @@ pub async fn init_display(
 #[embassy_executor::task]
 pub async fn display_handler(mut display: DISPLAY) {
     loop {
-        unsafe { FRAMEBUFFER.safe_draw(&mut display).await.unwrap() };
+        let fb = if cfg!(feature = "pimoroni2w") {
+            if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
+                unsafe { &mut FRAMEBUFFER }
+            } else {
+                unsafe { &mut FRAMEBUFFER2 }
+            }
+        } else {
+            unsafe { &mut FRAMEBUFFER }
+        };
+        fb.safe_draw(&mut display).await.unwrap();
 
         // small yield to allow other tasks to run
         Timer::after_nanos(100).await;

kernel/src/framebuffer.rs

@@ -23,23 +23,29 @@ type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
 
 pub const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
 
-pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
-
-static mut DIRTY_TILES: LazyLock<heapless::Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
-    let mut tiles = heapless::Vec::new();
-    for _ in 0..TILE_COUNT {
-        tiles.push(AtomicBool::new(true)).unwrap();
-    }
-    tiles
-});
-
 #[allow(dead_code)]
-pub struct AtomicFrameBuffer<'a>(&'a mut [u16]);
+pub struct AtomicFrameBuffer<'a> {
+    fb: &'a mut [u16],
+    dirty_tiles: heapless::Vec<AtomicBool, TILE_COUNT>,
+}
 
 impl<'a> AtomicFrameBuffer<'a> {
     pub fn new(buffer: &'a mut [u16]) -> Self {
         assert!(buffer.len() == SIZE);
-        Self(buffer)
+        let mut dirty_tiles = heapless::Vec::new();
+        for _ in 0..TILE_COUNT {
+            dirty_tiles.push(AtomicBool::new(true)).unwrap()
+        }
+        Self {
+            fb: buffer,
+            dirty_tiles,
+        }
+    }
+
+    pub fn set_all_tiles(&mut self, set: bool) {
+        for t in self.dirty_tiles.iter_mut() {
+            t.store(set, Ordering::Release);
+        }
     }
 
     fn mark_tiles_dirty(&mut self, rect: Rectangle) {
@@ -52,7 +58,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         for ty in start_ty..=end_ty {
             for tx in start_tx..=end_tx {
                 let tile_idx = ty * tiles_x + tx;
-                unsafe { DIRTY_TILES.get_mut()[tile_idx].store(true, Ordering::Release) };
+                self.dirty_tiles[tile_idx].store(true, Ordering::Release);
             }
         }
     }
@@ -78,7 +84,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         for y in sy..=ey {
             for x in sx..=ex {
                 if let Some(color) = color_iter.next() {
-                    self.0[(y as usize * SCREEN_WIDTH) + x as usize] = color;
+                    self.fb[(y as usize * SCREEN_WIDTH) + x as usize] = color;
                 } else {
                     return Err(()); // Not enough data
                 }
@@ -101,7 +107,7 @@ impl<'a> AtomicFrameBuffer<'a> {
             let mut tx = 0;
             while tx < tiles_x {
                 let idx = ty * tiles_x + tx;
-                if !unsafe { DIRTY_TILES.get()[idx].load(Ordering::Acquire) } {
+                if !self.dirty_tiles[idx].load(Ordering::Acquire) {
                     tx += 1;
                     continue;
                 }
@@ -113,7 +119,7 @@ impl<'a> AtomicFrameBuffer<'a> {
                 // Grow horizontally, but keep under MAX_TILES_PER_METATILE
                 while tx + width_tiles < tiles_x
                     && unsafe {
-                        DIRTY_TILES.get()[ty * tiles_x + tx + width_tiles].load(Ordering::Acquire)
+                        self.dirty_tiles[ty * tiles_x + tx + width_tiles].load(Ordering::Acquire)
                     }
                     && (width_tiles + height_tiles) <= MAX_META_TILES
                 {
@@ -124,8 +130,7 @@ impl<'a> AtomicFrameBuffer<'a> {
 
                 for x_off in 0..width_tiles {
                     unsafe {
-                        DIRTY_TILES.get()[ty * tiles_x + tx + x_off]
-                            .store(false, Ordering::Release);
+                        self.dirty_tiles[ty * tiles_x + tx + x_off].store(false, Ordering::Release);
                     };
                 }
 
@@ -165,12 +170,12 @@ impl<'a> AtomicFrameBuffer<'a> {
                 0,
                 self.size().width as u16 - 1,
                 self.size().height as u16 - 1,
-                &self.0[..],
+                &self.fb[..],
             )
             .await?;
 
         unsafe {
-            for tile in DIRTY_TILES.get_mut().iter() {
+            for tile in self.dirty_tiles.iter() {
                 tile.store(false, Ordering::Release);
             }
         };
@@ -191,11 +196,10 @@ impl<'a> AtomicFrameBuffer<'a> {
         let tiles_x = SCREEN_WIDTH / TILE_SIZE;
         let _tiles_y = SCREEN_HEIGHT / TILE_SIZE;
 
-        let tiles = unsafe { DIRTY_TILES.get_mut() };
         let mut pixel_buffer: heapless::Vec<u16, { TILE_SIZE * TILE_SIZE }> = heapless::Vec::new();
 
         for tile_idx in 0..TILE_COUNT {
-            if tiles[tile_idx].swap(false, Ordering::AcqRel) {
+            if self.dirty_tiles[tile_idx].swap(false, Ordering::AcqRel) {
                 let tx = tile_idx % tiles_x;
                 let ty = tile_idx / tiles_x;
 
@@ -210,7 +214,9 @@ impl<'a> AtomicFrameBuffer<'a> {
                 for y in y_start..y_end {
                     let start = y * SCREEN_WIDTH + x_start;
                     let end = y * SCREEN_WIDTH + x_end;
-                    pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
+                    pixel_buffer
+                        .extend_from_slice(&self.fb[start..end])
+                        .unwrap();
                 }
 
                 display
@@ -240,7 +246,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         RST: OutputPin,
         DELAY: DelayNs,
     {
-        if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
+        if unsafe { self.dirty_tiles.iter().any(|p| p.load(Ordering::Acquire)) } {
             let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
             let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
 
@@ -264,7 +270,9 @@ impl<'a> AtomicFrameBuffer<'a> {
                     let end = start + rect_width;
 
                     // Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
-                    pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
+                    pixel_buffer
+                        .extend_from_slice(&self.fb[start..end])
+                        .unwrap();
                 }
 
                 display
@@ -286,7 +294,7 @@ impl<'a> AtomicFrameBuffer<'a> {
                 for ty in start_ty..=end_ty {
                     for tx in start_tx..=end_tx {
                         let tile_idx = ty * tiles_x + tx;
-                        unsafe { DIRTY_TILES.get_mut()[tile_idx].store(false, Ordering::Release) };
+                        self.dirty_tiles[tile_idx].store(false, Ordering::Release);
                     }
                 }
             }
@@ -315,8 +323,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                 if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
                     let idx = (y as usize) * SCREEN_WIDTH + (x as usize);
                     let raw_color = RawU16::from(color).into_inner();
-                    if self.0[idx] != raw_color {
-                        self.0[idx] = raw_color;
+                    if self.fb[idx] != raw_color {
+                        self.fb[idx] = raw_color;
                         changed = true;
                     }
 
@@ -365,8 +373,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                         if let Some(color) = colors.next() {
                             let idx = (p.y as usize * SCREEN_WIDTH) + (p.x as usize);
                             let raw_color = RawU16::from(color).into_inner();
-                            if self.0[idx] != raw_color {
-                                self.0[idx] = raw_color;
+                            if self.fb[idx] != raw_color {
+                                self.fb[idx] = raw_color;
                                 changed = true;
                             }
                         } else {
@@ -404,7 +412,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                 .take((self.size().width * self.size().height) as usize),
         )?;
 
-        for tile in unsafe { DIRTY_TILES.get_mut() }.iter() {
+        for tile in self.dirty_tiles.iter() {
             tile.store(true, Ordering::Release);
         }
 

kernel/src/main.rs

@@ -323,6 +323,11 @@ async fn kernel_task(
     spawner
         .spawn(watchdog_task(Watchdog::new(watchdog)))
         .unwrap();
+
+    // setup_psram(psram).await;
+    #[cfg(feature = "pimoroni2w")]
+    setup_qmi_psram().await;
+
     setup_mcu(mcu).await;
     setup_display(display, spawner).await;
     setup_sd(sd).await;
@@ -330,10 +335,6 @@ async fn kernel_task(
     let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
     // spawner.spawn(usb_handler(usb)).unwrap();
 
-    // setup_psram(psram).await;
-    #[cfg(feature = "pimoroni2w")]
-    setup_qmi_psram().await;
-
     loop {
         let ui_enabled = ENABLE_UI.load(Ordering::Relaxed);
         if ui_enabled {

kernel/src/ui.rs

@@ -1,10 +1,13 @@
 use crate::{
-    BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
-    peripherals::keyboard, storage::FileName,
+    BINARY_CH,
+    display::{FRAMEBUFFER, FRAMEBUFFER2, WRITE_FRAMEBUFFER2},
+    elf::load_binary,
+    peripherals::keyboard,
+    storage::FileName,
 };
 use abi_sys::keyboard::{KeyCode, KeyState};
 use alloc::{str::FromStr, string::String, vec::Vec};
-use core::sync::atomic::Ordering;
+use core::{ops::DerefMut, sync::atomic::Ordering};
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
 use embedded_graphics::{
     Drawable,
@@ -83,7 +86,15 @@ async fn draw_selection() {
     const NO_BINS: &str = "No Programs found on SD Card. Ensure programs end with '.bin', and are located in the root directory";
     let no_bins = String::from_str(NO_BINS).unwrap();
 
-    FB_PAUSED.store(true, Ordering::Release); // ensure all elements show up at once
+    let mut fb = if cfg!(feature = "pimoroni2w") {
+        if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
+            unsafe { FRAMEBUFFER2.deref_mut() }
+        } else {
+            unsafe { &mut FRAMEBUFFER }
+        }
+    } else {
+        unsafe { &mut FRAMEBUFFER }
+    };
 
     if file_names.is_empty() {
         TextBox::new(
@@ -94,7 +105,7 @@ async fn draw_selection() {
             ),
             text_style,
         )
-        .draw(unsafe { &mut *FRAMEBUFFER })
+        .draw(fb.deref_mut())
         .unwrap();
     } else {
         let mut views: alloc::vec::Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
@@ -119,16 +130,17 @@ async fn draw_selection() {
             .bounding_box();
         Rectangle::new(selected_bounds.top_left, selected_bounds.size)
             .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
-            .draw(unsafe { &mut *FRAMEBUFFER })
+            .draw(fb.deref_mut())
             .unwrap();
 
         guard.last_bounds = Some(layout.bounds());
 
-        layout.draw(unsafe { &mut *FRAMEBUFFER }).unwrap();
+        layout.draw(fb.deref_mut()).unwrap();
     }
 
     guard.changed = false;
-    FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
+
+    WRITE_FRAMEBUFFER2.fetch_not(Ordering::AcqRel);
 }
 
 #[derive(Clone)]