trying proper scsi handling

kernel/src/main.rs

@@ -24,26 +24,22 @@ mod usb;
 mod utils;
 
 #[cfg(feature = "pimoroni2w")]
-use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi};
+use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram_qmi};
 
 use crate::{
     abi::{KEY_CACHE, MS_SINCE_LAUNCH},
-    display::{FRAMEBUFFER, display_handler, init_display},
-    heap::HEAP,
+    display::{display_handler, init_display},
+    elf::load_binary,
     peripherals::{
         conf_peripherals,
         keyboard::{KeyState, read_keyboard_fifo},
     },
     psram::init_psram,
-    scsi::MSC_SHUTDOWN,
     storage::{SDCARD, SdCard},
-    ui::{SELECTIONS, clear_selection, ui_handler},
+    ui::{clear_screen, ui_handler},
+    usb::usb_handler,
 };
-use abi_sys::EntryFn;
-use bumpalo::Bump;
-use core::sync::atomic::{AtomicBool, Ordering};
 use embassy_executor::{Executor, Spawner};
-use embassy_futures::{join::join, select::select};
 use embassy_rp::{
     Peri,
     gpio::{Input, Level, Output, Pull},
@@ -63,12 +59,8 @@ use embassy_sync::{
     blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, signal::Signal,
 };
 use embassy_time::{Delay, Duration, Instant, Ticker, Timer};
-use embedded_graphics::{
-    pixelcolor::Rgb565,
-    prelude::{DrawTarget, RgbColor},
-};
 use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::SdCard as SdmmcSdCard;
+use embedded_sdmmc::{SdCard as SdmmcSdCard, ShortFileName};
 use static_cell::StaticCell;
 use talc::*;
 use {defmt_rtt as _, panic_probe as _};
@@ -113,9 +105,6 @@ async fn watchdog_task(mut watchdog: Watchdog) {
     }
 }
 
-static ENABLE_UI: AtomicBool = AtomicBool::new(true);
-static UI_CHANGE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
@@ -173,39 +162,25 @@ async fn main(_spawner: Spawner) {
 }
 
 // One-slot channel to pass EntryFn from core1
-static BINARY_CH: Channel<CriticalSectionRawMutex, (EntryFn, Bump), 1> = Channel::new();
+static BINARY_CH: Channel<CriticalSectionRawMutex, ShortFileName, 1> = Channel::new();
 
 // runs dynamically loaded elf files
 #[embassy_executor::task]
 async fn userland_task() {
     let recv = BINARY_CH.receiver();
     loop {
-        let (entry, _bump) = recv.receive().await;
+        let name = recv.receive().await;
+        let (entry, _bump) = unsafe { load_binary(&name).await.expect("unable to load binary") };
 
-        // disable kernel ui
-        {
-            ENABLE_UI.store(false, Ordering::Release);
-            UI_CHANGE.signal(());
-
-            clear_selection().await;
-
-            MSC_SHUTDOWN.signal(());
-        }
+        clear_screen().await;
 
         unsafe { MS_SINCE_LAUNCH = Some(Instant::now()) };
         #[cfg(feature = "defmt")]
         defmt::info!("Executing Binary");
         entry();
 
-        // enable kernel ui
-        {
-            ENABLE_UI.store(true, Ordering::Release);
-            UI_CHANGE.signal(());
-            unsafe { FRAMEBUFFER.as_mut().unwrap().clear(Rgb565::BLACK).unwrap() };
-
-            let mut selections = SELECTIONS.lock().await;
-            selections.set_changed(true);
-        }
+        STOP_KEY_HANDLER.signal(());
+        clear_screen().await;
     }
 }
 
