updates

kernel/src/main.rs

@@ -287,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));
 }

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,6 +1,6 @@
 use core::sync::atomic::{AtomicBool, Ordering};
 use embassy_futures::yield_now;
-use embassy_sync::lazy_lock::LazyLock;
+use embassy_time::Timer;
 use embassy_usb::Builder;
 use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
 use embedded_sdmmc::{Block, BlockIdx};
@@ -8,6 +8,9 @@ use heapless::Vec;
 
 mod scsi_types;
 use scsi_types::*;
+#[allow(unused)]
+mod error;
+use error::ScsiSense;
 
 use crate::storage::{SDCARD, SdCard};
 use crate::usb::stop_usb;
@@ -21,17 +24,13 @@ pub static SCSI_BUSY: AtomicBool = AtomicBool::new(false);
 // start no more transfers, usb is trying to stop
 pub static SCSI_HALT: 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 = 10;
-static mut BLOCK_BUF: LazyLock<[Block; BLOCKS]> =
-    LazyLock::new(|| core::array::from_fn(|_| Block::new()));
-
 pub struct MassStorageClass<'d, D: Driver<'d>> {
     temp_sd: Option<SdCard>, // temporary owns sdcard when scsi is running
     pub pending_eject: bool,
+    pub prevent_removal: bool,
     bulk_out: D::EndpointOut,
     bulk_in: D::EndpointIn,
+    last_sense: ScsiSense,
 }
 
 impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
@@ -46,8 +45,10 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
         Self {
             temp_sd: None,
             pending_eject: false,
+            prevent_removal: false,
             bulk_out,
             bulk_in,
+            last_sense: ScsiSense::no_sense(),
         }
     }
 
@@ -72,23 +73,20 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
     pub async fn poll(&mut self) {
         loop {
-            if SCSI_HALT.load(Ordering::Acquire) {
+            if !self.prevent_removal {
-                break;
+                if SCSI_HALT.load(Ordering::Acquire) || self.pending_eject {
+                    break;
+                }
             }
 
-            if self.pending_eject {
-                break;
-            }
             self.handle_cbw().await;
 
-            if self.pending_eject {
+            if !self.prevent_removal && self.pending_eject {
                 break;
             }
 
-            yield_now().await;
+            Timer::after_millis(1).await;
         }
-
-        stop_usb();
     }
 
     async fn handle_cbw(&mut self) {
@@ -106,7 +104,13 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                     }
 
                     SCSI_BUSY.store(false, Ordering::Release);
+                } 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;
             }
         }
     }
@@ -114,6 +118,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 {
@@ -199,10 +209,21 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                     Err(())
                 }
             }
-            ScsiCommand::RequestSense {
+            ScsiCommand::RequestSense { desc: _, alloc_len } => {
-                desc: _,
+                // Prepare the buffer
-                alloc_len: _,
+                let mut buf = [0u8; 18];
-            } => Ok(()),
+
+                // 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: _,
@@ -242,24 +263,22 @@ 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 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 as u32).to_be_bytes())?;
-                response.extend_from_slice(&(block_size 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 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(&(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;
@@ -267,17 +286,20 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
             }
             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;
 
+                let mut error_occurred = false;
+
                 while blocks > 0 {
                     if blocks >= block_buf.len() as u64 {
-                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
+                        sdcard.read_blocks(&mut block_buf, BlockIdx(idx as u32))?;
 
-                        for block in &mut *block_buf {
+                        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(|_| ())?;
+                                if self.bulk_in.write(chunk).await.map_err(|_| ()).is_err() {
+                                    error_occurred = true
+                                }
                             }
                         }
 
@@ -289,7 +311,9 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
 
                         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(|_| ())?;
+                                if self.bulk_in.write(chunk).await.map_err(|_| ()).is_err() {
+                                    error_occurred = true
+                                }
                             }
                         }
 
@@ -297,24 +321,33 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                         blocks = 0;
                     }
                 }
+
+                if error_occurred {
+                    self.last_sense = ScsiSense::unrecovered_read_error();
+                    return Err(());
+                }
+
                 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;
 
