eepy: initial (broken) impl of userspace USB

eepy-launcher/Cargo.toml

···
 eepy-sys = { path = "../eepy-sys" }
 eepy-gui = { path = "../eepy-gui" }
 embedded-graphics.workspace = true
+usb-device.workspace = true
+usbd-serial.workspace = true
 panic-halt = "1.0"

eepy-launcher/src/main.rs

···
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::prelude::*;
 use embedded_graphics::primitives::{Circle, Line, PrimitiveStyle, Rectangle};
+use usb_device::bus::UsbBusAllocator;
 use eepy_gui::draw_target::EpdDrawTarget;
 use eepy_gui::element::button::Button;
 use eepy_gui::element::Gui;
···
 use eepy_sys::image::RefreshBlockMode;
 use eepy_sys::input::{has_event, next_event, set_touch_enabled, Event, TouchEventType};
 use eepy_sys::header::{ProgramSlotHeader, Programs};
+use eepy_sys::misc::{get_serial, info};
+use eepy_sys::usb;
+use eepy_sys::usb::UsbBus;
+use usb_device::prelude::*;
+use usbd_serial::SerialPort;
 
 #[link_section = ".header"]
 #[used]
···
                 let response = button.tick(draw_target, ev);
 
                 if response.clicked {
+                    cleanup_usb();
                     exec(*s);
                 }
 
···
     }
 }
 
+static mut USB: Option<UsbBusAllocator<UsbBus>> = None;
+static mut USB_DEVICE: Option<UsbDevice<UsbBus>> = None;
+static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+
+#[allow(static_mut_refs)]
+pub extern "C" fn testing_usb_handler() {
+    let dev: &mut UsbDevice<UsbBus> = unsafe { USB_DEVICE.as_mut().unwrap() };
+    let serial: &mut SerialPort<UsbBus> = unsafe { USB_SERIAL.as_mut().unwrap() };
+
+    info("hello from USB handler");
+
+    if dev.poll(&mut [serial]) {
+        let mut buf = [0u8; 64];
+        match serial.read(&mut buf) {
+            Err(_) => {},
+            Ok(0) => {},
+            Ok(_) => {
+                let s = core::str::from_utf8(&buf);
+                if let Ok(s) = s {
+                    info(s);
+                }
+            }
+        }
+    }
+}
+
+fn cleanup_usb() {
+    #[allow(static_mut_refs)]
+    unsafe {
+        let _ = USB.take();
+        let _ = USB_DEVICE.take();
+        let _ = USB_SERIAL.take();
+    }
+}
 
 #[no_mangle]
 pub extern "C" fn entry() {
+    #[allow(static_mut_refs)]
+    unsafe {
+        let bus = UsbBusAllocator::new(UsbBus::init());
+        USB = Some(bus);
+        let bus_ref = USB.as_ref().unwrap();
+
+        let serial = SerialPort::new(bus_ref);
+        USB_SERIAL = Some(serial);
+
+        let usb_dev = UsbDeviceBuilder::new(
+            bus_ref,
+            UsbVidPid(0x2e8a, 0x000a),
+        )
+            .strings(&[StringDescriptors::default()
+                .manufacturer("arthomnix")
+                .product("Touchscreen E-Paper Input Module for Framework 16 [eepyOS Launcher]")
+                .serial_number(get_serial())
+            ])
+            .unwrap()
+            .device_class(usbd_serial::USB_CLASS_CDC)
+            .build();
+        USB_DEVICE = Some(usb_dev);
+    }
+
+    usb::set_handler(testing_usb_handler);
+
     let mut draw_target = EpdDrawTarget::new();
     set_touch_enabled(true);
     let mut gui = MainGui::new();

eepy-sys/Cargo.toml

···
 defmt = { workspace = true, optional = true }
 embedded-graphics = { workspace = true, optional = true }
 serde.workspace = true
-crc32fast.workspace = true
+crc32fast.workspace = true
+usb-device.workspace = true
+
+[features]
+defmt = ["dep:defmt", "usb-device/defmt"]

eepy-sys/src/lib.rs

···
             SafeOption::Some(v) => Some(v),
         }
     }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SafeResult<T, E> {
+    Ok(T),
+    Err(E),
+}
+
+impl<T, E> From<SafeResult<T, E>> for Result<T, E> {
+    fn from(value: SafeResult<T, E>) -> Self {
+        match value {
+            SafeResult::Ok(v) => Ok(v),
+            SafeResult::Err(e) => Err(e),
+        }
+    }
+}
+
+impl<T, E> From<Result<T, E>> for SafeResult<T, E> {
+    fn from(value: Result<T, E>) -> Self {
+        match value {
+            Ok(v) => SafeResult::Ok(v),
+            Err(e) => SafeResult::Err(e),
+        }
+    }
 }

eepy-sys/src/misc.rs

