Use separate hid interface for keyboard proto

4 files changed, 127 insertions, 99 deletions

diff --git a/src/hid.c b/src/hid.c
index 6aecda1..bc9a457 100644
--- a/src/hid.c
+++ b/src/hid.c
@@ -1,16 +1,17 @@
 #include "hid.h"
 
-#include "keysym/consumer.h"
-#include "keysym/system.h"
-#include "hid/keyboard.h"
-#include "hid/consumer.h"
-#include "hid/system.h"
-
+#include "led.h"
 #include "split.h"
 #include "keymat.h"
 #include "keysym.h"
 #include "keymap.h"
 
+#include "class/hid/hid.h"
+#include "keysym/consumer.h"
+#include "keysym/system.h"
+#include "hid/keyboard.h"
+#include "hid/consumer.h"
+#include "hid/system.h"
 #include "hardware/timer.h"
 #include "bsp/board.h"
 #include "pico/types.h"
@@ -95,6 +96,8 @@ static bool macro_held_find(uint32_t keysym);
 
 static void add_keycode(uint8_t keycode);
 
+/* TODO: add static prototypes */
+
 void
 active_layers_reset(void)
 {
@@ -384,6 +387,28 @@ send_keyboard_report(void)
 }
 
 bool
+send_mouse_report(void)
+{
+	bool sent;
+
+	sent = false;
+	if (memcmp(&mouse_report, &mouse_report_prev,
+			sizeof(mouse_report))) {
+		tud_hid_n_mouse_report(INST_HID_MISC,
+			REPORT_ID_MOUSE, mouse_report.btns,
+			mouse_report.x, mouse_report.y,
+			mouse_report.h, mouse_report.v);
+		memcpy(&mouse_report_prev, &mouse_report,
+			sizeof(mouse_report));
+		sent = true;
+	}
+
+	memset(&mouse_report, 0, sizeof(mouse_report));
+
+	return sent;
+}
+
+bool
 send_consumer_report(void)
 {
 	bool sent;
@@ -391,7 +416,8 @@ send_consumer_report(void)
 	sent = false;
 	if (memcmp(&consumer_report, &consumer_report_prev,
 			sizeof(consumer_report))) {
-		tud_hid_report(REPORT_ID_CONSUMER,
+		INFO("CONSUMER SEND");
+		tud_hid_n_report(INST_HID_MISC, REPORT_ID_CONSUMER,
 			&consumer_report.code, 2);
 		memcpy(&consumer_report_prev, &consumer_report,
 			sizeof(consumer_report));
@@ -411,7 +437,7 @@ send_system_report(void)
 	sent = false;
 	if (memcmp(&system_report, &system_report_prev,
 			sizeof(system_report))) {
-		tud_hid_report(REPORT_ID_SYSTEM,
+		tud_hid_n_report(INST_HID_MISC, REPORT_ID_SYSTEM,
 			&system_report.code, 2);
 		memcpy(&system_report_prev, &system_report,
 			sizeof(system_report));
@@ -424,27 +450,6 @@ send_system_report(void)
 }
 
 bool
-send_mouse_report(void)
-{
-	bool sent;
-
-	sent = false;
-	if (memcmp(&mouse_report, &mouse_report_prev,
-			sizeof(mouse_report))) {
-		tud_hid_mouse_report(REPORT_ID_NONE, mouse_report.btns,
-			mouse_report.x, mouse_report.y,
-			mouse_report.h, mouse_report.v);
-		memcpy(&mouse_report_prev, &mouse_report,
-			sizeof(mouse_report));
-		sent = true;
-	}
-
-	memset(&mouse_report, 0, sizeof(mouse_report));
-
-	return sent;
-}
-
-bool
 send_gamepad_report(void)
 {
 	bool sent;
@@ -452,7 +457,7 @@ send_gamepad_report(void)
 	sent = false;
 	if (memcmp(&gamepad_report, &gamepad_report_prev,
 			sizeof(gamepad_report))) {
-		tud_hid_gamepad_report(REPORT_ID_GAMEPAD,
+		tud_hid_n_gamepad_report(INST_HID_MISC, REPORT_ID_GAMEPAD,
 			gamepad_report.x, gamepad_report.y, gamepad_report.z,
 			gamepad_report.rz, gamepad_report.rx, gamepad_report.ry,
 			gamepad_report.hat, gamepad_report.btns);
@@ -470,12 +475,12 @@ bool
 send_hid_report(int id)
 {
 	switch (id) {
+	case REPORT_ID_MOUSE:
+		return send_mouse_report();
 	case REPORT_ID_CONSUMER:
 		return send_consumer_report();
 	case REPORT_ID_SYSTEM:
 		return send_system_report();
-	case REPORT_ID_MOUSE:
-		return send_mouse_report();
 	case REPORT_ID_GAMEPAD:
 		return send_gamepad_report();
 	}
@@ -494,11 +499,31 @@ send_next_hid_report(uint8_t min)
 	}
 }
 
+bool
+hid_ready()
+{
+	return tud_hid_n_ready(INST_HID_KBD)
+		&& tud_hid_n_ready(INST_HID_MISC);
+}
+
+void
+tud_hid_set_protocol_cb(uint8_t instance, uint8_t protocol)
+{
+	if (protocol == HID_PROTOCOL_BOOT) {
+		led_rgb = WS2812_U32RGB(100, 100, 0);
+	} else {
+		led_rgb = WS2812_U32RGB(100, 0, 100);
+	}
+	led_mode = LED_ON;
+	led_reset = true;
+}
+
 void
 tud_hid_report_complete_cb(uint8_t instance,
 	uint8_t const *report, uint8_t len)
 {
-	send_next_hid_report(report[0] + 1);
+	if (report[0] >= REPORT_ID_MIN)
+		send_next_hid_report(report[0] + 1);
 }
 
 void
@@ -538,11 +563,12 @@ hid_send_macro(const uint32_t *keysyms, uint cnt)
 
 	active_mods = 0;
 	active_weak_mods = 0;
+	macro_running = true;
 	memset(&keyboard_report, 0, sizeof(keyboard_report));
 	memset(&keyboard_report_prev, 0, sizeof(keyboard_report));
 	memset(&seen_mat, 0, sizeof(seen_mat));
+	while (!hid_ready()) tud_task();
 
-	macro_running = true;
 	for (i = 0; i < cnt; i++) {
 		if (IS_MACRO_DELAY(keysyms[i])) {
 			start_ms = board_millis();
@@ -579,22 +605,19 @@ hid_send_macro(const uint32_t *keysyms, uint cnt)
 			process_keydown(keysyms[i], mx, my);
 		}
 
-		while (!tud_hid_n_ready(INST_HID_KBD))
-			tud_task();
-		send_next_hid_report(REPORT_ID_MIN);
+		send_keyboard_report();
+		while (!hid_ready()) tud_task();
 
 		if (IS_MACRO_PRESS(keysyms[i])) {
 			memcpy(&keyboard_report, &tmp, sizeof(keyboard_report));
-			while (!tud_hid_n_ready(INST_HID_KBD))
-				tud_task();
-			send_next_hid_report(REPORT_ID_MIN);
+			send_keyboard_report();
+			while (!hid_ready()) tud_task();
 		}
 	}
 
 	memset(&keyboard_report, 0, sizeof(keyboard_report));
-	send_next_hid_report(REPORT_ID_MIN);
-	while (!tud_hid_n_ready(INST_HID_KBD))
-		tud_task();
+	send_keyboard_report();
+	while (!hid_ready()) tud_task();
 
 	macro_running = false;
 }
@@ -605,5 +628,7 @@ hid_task(void)
 	update_report();
 	if (tud_hid_n_ready(INST_HID_KBD))
 		send_keyboard_report();
+	if (tud_hid_n_ready(INST_HID_MISC))
+		send_next_hid_report(REPORT_ID_MIN);
 }
 
diff --git a/src/hid.h b/src/hid.h
index 64536e3..93a039d 100644
--- a/src/hid.h
+++ b/src/hid.h
@@ -12,9 +12,9 @@
 #define REPORT_ID_MIN 1
 
 enum {
-	REPORT_ID_CONSUMER = REPORT_ID_MIN,
+	REPORT_ID_MOUSE = REPORT_ID_MIN,
+	REPORT_ID_CONSUMER,
 	REPORT_ID_SYSTEM,
-	REPORT_ID_MOUSE,
 	REPORT_ID_GAMEPAD,
 	REPORT_ID_MAX
 };
diff --git a/src/tusb_config.h b/src/tusb_config.h
index 54378b0..0efec1c 100644
--- a/src/tusb_config.h
+++ b/src/tusb_config.h
@@ -42,12 +42,10 @@ extern "C" {
 
 #define CFG_TUD_CDC               1
 #define CFG_TUD_MSC               0
-#define CFG_TUD_HID               1
+#define CFG_TUD_HID               2
 #define CFG_TUD_MIDI              0
 #define CFG_TUD_VENDOR            0
 
-#define CFG_TUD_HID_EP_BUFSIZE 16
-
 #define CFG_TUD_CDC_EP_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
 #define CFG_TUD_CDC_RX_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
 #define CFG_TUD_CDC_TX_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
diff --git a/src/usb_descriptors.c b/src/usb_descriptors.c
index 9f5352a..e015163 100644
--- a/src/usb_descriptors.c
+++ b/src/usb_descriptors.c
@@ -12,26 +12,28 @@
 #define USB_PID (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) \
 	 | _PID_MAP(HID, 2) | _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4))
 
-#define USB_VID 0x1523
-#define USB_BCD 0x0200
+#define USB_VID 0x1209
+#define USB_BCD 0xDDDD
 
 #define CONFIG_TOTAL_LEN \
-	(TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_DESC_LEN)
+	(TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + 2 * TUD_HID_DESC_LEN)
 
 /* MCU-specific! */
-#define EPNUM_CDC_NOTIF   0x81
-#define EPNUM_CDC_OUT     0x02
-#define EPNUM_CDC_IN      0x82
-#define EPNUM_HID         0x83
+#define EPNUM_HID_KBD    0x81
+#define EPNUM_HID_MISC   0x82
+#define EPNUM_CDC_NOTIF  0x84
+#define EPNUM_CDC_IN     0x85
+#define EPNUM_CDC_OUT    0x05
 
 enum {
 	ITF_NUM_CDC,
 	ITF_NUM_CDC_DATA,
 	ITF_NUM_HID_KBD,
+	ITF_NUM_HID_MISC,
 	ITF_NUM_TOTAL
 };
 
-tusb_desc_device_t const desc_device = {
+static const tusb_desc_device_t desc_device = {
 	.bLength            = sizeof(tusb_desc_device_t),
 	.bDescriptorType    = TUSB_DESC_DEVICE,
 	.bcdUSB             = USB_BCD,
@@ -53,18 +55,18 @@ tusb_desc_device_t const desc_device = {
 	.bNumConfigurations = 0x01
 };
 
-uint8_t const desc_hid_kbd_report[] = {
+static const uint8_t desc_hid_kbd_report[] = {
 	TUD_HID_REPORT_DESC_KEYBOARD()
 };
 
-uint8_t const desc_hid_misc_report[] = {
+static const uint8_t desc_hid_misc_report[] = {
 	TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(REPORT_ID_MOUSE)),
 	TUD_HID_REPORT_DESC_CONSUMER(HID_REPORT_ID(REPORT_ID_CONSUMER)),
 	TUD_HID_REPORT_DESC_SYSTEM_CONTROL(HID_REPORT_ID(REPORT_ID_SYSTEM)),
 	TUD_HID_REPORT_DESC_GAMEPAD(HID_REPORT_ID(REPORT_ID_GAMEPAD))
 };
 
-uint8_t const desc_fs_configuration[] = {
+static const uint8_t desc_fs_configuration[] = {
 	/* Config number, interface count, string index,
 	 * total length, attribute, power in mA */
 	TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN,
@@ -78,11 +80,13 @@ uint8_t const desc_fs_configuration[] = {
 	/* Interface number, string index, protocol, report descriptor len,
 	 * EP In address, size & polling interval */
 	TUD_HID_DESCRIPTOR(ITF_NUM_HID_KBD, 0, HID_ITF_PROTOCOL_KEYBOARD,
-		sizeof(desc_hid_kbd_report), EPNUM_HID, 8, 1)
+		sizeof(desc_hid_kbd_report), EPNUM_HID_KBD, 8, 1),
+	TUD_HID_DESCRIPTOR(ITF_NUM_HID_MISC, 0, HID_ITF_PROTOCOL_NONE,
+		sizeof(desc_hid_misc_report), EPNUM_HID_MISC, 16, 1)
 };
 
 #if TUD_OPT_HIGH_SPEED
-uint8_t const desc_hs_configuration[] = {
+static const uint8_t desc_hs_configuration[] = {
 	/* Config number, interface count, string index,
 	 * total length, attribute, power in mA */
 	TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN,
@@ -96,12 +100,14 @@ uint8_t const desc_hs_configuration[] = {
 	/* Interface number, string index, protocol, report descriptor len,
 	 * EP In address, size & polling interval */
 	TUD_HID_DESCRIPTOR(ITF_NUM_HID_KBD, 0, HID_ITF_PROTOCOL_KEYBOARD,
-		sizeof(desc_hid_kbd_report), EPNUM_HID, 8, 1)
+		sizeof(desc_hid_kbd_report), EPNUM_HID_KBD, 8, 1),
+	TUD_HID_DESCRIPTOR(ITF_NUM_HID_MISC, 0, HID_ITF_PROTOCOL_NONE,
+		sizeof(desc_hid_misc_report), EPNUM_HID_MISC, 16, 1)
 };
 
-uint8_t desc_other_speed_config[CONFIG_TOTAL_LEN];
+static uint8_t desc_other_speed_config[CONFIG_TOTAL_LEN];
 
-tusb_desc_device_qualifier_t const desc_device_qualifier =
+static const tusb_desc_device_qualifier_t desc_device_qualifier =
 {
 	.bLength            = sizeof(tusb_desc_device_qualifier_t),
 	.bDescriptorType    = TUSB_DESC_DEVICE_QUALIFIER,
@@ -117,54 +123,52 @@ tusb_desc_device_qualifier_t const desc_device_qualifier =
 };
 #endif
 
-char const *string_desc_arr[] = {
-	[0] = "\x07\x04",         /* LangID: German (0x0407) */
-	[1] = "TinyUSB",          /* Manufacturer */
-	[2] = "TinyUSB Device",   /* Product */
-	[3] = "123456",           /* Serials, should use chip ID */
-	[4] = "SXKBD CDC",
+static const char *string_desc_arr[] = {
+	[0] = "\x07\x04",       /* LangID: German (0x0407) */
+	[1] = "SNX",            /* Manufacturer */
+	[2] = "SXKBD Keyboard", /* Product */
+	[3] = "000001",         /* Serial Number */
+	[4] = "HID-CDC",
+	[5] = "HID-KBD",
+	[6] = "HID-MISC"
 };
 
 static uint16_t _desc_str[32];
 
-/* Invoked on GET DEVICE DESCRIPTOR */
-uint8_t const *
+const uint8_t *
 tud_descriptor_device_cb(void)
 {
-	return (uint8_t const *) &desc_device;
+	return (const uint8_t *) &desc_device;
 }
 
-/* Invoked on GET HID REPORT DESCRIPTOR */
-uint8_t const *
-tud_hid_descriptor_report_cb(uint8_t itf)
+const uint8_t *
+tud_hid_descriptor_report_cb(uint8_t instance)
 {
-	(void) itf;
-	return desc_hid_kbd_report;
+	if (instance == INST_HID_KBD)
+		return desc_hid_kbd_report;
+	else
+		return desc_hid_misc_report;
 }
 
-/* Invoked on GET CONFIGURATION DESCRIPTOR */
-uint8_t const *
-tud_descriptor_configuration_cb(uint8_t index)
+const uint8_t *
+tud_descriptor_configuration_cb(uint8_t instance)
 {
-	(void) index;
-
 #if TUD_OPT_HIGH_SPEED
-	return (tud_speed_get() == TUSB_SPEED_HIGH) ?
-		desc_hs_configuration : desc_fs_configuration;
+	if (tud_speed_get() == TUSB_SPEED_HIGH)
+		return desc_hs_configuration;
+	else
+		return desc_fs_configuration;
 #else
 	return desc_fs_configuration;
 #endif
 }
 
-/* Invoked on GET STRING DESCRIPTOR */
-uint16_t const *
+const uint16_t *
 tud_descriptor_string_cb(uint8_t index, uint16_t langid)
 {
 	const char *str;
 	uint8_t i, chr_count;
 
-	(void) langid;
-
 	if (index == 0) {
 		memcpy(&_desc_str[1], string_desc_arr[0], 2);
 		chr_count = 1;
@@ -190,21 +194,22 @@ tud_descriptor_string_cb(uint8_t index, uint16_t langid)
 }
 
 #if TUD_OPT_HIGH_SPEED
-uint8_t const *
+const uint8_t *
 tud_descriptor_device_qualifier_cb(void)
 {
-	return (uint8_t const*) &desc_device_qualifier;
+	return (const uint8_t*) &desc_device_qualifier;
 }
 
-/* Invoked on GET OTHER SEED CONFIGURATION DESCRIPTOR */
-uint8_t const *
-tud_descriptor_other_speed_configuration_cb(uint8_t index)
+const uint8_t *
+tud_descriptor_other_speed_configuration_cb(uint8_t instance)
 {
-	(void) index;
-
-	memcpy(desc_other_speed_config, (tud_speed_get() == TUSB_SPEED_HIGH)
-		? desc_fs_configuration : desc_hs_configuration,
-		CONFIG_TOTAL_LEN);
+	if (tud_speed_get() == TUSB_SPEED_HIGH) {
+		memcpy(desc_other_speed_config, desc_hs_configuration,
+			CONFIG_TOTAL_LEN);
+	} else {
+		memcpy(desc_other_speed_config, desc_fs_configuration,
+			CONFIG_TOTAL_LEN);
+	}
 
 	desc_other_speed_config[1] = TUSB_DESC_OTHER_SPEED_CONFIG;