+                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())
                             {
-                                self.bulk_out.read(chunk).await.map_err(|_| ())?;
+                                if self.bulk_out.read(chunk).await.map_err(|_| ()).is_err() {
+                                    error_occurred = true
+                                }
                             }
                         }
 
-                        sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?;
+                        sdcard.read_blocks(&mut block_buf, BlockIdx(idx as u32))?;
 
                         blocks -= block_buf.len() as u64;
                         idx += block_buf.len() as u64;
@@ -322,7 +355,9 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                         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(|_| ())?;
+                                if self.bulk_out.read(chunk).await.map_err(|_| ()).is_err() {
+                                    error_occurred = true
+                                }
                             }
                         }
 
@@ -335,6 +370,12 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                         blocks = 0;
                     }
                 }
+
+                if error_occurred {
+                    self.last_sense = ScsiSense::unrecovered_write_error();
+                    return Err(());
+                }
+
                 Ok(())
             }
             ScsiCommand::ReadFormatCapacities { alloc_len } => {
@@ -357,7 +398,10 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
                     .await
                     .map_err(|_| ())
             }
-            ScsiCommand::PreventAllowMediumRemoval { prevent: _prevent } => Ok(()),
+            ScsiCommand::PreventAllowMediumRemoval { prevent } => {
+                self.prevent_removal = prevent;
+                Ok(())
+            }
             ScsiCommand::StartStopUnit { start, load_eject } => {
                 if !start && load_eject {
                     self.pending_eject = true;
@@ -373,7 +417,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

@@ -41,6 +41,12 @@ pub async fn ui_handler() {
     update_selections().await;
 
     loop {
+        // reset page, if usb was disabled internally
+        if ui.page == UiPage::Scsi && !USB_ACTIVE.load(Ordering::Acquire) {
+            menu.clear().await;
+            ui.page = UiPage::Menu;
+        }
+
         if input_handler(&mut ui, &mut menu, &mut scsi).await {
             overlay.clear().await;
             return;
@@ -110,9 +116,11 @@ impl Overlay {
         if let Some(rect) = self.last_bounds {
             clear_rect(rect).await
         }
+        self.last_bounds = None;
     }
 }
 
+#[derive(PartialEq)]
 enum UiPage {
     Menu,
     Scsi,
@@ -138,14 +146,15 @@ impl Page for ScsiPage {
         let fb = unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() };
         let bounds = fb.bounding_box();
 
-        Text::with_alignment(
+        let text = Text::with_alignment(
             "Usb Mass storage enabled",
             bounds.center(),
             text_style,
             Alignment::Center,
-        )
+        );
-        .draw(fb)
+
-        .unwrap();
+        self.last_bounds = Some(text.bounds());
+        text.draw(fb).unwrap();
     }
 
     async fn handle_input(&mut self, _key: KeyCode) -> bool {
@@ -156,6 +165,7 @@ impl Page for ScsiPage {
         if let Some(rect) = self.last_bounds {
             clear_rect(rect).await;
         }
+        self.last_bounds = None;
     }
 }
 
@@ -285,6 +295,7 @@ impl Page for MenuPage {
         if let Some(rect) = self.last_bounds {
             clear_rect(rect).await;
         }
+        self.last_bounds = None;
     }
 }
 

kernel/src/usb.rs

@@ -1,6 +1,6 @@
 use crate::scsi::{MassStorageClass, SCSI_BUSY, SCSI_HALT};
 use core::sync::atomic::{AtomicBool, Ordering};
-use embassy_futures::{join::join, select::select};
+use embassy_futures::select::select;
 use embassy_rp::{peripherals::USB, usb::Driver};
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel};
 use embassy_time::Timer;
@@ -55,17 +55,14 @@ pub async fn usb_handler(driver: Driver<'static, USB>) {
                     Timer::after_millis(100).await;
                 }
             },
-            async {
+            // runs the usb, until cancelled
-                // runs the usb, until cancelled
+            select(
-                join(
+                async {
-                    async {
+                    let _ = usb.remote_wakeup().await;
-                        let _ = usb.remote_wakeup().await;
+                    usb.run().await;
-                        usb.run().await
+                },
-                    },
+                scsi.poll(),
-                    scsi.poll(),
+            ),
-                )
-                .await;
-            },
         )
         .await;
         usb.disable().await;