···
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum MiscSyscall {
     GetSerial = 0,
+    LogMessage = 1,
 }
 
 impl TryFrom<usize> for MiscSyscall {
···
     fn try_from(value: usize) -> Result<Self, Self::Error> {
         match value {
             x if x == MiscSyscall::GetSerial as usize => Ok(MiscSyscall::GetSerial),
+            x if x == MiscSyscall::LogMessage as usize => Ok(MiscSyscall::LogMessage),
+            _ => Err(()),
+        }
+    }
+}
+
+#[repr(usize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum LogLevel {
+    Trace = 0,
+    Debug = 1,
+    Info = 2,
+    Warn = 3,
+    Error = 4,
+}
+
+impl TryFrom<usize> for LogLevel {
+    type Error = ();
+
+    fn try_from(value: usize) -> Result<Self, ()> {
+        match value {
+            x if x == LogLevel::Trace as usize => Ok(LogLevel::Trace),
+            x if x == LogLevel::Info as usize => Ok(LogLevel::Info),
+            x if x == LogLevel::Debug as usize => Ok(LogLevel::Debug),
+            x if x == LogLevel::Warn as usize => Ok(LogLevel::Warn),
+            x if x == LogLevel::Error as usize => Ok(LogLevel::Error),
             _ => Err(()),
         }
     }
···
         );
         core::str::from_utf8_unchecked(&*ptr)
     }
+}
+
+pub fn log(message: &str, level: LogLevel) {
+    let len = message.len();
+    let ptr = message.as_ptr();
+
+    unsafe {
+        syscall!(
+            SyscallNumber::Misc,
+            in MiscSyscall::LogMessage,
+            in level,
+            in len,
+            in ptr,
+        );
+    }
+}
+
+pub fn trace(message: &str) {
+    log(message, LogLevel::Trace);
+}
+
+pub fn debug(message: &str) {
+    log(message, LogLevel::Debug);
+}
+
+pub fn info(message: &str) {
+    log(message, LogLevel::Info);
+}
+
+pub fn warn(message: &str) {
+    log(message, LogLevel::Warn);
+}
+
+pub fn error(message: &str) {
+    log(message, LogLevel::Error);
 }

eepy-sys/src/usb.rs

···
+use core::mem::MaybeUninit;
+use usb_device::bus::PollResult;
+use usb_device::class_prelude::{EndpointAddress, EndpointType};
+use usb_device::{UsbDirection, UsbError};
+use usb_device::endpoint::{IsochronousSynchronizationType, IsochronousUsageType};
+use crate::{syscall, SafeOption, SafeResult};
+use crate::syscall::SyscallNumber;
+
 #[repr(usize)]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum UsbSyscall {
     UsbRet = 0,