@@ -270,6 +245,7 @@ async fn setup_display(display: Display, spawner: Spawner) {
 
 // psram is kind of useless on the pico calc
 // ive opted to use the pimoroni with on onboard xip psram instead
+#[allow(unused)]
 async fn setup_psram(psram: Psram) {
     let psram = init_psram(
         psram.pio, psram.sclk, psram.mosi, psram.miso, psram.cs, psram.dma1, psram.dma2,
@@ -311,7 +287,7 @@ async fn setup_sd(sd: Sd) {
     let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
     let sdcard = SdmmcSdCard::new(device, Delay);
 
-    config.frequency = 32_000_000;
+    config.frequency = 64_000_000;
     sdcard.spi(|dev| dev.bus_mut().set_config(&config));
     SDCARD.get().lock().await.replace(SdCard::new(sdcard, det));
 }
@@ -322,7 +298,7 @@ async fn kernel_task(
     watchdog: Peri<'static, WATCHDOG>,
     display: Display,
     sd: Sd,
-    psram: Psram,
+    _psram: Psram,
     mcu: Mcu,
     usb: Peri<'static, USB>,
 ) {
@@ -343,39 +319,28 @@ async fn kernel_task(
     setup_display(display, spawner).await;
     setup_sd(sd).await;
 
-    let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
-    // spawner.spawn(usb_handler(usb)).unwrap();
+    let usb_driver = embassy_rp_usb::Driver::new(usb, Irqs);
+    spawner.spawn(usb_handler(usb_driver)).unwrap();
 
+    let mut ui_enabled = true;
     loop {
-        let ui_enabled = ENABLE_UI.load(Ordering::Relaxed);
         if ui_enabled {
-            select(join(ui_handler(), prog_search_handler()), UI_CHANGE.wait()).await;
+            ui_handler().await;
         } else {
-            select(key_handler(), UI_CHANGE.wait()).await;
+            key_handler().await;
         }
+        ui_enabled ^= true // flip bool
     }
 }
 
-async fn prog_search_handler() {
-    loop {
-        {
-            let mut guard = SDCARD.get().lock().await;
-            let sd = guard.as_mut().unwrap();
-
-            let files = sd.list_files_by_extension(".bin").unwrap();
-            let mut select = SELECTIONS.lock().await;
-
-            if *select.selections() != files {
-                select.update_selections(files);
-                select.reset();
-            }
-        }
-        Timer::after_secs(5).await;
-    }
-}
+static STOP_KEY_HANDLER: Signal<CriticalSectionRawMutex, ()> = Signal::new();
 
 async fn key_handler() {
     loop {
+        if STOP_KEY_HANDLER.try_take().is_some() {
+            break;
+        }
+
         if let Some(event) = read_keyboard_fifo().await {
             if let KeyState::Pressed = event.state {
                 unsafe {

kernel/src/scsi/error.rs

@@ -0,0 +1,100 @@
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Clone, Copy, Debug)]
+pub struct ScsiSense {
+    pub key: u8,
+    pub asc: u8,
+    pub ascq: u8,
+}
+
+impl ScsiSense {
+    pub const fn new(key: u8, asc: u8, ascq: u8) -> Self {
+        Self { key, asc, ascq }
+    }
+
+    // --- Sense Key constants ---
+    pub const KEY_NO_SENSE: u8 = 0x00;
+    pub const KEY_RECOVERED_ERROR: u8 = 0x01;
+    pub const KEY_NOT_READY: u8 = 0x02;
+    pub const KEY_MEDIUM_ERROR: u8 = 0x03;
+    pub const KEY_HARDWARE_ERROR: u8 = 0x04;
+    pub const KEY_ILLEGAL_REQUEST: u8 = 0x05;
+    pub const KEY_UNIT_ATTENTION: u8 = 0x06;
+    pub const KEY_DATA_PROTECT: u8 = 0x07;
+    pub const KEY_BLANK_CHECK: u8 = 0x08;
+    pub const KEY_VENDOR_SPECIFIC: u8 = 0x09;
+    pub const KEY_COPY_ABORTED: u8 = 0x0A;
+    pub const KEY_ABORTED_COMMAND: u8 = 0x0B;
+    pub const KEY_VOLUME_OVERFLOW: u8 = 0x0D;
+    pub const KEY_MISCOMPARE: u8 = 0x0E;
+
+    // --- Common ASC/ASCQ pairs (subset of most-used codes) ---
+    pub const ASC_NO_ADDITIONAL_SENSE: u8 = 0x00;
+
+    // Medium errors
+    pub const ASC_UNRECOVERED_READ_ERROR: u8 = 0x11;
+    pub const ASCQ_UNRECOVERED_READ_ERROR: u8 = 0x00;
+    pub const ASC_UNRECOVERED_WRITE_ERROR: u8 = 0x03;
+    pub const ASCQ_UNRECOVERED_WRITE_ERROR: u8 = 0x01;
+    pub const ASC_WRITE_FAULT: u8 = 0x03;
+    pub const ASC_ID_CRC_ERROR: u8 = 0x10;
+
+    // Illegal requests
+    pub const ASC_INVALID_COMMAND_OPERATION_CODE: u8 = 0x20;
+    pub const ASC_LBA_OUT_OF_RANGE: u8 = 0x21;
+    pub const ASC_INVALID_FIELD_IN_CDB: u8 = 0x24;
+
+    // Not ready
+    pub const ASC_LOGICAL_UNIT_NOT_READY: u8 = 0x04;
+    pub const ASC_MEDIUM_NOT_PRESENT: u8 = 0x3A;
+
+    // Unit attention
+    pub const ASC_POWER_ON_RESET_OCCURRED: u8 = 0x29;
+    pub const ASC_MEDIUM_CHANGED: u8 = 0x28;
+
+    // Data protect
+    pub const ASC_WRITE_PROTECTED: u8 = 0x27;
+
+    // Aborted command
+    pub const ASC_COMMAND_ABORTED: u8 = 0x47;
+
+    // --- Helpers for common conditions ---
+    pub const fn no_sense() -> Self {
+        Self::new(Self::KEY_NO_SENSE, Self::ASC_NO_ADDITIONAL_SENSE, 0x00)
+    }
+
+    pub const fn invalid_cdb() -> Self {
+        Self::new(
+            Self::KEY_ILLEGAL_REQUEST,
+            Self::ASC_INVALID_FIELD_IN_CDB,
+            0x00,
+        )
+    }
+
+    pub const fn lba_out_of_range() -> Self {
+        Self::new(Self::KEY_ILLEGAL_REQUEST, Self::ASC_LBA_OUT_OF_RANGE, 0x00)
+    }
+
+    pub const fn medium_not_present() -> Self {
+        Self::new(Self::KEY_NOT_READY, Self::ASC_MEDIUM_NOT_PRESENT, 0x00)
+    }
+
+    pub const fn unrecovered_read_error() -> Self {
+        Self::new(
+            Self::KEY_MEDIUM_ERROR,
+            Self::ASC_UNRECOVERED_READ_ERROR,
+            Self::ASCQ_UNRECOVERED_READ_ERROR,
+        )
+    }
+
+    pub const fn unrecovered_write_error() -> Self {
+        Self::new(
+            Self::KEY_MEDIUM_ERROR,
+            Self::ASC_UNRECOVERED_WRITE_ERROR,
+            Self::ASCQ_UNRECOVERED_WRITE_ERROR,
+        )
+    }
+
+    pub const fn write_protected() -> Self {
+        Self::new(Self::KEY_DATA_PROTECT, Self::ASC_WRITE_PROTECTED, 0x00)
+    }
+}

kernel/src/scsi/mod.rs

@@ -1,7 +1,6 @@
-use embassy_futures::select::select;
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy_sync::lazy_lock::LazyLock;
-use embassy_sync::signal::Signal;
+use crate::storage::{SDCARD, SdCard};
+use core::sync::atomic::{AtomicBool, Ordering};
+use embassy_time::Timer;
 use embassy_usb::Builder;
 use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
 use embedded_sdmmc::{Block, BlockIdx};
@@ -9,29 +8,32 @@ use heapless::Vec;
 
 mod scsi_types;
 use scsi_types::*;
-
-use crate::storage::{SDCARD, SdCard};
+#[allow(unused)]
+mod error;
+use error::ScsiSense;
 
 const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
 
-pub static MSC_SHUTDOWN: Signal<CriticalSectionRawMutex, ()> = Signal::new();
+// indicates that a scsi transaction is occurring and is
+// NOT safe to disable usb, or acquire sdcard
+pub static SCSI_BUSY: AtomicBool = AtomicBool::new(false);
 
-// number of blocks to read from sd at once
-// higher is better, but is larger. Size is BLOCKS * 512 bytes
-const BLOCKS: usize = 32;
-static mut BLOCK_BUF: LazyLock<[Block; BLOCKS]> =
-    LazyLock::new(|| core::array::from_fn(|_| Block::new()));
+// stop scsi and return sdcard when safe to do so
+pub static SCSI_HALT: AtomicBool = AtomicBool::new(false);
+
+pub static SCSI_EJECTED: AtomicBool = AtomicBool::new(false);
 
 pub struct MassStorageClass<'d, D: Driver<'d>> {
     temp_sd: Option<SdCard>, // temporary owns sdcard when scsi is running
-    ejected: bool,
-    pending_eject: bool,
     bulk_out: D::EndpointOut,
     bulk_in: D::EndpointIn,
+    last_sense: ScsiSense,
+    prevent_removal: bool,
+    pending_eject: bool,
 }
 
 impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
-    pub fn new(builder: &mut Builder<'d, D>, temp_sd: Option<SdCard>) -> Self {
+    pub fn new(builder: &mut Builder<'d, D>) -> Self {
         let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
         let mut interface = function.interface();
         let mut alt = interface.alt_setting(0x08, SUBCLASS_SCSI, 0x50, None);
@@ -40,32 +42,56 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         let bulk_in = alt.endpoint_bulk_in(None, BULK_ENDPOINT_PACKET_SIZE as u16);
 
         Self {
-            temp_sd,
-            pending_eject: false,
-            ejected: false,
+            temp_sd: None,
             bulk_out,
             bulk_in,
+            last_sense: ScsiSense::no_sense(),
+            prevent_removal: false,
+            pending_eject: false,
+        }
+    }
+
+    // Take sdcard to increase speed
+    pub async fn take_sdcard(&mut self) {
+        if self.temp_sd.is_none() {
+            let mut guard = SDCARD.get().lock().await;
+            if let Some(sd) = guard.take() {
+                self.temp_sd = Some(sd);
+            } else {
+                panic!("Tried to take SDCARD but it was already taken");
+            }
+        }
+    }
+
+    // return sdcard to global, so other tasks can use it
+    pub async fn return_sdcard(&mut self) {
+        if let Some(card) = self.temp_sd.take() {
+            let mut guard = SDCARD.get().lock().await;
+            *guard = Some(card);
         }
     }
 
     pub async fn poll(&mut self) {
         loop {
-            if !self.ejected {
-                select(self.handle_cbw(), MSC_SHUTDOWN.wait()).await;
-
-                if MSC_SHUTDOWN.signaled() {
-                    #[cfg(feature = "defmt")]
-                    defmt::info!("MSC shutting down");
-
-                    if self.temp_sd.is_some() {
-                        let mut guard = SDCARD.get().lock().await;
-                        guard.replace(self.temp_sd.take().unwrap()).unwrap();
-                    }
-
-                    self.ejected = true;
-
-                    return;
+            if !self.prevent_removal && (SCSI_HALT.load(Ordering::Acquire) || self.pending_eject) {
+                if self.temp_sd.is_some() {
+                    self.return_sdcard().await;
+                    SCSI_BUSY.store(false, Ordering::Release);
+                    self.pending_eject = false;
                 }
+            } else {
+                self.handle_cbw().await;
+            }
+
+            if SCSI_EJECTED.load(Ordering::Acquire) {
+                Timer::after_millis(100).await;
+                continue;
+            }
+
+            if SCSI_BUSY.load(Ordering::Relaxed) {
+                Timer::after_millis(1).await;
+            } else {
+                Timer::after_millis(100).await;
             }
         }
     }
@@ -75,31 +101,19 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
             if n == 31 {
                 if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
-                    // Take sdcard to increase speed
-                    if self.temp_sd.is_none() {
-                        let mut guard = SDCARD.get().lock().await;
-                        if let Some(sd) = guard.take() {
-                            self.temp_sd = Some(sd);
-                        } else {
-                            #[cfg(feature = "defmt")]
-                            defmt::warn!("Tried to take SDCARD but it was already taken");
-                            return;
-                        }
-                    }
-
                     let command = parse_cb(&cbw.CBWCB);
                     if self.handle_command(command).await.is_ok() {
                         self.send_csw_success(cbw.dCBWTag).await
                     } else {
                         self.send_csw_fail(cbw.dCBWTag).await
                     }
-
-                    if self.pending_eject {
-                        if let ScsiCommand::Write { lba: _, len: _ } = command {
-                            MSC_SHUTDOWN.signal(());
-                        }
-                    }
+                } else {
+                    self.last_sense = ScsiSense::invalid_cdb();
+                    self.send_csw_fail(0).await;
                 }
+            } else {
+                self.last_sense = ScsiSense::invalid_cdb();
+                self.send_csw_fail(0).await;
             }
         }
     }
@@ -107,6 +121,12 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
     async fn handle_command(&mut self, command: ScsiCommand) -> Result<(), ()> {
         let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
 
+        const BLOCK_SIZE: usize = 512;
+        // number of blocks to read from sd at once
+        // higher is better, but is larger. Size is BLOCKS * 512 bytes
+        const BLOCKS: usize = 10;
+        let mut block_buf: [Block; BLOCKS] = core::array::from_fn(|_| Block::new());
+
         match command {
             ScsiCommand::Unknown => Err(()),
             ScsiCommand::Inquiry {
@@ -186,16 +206,41 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
             ScsiCommand::TestUnitReady => {
-                if self.temp_sd.as_ref().unwrap().is_attached() {
-                    Ok(())
-                } else {
-                    Err(())
+                if !SCSI_EJECTED.load(Ordering::Acquire) && self.temp_sd.is_none() {
+                    SCSI_BUSY.store(true, Ordering::Release);
+                    self.take_sdcard().await;
+                }
+
+                match &self.temp_sd {
+                    Some(sd) => {
+                        if sd.is_attached() {
+                            Ok(())
+                        } else {
+                            self.last_sense = ScsiSense::medium_not_present();
+                            Err(())
+                        }
+                    }
+                    None => {
+                        self.last_sense = ScsiSense::medium_not_present();
+                        Err(())
+                    }
                 }
             }
-            ScsiCommand::RequestSense {
-                desc: _,
-                alloc_len: _,
-            } => Ok(()),
+            ScsiCommand::RequestSense { desc: _, alloc_len } => {
+                // Prepare the buffer
+                let mut buf = [0u8; 18];
+
+                // Fixed format sense data
+                buf[0] = 0x70; // Response code, current errors
+                buf[2] = self.last_sense.key; // Sense Key
+                buf[7] = 0x0A; // Additional sense length (n-8)
+                buf[12] = self.last_sense.asc; // Additional Sense Code
+                buf[13] = self.last_sense.ascq; // Additional Sense Code Qualifier
+
+                let len = core::cmp::min(buf.len(), alloc_len as usize);
+                self.last_sense = ScsiSense::no_sense();
+                self.bulk_in.write(&buf[..len]).await.map_err(|_| ())
+            }
             ScsiCommand::ModeSense6 {
                 dbd: _,
                 page_control: _,
@@ -234,125 +279,183 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
                 self.bulk_in.write(&response[..len]).await.map_err(|_| ())
             }
-            ScsiCommand::ReadCapacity10 => {
-                let block_size = SdCard::BLOCK_SIZE as u64;
-                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
+            ScsiCommand::ReadCapacity10 => match self.temp_sd.as_ref() {
+                Some(sd) => {
+                    let total_blocks = sd.size() / BLOCK_SIZE as u64;
 
-                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+                    let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
 
-                response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
-                response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
+                    response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
+                    response.extend_from_slice(&(BLOCK_SIZE as u32).to_be_bytes())?;
 
-                self.bulk_in.write(&response).await.map_err(|_| ())
-            }
-            ScsiCommand::ReadCapacity16 { alloc_len } => {
-                let block_size = SdCard::BLOCK_SIZE as u64;
-                let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size;
-
-                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
-
-                response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
-                response.extend_from_slice(&(block_size as u32).to_be_bytes())?; // 4 bytes block length
-                response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
-
-                let len = alloc_len.min(response.len() as u32) as usize;
-                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
-            }
-            ScsiCommand::Read { lba, len } => {
-                let sdcard = self.temp_sd.as_ref().unwrap();
-                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
-                let mut blocks = len;
-                let mut idx = lba;
-
-                while blocks > 0 {
-                    if blocks >= block_buf.len() as u64 {
-                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
-
-                        for block in &mut *block_buf {
-                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        blocks -= block_buf.len() as u64;
-                        idx += block_buf.len() as u64;
-                    } else {
-                        sdcard
-                            .read_blocks(&mut block_buf[..blocks as usize], BlockIdx(idx as u32))?;
-
-                        for block in &block_buf[..blocks as usize] {
-                            for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
-                                self.bulk_in.write(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        idx += blocks;
-                        blocks = 0;
-                    }
+                    self.bulk_in.write(&response).await.map_err(|_| ())
                 }
+                None => {
+                    self.last_sense = ScsiSense::medium_not_present();
+                    Err(())
+                }
+            },
+            ScsiCommand::ReadCapacity16 { alloc_len } => match self.temp_sd.as_ref() {
+                Some(sd) => {
+                    let total_blocks = sd.size() / BLOCK_SIZE as u64;
+
+                    let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+
+                    response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
+                    response.extend_from_slice(&(BLOCK_SIZE as u32).to_be_bytes())?; // 4 bytes block length
+                    response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
+
+                    let len = alloc_len.min(response.len() as u32) as usize;
+                    self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+                }
+                None => {
+                    self.last_sense = ScsiSense::medium_not_present();
+                    Err(())
+                }
+            },
+            ScsiCommand::Read { lba, len } => match self.temp_sd.as_ref() {
+                Some(sd) => {
+                    let mut blocks = len;
+                    let mut idx = lba;
+
+                    let mut error_occurred = false;
+
+                    while blocks > 0 {
+                        if blocks >= block_buf.len() as u64 {
+                            sd.read_blocks(&mut block_buf, BlockIdx(idx as u32))?;
+
+                            for block in &mut block_buf {
+                                for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into())
+                                {
+                                    if self.bulk_in.write(chunk).await.map_err(|_| ()).is_err() {
+                                        error_occurred = true
+                                    }
+                                }
+                            }
+
+                            blocks -= block_buf.len() as u64;
+                            idx += block_buf.len() as u64;
+                        } else {
+                            sd.read_blocks(
+                                &mut block_buf[..blocks as usize],
+                                BlockIdx(idx as u32),
+                            )?;
+
+                            for block in &block_buf[..blocks as usize] {
+                                for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into())
+                                {
+                                    if self.bulk_in.write(chunk).await.map_err(|_| ()).is_err() {
+                                        error_occurred = true
+                                    }
+                                }
+                            }
+
+                            idx += blocks;
+                            blocks = 0;
+                        }
+                    }
+
+                    if error_occurred {
+                        self.last_sense = ScsiSense::unrecovered_read_error();
+                        return Err(());
+                    }
+
+                    Ok(())
+                }
+                None => {
+                    self.last_sense = ScsiSense::medium_not_present();
+                    Err(())
+                }
+            },
+            ScsiCommand::Write { lba, len } => match self.temp_sd.as_ref() {
+                Some(sd) => {
+                    let mut blocks = len;
+                    let mut idx = lba;
+
+                    let mut error_occurred = false;
+
+                    while blocks > 0 {
+                        if blocks >= block_buf.len() as u64 {
+                            for block in block_buf.as_mut() {
+                                for chunk in
+                                    block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
+                                {
+                                    if self.bulk_out.read(chunk).await.map_err(|_| ()).is_err() {
+                                        error_occurred = true
+                                    }
+                                }
+                            }
+
+                            sd.read_blocks(&mut block_buf, BlockIdx(idx as u32))?;
+
+                            blocks -= block_buf.len() as u64;
+                            idx += block_buf.len() as u64;
+                        } else {
+                            for block in block_buf[..blocks as usize].as_mut() {
+                                for chunk in
+                                    block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
+                                {
+                                    if self.bulk_out.read(chunk).await.map_err(|_| ()).is_err() {
+                                        error_occurred = true
+                                    }
+                                }
+                            }
+
+                            sd.write_blocks(
+                                &mut block_buf[..blocks as usize],
+                                BlockIdx(idx as u32),
+                            )?;
+
+                            idx += blocks;
+                            blocks = 0;
+                        }
+                    }
+
+                    if error_occurred {
+                        self.last_sense = ScsiSense::unrecovered_write_error();
+                        return Err(());
+                    }
+
+                    Ok(())
+                }
+                None => {
+                    self.last_sense = ScsiSense::medium_not_present();
+                    Err(())
+                }
+            },
+            ScsiCommand::ReadFormatCapacities { alloc_len } => match self.temp_sd.as_ref() {
+                Some(sd) => {
+                    let block_size = SdCard::BLOCK_SIZE as u32;
+                    let num_blocks = (sd.size() / block_size as u64) as u32;
+
+                    let mut response = [0u8; 12];
+
+                    // Capacity List Length (8 bytes follows)
+                    response[3] = 8;
+
+                    // Descriptor
+                    response[4..8].copy_from_slice(&num_blocks.to_be_bytes());
+                    response[8] = 0x03; // formatted media
+                    response[9..12].copy_from_slice(&block_size.to_be_bytes()[1..4]); // only 3 bytes
+
+                    let response_len = alloc_len.min(response.len() as u16) as usize;
+                    self.bulk_in
+                        .write(&response[..response_len])
+                        .await
+                        .map_err(|_| ())
+                }
+                None => {
+                    self.last_sense = ScsiSense::medium_not_present();
+                    Err(())
+                }
+            },
+            ScsiCommand::PreventAllowMediumRemoval { prevent } => {
+                self.prevent_removal = prevent;
                 Ok(())
             }
-            ScsiCommand::Write { lba, len } => {
-                let sdcard = self.temp_sd.as_ref().unwrap();
-                let block_buf = unsafe { &mut *BLOCK_BUF.get_mut() };
-                let mut blocks = len;
-                let mut idx = lba;
-
-                while blocks > 0 {
-                    if blocks >= block_buf.len() as u64 {
-                        for block in block_buf.as_mut() {
-                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
-                            {
-                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
-
-                        blocks -= block_buf.len() as u64;
-                        idx += block_buf.len() as u64;
-                    } else {
-                        for block in block_buf[..blocks as usize].as_mut() {
-                            for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
-                            {
-                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
-                            }
-                        }
-
-                        sdcard.write_blocks(
-                            &mut block_buf[..blocks as usize],
-                            BlockIdx(idx as u32),
-                        )?;
-
-                        idx += blocks;
-                        blocks = 0;
-                    }
-                }
-                Ok(())
-            }
-            ScsiCommand::ReadFormatCapacities { alloc_len } => {
-                let block_size = SdCard::BLOCK_SIZE as u32;
-                let num_blocks = (self.temp_sd.as_ref().unwrap().size() / block_size as u64) as u32;
-
-                let mut response = [0u8; 12];
-
-                // Capacity List Length (8 bytes follows)
-                response[3] = 8;
-
-                // Descriptor
-                response[4..8].copy_from_slice(&num_blocks.to_be_bytes());
-                response[8] = 0x03; // formatted media
-                response[9..12].copy_from_slice(&block_size.to_be_bytes()[1..4]); // only 3 bytes
-
-                let response_len = alloc_len.min(response.len() as u16) as usize;
-                self.bulk_in
-                    .write(&response[..response_len])
-                    .await
-                    .map_err(|_| ())
-            }
-            ScsiCommand::PreventAllowMediumRemoval { prevent: _prevent } => Ok(()),
             ScsiCommand::StartStopUnit { start, load_eject } => {
                 if !start && load_eject {
+                    SCSI_EJECTED.store(true, Ordering::Release);
                     self.pending_eject = true;
                 }
                 Ok(())
@@ -366,7 +469,9 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
     pub async fn send_csw_fail(&mut self, tag: u32) {
         #[cfg(feature = "defmt")]
-        defmt::error!("Command Failed: {}", tag);
+        if tag != 0 {
+            defmt::error!("Command Failed: {}", tag);
+        }
         self.send_csw(tag, 0x01, 0).await; // 0x01 = Command Failed
     }
 

kernel/src/ui.rs

@@ -1,18 +1,26 @@
 use crate::{
-    BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
-    peripherals::keyboard, storage::FileName,
+    BINARY_CH,
+    display::FRAMEBUFFER,
+    framebuffer::FB_PAUSED,
+    peripherals::keyboard,
+    scsi::SCSI_BUSY,
+    storage::{FileName, SDCARD},
 };
 use abi_sys::keyboard::{KeyCode, KeyState};
 use alloc::{str::FromStr, string::String, vec::Vec};
 use core::sync::atomic::Ordering;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
+use embassy_time::Timer;
 use embedded_graphics::{
     Drawable,
-    mono_font::{MonoTextStyle, ascii::FONT_10X20},
+    mono_font::{
+        MonoTextStyle,
+        ascii::{FONT_4X6, FONT_10X20},
+    },
     pixelcolor::Rgb565,
     prelude::{Dimensions, Point, Primitive, RgbColor, Size},
     primitives::{PrimitiveStyle, Rectangle},
-    text::Text,
+    text::{Alignment, Text},
 };
 use embedded_layout::{
     align::{horizontal, vertical},
@@ -21,167 +29,240 @@ use embedded_layout::{
 };
 use embedded_text::TextBox;
 
-pub static SELECTIONS: Mutex<CriticalSectionRawMutex, SelectionList> =
-    Mutex::new(SelectionList::new());
-
 pub async fn ui_handler() {
-    loop {
-        if let Some(event) = keyboard::read_keyboard_fifo().await {
-            if let KeyState::Pressed = event.state {
-                match event.key {
-                    KeyCode::Up => {
-                        let mut selections = SELECTIONS.lock().await;
-                        selections.up();
-                    }
-                    KeyCode::Down => {
-                        let mut selections = SELECTIONS.lock().await;
-                        selections.down();
-                    }
-                    KeyCode::Enter | KeyCode::Right => {
-                        let selections = SELECTIONS.lock().await;
-                        let selection =
-                            selections.selections[selections.current_selection as usize].clone();
+    let mut ui = UiState { page: UiPage::Menu };
+    let mut menu = MenuPage {
+        last_bounds: None,
+        selection: 0,
+        changed: true,
+    };
+    let mut scsi = ScsiPage { last_bounds: None };
+    update_selections().await;
 
-                        let entry = unsafe {
-                            load_binary(&selection.short_name)
-                                .await
-                                .expect("unable to load binary")
-                        };
-                        BINARY_CH.send(entry).await;
-                    }
-                    _ => (),
-                }
+    loop {
+        // reset page, if usb was disabled internally
+        if ui.page == UiPage::Scsi && !SCSI_BUSY.load(Ordering::Acquire) {
+            scsi.clear().await;
+            ui.page = UiPage::Menu;
+        } else if ui.page == UiPage::Menu && SCSI_BUSY.load(Ordering::Acquire) {
+            menu.clear().await;
+            ui.page = UiPage::Scsi;
+        }
+
+        if input_handler(&mut ui, &mut menu, &mut scsi).await {
+            return;
+        }
+        match ui.page {
+            UiPage::Menu => menu.draw().await,
+            UiPage::Scsi => scsi.draw().await,
+        }
+        Timer::after_millis(5).await;
+    }
+}
+
+async fn input_handler(ui: &mut UiState, menu: &mut MenuPage, scsi: &mut ScsiPage) -> bool {
+    if let Some(event) = keyboard::read_keyboard_fifo().await {
+        if event.state == KeyState::Pressed {
+            match (&mut ui.page, event.key) {
+                (UiPage::Menu, _) => return menu.handle_input(event.key).await,
+                (UiPage::Scsi, _) => return scsi.handle_input(event.key).await,
             }
         }
-
-        let changed = SELECTIONS.lock().await.changed;
-        if changed {
-            clear_selection().await;
-            draw_selection().await;
-        }
     }
+    false
 }
 
-pub async fn clear_selection() {
-    let sel = SELECTIONS.lock().await;
-
-    if let Some(area) = sel.last_bounds {
-        Rectangle::new(area.top_left, area.size)
-            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
-            .unwrap();
-    }
+#[derive(PartialEq)]
+enum UiPage {
+    Menu,
+    Scsi,
 }
 
-async fn draw_selection() {
-    let mut guard = SELECTIONS.lock().await;
-    let file_names = &guard.selections.clone();
-
-    let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
-    let display_area = unsafe { FRAMEBUFFER.as_mut().unwrap().bounding_box() };
-
-    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
-
-    if file_names.is_empty() {
-        TextBox::new(
-            &no_bins,
-            Rectangle::new(
-                Point::new(25, 25),
-                Size::new(display_area.size.width - 50, display_area.size.width - 50),
-            ),
-            text_style,
-        )
-        .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
-        .unwrap();
-    } else {
-        let mut views: alloc::vec::Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
-
-        for i in file_names {
-            views.push(Text::new(&i.long_name, Point::zero(), text_style));
-        }
-
-        let views_group = Views::new(views.as_mut_slice());
-
-        let layout = LinearLayout::vertical(views_group)
-            .with_alignment(horizontal::Center)
-            .with_spacing(FixedMargin(5))
-            .arrange()
-            .align_to(&display_area, horizontal::Center, vertical::Center);
-
-        // draw selected box
-        let selected_bounds = layout
-            .inner()
-            .get(guard.current_selection as usize)
-            .expect("Selected binary missing")
-            .bounding_box();
-        Rectangle::new(selected_bounds.top_left, selected_bounds.size)
-            .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
-            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
-            .unwrap();
-
-        guard.last_bounds = Some(layout.bounds());
-
-        layout
-            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
-            .unwrap();
-    }
-
-    guard.changed = false;
-    FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
+struct UiState {
+    page: UiPage,
 }
 
-#[derive(Clone)]
-pub struct SelectionList {
-    // allows easy clearing of selection ui,
-    // based on previous bounds
+trait Page {
+    async fn draw(&mut self);
+    async fn handle_input(&mut self, key: KeyCode) -> bool;
+    async fn clear(&mut self);
+}
+
+struct ScsiPage {
     last_bounds: Option<Rectangle>,
-    current_selection: u16,
-    selections: Vec<FileName>,
+}
+
+impl Page for ScsiPage {
+    async fn draw(&mut self) {
+        let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        let fb = unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() };
+        let bounds = fb.bounding_box();
+
+        let text = Text::with_alignment(
+            "Usb Mass storage enabled",
+            bounds.center(),
+            text_style,
+            Alignment::Center,
+        );
+
+        self.last_bounds = Some(text.bounds());
+        text.draw(fb).unwrap();
+    }
+
+    async fn handle_input(&mut self, _key: KeyCode) -> bool {
+        false
+    }
+
+    async fn clear(&mut self) {
+        if let Some(rect) = self.last_bounds {
+            clear_rect(rect).await;
+        }
+        self.last_bounds = None;
+    }
+}
+
+static SELECTIONS: Mutex<CriticalSectionRawMutex, Vec<FileName>> = Mutex::new(Vec::new());
+static mut SELECTIONS_CHANGED: bool = true;
+
+async fn update_selections() {
+    while SCSI_BUSY.load(Ordering::Acquire) {
+        Timer::after_millis(100).await;
+    }
+    let mut guard = SDCARD.get().lock().await;
+    let sd = guard.as_mut().unwrap();
+
+    let files = sd.list_files_by_extension(".bin").unwrap();
+    let mut selections = SELECTIONS.lock().await;
+
+    if *selections != files {
+        *selections = files;
+        unsafe { SELECTIONS_CHANGED = true }
+    }
+}
+struct MenuPage {
+    last_bounds: Option<Rectangle>,
+    selection: usize,
     changed: bool,
 }
 
-impl SelectionList {
-    pub const fn new() -> Self {
-        Self {
-            last_bounds: None,
-            selections: Vec::new(),
-            current_selection: 0,
-            changed: false,
+impl Page for MenuPage {
+    async fn draw(&mut self) {
+        if self.changed {
+            self.clear().await;
         }
+
+        let guard = SELECTIONS.lock().await;
+        let file_names = &guard.clone();
+
+        let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        let display_area = unsafe { FRAMEBUFFER.as_mut().unwrap().bounding_box() };
+
+        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
+
+        if file_names.is_empty() {
+            TextBox::new(
+                &no_bins,
+                Rectangle::new(
+                    Point::new(25, 25),
+                    Size::new(display_area.size.width - 50, display_area.size.width - 50),
+                ),
+                text_style,
+            )
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
+            .unwrap();
+        } else {
+            let mut views: alloc::vec::Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
+
+            for i in file_names {
+                views.push(Text::new(&i.long_name, Point::zero(), text_style));
+            }
+
+            let views_group = Views::new(views.as_mut_slice());
+
+            let layout = LinearLayout::vertical(views_group)
+                .with_alignment(horizontal::Center)
+                .with_spacing(FixedMargin(5))
+                .arrange()
+                .align_to(&display_area, horizontal::Center, vertical::Center);
+
+            // draw selected box
+            let selected_bounds = layout
+                .inner()
+                .get(self.selection)
+                .expect("Selected binary missing")
+                .bounding_box();
+            Rectangle::new(selected_bounds.top_left, selected_bounds.size)
+                .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
+                .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
+                .unwrap();
+
+            self.last_bounds = Some(layout.bounds());
+
+            layout
+                .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
+                .unwrap();
+        }
+
+        self.changed = false;
+        FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
     }
 
-    pub fn set_changed(&mut self, changed: bool) {
-        self.changed = changed
-    }
+    async fn handle_input(&mut self, key: KeyCode) -> bool {
+        match key {
+            KeyCode::Enter | KeyCode::Right => {
+                let selections = SELECTIONS.lock().await;
+                let selection = selections[self.selection].clone();
 
-    pub fn update_selections(&mut self, selections: Vec<FileName>) {
-        self.selections = selections;
+                self.clear().await;
+                BINARY_CH.send(selection.short_name).await;
+                return true;
+            }
+            KeyCode::Up => {
+                if self.selection > 0 {
+                    self.selection -= 1;
+                } else {
+                    let len = SELECTIONS.lock().await.len();
+                    if len > 0 {
+                        self.selection = len - 1;
+                    }
+                }
+            }
+            KeyCode::Down => {
+                if self.selection + 1 < SELECTIONS.lock().await.len() {
+                    self.selection += 1;
+                } else {
+                    self.selection = 0; // wrap to top
+                }
+            }
+            _ => (),
+        }
         self.changed = true;
+        false
     }
 
-    pub fn selections(&self) -> &Vec<FileName> {
-        &self.selections
-    }
-
-    pub fn reset(&mut self) {
-        self.current_selection = 0;
-        self.changed = true;
-    }
-
-    fn up(&mut self) {
-        if self.current_selection > 0 {
-            self.current_selection -= 1;
-            self.changed = true;
-        }
-    }
-
-    fn down(&mut self) {
-        if self.current_selection + 1 < self.selections.len() as u16 {
-            self.current_selection += 1;
-            self.changed = true;
+    async fn clear(&mut self) {
+        if let Some(rect) = self.last_bounds {
+            clear_rect(rect).await;
         }
+        self.last_bounds = None;
     }
 }
+
+pub async fn clear_screen() {
+    clear_rect(Rectangle {
+        top_left: Point::zero(),
+        size: Size::new(320, 320),
+    })
+    .await
+}
+
+async fn clear_rect(rect: Rectangle) {
+    let fb = unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() };
+    Rectangle::new(rect.top_left, rect.size)
+        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+        .draw(fb)
+        .unwrap();
+}

kernel/src/usb.rs

@@ -1,10 +1,8 @@
-use crate::{scsi::MassStorageClass, storage::SdCard};
-use core::sync::atomic::{AtomicBool, Ordering};
-use embassy_futures::select::select;
+use crate::scsi::{MassStorageClass, SCSI_EJECTED};
+use core::sync::atomic::Ordering;
+use embassy_futures::join::join;
 use embassy_rp::{peripherals::USB, usb::Driver};
-use embassy_usb::{Builder, Config, UsbDevice};
-
-pub static USB_ACTIVE: AtomicBool = AtomicBool::new(false);
+use embassy_usb::{Builder, Config};
 
 #[embassy_executor::task]
 pub async fn usb_handler(driver: Driver<'static, USB>) {
@@ -28,18 +26,18 @@ pub async fn usb_handler(driver: Driver<'static, USB>) {
         &mut control_buf,
     );
 
-    let temp_sd: Option<SdCard> = None;
-    let mut scsi = MassStorageClass::new(&mut builder, temp_sd);
-    let usb = builder.build();
+    let mut scsi = MassStorageClass::new(&mut builder);
+    let mut usb = builder.build();
 
-    select(run(usb), scsi.poll()).await;
-}
-
-async fn run<'d>(mut usb: UsbDevice<'d, Driver<'d, USB>>) -> ! {
-    loop {
-        usb.wait_resume().await;
-        USB_ACTIVE.store(true, Ordering::Release);
-        usb.run_until_suspend().await;
-        USB_ACTIVE.store(false, Ordering::Release);
-    }
+    join(
+        async {
+            loop {
+                usb.wait_resume().await;
+                SCSI_EJECTED.store(false, Ordering::Release);
+                usb.run_until_suspend().await;
+            }
+        },
+        scsi.poll(),
+    )
+    .await;
 }