diff --git a/CMakeLists.txt b/CMakeLists.txt index 724d17f..8b852bd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,7 +14,10 @@ target_sources(app PRIVATE src/main.c src/battery_module.c src/keyboard_core_module.c + src/usb_hid_module.c + src/events/hid_led_event.c src/mode_switch_module.c src/events/keyboard_hid_report_event.c src/events/mode_switch_event.c + src/events/set_protocol_event.c ) diff --git a/boards/atguigu/mini_keyboard/mini_keyboard.dts b/boards/atguigu/mini_keyboard/mini_keyboard.dts index 9e5b20a..75afc76 100644 --- a/boards/atguigu/mini_keyboard/mini_keyboard.dts +++ b/boards/atguigu/mini_keyboard/mini_keyboard.dts @@ -17,6 +17,24 @@ led0 = &myled0; }; + hid_kbd: hid_kbd { + compatible = "zephyr,hid-device"; + label = "HID_KBD"; + protocol-code = "keyboard"; + in-report-size = <29>; + out-report-size = <1>; + in-polling-period-us = <1000>; + out-polling-period-us = <1000>; + }; + + hid_consumer: hid_consumer { + compatible = "zephyr,hid-device"; + label = "HID_CONSUMER"; + protocol-code = "none"; + in-report-size = <2>; + in-polling-period-us = <1000>; + }; + leds { compatible = "gpio-leds"; myled0: led_0 { @@ -128,3 +146,12 @@ &gpiote { status = "okay"; }; + +&usbd { + status = "okay"; + num-bidir-endpoints = <0>; + num-in-endpoints = <2>; + num-out-endpoints = <1>; + num-isoin-endpoints = <0>; + num-isoout-endpoints = <0>; +}; diff --git a/inc/events/hid_led_event.h b/inc/events/hid_led_event.h new file mode 100644 index 0000000..bc30781 --- /dev/null +++ b/inc/events/hid_led_event.h @@ -0,0 +1,22 @@ +#ifndef BLINKY_HID_LED_EVENT_H_ +#define BLINKY_HID_LED_EVENT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct hid_led_event { + struct app_event_header header; + uint8_t led_bm; +}; + +APP_EVENT_TYPE_DECLARE(hid_led_event); + +#ifdef __cplusplus +} +#endif + +#endif /* BLINKY_HID_LED_EVENT_H_ */ diff --git a/inc/events/set_protocol_event.h b/inc/events/set_protocol_event.h new file mode 100644 index 0000000..60064af --- /dev/null +++ b/inc/events/set_protocol_event.h @@ -0,0 +1,24 @@ +#ifndef BLINKY_SET_PROTOCOL_EVENT_H_ +#define BLINKY_SET_PROTOCOL_EVENT_H_ + +#include +#include + +#include "keyboard_core.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct set_protocol_event { + struct app_event_header header; + enum keyboard_protocol_mode protocol_mode; +}; + +APP_EVENT_TYPE_DECLARE(set_protocol_event); + +#ifdef __cplusplus +} +#endif + +#endif /* BLINKY_SET_PROTOCOL_EVENT_H_ */ diff --git a/prj.conf b/prj.conf index 7462c2d..5884836 100644 --- a/prj.conf +++ b/prj.conf @@ -12,6 +12,10 @@ CONFIG_HEAP_MEM_POOL_SIZE=2048 CONFIG_LOG=y CONFIG_ASSERT=y +# USB HID next stack +CONFIG_USB_DEVICE_STACK_NEXT=y +CONFIG_USBD_HID_SUPPORT=y + # Power manager CONFIG_CAF_POWER_MANAGER=y CONFIG_CAF_POWER_MANAGER_TIMEOUT=120 diff --git a/src/battery_module.c b/src/battery_module.c index fbecbf8..ad9570f 100644 --- a/src/battery_module.c +++ b/src/battery_module.c @@ -84,8 +84,8 @@ static void battery_sample_fn(struct k_work *work) } voltage_mv = sensor_value_to_mv(&voltage); - LOG_INF("Battery: %d mV, charging=%d, full=%d", - voltage_mv, pmic_status.charging, pmic_status.full); + // LOG_INF("Battery: %d mV, charging=%d, full=%d", + // voltage_mv, pmic_status.charging, pmic_status.full); reschedule: if (running) { diff --git a/src/events/hid_led_event.c b/src/events/hid_led_event.c new file mode 100644 index 0000000..c30596a --- /dev/null +++ b/src/events/hid_led_event.c @@ -0,0 +1,27 @@ +#include "hid_led_event.h" + +static void log_hid_led_event(const struct app_event_header *aeh) +{ + const struct hid_led_event *event = cast_hid_led_event(aeh); + + APP_EVENT_MANAGER_LOG(aeh, "led_bm:0x%02x", event->led_bm); +} + +static void profile_hid_led_event(struct log_event_buf *buf, + const struct app_event_header *aeh) +{ + const struct hid_led_event *event = cast_hid_led_event(aeh); + + nrf_profiler_log_encode_uint8(buf, event->led_bm); +} + +APP_EVENT_INFO_DEFINE(hid_led_event, + ENCODE(NRF_PROFILER_ARG_U8), + ENCODE("led_bm"), + profile_hid_led_event); + +APP_EVENT_TYPE_DEFINE(hid_led_event, + log_hid_led_event, + &hid_led_event_info, + APP_EVENT_FLAGS_CREATE( + APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE)); diff --git a/src/events/set_protocol_event.c b/src/events/set_protocol_event.c new file mode 100644 index 0000000..fc1bfc5 --- /dev/null +++ b/src/events/set_protocol_event.c @@ -0,0 +1,40 @@ +#include "set_protocol_event.h" + +static const char *protocol_mode_name(enum keyboard_protocol_mode protocol_mode) +{ + switch (protocol_mode) { + case KEYBOARD_PROTOCOL_MODE_BOOT: + return "boot"; + case KEYBOARD_PROTOCOL_MODE_REPORT: + return "report"; + default: + return "?"; + } +} + +static void log_set_protocol_event(const struct app_event_header *aeh) +{ + const struct set_protocol_event *event = cast_set_protocol_event(aeh); + + APP_EVENT_MANAGER_LOG(aeh, "protocol:%s", + protocol_mode_name(event->protocol_mode)); +} + +static void profile_set_protocol_event(struct log_event_buf *buf, + const struct app_event_header *aeh) +{ + const struct set_protocol_event *event = cast_set_protocol_event(aeh); + + nrf_profiler_log_encode_uint8(buf, event->protocol_mode); +} + +APP_EVENT_INFO_DEFINE(set_protocol_event, + ENCODE(NRF_PROFILER_ARG_U8), + ENCODE("protocol_mode"), + profile_set_protocol_event); + +APP_EVENT_TYPE_DEFINE(set_protocol_event, + log_set_protocol_event, + &set_protocol_event_info, + APP_EVENT_FLAGS_CREATE( + APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE)); diff --git a/src/keyboard_core_module.c b/src/keyboard_core_module.c index 2529c3c..6eceace 100644 --- a/src/keyboard_core_module.c +++ b/src/keyboard_core_module.c @@ -17,6 +17,7 @@ #include "keyboard_core.h" #include "keyboard_hid_report_event.h" #include "mode_switch_event.h" +#include "set_protocol_event.h" LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF); @@ -66,7 +67,7 @@ static const struct keymap_entry keymap[] = { { KEY_ID(2, 2), KEY_USAGE_TYPE_KEYBOARD, 0x0061 }, /* keypad 9 */ { KEY_ID(2, 3), KEY_USAGE_TYPE_KEYBOARD, 0x005E }, /* keypad 6 */ { KEY_ID(2, 4), KEY_USAGE_TYPE_KEYBOARD, 0x005B }, /* keypad 3 */ - { KEY_ID(2, 5), KEY_USAGE_TYPE_KEYBOARD, 0x0058 }, /* keypad enter */ + { KEY_ID(3, 5), KEY_USAGE_TYPE_KEYBOARD, 0x0058 }, /* keypad enter */ { KEY_ID(3, 0), KEY_USAGE_TYPE_CONSUMER, KEYBOARD_CONSUMER_CTRL_MUTE }, { KEY_ID(3, 1), KEY_USAGE_TYPE_KEYBOARD, 0x0056 }, /* keypad - */ { KEY_ID(3, 3), KEY_USAGE_TYPE_KEYBOARD, 0x0057 }, /* keypad + */ @@ -421,6 +422,20 @@ static bool app_event_handler(const struct app_event_header *aeh) return handle_button_event(cast_button_event(aeh)); } + if (is_set_protocol_event(aeh)) { + const struct set_protocol_event *event = cast_set_protocol_event(aeh); + + if (protocol_mode != event->protocol_mode) { + protocol_mode = event->protocol_mode; + + if (running && mode_valid && (current_mode == MODE_SWITCH_USB)) { + emit_keys_report(true); + } + } + + return false; + } + if (is_mode_switch_event(aeh)) { return handle_mode_switch_event(cast_mode_switch_event(aeh)); } @@ -481,6 +496,7 @@ static bool app_event_handler(const struct app_event_header *aeh) APP_EVENT_LISTENER(MODULE, app_event_handler); APP_EVENT_SUBSCRIBE(MODULE, button_event); +APP_EVENT_SUBSCRIBE(MODULE, set_protocol_event); APP_EVENT_SUBSCRIBE(MODULE, mode_switch_event); APP_EVENT_SUBSCRIBE(MODULE, module_state_event); APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event); diff --git a/src/usb_hid_module.c b/src/usb_hid_module.c new file mode 100644 index 0000000..e9275df --- /dev/null +++ b/src/usb_hid_module.c @@ -0,0 +1,652 @@ +#include +#include +#include +#include + +#include + +#define MODULE usb_hid_module +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "hid_led_event.h" +#include "keyboard_core.h" +#include "keyboard_hid_report_event.h" +#include "set_protocol_event.h" + +LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF); + +#define USB_HID_VID 0x1915 +#define USB_HID_PID 0x52F0 +#define USB_HID_MANUFACTURER "blinky" +#define USB_HID_PRODUCT "Mini Keyboard" +#define USB_HID_POLLING_US 1000U + +#define KBD_LED_REPORT_SIZE 1U + +enum usb_hid_interface { + USB_HID_INTERFACE_KEYBOARD, + USB_HID_INTERFACE_CONSUMER, + USB_HID_INTERFACE_COUNT, +}; + +struct usb_hid_interface_state { + const struct device *dev; + bool ready; +}; + +static const uint8_t keyboard_report_desc[] = { + 0x05, 0x01, /* Usage Page (Generic Desktop) */ + 0x09, 0x06, /* Usage (Keyboard) */ + 0xA1, 0x01, /* Collection (Application) */ + 0x05, 0x07, /* Usage Page (Keyboard/Keypad) */ + 0x19, 0xE0, /* Usage Minimum (0xE0) */ + 0x29, 0xE7, /* Usage Maximum (0xE7) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x25, 0x01, /* Logical Maximum (1) */ + 0x75, 0x01, /* Report Size (1) */ + 0x95, 0x08, /* Report Count (8) */ + 0x81, 0x02, /* Input (Data,Var,Abs) */ + 0x05, 0x07, /* Usage Page (Keyboard/Keypad) */ + 0x19, 0x00, /* Usage Minimum (0x00) */ + 0x2A, 0xDF, 0x00, /* Usage Maximum (0x00DF) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x25, 0x01, /* Logical Maximum (1) */ + 0x75, 0x01, /* Report Size (1) */ + 0x96, 0xE0, 0x00, /* Report Count (224) */ + 0x81, 0x02, /* Input (Data,Var,Abs) */ + 0x05, 0x08, /* Usage Page (LEDs) */ + 0x19, 0x01, /* Usage Minimum (1) */ + 0x29, 0x05, /* Usage Maximum (5) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x25, 0x01, /* Logical Maximum (1) */ + 0x75, 0x01, /* Report Size (1) */ + 0x95, 0x05, /* Report Count (5) */ + 0x91, 0x02, /* Output (Data,Var,Abs) */ + 0x75, 0x03, /* Report Size (3) */ + 0x95, 0x01, /* Report Count (1) */ + 0x91, 0x01, /* Output (Const,Array,Abs) */ + 0xC0 /* End Collection */ +}; + +static const uint8_t consumer_report_desc[] = { + 0x05, 0x0C, /* Usage Page (Consumer) */ + 0x09, 0x01, /* Usage (Consumer Control) */ + 0xA1, 0x01, /* Collection (Application) */ + 0x15, 0x00, /* Logical Minimum (0) */ + 0x26, 0xFF, 0x03, /* Logical Maximum (1023) */ + 0x19, 0x00, /* Usage Minimum (0) */ + 0x2A, 0xFF, 0x03, /* Usage Maximum (1023) */ + 0x75, 0x10, /* Report Size (16) */ + 0x95, 0x01, /* Report Count (1) */ + 0x81, 0x00, /* Input (Data,Array,Abs) */ + 0xC0 /* End Collection */ +}; + +static struct usb_hid_interface_state hid_ifaces[USB_HID_INTERFACE_COUNT] = { + [USB_HID_INTERFACE_KEYBOARD] = { + .dev = DEVICE_DT_GET(DT_NODELABEL(hid_kbd)), + }, + [USB_HID_INTERFACE_CONSUMER] = { + .dev = DEVICE_DT_GET(DT_NODELABEL(hid_consumer)), + }, +}; + +static enum keyboard_protocol_mode keyboard_protocol_mode = + KEYBOARD_PROTOCOL_MODE_REPORT; +static bool initialized; +static bool running; +static bool usb_enabled; +static bool keyboard_report_in_flight; +static bool consumer_report_in_flight; + +UDC_STATIC_BUF_DEFINE(keyboard_tx_buf, KEYBOARD_NKRO_REPORT_SIZE); +UDC_STATIC_BUF_DEFINE(consumer_tx_buf, KEYBOARD_CONSUMER_REPORT_SIZE); + +USBD_DEVICE_DEFINE(blinky_usbd, DEVICE_DT_GET(DT_NODELABEL(usbd)), + USB_HID_VID, USB_HID_PID); + +USBD_DESC_LANG_DEFINE(blinky_lang); +USBD_DESC_MANUFACTURER_DEFINE(blinky_mfr, USB_HID_MANUFACTURER); +USBD_DESC_PRODUCT_DEFINE(blinky_product, USB_HID_PRODUCT); + +USBD_DESC_CONFIG_DEFINE(blinky_fs_cfg_desc, "FS Configuration"); +USBD_CONFIGURATION_DEFINE(blinky_fs_config, 0, 250, &blinky_fs_cfg_desc); + +static const char *const class_blocklist[] = { + NULL, +}; + +static struct usb_hid_interface_state *iface_from_dev(const struct device *dev) +{ + for (size_t i = 0; i < ARRAY_SIZE(hid_ifaces); i++) { + if (hid_ifaces[i].dev == dev) { + return &hid_ifaces[i]; + } + } + + return NULL; +} + +static enum keyboard_protocol_mode usb_proto_to_keyboard_proto(uint8_t proto) +{ + return (proto == HID_PROTOCOL_BOOT) ? KEYBOARD_PROTOCOL_MODE_BOOT + : KEYBOARD_PROTOCOL_MODE_REPORT; +} + +static void submit_set_protocol_event(enum keyboard_protocol_mode protocol_mode) +{ + struct set_protocol_event *event = new_set_protocol_event(); + + event->protocol_mode = protocol_mode; + APP_EVENT_SUBMIT(event); +} + +static void submit_hid_led_event(uint8_t led_bm) +{ + struct hid_led_event *event = new_hid_led_event(); + + event->led_bm = led_bm; + APP_EVENT_SUBMIT(event); +} + +static void keyboard_iface_ready(const struct device *dev, const bool ready) +{ + struct usb_hid_interface_state *iface = iface_from_dev(dev); + + if (!iface) { + return; + } + + iface->ready = ready; + if (!ready) { + keyboard_report_in_flight = false; + } + LOG_INF("%s interface %s", + dev->name, ready ? "ready" : "not ready"); +} + +static int keyboard_get_report(const struct device *dev, + const uint8_t type, const uint8_t id, + const uint16_t len, uint8_t *const buf) +{ + ARG_UNUSED(dev); + ARG_UNUSED(type); + ARG_UNUSED(id); + ARG_UNUSED(len); + ARG_UNUSED(buf); + + return -ENOTSUP; +} + +static int keyboard_set_report(const struct device *dev, + const uint8_t type, const uint8_t id, + const uint16_t len, const uint8_t *const buf) +{ + ARG_UNUSED(dev); + ARG_UNUSED(type); + ARG_UNUSED(id); + ARG_UNUSED(len); + ARG_UNUSED(buf); + + return -ENOTSUP; +} + +static void keyboard_set_idle(const struct device *dev, + const uint8_t id, const uint32_t duration) +{ + ARG_UNUSED(dev); + ARG_UNUSED(id); + ARG_UNUSED(duration); +} + +static uint32_t keyboard_get_idle(const struct device *dev, const uint8_t id) +{ + ARG_UNUSED(dev); + ARG_UNUSED(id); + + return 0U; +} + +static void keyboard_set_protocol(const struct device *dev, const uint8_t proto) +{ + ARG_UNUSED(dev); + + enum keyboard_protocol_mode new_mode = usb_proto_to_keyboard_proto(proto); + + if (keyboard_protocol_mode == new_mode) { + return; + } + + keyboard_protocol_mode = new_mode; + LOG_INF("USB keyboard protocol -> %s", + (new_mode == KEYBOARD_PROTOCOL_MODE_BOOT) ? "boot" : "report"); + submit_set_protocol_event(new_mode); +} + +static void keyboard_input_report_done(const struct device *dev, + const uint8_t *const report) +{ + ARG_UNUSED(report); + + keyboard_report_in_flight = false; + LOG_DBG("USB keyboard report sent by %s", dev->name); +} + +static void keyboard_output_report(const struct device *dev, + const uint16_t len, + const uint8_t *const buf) +{ + ARG_UNUSED(dev); + + if ((len < KBD_LED_REPORT_SIZE) || (buf == NULL)) { + LOG_WRN("Invalid keyboard output report"); + return; + } + + submit_hid_led_event(buf[0]); +} + +static const struct hid_device_ops keyboard_ops = { + .iface_ready = keyboard_iface_ready, + .get_report = keyboard_get_report, + .set_report = keyboard_set_report, + .set_idle = keyboard_set_idle, + .get_idle = keyboard_get_idle, + .set_protocol = keyboard_set_protocol, + .input_report_done = keyboard_input_report_done, + .output_report = keyboard_output_report, +}; + +static void consumer_iface_ready(const struct device *dev, const bool ready) +{ + struct usb_hid_interface_state *iface = iface_from_dev(dev); + + if (!iface) { + return; + } + + iface->ready = ready; + if (!ready) { + consumer_report_in_flight = false; + } + LOG_INF("%s interface %s", + dev->name, ready ? "ready" : "not ready"); +} + +static int consumer_get_report(const struct device *dev, + const uint8_t type, const uint8_t id, + const uint16_t len, uint8_t *const buf) +{ + ARG_UNUSED(dev); + ARG_UNUSED(type); + ARG_UNUSED(id); + ARG_UNUSED(len); + ARG_UNUSED(buf); + + return -ENOTSUP; +} + +static int consumer_set_report(const struct device *dev, + const uint8_t type, const uint8_t id, + const uint16_t len, const uint8_t *const buf) +{ + ARG_UNUSED(dev); + ARG_UNUSED(type); + ARG_UNUSED(id); + ARG_UNUSED(len); + ARG_UNUSED(buf); + + return -ENOTSUP; +} + +static void consumer_set_idle(const struct device *dev, + const uint8_t id, const uint32_t duration) +{ + ARG_UNUSED(dev); + ARG_UNUSED(id); + ARG_UNUSED(duration); +} + +static uint32_t consumer_get_idle(const struct device *dev, const uint8_t id) +{ + ARG_UNUSED(dev); + ARG_UNUSED(id); + + return 0U; +} + +static void consumer_set_protocol(const struct device *dev, const uint8_t proto) +{ + ARG_UNUSED(dev); + ARG_UNUSED(proto); +} + +static void consumer_input_report_done(const struct device *dev, + const uint8_t *const report) +{ + ARG_UNUSED(report); + + consumer_report_in_flight = false; + LOG_DBG("USB consumer report sent by %s", dev->name); +} + +static void consumer_output_report(const struct device *dev, + const uint16_t len, + const uint8_t *const buf) +{ + ARG_UNUSED(dev); + ARG_UNUSED(len); + ARG_UNUSED(buf); +} + +static const struct hid_device_ops consumer_ops = { + .iface_ready = consumer_iface_ready, + .get_report = consumer_get_report, + .set_report = consumer_set_report, + .set_idle = consumer_set_idle, + .get_idle = consumer_get_idle, + .set_protocol = consumer_set_protocol, + .input_report_done = consumer_input_report_done, + .output_report = consumer_output_report, +}; + +static void usbd_msg_cb(struct usbd_context *const usbd_ctx, + const struct usbd_msg *const msg) +{ + ARG_UNUSED(usbd_ctx); + + if (msg->type == USBD_MSG_VBUS_READY) { + if (!usb_enabled) { + int err = usbd_enable(&blinky_usbd); + + if (err) { + LOG_ERR("usbd_enable failed (%d)", err); + } else { + usb_enabled = true; + } + } + + return; + } + + if (msg->type == USBD_MSG_VBUS_REMOVED) { + if (usb_enabled) { + int err = usbd_disable(&blinky_usbd); + + if (err) { + LOG_ERR("usbd_disable failed (%d)", err); + } else { + usb_enabled = false; + for (size_t i = 0; i < ARRAY_SIZE(hid_ifaces); i++) { + hid_ifaces[i].ready = false; + } + keyboard_report_in_flight = false; + consumer_report_in_flight = false; + } + } + + return; + } +} + +static int usb_descriptors_init(void) +{ + int err; + + err = usbd_add_descriptor(&blinky_usbd, &blinky_lang); + if (err) { + return err; + } + + err = usbd_add_descriptor(&blinky_usbd, &blinky_mfr); + if (err) { + return err; + } + + err = usbd_add_descriptor(&blinky_usbd, &blinky_product); + if (err) { + return err; + } + + err = usbd_add_configuration(&blinky_usbd, USBD_SPEED_FS, &blinky_fs_config); + if (err) { + return err; + } + + err = usbd_register_all_classes(&blinky_usbd, USBD_SPEED_FS, 1, class_blocklist); + if (err) { + return err; + } + + usbd_device_set_code_triple(&blinky_usbd, USBD_SPEED_FS, 0, 0, 0); + + return 0; +} + +static int usb_hid_register_devices(void) +{ + int err; + + for (size_t i = 0; i < ARRAY_SIZE(hid_ifaces); i++) { + if (!device_is_ready(hid_ifaces[i].dev)) { + LOG_ERR("HID device %s not ready", hid_ifaces[i].dev->name); + return -ENODEV; + } + } + + err = hid_device_register(hid_ifaces[USB_HID_INTERFACE_KEYBOARD].dev, + keyboard_report_desc, + sizeof(keyboard_report_desc), + &keyboard_ops); + if (err) { + return err; + } + + err = hid_device_register(hid_ifaces[USB_HID_INTERFACE_CONSUMER].dev, + consumer_report_desc, + sizeof(consumer_report_desc), + &consumer_ops); + if (err) { + return err; + } + + return 0; +} + +static int module_init(void) +{ + int err; + + err = usb_hid_register_devices(); + if (err) { + LOG_ERR("hid_device_register failed (%d)", err); + return err; + } + + err = usbd_msg_register_cb(&blinky_usbd, usbd_msg_cb); + if (err) { + LOG_ERR("usbd_msg_register_cb failed (%d)", err); + return err; + } + + err = usb_descriptors_init(); + if (err) { + LOG_ERR("usb descriptor init failed (%d)", err); + return err; + } + + err = usbd_init(&blinky_usbd); + if (err) { + LOG_ERR("usbd_init failed (%d)", err); + return err; + } + + if (!usbd_can_detect_vbus(&blinky_usbd)) { + err = usbd_enable(&blinky_usbd); + if (err) { + LOG_ERR("usbd_enable failed (%d)", err); + return err; + } + + usb_enabled = true; + } + + return 0; +} + +static int module_start(void) +{ + if (running) { + return 0; + } + + running = true; + return 0; +} + +static void module_pause(void) +{ + running = false; +} + +static bool handle_keyboard_hid_report_event(const struct keyboard_hid_report_event *event) +{ + int err; + + if (!running || (event->mode != MODE_SWITCH_USB)) { + return false; + } + + if (event->report_type == KEYBOARD_REPORT_TYPE_KEYS) { + if (event->protocol_mode != keyboard_protocol_mode) { + LOG_WRN("Drop USB keys report due to protocol mismatch"); + return false; + } + + if (!hid_ifaces[USB_HID_INTERFACE_KEYBOARD].ready) { + LOG_DBG("USB keyboard interface not ready"); + return false; + } + + if (keyboard_report_in_flight) { + LOG_WRN("Drop USB keyboard report while previous report is in flight"); + return false; + } + + memcpy(keyboard_tx_buf, event->dyndata.data, event->dyndata.size); + + err = hid_device_submit_report( + hid_ifaces[USB_HID_INTERFACE_KEYBOARD].dev, + (uint16_t)event->dyndata.size, + keyboard_tx_buf); + if (err) { + LOG_WRN("USB keyboard report submit failed (%d)", err); + } else { + keyboard_report_in_flight = true; + } + + return false; + } + + if (event->report_type == KEYBOARD_REPORT_TYPE_CONSUMER) { + if (!hid_ifaces[USB_HID_INTERFACE_CONSUMER].ready) { + LOG_DBG("USB consumer interface not ready"); + return false; + } + + if (consumer_report_in_flight) { + LOG_WRN("Drop USB consumer report while previous report is in flight"); + return false; + } + + memcpy(consumer_tx_buf, event->dyndata.data, event->dyndata.size); + + err = hid_device_submit_report( + hid_ifaces[USB_HID_INTERFACE_CONSUMER].dev, + (uint16_t)event->dyndata.size, + consumer_tx_buf); + if (err) { + LOG_WRN("USB consumer report submit failed (%d)", err); + } else { + consumer_report_in_flight = true; + } + } + + return false; +} + +static bool app_event_handler(const struct app_event_header *aeh) +{ + if (is_keyboard_hid_report_event(aeh)) { + return handle_keyboard_hid_report_event( + cast_keyboard_hid_report_event(aeh)); + } + + if (is_module_state_event(aeh)) { + const struct module_state_event *event = cast_module_state_event(aeh); + + if (check_state(event, MODULE_ID(main), MODULE_STATE_READY)) { + int err; + + if (!initialized) { + err = module_init(); + if (err) { + module_set_state(MODULE_STATE_ERROR); + return false; + } + + initialized = true; + } + + err = module_start(); + if (err) { + module_set_state(MODULE_STATE_ERROR); + } else { + module_set_state(MODULE_STATE_READY); + } + } + + return false; + } + + if (is_power_down_event(aeh)) { + if (initialized) { + module_pause(); + module_set_state(MODULE_STATE_STANDBY); + } + + return false; + } + + if (is_wake_up_event(aeh)) { + if (initialized) { + int err = module_start(); + + if (err) { + module_set_state(MODULE_STATE_ERROR); + } else { + module_set_state(MODULE_STATE_READY); + } + } + + return false; + } + + __ASSERT_NO_MSG(false); + return false; +} + +APP_EVENT_LISTENER(MODULE, app_event_handler); +APP_EVENT_SUBSCRIBE(MODULE, module_state_event); +APP_EVENT_SUBSCRIBE(MODULE, keyboard_hid_report_event); +APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event); +APP_EVENT_SUBSCRIBE(MODULE, wake_up_event);