Merge usb-mass-storage branch

kernel/src/main.rs

@@ -6,6 +6,8 @@
 use crate::{
     display::DISPLAY_SIGNAL,
     peripherals::keyboard::{KeyCode, KeyState, read_keyboard_fifo},
+    storage::SdCard,
+    usb::usb_handler,
 };
 
 use {defmt_rtt as _, panic_probe as _};
@@ -13,72 +15,76 @@ use {defmt_rtt as _, panic_probe as _};
 use core::cell::RefCell;
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
-use embassy_rp::peripherals::I2C1;
+use embassy_rp::{
+    gpio::{Input, Level, Output, Pull},
+    peripherals::{I2C1, USB},
+    spi::Spi,
+    usb as embassy_rp_usb,
+};
 use embassy_rp::{i2c, i2c::I2c, spi};
 use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
 use embassy_sync::mutex::Mutex;
-use embassy_time::Timer;
+use embassy_time::{Delay, Timer};
 use embedded_graphics::primitives::Rectangle;
+use embedded_hal_bus::spi::ExclusiveDevice;
+use embedded_sdmmc::SdCard as SdmmcSdCard;
 use heapless::String;
 
 mod peripherals;
 use peripherals::conf_peripherals;
 mod display;
 use display::display_handler;
+mod scsi;
+mod storage;
+mod usb;
+mod utils;
 
 embassy_rp::bind_interrupts!(struct Irqs {
     I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+    USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
 });
 
-static STRING: Mutex<ThreadModeRawMutex, String<25>> = Mutex::new(String::new());
-static LAST_TEXT_RECT: Mutex<ThreadModeRawMutex, RefCell<Option<Rectangle>>> =
-    Mutex::new(RefCell::new(None));
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
 
-    STRING.lock().await.push_str("Press Del").unwrap();
-
-    // configure keyboard event handler
+    // MCU i2c bus for peripherals
     let mut config = i2c::Config::default();
     config.frequency = 400_000;
     let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
     conf_peripherals(i2c1).await;
 
+    // SPI1 bus display
     let mut config = spi::Config::default();
     config.frequency = 16_000_000;
     let spi1 = spi::Spi::new(
         p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, p.DMA_CH0, p.DMA_CH1, config,
     );
 
-    join(
-        async {
-            loop {
-                Timer::after_millis(20).await;
-                if let Some(key) = read_keyboard_fifo().await
-                    && key.state == KeyState::Pressed
-                {
-                    let mut string = STRING.lock().await;
-                    match key.key {
-                        KeyCode::Backspace => {
-                            string.pop().unwrap();
-                        }
-                        KeyCode::Del => {
-                            string.clear();
-                        }
-                        KeyCode::Char(c) => {
-                            string.push(c).unwrap();
-                        }
-                        _ => (),
-                    }
-                    DISPLAY_SIGNAL.signal(());
-                }
-            }
-        },
-        display_handler(spi1, p.PIN_13, p.PIN_14, p.PIN_15),
-    )
-    .await;
+    let usb = embassy_rp_usb::Driver::new(p.USB, Irqs);
+
+    let sdcard = {
+        let mut config = spi::Config::default();
+        config.frequency = 400_000;
+        let spi = Spi::new_blocking(
+            p.SPI0,
+            p.PIN_18, // clk
+            p.PIN_19, // mosi
+            p.PIN_16, // miso
+            config.clone(),
+        );
+        let cs = Output::new(p.PIN_17, Level::High);
+        let det = Input::new(p.PIN_22, Pull::None);
+
+        let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
+        let sdcard = SdmmcSdCard::new(device, Delay);
+
+        config.frequency = 32_000_000;
+        sdcard.spi(|dev| dev.bus_mut().set_config(&config));
+        SdCard::new(sdcard, det)
+    };
+
+    usb_handler(usb, sdcard).await;
 }
 
 use abi::Syscall;
@@ -87,7 +93,7 @@ use abi::Syscall;
 pub extern "C" fn syscall_dispatch(call: *const Syscall) -> usize {
     let call = unsafe { &*call };
     match call {
-        Syscall::DrawPixel { x, y, color } => {
+        Syscall::DrawPixels { x, y, color } => {
             draw_pixel(*x, *y, *color);
             0
         }