only enable scsi when sdcard is detected

kernel/src/main.rs

@@ -42,9 +42,6 @@ embassy_rp::bind_interrupts!(struct Irqs {
     USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
 });
 
-// Controls the usb running to prevents sdcard writes via scsi and by the kernel
-static USB_ENABLED: Signal<ThreadModeRawMutex, bool> = Signal::new();
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
@@ -90,7 +87,6 @@ async fn main(_spawner: Spawner) {
     };
 
     let usb = embassy_rp_usb::Driver::new(p.USB, Irqs);
-    USB_ENABLED.signal(true);
     let usb_fut = usb_handler(usb, sdcard);
 
     join(usb_fut, display_fut).await;

kernel/src/usb.rs

@@ -1,7 +1,17 @@
-use crate::{USB_ENABLED, scsi::MassStorageClass, storage::SdCard};
+use core::sync::atomic::Ordering;
-use embassy_futures::{join::join, select::select3};
+
+use crate::{scsi::MassStorageClass, storage::SdCard};
+use embassy_futures::{
+    join::join,
+    select::{select, select3},
+};
 use embassy_rp::{peripherals::USB, usb::Driver};
+use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, signal::Signal};
 use embassy_usb::{Builder, Config};
+use portable_atomic::AtomicBool;
+
+static RESTART_USB: Signal<ThreadModeRawMutex, ()> = Signal::new();
+static ENABLE_SCSI: AtomicBool = AtomicBool::new(false);
 
 pub async fn usb_handler(driver: Driver<'static, USB>, sdcard: SdCard) {
     let mut config = Config::new(0xc0de, 0xcafe);
@@ -24,23 +34,27 @@ pub async fn usb_handler(driver: Driver<'static, USB>, sdcard: SdCard) {
         &mut control_buf,
     );
 
+    if sdcard.is_attached() {
+        ENABLE_SCSI.store(true, Ordering::Relaxed);
+    }
     let mut scsi = MassStorageClass::new(&mut builder, sdcard);
     let mut usb = builder.build();
 
     loop {
-        if USB_ENABLED.wait().await {
+        select3(
-            select3(
+            async {
-                async {
+                loop {
-                    loop {
+                    RESTART_USB.wait().await;
-                        // stop usb task until usb is enabled again
+                    return;
-                        USB_ENABLED.wait().await;
+                }
-                        return; // breaks out of select
+            },
-                    }
+            usb.run(),
-                },
+            async {
-                usb.run(),
+                if ENABLE_SCSI.load(Ordering::Acquire) {
-                scsi.poll(),
+                    scsi.poll().await
-            )
+                }
-            .await;
+            },
-        }
+        )
+        .await;
     }
 }