- /*
- * (c) 2015 flabberast <s3+flabbergast@sdfeu.org>
- *
- * Based on the following work:
- * - Guillaume Duc's raw hid example (MIT License)
- * https://github.com/guiduc/usb-hid-chibios-example
- * - PJRC Teensy examples (MIT License)
- * https://www.pjrc.com/teensy/usb_keyboard.html
- * - hasu's TMK keyboard code (GPL v2 and some code Modified BSD)
- * https://github.com/tmk/tmk_keyboard/
- * - ChibiOS demo code (Apache 2.0 License)
- * http://www.chibios.org
- *
- * Since some GPL'd code is used, this work is licensed under
- * GPL v2 or later.
- */
-
- /*
- * Implementation notes:
- *
- * USBEndpointConfig - Configured using explicit order instead of struct member name.
- * This is due to ChibiOS hal LLD differences, which is dependent on hardware,
- * "USBv1" devices have `ep_buffers` and "OTGv1" have `in_multiplier`.
- * Given `USBv1/hal_usb_lld.h` marks the field as "not currently used" this code file
- * makes the assumption this is safe to avoid littering with preprocessor directives.
- */
-
- #include <ch.h>
- #include <hal.h>
- #include <string.h>
-
- #include "usb_main.h"
-
- #include "host.h"
- #include "debug.h"
- #include "suspend.h"
- #ifdef SLEEP_LED_ENABLE
- # include "sleep_led.h"
- # include "led.h"
- #endif
- #include "wait.h"
- #include "usb_descriptor.h"
- #include "usb_driver.h"
-
- #ifdef NKRO_ENABLE
- # include "keycode_config.h"
-
- extern keymap_config_t keymap_config;
- #endif
-
- #ifdef JOYSTICK_ENABLE
- # include "joystick.h"
- #endif
-
- /* ---------------------------------------------------------
- * Global interface variables and declarations
- * ---------------------------------------------------------
- */
-
- #ifndef usb_lld_connect_bus
- # define usb_lld_connect_bus(usbp)
- #endif
-
- #ifndef usb_lld_disconnect_bus
- # define usb_lld_disconnect_bus(usbp)
- #endif
-
- uint8_t keyboard_idle __attribute__((aligned(2))) = 0;
- uint8_t keyboard_protocol __attribute__((aligned(2))) = 1;
- uint8_t keyboard_led_state = 0;
- volatile uint16_t keyboard_idle_count = 0;
- static virtual_timer_t keyboard_idle_timer;
- static void keyboard_idle_timer_cb(void *arg);
-
- report_keyboard_t keyboard_report_sent = {{0}};
- #ifdef MOUSE_ENABLE
- report_mouse_t mouse_report_blank = {0};
- #endif /* MOUSE_ENABLE */
- #ifdef EXTRAKEY_ENABLE
- uint8_t extra_report_blank[3] = {0};
- #endif /* EXTRAKEY_ENABLE */
-
- /* ---------------------------------------------------------
- * Descriptors and USB driver objects
- * ---------------------------------------------------------
- */
-
- /* HID specific constants */
- #define HID_GET_REPORT 0x01
- #define HID_GET_IDLE 0x02
- #define HID_GET_PROTOCOL 0x03
- #define HID_SET_REPORT 0x09
- #define HID_SET_IDLE 0x0A
- #define HID_SET_PROTOCOL 0x0B
-
- /*
- * Handles the GET_DESCRIPTOR callback
- *
- * Returns the proper descriptor
- */
- static const USBDescriptor *usb_get_descriptor_cb(USBDriver *usbp, uint8_t dtype, uint8_t dindex, uint16_t wIndex) {
- (void)usbp;
- static USBDescriptor desc;
- uint16_t wValue = ((uint16_t)dtype << 8) | dindex;
- desc.ud_string = NULL;
- desc.ud_size = get_usb_descriptor(wValue, wIndex, (const void **const) & desc.ud_string);
- if (desc.ud_string == NULL)
- return NULL;
- else
- return &desc;
- }
-
- #ifndef KEYBOARD_SHARED_EP
- /* keyboard endpoint state structure */
- static USBInEndpointState kbd_ep_state;
- /* keyboard endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */
- static const USBEndpointConfig kbd_ep_config = {
- USB_EP_MODE_TYPE_INTR, /* Interrupt EP */
- NULL, /* SETUP packet notification callback */
- kbd_in_cb, /* IN notification callback */
- NULL, /* OUT notification callback */
- KEYBOARD_EPSIZE, /* IN maximum packet size */
- 0, /* OUT maximum packet size */
- &kbd_ep_state, /* IN Endpoint state */
- NULL, /* OUT endpoint state */
- 2, /* IN multiplier */
- NULL /* SETUP buffer (not a SETUP endpoint) */
- };
- #endif
-
- #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
- /* mouse endpoint state structure */
- static USBInEndpointState mouse_ep_state;
-
- /* mouse endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */
- static const USBEndpointConfig mouse_ep_config = {
- USB_EP_MODE_TYPE_INTR, /* Interrupt EP */
- NULL, /* SETUP packet notification callback */
- mouse_in_cb, /* IN notification callback */
- NULL, /* OUT notification callback */
- MOUSE_EPSIZE, /* IN maximum packet size */
- 0, /* OUT maximum packet size */
- &mouse_ep_state, /* IN Endpoint state */
- NULL, /* OUT endpoint state */
- 2, /* IN multiplier */
- NULL /* SETUP buffer (not a SETUP endpoint) */
- };
- #endif
-
- #ifdef SHARED_EP_ENABLE
- /* shared endpoint state structure */
- static USBInEndpointState shared_ep_state;
-
- /* shared endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */
- static const USBEndpointConfig shared_ep_config = {
- USB_EP_MODE_TYPE_INTR, /* Interrupt EP */
- NULL, /* SETUP packet notification callback */
- shared_in_cb, /* IN notification callback */
- NULL, /* OUT notification callback */
- SHARED_EPSIZE, /* IN maximum packet size */
- 0, /* OUT maximum packet size */
- &shared_ep_state, /* IN Endpoint state */
- NULL, /* OUT endpoint state */
- 2, /* IN multiplier */
- NULL /* SETUP buffer (not a SETUP endpoint) */
- };
- #endif
-
- #if STM32_USB_USE_OTG1
- typedef struct {
- size_t queue_capacity_in;
- size_t queue_capacity_out;
- USBInEndpointState in_ep_state;
- USBOutEndpointState out_ep_state;
- USBInEndpointState int_ep_state;
- USBEndpointConfig inout_ep_config;
- USBEndpointConfig int_ep_config;
- const QMKUSBConfig config;
- QMKUSBDriver driver;
- } usb_driver_config_t;
- #else
- typedef struct {
- size_t queue_capacity_in;
- size_t queue_capacity_out;
- USBInEndpointState in_ep_state;
- USBOutEndpointState out_ep_state;
- USBInEndpointState int_ep_state;
- USBEndpointConfig in_ep_config;
- USBEndpointConfig out_ep_config;
- USBEndpointConfig int_ep_config;
- const QMKUSBConfig config;
- QMKUSBDriver driver;
- } usb_driver_config_t;
- #endif
-
- #if STM32_USB_USE_OTG1
- /* Reusable initialization structure - see USBEndpointConfig comment at top of file */
- # define QMK_USB_DRIVER_CONFIG(stream, notification, fixedsize) \
- { \
- .queue_capacity_in = stream##_IN_CAPACITY, .queue_capacity_out = stream##_OUT_CAPACITY, \
- .inout_ep_config = \
- { \
- stream##_IN_MODE, /* Interrupt EP */ \
- NULL, /* SETUP packet notification callback */ \
- qmkusbDataTransmitted, /* IN notification callback */ \
- qmkusbDataReceived, /* OUT notification callback */ \
- stream##_EPSIZE, /* IN maximum packet size */ \
- stream##_EPSIZE, /* OUT maximum packet size */ \
- NULL, /* IN Endpoint state */ \
- NULL, /* OUT endpoint state */ \
- 2, /* IN multiplier */ \
- NULL /* SETUP buffer (not a SETUP endpoint) */ \
- }, \
- .int_ep_config = \
- { \
- USB_EP_MODE_TYPE_INTR, /* Interrupt EP */ \
- NULL, /* SETUP packet notification callback */ \
- qmkusbInterruptTransmitted, /* IN notification callback */ \
- NULL, /* OUT notification callback */ \
- CDC_NOTIFICATION_EPSIZE, /* IN maximum packet size */ \
- 0, /* OUT maximum packet size */ \
- NULL, /* IN Endpoint state */ \
- NULL, /* OUT endpoint state */ \
- 2, /* IN multiplier */ \
- NULL, /* SETUP buffer (not a SETUP endpoint) */ \
- }, \
- .config = { \
- .usbp = &USB_DRIVER, \
- .bulk_in = stream##_IN_EPNUM, \
- .bulk_out = stream##_OUT_EPNUM, \
- .int_in = notification, \
- .in_buffers = stream##_IN_CAPACITY, \
- .out_buffers = stream##_OUT_CAPACITY, \
- .in_size = stream##_EPSIZE, \
- .out_size = stream##_EPSIZE, \
- .fixed_size = fixedsize, \
- .ib = (__attribute__((aligned(4))) uint8_t[BQ_BUFFER_SIZE(stream##_IN_CAPACITY, stream##_EPSIZE)]){}, \
- .ob = (__attribute__((aligned(4))) uint8_t[BQ_BUFFER_SIZE(stream##_OUT_CAPACITY, stream##_EPSIZE)]){}, \
- } \
- }
- #else
- /* Reusable initialization structure - see USBEndpointConfig comment at top of file */
- # define QMK_USB_DRIVER_CONFIG(stream, notification, fixedsize) \
- { \
- .queue_capacity_in = stream##_IN_CAPACITY, .queue_capacity_out = stream##_OUT_CAPACITY, \
- .in_ep_config = \
- { \
- stream##_IN_MODE, /* Interrupt EP */ \
- NULL, /* SETUP packet notification callback */ \
- qmkusbDataTransmitted, /* IN notification callback */ \
- NULL, /* OUT notification callback */ \
- stream##_EPSIZE, /* IN maximum packet size */ \
- 0, /* OUT maximum packet size */ \
- NULL, /* IN Endpoint state */ \
- NULL, /* OUT endpoint state */ \
- 2, /* IN multiplier */ \
- NULL /* SETUP buffer (not a SETUP endpoint) */ \
- }, \
- .out_ep_config = \
- { \
- stream##_OUT_MODE, /* Interrupt EP */ \
- NULL, /* SETUP packet notification callback */ \
- NULL, /* IN notification callback */ \
- qmkusbDataReceived, /* OUT notification callback */ \
- 0, /* IN maximum packet size */ \
- stream##_EPSIZE, /* OUT maximum packet size */ \
- NULL, /* IN Endpoint state */ \
- NULL, /* OUT endpoint state */ \
- 2, /* IN multiplier */ \
- NULL, /* SETUP buffer (not a SETUP endpoint) */ \
- }, \
- .int_ep_config = \
- { \
- USB_EP_MODE_TYPE_INTR, /* Interrupt EP */ \
- NULL, /* SETUP packet notification callback */ \
- qmkusbInterruptTransmitted, /* IN notification callback */ \
- NULL, /* OUT notification callback */ \
- CDC_NOTIFICATION_EPSIZE, /* IN maximum packet size */ \
- 0, /* OUT maximum packet size */ \
- NULL, /* IN Endpoint state */ \
- NULL, /* OUT endpoint state */ \
- 2, /* IN multiplier */ \
- NULL, /* SETUP buffer (not a SETUP endpoint) */ \
- }, \
- .config = { \
- .usbp = &USB_DRIVER, \
- .bulk_in = stream##_IN_EPNUM, \
- .bulk_out = stream##_OUT_EPNUM, \
- .int_in = notification, \
- .in_buffers = stream##_IN_CAPACITY, \
- .out_buffers = stream##_OUT_CAPACITY, \
- .in_size = stream##_EPSIZE, \
- .out_size = stream##_EPSIZE, \
- .fixed_size = fixedsize, \
- .ib = (__attribute__((aligned(4))) uint8_t[BQ_BUFFER_SIZE(stream##_IN_CAPACITY, stream##_EPSIZE)]){}, \
- .ob = (__attribute__((aligned(4))) uint8_t[BQ_BUFFER_SIZE(stream##_OUT_CAPACITY, stream##_EPSIZE)]){}, \
- } \
- }
- #endif
-
- typedef struct {
- union {
- struct {
- #ifdef CONSOLE_ENABLE
- usb_driver_config_t console_driver;
- #endif
- #ifdef RAW_ENABLE
- usb_driver_config_t raw_driver;
- #endif
- #ifdef MIDI_ENABLE
- usb_driver_config_t midi_driver;
- #endif
- #ifdef VIRTSER_ENABLE
- usb_driver_config_t serial_driver;
- #endif
- #ifdef JOYSTICK_ENABLE
- usb_driver_config_t joystick_driver;
- #endif
- #if defined(DIGITIZER_ENABLE) && !defined(DIGITIZER_SHARED_EP)
- usb_driver_config_t digitizer_driver;
- #endif
- };
- usb_driver_config_t array[0];
- };
- } usb_driver_configs_t;
-
- static usb_driver_configs_t drivers = {
- #ifdef CONSOLE_ENABLE
- # define CONSOLE_IN_CAPACITY 4
- # define CONSOLE_OUT_CAPACITY 4
- # define CONSOLE_IN_MODE USB_EP_MODE_TYPE_INTR
- # define CONSOLE_OUT_MODE USB_EP_MODE_TYPE_INTR
- .console_driver = QMK_USB_DRIVER_CONFIG(CONSOLE, 0, true),
- #endif
- #ifdef RAW_ENABLE
- # define RAW_IN_CAPACITY 4
- # define RAW_OUT_CAPACITY 4
- # define RAW_IN_MODE USB_EP_MODE_TYPE_INTR
- # define RAW_OUT_MODE USB_EP_MODE_TYPE_INTR
- .raw_driver = QMK_USB_DRIVER_CONFIG(RAW, 0, false),
- #endif
-
- #ifdef MIDI_ENABLE
- # define MIDI_STREAM_IN_CAPACITY 4
- # define MIDI_STREAM_OUT_CAPACITY 4
- # define MIDI_STREAM_IN_MODE USB_EP_MODE_TYPE_BULK
- # define MIDI_STREAM_OUT_MODE USB_EP_MODE_TYPE_BULK
- .midi_driver = QMK_USB_DRIVER_CONFIG(MIDI_STREAM, 0, false),
- #endif
-
- #ifdef VIRTSER_ENABLE
- # define CDC_IN_CAPACITY 4
- # define CDC_OUT_CAPACITY 4
- # define CDC_IN_MODE USB_EP_MODE_TYPE_BULK
- # define CDC_OUT_MODE USB_EP_MODE_TYPE_BULK
- .serial_driver = QMK_USB_DRIVER_CONFIG(CDC, CDC_NOTIFICATION_EPNUM, false),
- #endif
-
- #ifdef JOYSTICK_ENABLE
- # define JOYSTICK_IN_CAPACITY 4
- # define JOYSTICK_OUT_CAPACITY 4
- # define JOYSTICK_IN_MODE USB_EP_MODE_TYPE_BULK
- # define JOYSTICK_OUT_MODE USB_EP_MODE_TYPE_BULK
- .joystick_driver = QMK_USB_DRIVER_CONFIG(JOYSTICK, 0, false),
- #endif
-
- #if defined(DIGITIZER_ENABLE) && !defined(DIGITIZER_SHARED_EP)
- # define DIGITIZER_IN_CAPACITY 4
- # define DIGITIZER_OUT_CAPACITY 4
- # define DIGITIZER_IN_MODE USB_EP_MODE_TYPE_BULK
- # define DIGITIZER_OUT_MODE USB_EP_MODE_TYPE_BULK
- .digitizer_driver = QMK_USB_DRIVER_CONFIG(DIGITIZER, 0, false),
- #endif
- };
-
- #define NUM_USB_DRIVERS (sizeof(drivers) / sizeof(usb_driver_config_t))
-
- /* ---------------------------------------------------------
- * USB driver functions
- * ---------------------------------------------------------
- */
-
- #define USB_EVENT_QUEUE_SIZE 16
- usbevent_t event_queue[USB_EVENT_QUEUE_SIZE];
- uint8_t event_queue_head;
- uint8_t event_queue_tail;
-
- void usb_event_queue_init(void) {
- // Initialise the event queue
- memset(&event_queue, 0, sizeof(event_queue));
- event_queue_head = 0;
- event_queue_tail = 0;
- }
-
- static inline bool usb_event_queue_enqueue(usbevent_t event) {
- uint8_t next = (event_queue_head + 1) % USB_EVENT_QUEUE_SIZE;
- if (next == event_queue_tail) {
- return false;
- }
- event_queue[event_queue_head] = event;
- event_queue_head = next;
- return true;
- }
-
- static inline bool usb_event_queue_dequeue(usbevent_t *event) {
- if (event_queue_head == event_queue_tail) {
- return false;
- }
- *event = event_queue[event_queue_tail];
- event_queue_tail = (event_queue_tail + 1) % USB_EVENT_QUEUE_SIZE;
- return true;
- }
-
- static inline void usb_event_suspend_handler(void) {
- #ifdef SLEEP_LED_ENABLE
- sleep_led_enable();
- #endif /* SLEEP_LED_ENABLE */
- }
-
- static inline void usb_event_wakeup_handler(void) {
- suspend_wakeup_init();
- #ifdef SLEEP_LED_ENABLE
- sleep_led_disable();
- // NOTE: converters may not accept this
- led_set(host_keyboard_leds());
- #endif /* SLEEP_LED_ENABLE */
- }
-
- bool last_suspend_state = false;
-
- void usb_event_queue_task(void) {
- usbevent_t event;
- while (usb_event_queue_dequeue(&event)) {
- switch (event) {
- case USB_EVENT_SUSPEND:
- last_suspend_state = true;
- usb_event_suspend_handler();
- break;
- case USB_EVENT_WAKEUP:
- last_suspend_state = false;
- usb_event_wakeup_handler();
- break;
- default:
- // Nothing to do, we don't handle it.
- break;
- }
- }
- }
-
- /* Handles the USB driver global events
- * TODO: maybe disable some things when connection is lost? */
- static void usb_event_cb(USBDriver *usbp, usbevent_t event) {
- switch (event) {
- case USB_EVENT_ADDRESS:
- return;
-
- case USB_EVENT_CONFIGURED:
- osalSysLockFromISR();
- /* Enable the endpoints specified into the configuration. */
- #ifndef KEYBOARD_SHARED_EP
- usbInitEndpointI(usbp, KEYBOARD_IN_EPNUM, &kbd_ep_config);
- #endif
- #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
- usbInitEndpointI(usbp, MOUSE_IN_EPNUM, &mouse_ep_config);
- #endif
- #ifdef SHARED_EP_ENABLE
- usbInitEndpointI(usbp, SHARED_IN_EPNUM, &shared_ep_config);
- #endif
- for (int i = 0; i < NUM_USB_DRIVERS; i++) {
- #if STM32_USB_USE_OTG1
- usbInitEndpointI(usbp, drivers.array[i].config.bulk_in, &drivers.array[i].inout_ep_config);
- #else
- usbInitEndpointI(usbp, drivers.array[i].config.bulk_in, &drivers.array[i].in_ep_config);
- usbInitEndpointI(usbp, drivers.array[i].config.bulk_out, &drivers.array[i].out_ep_config);
- #endif
- if (drivers.array[i].config.int_in) {
- usbInitEndpointI(usbp, drivers.array[i].config.int_in, &drivers.array[i].int_ep_config);
- }
- qmkusbConfigureHookI(&drivers.array[i].driver);
- }
- osalSysUnlockFromISR();
- if (last_suspend_state) {
- usb_event_queue_enqueue(USB_EVENT_WAKEUP);
- }
- return;
- case USB_EVENT_SUSPEND:
- usb_event_queue_enqueue(USB_EVENT_SUSPEND);
- /* Falls into.*/
- case USB_EVENT_UNCONFIGURED:
- /* Falls into.*/
- case USB_EVENT_RESET:
- for (int i = 0; i < NUM_USB_DRIVERS; i++) {
- chSysLockFromISR();
- /* Disconnection event on suspend.*/
- qmkusbSuspendHookI(&drivers.array[i].driver);
- chSysUnlockFromISR();
- }
- return;
-
- case USB_EVENT_WAKEUP:
- // TODO: from ISR! print("[W]");
- for (int i = 0; i < NUM_USB_DRIVERS; i++) {
- chSysLockFromISR();
- /* Disconnection event on suspend.*/
- qmkusbWakeupHookI(&drivers.array[i].driver);
- chSysUnlockFromISR();
- }
- usb_event_queue_enqueue(USB_EVENT_WAKEUP);
- return;
-
- case USB_EVENT_STALLED:
- return;
- }
- }
-
- /* Function used locally in os/hal/src/usb.c for getting descriptors
- * need it here for HID descriptor */
- static uint16_t get_hword(uint8_t *p) {
- uint16_t hw;
-
- hw = (uint16_t)*p++;
- hw |= (uint16_t)*p << 8U;
- return hw;
- }
-
- /*
- * Appendix G: HID Request Support Requirements
- *
- * The following table enumerates the requests that need to be supported by various types of HID class devices.
- * Device type GetReport SetReport GetIdle SetIdle GetProtocol SetProtocol
- * ------------------------------------------------------------------------------------------
- * Boot Mouse Required Optional Optional Optional Required Required
- * Non-Boot Mouse Required Optional Optional Optional Optional Optional
- * Boot Keyboard Required Optional Required Required Required Required
- * Non-Boot Keybrd Required Optional Required Required Optional Optional
- * Other Device Required Optional Optional Optional Optional Optional
- */
-
- static uint8_t set_report_buf[2] __attribute__((aligned(4)));
- static void set_led_transfer_cb(USBDriver *usbp) {
- if (usbp->setup[6] == 2) { /* LSB(wLength) */
- uint8_t report_id = set_report_buf[0];
- if ((report_id == REPORT_ID_KEYBOARD) || (report_id == REPORT_ID_NKRO)) {
- keyboard_led_state = set_report_buf[1];
- }
- } else {
- keyboard_led_state = set_report_buf[0];
- }
- }
-
- /* Callback for SETUP request on the endpoint 0 (control) */
- static bool usb_request_hook_cb(USBDriver *usbp) {
- const USBDescriptor *dp;
-
- /* usbp->setup fields:
- * 0: bmRequestType (bitmask)
- * 1: bRequest
- * 2,3: (LSB,MSB) wValue
- * 4,5: (LSB,MSB) wIndex
- * 6,7: (LSB,MSB) wLength (number of bytes to transfer if there is a data phase) */
-
- /* Handle HID class specific requests */
- if (((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) && ((usbp->setup[0] & USB_RTYPE_RECIPIENT_MASK) == USB_RTYPE_RECIPIENT_INTERFACE)) {
- switch (usbp->setup[0] & USB_RTYPE_DIR_MASK) {
- case USB_RTYPE_DIR_DEV2HOST:
- switch (usbp->setup[1]) { /* bRequest */
- case HID_GET_REPORT:
- switch (usbp->setup[4]) { /* LSB(wIndex) (check MSB==0?) */
- case KEYBOARD_INTERFACE:
- usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, sizeof(keyboard_report_sent), NULL);
- return TRUE;
- break;
-
- #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
- case MOUSE_INTERFACE:
- usbSetupTransfer(usbp, (uint8_t *)&mouse_report_blank, sizeof(mouse_report_blank), NULL);
- return TRUE;
- break;
- #endif
-
- default:
- usbSetupTransfer(usbp, NULL, 0, NULL);
- return TRUE;
- break;
- }
- break;
-
- case HID_GET_PROTOCOL:
- if ((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */
- usbSetupTransfer(usbp, &keyboard_protocol, 1, NULL);
- return TRUE;
- }
- break;
-
- case HID_GET_IDLE:
- usbSetupTransfer(usbp, &keyboard_idle, 1, NULL);
- return TRUE;
- break;
- }
- break;
-
- case USB_RTYPE_DIR_HOST2DEV:
- switch (usbp->setup[1]) { /* bRequest */
- case HID_SET_REPORT:
- switch (usbp->setup[4]) { /* LSB(wIndex) (check MSB==0?) */
- case KEYBOARD_INTERFACE:
- #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
- case SHARED_INTERFACE:
- #endif
- usbSetupTransfer(usbp, set_report_buf, sizeof(set_report_buf), set_led_transfer_cb);
- return TRUE;
- break;
- }
- break;
-
- case HID_SET_PROTOCOL:
- if ((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */
- keyboard_protocol = ((usbp->setup[2]) != 0x00); /* LSB(wValue) */
- #ifdef NKRO_ENABLE
- keymap_config.nkro = !!keyboard_protocol;
- if (!keymap_config.nkro && keyboard_idle) {
- #else /* NKRO_ENABLE */
- if (keyboard_idle) {
- #endif /* NKRO_ENABLE */
- /* arm the idle timer if boot protocol & idle */
- osalSysLockFromISR();
- chVTSetI(&keyboard_idle_timer, 4 * TIME_MS2I(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
- osalSysUnlockFromISR();
- }
- }
- usbSetupTransfer(usbp, NULL, 0, NULL);
- return TRUE;
- break;
-
- case HID_SET_IDLE:
- keyboard_idle = usbp->setup[3]; /* MSB(wValue) */
- /* arm the timer */
- #ifdef NKRO_ENABLE
- if (!keymap_config.nkro && keyboard_idle) {
- #else /* NKRO_ENABLE */
- if (keyboard_idle) {
- #endif /* NKRO_ENABLE */
- osalSysLockFromISR();
- chVTSetI(&keyboard_idle_timer, 4 * TIME_MS2I(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
- osalSysUnlockFromISR();
- }
- usbSetupTransfer(usbp, NULL, 0, NULL);
- return TRUE;
- break;
- }
- break;
- }
- }
-
- /* Handle the Get_Descriptor Request for HID class (not handled by the default hook) */
- if ((usbp->setup[0] == 0x81) && (usbp->setup[1] == USB_REQ_GET_DESCRIPTOR)) {
- dp = usbp->config->get_descriptor_cb(usbp, usbp->setup[3], usbp->setup[2], get_hword(&usbp->setup[4]));
- if (dp == NULL) return FALSE;
- usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size, NULL);
- return TRUE;
- }
-
- for (int i = 0; i < NUM_USB_DRIVERS; i++) {
- if (drivers.array[i].config.int_in) {
- // NOTE: Assumes that we only have one serial driver
- return qmkusbRequestsHook(usbp);
- }
- }
-
- return FALSE;
- }
-
- /* Start-of-frame callback */
- static void usb_sof_cb(USBDriver *usbp) {
- kbd_sof_cb(usbp);
- osalSysLockFromISR();
- for (int i = 0; i < NUM_USB_DRIVERS; i++) {
- qmkusbSOFHookI(&drivers.array[i].driver);
- }
- osalSysUnlockFromISR();
- }
-
- /* USB driver configuration */
- static const USBConfig usbcfg = {
- usb_event_cb, /* USB events callback */
- usb_get_descriptor_cb, /* Device GET_DESCRIPTOR request callback */
- usb_request_hook_cb, /* Requests hook callback */
- usb_sof_cb /* Start Of Frame callback */
- };
-
- /*
- * Initialize the USB driver
- */
- void init_usb_driver(USBDriver *usbp) {
- for (int i = 0; i < NUM_USB_DRIVERS; i++) {
- #if STM32_USB_USE_OTG1
- QMKUSBDriver *driver = &drivers.array[i].driver;
- drivers.array[i].inout_ep_config.in_state = &drivers.array[i].in_ep_state;
- drivers.array[i].inout_ep_config.out_state = &drivers.array[i].out_ep_state;
- drivers.array[i].int_ep_config.in_state = &drivers.array[i].int_ep_state;
- qmkusbObjectInit(driver, &drivers.array[i].config);
- qmkusbStart(driver, &drivers.array[i].config);
- #else
- QMKUSBDriver *driver = &drivers.array[i].driver;
- drivers.array[i].in_ep_config.in_state = &drivers.array[i].in_ep_state;
- drivers.array[i].out_ep_config.out_state = &drivers.array[i].out_ep_state;
- drivers.array[i].int_ep_config.in_state = &drivers.array[i].int_ep_state;
- qmkusbObjectInit(driver, &drivers.array[i].config);
- qmkusbStart(driver, &drivers.array[i].config);
- #endif
- }
-
- /*
- * Activates the USB driver and then the USB bus pull-up on D+.
- * Note, a delay is inserted in order to not have to disconnect the cable
- * after a reset.
- */
- usbDisconnectBus(usbp);
- wait_ms(1500);
- usbStart(usbp, &usbcfg);
- usbConnectBus(usbp);
-
- chVTObjectInit(&keyboard_idle_timer);
- }
-
- __attribute__((weak)) void restart_usb_driver(USBDriver *usbp) {
- usbStop(usbp);
- usbDisconnectBus(usbp);
-
- #if USB_SUSPEND_WAKEUP_DELAY > 0
- // Some hubs, kvm switches, and monitors do
- // weird things, with USB device state bouncing
- // around wildly on wakeup, yielding race
- // conditions that can corrupt the keyboard state.
- //
- // Pause for a while to let things settle...
- wait_ms(USB_SUSPEND_WAKEUP_DELAY);
- #endif
-
- usbStart(usbp, &usbcfg);
- usbConnectBus(usbp);
- }
-
- /* ---------------------------------------------------------
- * Keyboard functions
- * ---------------------------------------------------------
- */
- /* keyboard IN callback hander (a kbd report has made it IN) */
- #ifndef KEYBOARD_SHARED_EP
- void kbd_in_cb(USBDriver *usbp, usbep_t ep) {
- /* STUB */
- (void)usbp;
- (void)ep;
- }
- #endif
-
- /* start-of-frame handler
- * TODO: i guess it would be better to re-implement using timers,
- * so that this is not going to have to be checked every 1ms */
- void kbd_sof_cb(USBDriver *usbp) { (void)usbp; }
-
- /* Idle requests timer code
- * callback (called from ISR, unlocked state) */
- static void keyboard_idle_timer_cb(void *arg) {
- USBDriver *usbp = (USBDriver *)arg;
-
- osalSysLockFromISR();
-
- /* check that the states of things are as they're supposed to */
- if (usbGetDriverStateI(usbp) != USB_ACTIVE) {
- /* do not rearm the timer, should be enabled on IDLE request */
- osalSysUnlockFromISR();
- return;
- }
-
- #ifdef NKRO_ENABLE
- if (!keymap_config.nkro && keyboard_idle && keyboard_protocol) {
- #else /* NKRO_ENABLE */
- if (keyboard_idle && keyboard_protocol) {
- #endif /* NKRO_ENABLE */
- /* TODO: are we sure we want the KBD_ENDPOINT? */
- if (!usbGetTransmitStatusI(usbp, KEYBOARD_IN_EPNUM)) {
- usbStartTransmitI(usbp, KEYBOARD_IN_EPNUM, (uint8_t *)&keyboard_report_sent, KEYBOARD_EPSIZE);
- }
- /* rearm the timer */
- chVTSetI(&keyboard_idle_timer, 4 * TIME_MS2I(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
- }
-
- /* do not rearm the timer if the condition above fails
- * it should be enabled again on either IDLE or SET_PROTOCOL requests */
- osalSysUnlockFromISR();
- }
-
- /* LED status */
- uint8_t keyboard_leds(void) { return keyboard_led_state; }
-
- /* prepare and start sending a report IN
- * not callable from ISR or locked state */
- void send_keyboard(report_keyboard_t *report) {
- osalSysLock();
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- goto unlock;
- }
-
- #ifdef NKRO_ENABLE
- if (keymap_config.nkro && keyboard_protocol) { /* NKRO protocol */
- /* need to wait until the previous packet has made it through */
- /* can rewrite this using the synchronous API, then would wait
- * until *after* the packet has been transmitted. I think
- * this is more efficient */
- /* busy wait, should be short and not very common */
- if (usbGetTransmitStatusI(&USB_DRIVER, SHARED_IN_EPNUM)) {
- /* Need to either suspend, or loop and call unlock/lock during
- * every iteration - otherwise the system will remain locked,
- * no interrupts served, so USB not going through as well.
- * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
- osalThreadSuspendS(&(&USB_DRIVER)->epc[SHARED_IN_EPNUM]->in_state->thread);
-
- /* after osalThreadSuspendS returns USB status might have changed */
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- goto unlock;
- }
- }
- usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)report, sizeof(struct nkro_report));
- } else
- #endif /* NKRO_ENABLE */
- { /* regular protocol */
- /* need to wait until the previous packet has made it through */
- /* busy wait, should be short and not very common */
- if (usbGetTransmitStatusI(&USB_DRIVER, KEYBOARD_IN_EPNUM)) {
- /* Need to either suspend, or loop and call unlock/lock during
- * every iteration - otherwise the system will remain locked,
- * no interrupts served, so USB not going through as well.
- * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
- osalThreadSuspendS(&(&USB_DRIVER)->epc[KEYBOARD_IN_EPNUM]->in_state->thread);
-
- /* after osalThreadSuspendS returns USB status might have changed */
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- goto unlock;
- }
- }
- uint8_t *data, size;
- if (keyboard_protocol) {
- data = (uint8_t *)report;
- size = KEYBOARD_REPORT_SIZE;
- } else { /* boot protocol */
- data = &report->mods;
- size = 8;
- }
- usbStartTransmitI(&USB_DRIVER, KEYBOARD_IN_EPNUM, data, size);
- }
- keyboard_report_sent = *report;
-
- unlock:
- osalSysUnlock();
- }
-
- /* ---------------------------------------------------------
- * Mouse functions
- * ---------------------------------------------------------
- */
-
- #ifdef MOUSE_ENABLE
-
- # ifndef MOUSE_SHARED_EP
- /* mouse IN callback hander (a mouse report has made it IN) */
- void mouse_in_cb(USBDriver *usbp, usbep_t ep) {
- (void)usbp;
- (void)ep;
- }
- # endif
-
- void send_mouse(report_mouse_t *report) {
- osalSysLock();
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- osalSysUnlock();
- return;
- }
-
- if (usbGetTransmitStatusI(&USB_DRIVER, MOUSE_IN_EPNUM)) {
- /* Need to either suspend, or loop and call unlock/lock during
- * every iteration - otherwise the system will remain locked,
- * no interrupts served, so USB not going through as well.
- * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
- if (osalThreadSuspendTimeoutS(&(&USB_DRIVER)->epc[MOUSE_IN_EPNUM]->in_state->thread, TIME_MS2I(10)) == MSG_TIMEOUT) {
- osalSysUnlock();
- return;
- }
- }
- usbStartTransmitI(&USB_DRIVER, MOUSE_IN_EPNUM, (uint8_t *)report, sizeof(report_mouse_t));
- osalSysUnlock();
- }
-
- #else /* MOUSE_ENABLE */
- void send_mouse(report_mouse_t *report) { (void)report; }
- #endif /* MOUSE_ENABLE */
-
- /* ---------------------------------------------------------
- * Shared EP functions
- * ---------------------------------------------------------
- */
- #ifdef SHARED_EP_ENABLE
- /* shared IN callback hander */
- void shared_in_cb(USBDriver *usbp, usbep_t ep) {
- /* STUB */
- (void)usbp;
- (void)ep;
- }
- #endif
-
- /* ---------------------------------------------------------
- * Extrakey functions
- * ---------------------------------------------------------
- */
-
- #ifdef EXTRAKEY_ENABLE
- static void send_extra(uint8_t report_id, uint16_t data) {
- osalSysLock();
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- osalSysUnlock();
- return;
- }
-
- if (usbGetTransmitStatusI(&USB_DRIVER, SHARED_IN_EPNUM)) {
- /* Need to either suspend, or loop and call unlock/lock during
- * every iteration - otherwise the system will remain locked,
- * no interrupts served, so USB not going through as well.
- * Note: for suspend, need USB_USE_WAIT == TRUE in halconf.h */
- if (osalThreadSuspendTimeoutS(&(&USB_DRIVER)->epc[SHARED_IN_EPNUM]->in_state->thread, TIME_MS2I(10)) == MSG_TIMEOUT) {
- osalSysUnlock();
- return;
- }
- }
-
- static report_extra_t report;
- report = (report_extra_t){.report_id = report_id, .usage = data};
-
- usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)&report, sizeof(report_extra_t));
- osalSysUnlock();
- }
- #endif
-
- void send_system(uint16_t data) {
- #ifdef EXTRAKEY_ENABLE
- send_extra(REPORT_ID_SYSTEM, data);
- #endif
- }
-
- void send_consumer(uint16_t data) {
- #ifdef EXTRAKEY_ENABLE
- send_extra(REPORT_ID_CONSUMER, data);
- #endif
- }
-
- void send_digitizer(report_digitizer_t *report) {
- #ifdef DIGITIZER_ENABLE
- # ifdef DIGITIZER_SHARED_EP
- osalSysLock();
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- osalSysUnlock();
- return;
- }
-
- usbStartTransmitI(&USB_DRIVER, DIGITIZER_IN_EPNUM, (uint8_t *)report, sizeof(report_digitizer_t));
- osalSysUnlock();
- # else
- chnWrite(&drivers.digitizer_driver.driver, (uint8_t *)report, sizeof(report_digitizer_t));
- # endif
- #endif
- }
-
- /* ---------------------------------------------------------
- * Console functions
- * ---------------------------------------------------------
- */
-
- #ifdef CONSOLE_ENABLE
-
- int8_t sendchar(uint8_t c) {
- static bool timed_out = false;
- /* The `timed_out` state is an approximation of the ideal `is_listener_disconnected?` state.
- *
- * When a 5ms timeout write has timed out, hid_listen is most likely not running, or not
- * listening to this keyboard, so we go into the timed_out state. In this state we assume
- * that hid_listen is most likely not gonna be connected to us any time soon, so it would
- * be wasteful to write follow-up characters with a 5ms timeout, it would all add up and
- * unncecessarily slow down the firmware. However instead of just dropping the characters,
- * we write them with a TIME_IMMEDIATE timeout, which is a zero timeout,
- * and this will succeed only if hid_listen gets connected again. When a write with
- * TIME_IMMEDIATE timeout succeeds, we know that hid_listen is listening to us again, and
- * we can go back to the timed_out = false state, and following writes will be executed
- * with a 5ms timeout. The reason we don't just send all characters with the TIME_IMMEDIATE
- * timeout is that this could cause bytes to be lost even if hid_listen is running, if there
- * is a lot of data being sent over the console.
- *
- * This logic will work correctly as long as hid_listen is able to receive at least 200
- * bytes per second. On a heavily overloaded machine that's so overloaded that it's
- * unusable, and constantly swapping, hid_listen might have trouble receiving 200 bytes per
- * second, so some bytes might be lost on the console.
- */
-
- const sysinterval_t timeout = timed_out ? TIME_IMMEDIATE : TIME_MS2I(5);
- const size_t result = chnWriteTimeout(&drivers.console_driver.driver, &c, 1, timeout);
- timed_out = (result == 0);
- return result;
- }
-
- // Just a dummy function for now, this could be exposed as a weak function
- // Or connected to the actual QMK console
- static void console_receive(uint8_t *data, uint8_t length) {
- (void)data;
- (void)length;
- }
-
- void console_task(void) {
- uint8_t buffer[CONSOLE_EPSIZE];
- size_t size = 0;
- do {
- size_t size = chnReadTimeout(&drivers.console_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
- if (size > 0) {
- console_receive(buffer, size);
- }
- } while (size > 0);
- }
-
- #endif /* CONSOLE_ENABLE */
-
- #ifdef RAW_ENABLE
- void raw_hid_send(uint8_t *data, uint8_t length) {
- // TODO: implement variable size packet
- if (length != RAW_EPSIZE) {
- return;
- }
- chnWrite(&drivers.raw_driver.driver, data, length);
- }
-
- __attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) {
- // Users should #include "raw_hid.h" in their own code
- // and implement this function there. Leave this as weak linkage
- // so users can opt to not handle data coming in.
- }
-
- void raw_hid_task(void) {
- uint8_t buffer[RAW_EPSIZE];
- size_t size = 0;
- do {
- size_t size = chnReadTimeout(&drivers.raw_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
- if (size > 0) {
- raw_hid_receive(buffer, size);
- }
- } while (size > 0);
- }
-
- #endif
-
- #ifdef MIDI_ENABLE
-
- void send_midi_packet(MIDI_EventPacket_t *event) { chnWrite(&drivers.midi_driver.driver, (uint8_t *)event, sizeof(MIDI_EventPacket_t)); }
-
- bool recv_midi_packet(MIDI_EventPacket_t *const event) {
- size_t size = chnReadTimeout(&drivers.midi_driver.driver, (uint8_t *)event, sizeof(MIDI_EventPacket_t), TIME_IMMEDIATE);
- return size == sizeof(MIDI_EventPacket_t);
- }
- void midi_ep_task(void) {
- uint8_t buffer[MIDI_STREAM_EPSIZE];
- size_t size = 0;
- do {
- size_t size = chnReadTimeout(&drivers.midi_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
- if (size > 0) {
- MIDI_EventPacket_t event;
- recv_midi_packet(&event);
- }
- } while (size > 0);
- }
- #endif
-
- #ifdef VIRTSER_ENABLE
-
- void virtser_send(const uint8_t byte) { chnWrite(&drivers.serial_driver.driver, &byte, 1); }
-
- __attribute__((weak)) void virtser_recv(uint8_t c) {
- // Ignore by default
- }
-
- void virtser_task(void) {
- uint8_t numBytesReceived = 0;
- uint8_t buffer[16];
- do {
- numBytesReceived = chnReadTimeout(&drivers.serial_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
- for (int i = 0; i < numBytesReceived; i++) {
- virtser_recv(buffer[i]);
- }
- } while (numBytesReceived > 0);
- }
-
- #endif
-
- #ifdef JOYSTICK_ENABLE
-
- void send_joystick_packet(joystick_t *joystick) {
- static joystick_report_t rep;
- rep = (joystick_report_t) {
- # if JOYSTICK_AXES_COUNT > 0
- .axes =
- { joystick->axes[0],
-
- # if JOYSTICK_AXES_COUNT >= 2
- joystick->axes[1],
- # endif
- # if JOYSTICK_AXES_COUNT >= 3
- joystick->axes[2],
- # endif
- # if JOYSTICK_AXES_COUNT >= 4
- joystick->axes[3],
- # endif
- # if JOYSTICK_AXES_COUNT >= 5
- joystick->axes[4],
- # endif
- # if JOYSTICK_AXES_COUNT >= 6
- joystick->axes[5],
- # endif
- },
- # endif // JOYSTICK_AXES_COUNT>0
-
- # if JOYSTICK_BUTTON_COUNT > 0
- .buttons = {
- joystick->buttons[0],
-
- # if JOYSTICK_BUTTON_COUNT > 8
- joystick->buttons[1],
- # endif
- # if JOYSTICK_BUTTON_COUNT > 16
- joystick->buttons[2],
- # endif
- # if JOYSTICK_BUTTON_COUNT > 24
- joystick->buttons[3],
- # endif
- }
- # endif // JOYSTICK_BUTTON_COUNT>0
- };
-
- // chnWrite(&drivers.joystick_driver.driver, (uint8_t *)&rep, sizeof(rep));
- osalSysLock();
- if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- osalSysUnlock();
- return;
- }
-
- usbStartTransmitI(&USB_DRIVER, JOYSTICK_IN_EPNUM, (uint8_t *)&rep, sizeof(joystick_report_t));
- osalSysUnlock();
- }
-
- #endif
|