+    SetHandler = 1,
+    ClearHandler = 2,
+    Init = 3,
+    Uninit = 4,
+    AllocEp = 5,
+    Enable = 6,
+    Reset = 7,
+    SetDeviceAddr = 8,
+    Write = 9,
+    Read = 10,
+    SetStalled = 11,
+    IsStalled = 12,
+    Poll = 13,
 }
 
 impl TryFrom<usize> for UsbSyscall {
···
     fn try_from(value: usize) -> Result<Self, Self::Error> {
         match value {
             x if x == UsbSyscall::UsbRet as usize => Ok(UsbSyscall::UsbRet),
+            x if x == UsbSyscall::SetHandler as usize => Ok(UsbSyscall::SetHandler),
+            x if x == UsbSyscall::ClearHandler as usize => Ok(UsbSyscall::ClearHandler),
+            x if x == UsbSyscall::Init as usize => Ok(UsbSyscall::Init),
+            x if x == UsbSyscall::Uninit as usize => Ok(UsbSyscall::Uninit),
+            x if x == UsbSyscall::AllocEp as usize => Ok(UsbSyscall::AllocEp),
+            x if x == UsbSyscall::Enable as usize => Ok(UsbSyscall::Enable),
+            x if x == UsbSyscall::Reset as usize => Ok(UsbSyscall::Reset),
+            x if x == UsbSyscall::SetDeviceAddr as usize => Ok(UsbSyscall::SetDeviceAddr),
+            x if x == UsbSyscall::Write as usize => Ok(UsbSyscall::Write),
+            x if x == UsbSyscall::Read as usize => Ok(UsbSyscall::Read),
+            x if x == UsbSyscall::SetStalled as usize => Ok(UsbSyscall::SetStalled),
+            x if x == UsbSyscall::IsStalled as usize => Ok(UsbSyscall::IsStalled),
+            x if x == UsbSyscall::Poll as usize => Ok(UsbSyscall::Poll),
+
             _ => Err(()),
+        }
+    }
+}
+
+pub fn set_handler(f: extern "C" fn()) {
+    unsafe {
+        syscall!(
+            SyscallNumber::Usb,
+            in UsbSyscall::SetHandler,
+            in f,
+        );
+    }
+}
+
+pub fn clear_handler() {
+    unsafe {
+        syscall!(
+            SyscallNumber::Usb,
+            in UsbSyscall::ClearHandler,
+        )
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SafePollResult {
+    None,
+    Reset,
+    Data {
+        ep_out: u16,
+        ep_in_complete: u16,
+        ep_setup: u16,
+    },
+    Suspend,
+    Resume,
+}
+
+impl From<SafePollResult> for PollResult {
+    fn from(value: SafePollResult) -> Self {
+        match value {
+            SafePollResult::None => PollResult::None,
+            SafePollResult::Reset => PollResult::Reset,
+            SafePollResult::Data { ep_out, ep_in_complete, ep_setup } => PollResult::Data { ep_out, ep_in_complete, ep_setup },
+            SafePollResult::Suspend => PollResult::Suspend,
+            SafePollResult::Resume => PollResult::Resume
+        }
+    }
+}
+
+impl From<PollResult> for SafePollResult {
+    fn from(value: PollResult) -> Self {
+        match value {
+            PollResult::None => SafePollResult::None,
+            PollResult::Reset => SafePollResult::Reset,
+            PollResult::Data { ep_out, ep_in_complete, ep_setup } => SafePollResult::Data { ep_out, ep_in_complete, ep_setup },
+            PollResult::Suspend => SafePollResult::Suspend,
+            PollResult::Resume => SafePollResult::Resume,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SafeUsbError {
+    WouldBlock,
+    ParseError,
+    BufferOverflow,
+    EndpointOverflow,
+    EndpointMemoryOverflow,
+    InvalidEndpoint,
+    Unsupported,
+    InvalidState,
+}
+
+impl From<SafeUsbError> for UsbError {
+    fn from(value: SafeUsbError) -> Self {
+        match value {
+            SafeUsbError::WouldBlock => UsbError::WouldBlock,
+            SafeUsbError::ParseError => UsbError::ParseError,
+            SafeUsbError::BufferOverflow => UsbError::BufferOverflow,
+            SafeUsbError::EndpointOverflow => UsbError::EndpointOverflow,
+            SafeUsbError::EndpointMemoryOverflow => UsbError::EndpointMemoryOverflow,
+            SafeUsbError::InvalidEndpoint => UsbError::InvalidEndpoint,
+            SafeUsbError::Unsupported => UsbError::Unsupported,
+            SafeUsbError::InvalidState => UsbError::InvalidState,
+        }
+    }
+}
+
+impl From<UsbError> for SafeUsbError {
+    fn from(value: UsbError) -> Self {
+        match value {
+            UsbError::WouldBlock => SafeUsbError::WouldBlock,
+            UsbError::ParseError => SafeUsbError::ParseError,
+            UsbError::BufferOverflow => SafeUsbError::BufferOverflow,
+            UsbError::EndpointOverflow => SafeUsbError::EndpointOverflow,
+            UsbError::EndpointMemoryOverflow => SafeUsbError::EndpointMemoryOverflow,
+            UsbError::InvalidEndpoint => SafeUsbError::InvalidEndpoint,
+            UsbError::Unsupported => SafeUsbError::Unsupported,
+            UsbError::InvalidState => SafeUsbError::InvalidState,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SafeIsochronousSynchronizationType {
+    NoSynchronization,
+    Asynchronous,
+    Adaptive,
+    Synchronous,
+}
+
+impl From<IsochronousSynchronizationType> for SafeIsochronousSynchronizationType {
+    fn from(value: IsochronousSynchronizationType) -> Self {
+        match value {
+            IsochronousSynchronizationType::NoSynchronization => SafeIsochronousSynchronizationType::NoSynchronization,
+            IsochronousSynchronizationType::Asynchronous => SafeIsochronousSynchronizationType::Asynchronous,
+            IsochronousSynchronizationType::Adaptive => SafeIsochronousSynchronizationType::Adaptive,
+            IsochronousSynchronizationType::Synchronous => SafeIsochronousSynchronizationType::Synchronous,
+        }
+    }
+}
+
+impl From<SafeIsochronousSynchronizationType> for IsochronousSynchronizationType {
+    fn from(value: SafeIsochronousSynchronizationType) -> Self {
+        match value {
+            SafeIsochronousSynchronizationType::NoSynchronization => IsochronousSynchronizationType::NoSynchronization,
+            SafeIsochronousSynchronizationType::Asynchronous => IsochronousSynchronizationType::Asynchronous,
+            SafeIsochronousSynchronizationType::Adaptive => IsochronousSynchronizationType::Adaptive,
+            SafeIsochronousSynchronizationType::Synchronous => IsochronousSynchronizationType::Synchronous,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SafeIsochronousUsageType {
+    Data,
+    Feedback,
+    ImplicitFeedbackData,
+}
+
+impl From<IsochronousUsageType> for SafeIsochronousUsageType {
+    fn from(value: IsochronousUsageType) -> Self {
+        match value {
+            IsochronousUsageType::Data => SafeIsochronousUsageType::Data,
+            IsochronousUsageType::Feedback => SafeIsochronousUsageType::Feedback,
+            IsochronousUsageType::ImplicitFeedbackData => SafeIsochronousUsageType::ImplicitFeedbackData,
+        }
+    }
+}
+
+impl From<SafeIsochronousUsageType> for IsochronousUsageType {
+    fn from(value: SafeIsochronousUsageType) -> Self {
+        match value {
+            SafeIsochronousUsageType::Data => IsochronousUsageType::Data,
+            SafeIsochronousUsageType::Feedback => IsochronousUsageType::Feedback,
+            SafeIsochronousUsageType::ImplicitFeedbackData => IsochronousUsageType::ImplicitFeedbackData,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SafeEndpointType {
+    Control,
+    Isochronous {
+        synchronization: SafeIsochronousSynchronizationType,
+        usage: SafeIsochronousUsageType,
+    },
+    Bulk,
+    Interrupt,
+}
+
+impl From<EndpointType> for SafeEndpointType {
+    fn from(value: EndpointType) -> Self {
+        match value {
+            EndpointType::Control => SafeEndpointType::Control,
+            EndpointType::Isochronous { synchronization, usage } => {
+                SafeEndpointType::Isochronous { synchronization: synchronization.into(), usage: usage.into() }
+            },
+            EndpointType::Bulk => SafeEndpointType::Bulk,
+            EndpointType::Interrupt => SafeEndpointType::Interrupt,
+        }
+    }
+}
+
+impl From<SafeEndpointType> for EndpointType {
+    fn from(value: SafeEndpointType) -> Self {
+        match value {
+            SafeEndpointType::Control => EndpointType::Control,
+            SafeEndpointType::Isochronous { synchronization, usage } => {
+                EndpointType::Isochronous { synchronization: synchronization.into(), usage: usage.into() }
+            },
+            SafeEndpointType::Bulk => EndpointType::Bulk,
+            SafeEndpointType::Interrupt => EndpointType::Interrupt,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct UsbEpAllocArgs {
+    pub ep_dir: UsbDirection,
+    pub ep_addr: SafeOption<u8>,
+    pub ep_type: SafeEndpointType,
+    pub max_packet_size: u16,
+    pub interval: u8,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct UsbWriteArgs {
+    pub ep_addr: u8,
+    pub len: usize,
+    pub buf: *const u8,
+    pub ptr: *mut SafeResult<usize, SafeUsbError>,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct UsbReadArgs {
+    pub ep_addr: u8,
+    pub len: usize,
+    pub buf: *mut u8,
+    pub ptr: *mut SafeResult<usize, SafeUsbError>,
+}
+
+pub struct UsbBus {
+    _dummy: (),
+}
+
+impl UsbBus {
+    pub fn init() -> Self {
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Init,
+            );
+        }
+
+        Self { _dummy: () }
+    }
+}
+
+impl Drop for UsbBus {
+    fn drop(&mut self) {
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Uninit,
+            )
+        }
+    }
+}
+
+impl usb_device::bus::UsbBus for UsbBus {
+    fn alloc_ep(
+        &mut self,
+        ep_dir: UsbDirection,
+        ep_addr: Option<EndpointAddress>,
+        ep_type: EndpointType,
+        max_packet_size: u16,
+        interval: u8
+    ) -> usb_device::Result<EndpointAddress> {
+        let mut res: MaybeUninit<SafeResult<u8, SafeUsbError>> = MaybeUninit::uninit();
+        let res_ptr = res.as_mut_ptr();
+
+        let alloc_info = UsbEpAllocArgs {
+            ep_dir,
+            ep_addr: ep_addr.map(|v| v.into()).into(),
+            ep_type: ep_type.into(),
+            max_packet_size,
+            interval
+        };
+
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::AllocEp,
+                in &raw const alloc_info,
+                in res_ptr,
+            );
+
+            let res: Result<u8, SafeUsbError> = res.assume_init().into();
+            res.map(|v| v.into()).map_err(|e| e.into())
+        }
+    }
+
+    fn enable(&mut self) {
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Enable,
+            );
+        }
+    }
+
+    fn reset(&self) {
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Reset,
+            );
+        }
+    }
+
+    fn set_device_address(&self, addr: u8) {
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::SetDeviceAddr,
+                in addr,
+            );
+        }
+    }
+
+    fn write(&self, ep_addr: EndpointAddress, buf: &[u8]) -> usb_device::Result<usize> {
+        let ep_addr: u8 = ep_addr.into();
+        let mut res: MaybeUninit<SafeResult<usize, SafeUsbError>> = MaybeUninit::uninit();
+        let ptr = res.as_mut_ptr();
+        let len = buf.len();
+        let buf = buf.as_ptr();
+
+        let args = UsbWriteArgs {
+            ep_addr,
+            len,
+            buf,
+            ptr,
+        };
+
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Write,
+                in &raw const args,
+            );
+
+            let stdres: Result<usize, SafeUsbError> = res.assume_init().into();
+            stdres.map_err(|e| e.into())
+        }
+    }
+
+    fn read(&self, ep_addr: EndpointAddress, buf: &mut [u8]) -> usb_device::Result<usize> {
+        let ep_addr: u8 = ep_addr.into();
+        let mut res: MaybeUninit<SafeResult<usize, SafeUsbError>> = MaybeUninit::uninit();
+        let ptr = res.as_mut_ptr();
+        let len = buf.len();
+        let buf = buf.as_mut_ptr();
+
+        let args = UsbReadArgs {
+            ep_addr,
+            len,
+            buf,
+            ptr,
+        };
+
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Read,
+                in &raw const args,
+            );
+
+            let stdres: Result<usize, SafeUsbError> = res.assume_init().into();
+            stdres.map_err(|e| e.into())
+        }
+    }
+
+    fn set_stalled(&self, ep_addr: EndpointAddress, stalled: bool) {
+        let ep_addr: u8 = ep_addr.into();
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::SetStalled,
+                in ep_addr,
+                in stalled,
+            )
+        }
+    }
+
+    fn is_stalled(&self, ep_addr: EndpointAddress) -> bool {
+        let ep_addr: u8 = ep_addr.into();
+
+        let mut stalled: usize;
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                out stalled in UsbSyscall::IsStalled,
+                in ep_addr,
+            );
+        }
+
+        stalled != 0
+    }
+
+    fn suspend(&self) {
+        // not implemented in rp2040 usb-device implementation
+    }
+
+    fn resume(&self) {
+        // not implemented in rp2040 usb-device implementation
+    }
+
+    fn poll(&self) -> PollResult {
+        let mut spr: MaybeUninit<SafePollResult> = MaybeUninit::uninit();
+        let ptr = spr.as_mut_ptr();
+        unsafe {
+            syscall!(
+                SyscallNumber::Usb,
+                in UsbSyscall::Poll,
+                in ptr,
+            );
+
+            spr.assume_init().into()
         }
     }
 }

