usb: Move usb handling out into main loop

It best practice to do as little work as possible in the interrupt
handlers. In this commit the parsing is moved from the interrupts
handlers to the main loop.

This is also a requirement for having multiple transports.

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