clang-format changes

9 files changed, 937 insertions, 1000 deletions

diff --git a/tmk_core/protocol/vusb/main.c b/tmk_core/protocol/vusb/main.c
index 86c2188c87..f8322d94ac 100644
--- a/tmk_core/protocol/vusb/main.c
+++ b/tmk_core/protocol/vusb/main.c
@@ -21,19 +21,16 @@
 #include "uart.h"
 #include "debug.h"
 
-
 #define UART_BAUD_RATE 115200
 
-
 /* This is from main.c of USBaspLoader */
-static void initForUsbConnectivity(void)
-{
+static void initForUsbConnectivity(void) {
     uint8_t i = 0;
 
     usbInit();
     /* enforce USB re-enumerate: */
-    usbDeviceDisconnect();  /* do this while interrupts are disabled */
-    while(--i){         /* fake USB disconnect for > 250 ms */
+    usbDeviceDisconnect(); /* do this while interrupts are disabled */
+    while (--i) {          /* fake USB disconnect for > 250 ms */
         wdt_reset();
         _delay_ms(1);
     }
@@ -41,8 +38,7 @@ static void initForUsbConnectivity(void)
     sei();
 }
 
-int main(void)
-{
+int main(void) {
     bool suspended = false;
 #if USB_COUNT_SOF
     uint16_t last_timer = timer_read();
@@ -68,26 +64,26 @@ int main(void)
     while (1) {
 #if USB_COUNT_SOF
         if (usbSofCount != 0) {
-            suspended = false;
+            suspended   = false;
             usbSofCount = 0;
-            last_timer = timer_read();
+            last_timer  = timer_read();
         } else {
             // Suspend when no SOF in 3ms-10ms(7.1.7.4 Suspending of USB1.1)
             if (timer_elapsed(last_timer) > 5) {
                 suspended = true;
-/*
-                uart_putchar('S');
-                _delay_ms(1);
-                cli();
-                set_sleep_mode(SLEEP_MODE_PWR_DOWN);
-                sleep_enable();
-                sleep_bod_disable();
-                sei();
-                sleep_cpu();
-                sleep_disable();
-                _delay_ms(10);
-                uart_putchar('W');
-*/
+                /*
+                                uart_putchar('S');
+                                _delay_ms(1);
+                                cli();
+                                set_sleep_mode(SLEEP_MODE_PWR_DOWN);
+                                sleep_enable();
+                                sleep_bod_disable();
+                                sei();
+                                sleep_cpu();
+                                sleep_disable();
+                                _delay_ms(10);
+                                uart_putchar('W');
+                */
             }
         }
 #endif
diff --git a/tmk_core/protocol/vusb/sendchar_usart.c b/tmk_core/protocol/vusb/sendchar_usart.c
index 8d24f87d1e..42bd9ee363 100644
--- a/tmk_core/protocol/vusb/sendchar_usart.c
+++ b/tmk_core/protocol/vusb/sendchar_usart.c
@@ -6,18 +6,14 @@
 #include "oddebug.h"
 #include "sendchar.h"
 
-
 #if DEBUG_LEVEL > 0
 /* from oddebug.c */
-int8_t sendchar(uint8_t c)
-{
-    while(!(ODDBG_USR & (1 << ODDBG_UDRE)));    /* wait for data register empty */
+int8_t sendchar(uint8_t c) {
+    while (!(ODDBG_USR & (1 << ODDBG_UDRE)))
+        ; /* wait for data register empty */
     ODDBG_UDR = c;
     return 1;
 }
 #else
-int8_t sendchar(uint8_t c)
-{
-    return 1;
-}
+int8_t sendchar(uint8_t c) { return 1; }
 #endif
diff --git a/tmk_core/protocol/vusb/usbdrv/oddebug.c b/tmk_core/protocol/vusb/usbdrv/oddebug.c
index 945457c1f4..bcd28ff014 100644
--- a/tmk_core/protocol/vusb/usbdrv/oddebug.c
+++ b/tmk_core/protocol/vusb/usbdrv/oddebug.c
@@ -12,34 +12,30 @@
 
 #if DEBUG_LEVEL > 0
 
-#warning "Never compile production devices with debugging enabled"
+#    warning "Never compile production devices with debugging enabled"
 
-static void uartPutc(char c)
-{
-    while(!(ODDBG_USR & (1 << ODDBG_UDRE)));    /* wait for data register empty */
+static void uartPutc(char c) {
+    while (!(ODDBG_USR & (1 << ODDBG_UDRE)))
+        ; /* wait for data register empty */
     ODDBG_UDR = c;
 }
 
-static uchar    hexAscii(uchar h)
-{
+static uchar hexAscii(uchar h) {
     h &= 0xf;
-    if(h >= 10)
-        h += 'a' - (uchar)10 - '0';
+    if (h >= 10) h += 'a' - (uchar)10 - '0';
     h += '0';
     return h;
 }
 
-static void printHex(uchar c)
-{
+static void printHex(uchar c) {
     uartPutc(hexAscii(c >> 4));
     uartPutc(hexAscii(c));
 }
 
-void    odDebug(uchar prefix, uchar *data, uchar len)
-{
+void odDebug(uchar prefix, uchar *data, uchar len) {
     printHex(prefix);
     uartPutc(':');
-    while(len--){
+    while (len--) {
         uartPutc(' ');
         printHex(*data++);
     }
diff --git a/tmk_core/protocol/vusb/usbdrv/oddebug.h b/tmk_core/protocol/vusb/usbdrv/oddebug.h
index d61309daac..f93f338794 100644
--- a/tmk_core/protocol/vusb/usbdrv/oddebug.h
+++ b/tmk_core/protocol/vusb/usbdrv/oddebug.h
@@ -23,39 +23,38 @@ A debug log consists of a label ('prefix') to indicate which debug log created
 the output and a memory block to dump in hex ('data' and 'len').
 */
 
-
 #ifndef F_CPU
-#   define  F_CPU   12000000    /* 12 MHz */
+#    define F_CPU 12000000 /* 12 MHz */
 #endif
 
 /* make sure we have the UART defines: */
 #include "usbportability.h"
 
 #ifndef uchar
-#   define  uchar   unsigned char
+#    define uchar unsigned char
 #endif
 
 #if DEBUG_LEVEL > 0 && !(defined TXEN || defined TXEN0) /* no UART in device */
-#   warning "Debugging disabled because device has no UART"
-#   undef   DEBUG_LEVEL
+#    warning "Debugging disabled because device has no UART"
+#    undef DEBUG_LEVEL
 #endif
 
 #ifndef DEBUG_LEVEL
-#   define  DEBUG_LEVEL 0
+#    define DEBUG_LEVEL 0
 #endif
 
 /* ------------------------------------------------------------------------- */
 
 #if DEBUG_LEVEL > 0
-#   define  DBG1(prefix, data, len) odDebug(prefix, data, len)
+#    define DBG1(prefix, data, len) odDebug(prefix, data, len)
 #else
-#   define  DBG1(prefix, data, len)
+#    define DBG1(prefix, data, len)
 #endif
 
 #if DEBUG_LEVEL > 1
-#   define  DBG2(prefix, data, len) odDebug(prefix, data, len)
+#    define DBG2(prefix, data, len) odDebug(prefix, data, len)
 #else
-#   define  DBG2(prefix, data, len)
+#    define DBG2(prefix, data, len)
 #endif
 
 /* ------------------------------------------------------------------------- */
@@ -65,57 +64,56 @@ extern void odDebug(uchar prefix, uchar *data, uchar len);
 
 /* Try to find our control registers; ATMEL likes to rename these */
 
-#if defined UBRR
-#   define  ODDBG_UBRR  UBRR
-#elif defined UBRRL
-#   define  ODDBG_UBRR  UBRRL
-#elif defined UBRR0
-#   define  ODDBG_UBRR  UBRR0
-#elif defined UBRR0L
-#   define  ODDBG_UBRR  UBRR0L
-#endif
-
-#if defined UCR
-#   define  ODDBG_UCR   UCR
-#elif defined UCSRB
-#   define  ODDBG_UCR   UCSRB
-#elif defined UCSR0B
-#   define  ODDBG_UCR   UCSR0B
-#endif
-
-#if defined TXEN
-#   define  ODDBG_TXEN  TXEN
-#else
-#   define  ODDBG_TXEN  TXEN0
-#endif
-
-#if defined USR
-#   define  ODDBG_USR   USR
-#elif defined UCSRA
-#   define  ODDBG_USR   UCSRA
-#elif defined UCSR0A
-#   define  ODDBG_USR   UCSR0A
-#endif
-
-#if defined UDRE
-#   define  ODDBG_UDRE  UDRE
-#else
-#   define  ODDBG_UDRE  UDRE0
-#endif
-
-#if defined UDR
-#   define  ODDBG_UDR   UDR
-#elif defined UDR0
-#   define  ODDBG_UDR   UDR0
-#endif
-
-static inline void  odDebugInit(void)
-{
-    ODDBG_UCR |= (1<<ODDBG_TXEN);
+#    if defined UBRR
+#        define ODDBG_UBRR UBRR
+#    elif defined UBRRL
+#        define ODDBG_UBRR UBRRL
+#    elif defined UBRR0
+#        define ODDBG_UBRR UBRR0
+#    elif defined UBRR0L
+#        define ODDBG_UBRR UBRR0L
+#    endif
+
+#    if defined UCR
+#        define ODDBG_UCR UCR
+#    elif defined UCSRB
+#        define ODDBG_UCR UCSRB
+#    elif defined UCSR0B
+#        define ODDBG_UCR UCSR0B
+#    endif
+
+#    if defined TXEN
+#        define ODDBG_TXEN TXEN
+#    else
+#        define ODDBG_TXEN TXEN0
+#    endif
+
+#    if defined USR
+#        define ODDBG_USR USR
+#    elif defined UCSRA
+#        define ODDBG_USR UCSRA
+#    elif defined UCSR0A
+#        define ODDBG_USR UCSR0A
+#    endif
+
+#    if defined UDRE
+#        define ODDBG_UDRE UDRE
+#    else
+#        define ODDBG_UDRE UDRE0
+#    endif
+
+#    if defined UDR
+#        define ODDBG_UDR UDR
+#    elif defined UDR0
+#        define ODDBG_UDR UDR0
+#    endif
+
+static inline void odDebugInit(void) {
+    ODDBG_UCR |= (1 << ODDBG_TXEN);
     ODDBG_UBRR = F_CPU / (19200 * 16L) - 1;
 }
 #else
-#   define odDebugInit()
+#    define odDebugInit()
 #endif
 
 /* ------------------------------------------------------------------------- */
diff --git a/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h b/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h
index 847710e2a0..020ea51474 100644
--- a/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h
+++ b/tmk_core/protocol/vusb/usbdrv/usbconfig-prototype.h
@@ -26,15 +26,15 @@ section at the end of this file).
 
 /* ---------------------------- Hardware Config ---------------------------- */
 
-#define USB_CFG_IOPORTNAME      D
+#define USB_CFG_IOPORTNAME D
 /* This is the port where the USB bus is connected. When you configure it to
  * "B", the registers PORTB, PINB and DDRB will be used.
  */
-#define USB_CFG_DMINUS_BIT      4
+#define USB_CFG_DMINUS_BIT 4
 /* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected.
  * This may be any bit in the port.
  */
-#define USB_CFG_DPLUS_BIT       2
+#define USB_CFG_DPLUS_BIT 2
 /* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected.
  * This may be any bit in the port. Please note that D+ must also be connected
  * to interrupt pin INT0! [You can also use other interrupts, see section
@@ -43,7 +43,7 @@ section at the end of this file).
  * interrupt, the USB interrupt will also be triggered at Start-Of-Frame
  * markers every millisecond.]
  */
-#define USB_CFG_CLOCK_KHZ       (F_CPU/1000)
+#define USB_CFG_CLOCK_KHZ (F_CPU / 1000)
 /* Clock rate of the AVR in kHz. Legal values are 12000, 12800, 15000, 16000,
  * 16500, 18000 and 20000. The 12.8 MHz and 16.5 MHz versions of the code
  * require no crystal, they tolerate +/- 1% deviation from the nominal
@@ -52,7 +52,7 @@ section at the end of this file).
  * Since F_CPU should be defined to your actual clock rate anyway, you should
  * not need to modify this setting.
  */
-#define USB_CFG_CHECK_CRC       0
+#define USB_CFG_CHECK_CRC 0
 /* Define this to 1 if you want that the driver checks integrity of incoming
  * data packets (CRC checks). CRC checks cost quite a bit of code size and are
  * currently only available for 18 MHz crystal clock. You must choose
@@ -75,18 +75,18 @@ section at the end of this file).
 
 /* --------------------------- Functional Range ---------------------------- */
 
-#define USB_CFG_HAVE_INTRIN_ENDPOINT    0
+#define USB_CFG_HAVE_INTRIN_ENDPOINT 0
 /* Define this to 1 if you want to compile a version with two endpoints: The
  * default control endpoint 0 and an interrupt-in endpoint (any other endpoint
  * number).
  */
-#define USB_CFG_HAVE_INTRIN_ENDPOINT3   0
+#define USB_CFG_HAVE_INTRIN_ENDPOINT3 0
 /* Define this to 1 if you want to compile a version with three endpoints: The
  * default control endpoint 0, an interrupt-in endpoint 3 (or the number
  * configured below) and a catch-all default interrupt-in endpoint as above.
  * You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature.
  */
-#define USB_CFG_EP3_NUMBER              3
+#define USB_CFG_EP3_NUMBER 3
 /* If the so-called endpoint 3 is used, it can now be configured to any other
  * endpoint number (except 0) with this macro. Default if undefined is 3.
  */
@@ -96,13 +96,13 @@ section at the end of this file).
  * Since the token is toggled BEFORE sending any data, the first packet is
  * sent with the oposite value of this configuration!
  */
-#define USB_CFG_IMPLEMENT_HALT          0
+#define USB_CFG_IMPLEMENT_HALT 0
 /* Define this to 1 if you also want to implement the ENDPOINT_HALT feature
  * for endpoint 1 (interrupt endpoint). Although you may not need this feature,
  * it is required by the standard. We have made it a config option because it
  * bloats the code considerably.
  */
-#define USB_CFG_SUPPRESS_INTR_CODE      0
+#define USB_CFG_SUPPRESS_INTR_CODE 0
 /* Define this to 1 if you want to declare interrupt-in endpoints, but don't
  * want to send any data over them. If this macro is defined to 1, functions
  * usbSetInterrupt() and usbSetInterrupt3() are omitted. This is useful if
@@ -110,48 +110,48 @@ section at the end of this file).
  * (e.g. HID), but never want to send any data. This option saves a couple
  * of bytes in flash memory and the transmit buffers in RAM.
  */
-#define USB_CFG_INTR_POLL_INTERVAL      10
+#define USB_CFG_INTR_POLL_INTERVAL 10
 /* If you compile a version with endpoint 1 (interrupt-in), this is the poll
  * interval. The value is in milliseconds and must not be less than 10 ms for
  * low speed devices.
  */
-#define USB_CFG_IS_SELF_POWERED         0
+#define USB_CFG_IS_SELF_POWERED 0
 /* Define this to 1 if the device has its own power supply. Set it to 0 if the
  * device is powered from the USB bus.
  */
-#define USB_CFG_MAX_BUS_POWER           100
+#define USB_CFG_MAX_BUS_POWER 100
 /* Set this variable to the maximum USB bus power consumption of your device.
  * The value is in milliamperes. [It will be divided by two since USB
  * communicates power requirements in units of 2 mA.]
  */
-#define USB_CFG_IMPLEMENT_FN_WRITE      0
+#define USB_CFG_IMPLEMENT_FN_WRITE 0
 /* Set this to 1 if you want usbFunctionWrite() to be called for control-out
  * transfers. Set it to 0 if you don't need it and want to save a couple of
  * bytes.
  */
-#define USB_CFG_IMPLEMENT_FN_READ       0
+#define USB_CFG_IMPLEMENT_FN_READ 0
 /* Set this to 1 if you need to send control replies which are generated
  * "on the fly" when usbFunctionRead() is called. If you only want to send
  * data from a static buffer, set it to 0 and return the data from
  * usbFunctionSetup(). This saves a couple of bytes.
  */
-#define USB_CFG_IMPLEMENT_FN_WRITEOUT   0
+#define USB_CFG_IMPLEMENT_FN_WRITEOUT 0
 /* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints.
  * You must implement the function usbFunctionWriteOut() which receives all
  * interrupt/bulk data sent to any endpoint other than 0. The endpoint number
  * can be found in 'usbRxToken'.
  */
-#define USB_CFG_HAVE_FLOWCONTROL        0
+#define USB_CFG_HAVE_FLOWCONTROL 0
 /* Define this to 1 if you want flowcontrol over USB data. See the definition
  * of the macros usbDisableAllRequests() and usbEnableAllRequests() in
  * usbdrv.h.
  */
-#define USB_CFG_DRIVER_FLASH_PAGE       0
+#define USB_CFG_DRIVER_FLASH_PAGE 0
 /* If the device has more than 64 kBytes of flash, define this to the 64 k page
  * where the driver's constants (descriptors) are located. Or in other words:
  * Define this to 1 for boot loaders on the ATMega128.
  */
-#define USB_CFG_LONG_TRANSFERS          0
+#define USB_CFG_LONG_TRANSFERS 0
 /* Define this to 1 if you want to send/receive blocks of more than 254 bytes
  * in a single control-in or control-out transfer. Note that the capability
  * for long transfers increases the driver size.
@@ -172,7 +172,7 @@ section at the end of this file).
 /* This macro (if defined) is executed when a USB SET_ADDRESS request was
  * received.
  */
-#define USB_COUNT_SOF                   0
+#define USB_COUNT_SOF 0
 /* define this macro to 1 if you need the global variable "usbSofCount" which
  * counts SOF packets. This feature requires that the hardware interrupt is
  * connected to D- instead of D+.
@@ -196,7 +196,7 @@ section at the end of this file).
  * Please note that Start Of Frame detection works only if D- is wired to the
  * interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES!
  */
-#define USB_CFG_CHECK_DATA_TOGGLING     0
+#define USB_CFG_CHECK_DATA_TOGGLING 0
 /* define this macro to 1 if you want to filter out duplicate data packets
  * sent by the host. Duplicates occur only as a consequence of communication
  * errors, when the host does not receive an ACK. Please note that you need to
@@ -204,11 +204,11 @@ section at the end of this file).
  * usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable
  * for each control- and out-endpoint to check for duplicate packets.
  */
-#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH   0
+#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH 0
 /* define this macro to 1 if you want the function usbMeasureFrameLength()
  * compiled in. This function can be used to calibrate the AVR's RC oscillator.
  */
-#define USB_USE_FAST_CRC                0
+#define USB_USE_FAST_CRC 0
 /* The assembler module has two implementations for the CRC algorithm. One is
  * faster, the other is smaller. This CRC routine is only used for transmitted
  * messages where timing is not critical. The faster routine needs 31 cycles
@@ -219,7 +219,7 @@ section at the end of this file).
 
 /* -------------------------- Device Description --------------------------- */
 
-#define  USB_CFG_VENDOR_ID       0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */
+#define USB_CFG_VENDOR_ID 0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */
 /* USB vendor ID for the device, low byte first. If you have registered your
  * own Vendor ID, define it here. Otherwise you may use one of obdev's free
  * shared VID/PID pairs. Be sure to read USB-IDs-for-free.txt for rules!
@@ -228,7 +228,7 @@ section at the end of this file).
  * with libusb: 0x16c0/0x5dc.  Use this VID/PID pair ONLY if you understand
  * the implications!
  */
-#define  USB_CFG_DEVICE_ID       0xdc, 0x05 /* = 0x05dc = 1500 */
+#define USB_CFG_DEVICE_ID 0xdc, 0x05 /* = 0x05dc = 1500 */
 /* This is the ID of the product, low byte first. It is interpreted in the
  * scope of the vendor ID. If you have registered your own VID with usb.org
  * or if you have licensed a PID from somebody else, define it here. Otherwise
@@ -239,10 +239,10 @@ section at the end of this file).
  * with libusb: 0x16c0/0x5dc.  Use this VID/PID pair ONLY if you understand
  * the implications!
  */
-#define USB_CFG_DEVICE_VERSION  0x00, 0x01
+#define USB_CFG_DEVICE_VERSION 0x00, 0x01
 /* Version number of the device: Minor number first, then major number.
  */
-#define USB_CFG_VENDOR_NAME     'o', 'b', 'd', 'e', 'v', '.', 'a', 't'
+#define USB_CFG_VENDOR_NAME 'o', 'b', 'd', 'e', 'v', '.', 'a', 't'
 #define USB_CFG_VENDOR_NAME_LEN 8
 /* These two values define the vendor name returned by the USB device. The name
  * must be given as a list of characters under single quotes. The characters
@@ -252,7 +252,7 @@ section at the end of this file).
  * obdev's free shared VID/PID pair. See the file USB-IDs-for-free.txt for
  * details.
  */
-#define USB_CFG_DEVICE_NAME     'T', 'e', 'm', 'p', 'l', 'a', 't', 'e'
+#define USB_CFG_DEVICE_NAME 'T', 'e', 'm', 'p', 'l', 'a', 't', 'e'
 #define USB_CFG_DEVICE_NAME_LEN 8
 /* Same as above for the device name. If you don't want a device name, undefine
  * the macros. See the file USB-IDs-for-free.txt before you assign a name if
@@ -267,14 +267,14 @@ section at the end of this file).
  * to fine tune control over USB descriptors such as the string descriptor
  * for the serial number.
  */
-#define USB_CFG_DEVICE_CLASS        0xff    /* set to 0 if deferred to interface */
-#define USB_CFG_DEVICE_SUBCLASS     0
+#define USB_CFG_DEVICE_CLASS 0xff /* set to 0 if deferred to interface */
+#define USB_CFG_DEVICE_SUBCLASS 0
 /* See USB specification if you want to conform to an existing device class.
  * Class 0xff is "vendor specific".
  */
-#define USB_CFG_INTERFACE_CLASS     0   /* define class here if not at device level */
-#define USB_CFG_INTERFACE_SUBCLASS  0
-#define USB_CFG_INTERFACE_PROTOCOL  0
+#define USB_CFG_INTERFACE_CLASS 0 /* define class here if not at device level */
+#define USB_CFG_INTERFACE_SUBCLASS 0
+#define USB_CFG_INTERFACE_PROTOCOL 0
 /* See USB specification if you want to conform to an existing device class or
  * protocol. The following classes must be set at interface level:
  * HID class is 3, no subclass and protocol required (but may be useful!)
@@ -345,16 +345,16 @@ section at the end of this file).
  * };
  */
 
-#define USB_CFG_DESCR_PROPS_DEVICE                  0
-#define USB_CFG_DESCR_PROPS_CONFIGURATION           0
-#define USB_CFG_DESCR_PROPS_STRINGS                 0
-#define USB_CFG_DESCR_PROPS_STRING_0                0
-#define USB_CFG_DESCR_PROPS_STRING_VENDOR           0
-#define USB_CFG_DESCR_PROPS_STRING_PRODUCT          0
-#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    0
-#define USB_CFG_DESCR_PROPS_HID                     0
-#define USB_CFG_DESCR_PROPS_HID_REPORT              0
-#define USB_CFG_DESCR_PROPS_UNKNOWN                 0
+#define USB_CFG_DESCR_PROPS_DEVICE 0
+#define USB_CFG_DESCR_PROPS_CONFIGURATION 0
+#define USB_CFG_DESCR_PROPS_STRINGS 0
+#define USB_CFG_DESCR_PROPS_STRING_0 0
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR 0
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0
+#define USB_CFG_DESCR_PROPS_HID 0
+#define USB_CFG_DESCR_PROPS_HID_REPORT 0
+#define USB_CFG_DESCR_PROPS_UNKNOWN 0
 
 /* ----------------------- Optional MCU Description ------------------------ */
 
diff --git a/tmk_core/protocol/vusb/usbdrv/usbdrv.c b/tmk_core/protocol/vusb/usbdrv/usbdrv.c
index 30cdc9dcfc..f69198b1b9 100644
--- a/tmk_core/protocol/vusb/usbdrv/usbdrv.c
+++ b/tmk_core/protocol/vusb/usbdrv/usbdrv.c
@@ -21,36 +21,36 @@ documentation of the entire driver.
 /* ------------------------------------------------------------------------- */
 
 /* raw USB registers / interface to assembler code: */
-uchar usbRxBuf[2*USB_BUFSIZE];  /* raw RX buffer: PID, 8 bytes data, 2 bytes CRC */
-uchar       usbInputBufOffset;  /* offset in usbRxBuf used for low level receiving */
-uchar       usbDeviceAddr;      /* assigned during enumeration, defaults to 0 */
-uchar       usbNewDeviceAddr;   /* device ID which should be set after status phase */
-uchar       usbConfiguration;   /* currently selected configuration. Administered by driver, but not used */
-volatile schar usbRxLen;        /* = 0; number of bytes in usbRxBuf; 0 means free, -1 for flow control */
-uchar       usbCurrentTok;      /* last token received or endpoint number for last OUT token if != 0 */
-uchar       usbRxToken;         /* token for data we received; or endpont number for last OUT */
-volatile uchar usbTxLen = USBPID_NAK;   /* number of bytes to transmit with next IN token or handshake token */
-uchar       usbTxBuf[USB_BUFSIZE];/* data to transmit with next IN, free if usbTxLen contains handshake token */
+uchar          usbRxBuf[2 * USB_BUFSIZE]; /* raw RX buffer: PID, 8 bytes data, 2 bytes CRC */
+uchar          usbInputBufOffset;         /* offset in usbRxBuf used for low level receiving */
+uchar          usbDeviceAddr;             /* assigned during enumeration, defaults to 0 */
+uchar          usbNewDeviceAddr;          /* device ID which should be set after status phase */
+uchar          usbConfiguration;          /* currently selected configuration. Administered by driver, but not used */
+volatile schar usbRxLen;                  /* = 0; number of bytes in usbRxBuf; 0 means free, -1 for flow control */
+uchar          usbCurrentTok;             /* last token received or endpoint number for last OUT token if != 0 */
+uchar          usbRxToken;                /* token for data we received; or endpont number for last OUT */
+volatile uchar usbTxLen = USBPID_NAK;     /* number of bytes to transmit with next IN token or handshake token */
+uchar          usbTxBuf[USB_BUFSIZE];     /* data to transmit with next IN, free if usbTxLen contains handshake token */
 #if USB_COUNT_SOF
-volatile uchar  usbSofCount;    /* incremented by assembler module every SOF */
+volatile uchar usbSofCount; /* incremented by assembler module every SOF */
 #endif
 #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
-usbTxStatus_t  usbTxStatus1;
-#   if USB_CFG_HAVE_INTRIN_ENDPOINT3
-usbTxStatus_t  usbTxStatus3;
-#   endif
+usbTxStatus_t usbTxStatus1;
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3
+usbTxStatus_t usbTxStatus3;
+#    endif
 #endif
 #if USB_CFG_CHECK_DATA_TOGGLING
-uchar       usbCurrentDataToken;/* when we check data toggling to ignore duplicate packets */
+uchar usbCurrentDataToken; /* when we check data toggling to ignore duplicate packets */
 #endif
 
 /* USB status registers / not shared with asm code */
-uchar               *usbMsgPtr;     /* data to transmit next -- ROM or RAM address */
-static usbMsgLen_t  usbMsgLen = USB_NO_MSG; /* remaining number of bytes */
-static uchar        usbMsgFlags;    /* flag values see below */
+uchar *            usbMsgPtr;              /* data to transmit next -- ROM or RAM address */
+static usbMsgLen_t usbMsgLen = USB_NO_MSG; /* remaining number of bytes */
+static uchar       usbMsgFlags;            /* flag values see below */
 
-#define USB_FLG_MSGPTR_IS_ROM   (1<<6)
-#define USB_FLG_USE_USER_RW     (1<<7)
+#define USB_FLG_MSGPTR_IS_ROM (1 << 6)
+#define USB_FLG_USE_USER_RW (1 << 7)
 
 /*
 optimizing hints:
@@ -64,196 +64,174 @@ optimizing hints:
 
 #if USB_CFG_DESCR_PROPS_STRINGS == 0
 
-#if USB_CFG_DESCR_PROPS_STRING_0 == 0
-#undef USB_CFG_DESCR_PROPS_STRING_0
-#define USB_CFG_DESCR_PROPS_STRING_0    sizeof(usbDescriptorString0)
-const PROGMEM char usbDescriptorString0[] = { /* language descriptor */
+#    if USB_CFG_DESCR_PROPS_STRING_0 == 0
+#        undef USB_CFG_DESCR_PROPS_STRING_0
+#        define USB_CFG_DESCR_PROPS_STRING_0 sizeof(usbDescriptorString0)
+const PROGMEM char usbDescriptorString0[] = {
+    /* language descriptor */
     4,          /* sizeof(usbDescriptorString0): length of descriptor in bytes */
     3,          /* descriptor type */
     0x09, 0x04, /* language index (0x0409 = US-English) */
 };
-#endif
+#    endif
 
-#if USB_CFG_DESCR_PROPS_STRING_VENDOR == 0 && USB_CFG_VENDOR_NAME_LEN
-#undef USB_CFG_DESCR_PROPS_STRING_VENDOR
-#define USB_CFG_DESCR_PROPS_STRING_VENDOR   sizeof(usbDescriptorStringVendor)
-const PROGMEM int  usbDescriptorStringVendor[] = {
-    USB_STRING_DESCRIPTOR_HEADER(USB_CFG_VENDOR_NAME_LEN),
-    USB_CFG_VENDOR_NAME
-};
-#endif
+#    if USB_CFG_DESCR_PROPS_STRING_VENDOR == 0 && USB_CFG_VENDOR_NAME_LEN
+#        undef USB_CFG_DESCR_PROPS_STRING_VENDOR
+#        define USB_CFG_DESCR_PROPS_STRING_VENDOR sizeof(usbDescriptorStringVendor)
+const PROGMEM int usbDescriptorStringVendor[] = {USB_STRING_DESCRIPTOR_HEADER(USB_CFG_VENDOR_NAME_LEN), USB_CFG_VENDOR_NAME};
+#    endif
 
-#if USB_CFG_DESCR_PROPS_STRING_PRODUCT == 0 && USB_CFG_DEVICE_NAME_LEN
-#undef USB_CFG_DESCR_PROPS_STRING_PRODUCT
-#define USB_CFG_DESCR_PROPS_STRING_PRODUCT   sizeof(usbDescriptorStringDevice)
-const PROGMEM int  usbDescriptorStringDevice[] = {
-    USB_STRING_DESCRIPTOR_HEADER(USB_CFG_DEVICE_NAME_LEN),
-    USB_CFG_DEVICE_NAME
-};
-#endif
+#    if USB_CFG_DESCR_PROPS_STRING_PRODUCT == 0 && USB_CFG_DEVICE_NAME_LEN
+#        undef USB_CFG_DESCR_PROPS_STRING_PRODUCT
+#        define USB_CFG_DESCR_PROPS_STRING_PRODUCT sizeof(usbDescriptorStringDevice)
+const PROGMEM int usbDescriptorStringDevice[] = {USB_STRING_DESCRIPTOR_HEADER(USB_CFG_DEVICE_NAME_LEN), USB_CFG_DEVICE_NAME};
+#    endif
 
-#if USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER == 0 && USB_CFG_SERIAL_NUMBER_LEN
-#undef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
-#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    sizeof(usbDescriptorStringSerialNumber)
-const PROGMEM int usbDescriptorStringSerialNumber[] = {
-    USB_STRING_DESCRIPTOR_HEADER(USB_CFG_SERIAL_NUMBER_LEN),
-    USB_CFG_SERIAL_NUMBER
-};
-#endif
+#    if USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER == 0 && USB_CFG_SERIAL_NUMBER_LEN
+#        undef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+#        define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER sizeof(usbDescriptorStringSerialNumber)
+const PROGMEM int usbDescriptorStringSerialNumber[] = {USB_STRING_DESCRIPTOR_HEADER(USB_CFG_SERIAL_NUMBER_LEN), USB_CFG_SERIAL_NUMBER};
+#    endif
 
-#endif  /* USB_CFG_DESCR_PROPS_STRINGS == 0 */
+#endif /* USB_CFG_DESCR_PROPS_STRINGS == 0 */
 
 /* --------------------------- Device Descriptor --------------------------- */
 
 #if USB_CFG_DESCR_PROPS_DEVICE == 0
-#undef USB_CFG_DESCR_PROPS_DEVICE
-#define USB_CFG_DESCR_PROPS_DEVICE  sizeof(usbDescriptorDevice)
-const PROGMEM char usbDescriptorDevice[] = {    /* USB device descriptor */
-    18,         /* sizeof(usbDescriptorDevice): length of descriptor in bytes */
-    USBDESCR_DEVICE,        /* descriptor type */
-    0x10, 0x01,             /* USB version supported */
-    USB_CFG_DEVICE_CLASS,
-    USB_CFG_DEVICE_SUBCLASS,
-    0,                      /* protocol */
-    8,                      /* max packet size */
+#    undef USB_CFG_DESCR_PROPS_DEVICE
+#    define USB_CFG_DESCR_PROPS_DEVICE sizeof(usbDescriptorDevice)
+const PROGMEM char usbDescriptorDevice[] = {
+    /* USB device descriptor */
+    18,                                               /* sizeof(usbDescriptorDevice): length of descriptor in bytes */
+    USBDESCR_DEVICE,                                  /* descriptor type */
+    0x10, 0x01,                                       /* USB version supported */
+    USB_CFG_DEVICE_CLASS, USB_CFG_DEVICE_SUBCLASS, 0, /* protocol */
+    8,                                                /* max packet size */
     /* the following two casts affect the first byte of the constant only, but
      * that's sufficient to avoid a warning with the default values.
      */
-    (char)USB_CFG_VENDOR_ID,/* 2 bytes */
-    (char)USB_CFG_DEVICE_ID,/* 2 bytes */
-    USB_CFG_DEVICE_VERSION, /* 2 bytes */
-    USB_CFG_DESCR_PROPS_STRING_VENDOR != 0 ? 1 : 0,         /* manufacturer string index */
-    USB_CFG_DESCR_PROPS_STRING_PRODUCT != 0 ? 2 : 0,        /* product string index */
-    USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER != 0 ? 3 : 0,  /* serial number string index */
-    1,          /* number of configurations */
+    (char)USB_CFG_VENDOR_ID,                               /* 2 bytes */
+    (char)USB_CFG_DEVICE_ID,                               /* 2 bytes */
+    USB_CFG_DEVICE_VERSION,                                /* 2 bytes */
+    USB_CFG_DESCR_PROPS_STRING_VENDOR != 0 ? 1 : 0,        /* manufacturer string index */
+    USB_CFG_DESCR_PROPS_STRING_PRODUCT != 0 ? 2 : 0,       /* product string index */
+    USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER != 0 ? 3 : 0, /* serial number string index */
+    1,                                                     /* number of configurations */
 };
 #endif
 
 /* ----------------------- Configuration Descriptor ------------------------ */
 
 #if USB_CFG_DESCR_PROPS_HID_REPORT != 0 && USB_CFG_DESCR_PROPS_HID == 0
-#undef USB_CFG_DESCR_PROPS_HID
-#define USB_CFG_DESCR_PROPS_HID     9   /* length of HID descriptor in config descriptor below */
+#    undef USB_CFG_DESCR_PROPS_HID
+#    define USB_CFG_DESCR_PROPS_HID 9 /* length of HID descriptor in config descriptor below */
 #endif
 
 #if USB_CFG_DESCR_PROPS_CONFIGURATION == 0
-#undef USB_CFG_DESCR_PROPS_CONFIGURATION
-#define USB_CFG_DESCR_PROPS_CONFIGURATION   sizeof(usbDescriptorConfiguration)
-PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor */
-    9,          /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */
-    USBDESCR_CONFIG,    /* descriptor type */
-    18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 +
-                (USB_CFG_DESCR_PROPS_HID & 0xff), 0,
-                /* total length of data returned (including inlined descriptors) */
-    1,          /* number of interfaces in this configuration */
-    1,          /* index of this configuration */
-    0,          /* configuration name string index */
-#if USB_CFG_IS_SELF_POWERED
-    (1 << 7) | USBATTR_SELFPOWER,       /* attributes */
-#else
-    (1 << 7),                           /* attributes */
-#endif
-    USB_CFG_MAX_BUS_POWER/2,            /* max USB current in 2mA units */
-/* interface descriptor follows inline: */
-    9,          /* sizeof(usbDescrInterface): length of descriptor in bytes */
-    USBDESCR_INTERFACE, /* descriptor type */
-    0,          /* index of this interface */
-    0,          /* alternate setting for this interface */
-    USB_CFG_HAVE_INTRIN_ENDPOINT + USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */
-    USB_CFG_INTERFACE_CLASS,
-    USB_CFG_INTERFACE_SUBCLASS,
-    USB_CFG_INTERFACE_PROTOCOL,
-    0,          /* string index for interface */
-#if (USB_CFG_DESCR_PROPS_HID & 0xff)    /* HID descriptor */
-    9,          /* sizeof(usbDescrHID): length of descriptor in bytes */
-    USBDESCR_HID,   /* descriptor type: HID */
-    0x01, 0x01, /* BCD representation of HID version */
-    0x00,       /* target country code */
-    0x01,       /* number of HID Report (or other HID class) Descriptor infos to follow */
-    0x22,       /* descriptor type: report */
-    USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH, 0,  /* total length of report descriptor */
-#endif
-#if USB_CFG_HAVE_INTRIN_ENDPOINT    /* endpoint descriptor for endpoint 1 */
-    7,          /* sizeof(usbDescrEndpoint) */
-    USBDESCR_ENDPOINT,  /* descriptor type = endpoint */
-    (char)0x81, /* IN endpoint number 1 */
-    0x03,       /* attrib: Interrupt endpoint */
-    8, 0,       /* maximum packet size */
-    USB_CFG_INTR_POLL_INTERVAL, /* in ms */
-#endif
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3   /* endpoint descriptor for endpoint 3 */
-    7,          /* sizeof(usbDescrEndpoint) */
-    USBDESCR_ENDPOINT,  /* descriptor type = endpoint */
+#    undef USB_CFG_DESCR_PROPS_CONFIGURATION
+#    define USB_CFG_DESCR_PROPS_CONFIGURATION sizeof(usbDescriptorConfiguration)
+PROGMEM char usbDescriptorConfiguration[] = {
+    /* USB configuration descriptor */
+    9,               /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */
+    USBDESCR_CONFIG, /* descriptor type */
+    18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + (USB_CFG_DESCR_PROPS_HID & 0xff), 0,
+    /* total length of data returned (including inlined descriptors) */
+    1, /* number of interfaces in this configuration */
+    1, /* index of this configuration */
+    0, /* configuration name string index */
+#    if USB_CFG_IS_SELF_POWERED
+    (1 << 7) | USBATTR_SELFPOWER, /* attributes */
+#    else
+    (1 << 7), /* attributes */
+#    endif
+    USB_CFG_MAX_BUS_POWER / 2,                                                          /* max USB current in 2mA units */
+                                                                                        /* interface descriptor follows inline: */
+    9,                                                                                  /* sizeof(usbDescrInterface): length of descriptor in bytes */
+    USBDESCR_INTERFACE,                                                                 /* descriptor type */
+    0,                                                                                  /* index of this interface */
+    0,                                                                                  /* alternate setting for this interface */
+    USB_CFG_HAVE_INTRIN_ENDPOINT + USB_CFG_HAVE_INTRIN_ENDPOINT3,                       /* endpoints excl 0: number of endpoint descriptors to follow */
+    USB_CFG_INTERFACE_CLASS, USB_CFG_INTERFACE_SUBCLASS, USB_CFG_INTERFACE_PROTOCOL, 0, /* string index for interface */
+#    if (USB_CFG_DESCR_PROPS_HID & 0xff)                                                /* HID descriptor */
+    9,                                                                                  /* sizeof(usbDescrHID): length of descriptor in bytes */
+    USBDESCR_HID,                                                                       /* descriptor type: HID */
+    0x01, 0x01,                                                                         /* BCD representation of HID version */
+    0x00,                                                                               /* target country code */
+    0x01,                                                                               /* number of HID Report (or other HID class) Descriptor infos to follow */
+    0x22,                                                                               /* descriptor type: report */
+    USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH, 0,                                            /* total length of report descriptor */
+#    endif
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT /* endpoint descriptor for endpoint 1 */
+    7,                               /* sizeof(usbDescrEndpoint) */
+    USBDESCR_ENDPOINT,               /* descriptor type = endpoint */
+    (char)0x81,                      /* IN endpoint number 1 */
+    0x03,                            /* attrib: Interrupt endpoint */
+    8, 0,                            /* maximum packet size */
+    USB_CFG_INTR_POLL_INTERVAL,      /* in ms */
+#    endif
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3  /* endpoint descriptor for endpoint 3 */
+    7,                                 /* sizeof(usbDescrEndpoint) */
+    USBDESCR_ENDPOINT,                 /* descriptor type = endpoint */
     (char)(0x80 | USB_CFG_EP3_NUMBER), /* IN endpoint number 3 */
-    0x03,       /* attrib: Interrupt endpoint */
-    8, 0,       /* maximum packet size */
-    USB_CFG_INTR_POLL_INTERVAL, /* in ms */
-#endif
+    0x03,                              /* attrib: Interrupt endpoint */
+    8, 0,                              /* maximum packet size */
+    USB_CFG_INTR_POLL_INTERVAL,        /* in ms */
+#    endif
 };
 #endif
 
 /* ------------------------------------------------------------------------- */
 
-static inline void  usbResetDataToggling(void)
-{
+static inline void usbResetDataToggling(void) {
 #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
-    USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN);  /* reset data toggling for interrupt endpoint */
-#   if USB_CFG_HAVE_INTRIN_ENDPOINT3
-    USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN);  /* reset data toggling for interrupt endpoint */
-#   endif
+    USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3
+    USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */
+#    endif
 #endif
 }
 
-static inline void  usbResetStall(void)
-{
+static inline void usbResetStall(void) {
 #if USB_CFG_IMPLEMENT_HALT && USB_CFG_HAVE_INTRIN_ENDPOINT
-        usbTxLen1 = USBPID_NAK;
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-        usbTxLen3 = USBPID_NAK;
-#endif
+    usbTxLen1 = USBPID_NAK;
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3
+    usbTxLen3 = USBPID_NAK;
+#    endif
 #endif
 }
 
 /* ------------------------------------------------------------------------- */
 
 #if !USB_CFG_SUPPRESS_INTR_CODE
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
-static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus)
-{
-uchar   *p;
-char    i;
-
-#if USB_CFG_IMPLEMENT_HALT
-    if(usbTxLen1 == USBPID_STALL)
-        return;
-#endif
-    if(txStatus->len & 0x10){   /* packet buffer was empty */
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT
+static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus) {
+    uchar *p;
+    char   i;
+
+#        if USB_CFG_IMPLEMENT_HALT
+    if (usbTxLen1 == USBPID_STALL) return;
+#        endif
+    if (txStatus->len & 0x10) {                             /* packet buffer was empty */
         txStatus->buffer[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* toggle token */
-    }else{
+    } else {
         txStatus->len = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */
     }
     p = txStatus->buffer + 1;
     i = len;
-    do{                         /* if len == 0, we still copy 1 byte, but that's no problem */
+    do { /* if len == 0, we still copy 1 byte, but that's no problem */
         *p++ = *data++;
-    }while(--i > 0);            /* loop control at the end is 2 bytes shorter than at beginning */
+    } while (--i > 0); /* loop control at the end is 2 bytes shorter than at beginning */
     usbCrc16Append(&txStatus->buffer[1], len);
-    txStatus->len = len + 4;    /* len must be given including sync byte */
+    txStatus->len = len + 4; /* len must be given including sync byte */
     DBG2(0x21 + (((int)txStatus >> 3) & 3), txStatus->buffer, len + 3);
 }
 
-USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len)
-{
-    usbGenericSetInterrupt(data, len, &usbTxStatus1);
-}
-#endif
+USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len) { usbGenericSetInterrupt(data, len, &usbTxStatus1); }
+#    endif
 
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
-USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len)
-{
-    usbGenericSetInterrupt(data, len, &usbTxStatus3);
-}
-#endif
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3
+USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len) { usbGenericSetInterrupt(data, len, &usbTxStatus3); }
+#    endif
 #endif /* USB_CFG_SUPPRESS_INTR_CODE */
 
 /* ------------------ utilities for code following below ------------------- */
@@ -264,26 +242,58 @@ USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len)
  * cases.
  */
 #if USB_CFG_USE_SWITCH_STATEMENT
-#   define SWITCH_START(cmd)       switch(cmd){{
-#   define SWITCH_CASE(value)      }break; case (value):{
-#   define SWITCH_CASE2(v1,v2)     }break; case (v1): case(v2):{
-#   define SWITCH_CASE3(v1,v2,v3)  }break; case (v1): case(v2): case(v3):{
-#   define SWITCH_DEFAULT          }break; default:{
-#   define SWITCH_END              }}
+#    define SWITCH_START(cmd) \
+        switch (cmd) {        \
+            {
+#    define SWITCH_CASE(value) \
+        }                      \
+        break;                 \
+        case (value): {
+#    define SWITCH_CASE2(v1, v2) \
+        }                        \
+        break;                   \
+        case (v1):               \
+        case (v2): {
+#    define SWITCH_CASE3(v1, v2, v3) \
+        }                            \
+        break;                       \
+        case (v1):                   \
+        case (v2):                   \
+        case (v3): {
+#    define SWITCH_DEFAULT \
+        }                  \
+        break;             \
+        default: {
+#    define SWITCH_END \
+        }              \
+        }
 #else
-#   define SWITCH_START(cmd)       {uchar _cmd = cmd; if(0){
-#   define SWITCH_CASE(value)      }else if(_cmd == (value)){
-#   define SWITCH_CASE2(v1,v2)     }else if(_cmd == (v1) || _cmd == (v2)){
-#   define SWITCH_CASE3(v1,v2,v3)  }else if(_cmd == (v1) || _cmd == (v2) || (_cmd == v3)){
-#   define SWITCH_DEFAULT          }else{
-#   define SWITCH_END              }}
+#    define SWITCH_START(cmd) \
+        {                     \
+            uchar _cmd = cmd; \
+            if (0) {
+#    define SWITCH_CASE(value) \
+        }                      \
+        else if (_cmd == (value)) {
+#    define SWITCH_CASE2(v1, v2) \
+        }                        \
+        else if (_cmd == (v1) || _cmd == (v2)) {
+#    define SWITCH_CASE3(v1, v2, v3) \
+        }                            \
+        else if (_cmd == (v1) || _cmd == (v2) || (_cmd == v3)) {
+#    define SWITCH_DEFAULT \
+        }                  \
+        else {
+#    define SWITCH_END \
+        }              \
+        }
 #endif
 
 #ifndef USB_RX_USER_HOOK
-#define USB_RX_USER_HOOK(data, len)
+#    define USB_RX_USER_HOOK(data, len)
 #endif
 #ifndef USB_SET_ADDRESS_HOOK
-#define USB_SET_ADDRESS_HOOK()
+#    define USB_SET_ADDRESS_HOOK()
 #endif
 
 /* ------------------------------------------------------------------------- */
@@ -293,62 +303,59 @@ USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len)
  * This may cause problems with undefined symbols if compiled without
  * optimizing!
  */
-#define GET_DESCRIPTOR(cfgProp, staticName)         \
-    if(cfgProp){                                    \
-        if((cfgProp) & USB_PROP_IS_RAM)             \
-            flags = 0;                              \
-        if((cfgProp) & USB_PROP_IS_DYNAMIC){        \
-            len = usbFunctionDescriptor(rq);        \
-        }else{                                      \
-            len = USB_PROP_LENGTH(cfgProp);         \
-            usbMsgPtr = (uchar *)(staticName);      \
-        }                                           \
+#define GET_DESCRIPTOR(cfgProp, staticName)       \
+    if (cfgProp) {                                \
+        if ((cfgProp)&USB_PROP_IS_RAM) flags = 0; \
+        if ((cfgProp)&USB_PROP_IS_DYNAMIC) {      \
+            len = usbFunctionDescriptor(rq);      \
+        } else {                                  \
+            len       = USB_PROP_LENGTH(cfgProp); \
+            usbMsgPtr = (uchar *)(staticName);    \
+        }                                         \
     }
 
 /* usbDriverDescriptor() is similar to usbFunctionDescriptor(), but used
  * internally for all types of descriptors.
  */
-static inline usbMsgLen_t usbDriverDescriptor(usbRequest_t *rq)
-{
-usbMsgLen_t len = 0;
-uchar       flags = USB_FLG_MSGPTR_IS_ROM;
+static inline usbMsgLen_t usbDriverDescriptor(usbRequest_t *rq) {
+    usbMsgLen_t len   = 0;
+    uchar       flags = USB_FLG_MSGPTR_IS_ROM;
 
     SWITCH_START(rq->wValue.bytes[1])
-    SWITCH_CASE(USBDESCR_DEVICE)    /* 1 */
-        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice)
-    SWITCH_CASE(USBDESCR_CONFIG)    /* 2 */
-        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration)
-    SWITCH_CASE(USBDESCR_STRING)    /* 3 */
+    SWITCH_CASE(USBDESCR_DEVICE) /* 1 */
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice)
+    SWITCH_CASE(USBDESCR_CONFIG) /* 2 */
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration)
+    SWITCH_CASE(USBDESCR_STRING) /* 3 */
 #if USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC
-        if(USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_RAM)
-            flags = 0;
+    if (USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_RAM) flags = 0;
+    len = usbFunctionDescriptor(rq);
+#else                              /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
+    SWITCH_START(rq->wValue.bytes[0])
+    SWITCH_CASE(0)
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0)
+    SWITCH_CASE(1)
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor)
+    SWITCH_CASE(2)
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice)
+    SWITCH_CASE(3)
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER, usbDescriptorStringSerialNumber)
+    SWITCH_DEFAULT
+    if (USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC) {
         len = usbFunctionDescriptor(rq);
-#else   /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
-        SWITCH_START(rq->wValue.bytes[0])
-        SWITCH_CASE(0)
-            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0)
-        SWITCH_CASE(1)
-            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor)
-        SWITCH_CASE(2)
-            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice)
-        SWITCH_CASE(3)
-            GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER, usbDescriptorStringSerialNumber)
-        SWITCH_DEFAULT
-            if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){
-                len = usbFunctionDescriptor(rq);
-            }
-        SWITCH_END
-#endif  /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
-#if USB_CFG_DESCR_PROPS_HID_REPORT  /* only support HID descriptors if enabled */
-    SWITCH_CASE(USBDESCR_HID)       /* 0x21 */
-        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID, usbDescriptorConfiguration + 18)
-    SWITCH_CASE(USBDESCR_HID_REPORT)/* 0x22 */
-        GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID_REPORT, usbDescriptorHidReport)
+    }
+    SWITCH_END
+#endif                             /* USB_CFG_DESCR_PROPS_STRINGS & USB_PROP_IS_DYNAMIC */
+#if USB_CFG_DESCR_PROPS_HID_REPORT /* only support HID descriptors if enabled */
+    SWITCH_CASE(USBDESCR_HID)      /* 0x21 */
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID, usbDescriptorConfiguration + 18)
+    SWITCH_CASE(USBDESCR_HID_REPORT) /* 0x22 */
+    GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_HID_REPORT, usbDescriptorHidReport)
 #endif
     SWITCH_DEFAULT
