Merge branch 'context'

Author: benma

src/bootloader/startup.c

@@ -16,6 +16,7 @@
 #include "mpu_regions.h"
 #include "platform_config.h"
 #include "platform_init.h"
+#include "usb/class/hid/hww/hid_hww.h"
 
 #include <driver_init.h>
 #include <hardfault.h>
@@ -56,8 +57,22 @@ int main(void)
 #endif
     bootloader_jump();
 
+    const uint8_t* hww_data = NULL;
+    uint8_t hww_frame[USB_REPORT_SIZE] = {0};
+
     // If did not jump to firmware code, begin USB processing
     while (1) {
+        if (hid_hww_read(&hww_frame[0])) {
+            usb_packet_process((const USB_FRAME*)hww_frame);
+        }
+        if (!hww_data) {
+            hww_data = queue_pull(queue_hww_queue());
+        }
+        if (hww_data) {
+            if (hid_hww_write_poll(hww_data)) {
+                hww_data = NULL;
+            }
+        }
         usb_processing_process(usb_processing_hww());
     }
     return 0;

src/firmware_main_loop.c

@@ -15,43 +15,94 @@
 #include "firmware_main_loop.h"
 
 #include "hardfault.h"
+#include "hid_hww.h"
 #include "hww.h"
 #include "touch/gestures.h"
-#include "u2f.h"
 #include "ui/screen_process.h"
 #include "ui/screen_stack.h"
+#include "usb/class/hid/hww/hid_hww.h"
 #include "usb/usb.h"
+#include "usb/usb_frame.h"
 #include "usb/usb_processing.h"
 #include "workflow/orientation_screen.h"
 #include <rust/rust.h>
