clang-format changes

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 */
 
 /* --------------