-        if(USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC){
-            len = usbFunctionDescriptor(rq);
-        }
+    if (USB_CFG_DESCR_PROPS_UNKNOWN & USB_PROP_IS_DYNAMIC) {
+        len = usbFunctionDescriptor(rq);
+    }
     SWITCH_END
     usbMsgFlags = flags;
     return len;
@@ -359,56 +366,53 @@ uchar       flags = USB_FLG_MSGPTR_IS_ROM;
 /* usbDriverSetup() is similar to usbFunctionSetup(), but it's used for
  * standard requests instead of class and custom requests.
  */
-static inline usbMsgLen_t usbDriverSetup(usbRequest_t *rq)
-{
-uchar   len  = 0, *dataPtr = usbTxBuf + 9;  /* there are 2 bytes free space at the end of the buffer */
-uchar   value = rq->wValue.bytes[0];
+static inline usbMsgLen_t usbDriverSetup(usbRequest_t *rq) {
+    uchar len = 0, *dataPtr = usbTxBuf + 9; /* there are 2 bytes free space at the end of the buffer */
+    uchar value = rq->wValue.bytes[0];
 #if USB_CFG_IMPLEMENT_HALT
-uchar   index = rq->wIndex.bytes[0];
+    uchar index = rq->wIndex.bytes[0];
 #endif
 
     dataPtr[0] = 0; /* default reply common to USBRQ_GET_STATUS and USBRQ_GET_INTERFACE */
     SWITCH_START(rq->bRequest)
-    SWITCH_CASE(USBRQ_GET_STATUS)           /* 0 */
-        uchar recipient = rq->bmRequestType & USBRQ_RCPT_MASK;  /* assign arith ops to variables to enforce byte size */
-        if(USB_CFG_IS_SELF_POWERED && recipient == USBRQ_RCPT_DEVICE)
-            dataPtr[0] =  USB_CFG_IS_SELF_POWERED;
+    SWITCH_CASE(USBRQ_GET_STATUS)                          /* 0 */
+    uchar recipient = rq->bmRequestType & USBRQ_RCPT_MASK; /* assign arith ops to variables to enforce byte size */
+    if (USB_CFG_IS_SELF_POWERED && recipient == USBRQ_RCPT_DEVICE) dataPtr[0] = USB_CFG_IS_SELF_POWERED;
 #if USB_CFG_IMPLEMENT_HALT
-        if(recipient == USBRQ_RCPT_ENDPOINT && index == 0x81)   /* request status for endpoint 1 */
-            dataPtr[0] = usbTxLen1 == USBPID_STALL;
+    if (recipient == USBRQ_RCPT_ENDPOINT && index == 0x81) /* request status for endpoint 1 */
+        dataPtr[0] = usbTxLen1 == USBPID_STALL;
 #endif
-        dataPtr[1] = 0;
-        len = 2;
+    dataPtr[1] = 0;
+    len        = 2;
 #if USB_CFG_IMPLEMENT_HALT
-    SWITCH_CASE2(USBRQ_CLEAR_FEATURE, USBRQ_SET_FEATURE)    /* 1, 3 */
-        if(value == 0 && index == 0x81){    /* feature 0 == HALT for endpoint == 1 */
-            usbTxLen1 = rq->bRequest == USBRQ_CLEAR_FEATURE ? USBPID_NAK : USBPID_STALL;
-            usbResetDataToggling();
-        }
+    SWITCH_CASE2(USBRQ_CLEAR_FEATURE, USBRQ_SET_FEATURE) /* 1, 3 */
+    if (value == 0 && index == 0x81) {                   /* feature 0 == HALT for endpoint == 1 */
+        usbTxLen1 = rq->bRequest == USBRQ_CLEAR_FEATURE ? USBPID_NAK : USBPID_STALL;
+        usbResetDataToggling();
+    }
 #endif
-    SWITCH_CASE(USBRQ_SET_ADDRESS)          /* 5 */
-        usbNewDeviceAddr = value;
-        USB_SET_ADDRESS_HOOK();
-    SWITCH_CASE(USBRQ_GET_DESCRIPTOR)       /* 6 */
-        len = usbDriverDescriptor(rq);
-        goto skipMsgPtrAssignment;
-    SWITCH_CASE(USBRQ_GET_CONFIGURATION)    /* 8 */
-        dataPtr = &usbConfiguration;  /* send current configuration value */
-        len = 1;
-    SWITCH_CASE(USBRQ_SET_CONFIGURATION)    /* 9 */
-        usbConfiguration = value;
-        usbResetStall();
-    SWITCH_CASE(USBRQ_GET_INTERFACE)        /* 10 */
-        len = 1;
+    SWITCH_CASE(USBRQ_SET_ADDRESS) /* 5 */
+    usbNewDeviceAddr = value;
+    USB_SET_ADDRESS_HOOK();
+    SWITCH_CASE(USBRQ_GET_DESCRIPTOR) /* 6 */
+    len = usbDriverDescriptor(rq);
+    goto skipMsgPtrAssignment;
+    SWITCH_CASE(USBRQ_GET_CONFIGURATION) /* 8 */
+    dataPtr = &usbConfiguration;         /* send current configuration value */
+    len     = 1;
+    SWITCH_CASE(USBRQ_SET_CONFIGURATION) /* 9 */
+    usbConfiguration = value;
+    usbResetStall();
+    SWITCH_CASE(USBRQ_GET_INTERFACE) /* 10 */
+    len = 1;
 #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
-    SWITCH_CASE(USBRQ_SET_INTERFACE)        /* 11 */
-        usbResetDataToggling();
-        usbResetStall();
+    SWITCH_CASE(USBRQ_SET_INTERFACE) /* 11 */
+    usbResetDataToggling();
+    usbResetStall();
 #endif
-    SWITCH_DEFAULT                          /* 7=SET_DESCRIPTOR, 12=SYNC_FRAME */
+    SWITCH_DEFAULT /* 7=SET_DESCRIPTOR, 12=SYNC_FRAME */
         /* Should we add an optional hook here? */
-    SWITCH_END
-    usbMsgPtr = dataPtr;
+        SWITCH_END usbMsgPtr = dataPtr;
 skipMsgPtrAssignment:
     return len;
 }
@@ -419,65 +423,64 @@ skipMsgPtrAssignment:
  * routine. It distinguishes between SETUP and DATA packets and processes
  * them accordingly.
  */
-static inline void usbProcessRx(uchar *data, uchar len)
-{
-usbRequest_t    *rq = (void *)data;
-
-/* usbRxToken can be:
- * 0x2d 00101101 (USBPID_SETUP for setup data)
- * 0xe1 11100001 (USBPID_OUT: data phase of setup transfer)
- * 0...0x0f for OUT on endpoint X
- */
+static inline void usbProcessRx(uchar *data, uchar len) {
+    usbRequest_t *rq = (void *)data;
+
+    /* usbRxToken can be:
+     * 0x2d 00101101 (USBPID_SETUP for setup data)
+     * 0xe1 11100001 (USBPID_OUT: data phase of setup transfer)
+     * 0...0x0f for OUT on endpoint X
+     */
     DBG2(0x10 + (usbRxToken & 0xf), data, len + 2); /* SETUP=1d, SETUP-DATA=11, OUTx=1x */
     USB_RX_USER_HOOK(data, len)
 #if USB_CFG_IMPLEMENT_FN_WRITEOUT
-    if(usbRxToken < 0x10){  /* OUT to endpoint != 0: endpoint number in usbRxToken */
+    if (usbRxToken < 0x10) { /* OUT to endpoint != 0: endpoint number in usbRxToken */
         usbFunctionWriteOut(data, len);
         return;
     }
 #endif
-    if(usbRxToken == (uchar)USBPID_SETUP){
-        if(len != 8)    /* Setup size must be always 8 bytes. Ignore otherwise. */
+    if (usbRxToken == (uchar)USBPID_SETUP) {
+        if (len != 8) /* Setup size must be always 8 bytes. Ignore otherwise. */
             return;
         usbMsgLen_t replyLen;
-        usbTxBuf[0] = USBPID_DATA0;         /* initialize data toggling */
-        usbTxLen = USBPID_NAK;              /* abort pending transmit */
+        usbTxBuf[0] = USBPID_DATA0; /* initialize data toggling */
+        usbTxLen    = USBPID_NAK;   /* abort pending transmit */
         usbMsgFlags = 0;
-        uchar type = rq->bmRequestType & USBRQ_TYPE_MASK;
-        if(type != USBRQ_TYPE_STANDARD){    /* standard requests are handled by driver */
+        uchar type  = rq->bmRequestType & USBRQ_TYPE_MASK;
+        if (type != USBRQ_TYPE_STANDARD) { /* standard requests are handled by driver */
             replyLen = usbFunctionSetup(data);
-        }else{
+        } else {
             replyLen = usbDriverSetup(rq);
         }
 #if USB_CFG_IMPLEMENT_FN_READ || USB_CFG_IMPLEMENT_FN_WRITE
-        if(replyLen == USB_NO_MSG){         /* use user-supplied read/write function */
+        if (replyLen == USB_NO_MSG) { /* use user-supplied read/write function */
             /* do some conditioning on replyLen, but on IN transfers only */
-            if((rq->bmRequestType & USBRQ_DIR_MASK) != USBRQ_DIR_HOST_TO_DEVICE){
-                if(sizeof(replyLen) < sizeof(rq->wLength.word)){ /* help compiler with optimizing */
+            if ((rq->bmRequestType & USBRQ_DIR_MASK) != USBRQ_DIR_HOST_TO_DEVICE) {
+                if (sizeof(replyLen) < sizeof(rq->wLength.word)) { /* help compiler with optimizing */
                     replyLen = rq->wLength.bytes[0];
-                }else{
+                } else {
                     replyLen = rq->wLength.word;
                 }
             }
             usbMsgFlags = USB_FLG_USE_USER_RW;
-        }else   /* The 'else' prevents that we limit a replyLen of USB_NO_MSG to the maximum transfer len. */
+        } else /* The 'else' prevents that we limit a replyLen of USB_NO_MSG to the maximum transfer len. */
 #endif
-        if(sizeof(replyLen) < sizeof(rq->wLength.word)){ /* help compiler with optimizing */
-            if(!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0])    /* limit length to max */
+            if (sizeof(replyLen) < sizeof(rq->wLength.word)) {            /* help compiler with optimizing */
+            if (!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0]) /* limit length to max */
                 replyLen = rq->wLength.bytes[0];
-        }else{
-            if(replyLen > rq->wLength.word)     /* limit length to max */
+        } else {
+            if (replyLen > rq->wLength.word) /* limit length to max */
                 replyLen = rq->wLength.word;
         }
         usbMsgLen = replyLen;
-    }else{  /* usbRxToken must be USBPID_OUT, which means data phase of setup (control-out) */
+    } else { /* usbRxToken must be USBPID_OUT, which means data phase of setup (control-out) */
 #if USB_CFG_IMPLEMENT_FN_WRITE
-        if(usbMsgFlags & USB_FLG_USE_USER_RW){
+        if (usbMsgFlags & USB_FLG_USE_USER_RW) {
             uchar rval = usbFunctionWrite(data, len);
-            if(rval == 0xff){   /* an error occurred */
+            if (rval == 0xff) { /* an error occurred */
                 usbTxLen = USBPID_STALL;
-            }else if(rval != 0){    /* This was the final package */
-                usbMsgLen = 0;  /* answer with a zero-sized data packet */
+            } else if (rval != 0) { /* This was the final package */
+                usbMsgLen = 0;      /* answer with a zero-sized data packet */
             }
         }
 #endif
@@ -489,26 +492,25 @@ usbRequest_t    *rq = (void *)data;
 /* This function is similar to usbFunctionRead(), but it's also called for
  * data handled automatically by the driver (e.g. descriptor reads).
  */
-static uchar usbDeviceRead(uchar *data, uchar len)
-{
-    if(len > 0){    /* don't bother app with 0 sized reads */
+static uchar usbDeviceRead(uchar *data, uchar len) {
+    if (len > 0) { /* don't bother app with 0 sized reads */
 #if USB_CFG_IMPLEMENT_FN_READ
-        if(usbMsgFlags & USB_FLG_USE_USER_RW){
+        if (usbMsgFlags & USB_FLG_USE_USER_RW) {
             len = usbFunctionRead(data, len);
-        }else
+        } else
 #endif
         {
             uchar i = len, *r = usbMsgPtr;
-            if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){    /* ROM data */
-                do{
-                    uchar c = USB_READ_FLASH(r);    /* assign to char size variable to enforce byte ops */
+            if (usbMsgFlags & USB_FLG_MSGPTR_IS_ROM) { /* ROM data */
+                do {
+                    uchar c = USB_READ_FLASH(r); /* assign to char size variable to enforce byte ops */
                     *data++ = c;
                     r++;
-                }while(--i);
-            }else{  /* RAM data */
-                do{
+                } while (--i);
+            } else { /* RAM data */
+                do {
                     *data++ = *r++;
-                }while(--i);
+                } while (--i);
             }
             usbMsgPtr = r;
         }
@@ -521,39 +523,36 @@ static uchar usbDeviceRead(uchar *data, uchar len)
 /* usbBuildTxBlock() is called when we have data to transmit and the
  * interrupt routine's transmit buffer is empty.
  */
-static inline void usbBuildTxBlock(void)
-{
-usbMsgLen_t wantLen;
-uchar       len;
+static inline void usbBuildTxBlock(void) {
+    usbMsgLen_t wantLen;
+    uchar       len;
 
     wantLen = usbMsgLen;
-    if(wantLen > 8)
-        wantLen = 8;
+    if (wantLen > 8) wantLen = 8;
     usbMsgLen -= wantLen;
     usbTxBuf[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* DATA toggling */
     len = usbDeviceRead(usbTxBuf + 1, wantLen);
-    if(len <= 8){           /* valid data packet */
+    if (len <= 8) { /* valid data packet */
         usbCrc16Append(&usbTxBuf[1], len);
-        len += 4;           /* length including sync byte */
-        if(len < 12)        /* a partial package identifies end of message */
+        len += 4;     /* length including sync byte */
+        if (len < 12) /* a partial package identifies end of message */
             usbMsgLen = USB_NO_MSG;
-    }else{
-        len = USBPID_STALL;   /* stall the endpoint */
+    } else {
+        len       = USBPID_STALL; /* stall the endpoint */
         usbMsgLen = USB_NO_MSG;
     }
     usbTxLen = len;
-    DBG2(0x20, usbTxBuf, len-1);
+    DBG2(0x20, usbTxBuf, len - 1);
 }
 
 /* ------------------------------------------------------------------------- */
 
-static inline void usbHandleResetHook(uchar notResetState)
-{
+static inline void usbHandleResetHook(uchar notResetState) {
 #ifdef USB_RESET_HOOK
-static uchar    wasReset;
-uchar           isReset = !notResetState;
+    static uchar wasReset;
+    uchar        isReset = !notResetState;
 
-    if(wasReset != isReset){
+    if (wasReset != isReset) {
         USB_RESET_HOOK(isReset);
         wasReset = isReset;
     }
@@ -562,40 +561,39 @@ uchar           isReset = !notResetState;
 
 /* ------------------------------------------------------------------------- */
 
-USB_PUBLIC void usbPoll(void)
-{
-schar   len;
-uchar   i;
+USB_PUBLIC void usbPoll(void) {
+    schar len;
+    uchar i;
 
     len = usbRxLen - 3;
-    if(len >= 0){
-/* We could check CRC16 here -- but ACK has already been sent anyway. If you
- * need data integrity checks with this driver, check the CRC in your app
- * code and report errors back to the host. Since the ACK was already sent,
- * retries must be handled on application level.
- * unsigned crc = usbCrc16(buffer + 1, usbRxLen - 3);
- */
+    if (len >= 0) {
+        /* We could check CRC16 here -- but ACK has already been sent anyway. If you
+         * need data integrity checks with this driver, check the CRC in your app
+         * code and report errors back to the host. Since the ACK was already sent,
+         * retries must be handled on application level.
+         * unsigned crc = usbCrc16(buffer + 1, usbRxLen - 3);
+         */
         usbProcessRx(usbRxBuf + USB_BUFSIZE + 1 - usbInputBufOffset, len);
 #if USB_CFG_HAVE_FLOWCONTROL
-        if(usbRxLen > 0)    /* only mark as available if not inactivated */
+        if (usbRxLen > 0) /* only mark as available if not inactivated */
             usbRxLen = 0;
 #else
-        usbRxLen = 0;       /* mark rx buffer as available */
+        usbRxLen = 0; /* mark rx buffer as available */
 #endif
     }
-    if(usbTxLen & 0x10){    /* transmit system idle */
-        if(usbMsgLen != USB_NO_MSG){    /* transmit data pending? */
+    if (usbTxLen & 0x10) {             /* transmit system idle */
+        if (usbMsgLen != USB_NO_MSG) { /* transmit data pending? */
             usbBuildTxBlock();
         }
     }
-    for(i = 20; i > 0; i--){
+    for (i = 20; i > 0; i--) {
         uchar usbLineStatus = USBIN & USBMASK;
-        if(usbLineStatus != 0)  /* SE0 has ended */
+        if (usbLineStatus != 0) /* SE0 has ended */
             goto isNotReset;
     }
     /* RESET condition, called multiple times during reset */
     usbNewDeviceAddr = 0;
-    usbDeviceAddr = 0;
+    usbDeviceAddr    = 0;
     usbResetStall();
     DBG1(0xff, 0, 0);
 isNotReset:
@@ -604,8 +602,7 @@ isNotReset:
 
 /* ------------------------------------------------------------------------- */
 
-USB_PUBLIC void usbInit(void)
-{
+USB_PUBLIC void usbInit(void) {
 #if USB_INTR_CFG_SET != 0
     USB_INTR_CFG |= USB_INTR_CFG_SET;
 #endif
@@ -616,9 +613,9 @@ USB_PUBLIC void usbInit(void)
     usbResetDataToggling();
 #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE
     usbTxLen1 = USBPID_NAK;
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3
     usbTxLen3 = USBPID_NAK;
-#endif
+#    endif
 #endif
 }
 
diff --git a/tmk_core/protocol/vusb/usbdrv/usbdrv.h b/tmk_core/protocol/vusb/usbdrv/usbdrv.h
index 42fe163720..88a1bce76e 100644
--- a/tmk_core/protocol/vusb/usbdrv/usbdrv.h
+++ b/tmk_core/protocol/vusb/usbdrv/usbdrv.h
@@ -122,7 +122,7 @@ USB messages, even if they address another (low-speed) device on the same bus.
 /* --------------------------- Module Interface ---------------------------- */
 /* ------------------------------------------------------------------------- */
 
-#define USBDRV_VERSION  20100715
+#define USBDRV_VERSION 20100715
 /* This define uniquely identifies a driver version. It is a decimal number
  * constructed from the driver's release date in the form YYYYMMDD. If the
  * driver's behavior or interface changes, you can use this constant to
@@ -130,9 +130,8 @@ USB messages, even if they address another (low-speed) device on the same bus.
  * older than 2006-01-25.
  */
 
-
 #ifndef USB_PUBLIC
-#define USB_PUBLIC
+#    define USB_PUBLIC
 #endif
 /* USB_PUBLIC is used as declaration attribute for all functions exported by
  * the USB driver. The default is no attribute (see above). You may define it
@@ -142,28 +141,28 @@ USB messages, even if they address another (low-speed) device on the same bus.
  */
 
 #ifndef __ASSEMBLER__
-#ifndef uchar
-#define uchar   unsigned char
-#endif
-#ifndef schar
-#define schar   signed char
-#endif
+#    ifndef uchar
+#        define uchar unsigned char
+#    endif
+#    ifndef schar
+#        define schar signed char
+#    endif
 /* shortcuts for well defined 8 bit integer types */
 
-#if USB_CFG_LONG_TRANSFERS  /* if more than 254 bytes transfer size required */
-#   define usbMsgLen_t unsigned
-#else
-#   define usbMsgLen_t uchar
-#endif
+#    if USB_CFG_LONG_TRANSFERS /* if more than 254 bytes transfer size required */
+#        define usbMsgLen_t unsigned
+#    else
+#        define usbMsgLen_t uchar
+#    endif
 /* usbMsgLen_t is the data type used for transfer lengths. By default, it is
  * defined to uchar, allowing a maximum of 254 bytes (255 is reserved for
  * USB_NO_MSG below). If the usbconfig.h defines USB_CFG_LONG_TRANSFERS to 1,
  * a 16 bit data type is used, allowing up to 16384 bytes (the rest is used
  * for flags in the descriptor configuration).
  */
-#define USB_NO_MSG  ((usbMsgLen_t)-1)   /* constant meaning "no message" */
+#    define USB_NO_MSG ((usbMsgLen_t)-1) /* constant meaning "no message" */
 
-struct usbRequest;  /* forward declaration */
+struct usbRequest; /* forward declaration */
 
 USB_PUBLIC void usbInit(void);
 /* This function must be called before interrupts are enabled and the main
@@ -216,7 +215,7 @@ USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq);
  * usbFunctionSetup() above, but it is called only to request USB descriptor
  * data. See the documentation of usbFunctionSetup() above for more info.
  */
-#if USB_CFG_HAVE_INTRIN_ENDPOINT
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT
 USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len);
 /* This function sets the message which will be sent during the next interrupt
  * IN transfer. The message is copied to an internal buffer and must not exceed
@@ -224,19 +223,19 @@ USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len);
  * interrupt status to the host.
  * If you need to transfer more bytes, use a control read after the interrupt.
  */
-#define usbInterruptIsReady()   (usbTxLen1 & 0x10)
+#        define usbInterruptIsReady() (usbTxLen1 & 0x10)
 /* This macro indicates whether the last interrupt message has already been
  * sent. If you set a new interrupt message before the old was sent, the
  * message already buffered will be lost.
  */
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3
+#        if USB_CFG_HAVE_INTRIN_ENDPOINT3
 USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len);
-#define usbInterruptIsReady3()   (usbTxLen3 & 0x10)
+#            define usbInterruptIsReady3() (usbTxLen3 & 0x10)
 /* Same as above for endpoint 3 */
-#endif
-#endif /* USB_CFG_HAVE_INTRIN_ENDPOINT */
-#if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    /* simplified interface for backward compatibility */
-#define usbHidReportDescriptor  usbDescriptorHidReport
+#        endif
+#    endif                                   /* USB_CFG_HAVE_INTRIN_ENDPOINT */
+#    if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* simplified interface for backward compatibility */
+#        define usbHidReportDescriptor usbDescriptorHidReport
 /* should be declared as: PROGMEM char usbHidReportDescriptor[]; */
 /* If you implement an HID device, you need to provide a report descriptor.
  * The HID report descriptor syntax is a bit complex. If you understand how
@@ -244,8 +243,8 @@ USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len);
  * Descriptor Tool from usb.org, see http://www.usb.org/developers/hidpage/.
  * Otherwise you should probably start with a working example.
  */
-#endif  /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */
-#if USB_CFG_IMPLEMENT_FN_WRITE
+#    endif /* USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH */
+#    if USB_CFG_IMPLEMENT_FN_WRITE
 USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len);
 /* This function is called by the driver to provide a control transfer's
  * payload data (control-out). It is called in chunks of up to 8 bytes. The
@@ -262,8 +261,8 @@ USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len);
  * In order to get usbFunctionWrite() called, define USB_CFG_IMPLEMENT_FN_WRITE
  * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
  */
-#endif /* USB_CFG_IMPLEMENT_FN_WRITE */
-#if USB_CFG_IMPLEMENT_FN_READ
+#    endif /* USB_CFG_IMPLEMENT_FN_WRITE */
+#    if USB_CFG_IMPLEMENT_FN_READ
 USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len);
 /* This function is called by the driver to ask the application for a control
  * transfer's payload data (control-in). It is called in chunks of up to 8
@@ -274,26 +273,24 @@ USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len);
  * In order to get usbFunctionRead() called, define USB_CFG_IMPLEMENT_FN_READ
  * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
  */
-#endif /* USB_CFG_IMPLEMENT_FN_READ */
+#    endif /* USB_CFG_IMPLEMENT_FN_READ */
 
-extern uchar usbRxToken;    /* may be used in usbFunctionWriteOut() below */
-#if USB_CFG_IMPLEMENT_FN_WRITEOUT
+extern uchar usbRxToken; /* may be used in usbFunctionWriteOut() below */
+#    if USB_CFG_IMPLEMENT_FN_WRITEOUT
 USB_PUBLIC void usbFunctionWriteOut(uchar *data, uchar len);
 /* This function is called by the driver when data is received on an interrupt-
  * or bulk-out endpoint. The endpoint number can be found in the global
  * variable usbRxToken. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT to 1 in
  * usbconfig.h to get this function called.
  */
-#endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */
-#ifdef USB_CFG_PULLUP_IOPORTNAME
-#define usbDeviceConnect()      ((USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT)), \
-                                  (USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT)))
-#define usbDeviceDisconnect()   ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \
-                                  (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT)))
-#else /* USB_CFG_PULLUP_IOPORTNAME */
-#define usbDeviceConnect()      (USBDDR &= ~(1<<USBMINUS))
-#define usbDeviceDisconnect()   (USBDDR |= (1<<USBMINUS))
-#endif /* USB_CFG_PULLUP_IOPORTNAME */
+#    endif /* USB_CFG_IMPLEMENT_FN_WRITEOUT */
+#    ifdef USB_CFG_PULLUP_IOPORTNAME
+#        define usbDeviceConnect() ((USB_PULLUP_DDR |= (1 << USB_CFG_PULLUP_BIT)), (USB_PULLUP_OUT |= (1 << USB_CFG_PULLUP_BIT)))
+#        define usbDeviceDisconnect() ((USB_PULLUP_DDR &= ~(1 << USB_CFG_PULLUP_BIT)), (USB_PULLUP_OUT &= ~(1 << USB_CFG_PULLUP_BIT)))
+#    else /* USB_CFG_PULLUP_IOPORTNAME */
+#        define usbDeviceConnect() (USBDDR &= ~(1 << USBMINUS))
+#        define usbDeviceDisconnect() (USBDDR |= (1 << USBMINUS))
+#    endif /* USB_CFG_PULLUP_IOPORTNAME */
 /* The macros usbDeviceConnect() and usbDeviceDisconnect() (intended to look
  * like a function) connect resp. disconnect the device from the host's USB.
  * If the constants USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT are defined
@@ -307,7 +304,7 @@ USB_PUBLIC void usbFunctionWriteOut(uchar *data, uchar len);
  * or use cli() to disable interrupts globally.
  */
 extern unsigned usbCrc16(unsigned data, uchar len);
-#define usbCrc16(data, len) usbCrc16((unsigned)(data), len)
+#    define usbCrc16(data, len) usbCrc16((unsigned)(data), len)
 /* This function calculates the binary complement of the data CRC used in
  * USB data packets. The value is used to build raw transmit packets.
  * You may want to use this function for data checksums or to verify received
@@ -315,12 +312,12 @@ extern unsigned usbCrc16(unsigned data, uchar len);
  * tiny memory model.
  */
 extern unsigned usbCrc16Append(unsigned data, uchar len);
-#define usbCrc16Append(data, len)    usbCrc16Append((unsigned)(data), len)
+#    define usbCrc16Append(data, len) usbCrc16Append((unsigned)(data), len)
 /* This function is equivalent to usbCrc16() above, except that it appends
  * the 2 bytes CRC (lowbyte first) in the 'data' buffer after reading 'len'
  * bytes.
  */
-#if USB_CFG_HAVE_MEASURE_FRAME_LENGTH
+#    if USB_CFG_HAVE_MEASURE_FRAME_LENGTH
 extern unsigned usbMeasureFrameLength(void);
 /* This function MUST be called IMMEDIATELY AFTER USB reset and measures 1/7 of
  * the number of CPU cycles during one USB frame minus one low speed bit
@@ -329,59 +326,58 @@ extern unsigned usbMeasureFrameLength(void);
  * calling this function.
  * This can be used to calibrate the AVR's RC oscillator.
  */
-#endif
-extern uchar    usbConfiguration;
+#    endif
+extern uchar usbConfiguration;
 /* This value contains the current configuration set by the host. The driver
  * allows setting and querying of this variable with the USB SET_CONFIGURATION
  * and GET_CONFIGURATION requests, but does not use it otherwise.
  * You may want to reflect the "configured" status with a LED on the device or
  * switch on high power parts of the circuit only if the device is configured.
  */
-#if USB_COUNT_SOF
-extern volatile uchar   usbSofCount;
+#    if USB_COUNT_SOF
+extern volatile uchar usbSofCount;
 /* This variable is incremented on every SOF packet. It is only available if
  * the macro USB_COUNT_SOF is defined to a value != 0.
  */
-#endif
-#if USB_CFG_CHECK_DATA_TOGGLING
-extern uchar    usbCurrentDataToken;
+#    endif
+#    if USB_CFG_CHECK_DATA_TOGGLING
+extern uchar usbCurrentDataToken;
 /* This variable can be checked in usbFunctionWrite() and usbFunctionWriteOut()
  * to ignore duplicate packets.
  */
-#endif
+#    endif
 
-#define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2*(stringLength)+2) | (3<<8))
+#    define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2 * (stringLength) + 2) | (3 << 8))
 /* This macro builds a descriptor header for a string descriptor given the
  * string's length. See usbdrv.c for an example how to use it.
  */
-#if USB_CFG_HAVE_FLOWCONTROL
-extern volatile schar   usbRxLen;
-#define usbDisableAllRequests()     usbRxLen = -1
+#    if USB_CFG_HAVE_FLOWCONTROL
+extern volatile schar usbRxLen;
+#        define usbDisableAllRequests() usbRxLen = -1
 /* Must be called from usbFunctionWrite(). This macro disables all data input
  * from the USB interface. Requests from the host are answered with a NAK
  * while they are disabled.
  */
-#define usbEnableAllRequests()      usbRxLen = 0
+#        define usbEnableAllRequests() usbRxLen = 0
 /* May only be called if requests are disabled. This macro enables input from
  * the USB interface after it has been disabled with usbDisableAllRequests().
  */
-#define usbAllRequestsAreDisabled() (usbRxLen < 0)
+#        define usbAllRequestsAreDisabled() (usbRxLen < 0)
 /* Use this macro to find out whether requests are disabled. It may be needed
  * to ensure that usbEnableAllRequests() is never called when requests are
  * enabled.
  */
-#endif
+#    endif
 
-#define USB_SET_DATATOKEN1(token)   usbTxBuf1[0] = token
-#define USB_SET_DATATOKEN3(token)   usbTxBuf3[0] = token
+#    define USB_SET_DATATOKEN1(token) usbTxBuf1[0] = token
+#    define USB_SET_DATATOKEN3(token) usbTxBuf3[0] = token
 /* These two macros can be used by application software to reset data toggling
  * for interrupt-in endpoints 1 and 3. Since the token is toggled BEFORE
  * sending data, you must set the opposite value of the token which should come
  * first.
  */
 
-#endif  /* __ASSEMBLER__ */
-
+#endif /* __ASSEMBLER__ */
 
 /* ------------------------------------------------------------------------- */
 /* ----------------- Definitions for Descriptor Properties ----------------- */
@@ -390,57 +386,57 @@ extern volatile schar   usbRxLen;
  * about the various methods to define USB descriptors. If you do nothing,
  * the default descriptors will be used.
  */
-#define USB_PROP_IS_DYNAMIC     (1 << 14)
+#define USB_PROP_IS_DYNAMIC (1 << 14)
 /* If this property is set for a descriptor, usbFunctionDescriptor() will be
  * used to obtain the particular descriptor. Data directly returned via
  * usbMsgPtr are FLASH data by default, combine (OR) with USB_PROP_IS_RAM to
  * return RAM data.
  */
-#define USB_PROP_IS_RAM         (1 << 15)
+#define USB_PROP_IS_RAM (1 << 15)
 /* If this property is set for a descriptor, the data is read from RAM
  * memory instead of Flash. The property is used for all methods to provide
  * external descriptors.
  */
-#define USB_PROP_LENGTH(len)    ((len) & 0x3fff)
+#define USB_PROP_LENGTH(len) ((len)&0x3fff)
 /* If a static external descriptor is used, this is the total length of the
  * descriptor in bytes.
  */
 
 /* all descriptors which may have properties: */
 #ifndef USB_CFG_DESCR_PROPS_DEVICE
-#define USB_CFG_DESCR_PROPS_DEVICE                  0
+#    define USB_CFG_DESCR_PROPS_DEVICE 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_CONFIGURATION
-#define USB_CFG_DESCR_PROPS_CONFIGURATION           0
+#    define USB_CFG_DESCR_PROPS_CONFIGURATION 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_STRINGS
-#define USB_CFG_DESCR_PROPS_STRINGS                 0
+#    define USB_CFG_DESCR_PROPS_STRINGS 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_STRING_0
-#define USB_CFG_DESCR_PROPS_STRING_0                0
+#    define USB_CFG_DESCR_PROPS_STRING_0 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_STRING_VENDOR
-#define USB_CFG_DESCR_PROPS_STRING_VENDOR           0
+#    define USB_CFG_DESCR_PROPS_STRING_VENDOR 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_STRING_PRODUCT
-#define USB_CFG_DESCR_PROPS_STRING_PRODUCT          0
+#    define USB_CFG_DESCR_PROPS_STRING_PRODUCT 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
-#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    0
+#    define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER 0
 #endif
 #ifndef USB_CFG_DESCR_PROPS_HID
-#define USB_CFG_DESCR_PROPS_HID                     0
+#    define USB_CFG_DESCR_PROPS_HID 0
 #endif
 #if !(USB_CFG_DESCR_PROPS_HID_REPORT)
-#   undef USB_CFG_DESCR_PROPS_HID_REPORT
-#   if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */
-#       define USB_CFG_DESCR_PROPS_HID_REPORT       USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
-#   else
-#       define USB_CFG_DESCR_PROPS_HID_REPORT       0
-#   endif
+#    undef USB_CFG_DESCR_PROPS_HID_REPORT
+#    if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */
+#        define USB_CFG_DESCR_PROPS_HID_REPORT USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
+#    else
+#        define USB_CFG_DESCR_PROPS_HID_REPORT 0
+#    endif
 #endif
 #ifndef USB_CFG_DESCR_PROPS_UNKNOWN
-#define USB_CFG_DESCR_PROPS_UNKNOWN                 0
+#    define USB_CFG_DESCR_PROPS_UNKNOWN 0
 #endif
 
 /* ------------------ forward declaration of descriptors ------------------- */
@@ -449,46 +445,46 @@ extern volatile schar   usbRxLen;
  */
 #ifndef __ASSEMBLER__
 extern
-#if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const char usbDescriptorDevice[];
+#    if !(USB_CFG_DESCR_PROPS_DEVICE & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const char usbDescriptorDevice[];
 
 extern
-#if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const char usbDescriptorConfiguration[];
+#    if !(USB_CFG_DESCR_PROPS_CONFIGURATION & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const char usbDescriptorConfiguration[];
 
 extern
-#if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const char usbDescriptorHidReport[];
+#    if !(USB_CFG_DESCR_PROPS_HID_REPORT & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const char usbDescriptorHidReport[];
 
 extern
-#if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const char usbDescriptorString0[];
+#    if !(USB_CFG_DESCR_PROPS_STRING_0 & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const char usbDescriptorString0[];
 
 extern
-#if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const int usbDescriptorStringVendor[];
+#    if !(USB_CFG_DESCR_PROPS_STRING_VENDOR & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const int usbDescriptorStringVendor[];
 
 extern
-#if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const int usbDescriptorStringDevice[];
+#    if !(USB_CFG_DESCR_PROPS_STRING_PRODUCT & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const int usbDescriptorStringDevice[];
 
 extern
-#if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM)
-PROGMEM
-#endif
-const int usbDescriptorStringSerialNumber[];
+#    if !(USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER & USB_PROP_IS_RAM)
+    PROGMEM
+#    endif
+    const int usbDescriptorStringSerialNumber[];
 
 #endif /* __ASSEMBLER__ */
 
@@ -496,12 +492,12 @@ const int usbDescriptorStringSerialNumber[];
 /* ------------------------ General Purpose Macros ------------------------- */
 /* ------------------------------------------------------------------------- */
 
-#define USB_CONCAT(a, b)            a ## b
-#define USB_CONCAT_EXPANDED(a, b)   USB_CONCAT(a, b)
+#define USB_CONCAT(a, b) a##b
+#define USB_CONCAT_EXPANDED(a, b) USB_CONCAT(a, b)
 
-#define USB_OUTPORT(name)           USB_CONCAT(PORT, name)
-#define USB_INPORT(name)            USB_CONCAT(PIN, name)
-#define USB_DDRPORT(name)           USB_CONCAT(DDR, name)
+#define USB_OUTPORT(name) USB_CONCAT(PORT, name)
+#define USB_INPORT(name) USB_CONCAT(PIN, name)
+#define USB_DDRPORT(name) USB_CONCAT(DDR, name)
 /* The double-define trick above lets us concatenate strings which are
  * defined by macros.
  */
@@ -511,7 +507,7 @@ const int usbDescriptorStringSerialNumber[];
 /* ------------------------------------------------------------------------- */
 
 #if !defined __ASSEMBLER__ && (!defined USB_CFG_VENDOR_ID || !defined USB_CFG_DEVICE_ID)
-#warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h"
+#    warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h"
 /* If the user has not defined IDs, we default to obdev's free IDs.
  * See USB-IDs-for-free.txt for details.
  */
@@ -519,96 +515,96 @@ const int usbDescriptorStringSerialNumber[];
 
 /* make sure we have a VID and PID defined, byte order is lowbyte, highbyte */
 #ifndef USB_CFG_VENDOR_ID
-#   define  USB_CFG_VENDOR_ID   0xc0, 0x16  /* = 0x16c0 = 5824 = voti.nl */
+#    define USB_CFG_VENDOR_ID 0xc0, 0x16 /* = 0x16c0 = 5824 = voti.nl */
 #endif
 
 #ifndef USB_CFG_DEVICE_ID
-#   if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
-#       define USB_CFG_DEVICE_ID    0xdf, 0x05  /* = 0x5df = 1503, shared PID for HIDs */
-#   elif USB_CFG_INTERFACE_CLASS == 2
-#       define USB_CFG_DEVICE_ID    0xe1, 0x05  /* = 0x5e1 = 1505, shared PID for CDC Modems */
-#   else
-#       define USB_CFG_DEVICE_ID    0xdc, 0x05  /* = 0x5dc = 1500, obdev's free PID */
-#   endif
+#    if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH
+#        define USB_CFG_DEVICE_ID 0xdf, 0x05 /* = 0x5df = 1503, shared PID for HIDs */
+#    elif USB_CFG_INTERFACE_CLASS == 2
+#        define USB_CFG_DEVICE_ID 0xe1, 0x05 /* = 0x5e1 = 1505, shared PID for CDC Modems */
+#    else
+#        define USB_CFG_DEVICE_ID 0xdc, 0x05 /* = 0x5dc = 1500, obdev's free PID */
+#    endif
 #endif
 
 /* Derive Output, Input and DataDirection ports from port names */
 #ifndef USB_CFG_IOPORTNAME
-#error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h"
+#    error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h"
 #endif
 
-#define USBOUT          USB_OUTPORT(USB_CFG_IOPORTNAME)
-#define USB_PULLUP_OUT  USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
-#define USBIN           USB_INPORT(USB_CFG_IOPORTNAME)
-#define USBDDR          USB_DDRPORT(USB_CFG_IOPORTNAME)
-#define USB_PULLUP_DDR  USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME)
+#define USBOUT USB_OUTPORT(USB_CFG_IOPORTNAME)
+#define USB_PULLUP_OUT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
+#define USBIN USB_INPORT(USB_CFG_IOPORTNAME)
+#define USBDDR USB_DDRPORT(USB_CFG_IOPORTNAME)
+#define USB_PULLUP_DDR USB_DDRPORT(USB_CFG_PULLUP_IOPORTNAME)
 
-#define USBMINUS    USB_CFG_DMINUS_BIT
-#define USBPLUS     USB_CFG_DPLUS_BIT
-#define USBIDLE     (1<<USB_CFG_DMINUS_BIT) /* value representing J state */
-#define USBMASK     ((1<<USB_CFG_DPLUS_BIT) | (1<<USB_CFG_DMINUS_BIT))  /* mask for USB I/O bits */
+#define USBMINUS USB_CFG_DMINUS_BIT
+#define USBPLUS USB_CFG_DPLUS_BIT
+#define USBIDLE (1 << USB_CFG_DMINUS_BIT)                              /* value representing J state */
+#define USBMASK ((1 << USB_CFG_DPLUS_BIT) | (1 << USB_CFG_DMINUS_BIT)) /* mask for USB I/O bits */
 
 /* defines for backward compatibility with older driver versions: */
-#define USB_CFG_IOPORT          USB_OUTPORT(USB_CFG_IOPORTNAME)
+#define USB_CFG_IOPORT USB_OUTPORT(USB_CFG_IOPORTNAME)
 #ifdef USB_CFG_PULLUP_IOPORTNAME
-#define USB_CFG_PULLUP_IOPORT   USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
+#    define USB_CFG_PULLUP_IOPORT USB_OUTPORT(USB_CFG_PULLUP_IOPORTNAME)
 #endif
 
-#ifndef USB_CFG_EP3_NUMBER  /* if not defined in usbconfig.h */
-#define USB_CFG_EP3_NUMBER  3
+#ifndef USB_CFG_EP3_NUMBER /* if not defined in usbconfig.h */
+#    define USB_CFG_EP3_NUMBER 3
 #endif
 
 #ifndef USB_CFG_HAVE_INTRIN_ENDPOINT3
-#define USB_CFG_HAVE_INTRIN_ENDPOINT3   0
+#    define USB_CFG_HAVE_INTRIN_ENDPOINT3 0
 #endif
 
-#define USB_BUFSIZE     11  /* PID, 8 bytes data, 2 bytes CRC */
+#define USB_BUFSIZE 11 /* PID, 8 bytes data, 2 bytes CRC */
 
 /* ----- Try to find registers and bits responsible for ext interrupt 0 ----- */
 
-#ifndef USB_INTR_CFG    /* allow user to override our default */
-#   if defined  EICRA
-#       define USB_INTR_CFG EICRA
-#   else
-#       define USB_INTR_CFG MCUCR
-#   endif
-#endif
-#ifndef USB_INTR_CFG_SET    /* allow user to override our default */
-#   if defined(USB_COUNT_SOF) || defined(USB_SOF_HOOK)
-#       define USB_INTR_CFG_SET (1 << ISC01)                    /* cfg for falling edge */
-        /* If any SOF logic is used, the interrupt must be wired to D- where
-         * we better trigger on falling edge
-         */
-#   else
-#       define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01))   /* cfg for rising edge */
-#   endif
-#endif
-#ifndef USB_INTR_CFG_CLR    /* allow user to override our default */
-#   define USB_INTR_CFG_CLR 0    /* no bits to clear */
-#endif
-
-#ifndef USB_INTR_ENABLE     /* allow user to override our default */
-#   if defined GIMSK
-#       define USB_INTR_ENABLE  GIMSK
-#   elif defined EIMSK
-#       define USB_INTR_ENABLE  EIMSK
-#   else
-#       define USB_INTR_ENABLE  GICR
-#   endif
+#ifndef USB_INTR_CFG /* allow user to override our default */
+#    if defined EICRA
+#        define USB_INTR_CFG EICRA
+#    else
+#        define USB_INTR_CFG MCUCR
+#    endif
+#endif
+#ifndef USB_INTR_CFG_SET /* allow user to override our default */
+#    if defined(USB_COUNT_SOF) || defined(USB_SOF_HOOK)
+#        define USB_INTR_CFG_SET (1 << ISC01) /* cfg for falling edge */
+                                              /* If any SOF logic is used, the interrupt must be wired to D- where
+                                               * we better trigger on falling edge
+                                               */
+#    else
+#        define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) /* cfg for rising edge */
+#    endif
+#endif
+#ifndef USB_INTR_CFG_CLR       /* allow user to override our default */
+#    define USB_INTR_CFG_CLR 0 /* no bits to clear */
+#endif
+
+#ifndef USB_INTR_ENABLE /* allow user to override our default */
+#    if defined GIMSK
+#        define USB_INTR_ENABLE GIMSK
+#    elif defined EIMSK
+#        define USB_INTR_ENABLE EIMSK
+#    else
+#        define USB_INTR_ENABLE GICR
+#    endif
 #endif
 #ifndef USB_INTR_ENABLE_BIT /* allow user to override our default */
-#   define USB_INTR_ENABLE_BIT  INT0
+#    define USB_INTR_ENABLE_BIT INT0
 #endif
 
-#ifndef USB_INTR_PENDING    /* allow user to override our default */
-#   if defined  EIFR
-#       define USB_INTR_PENDING EIFR
-#   else
-#       define USB_INTR_PENDING GIFR
-#   endif
+#ifndef USB_INTR_PENDING /* allow user to override our default */
+#    if defined EIFR
+#        define USB_INTR_PENDING EIFR
+#    else
+#        define USB_INTR_PENDING GIFR
+#    endif
 #endif
-#ifndef USB_INTR_PENDING_BIT    /* allow user to override our default */
-#   define USB_INTR_PENDING_BIT INTF0
+#ifndef USB_INTR_PENDING_BIT /* allow user to override our default */
+#    define USB_INTR_PENDING_BIT INTF0
 #endif
 
 /*
@@ -628,46 +624,45 @@ at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM
 /* ------------------------------------------------------------------------- */
 
 /* USB Token values */
-#define USBPID_SETUP    0x2d
-#define USBPID_OUT      0xe1
-#define USBPID_IN       0x69
-#define USBPID_DATA0    0xc3
-#define USBPID_DATA1    0x4b
+#define USBPID_SETUP 0x2d
+#define USBPID_OUT 0xe1
+#define USBPID_IN 0x69
+#define USBPID_DATA0 0xc3
+#define USBPID_DATA1 0x4b
 
-#define USBPID_ACK      0xd2
-#define USBPID_NAK      0x5a
-#define USBPID_STALL    0x1e
+#define USBPID_ACK 0xd2
+#define USBPID_NAK 0x5a
+#define USBPID_STALL 0x1e
 
 #ifndef USB_INITIAL_DATATOKEN
-#define USB_INITIAL_DATATOKEN   USBPID_DATA1
+#    define USB_INITIAL_DATATOKEN USBPID_DATA1
 #endif
 
 #ifndef __ASSEMBLER__
 
-typedef struct usbTxStatus{
-    volatile uchar   len;
-    uchar   buffer[USB_BUFSIZE];
-}usbTxStatus_t;
-
-extern usbTxStatus_t   usbTxStatus1, usbTxStatus3;
-#define usbTxLen1   usbTxStatus1.len
-#define usbTxBuf1   usbTxStatus1.buffer
-#define usbTxLen3   usbTxStatus3.len
-#define usbTxBuf3   usbTxStatus3.buffer
-
-
-typedef union usbWord{
-    unsigned    word;
-    uchar       bytes[2];
-}usbWord_t;
-
-typedef struct usbRequest{
-    uchar       bmRequestType;
-    uchar       bRequest;
-    usbWord_t   wValue;
-    usbWord_t   wIndex;
-    usbWord_t   wLength;
-}usbRequest_t;
+typedef struct usbTxStatus {
+    volatile uchar len;
+    uchar          buffer[USB_BUFSIZE];
+} usbTxStatus_t;
+
+extern usbTxStatus_t usbTxStatus1, usbTxStatus3;
+#    define usbTxLen1 usbTxStatus1.len
+#    define usbTxBuf1 usbTxStatus1.buffer
+#    define usbTxLen3 usbTxStatus3.len
+#    define usbTxBuf3 usbTxStatus3.buffer
+
+typedef union usbWord {
+    unsigned word;
+    uchar    bytes[2];
+} usbWord_t;
+
+typedef struct usbRequest {
+    uchar     bmRequestType;
+    uchar     bRequest;
+    usbWord_t wValue;
+    usbWord_t wIndex;
+    usbWord_t wLength;
+} usbRequest_t;
 /* This structure matches the 8 byte setup request */
 #endif
 
@@ -679,56 +674,56 @@ typedef struct usbRequest{
  */
 
 /* USB setup recipient values */
-#define USBRQ_RCPT_MASK         0x1f
-#define USBRQ_RCPT_DEVICE       0
-#define USBRQ_RCPT_INTERFACE    1
-#define USBRQ_RCPT_ENDPOINT     2
+#define USBRQ_RCPT_MASK 0x1f
+#define USBRQ_RCPT_DEVICE 0
+#define USBRQ_RCPT_INTERFACE 1
+#define USBRQ_RCPT_ENDPOINT 2
 
 /* USB request type values */
-#define USBRQ_TYPE_MASK         0x60
-#define USBRQ_TYPE_STANDARD     (0<<5)
-#define USBRQ_TYPE_CLASS        (1<<5)
-#define USBRQ_TYPE_VENDOR       (2<<5)
+#define USBRQ_TYPE_MASK 0x60
+#define USBRQ_TYPE_STANDARD (0 << 5)
+#define USBRQ_TYPE_CLASS (1 << 5)
+#define USBRQ_TYPE_VENDOR (2 << 5)
 
 /* USB direction values: */
-#define USBRQ_DIR_MASK              0x80
-#define USBRQ_DIR_HOST_TO_DEVICE    (0<<7)
-#define USBRQ_DIR_DEVICE_TO_HOST    (1<<7)
+#define USBRQ_DIR_MASK 0x80
+#define USBRQ_DIR_HOST_TO_DEVICE (0 << 7)
+#define USBRQ_DIR_DEVICE_TO_HOST (1 << 7)
 
 /* USB Standard Requests */
-#define USBRQ_GET_STATUS        0
-#define USBRQ_CLEAR_FEATURE     1
-#define USBRQ_SET_FEATURE       3
-#define USBRQ_SET_ADDRESS       5
-#define USBRQ_GET_DESCRIPTOR    6
-#define USBRQ_SET_DESCRIPTOR    7
+#define USBRQ_GET_STATUS 0
+#define USBRQ_CLEAR_FEATURE 1
+#define USBRQ_SET_FEATURE 3
+#define USBRQ_SET_ADDRESS 5
+#define USBRQ_GET_DESCRIPTOR 6
+#define USBRQ_SET_DESCRIPTOR 7
 #define USBRQ_GET_CONFIGURATION 8
 #define USBRQ_SET_CONFIGURATION 9
-#define USBRQ_GET_INTERFACE     10
-#define USBRQ_SET_INTERFACE     11
-#define USBRQ_SYNCH_FRAME       12
+#define USBRQ_GET_INTERFACE 10
+#define USBRQ_SET_INTERFACE 11
+#define USBRQ_SYNCH_FRAME 12
 
 /* USB descriptor constants */
-#define USBDESCR_DEVICE         1
-#define USBDESCR_CONFIG         2
-#define USBDESCR_STRING         3
-#define USBDESCR_INTERFACE      4
-#define USBDESCR_ENDPOINT       5
-#define USBDESCR_HID            0x21
-#define USBDESCR_HID_REPORT     0x22
-#define USBDESCR_HID_PHYS       0x23
+#define USBDESCR_DEVICE 1
+#define USBDESCR_CONFIG 2
+#define USBDESCR_STRING 3
+#define USBDESCR_INTERFACE 4
+#define USBDESCR_ENDPOINT 5
+#define USBDESCR_HID 0x21
+#define USBDESCR_HID_REPORT 0x22
+#define USBDESCR_HID_PHYS 0x23
 
 //#define USBATTR_BUSPOWER        0x80  // USB 1.1 does not define this value any more
-#define USBATTR_SELFPOWER       0x40
-#define USBATTR_REMOTEWAKE      0x20
+#define USBATTR_SELFPOWER 0x40
+#define USBATTR_REMOTEWAKE 0x20
 
 /* USB HID Requests */
-#define USBRQ_HID_GET_REPORT    0x01
-#define USBRQ_HID_GET_IDLE      0x02
-#define USBRQ_HID_GET_PROTOCOL  0x03
-#define USBRQ_HID_SET_REPORT    0x09
-#define USBRQ_HID_SET_IDLE      0x0a
-#define USBRQ_HID_SET_PROTOCOL  0x0b
+#define USBRQ_HID_GET_REPORT 0x01
+#define USBRQ_HID_GET_IDLE 0x02
+#define USBRQ_HID_GET_PROTOCOL 0x03
+#define USBRQ_HID_SET_REPORT 0x09
+#define USBRQ_HID_SET_IDLE 0x0a
+#define USBRQ_HID_SET_PROTOCOL 0x0b
 
 /* ------------------------------------------------------------------------- */
 
diff --git a/tmk_core/protocol/vusb/vusb.c b/tmk_core/protocol/vusb/vusb.c
index 60e48c3a9c..3719b7aa0f 100644
--- a/tmk_core/protocol/vusb/vusb.c
+++ b/tmk_core/protocol/vusb/vusb.c
@@ -29,36 +29,38 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "bootloader.h"
 #include <util/delay.h>
 
-
 static uint8_t vusb_keyboard_leds = 0;
-static uint8_t vusb_idle_rate = 0;
+static uint8_t vusb_idle_rate     = 0;
 
 /* Keyboard report send buffer */
 #define KBUF_SIZE 16
 static report_keyboard_t kbuf[KBUF_SIZE];
-static uint8_t kbuf_head = 0;
-static uint8_t kbuf_tail = 0;
+static uint8_t           kbuf_head = 0;
+static uint8_t           kbuf_tail = 0;
 
 typedef struct {
-        uint8_t modifier;
-        uint8_t reserved;
-        uint8_t keycode[6];
+    uint8_t modifier;
+    uint8_t reserved;
+    uint8_t keycode[6];
 } keyboard_report_t;
 
-static keyboard_report_t keyboard_report; // sent to PC
+static keyboard_report_t keyboard_report;  // sent to PC
 
 #define VUSB_TRANSFER_KEYBOARD_MAX_TRIES 10
 
 /* transfer keyboard report from buffer */
-void vusb_transfer_keyboard(void)
-{
+void vusb_transfer_keyboard(void) {
     for (int i = 0; i < VUSB_TRANSFER_KEYBOARD_MAX_TRIES; i++) {
         if (usbInterruptIsReady()) {
             if (kbuf_head != kbuf_tail) {
                 usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
                 kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
                 if (debug_keyboard) {
-                    print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("](");
+                    print("V-USB: kbuf[");
+                    pdec(kbuf_tail);
+                    print("->");
+                    pdec(kbuf_head);
+                    print("](");
                     phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
                     print(")\n");
                 }
@@ -70,39 +72,26 @@ void vusb_transfer_keyboard(void)
     }
 }
 
-
 /*------------------------------------------------------------------*
  * Host driver
  *------------------------------------------------------------------*/
 static uint8_t keyboard_leds(void);
-static void send_keyboard(report_keyboard_t *report);
-static void send_mouse(report_mouse_t *report);
-static void send_system(uint16_t data);
-static void send_consumer(uint16_t data);
-
-static host_driver_t driver = {
-        keyboard_leds,
-        send_keyboard,
-        send_mouse,
-        send_system,
-        send_consumer
-};
+static void    send_keyboard(report_keyboard_t *report);
+static void    send_mouse(report_mouse_t *report);
+static void    send_system(uint16_t data);
+static void    send_consumer(uint16_t data);
 
-host_driver_t *vusb_driver(void)
-{
-    return &driver;
-}
+static host_driver_t driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};
 
-static uint8_t keyboard_leds(void) {
-    return vusb_keyboard_leds;
-}
+host_driver_t *vusb_driver(void) { return &driver; }
+
+static uint8_t keyboard_leds(void) { return vusb_keyboard_leds; }
 
-static void send_keyboard(report_keyboard_t *report)
-{
+static void send_keyboard(report_keyboard_t *report) {
     uint8_t next = (kbuf_head + 1) % KBUF_SIZE;
     if (next != kbuf_tail) {
         kbuf[kbuf_head] = *report;
-        kbuf_head = next;
+        kbuf_head       = next;
     } else {
         debug("kbuf: full\n");
     }
@@ -112,119 +101,97 @@ static void send_keyboard(report_keyboard_t *report)
     vusb_transfer_keyboard();
 }
 
-
 typedef struct {
-    uint8_t report_id;
+    uint8_t        report_id;
     report_mouse_t report;
-} __attribute__ ((packed)) vusb_mouse_report_t;
-
-static void send_mouse(report_mouse_t *report)
-{
-    vusb_mouse_report_t r = {
-        .report_id = REPORT_ID_MOUSE,
-        .report = *report
-    };
+} __attribute__((packed)) vusb_mouse_report_t;
+
+static void send_mouse(report_mouse_t *report) {
+    vusb_mouse_report_t r = {.report_id = REPORT_ID_MOUSE, .report = *report};
     if (usbInterruptIsReady3()) {
         usbSetInterrupt3((void *)&r, sizeof(vusb_mouse_report_t));
     }
 }
 
-
 typedef struct {
     uint8_t  report_id;
     uint16_t usage;
-} __attribute__ ((packed)) report_extra_t;
+} __attribute__((packed)) report_extra_t;
 
-static void send_system(uint16_t data)
-{
+static void send_system(uint16_t data) {
     static uint16_t last_data = 0;
     if (data == last_data) return;
     last_data = data;
 
-    report_extra_t report = {
-        .report_id = REPORT_ID_SYSTEM,
-        .usage = data
-    };
+    report_extra_t report = {.report_id = REPORT_ID_SYSTEM, .usage = data};
     if (usbInterruptIsReady3()) {
         usbSetInterrupt3((void *)&report, sizeof(report));
     }
 }
 
-static void send_consumer(uint16_t data)
-{
+static void send_consumer(uint16_t data) {
     static uint16_t last_data = 0;
     if (data == last_data) return;
     last_data = data;
 
-    report_extra_t report = {
-        .report_id = REPORT_ID_CONSUMER,
-        .usage = data
-    };
+    report_extra_t report = {.report_id = REPORT_ID_CONSUMER, .usage = data};
     if (usbInterruptIsReady3()) {
         usbSetInterrupt3((void *)&report, sizeof(report));
     }
 }
 
-
-
 /*------------------------------------------------------------------*
  * Request from host                                                *
  *------------------------------------------------------------------*/
 static struct {
-    uint16_t        len;
-    enum {
-        NONE,
-        BOOTLOADER,
-        SET_LED
-    }               kind;
+    uint16_t len;
+    enum { NONE, BOOTLOADER, SET_LED } kind;
 } last_req;
 
-usbMsgLen_t usbFunctionSetup(uchar data[8])
-{
-usbRequest_t    *rq = (void *)data;
+usbMsgLen_t usbFunctionSetup(uchar data[8]) {
+    usbRequest_t *rq = (void *)data;
 
-    if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){    /* class request type */
-        if(rq->bRequest == USBRQ_HID_GET_REPORT){
+    if ((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS) { /* class request type */
+        if (rq->bRequest == USBRQ_HID_GET_REPORT) {
             debug("GET_REPORT:");
             /* we only have one report type, so don't look at wValue */
             usbMsgPtr = (void *)&keyboard_report;
             return sizeof(keyboard_report);
-        }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
+        } else if (rq->bRequest == USBRQ_HID_GET_IDLE) {
             debug("GET_IDLE: ");
-            //debug_hex(vusb_idle_rate);
+            // debug_hex(vusb_idle_rate);
             usbMsgPtr = &vusb_idle_rate;
             return 1;
-        }else if(rq->bRequest == USBRQ_HID_SET_IDLE){
+        } else if (rq->bRequest == USBRQ_HID_SET_IDLE) {
             vusb_idle_rate = rq->wValue.bytes[1];
             debug("SET_IDLE: ");
             debug_hex(vusb_idle_rate);
-        }else if(rq->bRequest == USBRQ_HID_SET_REPORT){
+        } else if (rq->bRequest == USBRQ_HID_SET_REPORT) {
             debug("SET_REPORT: ");
             // Report Type: 0x02(Out)/ReportID: 0x00(none) && Interface: 0(keyboard)
             if (rq->wValue.word == 0x0200 && rq->wIndex.word == 0) {
                 debug("SET_LED: ");
                 last_req.kind = SET_LED;
-                last_req.len = rq->wLength.word;
+                last_req.len  = rq->wLength.word;
 #ifdef BOOTLOADER_SIZE
-            } else if(rq->wValue.word == 0x0301) {
+            } else if (rq->wValue.word == 0x0301) {
                 last_req.kind = BOOTLOADER;
-                last_req.len = rq->wLength.word;
+                last_req.len  = rq->wLength.word;
 #endif
             }
-            return USB_NO_MSG; // to get data in usbFunctionWrite
+            return USB_NO_MSG;  // to get data in usbFunctionWrite
         } else {
             debug("UNKNOWN:");
         }
-    }else{
+    } else {
         debug("VENDOR:");
         /* no vendor specific requests implemented */
     }
     debug("\n");
-    return 0;   /* default for not implemented requests: return no data back to host */
+    return 0; /* default for not implemented requests: return no data back to host */
 }
 
-uchar usbFunctionWrite(uchar *data, uchar len)
-{
+uchar usbFunctionWrite(uchar *data, uchar len) {
     if (last_req.len == 0) {
         return -1;
     }
@@ -234,7 +201,7 @@ uchar usbFunctionWrite(uchar *data, uchar len)
             debug_hex(data[0]);
             debug("\n");
             vusb_keyboard_leds = data[0];
-            last_req.len = 0;
+            last_req.len       = 0;
             return 1;
             break;
         case BOOTLOADER:
@@ -250,8 +217,6 @@ uchar usbFunctionWrite(uchar *data, uchar len)
     return 1;
 }
 
-
-
 /*------------------------------------------------------------------*
  * Descriptors                                                      *
  *------------------------------------------------------------------*/
@@ -262,38 +227,38 @@ uchar usbFunctionWrite(uchar *data, uchar len)
  * from an example in HID spec appendix
  */
 const PROGMEM uchar keyboard_hid_report[] = {
-    0x05, 0x01,          // Usage Page (Generic Desktop),
-    0x09, 0x06,          // Usage (Keyboard),
-    0xA1, 0x01,          // Collection (Application),
-    0x75, 0x01,          //   Report Size (1),
-    0x95, 0x08,          //   Report Count (8),
-    0x05, 0x07,          //   Usage Page (Key Codes),
-    0x19, 0xE0,          //   Usage Minimum (224),
-    0x29, 0xE7,          //   Usage Maximum (231),
-    0x15, 0x00,          //   Logical Minimum (0),
-    0x25, 0x01,          //   Logical Maximum (1),
-    0x81, 0x02,          //   Input (Data, Variable, Absolute), ;Modifier byte
-    0x95, 0x01,          //   Report Count (1),
-    0x75, 0x08,          //   Report Size (8),
-    0x81, 0x03,          //   Input (Constant),                 ;Reserved byte
-    0x95, 0x05,          //   Report Count (5),
-    0x75, 0x01,          //   Report Size (1),
-    0x05, 0x08,          //   Usage Page (LEDs),
-    0x19, 0x01,          //   Usage Minimum (1),
-    0x29, 0x05,          //   Usage Maximum (5),
-    0x91, 0x02,          //   Output (Data, Variable, Absolute), ;LED report
-    0x95, 0x01,          //   Report Count (1),
-    0x75, 0x03,          //   Report Size (3),
-    0x91, 0x03,          //   Output (Constant),                 ;LED report padding
-    0x95, 0x06,          //   Report Count (6),
-    0x75, 0x08,          //   Report Size (8),
-    0x15, 0x00,          //   Logical Minimum (0),
-    0x26, 0xFF, 0x00,    //   Logical Maximum(255),
-    0x05, 0x07,          //   Usage Page (Key Codes),
-    0x19, 0x00,          //   Usage Minimum (0),
-    0x29, 0xFF,          //   Usage Maximum (255),
-    0x81, 0x00,          //   Input (Data, Array),
-    0xc0                 // End Collection
+    0x05, 0x01,        // Usage Page (Generic Desktop),
+    0x09, 0x06,        // Usage (Keyboard),
+    0xA1, 0x01,        // Collection (Application),
+    0x75, 0x01,        //   Report Size (1),
+    0x95, 0x08,        //   Report Count (8),
+    0x05, 0x07,        //   Usage Page (Key Codes),
+    0x19, 0xE0,        //   Usage Minimum (224),
+    0x29, 0xE7,        //   Usage Maximum (231),
+    0x15, 0x00,        //   Logical Minimum (0),
+    0x25, 0x01,        //   Logical Maximum (1),
+    0x81, 0x02,        //   Input (Data, Variable, Absolute), ;Modifier byte
+    0x95, 0x01,        //   Report Count (1),
+    0x75, 0x08,        //   Report Size (8),
+    0x81, 0x03,        //   Input (Constant),                 ;Reserved byte
+    0x95, 0x05,        //   Report Count (5),
+    0x75, 0x01,        //   Report Size (1),
+    0x05, 0x08,        //   Usage Page (LEDs),
+    0x19, 0x01,        //   Usage Minimum (1),
+    0x29, 0x05,        //   Usage Maximum (5),
+    0x91, 0x02,        //   Output (Data, Variable, Absolute), ;LED report
+    0x95, 0x01,        //   Report Count (1),
+    0x75, 0x03,        //   Report Size (3),
+    0x91, 0x03,        //   Output (Constant),                 ;LED report padding
+    0x95, 0x06,        //   Report Count (6),
+    0x75, 0x08,        //   Report Size (8),
+    0x15, 0x00,        //   Logical Minimum (0),
+    0x26, 0xFF, 0x00,  //   Logical Maximum(255),
+    0x05, 0x07,        //   Usage Page (Key Codes),
+    0x19, 0x00,        //   Usage Minimum (0),
+    0x29, 0xFF,        //   Usage Maximum (255),
+    0x81, 0x00,        //   Input (Data, Array),
+    0xc0               // End Collection
 };
 
 /*
@@ -306,196 +271,191 @@ const PROGMEM uchar keyboard_hid_report[] = {
  */
 const PROGMEM uchar mouse_hid_report[] = {
     /* mouse */
-    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
-    0x09, 0x02,                    // USAGE (Mouse)
-    0xa1, 0x01,                    // COLLECTION (Application)
-    0x85, REPORT_ID_MOUSE,         //   REPORT_ID (1)
-    0x09, 0x01,                    //   USAGE (Pointer)
-    0xa1, 0x00,                    //   COLLECTION (Physical)
-                                   // ----------------------------  Buttons
-    0x05, 0x09,                    //     USAGE_PAGE (Button)
-    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
-    0x29, 0x05,                    //     USAGE_MAXIMUM (Button 5)
-    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
-    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
-    0x75, 0x01,                    //     REPORT_SIZE (1)
-    0x95, 0x05,                    //     REPORT_COUNT (5)
-    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-    0x75, 0x03,                    //     REPORT_SIZE (3)
-    0x95, 0x01,                    //     REPORT_COUNT (1)
-    0x81, 0x03,                    //     INPUT (Cnst,Var,Abs)
-                                   // ----------------------------  X,Y position
-    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
-    0x09, 0x30,                    //     USAGE (X)
-    0x09, 0x31,                    //     USAGE (Y)
-    0x15, 0x81,                    //     LOGICAL_MINIMUM (-127)
-    0x25, 0x7f,                    //     LOGICAL_MAXIMUM (127)
-    0x75, 0x08,                    //     REPORT_SIZE (8)
-    0x95, 0x02,                    //     REPORT_COUNT (2)
-    0x81, 0x06,                    //     INPUT (Data,Var,Rel)
-                                   // ----------------------------  Vertical wheel
-    0x09, 0x38,                    //     USAGE (Wheel)
-    0x15, 0x81,                    //     LOGICAL_MINIMUM (-127)
-    0x25, 0x7f,                    //     LOGICAL_MAXIMUM (127)
-    0x35, 0x00,                    //     PHYSICAL_MINIMUM (0)        - reset physical
-    0x45, 0x00,                    //     PHYSICAL_MAXIMUM (0)
-    0x75, 0x08,                    //     REPORT_SIZE (8)
-    0x95, 0x01,                    //     REPORT_COUNT (1)
-    0x81, 0x06,                    //     INPUT (Data,Var,Rel)
-                                   // ----------------------------  Horizontal wheel
-    0x05, 0x0c,                    //     USAGE_PAGE (Consumer Devices)
-    0x0a, 0x38, 0x02,              //     USAGE (AC Pan)
-    0x15, 0x81,                    //     LOGICAL_MINIMUM (-127)
-    0x25, 0x7f,                    //     LOGICAL_MAXIMUM (127)
-    0x75, 0x08,                    //     REPORT_SIZE (8)
-    0x95, 0x01,                    //     REPORT_COUNT (1)
-    0x81, 0x06,                    //     INPUT (Data,Var,Rel)
-    0xc0,                          //   END_COLLECTION
-    0xc0,                          // END_COLLECTION
+    0x05, 0x01,             // USAGE_PAGE (Generic Desktop)
+    0x09, 0x02,             // USAGE (Mouse)
+    0xa1, 0x01,             // COLLECTION (Application)
+    0x85, REPORT_ID_MOUSE,  //   REPORT_ID (1)
+    0x09, 0x01,             //   USAGE (Pointer)
+    0xa1, 0x00,             //   COLLECTION (Physical)
+                            // ----------------------------  Buttons
+    0x05, 0x09,             //     USAGE_PAGE (Button)
+    0x19, 0x01,             //     USAGE_MINIMUM (Button 1)
+    0x29, 0x05,             //     USAGE_MAXIMUM (Button 5)
+    0x15, 0x00,             //     LOGICAL_MINIMUM (0)
+    0x25, 0x01,             //     LOGICAL_MAXIMUM (1)
+    0x75, 0x01,             //     REPORT_SIZE (1)
+    0x95, 0x05,             //     REPORT_COUNT (5)
+    0x81, 0x02,             //     INPUT (Data,Var,Abs)
+    0x75, 0x03,             //     REPORT_SIZE (3)
+    0x95, 0x01,             //     REPORT_COUNT (1)
+    0x81, 0x03,             //     INPUT (Cnst,Var,Abs)
+                            // ----------------------------  X,Y position
+    0x05, 0x01,             //     USAGE_PAGE (Generic Desktop)
+    0x09, 0x30,             //     USAGE (X)
+    0x09, 0x31,             //     USAGE (Y)
+    0x15, 0x81,             //     LOGICAL_MINIMUM (-127)
+    0x25, 0x7f,             //     LOGICAL_MAXIMUM (127)
+    0x75, 0x08,             //     REPORT_SIZE (8)
+    0x95, 0x02,             //     REPORT_COUNT (2)
+    0x81, 0x06,             //     INPUT (Data,Var,Rel)
+                            // ----------------------------  Vertical wheel
+    0x09, 0x38,             //     USAGE (Wheel)
+    0x15, 0x81,             //     LOGICAL_MINIMUM (-127)
+    0x25, 0x7f,             //     LOGICAL_MAXIMUM (127)
+    0x35, 0x00,             //     PHYSICAL_MINIMUM (0)        - reset physical
+    0x45, 0x00,             //     PHYSICAL_MAXIMUM (0)
+    0x75, 0x08,             //     REPORT_SIZE (8)
+    0x95, 0x01,             //     REPORT_COUNT (1)
+    0x81, 0x06,             //     INPUT (Data,Var,Rel)
+                            // ----------------------------  Horizontal wheel
+    0x05, 0x0c,             //     USAGE_PAGE (Consumer Devices)
+    0x0a, 0x38, 0x02,       //     USAGE (AC Pan)
+    0x15, 0x81,             //     LOGICAL_MINIMUM (-127)
+    0x25, 0x7f,             //     LOGICAL_MAXIMUM (127)
+    0x75, 0x08,             //     REPORT_SIZE (8)
+    0x95, 0x01,             //     REPORT_COUNT (1)
+    0x81, 0x06,             //     INPUT (Data,Var,Rel)
+    0xc0,                   //   END_COLLECTION
+    0xc0,                   // END_COLLECTION
     /* system control */
-    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
-    0x09, 0x80,                    // USAGE (System Control)
-    0xa1, 0x01,                    // COLLECTION (Application)
-    0x85, REPORT_ID_SYSTEM,        //   REPORT_ID (2)
-    0x15, 0x01,                    //   LOGICAL_MINIMUM (0x1)
-    0x26, 0xb7, 0x00,              //   LOGICAL_MAXIMUM (0xb7)
-    0x19, 0x01,                    //   USAGE_MINIMUM (0x1)
-    0x29, 0xb7,                    //   USAGE_MAXIMUM (0xb7)
-    0x75, 0x10,                    //   REPORT_SIZE (16)
-    0x95, 0x01,                    //   REPORT_COUNT (1)
-    0x81, 0x00,                    //   INPUT (Data,Array,Abs)
-    0xc0,                          // END_COLLECTION
+    0x05, 0x01,              // USAGE_PAGE (Generic Desktop)
+    0x09, 0x80,              // USAGE (System Control)
+    0xa1, 0x01,              // COLLECTION (Application)
+    0x85, REPORT_ID_SYSTEM,  //   REPORT_ID (2)
+    0x15, 0x01,              //   LOGICAL_MINIMUM (0x1)
+    0x26, 0xb7, 0x00,        //   LOGICAL_MAXIMUM (0xb7)
+    0x19, 0x01,              //   USAGE_MINIMUM (0x1)
+    0x29, 0xb7,              //   USAGE_MAXIMUM (0xb7)
+    0x75, 0x10,              //   REPORT_SIZE (16)
+    0x95, 0x01,              //   REPORT_COUNT (1)
+    0x81, 0x00,              //   INPUT (Data,Array,Abs)
+    0xc0,                    // END_COLLECTION
     /* consumer */
-    0x05, 0x0c,                    // USAGE_PAGE (Consumer Devices)
-    0x09, 0x01,                    // USAGE (Consumer Control)
-    0xa1, 0x01,                    // COLLECTION (Application)
-    0x85, REPORT_ID_CONSUMER,      //   REPORT_ID (3)
-    0x15, 0x01,                    //   LOGICAL_MINIMUM (0x1)
-    0x26, 0x9c, 0x02,              //   LOGICAL_MAXIMUM (0x29c)
-    0x19, 0x01,                    //   USAGE_MINIMUM (0x1)
-    0x2a, 0x9c, 0x02,              //   USAGE_MAXIMUM (0x29c)
-    0x75, 0x10,                    //   REPORT_SIZE (16)
-    0x95, 0x01,                    //   REPORT_COUNT (1)
-    0x81, 0x00,                    //   INPUT (Data,Array,Abs)
-    0xc0,                          // END_COLLECTION
+    0x05, 0x0c,                // USAGE_PAGE (Consumer Devices)
+    0x09, 0x01,                // USAGE (Consumer Control)
+    0xa1, 0x01,                // COLLECTION (Application)
+    0x85, REPORT_ID_CONSUMER,  //   REPORT_ID (3)
+    0x15, 0x01,                //   LOGICAL_MINIMUM (0x1)
+    0x26, 0x9c, 0x02,          //   LOGICAL_MAXIMUM (0x29c)
+    0x19, 0x01,                //   USAGE_MINIMUM (0x1)
+    0x2a, 0x9c, 0x02,          //   USAGE_MAXIMUM (0x29c)
+    0x75, 0x10,                //   REPORT_SIZE (16)
+    0x95, 0x01,                //   REPORT_COUNT (1)
+    0x81, 0x00,                //   INPUT (Data,Array,Abs)
+    0xc0,                      // END_COLLECTION
 };
 
-
-/* 
+/*
  * Descriptor for compite device: Keyboard + Mouse
- * 
+ *
  * contains: device, interface, HID and endpoint descriptors
  */
 #if USB_CFG_DESCR_PROPS_CONFIGURATION
-const PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor */
-    9,          /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */
-    USBDESCR_CONFIG,    /* descriptor type */
+const PROGMEM char usbDescriptorConfiguration[] = {
+    /* USB configuration descriptor */
+    9,               /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */
+    USBDESCR_CONFIG, /* descriptor type */
     9 + (9 + 9 + 7) + (9 + 9 + 7), 0,
-    //18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + 9, 0,
-                /* total length of data returned (including inlined descriptors) */
-    2,          /* number of interfaces in this configuration */
-    1,          /* index of this configuration */
-    0,          /* configuration name string index */
-#if USB_CFG_IS_SELF_POWERED
-    (1 << 7) | USBATTR_SELFPOWER,       /* attributes */
-#else
-    (1 << 7),                           /* attributes */
-#endif
-    USB_CFG_MAX_BUS_POWER/2,            /* max USB current in 2mA units */
+    // 18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT3 + 9, 0,
+    /* total length of data returned (including inlined descriptors) */
+    2, /* number of interfaces in this configuration */
+    1, /* index of this configuration */
+    0, /* configuration name string index */
+#    if USB_CFG_IS_SELF_POWERED
+    (1 << 7) | USBATTR_SELFPOWER, /* attributes */
+#    else
+    (1 << 7), /* attributes */
+#    endif
+    USB_CFG_MAX_BUS_POWER / 2, /* max USB current in 2mA units */
 
     /*
      * Keyboard interface
      */
     /* Interface descriptor */
-    9,          /* sizeof(usbDescrInterface): length of descriptor in bytes */
-    USBDESCR_INTERFACE, /* descriptor type */
-    0,          /* index of this interface */
-    0,          /* alternate setting for this interface */
-    USB_CFG_HAVE_INTRIN_ENDPOINT, /* endpoints excl 0: number of endpoint descriptors to follow */
-    USB_CFG_INTERFACE_CLASS,
-    USB_CFG_INTERFACE_SUBCLASS,
-    USB_CFG_INTERFACE_PROTOCOL,
-    0,          /* string index for interface */
+    9,                                                                                  /* sizeof(usbDescrInterface): length of descriptor in bytes */
+    USBDESCR_INTERFACE,                                                                 /* descriptor type */
+    0,                                                                                  /* index of this interface */
+    0,                                                                                  /* alternate setting for this interface */
+    USB_CFG_HAVE_INTRIN_ENDPOINT,                                                       /* endpoints excl 0: number of endpoint descriptors to follow */
+    USB_CFG_INTERFACE_CLASS, USB_CFG_INTERFACE_SUBCLASS, USB_CFG_INTERFACE_PROTOCOL, 0, /* string index for interface */
     /* HID descriptor */
-    9,          /* sizeof(usbDescrHID): length of descriptor in bytes */
-    USBDESCR_HID,   /* descriptor type: HID */
-    0x01, 0x01, /* BCD representation of HID version */
-    0x00,       /* target country code */
-    0x01,       /* number of HID Report (or other HID class) Descriptor infos to follow */
-    0x22,       /* descriptor type: report */
-    sizeof(keyboard_hid_report), 0,  /* total length of report descriptor */
-    /* Endpoint descriptor */
-#if USB_CFG_HAVE_INTRIN_ENDPOINT    /* endpoint descriptor for endpoint 1 */
-    7,          /* sizeof(usbDescrEndpoint) */
-    USBDESCR_ENDPOINT,  /* descriptor type = endpoint */
-    (char)0x81, /* IN endpoint number 1 */
-    0x03,       /* attrib: Interrupt endpoint */
-    8, 0,       /* maximum packet size */
-    USB_CFG_INTR_POLL_INTERVAL, /* in ms */
-#endif
+    9,                              /* sizeof(usbDescrHID): length of descriptor in bytes */
+    USBDESCR_HID,                   /* descriptor type: HID */
+    0x01, 0x01,                     /* BCD representation of HID version */
+    0x00,                           /* target country code */
+    0x01,                           /* number of HID Report (or other HID class) Descriptor infos to follow */
+    0x22,                           /* descriptor type: report */
+    sizeof(keyboard_hid_report), 0, /* total length of report descriptor */
+/* Endpoint descriptor */
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT /* endpoint descriptor for endpoint 1 */
+    7,                               /* sizeof(usbDescrEndpoint) */
+    USBDESCR_ENDPOINT,               /* descriptor type = endpoint */
+    (char)0x81,                      /* IN endpoint number 1 */
+    0x03,                            /* attrib: Interrupt endpoint */
+    8, 0,                            /* maximum packet size */
+    USB_CFG_INTR_POLL_INTERVAL,      /* in ms */
+#    endif
 
     /*
      * Mouse interface
      */
     /* Interface descriptor */
-    9,          /* sizeof(usbDescrInterface): length of descriptor in bytes */
-    USBDESCR_INTERFACE, /* descriptor type */
-    1,          /* index of this interface */
-    0,          /* alternate setting for this interface */
+    9,                             /* sizeof(usbDescrInterface): length of descriptor in bytes */
+    USBDESCR_INTERFACE,            /* descriptor type */
+    1,                             /* index of this interface */
+    0,                             /* alternate setting for this interface */
     USB_CFG_HAVE_INTRIN_ENDPOINT3, /* endpoints excl 0: number of endpoint descriptors to follow */
-    0x03,       /* CLASS: HID */
-    0,          /* SUBCLASS: none */
-    0,          /* PROTOCOL: none */
-    0,          /* string index for interface */
+    0x03,                          /* CLASS: HID */
+    0,                             /* SUBCLASS: none */
+    0,                             /* PROTOCOL: none */
+    0,                             /* string index for interface */
     /* HID descriptor */
-    9,          /* sizeof(usbDescrHID): length of descriptor in bytes */
-    USBDESCR_HID,   /* descriptor type: HID */
-    0x01, 0x01, /* BCD representation of HID version */
-    0x00,       /* target country code */
-    0x01,       /* number of HID Report (or other HID class) Descriptor infos to follow */
-    0x22,       /* descriptor type: report */
-    sizeof(mouse_hid_report), 0,  /* total length of report descriptor */
-#if USB_CFG_HAVE_INTRIN_ENDPOINT3   /* endpoint descriptor for endpoint 3 */
+    9,                                /* sizeof(usbDescrHID): length of descriptor in bytes */
+    USBDESCR_HID,                     /* descriptor type: HID */
+    0x01, 0x01,                       /* BCD representation of HID version */
+    0x00,                             /* target country code */
+    0x01,                             /* number of HID Report (or other HID class) Descriptor infos to follow */
+    0x22,                             /* descriptor type: report */
+    sizeof(mouse_hid_report), 0,      /* total length of report descriptor */
+#    if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* endpoint descriptor for endpoint 3 */
     /* Endpoint descriptor */
-    7,          /* sizeof(usbDescrEndpoint) */
-    USBDESCR_ENDPOINT,  /* descriptor type = endpoint */
+    7,                                 /* sizeof(usbDescrEndpoint) */
+    USBDESCR_ENDPOINT,                 /* descriptor type = endpoint */
     (char)(0x80 | USB_CFG_EP3_NUMBER), /* IN endpoint number 3 */
-    0x03,       /* attrib: Interrupt endpoint */
-    8, 0,       /* maximum packet size */
-    USB_CFG_INTR_POLL_INTERVAL, /* in ms */
-#endif
+    0x03,                              /* attrib: Interrupt endpoint */
+    8, 0,                              /* maximum packet size */
+    USB_CFG_INTR_POLL_INTERVAL,        /* in ms */
+#    endif
 };
 #endif
 
-
-USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq)
-{
+USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq) {
     usbMsgLen_t len = 0;
 
-/*
-    debug("usbFunctionDescriptor: ");
-    debug_hex(rq->bmRequestType); debug(" ");
-    debug_hex(rq->bRequest); debug(" ");
-    debug_hex16(rq->wValue.word); debug(" ");
-    debug_hex16(rq->wIndex.word); debug(" ");
-    debug_hex16(rq->wLength.word); debug("\n");
-*/
+    /*
+        debug("usbFunctionDescriptor: ");
+        debug_hex(rq->bmRequestType); debug(" ");
+        debug_hex(rq->bRequest); debug(" ");
+        debug_hex16(rq->wValue.word); debug(" ");
+        debug_hex16(rq->wIndex.word); debug(" ");
+        debug_hex16(rq->wLength.word); debug("\n");
+    */
     switch (rq->wValue.bytes[1]) {
 #if USB_CFG_DESCR_PROPS_CONFIGURATION
         case USBDESCR_CONFIG:
             usbMsgPtr = (unsigned char *)usbDescriptorConfiguration;
-            len = sizeof(usbDescriptorConfiguration);
+            len       = sizeof(usbDescriptorConfiguration);
             break;
 #endif
         case USBDESCR_HID:
             switch (rq->wValue.bytes[0]) {
                 case 0:
                     usbMsgPtr = (unsigned char *)(usbDescriptorConfiguration + 9 + 9);
-                    len = 9;
+                    len       = 9;
                     break;
                 case 1:
                     usbMsgPtr = (unsigned char *)(usbDescriptorConfiguration + 9 + (9 + 9 + 7) + 9);
-                    len = 9;
+                    len       = 9;
                     break;
             }
             break;
@@ -504,15 +464,15 @@ USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq)
             switch (rq->wIndex.word) {
                 case 0:
                     usbMsgPtr = (unsigned char *)keyboard_hid_report;
-                    len = sizeof(keyboard_hid_report);
+                    len       = sizeof(keyboard_hid_report);
                     break;
                 case 1:
                     usbMsgPtr = (unsigned char *)mouse_hid_report;
-                    len = sizeof(mouse_hid_report);
+                    len       = sizeof(mouse_hid_report);
                     break;
             }
             break;
     }
-    //debug("desc len: "); debug_hex(len); debug("\n");
+    // debug("desc len: "); debug_hex(len); debug("\n");
     return len;
 }
diff --git a/tmk_core/protocol/vusb/vusb.h b/tmk_core/protocol/vusb/vusb.h
index 5accf233be..7e3f8c394d 100644
--- a/tmk_core/protocol/vusb/vusb.h
+++ b/tmk_core/protocol/vusb/vusb.h
@@ -20,8 +20,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "host_driver.h"
 
-
 host_driver_t *vusb_driver(void);
-void vusb_transfer_keyboard(void);
+void           vusb_transfer_keyboard(void);
 
 #endif