+#if APP_U2F == 1
+#include "u2f.h"
+#include "u2f/u2f_packet.h"
+#include "usb/class/hid/u2f/hid_u2f.h"
+#endif
 
 void firmware_main_loop(void)
 {
     // This starts the async orientation screen workflow, which is processed by the loop below.
     orientation_screen();
 
-    while (1) {
-        screen_process();
-        /* And finally, run the high-level event processing. */
-
-        rust_workflow_spin();
+    const uint8_t* hww_data = NULL;
+    uint8_t hww_frame[USB_REPORT_SIZE] = {0};
 
-        if (usb_is_enabled()) {
-            rust_async_usb_spin();
+#if APP_U2F == 1
+    u2f_packet_init();
+    const uint8_t* u2f_data = NULL;
+    uint8_t u2f_frame[USB_REPORT_SIZE] = {0};
+#endif
 
-            /* First, process all the incoming USB traffic. */
-            usb_processing_process(usb_processing_hww());
+    while (1) {
+        // Do USB I/O
+        if (!hww_data) {
+            hww_data = queue_pull(queue_hww_queue());
+        }
 #if APP_U2F == 1
-            usb_processing_process(usb_processing_u2f());
+        // Generate timeout packets
+        uint32_t timeout_cid;
+        while (u2f_packet_timeout_get(&timeout_cid)) {
+            u2f_packet_timeout(timeout_cid);
+        }
+        if (!u2f_data) {
+            u2f_data = queue_pull(queue_u2f_queue());
+        }
 #endif
-            /*
-             * If USB has generated events at the application level,
-             * process them now.
-             */
-            hww_process();
+        // Only read new messages if we have nothing to send
+        if (!hww_data && hid_hww_read(&hww_frame[0])) {
+            usb_packet_process((const USB_FRAME*)hww_frame);
+        }
 #if APP_U2F == 1
-            u2f_process();
+        if (!u2f_data && hid_u2f_read(&u2f_frame[0])) {
+            u2f_packet_process((const USB_FRAME*)u2f_frame);
+        }
 #endif
+
+        if (hww_data) {
+            if (hid_hww_write_poll(hww_data)) {
+                hww_data = NULL;
+            }
+        }
+#if APP_U2F == 1
+        if (u2f_data) {
+            if (hid_u2f_write_poll(u2f_data)) {
+                u2f_data = NULL;
+            }
         }
+#endif
+
+        /* First, process all the incoming USB traffic. */
+        usb_processing_process(usb_processing_hww());
+#if APP_U2F == 1
+        usb_processing_process(usb_processing_u2f());
+#endif
+        /*
+         * If USB has generated events at the application level,
+         * process them now.
+         */
+        hww_process();
+#if APP_U2F == 1
+        u2f_process();
+#endif
+
+        screen_process();
+        /* And finally, run the high-level event processing. */
+
+        rust_workflow_spin();
+
+        rust_async_usb_spin();
     }
 }

src/rust/bitbox02-rust-c/src/workflow.rs

@@ -40,13 +40,12 @@ static mut CONFIRM_TITLE: Option<String> = None;
 static mut CONFIRM_BODY: Option<String> = None;
 static mut CONFIRM_PARAMS: Option<confirm::Params> = None;
 static mut CONFIRM_STATE: TaskState<'static, Result<(), confirm::UserAbort>> = TaskState::Nothing;
-static mut REAL_WORKFLOWS: bitbox02_rust::workflow::RealWorkflows =
-    bitbox02_rust::workflow::RealWorkflows;
+static mut BITBOX02_HAL: bitbox02_rust::hal::BitBox02Hal = bitbox02_rust::hal::BitBox02Hal::new();
 
 #[no_mangle]
 pub unsafe extern "C" fn rust_workflow_spawn_unlock() {
     UNLOCK_STATE = TaskState::Running(Box::pin(bitbox02_rust::workflow::unlock::unlock(
-        &mut REAL_WORKFLOWS,
+        &mut BITBOX02_HAL,
     )));
 }
 

src/rust/bitbox02-rust/src/hal.rs

@@ -0,0 +1,98 @@
+// Copyright 2025 Shift Crypto AG
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::workflow::RealWorkflows;
+pub use crate::workflow::Workflows as Ui;
+
+pub trait Sd {
+    fn sdcard_inserted(&mut self) -> bool;
+}
+
+/// Hardware abstraction layer for BitBox devices.
+pub trait Hal {
+    fn ui(&mut self) -> &mut impl Ui;
+    fn sd(&mut self) -> &mut impl Sd;
+}
+
+pub struct BitBox02Sd;
+
+impl Sd for BitBox02Sd {
+    fn sdcard_inserted(&mut self) -> bool {
+        bitbox02::sd::sdcard_inserted()
+    }
+}
+
+pub struct BitBox02Hal {
+    ui: RealWorkflows,
+    sd: BitBox02Sd,
+}
+
+impl BitBox02Hal {
+    pub const fn new() -> Self {
+        Self {
+            ui: crate::workflow::RealWorkflows,
+            sd: BitBox02Sd,
+        }
+    }
+}
+
+impl Hal for BitBox02Hal {
+    fn ui(&mut self) -> &mut impl Ui {
+        &mut self.ui
+    }
+    fn sd(&mut self) -> &mut impl Sd {
+        &mut self.sd
+    }
+}
+
+#[cfg(feature = "testing")]
+pub mod testing {
+    pub struct TestingSd {
+        pub inserted: Option<bool>,
+    }
+
+    impl TestingSd {
+        pub fn new() -> Self {
+            Self { inserted: None }
+        }
+    }
+    pub struct TestingHal<'a> {
+        pub ui: crate::workflow::testing::TestingWorkflows<'a>,
+        pub sd: TestingSd,
+    }
+
+    impl super::Sd for TestingSd {
+        fn sdcard_inserted(&mut self) -> bool {
+            self.inserted.unwrap()
+        }
+    }
+
+    impl TestingHal<'_> {
+        pub fn new() -> Self {
+            Self {
+                ui: crate::workflow::testing::TestingWorkflows::new(),
+                sd: TestingSd::new(),
+            }
+        }
+    }
+
+    impl super::Hal for TestingHal<'_> {
+        fn ui(&mut self) -> &mut impl super::Ui {
+            &mut self.ui
+        }
+        fn sd(&mut self) -> &mut impl super::Sd {
+            &mut self.sd
+        }
+    }
+}