summaryrefslogtreecommitdiff
path: root/tmk_core/protocol/chibios
diff options
context:
space:
mode:
authorskullY <skullydazed@gmail.com>2019-08-30 11:19:03 -0700
committerFlorian Didron <fdidron@users.noreply.github.com>2019-10-01 10:21:12 +0900
commit93f6749e06b70ba81e15f8b77e5a18675dacddfe (patch)
treefcf75ef930800a948e5a3ba015d6759889f2284d /tmk_core/protocol/chibios
parentda34bddba16ba7a8495dc30bfe4542551ba87ed4 (diff)
clang-format changes
Diffstat (limited to 'tmk_core/protocol/chibios')
-rw-r--r--tmk_core/protocol/chibios/lufa_utils/LUFA/Drivers/USB/USB.h8
-rw-r--r--tmk_core/protocol/chibios/main.c180
-rw-r--r--tmk_core/protocol/chibios/usb_driver.c435
-rw-r--r--tmk_core/protocol/chibios/usb_driver.h168
-rw-r--r--tmk_core/protocol/chibios/usb_main.c1048
-rw-r--r--tmk_core/protocol/chibios/usb_main.h7
6 files changed, 873 insertions, 973 deletions
diff --git a/tmk_core/protocol/chibios/lufa_utils/LUFA/Drivers/USB/USB.h b/tmk_core/protocol/chibios/lufa_utils/LUFA/Drivers/USB/USB.h
index a5374d820c..f59c8d1dda 100644
--- a/tmk_core/protocol/chibios/lufa_utils/LUFA/Drivers/USB/USB.h
+++ b/tmk_core/protocol/chibios/lufa_utils/LUFA/Drivers/USB/USB.h
@@ -2,7 +2,7 @@
#include "stddef.h"
#include "inttypes.h"
-#define ATTR_PACKED __attribute__ ((packed))
+#define ATTR_PACKED __attribute__((packed))
/** Concatenates the given input into a single token, via the C Preprocessor.
*
* \param[in] x First item to concatenate.
@@ -10,7 +10,7 @@
*
* \return Concatenated version of the input.
*/
-#define CONCAT(x, y) x ## y
+#define CONCAT(x, y) x##y
/** CConcatenates the given input into a single token after macro expansion, via the C Preprocessor.
*
@@ -19,8 +19,8 @@
*
* \return Concatenated version of the expanded input.
*/
-#define CONCAT_EXPANDED(x, y) CONCAT(x, y)
-#define CPU_TO_LE16(x) (x)
+#define CONCAT_EXPANDED(x, y) CONCAT(x, y)
+#define CPU_TO_LE16(x) (x)
// We don't need anything from the following files, or we have defined it already
#define __LUFA_COMMON_H__
diff --git a/tmk_core/protocol/chibios/main.c b/tmk_core/protocol/chibios/main.c
index 8de55bfe3f..de2b493b84 100644
--- a/tmk_core/protocol/chibios/main.c
+++ b/tmk_core/protocol/chibios/main.c
@@ -33,19 +33,19 @@
#include "debug.h"
#include "printf.h"
#ifdef SLEEP_LED_ENABLE
-#include "sleep_led.h"
+# include "sleep_led.h"
#endif
#ifdef SERIAL_LINK_ENABLE
-#include "serial_link/system/serial_link.h"
+# include "serial_link/system/serial_link.h"
#endif
#ifdef VISUALIZER_ENABLE
-#include "visualizer/visualizer.h"
+# include "visualizer/visualizer.h"
#endif
#ifdef MIDI_ENABLE
-#include "qmk_midi.h"
+# include "qmk_midi.h"
#endif
#ifdef STM32_EEPROM_ENABLE
-#include "eeprom_stm32.h"
+# include "eeprom_stm32.h"
#endif
#include "suspend.h"
#include "wait.h"
@@ -57,19 +57,13 @@
/* declarations */
uint8_t keyboard_leds(void);
-void send_keyboard(report_keyboard_t *report);
-void send_mouse(report_mouse_t *report);
-void send_system(uint16_t data);
-void send_consumer(uint16_t data);
+void send_keyboard(report_keyboard_t *report);
+void send_mouse(report_mouse_t *report);
+void send_system(uint16_t data);
+void send_consumer(uint16_t data);
/* host struct */
-host_driver_t chibios_driver = {
- keyboard_leds,
- send_keyboard,
- send_mouse,
- send_system,
- send_consumer
-};
+host_driver_t chibios_driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};
#ifdef VIRTSER_ENABLE
void virtser_task(void);
@@ -103,127 +97,123 @@ void console_task(void);
// }
// }
-
-
/* Main thread
*/
int main(void) {
- /* ChibiOS/RT init */
- halInit();
- chSysInit();
+ /* ChibiOS/RT init */
+ halInit();
+ chSysInit();
#ifdef STM32_EEPROM_ENABLE
- EEPROM_Init();
+ EEPROM_Init();
#endif
- // TESTING
- // chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
+ // TESTING
+ // chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
- keyboard_setup();
+ keyboard_setup();
- /* Init USB */
- init_usb_driver(&USB_DRIVER);
+ /* Init USB */
+ init_usb_driver(&USB_DRIVER);
- /* init printf */
- init_printf(NULL,sendchar_pf);
+ /* init printf */
+ init_printf(NULL, sendchar_pf);
#ifdef MIDI_ENABLE
- setup_midi();
+ setup_midi();
#endif
#ifdef SERIAL_LINK_ENABLE
- init_serial_link();
+ init_serial_link();
#endif
#ifdef VISUALIZER_ENABLE
- visualizer_init();
+ visualizer_init();
#endif
+ host_driver_t *driver = NULL;
- host_driver_t* driver = NULL;
-
- /* Wait until the USB or serial link is active */
- while (true) {
+ /* Wait until the USB or serial link is active */
+ while (true) {
#if defined(WAIT_FOR_USB) || defined(SERIAL_LINK_ENABLE)
- if(USB_DRIVER.state == USB_ACTIVE) {
- driver = &chibios_driver;
- break;
- }
+ if (USB_DRIVER.state == USB_ACTIVE) {
+ driver = &chibios_driver;
+ break;
+ }
#else
- driver = &chibios_driver;
- break;
+ driver = &chibios_driver;
+ break;
#endif
#ifdef SERIAL_LINK_ENABLE
- if(is_serial_link_connected()) {
- driver = get_serial_link_driver();
- break;
- }
- serial_link_update();
+ if (is_serial_link_connected()) {
+ driver = get_serial_link_driver();
+ break;
+ }
+ serial_link_update();
#endif
- wait_ms(50);
- }
+ wait_ms(50);
+ }
- /* Do need to wait here!
- * Otherwise the next print might start a transfer on console EP
- * before the USB is completely ready, which sometimes causes
- * HardFaults.
- */
- wait_ms(50);
+ /* Do need to wait here!
+ * Otherwise the next print might start a transfer on console EP
+ * before the USB is completely ready, which sometimes causes
+ * HardFaults.
+ */
+ wait_ms(50);
- print("USB configured.\n");
+ print("USB configured.\n");
- /* init TMK modules */
- keyboard_init();
- host_set_driver(driver);
+ /* init TMK modules */
+ keyboard_init();
+ host_set_driver(driver);
#ifdef SLEEP_LED_ENABLE
- sleep_led_init();
+ sleep_led_init();
#endif
- print("Keyboard start.\n");
-
- /* Main loop */
- while(true) {
+ print("Keyboard start.\n");
+ /* Main loop */
+ while (true) {
#if !defined(NO_USB_STARTUP_CHECK)
- if(USB_DRIVER.state == USB_SUSPENDED) {
- print("[s]");
-#ifdef VISUALIZER_ENABLE
- visualizer_suspend();
-#endif
- while(USB_DRIVER.state == USB_SUSPENDED) {
- /* Do this in the suspended state */
-#ifdef SERIAL_LINK_ENABLE
- serial_link_update();
-#endif
- suspend_power_down(); // on AVR this deep sleeps for 15ms
- /* Remote wakeup */
- if(suspend_wakeup_condition()) {
- usbWakeupHost(&USB_DRIVER);
+ if (USB_DRIVER.state == USB_SUSPENDED) {
+ print("[s]");
+# ifdef VISUALIZER_ENABLE
+ visualizer_suspend();
+# endif
+ while (USB_DRIVER.state == USB_SUSPENDED) {
+ /* Do this in the suspended state */
+# ifdef SERIAL_LINK_ENABLE
+ serial_link_update();
+# endif
+ suspend_power_down(); // on AVR this deep sleeps for 15ms
+ /* Remote wakeup */
+ if (suspend_wakeup_condition()) {
+ usbWakeupHost(&USB_DRIVER);
+ }
+ }
+ /* Woken up */
+ // variables has been already cleared by the wakeup hook
+ send_keyboard_report();
+# ifdef MOUSEKEY_ENABLE
+ mousekey_send();
+# endif /* MOUSEKEY_ENABLE */
+
+# ifdef VISUALIZER_ENABLE
+ visualizer_resume();
+# endif
}
- }
- /* Woken up */
- // variables has been already cleared by the wakeup hook
- send_keyboard_report();
-#ifdef MOUSEKEY_ENABLE
- mousekey_send();
-#endif /* MOUSEKEY_ENABLE */
-
-#ifdef VISUALIZER_ENABLE
- visualizer_resume();
-#endif
- }
#endif
- keyboard_task();
+ keyboard_task();
#ifdef CONSOLE_ENABLE
- console_task();
+ console_task();
#endif
#ifdef VIRTSER_ENABLE
- virtser_task();
+ virtser_task();
#endif
#ifdef RAW_ENABLE
- raw_hid_task();
+ raw_hid_task();
#endif
- }
+ }
}
diff --git a/tmk_core/protocol/chibios/usb_driver.c b/tmk_core/protocol/chibios/usb_driver.c
index fe535eeb3a..28a8c66635 100644
--- a/tmk_core/protocol/chibios/usb_driver.c
+++ b/tmk_core/protocol/chibios/usb_driver.c
@@ -41,93 +41,62 @@
/*
* Current Line Coding.
*/
-static cdc_linecoding_t linecoding = {
- {0x00, 0x96, 0x00, 0x00}, /* 38400. */
- LC_STOP_1, LC_PARITY_NONE, 8
-};
+static cdc_linecoding_t linecoding = {{0x00, 0x96, 0x00, 0x00}, /* 38400. */
+ LC_STOP_1,
+ LC_PARITY_NONE,
+ 8};
/*===========================================================================*/
/* Driver local functions. */
/*===========================================================================*/
static bool qmkusb_start_receive(QMKUSBDriver *qmkusbp) {
- uint8_t *buf;
-
- /* If the USB driver is not in the appropriate state then transactions
- must not be started.*/
- if ((usbGetDriverStateI(qmkusbp->config->usbp) != USB_ACTIVE) ||
- (qmkusbp->state != QMKUSB_READY)) {
- return true;
- }
-
- /* Checking if there is already a transaction ongoing on the endpoint.*/
- if (usbGetReceiveStatusI(qmkusbp->config->usbp, qmkusbp->config->bulk_in)) {
- return true;
- }
-
- /* Checking if there is a buffer ready for incoming data.*/
- buf = ibqGetEmptyBufferI(&qmkusbp->ibqueue);
- if (buf == NULL) {
- return true;
- }
-
- /* Buffer found, starting a new transaction.*/
- usbStartReceiveI(qmkusbp->config->usbp, qmkusbp->config->bulk_out,
- buf, qmkusbp->ibqueue.bsize - sizeof(size_t));
-
- return false;
-}
-
-/*
- * Interface implementation.
- */
-
-static size_t _write(void *ip, const uint8_t *bp, size_t n) {
+ uint8_t *buf;
- return obqWriteTimeout(&((QMKUSBDriver *)ip)->obqueue, bp,
- n, TIME_INFINITE);
-}
+ /* If the USB driver is not in the appropriate state then transactions
+ must not be started.*/
+ if ((usbGetDriverStateI(qmkusbp->config->usbp) != USB_ACTIVE) || (qmkusbp->state != QMKUSB_READY)) {
+ return true;
+ }
-static size_t _read(void *ip, uint8_t *bp, size_t n) {
+ /* Checking if there is already a transaction ongoing on the endpoint.*/
+ if (usbGetReceiveStatusI(qmkusbp->config->usbp, qmkusbp->config->bulk_in)) {
+ return true;
+ }
- return ibqReadTimeout(&((QMKUSBDriver *)ip)->ibqueue, bp,
- n, TIME_INFINITE);
-}
+ /* Checking if there is a buffer ready for incoming data.*/
+ buf = ibqGetEmptyBufferI(&qmkusbp->ibqueue);
+ if (buf == NULL) {
+ return true;
+ }
-static msg_t _put(void *ip, uint8_t b) {
+ /* Buffer found, starting a new transaction.*/
+ usbStartReceiveI(qmkusbp->config->usbp, qmkusbp->config->bulk_out, buf, qmkusbp->ibqueue.bsize - sizeof(size_t));
- return obqPutTimeout(&((QMKUSBDriver *)ip)->obqueue, b, TIME_INFINITE);
+ return false;
}
-static msg_t _get(void *ip) {
-
- return ibqGetTimeout(&((QMKUSBDriver *)ip)->ibqueue, TIME_INFINITE);
-}
+/*
+ * Interface implementation.
+ */
-static msg_t _putt(void *ip, uint8_t b, systime_t timeout) {
+static size_t _write(void *ip, const uint8_t *bp, size_t n) { return obqWriteTimeout(&((QMKUSBDriver *)ip)->obqueue, bp, n, TIME_INFINITE); }
- return obqPutTimeout(&((QMKUSBDriver *)ip)->obqueue, b, timeout);
-}
+static size_t _read(void *ip, uint8_t *bp, size_t n) { return ibqReadTimeout(&((QMKUSBDriver *)ip)->ibqueue, bp, n, TIME_INFINITE); }
-static msg_t _gett(void *ip, systime_t timeout) {
+static msg_t _put(void *ip, uint8_t b) { return obqPutTimeout(&((QMKUSBDriver *)ip)->obqueue, b, TIME_INFINITE); }
- return ibqGetTimeout(&((QMKUSBDriver *)ip)->ibqueue, timeout);
-}
+static msg_t _get(void *ip) { return ibqGetTimeout(&((QMKUSBDriver *)ip)->ibqueue, TIME_INFINITE); }
-static size_t _writet(void *ip, const uint8_t *bp, size_t n, systime_t timeout) {
+static msg_t _putt(void *ip, uint8_t b, systime_t timeout) { return obqPutTimeout(&((QMKUSBDriver *)ip)->obqueue, b, timeout); }
- return obqWriteTimeout(&((QMKUSBDriver *)ip)->obqueue, bp, n, timeout);
-}
+static msg_t _gett(void *ip, systime_t timeout) { return ibqGetTimeout(&((QMKUSBDriver *)ip)->ibqueue, timeout); }
-static size_t _readt(void *ip, uint8_t *bp, size_t n, systime_t timeout) {
+static size_t _writet(void *ip, const uint8_t *bp, size_t n, systime_t timeout) { return obqWriteTimeout(&((QMKUSBDriver *)ip)->obqueue, bp, n, timeout); }
- return ibqReadTimeout(&((QMKUSBDriver *)ip)->ibqueue, bp, n, timeout);
-}
+static size_t _readt(void *ip, uint8_t *bp, size_t n, systime_t timeout) { return ibqReadTimeout(&((QMKUSBDriver *)ip)->ibqueue, bp, n, timeout); }
-static const struct QMKUSBDriverVMT vmt = {
- _write, _read, _put, _get,
- _putt, _gett, _writet, _readt
-};
+static const struct QMKUSBDriverVMT vmt = {_write, _read, _put, _get, _putt, _gett, _writet, _readt};
/**
* @brief Notification of empty buffer released into the input buffers queue.
@@ -135,8 +104,8 @@ static const struct QMKUSBDriverVMT vmt = {
* @param[in] bqp the buffers queue pointer.
*/
static void ibnotify(io_buffers_queue_t *bqp) {
- QMKUSBDriver *qmkusbp = bqGetLinkX(bqp);
- (void) qmkusb_start_receive(qmkusbp);
+ QMKUSBDriver *qmkusbp = bqGetLinkX(bqp);
+ (void)qmkusb_start_receive(qmkusbp);
}
/**
@@ -145,25 +114,24 @@ static void ibnotify(io_buffers_queue_t *bqp) {
* @param[in] bqp the buffers queue pointer.
*/
static void obnotify(io_buffers_queue_t *bqp) {
- size_t n;
- QMKUSBDriver *qmkusbp = bqGetLinkX(bqp);
-
- /* If the USB driver is not in the appropriate state then transactions
- must not be started.*/
- if ((usbGetDriverStateI(qmkusbp->config->usbp) != USB_ACTIVE) ||
- (qmkusbp->state != QMKUSB_READY)) {
- return;
- }
-
- /* Checking if there is already a transaction ongoing on the endpoint.*/
- if (!usbGetTransmitStatusI(qmkusbp->config->usbp, qmkusbp->config->bulk_in)) {
- /* Trying to get a full buffer.*/
- uint8_t *buf = obqGetFullBufferI(&qmkusbp->obqueue, &n);
- if (buf != NULL) {
- /* Buffer found, starting a new transaction.*/
- usbStartTransmitI(qmkusbp->config->usbp, qmkusbp->config->bulk_in, buf, n);
+ size_t n;
+ QMKUSBDriver *qmkusbp = bqGetLinkX(bqp);
+
+ /* If the USB driver is not in the appropriate state then transactions
+ must not be started.*/
+ if ((usbGetDriverStateI(qmkusbp->config->usbp) != USB_ACTIVE) || (qmkusbp->state != QMKUSB_READY)) {
+ return;
+ }
+
+ /* Checking if there is already a transaction ongoing on the endpoint.*/
+ if (!usbGetTransmitStatusI(qmkusbp->config->usbp, qmkusbp->config->bulk_in)) {
+ /* Trying to get a full buffer.*/
+ uint8_t *buf = obqGetFullBufferI(&qmkusbp->obqueue, &n);
+ if (buf != NULL) {
+ /* Buffer found, starting a new transaction.*/
+ usbStartTransmitI(qmkusbp->config->usbp, qmkusbp->config->bulk_in, buf, n);
+ }
}
- }
}
/*===========================================================================*/
@@ -177,8 +145,7 @@ static void obnotify(io_buffers_queue_t *bqp) {
*
* @init
*/
-void qmkusbInit(void) {
-}
+void qmkusbInit(void) {}
/**
* @brief Initializes a generic full duplex driver object.
@@ -190,17 +157,12 @@ void qmkusbInit(void) {
* @init
*/
void qmkusbObjectInit(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config) {
-
- qmkusbp->vmt = &vmt;
- osalEventObjectInit(&qmkusbp->event);
- qmkusbp->state = QMKUSB_STOP;
- // Note that the config uses the USB direction naming
- ibqObjectInit(&qmkusbp->ibqueue, true, config->ob,
- config->out_size, config->out_buffers,
- ibnotify, qmkusbp);
- obqObjectInit(&qmkusbp->obqueue, true, config->ib,
- config->in_size, config->in_buffers,
- obnotify, qmkusbp);
+ qmkusbp->vmt = &vmt;
+ osalEventObjectInit(&qmkusbp->event);
+ qmkusbp->state = QMKUSB_STOP;
+ // Note that the config uses the USB direction naming
+ ibqObjectInit(&qmkusbp->ibqueue, true, config->ob, config->out_size, config->out_buffers, ibnotify, qmkusbp);
+ obqObjectInit(&qmkusbp->obqueue, true, config->ib, config->in_size, config->in_buffers, obnotify, qmkusbp);
}
/**
@@ -212,21 +174,20 @@ void qmkusbObjectInit(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config) {
* @api
*/
void qmkusbStart(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config) {
- USBDriver *usbp = config->usbp;
-
- osalDbgCheck(qmkusbp != NULL);
-
- osalSysLock();
- osalDbgAssert((qmkusbp->state == QMKUSB_STOP) || (qmkusbp->state == QMKUSB_READY),
- "invalid state");
- usbp->in_params[config->bulk_in - 1U] = qmkusbp;
- usbp->out_params[config->bulk_out - 1U] = qmkusbp;
- if (config->int_in > 0U) {
- usbp->in_params[config->int_in - 1U] = qmkusbp;
- }
- qmkusbp->config = config;
- qmkusbp->state = QMKUSB_READY;
- osalSysUnlock();
+ USBDriver *usbp = config->usbp;
+
+ osalDbgCheck(qmkusbp != NULL);
+
+ osalSysLock();
+ osalDbgAssert((qmkusbp->state == QMKUSB_STOP) || (qmkusbp->state == QMKUSB_READY), "invalid state");
+ usbp->in_params[config->bulk_in - 1U] = qmkusbp;
+ usbp->out_params[config->bulk_out - 1U] = qmkusbp;
+ if (config->int_in > 0U) {
+ usbp->in_params[config->int_in - 1U] = qmkusbp;
+ }
+ qmkusbp->config = config;
+ qmkusbp->state = QMKUSB_READY;
+ osalSysUnlock();
}
/**
@@ -239,31 +200,30 @@ void qmkusbStart(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config) {
* @api
*/
void qmkusbStop(QMKUSBDriver *qmkusbp) {
- USBDriver *usbp = qmkusbp->config->usbp;
+ USBDriver *usbp = qmkusbp->config->usbp;
- osalDbgCheck(qmkusbp != NULL);
+ osalDbgCheck(qmkusbp != NULL);
- osalSysLock();
+ osalSysLock();
- osalDbgAssert((qmkusbp->state == QMKUSB_STOP) || (qmkusbp->state == QMKUSB_READY),
- "invalid state");
+ osalDbgAssert((qmkusbp->state == QMKUSB_STOP) || (qmkusbp->state == QMKUSB_READY), "invalid state");
- /* Driver in stopped state.*/
- usbp->in_params[qmkusbp->config->bulk_in - 1U] = NULL;
- usbp->out_params[qmkusbp->config->bulk_out - 1U] = NULL;
- if (qmkusbp->config->int_in > 0U) {
- usbp->in_params[qmkusbp->config->int_in - 1U] = NULL;
- }
- qmkusbp->config = NULL;
- qmkusbp->state = QMKUSB_STOP;
+ /* Driver in stopped state.*/
+ usbp->in_params[qmkusbp->config->bulk_in - 1U] = NULL;
+ usbp->out_params[qmkusbp->config->bulk_out - 1U] = NULL;
+ if (qmkusbp->config->int_in > 0U) {
+ usbp->in_params[qmkusbp->config->int_in - 1U] = NULL;
+ }
+ qmkusbp->config = NULL;
+ qmkusbp->state = QMKUSB_STOP;
- /* Enforces a disconnection.*/
- chnAddFlagsI(qmkusbp, CHN_DISCONNECTED);
- ibqResetI(&qmkusbp->ibqueue);
- obqResetI(&qmkusbp->obqueue);
- osalOsRescheduleS();
+ /* Enforces a disconnection.*/
+ chnAddFlagsI(qmkusbp, CHN_DISCONNECTED);
+ ibqResetI(&qmkusbp->ibqueue);
+ obqResetI(&qmkusbp->obqueue);
+ osalOsRescheduleS();
- osalSysUnlock();
+ osalSysUnlock();
}
/**
@@ -279,10 +239,9 @@ void qmkusbStop(QMKUSBDriver *qmkusbp) {
* @iclass
*/
void qmkusbSuspendHookI(QMKUSBDriver *qmkusbp) {
-
- chnAddFlagsI(qmkusbp, CHN_DISCONNECTED);
- bqSuspendI(&qmkusbp->ibqueue);
- bqSuspendI(&qmkusbp->obqueue);
+ chnAddFlagsI(qmkusbp, CHN_DISCONNECTED);
+ bqSuspendI(&qmkusbp->ibqueue);
+ bqSuspendI(&qmkusbp->obqueue);
}
/**
@@ -298,10 +257,9 @@ void qmkusbSuspendHookI(QMKUSBDriver *qmkusbp) {
* @iclass
*/
void qmkusbWakeupHookI(QMKUSBDriver *qmkusbp) {
-
- chnAddFlagsI(qmkusbp, CHN_CONNECTED);
- bqResumeX(&qmkusbp->ibqueue);
- bqResumeX(&qmkusbp->obqueue);
+ chnAddFlagsI(qmkusbp, CHN_CONNECTED);
+ bqResumeX(&qmkusbp->ibqueue);
+ bqResumeX(&qmkusbp->obqueue);
}
/**
@@ -312,13 +270,12 @@ void qmkusbWakeupHookI(QMKUSBDriver *qmkusbp) {
* @iclass
*/
void qmkusbConfigureHookI(QMKUSBDriver *qmkusbp) {
-
- ibqResetI(&qmkusbp->ibqueue);
- bqResumeX(&qmkusbp->ibqueue);
- obqResetI(&qmkusbp->obqueue);
- bqResumeX(&qmkusbp->obqueue);
- chnAddFlagsI(qmkusbp, CHN_CONNECTED);
- (void) qmkusb_start_receive(qmkusbp);
+ ibqResetI(&qmkusbp->ibqueue);
+ bqResumeX(&qmkusbp->ibqueue);
+ obqResetI(&qmkusbp->obqueue);
+ bqResumeX(&qmkusbp->obqueue);
+ chnAddFlagsI(qmkusbp, CHN_CONNECTED);
+ (void)qmkusb_start_receive(qmkusbp);
}
/**
@@ -337,24 +294,23 @@ void qmkusbConfigureHookI(QMKUSBDriver *qmkusbp) {
* @retval false Message not handled.
*/
bool qmkusbRequestsHook(USBDriver *usbp) {
-
- if ((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) {
- switch (usbp->setup[1]) {
- case CDC_GET_LINE_CODING:
- usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding), NULL);
- return true;
- case CDC_SET_LINE_CODING:
- usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding), NULL);
- return true;
- case CDC_SET_CONTROL_LINE_STATE:
- /* Nothing to do, there are no control lines.*/
- usbSetupTransfer(usbp, NULL, 0, NULL);
- return true;
- default:
- return false;
+ if ((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) {
+ switch (usbp->setup[1]) {
+ case CDC_GET_LINE_CODING:
+ usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding), NULL);
+ return true;
+ case CDC_SET_LINE_CODING:
+ usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding), NULL);
+ return true;
+ case CDC_SET_CONTROL_LINE_STATE:
+ /* Nothing to do, there are no control lines.*/
+ usbSetupTransfer(usbp, NULL, 0, NULL);
+ return true;
+ default:
+ return false;
+ }
}
- }
- return false;
+ return false;
}
/**
@@ -367,36 +323,34 @@ bool qmkusbRequestsHook(USBDriver *usbp) {
* @iclass
*/
void qmkusbSOFHookI(QMKUSBDriver *qmkusbp) {
+ /* If the USB driver is not in the appropriate state then transactions
+ must not be started.*/
+ if ((usbGetDriverStateI(qmkusbp->config->usbp) != USB_ACTIVE) || (qmkusbp->state != QMKUSB_READY)) {
+ return;
+ }
- /* If the USB driver is not in the appropriate state then transactions
- must not be started.*/
- if ((usbGetDriverStateI(qmkusbp->config->usbp) != USB_ACTIVE) ||
- (qmkusbp->state != QMKUSB_READY)) {
- return;
- }
-
- /* If there is already a transaction ongoing then another one cannot be
- started.*/
- if (usbGetTransmitStatusI(qmkusbp->config->usbp, qmkusbp->config->bulk_in)) {
- return;
- }
-
- /* Checking if there only a buffer partially filled, if so then it is
- enforced in the queue and transmitted.*/
- if (obqTryFlushI(&qmkusbp->obqueue)) {
- size_t n;
- uint8_t *buf = obqGetFullBufferI(&qmkusbp->obqueue, &n);
-
- /* For fixed size drivers, fill the end with zeros */
- if (qmkusbp->config->fixed_size) {
- memset(buf + n, 0, qmkusbp->config->in_size - n);
- n = qmkusbp->config->in_size;
+ /* If there is already a transaction ongoing then another one cannot be
+ started.*/
+ if (usbGetTransmitStatusI(qmkusbp->config->usbp, qmkusbp->config->bulk_in)) {
+ return;
}
- osalDbgAssert(buf != NULL, "queue is empty");
+ /* Checking if there only a buffer partially filled, if so then it is
+ enforced in the queue and transmitted.*/
+ if (obqTryFlushI(&qmkusbp->obqueue)) {
+ size_t n;
+ uint8_t *buf = obqGetFullBufferI(&qmkusbp->obqueue, &n);
- usbStartTransmitI(qmkusbp->config->usbp, qmkusbp->config->bulk_in, buf, n);
- }
+ /* For fixed size drivers, fill the end with zeros */
+ if (qmkusbp->config->fixed_size) {
+ memset(buf + n, 0, qmkusbp->config->in_size - n);
+ n = qmkusbp->config->in_size;
+ }
+
+ osalDbgAssert(buf != NULL, "queue is empty");
+
+ usbStartTransmitI(qmkusbp->config->usbp, qmkusbp->config->bulk_in, buf, n);
+ }
}
/**
@@ -408,49 +362,45 @@ void qmkusbSOFHookI(QMKUSBDriver *qmkusbp) {
* @param[in] ep IN endpoint number
*/
void qmkusbDataTransmitted(USBDriver *usbp, usbep_t ep) {
- uint8_t *buf;
- size_t n;
- QMKUSBDriver *qmkusbp = usbp->in_params[ep - 1U];
+ uint8_t * buf;
+ size_t n;
+ QMKUSBDriver *qmkusbp = usbp->in_params[ep - 1U];
- if (qmkusbp == NULL) {
- return;
- }
+ if (qmkusbp == NULL) {
+ return;
+ }
- osalSysLockFromISR();
+ osalSysLockFromISR();
- /* Signaling that space is available in the output queue.*/
- chnAddFlagsI(qmkusbp, CHN_OUTPUT_EMPTY);
+ /* Signaling that space is available in the output queue.*/
+ chnAddFlagsI(qmkusbp, CHN_OUTPUT_EMPTY);
- /* Freeing the buffer just transmitted, if it was not a zero size packet.*/
- if (usbp->epc[ep]->in_state->txsize > 0U) {
- obqReleaseEmptyBufferI(&qmkusbp->obqueue);
- }
+ /* Freeing the buffer just transmitted, if it was not a zero size packet.*/
+ if (usbp->epc[ep]->in_state->txsize > 0U) {
+ obqReleaseEmptyBufferI(&qmkusbp->obqueue);
+ }
- /* Checking if there is a buffer ready for transmission.*/
- buf = obqGetFullBufferI(&qmkusbp->obqueue, &n);
+ /* Checking if there is a buffer ready for transmission.*/
+ buf = obqGetFullBufferI(&qmkusbp->obqueue, &n);
- if (buf != NULL) {
- /* The endpoint cannot be busy, we are in the context of the callback,
- so it is safe to transmit without a check.*/
- usbStartTransmitI(usbp, ep, buf, n);
- }
- else if ((usbp->epc[ep]->in_state->txsize > 0U) &&
- ((usbp->epc[ep]->in_state->txsize &
- ((size_t)usbp->epc[ep]->in_maxsize - 1U)) == 0U)) {
- /* Transmit zero sized packet in case the last one has maximum allowed
- size. Otherwise the recipient may expect more data coming soon and
- not return buffered data to app. See section 5.8.3 Bulk Transfer
- Packet Size Constraints of the USB Specification document.*/
- if (!qmkusbp->config->fixed_size) {
- usbStartTransmitI(usbp, ep, usbp->setup, 0);
+ if (buf != NULL) {
+ /* The endpoint cannot be busy, we are in the context of the callback,
+ so it is safe to transmit without a check.*/
+ usbStartTransmitI(usbp, ep, buf, n);
+ } else if ((usbp->epc[ep]->in_state->txsize > 0U) && ((usbp->epc[ep]->in_state->txsize & ((size_t)usbp->epc[ep]->in_maxsize - 1U)) == 0U)) {
+ /* Transmit zero sized packet in case the last one has maximum allowed
+ size. Otherwise the recipient may expect more data coming soon and
+ not return buffered data to app. See section 5.8.3 Bulk Transfer
+ Packet Size Constraints of the USB Specification document.*/
+ if (!qmkusbp->config->fixed_size) {
+ usbStartTransmitI(usbp, ep, usbp->setup, 0);
+ }
+
+ } else {
+ /* Nothing to transmit.*/
}
- }
- else {
- /* Nothing to transmit.*/
- }
-
- osalSysUnlockFromISR();
+ osalSysUnlockFromISR();
}
/**
@@ -462,27 +412,25 @@ void qmkusbDataTransmitted(USBDriver *usbp, usbep_t ep) {
* @param[in] ep OUT endpoint number
*/
void qmkusbDataReceived(USBDriver *usbp, usbep_t ep) {
- QMKUSBDriver *qmkusbp = usbp->out_params[ep - 1U];
- if (qmkusbp == NULL) {
- return;
- }
+ QMKUSBDriver *qmkusbp = usbp->out_params[ep - 1U];
+ if (qmkusbp == NULL) {
+ return;
+ }
- osalSysLockFromISR();
+ osalSysLockFromISR();
- /* Signaling that data is available in the input queue.*/
- chnAddFlagsI(qmkusbp, CHN_INPUT_AVAILABLE);
+ /* Signaling that data is available in the input queue.*/
+ chnAddFlagsI(qmkusbp, CHN_INPUT_AVAILABLE);
- /* Posting the filled buffer in the queue.*/
- ibqPostFullBufferI(&qmkusbp->ibqueue,
- usbGetReceiveTransactionSizeX(qmkusbp->config->usbp,
- qmkusbp->config->bulk_out));
+ /* Posting the filled buffer in the queue.*/
+ ibqPostFullBufferI(&qmkusbp->ibqueue, usbGetReceiveTransactionSizeX(qmkusbp->config->usbp, qmkusbp->config->bulk_out));
- /* The endpoint cannot be busy, we are in the context of the callback,
- so a packet is in the buffer for sure. Trying to get a free buffer
- for the next transaction.*/
- (void) qmkusb_start_receive(qmkusbp);
+ /* The endpoint cannot be busy, we are in the context of the callback,
+ so a packet is in the buffer for sure. Trying to get a free buffer
+ for the next transaction.*/
+ (void)qmkusb_start_receive(qmkusbp);
- osalSysUnlockFromISR();
+ osalSysUnlockFromISR();
}
/**
@@ -494,9 +442,8 @@ void qmkusbDataReceived(USBDriver *usbp, usbep_t ep) {
* @param[in] ep endpoint number
*/
void qmkusbInterruptTransmitted(USBDriver *usbp, usbep_t ep) {
-
- (void)usbp;
- (void)ep;
+ (void)usbp;
+ (void)ep;
}
/** @} */
diff --git a/tmk_core/protocol/chibios/usb_driver.h b/tmk_core/protocol/chibios/usb_driver.h
index 558479e197..77dff80669 100644
--- a/tmk_core/protocol/chibios/usb_driver.h
+++ b/tmk_core/protocol/chibios/usb_driver.h
@@ -23,9 +23,9 @@
*/
#ifndef USB_DRIVER_H
-#define USB_DRIVER_H
+# define USB_DRIVER_H
-#include "hal_usb_cdc.h"
+# include "hal_usb_cdc.h"
/*===========================================================================*/
/* Driver constants. */
@@ -35,9 +35,9 @@
/* Derived constants and error checks. */
/*===========================================================================*/
-#if HAL_USE_USB == FALSE
-#error "The USB Driver requires HAL_USE_USB"
-#endif
+# if HAL_USE_USB == FALSE
+# error "The USB Driver requires HAL_USE_USB"
+# endif
/*===========================================================================*/
/* Driver data structures and types. */
@@ -47,9 +47,9 @@
* @brief Driver state machine possible states.
*/
typedef enum {
- QMKUSB_UNINIT = 0, /**< Not initialized. */
- QMKUSB_STOP = 1, /**< Stopped. */
- QMKUSB_READY = 2 /**< Ready. */
+ QMKUSB_UNINIT = 0, /**< Not initialized. */
+ QMKUSB_STOP = 1, /**< Stopped. */
+ QMKUSB_READY = 2 /**< Ready. */
} qmkusbstate_t;
/**
@@ -63,72 +63,70 @@ typedef struct QMKUSBDriver QMKUSBDriver;
* in order to configure and start the driver operations.
*/
typedef struct {
- /**
- * @brief USB driver to use.
- */
- USBDriver *usbp;
- /**
- * @brief Bulk IN endpoint used for outgoing data transfer.
- */
- usbep_t bulk_in;
- /**
- * @brief Bulk OUT endpoint used for incoming data transfer.
- */
- usbep_t bulk_out;
- /**
- * @brief Interrupt IN endpoint used for notifications.
- * @note If set to zero then the INT endpoint is assumed to be not
- * present, USB descriptors must be changed accordingly.
- */
- usbep_t int_in;
-
- /**
- * @brief The number of buffers in the queues
- */
- size_t in_buffers;
- size_t out_buffers;
-
- /**
- * @brief The size of each buffer in the queue, typically the same as the endpoint size
- */
- size_t in_size;
- size_t out_size;
-
- /**
- * @brief Always send full buffers in_size (the rest is filled with zeroes)
- */
- bool fixed_size;
-
- /* Input buffer
- * @note needs to be initialized with a memory buffer of the right size
- */
- uint8_t* ib;
- /* Output buffer
- * @note needs to be initialized with a memory buffer of the right size
- */
- uint8_t* ob;
+ /**
+ * @brief USB driver to use.
+ */
+ USBDriver *usbp;
+ /**
+ * @brief Bulk IN endpoint used for outgoing data transfer.
+ */
+ usbep_t bulk_in;
+ /**
+ * @brief Bulk OUT endpoint used for incoming data transfer.
+ */
+ usbep_t bulk_out;
+ /**
+ * @brief Interrupt IN endpoint used for notifications.
+ * @note If set to zero then the INT endpoint is assumed to be not
+ * present, USB descriptors must be changed accordingly.
+ */
+ usbep_t int_in;
+
+ /**
+ * @brief The number of buffers in the queues
+ */
+ size_t in_buffers;
+ size_t out_buffers;
+
+ /**
+ * @brief The size of each buffer in the queue, typically the same as the endpoint size
+ */
+ size_t in_size;
+ size_t out_size;
+
+ /**
+ * @brief Always send full buffers in_size (the rest is filled with zeroes)
+ */
+ bool fixed_size;
+
+ /* Input buffer
+ * @note needs to be initialized with a memory buffer of the right size
+ */
+ uint8_t *ib;
+ /* Output buffer
+ * @note needs to be initialized with a memory buffer of the right size
+ */
+ uint8_t *ob;
} QMKUSBConfig;
/**
* @brief @p SerialDriver specific data.
*/
-#define _qmk_usb_driver_data \
- _base_asynchronous_channel_data \
- /* Driver state.*/ \
- qmkusbstate_t state; \
- /* Input buffers queue.*/ \
- input_buffers_queue_t ibqueue; \
- /* Output queue.*/ \
- output_buffers_queue_t obqueue; \
- /* End of the mandatory fields.*/ \
- /* Current configuration data.*/ \
- const QMKUSBConfig *config;
+# define _qmk_usb_driver_data \
+ _base_asynchronous_channel_data /* Driver state.*/ \
+ qmkusbstate_t state; \
+ /* Input buffers queue.*/ \
+ input_buffers_queue_t ibqueue; \
+ /* Output queue.*/ \
+ output_buffers_queue_t obqueue; \
+ /* End of the mandatory fields.*/ \
+ /* Current configuration data.*/ \
+ const QMKUSBConfig *config;
/**
* @brief @p SerialUSBDriver specific methods.
*/
-#define _qmk_usb_driver_methods \
- _base_asynchronous_channel_methods
+# define _qmk_usb_driver_methods _base_asynchronous_channel_methods
/**
* @extends BaseAsynchronousChannelVMT
@@ -136,7 +134,7 @@ typedef struct {
* @brief @p SerialDriver virtual methods table.
*/
struct QMKUSBDriverVMT {
- _qmk_usb_driver_methods
+ _qmk_usb_driver_methods
};
/**
@@ -147,9 +145,9 @@ struct QMKUSBDriverVMT {
* I/O queues.
*/
struct QMKUSBDriver {
- /** @brief Virtual Methods Table.*/
- const struct QMKUSBDriverVMT *vmt;
- _qmk_usb_driver_data
+ /** @brief Virtual Methods Table.*/
+ const struct QMKUSBDriverVMT *vmt;
+ _qmk_usb_driver_data
};
/*===========================================================================*/
@@ -160,24 +158,24 @@ struct QMKUSBDriver {
/* External declarations. */
/*===========================================================================*/
-#ifdef __cplusplus
+# ifdef __cplusplus
extern "C" {
-#endif
- void qmkusbInit(void);
- void qmkusbObjectInit(QMKUSBDriver *qmkusbp, const QMKUSBConfig * config);
- void qmkusbStart(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config);
- void qmkusbStop(QMKUSBDriver *qmkusbp);
- void qmkusbSuspendHookI(QMKUSBDriver *qmkusbp);
- void qmkusbWakeupHookI(QMKUSBDriver *qmkusbp);
- void qmkusbConfigureHookI(QMKUSBDriver *qmkusbp);
- bool qmkusbRequestsHook(USBDriver *usbp);
- void qmkusbSOFHookI(QMKUSBDriver *qmkusbp);
- void qmkusbDataTransmitted(USBDriver *usbp, usbep_t ep);
- void qmkusbDataReceived(USBDriver *usbp, usbep_t ep);
- void qmkusbInterruptTransmitted(USBDriver *usbp, usbep_t ep);
-#ifdef __cplusplus
+# endif
+void qmkusbInit(void);
+void qmkusbObjectInit(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config);
+void qmkusbStart(QMKUSBDriver *qmkusbp, const QMKUSBConfig *config);
+void qmkusbStop(QMKUSBDriver *qmkusbp);
+void qmkusbSuspendHookI(QMKUSBDriver *qmkusbp);
+void qmkusbWakeupHookI(QMKUSBDriver *qmkusbp);
+void qmkusbConfigureHookI(QMKUSBDriver *qmkusbp);
+bool qmkusbRequestsHook(USBDriver *usbp);
+void qmkusbSOFHookI(QMKUSBDriver *qmkusbp);
+void qmkusbDataTransmitted(USBDriver *usbp, usbep_t ep);
+void qmkusbDataReceived(USBDriver *usbp, usbep_t ep);
+void qmkusbInterruptTransmitted(USBDriver *usbp, usbep_t ep);
+# ifdef __cplusplus
}
-#endif
+# endif
#endif /* USB_DRIVER_H */
diff --git a/tmk_core/protocol/chibios/usb_main.c b/tmk_core/protocol/chibios/usb_main.c
index 8223d97228..c8a6bbb43f 100644
--- a/tmk_core/protocol/chibios/usb_main.c
+++ b/tmk_core/protocol/chibios/usb_main.c
@@ -24,17 +24,17 @@
#include "debug.h"
#include "suspend.h"
#ifdef SLEEP_LED_ENABLE
-#include "sleep_led.h"
-#include "led.h"
+# 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"
+# include "keycode_config.h"
- extern keymap_config_t keymap_config;
+extern keymap_config_t keymap_config;
#endif
/* ---------------------------------------------------------
@@ -43,19 +43,19 @@
*/
#ifndef usb_lld_connect_bus
- #define usb_lld_connect_bus(usbp)
+# define usb_lld_connect_bus(usbp)
#endif
#ifndef usb_lld_disconnect_bus
- #define usb_lld_disconnect_bus(usbp)
+# define usb_lld_disconnect_bus(usbp)
#endif
-uint8_t keyboard_idle __attribute__((aligned(2))) = 0;
-uint8_t keyboard_protocol __attribute__((aligned(2))) = 1;
-uint16_t keyboard_led_stats __attribute__((aligned(2))) = 0;
-volatile uint16_t keyboard_idle_count = 0;
+uint8_t keyboard_idle __attribute__((aligned(2))) = 0;
+uint8_t keyboard_protocol __attribute__((aligned(2))) = 1;
+uint16_t keyboard_led_stats __attribute__((aligned(2))) = 0;
+volatile uint16_t keyboard_idle_count = 0;
static virtual_timer_t keyboard_idle_timer;
-static void keyboard_idle_timer_cb(void *arg);
+static void keyboard_idle_timer_cb(void *arg);
report_keyboard_t keyboard_report_sent = {{0}};
#ifdef MOUSE_ENABLE
@@ -84,15 +84,15 @@ uint8_t extra_report_blank[3] = {0};
* 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;
+ (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
@@ -100,16 +100,16 @@ static const USBDescriptor *usb_get_descriptor_cb(USBDriver *usbp, uint8_t dtype
static USBInEndpointState kbd_ep_state;
/* keyboard endpoint initialization structure (IN) */
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) */
+ 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
@@ -119,16 +119,16 @@ static USBInEndpointState mouse_ep_state;
/* mouse endpoint initialization structure (IN) */
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) */
+ 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
@@ -138,145 +138,141 @@ static USBInEndpointState shared_ep_state;
/* shared endpoint initialization structure (IN) */
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) */
+ 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
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;
+ 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;
-#define QMK_USB_DRIVER_CONFIG(stream, notification, fixedsize) { \
- .queue_capacity_in = stream##_IN_CAPACITY, \
- .queue_capacity_out = stream##_OUT_CAPACITY, \
- .in_ep_config = { \
- .ep_mode = stream##_IN_MODE, \
- .setup_cb = NULL, \
- .in_cb = qmkusbDataTransmitted, \
- .out_cb = NULL, \
- .in_maxsize = stream##_EPSIZE, \
- .out_maxsize = 0, \
- /* The pointer to the states will be filled during initialization */ \
- .in_state = NULL, \
- .out_state = NULL, \
- .ep_buffers = 2, \
- .setup_buf = NULL \
- }, \
- .out_ep_config = { \
- .ep_mode = stream##_OUT_MODE, \
- .setup_cb = NULL, \
- .in_cb = NULL, \
- .out_cb = qmkusbDataReceived, \
- .in_maxsize = 0, \
- .out_maxsize = stream##_EPSIZE, \
- /* The pointer to the states will be filled during initialization */ \
- .in_state = NULL, \
- .out_state = NULL, \
- .ep_buffers = 2, \
- .setup_buf = NULL, \
- }, \
- .int_ep_config = { \
- .ep_mode = USB_EP_MODE_TYPE_INTR, \
- .setup_cb = NULL, \
- .in_cb = qmkusbInterruptTransmitted, \
- .out_cb = NULL, \
- .in_maxsize = CDC_NOTIFICATION_EPSIZE, \
- .out_maxsize = 0, \
- /* The pointer to the states will be filled during initialization */ \
- .in_state = NULL, \
- .out_state = NULL, \
- .ep_buffers = 2, \
- .setup_buf = NULL, \
- }, \
- .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 = (uint8_t[BQ_BUFFER_SIZE(stream##_IN_CAPACITY, stream##_EPSIZE)]) {}, \
- .ob = (uint8_t[BQ_BUFFER_SIZE(stream##_OUT_CAPACITY,stream##_EPSIZE)]) {}, \
- } \
-}
+#define QMK_USB_DRIVER_CONFIG(stream, notification, fixedsize) \
+ { \
+ .queue_capacity_in = stream##_IN_CAPACITY, .queue_capacity_out = stream##_OUT_CAPACITY, \
+ .in_ep_config = {.ep_mode = stream##_IN_MODE, \
+ .setup_cb = NULL, \
+ .in_cb = qmkusbDataTransmitted, \
+ .out_cb = NULL, \
+ .in_maxsize = stream##_EPSIZE, \
+ .out_maxsize = 0, /* The pointer to the states will be filled during initialization */ \
+ .in_state = NULL, \
+ .out_state = NULL, \
+ .ep_buffers = 2, \
+ .setup_buf = NULL}, \
+ .out_ep_config = \
+ { \
+ .ep_mode = stream##_OUT_MODE, \
+ .setup_cb = NULL, \
+ .in_cb = NULL, \
+ .out_cb = qmkusbDataReceived, \
+ .in_maxsize = 0, \
+ .out_maxsize = stream##_EPSIZE, /* The pointer to the states will be filled during initialization */ \
+ .in_state = NULL, \
+ .out_state = NULL, \
+ .ep_buffers = 2, \
+ .setup_buf = NULL, \
+ }, \
+ .int_ep_config = \
+ { \
+ .ep_mode = USB_EP_MODE_TYPE_INTR, \
+ .setup_cb = NULL, \
+ .in_cb = qmkusbInterruptTransmitted, \
+ .out_cb = NULL, \
+ .in_maxsize = CDC_NOTIFICATION_EPSIZE, \
+ .out_maxsize = 0, /* The pointer to the states will be filled during initialization */ \
+ .in_state = NULL, \
+ .out_state = NULL, \
+ .ep_buffers = 2, \
+ .setup_buf = NULL, \
+ }, \
+ .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 = (uint8_t[BQ_BUFFER_SIZE(stream##_IN_CAPACITY, stream##_EPSIZE)]){}, \
+ .ob = (uint8_t[BQ_BUFFER_SIZE(stream##_OUT_CAPACITY, stream##_EPSIZE)]){}, \
+ } \
+ }
typedef struct {
- union {
- struct {
+ union {
+ struct {
#ifdef CONSOLE_ENABLE
- usb_driver_config_t console_driver;
+ usb_driver_config_t console_driver;
#endif
#ifdef RAW_ENABLE
- usb_driver_config_t raw_driver;
+ usb_driver_config_t raw_driver;
#endif
#ifdef MIDI_ENABLE
- usb_driver_config_t midi_driver;
+ usb_driver_config_t midi_driver;
#endif
#ifdef VIRTSER_ENABLE
- usb_driver_config_t serial_driver;
+ usb_driver_config_t serial_driver;
#endif
+ };
+ usb_driver_config_t array[0];
};
- 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),
+# 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),
+# 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),
+# 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),
+# 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
};
#define NUM_USB_DRIVERS (sizeof(drivers) / sizeof(usb_driver_config_t))
-
/* ---------------------------------------------------------
* USB driver functions
* ---------------------------------------------------------
@@ -285,77 +281,77 @@ static usb_driver_configs_t drivers = {
/* 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;
+ switch (event) {
+ case USB_EVENT_ADDRESS:
+ return;
- case USB_EVENT_CONFIGURED:
- osalSysLockFromISR();
- /* Enable the endpoints specified into the configuration. */
+ case USB_EVENT_CONFIGURED:
+ osalSysLockFromISR();
+ /* Enable the endpoints specified into the configuration. */
#ifndef KEYBOARD_SHARED_EP
- usbInitEndpointI(usbp, KEYBOARD_IN_EPNUM, &kbd_ep_config);
+ 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);
+ usbInitEndpointI(usbp, MOUSE_IN_EPNUM, &mouse_ep_config);
#endif
#ifdef SHARED_EP_ENABLE
- usbInitEndpointI(usbp, SHARED_IN_EPNUM, &shared_ep_config);
+ usbInitEndpointI(usbp, SHARED_IN_EPNUM, &shared_ep_config);
#endif
- for (int i=0;i<NUM_USB_DRIVERS;i++) {
- 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);
- 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();
- return;
- case USB_EVENT_SUSPEND:
+ for (int i = 0; i < NUM_USB_DRIVERS; i++) {
+ 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);
+ 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();
+ return;
+ case USB_EVENT_SUSPEND:
#ifdef SLEEP_LED_ENABLE
- sleep_led_enable();
-#endif /* SLEEP_LED_ENABLE */
- /* 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();
- }
- suspend_wakeup_init();
+ sleep_led_enable();
+#endif /* SLEEP_LED_ENABLE */
+ /* 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();
+ }
+ suspend_wakeup_init();
#ifdef SLEEP_LED_ENABLE
- sleep_led_disable();
- // NOTE: converters may not accept this
- led_set(host_keyboard_leds());
+ sleep_led_disable();
+ // NOTE: converters may not accept this
+ led_set(host_keyboard_leds());
#endif /* SLEEP_LED_ENABLE */
- return;
+ return;
- case USB_EVENT_STALLED:
- 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;
+ uint16_t hw;
- hw = (uint16_t)*p++;
- hw |= (uint16_t)*p << 8U;
- return hw;
+ hw = (uint16_t)*p++;
+ hw |= (uint16_t)*p << 8U;
+ return hw;
}
/*
@@ -373,197 +369,193 @@ static uint16_t get_hword(uint8_t *p) {
#ifdef SHARED_EP_ENABLE
static uint8_t set_report_buf[2] __attribute__((aligned(2)));
-static void set_led_transfer_cb(USBDriver *usbp) {
- if ((set_report_buf[0] == REPORT_ID_KEYBOARD) ||
- (set_report_buf[0] == REPORT_ID_NKRO)) {
- keyboard_led_stats = set_report_buf[1];
- }
+static void set_led_transfer_cb(USBDriver *usbp) {
+ if ((set_report_buf[0] == REPORT_ID_KEYBOARD) || (set_report_buf[0] == REPORT_ID_NKRO)) {
+ keyboard_led_stats = set_report_buf[1];
+ }
}
#endif
/* Callback for SETUP request on the endpoint 0 (control) */
static bool usb_request_hook_cb(USBDriver *usbp) {
- const USBDescriptor *dp;
- int has_report_id;
-
- /* 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;
+ const USBDescriptor *dp;
+ int has_report_id;
+
+ /* 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;
+ 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 and wLength==1?) */
- case KEYBOARD_INTERFACE:
+ 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 and wLength==1?) */
+ case KEYBOARD_INTERFACE:
#if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
- case SHARED_INTERFACE:
+ case SHARED_INTERFACE:
#endif
- /* keyboard_led_stats = <read byte from next OUT report>
- * keyboard_led_stats needs be word (or dword), otherwise we get an exception on F0 */
- has_report_id = 0;
+ /* keyboard_led_stats = <read byte from next OUT report>
+ * keyboard_led_stats needs be word (or dword), otherwise we get an exception on F0 */
+ has_report_id = 0;
#if defined(SHARED_EP_ENABLE)
- if (usbp->setup[4] == SHARED_INTERFACE) {
- has_report_id = 1;
- }
+ if (usbp->setup[4] == SHARED_INTERFACE) {
+ has_report_id = 1;
+ }
#endif
- if (usbp->setup[4] == KEYBOARD_INTERFACE && !keyboard_protocol) {
- has_report_id = 0;
- }
- if (has_report_id) {
- usbSetupTransfer(usbp, set_report_buf, sizeof(set_report_buf), set_led_transfer_cb);
- } else {
- usbSetupTransfer(usbp, (uint8_t *)&keyboard_led_stats, 1, NULL);
- }
- 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) */
+ if (usbp->setup[4] == KEYBOARD_INTERFACE && !keyboard_protocol) {
+ has_report_id = 0;
+ }
+ if (has_report_id) {
+ usbSetupTransfer(usbp, set_report_buf, sizeof(set_report_buf), set_led_transfer_cb);
+ } else {
+ usbSetupTransfer(usbp, (uint8_t *)&keyboard_led_stats, 1, NULL);
+ }
+ 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*MS2ST(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 */
+ 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 * MS2ST(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) {
+ if (!keymap_config.nkro && keyboard_idle) {
+#else /* NKRO_ENABLE */
+ if (keyboard_idle) {
#endif /* NKRO_ENABLE */
- osalSysLockFromISR();
- chVTSetI(&keyboard_idle_timer, 4*MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
- osalSysUnlockFromISR();
+ osalSysLockFromISR();
+ chVTSetI(&keyboard_idle_timer, 4 * MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
+ osalSysUnlockFromISR();
+ }
+ usbSetupTransfer(usbp, NULL, 0, NULL);
+ return TRUE;
+ break;
+ }
+ break;
}
- usbSetupTransfer(usbp, NULL, 0, NULL);
+ }
+
+ /* 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;
- 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);
+
+ 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;
+ 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();
+ 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 */
+ 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++) {
- 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);
- }
-
- /*
- * 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);
+ for (int i = 0; i < NUM_USB_DRIVERS; i++) {
+ 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);
+ }
+
+ /*
+ * 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);
}
/* ---------------------------------------------------------
@@ -573,108 +565,104 @@ void init_usb_driver(USBDriver *usbp) {
/* 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;
+ /* 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;
-}
+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;
+ USBDriver *usbp = (USBDriver *)arg;
- osalSysLockFromISR();
+ 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;
- }
+ /* 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) {
+ 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);
+ /* 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 * MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp);
}
- /* rearm the timer */
- chVTSetI(&keyboard_idle_timer, 4*MS2ST(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();
+ /* 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 (uint8_t)(keyboard_led_stats & 0xFF);
-}
+uint8_t keyboard_leds(void) { return (uint8_t)(keyboard_led_stats & 0xFF); }
/* 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) {
- osalSysUnlock();
- return;
- }
- osalSysUnlock();
-
-#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 */
osalSysLock();
- 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);
+ if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+ osalSysUnlock();
+ return;
}
- usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)report, sizeof(struct nkro_report));
osalSysUnlock();
- } else
+
+#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 */
+ osalSysLock();
+ 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);
+ }
+ usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)report, sizeof(struct nkro_report));
+ osalSysUnlock();
+ } 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 */
- osalSysLock();
- 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);
- }
- uint8_t *data, size;
- if (keyboard_protocol) {
- data = (uint8_t*)report;
- size = KEYBOARD_REPORT_SIZE;
- } else { /* boot protocol */
- data = &report->mods;
- size = 8;
+ { /* regular protocol */
+ /* need to wait until the previous packet has made it through */
+ /* busy wait, should be short and not very common */
+ osalSysLock();
+ 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);
+ }
+ 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);
+ osalSysUnlock();
}
- usbStartTransmitI(&USB_DRIVER, KEYBOARD_IN_EPNUM, data, size);
- osalSysUnlock();
- }
- keyboard_report_sent = *report;
+ keyboard_report_sent = *report;
}
/* ---------------------------------------------------------
@@ -684,39 +672,37 @@ void send_keyboard(report_keyboard_t *report) {
#ifdef MOUSE_ENABLE
-#ifndef MOUSE_SHARED_EP
+# 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;
+ (void)usbp;
+ (void)ep;
}
-#endif
+# 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, MS2ST(10))==MSG_TIMEOUT) {
- osalSysUnlock();
- return;
+ osalSysLock();
+ if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+ 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;
+ 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, MS2ST(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 */
/* ---------------------------------------------------------
@@ -726,9 +712,9 @@ void send_mouse(report_mouse_t *report) {
#ifdef SHARED_EP_ENABLE
/* shared IN callback hander */
void shared_in_cb(USBDriver *usbp, usbep_t ep) {
- /* STUB */
- (void)usbp;
- (void)ep;
+ /* STUB */
+ (void)usbp;
+ (void)ep;
}
#endif
@@ -739,36 +725,25 @@ void shared_in_cb(USBDriver *usbp, usbep_t ep) {
#ifdef EXTRAKEY_ENABLE
static void send_extra_report(uint8_t report_id, uint16_t data) {
- osalSysLock();
- if(usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
- osalSysUnlock();
- return;
- }
+ osalSysLock();
+ if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) {
+ osalSysUnlock();
+ return;
+ }
- report_extra_t report = {
- .report_id = report_id,
- .usage = data
- };
+ report_extra_t report = {.report_id = report_id, .usage = data};
- usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)&report, sizeof(report_extra_t));
- osalSysUnlock();
+ usbStartTransmitI(&USB_DRIVER, SHARED_IN_EPNUM, (uint8_t *)&report, sizeof(report_extra_t));
+ osalSysUnlock();
}
-void send_system(uint16_t data) {
- send_extra_report(REPORT_ID_SYSTEM, data);
-}
+void send_system(uint16_t data) { send_extra_report(REPORT_ID_SYSTEM, data); }
-void send_consumer(uint16_t data) {
- send_extra_report(REPORT_ID_CONSUMER, data);
-}
+void send_consumer(uint16_t data) { send_extra_report(REPORT_ID_CONSUMER, data); }
-#else /* EXTRAKEY_ENABLE */
-void send_system(uint16_t data) {
- (void)data;
-}
-void send_consumer(uint16_t data) {
- (void)data;
-}
+#else /* EXTRAKEY_ENABLE */
+void send_system(uint16_t data) { (void)data; }
+void send_consumer(uint16_t data) { (void)data; }
#endif /* EXTRAKEY_ENABLE */
/* ---------------------------------------------------------
@@ -779,106 +754,97 @@ void send_consumer(uint16_t data) {
#ifdef CONSOLE_ENABLE
int8_t sendchar(uint8_t c) {
- // The previous implmentation had timeouts, but I think it's better to just slow down
- // and make sure that everything is transferred, rather than dropping stuff
- return chnWrite(&drivers.console_driver.driver, &c, 1);
+ // The previous implmentation had timeouts, but I think it's better to just slow down
+ // and make sure that everything is transferred, rather than dropping stuff
+ return chnWrite(&drivers.console_driver.driver, &c, 1);
}
// 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;
+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);
+ 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);
}
-#else /* CONSOLE_ENABLE */
+#else /* CONSOLE_ENABLE */
int8_t sendchar(uint8_t c) {
- (void)c;
- return 0;
+ (void)c;
+ return 0;
}
#endif /* CONSOLE_ENABLE */
void sendchar_pf(void *p, char c) {
- (void)p;
- sendchar((uint8_t)c);
+ (void)p;
+ sendchar((uint8_t)c);
}
#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);
+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.
+__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);
+ 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));
-}
+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);
+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);
}
#endif
#ifdef VIRTSER_ENABLE
-void virtser_send(const uint8_t byte) {
- chnWrite(&drivers.serial_driver.driver, &byte, 1);
-}
+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
+__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);
+ 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
diff --git a/tmk_core/protocol/chibios/usb_main.h b/tmk_core/protocol/chibios/usb_main.h
index 55e8882cc4..cd2bb695ba 100644
--- a/tmk_core/protocol/chibios/usb_main.h
+++ b/tmk_core/protocol/chibios/usb_main.h
@@ -15,7 +15,6 @@
* GPL v2 or later.
*/
-
#ifndef _USB_MAIN_H_
#define _USB_MAIN_H_
@@ -82,9 +81,9 @@ void shared_in_cb(USBDriver *usbp, usbep_t ep);
/* extra report structure */
typedef struct {
- uint8_t report_id;
- uint16_t usage;
-} __attribute__ ((packed)) report_extra_t;
+ uint8_t report_id;
+ uint16_t usage;
+} __attribute__((packed)) report_extra_t;
#endif /* EXTRAKEY_ENABLE */
/* --------------