eepy/Cargo.toml

···
 [dependencies]
 fw16-epd-bsp = { path = "../fw16-epd-bsp" }
 eepy-sys = { path = "../eepy-sys", features = ["defmt"] }
-eepy-gui = { path = "../eepy-gui", features = ["defmt-derive"] }
 eepy-serial = { path = "../eepy-serial" }
 tp370pgh01 = { path = "../tp370pgh01", features = ["rp2040", "defmt"] }
 cortex-m.workspace = true
···
 panic-probe.workspace = true
 critical-section.workspace = true
 portable-atomic.workspace = true
-mcp9808.workspace = true
 usb-device.workspace = true
-usbd-serial.workspace = true
-crc32fast.workspace = true
-embedded-graphics = { workspace = true, features = ["defmt"] }
-heapless.workspace = true
-once_cell.workspace = true
+once_cell.workspace = true
+mcp9808.workspace = true

eepy/src/exception.rs

···
 use defmt::Formatter;
 
+#[repr(C)]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub(crate) struct StackFrame {
     pub r0: usize,

eepy/src/main.rs

···
 #![no_main]
 #![no_std]
 
-mod serial;
+//mod serial;
 mod ringbuffer;
 mod syscall;
 mod launcher;
···
 use once_cell::sync::OnceCell;
 use portable_atomic::{AtomicBool, AtomicU8};
 use portable_atomic::Ordering;
