clang-format changes

3 files changed, 144 insertions, 174 deletions

diff --git a/tmk_core/protocol/mbed/HIDKeyboard.cpp b/tmk_core/protocol/mbed/HIDKeyboard.cpp
index 947077cd24..dbaf108fa1 100644
--- a/tmk_core/protocol/mbed/HIDKeyboard.cpp
+++ b/tmk_core/protocol/mbed/HIDKeyboard.cpp
@@ -6,20 +6,14 @@
 
 #define DEFAULT_CONFIGURATION (1)
 
-
-HIDKeyboard::HIDKeyboard(uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release)
-{
-    USBDevice::connect();
-}
+HIDKeyboard::HIDKeyboard(uint16_t vendor_id, uint16_t product_id, uint16_t product_release) : USBDevice(vendor_id, product_id, product_release) { USBDevice::connect(); }
 
 bool HIDKeyboard::sendReport(report_keyboard_t report) {
     USBDevice::write(EP1IN, report.raw, sizeof(report), MAX_PACKET_SIZE_EP1);
     return true;
 }
 
-uint8_t HIDKeyboard::leds() {
-    return led_state;
-}
+uint8_t HIDKeyboard::leds() { return led_state; }
 
 bool HIDKeyboard::USBCallback_setConfiguration(uint8_t configuration) {
     if (configuration != DEFAULT_CONFIGURATION) {
@@ -28,80 +22,86 @@ bool HIDKeyboard::USBCallback_setConfiguration(uint8_t configuration) {
 
     // Configure endpoints > 0
     addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT);
-    //addEndpoint(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
+    // addEndpoint(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
 
     // We activate the endpoint to be able to recceive data
-    //readStart(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
+    // readStart(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
     return true;
 }
 
-
-uint8_t * HIDKeyboard::stringImanufacturerDesc() {
+uint8_t *HIDKeyboard::stringImanufacturerDesc() {
     static uint8_t stringImanufacturerDescriptor[] = {
-        0x18,                                            /*bLength*/
-        STRING_DESCRIPTOR,                               /*bDescriptorType 0x03*/
-        't',0,'m',0,'k',0,'-',0,'k',0,'b',0,'d',0,'.',0,'c',0,'o',0,'m',0   /*bString iManufacturer*/
+        0x18,              /*bLength*/
+        STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
+        't',
+        0,
+        'm',
+        0,
+        'k',
+        0,
+        '-',
+        0,
+        'k',
+        0,
+        'b',
+        0,
+        'd',
+        0,
+        '.',
+        0,
+        'c',
+        0,
+        'o',
+        0,
+        'm',
+        0 /*bString iManufacturer*/
     };
     return stringImanufacturerDescriptor;
 }
 
-uint8_t * HIDKeyboard::stringIproductDesc() {
+uint8_t *HIDKeyboard::stringIproductDesc() {
     static uint8_t stringIproductDescriptor[] = {
-        0x0a,                                                       /*bLength*/
-        STRING_DESCRIPTOR,                                          /*bDescriptorType 0x03*/
-        'm',0,'b',0,'e',0,'d',0                                     /*bString iProduct*/
+        0x0a,              /*bLength*/
+        STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
+        'm',
+        0,
+        'b',
+        0,
+        'e',
+        0,
+        'd',
+        0 /*bString iProduct*/
     };
     return stringIproductDescriptor;
 }
 
-uint8_t * HIDKeyboard::stringIserialDesc() {
+uint8_t *HIDKeyboard::stringIserialDesc() {
     static uint8_t stringIserialDescriptor[] = {
-        0x04,                                                           /*bLength*/
-        STRING_DESCRIPTOR,                                              /*bDescriptorType 0x03*/
-        '0',0                                                           /*bString iSerial*/
+        0x04,              /*bLength*/
+        STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
+        '0', 0             /*bString iSerial*/
     };
     return stringIserialDescriptor;
 }
 
-uint8_t * HIDKeyboard::reportDesc() {
+uint8_t *HIDKeyboard::reportDesc() {
     static uint8_t reportDescriptor[] = {
-        USAGE_PAGE(1), 0x01,                    // Generic Desktop
-        USAGE(1), 0x06,                         // Keyboard
-        COLLECTION(1), 0x01,                    // Application
-
-        USAGE_PAGE(1), 0x07,                    // Key Codes
-        USAGE_MINIMUM(1), 0xE0,
-        USAGE_MAXIMUM(1), 0xE7,
-        LOGICAL_MINIMUM(1), 0x00,
-        LOGICAL_MAXIMUM(1), 0x01,
-        REPORT_SIZE(1), 0x01,
-        REPORT_COUNT(1), 0x08,
-        INPUT(1), 0x02,                         // Data, Variable, Absolute
+        USAGE_PAGE(1),     0x01,  // Generic Desktop
+        USAGE(1),          0x06,  // Keyboard
+        COLLECTION(1),     0x01,  // Application
 
-        REPORT_COUNT(1), 0x01,
-        REPORT_SIZE(1), 0x08,
-        INPUT(1), 0x01,                         // Constant
+        USAGE_PAGE(1),     0x07,                                                                                                                                           // Key Codes
+        USAGE_MINIMUM(1),  0xE0, USAGE_MAXIMUM(1), 0xE7, LOGICAL_MINIMUM(1), 0x00, LOGICAL_MAXIMUM(1), 0x01, REPORT_SIZE(1), 0x01, REPORT_COUNT(1), 0x08, INPUT(1), 0x02,  // Data, Variable, Absolute
 
-        REPORT_COUNT(1), 0x05,
-        REPORT_SIZE(1), 0x01,
-        USAGE_PAGE(1), 0x08,                    // LEDs
-        USAGE_MINIMUM(1), 0x01,
-        USAGE_MAXIMUM(1), 0x05,
-        OUTPUT(1), 0x02,                        // Data, Variable, Absolute
+        REPORT_COUNT(1),   0x01, REPORT_SIZE(1),   0x08, INPUT(1),           0x01,  // Constant
 
-        REPORT_COUNT(1), 0x01,
-        REPORT_SIZE(1), 0x03,
-        OUTPUT(1), 0x01,                        // Constant
+        REPORT_COUNT(1),   0x05, REPORT_SIZE(1),   0x01, USAGE_PAGE(1),      0x08,  // LEDs
+        USAGE_MINIMUM(1),  0x01, USAGE_MAXIMUM(1), 0x05, OUTPUT(1),          0x02,  // Data, Variable, Absolute
 
+        REPORT_COUNT(1),   0x01, REPORT_SIZE(1),   0x03, OUTPUT(1),          0x01,  // Constant
 
-        REPORT_COUNT(1), 0x06,
-        REPORT_SIZE(1), 0x08,
-        LOGICAL_MINIMUM(1), 0x00,
-        LOGICAL_MAXIMUM(1), 0xFF,
-        USAGE_PAGE(1), 0x07,                    // Key Codes
-        USAGE_MINIMUM(1), 0x00,
-        USAGE_MAXIMUM(1), 0xFF,
-        INPUT(1), 0x00,                         // Data, Array
+        REPORT_COUNT(1),   0x06, REPORT_SIZE(1),   0x08, LOGICAL_MINIMUM(1), 0x00, LOGICAL_MAXIMUM(1), 0xFF, USAGE_PAGE(1),  0x07,  // Key Codes
+        USAGE_MINIMUM(1),  0x00, USAGE_MAXIMUM(1), 0xFF, INPUT(1),           0x00,                                                  // Data, Array
         END_COLLECTION(0),
     };
     reportLength = sizeof(reportDescriptor);
@@ -113,48 +113,45 @@ uint16_t HIDKeyboard::reportDescLength() {
     return reportLength;
 }
 
-#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \
-                               + (1 * INTERFACE_DESCRIPTOR_LENGTH) \
-                               + (1 * HID_DESCRIPTOR_LENGTH) \
-                               + (1 * ENDPOINT_DESCRIPTOR_LENGTH))
-uint8_t * HIDKeyboard::configurationDesc() {
+#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) + (1 * INTERFACE_DESCRIPTOR_LENGTH) + (1 * HID_DESCRIPTOR_LENGTH) + (1 * ENDPOINT_DESCRIPTOR_LENGTH))
+uint8_t *HIDKeyboard::configurationDesc() {
     static uint8_t configurationDescriptor[] = {
-        CONFIGURATION_DESCRIPTOR_LENGTH,// bLength
-        CONFIGURATION_DESCRIPTOR,       // bDescriptorType
-        LSB(TOTAL_DESCRIPTOR_LENGTH),   // wTotalLength (LSB)
-        MSB(TOTAL_DESCRIPTOR_LENGTH),   // wTotalLength (MSB)
-        0x01,                           // bNumInterfaces
-        DEFAULT_CONFIGURATION,          // bConfigurationValue
-        0x00,                           // iConfiguration
-        C_RESERVED | C_REMOTE_WAKEUP,   // bmAttributes
-        C_POWER(100),                   // bMaxPowerHello World from Mbed
-
-        INTERFACE_DESCRIPTOR_LENGTH,    // bLength
-        INTERFACE_DESCRIPTOR,           // bDescriptorType
-        0x00,                           // bInterfaceNumber
-        0x00,                           // bAlternateSetting
-        0x01,                           // bNumEndpoints
-        HID_CLASS,                      // bInterfaceClass
-        1,                              // bInterfaceSubClass (boot)
-        1,                              // bInterfaceProtocol (keyboard)
-        0x00,                           // iInterface
-
-        HID_DESCRIPTOR_LENGTH,          // bLength
-        HID_DESCRIPTOR,                 // bDescriptorType
-        LSB(HID_VERSION_1_11),          // bcdHID (LSB)
-        MSB(HID_VERSION_1_11),          // bcdHID (MSB)
-        0x00,                           // bCountryCode
-        0x01,                           // bNumDescriptors
-        REPORT_DESCRIPTOR,              // bDescriptorType
+        CONFIGURATION_DESCRIPTOR_LENGTH,  // bLength
+        CONFIGURATION_DESCRIPTOR,         // bDescriptorType
+        LSB(TOTAL_DESCRIPTOR_LENGTH),     // wTotalLength (LSB)
+        MSB(TOTAL_DESCRIPTOR_LENGTH),     // wTotalLength (MSB)
+        0x01,                             // bNumInterfaces
+        DEFAULT_CONFIGURATION,            // bConfigurationValue
+        0x00,                             // iConfiguration
+        C_RESERVED | C_REMOTE_WAKEUP,     // bmAttributes
+        C_POWER(100),                     // bMaxPowerHello World from Mbed
+
+        INTERFACE_DESCRIPTOR_LENGTH,  // bLength
+        INTERFACE_DESCRIPTOR,         // bDescriptorType
+        0x00,                         // bInterfaceNumber
+        0x00,                         // bAlternateSetting
+        0x01,                         // bNumEndpoints
+        HID_CLASS,                    // bInterfaceClass
+        1,                            // bInterfaceSubClass (boot)
+        1,                            // bInterfaceProtocol (keyboard)
+        0x00,                         // iInterface
+
+        HID_DESCRIPTOR_LENGTH,               // bLength
+        HID_DESCRIPTOR,                      // bDescriptorType
+        LSB(HID_VERSION_1_11),               // bcdHID (LSB)
+        MSB(HID_VERSION_1_11),               // bcdHID (MSB)
+        0x00,                                // bCountryCode
+        0x01,                                // bNumDescriptors
+        REPORT_DESCRIPTOR,                   // bDescriptorType
         (uint8_t)(LSB(reportDescLength())),  // wDescriptorLength (LSB)
         (uint8_t)(MSB(reportDescLength())),  // wDescriptorLength (MSB)
 
-        ENDPOINT_DESCRIPTOR_LENGTH,     // bLength
-        ENDPOINT_DESCRIPTOR,            // bDescriptorType
-        PHY_TO_DESC(EP1IN),             // bEndpointAddress
-        E_INTERRUPT,                    // bmAttributes
-        LSB(MAX_PACKET_SIZE_EPINT),     // wMaxPacketSize (LSB)
-        MSB(MAX_PACKET_SIZE_EPINT),     // wMaxPacketSize (MSB)
+        ENDPOINT_DESCRIPTOR_LENGTH,  // bLength
+        ENDPOINT_DESCRIPTOR,         // bDescriptorType
+        PHY_TO_DESC(EP1IN),          // bEndpointAddress
+        E_INTERRUPT,                 // bmAttributes
+        LSB(MAX_PACKET_SIZE_EPINT),  // wMaxPacketSize (LSB)
+        MSB(MAX_PACKET_SIZE_EPINT),  // wMaxPacketSize (MSB)
         1,                           // bInterval (milliseconds)
     };
     return configurationDescriptor;
@@ -187,41 +184,35 @@ uint8_t * HIDKeyboard::deviceDesc() {
 #endif
 
 bool HIDKeyboard::USBCallback_request() {
-    bool success = false;
-    CONTROL_TRANSFER * transfer = getTransferPtr();
-    uint8_t *hidDescriptor;
+    bool              success  = false;
+    CONTROL_TRANSFER *transfer = getTransferPtr();
+    uint8_t *         hidDescriptor;
 
     // Process additional standard requests
 
-    if ((transfer->setup.bmRequestType.Type == STANDARD_TYPE))
-    {
-        switch (transfer->setup.bRequest)
-        {
+    if ((transfer->setup.bmRequestType.Type == STANDARD_TYPE)) {
+        switch (transfer->setup.bRequest) {
             case GET_DESCRIPTOR:
-                switch (DESCRIPTOR_TYPE(transfer->setup.wValue))
-                {
+                switch (DESCRIPTOR_TYPE(transfer->setup.wValue)) {
                     case REPORT_DESCRIPTOR:
-                        if ((reportDesc() != NULL) \
-                            && (reportDescLength() != 0))
-                        {
+                        if ((reportDesc() != NULL) && (reportDescLength() != 0)) {
                             transfer->remaining = reportDescLength();
-                            transfer->ptr = reportDesc();
+                            transfer->ptr       = reportDesc();
                             transfer->direction = DEVICE_TO_HOST;
-                            success = true;
+                            success             = true;
                         }
                         break;
                     case HID_DESCRIPTOR:
-                            // Find the HID descriptor, after the configuration descriptor
-                            hidDescriptor = findDescriptor(HID_DESCRIPTOR);
-                            if (hidDescriptor != NULL)
-                            {
-                                transfer->remaining = HID_DESCRIPTOR_LENGTH;
-                                transfer->ptr = hidDescriptor;
-                                transfer->direction = DEVICE_TO_HOST;
-                                success = true;
-                            }
-                            break;
-                     
+                        // Find the HID descriptor, after the configuration descriptor
+                        hidDescriptor = findDescriptor(HID_DESCRIPTOR);
+                        if (hidDescriptor != NULL) {
+                            transfer->remaining = HID_DESCRIPTOR_LENGTH;
+                            transfer->ptr       = hidDescriptor;
+                            transfer->direction = DEVICE_TO_HOST;
+                            success             = true;
+                        }
+                        break;
+
                     default:
                         break;
                 }
@@ -232,8 +223,7 @@ bool HIDKeyboard::USBCallback_request() {
     }
 
     // Process class-specific requests
-    if (transfer->setup.bmRequestType.Type == CLASS_TYPE)
-    {
+    if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
         switch (transfer->setup.bRequest) {
             case SET_REPORT:
                 // LED indicator
@@ -242,10 +232,10 @@ bool HIDKeyboard::USBCallback_request() {
                 // if (transfer->setup.wLength == 1)
 
                 transfer->remaining = 1;
-                //transfer->ptr = ?? what ptr should be set when OUT(not used?)
+                // transfer->ptr = ?? what ptr should be set when OUT(not used?)
                 transfer->direction = HOST_TO_DEVICE;
-                transfer->notify = true;    /* notify with USBCallback_requestCompleted */
-                success = true;
+                transfer->notify    = true; /* notify with USBCallback_requestCompleted */
+                success             = true;
             default:
                 break;
         }
@@ -254,8 +244,7 @@ bool HIDKeyboard::USBCallback_request() {
     return success;
 }
 
-void HIDKeyboard::USBCallback_requestCompleted(uint8_t * buf, uint32_t length)
-{
+void HIDKeyboard::USBCallback_requestCompleted(uint8_t *buf, uint32_t length) {
     if (length > 0) {
         CONTROL_TRANSFER *transfer = getTransferPtr();
         if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
diff --git a/tmk_core/protocol/mbed/HIDKeyboard.h b/tmk_core/protocol/mbed/HIDKeyboard.h
index c537e5ecee..e8ff108699 100644
--- a/tmk_core/protocol/mbed/HIDKeyboard.h
+++ b/tmk_core/protocol/mbed/HIDKeyboard.h
@@ -1,30 +1,31 @@
 #ifndef HIDKEYBOARD_H
 
-#include "stdint.h"
-#include "stdbool.h"
-#include "USBHID.h"
-#include "report.h"
-
+#    include "stdint.h"
+#    include "stdbool.h"
+#    include "USBHID.h"
+#    include "report.h"
 
 class HIDKeyboard : public USBDevice {
-public:
+   public:
     HIDKeyboard(uint16_t vendor_id = 0xFEED, uint16_t product_id = 0xabed, uint16_t product_release = 0x0001);
 
-    bool sendReport(report_keyboard_t report);
+    bool    sendReport(report_keyboard_t report);
     uint8_t leds(void);
-protected:
-    uint16_t reportLength;
-    virtual bool USBCallback_setConfiguration(uint8_t configuration);
-    virtual uint8_t * stringImanufacturerDesc();
-    virtual uint8_t * stringIproductDesc();
-    virtual uint8_t * stringIserialDesc();
+
+   protected:
+    uint16_t         reportLength;
+    virtual bool     USBCallback_setConfiguration(uint8_t configuration);
+    virtual uint8_t* stringImanufacturerDesc();
+    virtual uint8_t* stringIproductDesc();
+    virtual uint8_t* stringIserialDesc();
     virtual uint16_t reportDescLength();
-    virtual uint8_t * reportDesc();
-    virtual uint8_t * configurationDesc();
-    //virtual uint8_t * deviceDesc();
+    virtual uint8_t* reportDesc();
+    virtual uint8_t* configurationDesc();
+    // virtual uint8_t * deviceDesc();
     virtual bool USBCallback_request();
-    virtual void USBCallback_requestCompleted(uint8_t * buf, uint32_t length);
-private:
+    virtual void USBCallback_requestCompleted(uint8_t* buf, uint32_t length);
+
+   private:
     uint8_t led_state;
 };
 
diff --git a/tmk_core/protocol/mbed/mbed_driver.cpp b/tmk_core/protocol/mbed/mbed_driver.cpp
index 6c7b16e23d..83086499c7 100644
--- a/tmk_core/protocol/mbed/mbed_driver.cpp
+++ b/tmk_core/protocol/mbed/mbed_driver.cpp
@@ -5,37 +5,17 @@
 
 HIDKeyboard keyboard;
 
-
 /* 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);
-
-host_driver_t mbed_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 mbed_driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};
 
-static uint8_t keyboard_leds(void)
-{
-    return keyboard.leds();
-}
-static void send_keyboard(report_keyboard_t *report)
-{
-    keyboard.sendReport(*report);
-}
-static void send_mouse(report_mouse_t *report)
-{
-}
-static void send_system(uint16_t data)
-{
-}
-static void send_consumer(uint16_t data)
-{
-}
+static uint8_t keyboard_leds(void) { return keyboard.leds(); }
+static void    send_keyboard(report_keyboard_t *report) { keyboard.sendReport(*report); }
+static void    send_mouse(report_mouse_t *report) {}
+static void    send_system(uint16_t data) {}
+static void    send_consumer(uint16_t data) {}