U2F: separate queues

Author: NickeZ

src/CMakeLists.txt

@@ -78,6 +78,7 @@ set(DBB-FIRMWARE-USB-SOURCES
   ${CMAKE_SOURCE_DIR}/src/usb/usb.c
   ${CMAKE_SOURCE_DIR}/src/usb/usb_frame.c
   ${CMAKE_SOURCE_DIR}/src/usb/usb_packet.c
+  ${CMAKE_SOURCE_DIR}/src/u2f/u2f_packet.c
   ${CMAKE_SOURCE_DIR}/src/usb/usb_processing.c
   ${CMAKE_SOURCE_DIR}/src/queue.c
 )

src/bootloader/bootloader.c

@@ -779,7 +779,7 @@ static void _api_setup(void)
 {
     const CMD_Callback cmd_callbacks[] = {{BOOTLOADER_CMD, _api_msg}};
 
-    usb_processing_register_cmds(cmd_callbacks, 1);
+    usb_processing_register_cmds(usb_processing_hww(), cmd_callbacks, 1);
 }
 
 #ifdef BOOTLOADER_PRODUCTION

src/bootloader/startup.c

@@ -50,7 +50,7 @@ int main(void)
 
     // If did not jump to firmware code, begin USB processing
     while (1) {
-        usb_processing_process();
+        usb_processing_process(usb_processing_hww());
     }
 
     return 0;

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

@@ -17,6 +17,7 @@
 #include <queue.h>
 #include "hid_hww.h"
 #include "usb_desc.h"
+#include "usb/usb_processing.h"
 
 #define HID_HWW_VERSION 0x00000001u
 
@@ -125,6 +126,8 @@ void hid_hww_setup(void) {
     // 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();
 }

src/drivers/usb/class/hid/u2f/hid_u2f.c

@@ -13,10 +13,11 @@
 // limitations under the License.
 
 #include <string.h>
-#include <usb/usb_packet.h>
+#include <u2f/u2f_packet.h>
 #include <queue.h>
 #include "hid_u2f.h"
 #include "usb_desc.h"
+#include "usb/usb_processing.h"
 
 #define HID_U2F_VERSION 0x00000001u
 
@@ -65,7 +66,7 @@ static int32_t _read(void)
  * Sends the next data, if the USB interface is ready.
  */
 static void _send_next(void) {
-    const uint8_t *data = queue_pull(queue_hww_queue());
+    const uint8_t *data = queue_pull(queue_u2f_queue());
     if (data != NULL) {
         hid_write(&_func_data, data, USB_HID_REPORT_OUT_SIZE);
     } else {
@@ -86,7 +87,7 @@ static uint8_t _out(const uint8_t ep, const enum usb_xfer_code rc,
     (void) rc;
     (void) count;
 
-    bool need_more = usb_packet_process((const USB_FRAME *) _out_report, _send_next);
+    bool need_more = u2f_packet_process((const USB_FRAME *) _out_report, _send_next);
     if (need_more) {
         _read();
     }
@@ -125,6 +126,8 @@ void hid_u2f_setup(void) {
     // usb_report_sent is called when the outgoing usb frame is fully transmitted.
     hid_u2f_register_callback(HID_CB_WRITE, (FUNC_PTR) _sent_done);
 
+    usb_processing_set_send(usb_processing_u2f(), _send_next);
+
     // Wait for data
     _read();
 }

src/factorysetup.c

@@ -170,7 +170,8 @@ static void _api_msg(const Packet* in_packet, Packet* out_packet, const size_t m
 static void _api_setup(void)
 {
     const CMD_Callback cmd_callbacks[] = {{FACTORYSETUP_CMD, _api_msg}};
-    usb_processing_register_cmds(cmd_callbacks, sizeof(cmd_callbacks) / sizeof(CMD_Callback));
+    usb_processing_register_cmds(
+        usb_processing_hww(), cmd_callbacks, sizeof(cmd_callbacks) / sizeof(CMD_Callback));
     screen_print_debug("READY", 0);
 }
 
@@ -197,6 +198,6 @@ int main(void)
     }
     usb_start(_api_setup);
     while (1) {
-        usb_processing_process();
+        usb_processing_process(usb_processing_hww());
     }
 }

src/hww.c

@@ -110,5 +110,5 @@ void hww_setup(void)
 {
     const CMD_Callback hww_cmd_callbacks[] = {{HWW_MSG, _msg}};
     usb_processing_register_cmds(
-        hww_cmd_callbacks, sizeof(hww_cmd_callbacks) / sizeof(CMD_Callback));
+        usb_processing_hww(), hww_cmd_callbacks, sizeof(hww_cmd_callbacks) / sizeof(CMD_Callback));
 }

src/queue.c

@@ -25,8 +25,8 @@
 
 // `start` and `end` are indices into `items`
 struct queue {
-    uint32_t start;
-    uint32_t end;
+    uint32_t volatile start;
+    uint32_t volatile end;
     uint8_t items[QUEUE_NUM_REPORTS][USB_REPORT_SIZE];
 };
 
@@ -47,7 +47,7 @@ const uint8_t* queue_pull(struct queue* ctx)
     return ctx->items[p];
 }
 
-int32_t queue_push(struct queue* ctx, const uint8_t* data)
+queue_error_t queue_push(struct queue* ctx, const uint8_t* data)
 {
     uint32_t next = (ctx->end + 1) % QUEUE_NUM_REPORTS;
     if (ctx->start == next) {

src/queue.h

@@ -18,8 +18,10 @@
 #include <stdint.h>
 #include <string.h>
 
-#define QUEUE_ERR_NONE 0
-#define QUEUE_ERR_FULL -1
+typedef enum {
+    QUEUE_ERR_NONE = 0,
+    QUEUE_ERR_FULL = 1,
+} queue_error_t;
 
 struct queue;
 
@@ -28,7 +30,7 @@ struct queue;
  * Returns QUEUE_ERR_NONE if the data was added and QUEUE_ERR_FULL if the buffer was full.
  * data must be USB_REPORT_SIZE large
  */
-int32_t queue_push(struct queue* ctx, const uint8_t* data);
+queue_error_t queue_push(struct queue* ctx, const uint8_t* data);
 
 /**
  * Return the first data that was added to the queue.

src/u2f.c

@@ -577,6 +577,6 @@ void u2f_device_setup(void)
         {U2FHID_MSG, _cmd_msg},
     };
     usb_processing_register_cmds(
-        u2f_cmd_callbacks, sizeof(u2f_cmd_callbacks) / sizeof(CMD_Callback));
+        usb_processing_u2f(), u2f_cmd_callbacks, sizeof(u2f_cmd_callbacks) / sizeof(CMD_Callback));
 #endif
 }