-use usb_device::bus::UsbBusAllocator;
-use usb_device::prelude::*;
-use usbd_serial::SerialPort;
 use eepy_sys::exec::exec;
 use fw16_epd_bsp::{entry, hal, pac, EpdBusy, EpdCs, EpdDc, EpdPowerSwitch, EpdReset, EpdSck, EpdSdaWrite, EpdTouchInt, EpdTouchReset, I2CScl, I2CSda, LaptopSleep, Pins};
 use fw16_epd_bsp::hal::{Sio, Timer, I2C};
···
 use fw16_epd_bsp::pac::I2C0;
 use fw16_epd_bsp::pac::interrupt;
 use eepy_sys::input::{Event, TouchEvent, TouchEventType};
-use eepy_sys::misc::get_serial;
 use tp370pgh01::rp2040::{Rp2040PervasiveSpiDelays, IoPin};
 use tp370pgh01::{Tp370pgh01, IMAGE_BYTES};
 use crate::ringbuffer::RingBuffer;
···
 static REFRESHING: AtomicBool = AtomicBool::new(false);
 static EPD_NEEDS_HARD_RESET: AtomicBool = AtomicBool::new(true);
 static TEMP: AtomicU8 = AtomicU8::new(20);
-
-static mut GLOBAL_USB_DEVICE: Option<UsbDevice<hal::usb::UsbBus>> = None;
-static mut GLOBAL_USB_BUS: Option<UsbBusAllocator<hal::usb::UsbBus>> = None;
-static mut GLOBAL_USB_SERIAL: Option<SerialPort<hal::usb::UsbBus>> = None;
-
 static SERIAL_NUMBER: OnceCell<[u8; 16]> = OnceCell::new();
 
 static EVENT_QUEUE: Mutex<RefCell<RingBuffer<Event>>> = Mutex::new(RefCell::new(RingBuffer::new()));
···
     }
     pac::NVIC::pend(interrupt::TIMER_IRQ_0);
 
+    usb::init_usb(pac.USBCTRL_REGS, pac.USBCTRL_DPRAM, clocks.usb_clock);
+
+    /*
     let usb_bus = UsbBusAllocator::new(hal::usb::UsbBus::new(
         pac.USBCTRL_REGS,
         pac.USBCTRL_DPRAM,
···
         // FIXME testing
         core.NVIC.set_priority(interrupt::SW5_IRQ, 0b11000000);
         pac::NVIC::unmask(interrupt::SW5_IRQ);
+    }
+     */
+
+    unsafe {
+        core.NVIC.set_priority(interrupt::SW5_IRQ, 0b11000000);
     }
 
     let mut mc = Multicore::new(&mut pac.PSM, &mut pac.PPB, &mut sio.fifo);
···
             TEMP.store(clamped, Ordering::Relaxed);
 
             alarm.clear_interrupt();
-            alarm.schedule(1.secs()).unwrap();
+            alarm.schedule(1.minutes()).unwrap();
         } else {
             // I2C bus was in use, so try again in a short time
             alarm.clear_interrupt();
···
     }
 
     critical_section::with(|cs| GLOBAL_I2C.borrow(cs).replace(i2c));
-
-    // FIXME testing
-    pac::NVIC::pend(interrupt::SW5_IRQ);
 }
 
 #[interrupt]

eepy/src/serial.rs

···
 use eepy_serial::{Response, SerialCommand};
 use eepy_sys::image::{refresh, write_image, RefreshBlockMode};
 use tp370pgh01::IMAGE_BYTES;
-use crate::{GLOBAL_USB_DEVICE, GLOBAL_USB_SERIAL};
-
 #[derive(Copy, Clone, Debug, defmt::Format)]
 enum SerialState {
     ReadyForCommand,
···
     debug!("End write slot {} page {}", slot, page);
 }
 
+/*
 #[interrupt]
 fn USBCTRL_IRQ() {
     static mut STATE: SerialState = SerialState::ReadyForCommand;
···
             }
         }
     }
-}
+}
+ */

eepy/src/syscall.rs

···
 use core::arch::{asm, global_asm};
-use defmt::{debug, trace, Formatter};
+use defmt::trace;
 use eepy_sys::exec::exec;
 use eepy_sys::header::slot;
 use eepy_sys::syscall::SyscallNumber;
