Merge pull request #1409 from NickeZ/nickez/usb-processing-in-mainloop

usb: Move usb handling out into main loop

Author: NickeZ

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/u2f/u2f_packet.c

@@ -65,6 +65,7 @@ static void _reset_state(void)
     queue_clear(queue_u2f_queue());
     _timeout_disable(_in_state.cid);
     memset(&_in_state, 0, sizeof(_in_state));
+    _in_state.buf_ptr = _in_state.data;
 }
 
 /**
@@ -180,3 +181,8 @@ bool u2f_packet_process(const USB_FRAME* frame)
     }
     return false;
 }
+
+void u2f_packet_init(void)
+{
+    _reset_state();
+}

src/u2f/u2f_packet.h

@@ -54,4 +54,6 @@ void u2f_packet_timeout_enable(uint32_t cid);
  */
 void u2f_invalid_endpoint(struct queue* queue, uint32_t cid);
 
+void u2f_packet_init(void);
+
 #endif

src/usb/class/hid/hid.h

@@ -26,6 +26,8 @@
 struct usbdc_handler;
 struct usbdf_handler;
 struct usbdf_driver;
+struct usb_req;
+enum usb_ctrl_stage { USB_SETUP_STAGE = 0, USB_DATA_STAGE = 1, USB_STATUS_STAGE = 2 };
 typedef void (*FUNC_PTR)(void);
 #endif
 

src/usb/class/hid/hww/hid_hww.c

@@ -51,68 +51,66 @@ static int32_t _request(uint8_t ep, struct usb_req* req, enum usb_ctrl_stage sta
  */
 static struct usbdc_handler _request_handler = {NULL, (FUNC_PTR)_request};
 
-// Stores the reports for the HWW interface.
-static uint8_t _out_report[USB_HID_REPORT_OUT_SIZE];
-
-/**
- * Sets the buffer address for the incoming endpoint to `_out_report`.
+/*
+ * Flags for communication between main loop and ISR
  */
-static int32_t _read(void)
+static volatile bool _send_busy = false;
+static volatile bool _has_data = false;
+static volatile bool _request_in_flight = false;
+
+// First time this function is called it initiates a transfer. Call it multiple times to poll for
+// completion. Once it returns true, there is data in the buffer.
+bool hid_hww_read(uint8_t* data)
 {
-    return hid_read(&_func_data, _out_report, USB_HID_REPORT_OUT_SIZE);
+    if (_request_in_flight && _has_data) {
+        _request_in_flight = false;
+        return true;
+    }
+    if (_request_in_flight) {
+        return false;
+    }
+    if (hid_read(&_func_data, data, USB_HID_REPORT_OUT_SIZE) == ERR_NONE) {
+        _has_data = false;
+        _request_in_flight = true;
+    }
+    return false;
 }
 
-/** Set when the send channel is busy sending data. */
-static bool _send_busy = false;
-
 /**
  * Sends the next frame, if the USB interface is ready.
  */
-static void _send_next(void)
+bool hid_hww_write_poll(const uint8_t* data)
 {
+    ASSERT(data);
     if (_send_busy) {
-        /*
-         * We can't send yet. Whenever the current sender finished, it will
-         * flush anything that's still queued.
-         */
-        return;
+        return false;
     }
-    const uint8_t* data = queue_pull(queue_hww_queue());
-    if (data != NULL) {
+    if (hid_write(&_func_data, data, USB_HID_REPORT_OUT_SIZE) == ERR_NONE) {
         _send_busy = true;
-        hid_write(&_func_data, data, USB_HID_REPORT_OUT_SIZE);
+        return true;
     }
+    return false;
 }
 
 /**
  * The callback function is called after usb data has been received (endpoint = OUT).
- * This is a result of calling _read().
- * The received data is stored in '_out_report'.
  */
-static uint8_t _out(const uint8_t ep, const enum usb_xfer_code rc, const uint32_t count)
+static uint8_t _rx_cb(const uint8_t ep, const enum usb_xfer_code rc, const uint32_t count)
 {
     (void)ep;
     (void)rc;
     (void)count;
-    usb_packet_process((const USB_FRAME*)_out_report);
-    /* Incoming data has been processed completely. Start a new read. */
-    _read();
+    _has_data = true;
     return ERR_NONE;
 }
 
 /**
  * Called when a usb frame has been replied to the host via the HWW interface
  * and the device is ready to send the next frame.
  */
-static void _sent_done(void)
+static void _tx_cb(void)
 {
     _send_busy = false;
-    /*
-     * If there is more data queued, push it immediately to save some time.
-     * Otherwise, sending will stop until somebody explicitely queues
-     * a frame again.
-     */
-    _send_next();
 }
 
 /**
@@ -135,14 +133,10 @@ int32_t hid_hww_init(void (*callback)(void))
  */
 void hid_hww_setup(void)
 {
-    hid_hww_register_callback(HID_CB_READ, (FUNC_PTR)_out);
-    // usb_report_sent is called when the outgoing usb frame is fully transmitted.
-    hid_hww_register_callback(HID_CB_WRITE, (FUNC_PTR)_sent_done);
-
-    usb_processing_set_send(usb_processing_hww(), _send_next);
-
-    // Wait for data
-    _read();
+    // RX callback is called when there is data available to read
+    hid_hww_register_callback(HID_CB_READ, (FUNC_PTR)_rx_cb);
+    // TX callback is called when data has been sent
+    hid_hww_register_callback(HID_CB_WRITE, (FUNC_PTR)_tx_cb);
 }
 
 /**

src/usb/class/hid/hww/hid_hww.h

@@ -60,4 +60,20 @@ int32_t hid_hww_register_callback(enum hid_trans_type trans_type, FUNC_PTR func)
  */
 void hid_hww_setup(void);
 
+/**
+ * Send out data
+ * returns true if data sent out, false if busy (need retry)
+ */
+bool hid_hww_write_poll(const uint8_t* data);
+
+/**
+ * Read data
+ *
+ * data must fit 64 bytes data.
+ * Returns true if there is valid data in the buffer. data is invalidated when this is called again.
+ * Returns false if USB subsystem was not ready to receive or there is a request in flight and data
+ * is not.
+ */
+bool hid_hww_read(uint8_t* data);
+
 #endif