···
 }
 
 fn handle_exec(stack_values: &mut StackFrame, using_psp: bool) {
+    // cleanup previous program's USB
+    crate::usb::handle_uninit();
+    crate::usb::handle_clear_handler();
+
     // disable privileged mode
     unsafe {
         asm!(
···
 }
 
 mod misc {
-    use eepy_sys::misc::MiscSyscall;
+    use defmt::{debug, error, info, trace, warn};
+    use eepy_sys::header::{SLOT_SIZE, XIP_BASE};
+    use eepy_sys::misc::{LogLevel, MiscSyscall};
     use crate::SERIAL_NUMBER;
     use super::StackFrame;
 
     pub(super) fn handle_misc(stack_values: &mut StackFrame) {
         match MiscSyscall::try_from(stack_values.r0) {
             Ok(MiscSyscall::GetSerial) => handle_get_serial(stack_values),
-            _ => panic!("illegal syscall"),
+            Ok(MiscSyscall::LogMessage) => handle_log_message(stack_values),
+            Err(_) => panic!("illegal syscall"),
         }
     }
 
     fn handle_get_serial(stack_values: &mut StackFrame) {
         stack_values.r0 = (&raw const *SERIAL_NUMBER.get().unwrap()) as usize;
     }
+
+    fn handle_log_message(stack_values: &mut StackFrame) {
+        let log_level: LogLevel = stack_values.r1.try_into().expect("invalid log level");
+        let len = stack_values.r2;
+        let ptr = stack_values.r3 as *const u8;
+        let s = unsafe { core::str::from_utf8_unchecked(core::slice::from_raw_parts(ptr, len)) };
+        let slot_n = (stack_values.pc as usize - XIP_BASE as usize) / SLOT_SIZE;
+
+        match log_level {
+            LogLevel::Trace => trace!("[PROGRAM:{}] {}", slot_n, s),
+            LogLevel::Debug => debug!("[PROGRAM:{}] {}", slot_n, s),
+            LogLevel::Info => info!("[PROGRAM:{}] {}", slot_n, s),
+            LogLevel::Warn => warn!("[PROGRAM:{}] {}", slot_n, s),
+            LogLevel::Error => error!("[PROGRAM:{}] {}", slot_n, s),
+        }
+    }
 }
 
 mod image {
···
         match ImageSyscall::try_from(stack_values.r0) {
             Ok(ImageSyscall::WriteImage) => handle_write_image(stack_values),
             Ok(ImageSyscall::Refresh) => handle_refresh(stack_values),
-            _ => panic!("illegal syscall"),
+            Err(_) => panic!("illegal syscall"),
         }
     }
 
···
             Ok(InputSyscall::NextEvent) => handle_next_event(stack_values),
             Ok(InputSyscall::SetTouchEnabled) => handle_set_touch_enabled(stack_values),
             Ok(InputSyscall::HasEvent) => handle_has_event(stack_values),
-            _ => panic!("illegal syscall"),
+            Err(_) => panic!("illegal syscall"),
         }
     }
 

eepy/src/usb.rs

···
 use core::arch::{asm, global_asm};
-use defmt::trace;
-use eepy_sys::misc::get_serial;
-use eepy_sys::usb::UsbSyscall;
+use core::cell::RefCell;
+use core::fmt::{Debug, Formatter};
+use core::sync::atomic::Ordering;
+use critical_section::Mutex;
+use defmt::{debug, trace, warn};
+use portable_atomic::AtomicPtr;
+use eepy_sys::usb::{SafePollResult, SafeUsbError, UsbEpAllocArgs, UsbReadArgs, UsbSyscall, UsbWriteArgs};
+use fw16_epd_bsp::hal::clocks::UsbClock;
+use fw16_epd_bsp::hal::usb::UsbBus;
 use fw16_epd_bsp::pac;
-use fw16_epd_bsp::pac::interrupt;
+use fw16_epd_bsp::pac::{interrupt, USBCTRL_DPRAM, USBCTRL_REGS};
+use usb_device::class_prelude::{*, UsbBus as _};
+use eepy_sys::SafeResult;
 use crate::exception::StackFrame;
 
 global_asm!(include_str!("usb.s"));
 
-extern "C" {
-    fn usb_ret();
+struct Usb {
+    bus: Option<UsbBus>,
+    freed: Option<(USBCTRL_REGS, USBCTRL_DPRAM, UsbClock)>,
+}
+
+impl Usb {
+    fn init_bus(&mut self) {
+        if let Some((regs, dpram, clock)) = self.freed.take() {
+            self.bus.replace(UsbBus::new(
+                regs,
+                dpram,
+                clock,
+                false,
+                &mut unsafe { pac::RESETS::steal() },
+            ));
+        }
+    }
+
+    fn free_bus(&mut self) {
+        if let Some(bus) = self.bus.take() {
+            let (regs, dpram, clock) = bus.free(
+                &mut unsafe { pac::RESETS::steal() }
+            );
+            self.freed.replace((regs, dpram, clock));
+        }
+    }
+
+    fn get_bus(&mut self) -> &mut UsbBus {
+        self.bus.as_mut().expect("USB bus not initialised")
+    }
+}
+
+impl Debug for Usb {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        if self.bus.is_some() {
+            f.write_str("Active USB")
+        } else if self.freed.is_some() {
+            f.write_str("Freed USB")
+        } else {
+            f.write_str("Uninitialised USB")
+        }
+    }
+}
+
+static USB: Mutex<RefCell<Option<Usb>>> = Mutex::new(RefCell::new(None));
+
+fn with_usb<R>(mut f: impl FnMut(&mut Usb) -> R) -> R {
+    critical_section::with(|cs| {
+        f(
+            USB
+                .borrow_ref_mut(cs)
+                .as_mut()
+                .expect("USB bus not initialised")
+        )
+    })
+}
+
+fn with_usb_bus<R>(mut f: impl FnMut(&mut UsbBus) -> R) -> R {
+    critical_section::with(|cs| {
+        f(
+            USB
+                .borrow_ref_mut(cs)
+                .as_mut()
+                .expect("USB bus not initialised")
+                .get_bus()
+        )
+    })
 }
 
-extern "C" fn example_usb_handler() {
-    // Do a syscall so it shows up in the kernel logs
-    // (we should be in unprivileged thread mode here so we can't use defmt)
-    core::hint::black_box(get_serial());
+pub(crate) fn init_usb(regs: USBCTRL_REGS, dpram: USBCTRL_DPRAM, clock: UsbClock) {
+    critical_section::with(|cs| USB.borrow_ref_mut(cs).replace(
+        Usb {
+            bus: None,
+            freed: Some((regs, dpram, clock)),
+        }
+    ));
+}
+
+static USB_HANDLER: AtomicPtr<u8> = AtomicPtr::new(core::ptr::null_mut());
+
+extern "C" {
+    fn usb_ret();
 }
 
 #[no_mangle]
 extern "C" fn handle_usb_irq(sp: *mut StackFrame, using_psp: bool) {
-    trace!("fake USBCTRL_IRQ");
+    trace!("USBCTRL_IRQ");
 
     if !using_psp {
         return;
     }
 
+    let handler = USB_HANDLER.load(Ordering::Relaxed);
+    if handler.is_null() {
+        warn!("USB handler is null but interrupt was not masked");
+        return;
+    }
+
+    // make sure the interrupt doesn't fire again whilst the unprivileged handler
+    // is running (we unmask again after the handler is done as part of the UsbRet
+    // syscall
+    trace!("masking USBCTRL_IRQ");
+    pac::NVIC::mask(interrupt::USBCTRL_IRQ);
+
     unsafe {
         let new_sp = sp.sub(1);
         new_sp.write(StackFrame {
···
             r3: 0,
             r12: 0,
             lr: usb_ret as *const u8,
-            pc: example_usb_handler as *const u8,
+            pc: handler,
             xpsr: 0x1000000,
         });
 
···
 pub(crate) fn handle_usb(stack_values: &mut StackFrame) {
     match UsbSyscall::try_from(stack_values.r0) {
         Ok(UsbSyscall::UsbRet) => handle_usb_ret(stack_values),
-        Err(_) => {},
+        Ok(UsbSyscall::SetHandler) => handle_set_handler(stack_values),
+        Ok(UsbSyscall::ClearHandler) => handle_clear_handler(),
+        Ok(UsbSyscall::Init) => handle_init(),
+        Ok(UsbSyscall::Uninit) => handle_uninit(),
+        Ok(UsbSyscall::AllocEp) => handle_alloc_ep(stack_values),
+        Ok(UsbSyscall::Enable) => handle_enable(),
+        Ok(UsbSyscall::Reset) => handle_reset(),
+        Ok(UsbSyscall::SetDeviceAddr) => handle_set_device_addr(stack_values),
+        Ok(UsbSyscall::Write) => handle_write(stack_values),
+        Ok(UsbSyscall::Read) => handle_read(stack_values),
+        Ok(UsbSyscall::SetStalled) => handle_set_stalled(stack_values),
+        Ok(UsbSyscall::IsStalled) => handle_is_stalled(stack_values),
+        Ok(UsbSyscall::Poll) => handle_poll(stack_values),
+        Err(_) => panic!("illegal syscall"),
+    }
+}
+
+pub(crate) fn handle_clear_handler() {
+    USB_HANDLER.store(core::ptr::null_mut(), Ordering::Relaxed);
+    trace!("masking USBCTRL_IRQ");
+    pac::NVIC::mask(interrupt::USBCTRL_IRQ);
+}
+
+fn handle_set_handler(stack_values: &mut StackFrame) {
+    let handler = stack_values.r1 as *mut u8;
+    USB_HANDLER.store(handler, Ordering::Relaxed);
+    unsafe {
+        trace!("unmasking USBCTRL_IRQ");
+        pac::NVIC::unmask(interrupt::USBCTRL_IRQ);
     }
 }
 
 fn handle_usb_ret(stack_values: &mut StackFrame) {
     trace!("usb_ret");
     unsafe {
+        trace!("unmasking USBCTRL_IRQ");
+        pac::NVIC::unmask(interrupt::USBCTRL_IRQ);
+
         let new_sp = (&raw mut *stack_values).add(1);
         asm!(
             "msr psp, {new_psp}",
             new_psp = in(reg) new_sp,
         );
+    }
+}
+
+fn handle_init() {
+    trace!("USB init");
+    with_usb(|usb| usb.init_bus());
+}
+
+pub(crate) fn handle_uninit() {
+    trace!("USB uninit");
+    with_usb(|usb| usb.free_bus());
+}
+
+fn handle_alloc_ep(stack_values: &mut StackFrame) {
+    trace!("USB alloc endpoint");
+    let alloc_info = stack_values.r1 as *const UsbEpAllocArgs;
+    trace!("{}", unsafe { *alloc_info });
+
+    let ep_dir = unsafe { (*alloc_info).ep_dir };
+    let ep_addr: Option<EndpointAddress> = unsafe {
+        let addr: Option<u8> = (*alloc_info).ep_addr.into();
+        addr.map(|v| v.into())
+    };
+    let ep_type: EndpointType = unsafe { (*alloc_info).ep_type.into() };
+    let max_packet_size = unsafe { (*alloc_info).max_packet_size };
+    let interval = unsafe { (*alloc_info).interval };
+
+    let res_ptr = stack_values.r2 as *mut SafeResult<u8, SafeUsbError>;
+
+    let res = with_usb_bus(|bus| {
+        bus.alloc_ep(
+            ep_dir,
+            ep_addr,
+            ep_type,
+            max_packet_size,
+            interval,
+        )
+    });
+
+    let res: Result<u8, SafeUsbError> = res.map(|v| v.into()).map_err(|e| e.into());
+    unsafe {
+        res_ptr.write(res.into());
+    }
+}
+
+fn handle_enable() {
+    trace!("USB enable");
+    with_usb_bus(|bus| bus.enable());
+}
+
+fn handle_reset() {
+    trace!("USB reset");
+    with_usb_bus(|bus| bus.reset());
+}
+
+fn handle_set_device_addr(stack_values: &mut StackFrame) {
+    trace!("USB set device address");
+    with_usb_bus(|bus| bus.set_device_address(stack_values.r1 as u8));
+}
+
+fn handle_write(stack_values: &mut StackFrame) {
+    trace!("USB write");
+    let args = stack_values.r1 as *const UsbWriteArgs;
+
+    let ep_addr = unsafe { (*args).ep_addr }.into();
+    let buf = unsafe { core::slice::from_raw_parts((*args).buf, (*args).len) };
+
+    let res = with_usb_bus(|bus| {
+        bus.write(ep_addr, buf)
+    });
+
+    let res: Result<usize, SafeUsbError> = res.map_err(|e| e.into());
+    unsafe {
+        (*args).ptr.write(res.into());
+    }
+}
+
+fn handle_read(stack_values: &mut StackFrame) {
+    trace!("USB read");
+    let args = stack_values.r1 as *const UsbReadArgs;
+
+    let ep_addr = unsafe { (*args).ep_addr }.into();
+    let buf = unsafe { core::slice::from_raw_parts_mut((*args).buf, (*args).len) };
+
+    let res = with_usb_bus(|bus| {
+        bus.read(ep_addr, buf)
+    });
+
+    let res: Result<usize, SafeUsbError> = res.map_err(|e| e.into());
+    unsafe {
+        (*args).ptr.write(res.into());
+    }
+}
+
+fn handle_set_stalled(stack_values: &mut StackFrame) {
+    trace!("USB set stalled");
+    let ep_addr: EndpointAddress = (stack_values.r1 as u8).into();
+    let stalled = stack_values.r2 != 0;
+    with_usb_bus(|bus| bus.set_stalled(ep_addr, stalled));
+}
+
+fn handle_is_stalled(stack_values: &mut StackFrame) {
+    trace!("USB query stalled");
+    let ep_addr: EndpointAddress = (stack_values.r1 as u8).into();
+    let stalled = with_usb_bus(|bus| bus.is_stalled(ep_addr));
+    stack_values.r0 = stalled as usize;
+}
+
+fn handle_poll(stack_values: &mut StackFrame) {
+    trace!("USB poll");
+    let res_ptr = stack_values.r1 as *mut SafePollResult;
+    let result = with_usb_bus(|bus| bus.poll());
+    unsafe {
+        res_ptr.write(result.into());
     }
 }

eepy/src/usb.s

···
-//.global USBCTRL_IRQ
-.global SW5_IRQ
+.global USBCTRL_IRQ
+//.global SW5_IRQ
 
     .thumb_func
-//USBCTRL_IRQ:
-SW5_IRQ:
+USBCTRL_IRQ:
+//SW5_IRQ:
     ldr     r2, =handle_usb_irq
     movs    r0, #4
     mov     r1, lr

elf2epb/src/main.rs

···
     let mut current_addr: Option<u32> = None;
 
     for phdr in elf.segments().expect("Failed to parse ELF file") {
-        if phdr.p_type == PT_LOAD {
+        if phdr.p_type == PT_LOAD && phdr.p_filesz > 0 {
             if current_addr.is_none() {
-                current_addr.replace(phdr.p_vaddr as u32);
+                current_addr.replace(phdr.p_paddr as u32);
             }
 
             let current_addr = current_addr.as_mut().unwrap();
 
-            if *current_addr < phdr.p_vaddr as u32 {
-                let diff = phdr.p_vaddr as u32 - *current_addr;
+            if *current_addr < phdr.p_paddr as u32 {
+                let diff = phdr.p_paddr as u32 - *current_addr;
                 for _ in 0..diff {
                     bin.push(0);
                 }
···
     let len = bin.len() as u32;
 
     // Add missing EPB header entries
-    bin[8..12].copy_from_slice(&len.to_le_bytes());             // len
+    bin[8..12].copy_from_slice(&len.to_le_bytes());          // len
     bin[12..16].copy_from_slice(&data_len.to_le_bytes());       // data_len
     bin[16..20].copy_from_slice(&data_paddr.to_le_bytes());     // data_lma
     bin[20..24].copy_from_slice(&data_vaddr.to_le_bytes());     // data_vma